@gajae-code/coding-agent 0.11.6 → 0.11.8

package/src/cli.ts

@@ -8,6 +8,12 @@ import "@gajae-code/utils/postmortem";
 import { Args, type CliConfig, Command, type CommandEntry, Flags, run } from "@gajae-code/utils/cli";
 import { APP_NAME, formatBunRuntimeError, MIN_BUN_VERSION, VERSION } from "@gajae-code/utils/dirs";
 import { runFixtureReport } from "./cli/fixture-report";
+import { admitManagedOwnerBeforeCli, completeManagedOwnerRecovery } from "./gjc-runtime/managed-owner-admission";
+import {
+	isManagedOwnerSupervisorArgv,
+	MANAGED_OWNER_CHILD_TOKEN_ENV,
+	runManagedOwnerSupervisor,
+} from "./gjc-runtime/managed-owner-supervisor";
 import { isTmuxOwnerIsolationCliArgv, runTmuxOwnerIsolationCliFromStdin } from "./gjc-runtime/tmux-owner-isolation-cli";
 import { smokeTestTabWorker } from "./tools/browser/tab-worker-smoke";
 
@@ -287,9 +293,34 @@ export function normalizeResumeAlias(argv: readonly string[]): string[] {
 	return argv.length === 1 && argv[0] === "resume" ? ["--resume"] : [...argv];
 }
 
+function routeLegacyRootArgv(argv: readonly string[]): string[] | undefined {
+	if (argv[0] === "coordinator-mcp") return ["mcp-serve", "coordinator", ...argv.slice(1)];
+	if (argv[0] !== "--team") return undefined;
+	const sizeValues: string[] = [];
+	const remaining: string[] = [];
+	for (let index = 1; index < argv.length; index++) {
+		const arg = argv[index] ?? "";
+		if (arg === "--team-size") {
+			sizeValues.push(argv[index + 1] ?? "");
+			index++;
+		} else if (arg.startsWith("--team-size=")) {
+			sizeValues.push(arg.slice("--team-size=".length));
+		} else {
+			remaining.push(arg);
+		}
+	}
+	const size = sizeValues[0];
+	if (sizeValues.length !== 1 || !size || !/^[1-9]\d*$/.test(size)) {
+		return ["team", "0", "invalid legacy --team-size"];
+	}
+	return ["team", size, ...remaining];
+}
+
 /** Apply the same default-launch routing used by runCli after root fast paths. */
 export function routeRootArgv(argv: readonly string[]): string[] {
 	const normalizedArgv = normalizeResumeAlias(argv);
+	const legacyArgv = routeLegacyRootArgv(normalizedArgv);
+	if (legacyArgv) return legacyArgv;
 	const first = normalizedArgv[0];
 	return first === "--help" || first === "-h" || first === "--version" || first === "-v" || first === "help"
 		? normalizedArgv
@@ -325,6 +356,18 @@ export async function runCli(argv: string[]): Promise<void> {
 		await runTmuxOwnerIsolationCliFromStdin();
 		return;
 	}
+	if (isManagedOwnerSupervisorArgv(argv)) {
+		await runManagedOwnerSupervisor();
+		return;
+	}
+	if (process.env[MANAGED_OWNER_CHILD_TOKEN_ENV] !== undefined) {
+		const admission = await admitManagedOwnerBeforeCli();
+		if (admission.kind === "blocked") return;
+		if (admission.kind === "recovery") {
+			await completeManagedOwnerRecovery(admission.context);
+			return;
+		}
+	}
 	if (isNotifyDaemonInternalFastPath(argv)) {
 		await runNotifyDaemonInternalFastPath(argv);
 		return;
@@ -348,11 +391,9 @@ export async function runCli(argv: string[]): Promise<void> {
 		process.exitCode = await runFixtureReport(id);
 		return;
 	}
-	if (isStatsHelpFastPath(argv)) {
-		showStatsFastHelp();
-		return;
-	}
-	if (hasRootHelpFlag(argv)) {
+	const normalizedArgv = normalizeResumeAlias(argv);
+	const legacyArgv = routeLegacyRootArgv(normalizedArgv);
+	if (!legacyArgv && hasRootHelpFlag(normalizedArgv)) {
 		const { renderRootHelp } = await import("@gajae-code/utils/cli");
 		const { getExtraHelpText } = await import("./cli/fast-help");
 		renderRootHelp({ bin: APP_NAME, version: VERSION, commands: new Map([["launch", RootHelpCommand]]) });
@@ -362,14 +403,16 @@ export async function runCli(argv: string[]): Promise<void> {
 		}
 		return;
 	}
-	if (hasRootVersionFlag(argv)) {
+	if (!legacyArgv && hasRootVersionFlag(normalizedArgv)) {
 		process.stdout.write(`${APP_NAME}/${VERSION}\n`);
 		return;
 	}
+	const runArgv = legacyArgv ?? routeRootArgv(normalizedArgv);
+	if (isStatsHelpFastPath(runArgv)) {
+		showStatsFastHelp();
+		return;
+	}
 	await installRuntimeGlobals();
-	// --help and --version are handled by run() directly, don't rewrite those.
-	// Everything else that isn't a known subcommand routes to "launch".
-	const runArgv = routeRootArgv(argv);
 	return run({ bin: APP_NAME, version: VERSION, argv: runArgv, commands, help: showHelp });
 }
 

package/src/commands/daemon.ts

@@ -1,7 +1,7 @@
 /**
  * Manage GJC background daemons (status/list/stop/reload).
  */
-import { Args, Command, Flags } from "@gajae-code/utils/cli";
+import { Args, CliParseError, Command, Flags } from "@gajae-code/utils/cli";
 import {
 	type DaemonCommandAction,
 	type DaemonCommandArgs,
@@ -15,6 +15,18 @@ import { runSdkSessionCli } from "../sdk/cli";
 
 const ACTIONS = [...DAEMON_ACTION_TOKENS, "discord-internal", "slack-internal", "session"] as const;
 
+function parsePositiveTimeout(raw: string | undefined, flagName: string): number | undefined {
+	if (raw === undefined) return undefined;
+	if (!/^[0-9]+$/.test(raw)) {
+		throw new CliParseError(`Expected ${flagName} to be a positive safe integer, got "${raw}"`);
+	}
+	const value = Number(raw);
+	if (!Number.isSafeInteger(value) || value <= 0) {
+		throw new CliParseError(`Expected ${flagName} to be a positive safe integer, got "${raw}"`);
+	}
+	return value;
+}
+
 export default class Daemon extends Command {
 	static description =
 		"Manage GJC background daemons and SDK sessions. Routine use: `gjc daemon status` to check, `gjc daemon restart` to reload (spawns one if none is running). `stop`/`list` and the escalation flags below are advanced primitives.";
@@ -41,8 +53,8 @@ export default class Daemon extends Command {
 		all: Flags.boolean({ description: "Target all registered daemon kinds" }),
 		json: Flags.boolean({ description: "Emit JSON output" }),
 		force: Flags.boolean({ description: "Allow hard-kill escalation when graceful stop times out" }),
-		"graceful-timeout-ms": Flags.integer({ description: "Cooperative stop timeout before escalation" }),
-		"kill-timeout-ms": Flags.integer({ description: "Wait for old pid death after SIGKILL" }),
+		"graceful-timeout-ms": Flags.string({ description: "Cooperative stop timeout before escalation" }),
+		"kill-timeout-ms": Flags.string({ description: "Wait for old pid death after SIGKILL" }),
 		"spawn-if-stopped": Flags.boolean({ description: "On reload, spawn even when no daemon is running" }),
 		smoke: Flags.boolean({ description: "Internal: run worker smoke without configuration or network" }),
 		"owner-id": Flags.string({ description: "Internal: daemon owner id" }),
@@ -64,6 +76,11 @@ export default class Daemon extends Command {
 		const rawAction = args.action ?? "status";
 		const positional = Array.isArray(args.kind) ? args.kind : args.kind ? [args.kind] : [];
 		const flagRec = flags as Record<string, unknown>;
+		const gracefulTimeoutMs = parsePositiveTimeout(
+			flagRec["graceful-timeout-ms"] as string | undefined,
+			"--graceful-timeout-ms",
+		);
+		const killTimeoutMs = parsePositiveTimeout(flagRec["kill-timeout-ms"] as string | undefined, "--kill-timeout-ms");
 		if (rawAction === "session") {
 			await runSdkSessionCli({
 				action: positional[0],
@@ -91,8 +108,8 @@ export default class Daemon extends Command {
 			json: Boolean(flags.json),
 			force: Boolean(flags.force),
 			verbose: Boolean(flags.verbose),
-			gracefulTimeoutMs: flagRec["graceful-timeout-ms"] as number | undefined,
-			killTimeoutMs: flagRec["kill-timeout-ms"] as number | undefined,
+			gracefulTimeoutMs,
+			killTimeoutMs,
 			spawnIfStopped: flagRec["spawn-if-stopped"] as boolean | undefined,
 			smoke: Boolean(flags.smoke),
 			ownerId: flagRec["owner-id"] as string | undefined,

package/src/commands/sdk.ts

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { Args, Command, Flags } from "@gajae-code/utils/cli";
+import { Args, CliParseError, Command, Flags, renderCommandHelp } from "@gajae-code/utils/cli";
 import type { Args as ParsedArgs } from "../cli/args";
 import { Settings } from "../config/settings";
 import { applyStartupModelProfiles, createSessionManager } from "../main";
@@ -25,6 +25,7 @@ import {
 	type SdkStartupRollbackResult,
 	SdkStartupRollbackTracker,
 } from "../sdk/startup-capability";
+import { runSdkServe } from "../sdk/transport/serve-cli";
 import {
 	type CapturedSessionTranscriptSnapshot,
 	type ResumeSessionIdentity,
@@ -294,14 +295,14 @@ export async function runSessionHost(
 		rollback.recordAbsent();
 		const failure = normalizeSdkStartupFailure("registration", "failed", error);
 		await writeFailure(failure, rollback.result);
-		throw new Error(failure.message);
+		throw failure;
 	}
 	const { parsed } = opened;
 	if ("failure" in created) {
 		created.rollback.recordAbsent();
 		await writeFailure(created.failure, created.rollback.result);
 
-		throw new Error(created.failure.message);
+		throw created.failure;
 	}
 	const { session, capability, rollback } = created;
 	let sessionDisposal: Promise<void> | undefined;
@@ -423,19 +424,51 @@ export async function runSessionHost(
 	await new Promise<void>(() => {});
 }
 
+export type SdkInternalArgv = { action: "broker-internal"; agentDir: string } | { action: "session-host-internal" };
+
+/** Parses the exact private argv contracts used by SDK child-process spawns. */
+export function parseSdkInternalArgv(argv: readonly string[]): SdkInternalArgv {
+	if (argv[0] === "session-host-internal" && argv.length === 1) return { action: "session-host-internal" };
+	if (argv[0] === "broker-internal" && argv.length === 3 && argv[1] === "--agent-dir" && argv[2])
+		return { action: "broker-internal", agentDir: argv[2] };
+	throw new CliParseError("Invalid internal SDK invocation.");
+}
+
+class SdkServeHelp extends Command {
+	static description = "gjc sdk serve --stdio | --socket <path> [--session <id>] [--pending-ceiling <bytes>]";
+	static flags = {
+		stdio: Flags.boolean({ description: "Serve SDK frames over standard input and output" }),
+		socket: Flags.string({ description: "Serve SDK frames over a Unix socket path" }),
+		session: Flags.string({ description: "Attach to a specific SDK session" }),
+		"pending-ceiling": Flags.string({ description: "Maximum queued relay bytes per direction" }),
+	};
+	async run(): Promise<void> {}
+}
+
 export default class Sdk extends Command {
-	static description = "SDK internal services";
-	static hidden = true;
-	static args = { action: Args.string({ required: true, options: ["broker-internal", "session-host-internal"] }) };
-	static flags = { "agent-dir": Flags.string({ description: "Internal broker agent directory" }) };
+	static description = "gjc sdk serve --stdio | --socket <path> [--session <id>] [--pending-ceiling <bytes>]";
+	static hidden = false;
+	static delegateHelp = true;
+	static args = { action: Args.string({ required: false, options: ["serve"] }) };
+	static flags = SdkServeHelp.flags;
 	async run(): Promise<void> {
-		const { args, flags } = await this.parse(Sdk);
-		if (args.action === "session-host-internal") {
+		const action = this.argv[0];
+		if (this.argv.includes("--help") || this.argv.includes("-h")) {
+			renderCommandHelp("gjc", action === "serve" ? "sdk serve" : "sdk", action === "serve" ? SdkServeHelp : Sdk);
+			return;
+		}
+		if (action === "serve") {
+			await runSdkServe(this.argv.slice(1));
+			return;
+		}
+		if (action !== "broker-internal" && action !== "session-host-internal")
+			throw new CliParseError("Expected action to be serve.");
+		const internal = parseSdkInternalArgv(this.argv);
+		if (internal.action === "session-host-internal") {
 			await runSessionHost();
 			return;
 		}
-		const agentDir = flags["agent-dir"] as string | undefined;
-		if (!agentDir) throw new Error("--agent-dir is required for sdk broker-internal.");
+		const agentDir = internal.agentDir;
 		const broker = new Broker({
 			agentDir,
 			resolveDirectoryMigration: async cwd => {

package/src/config/keybindings.ts

@@ -5,6 +5,7 @@ import {
 	type KeybindingDefinitions,
 	type KeybindingsConfig,
 	type KeyId,
+	parseKeyId,
 	setKeybindings,
 	TUI_KEYBINDINGS,
 	KeybindingsManager as TuiKeybindingsManager,
@@ -172,7 +173,7 @@ export const KEYBINDINGS = {
 	},
 	"app.session.fork": {
 		defaultKeys: [],
-		description: "Fork session",
+		description: "Branch from message",
 	},
 	"app.session.resume": {
 		defaultKeys: [],
@@ -352,10 +353,29 @@ function toKeybindingsConfig(value: unknown): KeybindingsConfig {
 			logger.info("Ignoring unknown keybinding entry", { key });
 			continue;
 		}
-		if (val === undefined) config[key] = undefined;
-		else if (typeof val === "string") config[key] = val as KeyId;
-		else if (Array.isArray(val) && val.every(v => typeof v === "string")) config[key] = val as KeyId[];
-		else logger.info("Ignoring malformed keybinding entry", { key });
+		if (val === undefined) {
+			config[key] = undefined;
+			continue;
+		}
+
+		const keys = typeof val === "string" ? [val] : Array.isArray(val) ? val : undefined;
+		if (!keys?.every(keyValue => typeof keyValue === "string")) {
+			logger.info("Ignoring malformed keybinding entry", { key });
+			continue;
+		}
+
+		const normalizedKeys: KeyId[] = [];
+		for (const keyValue of keys) {
+			const parsedKey = parseKeyId(keyValue);
+			if (!parsedKey) {
+				logger.info("Ignoring invalid keybinding entry", { key, category: "invalid-keybinding" });
+				normalizedKeys.length = 0;
+				break;
+			}
+			normalizedKeys.push(parsedKey.keyId);
+		}
+		if (normalizedKeys.length !== keys.length) continue;
+		config[key] = typeof val === "string" ? normalizedKeys[0] : normalizedKeys;
 	}
 	return config;
 }
@@ -461,11 +481,18 @@ function migrateKeybindingsConfigFile(agentDir: string): void {
  */
 export class KeybindingsManager extends TuiKeybindingsManager {
 	#configPath: string | undefined;
+	#displayContext: KeyDisplayContext = runtimeKeyDisplayContext;
 
 	constructor(userBindings: KeybindingsConfig = {}, configPath?: string) {
-		super(KEYBINDINGS, userBindings);
+		super(KEYBINDINGS, toKeybindingsConfig(userBindings));
 		this.#configPath = configPath;
 	}
+	/**
+	 * Replace user bindings only after canonical grammar validation.
+	 */
+	override setUserBindings(userBindings: KeybindingsConfig): void {
+		super.setUserBindings(toKeybindingsConfig(userBindings));
+	}
 
 	/**
 	 * Create from config file at agentDir/keybindings.json.
@@ -485,6 +512,13 @@ export class KeybindingsManager extends TuiKeybindingsManager {
 	static inMemory(userBindings: KeybindingsConfig = {}): KeybindingsManager {
 		return new KeybindingsManager(userBindings);
 	}
+	/**
+	 * Set the default display context used by composed surfaces that do not
+	 * supply an explicit context.
+	 */
+	setDisplayContext(context: KeyDisplayContext): void {
+		this.#displayContext = context;
+	}
 
 	/**
 	 * Reload keybindings from the config file.
@@ -504,9 +538,29 @@ export class KeybindingsManager extends TuiKeybindingsManager {
 	/**
 	 * Get display string for a keybinding (e.g., "ctrl+c/escape").
 	 */
-	getDisplayString(keybinding: Keybinding): string {
+	getDisplayString(keybinding: Keybinding, context: KeyDisplayContext = this.#displayContext): string {
+		const keys = this.getKeys(keybinding);
+		return formatKeyHints(keys, context);
+	}
+	/**
+	 * Get an accessibility-oriented display string for help surfaces.
+	 * Darwin chords include both the concise glyphs and expanded key names.
+	 */
+	getAccessibleDisplayString(keybinding: Keybinding, context: KeyDisplayContext = this.#displayContext): string {
 		const keys = this.getKeys(keybinding);
-		return formatKeyHints(keys.length === 0 ? [] : keys);
+		return formatAccessibleKeyHints(keys, context);
+	}
+	/**
+	 * Format a fixed key chord using this manager's display context.
+	 */
+	formatKeyHint(key: string): string {
+		return formatKeyHint(key, this.#displayContext);
+	}
+	/**
+	 * Format a fixed key chord for accessibility-oriented help surfaces.
+	 */
+	formatAccessibleKeyHint(key: string): string {
+		return formatAccessibleKeyHint(key, this.#displayContext);
 	}
 
 	/**
@@ -520,13 +574,20 @@ export class KeybindingsManager extends TuiKeybindingsManager {
 /**
  * Key hint formatting utilities for UI labels.
  */
-const MODIFIER_LABELS: Record<string, string> = {
+export interface KeyDisplayContext {
+	platform: NodeJS.Platform;
+}
+
+const runtimeKeyDisplayContext: KeyDisplayContext = { platform: process.platform };
+
+const TEXTUAL_MODIFIER_LABELS: Record<string, string> = {
 	ctrl: "Ctrl",
-	shift: "Shift",
 	alt: "Alt",
+	shift: "Shift",
+	super: "Super",
 };
 
-const KEY_LABELS: Record<string, string> = {
+const TEXTUAL_KEY_LABELS: Record<string, string> = {
 	esc: "Esc",
 	escape: "Esc",
 	enter: "Enter",
@@ -535,33 +596,105 @@ const KEY_LABELS: Record<string, string> = {
 	tab: "Tab",
 	backspace: "Backspace",
 	delete: "Delete",
+	insert: "Insert",
+	clear: "Clear",
 	home: "Home",
 	end: "End",
-	pageup: "PgUp",
-	pagedown: "PgDn",
+	pageUp: "PgUp",
+	pageDown: "PgDn",
 	up: "Up",
 	down: "Down",
 	left: "Left",
 	right: "Right",
 };
 
-function formatKeyPart(part: string): string {
-	const lower = part.toLowerCase();
-	const modifier = MODIFIER_LABELS[lower];
-	if (modifier) return modifier;
-	const label = KEY_LABELS[lower];
+const DARWIN_MODIFIER_LABELS: Record<string, string> = {
+	ctrl: "⌃",
+	alt: "⌥",
+	shift: "⇧",
+	super: "⌘",
+};
+
+const DARWIN_KEY_LABELS: Record<string, string> = {
+	...TEXTUAL_KEY_LABELS,
+	esc: "⎋",
+	escape: "⎋",
+	enter: "↩",
+	return: "↩",
+	tab: "⇥",
+	backspace: "⌫",
+	delete: "⌦",
+	up: "↑",
+	down: "↓",
+	left: "←",
+	right: "→",
+};
+const DARWIN_ACCESSIBLE_MODIFIER_LABELS: Record<string, string> = {
+	ctrl: "Control",
+	alt: "Option",
+	shift: "Shift",
+	super: "Command",
+};
+
+const DARWIN_ACCESSIBLE_KEY_LABELS: Record<string, string> = {
+	...TEXTUAL_KEY_LABELS,
+	esc: "Escape",
+	escape: "Escape",
+	pageUp: "Page Up",
+	pageDown: "Page Down",
+};
+
+const DISPLAY_MODIFIER_ORDER = ["ctrl", "alt", "shift", "super"] as const;
+const INVALID_KEYBINDING_DISPLAY = "Invalid keybinding";
+
+function formatBaseKey(baseKey: string, labels: Record<string, string>): string {
+	const label = labels[baseKey];
 	if (label) return label;
-	if (part.length === 1) return part.toUpperCase();
-	return `${part.charAt(0).toUpperCase()}${part.slice(1)}`;
+	if (baseKey.length === 1) return baseKey.toUpperCase();
+	return `${baseKey.charAt(0).toUpperCase()}${baseKey.slice(1)}`;
+}
+
+export function formatKeyHint(key: string, context: KeyDisplayContext = runtimeKeyDisplayContext): string {
+	const parsed = parseKeyId(key);
+	if (!parsed) return INVALID_KEYBINDING_DISPLAY;
+
+	const darwin = context.platform === "darwin";
+	const modifierLabels = darwin ? DARWIN_MODIFIER_LABELS : TEXTUAL_MODIFIER_LABELS;
+	const baseLabels = darwin ? DARWIN_KEY_LABELS : TEXTUAL_KEY_LABELS;
+	const modifiers = DISPLAY_MODIFIER_ORDER.filter(modifier => parsed.modifiers.includes(modifier)).map(
+		modifier => modifierLabels[modifier],
+	);
+	const parts = [...modifiers, formatBaseKey(parsed.baseKey, baseLabels)];
+	return parts.join(darwin ? "" : "+");
+}
+
+export function formatAccessibleKeyHint(key: string, context: KeyDisplayContext = runtimeKeyDisplayContext): string {
+	const concise = formatKeyHint(key, context);
+	if (context.platform !== "darwin" || concise === INVALID_KEYBINDING_DISPLAY) return concise;
+
+	const parsed = parseKeyId(key);
+	if (!parsed) return INVALID_KEYBINDING_DISPLAY;
+	const modifiers = DISPLAY_MODIFIER_ORDER.filter(modifier => parsed.modifiers.includes(modifier)).map(
+		modifier => DARWIN_ACCESSIBLE_MODIFIER_LABELS[modifier],
+	);
+	const expanded = [...modifiers, formatBaseKey(parsed.baseKey, DARWIN_ACCESSIBLE_KEY_LABELS)].join("+");
+	return concise === expanded ? concise : `${concise} (${expanded})`;
 }
 
-export function formatKeyHint(key: KeyId): string {
-	return key.split("+").map(formatKeyPart).join("+");
+export function formatKeyHints(
+	keys: string | readonly string[],
+	context: KeyDisplayContext = runtimeKeyDisplayContext,
+): string {
+	const list: readonly string[] = typeof keys === "string" ? [keys] : keys;
+	return list.map(key => formatKeyHint(key, context)).join("/");
 }
 
-export function formatKeyHints(keys: KeyId | KeyId[]): string {
-	const list = Array.isArray(keys) ? keys : [keys];
-	return list.map(formatKeyHint).join("/");
+export function formatAccessibleKeyHints(
+	keys: string | readonly string[],
+	context: KeyDisplayContext = runtimeKeyDisplayContext,
+): string {
+	const list: readonly string[] = typeof keys === "string" ? [keys] : keys;
+	return list.map(key => formatAccessibleKeyHint(key, context)).join("/");
 }
 
 export type { Keybinding, KeybindingsConfig, KeyId };

package/src/config/model-profile-activation.ts

@@ -2,12 +2,15 @@ import { ThinkingLevel } from "@gajae-code/agent-core";
 import type { Api, Model } from "@gajae-code/ai";
 import type { AgentSession } from "../session/agent-session";
 import { formatClampedModelSelector } from "../thinking";
+import { validateModelProfileName } from "./model-profile-contract";
 import {
 	aggregateModelProfileRequiredProviders,
-	formatAvailableProfileNames,
 	formatModelProfileDisplayLabel,
 	resolveProfileBindings,
 } from "./model-profiles";
+
+export { resolveModelProfileName } from "./model-profile-contract";
+
 import {
 	GJC_MODEL_ASSIGNMENT_TARGETS,
 	type GjcModelAssignmentTargetId,
@@ -24,8 +27,6 @@ import {
 import { type ModelSelectorValue, normalizeModelSelectorValue } from "./model-selector-value";
 import type { Settings } from "./settings";
 
-const LEGACY_MODEL_PROFILE_ALIASES: ReadonlyMap<string, string> = new Map([["codex-standard", "codex-medium"]]);
-
 type ModelProfileActivationSession = Pick<
 	AgentSession,
 	"model" | "thinkingLevel" | "sessionId" | "getConfiguredModelChain" | "setConfiguredModelChain"
@@ -50,7 +51,7 @@ export interface PrepareModelProfileActivationOptions {
 		| "resolveCanonicalModel"
 		| "getCanonicalVariants"
 		| "getCanonicalId"
-	>;
+	> & { getError?: ModelRegistry["getError"] };
 	settings: Pick<Settings, "get">;
 	profileName: string;
 }
@@ -236,14 +237,6 @@ export function formatModelProfileCredentialError(profileLabel: string, provider
 	return `Model profile "${profileLabel}" requires credentials for: ${providers.join(", ")}. Run /login and configure the missing provider(s), then retry.`;
 }
 
-export function resolveModelProfileName(profileName: string, profiles: ReadonlyMap<string, unknown>): string {
-	// A retired-name alias is fallback-only: never shadow a profile that actually
-	// exists under the requested name (e.g. a user-defined `codex-standard`).
-	if (profiles.has(profileName)) return profileName;
-	const replacement = LEGACY_MODEL_PROFILE_ALIASES.get(profileName);
-	return replacement && profiles.has(replacement) ? replacement : profileName;
-}
-
 /**
  * Rewrite a selector only within the selector provider's own alternative group.
  * Strict providers are never rewritten, and authenticated alternative providers
@@ -348,12 +341,8 @@ export async function prepareModelProfileActivation(
 	options: PrepareModelProfileActivationOptions,
 ): Promise<PreparedModelProfileActivation> {
 	const profiles = options.modelRegistry.getModelProfiles();
-	const profileName = resolveModelProfileName(options.profileName, profiles);
-	const profile = profiles.get(profileName) ?? options.modelRegistry.getModelProfile(profileName);
-	if (!profile) {
-		const available = formatAvailableProfileNames(profiles);
-		throw new Error(`Unknown model profile "${options.profileName}". Available profiles: ${available}`);
-	}
+	const profileName = validateModelProfileName(options.profileName, profiles, options.modelRegistry.getError?.());
+	const profile = profiles.get(profileName) ?? options.modelRegistry.getModelProfile(profileName)!;
 	const profileLabel = formatModelProfileDisplayLabel(profile);
 
 	const requiredProviders = aggregateModelProfileRequiredProviders(profile.requiredProviders, profile);