magus-cli 7.11.4 → 7.11.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "magus-cli",
-  "version": "7.11.4",
+  "version": "7.11.5",
   "description": "TUI tool for managing Claude Code plugins, MCPs, and configuration",
   "type": "module",
   "main": "src/main.tsx",
@@ -65,8 +65,8 @@
     "typescript": "^5.6.3"
   },
   "optionalDependencies": {
-    "magus-cli-darwin-arm64": "7.11.4",
-    "magus-cli-darwin-x64": "7.11.4",
-    "magus-cli-linux-x64": "7.11.4"
+    "magus-cli-darwin-arm64": "7.11.5",
+    "magus-cli-darwin-x64": "7.11.5",
+    "magus-cli-linux-x64": "7.11.5"
   }
 }

package/src/__tests__/deprecated-remove-all-profiles.test.ts

@@ -0,0 +1,171 @@
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import fs from "fs-extra";
+import type { PluginScope } from "../services/claude-cli.js";
+import { readManifest, writeManifest } from "../services/manifest.js";
+import { reconcileActiveProfile } from "../services/profile-absorb.js";
+import { activateProfile } from "../services/profile-activate.js";
+import { removeDeprecatedPlugin } from "../services/update-engine.js";
+import type { ProfileManifest } from "../types/index.js";
+
+/**
+ * `d` on a deprecated plugin that is installed at no scope in this folder, but
+ * shows as a row because the profile render writes `"<id>": false` for it.
+ *
+ * The render writes `false` for every id in `allPluginIds`, the union of every
+ * profile in `.claude/profiles.json` (`renderProfile`), so a plugin a profile
+ * that is NOT active still lists keeps its key in the live settings.json. The
+ * Plugins screen turns that key into a row. Uninstalling touches nothing:
+ * there is no install here, and the CLI answers every scope with "nothing at
+ * this scope here", in the wording measured on Claude Code 2.1.312.
+ *
+ * CONTRACT the fix must provide, in `services/update-engine.ts`, for the
+ * Plugins screen's `d` to call when the plan carries no `remove` item:
+ *
+ *   export async function removeDeprecatedPlugin(
+ *     pluginId: string,
+ *     projectPath: string,
+ *     deps?: {
+ *       // default `uninstallPluginViaCli`
+ *       uninstall?: (id: string, scope: PluginScope, cwd: string) => Promise<void>;
+ *       // default `readInheritedRegistryRows`
+ *       inheritedRows?: (id: string, projectPath: string) => Promise<InstalledPluginEntry[]>;
+ *     },
+ *   ): Promise<{ problems: unknown[]; unlistedFrom: string[] }>
+ *
+ *   1. Uninstalls at user, project and local in `projectPath`; an error
+ *      `isNotInstalledAnswer` accepts is not a problem.
+ *   2. Uninstalls each inherited row in its own folder; errors are problems.
+ *   3. Removes the id from EVERY profile in the project's profiles.json that
+ *      lists it (`removePluginFromProfile` per profile); `unlistedFrom` names
+ *      them. Profiles that do not list it are not written.
+ *   4. Re-applies the active profile, so the live settings.json no longer
+ *      carries a key for the id.
+ *
+ * Only for a deprecated (no longer published) plugin: the caller decides that.
+ */
+
+const ID = "code-analysis@magus";
+
+/** Measured, Claude Code 2.1.312, from a folder with no row while others hold PROJECT rows. */
+const wrongScope = (scope: PluginScope) =>
+	new Error(
+		`✘ Failed to uninstall plugin "${ID}": Plugin "${ID}" is installed in project scope, not ${scope}. Use --scope project to uninstall.`,
+	);
+
+/** The magus-src shape: the active profile does not list it, two others do. */
+const manifest = (): ProfileManifest => ({
+	version: 2,
+	profiles: {
+		default: { name: "Default", plugins: { "dev@magus": "latest" } },
+		maintainer: {
+			name: "Maintainer",
+			plugins: { "dev@magus": "latest", [ID]: "latest" },
+		},
+		lean: { name: "Lean", plugins: { [ID]: "latest" } },
+		minimal: { name: "Minimal", plugins: { "setup@magus": "latest" } },
+	},
+});
+
+describe("removeDeprecatedPlugin: a deprecated plugin only other profiles list", () => {
+	let project: string;
+	let log: ReturnType<typeof spyOn>;
+	const settingsPath = () => join(project, ".claude", "settings.json");
+	const profilesPath = () => join(project, ".claude", "profiles.json");
+	const mcpPath = () => join(project, ".mcp.json");
+
+	beforeEach(async () => {
+		project = await mkdtemp(join(tmpdir(), "deprecated-all-profiles-"));
+		log = spyOn(console, "log").mockImplementation(() => {});
+		await writeManifest(manifest(), project);
+		await activateProfile(manifest(), "default", project, {
+			onDisplace: () => {},
+		});
+	});
+	afterEach(async () => {
+		log.mockRestore();
+		await rm(project, { recursive: true, force: true });
+	});
+
+	// REGRESSION: deprecated plugin `d` failed with "installed in project scope, not user" and the row came back — Fixed in /dev:fix session dev-fix-20261029-2140-uninstall
+	test("should report no failure, unlist it from every profile, and leave no settings key for it", async () => {
+		// Seeded red: the render wrote the key that makes the row.
+		expect((await fs.readJson(settingsPath())).enabledPlugins[ID]).toBe(false);
+		const before = (await fs.readJson(profilesPath())).profiles;
+
+		const calls: Array<{ scope: PluginScope; cwd: string }> = [];
+		const result = await removeDeprecatedPlugin(ID, project, {
+			uninstall: async (_id, scope, cwd) => {
+				calls.push({ scope, cwd });
+				if (scope === "project") {
+					throw new Error(`Plugin "${ID}" is not installed in project scope.`);
+				}
+				throw wrongScope(scope);
+			},
+			inheritedRows: async () => [],
+		});
+
+		expect(result.problems).toEqual([]);
+		expect([...result.unlistedFrom].sort()).toEqual(["lean", "maintainer"]);
+		expect(calls.map((c) => c.scope).sort()).toEqual([
+			"local",
+			"project",
+			"user",
+		]);
+		expect(calls.every((c) => c.cwd === project)).toBe(true);
+
+		const after = (await readManifest(project)).profiles;
+		for (const id of Object.keys(after)) {
+			expect(after[id]?.plugins?.[ID]).toBeUndefined();
+		}
+		expect(after.maintainer?.plugins).toEqual({ "dev@magus": "latest" });
+		// Profiles that never listed it are not written at all.
+		const raw = (await fs.readJson(profilesPath())).profiles;
+		expect(raw.default).toEqual(before.default);
+		expect(raw.minimal).toEqual(before.minimal);
+
+		const live = (await fs.readJson(settingsPath())).enabledPlugins;
+		expect(Object.hasOwn(live, ID)).toBe(false);
+		expect(live["dev@magus"]).toBe(true);
+
+		// The row does not come back: the next entry point's reconcile and a
+		// fresh activation leave the key out.
+		await reconcileActiveProfile(project);
+		await activateProfile(await readManifest(project), "default", project, {
+			onDisplace: () => {},
+		});
+		expect(
+			Object.hasOwn((await fs.readJson(settingsPath())).enabledPlugins, ID),
+		).toBe(false);
+	});
+
+	// REGRESSION: deprecated plugin `d` re-rendered the live files without absorbing them, losing edits Claude Code made after the TUI started — Fixed in /dev:fix session dev-fix-20261029-2140-uninstall
+	test("should keep edits made to the live files after the profile was activated", async () => {
+		// Written straight into the live files, as Claude Code does mid-session.
+		const settings = await fs.readJson(settingsPath());
+		settings.permissions = { allow: ["Bash(ls:*)"] };
+		settings.enabledPlugins["other@magus"] = true;
+		await fs.writeJson(settingsPath(), settings, { spaces: 2 });
+		const mcp = await fs.readJson(mcpPath());
+		mcp.mcpServers = { ...mcp.mcpServers, local: { command: "local-mcp" } };
+		await fs.writeJson(mcpPath(), mcp, { spaces: 2 });
+
+		const result = await removeDeprecatedPlugin(ID, project, {
+			uninstall: async (_id, scope) => {
+				throw wrongScope(scope);
+			},
+			inheritedRows: async () => [],
+		});
+
+		expect(result.problems).toEqual([]);
+		const live = await fs.readJson(settingsPath());
+		expect(live.permissions?.allow).toEqual(["Bash(ls:*)"]);
+		expect(live.enabledPlugins["other@magus"]).toBe(true);
+		expect(Object.hasOwn(live.enabledPlugins, ID)).toBe(false);
+		expect((await fs.readJson(mcpPath())).mcpServers?.local).toEqual({
+			command: "local-mcp",
+		});
+	});
+});

package/src/__tests__/not-installed-answer-wrong-scope.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, test } from "bun:test";
+import { isNotInstalledAnswer } from "../services/claude-cli.js";
+
+/**
+ * `isNotInstalledAnswer` classifies the CLI's answer to an uninstall at a
+ * scope that holds nothing for this folder. Claude Code has two wordings for
+ * it, and both mean "nothing to do here", never a failure.
+ *
+ * MEASURED on Claude Code 2.1.312, from a folder with no registry row while
+ * other folders hold PROJECT rows for the plugin: `--scope user` and
+ * `--scope local` exit 1 with the strings below. The older wording is what the
+ * CLI says when no folder holds a row at all.
+ */
+
+const ID = "code-analysis@magus";
+
+/** The exact text `claude plugin uninstall … --scope user` printed. */
+const MEASURED_USER = `✘ Failed to uninstall plugin "${ID}": Plugin "${ID}" is installed in project scope, not user. Use --scope project to uninstall.`;
+/** The exact text `claude plugin uninstall … --scope local` printed. */
+const MEASURED_LOCAL = `✘ Failed to uninstall plugin "${ID}": Plugin "${ID}" is installed in project scope, not local. Use --scope project to uninstall.`;
+
+describe("isNotInstalledAnswer", () => {
+	// REGRESSION: deprecated plugin `d` failed with "installed in project scope, not user" and the row came back — Fixed in /dev:fix session dev-fix-20261029-2140-uninstall
+	test("should treat the measured 'installed in project scope, not user' answer as nothing to remove", () => {
+		expect(isNotInstalledAnswer(new Error(MEASURED_USER))).toBe(true);
+	});
+
+	// REGRESSION: deprecated plugin `d` failed with "installed in project scope, not user" and the row came back — Fixed in /dev:fix session dev-fix-20261029-2140-uninstall
+	test("should treat the measured 'installed in project scope, not local' answer as nothing to remove", () => {
+		expect(isNotInstalledAnswer(new Error(MEASURED_LOCAL))).toBe(true);
+	});
+
+	// REGRESSION: deprecated plugin `d` failed with "installed in project scope, not user" and the row came back — Fixed in /dev:fix session dev-fix-20261029-2140-uninstall
+	test("should still treat the older 'not installed in user scope' answer as nothing to remove", () => {
+		expect(
+			isNotInstalledAnswer(
+				new Error(`Plugin "${ID}" is not installed in user scope.`),
+			),
+		).toBe(true);
+	});
+
+	// REGRESSION: deprecated plugin `d` failed with "installed in project scope, not user" and the row came back — Fixed in /dev:fix session dev-fix-20261029-2140-uninstall
+	test("should still count an unrelated error as a failure", () => {
+		expect(isNotInstalledAnswer(new Error("claude timed out"))).toBe(false);
+	});
+});

package/src/__tests__/update-removes-deprecated-other-profiles.test.ts

@@ -0,0 +1,401 @@
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import fs from "fs-extra";
+import { setColorEnabled, stripAnsi } from "../cli/ansi.js";
+import { planReport } from "../cli/update-view.js";
+import type { PluginScope } from "../services/claude-cli.js";
+import { readManifest, writeManifest } from "../services/manifest.js";
+import type { PluginInfo } from "../services/plugin-manager.js";
+import { reconcileActiveProfile } from "../services/profile-absorb.js";
+import { activateProfile } from "../services/profile-activate.js";
+import { withCliBookkeeping } from "../services/profile-state.js";
+import {
+	pluginsAnyProfileLists,
+	resolveProfile,
+} from "../services/resolver.js";
+import {
+	type ApplyReporter,
+	type PluginApplyDeps,
+	REAL_REMOVE_DEPS,
+	applyPlugins,
+	describeRemoved,
+} from "../services/update-engine.js";
+import {
+	type PluginUpdateItem,
+	type UpdatePlan,
+	classifyPluginRows,
+	planIsBehind,
+	planPluginUpdates,
+} from "../services/update-plan.js";
+import type { ProfileManifest } from "../types/index.js";
+
+/**
+ * `magus update` and the Plugins screen plan a deprecated plugin that only a
+ * profile which is NOT active lists.
+ *
+ * The profile render writes `"<id>": false` into `.claude/settings.json` for
+ * every id ANY profile lists, and the Plugins screen shows that key as a
+ * deprecated row. The planner used to see only the active profile's pins and
+ * the plugins installed somewhere, so `magus update --check` answered "Nothing
+ * missing and nothing behind." while the row stayed, and `magus update` never
+ * removed it. When the active profile did list it, the removal dropped it from
+ * that profile only, so another profile kept it and the `false` came back on
+ * the next render.
+ *
+ * CONTRACT:
+ *  - `pluginsAnyProfileLists(manifest)` (resolver.ts): every plugin id some
+ *    profile turns on, `extends` resolved.
+ *  - `planPluginUpdates(pins, catalog, requiredBy, listedByProfiles)` and
+ *    `classifyPluginRows(plugins, pins, requiredBy, listedByProfiles)`: an id
+ *    in `listedByProfiles` that is neither pinned nor installed gets a
+ *    `remove` item with `scopes: []` when it is deprecated, and NO item
+ *    otherwise (published, moved, still required, marketplace unread).
+ *  - applying a `remove` drops the id from EVERY profile listing it, absorbing
+ *    the live files first, so the user's live edits survive and the key is
+ *    gone from settings.json afterwards.
+ */
+
+const ID = "code-analysis@magus";
+
+/** The reporter's shape: the active profile does not list it, two others do. */
+const manifest = (activeListsIt = false): ProfileManifest => ({
+	version: 2,
+	profiles: {
+		default: {
+			name: "Default",
+			plugins: {
+				"dev@magus": "latest",
+				...(activeListsIt ? { [ID]: "latest" } : {}),
+			},
+		},
+		maintainer: {
+			name: "Maintainer",
+			plugins: { "dev@magus": "latest", [ID]: "latest" },
+		},
+		lean: { name: "Lean", plugins: { [ID]: "latest" } },
+		minimal: { name: "Minimal", plugins: { "setup@magus": "latest" } },
+	},
+});
+
+function info(over: Partial<PluginInfo> & { id: string }): PluginInfo {
+	return {
+		name: over.id.split("@")[0] as string,
+		version: null,
+		description: "",
+		marketplace: over.id.split("@")[1] ?? "magus",
+		marketplaceDisplay: "",
+		...over,
+	};
+}
+
+/** Published and installed here — what makes "magus" a marketplace we read. */
+const DEV = info({
+	id: "dev@magus",
+	version: "1.0.0",
+	projectScope: { installed: true, version: "1.0.0" },
+});
+/** Published, installed nowhere. */
+const SETUP = info({ id: "setup@magus", version: "2.0.0" });
+
+/** The id's catalog entry as the screen sees it: a `false` key, an orphan. */
+const ORPHAN = info({ id: ID, isOrphaned: true });
+
+const CATALOG: PluginInfo[] = [DEV, SETUP, ORPHAN];
+
+function itemsFor(items: PluginUpdateItem[], id: string): PluginUpdateItem[] {
+	return items.filter((i) => i.pluginId === id);
+}
+
+afterEach(() => setColorEnabled(null));
+
+// ---------------------------------------------------------------------------
+// 1. The planner
+// ---------------------------------------------------------------------------
+
+describe("planner: a plugin only an inactive profile lists", () => {
+	// REGRESSION: `magus update --check` said "Nothing missing and nothing behind." while a deprecated plugin only other profiles list stayed a row — MTL-332
+	test("should plan one remove with no scopes for a deprecated id", () => {
+		const items = planPluginUpdates({ "dev@magus": "latest" }, CATALOG, {}, [
+			ID,
+			"dev@magus",
+			"setup@magus",
+		]);
+
+		const found = itemsFor(items, ID);
+		expect(found).toHaveLength(1);
+		expect({
+			action: found[0]?.action,
+			reason: found[0]?.reason,
+			scopes: found[0]?.scopes,
+		}).toEqual({ action: "remove", reason: "deprecated", scopes: [] });
+	});
+
+	test("should plan a deprecated id with no catalog entry at all", () => {
+		const items = planPluginUpdates({ "dev@magus": "latest" }, [DEV], {}, [ID]);
+		expect(itemsFor(items, ID).map((i) => i.action)).toEqual(["remove"]);
+	});
+
+	test("should plan nothing for a PUBLISHED id only an inactive profile lists", () => {
+		const items = planPluginUpdates({ "dev@magus": "latest" }, CATALOG, {}, [
+			ID,
+			"setup@magus",
+		]);
+		expect(itemsFor(items, "setup@magus")).toEqual([]);
+	});
+
+	test("should not plan a remove for one that moved to another marketplace", () => {
+		const moved = info({ id: "code-analysis@other", version: "3.0.0" });
+		const items = planPluginUpdates(
+			{ "dev@magus": "latest" },
+			[...CATALOG, moved],
+			{},
+			[ID],
+		);
+		expect(itemsFor(items, ID).filter((i) => i.action === "remove")).toEqual(
+			[],
+		);
+		expect(itemsFor(items, ID).filter((i) => i.action === "install")).toEqual(
+			[],
+		);
+	});
+
+	test("should not plan a remove for one a staying plugin still requires", () => {
+		const items = planPluginUpdates(
+			{ "dev@magus": "latest" },
+			CATALOG,
+			{ [ID]: ["dev@magus"] },
+			[ID],
+		);
+		expect(itemsFor(items, ID).filter((i) => i.action === "remove")).toEqual(
+			[],
+		);
+		expect(itemsFor(items, ID).filter((i) => i.action === "install")).toEqual(
+			[],
+		);
+	});
+
+	test("should plan nothing when the id's marketplace was not read", () => {
+		const unread = "thing@unread-market";
+		const items = planPluginUpdates({ "dev@magus": "latest" }, CATALOG, {}, [
+			unread,
+		]);
+		expect(itemsFor(items, unread)).toEqual([]);
+	});
+
+	test("should make --check behind and report it under the removed wording", () => {
+		setColorEnabled(false);
+		const plan: UpdatePlan = {
+			profileId: "default",
+			plugins: planPluginUpdates({ "dev@magus": "latest" }, CATALOG, {}, [ID]),
+			bins: [],
+			skills: [],
+			binSpecs: new Map(),
+		};
+		expect(planIsBehind(plan)).toBe(true);
+		const report = planReport(plan).map(stripAnsi).join("\n");
+		expect(report).toContain("code-analysis");
+		expect(describeRemoved([ID])).toBe(
+			"Removed code-analysis — no longer published",
+		);
+	});
+});
+
+describe("pluginsAnyProfileLists", () => {
+	test("should list every id some profile turns on, and none turned off", () => {
+		const m = manifest();
+		const entry = m.profiles.minimal;
+		if (entry) entry.plugins = { ...entry.plugins, "off@magus": false };
+		expect([...pluginsAnyProfileLists(m)].sort()).toEqual([
+			ID,
+			"dev@magus",
+			"setup@magus",
+		]);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// 2. Parity: the CLI's plan and the screen's rows
+// ---------------------------------------------------------------------------
+
+describe("parity: magus update and the Plugins screen", () => {
+	test("should agree on a deprecated id only an inactive profile lists", () => {
+		const pins = { "dev@magus": "latest" };
+		const listed = pluginsAnyProfileLists(manifest());
+		const cli = planPluginUpdates(pins, CATALOG, {}, listed);
+		const rows = classifyPluginRows(CATALOG, pins, {}, listed);
+
+		expect(rows.get(ID)).toEqual(itemsFor(cli, ID)[0]);
+		expect(rows.get(ID)?.action).toBe("remove");
+		expect(rows.has("setup@magus")).toBe(
+			itemsFor(cli, "setup@magus").length > 0,
+		);
+		expect(rows.has("setup@magus")).toBe(false);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// 3 + 4. Applying the plan on a real project
+// ---------------------------------------------------------------------------
+
+/** Measured, Claude Code 2.1.312, from a folder with no row while others hold PROJECT rows. */
+const wrongScope = (scope: PluginScope) =>
+	new Error(
+		`✘ Failed to uninstall plugin "${ID}": Plugin "${ID}" is installed in project scope, not ${scope}. Use --scope project to uninstall.`,
+	);
+
+const SILENT: ApplyReporter = {
+	begin: () => {},
+	finish: () => {},
+	detach: (work) => work(),
+};
+
+/** The real profile half; Claude Code's commands are doubles. */
+function deps(): PluginApplyDeps {
+	const unused = async () => {
+		throw new Error("a removal must not install, update or repair anything");
+	};
+	return {
+		install: unused,
+		update: unused,
+		repair: unused,
+		readInstalled: unused,
+		saveInstalled: unused,
+		repairStaleLoad: unused,
+		registryRows: async () => [],
+		remove: {
+			...REAL_REMOVE_DEPS,
+			uninstall: async (_id, scope) => {
+				throw wrongScope(scope);
+			},
+			isInstalled: async () => false,
+			forgetVersion: async () => {},
+		},
+	};
+}
+
+/** Both callers: `magus update` (under bookkeeping) and the Plugins screen. */
+const SURFACES = [
+	["magus update", true],
+	["the Plugins screen", false],
+] as const;
+
+describe("applying the plan removes it from every profile", () => {
+	let project: string;
+	let log: ReturnType<typeof spyOn>;
+	const settingsPath = () => join(project, ".claude", "settings.json");
+	const profilesPath = () => join(project, ".claude", "profiles.json");
+
+	async function setUp(activeListsIt: boolean) {
+		await writeManifest(manifest(activeListsIt), project);
+		await activateProfile(manifest(activeListsIt), "default", project, {
+			onDisplace: () => {},
+		});
+	}
+
+	/** The plan exactly as `magus update` makes it. */
+	async function plan(): Promise<PluginUpdateItem[]> {
+		const m = await readManifest(project);
+		const closure = await resolveProfile(m, "default");
+		return planPluginUpdates(
+			closure.plugins,
+			CATALOG,
+			{},
+			pluginsAnyProfileLists(m),
+		).filter((i) => i.action === "remove");
+	}
+
+	async function apply(items: PluginUpdateItem[], bookkept: boolean) {
+		const run = () =>
+			applyPlugins(items, project, deps(), SILENT, { profile: "default" });
+		return bookkept ? withCliBookkeeping(project, run) : run();
+	}
+
+	beforeEach(async () => {
+		project = await mkdtemp(join(tmpdir(), "update-deprecated-others-"));
+		log = spyOn(console, "log").mockImplementation(() => {});
+	});
+	afterEach(async () => {
+		log.mockRestore();
+		await rm(project, { recursive: true, force: true });
+	});
+
+	for (const [surface, bookkept] of SURFACES) {
+		// REGRESSION: `magus update` never removed a deprecated plugin only inactive profiles list; its `false` key stayed in settings.json — MTL-332
+		test(`${surface}: no profile lists it, untouched profiles are byte-equal, no settings key`, async () => {
+			await setUp(false);
+			// Seeded red: the render wrote the key that makes the row.
+			expect((await fs.readJson(settingsPath())).enabledPlugins[ID]).toBe(
+				false,
+			);
+			const before = (await fs.readJson(profilesPath())).profiles;
+
+			const items = await plan();
+			expect(items.map((i) => i.pluginId)).toEqual([ID]);
+			const result = await apply(items, bookkept);
+
+			expect(result.failed).toEqual([]);
+			expect(result.removed).toEqual([ID]);
+			const after = (await readManifest(project)).profiles;
+			for (const id of Object.keys(after)) {
+				expect(after[id]?.plugins?.[ID]).toBeUndefined();
+			}
+			expect(after.maintainer?.plugins).toEqual({ "dev@magus": "latest" });
+			const raw = (await fs.readJson(profilesPath())).profiles;
+			expect(raw.default).toEqual(before.default);
+			expect(raw.minimal).toEqual(before.minimal);
+
+			const live = (await fs.readJson(settingsPath())).enabledPlugins;
+			expect(Object.hasOwn(live, ID)).toBe(false);
+			expect(live["dev@magus"]).toBe(true);
+
+			// It does not come back on the next entry point.
+			await reconcileActiveProfile(project);
+			expect(
+				Object.hasOwn((await fs.readJson(settingsPath())).enabledPlugins, ID),
+			).toBe(false);
+			expect(await plan()).toEqual([]);
+		});
+
+		// REGRESSION: removing a deprecated plugin must not lose live edits made after the profile was activated — MTL-332
+		test(`${surface}: a live edit survives the removal`, async () => {
+			await setUp(false);
+			const settings = await fs.readJson(settingsPath());
+			settings.permissions = { allow: ["Bash(ls:*)"] };
+			settings.enabledPlugins["other@magus"] = true;
+			await fs.writeJson(settingsPath(), settings, { spaces: 2 });
+
+			const result = await apply(await plan(), bookkept);
+
+			expect(result.failed).toEqual([]);
+			const live = await fs.readJson(settingsPath());
+			expect(live.permissions?.allow).toEqual(["Bash(ls:*)"]);
+			expect(live.enabledPlugins["other@magus"]).toBe(true);
+			expect(Object.hasOwn(live.enabledPlugins, ID)).toBe(false);
+			for (const entry of Object.values(
+				(await readManifest(project)).profiles,
+			)) {
+				expect(entry.plugins?.[ID]).toBeUndefined();
+			}
+		});
+
+		// REGRESSION: removing a deprecated plugin the active profile lists dropped it from that profile only, so another profile kept it — MTL-332
+		test(`${surface}: the active profile and another both list it, neither does afterwards`, async () => {
+			await setUp(true);
+			const items = await plan();
+			expect(items.map((i) => i.pluginId)).toEqual([ID]);
+
+			const result = await apply(items, bookkept);
+
+			expect(result.failed).toEqual([]);
+			const after = (await readManifest(project)).profiles;
+			expect(after.default?.plugins?.[ID]).toBeUndefined();
+			expect(after.maintainer?.plugins?.[ID]).toBeUndefined();
+			expect(after.lean?.plugins?.[ID]).toBeUndefined();
+			expect(
+				Object.hasOwn((await fs.readJson(settingsPath())).enabledPlugins, ID),
+			).toBe(false);
+		});
+	}
+});

package/src/cli/update.ts

@@ -63,7 +63,11 @@ import {
 	switchHint,
 	withCliBookkeeping,
 } from "../services/profile-state.js";
-import { requirersHere, resolveProfile } from "../services/resolver.js";
+import {
+	pluginsAnyProfileLists,
+	requirersHere,
+	resolveProfile,
+} from "../services/resolver.js";
 import { getInstalledSkillNames } from "../services/skills-manager.js";
 import { REAL_TOOL_PROBE_IO, probeTools } from "../services/tool-probe.js";
 import { managedBins } from "../services/toolchain.js";
@@ -503,7 +507,15 @@ async function updateProfile(
 	);
 	const plan: UpdatePlan = {
 		profileId: targetId,
-		plugins: planPluginUpdates(closure.plugins, catalog, requiredBy),
+		// Every profile's plugins, not only this one's: a deprecated plugin a
+		// profile that is not active lists is still a row the render keeps, and
+		// is planned for removal.
+		plugins: planPluginUpdates(
+			closure.plugins,
+			catalog,
+			requiredBy,
+			pluginsAnyProfileLists(current),
+		),
 		bins: planBinUpdates(tools, toolFacts),
 		skills: planSkillUpdates(skillRefs, installedSkills),
 		binSpecs: new Map(tools.map((b) => [b.name, b])),

package/src/services/active-closure.ts

@@ -21,7 +21,7 @@ import type {
 } from "../types/index.js";
 import { readManifest, validateManifest } from "./manifest.js";
 import { activeProfile } from "./profile-live.js";
-import { resolveProfile } from "./resolver.js";
+import { pluginsAnyProfileLists, resolveProfile } from "./resolver.js";
 
 /**
  * The profile to use: the explicit one, else the active one, else the only one.
@@ -45,6 +45,12 @@ export function selectProfileId(
 export interface ActiveClosure {
 	profileId: string;
 	closure: ResolvedClosure;
+	/**
+	 * Every plugin id ANY profile in the manifest lists
+	 * (`pluginsAnyProfileLists`) — the planner's `listedByProfiles`, the same
+	 * set `magus update` passes it.
+	 */
+	listedByProfiles: string[];
 }
 
 export interface ActiveClosureDeps {
@@ -110,7 +116,11 @@ export async function loadActiveClosure(
 			profileId,
 			opts.resolveBins === false ? { binResolver: NO_BINS } : {},
 		);
-		return { profileId, closure };
+		return {
+			profileId,
+			closure,
+			listedByProfiles: pluginsAnyProfileLists(manifest),
+		};
 	} catch {
 		return null;
 	}

package/src/services/claude-cli.ts

@@ -271,10 +271,21 @@ export async function uninstallPluginViaCli(
 /**
  * Is `error` the CLI's answer that the plugin is not installed at the scope it
  * was asked about — the one failure of an uninstall that means "nothing to do".
+ *
+ * Claude Code has two wordings for it. With no row anywhere: `Plugin "<id>" is
+ * not installed in <scope> scope`. With rows only at another scope or in other
+ * folders (measured, Claude Code 2.1.312): `Plugin "<id>" is installed in
+ * <other> scope, not <scope>. Use --scope <other> to uninstall.` Both mean the
+ * asked scope holds nothing here; anything else is a real failure.
  */
 export function isNotInstalledAnswer(error: unknown): boolean {
 	const message = error instanceof Error ? error.message : String(error);
-	return /not installed in (user|project|local) scope/i.test(message);
+	return (
+		/not installed in (user|project|local) scope/i.test(message) ||
+		/is installed in (user|project|local) scope, not (user|project|local)\b/i.test(
+			message,
+		)
+	);
 }
 
 /**

package/src/services/profile-state.ts

@@ -26,7 +26,7 @@
  */
 
 import path from "node:path";
-import type { ProfileManifest, ProfileManifestEntry } from "../types/index.js";
+import type { ProfileManifest } from "../types/index.js";
 import { selectProfileId } from "./active-closure.js";
 import { updateManagedGitignoreBlock } from "./conventions-manager.js";
 import { readManifest, updateProfileEntry, writeManifest } from "./manifest.js";
@@ -74,7 +74,7 @@ import {
 	skillFolder,
 	skillIgnoreLine,
 } from "./profile-skills.js";
-import { resolveExtends } from "./resolver.js";
+import { profileLists } from "./resolver.js";
 import type { SettingsParseError } from "./settings-file.js";
 
 export type ActiveProfileCheck =
@@ -674,16 +674,6 @@ export async function withCliBookkeeping<T>(
 	}
 }
 
-/** Whether a profile entry, `extends` included, turns the plugin on. */
-function profileLists(
-	entry: ProfileManifestEntry | undefined,
-	pluginId: string,
-): boolean {
-	if (!entry) return false;
-	const value = resolveExtends(entry).plugins?.[pluginId];
-	return value !== undefined && value !== false;
-}
-
 /**
  * Stop a profile listing `pluginId`, so its next activation does not turn the
  * plugin back on. Answers whether the profile no longer lists it — read back

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/screens/PluginsScreen.tsx

@@ -9,14 +9,8 @@ import {
 	type PluginScope,
 	addMarketplace as cliAddMarketplace,
 	repairPlugin as cliRepairPlugin,
-	isNotInstalledAnswer,
-	uninstallPluginViaCli,
 } from "../../services/claude-cli.js";
-import {
-	readInheritedRegistryRows,
-	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 {
@@ -49,6 +43,7 @@ import {
 	applyPlugins,
 	installPluginInScope,
 	pluginNeedsWork,
+	removeDeprecatedPlugin,
 	uninstallPluginInScope,
 	updatePluginInScope,
 } from "../../services/update-engine.js";
@@ -176,6 +171,14 @@ export function PluginsScreen() {
 	const [requiredBy, setRequiredBy] = useState<
 		Readonly<Record<string, readonly string[]>>
 	>({});
+	/**
+	 * Every plugin any profile lists — the same set `magus update` plans with,
+	 * so a deprecated plugin only another profile keeps is a `remove` row here
+	 * and a removal there.
+	 */
+	const [listedByProfiles, setListedByProfiles] = useState<readonly string[]>(
+		[],
+	);
 
 	// Fetch data (always fetches all scopes). Only the most recently started
 	// load may touch the screen.
@@ -209,6 +212,7 @@ export function PluginsScreen() {
 			setPins(active?.closure.plugins ?? null);
 			setActiveProfileId(active?.profileId ?? null);
 			setRequiredBy(required);
+			setListedByProfiles(active?.listedByProfiles ?? []);
 
 			// Which catalogs answered, and which only appeared to. Read straight
 			// after the fetch, while the record still describes this attempt.
@@ -300,9 +304,14 @@ export function PluginsScreen() {
 	const statuses = useMemo(
 		(): Map<string, PluginUpdateItem> =>
 			shownPlugins
-				? classifyPluginRows(shownPlugins, pins ?? {}, requiredBy)
+				? classifyPluginRows(
+						shownPlugins,
+						pins ?? {},
+						requiredBy,
+						listedByProfiles,
+					)
 				: new Map(),
-		[shownPlugins, pins, requiredBy],
+		[shownPlugins, pins, requiredBy, listedByProfiles],
 	);
 
 	/**
@@ -1265,39 +1274,16 @@ export function PluginsScreen() {
 			return;
 		}
 
-		// Errors are collected, not dropped: only the CLI's "is not installed in
-		// <scope> scope" answer is expected, and only for a scope with no row.
-		const problems: unknown[] = [];
+		// An orphan the plan keeps rather than removes — it moved, another plugin
+		// still requires it, or its marketplace was not read — and the user asked
+		// for it gone. The engine uninstalls everywhere, drops it from every
+		// profile and renders the active one again, so the row does not come back.
 		try {
-			// Remove from all scopes — try all to clean up stale references
-			const scopes: PluginScope[] = ["user", "project", "local"];
-			for (const scope of scopes) {
-				try {
-					modal.loading(
-						`Removing ${plugin.name} from ${scope}…\nclaude plugin uninstall ${plugin.id} --scope ${scope}`,
-					);
-					await uninstallPluginViaCli(plugin.id, scope, state.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.
-			const inherited = await readInheritedRegistryRows(
+			modal.loading(`Removing ${plugin.name}…`);
+			const { problems } = await removeDeprecatedPlugin(
 				plugin.id,
 				state.projectPath || process.cwd(),
 			);
-			for (const row of inherited) {
-				if (!row.projectPath) continue;
-				try {
-					modal.loading(
-						`Removing ${plugin.name} from the repository's main folder, which this folder shares…\nclaude plugin uninstall ${plugin.id} --scope ${row.scope}`,
-					);
-					await uninstallPluginViaCli(plugin.id, row.scope, row.projectPath);
-				} catch (error) {
-					problems.push(error);
-				}
-			}
 
 			modal.hideModal();
 			fetchData();