claudeup 6.5.1 → 6.6.0

package/src/__tests__/fixtures/tool-probe/uv-receipt-graphifyy.toml

@@ -0,0 +1,7 @@
+# captured 2026-09-12 00:42 AEST, read-only: cat ~/.local/share/uv/tools/graphifyy/uv-receipt.toml (uv 0.11.15)
+[tool]
+requirements = [{ name = "graphifyy", extras = ["mcp"] }]
+entrypoints = [
+    { name = "graphify", install-path = "/Users/jack/.local/bin/graphify", from = "graphifyy" },
+    { name = "graphify-mcp", install-path = "/Users/jack/.local/bin/graphify-mcp", from = "graphifyy" },
+]

package/src/__tests__/fixtures/tool-probe/uv-receipt-mcp.toml

@@ -0,0 +1,6 @@
+# captured 2026-09-12 00:42 AEST, read-only: cat ~/.local/share/uv/tools/mcp/uv-receipt.toml (uv 0.11.15)
+[tool]
+requirements = [{ name = "mcp" }]
+entrypoints = [
+    { name = "mcp", install-path = "/Users/jack/.local/bin/mcp", from = "mcp" },
+]

package/src/__tests__/fixtures/tool-probe/uv-receipt-serena-agent.toml

@@ -0,0 +1,9 @@
+# captured 2026-09-12 00:42 AEST, read-only: cat ~/.local/share/uv/tools/serena-agent/uv-receipt.toml (uv 0.11.15)
+[tool]
+requirements = [{ name = "serena-agent" }]
+python = "3.13"
+entrypoints = [
+    { name = "serena", install-path = "/Users/jack/.local/bin/serena", from = "serena-agent" },
+    { name = "serena-agent", install-path = "/Users/jack/.local/bin/serena-agent", from = "serena-agent" },
+    { name = "serena-hooks", install-path = "/Users/jack/.local/bin/serena-hooks", from = "serena-agent" },
+]

package/src/__tests__/fixtures/tool-probe/uv-tool-list-outdated-pinned.txt

@@ -0,0 +1,5 @@
+# captured 2026-09-12 00:54 AEST: UV_TOOL_DIR=$SESSION/validation/captures/uv-scratch/tools UV_TOOL_BIN_DIR=$SESSION/validation/captures/uv-scratch/bin UV_CACHE_DIR=$SESSION/validation/captures/uv-scratch/cache UV_PYTHON_INSTALL_DIR=$SESSION/validation/captures/uv-scratch/python NO_COLOR=1 uv tool list --outdated   (exit=0)
+# cowsay was installed as 'cowsay==6.0' (receipt specifier ==6.0); uv still lists it as outdated.
+# $SESSION = claudish worktree update-fix2 ai-docs/sessions/dev-feature-claudeup-unify-20260911-2240 (the user's real uv tools were never touched)
+cowsay v6.0 [latest: 6.1]
+- cowsay

package/src/__tests__/fixtures/tool-probe/uv-tool-list-outdated.txt

@@ -0,0 +1,11 @@
+# captured 2026-09-12 00:42 AEST on the reporter's machine, read-only: uv tool list --outdated   (uv 0.11.15, exit=0)
+# Same text as the 2026-09-11 23:12 baseline. browser-use and mcp are absent: current.
+claude-swap v0.24.1 [latest: 0.26.0]
+- claude-swap
+- cswap
+graphifyy v0.9.50 [latest: 0.9.58]
+- graphify
+- graphify-mcp
+mistral-vibe v2.5.0 [latest: 2.25.3]
+- vibe
+- vibe-acp

package/src/__tests__/fixtures/tool-probe/uv-tool-list.txt

@@ -0,0 +1,22 @@
+# captured 2026-09-12 00:42 AEST on the reporter's machine, read-only: uv tool list   (uv 0.11.15, exit=0)
+browser-use v0.13.10
+- browser
+- browser-use
+- browser-use-tui
+- browseruse
+- bu
+claude-swap v0.24.1
+- claude-swap
+- cswap
+graphifyy v0.9.50
+- graphify
+- graphify-mcp
+mcp v2.2.0
+- mcp
+mistral-vibe v2.5.0
+- vibe
+- vibe-acp
+serena-agent v1.7.0
+- serena
+- serena-agent
+- serena-hooks

package/src/__tests__/{gitignore-prerun.test.ts → gitignore-check.test.ts}

@@ -6,8 +6,8 @@ import { join } from "node:path";
 import { BUILTIN_DEFAULTS } from "../data/gitignore-defaults.js";
 import {
 	checkGitignore,
-	formatPrerunWarning,
-} from "../services/gitignore-prerun";
+	formatGitignoreWarning,
+} from "../services/gitignore-check";
 
 function git(cwd: string, ...args: string[]): void {
 	spawnSync("git", ["-c", "core.excludesFile=/dev/null", ...args], { cwd });
@@ -17,7 +17,7 @@ describe("checkGitignore", () => {
 	let projectDir: string;
 
 	beforeEach(async () => {
-		projectDir = await mkdtemp(join(tmpdir(), "gitig-prerun-"));
+		projectDir = await mkdtemp(join(tmpdir(), "gitig-check-"));
 	});
 
 	afterEach(async () => {
@@ -55,13 +55,15 @@ describe("checkGitignore", () => {
 	});
 });
 
-describe("formatPrerunWarning", () => {
+describe("formatGitignoreWarning", () => {
 	it("returns null when no violations", () => {
-		expect(formatPrerunWarning({ violationCount: 0, warnings: [] })).toBeNull();
+		expect(
+			formatGitignoreWarning({ violationCount: 0, warnings: [] }),
+		).toBeNull();
 	});
 
 	it("returns a warning string when violations exist", () => {
-		const w = formatPrerunWarning({ violationCount: 3, warnings: [] });
+		const w = formatGitignoreWarning({ violationCount: 3, warnings: [] });
 		expect(w).not.toBeNull();
 		expect(w).toContain("3 git state");
 		expect(w).toContain("Git State tab");

package/src/__tests__/plugin-cli-argv.test.ts

@@ -15,7 +15,7 @@
  *
  * Both exit 0. The no-op is indistinguishable from success at every layer
  * above, so every claudeup update path — the TUI's `U`, "update all", the
- * scope menu, `claudeup update`, the prerunner's auto-update — reported
+ * scope menu, `claudeup update` — reported
  * success and changed nothing, for ever.
  *
  * Mocking the CLI cannot catch that: a stub answers whatever the test asks it

package/src/__tests__/plugin-row-text.test.ts

@@ -0,0 +1,336 @@
+import { describe, expect, test } from "bun:test";
+import type { PluginInfo } from "../services/plugin-manager.js";
+import {
+	type PluginUpdateItem,
+	classifyPluginRows,
+	planPluginUpdates,
+} from "../services/update-plan.js";
+import type { Marketplace } from "../types/index.js";
+import {
+	type PluginPluginItem,
+	buildPluginBrowserItems,
+} from "../ui/adapters/pluginsAdapter.js";
+import { pluginRowText } from "../ui/renderers/pluginRowText.js";
+import { pluginStatusText } from "../ui/renderers/pluginStatusText.js";
+
+/**
+ * `pluginRowText` is exactly what a Plugins row prints after the name, in
+ * every branch of `pluginRow` — selected, unselected, orphan. So asserting on
+ * it asserts on the screen.
+ *
+ * Rows here are built the way the screen builds them: `classifyPluginRows` over
+ * the plugin list and the profile's pins, then `buildPluginBrowserItems`. The
+ * note each row must contain is taken from `planPluginUpdates` — the CLI's own
+ * answer — never retyped, so the two front ends are compared, not two copies.
+ */
+
+const OFFICIAL: Marketplace = {
+	name: "claude-plugins-official",
+	displayName: "Anthropic Official",
+	source: { source: "github", repo: "anthropics/claude-plugins-official" },
+	description: "",
+} as Marketplace;
+
+const MAGUS: Marketplace = {
+	name: "magus",
+	displayName: "Magus",
+	source: { source: "github", repo: "MadAppGang/magus" },
+	description: "",
+	owned: true,
+} as Marketplace;
+
+function info(over: Partial<PluginInfo> & { id: string }): PluginInfo {
+	const [name, marketplace] = over.id.split("@");
+	return {
+		name,
+		version: null,
+		description: "",
+		marketplace,
+		marketplaceDisplay: "",
+		enabled: true,
+		author: { name: "Anthropic" },
+		...over,
+	} as PluginInfo;
+}
+
+/** Real: `code-review@claude-plugins-official` in /Users/jack/mag/claudish. */
+const CODE_REVIEW = info({
+	id: "code-review@claude-plugins-official",
+	version: null, // the official catalog publishes no version for it
+	installedVersion: "3ea32df27be7",
+	projectScope: { enabled: true, version: "3ea32df27be7" },
+});
+
+/** A registry "0.0.0" — the value the old row hid every status behind. */
+const ZERO = info({
+	id: "zero-version@claude-plugins-official",
+	version: null,
+	installedVersion: "0.0.0",
+	projectScope: { enabled: true, version: "0.0.0" },
+});
+
+/** Other listed ids, so each marketplace demonstrably was read. */
+const LISTED = [
+	info({ id: "dev@magus", version: "4.7.0", author: { name: "MadAppGang" } }),
+	info({ id: "github@claude-plugins-official", version: null }),
+];
+
+function rows(
+	plugins: PluginInfo[],
+	pins: Record<string, string> = {},
+): Map<string, PluginPluginItem> {
+	const all = [...plugins, ...LISTED];
+	const items = buildPluginBrowserItems({
+		marketplaces: [MAGUS, OFFICIAL],
+		plugins: all,
+		collapsedMarketplaces: new Set(),
+		statuses: classifyPluginRows(all, pins),
+	});
+	return new Map(
+		items
+			.filter((i): i is PluginPluginItem => i.kind === "plugin")
+			.map((i) => [i.plugin.id, i]),
+	);
+}
+
+/** The note `claudeup update` prints for this plugin under this pin. */
+function cliNote(
+	plugins: PluginInfo[],
+	id: string,
+	pin = "latest",
+): string | undefined {
+	const all = [...plugins, ...LISTED];
+	const [item] = planPluginUpdates(
+		{ [id]: pin },
+		new Map(all.map((p) => [p.id, p])),
+	);
+	return item?.note;
+}
+
+describe("pluginRowText — a status never depends on a displayable version", () => {
+	test("a sha-versioned unknown carries the CLI's reason verbatim", () => {
+		// The old row said "? not comparable" here; the CLI said the sentence
+		// below. Same state, different reason — the R2 violation.
+		const row = rows([CODE_REVIEW]).get(CODE_REVIEW.id);
+		const note = cliNote([CODE_REVIEW], CODE_REVIEW.id);
+		expect(note).toBe(
+			"its marketplace publishes no version for this plugin, so there is nothing to compare",
+		);
+		const { text } = pluginRowText(row as PluginPluginItem);
+		expect(text).toBe(` v3ea32df27be7 ? ${note}`);
+		expect(text).not.toContain("not comparable");
+	});
+
+	test('REGRESSION: a "0.0.0" unknown is no longer blank', () => {
+		// Every old status clause was gated on a displayable version, so this row
+		// printed nothing after its name and read as healthy.
+		const row = rows([ZERO]).get(ZERO.id) as PluginPluginItem;
+		expect(row.status?.action).toBe("unknown");
+		const { text, segments } = pluginRowText(row);
+		expect(text).toBe(` ? ${cliNote([ZERO], ZERO.id)}`);
+		// The version itself is still never printed.
+		expect(text).not.toContain("0.0.0");
+		expect(segments.at(-1)?.tone).toBe("warning");
+	});
+});
+
+describe("pluginRowText — orphans say what the CLI says (F9)", () => {
+	test("an orphan that moved names where it went", () => {
+		const seo = info({
+			id: "seo@magus",
+			version: "1.8.0",
+			installedVersion: "1.8.0",
+			isOrphaned: true,
+			movedTo: "magus-marketing",
+			projectScope: { enabled: true, version: "1.8.0" },
+		});
+		const row = rows([seo]).get(seo.id) as PluginPluginItem;
+		expect(cliNote([seo], seo.id)).toBe("moved to magus-marketing");
+		expect(pluginRowText(row).text).toBe(" v1.8.0 ? moved to magus-marketing");
+	});
+
+	test("an orphan with no movedTo, from a marketplace we read, is 'not offered'", () => {
+		const gone = info({
+			id: "gone@magus",
+			version: "2.0.0",
+			installedVersion: "2.0.0",
+			isOrphaned: true,
+			projectScope: { enabled: true, version: "2.0.0" },
+		});
+		const row = rows([gone]).get(gone.id) as PluginPluginItem;
+		expect(pluginRowText(row).text).toBe(
+			` v2.0.0 ? ${cliNote([gone], gone.id)}`,
+		);
+		expect(pluginRowText(row).text).toContain(
+			"not offered by any configured marketplace",
+		);
+	});
+
+	test("the old words are gone: no 'deprecated', no 'moved →'", () => {
+		const seo = info({
+			id: "seo@magus",
+			installedVersion: "1.8.0",
+			isOrphaned: true,
+			movedTo: "magus-marketing",
+			projectScope: { enabled: true, version: "1.8.0" },
+		});
+		const { text } = pluginRowText(rows([seo]).get(seo.id) as PluginPluginItem);
+		expect(text).not.toContain("deprecated");
+		expect(text).not.toContain("moved →");
+	});
+});
+
+describe("pluginRowText — history badges combine with the state", () => {
+	const updated = (over: Partial<PluginInfo>) =>
+		info({
+			id: "terminal@magus",
+			version: "3.3.1",
+			installedVersion: "3.0.1",
+			projectScope: { enabled: true, version: "3.0.1" },
+			author: { name: "MadAppGang" },
+			...over,
+		});
+
+	test("'updated' and a pending update are both shown", () => {
+		// An external update moved 2.9.0 → 3.0.1 while 3.3.1 is already out.
+		const p = updated({ recentlyUpdatedFrom: "2.9.0" });
+		const row = rows([p]).get(p.id) as PluginPluginItem;
+		const { text, segments } = pluginRowText(row);
+		expect(text).toBe(" v2.9.0 → v3.0.1 updated → v3.3.1 available");
+		expect(segments.map((s) => s.tone)).toEqual(["success", "warning"]);
+	});
+
+	test("'new' and a pending update are both shown", () => {
+		const p = updated({ recentlyInstalled: true });
+		const row = rows([p]).get(p.id) as PluginPluginItem;
+		expect(pluginRowText(row).text).toBe(" v3.0.1 new → v3.3.1 available");
+	});
+
+	test("'new' with no displayable version still says new", () => {
+		const p = updated({
+			recentlyInstalled: true,
+			version: "0.0.0",
+			installedVersion: "0.0.0",
+			projectScope: { enabled: true, version: "0.0.0" },
+		});
+		const row = rows([p]).get(p.id) as PluginPluginItem;
+		expect(pluginRowText(row).text).toBe(" new");
+	});
+
+	test("a current row shows only its version", () => {
+		const p = updated({
+			version: "3.0.1",
+		});
+		const row = rows([p]).get(p.id) as PluginPluginItem;
+		expect(row.status?.action).toBe("current");
+		expect(pluginRowText(row).text).toBe(" v3.0.1");
+	});
+});
+
+describe("pluginRowText — rows with no state claim none", () => {
+	test("an undeclared, uninstalled catalog entry has no status and no text", () => {
+		const browse = info({
+			id: "kanban@magus",
+			version: "1.6.2",
+			author: { name: "MadAppGang" },
+		});
+		const row = rows([browse]).get(browse.id) as PluginPluginItem;
+		expect(row.status).toBeNull();
+		expect(pluginRowText(row).text).toBe("");
+	});
+
+	test("the same entry DECLARED by the profile says the profile wants it", () => {
+		const declared = info({
+			id: "kanban@magus",
+			version: "1.6.2",
+			author: { name: "MadAppGang" },
+		});
+		const row = rows([declared], { "kanban@magus": "latest" }).get(
+			declared.id,
+		) as PluginPluginItem;
+		expect(pluginRowText(row).text).toBe(
+			" not installed — profile declares it",
+		);
+	});
+});
+
+describe("pluginStatusText — absent is not enabled-not-installed (LOW 6)", () => {
+	const status = (over: Partial<PluginUpdateItem>): PluginUpdateItem => ({
+		pluginId: "x@magus",
+		pinned: "latest",
+		installed: null,
+		available: "1.0.0",
+		target: "1.0.0",
+		action: "install",
+		reason: "absent",
+		scopes: [],
+		beforeVersions: {},
+		...over,
+	});
+
+	test("absent — only ever from a profile pin — may say the profile declares it", () => {
+		expect(pluginStatusText(status({}))).toEqual({
+			suffix: " not installed — profile declares it",
+			tone: "warning",
+		});
+	});
+
+	test("enabled-not-installed shows its note and never claims a declaration", () => {
+		const got = pluginStatusText(
+			status({
+				reason: "enabled-not-installed",
+				note: "enabled in settings, but no files on disk",
+			}),
+		);
+		expect(got).toEqual({
+			suffix: " not installed (enabled in settings, but no files on disk)",
+			tone: "danger",
+		});
+		expect(got.suffix).not.toContain("profile");
+	});
+
+	test("an undeclared enabled-but-not-installed ROW gets the enabled text", () => {
+		const broken = info({
+			id: "kanban@magus",
+			version: "1.6.2",
+			author: { name: "MadAppGang" },
+			localScope: { enabled: true },
+		});
+		const row = rows([broken]).get(broken.id) as PluginPluginItem;
+		expect(row.status?.reason).toBe("enabled-not-installed");
+		expect(pluginRowText(row).text).toBe(
+			" not installed (enabled in settings, but no files on disk)",
+		);
+	});
+
+	test("null status says nothing", () => {
+		expect(pluginStatusText(null)).toEqual({ suffix: "", tone: "muted" });
+	});
+
+	test("update with a pin-undeliverable note carries it", () => {
+		expect(
+			pluginStatusText(
+				status({
+					action: "update",
+					reason: "pin-undeliverable",
+					target: "9.9.9",
+					note: "manifest pins 4.6.1; the marketplace offers only 9.9.9",
+				}),
+			).suffix,
+		).toBe(
+			" → v9.9.9 available (manifest pins 4.6.1; the marketplace offers only 9.9.9)",
+		);
+	});
+
+	test("repair carries its note", () => {
+		expect(
+			pluginStatusText(
+				status({
+					action: "repair",
+					reason: "content-stale",
+					note: "files changed without a version bump",
+				}),
+			).suffix,
+		).toBe(" stale — reinstall (files changed without a version bump)");
+	});
+});

package/src/__tests__/scope-action.test.ts

@@ -1,8 +1,10 @@
 import { describe, expect, test } from "bun:test";
 import {
+	type PluginInfo,
 	isInstalledInScope,
 	resolveScopeAction,
 } from "../services/plugin-manager.js";
+import { planPluginUpdates, scopeIsBehind } from "../services/update-plan.js";
 
 /**
  * The scope keys (u / p / l) and the Enter scope picker both decide between
@@ -29,10 +31,18 @@ describe("isInstalledInScope", () => {
 		expect(isInstalledInScope({ enabled: true })).toBe(false);
 	});
 
-	test("a version with the flag off is not installed either", () => {
-		expect(isInstalledInScope({ enabled: false, version: "3.0.2" })).toBe(
-			false,
-		);
+	test("a registry version with the flag off IS installed", () => {
+		// Installation and enablement are separate facts. This asserted `false`
+		// until it was measured against the other direction: a plugin with a real
+		// registry row that the user had simply switched off reported "not
+		// installed", so its row offered to install what was already on disk, and
+		// the header counted it out.
+		//
+		// The hazard the sibling test above guards — pressing a scope key on
+		// enabled-with-no-version and having it run `uninstall` — is untouched:
+		// that case has no version, so it is still not installed, and still
+		// resolves to `install`.
+		expect(isInstalledInScope({ enabled: false, version: "3.0.2" })).toBe(true);
 	});
 
 	test("an absent scope is not installed", () => {
@@ -45,40 +55,80 @@ describe("isInstalledInScope", () => {
 });
 
 describe("resolveScopeAction", () => {
+	// The second argument is "is this scope provably behind?", which the screen
+	// takes from the classifier (`scopeIsBehind`). It used to be the catalog
+	// version, compared here with raw string inequality — a fourth rule.
+
 	test("REGRESSION: enabled but not installed resolves to install, never uninstall", () => {
 		// This is the reported bug. Before the fix this returned "uninstall".
-		expect(resolveScopeAction({ enabled: true }, "3.0.2")).toBe("install");
+		expect(resolveScopeAction({ enabled: true }, false)).toBe("install");
+		// Whatever the classifier says: the safety branch comes first.
+		expect(resolveScopeAction({ enabled: true }, true)).toBe("install");
 	});
 
 	test("a scope that was never enabled resolves to install", () => {
-		expect(resolveScopeAction(undefined, "3.0.2")).toBe("install");
-		expect(resolveScopeAction({ enabled: false }, "3.0.2")).toBe("install");
+		expect(resolveScopeAction(undefined, false)).toBe("install");
+		expect(resolveScopeAction({ enabled: false }, false)).toBe("install");
 	});
 
 	test("a healthy install at the latest version resolves to uninstall (toggle off)", () => {
-		expect(
-			resolveScopeAction({ enabled: true, version: "3.0.2" }, "3.0.2"),
-		).toBe("uninstall");
+		expect(resolveScopeAction({ enabled: true, version: "3.0.2" }, false)).toBe(
+			"uninstall",
+		);
 	});
 
 	test("a healthy install behind the catalog resolves to update", () => {
-		expect(
-			resolveScopeAction({ enabled: true, version: "2.9.0" }, "3.0.2"),
-		).toBe("update");
+		expect(resolveScopeAction({ enabled: true, version: "2.9.0" }, true)).toBe(
+			"update",
+		);
 	});
+});
 
+/** The screen's path: classify, then ask `scopeIsBehind` for the pressed scope. */
+function keyFor(installed: string, catalogVersion: string | null) {
+	const scope = { enabled: true, version: installed };
+	const [status] = planPluginUpdates(
+		{ "x@magus": "latest" },
+		new Map([
+			[
+				"x@magus",
+				{
+					id: "x@magus",
+					name: "x",
+					version: catalogVersion,
+					description: "",
+					marketplace: "magus",
+					marketplaceDisplay: "Magus",
+					enabled: true,
+					projectScope: scope,
+				} as PluginInfo,
+			],
+		]),
+	);
+	return resolveScopeAction(scope, scopeIsBehind(status, "project"));
+}
+
+describe("resolveScopeAction through the classifier — the screen's real path", () => {
 	test('an unknown catalog version ("0.0.0") never fabricates an update', () => {
 		// There is nothing to update *to*, so toggling must still mean uninstall.
-		expect(
-			resolveScopeAction({ enabled: true, version: "3.0.2" }, "0.0.0"),
-		).toBe("uninstall");
+		expect(keyFor("3.0.2", "0.0.0")).toBe("uninstall");
 	});
 
 	test("installed with unknown version resolves to update when a real version is published", () => {
 		// "0.0.0" installed against a real catalog version is a genuine upgrade
 		// path, not the broken state — it must not be treated as uninstall.
-		expect(
-			resolveScopeAction({ enabled: true, version: "0.0.0" }, "3.0.2"),
-		).toBe("update");
+		expect(keyFor("0.0.0", "3.0.2")).toBe("update");
+	});
+
+	test("REGRESSION: a scope AHEAD of the catalog no longer resolves to update", () => {
+		// Raw string inequality called 3.1.0 vs 3.0.2 "behind" and offered an
+		// update that could only reinstall the older version or no-op.
+		expect(keyFor("3.1.0", "3.0.2")).toBe("uninstall");
+	});
+
+	test("REGRESSION: an unorderable scope no longer resolves to update", () => {
+		// A sha against a semver cannot be ordered. The row says "?", so the key
+		// must not act as though it knew the scope was behind.
+		expect(keyFor("3ea32df27be7", "3.0.2")).toBe("uninstall");
 	});
 });

package/src/__tests__/shell-script-callers.test.ts

@@ -66,18 +66,18 @@ describe("only the toolchain bootstrap goes through a shell", () => {
 		expect(await callersOf(/\brunShellScript\(/)).toEqual(ALLOWED);
 	});
 
-	test("nothing spawns with `shell: true` outside utils/run.ts", async () => {
+	test("nothing spawns with a shell outside utils/run.ts", async () => {
 		// Catches someone reaching for `spawn`/`exec` directly rather than
 		// through the seam — a second shell path that never names
 		// `runShellScript`.
 		//
-		// Scope, stated honestly: this checks `shell: true` only. Several
-		// version-DETECTION helpers in CliToolsScreen still pass
-		// `shell: "/bin/bash"` to run pipelines like `which -a x 2>/dev/null`.
-		// Those interpolate a catalogue `name`, not an installer command, and
-		// were out of scope here — so this assertion would be false if it
-		// claimed no shell exists anywhere.
-		expect(await callersOf(/shell:\s*true/)).toEqual([]);
+		// Both spellings: `shell: true` and a named shell (`shell: "/bin/bash"`).
+		// The CLI Tools screen used the second for its version probe (`which -a`
+		// pipelines, a string-form `exec` of each check command); that probe now
+		// lives in services/tool-probe.ts and runs argv only. `shell: false` and
+		// the alias writer's `shell: ShellKind` values are not spawn options and
+		// do not match.
+		expect(await callersOf(/shell:\s*(true|["'`])/)).toEqual([]);
 	});
 
 	test("the scan can actually fail", async () => {