magus-cli 7.5.4 → 7.6.0

package/src/__tests__/profile-name-on-save.test.ts

@@ -0,0 +1,443 @@
+/**
+ * "Save what you have" asks for a name — written blind from the spec's public
+ * contract, never from the implementation.
+ *
+ * Requirements (from the spec):
+ *  REQ-1  The save row's label carries no generated id; it is exactly
+ *         `Save what you have as a new profile`.
+ *  REQ-3  ONE pure function validates the typed name; an invalid name is a
+ *         one-line reason, never silently changed to another id.
+ *  REQ-4  The new profile is written under the derived id with `name` = the
+ *         trimmed text (via applyProfileChoice's adopt `name`).
+ *  REQ-6  Applies to both states that offer the save row: inactive, unmigrated.
+ *  C-1    profileIdForName: empty/whitespace → "Enter a name for the profile."
+ *  C-2    id = lowercase, every run outside [a-z0-9] → one "-", edges trimmed.
+ *  C-3    empty id → "Use at least one letter or digit."
+ *  C-4    id already a key → 'A profile called "<name or id>" already exists.
+ *         Choose another name.'
+ *  C-5    otherwise { ok: true, id, name } with name trimmed.
+ *  C-6    applyProfileChoice adopt without `name` keeps current behaviour.
+ *
+ * REQ-2 and REQ-5 (the prompt itself, its suggestion default, and cancelling
+ * it) live in the CLI/TUI surfaces, which the contract does not expose; they
+ * are listed as known gaps in the run report.
+ */
+
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import fs from "fs-extra";
+import { readManifest, writeManifest } from "../services/manifest.js";
+import type { ProfileChoice } from "../services/profile-activate.js";
+import {
+	ADOPT_VALUE,
+	buildProfileOptions,
+	detectProfileStartupNeed,
+	parseProfileChoice,
+	profileIdForName,
+} from "../services/profile-startup.js";
+import { applyProfileChoice } from "../services/profile-state.js";
+import type { ProfileManifest } from "../types/index.js";
+
+const SAVE_LABEL = "Save what you have as a new profile";
+
+const MANIFEST: ProfileManifest = {
+	version: 2,
+	profiles: {
+		lean: { name: "Lean", plugins: { "terminal@magus": "latest" } },
+		full: {
+			name: "Full Stack",
+			plugins: { "terminal@magus": "latest", "dev@magus": "latest" },
+		},
+	},
+};
+
+/** A manifest with a profile that carries no display name. */
+const NAMELESS = {
+	version: 2,
+	profiles: {
+		default: { plugins: { "terminal@magus": "latest" } },
+	},
+} as unknown as ProfileManifest;
+
+const EMPTY: ProfileManifest = { version: 2, profiles: {} };
+
+describe("profileIdForName — empty input (C-1)", () => {
+	test("C-1: an empty string asks for a name", () => {
+		expect(profileIdForName("", MANIFEST)).toEqual({
+			ok: false,
+			reason: "Enter a name for the profile.",
+		});
+	});
+
+	test("C-1: whitespace only (spaces, tab, newline) asks for a name, not for a letter", () => {
+		// Rule order: trimming to empty is caught BEFORE the slug rule.
+		for (const input of [" ", "     ", "\t", "\n", " \t \n "]) {
+			expect(profileIdForName(input, MANIFEST)).toEqual({
+				ok: false,
+				reason: "Enter a name for the profile.",
+			});
+		}
+	});
+
+	test("C-1: empty input is rejected even against an empty manifest", () => {
+		expect(profileIdForName("", EMPTY)).toEqual({
+			ok: false,
+			reason: "Enter a name for the profile.",
+		});
+	});
+});
+
+describe("profileIdForName — no usable characters (C-3)", () => {
+	test("C-3: symbols only is rejected with the letter-or-digit reason", () => {
+		for (const input of ["!!!", "---", "@#$%", "  _-_  ", "...", "()[]{}"]) {
+			expect(profileIdForName(input, MANIFEST)).toEqual({
+				ok: false,
+				reason: "Use at least one letter or digit.",
+			});
+		}
+	});
+
+	test("C-3: letters outside [a-z0-9] leave no id and are rejected", () => {
+		// Non-ASCII letters are outside [a-z0-9] after lowercasing.
+		expect(profileIdForName("ÄÖÜ", EMPTY)).toEqual({
+			ok: false,
+			reason: "Use at least one letter or digit.",
+		});
+	});
+});
+
+describe("profileIdForName — id derivation (C-2, C-5)", () => {
+	const cases: Array<[string, string, string]> = [
+		// [input, expected id, expected name]
+		["backend", "backend", "backend"],
+		["Backend", "backend", "Backend"],
+		["My Team", "my-team", "My Team"],
+		["MiXeD CaSe", "mixed-case", "MiXeD CaSe"],
+		["UPPER123", "upper123", "UPPER123"],
+		["v2", "v2", "v2"],
+		["2026", "2026", "2026"],
+		["a.b.c", "a-b-c", "a.b.c"],
+		["Front--End!!v2", "front-end-v2", "Front--End!!v2"],
+		["one   two", "one-two", "one   two"],
+		["snake_case_name", "snake-case-name", "snake_case_name"],
+		["--Hello__World--", "hello-world", "--Hello__World--"],
+		["!!Release!!", "release", "!!Release!!"],
+		["Café Team", "caf-team", "Café Team"],
+		["x", "x", "x"],
+	];
+
+	for (const [input, id, name] of cases) {
+		test(`C-2/C-5: "${input}" becomes id "${id}"`, () => {
+			expect(profileIdForName(input, MANIFEST)).toEqual({ ok: true, id, name });
+		});
+	}
+
+	test("C-5: the returned name is trimmed at both ends, inner spacing kept", () => {
+		expect(profileIdForName("   My   Team  \t", MANIFEST)).toEqual({
+			ok: true,
+			id: "my-team",
+			name: "My   Team",
+		});
+	});
+
+	test("C-2: the id never starts or ends with a dash", () => {
+		const result = profileIdForName("  -*- Night Build -*-  ", EMPTY);
+		expect(result).toEqual({
+			ok: true,
+			id: "night-build",
+			name: "-*- Night Build -*-",
+		});
+	});
+
+	test("C-2: a derived id contains only [a-z0-9] and single dashes", () => {
+		const result = profileIdForName("Q3 / Mobile & Web — Beta!!", EMPTY);
+		expect(result.ok).toBe(true);
+		if (!result.ok) return;
+		expect(result.id).toBe("q3-mobile-web-beta");
+		expect(result.id).toMatch(/^[a-z0-9]+(-[a-z0-9]+)*$/);
+	});
+});
+
+describe("profileIdForName — collisions (C-4, REQ-3)", () => {
+	test("C-4: a name deriving an existing id is refused, naming that profile's display name", () => {
+		expect(profileIdForName("lean", MANIFEST)).toEqual({
+			ok: false,
+			reason: 'A profile called "Lean" already exists. Choose another name.',
+		});
+	});
+
+	test("C-4: the collision is judged on the derived id, whatever the case or padding", () => {
+		for (const input of ["LEAN", "  Lean  ", "lean!", "--lean--"]) {
+			expect(profileIdForName(input, MANIFEST)).toEqual({
+				ok: false,
+				reason: 'A profile called "Lean" already exists. Choose another name.',
+			});
+		}
+	});
+
+	test("C-4: the reason quotes the EXISTING profile's name, not what the user typed", () => {
+		expect(profileIdForName("FULL", MANIFEST)).toEqual({
+			ok: false,
+			reason:
+				'A profile called "Full Stack" already exists. Choose another name.',
+		});
+	});
+
+	test("C-4: a profile with no name is quoted by its id", () => {
+		expect(profileIdForName("Default", NAMELESS)).toEqual({
+			ok: false,
+			reason: 'A profile called "default" already exists. Choose another name.',
+		});
+	});
+
+	test("REQ-3: a colliding name is never silently moved to another id", () => {
+		// The old flow proposed `default-2`; a typed name that collides must be
+		// refused, not renumbered.
+		const result = profileIdForName("default", NAMELESS);
+		expect(result.ok).toBe(false);
+		expect(result).not.toHaveProperty("id");
+	});
+
+	test("C-4: matching an existing DISPLAY name under a different id is not a collision", () => {
+		// "Full Stack" is the name of id `full`; its derived id is `full-stack`,
+		// which is not a key — the rule compares ids only.
+		expect(profileIdForName("Full Stack", MANIFEST)).toEqual({
+			ok: true,
+			id: "full-stack",
+			name: "Full Stack",
+		});
+	});
+
+	test("C-4: a name whose id merely starts with an existing id is fine", () => {
+		expect(profileIdForName("Lean 2", MANIFEST)).toEqual({
+			ok: true,
+			id: "lean-2",
+			name: "Lean 2",
+		});
+	});
+});
+
+describe("profileIdForName — purity (REQ-3)", () => {
+	test("REQ-3: it does not modify the manifest and answers the same twice", () => {
+		const before = structuredClone(MANIFEST);
+		const first = profileIdForName("New One", MANIFEST);
+		const second = profileIdForName("New One", MANIFEST);
+		expect(first).toEqual(second);
+		expect(MANIFEST).toEqual(before);
+		// A valid name is not registered anywhere by being checked.
+		expect(Object.keys(MANIFEST.profiles)).toEqual(["lean", "full"]);
+	});
+});
+
+describe("the save row (REQ-1, REQ-6)", () => {
+	const unmigrated = {
+		state: "unmigrated" as const,
+		adopt: "default",
+		activate: [],
+		manifest: EMPTY,
+	};
+	const inactive = {
+		state: "inactive" as const,
+		adopt: "default-2",
+		activate: [
+			{ id: "lean", name: "Lean", pluginCount: 1 },
+			{ id: "full", name: "Full Stack", pluginCount: 2 },
+		],
+		manifest: MANIFEST,
+	};
+
+	for (const need of [unmigrated, inactive]) {
+		test(`REQ-1/REQ-6: in the ${need.state} state the save row reads exactly "${SAVE_LABEL}"`, () => {
+			const save = buildProfileOptions(need).find(
+				(o) => o.value === ADOPT_VALUE,
+			);
+			expect(save).toBeDefined();
+			expect(save?.label).toBe(SAVE_LABEL);
+		});
+
+		test(`REQ-1: in the ${need.state} state the save row does not show the generated id`, () => {
+			const save = buildProfileOptions(need).find(
+				(o) => o.value === ADOPT_VALUE,
+			);
+			expect(save?.label).not.toContain(need.adopt);
+			expect(save?.label).not.toContain('"');
+		});
+	}
+});
+
+describe("applyProfileChoice writes the user's name (REQ-4, REQ-6, C-6)", () => {
+	let project: string;
+	let wasTTY: boolean | undefined;
+	let log: ReturnType<typeof spyOn>;
+	let err: ReturnType<typeof spyOn>;
+
+	const enable = (ids: string[]) =>
+		fs.outputJson(join(project, ".claude", "settings.json"), {
+			enabledPlugins: Object.fromEntries(ids.map((id) => [id, true])),
+		});
+
+	beforeEach(async () => {
+		project = await mkdtemp(join(tmpdir(), "name-on-save-"));
+		wasTTY = process.stdin.isTTY;
+		Object.defineProperty(process.stdin, "isTTY", {
+			value: false,
+			configurable: true,
+		});
+		log = spyOn(console, "log").mockImplementation(() => {});
+		err = spyOn(console, "error").mockImplementation(() => {});
+	});
+	afterEach(async () => {
+		log.mockRestore();
+		err.mockRestore();
+		Object.defineProperty(process.stdin, "isTTY", {
+			value: wasTTY,
+			configurable: true,
+		});
+		await rm(project, { recursive: true, force: true });
+	});
+
+	test("REQ-4: adopt with a name writes that name under the given id", async () => {
+		await writeManifest(MANIFEST, project);
+		await enable(["code-search@magus"]);
+
+		const choice: ProfileChoice = {
+			kind: "adopt",
+			id: "my-team",
+			name: "My Team",
+		};
+		const result = await applyProfileChoice(choice, MANIFEST, project, {
+			onDisplace: () => {},
+		});
+
+		expect(result.profileId).toBe("my-team");
+		const written = await readManifest(project);
+		expect(written.profiles["my-team"]).toBeDefined();
+		expect(written.profiles["my-team"]?.name).toBe("My Team");
+	});
+
+	test("REQ-4: adopting under a new name leaves every existing profile untouched", async () => {
+		await writeManifest(MANIFEST, project);
+		await enable(["code-search@magus"]);
+
+		await applyProfileChoice(
+			{ kind: "adopt", id: "my-team", name: "My Team" },
+			MANIFEST,
+			project,
+			{ onDisplace: () => {} },
+		);
+
+		const written = await readManifest(project);
+		expect(written.profiles.lean).toEqual(MANIFEST.profiles.lean);
+		expect(written.profiles.full).toEqual(MANIFEST.profiles.full);
+		expect(Object.keys(written.profiles).sort()).toEqual([
+			"full",
+			"lean",
+			"my-team",
+		]);
+	});
+
+	test("REQ-4/REQ-6: inactive state — detect, choose save, name it, apply", async () => {
+		await writeManifest(MANIFEST, project);
+		await enable(["code-search@magus"]);
+
+		const need = await detectProfileStartupNeed(project);
+		expect(need.state).toBe("inactive");
+		const picked = parseProfileChoice(ADOPT_VALUE, need);
+		expect(picked).toEqual({ kind: "adopt", id: need.adopt as string });
+
+		const check = profileIdForName("  Release Candidate  ", need.manifest);
+		expect(check).toEqual({
+			ok: true,
+			id: "release-candidate",
+			name: "Release Candidate",
+		});
+		if (!check.ok || !picked) throw new Error("unreachable");
+
+		const result = await applyProfileChoice(
+			{ ...picked, id: check.id, name: check.name } as ProfileChoice,
+			need.manifest,
+			project,
+			{ onDisplace: () => {} },
+		);
+
+		expect(result.profileId).toBe("release-candidate");
+		const written = await readManifest(project);
+		expect(written.profiles["release-candidate"]?.name).toBe(
+			"Release Candidate",
+		);
+		// No auto-numbered profile was created alongside it.
+		expect(written.profiles[need.adopt as string]).toBeUndefined();
+		expect(written.profiles.lean).toEqual(MANIFEST.profiles.lean);
+		expect(written.profiles.full).toEqual(MANIFEST.profiles.full);
+	});
+
+	test("REQ-4/REQ-6: unmigrated state — the first profile gets the typed name", async () => {
+		// No profiles.json at all.
+		await enable(["dev@magus"]);
+
+		const need = await detectProfileStartupNeed(project);
+		expect(need.state).toBe("unmigrated");
+
+		const check = profileIdForName("Personal Setup", need.manifest);
+		expect(check).toEqual({
+			ok: true,
+			id: "personal-setup",
+			name: "Personal Setup",
+		});
+		if (!check.ok) throw new Error("unreachable");
+
+		const result = await applyProfileChoice(
+			{ kind: "adopt", id: check.id, name: check.name },
+			need.manifest,
+			project,
+			{ onDisplace: () => {} },
+		);
+
+		expect(result.profileId).toBe("personal-setup");
+		const written = await readManifest(project);
+		expect(Object.keys(written.profiles)).toEqual(["personal-setup"]);
+		expect(written.profiles["personal-setup"]?.name).toBe("Personal Setup");
+	});
+
+	test("REQ-4: accepting the suggestion writes the suggested id as the name", async () => {
+		await writeManifest(MANIFEST, project);
+		await enable(["code-search@magus"]);
+
+		const need = await detectProfileStartupNeed(project);
+		const suggestion = need.adopt as string;
+		const check = profileIdForName(suggestion, need.manifest);
+		expect(check).toEqual({ ok: true, id: suggestion, name: suggestion });
+		if (!check.ok) throw new Error("unreachable");
+
+		await applyProfileChoice(
+			{ kind: "adopt", id: check.id, name: check.name },
+			need.manifest,
+			project,
+			{ onDisplace: () => {} },
+		);
+
+		expect((await readManifest(project)).profiles[suggestion]?.name).toBe(
+			suggestion,
+		);
+	});
+
+	test("C-6: adopt without a name still creates the profile under its id", async () => {
+		await writeManifest(MANIFEST, project);
+		await enable(["code-search@magus"]);
+
+		const result = await applyProfileChoice(
+			{ kind: "adopt", id: "default" },
+			MANIFEST,
+			project,
+			{ onDisplace: () => {} },
+		);
+
+		expect(result.profileId).toBe("default");
+		const written = await readManifest(project);
+		expect(written.profiles.default).toBeDefined();
+		expect(written.profiles.lean).toEqual(MANIFEST.profiles.lean);
+		expect(written.profiles.full).toEqual(MANIFEST.profiles.full);
+	});
+});

package/src/__tests__/profile-startup.test.ts

@@ -373,7 +373,7 @@ describe("what the user is offered", () => {
 		// "Create <id> from this project" described the mechanism. The reason to
 		// pick this row is that it is the only one that keeps what is turned on.
 		expect(buildProfileOptions(inactive)[0]?.label).toBe(
-			'Save what you have as "default"',
+			"Save what you have as a new profile",
 		);
 	});
 

package/src/__tests__/prompt-eof.test.ts

@@ -0,0 +1,245 @@
+/**
+ * CLI prompts at end of input.
+ *
+ * Written blind — from the spec and the export signatures of src/cli/prompt.ts
+ * only. `promptValue(question)` and `askYesNo(question)` take no stream, so they
+ * read the process's own stdin: each case runs them in a CHILD `bun` process
+ * whose stdin is a pipe this test writes to and then closes. The child writes
+ * its outcome to a result file; the prompt text it prints is ignored.
+ *
+ * REQ-B1  stdin ends before a line is answered → promptValue rejects with
+ *         PromptAborted (instanceof, and isPromptAborted(err) is true),
+ *         instead of waiting forever.
+ * REQ-B2  same for askYesNo.
+ * REQ-B3  stdin that stays open a while and THEN ends still rejects.
+ * REQ-B4  a line followed by a newline is still returned; promptValue trims it.
+ * REQ-B5  askYesNo still answers a line followed by a newline.
+ *
+ * Each child has HOME, XDG_* and the cwd inside a temp dir and runs with
+ * `--no-env-file`, so nothing here reads or writes the real home or a project.
+ */
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import {
+	mkdir,
+	mkdtemp,
+	readFile,
+	realpath,
+	rm,
+	writeFile,
+} from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const PROMPT_MODULE = join(import.meta.dir, "..", "cli", "prompt.ts");
+
+/** Bounded wait for a child. A hang past this is the "waits forever" bug. */
+const CHILD_TIMEOUT_MS = 8_000;
+
+const CHILD = `
+const [fn, question, out] = process.argv.slice(2);
+const mod = await import(${JSON.stringify(PROMPT_MODULE)});
+let result;
+try {
+	const value = await mod[fn](question);
+	result = { outcome: "resolved", value };
+} catch (err) {
+	result = {
+		outcome: "rejected",
+		name: err?.name ?? null,
+		isPromptAbortedClass: err instanceof mod.PromptAborted,
+		isPromptAborted: mod.isPromptAborted(err),
+		message: String(err?.message ?? err),
+	};
+}
+await Bun.write(out, JSON.stringify(result));
+process.exit(0);
+`;
+
+type Outcome =
+	| { outcome: "resolved"; value: unknown }
+	| {
+			outcome: "rejected";
+			name: string | null;
+			isPromptAbortedClass: boolean;
+			isPromptAborted: boolean;
+			message: string;
+	  };
+
+interface ChildRun {
+	result: Outcome | null;
+	timedOut: boolean;
+	exitCode: number | null;
+	stderr: string;
+}
+
+let root: string;
+let childScript: string;
+let runs = 0;
+
+beforeAll(async () => {
+	root = await realpath(await mkdtemp(join(tmpdir(), "prompt-eof-")));
+	childScript = join(root, "child.ts");
+	await writeFile(childScript, CHILD);
+});
+
+afterAll(async () => {
+	await rm(root, { recursive: true, force: true });
+});
+
+async function runPrompt(
+	fn: "promptValue" | "askYesNo",
+	input: string,
+	opts: { holdOpenMs?: number } = {},
+): Promise<ChildRun> {
+	const dir = join(root, `run-${++runs}`);
+	const home = join(dir, "home");
+	await mkdir(home, { recursive: true });
+	const out = join(dir, "result.json");
+
+	const proc = Bun.spawn(
+		[process.execPath, "--no-env-file", childScript, fn, "Question? ", out],
+		{
+			cwd: dir,
+			stdin: "pipe",
+			stdout: "pipe",
+			stderr: "pipe",
+			env: {
+				PATH: process.env.PATH ?? "/usr/bin:/bin",
+				HOME: home,
+				XDG_CONFIG_HOME: join(dir, "xdg-config"),
+				XDG_CACHE_HOME: join(dir, "xdg-cache"),
+				XDG_DATA_HOME: join(dir, "xdg-data"),
+				XDG_STATE_HOME: join(dir, "xdg-state"),
+				TMPDIR: tmpdir(),
+				NO_COLOR: "1",
+				TERM: "dumb",
+			},
+		},
+	);
+
+	if (input.length > 0) proc.stdin.write(input);
+	await proc.stdin.flush();
+	if (opts.holdOpenMs) await Bun.sleep(opts.holdOpenMs);
+	await proc.stdin.end();
+
+	let timedOut = false;
+	const timer = setTimeout(() => {
+		timedOut = true;
+		proc.kill();
+	}, CHILD_TIMEOUT_MS);
+	const exitCode = await proc.exited;
+	clearTimeout(timer);
+	const stderr = await new Response(proc.stderr).text();
+
+	let result: Outcome | null = null;
+	try {
+		result = JSON.parse(await readFile(out, "utf8")) as Outcome;
+	} catch {
+		result = null;
+	}
+	return { result, timedOut, exitCode, stderr };
+}
+
+function expectAborted(run: ChildRun): void {
+	expect({
+		timedOut: run.timedOut,
+		stderr: run.timedOut ? run.stderr : "",
+	}).toEqual({
+		timedOut: false,
+		stderr: "",
+	});
+	if (run.result === null) {
+		throw new Error(
+			`child produced no result (exit ${run.exitCode}):\n${run.stderr}`,
+		);
+	}
+	expect(run.result.outcome).toBe("rejected");
+	if (run.result.outcome !== "rejected") return;
+	expect(run.result.name).toBe("PromptAborted");
+	expect(run.result.isPromptAbortedClass).toBe(true);
+	expect(run.result.isPromptAborted).toBe(true);
+}
+
+function expectResolved(run: ChildRun, value: unknown): void {
+	expect(run.timedOut).toBe(false);
+	if (run.result === null) {
+		throw new Error(
+			`child produced no result (exit ${run.exitCode}):\n${run.stderr}`,
+		);
+	}
+	expect(run.result).toEqual({ outcome: "resolved", value });
+}
+
+describe("promptValue at end of input", () => {
+	test(
+		"REQ-B1 rejects with PromptAborted when stdin closes with nothing on it",
+		async () => {
+			expectAborted(await runPrompt("promptValue", ""));
+		},
+		CHILD_TIMEOUT_MS + 4_000,
+	);
+
+	test(
+		"REQ-B3 rejects with PromptAborted when stdin stays open, then closes unanswered",
+		async () => {
+			expectAborted(await runPrompt("promptValue", "", { holdOpenMs: 300 }));
+		},
+		CHILD_TIMEOUT_MS + 4_000,
+	);
+
+	test(
+		"REQ-B4 returns a newline-terminated line, trimmed",
+		async () => {
+			expectResolved(
+				await runPrompt("promptValue", "  team-profile  \n"),
+				"team-profile",
+			);
+		},
+		CHILD_TIMEOUT_MS + 4_000,
+	);
+
+	test(
+		"REQ-B4 returns the first line when stdin then ends",
+		async () => {
+			expectResolved(
+				await runPrompt("promptValue", "hello\n", { holdOpenMs: 100 }),
+				"hello",
+			);
+		},
+		CHILD_TIMEOUT_MS + 4_000,
+	);
+});
+
+describe("askYesNo at end of input", () => {
+	test(
+		"REQ-B2 rejects with PromptAborted when stdin closes with nothing on it",
+		async () => {
+			expectAborted(await runPrompt("askYesNo", ""));
+		},
+		CHILD_TIMEOUT_MS + 4_000,
+	);
+
+	test(
+		"REQ-B3 rejects with PromptAborted when stdin stays open, then closes unanswered",
+		async () => {
+			expectAborted(await runPrompt("askYesNo", "", { holdOpenMs: 300 }));
+		},
+		CHILD_TIMEOUT_MS + 4_000,
+	);
+
+	test(
+		'REQ-B5 answers "y" + newline with true',
+		async () => {
+			expectResolved(await runPrompt("askYesNo", "y\n"), true);
+		},
+		CHILD_TIMEOUT_MS + 4_000,
+	);
+
+	test(
+		'REQ-B5 answers "n" + newline with false',
+		async () => {
+			expectResolved(await runPrompt("askYesNo", "n\n"), false);
+		},
+		CHILD_TIMEOUT_MS + 4_000,
+	);
+});