magus-cli 7.7.0 → 7.8.0

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

@@ -0,0 +1,827 @@
+/**
+ * Deprecated plugins are removed, and failed updates say why.
+ *
+ * A plugin whose marketplace was READ and does not list it is deprecated:
+ * Claude Code refuses to load it ("Plugin X not found in marketplace Y",
+ * measured on 2.1.284), so it is dead weight. The ONE plan both front ends share
+ * gives it the action `remove`; the ONE apply uninstalls it at every scope it
+ * is installed at here and drops it from the profile, so the next activation
+ * does not add it back.
+ *
+ * The profile half is proven against real files in a temp project: that the
+ * reconcile would absorb a project-scope uninstall into the ACTIVE profile on
+ * its own, that it would NOT reach a profile that is not active (so the edit
+ * cannot be left to it), and that the engine's edit and the reconcile agree.
+ *
+ * Two unlisted plugins are NOT removed, because removing them would lose
+ * something or would not stick: one another marketplace lists under the same
+ * name (it moved), and one the profile has only because another plugin
+ * requires it (the next resolve derives it again).
+ *
+ * A removal that fails reaches the Plugins screen's failure popup in the same
+ * words the CLI prints (failure-popup.test.tsx).
+ */
+
+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 { pendingHeadline, planReport } from "../cli/update-view.js";
+import {
+	type PluginScope,
+	uninstallPluginViaCli,
+} 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 {
+	removePluginFromProfile,
+	withCliBookkeeping,
+} from "../services/profile-state.js";
+import {
+	type ApplyReporter,
+	type FinishCause,
+	type PluginApplyDeps,
+	type PluginRemoveDeps,
+	REAL_REMOVE_DEPS,
+	applyPlan,
+	applyPlugins,
+	describeRemoved,
+	planWorkItems,
+	pluginNeedsWork,
+} from "../services/update-engine.js";
+import {
+	type PluginUpdateItem,
+	type UpdatePlan,
+	classifyPluginRows,
+	countPluginStates,
+	planIsBehind,
+	planPluginUpdates,
+} from "../services/update-plan.js";
+import type { ProfileManifest } from "../types/index.js";
+import { failureReasons } from "../ui/adapters/pluginsAdapter.js";
+import { pluginStatusText } from "../ui/renderers/pluginStatusText.js";
+
+// ── builders ────────────────────────────────────────────────────────────────
+
+function info(over: Partial<PluginInfo> & { id: string }): PluginInfo {
+	const [name = over.id, marketplace = ""] = over.id.split("@");
+	return {
+		name,
+		version: null,
+		description: "",
+		marketplace,
+		marketplaceDisplay: marketplace,
+		...over,
+	};
+}
+
+/** A plugin its marketplace still lists — proof that marketplace was read. */
+const LISTED = info({
+	id: "dev@magus",
+	version: "9.0.0",
+	projectScope: { installed: true, version: "9.0.0" },
+});
+
+/** Installed here, and no longer listed by a marketplace we read. */
+function orphan(id: string, over: Partial<PluginInfo> = {}): PluginInfo {
+	return info({
+		id,
+		version: "1.6.2",
+		installedVersion: "1.6.2",
+		isOrphaned: true,
+		projectScope: { installed: true, version: "1.6.2" },
+		...over,
+	});
+}
+
+function plan(plugins: PluginUpdateItem[], profileId = "team"): UpdatePlan {
+	return {
+		profileId,
+		plugins,
+		bins: [],
+		skills: [],
+		binSpecs: new Map(),
+	};
+}
+
+// ── A. the plan ─────────────────────────────────────────────────────────────
+
+describe("the plan: a deprecated plugin is work, not a shrug", () => {
+	test("installed and unlisted, marketplace read: remove / deprecated at every installed scope", () => {
+		const kanban = orphan("kanban@magus", {
+			userScope: { installed: true, version: "1.6.2" },
+			// A registry version at a scope that does NOT turn it on is not an install.
+			localScope: { installed: false, version: "1.6.2" },
+		});
+		const [item] = planPluginUpdates({}, [LISTED, kanban]).filter(
+			(i) => i.pluginId === "kanban@magus",
+		);
+
+		expect(item).toMatchObject({
+			action: "remove",
+			reason: "deprecated",
+			target: null,
+			scopes: ["user", "project"],
+			note: "no longer published",
+		});
+		expect(pluginNeedsWork(item as PluginUpdateItem)).toBe(true);
+	});
+
+	test("declared by the profile, installed nowhere: remove with no scopes, and still work", () => {
+		const [item] = planPluginUpdates({ "kanban@magus": "latest" }, [
+			LISTED,
+		]).filter((i) => i.pluginId === "kanban@magus");
+
+		expect(item).toMatchObject({
+			action: "remove",
+			reason: "deprecated",
+			scopes: [],
+		});
+		// The profile edit is the whole of the work, so it is counted as work.
+		expect(pluginNeedsWork(item as PluginUpdateItem)).toBe(true);
+	});
+
+	test("installed with its files missing and unlisted: its scope is uninstalled", () => {
+		const gone = orphan("gone@magus", {
+			installedVersion: undefined,
+			projectScope: { installed: true },
+		});
+		const [item] = planPluginUpdates({}, [LISTED, gone]).filter(
+			(i) => i.pluginId === "gone@magus",
+		);
+		expect(item).toMatchObject({ action: "remove", scopes: ["project"] });
+	});
+
+	test("NEGATIVE CONTROL: a marketplace that was not read proves nothing — unknown, never applied", () => {
+		const ghost = orphan("ghost@unread-mp");
+		const [item] = planPluginUpdates({}, [LISTED, ghost]).filter(
+			(i) => i.pluginId === "ghost@unread-mp",
+		);
+		expect(item).toMatchObject({
+			action: "unknown",
+			reason: "marketplace-unread",
+		});
+		expect(pluginNeedsWork(item as PluginUpdateItem)).toBe(false);
+	});
+
+	test("counted as work by --dry-run, the meter, --check and the header", () => {
+		const items = planPluginUpdates({ "agentdev@magus": "latest" }, [
+			LISTED,
+			orphan("kanban@magus"),
+			orphan("ghost@unread-mp"),
+		]);
+		const p = plan(items);
+
+		expect(planWorkItems(p).sort()).toEqual(["agentdev@magus", "kanban@magus"]);
+		expect(planIsBehind(p)).toBe(true);
+		expect(countPluginStates(items)).toMatchObject({ remove: 2, unknown: 1 });
+		// The TUI's rows come from the same plan.
+		expect(
+			classifyPluginRows([LISTED, orphan("kanban@magus")], {}).get(
+				"kanban@magus",
+			)?.action,
+		).toBe("remove");
+	});
+
+	test("--check says 'Changes pending' when removals are the only work, 'Updates available' otherwise", () => {
+		const removals = plan(
+			planPluginUpdates({}, [LISTED, orphan("kanban@magus")]),
+		);
+		expect(pendingHeadline(removals)).toBe("Changes pending");
+		const behind = info({
+			id: "mnemex@magus",
+			version: "2.0.0",
+			projectScope: { installed: true, version: "1.0.0" },
+		});
+		const mixed = plan(
+			planPluginUpdates({}, [LISTED, orphan("kanban@magus"), behind]),
+		);
+		expect(pendingHeadline(mixed)).toBe("Updates available");
+	});
+});
+
+describe("M4: a plugin that moved to another marketplace is not removed", () => {
+	/** magus-marketing still publishes seo — the plugin moved, it was not retired. */
+	const MOVED_TO = info({
+		id: "seo@magus-marketing",
+		version: "1.1.0",
+		marketplaceDisplay: "Magus Marketing",
+	});
+
+	test("installed under the old marketplace: unknown, 'moved to <display name>', never applied", () => {
+		const [item] = planPluginUpdates({}, [
+			LISTED,
+			MOVED_TO,
+			orphan("seo@magus"),
+		]).filter((i) => i.pluginId === "seo@magus");
+		expect(item).toMatchObject({
+			action: "unknown",
+			reason: "moved",
+			scopes: [],
+			note: "moved to Magus Marketing",
+		});
+		expect(pluginNeedsWork(item as PluginUpdateItem)).toBe(false);
+		// Kept on purpose, which is known: muted with the note, never the "?"
+		// of a check that could not tell.
+		expect(pluginStatusText(item as PluginUpdateItem)).toEqual({
+			suffix: " moved to Magus Marketing",
+			tone: "muted",
+		});
+	});
+
+	test("declared by the profile and installed nowhere: the same, so the pin is not dropped", () => {
+		const [item] = planPluginUpdates({ "seo@magus": "latest" }, [
+			LISTED,
+			MOVED_TO,
+		]).filter((i) => i.pluginId === "seo@magus");
+		expect(item).toMatchObject({ action: "unknown", reason: "moved" });
+	});
+
+	test("NEGATIVE CONTROL: the same name in the SAME marketplace is not a move", () => {
+		const [item] = planPluginUpdates({}, [
+			LISTED,
+			info({ id: "seo-tools@magus", version: "1.0.0" }),
+			orphan("seo@magus"),
+		]).filter((i) => i.pluginId === "seo@magus");
+		expect(item).toMatchObject({ action: "remove", reason: "deprecated" });
+	});
+
+	test("NEGATIVE CONTROL: an orphan of the other marketplace does not count as listed there", () => {
+		const [item] = planPluginUpdates({}, [
+			LISTED,
+			orphan("seo@magus-marketing"),
+			orphan("seo@magus"),
+		]).filter((i) => i.pluginId === "seo@magus");
+		expect(item).toMatchObject({ action: "remove", reason: "deprecated" });
+	});
+});
+
+describe("M3: a deprecated plugin the profile has only as a dependency is not removed", () => {
+	test("derived pin: unknown, naming the plugin that still requires it", () => {
+		const items = planPluginUpdates(
+			{ "dev@magus": "latest", "kanban@magus": "latest" },
+			[LISTED, orphan("kanban@magus")],
+			{ "kanban@magus": "dev@magus" },
+		);
+		const item = items.find((i) => i.pluginId === "kanban@magus");
+		expect(item).toMatchObject({
+			action: "unknown",
+			reason: "still-required",
+			note: "no longer published, but dev still requires it",
+		});
+		expect(pluginNeedsWork(item as PluginUpdateItem)).toBe(false);
+		// Not work, so --check does not fail forever on it.
+		expect(planIsBehind(plan(items))).toBe(false);
+	});
+
+	test("installed nowhere: the same — dropping it from the profile would drop nothing", () => {
+		const [item] = planPluginUpdates({ "kanban@magus": "latest" }, [LISTED], {
+			"kanban@magus": "dev@magus",
+		}).filter((i) => i.pluginId === "kanban@magus");
+		expect(item).toMatchObject({ action: "unknown", reason: "still-required" });
+	});
+
+	test("the TUI's rows read the same map", () => {
+		expect(
+			classifyPluginRows(
+				[LISTED, orphan("kanban@magus")],
+				{},
+				{
+					"kanban@magus": "dev@magus",
+				},
+			).get("kanban@magus")?.reason,
+		).toBe("still-required");
+	});
+
+	test("NEGATIVE CONTROL: a pin the profile names itself is still removed", () => {
+		const [item] = planPluginUpdates(
+			{ "kanban@magus": "latest" },
+			[LISTED, orphan("kanban@magus")],
+			{ "other@magus": "dev@magus" },
+		).filter((i) => i.pluginId === "kanban@magus");
+		expect(item).toMatchObject({ action: "remove", reason: "deprecated" });
+	});
+});
+
+// ── B. the apply ────────────────────────────────────────────────────────────
+
+interface Calls {
+	uninstalled: Array<{ id: string; scope: PluginScope }>;
+	dropped: Array<{ id: string; profile: string | null | undefined }>;
+}
+
+/**
+ * A `remove` double over a tiny in-memory world: which scopes each plugin is
+ * installed at, and which plugins the profile lists.
+ */
+function removeDeps(
+	installed: Record<string, PluginScope[]>,
+	listed: Set<string>,
+	opts: {
+		uninstallLeaves?: PluginScope[];
+		uninstallThrows?: string;
+		profileSticks?: boolean;
+	} = {},
+): { deps: PluginApplyDeps; calls: Calls } {
+	const calls: Calls = { uninstalled: [], dropped: [] };
+	const remove: PluginRemoveDeps = {
+		uninstall: async (id, scope) => {
+			calls.uninstalled.push({ id, scope });
+			if (opts.uninstallThrows) throw new Error(opts.uninstallThrows);
+			if (opts.uninstallLeaves?.includes(scope)) return;
+			installed[id] = (installed[id] ?? []).filter((s) => s !== scope);
+		},
+		isInstalled: async (id, scope) => (installed[id] ?? []).includes(scope),
+		dropFromProfile: async (id, _projectPath, profile) => {
+			calls.dropped.push({ id, profile });
+			if (!opts.profileSticks) listed.delete(id);
+			return !listed.has(id);
+		},
+	};
+	const unused = async () => {
+		throw new Error("a removal must not install, update or repair anything");
+	};
+	return {
+		calls,
+		deps: {
+			install: unused,
+			update: unused,
+			repair: unused,
+			readInstalled: unused,
+			saveInstalled: unused,
+			repairStaleLoad: unused,
+			remove,
+		},
+	};
+}
+
+function recorder(): {
+	reporter: ApplyReporter;
+	rows: Array<{ ok: boolean; name: string; detail: string; cause?: string }>;
+} {
+	const rows: Array<{
+		ok: boolean;
+		name: string;
+		detail: string;
+		cause?: string;
+	}> = [];
+	return {
+		rows,
+		reporter: {
+			begin: () => {},
+			finish: (ok, name, detail, _ms, cause?: FinishCause) => {
+				rows.push({ ok, name, detail, ...(cause ? { cause } : {}) });
+			},
+			detach: (work) => work(),
+		},
+	};
+}
+
+function removeItem(pluginId: string, scopes: PluginScope[]): PluginUpdateItem {
+	return {
+		pluginId,
+		pinned: "latest",
+		installed: scopes.length > 0 ? "1.6.2" : null,
+		loaded: null,
+		available: null,
+		target: null,
+		action: "remove",
+		reason: "deprecated",
+		scopes,
+		beforeVersions: {},
+		note: "no longer published",
+	};
+}
+
+describe("applyPlugins: remove", () => {
+	test("uninstalls at every planned scope, drops it from the profile, reads both back", async () => {
+		const { deps, calls } = removeDeps(
+			{ "kanban@magus": ["user", "project"] },
+			new Set(["kanban@magus"]),
+		);
+		const { reporter, rows } = recorder();
+
+		const result = await applyPlugins(
+			[removeItem("kanban@magus", ["user", "project"])],
+			"/tmp/project",
+			deps,
+			reporter,
+			{ profile: "team" },
+		);
+
+		expect(calls.uninstalled).toEqual([
+			{ id: "kanban@magus", scope: "user" },
+			{ id: "kanban@magus", scope: "project" },
+		]);
+		expect(calls.dropped).toEqual([{ id: "kanban@magus", profile: "team" }]);
+		expect(result).toMatchObject({
+			ok: 1,
+			failed: [],
+			removed: ["kanban@magus"],
+		});
+		expect(rows).toEqual([
+			{
+				ok: true,
+				name: "kanban@magus",
+				detail: "removed at USER, PROJECT · no longer published",
+			},
+		]);
+	});
+
+	test("declared and installed nowhere: no uninstall, the profile edit alone", async () => {
+		const { deps, calls } = removeDeps({}, new Set(["agentdev@magus"]));
+		const { reporter, rows } = recorder();
+
+		const result = await applyPlugins(
+			[removeItem("agentdev@magus", [])],
+			"/tmp/project",
+			deps,
+			reporter,
+		);
+
+		expect(calls.uninstalled).toEqual([]);
+		// No profile named: the removal chooses the active one itself.
+		expect(calls.dropped).toEqual([
+			{ id: "agentdev@magus", profile: undefined },
+		]);
+		expect(result.removed).toEqual(["agentdev@magus"]);
+		expect(rows[0]?.detail).toBe(
+			"removed from the profile · no longer published",
+		);
+	});
+
+	test("still installed afterwards is a FAILURE naming the scope, never 'removed'", async () => {
+		const { deps } = removeDeps(
+			{ "kanban@magus": ["user", "project"] },
+			new Set(),
+			{ uninstallLeaves: ["user"] },
+		);
+		const { reporter, rows } = recorder();
+
+		const result = await applyPlugins(
+			[removeItem("kanban@magus", ["user", "project"])],
+			"/tmp/project",
+			deps,
+			reporter,
+		);
+
+		expect(result).toMatchObject({
+			ok: 0,
+			failed: ["kanban@magus"],
+			removed: [],
+		});
+		expect(rows).toEqual([
+			{
+				ok: false,
+				name: "kanban@magus",
+				detail: "still installed at USER scope",
+			},
+		]);
+	});
+
+	test("installed at a scope the plan did not name is caught by the read-back", async () => {
+		// The read-back checks all three scopes, not just the planned ones.
+		const { deps } = removeDeps(
+			{ "kanban@magus": ["project", "local"] },
+			new Set(),
+		);
+		const { reporter, rows } = recorder();
+		const result = await applyPlugins(
+			[removeItem("kanban@magus", ["project"])],
+			"/tmp/project",
+			deps,
+			reporter,
+		);
+		expect(result.failed).toEqual(["kanban@magus"]);
+		expect(rows[0]?.detail).toBe("still installed at LOCAL scope");
+	});
+
+	test("a profile that still lists it is a failure", async () => {
+		const { deps } = removeDeps(
+			{ "kanban@magus": ["project"] },
+			new Set(["kanban@magus"]),
+			{ profileSticks: true },
+		);
+		const { reporter, rows } = recorder();
+		const result = await applyPlugins(
+			[removeItem("kanban@magus", ["project"])],
+			"/tmp/project",
+			deps,
+			reporter,
+		);
+		expect(result.removed).toEqual([]);
+		expect(rows[0]).toEqual({
+			ok: false,
+			name: "kanban@magus",
+			detail: "the profile still lists it",
+		});
+	});
+
+	test("the Claude Code command's own error is an exception, kept as its message", async () => {
+		const { deps, calls } = removeDeps(
+			{ "kanban@magus": ["project"] },
+			new Set(["kanban@magus"]),
+			{ uninstallThrows: "claude CLI not found in PATH" },
+		);
+		const { reporter, rows } = recorder();
+		await applyPlugins(
+			[removeItem("kanban@magus", ["project"])],
+			"/tmp/project",
+			deps,
+			reporter,
+		);
+		// The profile half still ran: a pin nothing publishes is dropped anyway.
+		expect(calls.dropped).toHaveLength(1);
+		expect(rows[0]).toEqual({
+			ok: false,
+			name: "kanban@magus",
+			detail: "claude CLI not found in PATH",
+			cause: "exception",
+		});
+	});
+
+	test("M6: the real removal uninstalls through the Claude Code command only, and a failure throws", async () => {
+		// Not `uninstallPlugin`, whose fallback edits the settings files itself on
+		// failure — which also hid the command's error from the read-back.
+		expect(REAL_REMOVE_DEPS.uninstall).toBe(uninstallPluginViaCli);
+
+		// A command that cannot run: PATH holds no `claude`. The function must
+		// throw, and write nothing, in a scratch project.
+		const scratch = await mkdtemp(join(tmpdir(), "magus-m6-"));
+		const settings = join(scratch, ".claude", "settings.json");
+		await fs.outputJson(settings, { enabledPlugins: { "kanban@magus": true } });
+		const savedPath = process.env.PATH;
+		process.env.PATH = join(scratch, "no-bin");
+		try {
+			await expect(
+				uninstallPluginViaCli("kanban@magus", "project", scratch),
+			).rejects.toThrow("claude CLI not found in PATH");
+		} finally {
+			process.env.PATH = savedPath;
+		}
+		expect(await fs.readJson(settings)).toEqual({
+			enabledPlugins: { "kanban@magus": true },
+		});
+		await rm(scratch, { recursive: true, force: true });
+	});
+
+	test("M6: an uninstall that throws reaches the engine as a failure with the command's words", async () => {
+		// The `uninstallError` branch: the double throws and leaves the plugin
+		// installed, the read-back finds it, and the command's own message is
+		// the reason — not a generic "still installed".
+		const { deps } = removeDeps(
+			{ "kanban@magus": ["user"] },
+			new Set(["kanban@magus"]),
+			{ uninstallThrows: "Plugin kanban@magus is not installed at scope user" },
+		);
+		const { reporter, rows } = recorder();
+		const result = await applyPlugins(
+			[removeItem("kanban@magus", ["user"])],
+			"/tmp/project",
+			deps,
+			reporter,
+		);
+		expect(result).toMatchObject({ failed: ["kanban@magus"], removed: [] });
+		expect(rows).toEqual([
+			{
+				ok: false,
+				name: "kanban@magus",
+				detail: "Plugin kanban@magus is not installed at scope user",
+				cause: "exception",
+			},
+		]);
+	});
+
+	test("deps that cannot remove fail the item instead of reporting a removal", async () => {
+		const { deps } = removeDeps({}, new Set());
+		const { remove: _gone, ...without } = deps;
+		const result = await applyPlugins(
+			[removeItem("kanban@magus", ["project"])],
+			"/tmp/project",
+			without,
+		);
+		expect(result).toMatchObject({ ok: 0, failed: ["kanban@magus"] });
+	});
+
+	test("applyPlan drops it from the profile the plan was made from, not a guess", async () => {
+		const { deps, calls } = removeDeps(
+			{ "kanban@magus": ["project"] },
+			new Set(["kanban@magus"]),
+		);
+		const outcome = await applyPlan(
+			plan([removeItem("kanban@magus", ["project"])], "lean"),
+			"/tmp/project",
+			{ deps },
+		);
+		expect(calls.dropped).toEqual([{ id: "kanban@magus", profile: "lean" }]);
+		expect(outcome.plugins.removed).toEqual(["kanban@magus"]);
+		expect(outcome.changed).toBe(1);
+	});
+});
+
+// ── C. the profile half, on real files ──────────────────────────────────────
+
+describe("dropping a deprecated plugin from the profile", () => {
+	let project: string;
+	let log: ReturnType<typeof spyOn>;
+	const settingsPath = () => join(project, ".claude", "settings.json");
+
+	const manifest = (): ProfileManifest => ({
+		version: 2,
+		profiles: {
+			team: {
+				name: "Team",
+				plugins: { "dev@magus": "latest", "kanban@magus": "latest" },
+			},
+			lean: { name: "Lean", plugins: { "kanban@magus": "latest" } },
+		},
+	});
+
+	async function start(m: ProfileManifest, profile = "team") {
+		await writeManifest(m, project);
+		await activateProfile(m, profile, project, { onDisplace: () => {} });
+	}
+
+	/**
+	 * What `claude plugin uninstall kanban@magus --scope project` does to this
+	 * project's settings. MEASURED on Claude Code 2.1.284 in a sandbox HOME: it
+	 * exits 0 for a plugin its marketplace no longer lists, DELETES the key from
+	 * `enabledPlugins` (it does not write `false`), and drops the registry row.
+	 */
+	async function claudeUninstallAtProject(id: string) {
+		const json = await fs.readJson(settingsPath());
+		delete json.enabledPlugins[id];
+		await fs.writeFile(settingsPath(), JSON.stringify(json));
+	}
+
+	async function plugins(profile: string) {
+		return (await readManifest(project)).profiles[profile]?.plugins;
+	}
+
+	beforeEach(async () => {
+		project = await mkdtemp(join(tmpdir(), "deprecated-remove-"));
+		log = spyOn(console, "log").mockImplementation(() => {});
+	});
+	afterEach(async () => {
+		log.mockRestore();
+		await rm(project, { recursive: true, force: true });
+	});
+
+	test("the reconcile ALONE absorbs a project-scope uninstall into the active profile", async () => {
+		await start(manifest());
+		await claudeUninstallAtProject("kanban@magus");
+
+		const result = await reconcileActiveProfile(project);
+
+		expect(result.lines).toEqual(['Removed kanban@magus from profile "team"']);
+		expect(await plugins("team")).toEqual({ "dev@magus": "latest" });
+	});
+
+	test("...but it never reaches a profile that is not active, so the engine edits it", async () => {
+		await start(manifest());
+		await claudeUninstallAtProject("kanban@magus");
+		await reconcileActiveProfile(project);
+		// `magus update lean` plans lean. The reconcile left it declaring kanban.
+		expect(await plugins("lean")).toEqual({ "kanban@magus": "latest" });
+
+		expect(await removePluginFromProfile(project, "kanban@magus", "lean")).toBe(
+			true,
+		);
+		// An entry with nothing left drops `plugins` rather than writing `{}`.
+		expect(await plugins("lean")).toBeUndefined();
+	});
+
+	test("the engine's edit and the reconcile after it agree: removed, and not added back", async () => {
+		await start(manifest());
+
+		// What `magus update` runs: the apply inside the CLI bookkeeping, whose
+		// reconcile runs when it finishes.
+		const lines: string[] = [];
+		const unlisted = await withCliBookkeeping(
+			project,
+			async () => {
+				await claudeUninstallAtProject("kanban@magus");
+				return removePluginFromProfile(project, "kanban@magus", "team");
+			},
+			{
+				installable: ["dev@magus", "kanban@magus"],
+				report: (l) => lines.push(l),
+			},
+		);
+
+		expect(unlisted).toBe(true);
+		expect(await plugins("team")).toEqual({ "dev@magus": "latest" });
+		const live = await fs.readJson(settingsPath());
+		// `lean` still names it, so this profile renders it OFF, never on.
+		expect(live.enabledPlugins["kanban@magus"]).not.toBe(true);
+		expect(live.enabledPlugins["dev@magus"]).toBe(true);
+
+		// Settled: the next entry point finds nothing to absorb or regenerate.
+		expect((await reconcileActiveProfile(project)).lines).toEqual([]);
+		// And activating the profile again does not bring it back.
+		await activateProfile(await readManifest(project), "team", project, {
+			onDisplace: () => {},
+		});
+		expect(
+			(await fs.readJson(settingsPath())).enabledPlugins["kanban@magus"],
+		).not.toBe(true);
+	});
+
+	test("undefined profile means the active one", async () => {
+		await start(manifest());
+		expect(await removePluginFromProfile(project, "kanban@magus")).toBe(true);
+		expect(await plugins("team")).toEqual({ "dev@magus": "latest" });
+		expect(await plugins("lean")).toEqual({ "kanban@magus": "latest" });
+	});
+
+	test("a plugin the profile inherits through `extends` is turned off with false", async () => {
+		await writeManifest(
+			{
+				version: 2,
+				profiles: { team: { name: "Team", extends: "must-have" } },
+			},
+			project,
+		);
+		expect(await removePluginFromProfile(project, "setup@magus", "team")).toBe(
+			true,
+		);
+		expect(await plugins("team")).toEqual({ "setup@magus": false });
+	});
+
+	test("a profile that never listed it is left untouched", async () => {
+		await writeManifest(manifest(), project);
+		const before = await fs.readFile(join(project, ".claude", "profiles.json"));
+		expect(await removePluginFromProfile(project, "seo@magus", "team")).toBe(
+			true,
+		);
+		expect(
+			await fs.readFile(join(project, ".claude", "profiles.json")),
+		).toEqual(before);
+	});
+});
+
+// ── D. the words ────────────────────────────────────────────────────────────
+
+describe("words: the same on both surfaces", () => {
+	afterEach(() => setColorEnabled(null));
+
+	test("TUI row: deprecated — press a to remove, in danger, no marketplace wording", () => {
+		expect(pluginStatusText(removeItem("kanban@magus", ["project"]))).toEqual({
+			suffix: " deprecated — press a to remove",
+			tone: "danger",
+		});
+	});
+
+	test("CLI: the Deprecated group with a DEPRECATED chip and a ✗ glyph, counted as work", () => {
+		setColorEnabled(false);
+		const out = planReport(
+			plan([
+				removeItem("code-analysis@magus", ["project"]),
+				removeItem("kanban@magus", ["project"]),
+			]),
+		).map(stripAnsi);
+
+		expect(out.some((l) => /^\s+Deprecated\s+2$/.test(l))).toBe(true);
+		const row = out.find((l) => l.includes("kanban@magus")) ?? "";
+		expect(row.trimStart().startsWith("✗")).toBe(true);
+		expect(row).toContain("DEPRECATED");
+		// The heading and chip carry the fact; the note is not printed again.
+		expect(row).not.toContain("no longer published");
+	});
+
+	test("the applied line", () => {
+		expect(describeRemoved(["code-analysis@magus", "kanban@magus"])).toBe(
+			"Removed code-analysis, kanban — no longer published",
+		);
+		expect(describeRemoved([])).toBeNull();
+	});
+});
+
+// ── E. a failed removal, in the popup ───────────────────────────────────────
+
+describe("a failed removal reaches the popup", () => {
+	test("its reason is the engine's, and the headline says 'removed'", async () => {
+		const popup = failureReasons();
+		const { deps } = removeDeps({ "kanban@magus": ["user"] }, new Set(), {
+			uninstallLeaves: ["user"],
+		});
+		const items = [removeItem("kanban@magus", ["user"])];
+		const result = await applyPlugins(
+			items,
+			"/tmp/project",
+			deps,
+			popup.reporter,
+		);
+		expect(
+			popup.report(result.failed, new Map([["kanban@magus", "remove"]])),
+		).toEqual({
+			headline: "kanban was not removed",
+			rows: [{ subject: "kanban", reason: "still installed at USER scope" }],
+			fix: null,
+		});
+	});
+});