claudeup 6.3.2 → 6.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudeup",
-  "version": "6.3.2",
+  "version": "6.5.0",
   "description": "TUI tool for managing Claude Code plugins, MCPs, and configuration",
   "type": "module",
   "main": "src/main.tsx",
@@ -64,8 +64,8 @@
     "typescript": "^5.6.3"
   },
   "optionalDependencies": {
-    "claudeup-darwin-arm64": "6.3.2",
-    "claudeup-darwin-x64": "6.3.2",
-    "claudeup-linux-x64": "6.3.2"
+    "claudeup-darwin-arm64": "6.5.0",
+    "claudeup-darwin-x64": "6.5.0",
+    "claudeup-linux-x64": "6.5.0"
   }
 }

package/src/__tests__/catalog-notice.test.ts

@@ -57,12 +57,12 @@ describe("buildCatalogNoticeText", () => {
 
 	it("names one or two failing marketplaces but only counts many", () => {
 		const few = buildCatalogNoticeText({
-			failures: [failure("magus"), failure("magus-alpha")],
+			failures: [failure("magus"), failure("magus-marketing")],
 			unverifiedPlugins: 0,
 			width: 160,
 			now: NOW,
 		});
-		expect(few).toContain("magus-alpha");
+		expect(few).toContain("magus-marketing");
 
 		const many = buildCatalogNoticeText({
 			failures: ["a", "b", "c", "d", "e", "f"].map((n) => failure(n)),
@@ -89,7 +89,7 @@ describe("buildCatalogNoticeText", () => {
 		const line = buildCatalogNoticeText({
 			failures: [
 				failure("magus", "rate-limited", NOW + 600_000),
-				failure("magus-alpha", "rate-limited", NOW + 45_000),
+				failure("magus-marketing", "rate-limited", NOW + 45_000),
 			],
 			unverifiedPlugins: 2,
 			width: 160,

package/src/__tests__/cli-live.test.ts

@@ -19,6 +19,7 @@
  */
 
 import { afterEach, describe, expect, test } from "bun:test";
+import { width } from "../cli/ansi.js";
 import { LiveRegion, withPaused } from "../cli/live.js";
 
 /** A write stream that records instead of drawing. */
@@ -157,7 +158,12 @@ describe("animated mode", () => {
 		const { live, writes } = region({ columns: 20 });
 		live.start(() => ["x".repeat(40)]);
 		const painted = writes.at(-1) ?? "";
-		expect(painted.replace(/\n$/, "")).toHaveLength(19);
+		// DISPLAY width, not `.length`. `truncate` appends a reset when colour is
+		// on, and colour is on exactly when stdout is a real terminal — so a
+		// `.length` assertion passed piped and failed the moment anyone ran the
+		// suite in a terminal, over four zero-width bytes. The claim being made
+		// here is about columns, so measure columns.
+		expect(width(painted.replace(/\n$/, ""))).toBe(19);
 		live.stop();
 	});
 
@@ -202,7 +208,8 @@ describe("resize", () => {
 		// biome-ignore lint/suspicious/noControlCharactersInRegex: ESC is the thing being matched.
 		const CURSOR_UP = /\x1b\[\d+A/;
 		expect(writes.some((w) => CURSOR_UP.test(w))).toBe(false);
-		expect(writes.at(-1)?.replace(/\n$/, "")).toHaveLength(39);
+		// Display width, for the reason given on the clipping test above.
+		expect(width((writes.at(-1) ?? "").replace(/\n$/, ""))).toBe(39);
 		live.stop();
 	});
 

package/src/__tests__/cli-update-view.test.ts

@@ -62,7 +62,7 @@ function plan(over: Partial<UpdatePlan> = {}): UpdatePlan {
 				scopes: [],
 			},
 			{
-				pluginId: "seo@magus",
+				pluginId: "designer@magus",
 				pinned: "latest",
 				installed: "1.8.0",
 				available: null,
@@ -182,7 +182,7 @@ describe("NO_COLOR", () => {
 
 	test("a note rides along on the row it explains", () => {
 		setColorEnabled(false);
-		const row = planReport(plan()).find((l) => l.includes("seo@magus"))!;
+		const row = planReport(plan()).find((l) => l.includes("designer@magus"))!;
 		expect(row).toContain("catalog unreachable");
 	});
 });

package/src/__tests__/footer-hints.test.ts

@@ -0,0 +1,40 @@
+/**
+ * `joinKeys` decides how a key group reads in the footer chip.
+ *
+ * Found on screen, not in review: the Models tab advertised apply as `Entera`, and the
+ * layout's own scroll hint had been rendering as `^U/^DPgUp/Dn` on EVERY screen in the app.
+ * Both are two key names concatenated with nothing between them, which reads as one key that
+ * does not exist.
+ */
+import { describe, expect, test } from "bun:test";
+import { joinKeys } from "../ui/components/layout/FooterHints.js";
+
+describe("joinKeys", () => {
+	test("single-character keys butt together, the way an arrow pair is written", () => {
+		expect(joinKeys(["↑", "↓"])).toBe("↑↓");
+		expect(joinKeys(["j", "k"])).toBe("jk");
+	});
+
+	test("one key is itself", () => {
+		expect(joinKeys(["U"])).toBe("U");
+		expect(joinKeys(["Enter"])).toBe("Enter");
+	});
+
+	test("named keys get a gap — the regression this exists for", () => {
+		expect(joinKeys(["Enter", "a"])).toBe("Enter a");
+		expect(joinKeys(["^U/^D", "PgUp/Dn"])).toBe("^U/^D PgUp/Dn");
+	});
+
+	test("a space, not a slash: several key names already contain one", () => {
+		expect(joinKeys(["^U/^D", "PgUp/Dn"])).not.toContain("//");
+	});
+
+	test("a multi-byte single character still counts as one", () => {
+		// "↑".length is 1 but an emoji's is 2 — count code points, not UTF-16 units.
+		expect(joinKeys(["⌘", "⇧"])).toBe("⌘⇧");
+	});
+
+	test("an empty group is empty rather than a stray separator", () => {
+		expect(joinKeys([])).toBe("");
+	});
+});

package/src/__tests__/gap-fill-versions.test.ts

@@ -117,20 +117,20 @@ describe("gapFillInstalledPluginVersions", () => {
 		await fs.remove(initTmpHome).catch(() => {});
 	});
 
-	// Scenario 1: "The kanban bug" — project has newer version, global is stale
-	it("bumps global when project has a newer version (the kanban bug)", async () => {
+	// Scenario 1: "The stale-global bug" — project has newer version, global is stale
+	it("bumps global when project has a newer version (the stale-global bug)", async () => {
 		await writeGlobalSettings({
-			installedPluginVersions: { "kanban@magus": "1.0.0" },
+			installedPluginVersions: { "designer@magus": "1.0.0" },
 		});
 		await writeProjectSettings({
-			installedPluginVersions: { "kanban@magus": "1.3.0" },
+			installedPluginVersions: { "designer@magus": "1.3.0" },
 		});
 
 		const result = await gapFillInstalledPluginVersions(tmpProject);
 
 		expect(result).toEqual([
 			{
-				pluginId: "kanban@magus",
+				pluginId: "designer@magus",
 				oldVersion: "1.0.0",
 				newVersion: "1.3.0",
 			},
@@ -138,7 +138,7 @@ describe("gapFillInstalledPluginVersions", () => {
 
 		// Verify the file was actually updated
 		const global = await readGlobalSettingsFromDisk();
-		expect((global as any).installedPluginVersions["kanban@magus"]).toBe(
+		expect((global as any).installedPluginVersions["designer@magus"]).toBe(
 			"1.3.0",
 		);
 	});
@@ -146,10 +146,10 @@ describe("gapFillInstalledPluginVersions", () => {
 	// Scenario 2: Global is already current — no changes needed
 	it("returns empty array when global is already at the highest version", async () => {
 		await writeGlobalSettings({
-			installedPluginVersions: { "kanban@magus": "1.3.0" },
+			installedPluginVersions: { "designer@magus": "1.3.0" },
 		});
 		await writeProjectSettings({
-			installedPluginVersions: { "kanban@magus": "1.3.0" },
+			installedPluginVersions: { "designer@magus": "1.3.0" },
 		});
 
 		const result = await gapFillInstalledPluginVersions(tmpProject);
@@ -158,7 +158,7 @@ describe("gapFillInstalledPluginVersions", () => {
 
 		// Verify global was NOT rewritten (check original content is intact)
 		const global = await readGlobalSettingsFromDisk();
-		expect((global as any).installedPluginVersions["kanban@magus"]).toBe(
+		expect((global as any).installedPluginVersions["designer@magus"]).toBe(
 			"1.3.0",
 		);
 	});
@@ -298,10 +298,10 @@ describe("gapFillInstalledPluginVersions", () => {
 	// Scenario 9: Global version is higher than project — no downgrade
 	it("does not downgrade global when global is higher than project", async () => {
 		await writeGlobalSettings({
-			installedPluginVersions: { "kanban@magus": "2.0.0" },
+			installedPluginVersions: { "designer@magus": "2.0.0" },
 		});
 		await writeProjectSettings({
-			installedPluginVersions: { "kanban@magus": "1.0.0" },
+			installedPluginVersions: { "designer@magus": "1.0.0" },
 		});
 
 		const result = await gapFillInstalledPluginVersions(tmpProject);
@@ -310,7 +310,7 @@ describe("gapFillInstalledPluginVersions", () => {
 
 		// Verify global was NOT downgraded
 		const global = await readGlobalSettingsFromDisk();
-		expect((global as any).installedPluginVersions["kanban@magus"]).toBe(
+		expect((global as any).installedPluginVersions["designer@magus"]).toBe(
 			"2.0.0",
 		);
 	});
@@ -318,12 +318,12 @@ describe("gapFillInstalledPluginVersions", () => {
 	// Scenario 10: Preserves unrelated settings fields during write
 	it("preserves other global settings fields when bumping versions", async () => {
 		await writeGlobalSettings({
-			enabledPlugins: { "kanban@magus": true, "dev@magus": true },
+			enabledPlugins: { "designer@magus": true, "dev@magus": true },
 			env: { SOME_VAR: "value" },
-			installedPluginVersions: { "kanban@magus": "1.0.0" },
+			installedPluginVersions: { "designer@magus": "1.0.0" },
 		});
 		await writeProjectSettings({
-			installedPluginVersions: { "kanban@magus": "2.0.0" },
+			installedPluginVersions: { "designer@magus": "2.0.0" },
 		});
 
 		const result = await gapFillInstalledPluginVersions(tmpProject);
@@ -333,11 +333,11 @@ describe("gapFillInstalledPluginVersions", () => {
 		// Verify other fields are preserved
 		const global = await readGlobalSettingsFromDisk();
 		expect((global as any).enabledPlugins).toEqual({
-			"kanban@magus": true,
+			"designer@magus": true,
 			"dev@magus": true,
 		});
 		expect((global as any).env).toEqual({ SOME_VAR: "value" });
-		expect((global as any).installedPluginVersions["kanban@magus"]).toBe(
+		expect((global as any).installedPluginVersions["designer@magus"]).toBe(
 			"2.0.0",
 		);
 	});
@@ -345,24 +345,24 @@ describe("gapFillInstalledPluginVersions", () => {
 	// Scenario 11: Invalid semver in GLOBAL scope gets overwritten
 	it("overwrites corrupted global version when project has valid semver", async () => {
 		await writeGlobalSettings({
-			installedPluginVersions: { "kanban@magus": "not-a-version" },
+			installedPluginVersions: { "designer@magus": "not-a-version" },
 		});
 		await writeProjectSettings({
-			installedPluginVersions: { "kanban@magus": "1.3.0" },
+			installedPluginVersions: { "designer@magus": "1.3.0" },
 		});
 
 		const result = await gapFillInstalledPluginVersions(tmpProject);
 
 		expect(result).toEqual([
 			{
-				pluginId: "kanban@magus",
+				pluginId: "designer@magus",
 				oldVersion: "not-a-version",
 				newVersion: "1.3.0",
 			},
 		]);
 
 		const global = await readGlobalSettingsFromDisk();
-		expect((global as any).installedPluginVersions["kanban@magus"]).toBe(
+		expect((global as any).installedPluginVersions["designer@magus"]).toBe(
 			"1.3.0",
 		);
 	});
@@ -370,10 +370,10 @@ describe("gapFillInstalledPluginVersions", () => {
 	// Scenario 12: Both global and project have invalid semver — no crash, no change
 	it("does nothing when all versions are invalid semver", async () => {
 		await writeGlobalSettings({
-			installedPluginVersions: { "kanban@magus": "broken" },
+			installedPluginVersions: { "designer@magus": "broken" },
 		});
 		await writeProjectSettings({
-			installedPluginVersions: { "kanban@magus": "also-broken" },
+			installedPluginVersions: { "designer@magus": "also-broken" },
 		});
 
 		const result = await gapFillInstalledPluginVersions(tmpProject);
@@ -382,7 +382,7 @@ describe("gapFillInstalledPluginVersions", () => {
 
 		// Global unchanged
 		const global = await readGlobalSettingsFromDisk();
-		expect((global as any).installedPluginVersions["kanban@magus"]).toBe(
+		expect((global as any).installedPluginVersions["designer@magus"]).toBe(
 			"broken",
 		);
 	});

package/src/__tests__/gitignore-prerun.test.ts

@@ -3,6 +3,7 @@ import { spawnSync } from "node:child_process";
 import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { BUILTIN_DEFAULTS } from "../data/gitignore-defaults.js";
 import {
 	checkGitignore,
 	formatPrerunWarning,
@@ -40,21 +41,13 @@ describe("checkGitignore", () => {
 		git(projectDir, "init", "-q");
 		git(projectDir, "config", "user.email", "t@t");
 		git(projectDir, "config", "user.name", "t");
-		// Suppress all built-in ignore rules
+		// Suppress all built-in ignore rules. DERIVED from the constant, not a
+		// hand-copied list: a copy silently becomes a different assertion the
+		// moment a pattern is added, and then fails for a reason that has nothing
+		// to do with what this test is about.
 		await writeFile(
 			join(projectDir, ".gitignore"),
-			`${[
-				".claude/settings.local.json",
-				".claude/scheduled_tasks.lock",
-				".claude/cache/",
-				".claude/.statusline-worktree-*",
-				".claude/_profiles/",
-				"ai-docs/sessions/",
-				".mnemex/",
-				".claudemem/",
-				"gtd/sessions/",
-				".agents/",
-			].join("\n")}\n`,
+			`${BUILTIN_DEFAULTS.ignore.join("\n")}\n`,
 		);
 		// Tracked files don't have to exist for the absent-track-path case to be ignored
 		const r = await checkGitignore(projectDir);

package/src/__tests__/hook-import-policy.test.ts

@@ -0,0 +1,90 @@
+/**
+ * The hook path must never load the TUI.
+ *
+ * Claude Code runs `claudeup hook …` on every matching tool call, so anything
+ * the entry point imports is paid for on every tool call — and `@opentui/*`
+ * plus the `src/ui/` tree is the expensive half of this program. Two guards,
+ * because they fail differently:
+ *
+ *  - H-1 BUNDLES `src/cli/hook.ts` and inspects the output. A transitive import
+ *    added three modules deep still shows up here.
+ *  - H-2 reads `src/main.tsx` as text. Bundling cannot see this one: the TUI is
+ *    reachable from main.tsx by design, just only through a dynamic import that
+ *    the hook branch returns before. A *static* import would re-couple them
+ *    while every runtime test still passed, so the source is what is pinned —
+ *    the same technique dual-write-prevention.test.ts uses.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+
+const HOOK_ENTRY = path.join(import.meta.dir, "..", "cli", "hook.ts");
+const MAIN_TSX = path.join(import.meta.dir, "..", "main.tsx");
+
+/** Drop `//` line comments and `/* *\/` blocks so the guards match code only. */
+function stripComments(source: string): string {
+	return source.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/[^\n]*/g, "");
+}
+
+describe("hook entry point", () => {
+	test("H-1: bundling src/cli/hook.ts pulls in neither @opentui nor src/ui", async () => {
+		const build = await Bun.build({
+			entrypoints: [HOOK_ENTRY],
+			target: "bun",
+		});
+
+		expect(build.logs).toEqual([]);
+		expect(build.success).toBe(true);
+		expect(build.outputs.length).toBeGreaterThan(0);
+
+		const bundle = (
+			await Promise.all(build.outputs.map((output) => output.text()))
+		).join("\n");
+
+		expect(bundle).not.toContain("@opentui");
+		expect(bundle).not.toContain("/ui/");
+	});
+});
+
+describe("main.tsx import policy", () => {
+	const source = stripComments(readFileSync(MAIN_TSX, "utf-8"));
+
+	/**
+	 * Every STATIC import/export specifier. `from "…"` only, which is exactly
+	 * what a dynamic `import("…")` does not have — so the dynamic loads main.tsx
+	 * relies on are invisible here, and that is the point.
+	 */
+	const staticSpecifiers = [
+		...source.matchAll(/\bfrom\s+["']([^"']+)["']/g),
+	].map((match) => match[1] as string);
+
+	test("H-2: no static import of @opentui/*", () => {
+		expect(staticSpecifiers.filter((s) => s.startsWith("@opentui"))).toEqual(
+			[],
+		);
+	});
+
+	test("H-2b: no static import of ./ui/*", () => {
+		expect(staticSpecifiers.filter((s) => s.startsWith("./ui/"))).toEqual([]);
+	});
+
+	test("H-2c: the guard sees the specifiers it is meant to see", () => {
+		// Negative control: a regex that matched nothing would pass H-2 and H-2b
+		// forever. main.tsx does still carry static imports — just harmless ones.
+		expect(staticSpecifiers.length).toBeGreaterThan(0);
+		expect(staticSpecifiers).toContain("./services/dotenv.js");
+	});
+
+	test("H-3: the hook branch is dispatched before the .env load", () => {
+		// Ordering, at source level, for the same reason theme-env.test.ts pins
+		// the snapshot: a hook must never open a project .env — it may be a
+		// symlink to a FIFO, and reading one blocks on every tool call.
+		const hookAt = source.indexOf('await import("./cli/hook.js")');
+		const dotenvAt = source.indexOf("loadProjectDotenv(");
+
+		expect(hookAt).toBeGreaterThan(-1);
+		expect(dotenvAt).toBeGreaterThan(-1);
+		expect(hookAt).toBeLessThan(dotenvAt);
+	});
+});

package/src/__tests__/hook-process.test.ts

@@ -0,0 +1,256 @@
+/**
+ * The hook as Claude Code actually runs it: a spawned process, a JSON payload on stdin, and
+ * whatever lands on stdout.
+ *
+ * `models-core.test.ts` covers the decision logic in-process. This file covers the things only
+ * a real spawn can show — that the binary starts, that it reads stdin, that it finds a config
+ * by walking up from the payload's cwd, and above all that EVERY failure mode is silent and
+ * exit 0. Claude Code spawns this on every Agent call in every session on the machine, so a
+ * hook that throws, hangs or exits non-zero would break delegation everywhere at once.
+ *
+ * The negative control is the point of the file: without a config, the same invocation must
+ * produce nothing at all. A test that only checks the happy path cannot tell a working hook
+ * from one that injects unconditionally.
+ */
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import {
+	mkdirSync,
+	mkdtempSync,
+	rmSync,
+	symlinkSync,
+	writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const MAIN = join(dirname(fileURLToPath(import.meta.url)), "..", "main.tsx");
+
+let dir: string;
+
+interface RunResult {
+	stdout: string;
+	stderr: string;
+	exitCode: number;
+	ms: number;
+}
+
+/** Spawn the hook exactly as a settings.json `command` entry would. */
+async function runHook(
+	payload: unknown,
+	opts: { cwd?: string; args?: string[] } = {},
+): Promise<RunResult> {
+	const started = Date.now();
+	const proc = Bun.spawn(
+		["bun", "--no-env-file", MAIN, "hook", ...(opts.args ?? ["agent-model"])],
+		{
+			cwd: opts.cwd ?? dir,
+			stdin: new TextEncoder().encode(
+				typeof payload === "string" ? payload : JSON.stringify(payload),
+			),
+			stdout: "pipe",
+			stderr: "pipe",
+		},
+	);
+	const [stdout, stderr, exitCode] = await Promise.all([
+		new Response(proc.stdout).text(),
+		new Response(proc.stderr).text(),
+		proc.exited,
+	]);
+	return { stdout, stderr, exitCode, ms: Date.now() - started };
+}
+
+const CONFIG = {
+	version: 1,
+	preset: "test",
+	main: { model: "opus", effort: "medium" },
+	grades: {
+		smart: { model: "fable", effort: "xhigh" },
+		normal: { model: "opus", effort: "medium" },
+		cheap: { model: "sonnet", effort: "low" },
+	},
+	agents: {
+		"dev:architect": "smart",
+		Explore: "cheap",
+		"dev:researcher": { model: "inherit" },
+	},
+	fallback: "normal",
+};
+
+function writeConfig(at: string, config: unknown = CONFIG): void {
+	mkdirSync(join(at, ".claude"), { recursive: true });
+	writeFileSync(
+		join(at, ".claude", "models.json"),
+		JSON.stringify(config, null, 2),
+	);
+}
+
+const agentPayload = (input: Record<string, unknown> = {}, cwd = dir) => ({
+	hook_event_name: "PreToolUse",
+	tool_name: "Agent",
+	cwd,
+	tool_input: { subagent_type: "dev:architect", prompt: "go", ...input },
+});
+
+beforeEach(() => {
+	dir = mkdtempSync(join(tmpdir(), "claudeup-hook-"));
+});
+afterEach(() => {
+	rmSync(dir, { recursive: true, force: true });
+});
+
+describe("claudeup hook agent-model", () => {
+	test("injects the routed model, and emits hookEventName", async () => {
+		writeConfig(dir);
+		const r = await runHook(agentPayload());
+		expect(r.exitCode).toBe(0);
+		expect(r.stderr).toBe("");
+		expect(JSON.parse(r.stdout)).toEqual({
+			hookSpecificOutput: {
+				hookEventName: "PreToolUse",
+				updatedInput: {
+					subagent_type: "dev:architect",
+					prompt: "go",
+					model: "fable",
+				},
+			},
+		});
+	});
+
+	test("NEGATIVE CONTROL: no config means no output at all", async () => {
+		// Without this the happy path above cannot distinguish routing from injecting always.
+		const r = await runHook(agentPayload());
+		expect(r.exitCode).toBe(0);
+		expect(r.stdout).toBe("");
+		expect(r.stderr).toBe("");
+	});
+
+	test("walks up to a config in a parent directory", async () => {
+		writeConfig(dir);
+		const nested = join(dir, "packages", "api", "src");
+		mkdirSync(nested, { recursive: true });
+		const r = await runHook(agentPayload({}, nested));
+		expect(JSON.parse(r.stdout).hookSpecificOutput.updatedInput.model).toBe(
+			"fable",
+		);
+	});
+
+	test("uses the payload's cwd, not the process's", async () => {
+		// A session's directory is not where this process was started, and the payload is the
+		// only thing that knows the difference.
+		const elsewhere = mkdtempSync(join(tmpdir(), "claudeup-hook-other-"));
+		try {
+			writeConfig(elsewhere);
+			const r = await runHook(agentPayload({}, elsewhere), { cwd: dir });
+			expect(JSON.parse(r.stdout).hookSpecificOutput.updatedInput.model).toBe(
+				"fable",
+			);
+		} finally {
+			rmSync(elsewhere, { recursive: true, force: true });
+		}
+	});
+
+	test("respects a model the caller already set", async () => {
+		writeConfig(dir);
+		const r = await runHook(agentPayload({ model: "haiku" }));
+		expect(r.stdout).toBe("");
+	});
+
+	test("`inherit` leaves the call alone", async () => {
+		writeConfig(dir);
+		const r = await runHook(agentPayload({ subagent_type: "dev:researcher" }));
+		expect(r.stdout).toBe("");
+	});
+
+	test("an unknown agent takes the fallback grade", async () => {
+		writeConfig(dir);
+		const r = await runHook(agentPayload({ subagent_type: "brand-new:agent" }));
+		expect(JSON.parse(r.stdout).hookSpecificOutput.updatedInput.model).toBe(
+			"opus",
+		);
+	});
+
+	test("ignores a tool that is not Agent", async () => {
+		writeConfig(dir);
+		const r = await runHook({
+			tool_name: "Bash",
+			cwd: dir,
+			tool_input: { command: "ls" },
+		});
+		expect(r.stdout).toBe("");
+		expect(r.exitCode).toBe(0);
+	});
+
+	describe("fails open", () => {
+		test("garbage on stdin", async () => {
+			writeConfig(dir);
+			const r = await runHook("not json at all {{{");
+			expect(r.exitCode).toBe(0);
+			expect(r.stdout).toBe("");
+		});
+
+		test("empty stdin", async () => {
+			writeConfig(dir);
+			const r = await runHook("");
+			expect(r.exitCode).toBe(0);
+			expect(r.stdout).toBe("");
+		});
+
+		test("an unparseable config", async () => {
+			mkdirSync(join(dir, ".claude"), { recursive: true });
+			writeFileSync(join(dir, ".claude", "models.json"), "{ broken");
+			const r = await runHook(agentPayload());
+			expect(r.exitCode).toBe(0);
+			expect(r.stdout).toBe("");
+		});
+
+		test("an INVALID config routes nothing rather than injecting a bad model", async () => {
+			// Measured (AMR-1 bogus-model): a non-alias refuses the spawn outright, so injecting
+			// one would break every delegation for everyone who pulled the config.
+			writeConfig(dir, {
+				...CONFIG,
+				grades: { ...CONFIG.grades, smart: { model: "kimi-k2" } },
+			});
+			const r = await runHook(agentPayload());
+			expect(r.exitCode).toBe(0);
+			expect(r.stdout).toBe("");
+		});
+
+		test("a config from a future version", async () => {
+			writeConfig(dir, { ...CONFIG, version: 99 });
+			const r = await runHook(agentPayload());
+			expect(r.exitCode).toBe(0);
+			expect(r.stdout).toBe("");
+		});
+
+		test("an unrecognised hook name", async () => {
+			writeConfig(dir);
+			const r = await runHook(agentPayload(), { args: ["something-else"] });
+			expect(r.exitCode).toBe(0);
+			expect(r.stdout).toBe("");
+		});
+	});
+
+	test("a .env symlinked to a FIFO does not hang the hook", async () => {
+		// In this repo `.env` is often a symlink to a 1Password FIFO. Bun autoloads the cwd's
+		// .env before user code unless told not to, and reading a FIFO with no writer blocks
+		// forever — which would look exactly like Claude Code freezing on every Agent call.
+		writeConfig(dir);
+		const fifo = join(dir, "fifo-target");
+		Bun.spawnSync(["mkfifo", fifo]);
+		symlinkSync(fifo, join(dir, ".env"));
+		const r = await runHook(agentPayload());
+		expect(r.exitCode).toBe(0);
+		expect(JSON.parse(r.stdout).hookSpecificOutput.updatedInput.model).toBe(
+			"fable",
+		);
+	});
+
+	test("stays well inside a hook timeout", async () => {
+		writeConfig(dir);
+		const r = await runHook(agentPayload());
+		// Registered with timeout: 5s. From source (not the compiled binary) this measures
+		// ~0.02-0.3s; a regression that pulls the TUI back onto this path would blow past it.
+		expect(r.ms).toBeLessThan(3000);
+	});
+});