magus-cli 7.11.3 → 7.11.5

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/bootstrap.ts

@@ -51,7 +51,6 @@ import { badge, bold, dim } from "./ansi.js";
 import { askYesNo, isPromptAborted, promptValue } from "./prompt.js";
 import { selectOption } from "./select.js";
 import {
-	type ScopeName,
 	fail as failLine,
 	field,
 	info as infoLine,
@@ -285,11 +284,10 @@ function printAdoptionPlan(result: AdoptResult): void {
 			`${bold(result.profileId)}  ${badge("NEW", brand.success)}`,
 		),
 	);
-	const scope: ScopeName = result.source === "user" ? "user" : "project";
 	console.log(
 		field(
 			"plugins",
-			`${bold(String(result.counts.plugins))}  ${scopeBadge(scope)}`,
+			`${bold(String(result.counts.plugins))}  ${scopeBadge("project")}`,
 		),
 	);
 	printList(Object.keys(result.entry.plugins ?? {}).map(pluginLabel));
@@ -300,20 +298,7 @@ function printAdoptionPlan(result: AdoptResult): void {
 	}
 	console.log("");
 
-	const warned =
-		result.source === "user" ||
-		result.skipped.length > 0 ||
-		result.machinePaths.length > 0;
-	if (result.source === "user") {
-		// Never let this be invisible: the profile is meant to be committed, and
-		// these are one person's global set, not anything this project chose.
-		console.log(warnLine("This project has no plugins of its own"));
-		console.log(
-			noteLine(
-				"These are your USER plugins, on in every project. Check them before committing.",
-			),
-		);
-	}
+	const warned = result.skipped.length > 0 || result.machinePaths.length > 0;
 	for (const id of result.skipped) {
 		console.log(
 			warnLine(`${id} can't be shared — it isn't from a marketplace`),
@@ -424,9 +409,8 @@ export async function ensureManifest(
 	// `--yes` alone is NOT consent to author this file. It means "do not ask me
 	// about the thing I invoked", and someone running `magus update --yes` in
 	// CI invoked an update, not the creation of their team's committed contract —
-	// which this would otherwise write unreviewed, possibly from the machine's
-	// user-scope plugin set. Creating it needs either a human at the prompt or
-	// the command whose whole purpose is to create it.
+	// which this would otherwise write unreviewed. Creating it needs either a
+	// human at the prompt or the command whose whole purpose is to create it.
 	if (opts.allowAdopt) {
 		// fall through to the write
 	} else if (!process.stdin.isTTY) {

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-adopt.ts

@@ -20,7 +20,6 @@ import type {
 } from "../types/index.js";
 import {
 	getEnabledPlugins,
-	getGlobalEnabledPlugins,
 	readMcpConfig,
 	readSettings,
 } from "./claude-settings.js";
@@ -53,7 +52,7 @@ export function freeProfileId(manifest: ProfileManifest): string {
 }
 
 export interface AdoptInput {
-	/** Union of enabled plugins across every scope: id -> enabled. */
+	/** The project's own enabled plugins (PROJECT scope): id -> enabled. */
 	enabledPlugins: Record<string, boolean>;
 	/** Project `.claude/settings.json`, verbatim. */
 	settings: Record<string, unknown>;
@@ -144,45 +143,33 @@ export interface AdoptResult {
 	profileId: string;
 	entry: ProfileManifestEntry;
 	counts: { plugins: number; mcpServers: number; settingsKeys: number };
-	/** Which settings file the plugin list came from. */
-	source: AdoptSource;
 	/** Enabled plugin ids skipped because they name no marketplace. */
 	skipped: string[];
 	/** Carried-over settings values naming an absolute path under $HOME. */
 	machinePaths: string[];
 }
 
-/** Which settings file the adopted plugin list came from. */
-export type AdoptSource = "project" | "user";
-
 /**
- * Find the plugins to adopt, preferring PROJECT scope.
+ * Find the plugins to adopt: the ones THIS project turns on, at PROJECT scope.
  *
  * The generated manifest is meant to be committed, so its plugin list must
  * describe the repo, not the machine. `.claude/settings.json` is exactly that:
  * the repo's own committed choice. User scope (`~/.claude/settings.json`) is
  * one developer's global set and local scope is gitignored personal state —
- * adopting either silently would publish a personal setup as the team's
- * contract.
+ * adopting either would publish a personal setup as the team's contract.
  *
- * User scope is still offered as a fallback, because a developer who enables
- * everything globally would otherwise have nothing to adopt. The caller is told
- * which source was used and says so, so the choice is never invisible.
+ * USER plugins are already on in every project, so they stay USER. Copying
+ * them into the profile would render them into the project's settings too,
+ * and they would then show as installed at PROJECT as well. A project that
+ * turns nothing on adopts an empty profile, which changes nothing it runs.
  */
 export async function collectEnabledPlugins(
 	projectPath: string,
-): Promise<{ plugins: Record<string, boolean>; source: AdoptSource }> {
-	// No catch on either read. A project settings file that does not parse is
-	// not "no project plugins": falling through to user scope there would adopt
-	// one developer's global set as the team's contract, the exact thing the
-	// project-first order exists to prevent. The SettingsParseError names the
-	// file, and adoption stops.
-	const project = await getEnabledPlugins(projectPath);
-	if (Object.values(project).some(Boolean)) {
-		return { plugins: project, source: "project" };
-	}
-	const user = await getGlobalEnabledPlugins();
-	return { plugins: user, source: "user" };
+): Promise<Record<string, boolean>> {
+	// No catch. A project settings file that does not parse is not "no project
+	// plugins": adopting an empty profile there would silently drop what the
+	// repo chose. The SettingsParseError names the file, and adoption stops.
+	return getEnabledPlugins(projectPath);
 }
 
 /**
@@ -206,8 +193,7 @@ export async function adoptCurrentProject(
 	/** Profile id to write. Defaults to the adopted-profile id. */
 	id: string = ADOPTED_PROFILE_ID,
 ): Promise<AdoptResult> {
-	const { plugins: enabledPlugins, source } =
-		await collectEnabledPlugins(projectPath);
+	const enabledPlugins = await collectEnabledPlugins(projectPath);
 	const settings = (await readSettings(projectPath)) as unknown as Record<
 		string,
 		unknown
@@ -250,7 +236,6 @@ export async function adoptCurrentProject(
 		manifest,
 		profileId: id,
 		entry,
-		source,
 		counts: {
 			plugins: Object.keys(entry.plugins ?? {}).length,
 			mcpServers: Object.keys(entry.mcpServers ?? {}).length,

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