claudeup 6.2.1 → 6.3.2

package/src/__tests__/alias-parser.test.ts

@@ -1,12 +1,12 @@
-import { describe, it, expect } from "bun:test";
+import { describe, expect, it } from "bun:test";
 import {
-  parseManagedBlock,
-  parseAliasLine,
-  parseAliasFromRc,
-  tokenizePosixAliasBody,
-  argsToFlagValues,
-  renderAlias,
-  renderArgsAsTokens,
+	argsToFlagValues,
+	parseAliasFromRc,
+	parseAliasLine,
+	parseManagedBlock,
+	renderAlias,
+	renderArgsAsTokens,
+	tokenizePosixAliasBody,
 } from "../services/alias-shell-writer";
 import { defaultAliasConfig } from "../services/alias-store";
 
@@ -17,393 +17,401 @@ import { defaultAliasConfig } from "../services/alias-store";
  * defaults aren't in the rc file at all).
  */
 
-function buildAndParse(mutate: (c: ReturnType<typeof defaultAliasConfig>) => void) {
-  const c = defaultAliasConfig();
-  c.aliasName = "c";
-  mutate(c);
-  const rendered = renderAlias(c, "zsh").block;
-  const parsed = parseAliasFromRc(rendered);
-  return { config: c, rendered, parsed };
+function buildAndParse(
+	mutate: (c: ReturnType<typeof defaultAliasConfig>) => void,
+) {
+	const c = defaultAliasConfig();
+	c.aliasName = "c";
+	mutate(c);
+	const rendered = renderAlias(c, "zsh").block;
+	const parsed = parseAliasFromRc(rendered);
+	return { config: c, rendered, parsed };
 }
 
 describe("parseManagedBlock", () => {
-  it("returns null when no managed block exists", () => {
-    expect(parseManagedBlock("export PATH=...\n")).toBeNull();
-    expect(parseManagedBlock("")).toBeNull();
-  });
-
-  it("returns null when only one marker is present", () => {
-    expect(parseManagedBlock("# >>> claudeup managed alias >>>\nalias c='claude'\n")).toBeNull();
-  });
-
-  it("extracts a minimal block with no args", () => {
-    const text =
-      "# >>> claudeup managed alias >>>\n" +
-      "alias c='claude'\n" +
-      "# <<< claudeup managed alias <<<\n";
-    const r = parseManagedBlock(text);
-    expect(r).not.toBeNull();
-    expect(r?.aliasName).toBe("c");
-    expect(r?.args).toEqual([]);
-  });
-
-  it("ignores text outside the block", () => {
-    const text =
-      "export FOO=bar\n" +
-      "# >>> claudeup managed alias >>>\n" +
-      "alias cc='claude --ide'\n" +
-      "# <<< claudeup managed alias <<<\n" +
-      "alias ll='ls -la'\n";
-    const r = parseManagedBlock(text);
-    expect(r?.aliasName).toBe("cc");
-    expect(r?.args).toEqual(["--ide"]);
-  });
+	it("returns null when no managed block exists", () => {
+		expect(parseManagedBlock("export PATH=...\n")).toBeNull();
+		expect(parseManagedBlock("")).toBeNull();
+	});
+
+	it("returns null when only one marker is present", () => {
+		expect(
+			parseManagedBlock("# >>> claudeup managed alias >>>\nalias c='claude'\n"),
+		).toBeNull();
+	});
+
+	it("extracts a minimal block with no args", () => {
+		const text =
+			"# >>> claudeup managed alias >>>\n" +
+			"alias c='claude'\n" +
+			"# <<< claudeup managed alias <<<\n";
+		const r = parseManagedBlock(text);
+		expect(r).not.toBeNull();
+		expect(r?.aliasName).toBe("c");
+		expect(r?.args).toEqual([]);
+	});
+
+	it("ignores text outside the block", () => {
+		const text =
+			"export FOO=bar\n" +
+			"# >>> claudeup managed alias >>>\n" +
+			"alias cc='claude --ide'\n" +
+			"# <<< claudeup managed alias <<<\n" +
+			"alias ll='ls -la'\n";
+		const r = parseManagedBlock(text);
+		expect(r?.aliasName).toBe("cc");
+		expect(r?.args).toEqual(["--ide"]);
+	});
 });
 
 describe("parseAliasLine", () => {
-  it("rejects lines that don't match the managed pattern", () => {
-    expect(parseAliasLine("alias ll='ls -la'")).toBeNull();
-    expect(parseAliasLine("alias =foo")).toBeNull();
-    expect(parseAliasLine("alias c='ls'")).toBeNull(); // not invoking claude
-  });
-
-  it("parses simple bare-flag lines", () => {
-    const r = parseAliasLine("alias c='claude --ide --dangerously-skip-permissions'");
-    expect(r?.aliasName).toBe("c");
-    expect(r?.args).toEqual(["--ide", "--dangerously-skip-permissions"]);
-  });
+	it("rejects lines that don't match the managed pattern", () => {
+		expect(parseAliasLine("alias ll='ls -la'")).toBeNull();
+		expect(parseAliasLine("alias =foo")).toBeNull();
+		expect(parseAliasLine("alias c='ls'")).toBeNull(); // not invoking claude
+	});
+
+	it("parses simple bare-flag lines", () => {
+		const r = parseAliasLine(
+			"alias c='claude --ide --dangerously-skip-permissions'",
+		);
+		expect(r?.aliasName).toBe("c");
+		expect(r?.args).toEqual(["--ide", "--dangerously-skip-permissions"]);
+	});
 });
 
 describe("tokenizePosixAliasBody — escape forms", () => {
-  it("splits bare tokens on whitespace", () => {
-    expect(tokenizePosixAliasBody("claude --ide --debug api,hooks")).toEqual([
-      "claude",
-      "--ide",
-      "--debug",
-      "api,hooks",
-    ]);
-  });
-
-  it("unescapes the close-escape-reopen sequence for spaces", () => {
-    // `'\''be terse'\''` inside outer quotes becomes the literal token `be terse`.
-    expect(
-      tokenizePosixAliasBody("claude --append-system-prompt '\\''be terse'\\''"),
-    ).toEqual(["claude", "--append-system-prompt", "be terse"]);
-  });
-
-  it("converts a substitution embed back into its template token", () => {
-    expect(
-      tokenizePosixAliasBody(
-        `claude --remote-control-session-name-prefix dev-'"$(basename "$PWD")"'-'"$(date +%d)"'`,
-      ),
-    ).toEqual([
-      "claude",
-      "--remote-control-session-name-prefix",
-      "dev-{folder}-{day}",
-    ]);
-  });
-
-  it("passes through unknown substitution code as the raw $(...) form", () => {
-    expect(
-      tokenizePosixAliasBody(`claude --remote-control-session-name-prefix '"$(whoami)"'`),
-    ).toEqual(["claude", "--remote-control-session-name-prefix", "$(whoami)"]);
-  });
+	it("splits bare tokens on whitespace", () => {
+		expect(tokenizePosixAliasBody("claude --ide --debug api,hooks")).toEqual([
+			"claude",
+			"--ide",
+			"--debug",
+			"api,hooks",
+		]);
+	});
+
+	it("unescapes the close-escape-reopen sequence for spaces", () => {
+		// `'\''be terse'\''` inside outer quotes becomes the literal token `be terse`.
+		expect(
+			tokenizePosixAliasBody(
+				"claude --append-system-prompt '\\''be terse'\\''",
+			),
+		).toEqual(["claude", "--append-system-prompt", "be terse"]);
+	});
+
+	it("converts a substitution embed back into its template token", () => {
+		expect(
+			tokenizePosixAliasBody(
+				`claude --remote-control-session-name-prefix dev-'"$(basename "$PWD")"'-'"$(date +%d)"'`,
+			),
+		).toEqual([
+			"claude",
+			"--remote-control-session-name-prefix",
+			"dev-{folder}-{day}",
+		]);
+	});
+
+	it("passes through unknown substitution code as the raw $(...) form", () => {
+		expect(
+			tokenizePosixAliasBody(
+				`claude --remote-control-session-name-prefix '"$(whoami)"'`,
+			),
+		).toEqual(["claude", "--remote-control-session-name-prefix", "$(whoami)"]);
+	});
 });
 
 describe("argsToFlagValues", () => {
-  it("returns an empty object for empty args", () => {
-    expect(argsToFlagValues([])).toEqual({});
-  });
-
-  it("marks boolean flags as enabled", () => {
-    const v = argsToFlagValues(["--ide", "--dangerously-skip-permissions"]);
-    expect(v["ide"]).toEqual({ kind: "boolean", enabled: true });
-    expect(v["dangerously-skip-permissions"]).toEqual({
-      kind: "boolean",
-      enabled: true,
-    });
-  });
-
-  it("recognises tri-state on/off variants", () => {
-    expect(argsToFlagValues(["--chrome"])).toMatchObject({
-      chrome: { kind: "tri-state", state: "on" },
-    });
-    expect(argsToFlagValues(["--no-chrome"])).toMatchObject({
-      chrome: { kind: "tri-state", state: "off" },
-    });
-  });
-
-  it("reads a select flag with a known value", () => {
-    expect(argsToFlagValues(["--effort", "high"])).toMatchObject({
-      effort: { kind: "select", enabled: true, value: "high" },
-    });
-  });
-
-  it("treats a bare --tmux (no variant) as the empty-value select", () => {
-    expect(argsToFlagValues(["--worktree", "--tmux"])).toMatchObject({
-      worktree: { kind: "boolean", enabled: true },
-      tmux: { kind: "select", enabled: true, value: "" },
-    });
-  });
-
-  it("reads multi-with-custom comma-joined tokens, splitting picked vs custom", () => {
-    expect(argsToFlagValues(["--debug", "api,hooks,!file"])).toMatchObject({
-      debug: {
-        kind: "multi-with-custom",
-        enabled: true,
-        picked: ["api", "hooks"],
-        custom: ["!file"],
-      },
-    });
-  });
-
-  it("collects repeated --dangerously-load-development-channels values", () => {
-    expect(
-      argsToFlagValues([
-        "--dangerously-load-development-channels",
-        "plugin:claudish@magus",
-        "--dangerously-load-development-channels",
-        "plugin:dev@magus",
-      ]),
-    ).toMatchObject({
-      "dangerously-load-development-channels": {
-        kind: "text-list",
-        enabled: true,
-        values: ["plugin:claudish@magus", "plugin:dev@magus"],
-      },
-    });
-  });
-
-  it("reads a text flag's value", () => {
-    expect(
-      argsToFlagValues(["--append-system-prompt", "be terse"]),
-    ).toMatchObject({
-      "append-system-prompt": {
-        kind: "text",
-        enabled: true,
-        value: "be terse",
-      },
-    });
-  });
-
-  it("recognises an optional-text flag in bare form (followed by another flag)", () => {
-    expect(
-      argsToFlagValues(["--remote-control", "--ide"]),
-    ).toMatchObject({
-      "remote-control": { kind: "boolean", enabled: true },
-      ide: { kind: "boolean", enabled: true },
-    });
-  });
-
-  it("silently skips unknown flag/value pairs without corrupting the rest", () => {
-    expect(
-      argsToFlagValues(["--unknown-future", "value", "--ide"]),
-    ).toMatchObject({ ide: { kind: "boolean", enabled: true } });
-  });
+	it("returns an empty object for empty args", () => {
+		expect(argsToFlagValues([])).toEqual({});
+	});
+
+	it("marks boolean flags as enabled", () => {
+		const v = argsToFlagValues(["--ide", "--dangerously-skip-permissions"]);
+		expect(v.ide).toEqual({ kind: "boolean", enabled: true });
+		expect(v["dangerously-skip-permissions"]).toEqual({
+			kind: "boolean",
+			enabled: true,
+		});
+	});
+
+	it("recognises tri-state on/off variants", () => {
+		expect(argsToFlagValues(["--chrome"])).toMatchObject({
+			chrome: { kind: "tri-state", state: "on" },
+		});
+		expect(argsToFlagValues(["--no-chrome"])).toMatchObject({
+			chrome: { kind: "tri-state", state: "off" },
+		});
+	});
+
+	it("reads a select flag with a known value", () => {
+		expect(argsToFlagValues(["--effort", "high"])).toMatchObject({
+			effort: { kind: "select", enabled: true, value: "high" },
+		});
+	});
+
+	it("treats a bare --tmux (no variant) as the empty-value select", () => {
+		expect(argsToFlagValues(["--worktree", "--tmux"])).toMatchObject({
+			worktree: { kind: "boolean", enabled: true },
+			tmux: { kind: "select", enabled: true, value: "" },
+		});
+	});
+
+	it("reads multi-with-custom comma-joined tokens, splitting picked vs custom", () => {
+		expect(argsToFlagValues(["--debug", "api,hooks,!file"])).toMatchObject({
+			debug: {
+				kind: "multi-with-custom",
+				enabled: true,
+				picked: ["api", "hooks"],
+				custom: ["!file"],
+			},
+		});
+	});
+
+	it("collects repeated --dangerously-load-development-channels values", () => {
+		expect(
+			argsToFlagValues([
+				"--dangerously-load-development-channels",
+				"plugin:claudish@magus",
+				"--dangerously-load-development-channels",
+				"plugin:dev@magus",
+			]),
+		).toMatchObject({
+			"dangerously-load-development-channels": {
+				kind: "text-list",
+				enabled: true,
+				values: ["plugin:claudish@magus", "plugin:dev@magus"],
+			},
+		});
+	});
+
+	it("reads a text flag's value", () => {
+		expect(
+			argsToFlagValues(["--append-system-prompt", "be terse"]),
+		).toMatchObject({
+			"append-system-prompt": {
+				kind: "text",
+				enabled: true,
+				value: "be terse",
+			},
+		});
+	});
+
+	it("recognises an optional-text flag in bare form (followed by another flag)", () => {
+		expect(argsToFlagValues(["--remote-control", "--ide"])).toMatchObject({
+			"remote-control": { kind: "boolean", enabled: true },
+			ide: { kind: "boolean", enabled: true },
+		});
+	});
+
+	it("silently skips unknown flag/value pairs without corrupting the rest", () => {
+		expect(
+			argsToFlagValues(["--unknown-future", "value", "--ide"]),
+		).toMatchObject({ ide: { kind: "boolean", enabled: true } });
+	});
 });
 
 describe("round-trip: render → parse → enabled subset matches", () => {
-  it("preserves a complex POSIX config end-to-end", () => {
-    const { parsed } = buildAndParse((c) => {
-      c.flags["dangerously-skip-permissions"] = {
-        kind: "boolean",
-        enabled: true,
-      };
-      c.flags["debug"] = {
-        kind: "multi-with-custom",
-        enabled: true,
-        picked: ["api", "hooks"],
-        custom: ["!file"],
-      };
-      c.flags["effort"] = { kind: "select", enabled: true, value: "high" };
-      c.flags["dangerously-load-development-channels"] = {
-        kind: "text-list",
-        enabled: true,
-        values: ["plugin:claudish@magus"],
-      };
-      c.flags["worktree"] = { kind: "boolean", enabled: true };
-      c.flags["tmux"] = { kind: "select", enabled: true, value: "classic" };
-    });
-    expect(parsed).not.toBeNull();
-    expect(parsed!.aliasName).toBe("c");
-
-    const f = parsed!.flags;
-    expect(f["dangerously-skip-permissions"]).toEqual({
-      kind: "boolean",
-      enabled: true,
-    });
-    expect(f["debug"]).toEqual({
-      kind: "multi-with-custom",
-      enabled: true,
-      picked: ["api", "hooks"],
-      custom: ["!file"],
-    });
-    expect(f["effort"]).toEqual({
-      kind: "select",
-      enabled: true,
-      value: "high",
-    });
-    expect(f["dangerously-load-development-channels"]).toEqual({
-      kind: "text-list",
-      enabled: true,
-      values: ["plugin:claudish@magus"],
-    });
-    expect(f["worktree"]).toEqual({ kind: "boolean", enabled: true });
-    expect(f["tmux"]).toEqual({
-      kind: "select",
-      enabled: true,
-      value: "classic",
-    });
-  });
-
-  it("preserves a templated remote-control prefix", () => {
-    const { parsed } = buildAndParse((c) => {
-      c.flags["remote-control-session-name-prefix"] = {
-        kind: "text",
-        enabled: true,
-        value: "dev-{folder}-{day}",
-      };
-    });
-    expect(parsed!.flags["remote-control-session-name-prefix"]).toEqual({
-      kind: "text",
-      enabled: true,
-      value: "dev-{folder}-{day}",
-    });
-  });
-
-  it("preserves a quoted text value with spaces", () => {
-    const { parsed } = buildAndParse((c) => {
-      c.flags["append-system-prompt"] = {
-        kind: "text",
-        enabled: true,
-        value: "be terse",
-      };
-    });
-    expect(parsed!.flags["append-system-prompt"]).toEqual({
-      kind: "text",
-      enabled: true,
-      value: "be terse",
-    });
-  });
-
-  it("preserves a custom aliasName", () => {
-    const { parsed } = buildAndParse((c) => {
-      c.aliasName = "cc";
-      c.flags["ide"] = { kind: "boolean", enabled: true };
-    });
-    expect(parsed!.aliasName).toBe("cc");
-    expect(parsed!.flags["ide"]).toEqual({ kind: "boolean", enabled: true });
-  });
+	it("preserves a complex POSIX config end-to-end", () => {
+		const { parsed } = buildAndParse((c) => {
+			c.flags["dangerously-skip-permissions"] = {
+				kind: "boolean",
+				enabled: true,
+			};
+			c.flags.debug = {
+				kind: "multi-with-custom",
+				enabled: true,
+				picked: ["api", "hooks"],
+				custom: ["!file"],
+			};
+			c.flags.effort = { kind: "select", enabled: true, value: "high" };
+			c.flags["dangerously-load-development-channels"] = {
+				kind: "text-list",
+				enabled: true,
+				values: ["plugin:claudish@magus"],
+			};
+			c.flags.worktree = { kind: "boolean", enabled: true };
+			c.flags.tmux = { kind: "select", enabled: true, value: "classic" };
+		});
+		expect(parsed).not.toBeNull();
+		expect(parsed!.aliasName).toBe("c");
+
+		const f = parsed!.flags;
+		expect(f["dangerously-skip-permissions"]).toEqual({
+			kind: "boolean",
+			enabled: true,
+		});
+		expect(f.debug).toEqual({
+			kind: "multi-with-custom",
+			enabled: true,
+			picked: ["api", "hooks"],
+			custom: ["!file"],
+		});
+		expect(f.effort).toEqual({
+			kind: "select",
+			enabled: true,
+			value: "high",
+		});
+		expect(f["dangerously-load-development-channels"]).toEqual({
+			kind: "text-list",
+			enabled: true,
+			values: ["plugin:claudish@magus"],
+		});
+		expect(f.worktree).toEqual({ kind: "boolean", enabled: true });
+		expect(f.tmux).toEqual({
+			kind: "select",
+			enabled: true,
+			value: "classic",
+		});
+	});
+
+	it("preserves a templated remote-control prefix", () => {
+		const { parsed } = buildAndParse((c) => {
+			c.flags["remote-control-session-name-prefix"] = {
+				kind: "text",
+				enabled: true,
+				value: "dev-{folder}-{day}",
+			};
+		});
+		expect(parsed!.flags["remote-control-session-name-prefix"]).toEqual({
+			kind: "text",
+			enabled: true,
+			value: "dev-{folder}-{day}",
+		});
+	});
+
+	it("preserves a quoted text value with spaces", () => {
+		const { parsed } = buildAndParse((c) => {
+			c.flags["append-system-prompt"] = {
+				kind: "text",
+				enabled: true,
+				value: "be terse",
+			};
+		});
+		expect(parsed!.flags["append-system-prompt"]).toEqual({
+			kind: "text",
+			enabled: true,
+			value: "be terse",
+		});
+	});
+
+	it("preserves a custom aliasName", () => {
+		const { parsed } = buildAndParse((c) => {
+			c.aliasName = "cc";
+			c.flags.ide = { kind: "boolean", enabled: true };
+		});
+		expect(parsed!.aliasName).toBe("cc");
+		expect(parsed!.flags.ide).toEqual({ kind: "boolean", enabled: true });
+	});
 });
 
 describe("channels: render-time union + parse-time provenance split", () => {
-  // The model: channels.values holds OWN channels only; dev-load values are
-  // unioned into --channels at render time and subtracted back out on parse,
-  // so the two lists stay distinct in storage but merge on the command line.
-
-  it("emits --channels as (own ∪ enabled dev-load), deduped, own-first", () => {
-    const c = defaultAliasConfig();
-    c.flags["channels"] = {
-      kind: "text-list",
-      enabled: true,
-      values: ["plugin:own@m"],
-    };
-    c.flags["dangerously-load-development-channels"] = {
-      kind: "text-list",
-      enabled: true,
-      values: ["plugin:dev@m", "plugin:own@m"], // overlap dedupes
-    };
-    const tokens = renderArgsAsTokens(c);
-    // --channels carries own + derived (deduped); dev-load still emits its own.
-    const channelsArgs = tokens
-      .map((t, i) => (tokens[i - 1] === "--channels" ? t : null))
-      .filter(Boolean);
-    expect(channelsArgs).toEqual(["plugin:own@m", "plugin:dev@m"]);
-  });
-
-  it("forces --channels to emit derived values even when own channels is OFF", () => {
-    const c = defaultAliasConfig();
-    c.flags["channels"] = { kind: "text-list", enabled: false, values: [] };
-    c.flags["dangerously-load-development-channels"] = {
-      kind: "text-list",
-      enabled: true,
-      values: ["plugin:dev@m"],
-    };
-    const tokens = renderArgsAsTokens(c);
-    expect(tokens).toContain("--channels");
-    const idx = tokens.indexOf("--channels");
-    expect(tokens[idx + 1]).toBe("plugin:dev@m");
-  });
-
-  it("does NOT emit --channels when both own and dev-load are empty/off", () => {
-    const c = defaultAliasConfig(); // both channels + dev-load default off
-    expect(renderArgsAsTokens(c)).not.toContain("--channels");
-  });
-
-  it("round-trips: derived values do NOT leak into parsed channels.values", () => {
-    const c = defaultAliasConfig();
-    c.aliasName = "c";
-    c.flags["channels"] = {
-      kind: "text-list",
-      enabled: true,
-      values: ["plugin:own@m"],
-    };
-    c.flags["dangerously-load-development-channels"] = {
-      kind: "text-list",
-      enabled: true,
-      values: ["plugin:dev@m"],
-    };
-    const rendered = renderAlias(c, "zsh").block;
-    const parsed = parseAliasFromRc(rendered);
-    // channels.values comes back as OWN ONLY — derived was subtracted.
-    expect(parsed!.flags["channels"]).toEqual({
-      kind: "text-list",
-      enabled: true,
-      values: ["plugin:own@m"],
-    });
-    // dev-load round-trips intact (it's the source of truth for derived).
-    expect(parsed!.flags["dangerously-load-development-channels"]).toEqual({
-      kind: "text-list",
-      enabled: true,
-      values: ["plugin:dev@m"],
-    });
-  });
-
-  it("round-trips a purely-derived channels list to disabled+empty own", () => {
-    const c = defaultAliasConfig();
-    c.aliasName = "c";
-    // No own channels; only dev-load.
-    c.flags["dangerously-load-development-channels"] = {
-      kind: "text-list",
-      enabled: true,
-      values: ["plugin:dev@m"],
-    };
-    const parsed = parseAliasFromRc(renderAlias(c, "zsh").block);
-    expect(parsed!.flags["channels"]).toEqual({
-      kind: "text-list",
-      enabled: false,
-      values: [],
-    });
-  });
+	// The model: channels.values holds OWN channels only; dev-load values are
+	// unioned into --channels at render time and subtracted back out on parse,
+	// so the two lists stay distinct in storage but merge on the command line.
+
+	it("emits --channels as (own ∪ enabled dev-load), deduped, own-first", () => {
+		const c = defaultAliasConfig();
+		c.flags.channels = {
+			kind: "text-list",
+			enabled: true,
+			values: ["plugin:own@m"],
+		};
+		c.flags["dangerously-load-development-channels"] = {
+			kind: "text-list",
+			enabled: true,
+			values: ["plugin:dev@m", "plugin:own@m"], // overlap dedupes
+		};
+		const tokens = renderArgsAsTokens(c);
+		// --channels carries own + derived (deduped); dev-load still emits its own.
+		const channelsArgs = tokens
+			.map((t, i) => (tokens[i - 1] === "--channels" ? t : null))
+			.filter(Boolean);
+		expect(channelsArgs).toEqual(["plugin:own@m", "plugin:dev@m"]);
+	});
+
+	it("forces --channels to emit derived values even when own channels is OFF", () => {
+		const c = defaultAliasConfig();
+		c.flags.channels = { kind: "text-list", enabled: false, values: [] };
+		c.flags["dangerously-load-development-channels"] = {
+			kind: "text-list",
+			enabled: true,
+			values: ["plugin:dev@m"],
+		};
+		const tokens = renderArgsAsTokens(c);
+		expect(tokens).toContain("--channels");
+		const idx = tokens.indexOf("--channels");
+		expect(tokens[idx + 1]).toBe("plugin:dev@m");
+	});
+
+	it("does NOT emit --channels when both own and dev-load are empty/off", () => {
+		const c = defaultAliasConfig(); // both channels + dev-load default off
+		expect(renderArgsAsTokens(c)).not.toContain("--channels");
+	});
+
+	it("round-trips: derived values do NOT leak into parsed channels.values", () => {
+		const c = defaultAliasConfig();
+		c.aliasName = "c";
+		c.flags.channels = {
+			kind: "text-list",
+			enabled: true,
+			values: ["plugin:own@m"],
+		};
+		c.flags["dangerously-load-development-channels"] = {
+			kind: "text-list",
+			enabled: true,
+			values: ["plugin:dev@m"],
+		};
+		const rendered = renderAlias(c, "zsh").block;
+		const parsed = parseAliasFromRc(rendered);
+		// channels.values comes back as OWN ONLY — derived was subtracted.
+		expect(parsed!.flags.channels).toEqual({
+			kind: "text-list",
+			enabled: true,
+			values: ["plugin:own@m"],
+		});
+		// dev-load round-trips intact (it's the source of truth for derived).
+		expect(parsed!.flags["dangerously-load-development-channels"]).toEqual({
+			kind: "text-list",
+			enabled: true,
+			values: ["plugin:dev@m"],
+		});
+	});
+
+	it("round-trips a purely-derived channels list to disabled+empty own", () => {
+		const c = defaultAliasConfig();
+		c.aliasName = "c";
+		// No own channels; only dev-load.
+		c.flags["dangerously-load-development-channels"] = {
+			kind: "text-list",
+			enabled: true,
+			values: ["plugin:dev@m"],
+		};
+		const parsed = parseAliasFromRc(renderAlias(c, "zsh").block);
+		expect(parsed!.flags.channels).toEqual({
+			kind: "text-list",
+			enabled: false,
+			values: [],
+		});
+	});
 });
 
 describe("parseAliasFromRc — entry point", () => {
-  it("returns null on text with no managed block", () => {
-    expect(parseAliasFromRc("export PATH=...\n")).toBeNull();
-  });
-
-  it("returns the alias name + flags for a well-formed block", () => {
-    const text =
-      "# >>> claudeup managed alias >>>\n" +
-      "alias c='claude --ide --effort high'\n" +
-      "# <<< claudeup managed alias <<<\n";
-    const r = parseAliasFromRc(text);
-    expect(r?.aliasName).toBe("c");
-    expect(r?.flags["ide"]).toEqual({ kind: "boolean", enabled: true });
-    expect(r?.flags["effort"]).toEqual({
-      kind: "select",
-      enabled: true,
-      value: "high",
-    });
-  });
+	it("returns null on text with no managed block", () => {
+		expect(parseAliasFromRc("export PATH=...\n")).toBeNull();
+	});
+
+	it("returns the alias name + flags for a well-formed block", () => {
+		const text =
+			"# >>> claudeup managed alias >>>\n" +
+			"alias c='claude --ide --effort high'\n" +
+			"# <<< claudeup managed alias <<<\n";
+		const r = parseAliasFromRc(text);
+		expect(r?.aliasName).toBe("c");
+		expect(r?.flags.ide).toEqual({ kind: "boolean", enabled: true });
+		expect(r?.flags.effort).toEqual({
+			kind: "select",
+			enabled: true,
+			value: "high",
+		});
+	});
 });