magus-cli 7.6.0 → 7.8.0

package/src/ui/screens/PluginsScreen.tsx

@@ -11,13 +11,9 @@ import {
 	repairPlugin as cliRepairPlugin,
 	uninstallPlugin as cliUninstallPlugin,
 } from "../../services/claude-cli.js";
-import {
-	SettingsParseError,
-	getMcpEnvVars,
-	readSettings,
-	setMcpEnvVar,
-} from "../../services/claude-settings.js";
+import { readSettings, setMcpEnvVar } from "../../services/claude-settings.js";
 import { clearContentDriftCache } from "../../services/content-drift.js";
+import { missingPluginEnvVars } from "../../services/plugin-env-needs.js";
 import {
 	type MarketplaceFetchFailure,
 	type PluginInfo,
@@ -33,16 +29,13 @@ import {
 	scopeFilesMissing,
 	versionInScope,
 } from "../../services/plugin-manager.js";
-import {
-	getPluginEnvRequirements,
-	getPluginSourcePath,
-} from "../../services/plugin-mcp-config.js";
 import {
 	checkMissingDeps,
 	getPluginSetupFromSource,
 	installPluginDeps,
 } from "../../services/plugin-setup.js";
 import { saveProfile } from "../../services/profiles.js";
+import { requirersHere } from "../../services/resolver.js";
 import {
 	fetchPluginContents,
 	fetchPluginSkillDetail,
@@ -61,41 +54,54 @@ import {
 // screen shows or acts on — row text, detail panel, header counts, U / a, the
 // scope picker — reads the same map it builds.
 import {
+	type PluginUpdateAction,
 	type PluginUpdateItem,
 	classifyPluginRows,
 	countPluginStates,
+	isKeptDeprecated,
 	scopeIsBehind,
 } from "../../services/update-plan.js";
-import {
-	diffVersions,
-	loadSeenVersions,
-	saveSeenVersions,
-} from "../../services/version-snapshot.js";
 import { fuzzyFilter } from "../../utils/fuzzy-search.js";
 import { createRequestGate } from "../../utils/request-gate.js";
 import { buildCatalogNoticeText } from "../adapters/catalogNotice.js";
+import { counted, failureReport } from "../adapters/failureReport.js";
 import {
+	type FailureVerb,
 	type PluginBrowserItem,
 	type PluginComponentItem,
 	type PluginPluginItem,
 	buildPluginBrowserItems,
-	noMoveReasons,
+	exceptionReason,
+	failureReasons,
+	failureVerb,
 	pluginContentsRepo,
+	pluginFailureReport,
 } from "../adapters/pluginsAdapter.js";
+import { stepFailureReport } from "../adapters/startupReports.js";
 import { EmptyFilterState } from "../components/EmptyFilterState.js";
 import { ScrollableList } from "../components/ScrollableList.js";
 import { ScreenLayout } from "../components/layout/index.js";
 import { useScreenKeys, useSearchInput } from "../input/KeyRouter.js";
-import { type BindingId, moveDirection, tabKey } from "../keymap.js";
+import { type BindingId, moveDirection } from "../keymap.js";
 import {
 	renderPluginDetail,
 	renderPluginRow,
 } from "../renderers/pluginRenderers.js";
 import { useApp, useModal, useProgress } from "../state/AppContext.js";
 import { useDimensions } from "../state/DimensionsContext.js";
-import { asyncValue } from "../state/types.js";
+import { type FailureReport, asyncValue } from "../state/types.js";
 import { theme } from "../theme.js";
 
+/** What a scope key did not do, for the failure popup's headline. */
+const SCOPE_ACTION_VERB: Record<
+	"install" | "update" | "uninstall",
+	FailureVerb
+> = {
+	install: "installed",
+	update: "updated",
+	uninstall: "removed",
+};
+
 /**
  * The latest Plugins load wins.
  *
@@ -150,10 +156,26 @@ export function PluginsScreen() {
 	const [pins, setPins] = useState<
 		Readonly<Record<string, string>> | null | undefined
 	>(undefined);
+	/**
+	 * The profile those pins came from — the one a deprecated plugin is dropped
+	 * from when `a` or `d` removes it. Same three states as `pins`; undefined
+	 * lets the removal choose the active profile itself.
+	 */
+	const [activeProfileId, setActiveProfileId] = useState<
+		string | null | undefined
+	>(undefined);
+	/**
+	 * For each plugin another one needs — the profile's or an installed one's —
+	 * every plugin that needs it: the same map `magus update` plans with
+	 * (`requirersHere`), so a deprecated dependency reads the same on both
+	 * surfaces and is never removed from under a plugin that stays.
+	 */
+	const [requiredBy, setRequiredBy] = useState<
+		Readonly<Record<string, readonly string[]>>
+	>({});
 
 	// Fetch data (always fetches all scopes). Only the most recently started
-	// load may touch the screen — or the seen-versions baseline, which a stale
-	// load would rewind.
+	// load may touch the screen.
 	const fetchData = useCallback(async () => {
 		const token = pluginsLoadGate.begin();
 		dispatch({ type: "PLUGINS_DATA_LOADING" });
@@ -173,7 +195,17 @@ export function PluginsScreen() {
 				}),
 			]);
 			if (!pluginsLoadGate.isCurrent(token)) return;
+			// The same edges `magus update` plans with: the profile's and every
+			// installed plugin's, so a plugin one of them needs is never removed.
+			const required = await requirersHere(
+				active?.closure.dependencies?.requiredBy,
+				pluginData.filter(isInstalledAnywhere).map((p) => p.id),
+				state.projectPath || process.cwd(),
+			);
+			if (!pluginsLoadGate.isCurrent(token)) return;
 			setPins(active?.closure.plugins ?? null);
+			setActiveProfileId(active?.profileId ?? null);
+			setRequiredBy(required);
 
 			// Which catalogs answered, and which only appeared to. Read straight
 			// after the fetch, while the record still describes this attempt.
@@ -191,32 +223,6 @@ export function PluginsScreen() {
 				),
 			);
 
-			// Surface version changes made outside magus (Claude Code's own
-			// plugin update, a manual CLI call). Diffing against
-			// what we last rendered catches all of them; logging only what
-			// magus did would miss every one.
-			const current: Record<string, string> = {};
-			for (const p of pluginData) {
-				if (p.installedVersion) current[p.id] = p.installedVersion;
-			}
-			const projectPath = state.projectPath || process.cwd();
-			const previous = await loadSeenVersions(projectPath);
-			if (!pluginsLoadGate.isCurrent(token)) return;
-			for (const change of diffVersions(previous, current)) {
-				const target = pluginData.find((p) => p.id === change.pluginId);
-				if (!target) continue;
-				if (change.kind === "updated") {
-					target.recentlyUpdatedFrom = change.from;
-				} else {
-					target.recentlyInstalled = true;
-				}
-			}
-			// Await the write. Fire-and-forget raced the next fetchData() — a
-			// refresh or a post-action refetch could load the baseline before the
-			// previous save landed and re-report the same change.
-			await saveSeenVersions(projectPath, current);
-			if (!pluginsLoadGate.isCurrent(token)) return;
-
 			dispatch({
 				type: "PLUGINS_DATA_SUCCESS",
 				marketplaces: allMarketplaces,
@@ -290,10 +296,53 @@ export function PluginsScreen() {
 	 */
 	const statuses = useMemo(
 		(): Map<string, PluginUpdateItem> =>
-			shownPlugins ? classifyPluginRows(shownPlugins, pins ?? {}) : new Map(),
-		[shownPlugins, pins],
+			shownPlugins
+				? classifyPluginRows(shownPlugins, pins ?? {}, requiredBy)
+				: new Map(),
+		[shownPlugins, pins, requiredBy],
 	);
 
+	/**
+	 * Installed plugins whose MCP server lacks variables, and how many — read
+	 * from the current config on every load and after every attempt to set them
+	 * (`envCheck`), so declining the question at install leaves a lasting state
+	 * on that plugin, and setting them clears it. Nothing records the decline.
+	 */
+	const [mcpSettingsNeeded, setMcpSettingsNeeded] = useState<
+		ReadonlyMap<string, number>
+	>(new Map());
+	const [envCheck, setEnvCheck] = useState(0);
+	// biome-ignore lint/correctness/useExhaustiveDependencies: envCheck is the re-read trigger after the variables were asked for; the body never reads it
+	useEffect(() => {
+		if (!shownPlugins) return;
+		let cancelled = false;
+		const installed = shownPlugins.filter(
+			(p) => !p.isOrphaned && isInstalledAnywhere(p),
+		);
+		void Promise.all(
+			installed.map(async (p) => {
+				try {
+					const missing = await missingPluginEnvVars(
+						p.marketplace,
+						p.name,
+						state.projectPath,
+					);
+					return [p.id, missing.length] as const;
+				} catch {
+					// Unreadable variables are reported where they are saved; a row
+					// that cannot tell claims nothing.
+					return [p.id, 0] as const;
+				}
+			}),
+		).then((counts) => {
+			if (cancelled) return;
+			setMcpSettingsNeeded(new Map(counts.filter(([, n]) => n > 0)));
+		});
+		return () => {
+			cancelled = true;
+		};
+	}, [shownPlugins, state.projectPath, envCheck]);
+
 	// Build list items (categories + plugins)
 	const allItems = useMemo((): PluginBrowserItem[] => {
 		if (!shownMarketplaces || !shownPlugins) return [];
@@ -304,6 +353,7 @@ export function PluginsScreen() {
 			expandedPlugins: pluginsState.expandedPlugins,
 			pluginContents: pluginsState.pluginContents,
 			statuses,
+			mcpSettingsNeeded,
 		});
 	}, [
 		shownMarketplaces,
@@ -312,6 +362,7 @@ export function PluginsScreen() {
 		pluginsState.expandedPlugins,
 		pluginsState.pluginContents,
 		statuses,
+		mcpSettingsNeeded,
 	]);
 
 	// Filter items by search query
@@ -517,6 +568,14 @@ export function PluginsScreen() {
 		remove: () => {
 			void handleRemoveDeprecated();
 		},
+		// The action behind the detail panel's "needs N settings — press e".
+		"set-env": () => {
+			const item = selectableItems[pluginsState.selectedIndex];
+			if (item?.kind !== "plugin" || !item.mcpSettingsNeeded) return;
+			void collectPluginEnvVars(item.plugin.name, item.plugin.marketplace, {
+				ask: false,
+			});
+		},
 		"add-marketplace": () => {
 			void handleShowAddMarketplaceInstructions();
 		},
@@ -544,12 +603,91 @@ export function PluginsScreen() {
 
 	// ── Helpers ───────────────────────────────────────────────────────────────
 
+	/**
+	 * Run the ONE apply engine over `items`, reload, and — only if something
+	 * failed, or ran and changed nothing — say why in ONE popup, each plugin
+	 * named with its reason in the same words the CLI prints. Shared by U, a
+	 * and d, so the three say the same thing about the same outcome. A success
+	 * says nothing: the reloaded rows show it. An item that ran and did not move
+	 * is "not updated" — the fact the CLI lists as "ran but did not change" —
+	 * because a row still offering the same update, with nothing said, reads as
+	 * a key that did nothing. A throw from the engine itself — not from one
+	 * item, which the engine catches and reports — names every item with its
+	 * message.
+	 */
+	const applyAndReportFailures = async (
+		items: readonly PluginUpdateItem[],
+		report: (capture: ApplyReporter) => ApplyReporter = (capture) => capture,
+	): Promise<void> => {
+		const reasons = failureReasons();
+		const actions = new Map(items.map((i) => [i.pluginId, i.action]));
+		let failure: FailureReport | null;
+		try {
+			const result = await applyPlugins(
+				[...items],
+				state.projectPath || process.cwd(),
+				REAL_PLUGIN_DEPS,
+				report(reasons.reporter),
+				// The profile these rows were judged against — the active one — is
+				// the one a removed plugin leaves.
+				{ profile: activeProfileId },
+			);
+			failure = reasons.report(result.failed, actions, result.unchanged);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			failure = pluginFailureReport(
+				items.map((i) => ({
+					pluginId: i.pluginId,
+					verb: failureVerb(i.action),
+					detail: message,
+					exception: true,
+				})),
+			);
+		}
+		modal.hideModal();
+		fetchData();
+		if (failure) await modal.failures(failure);
+	};
+
+	/**
+	 * The same popup for a single plugin action outside the apply engine — a
+	 * scope key, a plain uninstall — so it reads like every other failure here.
+	 */
+	const reportPluginFailure = async (
+		pluginId: string,
+		verb: FailureVerb,
+		error: unknown,
+	): Promise<void> => {
+		const report = pluginFailureReport([
+			{
+				pluginId,
+				verb,
+				detail: error instanceof Error ? error.message : String(error),
+				exception: true,
+			},
+		]);
+		if (report) await modal.failures(report);
+	};
+
+	/**
+	 * A marketplace that was not added. Magus runs the same command the user
+	 * would, so running it by hand is the one real fix when magus cannot say
+	 * why it failed.
+	 */
+	const addMarketplaceFailure = (repo: string, error: unknown) =>
+		stepFailureReport(
+			`Marketplace ${repo} was not added`,
+			repo,
+			error,
+			`Run it yourself: claude plugin marketplace add ${repo}`,
+		);
+
 	// ── Action handlers ────────────────────────────────────────────────────────
 
 	const handleRefresh = async () => {
 		progress.show("Refreshing cache...");
 		try {
-			const result = await refreshAllMarketplaces((p) => {
+			await refreshAllMarketplaces((p) => {
 				progress.show(`${p.name}`, p.current, p.total);
 			});
 			clearMarketplaceCache();
@@ -557,26 +695,16 @@ export function PluginsScreen() {
 			// that moves HEAD invalidates every cached answer.
 			clearContentDriftCache();
 			progress.hide();
-
-			let message =
-				"Cache refreshed.\n\n" +
-				"To update marketplaces from GitHub, run in Claude Code:\n" +
-				"  /plugin marketplace update\n\n" +
-				"Then refresh magus again with 'r'.";
-
-			if (result.repair.length > 0) {
-				const totalRepaired = result.repair.reduce(
-					(sum, r) => sum + r.repaired.length,
-					0,
-				);
-				message += `\n\nAuto-repaired ${totalRepaired} plugin(s) with missing agents/commands.`;
-			}
-
-			await modal.message("Refreshed", message, "success");
 			fetchData();
 		} catch (error) {
 			progress.hide();
-			await modal.message("Error", `Refresh failed: ${error}`, "error");
+			await modal.failures(
+				stepFailureReport(
+					"The marketplaces were not refreshed",
+					"marketplaces",
+					error,
+				),
+			);
 		}
 	};
 
@@ -617,12 +745,7 @@ export function PluginsScreen() {
 					await cliAddMarketplace(choice);
 					await handleRefresh();
 				} catch (e) {
-					await modal.message(
-						"Could not add marketplace",
-						`${(e as Error).message}\n\nRun it yourself if this persists:\n\n` +
-							`  claude plugin marketplace add ${choice}`,
-						"error",
-					);
+					await modal.failures(addMarketplaceFailure(choice, e));
 				}
 				return;
 			}
@@ -634,7 +757,6 @@ export function PluginsScreen() {
 				"  claude plugin marketplace add owner/repo\n\n" +
 				"Auto-update is enabled by default for new marketplaces.\n\n" +
 				"After adding, refresh magus with 'r' to see it.",
-			"info",
 		);
 	};
 
@@ -663,46 +785,37 @@ export function PluginsScreen() {
 			"NOTE: Individual plugin enablement is still project-specific.\n" +
 			'Use "Project" scope in magus to enable for the team.';
 
-		await modal.message("Team Configuration", helpText, "info");
+		await modal.message("Team Configuration", helpText);
 	};
 
 	/**
 	 * Collect environment variables required by a plugin's MCP servers.
+	 *
+	 * After an install it first asks whether to configure them now; from the
+	 * `e` key (`ask: false`) the user has already said yes. Declining, or
+	 * leaving a value empty, is not remembered: the plugin's detail panel keeps
+	 * saying what is missing, read from the config, until it is set.
 	 */
 	const collectPluginEnvVars = async (
 		pluginName: string,
 		marketplace: string,
+		{ ask = true }: { ask?: boolean } = {},
 	): Promise<boolean> => {
 		try {
-			const pluginSource = await getPluginSourcePath(marketplace, pluginName);
-			if (!pluginSource) return true;
-
-			const requirements = await getPluginEnvRequirements(
+			const missingVars = await missingPluginEnvVars(
 				marketplace,
-				pluginSource,
+				pluginName,
+				state.projectPath,
 			);
-			if (requirements.length === 0) return true;
-
-			const existingEnvVars = await getMcpEnvVars(state.projectPath);
-			const missingVars = requirements.filter(
-				(req) => !existingEnvVars[req.name] && !process.env[req.name],
-			);
-
 			if (missingVars.length === 0) return true;
 
-			const serverNames = [...new Set(missingVars.map((v) => v.serverName))];
-			const wantToConfigure = await modal.confirm(
-				"Configure MCP Servers?",
-				`This plugin includes MCP servers (${serverNames.join(", ")}) that need ${missingVars.length} environment variable(s).\n\nConfigure now?`,
-			);
-
-			if (!wantToConfigure) {
-				await modal.message(
-					"Skipped Configuration",
-					`You can configure these variables later in the Settings tab (press ${tabKey("settings")}).`,
-					"info",
+			if (ask) {
+				const serverNames = [...new Set(missingVars.map((v) => v.serverName))];
+				const wantToConfigure = await modal.confirm(
+					"Configure MCP Servers?",
+					`This plugin includes MCP servers (${serverNames.join(", ")}) that need ${missingVars.length} environment variable(s).\n\nConfigure now?`,
 				);
-				return true;
+				if (!wantToConfigure) return true;
 			}
 
 			for (const req of missingVars) {
@@ -724,14 +837,7 @@ export function PluginsScreen() {
 					"",
 				);
 
-				if (value === null) {
-					await modal.message(
-						"Configuration Incomplete",
-						`Skipped remaining configuration.\nYou can configure these later in the Settings tab (press ${tabKey("settings")}).`,
-						"info",
-					);
-					return true;
-				}
+				if (value === null) return true;
 
 				if (value) {
 					await setMcpEnvVar(req.name, value, state.projectPath);
@@ -740,19 +846,21 @@ export function PluginsScreen() {
 
 			return true;
 		} catch (error) {
-			// The plugin itself is installed either way. But a settings.local.json
-			// that does not parse is something the user has to fix by hand before
-			// any variable can be saved, so it is said, not logged out of sight.
-			if (error instanceof SettingsParseError) {
-				await modal.message(
-					"Environment variables not saved",
-					error.message,
-					"error",
-				);
-			} else {
-				console.error("Error collecting plugin env vars:", error);
-			}
+			// The plugin itself is installed either way, but its MCP server will
+			// not start without these — so it is said in the popup, never logged
+			// out of sight. A file that does not parse names itself and the fix.
+			modal.hideModal();
+			await modal.failures(
+				stepFailureReport(
+					`${pluginName} is installed, but its MCP server variables were not saved`,
+					pluginName,
+					error,
+				),
+			);
 			return true;
+		} finally {
+			// Re-read, so the panel's "needs N settings" matches what was saved.
+			setEnvCheck((n) => n + 1);
 		}
 	};
 
@@ -797,24 +905,28 @@ export function PluginsScreen() {
 			const result = await installPluginDeps(missing);
 			modal.hideModal();
 
-			if (result.failed.length > 0) {
-				const failMsg = result.failed
-					.map((f) => `${f.pkg}: ${f.error}`)
-					.join("\n");
-				await modal.message(
-					"Partial Install",
-					`Installed: ${result.installed.length}\nFailed:\n${failMsg}`,
-					"error",
-				);
-			} else if (result.installed.length > 0) {
-				await modal.message(
-					"Dependencies Installed",
-					`Installed ${result.installed.length} package(s):\n${result.installed.join(", ")}`,
-					"success",
-				);
-			}
+			// Only what did not install, each with why; what did shows nowhere.
+			const report = failureReport(
+				`${counted(result.failed.length, "dependency", "dependencies")} of ${pluginName} ${
+					result.failed.length === 1 ? "was" : "were"
+				} not installed`,
+				result.failed.map((f) => ({
+					subject: f.pkg,
+					reason: exceptionReason(f.error).reason,
+				})),
+			);
+			if (report) await modal.failures(report);
 		} catch (error) {
-			console.error("Error installing plugin deps:", error);
+			// Hide the loading modal first: it would otherwise stay up forever,
+			// and the failure behind it would never be read.
+			modal.hideModal();
+			await modal.failures(
+				stepFailureReport(
+					`${pluginName} is installed, but its dependencies were not installed`,
+					pluginName,
+					error,
+				),
+			);
 		}
 	};
 
@@ -835,7 +947,6 @@ export function PluginsScreen() {
 					await modal.message(
 						`Remove ${mp.displayName}?`,
 						`To remove this marketplace, run in Claude Code:\n\n  /plugin marketplace remove ${mp.name}\n\nAfter removing, refresh magus with 'r' to update the display.`,
-						"info",
 					);
 				}
 			} else {
@@ -853,11 +964,7 @@ export function PluginsScreen() {
 						await cliAddMarketplace(repo);
 						await handleRefresh();
 					} catch (e) {
-						await modal.message(
-							"Could not add marketplace",
-							`${(e as Error).message}\n\nRun it yourself if this persists:\n\n  claude plugin marketplace add ${repo}`,
-							"error",
-						);
+						await modal.failures(addMarketplaceFailure(repo, e));
 					}
 				}
 			}
@@ -984,7 +1091,7 @@ export function PluginsScreen() {
 				fetchData();
 			} catch (error) {
 				modal.hideModal();
-				await modal.message("Error", `Failed: ${error}`, "error");
+				await reportPluginFailure(plugin.id, SCOPE_ACTION_VERB[action], error);
 			}
 		}
 	};
@@ -1014,51 +1121,20 @@ export function PluginsScreen() {
 
 		modal.loading(
 			// A broken plugin runs NO claude command at all, so naming one here would
-			// misdescribe the work: the repair rewrites installed_plugins.json rows.
+			// misdescribe the work.
 			status.action === "stale-load"
-				? `Repairing ${plugin.name}…\nmoving this repository's install records forward to v${status.target ?? "?"}`
+				? `Repairing ${plugin.name}…\nmaking Claude Code load v${status.target ?? "?"} here`
 				: repairing
 					? `Repairing ${plugin.name}…\nclaude plugin uninstall ${plugin.id} --scope ${scope} && claude plugin install ${plugin.id} --scope ${scope}`
 					: `Updating ${plugin.name}…\nclaude plugin install ${plugin.id} --scope ${scope}`,
 		);
-		const reasons = noMoveReasons();
-		try {
-			// One plugin, but the SAME engine — so a single update records the
-			// version that landed and touches every scope that is behind, exactly
-			// as `magus update` does. The plan item IS the row's status: the
-			// classifier's answer for this plugin under its real pin (the
-			// profile's, or "latest" for an undeclared install — see pinForRow),
-			// so what runs is exactly what the row claimed.
-			const result = await applyPlugins(
-				[status],
-				state.projectPath || process.cwd(),
-				REAL_PLUGIN_DEPS,
-				reasons.reporter,
-			);
-			modal.hideModal();
-			if (result.failed.length > 0) {
-				await modal.message(
-					"Error",
-					`Failed to update ${plugin.name}`,
-					"error",
-				);
-				return;
-			}
-			// Ran, exited 0, moved nothing — and the row will not have moved
-			// either. Saying nothing here is what made "press U, press U,
-			// forever": the CLI names the cause, so the screen does too.
-			if (result.unchanged.length > 0) {
-				await modal.message(
-					"No change",
-					reasons.lines(result.unchanged),
-					"info",
-				);
-			}
-			fetchData();
-		} catch (error) {
-			modal.hideModal();
-			await modal.message("Error", `Failed to update: ${error}`, "error");
-		}
+		// One plugin, but the SAME engine — so a single update records the
+		// version that landed and touches every scope that is behind, exactly as
+		// `magus update` does. The plan item IS the row's status: the classifier's
+		// answer for this plugin under its real pin (the profile's, or "latest" for
+		// an undeclared install — see pinForRow), so what runs is exactly what the
+		// row claimed. A failure says why in a popup.
+		await applyAndReportFailures([status]);
 	};
 
 	/**
@@ -1079,60 +1155,37 @@ export function PluginsScreen() {
 		if (pluginsState.plugins.status !== "success") return;
 
 		// Every item that needs work, by the same `pluginNeedsWork` the CLI's
-		// apply uses: updates, content repairs, broken loads, missing files, and a
-		// profile plugin not installed yet — exactly what `magus update` would do.
+		// apply uses: updates, content repairs, broken loads, missing files, a
+		// profile plugin not installed yet, and deprecated plugins to remove —
+		// exactly what `magus update` would do.
 		const items = [...statuses.values()]
 			.filter(pluginNeedsWork)
 			.sort((a, b) => a.pluginId.localeCompare(b.pluginId));
 		if (items.length === 0) return;
 
-		const projectPath = state.projectPath || process.cwd();
-		const total = items.filter(pluginNeedsWork).length;
+		const total = items.length;
 
 		// A broken plugin is repaired in the registry, not updated, and the progress
 		// line is the only place the user sees which one happened to which plugin.
 		const actionOf = new Map(items.map((i) => [i.pluginId, i.action]));
+		const VERB: Partial<Record<PluginUpdateAction, string>> = {
+			"stale-load": "Repairing",
+			remove: "Removing",
+		};
 
 		let done = 0;
-		const reasons = noMoveReasons();
-		const reporter: ApplyReporter = {
+		// One popup afterwards, and only for failures: each plugin that failed,
+		// with why. The one this replaced listed six plugin names and not one
+		// reason. Everything else shows its new state once the list reloads.
+		await applyAndReportFailures(items, (capture) => ({
 			begin: (name) => {
 				done++;
-				const verb =
-					actionOf.get(name) === "stale-load" ? "Repairing" : "Updating";
+				const verb = VERB[actionOf.get(name) ?? "update"] ?? "Updating";
 				modal.loading(`${verb} ${name} (${done}/${total})…`);
 			},
-			finish: reasons.reporter.finish,
+			finish: capture.finish,
 			detach: (work) => work(),
-		};
-
-		try {
-			const result = await applyPlugins(
-				items,
-				projectPath,
-				REAL_PLUGIN_DEPS,
-				reporter,
-			);
-			modal.hideModal();
-			if (result.failed.length > 0) {
-				await modal.message(
-					"Some updates failed",
-					result.failed.join(", "),
-					"error",
-				);
-			}
-			if (result.unchanged.length > 0) {
-				await modal.message(
-					"No change",
-					reasons.lines(result.unchanged),
-					"info",
-				);
-			}
-			fetchData();
-		} catch (error) {
-			modal.hideModal();
-			await modal.message("Error", `Failed to update: ${error}`, "error");
-		}
+		}));
 	};
 
 	const handleScopeToggle = async (scope: "user" | "project" | "local") => {
@@ -1195,7 +1248,7 @@ export function PluginsScreen() {
 			fetchData();
 		} catch (error) {
 			modal.hideModal();
-			await modal.message("Error", `Failed: ${error}`, "error");
+			await reportPluginFailure(plugin.id, SCOPE_ACTION_VERB[action], error);
 		}
 	};
 
@@ -1212,6 +1265,17 @@ export function PluginsScreen() {
 		// was already installed. An orphan is removed; where else a name happens
 		// to appear is not this screen's guess to make.
 
+		// A DEPRECATED one goes through the engine `a` and `magus update` use, so
+		// `d` also drops it from the profile and reads the result back — the
+		// uninstall-only path below left the profile declaring it, and the row
+		// came straight back as "deprecated".
+		const status = statuses.get(plugin.id);
+		if (status?.action === "remove") {
+			modal.loading(`Removing ${plugin.name}…`);
+			await applyAndReportFailures([status]);
+			return;
+		}
+
 		try {
 			// Remove from all scopes — try all to clean up stale references
 			const scopes: PluginScope[] = ["user", "project", "local"];
@@ -1233,7 +1297,7 @@ export function PluginsScreen() {
 			fetchData();
 		} catch (error) {
 			modal.hideModal();
-			await modal.message("Error", `Failed to remove: ${error}`, "error");
+			await reportPluginFailure(plugin.id, "removed", error);
 		}
 	};
 
@@ -1245,10 +1309,12 @@ export function PluginsScreen() {
 			enabledPlugins =
 				(await readSettings(state.projectPath)).enabledPlugins ?? {};
 		} catch (error) {
-			await modal.message(
-				"Error",
-				`Cannot save a profile: ${error instanceof Error ? error.message : String(error)}`,
-				"error",
+			await modal.failures(
+				stepFailureReport(
+					"No profile was saved",
+					"this project's plugins",
+					error,
+				),
 			);
 			return;
 		}
@@ -1278,21 +1344,22 @@ export function PluginsScreen() {
 		try {
 			await saveProfile(name.trim(), enabledPlugins, scope, state.projectPath);
 			modal.hideModal();
-			await modal.message(
-				"Saved",
-				`Profile "${name.trim()}" saved.\nPress ${tabKey("profiles")} to manage profiles.`,
-				"success",
-			);
 		} catch (error) {
 			modal.hideModal();
-			await modal.message("Error", `Failed to save profile: ${error}`, "error");
+			await modal.failures(
+				stepFailureReport(
+					`Profile "${name.trim()}" was not saved`,
+					scope.toUpperCase(),
+					error,
+				),
+			);
 		}
 	};
 
 	// ── Render ─────────────────────────────────────────────────────────────────
 
 	// Only a genuine first load takes over the screen. A reload keeps the list on
-	// screen and says so in the notice line instead.
+	// screen and says so in the header's notice row instead.
 	if (!shownMarketplaces || !shownPlugins) {
 		if (
 			pluginsState.marketplaces.status === "loading" ||
@@ -1344,6 +1411,9 @@ export function PluginsScreen() {
 		...(selectedItem?.kind === "plugin" && selectedItem.plugin.isOrphaned
 			? []
 			: ["remove" as const]),
+		...(selectedItem?.kind === "plugin" && selectedItem.mcpSettingsNeeded
+			? []
+			: ["set-env" as const]),
 	];
 
 	const scopeLabel = pluginsState.scope === "global" ? "Global" : "Project";
@@ -1358,7 +1428,10 @@ export function PluginsScreen() {
 	// Cannot tell whether it is current. Counted and shown separately: folding
 	// it into `updateCount` would overstate, and folding it into silence is the
 	// "cannot tell rendered as fine" bug.
-	const unknownCount = counts.unknown;
+	// Moved or still-required plugins are `unknown` to the planner but known to
+	// the user — kept on purpose — so they are not counted as "unverified".
+	const unknownCount =
+		counts.unknown - [...statuses.values()].filter(isKeptDeprecated).length;
 	const installCount = counts.install;
 	// Broken: installed at the right version, loading an older one. Its own
 	// number, never folded into `updateCount` or into silence — a clean header
@@ -1368,8 +1441,11 @@ export function PluginsScreen() {
 	// a reader had to already know what "loads" versus "installed" means here
 	// before the count told them anything. `a` clears these.
 	const brokenCount = counts["stale-load"];
-	const subtitle = `${scopeLabel} │ ${installedCount} installed${updateCount > 0 ? ` │ ${updateCount} updates` : ""}${installCount > 0 ? ` │ ${installCount} to install` : ""}${brokenCount > 0 ? ` │ ${brokenCount} broken` : ""}${unknownCount > 0 ? ` │ ${unknownCount} unverified` : ""}`;
-	const searchPlaceholder = `${scopeLabel} │ ${installedCount} installed${updateCount > 0 ? ` │ ${updateCount} ⬆` : ""}${installCount > 0 ? ` │ ${installCount} +` : ""}${brokenCount > 0 ? ` │ ${brokenCount} ✗` : ""}${unknownCount > 0 ? ` │ ${unknownCount} ?` : ""} │ / to search`;
+	// No longer published, and `a` removes them. Counted where the rows can be
+	// seen to need work; they used to sit inside "unverified".
+	const deprecatedCount = counts.remove;
+	const subtitle = `${scopeLabel} │ ${installedCount} installed${updateCount > 0 ? ` │ ${updateCount} updates` : ""}${installCount > 0 ? ` │ ${installCount} to install` : ""}${brokenCount > 0 ? ` │ ${brokenCount} broken` : ""}${deprecatedCount > 0 ? ` │ ${deprecatedCount} deprecated` : ""}${unknownCount > 0 ? ` │ ${unknownCount} unverified` : ""}`;
+	const searchPlaceholder = `${scopeLabel} │ ${installedCount} installed${updateCount > 0 ? ` │ ${updateCount} ⬆` : ""}${installCount > 0 ? ` │ ${installCount} +` : ""}${brokenCount + deprecatedCount > 0 ? ` │ ${brokenCount + deprecatedCount} ✗` : ""}${unknownCount > 0 ? ` │ ${unknownCount} ?` : ""} │ / to search`;
 
 	const catalogNotice = buildCatalogNotice({
 		failures: catalogFailures,
@@ -1379,18 +1455,13 @@ export function PluginsScreen() {
 		width: dimensions.terminalWidth,
 		now: nowTick,
 	});
-	// Without a resolved profile, exact pins are unknown here and every row is
-	// judged against "latest". Saying so is what keeps a row that disagrees with
-	// `magus update <profile>` from reading as a contradiction.
+	// Without a resolved profile every row is judged against "latest". That is
+	// not said here: the startup question already tells the user there is no
+	// active profile, and "profile not resolved" was mechanism, not state.
 	const notice = isReloading ? (
 		<text fg={theme.colors.muted}>⟳ Refreshing catalogs from GitHub…</text>
 	) : (
-		(catalogNotice ??
-		(pins === null ? (
-			<text fg={theme.colors.muted}>
-				profile not resolved — states judged against latest
-			</text>
-		) : null))
+		catalogNotice
 	);
 
 	return (