claudeup 6.2.1 → 6.3.0

package/src/__tests__/alias-shell-writer.test.ts

@@ -1,544 +1,549 @@
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { mkdtemp, rm, writeFile, readFile, mkdir } from "node:fs/promises";
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { spawnSync } from "node:child_process";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { spawnSync } from "node:child_process";
 import {
-  detectShells,
-  renderArgsAsTokens as renderArgs,
-  renderArgs as renderArgsSegments,
-  renderAlias,
-  spliceManagedBlock,
-  validateConfig,
-  writeAliasToShell,
-  findUnquotableTokens,
-  expandTemplateValue,
-  type ShellTarget,
-  type Segment,
+	type Segment,
+	type ShellTarget,
+	detectShells,
+	expandTemplateValue,
+	findUnquotableTokens,
+	renderAlias,
+	renderArgsAsTokens as renderArgs,
+	renderArgs as renderArgsSegments,
+	spliceManagedBlock,
+	validateConfig,
+	writeAliasToShell,
 } from "../services/alias-shell-writer";
 import { defaultAliasConfig } from "../services/alias-store";
 
 describe("renderArgs", () => {
-  it("emits nothing when every flag is at default (off)", () => {
-    expect(renderArgs(defaultAliasConfig())).toEqual([]);
-  });
-
-  it("renders boolean flags as bare tokens", () => {
-    const c = defaultAliasConfig();
-    c.flags["dangerously-skip-permissions"] = {
-      kind: "boolean",
-      enabled: true,
-    };
-    c.flags["ide"] = { kind: "boolean", enabled: true };
-    expect(renderArgs(c)).toEqual(["--dangerously-skip-permissions", "--ide"]);
-  });
-
-  it("renders tri-state on/off and skips unset", () => {
-    const c = defaultAliasConfig();
-    c.flags["chrome"] = { kind: "tri-state", state: "on" };
-    expect(renderArgs(c)).toEqual(["--chrome"]);
-    c.flags["chrome"] = { kind: "tri-state", state: "off" };
-    expect(renderArgs(c)).toEqual(["--no-chrome"]);
-    c.flags["chrome"] = { kind: "tri-state", state: "unset" };
-    expect(renderArgs(c)).toEqual([]);
-  });
-
-  it("renders select with value", () => {
-    const c = defaultAliasConfig();
-    c.flags["effort"] = { kind: "select", enabled: true, value: "high" };
-    expect(renderArgs(c)).toEqual(["--effort", "high"]);
-  });
-
-  it("renders select with empty value as bare flag", () => {
-    const c = defaultAliasConfig();
-    c.flags["worktree"] = { kind: "boolean", enabled: true };
-    c.flags["tmux"] = { kind: "select", enabled: true, value: "" };
-    expect(renderArgs(c)).toEqual(["--worktree", "--tmux"]);
-  });
-
-  it("enforces requires: --tmux is dropped without --worktree", () => {
-    const c = defaultAliasConfig();
-    c.flags["tmux"] = { kind: "select", enabled: true, value: "classic" };
-    expect(renderArgs(c)).toEqual([]);
-  });
-
-  it("admits --tmux once --worktree is enabled", () => {
-    const c = defaultAliasConfig();
-    c.flags["worktree"] = { kind: "boolean", enabled: true };
-    c.flags["tmux"] = { kind: "select", enabled: true, value: "classic" };
-    expect(renderArgs(c)).toEqual(["--worktree", "--tmux", "classic"]);
-  });
-
-  it("enforces xor: --system-prompt wins over --system-prompt-file", () => {
-    const c = defaultAliasConfig();
-    c.flags["system-prompt"] = {
-      kind: "text",
-      enabled: true,
-      value: "hello",
-    };
-    c.flags["system-prompt-file"] = {
-      kind: "text",
-      enabled: true,
-      value: "/tmp/p.txt",
-    };
-    const args = renderArgs(c);
-    expect(args).toEqual(["--system-prompt", "hello"]);
-  });
-
-  it("renders text-list as repeated flag/value pairs", () => {
-    const c = defaultAliasConfig();
-    c.flags["dangerously-load-development-channels"] = {
-      kind: "text-list",
-      enabled: true,
-      values: ["plugin:claudish@magus", "plugin:dev@magus"],
-    };
-    // Enabling dev-load also forces --channels to emit (the render-time union),
-    // since a dev-loaded channel must be on the channels list to run. --channels
-    // comes first (catalog order), then the repeated dev-load pairs.
-    expect(renderArgs(c)).toEqual([
-      "--channels",
-      "plugin:claudish@magus",
-      "--channels",
-      "plugin:dev@magus",
-      "--dangerously-load-development-channels",
-      "plugin:claudish@magus",
-      "--dangerously-load-development-channels",
-      "plugin:dev@magus",
-    ]);
-  });
-
-  it("renders multi-with-custom: picked tokens then custom, deduped, comma-joined", () => {
-    const c = defaultAliasConfig();
-    c.flags["debug"] = {
-      kind: "multi-with-custom",
-      enabled: true,
-      picked: ["api", "hooks"],
-      custom: ["!1p", "!file", "api"], // duplicate "api"
-    };
-    expect(renderArgs(c)).toEqual(["--debug", "api,hooks,!1p,!file"]);
-  });
-
-  it("renders multi-with-custom with no tokens as bare --debug", () => {
-    const c = defaultAliasConfig();
-    c.flags["debug"] = {
-      kind: "multi-with-custom",
-      enabled: true,
-      picked: [],
-      custom: [],
-    };
-    expect(renderArgs(c)).toEqual(["--debug"]);
-  });
-
-  it("renders --remote-control as a boolean toggle", () => {
-    const c = defaultAliasConfig();
-    c.flags["remote-control"] = { kind: "boolean", enabled: true };
-    expect(renderArgs(c)).toEqual(["--remote-control"]);
-    c.flags["remote-control"] = { kind: "boolean", enabled: false };
-    expect(renderArgs(c)).toEqual([]);
-  });
-
-  it("renders --remote-control alongside --remote-control-session-name-prefix", () => {
-    const c = defaultAliasConfig();
-    c.flags["remote-control"] = { kind: "boolean", enabled: true };
-    c.flags["remote-control-session-name-prefix"] = {
-      kind: "text",
-      enabled: true,
-      value: "jack-laptop",
-    };
-    expect(renderArgs(c)).toEqual([
-      "--remote-control",
-      "--remote-control-session-name-prefix",
-      "jack-laptop",
-    ]);
-  });
+	it("emits nothing when every flag is at default (off)", () => {
+		expect(renderArgs(defaultAliasConfig())).toEqual([]);
+	});
+
+	it("renders boolean flags as bare tokens", () => {
+		const c = defaultAliasConfig();
+		c.flags["dangerously-skip-permissions"] = {
+			kind: "boolean",
+			enabled: true,
+		};
+		c.flags.ide = { kind: "boolean", enabled: true };
+		expect(renderArgs(c)).toEqual(["--dangerously-skip-permissions", "--ide"]);
+	});
+
+	it("renders tri-state on/off and skips unset", () => {
+		const c = defaultAliasConfig();
+		c.flags.chrome = { kind: "tri-state", state: "on" };
+		expect(renderArgs(c)).toEqual(["--chrome"]);
+		c.flags.chrome = { kind: "tri-state", state: "off" };
+		expect(renderArgs(c)).toEqual(["--no-chrome"]);
+		c.flags.chrome = { kind: "tri-state", state: "unset" };
+		expect(renderArgs(c)).toEqual([]);
+	});
+
+	it("renders select with value", () => {
+		const c = defaultAliasConfig();
+		c.flags.effort = { kind: "select", enabled: true, value: "high" };
+		expect(renderArgs(c)).toEqual(["--effort", "high"]);
+	});
+
+	it("renders select with empty value as bare flag", () => {
+		const c = defaultAliasConfig();
+		c.flags.worktree = { kind: "boolean", enabled: true };
+		c.flags.tmux = { kind: "select", enabled: true, value: "" };
+		expect(renderArgs(c)).toEqual(["--worktree", "--tmux"]);
+	});
+
+	it("enforces requires: --tmux is dropped without --worktree", () => {
+		const c = defaultAliasConfig();
+		c.flags.tmux = { kind: "select", enabled: true, value: "classic" };
+		expect(renderArgs(c)).toEqual([]);
+	});
+
+	it("admits --tmux once --worktree is enabled", () => {
+		const c = defaultAliasConfig();
+		c.flags.worktree = { kind: "boolean", enabled: true };
+		c.flags.tmux = { kind: "select", enabled: true, value: "classic" };
+		expect(renderArgs(c)).toEqual(["--worktree", "--tmux", "classic"]);
+	});
+
+	it("enforces xor: --system-prompt wins over --system-prompt-file", () => {
+		const c = defaultAliasConfig();
+		c.flags["system-prompt"] = {
+			kind: "text",
+			enabled: true,
+			value: "hello",
+		};
+		c.flags["system-prompt-file"] = {
+			kind: "text",
+			enabled: true,
+			value: "/tmp/p.txt",
+		};
+		const args = renderArgs(c);
+		expect(args).toEqual(["--system-prompt", "hello"]);
+	});
+
+	it("renders text-list as repeated flag/value pairs", () => {
+		const c = defaultAliasConfig();
+		c.flags["dangerously-load-development-channels"] = {
+			kind: "text-list",
+			enabled: true,
+			values: ["plugin:claudish@magus", "plugin:dev@magus"],
+		};
+		// Enabling dev-load also forces --channels to emit (the render-time union),
+		// since a dev-loaded channel must be on the channels list to run. --channels
+		// comes first (catalog order), then the repeated dev-load pairs.
+		expect(renderArgs(c)).toEqual([
+			"--channels",
+			"plugin:claudish@magus",
+			"--channels",
+			"plugin:dev@magus",
+			"--dangerously-load-development-channels",
+			"plugin:claudish@magus",
+			"--dangerously-load-development-channels",
+			"plugin:dev@magus",
+		]);
+	});
+
+	it("renders multi-with-custom: picked tokens then custom, deduped, comma-joined", () => {
+		const c = defaultAliasConfig();
+		c.flags.debug = {
+			kind: "multi-with-custom",
+			enabled: true,
+			picked: ["api", "hooks"],
+			custom: ["!1p", "!file", "api"], // duplicate "api"
+		};
+		expect(renderArgs(c)).toEqual(["--debug", "api,hooks,!1p,!file"]);
+	});
+
+	it("renders multi-with-custom with no tokens as bare --debug", () => {
+		const c = defaultAliasConfig();
+		c.flags.debug = {
+			kind: "multi-with-custom",
+			enabled: true,
+			picked: [],
+			custom: [],
+		};
+		expect(renderArgs(c)).toEqual(["--debug"]);
+	});
+
+	it("renders --remote-control as a boolean toggle", () => {
+		const c = defaultAliasConfig();
+		c.flags["remote-control"] = { kind: "boolean", enabled: true };
+		expect(renderArgs(c)).toEqual(["--remote-control"]);
+		c.flags["remote-control"] = { kind: "boolean", enabled: false };
+		expect(renderArgs(c)).toEqual([]);
+	});
+
+	it("renders --remote-control alongside --remote-control-session-name-prefix", () => {
+		const c = defaultAliasConfig();
+		c.flags["remote-control"] = { kind: "boolean", enabled: true };
+		c.flags["remote-control-session-name-prefix"] = {
+			kind: "text",
+			enabled: true,
+			value: "jack-laptop",
+		};
+		expect(renderArgs(c)).toEqual([
+			"--remote-control",
+			"--remote-control-session-name-prefix",
+			"jack-laptop",
+		]);
+	});
 });
 
 describe("renderAlias — POSIX (zsh/bash)", () => {
-  it("emits an empty alias when no flags are enabled", () => {
-    const r = renderAlias(defaultAliasConfig(), "zsh");
-    expect(r.block).toContain("alias c='claude'");
-    expect(r.block).toMatch(/^# >>> claudeup managed alias >>>\n/);
-    expect(r.block).toMatch(/# <<< claudeup managed alias <<<\n$/);
-  });
-
-  it("uses the configured alias name", () => {
-    const c = defaultAliasConfig();
-    c.aliasName = "ccc";
-    c.flags["ide"] = { kind: "boolean", enabled: true };
-    const r = renderAlias(c, "zsh");
-    expect(r.block).toContain("alias ccc='claude --ide'");
-    const fish = renderAlias(c, "fish");
-    expect(fish.block).toContain("alias ccc 'claude");
-  });
-
-  it("emits bare flags without quoting", () => {
-    const c = defaultAliasConfig();
-    c.flags["dangerously-skip-permissions"] = {
-      kind: "boolean",
-      enabled: true,
-    };
-    c.flags["ide"] = { kind: "boolean", enabled: true };
-    const r = renderAlias(c, "zsh");
-    expect(r.block).toContain(
-      "alias c='claude --dangerously-skip-permissions --ide'",
-    );
-  });
-
-  it("quotes values with spaces using nested single-quote escapes", () => {
-    const c = defaultAliasConfig();
-    c.flags["append-system-prompt"] = {
-      kind: "text",
-      enabled: true,
-      value: "be terse",
-    };
-    const r = renderAlias(c, "zsh");
-    // The final alias body should contain: --append-system-prompt 'be terse'
-    // Encoded inside the outer single-quoted alias as:
-    //   --append-system-prompt '\''be terse'\''
-    expect(r.block).toContain(
-      "alias c='claude --append-system-prompt '\\''be terse'\\'''",
-    );
-  });
-
-  it("leaves comma- and slash-bearing simple values unquoted", () => {
-    const c = defaultAliasConfig();
-    c.flags["debug"] = {
-      kind: "multi-with-custom",
-      enabled: true,
-      picked: ["api", "hooks"],
-      custom: ["!file"],
-    };
-    c.flags["append-system-prompt-file"] = {
-      kind: "text",
-      enabled: true,
-      value: "/tmp/p.txt",
-    };
-    const r = renderAlias(c, "zsh");
-    expect(r.block).toContain("--debug api,hooks,!file");
-    expect(r.block).toContain("--append-system-prompt-file /tmp/p.txt");
-  });
+	it("emits an empty alias when no flags are enabled", () => {
+		const r = renderAlias(defaultAliasConfig(), "zsh");
+		expect(r.block).toContain("alias c='claude'");
+		expect(r.block).toMatch(/^# >>> claudeup managed alias >>>\n/);
+		expect(r.block).toMatch(/# <<< claudeup managed alias <<<\n$/);
+	});
+
+	it("uses the configured alias name", () => {
+		const c = defaultAliasConfig();
+		c.aliasName = "ccc";
+		c.flags.ide = { kind: "boolean", enabled: true };
+		const r = renderAlias(c, "zsh");
+		expect(r.block).toContain("alias ccc='claude --ide'");
+		const fish = renderAlias(c, "fish");
+		expect(fish.block).toContain("alias ccc 'claude");
+	});
+
+	it("emits bare flags without quoting", () => {
+		const c = defaultAliasConfig();
+		c.flags["dangerously-skip-permissions"] = {
+			kind: "boolean",
+			enabled: true,
+		};
+		c.flags.ide = { kind: "boolean", enabled: true };
+		const r = renderAlias(c, "zsh");
+		expect(r.block).toContain(
+			"alias c='claude --dangerously-skip-permissions --ide'",
+		);
+	});
+
+	it("quotes values with spaces using nested single-quote escapes", () => {
+		const c = defaultAliasConfig();
+		c.flags["append-system-prompt"] = {
+			kind: "text",
+			enabled: true,
+			value: "be terse",
+		};
+		const r = renderAlias(c, "zsh");
+		// The final alias body should contain: --append-system-prompt 'be terse'
+		// Encoded inside the outer single-quoted alias as:
+		//   --append-system-prompt '\''be terse'\''
+		expect(r.block).toContain(
+			"alias c='claude --append-system-prompt '\\''be terse'\\'''",
+		);
+	});
+
+	it("leaves comma- and slash-bearing simple values unquoted", () => {
+		const c = defaultAliasConfig();
+		c.flags.debug = {
+			kind: "multi-with-custom",
+			enabled: true,
+			picked: ["api", "hooks"],
+			custom: ["!file"],
+		};
+		c.flags["append-system-prompt-file"] = {
+			kind: "text",
+			enabled: true,
+			value: "/tmp/p.txt",
+		};
+		const r = renderAlias(c, "zsh");
+		expect(r.block).toContain("--debug api,hooks,!file");
+		expect(r.block).toContain("--append-system-prompt-file /tmp/p.txt");
+	});
 });
 
 describe("renderAlias — fish", () => {
-  it("uses fish syntax (no = sign)", () => {
-    const c = defaultAliasConfig();
-    c.flags["ide"] = { kind: "boolean", enabled: true };
-    const r = renderAlias(c, "fish");
-    // Outer fish alias: alias c 'claude '--ide''  (each arg fish-quoted)
-    expect(r.block).toContain("alias c 'claude");
-    expect(r.block).toContain("--ide");
-    expect(r.block).not.toContain("alias c='claude");
-  });
+	it("uses fish syntax (no = sign)", () => {
+		const c = defaultAliasConfig();
+		c.flags.ide = { kind: "boolean", enabled: true };
+		const r = renderAlias(c, "fish");
+		// Outer fish alias: alias c 'claude '--ide''  (each arg fish-quoted)
+		expect(r.block).toContain("alias c 'claude");
+		expect(r.block).toContain("--ide");
+		expect(r.block).not.toContain("alias c='claude");
+	});
 });
 
 describe("expandTemplateValue", () => {
-  it("returns a single literal when no tokens are present", () => {
-    expect(expandTemplateValue("plain-prefix")).toEqual([
-      { kind: "literal", text: "plain-prefix" },
-    ]);
-  });
-
-  it("splits literal/raw alternations for known tokens", () => {
-    expect(expandTemplateValue("dev-{folder}-{day}")).toEqual([
-      { kind: "literal", text: "dev-" },
-      { kind: "raw", posix: '$(basename "$PWD")', fish: "(basename $PWD)" },
-      { kind: "literal", text: "-" },
-      { kind: "raw", posix: "$(date +%d)", fish: "(date +%d)" },
-    ]);
-  });
-
-  it("ignores unknown {bracketed} sequences (passes through as literal)", () => {
-    expect(expandTemplateValue("dev-{unknown}-{folder}")).toEqual([
-      { kind: "literal", text: "dev-{unknown}-" },
-      { kind: "raw", posix: '$(basename "$PWD")', fish: "(basename $PWD)" },
-    ]);
-  });
-
-  it("handles a value that's just a token", () => {
-    expect(expandTemplateValue("{year}")).toEqual([
-      { kind: "raw", posix: "$(date +%Y)", fish: "(date +%Y)" },
-    ]);
-  });
+	it("returns a single literal when no tokens are present", () => {
+		expect(expandTemplateValue("plain-prefix")).toEqual([
+			{ kind: "literal", text: "plain-prefix" },
+		]);
+	});
+
+	it("splits literal/raw alternations for known tokens", () => {
+		expect(expandTemplateValue("dev-{folder}-{day}")).toEqual([
+			{ kind: "literal", text: "dev-" },
+			{ kind: "raw", posix: '$(basename "$PWD")', fish: "(basename $PWD)" },
+			{ kind: "literal", text: "-" },
+			{ kind: "raw", posix: "$(date +%d)", fish: "(date +%d)" },
+		]);
+	});
+
+	it("ignores unknown {bracketed} sequences (passes through as literal)", () => {
+		expect(expandTemplateValue("dev-{unknown}-{folder}")).toEqual([
+			{ kind: "literal", text: "dev-{unknown}-" },
+			{ kind: "raw", posix: '$(basename "$PWD")', fish: "(basename $PWD)" },
+		]);
+	});
+
+	it("handles a value that's just a token", () => {
+		expect(expandTemplateValue("{year}")).toEqual([
+			{ kind: "raw", posix: "$(date +%Y)", fish: "(date +%Y)" },
+		]);
+	});
 });
 
 describe("renderAlias — templated values", () => {
-  it("emits a composite POSIX segment with embedded substitutions", () => {
-    const c = defaultAliasConfig();
-    c.flags["remote-control"] = { kind: "boolean", enabled: true };
-    c.flags["remote-control-session-name-prefix"] = {
-      kind: "text",
-      enabled: true,
-      value: "dev-{folder}-{day}",
-    };
-    const r = renderAlias(c, "zsh");
-    // Expected pattern: alias c='claude --remote-control --remote-control-session-name-prefix dev-'"$(basename "$PWD")"'-'"$(date +%d)"''
-    expect(r.block).toContain("--remote-control-session-name-prefix");
-    expect(r.block).toContain('dev-\'"$(basename "$PWD")"\'-\'"$(date +%d)"\'');
-    // Sanity: no raw `{folder}` literal made it through.
-    expect(r.block).not.toContain("{folder}");
-    expect(r.block).not.toContain("{day}");
-  });
-
-  it("emits a composite fish segment with fish-style substitutions", () => {
-    const c = defaultAliasConfig();
-    c.flags["remote-control-session-name-prefix"] = {
-      kind: "text",
-      enabled: true,
-      value: "{folder}-{year}",
-    };
-    const r = renderAlias(c, "fish");
-    // Fish treats adjacent quoted strings inside an alias body as one arg,
-    // so the literal `-` between the two substitutions stays single-quoted.
-    expect(r.block).toContain('\'"(basename $PWD)"\'\'-\'\'"(date +%Y)"\'');
-  });
-
-  it("falls back to a plain literal when no tokens are present", () => {
-    const c = defaultAliasConfig();
-    c.flags["remote-control-session-name-prefix"] = {
-      kind: "text",
-      enabled: true,
-      value: "static-prefix",
-    };
-    const r = renderAlias(c, "zsh");
-    expect(r.block).toContain("--remote-control-session-name-prefix static-prefix");
-    expect(r.block).not.toContain('"');
-  });
+	it("emits a composite POSIX segment with embedded substitutions", () => {
+		const c = defaultAliasConfig();
+		c.flags["remote-control"] = { kind: "boolean", enabled: true };
+		c.flags["remote-control-session-name-prefix"] = {
+			kind: "text",
+			enabled: true,
+			value: "dev-{folder}-{day}",
+		};
+		const r = renderAlias(c, "zsh");
+		// Expected pattern: alias c='claude --remote-control --remote-control-session-name-prefix dev-'"$(basename "$PWD")"'-'"$(date +%d)"''
+		expect(r.block).toContain("--remote-control-session-name-prefix");
+		expect(r.block).toContain('dev-\'"$(basename "$PWD")"\'-\'"$(date +%d)"\'');
+		// Sanity: no raw `{folder}` literal made it through.
+		expect(r.block).not.toContain("{folder}");
+		expect(r.block).not.toContain("{day}");
+	});
+
+	it("emits a composite fish segment with fish-style substitutions", () => {
+		const c = defaultAliasConfig();
+		c.flags["remote-control-session-name-prefix"] = {
+			kind: "text",
+			enabled: true,
+			value: "{folder}-{year}",
+		};
+		const r = renderAlias(c, "fish");
+		// Fish treats adjacent quoted strings inside an alias body as one arg,
+		// so the literal `-` between the two substitutions stays single-quoted.
+		expect(r.block).toContain("'\"(basename $PWD)\"''-''\"(date +%Y)\"'");
+	});
+
+	it("falls back to a plain literal when no tokens are present", () => {
+		const c = defaultAliasConfig();
+		c.flags["remote-control-session-name-prefix"] = {
+			kind: "text",
+			enabled: true,
+			value: "static-prefix",
+		};
+		const r = renderAlias(c, "zsh");
+		expect(r.block).toContain(
+			"--remote-control-session-name-prefix static-prefix",
+		);
+		expect(r.block).not.toContain('"');
+	});
 });
 
 describe("findUnquotableTokens", () => {
-  it("flags any literal segment text containing a single quote", () => {
-    const segs: Segment[] = [
-      { kind: "literal", text: "foo" },
-      { kind: "literal", text: "it's" },
-      { kind: "literal", text: "bar" },
-    ];
-    expect(findUnquotableTokens(segs)).toEqual(["it's"]);
-    expect(
-      findUnquotableTokens([
-        { kind: "literal", text: "foo" },
-        { kind: "literal", text: "bar" },
-      ]),
-    ).toEqual([]);
-  });
-
-  it("walks composite segments and flags unquotable literal parts", () => {
-    const segs: Segment[] = [
-      {
-        kind: "composite",
-        parts: [
-          { kind: "literal", text: "ok-" },
-          { kind: "raw", posix: "$(date +%d)", fish: "(date +%d)" },
-          { kind: "literal", text: "it's" },
-        ],
-      },
-    ];
-    expect(findUnquotableTokens(segs)).toEqual(["it's"]);
-  });
+	it("flags any literal segment text containing a single quote", () => {
+		const segs: Segment[] = [
+			{ kind: "literal", text: "foo" },
+			{ kind: "literal", text: "it's" },
+			{ kind: "literal", text: "bar" },
+		];
+		expect(findUnquotableTokens(segs)).toEqual(["it's"]);
+		expect(
+			findUnquotableTokens([
+				{ kind: "literal", text: "foo" },
+				{ kind: "literal", text: "bar" },
+			]),
+		).toEqual([]);
+	});
+
+	it("walks composite segments and flags unquotable literal parts", () => {
+		const segs: Segment[] = [
+			{
+				kind: "composite",
+				parts: [
+					{ kind: "literal", text: "ok-" },
+					{ kind: "raw", posix: "$(date +%d)", fish: "(date +%d)" },
+					{ kind: "literal", text: "it's" },
+				],
+			},
+		];
+		expect(findUnquotableTokens(segs)).toEqual(["it's"]);
+	});
 });
 
 describe("spliceManagedBlock", () => {
-  const block = `# >>> claudeup managed alias >>>\nalias c='claude --ide'\n# <<< claudeup managed alias <<<\n`;
-
-  it("appends the block to an empty file", () => {
-    expect(spliceManagedBlock("", block)).toBe(block);
-  });
-
-  it("appends the block with separator when existing has content", () => {
-    const existing = "export PATH=$PATH:/usr/local/bin\n";
-    const result = spliceManagedBlock(existing, block);
-    expect(result.startsWith(existing)).toBe(true);
-    expect(result.endsWith(block)).toBe(true);
-    expect(result).toContain("\n\n# >>> claudeup managed alias >>>");
-  });
-
-  it("replaces an existing block in place without disturbing surrounding lines", () => {
-    const before = "alias ll='ls -la'\n";
-    const after = "export EDITOR=vim\n";
-    const oldBlock = `# >>> claudeup managed alias >>>\nalias c='claude --debug'\n# <<< claudeup managed alias <<<\n`;
-    const existing = before + oldBlock + after;
-    const result = spliceManagedBlock(existing, block);
-    expect(result).toBe(before + block + after);
-  });
-
-  it("is idempotent: writing the same block twice yields the same file", () => {
-    const once = spliceManagedBlock("", block);
-    const twice = spliceManagedBlock(once, block);
-    expect(twice).toBe(once);
-  });
-
-  it("recovers when the END marker is missing (truncated/edited block)", () => {
-    const truncated = `# >>> claudeup managed alias >>>\nalias c='claude --broken\n`;
-    const result = spliceManagedBlock(truncated, block);
-    expect(result).toBe(block);
-  });
-
-  it("preserves a stray hand-edit outside the block", () => {
-    const existing = `# user comment\nalias g='git'\n${block}# trailing comment\n`;
-    // Re-render with same block — surrounding text is preserved verbatim.
-    const result = spliceManagedBlock(existing, block);
-    expect(result).toBe(existing);
-  });
+	const block = `# >>> claudeup managed alias >>>\nalias c='claude --ide'\n# <<< claudeup managed alias <<<\n`;
+
+	it("appends the block to an empty file", () => {
+		expect(spliceManagedBlock("", block)).toBe(block);
+	});
+
+	it("appends the block with separator when existing has content", () => {
+		const existing = "export PATH=$PATH:/usr/local/bin\n";
+		const result = spliceManagedBlock(existing, block);
+		expect(result.startsWith(existing)).toBe(true);
+		expect(result.endsWith(block)).toBe(true);
+		expect(result).toContain("\n\n# >>> claudeup managed alias >>>");
+	});
+
+	it("replaces an existing block in place without disturbing surrounding lines", () => {
+		const before = "alias ll='ls -la'\n";
+		const after = "export EDITOR=vim\n";
+		const oldBlock = `# >>> claudeup managed alias >>>\nalias c='claude --debug'\n# <<< claudeup managed alias <<<\n`;
+		const existing = before + oldBlock + after;
+		const result = spliceManagedBlock(existing, block);
+		expect(result).toBe(before + block + after);
+	});
+
+	it("is idempotent: writing the same block twice yields the same file", () => {
+		const once = spliceManagedBlock("", block);
+		const twice = spliceManagedBlock(once, block);
+		expect(twice).toBe(once);
+	});
+
+	it("recovers when the END marker is missing (truncated/edited block)", () => {
+		const truncated = `# >>> claudeup managed alias >>>\nalias c='claude --broken\n`;
+		const result = spliceManagedBlock(truncated, block);
+		expect(result).toBe(block);
+	});
+
+	it("preserves a stray hand-edit outside the block", () => {
+		const existing = `# user comment\nalias g='git'\n${block}# trailing comment\n`;
+		// Re-render with same block — surrounding text is preserved verbatim.
+		const result = spliceManagedBlock(existing, block);
+		expect(result).toBe(existing);
+	});
 });
 
 describe("validateConfig", () => {
-  it("reports nothing for the default config", () => {
-    expect(validateConfig(defaultAliasConfig())).toEqual([]);
-  });
-
-  it("flags --tmux as requiring --worktree", () => {
-    const c = defaultAliasConfig();
-    c.flags["tmux"] = { kind: "select", enabled: true, value: "classic" };
-    const issues = validateConfig(c);
-    expect(issues).toEqual([
-      { flagId: "tmux", reason: expect.stringContaining("--worktree") },
-    ]);
-  });
-
-  it("flags xor losers when both system-prompt fields are set", () => {
-    const c = defaultAliasConfig();
-    c.flags["system-prompt"] = { kind: "text", enabled: true, value: "a" };
-    c.flags["system-prompt-file"] = {
-      kind: "text",
-      enabled: true,
-      value: "/x",
-    };
-    const issues = validateConfig(c);
-    expect(issues).toHaveLength(1);
-    expect(issues[0].flagId).toBe("system-prompt-file");
-  });
-
-  it("reports nothing once the dependency is satisfied", () => {
-    const c = defaultAliasConfig();
-    c.flags["worktree"] = { kind: "boolean", enabled: true };
-    c.flags["tmux"] = { kind: "select", enabled: true, value: "classic" };
-    expect(validateConfig(c)).toEqual([]);
-  });
+	it("reports nothing for the default config", () => {
+		expect(validateConfig(defaultAliasConfig())).toEqual([]);
+	});
+
+	it("flags --tmux as requiring --worktree", () => {
+		const c = defaultAliasConfig();
+		c.flags.tmux = { kind: "select", enabled: true, value: "classic" };
+		const issues = validateConfig(c);
+		expect(issues).toEqual([
+			{ flagId: "tmux", reason: expect.stringContaining("--worktree") },
+		]);
+	});
+
+	it("flags xor losers when both system-prompt fields are set", () => {
+		const c = defaultAliasConfig();
+		c.flags["system-prompt"] = { kind: "text", enabled: true, value: "a" };
+		c.flags["system-prompt-file"] = {
+			kind: "text",
+			enabled: true,
+			value: "/x",
+		};
+		const issues = validateConfig(c);
+		expect(issues).toHaveLength(1);
+		expect(issues[0].flagId).toBe("system-prompt-file");
+	});
+
+	it("reports nothing once the dependency is satisfied", () => {
+		const c = defaultAliasConfig();
+		c.flags.worktree = { kind: "boolean", enabled: true };
+		c.flags.tmux = { kind: "select", enabled: true, value: "classic" };
+		expect(validateConfig(c)).toEqual([]);
+	});
 });
 
 describe("detectShells", () => {
-  let home: string;
-
-  beforeEach(async () => {
-    home = await mkdtemp(join(tmpdir(), "alias-detect-"));
-  });
-
-  afterEach(async () => {
-    await rm(home, { recursive: true, force: true });
-  });
-
-  it("reports no shell as existing when none of the rc files are present", async () => {
-    const shells = await detectShells(home, "/bin/zsh");
-    expect(shells.map((s) => s.kind)).toEqual(["zsh", "bash", "fish"]);
-    expect(shells.every((s) => !s.exists)).toBe(true);
-    expect(shells.find((s) => s.kind === "zsh")?.isDefault).toBe(true);
-  });
-
-  it("marks rc files that exist", async () => {
-    await writeFile(join(home, ".zshrc"), "# zshrc\n", "utf8");
-    await mkdir(join(home, ".config", "fish"), { recursive: true });
-    await writeFile(
-      join(home, ".config", "fish", "config.fish"),
-      "# fish\n",
-      "utf8",
-    );
-    const shells = await detectShells(home, "/usr/local/bin/fish");
-    const byKind = Object.fromEntries(shells.map((s) => [s.kind, s]));
-    expect(byKind.zsh.exists).toBe(true);
-    expect(byKind.bash.exists).toBe(false);
-    expect(byKind.fish.exists).toBe(true);
-    expect(byKind.fish.isDefault).toBe(true);
-  });
+	let home: string;
+
+	beforeEach(async () => {
+		home = await mkdtemp(join(tmpdir(), "alias-detect-"));
+	});
+
+	afterEach(async () => {
+		await rm(home, { recursive: true, force: true });
+	});
+
+	it("reports no shell as existing when none of the rc files are present", async () => {
+		const shells = await detectShells(home, "/bin/zsh");
+		expect(shells.map((s) => s.kind)).toEqual(["zsh", "bash", "fish"]);
+		expect(shells.every((s) => !s.exists)).toBe(true);
+		expect(shells.find((s) => s.kind === "zsh")?.isDefault).toBe(true);
+	});
+
+	it("marks rc files that exist", async () => {
+		await writeFile(join(home, ".zshrc"), "# zshrc\n", "utf8");
+		await mkdir(join(home, ".config", "fish"), { recursive: true });
+		await writeFile(
+			join(home, ".config", "fish", "config.fish"),
+			"# fish\n",
+			"utf8",
+		);
+		const shells = await detectShells(home, "/usr/local/bin/fish");
+		const byKind = Object.fromEntries(shells.map((s) => [s.kind, s]));
+		expect(byKind.zsh.exists).toBe(true);
+		expect(byKind.bash.exists).toBe(false);
+		expect(byKind.fish.exists).toBe(true);
+		expect(byKind.fish.isDefault).toBe(true);
+	});
 });
 
 describe("writeAliasToShell — end-to-end", () => {
-  let home: string;
-
-  beforeEach(async () => {
-    home = await mkdtemp(join(tmpdir(), "alias-write-"));
-  });
-
-  afterEach(async () => {
-    await rm(home, { recursive: true, force: true });
-  });
-
-  it("creates the rc file when missing and writes the managed block", async () => {
-    const target: ShellTarget = {
-      kind: "zsh",
-      path: join(home, ".zshrc"),
-      exists: false,
-      isDefault: true,
-    };
-    const c = defaultAliasConfig();
-    c.flags["ide"] = { kind: "boolean", enabled: true };
-    const result = await writeAliasToShell(c, target);
-    expect(result.action).toBe("created");
-    const written = await readFile(target.path, "utf8");
-    expect(written).toContain("alias c='claude --ide'");
-    expect(written).toContain("# >>> claudeup managed alias >>>");
-  });
-
-  it("updates an existing rc file in place without losing surrounding content", async () => {
-    const path = join(home, ".zshrc");
-    await writeFile(
-      path,
-      "export PATH=$PATH:/opt/bin\nalias ll='ls -la'\n",
-      "utf8",
-    );
-    const target: ShellTarget = {
-      kind: "zsh",
-      path,
-      exists: true,
-      isDefault: true,
-    };
-    const c = defaultAliasConfig();
-    c.flags["ide"] = { kind: "boolean", enabled: true };
-    const result = await writeAliasToShell(c, target);
-    expect(result.action).toBe("updated");
-    const written = await readFile(path, "utf8");
-    expect(written).toContain("export PATH=$PATH:/opt/bin");
-    expect(written).toContain("alias ll='ls -la'");
-    expect(written).toContain("alias c='claude --ide'");
-  });
-
-  it("re-writing replaces (not duplicates) the managed block", async () => {
-    const path = join(home, ".zshrc");
-    const target: ShellTarget = {
-      kind: "zsh",
-      path,
-      exists: false,
-      isDefault: true,
-    };
-    const c = defaultAliasConfig();
-    c.flags["ide"] = { kind: "boolean", enabled: true };
-    await writeAliasToShell(c, target);
-    target.exists = true;
-    c.flags["ide"] = { kind: "boolean", enabled: false };
-    c.flags["dangerously-skip-permissions"] = { kind: "boolean", enabled: true };
-    await writeAliasToShell(c, target);
-    const written = await readFile(path, "utf8");
-    expect(written).toContain("--dangerously-skip-permissions");
-    expect(written).not.toContain("--ide");
-    // Block markers appear exactly once
-    const beginMatches = written.match(/# >>> claudeup managed alias >>>/g);
-    expect(beginMatches?.length).toBe(1);
-  });
-
-  it("rejects writes containing tokens with embedded single quotes", async () => {
-    const path = join(home, ".zshrc");
-    const target: ShellTarget = {
-      kind: "zsh",
-      path,
-      exists: false,
-      isDefault: true,
-    };
-    const c = defaultAliasConfig();
-    c.flags["append-system-prompt"] = {
-      kind: "text",
-      enabled: true,
-      value: "it's tricky",
-    };
-    await expect(writeAliasToShell(c, target)).rejects.toThrow(/single quote/);
-  });
+	let home: string;
+
+	beforeEach(async () => {
+		home = await mkdtemp(join(tmpdir(), "alias-write-"));
+	});
+
+	afterEach(async () => {
+		await rm(home, { recursive: true, force: true });
+	});
+
+	it("creates the rc file when missing and writes the managed block", async () => {
+		const target: ShellTarget = {
+			kind: "zsh",
+			path: join(home, ".zshrc"),
+			exists: false,
+			isDefault: true,
+		};
+		const c = defaultAliasConfig();
+		c.flags.ide = { kind: "boolean", enabled: true };
+		const result = await writeAliasToShell(c, target);
+		expect(result.action).toBe("created");
+		const written = await readFile(target.path, "utf8");
+		expect(written).toContain("alias c='claude --ide'");
+		expect(written).toContain("# >>> claudeup managed alias >>>");
+	});
+
+	it("updates an existing rc file in place without losing surrounding content", async () => {
+		const path = join(home, ".zshrc");
+		await writeFile(
+			path,
+			"export PATH=$PATH:/opt/bin\nalias ll='ls -la'\n",
+			"utf8",
+		);
+		const target: ShellTarget = {
+			kind: "zsh",
+			path,
+			exists: true,
+			isDefault: true,
+		};
+		const c = defaultAliasConfig();
+		c.flags.ide = { kind: "boolean", enabled: true };
+		const result = await writeAliasToShell(c, target);
+		expect(result.action).toBe("updated");
+		const written = await readFile(path, "utf8");
+		expect(written).toContain("export PATH=$PATH:/opt/bin");
+		expect(written).toContain("alias ll='ls -la'");
+		expect(written).toContain("alias c='claude --ide'");
+	});
+
+	it("re-writing replaces (not duplicates) the managed block", async () => {
+		const path = join(home, ".zshrc");
+		const target: ShellTarget = {
+			kind: "zsh",
+			path,
+			exists: false,
+			isDefault: true,
+		};
+		const c = defaultAliasConfig();
+		c.flags.ide = { kind: "boolean", enabled: true };
+		await writeAliasToShell(c, target);
+		target.exists = true;
+		c.flags.ide = { kind: "boolean", enabled: false };
+		c.flags["dangerously-skip-permissions"] = {
+			kind: "boolean",
+			enabled: true,
+		};
+		await writeAliasToShell(c, target);
+		const written = await readFile(path, "utf8");
+		expect(written).toContain("--dangerously-skip-permissions");
+		expect(written).not.toContain("--ide");
+		// Block markers appear exactly once
+		const beginMatches = written.match(/# >>> claudeup managed alias >>>/g);
+		expect(beginMatches?.length).toBe(1);
+	});
+
+	it("rejects writes containing tokens with embedded single quotes", async () => {
+		const path = join(home, ".zshrc");
+		const target: ShellTarget = {
+			kind: "zsh",
+			path,
+			exists: false,
+			isDefault: true,
+		};
+		const c = defaultAliasConfig();
+		c.flags["append-system-prompt"] = {
+			kind: "text",
+			enabled: true,
+			value: "it's tricky",
+		};
+		await expect(writeAliasToShell(c, target)).rejects.toThrow(/single quote/);
+	});
 });
 
 /**
@@ -547,122 +552,130 @@ describe("writeAliasToShell — end-to-end", () => {
  * pure byte-equality tests above would miss.
  */
 describe("end-to-end via bash subprocess", () => {
-  let home: string;
-
-  beforeEach(async () => {
-    home = await mkdtemp(join(tmpdir(), "alias-bash-"));
-  });
-
-  afterEach(async () => {
-    await rm(home, { recursive: true, force: true });
-  });
-
-  it("bash sources the emitted block and `alias claude` reports the right body", async () => {
-    if (spawnSync("bash", ["-c", "true"]).status !== 0) {
-      // No bash on the runner — skip.
-      return;
-    }
-    const path = join(home, ".bashrc");
-    const target: ShellTarget = {
-      kind: "bash",
-      path,
-      exists: false,
-      isDefault: true,
-    };
-    const c = defaultAliasConfig();
-    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["append-system-prompt"] = {
-      kind: "text",
-      enabled: true,
-      value: "be terse",
-    };
-    await writeAliasToShell(c, target);
-
-    const result = spawnSync(
-      "bash",
-      ["--noprofile", "--norc", "-c", `source ${path} && alias c`],
-      { encoding: "utf8" },
-    );
-    expect(result.status).toBe(0);
-    // Bash's `alias c` prints: alias c='<body>'
-    // We just check the rendered body contains the flag tokens correctly
-    // separated and the quoted prompt value preserved.
-    expect(result.stdout).toContain("--dangerously-skip-permissions");
-    expect(result.stdout).toContain("--debug api,hooks,!file");
-    expect(result.stdout).toContain("--append-system-prompt");
-    expect(result.stdout).toContain("be terse");
-  });
-
-  it("templated prefix expands at alias-expansion time, not at write time", async () => {
-    if (spawnSync("bash", ["-c", "true"]).status !== 0) return;
-
-    const path = join(home, ".bashrc");
-    const target: ShellTarget = {
-      kind: "bash",
-      path,
-      exists: false,
-      isDefault: true,
-    };
-    const c = defaultAliasConfig();
-    c.flags["remote-control"] = { kind: "boolean", enabled: true };
-    c.flags["remote-control-session-name-prefix"] = {
-      kind: "text",
-      enabled: true,
-      value: "dev-{folder}-{day}",
-    };
-    await writeAliasToShell(c, target);
-
-    // Replace the underlying `claude` binary with a stub that echoes its argv,
-    // then invoke the alias from inside a directory we control. The captured
-    // stdout shows what argv claude would have been called with — including
-    // the actual expansion of {folder} and {day} from the surrounding shell.
-    const probeDir = await mkdtemp(join(tmpdir(), "alias-probe-"));
-    const stubBin = join(probeDir, "bin");
-    await mkdir(stubBin, { recursive: true });
-    const stubPath = join(stubBin, "claude");
-    await writeFile(
-      stubPath,
-      '#!/usr/bin/env bash\nfor a in "$@"; do echo "ARG:$a"; done\n',
-      "utf8",
-    );
-    spawnSync("chmod", ["+x", stubPath]);
-    const cwdNamed = join(probeDir, "myproject");
-    await mkdir(cwdNamed, { recursive: true });
-
-    const result = spawnSync(
-      "bash",
-      [
-        "--noprofile",
-        "--norc",
-        "-O",
-        "expand_aliases",
-        "-c",
-        // Run with the stub on PATH and cwd inside myproject so {folder}
-        // expands to "myproject". `-O expand_aliases` enables alias expansion
-        // in non-interactive bash; `eval` defers parsing of `c` so the alias
-        // is visible when it's resolved (bash parses the whole -c argument
-        // up-front, so a bare `c` would be unknown at parse time).
-        `export PATH="${stubBin}:$PATH" && cd "${cwdNamed}" && source ${path} && eval c`,
-      ],
-      { encoding: "utf8" },
-    );
-    expect(result.status).toBe(0);
-    // The session-name-prefix arg should have been expanded to the literal
-    // string `dev-myproject-<two-digit-day>`.
-    const argLines = result.stdout.split("\n").filter((l) => l.startsWith("ARG:"));
-    const prefixArg = argLines.find((l) =>
-      argLines.indexOf(l) > 0 && argLines[argLines.indexOf(l) - 1] === "ARG:--remote-control-session-name-prefix",
-    );
-    expect(prefixArg).toBeDefined();
-    // Match `dev-myproject-NN` where NN is a 2-digit day.
-    expect(prefixArg).toMatch(/^ARG:dev-myproject-\d{2}$/);
-
-    await rm(probeDir, { recursive: true, force: true });
-  });
+	let home: string;
+
+	beforeEach(async () => {
+		home = await mkdtemp(join(tmpdir(), "alias-bash-"));
+	});
+
+	afterEach(async () => {
+		await rm(home, { recursive: true, force: true });
+	});
+
+	it("bash sources the emitted block and `alias claude` reports the right body", async () => {
+		if (spawnSync("bash", ["-c", "true"]).status !== 0) {
+			// No bash on the runner — skip.
+			return;
+		}
+		const path = join(home, ".bashrc");
+		const target: ShellTarget = {
+			kind: "bash",
+			path,
+			exists: false,
+			isDefault: true,
+		};
+		const c = defaultAliasConfig();
+		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["append-system-prompt"] = {
+			kind: "text",
+			enabled: true,
+			value: "be terse",
+		};
+		await writeAliasToShell(c, target);
+
+		const result = spawnSync(
+			"bash",
+			["--noprofile", "--norc", "-c", `source ${path} && alias c`],
+			{ encoding: "utf8" },
+		);
+		expect(result.status).toBe(0);
+		// Bash's `alias c` prints: alias c='<body>'
+		// We just check the rendered body contains the flag tokens correctly
+		// separated and the quoted prompt value preserved.
+		expect(result.stdout).toContain("--dangerously-skip-permissions");
+		expect(result.stdout).toContain("--debug api,hooks,!file");
+		expect(result.stdout).toContain("--append-system-prompt");
+		expect(result.stdout).toContain("be terse");
+	});
+
+	it("templated prefix expands at alias-expansion time, not at write time", async () => {
+		if (spawnSync("bash", ["-c", "true"]).status !== 0) return;
+
+		const path = join(home, ".bashrc");
+		const target: ShellTarget = {
+			kind: "bash",
+			path,
+			exists: false,
+			isDefault: true,
+		};
+		const c = defaultAliasConfig();
+		c.flags["remote-control"] = { kind: "boolean", enabled: true };
+		c.flags["remote-control-session-name-prefix"] = {
+			kind: "text",
+			enabled: true,
+			value: "dev-{folder}-{day}",
+		};
+		await writeAliasToShell(c, target);
+
+		// Replace the underlying `claude` binary with a stub that echoes its argv,
+		// then invoke the alias from inside a directory we control. The captured
+		// stdout shows what argv claude would have been called with — including
+		// the actual expansion of {folder} and {day} from the surrounding shell.
+		const probeDir = await mkdtemp(join(tmpdir(), "alias-probe-"));
+		const stubBin = join(probeDir, "bin");
+		await mkdir(stubBin, { recursive: true });
+		const stubPath = join(stubBin, "claude");
+		await writeFile(
+			stubPath,
+			'#!/usr/bin/env bash\nfor a in "$@"; do echo "ARG:$a"; done\n',
+			"utf8",
+		);
+		spawnSync("chmod", ["+x", stubPath]);
+		const cwdNamed = join(probeDir, "myproject");
+		await mkdir(cwdNamed, { recursive: true });
+
+		const result = spawnSync(
+			"bash",
+			[
+				"--noprofile",
+				"--norc",
+				"-O",
+				"expand_aliases",
+				"-c",
+				// Run with the stub on PATH and cwd inside myproject so {folder}
+				// expands to "myproject". `-O expand_aliases` enables alias expansion
+				// in non-interactive bash; `eval` defers parsing of `c` so the alias
+				// is visible when it's resolved (bash parses the whole -c argument
+				// up-front, so a bare `c` would be unknown at parse time).
+				`export PATH="${stubBin}:$PATH" && cd "${cwdNamed}" && source ${path} && eval c`,
+			],
+			{ encoding: "utf8" },
+		);
+		expect(result.status).toBe(0);
+		// The session-name-prefix arg should have been expanded to the literal
+		// string `dev-myproject-<two-digit-day>`.
+		const argLines = result.stdout
+			.split("\n")
+			.filter((l) => l.startsWith("ARG:"));
+		const prefixArg = argLines.find(
+			(l) =>
+				argLines.indexOf(l) > 0 &&
+				argLines[argLines.indexOf(l) - 1] ===
+					"ARG:--remote-control-session-name-prefix",
+		);
+		expect(prefixArg).toBeDefined();
+		// Match `dev-myproject-NN` where NN is a 2-digit day.
+		expect(prefixArg).toMatch(/^ARG:dev-myproject-\d{2}$/);
+
+		await rm(probeDir, { recursive: true, force: true });
+	});
 });