magus-cli 7.12.0 → 7.12.1

package/package.json

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

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/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/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>