magus-cli 7.7.0 → 7.9.0

package/src/__tests__/blind-780-cli-tools.test.ts

@@ -0,0 +1,796 @@
+/**
+ * magus 7.8.0 QA — CLI Tools failure reports and step failure reports (C1–C6).
+ *
+ * Written blind: from the caller's C1–C6 behaviour spec and the exported
+ * declarations of ui/adapters/cliToolsAdapter.ts, ui/adapters/startupReports.ts,
+ * ui/adapters/failureReport.ts, ui/state/types.ts, utils/command-utils.ts and
+ * services/settings-file.ts (emitted with `tsc --emitDeclarationOnly`). No
+ * function body was read.
+ *
+ * Coverage map (requirement → describe block):
+ *   C1 commandFailureReason: stderr first, npm noise skipped, missing
+ *      installer and timeout said plainly, never "Command failed: <cmd>" → "C1"
+ *   C2 one tool action: headline verb, "Run it yourself: <cmd>" fix,
+ *      except timeout / missing claude / network keep their own fix     → "C2"
+ *   C3 update-all: one row per failed tool with its reason               → "C3"
+ *   C4 conflict stuck / partial reports                                  → "C4"
+ *   C5 stepFailureReport: settings file that does not parse, fallback fix → "C5"
+ *   C6 no internal word or absolute binary path in headline/reason       → "C6"
+ *
+ * Failures are built in the shape `runArgv` resolves with (`RunResult`):
+ * the exit code, whether the timeout killed it, the combined output tail, and
+ * for a missing executable a `spawn <cmd> ENOENT` spawn error. Nothing is
+ * spawned.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { SettingsParseError } from "../services/settings-file.js";
+import {
+	type CliToolCommandFailure,
+	cliToolConflictPartialReport,
+	cliToolConflictStuckReport,
+	cliToolFailureReport,
+	cliToolNotDone,
+	cliToolsNotUpdatedReport,
+	commandFailureReason,
+} from "../ui/adapters/cliToolsAdapter.js";
+import {
+	FIX_BY_HAND,
+	stepFailureReport,
+} from "../ui/adapters/startupReports.js";
+import type { FailureReport } from "../ui/state/types.js";
+import type { Command } from "../utils/command-utils.js";
+import type { RunResult } from "../utils/run.js";
+
+/** The installer timeout the spec names: 60 seconds. */
+const TIMEOUT_MS = 60_000;
+
+/**
+ * "Says it timed out" (C1): the words "timed out", or saying plainly that it
+ * did not finish within the limit. The spec fixes the meaning, not the wording.
+ */
+const TIMED_OUT =
+	/timed out|time ?out|did not finish (with)?in|took longer than|ran out of time/i;
+
+const NPM_INSTALL: Command = {
+	cmd: "npm",
+	args: ["install", "-g", "claudish"],
+};
+const NPM_UPDATE: Command = {
+	cmd: "npm",
+	args: ["install", "-g", "claudish@latest"],
+};
+const CLAUDE_UPDATE: Command = { cmd: "claude", args: ["update"] };
+const BREW_UPGRADE: Command = { cmd: "brew", args: ["upgrade", "tmux"] };
+
+function line(c: Command): string {
+	return [c.cmd, ...c.args].join(" ");
+}
+
+interface ExecErrorShape {
+	command: Command;
+	stderr?: string;
+	stdout?: string;
+	code?: number | string | null;
+	killed?: boolean;
+	signal?: string | null;
+}
+
+/** What `runArgv` resolves with when the command ran and failed. */
+function execError(o: ExecErrorShape): RunResult {
+	return {
+		exitCode:
+			typeof o.code === "number" ? o.code : o.code === undefined ? 1 : null,
+		signal: o.signal ?? null,
+		timedOut: o.killed ?? false,
+		outputTail: [o.stdout ?? "", o.stderr ?? ""].filter(Boolean).join("\n"),
+		durationMs: 0,
+	};
+}
+
+/** What `runArgv` resolves with when the executable does not exist. */
+function enoent(command: Command): RunResult {
+	return {
+		exitCode: null,
+		signal: null,
+		timedOut: false,
+		spawnError: `spawn ${command.cmd} ENOENT`,
+		outputTail: "",
+		durationMs: 0,
+	};
+}
+
+/** What a spawn throws when the executable does not exist (a step's error). */
+function enoentError(command: Command): Error {
+	return Object.assign(new Error(`spawn ${command.cmd} ENOENT`), {
+		code: "ENOENT",
+		syscall: `spawn ${command.cmd}`,
+		path: command.cmd,
+	});
+}
+
+/** What `runArgv` resolves with when its timeout killed the child. */
+function timedOut(command: Command, partialStderr = ""): RunResult {
+	return execError({
+		command,
+		code: null,
+		killed: true,
+		signal: "SIGTERM",
+		stderr: partialStderr,
+	});
+}
+
+/** npm's real E404 stderr, with the bookkeeping lines around the cause. */
+const NPM_404_STDERR = [
+	"npm error code E404",
+	"npm error 404 Not Found - GET https://npm.example.test/claudish-nope - Not found",
+	"npm error 404",
+	"npm error 404  'claudish-nope@*' is not in this package index.",
+	"npm error A complete log of this run can be found in: /Users/someone/.npm/_logs/2026-09-29T10_00_00_000Z-debug-0.log",
+].join("\n");
+
+/** npm's errno-style stderr, EACCES. */
+const NPM_EACCES_STDERR = [
+	"npm error code EACCES",
+	"npm error syscall mkdir",
+	"npm error path /usr/local/lib/node_modules/claudish",
+	"npm error errno -13",
+	"npm error Error: EACCES: permission denied, mkdir '/usr/local/lib/node_modules/claudish'",
+	"npm error A complete log of this run can be found in: /Users/someone/.npm/_logs/x-debug-0.log",
+].join("\n");
+
+/** npm's network stderr (DNS failure). */
+const NPM_NETWORK_STDERR = [
+	"npm error code ENOTFOUND",
+	"npm error syscall getaddrinfo",
+	"npm error errno ENOTFOUND",
+	"npm error network request to https://npm.example.test/claudish failed, reason: getaddrinfo ENOTFOUND npm.example.test",
+	"npm error network This is a problem related to network connectivity.",
+	"npm error network In most cases you are behind a proxy or have bad network settings.",
+	"npm error A complete log of this run can be found in: /Users/someone/.npm/_logs/y-debug-0.log",
+].join("\n");
+
+const NPM_NOISE: RegExp[] = [
+	/npm error code\b/i,
+	/npm error errno\b/i,
+	/A complete log of this run can be found in/i,
+];
+
+/** Words a user-facing headline or reason must never contain (C6). */
+const FORBIDDEN: RegExp[] = [
+	/loader/i,
+	/registry/i,
+	/\brows?\b/i,
+	/\brecords?\b/i,
+	/installed_plugins/i,
+	/** An absolute path to a binary: …/bin/<name>. */
+	/(^|[\s'"(])\/[^\s'"]*\/bin\/[\w.-]+/,
+];
+
+function leaks(text: string): string[] {
+	return FORBIDDEN.filter((re) => re.test(text)).map((re) => re.source);
+}
+
+/** Every headline and reason in a report, for the C6 sweep. */
+function wordsOf(r: FailureReport | null): string[] {
+	if (!r) return [];
+	return [r.headline, ...r.rows.map((row) => row.reason)];
+}
+
+/** Every fix the report carries: the shared one and each row's own. */
+function fixesOf(r: FailureReport): string[] {
+	const out: string[] = [];
+	if (r.fix) out.push(r.fix);
+	for (const row of r.rows) if (row.fix) out.push(row.fix);
+	return out;
+}
+
+/** All the text of a report, for "is X said anywhere" checks. */
+function allText(r: FailureReport): string {
+	return [
+		r.headline,
+		...r.rows.flatMap((row) => [row.subject, row.reason, row.fix ?? ""]),
+		r.fix ?? "",
+	].join("\n");
+}
+
+function failure(
+	tool: string,
+	command: Command,
+	error: unknown,
+): CliToolCommandFailure {
+	return {
+		tool,
+		command,
+		reason: commandFailureReason(command, error, TIMEOUT_MS),
+	};
+}
+
+// ---------------------------------------------------------------------------
+// C1 — commandFailureReason
+// ---------------------------------------------------------------------------
+
+describe("C1 commandFailureReason", () => {
+	test("C1: returns npm's own cause and skips its code/errno/log bookkeeping lines", () => {
+		const reason = commandFailureReason(
+			NPM_INSTALL,
+			execError({ command: NPM_INSTALL, stderr: NPM_404_STDERR }),
+			TIMEOUT_MS,
+		);
+		expect(reason).toContain("404 Not Found");
+		for (const noise of NPM_NOISE) expect(reason).not.toMatch(noise);
+		expect(reason).not.toContain("Command failed");
+	});
+
+	test("C1: skips an 'npm error errno' line and reaches the real EACCES cause", () => {
+		const reason = commandFailureReason(
+			NPM_INSTALL,
+			execError({
+				command: NPM_INSTALL,
+				stderr: NPM_EACCES_STDERR,
+				code: 243,
+			}),
+			TIMEOUT_MS,
+		);
+		expect(reason).toMatch(/permission denied/i);
+		for (const noise of NPM_NOISE) expect(reason).not.toMatch(noise);
+	});
+
+	test("C1: reads stderr before stdout and before the thrown message", () => {
+		const reason = commandFailureReason(
+			BREW_UPGRADE,
+			execError({
+				command: BREW_UPGRADE,
+				stdout: "==> Fetching downloads for: tmux",
+				stderr: 'Error: No available formula with the name "tmux-nope".',
+			}),
+			TIMEOUT_MS,
+		);
+		expect(reason).toContain("No available formula");
+		expect(reason).not.toContain("Fetching downloads");
+	});
+
+	test("C1: is one line, even when stderr has many", () => {
+		const reason = commandFailureReason(
+			NPM_INSTALL,
+			execError({ command: NPM_INSTALL, stderr: NPM_EACCES_STDERR }),
+			TIMEOUT_MS,
+		);
+		expect(reason).not.toContain("\n");
+		expect(reason.trim().length).toBeGreaterThan(0);
+	});
+
+	test("C1: a missing installer says plainly that it is not there", () => {
+		const reason = commandFailureReason(
+			NPM_INSTALL,
+			enoent(NPM_INSTALL),
+			TIMEOUT_MS,
+		);
+		expect(reason).toContain("npm");
+		expect(reason).toMatch(
+			/not (installed|found|on (your )?PATH)|missing|cannot be found|could not be found|no npm/i,
+		);
+		expect(reason).not.toMatch(/ENOENT/);
+		expect(reason).not.toMatch(/\bspawn\b/);
+		expect(reason).not.toContain("Command failed");
+	});
+
+	test("C1: a missing installer given by absolute path does not print that path", () => {
+		const cmd: Command = {
+			cmd: "/opt/homebrew/bin/brew",
+			args: ["install", "tmux"],
+		};
+		const reason = commandFailureReason(cmd, enoent(cmd), TIMEOUT_MS);
+		expect(reason).not.toContain("/opt/homebrew/bin/brew");
+		expect(reason).toContain("brew");
+		expect(reason).not.toMatch(/ENOENT/);
+	});
+
+	test("C1: when the 60-second timeout killed it, says it timed out", () => {
+		const reason = commandFailureReason(
+			NPM_INSTALL,
+			timedOut(NPM_INSTALL),
+			TIMEOUT_MS,
+		);
+		expect(reason).toMatch(TIMED_OUT);
+		expect(reason).not.toContain("Command failed");
+	});
+
+	test("C1: a timeout wins over whatever partial stderr the installer had written", () => {
+		const reason = commandFailureReason(
+			NPM_INSTALL,
+			timedOut(
+				NPM_INSTALL,
+				"npm http fetch GET 200 https://npm.example.test/claudish 812ms",
+			),
+			TIMEOUT_MS,
+		);
+		expect(reason).toMatch(TIMED_OUT);
+	});
+
+	test("C1: never returns a bare 'Command failed: <cmd>' when stderr and stdout are empty", () => {
+		const reason = commandFailureReason(
+			NPM_INSTALL,
+			execError({ command: NPM_INSTALL, code: 1 }),
+			TIMEOUT_MS,
+		);
+		expect(reason).not.toContain("Command failed");
+		expect(reason).not.toBe(line(NPM_INSTALL));
+		expect(reason.trim().length).toBeGreaterThan(0);
+	});
+
+	test("C1: an installer that printed nothing still yields a non-empty reason", () => {
+		const reason = commandFailureReason(
+			NPM_INSTALL,
+			execError({ command: NPM_INSTALL }),
+			TIMEOUT_MS,
+		);
+		expect(reason).toBe("npm exited with code 1");
+	});
+});
+
+// ---------------------------------------------------------------------------
+// C2 — one tool action
+// ---------------------------------------------------------------------------
+
+describe("C2 cliToolFailureReport (one tool action)", () => {
+	test("C2: each action has its own verb — installed, updated, reinstalled", () => {
+		expect(cliToolNotDone("install")).toMatch(/\binstalled$/);
+		expect(cliToolNotDone("update")).toMatch(/\bupdated$/);
+		expect(cliToolNotDone("reinstall")).toMatch(/\breinstalled$/);
+	});
+
+	/**
+	 * The declaration documents `cliToolNotDone` as returning the headline's
+	 * negative phrase: `/** What an Enter action did not do, for the headline:
+	 * "was not installed". *\/`. This pins that documented contract.
+	 */
+	// Resolved after the blind run: the doc comment was wrong, not the code. The
+	// function returns the verb and the screen builds "<tool> was not <verb>".
+	test("C2: cliToolNotDone returns the verb the headline puts after 'was not'", () => {
+		expect(cliToolNotDone("install")).toBe("installed");
+		expect(cliToolNotDone("update")).toBe("updated");
+		expect(cliToolNotDone("reinstall")).toBe("reinstalled");
+	});
+
+	test("C2: an ordinary failure: headline '<tool> was not updated', one row, fix 'Run it yourself: <cmd>'", () => {
+		const f = failure(
+			"claudish",
+			NPM_UPDATE,
+			execError({ command: NPM_UPDATE, stderr: NPM_EACCES_STDERR }),
+		);
+		const headline = "claudish was not updated";
+		const report = cliToolFailureReport(headline, [f]);
+		expect(report).not.toBeNull();
+		if (!report) return;
+		expect(report.headline).toBe("claudish was not updated");
+		expect(report.rows).toHaveLength(1);
+		expect(report.rows[0]?.subject).toContain("claudish");
+		expect(report.rows[0]?.reason).toMatch(/permission denied/i);
+		expect(report.fix).toBe("Run it yourself: npm install -g claudish@latest");
+	});
+
+	test("C2: an install failure names the install command in the fix", () => {
+		const f = failure(
+			"claudish",
+			NPM_INSTALL,
+			execError({ command: NPM_INSTALL, stderr: NPM_404_STDERR }),
+		);
+		const report = cliToolFailureReport("claudish was not installed", [f]);
+		expect(report?.headline).toBe("claudish was not installed");
+		expect(report?.rows).toHaveLength(1);
+		expect(report?.rows[0]?.reason).toContain("404 Not Found");
+		expect(report?.fix).toBe("Run it yourself: npm install -g claudish");
+	});
+
+	test("C2: a timeout keeps its own fix, not 'Run it yourself'", () => {
+		const f = failure("claudish", NPM_UPDATE, timedOut(NPM_UPDATE));
+		const report = cliToolFailureReport(
+			`claudish ${cliToolNotDone("update")}`,
+			[f],
+		);
+		expect(report).not.toBeNull();
+		if (!report) return;
+		const fixes = fixesOf(report);
+		expect(fixes.length).toBeGreaterThan(0);
+		for (const fix of fixes) expect(fix).not.toMatch(/^Run it yourself/);
+	});
+
+	test("C2: a missing claude keeps its own fix, not 'Run it yourself: claude update'", () => {
+		const f = failure("Claude Code", CLAUDE_UPDATE, enoent(CLAUDE_UPDATE));
+		const report = cliToolFailureReport(
+			`Claude Code ${cliToolNotDone("update")}`,
+			[f],
+		);
+		expect(report).not.toBeNull();
+		if (!report) return;
+		const fixes = fixesOf(report);
+		expect(fixes.length).toBeGreaterThan(0);
+		for (const fix of fixes) {
+			expect(fix).not.toMatch(/^Run it yourself/);
+			expect(fix).not.toContain("claude update");
+		}
+	});
+
+	test("C2: a network failure keeps its own fix, not 'Run it yourself'", () => {
+		const f = failure(
+			"claudish",
+			NPM_UPDATE,
+			execError({ command: NPM_UPDATE, stderr: NPM_NETWORK_STDERR }),
+		);
+		const report = cliToolFailureReport(
+			`claudish ${cliToolNotDone("update")}`,
+			[f],
+		);
+		expect(report).not.toBeNull();
+		if (!report) return;
+		const fixes = fixesOf(report);
+		expect(fixes.length).toBeGreaterThan(0);
+		for (const fix of fixes) expect(fix).not.toMatch(/^Run it yourself/);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// C3 — update-all
+// ---------------------------------------------------------------------------
+
+describe("C3 cliToolsNotUpdatedReport (update-all)", () => {
+	const TMUX_UPGRADE: Command = { cmd: "brew", args: ["upgrade", "tmux"] };
+	const failures: CliToolCommandFailure[] = [
+		{
+			tool: "claudish",
+			command: NPM_UPDATE,
+			reason: "permission denied, mkdir '~/.npm-global/lib'",
+		},
+		{
+			tool: "tmux",
+			command: TMUX_UPGRADE,
+			reason: 'No available formula with the name "tmux-nope"',
+		},
+	];
+
+	test("C3: one row per failed tool, naming the tool and carrying its reason", () => {
+		const report = cliToolsNotUpdatedReport(failures);
+		expect(report).not.toBeNull();
+		if (!report) return;
+		expect(report.rows).toHaveLength(2);
+		for (const f of failures) {
+			const row = report.rows.find((r) => r.subject.includes(f.tool));
+			expect(row).toBeDefined();
+			expect(row?.reason).toContain(f.reason);
+		}
+	});
+
+	test("C3: the headline says the tools were not updated", () => {
+		const report = cliToolsNotUpdatedReport(failures);
+		expect(report?.headline).toMatch(/not updated/i);
+	});
+
+	test("C3: a tool that succeeded is not listed", () => {
+		const report = cliToolsNotUpdatedReport([
+			failures[1] as CliToolCommandFailure,
+		]);
+		expect(report).not.toBeNull();
+		if (!report) return;
+		expect(report.rows).toHaveLength(1);
+		expect(allText(report)).not.toContain("claudish");
+		expect(report.rows[0]?.subject).toContain("tmux");
+	});
+
+	test("C3: when every tool updated there is no popup", () => {
+		expect(cliToolsNotUpdatedReport([])).toBeNull();
+	});
+});
+
+// ---------------------------------------------------------------------------
+// C4 — conflicts
+// ---------------------------------------------------------------------------
+
+describe("C4 conflict reports", () => {
+	test("C4 stuck: one row per install that could not be removed", () => {
+		const report = cliToolConflictStuckReport("claudish", [
+			{ method: "npm", reason: "npm is not on PATH" },
+			{ method: "Homebrew", reason: "the formula is pinned" },
+		]);
+		expect(report).not.toBeNull();
+		if (!report) return;
+		expect(report.rows).toHaveLength(2);
+		const npmRow = report.rows.find((r) =>
+			`${r.subject} ${r.reason}`.includes("npm"),
+		);
+		const brewRow = report.rows.find((r) =>
+			`${r.subject} ${r.reason}`.includes("Homebrew"),
+		);
+		expect(npmRow).toBeDefined();
+		expect(brewRow).toBeDefined();
+		expect(npmRow?.reason).toContain("npm is not on PATH");
+		expect(brewRow?.reason).toContain("the formula is pinned");
+		expect(report.headline).toContain("claudish");
+	});
+
+	test("C4 stuck: the fix tells the user to remove one by hand, then press r", () => {
+		const report = cliToolConflictStuckReport("claudish", [
+			{ method: "npm", reason: "npm is not on PATH" },
+			{ method: "Homebrew", reason: "the formula is pinned" },
+		]);
+		expect(report?.fix).toMatch(/remove/i);
+		expect(report?.fix).toMatch(/by hand/i);
+		expect(report?.fix).toMatch(/press r\b/i);
+	});
+
+	test("C4 partial: a failed removal is listed with the command to run by hand", () => {
+		const uninstall: Command = {
+			cmd: "npm",
+			args: ["uninstall", "-g", "claudish"],
+		};
+		const report = cliToolConflictPartialReport(
+			"claudish",
+			[{ method: "npm", command: uninstall, reason: "permission denied" }],
+			[],
+		);
+		expect(report).not.toBeNull();
+		if (!report) return;
+		expect(report.rows).toHaveLength(1);
+		expect(report.rows[0]?.reason).toContain("permission denied");
+		expect(allText(report)).toContain("npm uninstall -g claudish");
+	});
+
+	test("C4 partial: failed removals and installs left behind each get a row", () => {
+		const uninstall: Command = {
+			cmd: "npm",
+			args: ["uninstall", "-g", "claudish"],
+		};
+		const report = cliToolConflictPartialReport(
+			"claudish",
+			[{ method: "npm", command: uninstall, reason: "permission denied" }],
+			[{ method: "a standalone binary", reason: "magus did not install it" }],
+		);
+		expect(report).not.toBeNull();
+		if (!report) return;
+		expect(report.rows).toHaveLength(2);
+		const failedRow = report.rows.find((r) =>
+			r.reason.includes("permission denied"),
+		);
+		const leftRow = report.rows.find((r) =>
+			r.reason.includes("magus did not install it"),
+		);
+		expect(failedRow).toBeDefined();
+		expect(leftRow).toBeDefined();
+		expect(`${leftRow?.subject} ${leftRow?.reason}`).toContain(
+			"a standalone binary",
+		);
+		expect(allText(report)).toContain("npm uninstall -g claudish");
+		expect(report.headline).toContain("claudish");
+	});
+});
+
+// ---------------------------------------------------------------------------
+// C5 — stepFailureReport
+// ---------------------------------------------------------------------------
+
+describe("C5 stepFailureReport", () => {
+	const SETTINGS = "/tmp/blind-780-cli/.claude/settings.json";
+
+	function parseError(): SettingsParseError {
+		return new SettingsParseError(
+			SETTINGS,
+			new SyntaxError("JSON Parse error: Expected '}'"),
+		);
+	}
+
+	test("C5: a settings file that does not parse → the file is the subject", () => {
+		const report = stepFailureReport(
+			"The profile was not switched",
+			"profile work",
+			parseError(),
+		);
+		expect(report.rows).toHaveLength(1);
+		expect(report.rows[0]?.subject).toContain("settings.json");
+	});
+
+	test("C5: a settings file that does not parse → the problem is the reason", () => {
+		const err = parseError();
+		const report = stepFailureReport(
+			"The profile was not switched",
+			"profile work",
+			err,
+		);
+		expect(report.rows[0]?.reason).toContain(err.problem);
+		expect(report.rows[0]?.reason).not.toContain("\n");
+	});
+
+	test("C5: a settings file that does not parse → fix 'Fix the file by hand, then try again'", () => {
+		const report = stepFailureReport(
+			"The profile was not switched",
+			"profile work",
+			parseError(),
+		);
+		expect(FIX_BY_HAND).toBe("Fix the file by hand, then try again");
+		expect(report.fix).toBe("Fix the file by hand, then try again");
+	});
+
+	test("C5: the fallback fix does not replace the parse error's own fix", () => {
+		const report = stepFailureReport(
+			"The profile was not switched",
+			"profile work",
+			parseError(),
+			"Run it yourself: magus profile use team",
+		);
+		expect(report.fix).toBe(FIX_BY_HAND);
+		expect(fixesOf(report)).not.toContain(
+			"Run it yourself: magus profile use team",
+		);
+	});
+
+	test("C5: an unrecognised error takes the fallback fix, the subject and the first line as reason", () => {
+		const report = stepFailureReport(
+			"Plugins were not refreshed",
+			"magus",
+			new Error("something odd happened\n    at internal (file.ts:1:1)"),
+			"Run it yourself: claude plugin marketplace update magus",
+		);
+		expect(report.headline).toBe("Plugins were not refreshed");
+		expect(report.rows).toHaveLength(1);
+		expect(report.rows[0]?.subject).toBe("magus");
+		expect(report.rows[0]?.reason).toBe("something odd happened");
+		expect(report.fix).toBe(
+			"Run it yourself: claude plugin marketplace update magus",
+		);
+	});
+
+	test("C5: an unrecognised error with no fallback has no fix line", () => {
+		const report = stepFailureReport(
+			"Plugins were not refreshed",
+			"magus",
+			new Error("something odd happened"),
+		);
+		expect(report.fix).toBeNull();
+		expect(report.rows.every((r) => !r.fix)).toBe(true);
+	});
+
+	test("C5: a missing claude takes its own fix, not the fallback", () => {
+		const report = stepFailureReport(
+			"Plugins were not refreshed",
+			"magus",
+			enoentError({ cmd: "claude", args: ["plugin", "marketplace", "update"] }),
+			"Run it yourself: claude plugin marketplace update magus",
+		);
+		const fixes = fixesOf(report);
+		expect(fixes.length).toBeGreaterThan(0);
+		expect(fixes).not.toContain(
+			"Run it yourself: claude plugin marketplace update magus",
+		);
+	});
+
+	test("C5: a network failure takes its own fix, not the fallback", () => {
+		const err = Object.assign(new Error("getaddrinfo ENOTFOUND github.com"), {
+			code: "ENOTFOUND",
+			syscall: "getaddrinfo",
+			hostname: "github.com",
+		});
+		const report = stepFailureReport(
+			"Plugins were not refreshed",
+			"magus",
+			err,
+			"Run it yourself: claude plugin marketplace update magus",
+		);
+		const fixes = fixesOf(report);
+		expect(fixes.length).toBeGreaterThan(0);
+		expect(fixes).not.toContain(
+			"Run it yourself: claude plugin marketplace update magus",
+		);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// C6 — no internal words
+// ---------------------------------------------------------------------------
+
+describe("C6 no internal word in any headline or reason", () => {
+	const ABS_NPM: Command = {
+		cmd: "/usr/local/bin/npm",
+		args: ["install", "-g", "claudish"],
+	};
+	const ABS_CLAUDE: Command = {
+		cmd: "/Users/someone/.local/bin/claude",
+		args: ["update"],
+	};
+
+	const cases: Array<[string, FailureReport | null]> = [
+		[
+			"npm 404",
+			cliToolFailureReport("claudish was not installed", [
+				failure(
+					"claudish",
+					NPM_INSTALL,
+					execError({ command: NPM_INSTALL, stderr: NPM_404_STDERR }),
+				),
+			]),
+		],
+		[
+			"missing installer by absolute path",
+			cliToolFailureReport("claudish was not installed", [
+				failure("claudish", ABS_NPM, enoent(ABS_NPM)),
+			]),
+		],
+		[
+			"missing claude by absolute path",
+			cliToolFailureReport("Claude Code was not updated", [
+				failure("Claude Code", ABS_CLAUDE, enoent(ABS_CLAUDE)),
+			]),
+		],
+		[
+			"timeout by absolute path",
+			cliToolFailureReport("claudish was not updated", [
+				failure("claudish", ABS_NPM, timedOut(ABS_NPM)),
+			]),
+		],
+		[
+			"bare Command failed by absolute path",
+			cliToolFailureReport("claudish was not updated", [
+				failure("claudish", ABS_NPM, execError({ command: ABS_NPM })),
+			]),
+		],
+		[
+			"update-all",
+			cliToolsNotUpdatedReport([
+				failure(
+					"claudish",
+					ABS_NPM,
+					execError({ command: ABS_NPM, stderr: NPM_EACCES_STDERR }),
+				),
+				failure("tmux", BREW_UPGRADE, timedOut(BREW_UPGRADE)),
+			]),
+		],
+		[
+			"conflict stuck",
+			cliToolConflictStuckReport("claudish", [
+				{ method: "npm", reason: "npm is not on PATH" },
+				{ method: "Homebrew", reason: "the formula is pinned" },
+			]),
+		],
+		[
+			"conflict partial",
+			cliToolConflictPartialReport(
+				"claudish",
+				[
+					{
+						method: "npm",
+						command: { cmd: "npm", args: ["uninstall", "-g", "claudish"] },
+						reason: "permission denied",
+					},
+				],
+				[{ method: "a standalone binary", reason: "magus did not install it" }],
+			),
+		],
+		[
+			"step: settings parse",
+			stepFailureReport(
+				"The profile was not switched",
+				"profile work",
+				new SettingsParseError(
+					"/tmp/blind-780-cli/.claude/settings.json",
+					new SyntaxError("JSON Parse error: Expected '}'"),
+				),
+			),
+		],
+		[
+			"step: missing claude by absolute path",
+			stepFailureReport(
+				"Plugins were not refreshed",
+				"magus",
+				enoentError(ABS_CLAUDE),
+			),
+		],
+	];
+
+	for (const [name, report] of cases) {
+		test(`C6: ${name} — headline and reasons carry no internal word or binary path`, () => {
+			expect(report).not.toBeNull();
+			const found = wordsOf(report).flatMap((text) =>
+				leaks(text).map((w) => `${w} in "${text}"`),
+			);
+			expect(found).toEqual([]);
+		});
+	}
+});