magus-cli 7.5.2 → 7.5.4

package/src/__tests__/cli-profile-prompts.test.ts

@@ -0,0 +1,1165 @@
+/**
+ * Spec 7.5.4 v3 — REQ-1, REQ-2, REQ-3, REQ-5 and REQ-6.
+ *
+ * Written blind: from the spec and the exported signatures only, never from the
+ * implementation. Every assertion is on something a user can observe — a return
+ * value, a line printed, a file written or left alone.
+ *
+ * Anything that could read `~/.claude` (REQ-3, REQ-5) runs in a CHILD process that
+ * starts with HOME, CLAUDE_CONFIG_DIR and XDG_* already pointing at temp dirs: Bun's
+ * `os.homedir()` ignores a HOME changed at runtime, so an in-process test could read
+ * the real home of whoever runs it. The child captures console.log / console.error
+ * (and raw stdout / stderr writes) in its own process, with colours disabled, and
+ * hands the output and the resolved value back through a result file.
+ *
+ * The child's PATH carries only `bun` and `git`. A test must not reach a real
+ * `claude` CLI, whatever the code under test does.
+ *
+ * Helper scripts are written to a mkdtemp dir at runtime and removed afterwards.
+ */
+import {
+	afterAll,
+	afterEach,
+	beforeAll,
+	describe,
+	expect,
+	test,
+} from "bun:test";
+import { readdirSync } from "node:fs";
+import {
+	mkdir,
+	mkdtemp,
+	readFile,
+	readdir,
+	realpath,
+	rm,
+	symlink,
+	writeFile,
+} from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, dirname, join, relative } from "node:path";
+import { setColorEnabled } from "../cli/ansi.js";
+import {
+	type SelectKeypress,
+	type SelectStep,
+	selectKey,
+} from "../cli/select.js";
+import {
+	noteBlock,
+	question,
+	selectDone,
+	selectFrame,
+} from "../cli/update-view.js";
+import { findEnclosingManifest } from "../services/manifest.js";
+
+// ---------------------------------------------------------------------------
+// Shared scaffolding
+// ---------------------------------------------------------------------------
+
+const SRC = join(import.meta.dir, "..");
+const MODULES = {
+	ansi: join(SRC, "cli", "ansi.ts"),
+	bootstrap: join(SRC, "cli", "bootstrap.ts"),
+	prompt: join(SRC, "cli", "prompt.ts"),
+	select: join(SRC, "cli", "select.ts"),
+};
+
+/** A child that has not finished by then is killed; the test then fails on its output. */
+const CHILD_TIMEOUT_MS = 45_000;
+/** Per-test budget for anything that spawns a child. */
+const CHILD_TEST_TIMEOUT_MS = 60_000;
+
+const scratch: string[] = [];
+
+/** A fresh directory under os.tmpdir(), passed through realpath (macOS /var → /private/var). */
+async function tempRoot(prefix: string): Promise<string> {
+	const dir = await realpath(await mkdtemp(join(tmpdir(), prefix)));
+	scratch.push(dir);
+	return dir;
+}
+
+async function writeJson(path: string, value: unknown): Promise<void> {
+	await mkdir(dirname(path), { recursive: true });
+	await writeFile(path, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function countOf(haystack: string, needle: string): number {
+	return haystack.split(needle).length - 1;
+}
+
+function linesOf(text: string): string[] {
+	return text.split("\n");
+}
+
+afterAll(async () => {
+	for (const dir of scratch) await rm(dir, { recursive: true, force: true });
+});
+
+// ---------------------------------------------------------------------------
+// Child-process harness (REQ-2b, REQ-3, REQ-5, REQ-6d)
+// ---------------------------------------------------------------------------
+
+/**
+ * Calls `bootstrap[fn](project, opts)` with stdin/stdout/stderr forced non-TTY and colours
+ * off, capturing everything printed, in order, into one buffer.
+ */
+const BOOTSTRAP_CHILD = `
+import { writeFileSync } from "node:fs";
+import { format } from "node:util";
+
+const [fn, project, optsJson, resultPath] = process.argv.slice(2);
+const ansi = await import(${JSON.stringify(MODULES.ansi)});
+const bootstrap = await import(${JSON.stringify(MODULES.bootstrap)});
+
+ansi.setColorEnabled(false);
+for (const stream of [process.stdin, process.stdout, process.stderr]) {
+	Object.defineProperty(stream, "isTTY", { value: false, configurable: true });
+}
+
+const chunks = [];
+const decode = (chunk) =>
+	typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk);
+const capture = (...args) => {
+	chunks.push(format(...args) + "\\n");
+};
+console.log = capture;
+console.error = capture;
+console.warn = capture;
+console.info = capture;
+const captureWrite = (chunk, ...rest) => {
+	chunks.push(decode(chunk));
+	const done = rest.find((arg) => typeof arg === "function");
+	if (done) done();
+	return true;
+};
+process.stdout.write = captureWrite;
+process.stderr.write = captureWrite;
+
+let result = null;
+let error = null;
+try {
+	const value = await bootstrap[fn](project, JSON.parse(optsJson));
+	result = value === undefined ? null : value;
+} catch (e) {
+	error = e instanceof Error ? (e.stack ?? e.message) : String(e);
+}
+writeFileSync(
+	resultPath,
+	JSON.stringify({ result, error, output: chunks.join("") }),
+);
+process.exit(0);
+`;
+
+/** Calls askYesNo with a marker prompt and prints the result after it. */
+const PROMPT_CHILD = `
+const [promptText] = process.argv.slice(2);
+const prompt = await import(${JSON.stringify(MODULES.prompt)});
+const value = await prompt.askYesNo(promptText);
+process.stdout.write("\\n__RESULT__" + JSON.stringify(value === undefined ? null : value) + "\\n");
+process.exit(0);
+`;
+
+/**
+ * Calls selectOption and prints what it resolved to. `undefined` is reported as the
+ * string "undefined", so it can never pass for the `null` REQ-6d requires.
+ */
+const SELECT_CHILD = `
+const select = await import(${JSON.stringify(MODULES.select)});
+const value = await select.selectOption(
+	"Choose a profile",
+	[{ label: "Save" }, { label: "Activate Lean", meta: "4 plugins" }, { label: "Quit" }],
+	1,
+);
+process.stdout.write("\\n__RESULT__" + JSON.stringify(value === undefined ? "undefined" : value) + "\\n");
+process.exit(0);
+`;
+
+let helperDir = "";
+let binDir = "";
+
+beforeAll(async () => {
+	helperDir = await tempRoot("cpp-helpers-");
+	binDir = join(helperDir, "bin");
+	await mkdir(binDir);
+	await symlink(process.execPath, join(binDir, "bun"));
+	const git = Bun.which("git");
+	if (git) await symlink(git, join(binDir, "git"));
+	await writeFile(join(helperDir, "bootstrap-child.ts"), BOOTSTRAP_CHILD);
+	await writeFile(join(helperDir, "prompt-child.ts"), PROMPT_CHILD);
+	await writeFile(join(helperDir, "select-child.ts"), SELECT_CHILD);
+});
+
+interface Sandbox {
+	base: string;
+	home: string;
+	env: Record<string, string>;
+}
+
+/** HOME, CLAUDE_CONFIG_DIR and XDG_* in temp dirs. CLAUDE_CONFIG_DIR is `<HOME>/.claude`. */
+async function sandbox(): Promise<Sandbox> {
+	const base = await tempRoot("cpp-");
+	const home = join(base, "home");
+	const xdg = join(base, "xdg");
+	await mkdir(join(home, ".claude"), { recursive: true });
+	for (const kind of ["config", "cache", "data", "state"]) {
+		await mkdir(join(xdg, kind), { recursive: true });
+	}
+	return {
+		base,
+		home,
+		env: {
+			PATH: `${binDir}:/usr/bin:/bin`,
+			HOME: home,
+			CLAUDE_CONFIG_DIR: join(home, ".claude"),
+			XDG_CONFIG_HOME: join(xdg, "config"),
+			XDG_CACHE_HOME: join(xdg, "cache"),
+			XDG_DATA_HOME: join(xdg, "data"),
+			XDG_STATE_HOME: join(xdg, "state"),
+			TMPDIR: tmpdir(),
+			NO_COLOR: "1",
+			TERM: "dumb",
+			GIT_CONFIG_NOSYSTEM: "1",
+			GIT_CONFIG_GLOBAL: "/dev/null",
+		},
+	};
+}
+
+interface ChildRun {
+	code: number;
+	stdout: string;
+	stderr: string;
+	/** True when the child had to be killed at the deadline. */
+	timedOut: boolean;
+}
+
+async function runChild(
+	args: string[],
+	opts: {
+		env: Record<string, string>;
+		cwd: string;
+		input?: string;
+		/**
+		 * Give the child a stdin pipe that is never written to and never closed, so a
+		 * child that waits for input can only finish by being killed at the deadline.
+		 */
+		holdStdinOpen?: boolean;
+		timeoutMs?: number;
+	},
+): Promise<ChildRun> {
+	const proc = Bun.spawn({
+		cmd: [process.execPath, "--no-env-file", ...args],
+		cwd: opts.cwd,
+		env: opts.env,
+		stdin: opts.holdStdinOpen
+			? "pipe"
+			: opts.input === undefined
+				? "ignore"
+				: new Blob([opts.input]),
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+	let timedOut = false;
+	const timer = setTimeout(() => {
+		timedOut = true;
+		proc.kill();
+	}, opts.timeoutMs ?? CHILD_TIMEOUT_MS);
+	const [stdout, stderr, code] = await Promise.all([
+		new Response(proc.stdout).text(),
+		new Response(proc.stderr).text(),
+		proc.exited,
+	]);
+	clearTimeout(timer);
+	if (opts.holdStdinOpen && proc.stdin && typeof proc.stdin !== "number") {
+		try {
+			proc.stdin.end();
+		} catch {
+			// The child is gone; its pipe may already be closed.
+		}
+	}
+	return { code, stdout, stderr, timedOut };
+}
+
+interface BootstrapRun {
+	result: unknown;
+	error: string | null;
+	output: string;
+	lines: string[];
+}
+
+async function callBootstrap(
+	sb: Sandbox,
+	fn: "ensureManifest" | "profileGate",
+	project: string,
+	opts: Record<string, unknown>,
+): Promise<BootstrapRun> {
+	const resultPath = join(sb.base, `result-${fn}-${Date.now()}.json`);
+	const child = await runChild(
+		[
+			join(helperDir, "bootstrap-child.ts"),
+			fn,
+			project,
+			JSON.stringify(opts),
+			resultPath,
+		],
+		{ env: sb.env, cwd: project },
+	);
+	let raw: string;
+	try {
+		raw = await readFile(resultPath, "utf8");
+	} catch {
+		throw new Error(
+			`${fn} child wrote no result (exit ${child.code}).\nstdout:\n${child.stdout}\nstderr:\n${child.stderr}`,
+		);
+	}
+	const parsed = JSON.parse(raw) as Omit<BootstrapRun, "lines">;
+	return { ...parsed, lines: linesOf(parsed.output) };
+}
+
+interface PromptRun {
+	stdout: string;
+	value: unknown;
+}
+
+async function callPrompt(
+	promptText: string,
+	input: string,
+): Promise<PromptRun> {
+	const sb = await sandbox();
+	const child = await runChild(
+		[join(helperDir, "prompt-child.ts"), promptText],
+		{ env: sb.env, cwd: sb.base, input },
+	);
+	const match = /__RESULT__(.*)$/m.exec(child.stdout);
+	if (!match) {
+		throw new Error(
+			`askYesNo child printed no result (exit ${child.code}).\nstdout:\n${child.stdout}\nstderr:\n${child.stderr}`,
+		);
+	}
+	return {
+		stdout: child.stdout.slice(0, match.index),
+		value: JSON.parse(match[1] as string),
+	};
+}
+
+/** Every directory and file under `root`, with file contents, for a byte-level compare. */
+async function snapshotTree(root: string): Promise<Record<string, string>> {
+	const out: Record<string, string> = {};
+	async function walk(dir: string): Promise<void> {
+		const entries = await readdir(dir, { withFileTypes: true });
+		for (const entry of entries) {
+			const full = join(dir, entry.name);
+			const rel = relative(root, full);
+			if (entry.isDirectory()) {
+				out[`${rel}/`] = "<dir>";
+				await walk(full);
+			} else {
+				out[rel] = (await readFile(full)).toString("base64");
+			}
+		}
+	}
+	await walk(root);
+	return out;
+}
+
+const TWO_PLUGINS = {
+	enabledPlugins: { "dev@magus": true, "claudish@magus": true },
+};
+
+/** A project directory with its own `.claude/settings.json` and, by default, a `.git` dir. */
+async function makeProject(
+	dir: string,
+	settings: unknown = TWO_PLUGINS,
+	withGitDir = true,
+): Promise<string> {
+	await mkdir(dir, { recursive: true });
+	if (withGitDir) await mkdir(join(dir, ".git"), { recursive: true });
+	await writeJson(join(dir, ".claude", "settings.json"), settings);
+	return dir;
+}
+
+/**
+ * A project that is its own repo root (it carries the `.git`), so no ancestor inside its
+ * repo can hold a `.claude/profiles.json`. REQ-3b/3d/3d2/3e use this so that REQ-3c's
+ * "inside a project that already has profiles" branch cannot stop them.
+ */
+function standaloneProject(
+	sb: Sandbox,
+	settings: unknown = TWO_PLUGINS,
+): Promise<string> {
+	return makeProject(join(sb.base, "proj"), settings);
+}
+
+const TEAM_MANIFEST = {
+	version: 2,
+	profiles: { team: { name: "team", plugins: { "dev@magus": true } } },
+};
+
+/**
+ * Output with every run of whitespace collapsed to one space, for phrase checks: the CLI
+ * wraps long lines to the terminal, so a sentence may legitimately span two lines.
+ */
+function flatten(text: string): string {
+	return text.replace(/\s+/g, " ");
+}
+
+// ---------------------------------------------------------------------------
+// REQ-1 findEnclosingManifest
+// ---------------------------------------------------------------------------
+
+describe("REQ-1 findEnclosingManifest", () => {
+	async function manifestAt(dir: string): Promise<void> {
+		await writeJson(join(dir, ".claude", "profiles.json"), TEAM_MANIFEST);
+	}
+
+	test("REQ-1a returns the repo root for a subdirectory when the root has profiles.json", async () => {
+		const root = await tempRoot("req1a-");
+		await mkdir(join(root, ".git"));
+		await manifestAt(root);
+		const sub = join(root, "sub");
+		await mkdir(sub);
+
+		expect(await findEnclosingManifest(sub)).toBe(root);
+	});
+
+	test("REQ-1a returns the root from several levels down", async () => {
+		const root = await tempRoot("req1a-deep-");
+		await mkdir(join(root, ".git"));
+		await manifestAt(root);
+		const deep = join(root, "a", "b", "c");
+		await mkdir(deep, { recursive: true });
+
+		expect(await findEnclosingManifest(deep)).toBe(root);
+	});
+
+	test("REQ-1b the nearest ancestor with a manifest wins", async () => {
+		const root = await tempRoot("req1b-");
+		await mkdir(join(root, ".git"));
+		await manifestAt(root);
+		const middle = join(root, "packages");
+		await manifestAt(middle);
+		const project = join(middle, "app", "web");
+		await mkdir(project, { recursive: true });
+
+		expect(await findEnclosingManifest(project)).toBe(middle);
+	});
+
+	test("REQ-1c returns null when projectPath itself has a .git directory, even with a manifest above", async () => {
+		const top = await tempRoot("req1c-dir-");
+		await mkdir(join(top, ".git"));
+		await manifestAt(top);
+		const nested = join(top, "nested");
+		await mkdir(join(nested, ".git"), { recursive: true });
+
+		expect(await findEnclosingManifest(nested)).toBeNull();
+	});
+
+	test("REQ-1c returns null when projectPath itself has a .git FILE (worktree/submodule)", async () => {
+		const top = await tempRoot("req1c-file-");
+		await mkdir(join(top, ".git"));
+		await manifestAt(top);
+		const nested = join(top, "nested");
+		await mkdir(nested);
+		await writeFile(
+			join(nested, ".git"),
+			"gitdir: /nowhere/.git/worktrees/x\n",
+		);
+
+		expect(await findEnclosingManifest(nested)).toBeNull();
+	});
+
+	test("REQ-1d never searches above a directory containing .git", async () => {
+		const outer = await tempRoot("req1d-");
+		await mkdir(join(outer, ".git"));
+		await manifestAt(outer);
+		const repo = join(outer, "repo");
+		await mkdir(join(repo, ".git"), { recursive: true });
+		const sub = join(repo, "sub");
+		await mkdir(sub);
+
+		expect(await findEnclosingManifest(sub)).toBeNull();
+	});
+
+	test("REQ-1e returns an ancestor that has both .git and profiles.json", async () => {
+		const root = await tempRoot("req1e-");
+		await mkdir(join(root, ".git"));
+		await manifestAt(root);
+		const project = join(root, "tools", "cli");
+		await mkdir(project, { recursive: true });
+
+		expect(await findEnclosingManifest(project)).toBe(root);
+	});
+
+	test("REQ-1f returns null when no ancestor up to the repo root has a manifest", async () => {
+		const root = await tempRoot("req1f-");
+		await mkdir(join(root, ".git"));
+		const project = join(root, "a", "b");
+		await mkdir(project, { recursive: true });
+
+		expect(await findEnclosingManifest(project)).toBeNull();
+	});
+
+	test("REQ-1g projectPath's own manifest does not count", async () => {
+		const root = await tempRoot("req1g-");
+		await mkdir(join(root, ".git"));
+		const project = join(root, "sub");
+		await manifestAt(project);
+
+		expect(await findEnclosingManifest(project)).toBeNull();
+	});
+
+	test("REQ-1g with manifests at both projectPath and an ancestor, the ancestor is returned", async () => {
+		const root = await tempRoot("req1g-both-");
+		await mkdir(join(root, ".git"));
+		await manifestAt(root);
+		const project = join(root, "sub");
+		await manifestAt(project);
+
+		expect(await findEnclosingManifest(project)).toBe(root);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// REQ-2a question (in-process, colours off)
+// ---------------------------------------------------------------------------
+
+describe("REQ-2a question with colours off", () => {
+	afterEach(() => {
+		setColorEnabled(null);
+	});
+
+	test('REQ-2a question("Install this plan?") is exactly "  ?  Install this plan?  [Y/n] "', () => {
+		setColorEnabled(false);
+
+		expect(question("Install this plan?")).toBe(
+			"  ?  Install this plan?  [Y/n] ",
+		);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// REQ-2b askYesNo (child process, piped stdin)
+// ---------------------------------------------------------------------------
+
+describe("REQ-2b askYesNo", () => {
+	const cases: Array<[label: string, input: string, expected: boolean]> = [
+		["y", "y\n", true],
+		["Y", "Y\n", true],
+		["yes", "yes\n", true],
+		["an empty line", "\n", true],
+		["n", "n\n", false],
+		["no", "no\n", false],
+		["anything else (maybe)", "maybe\n", false],
+	];
+
+	for (const [label, input, expected] of cases) {
+		test(
+			`REQ-2b answers ${expected} for ${label}, writing the prompt once with nothing appended`,
+			async () => {
+				const run = await callPrompt("PROMPT>", input);
+
+				expect(run.value).toBe(expected);
+				expect(countOf(run.stdout, "PROMPT>")).toBe(1);
+				expect(run.stdout).not.toContain("[Y/n]");
+			},
+			CHILD_TEST_TIMEOUT_MS,
+		);
+	}
+});
+
+// ---------------------------------------------------------------------------
+// REQ-6 choosing from a list: an arrow-key list in the terminal, no TUI
+// ---------------------------------------------------------------------------
+
+const PROFILE_OPTIONS = [
+	{ label: "Save" },
+	{ label: "Activate Lean", meta: "4 plugins" },
+	{ label: "Quit" },
+];
+
+describe("REQ-6a / REQ-6b / REQ-6f the list's frames with colours off", () => {
+	afterEach(() => {
+		setColorEnabled(null);
+	});
+
+	test("REQ-6a selectFrame draws title, padded rows with ❯ on the selected one, and the key hint — exactly", () => {
+		setColorEnabled(false);
+
+		expect(selectFrame("Choose a profile", PROFILE_OPTIONS, 1)).toEqual([
+			"  ?  Choose a profile",
+			"       Save         ",
+			"     ❯ Activate Lean  4 plugins",
+			"       Quit         ",
+			"     ↑↓ move · enter select · esc cancel",
+		]);
+	});
+
+	test("REQ-6a (derived) at every index exactly one row carries ❯, and it is that index's label", () => {
+		setColorEnabled(false);
+
+		for (let index = 0; index < PROFILE_OPTIONS.length; index++) {
+			const marked = selectFrame(
+				"Choose a profile",
+				PROFILE_OPTIONS,
+				index,
+			).filter((line) => line.includes("❯"));
+			expect({ index, marked: marked.length }).toEqual({ index, marked: 1 });
+			expect(marked[0]).toContain(PROFILE_OPTIONS[index]?.label as string);
+		}
+	});
+
+	test('REQ-6b selectDone("Choose a profile", "Activate Lean") is exactly "  ✓  Choose a profile  Activate Lean"', () => {
+		setColorEnabled(false);
+
+		expect(selectDone("Choose a profile", "Activate Lean")).toBe(
+			"  ✓  Choose a profile  Activate Lean",
+		);
+	});
+
+	const PARAGRAPH_ONE =
+		"Claude Code treats each folder you start it in as a separate project, with its own plugins and settings, and magus follows along.";
+	const PARAGRAPH_TWO =
+		"Separately, to manage plugins for the whole project, run magus in the parent folder instead of this one.";
+	const NOTE = `${PARAGRAPH_ONE}\n\n${PARAGRAPH_TWO}`;
+	const words = (text: string): string[] => text.split(/\s+/).filter(Boolean);
+
+	test("REQ-6f every noteBlock line is empty or indented by 5 spaces, at 40 columns and at the default width", () => {
+		setColorEnabled(false);
+
+		for (const lines of [noteBlock(NOTE, 40), noteBlock(NOTE)]) {
+			expect(
+				lines.filter((line) => line !== "" && !line.startsWith("     ")),
+			).toEqual([]);
+		}
+	});
+
+	test("REQ-6f at 40 columns no line is longer than 40 characters", () => {
+		setColorEnabled(false);
+
+		const lines = noteBlock(NOTE, 40);
+
+		expect(lines.filter((line) => line.length > 40)).toEqual([]);
+	});
+
+	test("REQ-6f the input's words appear in order when the lines are joined", () => {
+		setColorEnabled(false);
+
+		const lines = noteBlock(NOTE, 40);
+
+		expect(words(lines.join(" "))).toEqual(words(NOTE));
+	});
+
+	test("REQ-6f a blank line in the input becomes an empty line between the paragraphs", () => {
+		setColorEnabled(false);
+
+		const lines = noteBlock(NOTE, 40);
+		const endOfFirst = lines.findIndex((line) => line.includes("along."));
+		const startOfSecond = lines.findIndex((line) =>
+			line.includes("Separately,"),
+		);
+
+		expect(endOfFirst).toBeGreaterThanOrEqual(0);
+		expect(startOfSecond).toBeGreaterThan(endOfFirst + 1);
+		expect(lines.slice(endOfFirst + 1, startOfSecond)).toContain("");
+		expect(
+			lines
+				.slice(endOfFirst + 1, startOfSecond)
+				.filter((line) => line.trim() !== ""),
+		).toEqual([]);
+	});
+});
+
+describe("REQ-6c selectKey with count 4", () => {
+	const cases: Array<
+		[index: number, key: SelectKeypress, expected: SelectStep, note: string]
+	> = [
+		[0, { name: "down" }, { index: 1 }, "down moves down"],
+		[3, { name: "down" }, { index: 0 }, "down from the last row wraps"],
+		[0, { name: "up" }, { index: 3 }, "up from the first row wraps"],
+		[2, { name: "k" }, { index: 1 }, "k moves up"],
+		[2, { name: "j" }, { index: 3 }, "j moves down"],
+		[2, { name: "return" }, { chosen: 2 }, "return picks the current row"],
+		[1, { name: "enter" }, { chosen: 1 }, "enter picks the current row"],
+		[0, { sequence: "3" }, { chosen: 2 }, "a digit picks that row at once"],
+		[
+			0,
+			{ sequence: "9" },
+			{ index: 0 },
+			"an out-of-range digit changes nothing",
+		],
+		[1, { name: "escape" }, { cancelled: true }, "escape cancels"],
+		[1, { name: "c", ctrl: true }, { cancelled: true }, "ctrl+c cancels"],
+		[1, { name: "x" }, { index: 1 }, "any other key leaves the cursor"],
+	];
+
+	for (const [index, key, expected, note] of cases) {
+		test(`REQ-6c ${note}: selectKey(${index}, ${JSON.stringify(key)}, 4) → ${JSON.stringify(expected)}`, () => {
+			expect(selectKey(index, key, 4)).toEqual(expected);
+		});
+	}
+});
+
+describe("REQ-6d selectOption without a terminal", () => {
+	test(
+		"REQ-6d with stdin piped it resolves null without waiting for input, and draws no ↑↓ hint",
+		async () => {
+			const sb = await sandbox();
+
+			const child = await runChild([join(helperDir, "select-child.ts")], {
+				env: sb.env,
+				cwd: sb.base,
+				holdStdinOpen: true,
+				timeoutMs: 10_000,
+			});
+
+			expect({ timedOut: child.timedOut, stderr: child.stderr }).toEqual({
+				timedOut: false,
+				stderr: child.stderr,
+			});
+			const match = /__RESULT__(.*)$/m.exec(child.stdout);
+			expect(match).not.toBeNull();
+			expect(JSON.parse(match?.[1] as string)).toBeNull();
+			expect(child.stdout.slice(0, match?.index)).not.toContain("↑↓");
+		},
+		CHILD_TEST_TIMEOUT_MS,
+	);
+});
+
+describe("REQ-6e the CLI mounts no TUI component and has no numbered choice", () => {
+	test("REQ-6e no file named tui-prompt.tsx exists under src/cli/", () => {
+		const found = (
+			readdirSync(join(SRC, "cli"), { recursive: true }) as string[]
+		).filter((entry) => basename(entry) === "tui-prompt.tsx");
+
+		expect(found).toEqual([]);
+	});
+
+	test("REQ-6e src/cli/prompt.ts does not export askChoice", async () => {
+		const promptModule: Record<string, unknown> = await import(
+			"../cli/prompt.js"
+		);
+
+		// The import worked: the module's own contract export is there.
+		expect(typeof promptModule.askYesNo).toBe("function");
+		expect("askChoice" in promptModule).toBe(false);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// REQ-3 ensureManifest (child process, non-TTY, colours off)
+// ---------------------------------------------------------------------------
+
+describe("REQ-3 ensureManifest", () => {
+	test(
+		"REQ-3a no manifest, no TTY, no allowAdopt: resolves null, names `magus profile init`, touches nothing",
+		async () => {
+			const sb = await sandbox();
+			const project = await standaloneProject(sb);
+			const before = await snapshotTree(project);
+
+			const run = await callBootstrap(sb, "ensureManifest", project, {});
+
+			expect(run.error).toBeNull();
+			expect(run.result).toBeNull();
+			expect(run.lines.some((l) => l.includes("magus profile init"))).toBe(
+				true,
+			);
+			expect(await snapshotTree(project)).toEqual(before);
+		},
+		CHILD_TEST_TIMEOUT_MS,
+	);
+
+	test(
+		"REQ-3b with no ancestor manifest, the plan leads with the state and never names a settings file",
+		async () => {
+			const sb = await sandbox();
+			const project = await standaloneProject(sb);
+
+			const run = await callBootstrap(sb, "ensureManifest", project, {});
+
+			expect(run.error).toBeNull();
+			const firstNonEmpty = run.lines.find((l) => l.trim() !== "");
+			expect(firstNonEmpty).toContain("No profiles in this project yet");
+			expect(run.lines.filter((l) => l.includes("settings.json"))).toEqual([]);
+			expect(run.lines.filter((l) => l.includes(".mcp.json"))).toEqual([]);
+			expect(run.lines.filter((l) => l.trim().startsWith("from "))).toEqual([]);
+		},
+		CHILD_TEST_TIMEOUT_MS,
+	);
+
+	/** `<base>/acme-repo` is the repo root and holds the profiles; the project sits below it. */
+	async function subfolderOfProfiledRepo(
+		sb: Sandbox,
+		segments: string[],
+	): Promise<{ root: string; project: string }> {
+		const root = join(sb.base, "acme-repo");
+		await mkdir(join(root, ".git"), { recursive: true });
+		await writeJson(join(root, ".claude", "profiles.json"), TEAM_MANIFEST);
+		const project = await makeProject(
+			join(root, ...segments),
+			TWO_PLUGINS,
+			false,
+		);
+		return { root, project };
+	}
+
+	const DEPTHS: Array<[rel: string, segments: string[]]> = [
+		["..", ["web"]],
+		["../..", ["apps", "web"]],
+	];
+
+	for (const [rel, segments] of DEPTHS) {
+		test(
+			`REQ-3c inside a project with profiles at ${rel}: resolves null with a plain note, asks nothing, writes nothing`,
+			async () => {
+				const sb = await sandbox();
+				const { root, project } = await subfolderOfProfiledRepo(sb, segments);
+				const before = await snapshotTree(root);
+
+				const run = await callBootstrap(sb, "ensureManifest", project, {});
+
+				expect(run.error).toBeNull();
+				expect(run.result).toBeNull();
+				const flat = flatten(run.output);
+				expect(flat).toContain("Inside another Claude Code project");
+				expect(flat).toContain(
+					"This folder is inside a Claude Code project that already has profiles",
+				);
+				expect(run.lines.map((l) => l.trim())).toContain(`${rel}  (acme-repo)`);
+				expect(flat).toContain(
+					"Claude Code treats each folder you start it in as a separate project",
+				);
+				expect(flat).toContain("run magus there");
+				expect(flat).toContain("magus profile init");
+				expect(run.output).not.toContain("[Y/n]");
+				expect(run.output).not.toContain("No profiles in this project yet");
+				expect(run.output).not.toContain("⚠");
+				expect(await snapshotTree(root)).toEqual(before);
+			},
+			CHILD_TEST_TIMEOUT_MS,
+		);
+	}
+
+	test(
+		"REQ-3c with allowAdopt in that subfolder: writes the subfolder's own profiles.json and leaves the ancestor's alone",
+		async () => {
+			const sb = await sandbox();
+			const { root, project } = await subfolderOfProfiledRepo(sb, ["web"]);
+			const ancestorManifest = join(root, ".claude", "profiles.json");
+			const ancestorBefore = await readFile(ancestorManifest, "utf8");
+
+			const run = await callBootstrap(sb, "ensureManifest", project, {
+				allowAdopt: true,
+			});
+
+			expect(run.error).toBeNull();
+			expect(
+				await Bun.file(join(project, ".claude", "profiles.json")).exists(),
+			).toBe(true);
+			expect(await readFile(ancestorManifest, "utf8")).toBe(ancestorBefore);
+			const result = run.result as { profiles?: unknown } | null;
+			expect(result).not.toBeNull();
+			expect(typeof result?.profiles).toBe("object");
+			expect(
+				run.lines.filter((l) =>
+					l.includes("Inside another Claude Code project"),
+				),
+			).toEqual([]);
+		},
+		CHILD_TEST_TIMEOUT_MS,
+	);
+
+	test(
+		"REQ-3c with no ancestor manifest, no line says Inside another Claude Code project",
+		async () => {
+			const sb = await sandbox();
+			const project = await standaloneProject(sb);
+
+			const run = await callBootstrap(sb, "ensureManifest", project, {});
+
+			expect(run.error).toBeNull();
+			expect(
+				run.lines.filter((l) =>
+					l.includes("Inside another Claude Code project"),
+				),
+			).toEqual([]);
+		},
+		CHILD_TEST_TIMEOUT_MS,
+	);
+
+	test(
+		"REQ-3d the plan counts 2 PROJECT plugins, lists them by bare name, and proposes profile default NEW",
+		async () => {
+			const sb = await sandbox();
+			const project = await standaloneProject(sb);
+
+			const run = await callBootstrap(sb, "ensureManifest", project, {});
+
+			expect(run.error).toBeNull();
+			const pluginsAt = run.lines.findIndex(
+				(l) =>
+					l.trim().startsWith("plugins") &&
+					/\b2\b/.test(l) &&
+					l.includes("PROJECT"),
+			);
+			expect(pluginsAt).toBeGreaterThanOrEqual(0);
+			const below = run.lines.slice(pluginsAt + 1).map((l) => l.trim());
+			expect(below).toContain("dev");
+			expect(below).toContain("claudish");
+			expect(run.lines.filter((l) => l.includes("@magus"))).toEqual([]);
+			expect(
+				run.lines.some(
+					(l) =>
+						l.trim().startsWith("profile") &&
+						l.includes("default") &&
+						l.includes("NEW"),
+				),
+			).toBe(true);
+		},
+		CHILD_TEST_TIMEOUT_MS,
+	);
+
+	test(
+		"REQ-3d2 with no project plugins and a USER plugin, the plugins line says USER and the project has none of its own",
+		async () => {
+			const sb = await sandbox();
+			const project = await standaloneProject(sb, {
+				enabledPlugins: {},
+			});
+			await writeJson(join(sb.home, ".claude", "settings.json"), {
+				enabledPlugins: { "dev@magus": true },
+			});
+
+			const run = await callBootstrap(sb, "ensureManifest", project, {});
+
+			expect(run.error).toBeNull();
+			const pluginLines = run.lines.filter((l) =>
+				l.trim().startsWith("plugins"),
+			);
+			expect(pluginLines.length).toBeGreaterThan(0);
+			expect(pluginLines.some((l) => l.includes("USER"))).toBe(true);
+			expect(pluginLines.filter((l) => l.includes("PROJECT"))).toEqual([]);
+			expect(
+				run.lines.some((l) =>
+					l.includes("This project has no plugins of its own"),
+				),
+			).toBe(true);
+		},
+		CHILD_TEST_TIMEOUT_MS,
+	);
+
+	test(
+		"REQ-3e allowAdopt writes profiles.json, resolves to a manifest, and says saved / commit / using",
+		async () => {
+			const sb = await sandbox();
+			const project = await standaloneProject(sb);
+
+			const run = await callBootstrap(sb, "ensureManifest", project, {
+				allowAdopt: true,
+			});
+
+			expect(run.error).toBeNull();
+			const written = JSON.parse(
+				await readFile(join(project, ".claude", "profiles.json"), "utf8"),
+			) as { profiles?: Record<string, unknown> };
+			expect(Object.keys(written.profiles ?? {}).length).toBeGreaterThan(0);
+			const result = run.result as {
+				profiles?: Record<string, unknown>;
+			} | null;
+			expect(result).not.toBeNull();
+			expect(Object.keys(result?.profiles ?? {}).length).toBeGreaterThan(0);
+			expect(run.lines.some((l) => l.includes("Saved profile"))).toBe(true);
+			expect(
+				run.lines.some((l) => l.includes("Commit .claude/profiles.json")),
+			).toBe(true);
+			expect(run.lines.some((l) => l.includes("Using profile"))).toBe(true);
+		},
+		CHILD_TEST_TIMEOUT_MS,
+	);
+
+	test(
+		"REQ-3f check mode resolves null, writes no profiles.json, and names --check",
+		async () => {
+			const sb = await sandbox();
+			const project = await standaloneProject(sb);
+
+			const run = await callBootstrap(sb, "ensureManifest", project, {
+				check: true,
+			});
+
+			expect(run.error).toBeNull();
+			expect(run.result).toBeNull();
+			expect(
+				await Bun.file(join(project, ".claude", "profiles.json")).exists(),
+			).toBe(false);
+			expect(run.lines.some((l) => l.includes("--check"))).toBe(true);
+		},
+		CHILD_TEST_TIMEOUT_MS,
+	);
+
+	test(
+		"REQ-3g an existing manifest with a profile is returned, and no adoption state is printed",
+		async () => {
+			const sb = await sandbox();
+			const project = await standaloneProject(sb);
+			await writeJson(join(project, ".claude", "profiles.json"), TEAM_MANIFEST);
+
+			const run = await callBootstrap(sb, "ensureManifest", project, {});
+
+			expect(run.error).toBeNull();
+			expect(run.result).toMatchObject(TEAM_MANIFEST);
+			expect(
+				run.lines.filter((l) => l.includes("No profiles in this project yet")),
+			).toEqual([]);
+		},
+		CHILD_TEST_TIMEOUT_MS,
+	);
+
+	test(
+		"REQ-3h in a real repo tracking settings.json, the tracked-file notice prints once and nothing is staged",
+		async () => {
+			const sb = await sandbox();
+			const project = join(sb.base, "proj");
+			await mkdir(project, { recursive: true });
+			const git = (...args: string[]): string => {
+				const r = Bun.spawnSync({
+					cmd: [
+						"git",
+						"-c",
+						"user.email=t@t",
+						"-c",
+						"user.name=t",
+						"-c",
+						"commit.gpgsign=false",
+						...args,
+					],
+					cwd: project,
+					env: sb.env,
+				});
+				if (r.exitCode !== 0) {
+					throw new Error(
+						`git ${args.join(" ")} failed: ${r.stderr.toString()}`,
+					);
+				}
+				return r.stdout.toString();
+			};
+			git("init", "-q");
+			await writeJson(join(project, ".claude", "settings.json"), TWO_PLUGINS);
+			git("add", ".claude/settings.json");
+			git("commit", "-q", "-m", "init");
+
+			const run = await callBootstrap(sb, "ensureManifest", project, {
+				allowAdopt: true,
+			});
+
+			expect(run.error).toBeNull();
+			expect(
+				countOf(
+					run.output,
+					"git tracks .claude/settings.json, but magus rewrites it",
+				),
+			).toBe(1);
+			expect(
+				countOf(
+					run.output,
+					"git rm --cached .claude/settings.json, then commit",
+				),
+			).toBe(1);
+			expect(git("diff", "--cached", "--name-only")).toBe("");
+		},
+		CHILD_TEST_TIMEOUT_MS,
+	);
+});
+
+// ---------------------------------------------------------------------------
+// REQ-5 profileGate with an old profile format (child process, non-TTY)
+// ---------------------------------------------------------------------------
+
+describe("REQ-5 profileGate and the old profile format", () => {
+	const STATE_LINE = "This project uses an old magus profile format";
+
+	async function oldFormatProject(
+		sb: Sandbox,
+		withOldDir: boolean,
+	): Promise<string> {
+		const project = join(sb.base, "proj");
+		await mkdir(join(project, ".git"), { recursive: true });
+		if (withOldDir) {
+			await writeJson(
+				join(project, ".claude", "_profiles", "team", "settings.json"),
+				{ enabledPlugins: { "dev@magus": true } },
+			);
+		}
+		await writeJson(join(project, ".claude", "profiles.json"), TEAM_MANIFEST);
+		return project;
+	}
+
+	test(
+		"REQ-5a non-TTY without yes: the state is printed once and nobody is asked",
+		async () => {
+			const sb = await sandbox();
+			const project = await oldFormatProject(sb, true);
+
+			const run = await callBootstrap(sb, "profileGate", project, {});
+
+			expect(run.error).toBeNull();
+			expect(countOf(run.output, STATE_LINE)).toBe(1);
+			expect(run.output).not.toContain("[Y/n]");
+		},
+		CHILD_TEST_TIMEOUT_MS,
+	);
+
+	test(
+		"REQ-5b with yes: the same state line is printed and nobody is asked",
+		async () => {
+			const sb = await sandbox();
+			const project = await oldFormatProject(sb, true);
+
+			const run = await callBootstrap(sb, "profileGate", project, {
+				yes: true,
+			});
+
+			expect(run.error).toBeNull();
+			expect(countOf(run.output, STATE_LINE)).toBeGreaterThanOrEqual(1);
+			expect(run.output).not.toContain("[Y/n]");
+		},
+		CHILD_TEST_TIMEOUT_MS,
+	);
+
+	test(
+		"REQ-5c without a .claude/_profiles directory, the old format is not mentioned",
+		async () => {
+			const sb = await sandbox();
+			const project = await oldFormatProject(sb, false);
+
+			const run = await callBootstrap(sb, "profileGate", project, {});
+
+			expect(run.error).toBeNull();
+			expect(run.output).not.toContain("old magus profile format");
+		},
+		CHILD_TEST_TIMEOUT_MS,
+	);
+
+	test(
+		"REQ-5d the old-format notice names no internal paths or jargon",
+		async () => {
+			const sb = await sandbox();
+			const project = await oldFormatProject(sb, true);
+
+			const run = await callBootstrap(sb, "profileGate", project, {});
+
+			expect(run.error).toBeNull();
+			for (const banned of [
+				"_profiles",
+				".magus-backups",
+				"older layout",
+				"live config",
+			]) {
+				expect({
+					banned,
+					lines: run.lines.filter((l) => l.includes(banned)),
+				}).toEqual({ banned, lines: [] });
+			}
+		},
+		CHILD_TEST_TIMEOUT_MS,
+	);
+});