claudeup 6.3.0 → 6.4.0

package/src/services/models-manager.ts

@@ -0,0 +1,606 @@
+/**
+ * Per-subagent model routing — everything that touches disk.
+ *
+ * `models-core.ts` holds the pure rules (what a config means, what settings it
+ * implies, what the hook should print) and is imported by the hot hook path.
+ * This module is the other half: reading and writing `.claude/models.json`,
+ * recording routing in the committed manifest, and resolving an alias to the
+ * full model id THIS machine runs.
+ *
+ * ## Where a config lives, and why there are two places
+ *
+ * The routing is a PROFILE property, committed in `.claude/profiles.json` under
+ * `profiles.<name>.models`. `.claude/models.json` is the generated view of it —
+ * a symlink into `_profiles/<active>/models.json` when a profile is active, a
+ * plain file when the project has no profiles. The hook reads the generated
+ * file (it walks up from the session's cwd looking for exactly that name); a
+ * teammate gets the routing by pulling profiles.json and running `claudeup
+ * install`.
+ *
+ * Writing only the generated file would be silently temporary: `claudeup
+ * install` rewrites `_profiles/<name>/` from the manifest, so the routing would
+ * disappear on the next install with nothing to explain why.
+ *
+ * ## Why the full model id is resolved live
+ *
+ * `modelSettings` is keyed by model, and MEASURED (AMR-1 `effort-conflict`) a
+ * full-id key beats an alias key when both are present and disagree. So both
+ * forms are written with the same value — which requires knowing the full id,
+ * and that id changes whenever Anthropic ships a new model behind an alias. A
+ * table in this repo would be wrong within weeks and would be wrong SILENTLY.
+ * `resolveFullModelId` reads it out of this machine's own session transcripts
+ * instead, and returns null rather than guessing.
+ */
+
+import {
+	closeSync,
+	existsSync,
+	fstatSync,
+	openSync,
+	readFileSync,
+	readSync,
+	readdirSync,
+	statSync,
+} from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import fs from "fs-extra";
+import { findPreset, presetNames } from "../data/models-presets.js";
+import type { ProfileManifest } from "../types/index.js";
+import {
+	isAgentModelHookRegistered,
+	registerAgentModelHook,
+} from "./hook-registration.js";
+import { readManifest, updateProfileEntry } from "./manifest.js";
+import {
+	type ModelAlias,
+	type ModelsConfig,
+	type ModelsStatus,
+	type ValidationError,
+	buildSettingsPatch,
+	computeModelsStatus,
+	validateModelsConfig,
+} from "./models-core.js";
+import { materializeProfile } from "./profile-materializer.js";
+import { resolveAllProfiles, resolveProfile } from "./resolver.js";
+import { readSettingsFile, updateSettingsFile } from "./settings-file.js";
+import { activeProfile, syncProfileLink } from "./symlink-manager.js";
+
+/** `<projectPath>/.claude/models.json` — what the hook looks for. */
+export function configPath(projectPath: string): string {
+	return path.join(projectPath, ".claude", "models.json");
+}
+
+/** `<projectPath>/.claude/settings.json` — a symlink when a profile is active. */
+function settingsPathFor(projectPath: string): string {
+	return path.join(projectPath, ".claude", "settings.json");
+}
+
+export interface ReadModelsResult {
+	/** The config, or null when there is no usable one. */
+	config: ModelsConfig | null;
+	errors: ValidationError[];
+	path: string;
+}
+
+/**
+ * Read and validate the project's `models.json`.
+ *
+ * A missing file is `{config: null, errors: []}` — routing is off, which is not
+ * a problem. An unparseable or invalid one is `{config: null, errors: [...]}`,
+ * because it IS a problem: the config is committed, so a bad value is a bad
+ * value for the whole team.
+ */
+export async function readModelsConfig(
+	projectPath: string,
+): Promise<ReadModelsResult> {
+	const file = configPath(projectPath);
+	if (!(await fs.pathExists(file))) {
+		return { config: null, errors: [], path: file };
+	}
+
+	let raw: unknown;
+	try {
+		raw = JSON.parse(await fs.readFile(file, "utf8"));
+	} catch (error) {
+		return {
+			config: null,
+			errors: [{ path: "", message: `not valid JSON: ${String(error)}` }],
+			path: file,
+		};
+	}
+
+	const errors = validateModelsConfig(raw);
+	return {
+		config: errors.length === 0 ? (raw as ModelsConfig) : null,
+		errors,
+		path: file,
+	};
+}
+
+// ─── Live alias → full model id ───────────────────────────────────────────────
+
+/** Resolved ids, keyed by home+alias+scan. Only successes are cached. */
+const fullIdCache = new Map<string, string>();
+
+/**
+ * The scan reads transcripts BACKWARDS in bounded chunks, under a total byte budget.
+ *
+ * Reading whole files here was a memory bomb, not merely slow. Session transcripts are
+ * append-only and unbounded: on this machine `~/.claude/projects` is 4 GB and the largest
+ * single `.jsonl` is 597 MB, so `readFileSync(file, "utf8")` on the newest sixty allocated
+ * hundreds of megabytes of string to find a value that appears on every line. Measured, one
+ * `claudeup models use` spent 6.5 s in this function.
+ *
+ * A single fixed tail is not the fix on its own, and MEASURED why: with one 512 KB tail per
+ * file, `claude-opus-5` still resolved and `claude-sonnet-5` stopped resolving — an alias this
+ * machine had not used in the newest records simply was not in the last half megabyte of any
+ * of them. Falling back to the alias key alone is not free either: a user whose `/effort`
+ * already wrote a full-id entry would keep it, because a full id beats an alias (AMR-1
+ * `effort-conflict`).
+ *
+ * So: walk each file from the end in `CHUNK_BYTES` steps, stop that file at its first hit,
+ * and stop everything at `BUDGET_BYTES`. The common case — the alias appears in the newest
+ * records — costs one chunk. The rare case is bounded instead of unbounded, and only one
+ * chunk is resident at a time.
+ */
+const CHUNK_BYTES = 512 * 1024;
+
+/** Give up after reading this much in total, across every file in one call. */
+const BUDGET_BYTES = 64 * 1024 * 1024;
+
+/**
+ * Never spend more than this on ONE file.
+ *
+ * Without it a single huge transcript eats the whole budget and the scan never reaches the
+ * files that would have answered. MEASURED: the newest transcript here is 597 MB and contains
+ * only opus records, so a budget-only bound read 64 MB of it, found no sonnet, and stopped —
+ * `claude-sonnet-5` stayed unresolved for the same reason as before the fix. Breadth across
+ * files beats depth into one, because different files are where different aliases live.
+ */
+const PER_FILE_BYTES = 4 * 1024 * 1024;
+
+/** Stop once this many `"model"` values have been counted. */
+const ENOUGH_HITS = 200;
+
+/**
+ * How many transcripts to consider, newest first.
+ *
+ * This is a COUNT standing in for a time window, and the two come apart badly. MEASURED on
+ * this machine: 2995 transcripts, and the newest 60 spanned fifty minutes — because every
+ * live session appends to its own file, so concurrent work floods the top of the ranking.
+ * Under a 60-file window `claude-sonnet-5` could not resolve at all: its most recent
+ * appearance was rank 85. An hour of history is not a sample of what this machine runs.
+ *
+ * The real bound is `BUDGET_BYTES`, not this number. Pass 1 reads one chunk per file and
+ * stops at the budget, so raising the count widens the window without raising the worst
+ * case: a common alias still answers from the first file or two.
+ */
+const DEFAULT_SCAN = 400;
+
+/** Read `length` bytes at `position`, or null if the file cannot be read. */
+function readAt(file: string, position: number, length: number): string | null {
+	let fd: number | undefined;
+	try {
+		fd = openSync(file, "r");
+		const buf = Buffer.allocUnsafe(length);
+		readSync(fd, buf, 0, length, position);
+		return buf.toString("utf8");
+	} catch {
+		return null;
+	} finally {
+		if (fd !== undefined) {
+			try {
+				closeSync(fd);
+			} catch {
+				// Closing a handle we already lost is not a failure worth reporting.
+			}
+		}
+	}
+}
+
+/** A file's size, or null if it cannot be stat'ed. */
+function sizeOf(file: string): number | null {
+	try {
+		return statSync(file).size;
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * The full model id this machine currently runs for `alias`, or null.
+ *
+ * Read LIVE from the newest session transcripts under
+ * `<home>/.claude/projects/<session>/*.jsonl`, taking the most frequent spelling with
+ * no bracketed suffix. Never a hardcoded table: model ids change under an alias
+ * and a stale one is worse than none — `buildSettingsPatch` writes only the
+ * alias key when this returns null, which still works.
+ *
+ * The scan is bounded (newest `scan` files, default 60) because this is called
+ * from `models status`, `doctor` and every apply. Successes are memoized for
+ * the life of the process; failures are not, so a machine that gains its first
+ * transcript mid-run resolves on the next call.
+ *
+ * Adapted from `benches/agent-model-routing/stage-setups.ts`, which throws
+ * where this returns null — a bench wants to stop, a CLI wants to carry on.
+ */
+export function resolveFullModelId(
+	alias: ModelAlias,
+	opts: { home?: string; scan?: number } = {},
+): string | null {
+	const home = opts.home ?? os.homedir();
+	const scan = opts.scan ?? DEFAULT_SCAN;
+	const cacheKey = `${home}\0${alias}\0${scan}`;
+	const cached = fullIdCache.get(cacheKey);
+	if (cached) return cached;
+
+	const projects = path.join(home, ".claude", "projects");
+	if (!existsSync(projects)) return null;
+
+	const files: { file: string; mtime: number }[] = [];
+	let encoded: string[];
+	try {
+		encoded = readdirSync(projects);
+	} catch {
+		return null;
+	}
+	for (const enc of encoded) {
+		const dir = path.join(projects, enc);
+		let entries: string[];
+		try {
+			entries = readdirSync(dir);
+		} catch {
+			continue;
+		}
+		for (const name of entries) {
+			if (!name.endsWith(".jsonl")) continue;
+			const file = path.join(dir, name);
+			try {
+				files.push({ file, mtime: statSync(file).mtimeMs });
+			} catch {
+				// A transcript that vanished between listing and stat is not an error.
+			}
+		}
+	}
+	files.sort((a, b) => b.mtime - a.mtime);
+
+	const rx = new RegExp(`"model":"(claude-${alias}[^"]*)"`, "g");
+	const counts = new Map<string, number>();
+	const newest = files.slice(0, scan).map((f) => f.file);
+	let hits = 0;
+	let budget = BUDGET_BYTES;
+
+	/** Scan one file backwards, at most `perFile` bytes, stopping at its first hit. */
+	const sweep = (file: string, perFile: number): void => {
+		const size = sizeOf(file);
+		if (size === null) return;
+		const floor = Math.max(0, size - perFile);
+		for (let end = size; end > floor && budget > 0; end -= CHUNK_BYTES) {
+			const length = Math.min(CHUNK_BYTES, end - floor);
+			const text = readAt(file, end - length, length);
+			budget -= length;
+			if (text === null) return;
+
+			let found = false;
+			for (const m of text.matchAll(rx)) {
+				const id = m[1] as string;
+				counts.set(id, (counts.get(id) ?? 0) + 1);
+				hits += 1;
+				found = true;
+			}
+			if (found) return;
+		}
+	};
+
+	// Pass 1 — BREADTH. One chunk from the end of every file. This answers for any alias
+	// used recently, which is the overwhelmingly common case, and costs at most
+	// scan × CHUNK_BYTES.
+	for (const file of newest) {
+		if (hits >= ENOUGH_HITS || budget <= 0) break;
+		sweep(file, CHUNK_BYTES);
+	}
+
+	// Pass 2 — DEPTH, and only when breadth found nothing. An alias this machine has not
+	// used lately still appears further back; without this, `claude-sonnet-5` went
+	// unresolved here while `claude-opus-5` resolved, which is worse than it sounds: the
+	// full-id key is what stops a user's own `/effort` entry from outranking the project's
+	// (AMR-1 `effort-conflict`). Depth is capped per file so one 597 MB transcript cannot
+	// consume the budget that the next file needed.
+	if (hits === 0) {
+		for (const file of newest) {
+			if (hits > 0 || budget <= 0) break;
+			sweep(file, PER_FILE_BYTES);
+		}
+	}
+
+	// Prefer the plainest spelling: Claude Code records `claude-opus-5` in
+	// transcripts and `claude-opus-5[1m]` in usage envelopes, and a
+	// context-window suffix is a DIFFERENT modelSettings key.
+	let best: string | null = null;
+	let bestCount = 0;
+	for (const [id, count] of counts) {
+		if (id.includes("[")) continue;
+		if (count > bestCount) {
+			best = id;
+			bestCount = count;
+		}
+	}
+	if (best) fullIdCache.set(cacheKey, best);
+	return best;
+}
+
+/** The alias → full-id resolver handed to the pure core. */
+const liveResolver = (alias: ModelAlias): string | null =>
+	resolveFullModelId(alias);
+
+// ─── Apply ────────────────────────────────────────────────────────────────────
+
+export interface ApplyModelPresetArgs {
+	projectPath: string;
+	/** A built-in preset name, or a config object to write verbatim. */
+	preset: string | ModelsConfig;
+	/**
+	 * Create `.claude/profiles.json` when the project has none.
+	 *
+	 * Injected rather than imported: `cli/bootstrap.ts`'s `ensureManifest`
+	 * prompts, and services here never own the terminal (nothing under
+	 * `services/` imports from `cli/`). `cli/models.ts` passes it; a caller that
+	 * does not gets the manifest-free path — a plain `.claude/models.json` and
+	 * `recordedInManifest: false`.
+	 */
+	ensureManifest?: (projectPath: string) => Promise<ProfileManifest | null>;
+}
+
+export interface ApplyModelPresetResult {
+	/** The profile the routing was recorded in, or null when there is none. */
+	profile: string | null;
+	settingsPath: string;
+	recordedInManifest: boolean;
+	config: ModelsConfig;
+	/** Settings keys written, for the CLI to echo. */
+	wrote: Record<string, unknown>;
+	hook: "registered" | "already";
+}
+
+/**
+ * Apply a routing preset to a project.
+ *
+ * Validation comes first: an invalid config makes every subagent spawn fail, so
+ * it must never reach disk. After that the order of the numbered steps below is
+ * load-bearing — the manifest is written before materialization because
+ * materialization regenerates `_profiles/<n>/` FROM the manifest, and the hook
+ * is registered last because a hook pointing at a config that failed to write is
+ * worse than no hook at all.
+ */
+export async function applyModelPreset(
+	args: ApplyModelPresetArgs,
+): Promise<ApplyModelPresetResult> {
+	const { projectPath } = args;
+
+	const config =
+		typeof args.preset === "string"
+			? findPreset(args.preset)
+			: (args.preset as ModelsConfig | undefined);
+	if (!config) {
+		throw new Error(
+			`Unknown preset "${String(args.preset)}". Available: ${presetNames().join(", ")}`,
+		);
+	}
+
+	const errors = validateModelsConfig(config);
+	if (errors.length > 0) {
+		throw new Error(
+			`Refusing to write an invalid model config — a model the Agent tool rejects makes every subagent spawn fail:\n${errors
+				.map((e) => `  ${e.path || "(root)"}: ${e.message}`)
+				.join("\n")}`,
+		);
+	}
+
+	const patch = buildSettingsPatch(config, liveResolver);
+	const settingsPath = settingsPathFor(projectPath);
+
+	// 1. A manifest, if the project can have one.
+	let manifest = await readManifest(projectPath);
+	if (Object.keys(manifest.profiles).length === 0 && args.ensureManifest) {
+		manifest = (await args.ensureManifest(projectPath)) ?? manifest;
+	}
+	const profile = await activeProfile(projectPath);
+
+	// 2. Record BOTH halves in the manifest: the routing, and the settings it
+	// implies. Without the settings half the next `claudeup install` rewrites
+	// settings.json from the manifest and silently reverts the main thread's
+	// model — the routing would keep working and the orchestrator would not.
+	const recordedInManifest = await updateProfileEntry(
+		projectPath,
+		profile,
+		(entry) => {
+			entry.models = config;
+			entry.settings = { ...(entry.settings ?? {}), ...patch.set };
+		},
+	);
+
+	// 3. Regenerate the profile dir from the manifest, then point
+	// .claude/models.json at it. Only the models link is touched: repointing all
+	// four here would replace a project's real .mcp.json with a symlink as a side
+	// effect of choosing a model.
+	if (recordedInManifest && profile) {
+		// Re-read: `manifest` above predates the write, so resolving from it would
+		// materialize the OLD entry — which, having no `models`, would delete the
+		// file this call exists to create.
+		const written = await readManifest(projectPath);
+		await materializeProfile(
+			profile,
+			await resolveProfile(written, profile, { binResolver: noBins }),
+			projectPath,
+			await unionPluginIds(projectPath),
+		);
+		await syncProfileLink(profile, "models", projectPath);
+	} else {
+		// No profile: models.json is a plain committed-alongside file.
+		await fs.outputFile(
+			configPath(projectPath),
+			`${JSON.stringify(config, null, 2)}\n`,
+		);
+	}
+
+	// 4. The live settings file (a symlink into the profile when one is active,
+	// so this lands in the same place materialization just wrote).
+	await updateSettingsFile(settingsPath, (settings) => {
+		for (const [key, value] of Object.entries(patch.set)) {
+			settings[key] = value;
+		}
+	});
+
+	// 5. Without this, nothing routes.
+	const hook = await registerAgentModelHook();
+
+	return {
+		profile,
+		settingsPath,
+		recordedInManifest,
+		config,
+		wrote: patch.set,
+		hook,
+	};
+}
+
+/**
+ * Turn routing off: drop it from the profile, delete the generated config, and
+ * unwind the settings keys it claimed.
+ */
+export async function clearModels(projectPath: string): Promise<void> {
+	// Read the config BEFORE deleting it — its patch names exactly which
+	// modelSettings keys were ours.
+	const { config } = await readModelsConfig(projectPath);
+	const claimed = config
+		? Object.keys(
+				(buildSettingsPatch(config, liveResolver).set.modelSettings ??
+					{}) as Record<string, unknown>,
+			)
+		: [];
+
+	const profile = await activeProfile(projectPath);
+	const removed = await updateProfileEntry(projectPath, profile, (entry) => {
+		// biome-ignore lint/performance/noDelete: absence is the state, not undefined
+		delete entry.models;
+		if (entry.settings) {
+			// biome-ignore lint/performance/noDelete: same
+			delete entry.settings.model;
+			// biome-ignore lint/performance/noDelete: same
+			delete entry.settings.effortLevel;
+			unclaimModelSettings(entry.settings, claimed);
+		}
+	});
+
+	if (removed && profile) {
+		// Re-materializing with no `models` in the closure DELETES
+		// _profiles/<n>/models.json, and the relink then removes the now-dangling
+		// .claude/models.json. That is the whole mechanism by which `off` is off.
+		const manifest = await readManifest(projectPath);
+		await materializeProfile(
+			profile,
+			await resolveProfile(manifest, profile, { binResolver: noBins }),
+			projectPath,
+			await unionPluginIds(projectPath),
+		);
+		await syncProfileLink(profile, "models", projectPath);
+	}
+	await fs.remove(configPath(projectPath));
+
+	const settingsPath = settingsPathFor(projectPath);
+	if (await fs.pathExists(settingsPath)) {
+		await updateSettingsFile(settingsPath, (settings) => {
+			// biome-ignore lint/performance/noDelete: Claude Code reads presence
+			delete settings.model;
+			// biome-ignore lint/performance/noDelete: same
+			delete settings.effortLevel;
+			unclaimModelSettings(settings, claimed);
+		});
+	}
+}
+
+/**
+ * Remove only the `modelSettings` keys this config claimed.
+ *
+ * NEVER the whole object: `/effort` writes a user's own per-model entries into
+ * the same place, and deleting the object would take their settings with ours.
+ * An object left empty is removed, so `off` leaves no husk.
+ */
+function unclaimModelSettings(
+	settings: Record<string, unknown>,
+	claimed: readonly string[],
+): void {
+	const modelSettings = settings.modelSettings;
+	if (typeof modelSettings !== "object" || modelSettings === null) return;
+	const rec = modelSettings as Record<string, unknown>;
+	for (const key of claimed) {
+		delete rec[key];
+	}
+	if (Object.keys(rec).length === 0) {
+		// biome-ignore lint/performance/noDelete: same
+		delete settings.modelSettings;
+	}
+}
+
+/**
+ * Materialization needs no binary requirements — it writes settings, mcp,
+ * models and skills, and reads none of `closure.bins`. Skipping the resolver's
+ * per-plugin `plugin.json` reads keeps `models use` off the marketplace cache
+ * entirely.
+ */
+const noBins = async () => [];
+
+/**
+ * The manifest-wide union of plugin ids, which `materializeProfile` needs to
+ * keep writing the explicit `false` entries that make `profile switch`
+ * exclusive. Re-materializing without it would silently make switching additive
+ * again — a routing change must not have that side effect.
+ */
+async function unionPluginIds(projectPath: string): Promise<string[]> {
+	const manifest = await readManifest(projectPath);
+	const union = await resolveAllProfiles(manifest, { binResolver: noBins });
+	return Object.keys(union.plugins);
+}
+
+// ─── Status ───────────────────────────────────────────────────────────────────
+
+/** What `claudeup models status` and `claudeup doctor` report. */
+export async function readModelsStatus(
+	projectPath: string,
+): Promise<ModelsStatus> {
+	const { config, errors } = await readModelsConfig(projectPath);
+	const settings = await readSettingsFileSafely(settingsPathFor(projectPath));
+	return computeModelsStatus({
+		config,
+		errors,
+		hookRegistered: await isAgentModelHookRegistered(),
+		settings,
+		resolveFullId: liveResolver,
+		subagentModelEnv: process.env.CLAUDE_CODE_SUBAGENT_MODEL ?? null,
+	});
+}
+
+/**
+ * Settings for a read-only comparison. A file we cannot parse reads as `{}`
+ * here — every key then shows as drift, which is the truth: nothing we asked
+ * for is in effect. `updateSettingsFile` still refuses to WRITE it.
+ */
+async function readSettingsFileSafely(
+	settingsPath: string,
+): Promise<Record<string, unknown>> {
+	try {
+		return await readSettingsFile(settingsPath);
+	} catch {
+		return {};
+	}
+}
+
+/** Re-apply the config already on disk. Used by `doctor --fix` to clear drift. */
+export async function reapplyModels(
+	projectPath: string,
+): Promise<ApplyModelPresetResult | null> {
+	const { config } = await readModelsConfig(projectPath);
+	if (!config) return null;
+	return applyModelPreset({ projectPath, preset: config });
+}

package/src/services/profile-materializer.ts

@@ -4,6 +4,9 @@
  * Writes the shared config the symlink manager later points at:
  *   _profiles/<name>/settings.json  — enabledPlugins + the profile's settings
  *   _profiles/<name>/mcp.json       — the profile's MCP servers
+ *   _profiles/<name>/models.json    — per-subagent model routing, when the
+ *                                     profile declares any; REMOVED when it
+ *                                     does not
  *   _profiles/<name>/skills/        — created empty; skills install into it
  *                                     (through the activated symlink)
  *
@@ -109,6 +112,20 @@ export async function materializeProfile(
 	await fs.writeJson(path.join(dir, "mcp.json"), buildProfileMcp(closure), {
 		spaces: 2,
 	});
+
+	// models.json is the one artifact that is REMOVED when the closure lacks it.
+	// Every other file here is unconditional, so "overwrite" is enough; routing
+	// is optional, and a profile that dropped it would otherwise keep routing
+	// from a file nothing writes any more — `claudeup models off` could not turn
+	// routing off, because the hook walks up to the nearest models.json and this
+	// one would still be there (and still linked).
+	const modelsPath = path.join(dir, "models.json");
+	if (closure.models) {
+		await fs.writeJson(modelsPath, closure.models, { spaces: 2 });
+	} else {
+		await fs.remove(modelsPath);
+	}
+
 	const skillsDir = path.join(dir, "skills");
 	await seedSkillsFromProject(skillsDir, projectPath);
 	await fs.ensureDir(skillsDir);

package/src/services/resolver.ts

@@ -69,6 +69,13 @@ export function resolveExtends(
 		// Entry values win over inherited ones.
 		plugins: { ...inheritedPlugins, ...(entry.plugins ?? {}) },
 		settings: { ...base.settings, ...(entry.settings ?? {}) },
+		// `models` inherits by whole object, not key-by-key: a ModelsConfig is
+		// validated as a complete unit (every grade present, one effort per
+		// model), so a half-inherited merge could produce a config neither side
+		// wrote and neither side validated.
+		...((entry.models ?? base.models)
+			? { models: entry.models ?? base.models }
+			: {}),
 	};
 }
 
@@ -198,6 +205,7 @@ export async function resolveProfile(
 		bins,
 		skills: [...(entry.skills ?? [])],
 		settings: { ...(entry.settings ?? {}) },
+		...(entry.models ? { models: entry.models } : {}),
 		env: {
 			required: [...(entry.env?.required ?? [])],
 			optional: [...(entry.env?.optional ?? [])],
@@ -294,6 +302,9 @@ function mergeClosures(
 		bins: [...binByName.values()],
 		skills: [...skillMap.values()],
 		settings: { ...b.settings, ...a.settings },
+		// Same precedence as settings: `a` wins. Whole-object, for the reason
+		// given in resolveExtends — half a routing config is not a routing config.
+		...((a.models ?? b.models) ? { models: a.models ?? b.models } : {}),
 		env: {
 			required: [...new Set([...a.env.required, ...b.env.required])],
 			optional: [...new Set([...a.env.optional, ...b.env.optional])],