claudeup 6.3.2 → 6.5.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,10 +14,13 @@ 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/",
-		"gtd/sessions/",
 		".agents/",
 	],
 	track: [

package/src/data/gitignore-reasons.ts

@@ -29,10 +29,6 @@ const RULE_REASONS = new Map<string, string>([
 		key("ignore", ".claudemem/"),
 		"Local claudemem indexes are generated from the repo and should not be committed.",
 	],
-	[
-		key("ignore", "gtd/sessions/"),
-		"Local GTD session artifacts are personal workflow state.",
-	],
 	[
 		key("ignore", ".agents/"),
 		"Local agent workspaces and runtime artifacts should stay out of team history.",

package/src/data/marketplaces.ts

@@ -47,25 +47,11 @@ export const defaultMarketplaces: Marketplace[] = [
 			source: "github",
 			repo: "MadAppGang/magus-marketing",
 		},
-		description:
-			"SEO, cold email outreach, AI image generation, and video editing plugins",
+		description: "AI image generation and video editing plugins",
 		official: false,
 		owned: true, // Ours: always listed even when uninstalled, sorted to the top
 		// Not featured: a niche channel, so keep it collapsed by default.
 	},
-	{
-		name: "magus-alpha",
-		displayName: "Magus Alpha",
-		source: {
-			source: "github",
-			repo: "MadAppGang/magus-alpha",
-		},
-		description:
-			"Experimental plugins with evolving interfaces — may change or be withdrawn without notice",
-		official: false,
-		owned: true, // Ours: always listed even when uninstalled, sorted to the top
-		// Not featured: experimental, so keep it collapsed by default.
-	},
 	{
 		name: "claude-plugins-official",
 		displayName: "Anthropic Official",

package/src/data/models-presets.ts

@@ -0,0 +1,270 @@
+/**
+ * Built-in presets and the shared agent → tier table.
+ *
+ * Hand-written constants rather than a glob over data files, for the same reason
+ * `src/data/styles/index.ts` hand-lists its embedded presets: a glob cannot resolve at
+ * `bun build --compile` time, and this module has to survive into the compiled binary — the
+ * hook path reads a project's own `models.json`, but `claudeup models list` and the TUI read
+ * these.
+ *
+ * Tiers name what a subagent is FOR, on one axis: `smart`, `normal`, `cheap`, plus `main` for
+ * the orchestrator. Which model serves each is the PRESET's call, and `smart` is not always
+ * its largest spend: `fable-advisor` sends the judgement calls to a different model (fable at
+ * `medium`) rather than a harder-working one. What holds everywhere is the other half: the
+ * thread dispatching the work is never strictly the biggest spend in the preset.
+ */
+import type { Grade, ModelsConfig } from "../services/models-core.js";
+
+/**
+ * Which tier each subagent gets, shared by every preset.
+ *
+ * Keys are `subagent_type` strings exactly as the Agent tool receives them: bare names for
+ * Claude Code's built-ins, `plugin:name` for plugin agents. A name absent from this table
+ * falls to the preset's `fallback`, so a newly installed plugin routes sensibly on day one
+ * instead of silently inheriting the orchestrator's model.
+ */
+export const DEFAULT_AGENT_GRADES: Record<string, Grade> = {
+	// `smart` is for JUDGEMENT — work where the agent decides something a person would
+	// argue about, and where being wrong is expensive to undo.
+	Plan: "smart",
+	"dev:architect": "smart",
+	"dev:reviewer": "smart",
+	"dev:debugger": "smart",
+	"multimodel:deep-analyst": "smart",
+
+	// `normal`: transforms material it is GIVEN. Real work, bounded judgement.
+	//
+	// `spec-writer` reads an interview log and writes it up as a spec — the decisions were
+	// made during the interview, and this turns answers into structure. `synthesizer` merges
+	// reviews it is handed into one report against thresholds it is handed. Neither decides
+	// what is true; both were on `smart` because "writes an important document" got confused
+	// with "makes an expensive judgement".
+	"dev:spec-writer": "normal",
+	"dev:synthesizer": "normal",
+
+	// Reading a lot is not analysing.
+	//
+	// `detective` is read-only: it locates implementations, traces a path and reports
+	// file:line. That is high-volume retrieval with light inference — the same shape as
+	// `Explore`, with more structure in the output. It sat on `smart` because "investigates"
+	// sounds like thinking; what it actually does is look.
+	"code-analysis:detective": "cheap",
+
+	// Search, transcription and bookkeeping: bounded, mechanical, high-volume.
+	Explore: "cheap",
+	"dev:scribe": "cheap",
+	"dev:stack-detector": "cheap",
+	"dev:docs": "cheap",
+	"terminal:tui-navigator": "cheap",
+	"statusline-setup": "cheap",
+};
+
+/**
+ * The three workflows the `dev` plugin actually runs, and the agents each one dispatches.
+ *
+ * A single "17 agents" bar counts every agent claudeup has ever heard of, weighted equally —
+ * which is not how a session spends anything. Nobody runs all seventeen; they run ONE of
+ * these, and what it costs depends on which handful it reaches for. `/dev:investigate`
+ * touching two cheap agents and `/dev:dev` touching five across three tiers are different
+ * answers to "what will this preset cost me", and the lump sum shows neither.
+ *
+ * Read out of `plugins/dev/commands/{dev,debug,investigate}.md` — agents only. Those files
+ * also name skills (`dev:context-detection`, `code-analysis:investigate`) which are not
+ * dispatched through the Agent tool and so are not routed at all.
+ */
+export const WORKFLOWS: { name: string; agents: string[] }[] = [
+	{
+		name: "dev",
+		agents: [
+			"dev:stack-detector",
+			"dev:architect",
+			"dev:developer",
+			"dev:test-architect",
+			"dev:reviewer",
+		],
+	},
+	{
+		name: "debug",
+		agents: [
+			"dev:stack-detector",
+			"code-analysis:detective",
+			"dev:debugger",
+			"dev:developer",
+		],
+	},
+	{
+		name: "investigate",
+		agents: ["code-analysis:detective", "dev:researcher"],
+	},
+];
+
+/**
+ * Agents whose model is a CAPABILITY choice, not a spend choice.
+ *
+ * The three tiers answer "how much model", and that is the wrong question for an agent that
+ * reads images. `designer:design-review` compares a rendered screen against a reference and
+ * `designer:ui` audits a screenshot for usability: what they need is the model that SEES
+ * best, which is not a point on a cheap-to-smart line and does not move when the preset
+ * changes.
+ *
+ * They are deliberately absent from the tier table above and from this map until the model
+ * is chosen from the live catalogue rather than from memory. Absent means they fall to the
+ * preset's `fallback`, which is a defensible default and an honest one; pinning them to a
+ * model id guessed here is neither.
+ */
+export const VISION_AGENTS = ["designer:design-review", "designer:ui"] as const;
+
+function preset(
+	name: string,
+	main: ModelsConfig["main"],
+	grades: ModelsConfig["grades"],
+): ModelsConfig {
+	return {
+		version: 1,
+		preset: name,
+		main,
+		grades,
+		agents: { ...DEFAULT_AGENT_GRADES },
+		fallback: "normal",
+	};
+}
+
+/**
+ * What each preset is CALLED on screen.
+ *
+ * The id (`fable-advisor`) is the machine name: it is what `models use` takes, what lands in
+ * the committed config, and what must never change. The label is what a person reads, and it
+ * says which model leads and which one helps — the thing you actually choose between. Kept
+ * beside the presets rather than in the UI so the CLI and the TUI cannot disagree.
+ */
+export const PRESET_LABELS: Record<string, string> = {
+	"fable-advisor": "Opus with Fable help",
+	"fable-lead": "Fable main",
+	"fable-top": "Fable top",
+	"opus-lead": "Opus main",
+	"sonnet-economy": "Sonnet",
+};
+
+/** The screen name for a preset id, falling back to the id for a hand-edited config. */
+export function presetLabel(id: string): string {
+	return PRESET_LABELS[id] ?? id;
+}
+
+/**
+ * The shipped presets.
+ *
+ * Effort is set per seat and reaches subagents through `modelSettings` — measured by
+ * `benches/agent-model-routing/` (AMR-1), which found alias keys honoured and a routed
+ * subagent running at its model's effort while the main thread kept its own.
+ *
+ * ## Effort belongs to the MODEL, so a preset gets one value per model
+ *
+ * `modelSettings` is keyed by model. Two seats naming the same model therefore cannot carry
+ * different efforts, and the validator rejects that rather than letting one silently win.
+ * That is the only cross-seat rule here: **within one preset, a model appears at exactly one
+ * effort.** Which effort is a per-preset choice — `fable-lead` runs fable at `medium` and
+ * `fable-top` runs it at `xhigh`, and that difference is the whole distinction between them.
+ *
+ * Presets never collide with each other, because only one is ever applied to a project.
+ *
+ * ## The levelling these presets apply
+ *
+ * Each one fixes every model it names at a single effort, which is what makes it writable:
+ *
+ *   opus      xhigh wherever it appears
+ *   fable     medium in `fable-lead`, xhigh in `fable-top`
+ *   sonnet    high in the `cheap` seat, xhigh when it holds the whole preset
+ *   haiku     not used
+ *
+ * A tier therefore differs from its neighbour by MODEL, not by a throttle on one model. That
+ * is not a style choice: a ramp like "fable xhigh on `smart`, fable low on `cheap`" is exactly
+ * what the `modelSettings` keying cannot express.
+ */
+export const BUILT_IN_PRESETS: ModelsConfig[] = [
+	// The default: opus runs everything except the judgement calls, which go to fable.
+	//
+	// Opus takes `main` and `normal` at `xhigh`, fable takes `smart` at its ordinary `medium`,
+	// and sonnet picks up the cheap seat at `high`. The id says what fable DOES here — it
+	// advises on the hard work rather than running the thread.
+	preset(
+		"fable-advisor",
+		{ model: "opus", effort: "xhigh" },
+		{
+			smart: { model: "fable", effort: "medium" },
+			normal: { model: "opus", effort: "xhigh" },
+			cheap: { model: "sonnet", effort: "high" },
+		},
+	),
+
+	// Fable runs everything it can, at its ordinary `medium`, with sonnet on the cheap seat.
+	//
+	// "Fable on the main orchestrator" — the request, literally, extended to the tiers it
+	// dispatches. Paired with `fable-top` below: the same model on `main` and `smart`, one
+	// effort apart.
+	preset(
+		"fable-lead",
+		{ model: "fable", effort: "medium" },
+		{
+			smart: { model: "fable", effort: "medium" },
+			normal: { model: "fable", effort: "medium" },
+			cheap: { model: "sonnet", effort: "high" },
+		},
+	),
+
+	// Fable at full stretch on the thread and the judgement calls; opus does the building.
+	//
+	// `fable-lead` runs fable at `medium` in three seats; this runs it at `xhigh` in two and
+	// hands `normal` — the highest-volume tier, since it is also the `fallback` — to opus.
+	// The difference between the two presets is fable's effort, which is why it has to BE two
+	// presets rather than one with a ramp.
+	preset(
+		"fable-top",
+		{ model: "fable", effort: "xhigh" },
+		{
+			smart: { model: "fable", effort: "xhigh" },
+			normal: { model: "opus", effort: "xhigh" },
+			cheap: { model: "sonnet", effort: "high" },
+		},
+	),
+
+	// Opus everywhere it is reached at all, at `xhigh`; sonnet only on the cheap seat.
+	//
+	// `main`, `smart` and `normal` are one spend decision wearing three names. That is legal
+	// precisely because they agree on effort, and it is the point of the preset rather than a
+	// compromise: the only thing NOT on opus is the searching and transcription.
+	preset(
+		"opus-lead",
+		{ model: "opus", effort: "xhigh" },
+		{
+			smart: { model: "opus", effort: "xhigh" },
+			normal: { model: "opus", effort: "xhigh" },
+			cheap: { model: "sonnet", effort: "high" },
+		},
+	),
+
+	// Sonnet, at `xhigh`, in all four seats.
+	//
+	// This preset deliberately has no tier differentiation: its saving is the model, and the
+	// effort is not throttled on top of it. Every routed agent runs sonnet at `xhigh`,
+	// including `cheap` — so the hook still pins the model (a session started on opus does
+	// not leak into its subagents) while the tier table itself makes no distinction.
+	preset(
+		"sonnet-economy",
+		{ model: "sonnet", effort: "xhigh" },
+		{
+			smart: { model: "sonnet", effort: "xhigh" },
+			normal: { model: "sonnet", effort: "xhigh" },
+			cheap: { model: "sonnet", effort: "xhigh" },
+		},
+	),
+];
+
+export const DEFAULT_PRESET = "fable-advisor";
+
+export function findPreset(name: string): ModelsConfig | undefined {
+	return BUILT_IN_PRESETS.find((p) => p.preset === name);
+}
+
+export function presetNames(): string[] {
+	return BUILT_IN_PRESETS.map((p) => p.preset);
+}

package/src/data/predefined-profiles.ts

@@ -1,3 +1,5 @@
+import type { ModelsConfig } from "../services/models-core.js";
+
 export interface PredefinedProfile {
 	id: string;
 	name: string;
@@ -7,6 +9,13 @@ export interface PredefinedProfile {
 	anthropicPlugins: string[];
 	skills: string[];
 	settings: Record<string, unknown>;
+	/**
+	 * Per-subagent model routing a profile inherits via `extends`. None of the
+	 * profiles below declare one — routing is chosen per project by `claudeup
+	 * models use`, not bundled with a plugin set — but the field is here so the
+	 * inheritance path in `resolveExtends` is real rather than notional.
+	 */
+	models?: ModelsConfig;
 }
 
 export const PREDEFINED_PROFILES: PredefinedProfile[] = [
@@ -48,7 +57,6 @@ export const PREDEFINED_PROFILES: PredefinedProfile[] = [
 			"browser-use",
 			"designer",
 			"terminal",
-			"kanban",
 		],
 		anthropicPlugins: [
 			"claude-code-setup",
@@ -121,14 +129,7 @@ export const PREDEFINED_PROFILES: PredefinedProfile[] = [
 		name: "Backend Forge",
 		description: "API development, debugging, code quality, data workflows",
 		icon: "★",
-		magusPlugins: [
-			"dev",
-			"code-analysis",
-			"terminal",
-			"setup",
-			"multimodel",
-			"gtd",
-		],
+		magusPlugins: ["dev", "code-analysis", "terminal", "setup", "multimodel"],
 		anthropicPlugins: [
 			"feature-dev",
 			"code-review",
@@ -162,7 +163,6 @@ export const PREDEFINED_PROFILES: PredefinedProfile[] = [
 			"terminal",
 			"setup",
 			"multimodel",
-			"gtd",
 			"browser-use",
 		],
 		anthropicPlugins: [
@@ -190,15 +190,13 @@ export const PREDEFINED_PROFILES: PredefinedProfile[] = [
 	{
 		id: "growth-marketer",
 		name: "Growth Marketer",
-		description:
-			"SEO, website audits, content production, marketing automation",
+		description: "Website audits, content production, marketing automation",
 		icon: "★",
 		magusPlugins: [
 			"dev",
 			"code-analysis",
 			"terminal",
 			"setup",
-			"seo@magus-marketing",
 			"browser-use",
 			"image-generate@magus-marketing",
 			"video-editing@magus-marketing",
@@ -228,14 +226,7 @@ export const PREDEFINED_PROFILES: PredefinedProfile[] = [
 		description:
 			"Planning, code review, coordination, and broad repo visibility",
 		icon: "★",
-		magusPlugins: [
-			"dev",
-			"code-analysis",
-			"terminal",
-			"setup",
-			"multimodel",
-			"gtd",
-		],
+		magusPlugins: ["dev", "code-analysis", "terminal", "setup", "multimodel"],
 		anthropicPlugins: [
 			"code-review",
 			"pr-review-toolkit",

package/src/data/settings-catalog.ts

@@ -66,6 +66,7 @@ export const SETTINGS_CATALOG: SettingDefinition[] = [
 			{ label: "Low", value: "low" },
 			{ label: "Medium", value: "medium" },
 			{ label: "High", value: "high" },
+			{ label: "Extra high", value: "xhigh" },
 		],
 		storage: { type: "setting", key: "effortLevel" },
 	},
@@ -135,14 +136,20 @@ export const SETTINGS_CATALOG: SettingDefinition[] = [
 	{
 		id: "model",
 		name: "Default Model",
-		description: "Override the default model for Claude Code",
+		// Aliases, never pinned ids. A pinned id in a shipped list goes stale the
+		// day Anthropic moves the alias, and goes stale SILENTLY — the setting
+		// keeps naming a model that is a release behind, and nothing reports it.
+		// The alias always names whatever that tier currently is.
+		description:
+			"Override the default model for Claude Code. Aliases track the current model for each tier",
 		category: "models",
 		type: "select",
 		options: [
 			{ label: "Default", value: "" },
-			{ label: "Sonnet", value: "claude-sonnet-4-6" },
-			{ label: "Opus", value: "claude-opus-4-6" },
-			{ label: "Haiku", value: "claude-haiku-4-5-20251001" },
+			{ label: "Opus", value: "opus" },
+			{ label: "Sonnet", value: "sonnet" },
+			{ label: "Haiku", value: "haiku" },
+			{ label: "Fable", value: "fable" },
 		],
 		storage: { type: "setting", key: "model" },
 	},