magus-cli 7.11.1 → 7.11.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "magus-cli",
-  "version": "7.11.1",
+  "version": "7.11.2",
   "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.1",
-    "magus-cli-darwin-x64": "7.11.1",
-    "magus-cli-linux-x64": "7.11.1"
+    "magus-cli-darwin-arm64": "7.11.2",
+    "magus-cli-darwin-x64": "7.11.2",
+    "magus-cli-linux-x64": "7.11.2"
   }
 }

package/src/__tests__/blind/requires-min-version/manifests.test.ts

@@ -40,8 +40,10 @@ describe("shipped plugin manifests under schema 2", () => {
 	}
 
 	// REQ-26: claudish gets a minVersion floor; no other requirement gets one. The floor
-	// moved from 10.7.0 to 11.1.0 with claudish plugin 2.5.0, which needs SlotRow.recent.
-	test("REQ-26 claudish's claudish requirement has minVersion 11.1.0", () => {
+	// moved from 10.7.0 to 11.1.0 with claudish plugin 2.5.0, which needs SlotRow.recent, and
+	// to 12.1.0 with claudish plugin 2.6.2, for resize_session, and to 12.3.0 with 2.8.1, whose
+	// resize goes down to 40 columns.
+	test("REQ-26 claudish's claudish requirement has minVersion 12.3.0", () => {
 		const claudish = declaring.find(({ name }) => name === "claudish");
 		if (!claudish) throw new Error("plugins/claudish declares no requires");
 		const result = parseRequires(claudish.json);
@@ -51,7 +53,7 @@ describe("shipped plugin manifests under schema 2", () => {
 			| (Record<string, unknown> & { name: string })
 			| undefined;
 		expect(req).toBeDefined();
-		expect(req?.minVersion).toBe("11.1.0");
+		expect(req?.minVersion).toBe("12.3.0");
 	});
 
 	test("REQ-26 no other shipped requirement declares a floor", () => {

package/src/__tests__/orphan-user-row-repair.test.ts

@@ -0,0 +1,102 @@
+// REGRESSION: MTL-221 orphan USER registry row blocks PROJECT install/repair; scope uninstall must drop from profile — Fixed in /dev:fix session dev-fix-20261022-magus-scope-7c3e
+
+/**
+ * An orphan USER registry row — a `user` row in installed_plugins.json for a
+ * plugin USER settings do not turn on — wins Claude Code's load resolution.
+ * The stale-load repair refused on it ("update it at USER scope") without
+ * asking whether USER actually installs the plugin, so every PROJECT install
+ * failed. The engine must remove the orphan through `claude plugin uninstall
+ * --scope user` and retry, and keep refusing when USER really installs it.
+ *
+ * Doubles only: nothing here reads or writes the real ~/.claude.
+ */
+
+import { describe, expect, mock, test } from "bun:test";
+import type { StaleLoadRepairResult } from "../services/claude-settings.js";
+import {
+	type PluginApplyDeps,
+	type PluginRemoveDeps,
+	installPluginInScope,
+} from "../services/update-engine.js";
+
+const PROJECT = "/tmp/mtl-221-project";
+const ID = "dev@magus";
+const OLD = "9.2.0";
+const NEW = "9.4.0";
+
+/** The refusal `repairStaleLoad` gives when the winning row is USER's. */
+function userRefusal(): StaleLoadRepairResult & { blockedBy: "user" } {
+	return {
+		pluginId: ID,
+		target: NEW,
+		rewritten: 0,
+		backup: null,
+		loaded: null,
+		ok: false,
+		error:
+			"Claude Code loads the USER install of it here — update it at USER scope",
+		blockedBy: "user",
+	};
+}
+
+function repaired(): StaleLoadRepairResult {
+	return {
+		pluginId: ID,
+		target: NEW,
+		rewritten: 0,
+		backup: null,
+		loaded: NEW,
+		ok: true,
+	};
+}
+
+function setup(userReallyInstalls: boolean) {
+	let repairCalls = 0;
+	const remove: PluginRemoveDeps = {
+		uninstall: mock(async () => {}),
+		isInstalled: mock(async (_id: string, scope: string) =>
+			scope === "user" ? userReallyInstalls : scope === "project",
+		),
+		dropFromProfile: mock(async () => true),
+		forgetVersion: mock(async () => {}),
+	};
+	const deps: PluginApplyDeps = {
+		install: mock(async () => {}),
+		update: mock(async () => {}),
+		repair: mock(async () => {}),
+		readInstalled: mock(async () => NEW),
+		saveInstalled: mock(async () => {}),
+		// The orphan USER row still wins until something removes it.
+		loadedVersion: mock(async () => OLD),
+		repairStaleLoad: mock(async () => {
+			repairCalls += 1;
+			return repairCalls === 1 ? userRefusal() : repaired();
+		}),
+		remove,
+	};
+	return { deps, remove, repairCalls: () => repairCalls };
+}
+
+describe("MTL-221: PROJECT install behind an orphan USER registry row", () => {
+	test("a. orphan USER row: uninstalled at USER once, repair retried, install succeeds", async () => {
+		const { deps, remove, repairCalls } = setup(false);
+
+		await expect(
+			installPluginInScope(ID, "project", PROJECT, deps),
+		).resolves.toBe(NEW);
+
+		expect(remove.uninstall).toHaveBeenCalledTimes(1);
+		expect(remove.uninstall).toHaveBeenCalledWith(ID, "user", PROJECT);
+		expect(repairCalls()).toBe(2);
+	});
+
+	test("b. real USER install: never uninstalled, the install still refuses naming USER", async () => {
+		const { deps, remove } = setup(true);
+
+		await expect(
+			installPluginInScope(ID, "project", PROJECT, deps),
+		).rejects.toThrow(/USER/);
+
+		expect(remove.uninstall).not.toHaveBeenCalled();
+	});
+});

package/src/__tests__/scope-uninstall-dependents.test.ts

@@ -0,0 +1,173 @@
+// REGRESSION: MTL-221 uninstalling a plugin a declared plugin depends on must refuse, not leave it declared — Fixed in /dev:fix session dev-fix-20261022-magus-scope-7c3e
+
+/**
+ * A profile's resolved closure re-adds every dependency of a plugin it
+ * declares (`resolveProfile` → `resolveDependencies` → `dependencies.derived`).
+ * `dev@magus` depends on `claudish@magus`, so dropping claudish from a profile
+ * that declares dev cannot take effect: claudish comes straight back.
+ *
+ * When an uninstall would need the profile to stop declaring the plugin
+ * (scope PROJECT, or no OTHER scope installs it) and a plugin the profile
+ * declares depends on it, `uninstallPluginInScope` refuses before doing
+ * anything, naming both plugins by name. A USER/LOCAL uninstall while PROJECT
+ * still installs it needs no profile change, so it is never refused.
+ *
+ * Doubles only: nothing here reads or writes the real ~/.claude.
+ */
+
+import { describe, expect, mock, test } from "bun:test";
+import * as resolver from "../services/resolver.js";
+import * as engine from "../services/update-engine.js";
+import type {
+	PluginApplyDeps,
+	PluginRemoveDeps,
+} from "../services/update-engine.js";
+import type { ProfileManifest } from "../types/index.js";
+
+const PROJECT = "/tmp/mtl-221-project";
+const ID = "claudish@magus";
+const PROFILE = "team";
+
+type Scope = "user" | "project" | "local";
+
+/**
+ * Remove deps over an in-memory install set, plus the assumed new optional
+ * `dependents` seam answering which declared plugins need `pluginId`.
+ */
+function setup(installedAt: Scope[], dependentIds: string[]) {
+	const installed = new Set<Scope>(installedAt);
+	const calls: string[] = [];
+	const dependents = mock(
+		async (
+			_pluginId: string,
+			_projectPath: string,
+			_profile: string | null | undefined,
+		) => dependentIds,
+	);
+	const remove = {
+		uninstall: mock(async (id: string, scope: Scope, path: string) => {
+			calls.push(`uninstall:${id}:${scope}:${path}`);
+			installed.delete(scope);
+		}),
+		isInstalled: mock(async (_id: string, scope: Scope) =>
+			installed.has(scope),
+		),
+		dropFromProfile: mock(async () => {
+			calls.push("dropFromProfile");
+			return true;
+		}),
+		forgetVersion: mock(async () => {
+			calls.push("forgetVersion");
+		}),
+		dependents,
+	} as PluginRemoveDeps & { dependents: typeof dependents };
+	const deps: PluginApplyDeps = {
+		install: mock(async () => {}),
+		update: mock(async () => {}),
+		repair: mock(async () => {}),
+		readInstalled: mock(async () => null),
+		saveInstalled: mock(async () => {}),
+		repairStaleLoad: mock(async () => {
+			throw new Error("repairStaleLoad must not run on an uninstall");
+		}),
+		remove,
+	};
+	return { deps, remove, calls };
+}
+
+const uninstallPluginInScope = engine.uninstallPluginInScope;
+
+describe("MTL-221: uninstalling a plugin a declared plugin depends on", () => {
+	test("f. PROJECT uninstall of a dependency of a declared plugin: refuses before doing anything", async () => {
+		const { deps, remove, calls } = setup(["project"], ["dev@magus"]);
+
+		let message: string | null = null;
+		try {
+			await uninstallPluginInScope(ID, "project", PROJECT, deps, PROFILE);
+		} catch (err) {
+			message = err instanceof Error ? err.message : String(err);
+		}
+
+		expect(message).not.toBeNull();
+		expect(message).toContain("dev needs claudish");
+		expect(message).toContain("uninstall dev first");
+		// Plugin names, not ids.
+		expect(message).not.toContain("@magus");
+		expect(remove.uninstall).not.toHaveBeenCalled();
+		expect(remove.forgetVersion).not.toHaveBeenCalled();
+		expect(remove.dropFromProfile).not.toHaveBeenCalled();
+		expect(calls).toEqual([]);
+	});
+
+	test("g. PROJECT uninstall with no declared dependent: uninstalls, then drops from the profile once", async () => {
+		const { deps, remove, calls } = setup(["project"], []);
+
+		await uninstallPluginInScope(ID, "project", PROJECT, deps, PROFILE);
+
+		expect(remove.uninstall).toHaveBeenCalledWith(ID, "project", PROJECT);
+		expect(remove.dropFromProfile).toHaveBeenCalledTimes(1);
+		expect(calls).toEqual([
+			`uninstall:${ID}:project:${PROJECT}`,
+			"forgetVersion",
+			"dropFromProfile",
+		]);
+	});
+
+	test("h. USER uninstall while PROJECT still installs it: not refused, profile untouched", async () => {
+		const { deps, remove } = setup(["user", "project"], ["dev@magus"]);
+
+		await uninstallPluginInScope(ID, "user", PROJECT, deps, PROFILE);
+
+		expect(remove.uninstall).toHaveBeenCalledWith(ID, "user", PROJECT);
+		expect(remove.dropFromProfile).not.toHaveBeenCalled();
+	});
+});
+
+/**
+ * Assumed signature, consistent with `resolveProfile` /
+ * `ResolveOptions.dependencyResolver` (a `PluginDependencyReader`):
+ *
+ *   profileDependentsOf(
+ *     manifest: ProfileManifest,
+ *     profileId: string,
+ *     pluginId: string,
+ *     dependencyResolver: PluginDependencyReader,
+ *   ): Promise<string[]>
+ *
+ * Answers the ids of plugins the profile declares that need `pluginId`.
+ */
+const profileDependentsOf = (resolver as Record<string, unknown>)
+	.profileDependentsOf as (
+	manifest: ProfileManifest,
+	profileId: string,
+	pluginId: string,
+	dependencyResolver: (
+		pluginId: string,
+		projectPath?: string,
+	) => Promise<string[] | null>,
+) => Promise<string[]>;
+
+describe("MTL-221: profileDependentsOf", () => {
+	test("i. names the declared plugin that depends on the given one", async () => {
+		const manifest: ProfileManifest = {
+			version: 2,
+			profiles: {
+				[PROFILE]: {
+					name: PROFILE,
+					plugins: { "dev@magus": "latest", "claudish@magus": "latest" },
+				},
+			},
+		};
+		const graph: Record<string, string[]> = {
+			"dev@magus": ["claudish@magus", "mnemex@magus"],
+			"claudish@magus": [],
+			"mnemex@magus": [],
+		};
+		const dependencyResolver = async (id: string) => graph[id] ?? [];
+
+		expect(typeof profileDependentsOf).toBe("function");
+		expect(
+			await profileDependentsOf(manifest, PROFILE, ID, dependencyResolver),
+		).toEqual(["dev@magus"]);
+	});
+});

package/src/__tests__/scope-uninstall-profile.test.ts

@@ -0,0 +1,103 @@
+// REGRESSION: MTL-221 orphan USER registry row blocks PROJECT install/repair; scope uninstall must drop from profile — Fixed in /dev:fix session dev-fix-20261022-magus-scope-7c3e
+
+/**
+ * The Plugins screen's scope uninstall never dropped the plugin from the
+ * active profile, so a profile-declared plugin came straight back as "not
+ * installed — profile declares it". `uninstallPluginInScope` is the one engine
+ * function both screen call sites will use: uninstall at the scope, read back,
+ * and drop from the profile when the scope was PROJECT or nothing installs the
+ * plugin any more — never while PROJECT still installs it.
+ *
+ * Doubles only: nothing here reads or writes the real ~/.claude.
+ */
+
+import { describe, expect, mock, test } from "bun:test";
+import * as engine from "../services/update-engine.js";
+import type {
+	PluginApplyDeps,
+	PluginRemoveDeps,
+} from "../services/update-engine.js";
+
+const PROJECT = "/tmp/mtl-221-project";
+const ID = "dev@magus";
+const PROFILE = "team";
+
+type Scope = "user" | "project" | "local";
+
+/**
+ * Remove deps over an in-memory install set: `uninstall` takes the scope out,
+ * `isInstalled` reads the set back.
+ */
+function setup(installedAt: Scope[]) {
+	const installed = new Set<Scope>(installedAt);
+	const calls: string[] = [];
+	const remove: PluginRemoveDeps = {
+		uninstall: mock(async (id: string, scope: Scope, path: string) => {
+			calls.push(`uninstall:${id}:${scope}:${path}`);
+			installed.delete(scope);
+		}),
+		isInstalled: mock(async (_id: string, scope: Scope) =>
+			installed.has(scope),
+		),
+		dropFromProfile: mock(async () => {
+			calls.push("dropFromProfile");
+			return true;
+		}),
+		forgetVersion: mock(async () => {}),
+	};
+	const deps: PluginApplyDeps = {
+		install: mock(async () => {}),
+		update: mock(async () => {}),
+		repair: mock(async () => {}),
+		readInstalled: mock(async () => null),
+		saveInstalled: mock(async () => {}),
+		repairStaleLoad: mock(async () => {
+			throw new Error("repairStaleLoad must not run on an uninstall");
+		}),
+		remove,
+	};
+	return { deps, remove, calls };
+}
+
+// Looked up off the namespace so the file loads before the export exists (RED).
+const uninstallPluginInScope = (engine as Record<string, unknown>)
+	.uninstallPluginInScope as (
+	pluginId: string,
+	scope: Scope,
+	projectPath: string,
+	deps?: PluginApplyDeps,
+	profile?: string | null,
+) => Promise<unknown>;
+
+describe("MTL-221: uninstallPluginInScope drops the plugin from the profile", () => {
+	test("c. PROJECT uninstall: uninstalls at PROJECT, then drops from the profile once", async () => {
+		const { deps, remove, calls } = setup(["project"]);
+
+		await uninstallPluginInScope(ID, "project", PROJECT, deps, PROFILE);
+
+		expect(remove.uninstall).toHaveBeenCalledWith(ID, "project", PROJECT);
+		expect(remove.dropFromProfile).toHaveBeenCalledTimes(1);
+		expect(calls).toEqual([
+			`uninstall:${ID}:project:${PROJECT}`,
+			"dropFromProfile",
+		]);
+	});
+
+	test("d. USER uninstall while PROJECT still installs it: the profile is untouched", async () => {
+		const { deps, remove } = setup(["user", "project"]);
+
+		await uninstallPluginInScope(ID, "user", PROJECT, deps, PROFILE);
+
+		expect(remove.uninstall).toHaveBeenCalledWith(ID, "user", PROJECT);
+		expect(remove.dropFromProfile).not.toHaveBeenCalled();
+	});
+
+	test("e. LOCAL uninstall leaving it installed nowhere: drops from the profile once", async () => {
+		const { deps, remove } = setup(["local"]);
+
+		await uninstallPluginInScope(ID, "local", PROJECT, deps, PROFILE);
+
+		expect(remove.uninstall).toHaveBeenCalledWith(ID, "local", PROJECT);
+		expect(remove.dropFromProfile).toHaveBeenCalledTimes(1);
+	});
+});

package/src/services/claude-settings.ts

@@ -1947,6 +1947,12 @@ export interface StaleLoadRepairResult {
 	ok: boolean;
 	/** Why it failed. Absent when `ok`. */
 	error?: string;
+	/**
+	 * Set when it refused because a machine-wide row wins here, naming that
+	 * scope — so a caller can tell a real USER install from an orphan USER row
+	 * without matching on `error`.
+	 */
+	blockedBy?: "user" | "managed";
 }
 
 /**
@@ -2087,11 +2093,19 @@ export async function repairStaleLoad(
 		// plugins, which the registry type in types/index.ts does not name — see
 		// `LoaderScope` in plugin-resolution.ts.
 		const scope: string = winner.scope;
-		return fail(
-			scope === "managed"
-				? "Claude Code loads the install your administrator manages here — ask them to update it"
-				: "Claude Code loads the USER install of it here — update it at USER scope",
-		);
+		return scope === "managed"
+			? {
+					...fail(
+						"Claude Code loads the install your administrator manages here — ask them to update it",
+					),
+					blockedBy: "managed",
+				}
+			: {
+					...fail(
+						"Claude Code loads the USER install of it here — update it at USER scope",
+					),
+					blockedBy: "user",
+				};
 	}
 
 	const stale = rows.filter(

package/src/services/resolver.ts

@@ -195,6 +195,38 @@ export async function requirersHere(
 	return edges;
 }
 
+/**
+ * The plugins `profileId` declares that need `pluginId` to load, directly or
+ * transitively — sorted ids, none when the profile does not exist.
+ *
+ * `resolveProfile` re-adds every dependency of a declared plugin, so while one
+ * of these is declared, the profile cannot stop enabling `pluginId`. Each
+ * declared plugin's closure is walked with the same `resolveDependencies` the
+ * resolve uses, so the two cannot disagree about what comes back.
+ */
+export async function profileDependentsOf(
+	manifest: ProfileManifest,
+	profileId: string,
+	pluginId: string,
+	dependencyResolver: PluginDependencyReader,
+): Promise<string[]> {
+	const raw = manifest.profiles[profileId];
+	if (!raw) return [];
+	const entry = resolveExtends(raw);
+	const off = new Set(
+		Object.entries(entry.plugins ?? {})
+			.filter(([, ver]) => ver === false)
+			.map(([id]) => id),
+	);
+	const dependents: string[] = [];
+	for (const id of Object.keys(normalizePlugins(entry.plugins))) {
+		if (id === pluginId) continue;
+		const report = await resolveDependencies([id], off, dependencyResolver);
+		if (report.derived.includes(pluginId)) dependents.push(id);
+	}
+	return dependents.sort();
+}
+
 function hasDependencies(report: DependencyReport): boolean {
 	return (
 		report.derived.length > 0 ||

package/src/services/update-engine.ts

@@ -39,6 +39,7 @@ import type {
 import type { Command } from "../utils/command-utils.js";
 import { formatCommand } from "../utils/command-utils.js";
 import { runArgv, succeeded } from "../utils/run.js";
+import { selectProfileId } from "./active-closure.js";
 import type { PluginScope } from "./claude-cli.js";
 import {
 	installPlugin,
@@ -58,13 +59,17 @@ import {
 	repairStaleLoad,
 	rowBelongsToRepository,
 } from "./claude-settings.js";
+import { readManifest } from "./manifest.js";
+import { readPluginDependencies } from "./plugin-dependencies.js";
 import {
 	compareVersions,
 	isRepairablyBehind,
 	readInstalledVersionForScope,
 	saveInstalledPluginVersionForScope,
 } from "./plugin-manager.js";
+import { activeProfile } from "./profile-live.js";
 import { removePluginFromProfile } from "./profile-state.js";
+import { profileDependentsOf } from "./resolver.js";
 import { installSkill } from "./skills-manager.js";
 import {
 	type ToolFacts,
@@ -302,6 +307,17 @@ export interface PluginRemoveDeps {
 		scope: PluginScope,
 		projectPath: string,
 	) => Promise<void>;
+	/**
+	 * The plugins `profile` declares that need `pluginId` (`profileDependentsOf`).
+	 * While any is declared, the profile re-adds `pluginId` as their dependency,
+	 * so dropping it cannot take effect. `profile` undefined means the active
+	 * one. Optional so a double that does not model dependencies skips the check.
+	 */
+	dependents?: (
+		pluginId: string,
+		projectPath: string,
+		profile: string | null | undefined,
+	) => Promise<string[]>;
 }
 
 /** The settings a scope's install lives in — the classifier's definition. */
@@ -321,6 +337,23 @@ export const REAL_REMOVE_DEPS: PluginRemoveDeps = {
 	dropFromProfile: (pluginId, projectPath, profile) =>
 		removePluginFromProfile(projectPath, pluginId, profile),
 	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.
+	dependents: async (pluginId, projectPath, profile) => {
+		const manifest = await readManifest(projectPath);
+		const id =
+			profile === undefined
+				? selectProfileId(
+						Object.keys(manifest.profiles),
+						undefined,
+						await activeProfile(projectPath),
+					)
+				: profile;
+		if (!id) return [];
+		return profileDependentsOf(manifest, id, pluginId, (dep) =>
+			readPluginDependencies(dep, projectPath),
+		);
+	},
 };
 
 export const REAL_PLUGIN_DEPS: PluginApplyDeps = {
@@ -455,7 +488,7 @@ async function followMisdirectedUpdate(
 			notFollowed: `it went to v${version}, not the v${target} this update asked for`,
 		};
 	}
-	const repair = await deps.repairStaleLoad(pluginId, version, projectPath);
+	const repair = await repairLoadHere(deps, pluginId, version, projectPath);
 	return {
 		elsewhere,
 		version,
@@ -506,6 +539,39 @@ export async function bringLoadForward(
 	if (!deps.loadedVersion) return null;
 	const loaded = await deps.loadedVersion(pluginId, projectPath);
 	if (!isRepairablyBehind(target, loaded)) return null;
+	return repairLoadHere(deps, pluginId, target, projectPath);
+}
+
+/**
+ * `deps.repairStaleLoad`, clearing an ORPHAN USER row first when that is what
+ * blocks it.
+ *
+ * A USER registry row for a plugin USER settings do not turn on still wins the
+ * loader's resolution in every project, so the repair refuses on it — yet the
+ * user installs nothing at USER. Claude Code's startup sync adds such rows and
+ * never removes them. `claude plugin uninstall --scope user` removes just that
+ * row (measured, Claude Code 2.1.308), so it runs once and the repair is
+ * retried. A REAL USER install keeps the refusal: moving it is the user's call.
+ */
+async function repairLoadHere(
+	deps: PluginApplyDeps,
+	pluginId: string,
+	target: string,
+	projectPath: string,
+): Promise<StaleLoadRepairResult> {
+	const first = await deps.repairStaleLoad(pluginId, target, projectPath);
+	const remove = deps.remove;
+	if (first.ok || first.blockedBy !== "user" || !remove) return first;
+	if (await remove.isInstalled(pluginId, "user", projectPath)) return first;
+	try {
+		await remove.uninstall(pluginId, "user", projectPath);
+	} catch (error) {
+		// The CLI's own words: no fallback writes the registry in its place.
+		return {
+			...first,
+			error: error instanceof Error ? error.message : String(error),
+		};
+	}
 	return deps.repairStaleLoad(pluginId, target, projectPath);
 }
 
@@ -747,7 +813,8 @@ async function applyStaleLoad(
 		return;
 	}
 	try {
-		const outcome = await deps.repairStaleLoad(
+		const outcome = await repairLoadHere(
+			deps,
 			item.pluginId,
 			item.target,
 			projectPath,
@@ -1131,6 +1198,80 @@ export async function updatePluginInScope(
 	);
 }
 
+/**
+ * Uninstall a plugin at ONE explicitly chosen scope, and stop the profile
+ * declaring it when that leaves nothing for the profile to keep.
+ *
+ * Without the profile step, a profile-declared plugin came straight back as
+ * "not installed — profile declares it". The profile is dropped when the scope
+ * was PROJECT — the settings the profile itself renders — or when the plugin is
+ * now installed at no scope. Never for a USER or LOCAL uninstall while PROJECT
+ * still installs it: the profile still describes that install.
+ *
+ * Success is read back, as in {@link applyRemove}: still installed at `scope`
+ * afterwards throws, whatever the command said.
+ *
+ * @param profile the profile to drop it from; undefined means the active one.
+ */
+export async function uninstallPluginInScope(
+	pluginId: string,
+	scope: PluginScope,
+	projectPath: string,
+	deps: PluginApplyDeps = REAL_PLUGIN_DEPS,
+	profile?: string | null,
+): Promise<void> {
+	const remove = deps.remove;
+	if (!remove) throw new Error("magus cannot remove plugins from here");
+
+	// Refuse BEFORE uninstalling when the profile drop below would be needed but
+	// cannot hold: a declared plugin that depends on this one re-adds it.
+	if (remove.dependents) {
+		let installedElsewhere = false;
+		for (const other of REMOVE_SCOPES) {
+			if (other === scope) continue;
+			if (await remove.isInstalled(pluginId, other, projectPath)) {
+				installedElsewhere = true;
+				break;
+			}
+		}
+		if (scope === "project" || !installedElsewhere) {
+			const dependents = await remove.dependents(
+				pluginId,
+				projectPath,
+				profile,
+			);
+			if (dependents.length > 0) {
+				const names = dependents.map(pluginName).join(", ");
+				const needs = dependents.length === 1 ? "needs" : "need";
+				throw new Error(
+					`${names} ${needs} ${pluginName(pluginId)} — uninstall ${names} first`,
+				);
+			}
+		}
+	}
+
+	await remove.uninstall(pluginId, scope, projectPath);
+	if (await remove.isInstalled(pluginId, scope, projectPath)) {
+		throw new Error(`still installed at ${scope.toUpperCase()} scope`);
+	}
+	// Best-effort, as in applyRemove: the read-back above is the judge.
+	await remove.forgetVersion?.(pluginId, scope, projectPath).catch(() => {});
+
+	let installedNowhere = true;
+	for (const other of REMOVE_SCOPES) {
+		if (await remove.isInstalled(pluginId, other, projectPath)) {
+			installedNowhere = false;
+			break;
+		}
+	}
+	if (scope !== "project" && !installedNowhere) return;
+	if (!(await remove.dropFromProfile(pluginId, projectPath, profile))) {
+		throw new Error(
+			`uninstalled at ${scope.toUpperCase()} scope, but the profile still lists it`,
+		);
+	}
+}
+
 // -- binaries ----------------------------------------------------------------
 
 /**

package/src/ui/screens/PluginsScreen.tsx

@@ -44,6 +44,7 @@ import {
 	applyPlugins,
 	installPluginInScope,
 	pluginNeedsWork,
+	uninstallPluginInScope,
 	updatePluginInScope,
 } from "../../services/update-engine.js";
 // The ONE plugin classifier, shared with `magus update`. Every state this
@@ -1019,7 +1020,15 @@ export function PluginsScreen() {
 					modal.loading(
 						`Uninstalling ${plugin.name} from ${scopeLabel}…\nclaude plugin uninstall ${plugin.id} --scope ${scope}`,
 					);
-					await cliUninstallPlugin(plugin.id, scope, state.projectPath);
+					// Through the engine, so the profile stops declaring what was
+					// just uninstalled and the result is read back.
+					await uninstallPluginInScope(
+						plugin.id,
+						scope,
+						state.projectPath || process.cwd(),
+						REAL_PLUGIN_DEPS,
+						activeProfileId,
+					);
 				} else if (action === "update") {
 					modal.loading(
 						`Updating ${plugin.name} in ${scopeLabel}…\nclaude plugin install ${plugin.id} --scope ${scope}`,
@@ -1185,7 +1194,14 @@ export function PluginsScreen() {
 				modal.loading(
 					`Uninstalling ${plugin.name} from ${scopeLabel}…\nclaude plugin uninstall ${plugin.id} --scope ${scope}`,
 				);
-				await cliUninstallPlugin(plugin.id, scope, state.projectPath);
+				// Engine uninstall: read back, and dropped from the profile — see above.
+				await uninstallPluginInScope(
+					plugin.id,
+					scope,
+					state.projectPath || process.cwd(),
+					REAL_PLUGIN_DEPS,
+					activeProfileId,
+				);
 			} else if (action === "update") {
 				modal.loading(
 					`Updating ${plugin.name} in ${scopeLabel}…\nclaude plugin install ${plugin.id} --scope ${scope}`,