magus-cli 7.11.8 → 7.12.1

package/src/data/alias-flags.ts

@@ -72,6 +72,19 @@ export interface AliasFlag {
 	 * token. See `TEMPLATE_TOKENS` for the supported placeholder set.
 	 */
 	templated?: boolean;
+	/**
+	 * 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;
+	/**
+	 * Value check for `kind: "text"` flags, run when the user enters a value.
+	 * Returns null when the value is valid, otherwise the reason it is not.
+	 */
+	validateValue?: (value: string) => string | null;
 	/** UI grouping; rendered as section headers in the list. */
 	group: FlagGroup;
 }
@@ -100,7 +113,8 @@ export type FlagGroup =
 	| "channels"
 	| "debug"
 	| "integration"
-	| "worktree";
+	| "worktree"
+	| "agents";
 
 export const FLAG_GROUPS: Array<{ id: FlagGroup; label: string }> = [
 	{ id: "danger", label: "Permissions" },
@@ -110,8 +124,81 @@ export const FLAG_GROUPS: Array<{ id: FlagGroup; label: string }> = [
 	{ id: "debug", label: "Debug" },
 	{ id: "integration", label: "Integrations" },
 	{ id: "worktree", label: "Worktree" },
+	{ id: "agents", label: "Agent teams" },
 ];
 
+/** Smallest auto-compact window Claude Code accepts, in tokens. */
+export const AUTOCOMPACT_MIN_TOKENS = 100_000;
+/** Largest auto-compact window Claude Code accepts, in tokens. */
+export const AUTOCOMPACT_MAX_TOKENS = 1_000_000;
+
+/** Claude Code's own wording when it refuses an `--autocompact` value. */
+export const AUTOCOMPACT_INVALID_REASON =
+	"It must be 'auto', or between 100k and 1M (e.g. 500k, 200000, or 200 as shorthand)";
+
+const EXPONENT_NUMBER = /^[+-]?(\d+(\.\d*)?|\.\d+)[eE][+-]?\d+$/;
+const GROUPED_DIGITS = /^[+-]?\d{1,3}([_,   ])\d{3}(?:\1\d{3})*$/;
+const DIGIT_SEPARATORS = /[_,   ]/g;
+
+/**
+ * Read an unsuffixed number the way Claude Code does: exponent notation
+ * (`2e5`) when it is an integer, digit groups (`200,000`, `200_000`), and
+ * otherwise `parseInt`, which keeps the leading digits of the string.
+ */
+function parsePlainNumber(text: string): number {
+	if (text.length <= 32) {
+		if (EXPONENT_NUMBER.test(text)) {
+			const n = Number(text);
+			return Number.isInteger(n) ? n : Number.NaN;
+		}
+		if (GROUPED_DIGITS.test(text)) {
+			return Number.parseInt(text.replace(DIGIT_SEPARATORS, ""), 10);
+		}
+	}
+	return Number.parseInt(text, 10);
+}
+
+/**
+ * Parse an `--autocompact` value exactly as Claude Code's option parser does.
+ *
+ * `auto` (any case) stays `"auto"`. A trailing `k` or `m` multiplies by a
+ * thousand or a million; an unsuffixed number from 100 to 1000 is read as
+ * thousands (`200` is 200,000 tokens). The result must fall between
+ * {@link AUTOCOMPACT_MIN_TOKENS} and {@link AUTOCOMPACT_MAX_TOKENS}.
+ *
+ * Returns the token count, `"auto"`, or `undefined` when Claude Code would
+ * refuse the value.
+ */
+export function parseAutocompactSize(
+	value: string,
+): number | "auto" | undefined {
+	if (value.trim().toLowerCase() === "auto") return "auto";
+	const text = value.trim();
+	const suffix = text.slice(-1).toLowerCase();
+	const multiplier =
+		suffix === "m" ? 1_000_000 : suffix === "k" ? 1_000 : undefined;
+	const parsed =
+		multiplier === undefined
+			? parsePlainNumber(text)
+			: Number.parseFloat(text) * multiplier;
+	const tokens =
+		multiplier === undefined && parsed >= 100 && parsed <= 1000
+			? parsed * 1000
+			: parsed;
+	if (Number.isNaN(tokens) || tokens < 1) return undefined;
+	if (tokens < AUTOCOMPACT_MIN_TOKENS || tokens > AUTOCOMPACT_MAX_TOKENS) {
+		return undefined;
+	}
+	return Math.round(tokens);
+}
+
+/** `validateValue` for the context window size: Claude Code's reason, or null. */
+export function validateAutocompactSize(value: string): string | null {
+	return parseAutocompactSize(value) === undefined
+		? AUTOCOMPACT_INVALID_REASON
+		: null;
+}
+
 export const ALIAS_FLAGS: AliasFlag[] = [
 	{
 		id: "dangerously-skip-permissions",
@@ -222,6 +309,16 @@ export const ALIAS_FLAGS: AliasFlag[] = [
 		description:
 			"Path to a file whose contents are appended to the default system prompt.",
 	},
+	{
+		id: "autocompact",
+		label: "Context window size",
+		flag: "--autocompact",
+		kind: "text",
+		group: "context",
+		validateValue: validateAutocompactSize,
+		description:
+			"The window size Claude Code compacts the conversation at: auto, or 100k to 1M tokens (e.g. 200k, 500k, 1m, 200000, or 200 as shorthand for 200k).",
+	},
 	{
 		id: "channels",
 		label: "Channels (approved)",
@@ -291,6 +388,22 @@ export const ALIAS_FLAGS: AliasFlag[] = [
 			{ label: "classic", value: "classic" },
 		],
 	},
+	{
+		id: "agent-teams",
+		label: "Agent teams",
+		flag: "--teammate-mode",
+		env: "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1",
+		kind: "select",
+		group: "agents",
+		description:
+			"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" },
+			{ label: "in-process", value: "in-process" },
+			{ label: "auto", value: "auto" },
+		],
+	},
 ];
 
 /** Look up a flag by id. Throws if missing — keeps callers honest. */

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

@@ -125,6 +125,9 @@ export function renderArgs(config: AliasConfig): Segment[] {
 	const seenXor = new Set<string>();
 
 	for (const flag of ALIAS_FLAGS) {
+		// 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;
@@ -154,18 +157,40 @@ export function renderArgs(config: AliasConfig): Segment[] {
 }
 
 /**
- * Convenience: render each segment to its literal-token approximation.
- * Composite segments are stringified by joining their literal parts with
- * `<sub>` placeholders for raw parts. Used by tests and validation summaries
- * where the actual shell substitution doesn't matter.
+ * The environment assignments (`NAME=VALUE`) the alias sets before `claude`,
+ * one per enabled env flag, in catalog order. `requires` applies here as it
+ * does to argv flags. Pure function.
+ */
+export function renderEnv(config: AliasConfig): string[] {
+	const out: string[] = [];
+	for (const flag of ALIAS_FLAGS) {
+		if (!flag.env) continue;
+		if (flag.requires && !isFlagEnabled(config.flags[flag.requires])) continue;
+		if (isFlagEnabled(config.flags[flag.id])) out.push(flag.env);
+	}
+	return out;
+}
+
+/**
+ * Convenience: the whole command after the alias name as literal tokens, env
+ * assignments first, then argv. Composite segments are stringified by joining
+ * their literal parts with `<sub>` placeholders for raw parts. Used by the
+ * adoption fixpoint check, tests and validation summaries, where the actual
+ * shell substitution doesn't matter.
  */
 export function renderArgsAsTokens(config: AliasConfig): string[] {
-	return renderArgs(config).map((seg) => {
+	const argv = renderArgs(config).map((seg) => {
 		if (seg.kind === "literal") return seg.text;
 		return seg.parts
 			.map((p) => (p.kind === "literal" ? p.text : `<${p.posix}>`))
 			.join("");
 	});
+	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 {
@@ -345,24 +370,32 @@ export function renderAlias(
 	shell: ShellKind,
 ): RenderedAlias {
 	const args = renderArgs(config);
+	const env = renderEnv(config);
 	const name = config.aliasName;
 	if (shell === "fish") {
-		return { shell, block: renderFishBlock(name, args) };
+		return { shell, block: renderFishBlock(name, env, args) };
 	}
-	return { shell, block: renderPosixBlock(name, args) };
+	return { shell, block: renderPosixBlock(name, env, args) };
 }
 
-function renderPosixBlock(name: string, segments: Segment[]): string {
+function renderPosixBlock(
+	name: string,
+	env: string[],
+	segments: Segment[],
+): string {
 	// The alias body lives inside outer single quotes:
-	//   alias <name>='claude … '
-	// Each segment becomes one shell-arg inside that body. Composite segments
+	//   alias <name>='NAME=VALUE claude … '
+	// Env assignments lead, so the shell exports them to `claude` alone. Each
+	// segment becomes one shell-arg inside that body. Composite segments
 	// (templated values) interleave literal text with double-quoted shell
 	// substitutions via close-outer + double-quote + reopen-outer.
+	const prefix =
+		env.length === 0 ? "" : `${env.map(quoteInsidePosixAlias).join(" ")} `;
 	const body =
 		segments.length === 0
 			? ""
 			: ` ${segments.map(renderPosixSegment).join(" ")}`;
-	const line = `alias ${name}='claude${body}'`;
+	const line = `alias ${name}='${prefix}claude${body}'`;
 	return `${BLOCK_BEGIN}\n${line}\n${BLOCK_END}\n`;
 }
 
@@ -425,13 +458,22 @@ export function findUnquotableTokens(segments: Segment[]): string[] {
 	return out;
 }
 
-function renderFishBlock(name: string, segments: Segment[]): string {
+function renderFishBlock(
+	name: string,
+	env: string[],
+	segments: Segment[],
+): string {
 	// Fish: `alias <name> 'claude --foo bar'` — outer single quotes, no `=`.
+	// Env assignments go through `env NAME=VALUE claude …`: the bare
+	// `NAME=VALUE cmd` form needs fish 3.1, `env` works on every version. The
+	// assignments are catalog constants of `[A-Za-z0-9_=]`, so they need no
+	// quoting inside the outer single quotes.
+	const prefix = env.length === 0 ? "" : `env ${env.join(" ")} `;
 	const body =
 		segments.length === 0
 			? ""
 			: ` ${segments.map(renderFishSegment).join(" ")}`;
-	const line = `alias ${name} 'claude${body}'`;
+	const line = `alias ${name} '${prefix}claude${body}'`;
 	return `${BLOCK_BEGIN}\n${line}\n${BLOCK_END}\n`;
 }
 
@@ -604,9 +646,33 @@ export function validateConfig(config: AliasConfig): FlagValidationIssue[] {
 
 export interface ParseResult {
 	aliasName: string | null;
+	/**
+	 * The env assignments before `claude` (`NAME=VALUE`), then the argv after
+	 * it — the shape {@link argsToFlagValuesWithLeftovers} reads.
+	 */
 	args: string[];
 }
 
+/** A shell environment assignment token: `NAME=VALUE`. */
+const ENV_ASSIGNMENT_RE = /^[A-Za-z_][A-Za-z0-9_]*=/;
+
+/**
+ * Split an alias command into the tokens {@link argsToFlagValuesWithLeftovers}
+ * reads: leading env assignments, then the argv after `claude`. Accepts the
+ * POSIX `NAME=VALUE claude …` form and the `env NAME=VALUE claude …` form the
+ * fish renderer writes. Returns null when the command is not `claude`.
+ */
+function commandTokensAfterEnv(tokens: string[]): string[] | null {
+	let i = tokens[0] === "env" ? 1 : 0;
+	const env: string[] = [];
+	while (i < tokens.length && ENV_ASSIGNMENT_RE.test(tokens[i])) {
+		env.push(tokens[i]);
+		i += 1;
+	}
+	if (tokens[i] !== "claude") return null;
+	return [...env, ...tokens.slice(i + 1)];
+}
+
 /**
  * Find the managed block in shell rc text, parse the alias line, and return
  * the alias name plus the argv tokens after `claude`.
@@ -644,10 +710,11 @@ export function parseAliasLine(line: string): ParseResult | null {
 	const match = ALIAS_LINE_RE.exec(line);
 	if (!match) return null;
 	const [, aliasName, body] = match;
-	// First token is the command itself (claude). Drop it; we only want argv.
-	const tokens = tokenizePosixAliasBody(body);
-	if (tokens.length === 0 || tokens[0] !== "claude") return null;
-	return { aliasName, args: tokens.slice(1) };
+	// The command is `claude`, optionally preceded by env assignments. Drop
+	// `claude` itself; keep the assignments ahead of the argv.
+	const args = commandTokensAfterEnv(tokenizePosixAliasBody(body));
+	if (!args) return null;
+	return { aliasName, args };
 }
 
 /**
@@ -793,13 +860,30 @@ export interface ParsedFlagsWithLeftovers {
  * catalog flag. Unknown `--flag value` pairs contribute BOTH tokens to
  * `leftovers` (the flag and its consumed value) so the adoption gate sees the
  * full extent of what wouldn't round-trip.
+ *
+ * Leading `NAME=VALUE` tokens are the env assignments set before `claude`.
+ * Each matches an env flag by its assignment string; an assignment the
+ * 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[],
 ): ParsedFlagsWithLeftovers {
-	// Index every flag by its primary `flag` string AND its triStateOff variant.
+	// Index argv flags by their primary `flag` string AND their triStateOff
+	// variant, and env flags by their assignment string.
 	const byFlag = new Map<string, { flag: AliasFlag; off?: boolean }>();
+	const byEnv = new Map<string, AliasFlag>();
 	for (const flag of ALIAS_FLAGS) {
+		if (flag.env) {
+			byEnv.set(flag.env, flag);
+			if (isEnvOnly(flag)) continue;
+		}
 		byFlag.set(flag.flag, { flag, off: false });
 		if (flag.triStateOff) {
 			byFlag.set(flag.triStateOff, { flag, off: true });
@@ -808,7 +892,17 @@ 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) 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) {
 		const tok = args[i];
 		const entry = byFlag.get(tok);
@@ -962,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 };
 }
 
@@ -1122,9 +1230,9 @@ function parseAdoptableLine(
 	if (!match) return null;
 	const [, name, , body] = match;
 	const tokens = tokenizeGeneralAliasBody(body);
-	if (!tokens || tokens.length === 0 || tokens[0] !== "claude") return null;
-
-	const args = tokens.slice(1);
+	if (!tokens) return null;
+	const args = commandTokensAfterEnv(tokens);
+	if (!args) return null;
 	const { flags, leftovers } = argsToFlagValuesWithLeftovers(args);
 
 	// Fixpoint: render the parsed flags back to tokens and re-parse. If the

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>

package/src/ui/screens/AliasScreen.tsx

@@ -7,6 +7,7 @@ import {
 	ALIAS_FLAGS,
 	type AliasFlag,
 	FLAG_GROUPS,
+	getFlagById,
 } from "../../data/alias-flags.js";
 import { loadAliasName, saveAliasName } from "../../services/alias-settings.js";
 import {
@@ -18,6 +19,7 @@ import {
 	findAdoptableAlias,
 	parseAliasFromRc,
 	renderArgs,
+	renderEnv,
 	validateConfig,
 	writeAliasToShell,
 } from "../../services/alias-shell-writer.js";
@@ -521,9 +523,10 @@ export function AliasScreen() {
 			selectedRow.flag,
 			selectedRow.value,
 			modal,
+			showFailures,
 		);
 		if (next) updateFlag(selectedRow.flag.id, next);
-	}, [selectedRow, modal, updateFlag, editAliasName]);
+	}, [selectedRow, modal, showFailures, updateFlag, editAliasName]);
 
 	const toggleSelected = useCallback(async () => {
 		if (!selectedRow) return;
@@ -680,6 +683,7 @@ export function AliasScreen() {
 
 	// ── Render ────────────────────────────────────────────────────────────
 	const previewSegments = config ? renderArgs(config) : [];
+	const previewEnv = config ? renderEnv(config) : [];
 	const previewAliasName = config?.aliasName ?? "";
 
 	// Native OpenTUI scrollboxes own the scroll math. We render every item
@@ -767,6 +771,7 @@ export function AliasScreen() {
 		selectedRow,
 		isGated,
 		previewAliasName,
+		previewEnv,
 		previewSegments,
 	);
 	// When editing --channels and there are derived rows, the right pane carries
@@ -795,6 +800,7 @@ export function AliasScreen() {
 				detailFlag,
 				detailValue,
 				previewAliasName,
+				previewEnv,
 				previewSegments,
 				derivedNote,
 				stateOverride,
@@ -1081,6 +1087,7 @@ async function editFlagValue(
 	flag: AliasFlag,
 	value: FlagValue,
 	modal: ReturnType<typeof useModal>,
+	showFailures: ReturnType<typeof useFailurePopup>,
 ): Promise<FlagValue | null> {
 	switch (value.kind) {
 		case "boolean":
@@ -1154,6 +1161,17 @@ async function editFlagValue(
 			}
 			const v = await modal.input(flag.label, flag.description, value.value);
 			if (v === null) return null;
+			// An empty value disables the flag, so only a non-empty one is checked.
+			// A refused value leaves the old one in place.
+			const reason = v.length > 0 ? (flag.validateValue?.(v) ?? null) : null;
+			if (reason) {
+				await showFailures(
+					failureReport(`The ${flag.label.toLowerCase()} was not changed`, [
+						{ subject: v, reason },
+					]),
+				);
+				return null;
+			}
 			return { kind: "text", enabled: v.length > 0, value: v };
 		}
 
@@ -1336,6 +1354,7 @@ function renderDetail(
 	row: Row | undefined,
 	isGated: (f: AliasFlag) => boolean,
 	aliasName: string,
+	env: string[],
 	segments: Segment[],
 ): React.ReactNode {
 	if (!row) {
@@ -1357,7 +1376,7 @@ function renderDetail(
 			{headerAndBody}
 			<text fg={theme.colors.text}> </text>
 			<text fg={theme.colors.muted}>Preview:</text>
-			{renderPreviewLines(aliasName, segments)}
+			{renderPreviewLines(aliasName, env, segments)}
 		</box>
 	);
 }
@@ -1407,7 +1426,7 @@ function renderFlagDetail(
 			</text>
 			{gated && (
 				<text fg={theme.colors.muted}>
-					{`Depends on --${row.flag.requires}. Enabling this will turn that on too.`}
+					{`Depends on ${getFlagById(row.flag.requires ?? "").flag}. Enabling this will turn that on too.`}
 				</text>
 			)}
 			{row.issue && (
@@ -1438,18 +1457,23 @@ function renderFlagDetail(
  */
 function renderPreviewLines(
 	aliasName: string,
+	env: string[],
 	segments: Segment[],
 ): React.ReactNode {
+	// Env assignments run before `claude`, so they sit on the head line.
+	const command = [...env, "claude"].join(" ");
 	if (segments.length === 0) {
 		return (
-			<text fg={theme.colors.text}>{`alias ${aliasName || "?"}='claude'`}</text>
+			<text
+				fg={theme.colors.text}
+			>{`alias ${aliasName || "?"}='${command}'`}</text>
 		);
 	}
 	const lines: React.ReactNode[] = [
 		<text
 			key="head"
 			fg={theme.colors.text}
-		>{`alias ${aliasName || "?"}='claude`}</text>,
+		>{`alias ${aliasName || "?"}='${command}`}</text>,
 	];
 	segments.forEach((seg, i) => {
 		lines.push(
@@ -1530,6 +1554,7 @@ function renderFlagDetailRightPane(
 	flag: AliasFlag,
 	value: FlagValue,
 	aliasName: string,
+	env: string[],
 	segments: Segment[],
 	derivedNote?: string,
 	stateOverride?: string,
@@ -1555,7 +1580,7 @@ function renderFlagDetailRightPane(
 			</text>
 			<text fg={theme.colors.text}> </text>
 			<text fg={theme.colors.muted}>Preview:</text>
-			{renderPreviewLines(aliasName, segments)}
+			{renderPreviewLines(aliasName, env, segments)}
 			<text fg={theme.colors.text}> </text>
 			<text fg={theme.colors.muted}>Keys:</text>
 			<text fg={theme.colors.text}>