magus-cli 7.11.2 → 7.11.3

package/package.json

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

package/src/__tests__/scratch-git.ts

@@ -0,0 +1,48 @@
+import { execFileSync } from "node:child_process";
+import os from "node:os";
+import path from "node:path";
+import fs from "fs-extra";
+
+/**
+ * Real scratch git repositories for tests that need `inheritablePaths` to
+ * answer for real. Everything lives under os.tmpdir(); nothing touches the
+ * operator's home or config.
+ */
+
+// Isolate from the operator's git config (signing, default branch, excludes).
+const GIT_CFG = [
+	"-c",
+	"user.name=test",
+	"-c",
+	"user.email=test@example.com",
+	"-c",
+	"commit.gpgsign=false",
+	"-c",
+	"init.defaultBranch=main",
+];
+
+export const git = (cwd: string, ...args: string[]): string =>
+	execFileSync("git", [...GIT_CFG, ...args], {
+		cwd,
+		encoding: "utf8",
+		stdio: ["ignore", "pipe", "pipe"],
+	}).trim();
+
+/** A new scratch directory; realpath'd because git reports real paths. */
+export async function makeScratch(): Promise<string> {
+	return fs.realpath(await fs.mkdtemp(path.join(os.tmpdir(), "magus-remove-")));
+}
+
+/** `git init` plus one commit at `dir`. */
+export async function initRepo(dir: string): Promise<void> {
+	await fs.ensureDir(dir);
+	git(dir, "init", "-q");
+	await fs.writeFile(path.join(dir, "README.md"), "hello\n");
+	git(dir, "add", "-A");
+	git(dir, "commit", "-qm", "initial");
+}
+
+/** A linked worktree of `main` at `dir`, on a new branch. */
+export function addWorktree(main: string, dir: string, branch: string): void {
+	git(main, "worktree", "add", "-q", "-b", branch, dir);
+}

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

@@ -0,0 +1,268 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import path from "node:path";
+import fs from "fs-extra";
+import { isNotInstalledAnswer } from "../services/claude-cli.js";
+import type { PluginScope } from "../services/claude-cli.js";
+import {
+	inheritedRegistryRows,
+	inheritedRowsOf,
+} from "../services/claude-settings.js";
+import { clearWorktreeCache } from "../services/git-worktree.js";
+import {
+	type ApplyReporter,
+	type PluginApplyDeps,
+	applyPlugins,
+} from "../services/update-engine.js";
+import type { PluginUpdateItem } from "../services/update-plan.js";
+import type { InstalledPluginEntry } from "../types/index.js";
+import { addWorktree, initRepo, makeScratch } from "./scratch-git.js";
+
+/**
+ * Removing a deprecated plugin from a linked worktree whose only registry row
+ * belongs to the main checkout: the reader that finds that row, the folder the
+ * uninstall runs in, and the failures that must not be swallowed.
+ *
+ * Repository membership is git's answer (`inheritablePaths`), so the cases that
+ * depend on it run against real scratch repositories.
+ */
+
+const OTHER = "/elsewhere/unrelated";
+const ID = "code-analysis@magus";
+
+let scratch: string;
+let MAIN: string;
+let TREE: string;
+// Two INDEPENDENT repositories, the second kept under the first's
+// `.claude/worktrees/` — a path shape that is not repository membership.
+let PARENT: string;
+let NESTED: string;
+
+beforeAll(async () => {
+	scratch = await makeScratch();
+	MAIN = path.join(scratch, "repo");
+	TREE = path.join(scratch, "feature");
+	await initRepo(MAIN);
+	addWorktree(MAIN, TREE, "feature");
+	PARENT = path.join(scratch, "parent");
+	NESTED = path.join(PARENT, ".claude", "worktrees", "child");
+	await initRepo(PARENT);
+	await initRepo(NESTED);
+	clearWorktreeCache();
+});
+
+afterAll(async () => {
+	if (scratch) await fs.remove(scratch);
+});
+
+const entry = (
+	scope: InstalledPluginEntry["scope"],
+	projectPath?: string,
+): InstalledPluginEntry => ({
+	scope,
+	version: "7.3.0",
+	projectPath,
+	installPath: "/cache/7.3.0",
+	installedAt: "2026-01-01T00:00:00.000Z",
+	lastUpdated: "2026-01-01T00:00:00.000Z",
+});
+
+describe("inheritedRegistryRows", () => {
+	test("finds the main checkout's project and local rows", () => {
+		const rows = inheritedRegistryRows(
+			[entry("project", MAIN), entry("local", MAIN)],
+			TREE,
+			[MAIN],
+		);
+		expect(rows.map((r) => r.scope).sort()).toEqual(["local", "project"]);
+		expect(rows.every((r) => r.projectPath === MAIN)).toBe(true);
+	});
+
+	test("does not return the project's own row", () => {
+		const rows = inheritedRegistryRows(
+			[entry("project", TREE), entry("project", MAIN)],
+			TREE,
+			[MAIN, TREE],
+		);
+		expect(rows.map((r) => r.projectPath)).toEqual([MAIN]);
+	});
+
+	test("never returns rows of an unrelated project or the user row", () => {
+		const rows = inheritedRegistryRows(
+			[entry("project", OTHER), entry("user")],
+			TREE,
+			[MAIN],
+		);
+		expect(rows).toEqual([]);
+	});
+
+	test("returns nothing when no same-repository folder is known", () => {
+		expect(inheritedRegistryRows([entry("project", MAIN)], TREE, [])).toEqual(
+			[],
+		);
+		expect(inheritedRegistryRows(undefined, TREE, [MAIN])).toEqual([]);
+	});
+
+	test("a linked worktree inherits its main checkout's row, per git", async () => {
+		const rows = await inheritedRowsOf(
+			[entry("project", MAIN), entry("project", OTHER)],
+			TREE,
+		);
+		expect(rows.map((r) => r.projectPath)).toEqual([MAIN]);
+	});
+
+	test("an unrelated parent repository's row is NEVER returned for a nested independent repository", async () => {
+		const rows = await inheritedRowsOf(
+			[entry("project", PARENT), entry("local", PARENT)],
+			NESTED,
+		);
+		expect(rows).toEqual([]);
+	});
+});
+
+describe("isNotInstalledAnswer", () => {
+	test("recognises the CLI's per-scope answer only", () => {
+		expect(
+			isNotInstalledAnswer(
+				new Error(`Plugin "${ID}" is not installed in project scope.`),
+			),
+		).toBe(true);
+		expect(isNotInstalledAnswer(new Error("claude timed out"))).toBe(false);
+	});
+});
+
+function harness(
+	rows: InstalledPluginEntry[],
+	uninstall: (id: string, scope: PluginScope, cwd: string) => Promise<void>,
+) {
+	const unused = async () => {
+		throw new Error("a removal must not install, update or repair");
+	};
+	const deps: PluginApplyDeps = {
+		install: unused,
+		update: unused,
+		repair: unused,
+		readInstalled: unused,
+		saveInstalled: unused,
+		repairStaleLoad: unused,
+		registryRows: async () => rows,
+		remove: {
+			uninstall,
+			isInstalled: async () => false,
+			dropFromProfile: async () => true,
+		},
+	};
+	const item: PluginUpdateItem = {
+		pluginId: ID,
+		pinned: "latest",
+		installed: null,
+		loaded: null,
+		available: null,
+		target: null,
+		action: "remove",
+		reason: "deprecated",
+		scopes: [],
+		beforeVersions: {},
+		note: "no longer published",
+	};
+	const details: string[] = [];
+	const reporter: ApplyReporter = {
+		begin: () => {},
+		finish: (_ok, _id, detail) => {
+			details.push(String(detail));
+		},
+		detach: (work) => work(),
+	};
+	return { deps, item, reporter, details };
+}
+
+describe("applyPlugins: removing an inherited row", () => {
+	test("runs the uninstall in the row's own folder", async () => {
+		let rows = [entry("project", MAIN), entry("project", OTHER)];
+		const calls: Array<[PluginScope, string]> = [];
+		const h = harness(rows, async (_id, scope, cwd) => {
+			calls.push([scope, cwd]);
+			rows = rows.filter((r) => r.projectPath !== cwd);
+		});
+		h.deps.registryRows = async () => rows;
+
+		const result = await applyPlugins([h.item], TREE, h.deps, h.reporter);
+
+		expect(calls).toEqual([["project", MAIN]]);
+		expect(result.failed).toEqual([]);
+		// The unrelated project's row is untouched.
+		expect(rows.map((r) => r.projectPath)).toEqual([OTHER]);
+	});
+
+	test("a real uninstall error surfaces instead of being swallowed", async () => {
+		const rows = [entry("project", MAIN)];
+		const h = harness(rows, async () => {
+			throw new Error("claude plugin uninstall timed out");
+		});
+
+		const result = await applyPlugins([h.item], TREE, h.deps, h.reporter);
+
+		expect(result.failed).toEqual([ID]);
+		expect(h.details.join(" ")).toContain("timed out");
+	});
+
+	test("says where it is still installed when the command reported nothing", async () => {
+		const rows = [entry("project", MAIN)];
+		const h = harness(rows, async () => {});
+
+		const result = await applyPlugins([h.item], TREE, h.deps, h.reporter);
+
+		expect(result.failed).toEqual([ID]);
+		const detail = h.details.join(" ");
+		expect(detail).toContain(
+			`still installed in ${path.basename(MAIN)}, another folder of this repository`,
+		);
+		// A folder is named, never an absolute path.
+		expect(detail).not.toContain(MAIN);
+	});
+
+	test("an unreadable registry after the uninstalls is a failed removal", async () => {
+		const rows = [entry("project", MAIN)];
+		let reads = 0;
+		const h = harness(rows, async () => {
+			throw new Error("claude plugin uninstall timed out");
+		});
+		h.deps.registryRows = async () => {
+			reads++;
+			if (reads > 1) throw new Error("registry unreadable");
+			return rows;
+		};
+
+		const result = await applyPlugins([h.item], TREE, h.deps, h.reporter);
+
+		expect(result.failed).toEqual([ID]);
+		expect(result.removed).toEqual([]);
+	});
+
+	test("an unreadable registry with no error from the CLI says it could not confirm", async () => {
+		const rows = [entry("project", MAIN)];
+		let reads = 0;
+		const h = harness(rows, async () => {});
+		h.deps.registryRows = async () => {
+			reads++;
+			if (reads > 1) throw new Error("registry unreadable");
+			return rows;
+		};
+
+		const result = await applyPlugins([h.item], TREE, h.deps, h.reporter);
+
+		expect(result.failed).toEqual([ID]);
+		expect(h.details.join(" ")).toContain("could not confirm it was removed");
+	});
+
+	test("never uninstalls an unrelated parent repository's row from a nested independent repository", async () => {
+		const rows = [entry("project", PARENT)];
+		const calls: string[] = [];
+		const h = harness(rows, async (_id, _scope, cwd) => {
+			calls.push(cwd);
+		});
+
+		await applyPlugins([h.item], NESTED, h.deps, h.reporter);
+
+		expect(calls).toEqual([]);
+	});
+});

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

@@ -0,0 +1,115 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import path from "node:path";
+import fs from "fs-extra";
+import type { PluginScope } from "../services/claude-cli.js";
+import { clearWorktreeCache } from "../services/git-worktree.js";
+import {
+	type ApplyReporter,
+	type PluginApplyDeps,
+	applyPlugins,
+} from "../services/update-engine.js";
+import type { PluginUpdateItem } from "../services/update-plan.js";
+import type { InstalledPluginEntry } from "../types/index.js";
+import { addWorktree, initRepo, makeScratch } from "./scratch-git.js";
+
+/**
+ * `d` on a deprecated plugin from a linked worktree, when the only registry
+ * row for it belongs to the MAIN checkout.
+ *
+ * The orphan row exists because the registry row is inherited from the main
+ * checkout, but no settings file here turns the plugin on, so the plan carries
+ * no scopes. The removal then runs zero uninstalls.
+ */
+
+const ID = "code-analysis@magus";
+
+// A real repository with a real linked worktree, so `inheritablePaths` answers
+// the way git does rather than from a path shape.
+let scratch: string;
+let MAIN: string;
+let TREE: string;
+
+beforeAll(async () => {
+	scratch = await makeScratch();
+	MAIN = path.join(scratch, "repo");
+	TREE = path.join(scratch, "feature");
+	await initRepo(MAIN);
+	addWorktree(MAIN, TREE, "feature");
+	clearWorktreeCache();
+});
+
+afterAll(async () => {
+	if (scratch) await fs.remove(scratch);
+});
+
+function row(projectPath: string): InstalledPluginEntry {
+	return {
+		scope: "project",
+		version: "7.3.0",
+		projectPath,
+		installPath: "/cache/7.3.0",
+		installedAt: "2026-01-01T00:00:00.000Z",
+		lastUpdated: "2026-01-01T00:00:00.000Z",
+	};
+}
+
+describe("applyPlugins: remove from a linked worktree", () => {
+	// REGRESSION: worktree d on a deprecated plugin removed nothing and showed no error — Fixed in /dev:fix session dev-fix-20261026-155239-490d2c7e
+	test("should not report success while the main checkout's registry row remains when removing from a linked worktree", async () => {
+		let rows: InstalledPluginEntry[] = [row(MAIN)];
+		const unused = async () => {
+			throw new Error("a removal must not install, update or repair");
+		};
+		const deps: PluginApplyDeps = {
+			install: unused,
+			update: unused,
+			repair: unused,
+			readInstalled: unused,
+			saveInstalled: unused,
+			repairStaleLoad: unused,
+			registryRows: async () => rows,
+			remove: {
+				// Like `claude plugin uninstall --scope project`: only the row
+				// pinned to exactly the cwd it runs in can be removed.
+				uninstall: async (_id, scope: PluginScope, cwd) => {
+					const hit = rows.some(
+						(r) => r.scope === scope && r.projectPath === cwd,
+					);
+					if (!hit) {
+						throw new Error(
+							`Plugin "${ID}" is not installed in ${scope} scope.`,
+						);
+					}
+					rows = rows.filter((r) => r.projectPath !== cwd);
+				},
+				// Settings-derived: no settings turn the plugin on here.
+				isInstalled: async () => false,
+				dropFromProfile: async () => true,
+			},
+		};
+		const item: PluginUpdateItem = {
+			pluginId: ID,
+			pinned: "latest",
+			installed: null,
+			loaded: null,
+			available: null,
+			target: null,
+			action: "remove",
+			reason: "deprecated",
+			scopes: [],
+			beforeVersions: {},
+			note: "no longer published",
+		};
+		const reporter: ApplyReporter = {
+			begin: () => {},
+			finish: () => {},
+			detach: (work) => work(),
+		};
+
+		const result = await applyPlugins([item], TREE, deps, reporter);
+
+		// Either the row is really gone (uninstall ran in the main checkout), or
+		// the removal says it failed. Success with the row still there is the bug.
+		expect(rows.length === 0 || result.failed.includes(ID)).toBe(true);
+	});
+});

package/src/services/claude-cli.ts

@@ -268,6 +268,15 @@ 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".
+ */
+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);
+}
+
 /**
  * Repair a plugin whose files drifted from the marketplace under an unchanged
  * version — uninstall, then install again at the same scope.

package/src/services/claude-settings.ts

@@ -434,6 +434,74 @@ export function ownRegistryEntry(
 	);
 }
 
+/**
+ * The project and local rows of one plugin that `projectPath` INHERITS: rows
+ * pinned to a same-repository folder (`fallbackPaths`, as
+ * {@link pickRegistryEntry} reads them) rather than to `projectPath` itself.
+ *
+ * These are the rows that make a plugin show up in a linked worktree that never
+ * installed it, and `claude plugin uninstall` removes them only when run from the
+ * row's own folder. Rows of any other project are never returned, and neither is
+ * the project's own row ({@link ownRegistryEntry} answers that one).
+ */
+export function inheritedRegistryRows(
+	entries: readonly InstalledPluginEntry[] | undefined,
+	projectPath: string,
+	fallbackPaths: readonly string[],
+): InstalledPluginEntry[] {
+	if (!Array.isArray(entries)) return [];
+	const own = path.resolve(projectPath);
+	const sources = new Set(fallbackPaths.map((p) => path.resolve(p)));
+	sources.delete(own);
+	return entries.filter(
+		(e) =>
+			(e.scope === "project" || e.scope === "local") &&
+			e.projectPath !== undefined &&
+			sources.has(path.resolve(e.projectPath)),
+	);
+}
+
+/**
+ * Same-repository folders whose rows `projectPath` inherits: git's
+ * `inheritablePaths`, the one definition the read side ({@link pickRegistryEntry})
+ * uses too. `[]` when git cannot answer.
+ */
+async function inheritableFolders(projectPath: string): Promise<string[]> {
+	return inheritablePaths(projectPath);
+}
+
+/**
+ * Read-only: the inherited rows of `pluginId` for `projectPath`, read from the
+ * registry. `[]` when the registry cannot be read or there are none.
+ */
+export async function readInheritedRegistryRows(
+	pluginId: string,
+	projectPath: string,
+): Promise<InstalledPluginEntry[]> {
+	try {
+		const registry = await readInstalledPluginsRegistry();
+		return inheritedRegistryRows(
+			registry.plugins?.[pluginId],
+			projectPath,
+			await inheritableFolders(projectPath),
+		);
+	} catch {
+		return [];
+	}
+}
+
+/** The inherited rows within `rows` already read, for a caller holding them. */
+export async function inheritedRowsOf(
+	rows: readonly InstalledPluginEntry[],
+	projectPath: string,
+): Promise<InstalledPluginEntry[]> {
+	return inheritedRegistryRows(
+		rows,
+		projectPath,
+		await inheritableFolders(projectPath),
+	);
+}
+
 async function overlayRegistryVersions(
 	base: Record<string, string>,
 	scope: "user" | "project" | "local",

package/src/services/update-engine.ts

@@ -43,6 +43,7 @@ import { selectProfileId } from "./active-closure.js";
 import type { PluginScope } from "./claude-cli.js";
 import {
 	installPlugin,
+	isNotInstalledAnswer,
 	repairPlugin,
 	uninstallPluginViaCli,
 	updatePlugin,
@@ -53,6 +54,7 @@ import {
 	getEnabledPlugins,
 	getGlobalEnabledPlugins,
 	getLocalEnabledPlugins,
+	inheritedRowsOf,
 	loadedVersionHere,
 	notDownloadedReason,
 	readInstalledPluginsRegistry,
@@ -883,11 +885,33 @@ async function applyRemove(
 	}
 	try {
 		let uninstallError: unknown = null;
+		// Errors of the inherited-row uninstalls, apart from the scope loop's: the
+		// CLI's "not installed in <scope> scope" is the expected answer there for a
+		// scope this folder only inherits, and is not a failure.
+		let inheritedError: unknown = null;
 		for (const scope of item.scopes) {
 			try {
 				await remove.uninstall(item.pluginId, scope, projectPath);
 			} catch (error) {
-				uninstallError ??= error;
+				if (!isNotInstalledAnswer(error)) uninstallError ??= error;
+			}
+		}
+		// A row this folder only INHERITS (a linked worktree reading its main
+		// checkout's install) is removed from the row's own folder; the CLI finds
+		// nothing to remove from anywhere else.
+		const inherited = await inheritedRowsOf(
+			(await readRows(deps, item.pluginId)) ?? [],
+			projectPath,
+		);
+		for (const row of inherited) {
+			try {
+				await remove.uninstall(
+					item.pluginId,
+					row.scope,
+					row.projectPath ?? projectPath,
+				);
+			} catch (error) {
+				inheritedError ??= error;
 			}
 		}
 		const unlisted = await remove.dropFromProfile(
@@ -913,6 +937,38 @@ async function applyRemove(
 					.catch(() => {});
 			}
 		}
+		// Success needs the rows READ and none remaining: a read-back that fails
+		// is a removal nobody confirmed, never "no rows remain".
+		const rowsNow = await readRows(deps, item.pluginId);
+		if (rowsNow === null && deps.registryRows) {
+			if (inheritedError instanceof Error) {
+				fail(inheritedError.message, "exception");
+			} else {
+				fail("could not confirm it was removed");
+			}
+			return;
+		}
+		const remaining = await inheritedRowsOf(rowsNow ?? [], projectPath);
+		if (remaining.length > 0) {
+			if (inheritedError instanceof Error) {
+				fail(inheritedError.message, "exception");
+				return;
+			}
+			const names = [
+				...new Set(
+					remaining
+						.map((r) => r.projectPath)
+						.filter((p): p is string => p !== undefined)
+						.map((p) => path.basename(p)),
+				),
+			];
+			fail(
+				names.length > 0
+					? `still installed in ${names.join(", ")}, another folder of this repository`
+					: "still installed in another folder of this repository",
+			);
+			return;
+		}
 		if (still.length > 0) {
 			// The CLI's own words when it said anything; ours otherwise.
 			if (uninstallError !== null) {

package/src/ui/screens/PluginsScreen.tsx

@@ -9,9 +9,14 @@ import {
 	type PluginScope,
 	addMarketplace as cliAddMarketplace,
 	repairPlugin as cliRepairPlugin,
-	uninstallPlugin as cliUninstallPlugin,
+	isNotInstalledAnswer,
+	uninstallPluginViaCli,
 } from "../../services/claude-cli.js";
-import { readSettings, setMcpEnvVar } from "../../services/claude-settings.js";
+import {
+	readInheritedRegistryRows,
+	readSettings,
+	setMcpEnvVar,
+} from "../../services/claude-settings.js";
 import { clearContentDriftCache } from "../../services/content-drift.js";
 import { missingPluginEnvVars } from "../../services/plugin-env-needs.js";
 import {
@@ -1260,25 +1265,45 @@ 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[] = [];
 		try {
 			// Remove from all scopes — try all to clean up stale references
 			const scopes: PluginScope[] = ["user", "project", "local"];
-			// Nothing tallies which scopes actually held it. The migrate dialog
-			// that consumed that tally is gone with the `moved` inference, and
-			// collecting it for no reader is how a value goes stale unnoticed.
 			for (const scope of scopes) {
 				try {
 					modal.loading(
 						`Removing ${plugin.name} from ${scope}…\nclaude plugin uninstall ${plugin.id} --scope ${scope}`,
 					);
-					await cliUninstallPlugin(plugin.id, scope, state.projectPath);
-				} catch {
-					// Ignore errors for scopes where it doesn't exist
+					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(
+				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();
+			if (problems.length > 0) {
+				await reportPluginFailure(plugin.id, "removed", problems[0]);
+			}
 		} catch (error) {
 			modal.hideModal();
 			await reportPluginFailure(plugin.id, "removed", error);