claudeup 6.3.0 → 6.4.0

package/src/__tests__/tabbar-layout.test.ts

@@ -4,13 +4,18 @@ import { TABS, barWidth, layoutTabs } from "../ui/components/TabBar.js";
 const FULL = TABS.map((t) => `${t.key}:${t.label}`);
 const FULL_WIDTH = barWidth(FULL);
 
+/** The widest the compacted bar ever gets — whichever active label is longest. */
+const WIDEST_COMPACT = Math.max(
+	...TABS.map((tab) => barWidth(layoutTabs(TABS, tab.screen, 0))),
+);
+
 describe("tab bar layout", () => {
 	test("shows every label when the bar fits", () => {
 		expect(layoutTabs(TABS, "plugins", FULL_WIDTH)).toEqual(FULL);
 	});
 
 	test("drops inactive labels when the bar does not fit", () => {
-		// A 94-column pane leaves ~90 usable, and nine full tabs need ~99 — the
+		// A 94-column pane leaves ~90 usable, and ten full tabs need ~110 — the
 		// width at which OpenTUI clipped each cell into a meaningless stub.
 		const texts = layoutTabs(TABS, "styles", 90);
 		expect(texts).toContain("9:Styles");
@@ -24,6 +29,26 @@ describe("tab bar layout", () => {
 		expect(barWidth(layoutTabs(TABS, "styles", 90))).toBeLessThanOrEqual(90);
 	});
 
+	test("the full bar no longer fits a standard window, so compacting is the norm", () => {
+		// The tenth tab pushed the full bar past 100 columns. That is not a
+		// regression — it is why the compact form has to stay readable, and why
+		// the test below measures it rather than assuming.
+		expect(FULL_WIDTH).toBeGreaterThan(100);
+		expect(layoutTabs(TABS, "models", 100)).not.toEqual(FULL);
+	});
+
+	test("the compact bar fits an 80-column terminal, on every tab", () => {
+		// The real question a tenth tab raises. ScreenLayout pads the bar by 1
+		// each side inside a container padded by 1, so an 80-column terminal
+		// leaves 76 — and the widest compact bar is well under it.
+		expect(WIDEST_COMPACT).toBeLessThanOrEqual(76);
+		for (const tab of TABS) {
+			expect(barWidth(layoutTabs(TABS, tab.screen, 76))).toBeLessThanOrEqual(
+				76,
+			);
+		}
+	});
+
 	test("keeps the label of whichever tab is active", () => {
 		for (const tab of TABS) {
 			const texts = layoutTabs(TABS, tab.screen, 40);
@@ -46,7 +71,9 @@ describe("tab bar layout", () => {
 
 	test("every tab key is a digit the global handler binds", () => {
 		// The compact bar shows only the number, so the number must be the key
-		// that actually navigates.
+		// that actually navigates. Models is keyed "0" and sits last, because the
+		// number row reads 1…9 then 0 — the order here and the order under the
+		// fingers have to agree.
 		expect(TABS.map((t) => t.key)).toEqual([
 			"1",
 			"2",
@@ -57,6 +84,17 @@ describe("tab bar layout", () => {
 			"7",
 			"8",
 			"9",
+			"0",
 		]);
+		expect(TABS.at(-1)).toEqual({
+			key: "0",
+			label: "Models",
+			screen: "models",
+		});
+	});
+
+	test("no two tabs share a key or a screen", () => {
+		expect(new Set(TABS.map((t) => t.key)).size).toBe(TABS.length);
+		expect(new Set(TABS.map((t) => t.screen)).size).toBe(TABS.length);
 	});
 });

package/src/__tests__/theme-adaptive-colors.test.ts

@@ -96,7 +96,18 @@ describe("contrast maths", () => {
 
 // ─── The palette ──────────────────────────────────────────────────────────────
 
-const ACCENTS = Object.entries(brand).filter(([name]) => name !== "ink");
+/**
+ * Inks we paint on a fill WE own, so they are measured against that fill and
+ * not against the terminal. They cannot satisfy the both-backgrounds rule and
+ * are not supposed to: `selectionDim` is a light grey chosen for the selection
+ * purple, which on a cream terminal would be invisible — and is never drawn
+ * there.
+ */
+const OWN_FILL_INKS = new Set(["ink", "selectionDim"]);
+
+const ACCENTS = Object.entries(brand).filter(
+	([name]) => !OWN_FILL_INKS.has(name),
+);
 
 describe("accents are legible on light AND dark terminals", () => {
 	test("the palette is non-empty (guards the loops below)", () => {
@@ -131,6 +142,42 @@ describe("accents are legible on light AND dark terminals", () => {
 		expect(failures).toEqual([]);
 	});
 
+	test("a SELECTED row has two legible inks, and the page palette is not among them", () => {
+		// Found on a screenshot: `(default)` was drawn in `theme.colors.muted` on
+		// the selection purple and simply was not there. Every page-level tone
+		// fails the same way — they are chosen against the terminal's background,
+		// and the selection fill is neither of the two references.
+		const bg = theme.selection.bg;
+		expect(contrastRatio(theme.selection.fg, bg)).toBeGreaterThanOrEqual(
+			INK_CONTRAST,
+		);
+		expect(contrastRatio(theme.selection.dim, bg)).toBeGreaterThanOrEqual(
+			UI_CONTRAST,
+		);
+
+		// And it must READ as secondary next to the primary ink, or the
+		// distinction it exists to make is not visible.
+		expect(
+			contrastRatio(theme.selection.dim, theme.selection.fg),
+		).toBeGreaterThan(1.2);
+		expect(contrastRatio(theme.selection.dim, bg)).toBeLessThan(
+			contrastRatio(theme.selection.fg, bg),
+		);
+	});
+
+	test("the meta tones are exactly why a selected row cannot use them", () => {
+		// The negative half of the rule above, kept measurable: if a future
+		// palette change made one of these legible on the selection, the
+		// selection-aware branch in MetaText would still be right, but this test
+		// would tell us the reasoning had changed.
+		const unreadable = Object.entries(theme.meta).filter(
+			([, hex]) => contrastRatio(hex, theme.selection.bg) < UI_CONTRAST,
+		);
+		expect(unreadable.map(([name]) => name).sort()).toEqual(
+			Object.keys(theme.meta).sort(),
+		);
+	});
+
 	test("the three scope colours are perceptually far apart", () => {
 		// They render as single-character squares, where a subtle shift is not
 		// readable at all. Deferring to ANSI put project and local on slots 2 and 3,

package/src/__tests__/version-snapshot.test.ts

@@ -150,12 +150,10 @@ describe("per-project baselines", () => {
 
 	test("a project with no baseline of its own reports nothing", async () => {
 		await withSandbox(async () => {
-			await saveSeenVersions("/proj/a", { "statusline@magus": "2.2.0" });
+			await saveSeenVersions("/proj/a", { "setup@magus": "2.2.0" });
 			const baseline = await loadSeenVersions("/proj/b");
 			expect(baseline).toBeNull();
-			expect(diffVersions(baseline, { "statusline@magus": "2.5.0" })).toEqual(
-				[],
-			);
+			expect(diffVersions(baseline, { "setup@magus": "2.5.0" })).toEqual([]);
 		});
 	});
 

package/src/cli/doctor.ts

@@ -6,15 +6,26 @@
  *      This is the check that would have caught a dead `tmux-mcp`.
  *   2. Profile symlink integrity — the active profile's links resolve.
  *   3. Convention compliance — .gitignore + CLAUDE.md blocks (ported engine).
+ *   4. Model routing — config validity, hook registration, and drift.
  */
 
 import path from "node:path";
 import fs from "fs-extra";
 import { checkBinaries, missingBinaries } from "../services/doctor-bins.js";
 import { checkProject, fixDoctorIssues } from "../services/doctor.js";
+import {
+	isAgentModelHookRegistered,
+	registerAgentModelHook,
+} from "../services/hook-registration.js";
 import { readManifest } from "../services/manifest.js";
+import {
+	readModelsConfig,
+	readModelsStatus,
+	reapplyModels,
+} from "../services/models-manager.js";
 import { resolveAllProfiles } from "../services/resolver.js";
 import { activeProfile, profileDir } from "../services/symlink-manager.js";
+import { resolveExecutable } from "../utils/command-utils.js";
 
 export async function runDoctorCommand(args: string[]): Promise<number> {
 	const fix = args.includes("--fix");
@@ -98,10 +109,89 @@ export async function runDoctorCommand(args: string[]): Promise<number> {
 		}
 	}
 
+	// 4. Model routing.
+	problems += await checkModels(projectPath, fix);
+
 	if (problems === 0) console.log("\n✓ No problems found.");
 	return problems > 0 && !fix ? 1 : 0;
 }
 
+/**
+ * Model routing health. Silent when the project has no routing at all — an
+ * absent `models.json` is the normal state, not a finding.
+ *
+ * Ordered by what blocks what: an invalid config routes nothing and cannot be
+ * fixed from here (the values are a human's decision); an unregistered hook
+ * routes nothing no matter how good the config is; drift only matters once
+ * both of those are sound.
+ */
+async function checkModels(projectPath: string, fix: boolean): Promise<number> {
+	const { config, errors, path: file } = await readModelsConfig(projectPath);
+	if (config === null && errors.length === 0) return 0;
+
+	console.log("\nModel routing:");
+	let problems = 0;
+
+	if (errors.length > 0) {
+		console.log(`  ✗ ${file} is invalid — nothing is routed:`);
+		for (const e of errors) {
+			console.log(`      ${e.path || "(root)"}: ${e.message}`);
+		}
+		console.log(
+			"    Not auto-fixable: these are choices, not damage. Edit the file (or",
+		);
+		console.log("    re-run `claudeup models use <preset>`) and check again.");
+		// An invalid config is worth exactly one problem, not one per message —
+		// the count drives the exit code, not the severity.
+		return 1;
+	}
+
+	// The hook is what applies the routing. Without it the config is inert.
+	if (await isAgentModelHookRegistered()) {
+		console.log("  ✓ agent-model hook registered at user scope.");
+	} else if (fix) {
+		await registerAgentModelHook();
+		console.log("  ✓ agent-model hook registered at user scope (fixed).");
+	} else {
+		console.log(
+			"  ✗ agent-model hook is not registered — the config is there, but nothing runs it.",
+		);
+		console.log("    Fix: claudeup doctor --fix");
+		problems++;
+	}
+
+	// The hook runs as a bare `claudeup`, deliberately (an absolute path dies on
+	// the next upgrade) — so PATH has to carry it. Warn only: PATH inside a
+	// Claude Code session is not necessarily PATH here.
+	if (!(await resolveExecutable("claudeup"))) {
+		console.log(
+			"  • `claudeup` is not on PATH in this shell. The hook invokes it by name,",
+		);
+		console.log(
+			"    so it must resolve in the shell Claude Code spawns hooks from.",
+		);
+	}
+
+	const status = await readModelsStatus(projectPath);
+	if (status.state === "stale") {
+		console.log("  ✗ settings have drifted from the config:");
+		for (const line of status.drift) console.log(`      ${line}`);
+		if (fix) {
+			await reapplyModels(projectPath);
+			console.log("    Re-applied the config (fixed).");
+		} else {
+			console.log("    Fix: claudeup doctor --fix");
+			problems++;
+		}
+	} else if (status.state === "on") {
+		console.log(`  ✓ preset "${status.preset}" applied, no drift.`);
+	}
+
+	for (const warning of status.warnings) console.log(`  ⚠ ${warning}`);
+
+	return problems;
+}
+
 /** Which of the active profile's expected symlinks are missing or dangling. */
 async function danglingLinks(
 	name: string,

package/src/cli/hook.ts

@@ -0,0 +1,129 @@
+/**
+ * `claudeup hook agent-model` — the PreToolUse hook Claude Code runs on every Agent call.
+ *
+ * This is the hottest path claudeup has: Claude Code spawns it once per subagent dispatch, in
+ * every session on the machine, and waits for it. Two consequences shape the whole file.
+ *
+ * IT MUST BE FAST. `main.tsx` routes here before it loads the project's `.env` and before it
+ * imports the router or the TUI, so nothing in this module may import `src/ui/` or anything
+ * that pulls in `@opentui`. `src/__tests__/hook-import-policy.test.ts` fails the build if that
+ * ever regresses. Measured: 0.02s on this path against 0.16s once the router is loaded.
+ *
+ * IT MUST FAIL OPEN. Every error path exits 0 with empty stdout, which Claude Code reads as
+ * "no opinion". A hook that throws, blocks, or exits non-zero takes the user's subagents with
+ * it, and the failure would surface as delegation mysteriously not working — in every project,
+ * not just the one with the bad config. Silence is always the safe answer, so it is the
+ * default and the fallback.
+ *
+ * It never writes a file, never exits 2, and never reads a `.env`.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, parse } from "node:path";
+import {
+	type ModelsConfig,
+	evaluateAgentHook,
+	validateModelsConfig,
+} from "../services/models-core.js";
+
+/** How far up the tree to look for a config before giving up. */
+const MAX_WALK_UP = 32;
+
+/**
+ * Find the nearest `.claude/models.json` at or above `startDir`.
+ *
+ * The walk matters: a session's cwd is frequently a subdirectory of the project, and this repo
+ * in particular runs most work inside git worktrees. Anchoring on the hook payload's `cwd`
+ * rather than `process.cwd()` is deliberate — Claude Code tells us where the session is, and
+ * that is not necessarily where this process was started.
+ */
+export function findModelsConfig(startDir: string): string | null {
+	let dir = startDir;
+	const root = parse(dir).root;
+	for (let i = 0; i < MAX_WALK_UP; i += 1) {
+		const candidate = join(dir, ".claude", "models.json");
+		if (existsSync(candidate)) return candidate;
+		if (dir === root) return null;
+		const parent = dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+	return null;
+}
+
+/**
+ * Read and validate a config. Returns null for every unusable state — missing, unreadable,
+ * unparseable, or invalid — because the hook's answer to all four is the same: do nothing.
+ *
+ * An invalid config is NOT an error here even though it is one everywhere else. `models use`
+ * refuses to write one, `claudeup install` refuses to apply one, and `doctor` reports one; by
+ * the time a session is running, the only useful behaviour left is to get out of the way.
+ */
+export function loadConfig(path: string): ModelsConfig | null {
+	let raw: unknown;
+	try {
+		raw = JSON.parse(readFileSync(path, "utf8"));
+	} catch {
+		return null;
+	}
+	if (validateModelsConfig(raw).length > 0) return null;
+	return raw as ModelsConfig;
+}
+
+async function readStdin(): Promise<string> {
+	// A hook always receives its payload on stdin. Guard the TTY case anyway so that a human
+	// typing the subcommand by hand gets an immediate no-op instead of a hang.
+	if (process.stdin.isTTY) return "";
+	const chunks: Uint8Array[] = [];
+	for await (const chunk of Bun.stdin.stream()) chunks.push(chunk);
+	return Buffer.concat(chunks).toString("utf8");
+}
+
+export async function runHookCommand(args: string[]): Promise<number> {
+	// `hook` with no recognised name is a no-op rather than a usage error: this process is
+	// wired into someone's session, and printing to stdout would be interpreted as a decision.
+	if (args[0] !== "agent-model") {
+		await readStdin();
+		return 0;
+	}
+
+	try {
+		const raw = await readStdin();
+		if (raw.trim().length === 0) return 0;
+
+		let payload: Record<string, unknown>;
+		try {
+			payload = JSON.parse(raw) as Record<string, unknown>;
+		} catch {
+			return 0;
+		}
+
+		// `cwd` is the session's directory, which is not this process's cwd.
+		const cwd =
+			typeof payload.cwd === "string" && payload.cwd.length > 0
+				? payload.cwd
+				: process.cwd();
+		const configPath = findModelsConfig(cwd);
+		const config = configPath === null ? null : loadConfig(configPath);
+
+		const decision = evaluateAgentHook(
+			{
+				tool_name:
+					typeof payload.tool_name === "string" ? payload.tool_name : undefined,
+				tool_input:
+					typeof payload.tool_input === "object" && payload.tool_input !== null
+						? (payload.tool_input as Record<string, unknown>)
+						: undefined,
+				cwd,
+			},
+			config,
+		);
+
+		if (decision.kind === "update")
+			process.stdout.write(JSON.stringify(decision.output));
+		return 0;
+	} catch {
+		// Belt and braces. Nothing above should throw, and if it ever does the session must
+		// not notice.
+		return 0;
+	}
+}

package/src/cli/models.ts

@@ -0,0 +1,214 @@
+/**
+ * `claudeup models list | use <preset> | status | off`
+ *
+ * The user-facing half of per-subagent model routing. Everything it prints is
+ * derived from `services/models-manager.ts`; this file owns wording and exit
+ * codes only.
+ *
+ * Exit codes: 1 for an unknown preset or a config that fails validation, 0
+ * otherwise. An unknown preset LISTS the valid names rather than near-matching
+ * one — `fable-lead` and `fable-advisor` differ by which model leads, and
+ * silently picking the closer string would route every subagent differently
+ * from what was asked.
+ */
+
+import {
+	BUILT_IN_PRESETS,
+	DEFAULT_PRESET,
+	presetLabel,
+	presetNames,
+} from "../data/models-presets.js";
+import {
+	GRADES,
+	type ModelsConfig,
+	type ModelsState,
+} from "../services/models-core.js";
+import {
+	applyModelPreset,
+	clearModels,
+	configPath,
+	readModelsConfig,
+	readModelsStatus,
+} from "../services/models-manager.js";
+import { ensureManifest } from "./bootstrap.js";
+
+const HEADLINE: Record<ModelsState, string> = {
+	off: "off — no .claude/models.json, subagents inherit the session model",
+	on: "on",
+	stale: "stale — settings no longer match the config",
+	invalid: "invalid — nothing is routed",
+	unhooked: "unhooked — the config is there, but nothing runs it",
+};
+
+/** `opus (medium)`, or `opus` when no effort is set. */
+function describeSpec(spec: { model: string; effort?: string }): string {
+	return spec.effort ? `${spec.model} (${spec.effort})` : spec.model;
+}
+
+/**
+ * A preset headed by what a person would call it, with the id beside it.
+ *
+ * Both, deliberately: the label is what you choose between ("Opus with Fable help" says which
+ * model leads and which helps), and the id is what you TYPE into `models use` and what lands
+ * in the committed config. Printing only the label would leave the command unguessable.
+ */
+function printPreset(preset: ModelsConfig, active: boolean): void {
+	const mark = active ? "●" : " ";
+	const isDefault = preset.preset === DEFAULT_PRESET ? "  (default)" : "";
+	console.log(
+		`${mark} ${presetLabel(preset.preset)}  —  ${preset.preset}${isDefault}`,
+	);
+	console.log(`    main       ${describeSpec(preset.main)}`);
+	for (const grade of GRADES) {
+		console.log(
+			`    ${grade.padEnd(10)} ${describeSpec(preset.grades[grade])}`,
+		);
+	}
+}
+
+async function runList(projectPath: string): Promise<number> {
+	const { config } = await readModelsConfig(projectPath);
+	console.log("\nModel tiers:\n");
+	for (const preset of BUILT_IN_PRESETS) {
+		printPreset(preset, config?.preset === preset.preset);
+		console.log();
+	}
+	if (config && !presetNames().includes(config.preset)) {
+		console.log(`● ${config.preset}  (this project's own, not a built-in)\n`);
+	}
+	console.log(
+		"Tiers name what a subagent is FOR: `smart` takes the judgement calls, `cheap`",
+	);
+	console.log(
+		"the searching. Which model serves each is the preset's call. Apply one with\n`claudeup models use <name>`.\n",
+	);
+	return 0;
+}
+
+async function runStatus(projectPath: string): Promise<number> {
+	const status = await readModelsStatus(projectPath);
+	console.log(`\nModel tiers: ${HEADLINE[status.state]}`);
+	if (status.preset)
+		console.log(
+			`Preset:      ${presetLabel(status.preset)} (${status.preset})`,
+		);
+	console.log(`Config:      ${configPath(projectPath)}`);
+
+	if (status.drift.length > 0) {
+		console.log(status.state === "invalid" ? "\nErrors:" : "\nDrift:");
+		for (const line of status.drift) console.log(`  ✗ ${line}`);
+		if (status.state === "stale") {
+			console.log(
+				"\n  Fix: claudeup models use <preset>  (or claudeup doctor --fix)",
+			);
+		}
+		if (status.state === "unhooked")
+			console.log("\n  Fix: claudeup doctor --fix");
+	}
+	for (const warning of status.warnings) console.log(`\n⚠ ${warning}`);
+	console.log();
+	return status.state === "invalid" ? 1 : 0;
+}
+
+async function runUse(projectPath: string, name?: string): Promise<number> {
+	if (!name) {
+		console.error("Usage: claudeup models use <preset>");
+		console.error(`Available: ${presetNames().join(", ")}`);
+		return 1;
+	}
+	if (!presetNames().includes(name)) {
+		// Never near-match. See the file header.
+		console.error(`Unknown preset "${name}".`);
+		console.error(`Available: ${presetNames().join(", ")}`);
+		return 1;
+	}
+
+	let result: Awaited<ReturnType<typeof applyModelPreset>>;
+	try {
+		result = await applyModelPreset({
+			projectPath,
+			preset: name,
+			ensureManifest: (p) => ensureManifest(p),
+		});
+	} catch (error) {
+		console.error(error instanceof Error ? error.message : String(error));
+		return 1;
+	}
+
+	console.log(`\n✓ Applied preset "${name}".`);
+	console.log(`  ${configPath(projectPath)}`);
+	console.log(`  ${result.settingsPath}`);
+	for (const [key, value] of Object.entries(result.wrote)) {
+		console.log(`    ${key} = ${JSON.stringify(value)}`);
+	}
+	console.log(
+		`  hook: ${result.hook === "registered" ? "registered at user scope" : "already registered"}`,
+	);
+
+	if (result.recordedInManifest && result.profile) {
+		console.log(
+			`\nRecorded in .claude/profiles.json under profiles.${result.profile}.`,
+		);
+		console.log("Commit .claude/profiles.json to share this with the team.");
+	} else {
+		console.log(
+			"\nNo active profile — written straight to .claude/models.json, which is",
+		);
+		console.log(
+			"generated and gitignored. Run `claudeup install` to adopt a profile if the",
+		);
+		console.log("team should share this routing.");
+	}
+	console.log();
+	return 0;
+}
+
+async function runOff(projectPath: string): Promise<number> {
+	await clearModels(projectPath);
+	console.log(
+		"\n✓ Model tiers off. Subagents inherit the session model again.",
+	);
+	console.log(
+		"  The hook stays registered — it is a no-op without a models.json.\n",
+	);
+	return 0;
+}
+
+function printUsage(): void {
+	console.log(`Usage: claudeup models <command>
+
+  list            Show the built-in tier presets; ● marks the active one
+  use <preset>    Apply a preset to this project and register the hook
+  status          What is routed right now, and any drift
+  off             Turn model tiers off (removes the config, keeps the hook)
+
+Available presets: ${presetNames().join(", ")}`);
+}
+
+/**
+ * `projectPath` defaults to the cwd, which is what the router passes. It is a
+ * parameter so tests can drive a temp project without moving the process —
+ * `cli/profile.ts` takes the same shape for the same reason.
+ */
+export async function runModelsCommand(
+	args: string[],
+	projectPath: string = process.cwd(),
+): Promise<number> {
+	const [command, ...rest] = args;
+
+	switch (command) {
+		case undefined:
+		case "status":
+			return runStatus(projectPath);
+		case "list":
+			return runList(projectPath);
+		case "use":
+			return runUse(projectPath, rest[0]);
+		case "off":
+			return runOff(projectPath);
+		default:
+			console.error(`Unknown models command "${command}".`);
+			printUsage();
+			return 1;
+	}
+}

package/src/cli/router.ts

@@ -12,6 +12,7 @@ import { parseThemeWord } from "../ui/theme-resolve.js";
 import { runClaudeCommand } from "./claude.js";
 import { runDoctorCommand } from "./doctor.js";
 import { runInstallCommand } from "./install.js";
+import { runModelsCommand } from "./models.js";
 import { runProfileCommand } from "./profile.js";
 import { runUpdateCommand } from "./update.js";
 import { runUpgradeCommand } from "./upgrade.js";
@@ -125,6 +126,8 @@ export async function route(
 			return HANDLED(await runInstallCommand(rest));
 		case "profile":
 			return HANDLED(await runProfileCommand(rest));
+		case "models":
+			return HANDLED(await runModelsCommand(rest));
 		case "doctor":
 			return HANDLED(await runDoctorCommand(rest));
 		default:
@@ -180,6 +183,15 @@ without one is offered adoption on first run. See docs/team-configuration.md.
   doctor             Check binary deps, profile symlinks, and conventions
     --fix            Apply the repairs it can make itself
 
+Per-subagent model routing — give each subagent its own model and effort. The
+routing lives on the active profile (committed in .claude/profiles.json) and is
+applied by a PreToolUse hook claudeup registers at user scope.
+  models list        Show the built-in presets; ● marks the active one
+  models use <p>     Apply a preset, record it on the active profile, and
+                     register the hook
+  models status      What is routed now, plus any drift from the config
+  models off         Stop routing; subagents inherit the session model again
+
 Other commands:
   claude [args...]   Check for plugin updates (1h cache), then run claude
     -f, --force      Force update check (bypass 1h cache)

package/src/data/gitignore-defaults.ts

@@ -14,6 +14,10 @@ export const BUILTIN_DEFAULTS: GitignoreManifest = {
 		".claude/.statusline-worktree-*",
 		// Generated, per-developer profile build output (like node_modules).
 		".claude/_profiles/",
+		// Generated from profiles.json (a symlink into _profiles/ when a profile
+		// is active). The routing itself IS committed — in profiles.json, under
+		// the profile that declares it.
+		".claude/models.json",
 		"ai-docs/sessions/",
 		".mnemex/",
 		".claudemem/",