magus-cli 7.5.2 → 7.5.4

package/src/ui/hooks/useGitignoreModal.ts

@@ -12,19 +12,38 @@ import type { ModalState } from "../state/types.js";
 export interface BuildModalArgs {
 	violationCount: number;
 	safeCount: number;
+	/**
+	 * Files magus generates from `.claude/profiles.json` that git tracks. The
+	 * fix untracks these in place; every other destructive fix stays in the tab.
+	 */
+	generated?: readonly string[];
 	onFixSafe: () => void;
 	onOpenTab: () => void;
 	onDismiss: () => void;
 }
 
+function entries(n: number): string {
+	return `${n} missing .gitignore entr${n === 1 ? "y" : "ies"}`;
+}
+
+function fixLabel(safeCount: number, generated: number): string {
+	if (generated > 0) {
+		const files = `${generated} generated file${generated === 1 ? "" : "s"}`;
+		return safeCount > 0
+			? `Stop tracking ${files} and add ${entries(safeCount)}`
+			: `Stop tracking ${files}`;
+	}
+	return safeCount > 0
+		? `Add ${entries(safeCount)}`
+		: "(no missing .gitignore entries)";
+}
+
 export function buildGitignoreModal(args: BuildModalArgs): ModalState {
 	const { violationCount, safeCount, onFixSafe, onOpenTab, onDismiss } = args;
+	const generated = args.generated ?? [];
 	const options = [
 		{
-			label:
-				safeCount > 0
-					? `Add ${safeCount} missing .gitignore entr${safeCount === 1 ? "y" : "ies"}`
-					: "(no missing .gitignore entries)",
+			label: fixLabel(safeCount, generated.length),
 			value: "fix-safe",
 		},
 		{
@@ -36,10 +55,20 @@ export function buildGitignoreModal(args: BuildModalArgs): ModalState {
 			value: "dismiss",
 		},
 	];
+	const generatedNote =
+		generated.length > 0
+			? `magus generates ${generated.length === 1 ? "this file" : "these files"} from .claude/profiles.json for each developer, so ${
+					generated.length === 1 ? "it is" : "they are"
+				} expected to be gitignored — but git tracks ${generated.length === 1 ? "it" : "them"}:\n${generated
+					.map((p) => `  ${p}`)
+					.join(
+						"\n",
+					)}\n\nThe first choice stops tracking ${generated.length === 1 ? "it" : "them"} (git rm --cached, staged for you to commit) and adds the .gitignore entries.\n\n`
+			: "";
 	return {
 		type: "select",
 		title: "Gitignore violations detected",
-		message: `Found ${violationCount} managed gitignore item(s) that do not match the current repo state.\n\nMissing .gitignore entries can be added now. Items that change git tracking are reviewed and fixed from the Gitignore tab.`,
+		message: `${generatedNote}Found ${violationCount} managed gitignore item(s) that do not match the current repo state.\n\nMissing .gitignore entries can be added now. Other items that change git tracking are reviewed and fixed from the Gitignore tab.`,
 		options,
 		onSelect: (value: string) => {
 			if (value === "fix-safe") onFixSafe();
@@ -58,27 +87,44 @@ export function useGitignoreModal() {
 		(args: {
 			violationCount: number;
 			safeCount: number;
-			onFixSafe: () => Promise<void> | void;
+			generated?: readonly string[];
+			/** Returns what it did, shown before returning to the app. */
+			onFixSafe: () => Promise<string | undefined> | string | undefined;
 		}) => {
 			if (args.violationCount === 0) return;
 			const dismiss = () => dispatch({ type: "HIDE_MODAL" });
 			const modal = buildGitignoreModal({
 				violationCount: args.violationCount,
 				safeCount: args.safeCount,
+				generated: args.generated,
 				onFixSafe: () => {
 					dispatch({ type: "HIDE_MODAL" });
-					void Promise.resolve(args.onFixSafe()).catch((err) => {
-						dispatch({
-							type: "SHOW_MODAL",
-							modal: {
-								type: "message",
-								title: "Safe fixes failed",
-								message: err instanceof Error ? err.message : String(err),
-								variant: "error",
-								onDismiss: dismiss,
-							},
+					void Promise.resolve(args.onFixSafe())
+						.then((report) => {
+							if (!report) return;
+							dispatch({
+								type: "SHOW_MODAL",
+								modal: {
+									type: "message",
+									title: "Gitignore fixed",
+									message: report,
+									variant: "success",
+									onDismiss: dismiss,
+								},
+							});
+						})
+						.catch((err) => {
+							dispatch({
+								type: "SHOW_MODAL",
+								modal: {
+									type: "message",
+									title: "Safe fixes failed",
+									message: err instanceof Error ? err.message : String(err),
+									variant: "error",
+									onDismiss: dismiss,
+								},
+							});
 						});
-					});
 				},
 				onOpenTab: () => {
 					dispatch({ type: "HIDE_MODAL" });

package/src/ui/hooks/useProfileStartupModal.ts

@@ -25,10 +25,13 @@ import {
 import type { DisplacedArtifact } from "../../services/profile-live.js";
 import {
 	type ProfileStartupNeed,
+	UPDATE_FORMAT_VALUE,
 	buildProfileOptions,
 	defaultOptionIndex,
 	describeNeed,
+	formatUpdateOutcome,
 	parseProfileChoice,
+	prepareProfileStartup,
 	unparseableNeed,
 } from "../../services/profile-startup.js";
 import { applyProfileChoice } from "../../services/profile-state.js";
@@ -39,6 +42,8 @@ import type { ModalState } from "../state/types.js";
 export interface BuildProfileModalArgs {
 	need: ProfileStartupNeed;
 	onChoose: (choice: ProfileChoice) => void;
+	/** "Update it now" on the `old-format` question — not a profile choice. */
+	onUpdateFormat?: () => void;
 	/**
 	 * Leave magus. NOT "dismiss" — there is deliberately no way to carry on
 	 * without a profile, because there is nothing to carry on with.
@@ -49,7 +54,7 @@ export interface BuildProfileModalArgs {
 export function buildProfileStartupModal(
 	args: BuildProfileModalArgs,
 ): ModalState {
-	const { need, onChoose, onQuit } = args;
+	const { need, onChoose, onUpdateFormat, onQuit } = args;
 	const { title, message } = describeNeed(need);
 	return {
 		type: "select",
@@ -60,6 +65,10 @@ export function buildProfileStartupModal(
 		// developer who has local work and therefore still gets asked.
 		defaultIndex: defaultOptionIndex(need),
 		onSelect: (value: string) => {
+			if (value === UPDATE_FORMAT_VALUE && onUpdateFormat) {
+				onUpdateFormat();
+				return;
+			}
 			const choice = parseProfileChoice(value, need);
 			if (choice) onChoose(choice);
 			else onQuit();
@@ -157,15 +166,27 @@ export function describeFailure(
 	].join("\n");
 }
 
-export function useProfileStartupModal(onQuit: () => void) {
+export function useProfileStartupModal(
+	onQuit: () => void,
+	/** Called once a choice has activated a profile — see App's gitignore re-check. */
+	onActivated?: () => void,
+) {
 	const { state, dispatch } = useApp();
 	const { navigateToScreen } = useNavigation();
 	const projectPath = state.projectPath;
 
 	const show = useCallback(
 		(need: ProfileStartupNeed) => {
-			/** Apply a choice, reporting the outcome either way. */
-			const apply = (choice: ProfileChoice, automatic: boolean): void => {
+			/**
+			 * Apply a choice, reporting the outcome either way. `current` is the
+			 * question it answers — after "Update it now" that is a NEW question,
+			 * whose manifest is the converted one, not the one magus opened with.
+			 */
+			const apply = (
+				choice: ProfileChoice,
+				automatic: boolean,
+				current: ProfileStartupNeed = need,
+			): void => {
 				dispatch({
 					type: "SHOW_MODAL",
 					modal: {
@@ -187,10 +208,11 @@ export function useProfileStartupModal(onQuit: () => void) {
 				// where they left it. `.magus-backups/` is gitignored, so git status
 				// showed the deletion and no sign of the copy.
 				const moved: DisplacedArtifact[] = [];
-				void applyProfileChoice(choice, need.manifest, projectPath, {
+				void applyProfileChoice(choice, current.manifest, projectPath, {
 					onDisplace: (artifact) => moved.push(artifact),
 				})
 					.then((result: ActivationResult) => {
+						onActivated?.();
 						const { profileId, displaced } = result;
 						dispatch({
 							type: "SHOW_MODAL",
@@ -223,7 +245,7 @@ export function useProfileStartupModal(onQuit: () => void) {
 							error instanceof SettingsParseError &&
 							error.path === getManifestPath(projectPath)
 								? unparseableNeed(error)
-								: need;
+								: current;
 						dispatch({
 							type: "SHOW_MODAL",
 							modal: {
@@ -236,7 +258,7 @@ export function useProfileStartupModal(onQuit: () => void) {
 									error,
 									moved,
 									projectPath,
-									need.declaredDefault,
+									current.declaredDefault,
 								),
 								variant: "error",
 								// A failure leaves the project without an active profile, so
@@ -249,12 +271,75 @@ export function useProfileStartupModal(onQuit: () => void) {
 					});
 			};
 
+			/**
+			 * "Update it now" on an old profile format: update it — the same gate
+			 * the CLI runs after its own question — then ask whatever is left, or
+			 * say it is done.
+			 */
+			const updateFormat = (): void => {
+				dispatch({
+					type: "SHOW_MODAL",
+					modal: { type: "loading", message: "Updating the profile format…" },
+				});
+				void prepareProfileStartup(projectPath, { convert: true })
+					.then((result) => {
+						const outcome = formatUpdateOutcome(result);
+						if (outcome.kind === "ask") {
+							onActivated?.();
+							ask(outcome.need);
+							return;
+						}
+						if (outcome.kind === "failed") {
+							// Refused, so still the old format: back to the question,
+							// as the CLI stops on the same lines.
+							dispatch({
+								type: "SHOW_MODAL",
+								modal: {
+									type: "message",
+									title: outcome.title,
+									message: outcome.message,
+									variant: "error",
+									onDismiss: () => ask(need),
+								},
+							});
+							return;
+						}
+						onActivated?.();
+						dispatch({
+							type: "SHOW_MODAL",
+							modal: {
+								type: "message",
+								title: outcome.title,
+								message: outcome.message,
+								variant: "success",
+								onDismiss: () => {
+									dispatch({ type: "HIDE_MODAL" });
+									navigateToScreen("profiles");
+								},
+							},
+						});
+					})
+					.catch((error: unknown) => {
+						dispatch({
+							type: "SHOW_MODAL",
+							modal: {
+								type: "message",
+								title: "Could not update the profile format",
+								message: `${error instanceof Error ? error.message : String(error)}\n\nYour profiles are kept. Open magus again to retry.`,
+								variant: "error",
+								onDismiss: () => ask(need),
+							},
+						});
+					});
+			};
+
 			function ask(current: ProfileStartupNeed = need): void {
 				dispatch({
 					type: "SHOW_MODAL",
 					modal: buildProfileStartupModal({
 						need: current,
-						onChoose: (choice) => apply(choice, false),
+						onChoose: (choice) => apply(choice, false, current),
+						onUpdateFormat: updateFormat,
 						onQuit,
 					}),
 				});
@@ -270,7 +355,7 @@ export function useProfileStartupModal(onQuit: () => void) {
 			}
 			ask();
 		},
-		[dispatch, navigateToScreen, projectPath, onQuit],
+		[dispatch, navigateToScreen, projectPath, onQuit, onActivated],
 	);
 
 	return { show };

package/src/ui/keymap.ts

@@ -156,7 +156,7 @@ const PLUGINS = [
 		"save-profile",
 		["s"],
 		"profile",
-		"Save the enabled plugins as a profile",
+		"Save the installed plugins as a profile",
 		60,
 	),
 	bind(

package/src/ui/renderers/pluginRenderers.tsx

@@ -2,8 +2,11 @@ import type React from "react";
 import { getMarketplaceVersion } from "../../services/marketplace-fetcher.js";
 import {
 	compareVersions,
-	isEnabledButNotInstalled,
+	hasMissingFiles,
+	isInstalledAnywhere,
 	isInstalledInScope,
+	scopeFilesMissing,
+	versionInScope,
 } from "../../services/plugin-manager.js";
 import type { ScopeStatus } from "../../services/plugin-manager.js";
 import type { PluginComponentKind } from "../../services/skills-manager.js";
@@ -195,9 +198,12 @@ function pluginRow(
 	isSelected: boolean,
 ): React.ReactNode {
 	const { plugin } = item;
-	const hasUser = !!plugin.userScope?.enabled;
-	const hasProject = !!plugin.projectScope?.enabled;
-	const hasLocal = !!plugin.localScope?.enabled;
+	// The squares and the name colour read the one installed-at-scope test, the
+	// same one the detail panel's dots read, so the row and the panel beside it
+	// cannot show two different states.
+	const hasUser = isInstalledInScope(plugin.userScope);
+	const hasProject = isInstalledInScope(plugin.projectScope);
+	const hasLocal = isInstalledInScope(plugin.localScope);
 	const hasAnyScope = hasUser || hasProject || hasLocal;
 
 	// Everything after the name — version, history badge, status — comes from
@@ -257,24 +263,13 @@ function pluginRow(
 		);
 	}
 
-	const installedSomewhere =
-		isInstalledInScope(plugin.userScope) ||
-		isInstalledInScope(plugin.projectScope) ||
-		isInstalledInScope(plugin.localScope);
-
 	return (
 		<text fg={theme.colors.text}>
 			<span> </span>
 			<ScopeSquares user={hasUser} project={hasProject} local={hasLocal} />
 			<span> </span>
 			<span fg={theme.colors.dim}>{arrow}</span>
-			<span
-				fg={
-					hasAnyScope && installedSomewhere
-						? theme.colors.text
-						: theme.colors.muted
-				}
-			>
+			<span fg={hasAnyScope ? theme.colors.text : theme.colors.muted}>
 				{displayName}
 			</span>
 			<RowSegments segments={segments} selected={false} />
@@ -344,14 +339,10 @@ function pluginDetail(
 	fetched?: PluginContentsEntry,
 ): React.ReactNode {
 	const { plugin, status } = item;
-	// "Installed" has to mean the same thing here as in the list row. Reading the
-	// `enabledPlugins` flag alone made this panel print "● Installed" for the
-	// exact plugin the row beside it was labelling "not installed".
-	const isInstalled =
-		isInstalledInScope(plugin.userScope) ||
-		isInstalledInScope(plugin.projectScope) ||
-		isInstalledInScope(plugin.localScope);
-	const brokenInstall = isEnabledButNotInstalled(plugin);
+	// "Installed" means the same thing here as in the list row: the one
+	// installed-at-scope test, at any scope.
+	const isInstalled = isInstalledAnywhere(plugin);
+	const filesMissing = hasMissingFiles(plugin);
 	// The ⬆ marker and the U hint claim that pressing U does something. That is
 	// exactly the classifier's update/repair, and nothing else.
 	const needsWork = status?.action === "update" || status?.action === "repair";
@@ -453,25 +444,25 @@ function pluginDetail(
 			<box marginTop={1}>
 				<text
 					fg={
-						isInstalled
-							? theme.colors.success
-							: brokenInstall
-								? theme.colors.danger
+						filesMissing
+							? theme.colors.danger
+							: isInstalled
+								? theme.colors.success
 								: theme.colors.muted
 					}
 				>
-					{isInstalled
-						? "● Installed"
-						: brokenInstall
-							? "○ Not installed — enabled in settings, no files on disk"
+					{filesMissing
+						? "● Installed — files missing"
+						: isInstalled
+							? "● Installed"
 							: "○ Not installed"}
 				</text>
 			</box>
-			{brokenInstall ? (
+			{filesMissing ? (
 				<box>
 					<text fg={theme.colors.muted}>
 						Claude Code cannot load it in this state. Press the scope key to
-						repair.
+						reinstall.
 					</text>
 				</box>
 			) : null}
@@ -631,10 +622,15 @@ function pluginDetail(
 /**
  * One line of the detail panel's scope breakdown.
  *
- * The filled dot means installed — registry-backed, same as everywhere else.
- * A scope that is enabled with nothing installed is called out explicitly
- * rather than shown as a plain empty dot, because those two states need
- * different actions from the user and used to look identical.
+ * The filled dot means what the list row's square means — installed at this
+ * scope — because both read `isInstalledInScope`. The version shows only where
+ * the plugin is installed: a registry row can be inherited from another
+ * directory of the same repository, and magus run in `tools/magus` once showed
+ * "Project team v0.8.1" for a plugin that directory's settings never turn on and
+ * Claude Code started there never loads.
+ *
+ * Installed with no version is named, in the danger colour, because it needs an
+ * action — the scope key reinstalls — and a plain dot would read as healthy.
  */
 function ScopeLine({
 	keyHint,
@@ -647,18 +643,16 @@ function ScopeLine({
 	qualifier: string;
 	scope?: ScopeStatus;
 }): React.ReactNode {
-	const installed = isInstalledInScope(scope);
+	const version = versionInScope(scope);
 	return (
 		<text fg={theme.colors.text}>
 			<ScopeKeyChip scopeKey={keyHint} />
-			<ScopeDot installed={installed} />
+			<ScopeDot installed={isInstalledInScope(scope)} />
 			<span>{name}</span>
 			<span fg={theme.colors.muted}> {qualifier}</span>
-			{scope?.version ? (
-				<span fg={theme.colors.info}> v{scope.version}</span>
-			) : null}
-			{!installed && scope?.enabled ? (
-				<span fg={theme.colors.danger}> enabled, not installed</span>
+			{version ? <span fg={theme.colors.info}> v{version}</span> : null}
+			{scopeFilesMissing(scope) ? (
+				<span fg={theme.colors.danger}> files missing</span>
 			) : null}
 		</text>
 	);

package/src/ui/renderers/pluginRowText.ts

@@ -38,8 +38,12 @@ export function pluginRowText(item: PluginPluginItem): PluginRowText {
 	// A version is shown only when it carries information. "0.0.0" means
 	// installed with an unknown version (Anthropic's official plugins record
 	// exactly that) — it is never printed, and nothing below depends on it.
-	const installed = status?.installed ?? plugin.installedVersion;
-	const shown = isKnownVersion(installed ?? undefined) ? installed : undefined;
+	//
+	// The classifier's version and nothing else. A fallback to
+	// `plugin.installedVersion` printed a version where the classifier had none —
+	// "v0.8.1 files missing", with 0.8.1 read off a scope not installed here.
+	const installed = status?.installed ?? undefined;
+	const shown = isKnownVersion(installed) ? installed : undefined;
 
 	// "What just changed" and "what state it is in now" are independent facts
 	// and both can be true at once: an external update can move a plugin

package/src/ui/renderers/pluginStatusText.ts

@@ -57,13 +57,14 @@ export function pluginStatusText(
 			return { suffix: " BROKEN — press a to fix", tone: "danger" };
 		case "install":
 			// `absent` only ever comes from a profile pin (see `pinForRow`), so it
-			// may say so. An undeclared row that is merely enabled must not.
+			// may say so. An undeclared row whose files are missing must not.
 			return status.reason === "absent"
 				? { suffix: " not installed — profile declares it", tone: "warning" }
-				: // Enabled with nothing on disk is a broken state; a missing
+				: // Files missing is installed, and broken — never "not installed",
+					// which would contradict the filled square beside it. A missing
 					// declared plugin is routine work. Red against amber is the
 					// distinction that matters.
-					{ suffix: ` not installed${withNote}`, tone: "danger" };
+					{ suffix: ` ${status.note ?? "files missing"}`, tone: "danger" };
 		case "current":
 			return { suffix: withNote, tone: "muted" };
 	}

package/src/ui/screens/PluginsScreen.tsx

@@ -26,9 +26,12 @@ import {
 	getAvailablePlugins,
 	getLocalMarketplacesInfo,
 	getMarketplaceFetchFailures,
+	isInstalledAnywhere,
 	isInstalledInScope,
 	refreshAllMarketplaces,
 	resolveScopeAction,
+	scopeFilesMissing,
+	versionInScope,
 } from "../../services/plugin-manager.js";
 import {
 	getPluginEnvRequirements,
@@ -44,7 +47,6 @@ import {
 	fetchPluginContents,
 	fetchPluginSkillDetail,
 } from "../../services/skills-manager.js";
-import { LiveFileRefusal } from "../../services/tracked-live-files.js";
 // The one update implementation, shared with `magus update`. See the header
 // of update-engine.ts for what drifted while the TUI had its own loop.
 import {
@@ -872,17 +874,16 @@ export function PluginsScreen() {
 				scope: ScopeStatus | undefined,
 				desc: string,
 			) => {
-				const installed = isInstalledInScope(scope);
-				const ver = scope?.version;
-				let label = installed ? `● ${name}` : `○ ${name}`;
+				const ver = versionInScope(scope);
+				let label = isInstalledInScope(scope) ? `● ${name}` : `○ ${name}`;
 				label += ` (${desc})`;
 				if (ver) label += ` v${ver}`;
 				if (scopeIsBehind(status, scopeKey) && status?.target)
 					label += ` → v${status.target}`;
-				// Enabled in settings with nothing installed. Without saying so the
-				// row reads exactly like a scope that was never enabled, and the
-				// user cannot tell that picking it repairs rather than adds.
-				if (!installed && scope?.enabled) label += " — not installed, repairs";
+				// Installed with no version. Without saying so the row reads like a
+				// healthy install, and the user cannot tell that picking it
+				// reinstalls rather than uninstalls.
+				if (scopeFilesMissing(scope)) label += " — files missing, reinstalls";
 				return label;
 			};
 
@@ -931,9 +932,9 @@ export function PluginsScreen() {
 						? "Project"
 						: "Local";
 
-			// Decided from the registry-backed version, not the `enabledPlugins`
-			// flag alone — see resolveScopeAction. Update-versus-uninstall is the
-			// same `scopeIsBehind` the label above used.
+			// Files missing reinstalls rather than uninstalls — see
+			// resolveScopeAction. Update-versus-uninstall is the same
+			// `scopeIsBehind` the label above used.
 			const action = resolveScopeAction(
 				selectedScope,
 				scopeIsBehind(status, scopeValue as PluginScope),
@@ -983,11 +984,7 @@ export function PluginsScreen() {
 				fetchData();
 			} catch (error) {
 				modal.hideModal();
-				await modal.message(
-					"Error",
-					error instanceof LiveFileRefusal ? error.message : `Failed: ${error}`,
-					"error",
-				);
+				await modal.message("Error", `Failed: ${error}`, "error");
 			}
 		}
 	};
@@ -1065,10 +1062,12 @@ export function PluginsScreen() {
 	};
 
 	/**
-	 * "Update all" — the SAME planner and the SAME apply engine `magus
-	 * update` runs. Only the selection differs, and only because a screen and a
-	 * profile genuinely mean different sets: here it is "everything listed with
-	 * an update", there it is "what the profile declares".
+	 * "Update all" — the SAME plan, the SAME selection and the SAME apply engine
+	 * `magus update` runs: every item of {@link planPluginUpdates} handed to
+	 * `applyPlugins`, which does the work each one needs (advance, repair,
+	 * reinstall missing files) and skips the rest. There used to be a different
+	 * selection here — "rows that say update" against the CLI's "what the profile
+	 * declares" — and the two surfaces disagreed about the same machine.
 	 *
 	 * This used to be a hand-rolled loop, and it had drifted from the CLI in
 	 * three ways that were bugs, not choices — it touched one scope derived from
@@ -1079,20 +1078,11 @@ export function PluginsScreen() {
 	const handleUpdateAll = async () => {
 		if (pluginsState.plugins.status !== "success") return;
 
-		// Exactly the rows that say "update", "stale — reinstall" or "BROKEN — press
-		// a to fix", each planned under its real pin. Content-stale plugins are
-		// included: they need repairing, and excluding them meant "update all" left
-		// the machine with silently outdated files. Broken (`stale-load`) rows are
-		// included because the row itself now names this key — leaving them out
-		// would make that hint a lie. `install` stays out: a plugin nothing has
-		// installed is `s`'s business, per the note above.
+		// 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.
 		const items = [...statuses.values()]
-			.filter(
-				(s) =>
-					s.action === "update" ||
-					s.action === "repair" ||
-					s.action === "stale-load",
-			)
+			.filter(pluginNeedsWork)
 			.sort((a, b) => a.pluginId.localeCompare(b.pluginId));
 		if (items.length === 0) return;
 
@@ -1160,12 +1150,10 @@ export function PluginsScreen() {
 					? plugin.projectScope
 					: plugin.localScope;
 
-		// This used to key off `scopeData.enabled` alone, so a plugin the list
-		// had just labelled "not installed" answered its own scope key by
-		// uninstalling itself — the `enabledPlugins` flag was set, the registry
-		// entry was missing, and only the flag was consulted. Update-versus-
-		// uninstall is the classifier's `scopeIsBehind`, the same rule the Enter
-		// scope picker labels with.
+		// A scope whose files are missing answers its key with a reinstall. It once
+		// answered with an uninstall, removing the plugin the row was reporting as
+		// broken. Update-versus-uninstall is the classifier's `scopeIsBehind`, the
+		// same rule the Enter scope picker labels with.
 		const action = resolveScopeAction(
 			scopeData,
 			scopeIsBehind(statuses.get(plugin.id), scope),
@@ -1207,11 +1195,7 @@ export function PluginsScreen() {
 			fetchData();
 		} catch (error) {
 			modal.hideModal();
-			await modal.message(
-				"Error",
-				error instanceof LiveFileRefusal ? error.message : `Failed: ${error}`,
-				"error",
-			);
+			await modal.message("Error", `Failed: ${error}`, "error");
 		}
 	};
 
@@ -1364,14 +1348,8 @@ export function PluginsScreen() {
 
 	const scopeLabel = pluginsState.scope === "global" ? "Global" : "Project";
 	const plugins: PluginInfo[] = shownPlugins ?? [];
-	// "installed" must mean the same thing here as in the rows beside it. This
-	// counted `p.enabled` — the settings flag — so the header read "11 installed"
-	// on a screen whose every row said "not installed". Same predicate as the
-	// row and the detail panel now.
-	const isInstalledAnywhere = (p: PluginInfo) =>
-		isInstalledInScope(p.userScope) ||
-		isInstalledInScope(p.projectScope) ||
-		isInstalledInScope(p.localScope);
+	// "installed" means the same thing here as in the rows beside it: the one
+	// installed-at-scope test the row and the detail panel read.
 	const installedCount = plugins.filter(isInstalledAnywhere).length;
 	// Every state count is the classifier's, over the same map the rows read,
 	// so a header can never count a row the list beside it does not show.