magus-cli 7.8.0 → 7.9.1

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

@@ -59,6 +59,7 @@ 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 ────────────────────────────────────────────────────────────────
@@ -129,20 +130,28 @@ const BINARY_PATH = /(^|[\s'"(])\/[^\s'"]*\/bin\/[\w.-]+/;
 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): Error {
-		return Object.assign(
-			new Error(`Command failed: ${ABS_NPM.cmd} install -g x`),
-			{ code, stderr, stdout: "", killed: false, signal: null },
-		);
+	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,
-				Object.assign(new Error(`spawn ${ABS_NPM.cmd} ENOENT`), {
-					code: "ENOENT",
-				}),
+				{
+					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");
@@ -155,7 +164,14 @@ describe("B1/B2: installer failures keep their own fix and never print a binary
 		const cmd = { cmd: "/Users/someone/.local/bin/claude", args: ["update"] };
 		const reason = commandFailureReason(
 			cmd,
-			Object.assign(new Error(`spawn ${cmd.cmd} ENOENT`), { code: "ENOENT" }),
+			{
+				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");

package/src/__tests__/fixtures/bins.ts

@@ -0,0 +1,55 @@
+/**
+ * Test builders for requirements, from the version-managed shape tests read
+ * best (`{ name, via, package, version }`), through the one bridge production
+ * uses (`managedOption`). Shared so no test hand-builds the `SelectedBin`
+ * shape its own way.
+ */
+
+import { type CliTool, cliTools, isOwnedEntry } from "../../data/cli-tools.js";
+import { ownedCliTool } from "../../services/cli-tool-commands.js";
+import { managedOption } from "../../services/toolchain.js";
+import type {
+	ManagedTool,
+	ResolvedBin,
+	SelectedBin,
+} from "../../types/index.js";
+
+/** A selected requirement whose one option (and choice) is `t`'s installer. */
+export function selected(t: ManagedTool, root?: string): SelectedBin {
+	const option = managedOption(t);
+	return {
+		name: t.name,
+		check: (t.check ?? `${t.name} --version`).trim().split(/\s+/),
+		install: [option],
+		chosen: option,
+		...(root ? { root } : {}),
+	};
+}
+
+/** {@link selected}, with provenance. */
+export function resolved(t: ManagedTool, sources: string[]): ResolvedBin {
+	return { ...selected(t), sources };
+}
+
+/**
+ * A plugin-owned catalogue tool's requirement as its plugin declares it today:
+ * a bun install of the package named after the tool.
+ */
+export async function ownedAsDeclared(
+	_pluginId: string,
+	name: string,
+): Promise<SelectedBin> {
+	return selected({ name, via: "bun", package: name });
+}
+
+/** The catalogue as CLI tools, owned entries resolved as {@link ownedAsDeclared}. */
+export function testCatalogue(): CliTool[] {
+	return cliTools.map((entry) =>
+		isOwnedEntry(entry)
+			? (ownedCliTool(
+					entry,
+					selected({ name: entry.name, via: "bun", package: entry.name }),
+				) as CliTool)
+			: entry,
+	);
+}

package/src/__tests__/install-plan.test.ts

@@ -8,6 +8,7 @@ import type {
 	InstalledPluginsRegistry,
 	ResolvedClosure,
 } from "../types/index.js";
+import { resolved } from "./fixtures/bins.js";
 
 function closure(overrides: Partial<ResolvedClosure> = {}): ResolvedClosure {
 	return {
@@ -91,7 +92,7 @@ describe("summarizeClosure", () => {
 			marketplaces: { magus: { source: "github", repo: "MadAppGang/magus" } },
 			plugins: { "dev@magus": "latest", "terminal@magus": "4.1.0" },
 			bins: [
-				{ name: "claudish", via: "bun", version: "1.2.0", sources: ["x"] },
+				resolved({ name: "claudish", via: "bun", version: "1.2.0" }, ["x"]),
 			],
 			env: { required: ["FIGMA_TOKEN"], optional: [] },
 		});
@@ -101,4 +102,17 @@ describe("summarizeClosure", () => {
 		expect(lines.some((l) => l.includes("claudish@1.2.0"))).toBe(true);
 		expect(lines.some((l) => l.startsWith("env"))).toBe(true);
 	});
+
+	test("a refused pin is shown with the tool, marked as not applied", () => {
+		const bin = {
+			...resolved({ name: "claudish", via: "brew", formula: "claudish" }, [
+				"profile:p.cliTools",
+			]),
+			refusedPins: ["6.1.0"],
+		};
+		const lines = summarizeClosure(closure({ bins: [bin] }));
+		expect(
+			lines.some((l) => l.includes("claudish@6.1.0 (pin not applied)")),
+		).toBe(true);
+	});
 });

package/src/__tests__/marketplace-refresh.test.ts

@@ -57,7 +57,13 @@ function writePluginJson(dir: string, version: string, pin: string) {
 	fs.mkdirSync(p, { recursive: true });
 	fs.writeFileSync(
 		path.join(p, "plugin.json"),
-		JSON.stringify({ version, setup: { go: [pin] } }),
+		JSON.stringify({
+			version,
+			requires: {
+				schema: 1,
+				bin: [{ name: "x", install: [{ via: "release", tag: pin }] }],
+			},
+		}),
 	);
 }
 function readPin(dir: string): { version: string; pin: string } {
@@ -67,7 +73,7 @@ function readPin(dir: string): { version: string; pin: string } {
 			"utf8",
 		),
 	);
-	return { version: j.version, pin: j.setup.go[0] };
+	return { version: j.version, pin: j.requires.bin[0].install[0].tag };
 }
 /** Clone origin into the marketplace dir for `name`, at origin's current HEAD. */
 function installClone(name: string): string {
@@ -111,7 +117,7 @@ afterEach(() => {
 });
 
 describe("refreshRegisteredMarketplaces — the fix (CLAIM #1)", () => {
-	it("fast-forwards a stale clone so a newly pinned setup.go becomes visible", async () => {
+	it("fast-forwards a stale clone so a newly pinned release tag becomes visible", async () => {
 		const dir = installClone("magus");
 		expect(readPin(dir).pin).toBe("x@latest"); // stale on-disk clone
 		publishV2(); // a release lands upstream

package/src/__tests__/no-shell-spawn.test.ts

@@ -0,0 +1,77 @@
+/**
+ * The plugin-dependency code paths never hand anything to a shell.
+ *
+ * Scoped, deliberately, to the files on the installer path: the one reader of
+ * `requires` (and the hook that runs it at session start), the executor, the
+ * runner, and the modules that feed them. Package names, check argv and script
+ * paths reach these from plugin manifests and profiles — data a marketplace or
+ * a teammate wrote — so here a shell is never acceptable. The test makes no
+ * claim about the rest of `src/`. A new file on the installer path joins
+ * {@link INSTALLER_PATH}.
+ */
+
+import { describe, expect, test } from "bun:test";
+import path from "node:path";
+import fs from "fs-extra";
+
+const SRC_DIR = path.join(import.meta.dir, "..");
+
+/** Files on the installer path, relative to `src/`. */
+const INSTALLER_PATH = [
+	"shared/plugin/hooks/lib/requires-probe.ts",
+	"shared/plugin/hooks/deps-check.ts",
+	"services/deps-plan.ts",
+	"services/deps-report.ts",
+	"services/doctor-bins.ts",
+	"utils/run.ts",
+	"cli/deps-view.ts",
+	"ui/adapters/depsAdapter.ts",
+];
+
+/** Each way a string can reach a shell, as the line that would do it. */
+const SHELL_PATTERNS: Array<[string, RegExp]> = [
+	["a shell spawn option", /\bshell:\s*(true|["'`])/],
+	["exec / execSync (string commands)", /\bexec(Sync)?\s*\(/],
+	[
+		"a string handed to spawn",
+		/(?<!Bun\.)\bspawn(Sync)?\s*\(\s*["'`][^"'`]*\s/,
+	],
+	["a string handed to Bun.spawn", /\bBun\.spawn(Sync)?\s*\(\s*["'`]/],
+	["Bun's shell", /\$`|from\s+["']bun["'].*\$/],
+];
+
+const isComment = (line: string) => {
+	const t = line.trim();
+	return t.startsWith("//") || t.startsWith("*") || t.startsWith("/*");
+};
+
+function shellUses(text: string): string[] {
+	const found: string[] = [];
+	text.split("\n").forEach((line, i) => {
+		if (isComment(line)) return;
+		for (const [what, re] of SHELL_PATTERNS) {
+			if (re.test(line)) found.push(`line ${i + 1}: ${what}`);
+		}
+	});
+	return found;
+}
+
+describe("the installer path never spawns a shell", () => {
+	for (const rel of INSTALLER_PATH) {
+		test(rel, async () => {
+			const text = await fs.readFile(path.join(SRC_DIR, rel), "utf8");
+			expect(shellUses(text)).toEqual([]);
+		});
+	}
+
+	test("the scan can fail", () => {
+		// Negative controls: each pattern fires on the line it exists for.
+		expect(shellUses("spawn(cmd, { shell: true });")).toHaveLength(1);
+		expect(shellUses(`spawn(cmd, { shell: "/bin/sh" });`)).toHaveLength(1);
+		expect(shellUses("execSync(`brew install ${f}`);")).toHaveLength(1);
+		expect(shellUses(`spawn("brew install tmux");`)).toHaveLength(1);
+		expect(shellUses(`Bun.spawn("brew install tmux");`)).toHaveLength(1);
+		// …and not on argv.
+		expect(shellUses(`spawn(exe, args, { stdio: "ignore" });`)).toEqual([]);
+	});
+});

package/src/__tests__/npm-package-name.test.ts

@@ -199,7 +199,7 @@ describe("the CLI Tools entry for magus", () => {
 	test("install targets the package", () => {
 		expect(cliToolInstall(magusEntry())).toEqual({
 			cmd: "bun",
-			args: ["install", "-g", PACKAGE],
+			args: ["add", "-g", PACKAGE],
 		});
 	});
 
@@ -251,10 +251,8 @@ describe("pins and probes resolve to the package", () => {
 	test("a pinned version installs `<package>@<version>` and checks the command", () => {
 		expect(cliToolToBin(COMMAND, PKG.version)).toMatchObject({
 			name: COMMAND,
-			via: "bun",
-			package: PACKAGE,
-			check: "magus --version",
-			version: PKG.version,
+			check: ["magus", "--version"],
+			chosen: { via: "bun", package: PACKAGE, version: PKG.version },
 		});
 	});
 
@@ -262,11 +260,10 @@ describe("pins and probes resolve to the package", () => {
 		const bin = cliToolToBin(COMMAND, "latest");
 		expect(bin).toMatchObject({
 			name: COMMAND,
-			via: "bun",
-			package: PACKAGE,
-			check: "magus --version",
+			check: ["magus", "--version"],
+			chosen: { via: "bun", package: PACKAGE },
 		});
-		expect(bin.version).toBeUndefined();
+		expect(bin.chosen && "version" in bin.chosen).toBe(false);
 	});
 
 	test("the catalogue spec (the dist-tags probe input) names the package", () => {

package/src/__tests__/plugin-requires.test.ts

@@ -1,187 +1,172 @@
+/**
+ * plugin-requires locates the plugin.json Claude Code loads and hands its
+ * `requires` to requires-probe; it parses nothing itself.
+ */
+
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { chmodSync, mkdirSync, writeFileSync } from "node:fs";
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import fs from "fs-extra";
 import {
-	parsePluginRequires,
 	readPluginRequires,
+	resolvePluginRequires,
+	selectBins,
 } from "../services/plugin-requires.js";
+import type { Requirement } from "../shared/plugin/hooks/lib/requires-probe.js";
 
-describe("parsePluginRequires", () => {
-	test("parses a valid requires.bin and fills defaults", () => {
-		const requires = parsePluginRequires({
-			name: "terminal",
-			requires: {
-				bin: [
-					{ name: "tmux", via: "brew", formula: "tmux", check: "tmux -V" },
-					{ name: "tmux-mcp", via: "bun", package: "tmux-mcp" },
-				],
-			},
-		});
-		expect(requires.bin).toHaveLength(2);
-		const tmux = requires.bin!.find((b) => b.name === "tmux")!;
-		expect(tmux.via).toBe("brew");
-		expect(tmux.check).toBe("tmux -V");
-		const mcp = requires.bin!.find((b) => b.name === "tmux-mcp")!;
-		// check defaulted from the name
-		expect(mcp.check).toBe("tmux-mcp --version");
-	});
-
-	test("drops entries with no name or an unknown installer", () => {
-		const requires = parsePluginRequires({
-			requires: {
-				bin: [
-					{ via: "bun" }, // no name
-					{ name: "x", via: "cargo" }, // unknown installer
-					{ name: "ok", via: "npm" },
-				],
-			},
-		});
-		expect(requires.bin).toHaveLength(1);
-		expect(requires.bin![0]!.name).toBe("ok");
-	});
+const BUN: Requirement = {
+	name: "bun",
+	check: ["bun", "--version"],
+	install: [{ via: "bootstrap", tool: "bun" }],
+};
+const declares = (bin: Requirement[]) => ({
+	name: "p",
+	requires: { schema: 1, bin },
+});
 
-	test("no requires / non-array bin → empty object", () => {
-		expect(parsePluginRequires({ name: "x" })).toEqual({});
-		expect(parsePluginRequires({ requires: {} })).toEqual({});
-		expect(parsePluginRequires({ requires: { bin: "nope" } })).toEqual({});
-		expect(parsePluginRequires(null)).toEqual({});
-	});
+let dir: string;
+beforeEach(async () => {
+	dir = await fs.realpath(await mkdtemp(join(tmpdir(), "plugreq-")));
+});
+afterEach(async () => {
+	await rm(dir, { recursive: true, force: true });
 });
 
-describe("parsePluginRequires — setup block (the established convention)", () => {
-	test("terminal's setup: go module + required system tool", () => {
-		// The real plugins/terminal/plugin.json shape.
-		const r = parsePluginRequires({
-			name: "terminal",
-			setup: {
-				go: ["github.com/MadAppGang/tmux-mcp@latest"],
-				required: ["tmux"],
-			},
+describe("readPluginRequires", () => {
+	test("parses .claude-plugin/plugin.json through requires-probe", async () => {
+		await fs.outputJson(
+			join(dir, ".claude-plugin", "plugin.json"),
+			declares([BUN]),
+		);
+		expect(await readPluginRequires(dir)).toEqual({
+			ok: true,
+			requirements: [BUN],
 		});
-		const mcp = r.bin!.find((b) => b.name === "tmux-mcp")!;
-		expect(mcp.via).toBe("go");
-		expect(mcp.module).toBe("github.com/MadAppGang/tmux-mcp");
-		expect(mcp.version).toBe("latest");
-		const tmux = r.bin!.find((b) => b.name === "tmux")!;
-		expect(tmux.via).toBe("brew");
-		expect(tmux.formula).toBe("tmux");
 	});
 
-	// Negative control for the /vN fix: basename(base) yields "v2" here, so
-	// without the go-module helper this test FAILS on `name`.
-	test("terminal's v2 pin: /v2 is the module's major version, not the binary", () => {
-		const r = parsePluginRequires({
-			name: "terminal",
+	test("a setup block is read by nothing: without requires the plugin declares nothing", async () => {
+		await fs.outputJson(join(dir, ".claude-plugin", "plugin.json"), {
+			name: "p",
 			setup: { go: ["github.com/MadAppGang/tmux-mcp/v2@v2.0.0"] },
 		});
-		expect(r.bin).toEqual([
-			{
-				name: "tmux-mcp",
-				via: "go",
-				module: "github.com/MadAppGang/tmux-mcp/v2",
-				version: "v2.0.0",
-				check: "tmux-mcp --version",
-			},
-		]);
-	});
-
-	// One manifest per spec: entries are keyed by binary name, so a v1 and a v2
-	// pin of the same module in ONE setup would (correctly) collapse to one.
-	test.each([
-		[
-			"github.com/MadAppGang/tmux-mcp@v1.7.1",
-			{
-				name: "tmux-mcp",
-				module: "github.com/MadAppGang/tmux-mcp",
-				version: "v1.7.1",
-			},
-		],
-		[
-			"github.com/MadAppGang/tmux-mcp/v2",
-			{
-				name: "tmux-mcp",
-				module: "github.com/MadAppGang/tmux-mcp/v2",
-				version: undefined,
-			},
-		],
-		[
-			"github.com/x/v2tool@v1.0.0",
-			{ name: "v2tool", module: "github.com/x/v2tool", version: "v1.0.0" },
-		],
-	])("go spec %s → name/module/version", (spec, expected) => {
-		const r = parsePluginRequires({ setup: { go: [spec] } });
-		expect(
-			r.bin!.map((b) => ({
-				name: b.name,
-				module: b.module,
-				version: b.version,
-			})),
-		).toEqual([expected]);
-	});
-
-	test("browser-use's setup: pip packages", () => {
-		const r = parsePluginRequires({
-			name: "browser-use",
-			setup: { pip: ["browser-use", "mcp"] },
+		expect(await readPluginRequires(dir)).toEqual({
+			ok: true,
+			requirements: [],
 		});
-		expect(r.bin!.map((b) => b.name).sort()).toEqual(["browser-use", "mcp"]);
-		expect(r.bin!.every((b) => b.via === "pip")).toBe(true);
 	});
 
-	test("bun/npm specs split name@version", () => {
-		const r = parsePluginRequires({
-			setup: { bun: ["claudish@1.2.0"], npm: ["@scope/tool@3.0.0"] },
+	test("an invalid declaration is reported, never dropped to empty", async () => {
+		await fs.outputJson(join(dir, ".claude-plugin", "plugin.json"), {
+			name: "p",
+			requires: { schema: 1, bin: [{ name: "x", via: "brew" }] },
 		});
-		const claudish = r.bin!.find((b) => b.name === "claudish")!;
-		expect(claudish.version).toBe("1.2.0");
-		const scoped = r.bin!.find((b) => b.name === "tool")!;
-		expect(scoped.package).toBe("@scope/tool");
-		expect(scoped.version).toBe("3.0.0");
+		const r = await readPluginRequires(dir);
+		expect(r?.ok).toBe(false);
 	});
 
-	test("explicit requires.bin overrides a setup entry of the same name", () => {
-		const r = parsePluginRequires({
-			setup: { required: ["tmux"] }, // → brew
-			requires: {
-				bin: [{ name: "tmux", via: "go", module: "example.com/tmux" }],
-			},
-		});
-		const tmux = r.bin!.find((b) => b.name === "tmux")!;
-		expect(tmux.via).toBe("go"); // requires.bin won
+	test("no manifest → null", async () => {
+		expect(await readPluginRequires(dir)).toBeNull();
 	});
 });
 
-describe("readPluginRequires", () => {
-	let dir: string;
-	beforeEach(async () => {
-		dir = await mkdtemp(join(tmpdir(), "plugreq-"));
-	});
-	afterEach(async () => {
-		await rm(dir, { recursive: true, force: true });
-	});
+describe("resolvePluginRequires reads the copy Claude Code loads", () => {
+	test("the installed copy wins over a newer marketplace clone", async () => {
+		const root = join(dir, "plugins-root");
+		const installed = join(root, "cache", "fixture", "app", "1.0.0");
+		const clone = join(dir, "clone", "app");
+		await fs.outputJson(
+			join(installed, ".claude-plugin", "plugin.json"),
+			declares([BUN]),
+		);
+		await fs.outputJson(join(clone, ".claude-plugin", "plugin.json"), {
+			name: "app",
+		});
+		await fs.outputJson(join(root, "installed_plugins.json"), {
+			version: 2,
+			plugins: {
+				"app@fixture": [
+					{
+						scope: "project",
+						projectPath: dir,
+						installPath: installed,
+						version: "1.0.0",
+						installedAt: "2026-01-01T00:00:00.000Z",
+						lastUpdated: "2026-01-01T00:00:00.000Z",
+					},
+				],
+			},
+		});
+		const found = await resolvePluginRequires("app@fixture", dir, {
+			root,
+			clone: async () => clone,
+		});
+		expect(found?.dir).toBe(installed);
+		expect(found?.parse).toEqual({ ok: true, requirements: [BUN] });
 
-	test("reads plugin.json at the plugin root", async () => {
-		await fs.writeJson(join(dir, "plugin.json"), {
-			name: "p",
-			requires: { bin: [{ name: "tmux", via: "brew" }] },
+		const notInstalled = await resolvePluginRequires("app@fixture", dir, {
+			root: join(dir, "no-registry"),
+			clone: async () => clone,
 		});
-		const r = await readPluginRequires(dir);
-		expect(r.bin?.[0]?.name).toBe("tmux");
+		expect(notInstalled?.dir).toBe(clone);
 	});
+});
 
-	test("falls back to .claude-plugin/plugin.json", async () => {
-		await fs.ensureDir(join(dir, ".claude-plugin"));
-		await fs.writeJson(join(dir, ".claude-plugin", "plugin.json"), {
-			name: "p",
-			requires: { bin: [{ name: "mnemex", via: "bun" }] },
-		});
-		const r = await readPluginRequires(dir);
-		expect(r.bin?.[0]?.name).toBe("mnemex");
+describe("selectBins", () => {
+	function pathWith(...tools: string[]): string {
+		const bin = join(dir, "bin");
+		mkdirSync(bin, { recursive: true });
+		for (const t of tools) {
+			writeFileSync(join(bin, t), "#!/bin/sh\nexit 0\n");
+			chmodSync(join(bin, t), 0o755);
+		}
+		return bin;
+	}
+
+	test("selects each requirement's first usable option, once, and records its root", () => {
+		const reqs: Requirement[] = [
+			BUN,
+			{
+				name: "claudish",
+				check: ["claudish", "--version"],
+				install: [{ via: "bun", package: "claudish", version: "6.0.0" }],
+			},
+			{
+				name: "jq",
+				check: ["jq", "--version"],
+				install: [{ via: "brew", formula: "jq" }],
+			},
+			{
+				name: "zsh",
+				check: ["zsh", "--version"],
+				install: [{ via: "apt", packages: ["zsh"] }],
+			},
+		];
+		const selected = selectBins(reqs, "/plugin", pathWith("brew", "apt-get"));
+		expect(selected.map((b) => [b.name, b.chosen, b.root])).toEqual([
+			// Bun's installer needs curl and unzip, and this PATH has neither.
+			["bun", null, "/plugin"],
+			[
+				"claudish",
+				{ via: "bun", package: "claudish", version: "6.0.0" },
+				"/plugin",
+			],
+			["jq", { via: "brew", formula: "jq" }, "/plugin"],
+			["zsh", { via: "apt", packages: ["zsh"] }, "/plugin"],
+		]);
+		// The declaration itself is carried unchanged.
+		expect(selected[1]?.check).toEqual(["claudish", "--version"]);
 	});
 
-	test("missing manifest → empty", async () => {
-		expect(await readPluginRequires(dir)).toEqual({});
+	test("a brew option is not selected without brew", () => {
+		const reqs: Requirement[] = [
+			{
+				name: "jq",
+				check: ["jq", "--version"],
+				install: [{ via: "brew", formula: "jq" }],
+			},
+		];
+		expect(selectBins(reqs, undefined, pathWith())[0]?.chosen).toBeNull();
 	});
 });