magus-cli 7.7.0 → 7.9.0

package/src/__tests__/final-fixes-780.test.tsx

@@ -0,0 +1,740 @@
+/**
+ * The final fixes before magus 7.8.0 — one describe per item (B1–B3, R1, R2,
+ * R4, R6, R7, R8). Pure builders are tested directly; screen parts are
+ * rendered into a character frame and read the way a user reads them. Every
+ * describe carries a negative control: the same input minus the one fact the
+ * fix keys on, which must NOT produce the new behaviour.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import os, { tmpdir } from "node:os";
+import { join } from "node:path";
+import { testRender } from "@opentui/react/test-utils";
+import { type ReactNode, act } from "react";
+import { setColorEnabled, stripAnsi } from "../cli/ansi.js";
+import { planReport, summaryLine } from "../cli/update-view.js";
+import { claudeFailureMessage } from "../services/claude-cli.js";
+import {
+	type PluginEnvNeedsDeps,
+	missingPluginEnvVars,
+} from "../services/plugin-env-needs.js";
+import type { PluginInfo } from "../services/plugin-manager.js";
+import type { ActivationResult } from "../services/profile-activate.js";
+import { requiredByHere, requirersHere } from "../services/resolver.js";
+import { SettingsParseError } from "../services/settings-file.js";
+import {
+	type PluginUpdateItem,
+	type UpdatePlan,
+	classifyPlugin,
+	indexCatalog,
+	isKeptDeprecated,
+	planIsBehind,
+	planPluginUpdates,
+	summarizePlan,
+} from "../services/update-plan.js";
+import {
+	RETRY_TIMEOUT_FIX,
+	cliToolFailureReport,
+	commandFailureReason,
+} from "../ui/adapters/cliToolsAdapter.js";
+import { mergeFailureReports } from "../ui/adapters/failureReport.js";
+import {
+	INSTALL_CLAUDE_FIX,
+	type PluginPluginItem,
+	RETRY_NETWORK_FIX,
+} from "../ui/adapters/pluginsAdapter.js";
+import {
+	FIX_BY_HAND,
+	PROFILE_STARTUP_HEADLINE,
+	profileStartupReport,
+	stepFailureReport,
+} from "../ui/adapters/startupReports.js";
+import { nextStartupStep } from "../ui/hooks/startupQueue.js";
+import {
+	renderMcpRegistryRow,
+	renderMcpRegistryStatus,
+} from "../ui/renderers/mcpRenderers.js";
+import { renderPluginDetail } from "../ui/renderers/pluginRenderers.js";
+import { pluginRowText } from "../ui/renderers/pluginRowText.js";
+import { pluginStatusText } from "../ui/renderers/pluginStatusText.js";
+import type { FailureReport } from "../ui/state/types.js";
+import type { RunResult } from "../utils/run.js";
+import { userFacingPath } from "../utils/user-path.js";
+
+// ── builders ────────────────────────────────────────────────────────────────
+
+function info(over: Partial<PluginInfo> & { id: string }): PluginInfo {
+	const [name = over.id, marketplace = ""] = over.id.split("@");
+	return {
+		name,
+		version: null,
+		description: "",
+		marketplace,
+		marketplaceDisplay: marketplace,
+		...over,
+	};
+}
+
+/** Listed by `magus` — proof that marketplace was read. */
+const LISTED = info({
+	id: "dev@magus",
+	version: "9.0.0",
+	projectScope: { installed: true, version: "9.0.0" },
+});
+
+/** Installed here, and no longer listed by a marketplace we read. */
+function orphan(id: string): PluginInfo {
+	return info({
+		id,
+		version: "1.0.0",
+		installedVersion: "1.0.0",
+		isOrphaned: true,
+		projectScope: { installed: true, version: "1.0.0" },
+	});
+}
+
+function plan(plugins: PluginUpdateItem[]): UpdatePlan {
+	return {
+		profileId: "team",
+		plugins,
+		bins: [],
+		skills: [],
+		binSpecs: new Map(),
+	};
+}
+
+async function frameOf(
+	node: ReactNode,
+	width = 100,
+	height = 30,
+): Promise<string> {
+	const { captureCharFrame, renderOnce, renderer } = await testRender(
+		<box flexDirection="column">{node}</box>,
+		{ width, height },
+	);
+	await act(async () => {
+		await renderOnce();
+		await renderOnce();
+	});
+	const frame = captureCharFrame();
+	await act(async () => renderer.destroy());
+	return frame;
+}
+
+/** An absolute path to a binary, anywhere in a string. */
+const BINARY_PATH = /(^|[\s'"(])\/[^\s'"]*\/bin\/[\w.-]+/;
+
+// ── B1 / B2 ──────────────────────────────────────────────────────────────────
+
+describe("B1/B2: installer failures keep their own fix and never print a binary path", () => {
+	const ABS_NPM = { cmd: "/usr/local/bin/npm", args: ["install", "-g", "x"] };
+
+	function execFailed(stderr: string, code: number | null = 1): RunResult {
+		return {
+			exitCode: code,
+			signal: null,
+			timedOut: false,
+			outputTail: stderr,
+			durationMs: 0,
+		};
+	}
+
+	test("the spec's two examples read without the path", () => {
+		expect(
+			commandFailureReason(
+				ABS_NPM,
+				{
+					exitCode: null,
+					signal: null,
+					timedOut: false,
+					spawnError: `spawn ${ABS_NPM.cmd} ENOENT`,
+					outputTail: "",
+					durationMs: 0,
+				},
+				60_000,
+			),
+		).toBe("npm is not installed on this machine");
+		expect(commandFailureReason(ABS_NPM, execFailed(""), 60_000)).toBe(
+			"npm exited with code 1",
+		);
+	});
+
+	test("a missing claude by absolute path is the claude-not-found wording, with the install fix", () => {
+		const cmd = { cmd: "/Users/someone/.local/bin/claude", args: ["update"] };
+		const reason = commandFailureReason(
+			cmd,
+			{
+				exitCode: null,
+				signal: null,
+				timedOut: false,
+				spawnError: `spawn ${cmd.cmd} ENOENT`,
+				outputTail: "",
+				durationMs: 0,
+			},
+			60_000,
+		);
+		expect(reason).toBe("claude CLI not found in PATH");
+		const report = cliToolFailureReport("Claude Code was not updated", [
+			{ tool: "Claude Code", command: cmd, reason },
+		]);
+		expect(report?.fix).toBe(INSTALL_CLAUDE_FIX);
+	});
+
+	test("an installer's own output that names a binary path loses the path", () => {
+		const reason = commandFailureReason(
+			ABS_NPM,
+			execFailed("sh: /opt/homebrew/bin/node: bad CPU type in executable"),
+			60_000,
+		);
+		expect(reason).toContain("node: bad CPU type");
+		expect(reason).not.toMatch(BINARY_PATH);
+	});
+
+	test("timeout, network: each keeps its own fix", () => {
+		const timeout = cliToolFailureReport("x was not updated", [
+			{
+				tool: "x",
+				command: ABS_NPM,
+				reason: "did not finish within 60 seconds",
+			},
+		]);
+		expect(timeout?.fix).toBe(RETRY_TIMEOUT_FIX);
+		const network = cliToolFailureReport("x was not updated", [
+			{
+				tool: "x",
+				command: ABS_NPM,
+				reason:
+					"network request to https://registry.test failed, reason: getaddrinfo ENOTFOUND",
+			},
+		]);
+		expect(network?.fix).toBe(RETRY_NETWORK_FIX);
+	});
+
+	test("NEGATIVE CONTROL: an ordinary failure still offers the command to run by hand", () => {
+		const report = cliToolFailureReport("x was not installed", [
+			{ tool: "x", command: ABS_NPM, reason: "permission denied" },
+		]);
+		expect(report?.fix).toBe(
+			"Run it yourself: /usr/local/bin/npm install -g x",
+		);
+	});
+});
+
+// ── B3 ───────────────────────────────────────────────────────────────────────
+
+describe("B3: a settings file that does not parse is named the way the user knows it", () => {
+	const home = os.homedir();
+
+	test("USER settings → ~/.claude/settings.json; the reason carries no absolute path", () => {
+		const file = join(home, ".claude", "settings.json");
+		const report = stepFailureReport(
+			"The profile was not switched",
+			"profile work",
+			new SettingsParseError(
+				file,
+				new SyntaxError(`JSON Parse error in ${file}: Expected '}'`),
+			),
+		);
+		expect(report.rows).toHaveLength(1);
+		expect(report.rows[0]?.subject).toBe("~/.claude/settings.json");
+		expect(report.rows[0]?.reason).toContain("is not valid JSON");
+		expect(report.rows[0]?.reason).not.toContain(home);
+		expect(report.fix).toBe(FIX_BY_HAND);
+	});
+
+	test("a project's file → relative to the project", () => {
+		expect(
+			userFacingPath(
+				"/work/app/.claude/settings.local.json",
+				"/work/app",
+				"/home/u",
+			),
+		).toBe(".claude/settings.local.json");
+		// Another project's file still reads from its `.claude/` on.
+		expect(
+			userFacingPath(
+				"/tmp/other/.claude/settings.json",
+				"/work/app",
+				"/home/u",
+			),
+		).toBe(".claude/settings.json");
+	});
+
+	test("a spawn-shaped missing claude is recognised, with the install fix", () => {
+		const report = stepFailureReport(
+			"Plugins were not refreshed",
+			"magus",
+			Object.assign(new Error("spawn /usr/local/bin/claude ENOENT"), {
+				code: "ENOENT",
+			}),
+			"Run it yourself: claude plugin marketplace update magus",
+		);
+		expect(report.rows[0]?.reason).toBe("claude CLI not found in PATH");
+		expect(report.fix).toBe(INSTALL_CLAUDE_FIX);
+	});
+
+	test("NEGATIVE CONTROL: a file-not-found ENOENT is not read as a missing claude", () => {
+		const report = stepFailureReport(
+			"Nothing was saved",
+			"styles",
+			new Error("ENOENT: no such file or directory, open 'x.json'"),
+		);
+		expect(report.rows[0]?.reason).toContain("no such file");
+		expect(report.fix).toBeNull();
+	});
+});
+
+// ── R1 ───────────────────────────────────────────────────────────────────────
+
+describe("R1: a server added from the registry shows as installed, needing a restart", () => {
+	const server = {
+		name: "io.example/docs",
+		short_description: "docs",
+		version: "1.2.0",
+		url: "https://example.invalid/mcp",
+	} as never;
+
+	test("its row and detail carry installed and the restart", async () => {
+		const item = { server, isInstalled: true, needsRestart: true };
+		const frame = await frameOf(
+			<>
+				{renderMcpRegistryRow(item, 0, false)}
+				{renderMcpRegistryRow(item, 0, true)}
+				{renderMcpRegistryStatus(item)}
+			</>,
+		);
+		const lines = frame.split("\n");
+		expect(lines[0]).toContain(
+			"● io.example/docs v1.2.0 ↻ restart Claude Code",
+		);
+		expect(lines[1]).toContain(
+			"● io.example/docs v1.2.0 ↻ restart Claude Code",
+		);
+		expect(frame).toContain("● Installed");
+		expect(frame).toContain("after restarting Claude Code");
+	});
+
+	test("NEGATIVE CONTROL: a server not touched this session says neither", async () => {
+		const item = { server, isInstalled: false, needsRestart: false };
+		const frame = await frameOf(
+			<>
+				{renderMcpRegistryRow(item, 0, false)}
+				{renderMcpRegistryStatus(item)}
+			</>,
+		);
+		expect(frame).not.toContain("restart");
+		expect(frame).not.toContain("●");
+		expect(frame).toContain("○ Not installed");
+	});
+});
+
+// ── R2 ───────────────────────────────────────────────────────────────────────
+
+describe("R2: deprecated plugins that require each other are removed in one pass", () => {
+	const action = (items: PluginUpdateItem[], id: string) =>
+		items.find((i) => i.pluginId === id)?.action;
+
+	test("a chain A → B, both deprecated: both removed", () => {
+		const items = planPluginUpdates(
+			{},
+			[LISTED, orphan("a@magus"), orphan("b@magus")],
+			{ "b@magus": ["a@magus"] },
+		);
+		expect(action(items, "a@magus")).toBe("remove");
+		expect(action(items, "b@magus")).toBe("remove");
+		expect(items.find((i) => i.pluginId === "b@magus")?.scopes).toEqual([
+			"project",
+		]);
+	});
+
+	test("a cycle A ↔ B, both deprecated: both removed", () => {
+		const items = planPluginUpdates(
+			{},
+			[LISTED, orphan("a@magus"), orphan("b@magus")],
+			{ "a@magus": ["b@magus"], "b@magus": ["a@magus"] },
+		);
+		expect(action(items, "a@magus")).toBe("remove");
+		expect(action(items, "b@magus")).toBe("remove");
+	});
+
+	test("`--check` right after the removal is clean", () => {
+		// What the apply leaves behind: neither installed, and the profile no
+		// longer naming them. The edges went with the plugins' own plugin.json.
+		const after = planPluginUpdates({ "dev@magus": "latest" }, [LISTED], {});
+		expect(planIsBehind(plan(after))).toBe(false);
+	});
+
+	test("a requirer that stays keeps its dependency, and the note names THAT requirer", () => {
+		// b is required by a (deprecated, removed) and by dev (listed, stays).
+		const items = planPluginUpdates(
+			{},
+			[LISTED, orphan("a@magus"), orphan("b@magus")],
+			{ "b@magus": ["a@magus", "dev@magus"] },
+		);
+		expect(action(items, "a@magus")).toBe("remove");
+		const b = items.find((i) => i.pluginId === "b@magus");
+		expect(b).toMatchObject({ action: "unknown", reason: "still-required" });
+		expect(b?.note).toBe("no longer published, but dev still requires it");
+	});
+
+	test("NEGATIVE CONTROL: judged one at a time, the chain's dependency is kept", () => {
+		const index = indexCatalog([LISTED, orphan("a@magus"), orphan("b@magus")]);
+		expect(
+			classifyPlugin("b@magus", "latest", index, { "b@magus": ["a@magus"] })
+				.reason,
+		).toBe("still-required");
+	});
+
+	test("requirersHere records every requirer, the profile's first", async () => {
+		const edges = await requirersHere(
+			{ "b@magus": "p@magus" },
+			["a@magus", "c@magus"],
+			"/tmp/r2",
+			async (id) => (id === "a@magus" || id === "c@magus" ? ["b@magus"] : []),
+		);
+		expect(edges).toEqual({ "b@magus": ["p@magus", "a@magus", "c@magus"] });
+		// The single-requirer view is unchanged: the profile's wins.
+		expect(
+			await requiredByHere(
+				{ "b@magus": "p@magus" },
+				["a@magus", "c@magus"],
+				"/tmp/r2",
+				async (id) => (id === "a@magus" || id === "c@magus" ? ["b@magus"] : []),
+			),
+		).toEqual({ "b@magus": "p@magus" });
+	});
+});
+
+// ── R4 ───────────────────────────────────────────────────────────────────────
+
+describe("R4: an MCP server that still lacks variables is lasting state on the plugin", () => {
+	function deps(configured: Record<string, string>): PluginEnvNeedsDeps {
+		return {
+			sourcePath: async () => "./plugins/figma",
+			requirements: async () => [
+				{
+					name: "FIGMA_TOKEN",
+					label: "Figma Token",
+					serverName: "figma",
+					required: true,
+				},
+				{
+					name: "FIGMA_TEAM",
+					label: "Figma Team",
+					serverName: "figma",
+					required: true,
+				},
+			],
+			configured: async () => configured,
+		};
+	}
+
+	test("derived from current config: two unset, one set, none once both are set", async () => {
+		const env = {};
+		expect(
+			(await missingPluginEnvVars("magus", "figma", "/p", env, deps({})))
+				.length,
+		).toBe(2);
+		expect(
+			(
+				await missingPluginEnvVars(
+					"magus",
+					"figma",
+					"/p",
+					env,
+					deps({ FIGMA_TOKEN: "t" }),
+				)
+			).map((r) => r.name),
+		).toEqual(["FIGMA_TEAM"]);
+		expect(
+			await missingPluginEnvVars(
+				"magus",
+				"figma",
+				"/p",
+				{ FIGMA_TEAM: "x" },
+				deps({ FIGMA_TOKEN: "t" }),
+			),
+		).toEqual([]);
+	});
+
+	function item(needed?: number): PluginPluginItem {
+		const plugin = info({
+			id: "figma@magus",
+			version: "1.0.0",
+			installedVersion: "1.0.0",
+			description: "Figma.",
+			projectScope: { installed: true, version: "1.0.0" },
+		});
+		return {
+			id: `pl:${plugin.id}`,
+			kind: "plugin",
+			label: plugin.name,
+			plugin,
+			isExpandable: false,
+			isExpanded: false,
+			status: null,
+			...(needed ? { mcpSettingsNeeded: needed } : {}),
+		};
+	}
+
+	test("the row carries ⚙ and the detail says how many and the key", async () => {
+		expect(pluginRowText(item(2)).text).toContain("⚙");
+		const frame = await frameOf(
+			renderPluginDetail(item(2), new Set<string>()),
+			120,
+			40,
+		);
+		expect(frame).toContain(
+			"its MCP server needs 2 settings — press e to set them",
+		);
+	});
+
+	test("NEGATIVE CONTROL: nothing missing, nothing said", async () => {
+		expect(pluginRowText(item()).text).not.toContain("⚙");
+		const frame = await frameOf(
+			renderPluginDetail(item(), new Set<string>()),
+			120,
+			40,
+		);
+		expect(frame).not.toContain("MCP server needs");
+	});
+});
+
+// ── R6 ───────────────────────────────────────────────────────────────────────
+
+describe("R6: moved and still-required are kept on purpose, not unverified", () => {
+	const MOVED_TO = info({
+		id: "seo@magus-marketing",
+		version: "1.1.0",
+		marketplaceDisplay: "Magus Marketing",
+	});
+
+	function items(): PluginUpdateItem[] {
+		return planPluginUpdates(
+			{},
+			[LISTED, MOVED_TO, orphan("seo@magus"), orphan("kanban@magus")],
+			{ "kanban@magus": ["dev@magus"] },
+		);
+	}
+
+	beforeEach(() => setColorEnabled(false));
+	afterEach(() => setColorEnabled(true));
+
+	test("CLI: listed under Deprecated as 'kept' with the note; never under Unverified", () => {
+		const lines = planReport(plan(items())).map(stripAnsi);
+		const text = lines.join("\n");
+		expect(text).not.toContain("Unverified");
+		const deprecated = lines.findIndex((l) => /^\s*Deprecated\b/.test(l));
+		expect(deprecated).toBeGreaterThanOrEqual(0);
+		const seo = lines.find((l) => l.includes("seo@magus"));
+		const kanban = lines.find((l) => l.includes("kanban@magus"));
+		expect(seo).toContain("kept — moved to Magus Marketing");
+		expect(kanban).toContain(
+			"kept — no longer published, but dev still requires it",
+		);
+		expect(seo).not.toContain("?");
+	});
+
+	test("CLI: not counted as 'could not be checked'; counted as kept", () => {
+		const counts = summarizePlan(plan(items()));
+		expect(counts.unknownPlugins).toBe(0);
+		expect(counts.unknown).toBe(0);
+		expect(counts.kept).toBe(2);
+		const line = stripAnsi(
+			summaryLine(0, 1, counts.unknown, 0, 10, 0, 2)[1] ?? "",
+		);
+		expect(line).toContain("2 kept");
+		expect(line).not.toContain("unverified");
+	});
+
+	test("TUI: muted with the note; the detail says KEPT", async () => {
+		const seo = items().find(
+			(i) => i.pluginId === "seo@magus",
+		) as PluginUpdateItem;
+		expect(isKeptDeprecated(seo)).toBe(true);
+		expect(pluginStatusText(seo)).toEqual({
+			suffix: " moved to Magus Marketing",
+			tone: "muted",
+		});
+		const plugin = orphan("seo@magus");
+		const frame = await frameOf(
+			renderPluginDetail(
+				{
+					id: "pl:seo@magus",
+					kind: "plugin",
+					label: "seo",
+					plugin,
+					isExpandable: false,
+					isExpanded: false,
+					status: seo,
+				},
+				new Set<string>(),
+			),
+			120,
+			30,
+		);
+		expect(frame).toContain("KEPT");
+		expect(frame).not.toContain("UNKNOWN");
+	});
+
+	test("NEGATIVE CONTROL: a marketplace that was not read is still unverified", () => {
+		const unread = planPluginUpdates({}, [orphan("x@elsewhere")]);
+		const [x] = unread;
+		expect(x).toMatchObject({
+			action: "unknown",
+			reason: "marketplace-unread",
+		});
+		expect(isKeptDeprecated(x as PluginUpdateItem)).toBe(false);
+		expect(summarizePlan(plan(unread)).unknownPlugins).toBe(1);
+		expect(pluginStatusText(x as PluginUpdateItem).tone).toBe("warning");
+		setColorEnabled(false);
+		expect(planReport(plan(unread)).map(stripAnsi).join("\n")).toContain(
+			"Unverified",
+		);
+	});
+});
+
+// ── R7 ───────────────────────────────────────────────────────────────────────
+
+describe("R7: a spawn in a folder that no longer exists says so", () => {
+	let dir: string;
+	beforeEach(async () => {
+		dir = await mkdtemp(join(tmpdir(), "magus-r7-"));
+	});
+	afterEach(async () => {
+		await rm(dir, { recursive: true, force: true });
+	});
+
+	const enoent = () =>
+		Object.assign(new Error("spawn /usr/local/bin/claude ENOENT"), {
+			code: "ENOENT",
+		});
+
+	test("ENOENT with a vanished cwd names the folder, not its path", async () => {
+		const gone = join(dir, "old-worktree");
+		const message = claudeFailureMessage(
+			enoent(),
+			["plugin", "install"],
+			30_000,
+			gone,
+		);
+		expect(message).toBe("the folder old-worktree no longer exists");
+		expect(message).not.toContain(dir);
+	});
+
+	test("NEGATIVE CONTROL: ENOENT with a cwd that exists is a missing claude", () => {
+		const message = claudeFailureMessage(
+			enoent(),
+			["plugin", "install"],
+			30_000,
+			dir,
+		);
+		expect(message).toMatch(/^claude CLI not found in PATH/);
+	});
+});
+
+// ── R8 ───────────────────────────────────────────────────────────────────────
+
+describe("R8: one startup popup, shown before the profile question", () => {
+	function activation(over: Partial<ActivationResult> = {}): ActivationResult {
+		return {
+			profileId: "team",
+			displaced: [],
+			skills: { skills: {}, installed: [], removed: [], failed: [] },
+			conversion: {
+				converted: false,
+				managed: {},
+				restored: [],
+				conflicts: [],
+				keptAt: null,
+			},
+			tracked: [],
+			keptAt: null,
+			...over,
+		};
+	}
+	const PROBLEM =
+		".claude/settings.json cannot be read (bad JSON) — fix it by hand; magus left it as it is and did not switch";
+	const UNREADABLE = activation({
+		dependencies: { derived: [], unreadable: ["mnemex@magus"], blocked: [] },
+	});
+
+	test("gate problems and activation failures merge into ONE report, each row keeping its fix", () => {
+		const report = profileStartupReport(
+			[PROBLEM],
+			[UNREADABLE],
+		) as FailureReport;
+		expect(report.headline).toBe(PROFILE_STARTUP_HEADLINE);
+		expect(report.rows.map((r) => r.subject)).toEqual([
+			".claude/settings.json",
+			"mnemex",
+		]);
+		expect(report.rows.map((r) => r.fix)).toEqual([
+			"Fix it by hand",
+			"Run magus install",
+		]);
+	});
+
+	test("NEGATIVE CONTROL: only one kind keeps its own headline", () => {
+		expect(profileStartupReport([PROBLEM], [])?.headline).toBe(
+			"This project's profile was not brought up to date",
+		);
+		expect(profileStartupReport([], [UNREADABLE])?.headline).toContain(
+			'Profile "team" is active',
+		);
+		expect(profileStartupReport([], [])).toBeNull();
+		expect(mergeFailureReports("x", [null, undefined])).toBeNull();
+	});
+
+	test("a report and the profile question queued in one tick: report first, question second", () => {
+		const report = profileStartupReport(
+			[PROBLEM],
+			[UNREADABLE],
+		) as FailureReport;
+		const need = { kind: "choose" };
+		// Both arrive together — the startup effect queues the report and sets
+		// the need in the same tick.
+		const first = nextStartupStep({
+			modalOpen: false,
+			reports: [report],
+			gitignoreReady: false,
+			brokenCount: null,
+			profileNeed: need,
+		});
+		expect(first).toEqual({ kind: "report", report, rest: [] });
+		// While the popup is open nothing else is shown.
+		expect(
+			nextStartupStep({
+				modalOpen: true,
+				reports: [],
+				gitignoreReady: false,
+				brokenCount: null,
+				profileNeed: need,
+			}),
+		).toBeNull();
+		// Dismissed: the slot is free and the queue empty — now the question.
+		expect(
+			nextStartupStep({
+				modalOpen: false,
+				reports: first?.kind === "report" ? first.rest : [],
+				gitignoreReady: false,
+				brokenCount: null,
+				profileNeed: need,
+			}),
+		).toEqual({ kind: "profile", need });
+	});
+
+	test("NEGATIVE CONTROL: with no report queued the question comes straight away", () => {
+		const need = { kind: "choose" };
+		expect(
+			nextStartupStep({
+				modalOpen: false,
+				reports: [],
+				gitignoreReady: false,
+				brokenCount: null,
+				profileNeed: need,
+			}),
+		).toEqual({ kind: "profile", need });
+	});
+});