magus-cli 7.12.0 → 7.12.2

package/package.json

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

package/src/__tests__/alias-agent-teams.test.ts

@@ -8,7 +8,7 @@ import {
 	renderArgsAsTokens,
 	renderEnv,
 } from "../services/alias-shell-writer";
-import type { AliasConfig } from "../services/alias-store";
+import { type AliasConfig, defaultValueFor } from "../services/alias-store";
 
 const assignment = "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1";
 const shells: ShellKind[] = ["bash", "zsh", "fish"];
@@ -31,23 +31,20 @@ function expectAliasLine(
 	if (shell === "fish") {
 		const quotedArgs =
 			argv.length === 0 ? "" : ` ${argv.map((arg) => `'${arg}'`).join(" ")}`;
-		expect([
-			`alias ${aliasName} '${prefix}${bareArgs}'`,
-			`alias ${aliasName} '${prefix}${quotedArgs}'`,
-		]).toContain(lines[0]);
+		expect(lines).toEqual([`alias ${aliasName} '${prefix}${quotedArgs}'`]);
 	} else {
 		expect(lines).toEqual([`alias ${aliasName}='${prefix}${bareArgs}'`]);
 	}
 }
 
 describe("agent teams catalog", () => {
-	it("TEST-7 REQ-1 REQ-4 exposes an env-backed boolean and the Agent teams group", () => {
+	it("TEST-7 REQ-1 REQ-4 exposes one env-backed select and the Agent teams group", () => {
 		expect(getFlagById("agent-teams")).toMatchObject({
 			id: "agent-teams",
 			label: "Agent teams",
-			kind: "boolean",
+			kind: "select",
 			env: assignment,
-			flag: assignment,
+			flag: "--teammate-mode",
 			group: "agents",
 		});
 		expect(FLAG_GROUPS.filter((group) => group.id === "agents")).toEqual([
@@ -56,26 +53,39 @@ describe("agent teams catalog", () => {
 		expect(
 			ALIAS_FLAGS.filter((flag) => flag.id === "agent-teams"),
 		).toHaveLength(1);
+		expect(
+			ALIAS_FLAGS.filter(
+				(flag) => flag.kind === "boolean" && flag.env !== undefined,
+			),
+		).toEqual([]);
 	});
 
-	it("TEST-8 REQ-4 exposes exactly the teammate choices and their dependency", () => {
-		const flag = getFlagById("teammate-mode");
+	it("TEST-8 REQ-4 exposes the ordered teammate choices without a dependency", () => {
+		const flag = getFlagById("agent-teams");
 
-		expect(flag).toMatchObject({
-			id: "teammate-mode",
-			label: "Teammate panes",
-			kind: "select",
-			flag: "--teammate-mode",
-			group: "agents",
-			requires: "agent-teams",
-		});
-		expect(flag.options?.map((option) => option.value).sort()).toEqual([
-			"auto",
-			"in-process",
-			"iterm2",
+		expect(flag.options?.map((option) => option.value)).toEqual([
 			"tmux",
+			"iterm2",
+			"in-process",
+			"auto",
 		]);
-		expect(flag.env).toBeUndefined();
+		expect(flag.requires).toBeUndefined();
+	});
+
+	it("TEST-22 REQ-1 REQ-4 has no separate teammate-mode catalog entry", () => {
+		expect(ALIAS_FLAGS.filter((flag) => flag.id === "teammate-mode")).toEqual(
+			[],
+		);
+	});
+
+	it("TEST-23 REQ-1 REQ-4 defaults agent teams to a disabled tmux select", () => {
+		const flag = getFlagById("agent-teams");
+
+		expect(defaultValueFor(flag)).toEqual({
+			kind: "select",
+			enabled: false,
+			value: "tmux",
+		});
 	});
 });
 
@@ -85,15 +95,23 @@ describe("environment and argv separation", () => {
 			const config: AliasConfig = { aliasName: "c", flags: {} };
 			if (state !== "missing") {
 				config.flags["agent-teams"] = {
-					kind: "boolean",
+					kind: "select",
 					enabled: state === "enabled",
+					value: "tmux",
 				};
 			}
 			const expectedEnv = state === "enabled" ? [assignment] : [];
+			const expectedArgv =
+				state === "enabled" ? ["--teammate-mode", "tmux"] : [];
 
 			expect(renderEnv(config)).toEqual(expectedEnv);
-			expect(renderArgs(config)).toEqual([]);
-			expect(renderArgsAsTokens(config)).toEqual(expectedEnv);
+			expect(renderArgs(config)).toEqual(
+				expectedArgv.map((text) => ({ kind: "literal", text })),
+			);
+			expect(renderArgsAsTokens(config)).toEqual([
+				...expectedEnv,
+				...expectedArgv,
+			]);
 		});
 	}
 });
@@ -101,20 +119,24 @@ describe("environment and argv separation", () => {
 describe("agent teams shell output and POSIX round-trips", () => {
 	// Fish rendering is covered; the parse-back contract uses POSIX alias lines.
 	for (const shell of shells) {
-		it(`TEST-10 REQ-8 REQ-13 renders agent teams alone before claude on ${shell}`, () => {
+		it(`TEST-10 REQ-8 REQ-13 renders automatic agent teams with env before claude on ${shell}`, () => {
 			const config: AliasConfig = {
 				aliasName: "c",
-				flags: { "agent-teams": { kind: "boolean", enabled: true } },
+				flags: {
+					"agent-teams": { kind: "select", enabled: true, value: "auto" },
+				},
 			};
 
 			const rendered = renderAlias(config, shell);
 
 			expect(rendered.shell).toBe(shell);
-			expectAliasLine(rendered.block, shell, true, []);
+			expectAliasLine(rendered.block, shell, true, ["--teammate-mode", "auto"]);
 			if (shell !== "fish") {
 				expect(parseAliasFromRc(rendered.block)).toEqual({
 					aliasName: "c",
-					flags: { "agent-teams": { kind: "boolean", enabled: true } },
+					flags: {
+						"agent-teams": { kind: "select", enabled: true, value: "auto" },
+					},
 				});
 			}
 		});
@@ -124,8 +146,7 @@ describe("agent teams shell output and POSIX round-trips", () => {
 				const config: AliasConfig = {
 					aliasName: "c",
 					flags: {
-						"agent-teams": { kind: "boolean", enabled: true },
-						"teammate-mode": { kind: "select", enabled: true, value: mode },
+						"agent-teams": { kind: "select", enabled: true, value: mode },
 					},
 				};
 
@@ -146,8 +167,7 @@ describe("agent teams shell output and POSIX round-trips", () => {
 					expect(parseAliasFromRc(rendered.block)).toEqual({
 						aliasName: "c",
 						flags: {
-							"agent-teams": { kind: "boolean", enabled: true },
-							"teammate-mode": { kind: "select", enabled: true, value: mode },
+							"agent-teams": { kind: "select", enabled: true, value: mode },
 						},
 					});
 				}
@@ -155,21 +175,26 @@ describe("agent teams shell output and POSIX round-trips", () => {
 		}
 
 		for (const state of ["missing", "disabled"] as const) {
-			it(`TEST-12 REQ-14 drops teammate-mode with ${state} agent teams but keeps context size on ${shell}`, () => {
+			it(`TEST-12 REQ-14 omits both team outputs with ${state} agent teams but keeps context size on ${shell}`, () => {
 				const config: AliasConfig = {
 					aliasName: "c",
 					flags: {
-						"teammate-mode": { kind: "select", enabled: true, value: "tmux" },
 						autocompact: { kind: "text", enabled: true, value: "200k" },
 					},
 				};
+				const withoutTeams = structuredClone(config);
 				if (state === "disabled") {
-					config.flags["agent-teams"] = { kind: "boolean", enabled: false };
+					config.flags["agent-teams"] = {
+						kind: "select",
+						enabled: false,
+						value: "tmux",
+					};
 				}
 				const original = structuredClone(config);
 
 				const rendered = renderAlias(config, shell);
 
+				expect(rendered).toEqual(renderAlias(withoutTeams, shell));
 				expect(renderEnv(config)).toEqual([]);
 				expect(renderArgs(config)).toEqual([
 					{ kind: "literal", text: "--autocompact" },
@@ -192,49 +217,47 @@ describe("agent teams shell output and POSIX round-trips", () => {
 			});
 		}
 
-		it(`TEST-13 REQ-4 REQ-7 REQ-8 REQ-13 keeps agent teams but omits a disabled teammate mode on ${shell}`, () => {
+		it(`TEST-13 REQ-4 REQ-7 REQ-8 REQ-13 omits both outputs for disabled agent teams on ${shell}`, () => {
 			const config: AliasConfig = {
 				aliasName: "c",
 				flags: {
-					"agent-teams": { kind: "boolean", enabled: true },
-					"teammate-mode": { kind: "select", enabled: false, value: "tmux" },
+					"agent-teams": { kind: "select", enabled: false, value: "tmux" },
 				},
 			};
+			const withoutTeams: AliasConfig = { aliasName: "c", flags: {} };
 
 			const rendered = renderAlias(config, shell);
 
+			expect(rendered).toEqual(renderAlias(withoutTeams, shell));
+			expect(renderEnv(config)).toEqual([]);
 			expect(renderArgs(config)).toEqual([]);
-			expect(renderArgsAsTokens(config)).toEqual([assignment]);
-			expectAliasLine(rendered.block, shell, true, []);
+			expect(renderArgsAsTokens(config)).toEqual([]);
+			expectAliasLine(rendered.block, shell, false, []);
 			if (shell !== "fish") {
 				expect(parseAliasFromRc(rendered.block)).toEqual({
 					aliasName: "c",
-					flags: { "agent-teams": { kind: "boolean", enabled: true } },
+					flags: {},
 				});
 			}
 		});
 
-		it(`TEST-14 REQ-6 REQ-7 REQ-8 REQ-9 REQ-13 renders all new options with env first on ${shell}`, () => {
+		it(`TEST-14 REQ-6 REQ-7 REQ-8 REQ-9 REQ-13 renders agent teams after context size with env first on ${shell}`, () => {
 			const config: AliasConfig = {
 				aliasName: "crew",
 				flags: {
-					"teammate-mode": { kind: "select", enabled: true, value: "tmux" },
+					"agent-teams": { kind: "select", enabled: true, value: "tmux" },
 					autocompact: { kind: "text", enabled: true, value: "200k" },
-					"agent-teams": { kind: "boolean", enabled: true },
 				},
 			};
 			const contextIndex = ALIAS_FLAGS.findIndex(
 				(flag) => flag.id === "autocompact",
 			);
-			const modeIndex = ALIAS_FLAGS.findIndex(
-				(flag) => flag.id === "teammate-mode",
+			const teamsIndex = ALIAS_FLAGS.findIndex(
+				(flag) => flag.id === "agent-teams",
 			);
 			expect(contextIndex).toBeGreaterThanOrEqual(0);
-			expect(modeIndex).toBeGreaterThanOrEqual(0);
-			const argv =
-				contextIndex < modeIndex
-					? ["--autocompact", "200k", "--teammate-mode", "tmux"]
-					: ["--teammate-mode", "tmux", "--autocompact", "200k"];
+			expect(teamsIndex).toBeGreaterThan(contextIndex);
+			const argv = ["--autocompact", "200k", "--teammate-mode", "tmux"];
 
 			const rendered = renderAlias(config, shell);
 
@@ -248,8 +271,7 @@ describe("agent teams shell output and POSIX round-trips", () => {
 				expect(parseAliasFromRc(rendered.block)).toEqual({
 					aliasName: "crew",
 					flags: {
-						"agent-teams": { kind: "boolean", enabled: true },
-						"teammate-mode": { kind: "select", enabled: true, value: "tmux" },
+						"agent-teams": { kind: "select", enabled: true, value: "tmux" },
 						autocompact: { kind: "text", enabled: true, value: "200k" },
 					},
 				});

package/src/__tests__/alias-env-adoption.test.ts

@@ -6,15 +6,16 @@ import {
 	parseAliasLine,
 	parseManagedBlock,
 	renderAlias,
+	renderArgsAsTokens,
 } from "../services/alias-shell-writer";
 import type { AliasConfig, FlagValue } from "../services/alias-store";
 
 const assignment = "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1";
+const modes = ["tmux", "iterm2", "in-process", "auto"];
 
 function combinedFlags(): Record<string, FlagValue> {
 	return {
-		"agent-teams": { kind: "boolean", enabled: true },
-		"teammate-mode": { kind: "select", enabled: true, value: "tmux" },
+		"agent-teams": { kind: "select", enabled: true, value: "tmux" },
 		autocompact: { kind: "text", enabled: true, value: "200k" },
 	};
 }
@@ -46,6 +47,80 @@ function commandBody(
 	].join(" ");
 }
 
+describe("single agent-team parse rows", () => {
+	type ParseRow = {
+		name: string;
+		env: string[];
+		argv: string[];
+		flags: () => Record<string, FlagValue>;
+		leftovers: string[];
+	};
+	const rows: ParseRow[] = [
+		...modes.map(
+			(mode): ParseRow => ({
+				name: `assignment and ${mode} argv become one select`,
+				env: [assignment],
+				argv: ["--teammate-mode", mode],
+				flags: () => ({
+					"agent-teams": { kind: "select", enabled: true, value: mode },
+				}),
+				leftovers: [],
+			}),
+		),
+		{
+			name: "assignment alone defaults to auto",
+			env: [assignment],
+			argv: [],
+			flags: () => ({
+				"agent-teams": { kind: "select", enabled: true, value: "auto" },
+			}),
+			leftovers: [],
+		},
+		...modes.map(
+			(mode): ParseRow => ({
+				name: `${mode} argv alone remains leftovers`,
+				env: [],
+				argv: ["--teammate-mode", mode],
+				flags: () => ({}),
+				leftovers: ["--teammate-mode", mode],
+			}),
+		),
+	];
+
+	for (const row of rows) {
+		it(`TEST-24 REQ-12 REQ-14 maps tokens so ${row.name}`, () => {
+			const args = [...row.env, ...row.argv];
+
+			expect(argsToFlagValuesWithLeftovers(args)).toEqual({
+				flags: row.flags(),
+				leftovers: [...row.leftovers],
+			});
+		});
+
+		for (const form of forms) {
+			it(`TEST-25 REQ-11 REQ-12 REQ-14 parses ${form.name} so ${row.name}`, () => {
+				const line = form.line(
+					commandBody(form.envLauncher, row.env, row.argv),
+				);
+
+				const parsed = parseAliasLine(line);
+
+				expect(parsed).toEqual({
+					aliasName: "crew",
+					args: [...row.env, ...row.argv],
+				});
+				if (parsed === null) {
+					throw new Error("Expected a parsed claude alias");
+				}
+				expect(argsToFlagValuesWithLeftovers(parsed.args)).toEqual({
+					flags: row.flags(),
+					leftovers: [...row.leftovers],
+				});
+			});
+		}
+	}
+});
+
 describe("managed assignment-prefixed alias parsing", () => {
 	const examples = [
 		{
@@ -126,6 +201,21 @@ describe("assignment mapping and leftovers", () => {
 			flags: combinedFlags,
 			leftovers: ["EMPTY=", "EXTRA=a=b"],
 		},
+		{
+			name: "unknown assignments on both sides of the known one",
+			args: [
+				"FIRST=one",
+				assignment,
+				"EMPTY=",
+				"EXTRA=a=b",
+				"--teammate-mode",
+				"tmux",
+				"--autocompact",
+				"200k",
+			],
+			flags: combinedFlags,
+			leftovers: ["FIRST=one", "EMPTY=", "EXTRA=a=b"],
+		},
 		{
 			name: "known env name with a different value",
 			args: ["CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=0", "--ide"],
@@ -159,7 +249,7 @@ describe("assignment mapping and leftovers", () => {
 
 		expect(argsToFlagValuesWithLeftovers(args)).toEqual({
 			flags: {
-				"agent-teams": { kind: "boolean", enabled: true },
+				"agent-teams": { kind: "select", enabled: true, value: "auto" },
 				ide: { kind: "boolean", enabled: true },
 			},
 			leftovers: ["EXTRA=keep"],
@@ -183,12 +273,14 @@ describe("assignment mapping and leftovers", () => {
 });
 
 describe("safe adoption of assignment-prefixed aliases", () => {
-	const losslessCases: Array<{
+	type LosslessCase = {
 		name: string;
 		env: string[];
 		argv: string[];
 		flags: () => Record<string, FlagValue>;
-	}> = [
+		renderedArgs: string[];
+	};
+	const losslessCases: LosslessCase[] = [
 		{
 			name: "context size only",
 			env: [],
@@ -196,21 +288,41 @@ describe("safe adoption of assignment-prefixed aliases", () => {
 			flags: () => ({
 				autocompact: { kind: "text", enabled: true, value: "200k" },
 			}),
+			renderedArgs: ["--autocompact", "200k"],
 		},
 		{
-			name: "agent teams only",
+			name: "agent teams assignment alone as auto",
 			env: [assignment],
 			argv: [],
 			flags: () => ({
-				"agent-teams": { kind: "boolean", enabled: true },
+				"agent-teams": { kind: "select", enabled: true, value: "auto" },
 			}),
+			renderedArgs: [assignment, "--teammate-mode", "auto"],
 		},
 		{
 			name: "all new options",
 			env: [assignment],
 			argv: ["--teammate-mode", "tmux", "--autocompact", "200k"],
 			flags: combinedFlags,
+			renderedArgs: [
+				assignment,
+				"--autocompact",
+				"200k",
+				"--teammate-mode",
+				"tmux",
+			],
 		},
+		...modes.map(
+			(mode): LosslessCase => ({
+				name: `agent teams with explicit ${mode} mode`,
+				env: [assignment],
+				argv: ["--teammate-mode", mode],
+				flags: () => ({
+					"agent-teams": { kind: "select", enabled: true, value: mode },
+				}),
+				renderedArgs: [assignment, "--teammate-mode", mode],
+			}),
+		),
 	];
 
 	const unknownCases: Array<{
@@ -241,6 +353,13 @@ describe("safe adoption of assignment-prefixed aliases", () => {
 			flags: combinedFlags,
 			leftovers: ["EXTRA=a=b"],
 		},
+		{
+			name: "unknown assignments on both sides of known teams in their original order",
+			env: ["FIRST=one", assignment, "EMPTY=", "EXTRA=a=b"],
+			argv: ["--teammate-mode", "tmux", "--autocompact", "200k"],
+			flags: combinedFlags,
+			leftovers: ["FIRST=one", "EMPTY=", "EXTRA=a=b"],
+		},
 		{
 			name: "a known assignment name with an unsupported value",
 			env: ["CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=0"],
@@ -277,6 +396,12 @@ describe("safe adoption of assignment-prefixed aliases", () => {
 					aliasName: adopted.name,
 					flags: adopted.flags,
 				};
+				const renderedArgs = renderArgsAsTokens(config);
+				expect(renderedArgs).toEqual(example.renderedArgs);
+				expect(argsToFlagValuesWithLeftovers(renderedArgs)).toEqual({
+					flags: expectedFlags,
+					leftovers: [],
+				});
 				expect(parseAliasFromRc(renderAlias(config, "bash").block)).toEqual({
 					aliasName: "crew",
 					flags: expectedFlags,
@@ -310,13 +435,29 @@ describe("safe adoption of assignment-prefixed aliases", () => {
 
 			const adopted = findAdoptableAlias(`${line}\n`);
 
+			expect(adopted).toEqual({
+				name: "crew",
+				flags: {},
+				lineRange: [0, 0],
+				leftovers: ["--teammate-mode", "tmux"],
+				lossless: false,
+				rawLine: line,
+				others: [],
+			});
+		});
+
+		it(`TEST-26 REQ-12 REQ-13 REQ-14 keeps context size but refuses lossless argv-only teams in ${form.name}`, () => {
+			const line = form.line("claude --teammate-mode tmux --autocompact 200k");
+
+			const adopted = findAdoptableAlias(`${line}\n`);
+
 			expect(adopted).toEqual({
 				name: "crew",
 				flags: {
-					"teammate-mode": { kind: "select", enabled: true, value: "tmux" },
+					autocompact: { kind: "text", enabled: true, value: "200k" },
 				},
 				lineRange: [0, 0],
-				leftovers: [],
+				leftovers: ["--teammate-mode", "tmux"],
 				lossless: false,
 				rawLine: line,
 				others: [],

package/src/__tests__/tui-scope-action-profile.test.ts

@@ -0,0 +1,241 @@
+/**
+ * The Plugins screen installs and uninstalls through `installPluginInScope`
+ * and `uninstallPluginInScope`. In a profiled project a PROJECT-scope install
+ * turns the plugin on in `.claude/settings.json`; the active profile must list
+ * it as soon as the action returns, and the profile's record of the live files
+ * must move with it, so the next magus command finds nothing left to absorb.
+ *
+ * Real files, real reconcile: a temp project with `.claude/profiles.json` and
+ * an activated profile, HOME pointed at a temp dir. Only the `claude` CLI is
+ * doubled — install sets `enabledPlugins[id] = true` in the scope's
+ * settings.json, uninstall deletes it — plus the version read-back.
+ */
+
+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 { readManifest, writeManifest } from "../services/manifest.js";
+import { reconcileActiveProfile } from "../services/profile-absorb.js";
+import { activateProfile } from "../services/profile-activate.js";
+import {
+	readActiveMarker,
+	writeActiveMarker,
+} from "../services/profile-live.js";
+import {
+	type PluginApplyDeps,
+	REAL_PLUGIN_DEPS,
+	REAL_REMOVE_DEPS,
+	installPluginInScope,
+	uninstallPluginInScope,
+	updatePluginInScope,
+} from "../services/update-engine.js";
+import type { ProfileManifest } from "../types/index.js";
+
+type Scope = "user" | "project" | "local";
+
+let project: string;
+let home: string;
+let log: ReturnType<typeof spyOn>;
+const saved = {
+	HOME: process.env.HOME,
+	CLAUDE_CONFIG_DIR: process.env.CLAUDE_CONFIG_DIR,
+};
+
+function manifest(): ProfileManifest {
+	return {
+		version: 2,
+		profiles: {
+			team: {
+				name: "Team",
+				plugins: { "dev@magus": "latest", "terminal@magus": "latest" },
+			},
+		},
+	};
+}
+
+/** The settings.json `claude plugin … --scope <scope>` writes. */
+function settingsFor(scope: Scope): string {
+	if (scope === "user") return join(home, ".claude", "settings.json");
+	if (scope === "local") return join(project, ".claude", "settings.local.json");
+	return join(project, ".claude", "settings.json");
+}
+
+async function setEnabled(
+	scope: Scope,
+	pluginId: string,
+	on: boolean,
+): Promise<void> {
+	const file = settingsFor(scope);
+	const json = (await fs.pathExists(file))
+		? ((await fs.readJson(file)) as Record<string, unknown>)
+		: {};
+	const enabled = {
+		...((json.enabledPlugins as Record<string, boolean>) ?? {}),
+	};
+	if (on) enabled[pluginId] = true;
+	else delete enabled[pluginId];
+	json.enabledPlugins = enabled;
+	await fs.outputFile(file, JSON.stringify(json));
+}
+
+/**
+ * The real engine deps with only the `claude` CLI and the version read-back
+ * doubled. The loader and registry probes are dropped so `bringLoadForward`
+ * skips; every other member stays real.
+ */
+function deps(): PluginApplyDeps {
+	const {
+		loadedVersion: _loaded,
+		registryRows: _rows,
+		...real
+	} = REAL_PLUGIN_DEPS;
+	return {
+		...real,
+		install: async (pluginId, scope) => setEnabled(scope, pluginId, true),
+		update: async () => {},
+		repair: async () => {},
+		readInstalled: async () => "1.0.0",
+		saveInstalled: async () => {},
+		repairStaleLoad: async () => {
+			throw new Error("repairStaleLoad must not run here");
+		},
+		remove: {
+			...REAL_REMOVE_DEPS,
+			uninstall: async (pluginId, scope) => setEnabled(scope, pluginId, false),
+		},
+	};
+}
+
+async function enabledIn(scope: Scope): Promise<Record<string, boolean>> {
+	const json = (await fs.readJson(settingsFor(scope))) as {
+		enabledPlugins?: Record<string, boolean>;
+	};
+	return json.enabledPlugins ?? {};
+}
+
+function profilesJson(): Promise<string> {
+	return fs.readFile(join(project, ".claude", "profiles.json"), "utf8");
+}
+
+async function profilePlugins(): Promise<Record<string, unknown>> {
+	const { profiles } = await readManifest(project);
+	return (profiles.team?.plugins ?? {}) as Record<string, unknown>;
+}
+
+beforeEach(async () => {
+	project = await mkdtemp(join(tmpdir(), "tui-scope-profile-"));
+	home = await mkdtemp(join(tmpdir(), "tui-scope-profile-home-"));
+	process.env.HOME = home;
+	process.env.CLAUDE_CONFIG_DIR = join(home, ".claude");
+	log = spyOn(console, "log").mockImplementation(() => {});
+	await writeManifest(manifest(), project);
+	await activateProfile(manifest(), "team", project, { onDisplace: () => {} });
+});
+
+afterEach(async () => {
+	log.mockRestore();
+	process.env.HOME = saved.HOME;
+	if (saved.CLAUDE_CONFIG_DIR === undefined) {
+		// biome-ignore lint/performance/noDelete: an unset env var must be absent, not "undefined"
+		delete process.env.CLAUDE_CONFIG_DIR;
+	} else process.env.CLAUDE_CONFIG_DIR = saved.CLAUDE_CONFIG_DIR;
+	await rm(project, { recursive: true, force: true });
+	await rm(home, { recursive: true, force: true });
+});
+
+describe("Plugins screen scope actions record the change in the active profile", () => {
+	test("PROJECT install: the profile lists the plugin, and nothing is left to absorb", async () => {
+		await installPluginInScope("aside@magus", "project", project, deps());
+		expect(await enabledIn("project")).toHaveProperty("aside@magus", true);
+
+		expect(await profilePlugins()).toHaveProperty("aside@magus");
+		const next = await reconcileActiveProfile(project);
+		expect(next.lines).toEqual([]);
+	});
+
+	test("PROJECT uninstall: the profile drops the plugin, and nothing is left to absorb", async () => {
+		await uninstallPluginInScope(
+			"terminal@magus",
+			"project",
+			project,
+			deps(),
+			"team",
+		);
+
+		expect(await profilePlugins()).not.toHaveProperty("terminal@magus");
+		const next = await reconcileActiveProfile(project);
+		expect(next.lines).toEqual([]);
+	});
+
+	test("USER install: the profile is left as it was", async () => {
+		const before = await fs.readFile(
+			join(project, ".claude", "profiles.json"),
+			"utf8",
+		);
+
+		await installPluginInScope("aside@magus", "user", project, deps());
+		expect(await enabledIn("user")).toHaveProperty("aside@magus", true);
+
+		expect(
+			await fs.readFile(join(project, ".claude", "profiles.json"), "utf8"),
+		).toBe(before);
+		expect(await profilePlugins()).not.toHaveProperty("aside@magus");
+	});
+
+	test("LOCAL install: the private install never reaches the shared profile", async () => {
+		const before = await profilesJson();
+
+		await installPluginInScope("aside@magus", "local", project, deps());
+		expect(await enabledIn("local")).toHaveProperty("aside@magus", true);
+
+		expect(await profilesJson()).toBe(before);
+		expect(await profilePlugins()).not.toHaveProperty("aside@magus");
+	});
+
+	test("PROJECT install under CLI bookkeeping: the profile is left to the wrapper", async () => {
+		const marker = await readActiveMarker(project);
+		if (!marker) throw new Error("activation wrote no marker");
+		await writeActiveMarker({ ...marker, cliBookkeeping: true }, project);
+		const before = await profilesJson();
+
+		await installPluginInScope("aside@magus", "project", project, deps());
+		expect(await enabledIn("project")).toHaveProperty("aside@magus", true);
+
+		expect(await profilesJson()).toBe(before);
+		expect((await readActiveMarker(project))?.cliBookkeeping).toBe(true);
+	});
+
+	test("PROJECT update of a declared plugin: nothing new is recorded", async () => {
+		const before = await profilesJson();
+		const updating: PluginApplyDeps = {
+			...deps(),
+			// `claude plugin update` rewrites the scope's settings.json; the
+			// plugin stays enabled.
+			update: async (pluginId, scope) => setEnabled(scope, pluginId, true),
+		};
+
+		await updatePluginInScope("dev@magus", "project", project, updating);
+
+		expect(await profilesJson()).toBe(before);
+		const next = await reconcileActiveProfile(project);
+		expect(next.lines).toEqual([]);
+	});
+
+	test("an unreadable live file: the install is reported done, the profile record refused", async () => {
+		const broken: PluginApplyDeps = {
+			...deps(),
+			install: async (pluginId, scope) => {
+				await setEnabled(scope, pluginId, true);
+				await fs.appendFile(settingsFor(scope), "{ not json");
+			},
+		};
+
+		await expect(
+			installPluginInScope("aside@magus", "project", project, broken),
+		).rejects.toThrow(
+			"installed at PROJECT scope, but the profile does not record it",
+		);
+	});
+});

package/src/data/alias-flags.ts

@@ -73,10 +73,11 @@ export interface AliasFlag {
 	 */
 	templated?: boolean;
 	/**
-	 * Environment assignment (`NAME=VALUE`) the alias sets before `claude`,
-	 * instead of an argv token. Only for `kind: "boolean"`: enabled emits the
-	 * assignment, disabled emits nothing. `flag` carries the same string so
-	 * lookups by `flag` keep working.
+	 * Environment assignment (`NAME=VALUE`) the alias sets before `claude`
+	 * whenever the flag is enabled. For `kind: "boolean"` the assignment is the
+	 * whole flag, and `flag` carries the same string so lookups by `flag` keep
+	 * working. For `kind: "select"` the flag also emits `flag <value>` as argv:
+	 * the assignment and the argv are one setting that only works as a pair.
 	 */
 	env?: string;
 	/**
@@ -390,22 +391,12 @@ export const ALIAS_FLAGS: AliasFlag[] = [
 	{
 		id: "agent-teams",
 		label: "Agent teams",
-		flag: "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1",
-		env: "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1",
-		kind: "boolean",
-		group: "agents",
-		description:
-			"Turn on agent teams, so the session can start teammates. Claude Code has no flag for this: the alias sets CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 before claude.",
-	},
-	{
-		id: "teammate-mode",
-		label: "Teammate panes",
 		flag: "--teammate-mode",
+		env: "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1",
 		kind: "select",
 		group: "agents",
-		requires: "agent-teams",
 		description:
-			"Where teammates run. tmux opens each teammate in a split pane, but only when the session starts inside tmux. iterm2 uses iTerm2 panes, in-process keeps them in this terminal, auto picks for you. Requires agent teams.",
+			"Turn on agent teams and pick where teammates run. The alias sets CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 and passes --teammate-mode, because one does nothing without the other. tmux opens each teammate in a split pane, but only when the session starts inside tmux. iterm2 uses iTerm2 panes, in-process keeps them in this terminal, auto picks for you.",
 		options: [
 			{ label: "tmux", value: "tmux" },
 			{ label: "iterm2", value: "iterm2" },

package/src/services/alias-shell-writer.ts

@@ -125,8 +125,9 @@ export function renderArgs(config: AliasConfig): Segment[] {
 	const seenXor = new Set<string>();
 
 	for (const flag of ALIAS_FLAGS) {
-		// Env flags are assignments before `claude`, never argv: see renderEnv.
-		if (flag.env) continue;
+		// A boolean env flag is only an assignment before `claude`: see renderEnv.
+		// A select env flag adds its argv here as well.
+		if (isEnvOnly(flag)) continue;
 		if (flag.requires) {
 			const dep = config.flags[flag.requires];
 			if (!isFlagEnabled(dep)) continue;
@@ -187,6 +188,11 @@ export function renderArgsAsTokens(config: AliasConfig): string[] {
 	return [...renderEnv(config), ...argv];
 }
 
+/** A boolean env flag emits its assignment and no argv. */
+function isEnvOnly(flag: AliasFlag): boolean {
+	return flag.env !== undefined && flag.kind === "boolean";
+}
+
 function isFlagEnabled(value: FlagValue | undefined): boolean {
 	if (!value) return false;
 	switch (value.kind) {
@@ -860,6 +866,11 @@ export interface ParsedFlagsWithLeftovers {
  * catalog does not know lands in `leftovers` on its own, so adoption never
  * removes a line it cannot reproduce. Env flags are matched only in that
  * leading run, never among the argv after it.
+ *
+ * A select env flag is one setting written as an assignment plus
+ * `flag <value>`. Its assignment alone reads as the option Claude Code uses
+ * when no value is given (`auto`); its argv alone lands in `leftovers`,
+ * because the pair is the only form the writer reproduces.
  */
 export function argsToFlagValuesWithLeftovers(
 	args: string[],
@@ -871,7 +882,7 @@ export function argsToFlagValuesWithLeftovers(
 	for (const flag of ALIAS_FLAGS) {
 		if (flag.env) {
 			byEnv.set(flag.env, flag);
-			continue;
+			if (isEnvOnly(flag)) continue;
 		}
 		byFlag.set(flag.flag, { flag, off: false });
 		if (flag.triStateOff) {
@@ -881,11 +892,15 @@ export function argsToFlagValuesWithLeftovers(
 
 	const out: Record<string, FlagValue> = {};
 	const leftovers: string[] = [];
+	const envSeen = new Set<string>();
 	let i = 0;
 	while (i < args.length && ENV_ASSIGNMENT_RE.test(args[i])) {
 		const envFlag = byEnv.get(args[i]);
-		if (envFlag) out[envFlag.id] = { kind: "boolean", enabled: true };
+		if (envFlag) envSeen.add(envFlag.id);
 		else leftovers.push(args[i]);
+		if (envFlag && isEnvOnly(envFlag)) {
+			out[envFlag.id] = { kind: "boolean", enabled: true };
+		}
 		i += 1;
 	}
 	while (i < args.length) {
@@ -1041,6 +1056,20 @@ export function argsToFlagValuesWithLeftovers(
 		};
 	}
 
+	// Pair each select env flag's assignment with its argv.
+	for (const flag of ALIAS_FLAGS) {
+		if (!flag.env || isEnvOnly(flag)) continue;
+		const parsed = out[flag.id];
+		const hasArgv = parsed !== undefined;
+		if (envSeen.has(flag.id) && !hasArgv) {
+			out[flag.id] = { kind: "select", enabled: true, value: "auto" };
+		} else if (!envSeen.has(flag.id) && hasArgv) {
+			delete out[flag.id];
+			const value = parsed.kind === "select" ? parsed.value : "";
+			leftovers.push(flag.flag, ...(value ? [value] : []));
+		}
+	}
+
 	return { flags: out, leftovers };
 }
 

package/src/services/update-engine.ts

@@ -267,6 +267,15 @@ export interface PluginApplyDeps {
 	 * that did not happen.
 	 */
 	remove?: PluginRemoveDeps;
+	/**
+	 * Absorb the live settings into the active profile and bring its record of
+	 * them forward (`recordScopeActionInProfile`). A Plugins-screen scope action
+	 * writes the live settings itself, through the `claude` CLI, so the profile
+	 * must record it at once — otherwise the next magus command absorbs it as an
+	 * edit the user made by hand. Optional so a double that does not model
+	 * profiles skips it.
+	 */
+	recordInProfile?: (projectPath: string) => Promise<void>;
 }
 
 /** The three calls a `remove` makes — see {@link applyRemove}. */
@@ -395,6 +404,7 @@ export const REAL_PLUGIN_DEPS: PluginApplyDeps = {
 		return Array.isArray(rows) ? rows : [];
 	},
 	remove: REAL_REMOVE_DEPS,
+	recordInProfile: recordScopeActionInProfile,
 };
 
 /**
@@ -1084,6 +1094,53 @@ export async function removeDeprecatedPlugin(
 	return { problems, unlistedFrom: unlisted.unlistedFrom };
 }
 
+/**
+ * Is a `withCliBookkeeping` run (`magus update`) in progress here? Its wrapper
+ * reconciles before it renders, so a reconcile inside the run would write a
+ * fresh marker, clear the bookkeeping flag, and turn the CLI's own install
+ * records into edits the user made.
+ */
+async function underCliBookkeeping(projectPath: string): Promise<boolean> {
+	const marker = (await hasCurrentMarker(projectPath))
+		? await readActiveMarker(projectPath)
+		: null;
+	return marker?.cliBookkeeping === true;
+}
+
+/**
+ * Absorb the live settings into the active profile after a Plugins-screen
+ * scope action, so the profile lists what the `claude` CLI just turned on or
+ * off and its record of the live files matches them. A no-op when the live
+ * files did not change or no profile is active, and left to the wrapper under
+ * {@link underCliBookkeeping}. Refuses, writing nothing, on an unreadable live
+ * file.
+ *
+ * The reconcile absorbs every pending edit to the live config, not only this
+ * action's own change, exactly as the next magus command would. The TUI shows
+ * no status for what it recorded.
+ */
+async function recordScopeActionInProfile(projectPath: string): Promise<void> {
+	if (await underCliBookkeeping(projectPath)) return;
+	refuseOnProblems(await reconcileActiveProfile(projectPath));
+}
+
+/**
+ * Run `deps.recordInProfile`, rethrowing a failure as one that says the action
+ * itself happened: the plugin is installed or removed, only the profile lags.
+ */
+async function recordInProfileOrExplain(
+	deps: PluginApplyDeps,
+	projectPath: string,
+	done: string,
+): Promise<void> {
+	try {
+		await deps.recordInProfile?.(projectPath);
+	} catch (error) {
+		const why = error instanceof Error ? error.message : String(error);
+		throw new Error(`${done}, but the profile does not record it: ${why}`);
+	}
+}
+
 /**
  * Stop EVERY profile in the project listing a deprecated plugin, keeping the
  * user's live edits — the profile half of both removals, {@link applyRemove}
@@ -1114,10 +1171,7 @@ async function unlistFromEveryProfile(
 	const problems: unknown[] = [];
 	const unlistedFrom: string[] = [];
 	try {
-		const marker = (await hasCurrentMarker(projectPath))
-			? await readActiveMarker(projectPath)
-			: null;
-		const wrapperReconciles = marker?.cliBookkeeping === true;
+		const wrapperReconciles = await underCliBookkeeping(projectPath);
 		// Refuses, writing nothing, on an unreadable live file.
 		if (!wrapperReconciles) {
 			refuseOnProblems(await reconcileActiveProfile(projectPath));
@@ -1321,6 +1375,7 @@ export async function applyPlugins(
  */
 async function applyOneInScope(
 	run: (pluginId: string, scope: PluginScope) => Promise<void>,
+	verb: "installed" | "updated",
 	pluginId: string,
 	scope: PluginScope,
 	projectPath: string,
@@ -1338,6 +1393,11 @@ async function applyOneInScope(
 			throw new Error(describeLoadNotForward(forward));
 		}
 	}
+	await recordInProfileOrExplain(
+		deps,
+		projectPath,
+		`${verb} at ${scope.toUpperCase()} scope`,
+	);
 	return actual;
 }
 
@@ -1359,7 +1419,14 @@ export async function installPluginInScope(
 	projectPath: string,
 	deps: PluginApplyDeps = REAL_PLUGIN_DEPS,
 ): Promise<string | null> {
-	return applyOneInScope(deps.install, pluginId, scope, projectPath, deps);
+	return applyOneInScope(
+		deps.install,
+		"installed",
+		pluginId,
+		scope,
+		projectPath,
+		deps,
+	);
 }
 
 /**
@@ -1381,6 +1448,7 @@ export async function updatePluginInScope(
 		async (id, sc) => {
 			await advanceInScope(deps, id, sc, projectPath);
 		},
+		"updated",
 		pluginId,
 		scope,
 		projectPath,
@@ -1454,12 +1522,13 @@ export async function uninstallPluginInScope(
 			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`,
-		);
+	const done = `uninstalled at ${scope.toUpperCase()} scope`;
+	if (scope === "project" || installedNowhere) {
+		if (!(await remove.dropFromProfile(pluginId, projectPath, profile))) {
+			throw new Error(`${done}, but the profile still lists it`);
+		}
 	}
+	await recordInProfileOrExplain(deps, projectPath, done);
 }
 
 // -- binaries ----------------------------------------------------------------

package/src/ui/components/modals/InputModal.tsx

@@ -61,6 +61,11 @@ export function InputModal({
 						if (typeof value === "string") onSubmit(value);
 					}}
 					focused
+					// OpenTUI paints input text white by default, which vanishes on a
+					// light terminal. The terminal's own foreground reads on both.
+					textColor={theme.colors.text}
+					focusedTextColor={theme.colors.text}
+					placeholderColor={theme.colors.muted}
 					width={50}
 				/>
 			</box>