@gajae-code/coding-agent 0.7.7 → 0.7.9

package/src/cli/update-cli.ts

@@ -14,6 +14,8 @@ import { theme } from "../modes/theme/theme";
 
 const RELEASE_REPO = "Yeachan-Heo/gajae-code";
 const PACKAGE = "@gajae-code/coding-agent";
+const NPM_WRAPPER_PACKAGE = "gajae-code";
+const NPM_MANAGED_PACKAGES = [NPM_WRAPPER_PACKAGE, PACKAGE] as const;
 
 interface ReleaseInfo {
 	tag: string;
@@ -27,6 +29,23 @@ export interface InstalledVersionVerification {
 	path?: string;
 	smokeTestFailed?: boolean;
 	smokeTestOutput?: string;
+	cleanupWarning?: string;
+}
+
+export interface PackageManagerUpdateResult {
+	exitCode: number | null;
+	text: () => string;
+}
+
+export type PackageManagerUpdateRunner = (expectedVersion: string) => Promise<PackageManagerUpdateResult>;
+
+export interface PackageManagerUpdateOptions {
+	managerName: string;
+	expectedVersion: string;
+	runInstall: PackageManagerUpdateRunner;
+	verifyInstalledRuntime: (expectedVersion: string) => Promise<InstalledVersionVerification>;
+	printVerificationResult?: (expectedVersion: string) => Promise<void>;
+	printRecoveredVerification?: (expectedVersion: string) => void;
 }
 
 /** Paths and verifier used while replacing a downloaded binary update. */
@@ -102,23 +121,76 @@ function isPathInDirectory(filePath: string, directoryPath: string): boolean {
 	return isPathInDirectoryLexical(resolvedFile, dirReal);
 }
 
-type UpdateTarget = { method: "bun" } | { method: "binary"; path: string };
+type PackageManagerTarget = { manager: "npm"; packageName: string };
+type UpdateTarget = { method: "bun" } | { method: "npm"; packageName: string } | { method: "binary"; path: string };
+
+type PathPlatform = NodeJS.Platform;
+type PackageExists = (packageName: string, packageRoot: string) => boolean;
+
+function pathApiForPlatform(platform: PathPlatform): typeof path.posix | typeof path.win32 {
+	return platform === "win32" ? path.win32 : path.posix;
+}
+
+function defaultPackageExists(_packageName: string, packageRoot: string): boolean {
+	return fs.existsSync(path.join(packageRoot, "package.json"));
+}
+
+function npmPackageRootForBinPath(binPath: string, packageName: string, platform: PathPlatform): string {
+	const pathApi = pathApiForPlatform(platform);
+	const segments = packageName.split("/");
+	return pathApi.join(pathApi.dirname(binPath), "node_modules", ...segments);
+}
+
+function resolveNpmManagedTarget(
+	ompPath: string,
+	platform: PathPlatform = process.platform,
+	packageExists: PackageExists = defaultPackageExists,
+): PackageManagerTarget | undefined {
+	if (platform !== "win32") return undefined;
+	const pathApi = pathApiForPlatform(platform);
+	const extension = pathApi.extname(ompPath).toLowerCase();
+	if (extension !== ".cmd" && extension !== ".ps1") return undefined;
+	const basename = pathApi.basename(ompPath, extension).toLowerCase();
+	if (basename !== APP_NAME.toLowerCase()) return undefined;
 
-function resolveUpdateMethod(ompPath: string, bunBinDir: string | undefined): "bun" | "binary" {
+	for (const packageName of NPM_MANAGED_PACKAGES) {
+		const packageRoot = npmPackageRootForBinPath(ompPath, packageName, platform);
+		if (packageExists(packageName, packageRoot)) return { manager: "npm", packageName };
+	}
+	return undefined;
+}
+
+function resolveUpdateMethod(ompPath: string, bunBinDir: string | undefined): "bun" | "npm" | "binary" {
+	if (resolveNpmManagedTarget(ompPath)) return "npm";
 	if (!bunBinDir) return "binary";
 	return isPathInDirectory(ompPath, bunBinDir) ? "bun" : "binary";
 }
 
-export function resolveUpdateMethodForTest(ompPath: string, bunBinDir: string | undefined): "bun" | "binary" {
+export function resolveUpdateMethodForTest(ompPath: string, bunBinDir: string | undefined): "bun" | "npm" | "binary" {
 	return resolveUpdateMethod(ompPath, bunBinDir);
 }
+
+export function resolveNpmManagedTargetForTest(
+	ompPath: string,
+	platform: PathPlatform,
+	packageExists: PackageExists,
+): PackageManagerTarget | undefined {
+	return resolveNpmManagedTarget(ompPath, platform, packageExists);
+}
 async function resolveUpdateTarget(): Promise<UpdateTarget> {
 	const bunBinDir = await getBunGlobalBinDir();
 	const ompPath = resolveGjcPath();
 
 	if (ompPath) {
+		const npmTarget = resolveNpmManagedTarget(ompPath);
+		if (npmTarget) return { method: "npm", packageName: npmTarget.packageName };
 		const method = resolveUpdateMethod(ompPath, bunBinDir);
 		if (method === "bun") return { method };
+		if (method === "npm") {
+			throw new Error(
+				formatUnsupportedTargetMessage(`Could not resolve npm package root for ${APP_NAME} shim ${ompPath}`),
+			);
+		}
 		return { method, path: ompPath };
 	}
 
@@ -262,6 +334,11 @@ function printVerifiedVersion(expectedVersion: string): void {
 	console.log(chalk.green(`\n${theme.status.success} Updated to ${expectedVersion}`));
 }
 
+function printSuccessfulVerification(expectedVersion: string): void {
+	printVerifiedVersion(expectedVersion);
+	printRestartGuidance();
+}
+
 function formatBinaryInstallInstruction(platform: NodeJS.Platform = process.platform): string {
 	if (platform === "win32") {
 		return `For a supported binary install, reinstall with PowerShell: irm https://raw.githubusercontent.com/${RELEASE_REPO}/main/scripts/install.ps1 | iex`;
@@ -351,8 +428,7 @@ export function formatVerificationFailureForTest(
 async function printVerification(expectedVersion: string): Promise<void> {
 	const result = await verifyInstalledRuntime(expectedVersion);
 	if (result.ok) {
-		printVerifiedVersion(expectedVersion);
-		printRestartGuidance();
+		printSuccessfulVerification(expectedVersion);
 		return;
 	}
 	console.log(chalk.yellow(`\nWarning: ${formatVerificationFailure(result, expectedVersion)}`));
@@ -367,6 +443,19 @@ async function unlinkIfExists(filePath: string): Promise<void> {
 	}
 }
 
+function formatBackupCleanupWarning(backupPath: string, err: unknown): string {
+	return `Installed update, but could not remove backup file ${backupPath}: ${err}. You can delete it manually after closing shells or antivirus processes that may still hold it.`;
+}
+
+async function cleanupVerifiedBackup(backupPath: string): Promise<string | undefined> {
+	try {
+		await unlinkIfExists(backupPath);
+		return undefined;
+	} catch (err) {
+		return formatBackupCleanupWarning(backupPath, err);
+	}
+}
+
 /**
  * Atomically replace the installed binary and roll back if version verification fails.
  */
@@ -386,8 +475,8 @@ export async function replaceBinaryForUpdate(options: BinaryReplacementOptions):
 		}
 
 		backupReady = false;
-		await unlinkIfExists(options.backupPath);
-		return verification;
+		const cleanupWarning = await cleanupVerifiedBackup(options.backupPath);
+		return cleanupWarning ? { ...verification, cleanupWarning } : verification;
 	} catch (err) {
 		if (backupReady) {
 			await unlinkIfExists(options.targetPath);
@@ -398,17 +487,67 @@ export async function replaceBinaryForUpdate(options: BinaryReplacementOptions):
 	}
 }
 
+function formatPackageManagerInstallFailure(
+	managerName: string,
+	result: PackageManagerUpdateResult,
+	verification: InstalledVersionVerification,
+	expectedVersion: string,
+): string {
+	const output = normalizeVerificationOutput(result.text());
+	const outputSuffix = output ? `: ${output}` : "";
+	return `${managerName} install failed with exit code ${result.exitCode ?? "unknown"}${outputSuffix}. ${formatVerificationFailure(verification, expectedVersion)}`;
+}
+
+export async function runPackageManagerUpdateForTest(
+	options: PackageManagerUpdateOptions,
+): Promise<InstalledVersionVerification> {
+	return updateViaPackageManager(options);
+}
+
+async function updateViaPackageManager(options: PackageManagerUpdateOptions): Promise<InstalledVersionVerification> {
+	const result = await options.runInstall(options.expectedVersion);
+	if (result.exitCode === 0) {
+		await (options.printVerificationResult ?? printVerification)(options.expectedVersion);
+		return await options.verifyInstalledRuntime(options.expectedVersion);
+	}
+
+	const verification = await options.verifyInstalledRuntime(options.expectedVersion);
+	if (verification.ok) {
+		console.warn(
+			chalk.yellow(
+				`${options.managerName} exited with ${result.exitCode ?? "unknown"}, but ${APP_NAME} now verifies as ${options.expectedVersion}. Treating the update as installed.`,
+			),
+		);
+		(options.printRecoveredVerification ?? printSuccessfulVerification)(options.expectedVersion);
+		return verification;
+	}
+
+	throw new Error(
+		formatPackageManagerInstallFailure(options.managerName, result, verification, options.expectedVersion),
+	);
+}
+
 /**
  * Update via bun package manager.
  */
 async function updateViaBun(expectedVersion: string): Promise<void> {
 	console.log(chalk.dim("Updating via bun..."));
-	const result = await $`bun install -g ${PACKAGE}@${expectedVersion}`.nothrow();
-	if (result.exitCode !== 0) {
-		throw new Error(`bun install failed with exit code ${result.exitCode}`);
-	}
+	await updateViaPackageManager({
+		managerName: "bun",
+		expectedVersion,
+		runInstall: async version => await $`bun install -g ${PACKAGE}@${version}`.nothrow(),
+		verifyInstalledRuntime,
+	});
+}
 
-	await printVerification(expectedVersion);
+async function updateViaNpm(packageName: string, expectedVersion: string): Promise<void> {
+	console.log(chalk.dim(`Updating npm-managed install via npm (${packageName})...`));
+	await updateViaPackageManager({
+		managerName: "npm",
+		expectedVersion,
+		runInstall: async version => await $`npm install -g ${packageName}@${version}`.nothrow(),
+		verifyInstalledRuntime,
+	});
 }
 
 /**
@@ -430,7 +569,7 @@ async function updateViaBinaryAt(targetPath: string, expectedVersion: string): P
 	await pipeline(response.body, fileStream);
 
 	console.log(chalk.dim("Installing update..."));
-	await replaceBinaryForUpdate({
+	const verification = await replaceBinaryForUpdate({
 		targetPath,
 		tempPath,
 		backupPath,
@@ -438,6 +577,7 @@ async function updateViaBinaryAt(targetPath: string, expectedVersion: string): P
 		verifyInstalledVersion: verifyInstalledRuntime,
 	});
 	printVerifiedVersion(expectedVersion);
+	if (verification.cleanupWarning) console.warn(chalk.yellow(verification.cleanupWarning));
 	printRestartGuidance();
 }
 
@@ -479,6 +619,8 @@ export async function runUpdateCommand(opts: { force: boolean; check: boolean })
 		const target = await resolveUpdateTarget();
 		if (target.method === "bun") {
 			await updateViaBun(release.version);
+		} else if (target.method === "npm") {
+			await updateViaNpm(target.packageName, release.version);
 		} else {
 			await updateViaBinaryAt(target.path, release.version);
 		}

package/src/cli.ts

@@ -26,6 +26,7 @@ export const commands: CommandEntry[] = [
 	{ name: "codex-native-hook", load: () => import("./commands/codex-native-hook").then(m => m.default) },
 	{ name: "state", load: () => import("./commands/state").then(m => m.default) },
 	{ name: "setup", load: () => import("./commands/setup").then(m => m.default) },
+	{ name: "acp", load: () => import("./commands/acp").then(m => m.default) },
 	{ name: "skills", load: () => import("./commands/skills").then(m => m.default) },
 	{ name: "session", load: () => import("./commands/session").then(m => m.default) },
 	{ name: "harness", load: () => import("./commands/harness").then(m => m.default) },
@@ -38,6 +39,7 @@ export const commands: CommandEntry[] = [
 	{ name: "notify", load: () => import("./commands/notify").then(m => m.default) },
 	{ name: "daemon", load: () => import("./commands/daemon").then(m => m.default) },
 	{ name: "web-search", aliases: ["q"], load: () => import("./commands/web-search").then(m => m.default) },
+	{ name: "local-provider", load: () => import("./commands/local-provider").then(m => m.default) },
 	{ name: "mcp-serve", load: () => import("./commands/mcp-serve").then(m => m.default) },
 	{ name: "mcp", load: () => import("./commands/mcp").then(m => m.default) },
 	{
@@ -79,6 +81,19 @@ async function installRuntimeGlobals(): Promise<void> {
 	delete process.env.MallocStackLoggingNoCompact;
 }
 
+function isNotifyDaemonInternalFastPath(argv: string[]): boolean {
+	return argv[0] === "notify" && argv[1] === "daemon-internal";
+}
+
+async function runNotifyDaemonInternalFastPath(argv: string[]): Promise<void> {
+	const { parseNotifyArgs, runNotifyCommand } = await import("./cli/notify-cli");
+	const cmd = parseNotifyArgs(argv);
+	if (cmd?.action !== "daemon-internal") {
+		throw new Error("invalid notify daemon-internal fast path");
+	}
+	await runNotifyCommand(cmd);
+}
+
 function hasRootFastFlag(argv: string[], flags: readonly string[]): boolean {
 	for (const arg of argv) {
 		if (isSubcommand(arg)) return false;
@@ -208,6 +223,10 @@ async function runSmokeTest(): Promise<void> {
 
 /** Run the CLI with the given argv (no `process.argv` prefix). */
 export async function runCli(argv: string[]): Promise<void> {
+	if (isNotifyDaemonInternalFastPath(argv)) {
+		await runNotifyDaemonInternalFastPath(argv);
+		return;
+	}
 	if (argv[0] === "--smoke-test") {
 		await runSmokeTest();
 		return;

package/src/commands/launch.ts

@@ -2,15 +2,54 @@
  * Root command for the coding agent CLI.
  */
 
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import { THINKING_EFFORTS } from "@gajae-code/ai";
 import { APP_NAME, setProjectDir } from "@gajae-code/utils";
 import { Args, Command, Flags } from "@gajae-code/utils/cli";
 import { parseArgs } from "../cli/args";
 import { launchDefaultTmuxIfNeeded } from "../gjc-runtime/launch-tmux";
 import { prepareLaunchWorktree } from "../gjc-runtime/launch-worktree";
+import {
+	GJC_COORDINATOR_SESSION_ID_ENV,
+	GJC_COORDINATOR_SESSION_STATE_FILE_ENV,
+} from "../gjc-runtime/session-state-sidecar";
 import { runRootCommand } from "../main";
 import { prepareAcpTerminalAuthArgs } from "../modes/acp/terminal-auth";
 
+async function persistCoordinatorLaunchFailure(error: unknown, cwd: string): Promise<void> {
+	const stateFile = process.env[GJC_COORDINATOR_SESSION_STATE_FILE_ENV]?.trim();
+	if (!stateFile) return;
+	const message = error instanceof Error ? error.message : String(error);
+	const code = message.split(":", 1)[0] || "launch_failed";
+	const now = new Date().toISOString();
+	const payload = {
+		schema_version: 1,
+		session_id: process.env[GJC_COORDINATOR_SESSION_ID_ENV]?.trim() || null,
+		state: "errored",
+		ready_for_input: false,
+		updated_at: now,
+		current_turn_id: null,
+		last_turn_id: null,
+		live: false,
+		reason: code,
+		source: "agent_session_event",
+		event: "launch_error",
+		cwd,
+		session_file: null,
+		final_response: {
+			text: message,
+			format: "markdown",
+			source: "launch_error",
+			artifact_path: null,
+			truncated: false,
+		},
+		error: { code, message, recoverable: true },
+	};
+	await fs.mkdir(path.dirname(stateFile), { recursive: true });
+	await Bun.write(stateFile, `${JSON.stringify(payload, null, 2)}\n`);
+}
+
 export default class Index extends Command {
 	static description = "Red-claw AI coding assistant";
 	static hidden = true;
@@ -157,7 +196,13 @@ export default class Index extends Command {
 			return;
 		}
 
-		const launch = prepareLaunchWorktree(process.cwd(), args);
+		let launch: ReturnType<typeof prepareLaunchWorktree>;
+		try {
+			launch = prepareLaunchWorktree(process.cwd(), args);
+		} catch (error) {
+			await persistCoordinatorLaunchFailure(error, process.cwd());
+			throw error;
+		}
 		if (launch.worktree.enabled) {
 			process.chdir(launch.cwd);
 			setProjectDir(launch.cwd);

package/src/commands/local-provider.ts

@@ -0,0 +1,62 @@
+/**
+ * Test configured local OpenAI-compatible providers.
+ */
+import { Args, Command, Flags } from "@gajae-code/utils/cli";
+import {
+	runLocalProviderDiscoverCommand,
+	runLocalProviderSmokeCommand,
+	runLocalProviderStatusCommand,
+} from "../cli/local-provider-smoke";
+
+export const LOCAL_PROVIDER_ACTIONS = ["status", "diagnose", "discover", "models", "smoke"] as const;
+export const LOCAL_PROVIDER_DEFAULT_ACTION = "status";
+
+export default class LocalProvider extends Command {
+	static description = "Diagnose configured local OpenAI-compatible providers";
+
+	static args = {
+		action: Args.string({ description: "Action", required: false, options: LOCAL_PROVIDER_ACTIONS }),
+	};
+
+	static flags = {
+		model: Flags.string({ description: "Model id to use for smoke (otherwise uses the first /models id)" }),
+		"models-path": Flags.string({ description: "Override models config path" }),
+		"timeout-ms": Flags.integer({ description: "Request timeout in milliseconds" }),
+		smoke: Flags.boolean({ description: "Run optional streaming chat smoke during status/diagnose" }),
+		json: Flags.boolean({ description: "Output JSON" }),
+	};
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(LocalProvider);
+		const action = args.action ?? LOCAL_PROVIDER_DEFAULT_ACTION;
+		if (action === "status" || action === "diagnose") {
+			await runLocalProviderStatusCommand({
+				model: flags.model,
+				modelsPath: flags["models-path"],
+				timeoutMs: flags["timeout-ms"],
+				smoke: flags.smoke,
+				json: flags.json,
+			});
+			return;
+		}
+		if (action === "discover" || action === "models") {
+			await runLocalProviderDiscoverCommand({
+				modelsPath: flags["models-path"],
+				timeoutMs: flags["timeout-ms"],
+				json: flags.json,
+			});
+			return;
+		}
+		if (action === "smoke") {
+			await runLocalProviderSmokeCommand({
+				model: flags.model,
+				modelsPath: flags["models-path"],
+				timeoutMs: flags["timeout-ms"],
+				json: flags.json,
+			});
+			return;
+		}
+		process.stderr.write(`Unsupported local-provider action: ${action}\n`);
+		process.exitCode = 1;
+	}
+}

package/src/commands/notify.ts

@@ -55,7 +55,7 @@ export default class Notify extends Command {
 			redact: Boolean(flags.redact),
 		};
 
-		await initTheme();
+		if (action !== "daemon-internal") await initTheme();
 		await runNotifyCommand(cmd);
 	}
 }

package/src/config/keybindings.ts

@@ -118,7 +118,7 @@ export const KEYBINDINGS = {
 	},
 	"app.message.followUp": {
 		defaultKeys: [],
-		description: "Send follow-up message (no default; Ctrl+Enter inserts a newline)",
+		description: "Send follow-up message (no default; Ctrl+Enter submits)",
 	},
 	"app.message.queue": {
 		defaultKeys: "alt+enter",

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

@@ -5,6 +5,7 @@ import { formatClampedModelSelector } from "../thinking";
 import {
 	aggregateModelProfileRequiredProviders,
 	formatAvailableProfileNames,
+	formatModelProfileDisplayLabel,
 	resolveProfileBindings,
 } from "./model-profiles";
 import {
@@ -46,7 +47,7 @@ export interface PrepareModelProfileActivationOptions {
 export interface PreparedModelProfileActivation {
 	profileName: string;
 	session: ModelProfileActivationSession & { setModelTemporary: AgentSession["setModelTemporary"] };
-	settings: Pick<Settings, "get" | "override" | "set" | "flush">;
+	settings: Pick<Settings, "clearOverride" | "get" | "getGlobal" | "override" | "set" | "flush">;
 	previousModel: Model<Api> | undefined;
 	previousThinkingLevel: ThinkingLevel | undefined;
 	previousAgentModelOverrides: Record<string, string>;
@@ -108,8 +109,8 @@ export function materializeActiveModelProfileAssignment(options: MaterializeMode
 	return true;
 }
 
-export function formatModelProfileCredentialError(profileName: string, providers: readonly string[]): string {
-	return `Model profile "${profileName}" requires credentials for: ${providers.join(", ")}. Run /login and configure the missing provider(s), then retry.`;
+export function formatModelProfileCredentialError(profileLabel: string, providers: readonly string[]): string {
+	return `Model profile "${profileLabel}" requires credentials for: ${providers.join(", ")}. Run /login and configure the missing provider(s), then retry.`;
 }
 
 function resolveModelProfileName(profileName: string, profiles: ReadonlyMap<string, unknown>): string {
@@ -183,6 +184,7 @@ export async function prepareModelProfileActivation(
 		const available = formatAvailableProfileNames(profiles);
 		throw new Error(`Unknown model profile "${options.profileName}". Available profiles: ${available}`);
 	}
+	const profileLabel = formatModelProfileDisplayLabel(profile);
 
 	const allProviders = aggregateModelProfileRequiredProviders(profile.requiredProviders, profile);
 	const alternativeGroups = profile.alternativeProviderGroups ?? [];
@@ -202,19 +204,19 @@ export async function prepareModelProfileActivation(
 	// Check strict (non-alternative) providers — all must be authenticated.
 	const strictMissing = missingProviders.filter(p => !alternativeSet.has(p));
 	if (strictMissing.length > 0) {
-		throw new Error(formatModelProfileCredentialError(options.profileName, strictMissing));
+		throw new Error(formatModelProfileCredentialError(profileLabel, strictMissing));
 	}
 
 	// Check alternative groups — at least one provider per group must be authenticated.
 	for (const group of alternativeGroups) {
 		const groupAuthenticated = group.some(p => authenticatedProviders.includes(p));
 		if (!groupAuthenticated) {
-			throw new Error(formatModelProfileCredentialError(options.profileName, [...group]));
+			throw new Error(formatModelProfileCredentialError(profileLabel, [...group]));
 		}
 	}
 
 	if (authenticatedProviders.length === 0) {
-		throw new Error(formatModelProfileCredentialError(options.profileName, missingProviders));
+		throw new Error(formatModelProfileCredentialError(profileLabel, missingProviders));
 	}
 
 	const availableModels = options.modelRegistry.getAll();
@@ -229,9 +231,7 @@ export async function prepareModelProfileActivation(
 			})
 		: undefined;
 	if (bindings.defaultSelector && !resolvedDefault?.model) {
-		throw new Error(
-			`Model profile "${options.profileName}" default selector did not resolve: ${bindings.defaultSelector}`,
-		);
+		throw new Error(`Model profile "${profileLabel}" default selector did not resolve: ${bindings.defaultSelector}`);
 	}
 
 	const modelRoles: Record<string, string> = {};
@@ -241,7 +241,7 @@ export async function prepareModelProfileActivation(
 			modelRegistry: options.modelRegistry,
 		});
 		if (!resolved.model) {
-			throw new Error(`Model profile "${options.profileName}" ${role} selector did not resolve: ${selector}`);
+			throw new Error(`Model profile "${profileLabel}" ${role} selector did not resolve: ${selector}`);
 		}
 		modelRoles[role] = formatClampedModelSelector(selector, resolved.model);
 	}
@@ -256,7 +256,7 @@ export async function prepareModelProfileActivation(
 			modelRegistry: options.modelRegistry,
 		});
 		if (!resolved.model) {
-			throw new Error(`Model profile "${options.profileName}" ${role} selector did not resolve: ${selector}`);
+			throw new Error(`Model profile "${profileLabel}" ${role} selector did not resolve: ${selector}`);
 		}
 		agentModelOverrides[role] = formatClampedModelSelector(selector, resolved.model);
 	}
@@ -357,6 +357,87 @@ export async function applyPreparedModelProfileActivation(
 	}
 }
 
+export interface MaterializeModelProfileForDeletionResult {
+	modelRoles: Record<string, string>;
+	agentModelOverrides: Record<string, string>;
+	previousModelRoles: Record<string, string>;
+	previousAgentModelOverrides: Record<string, string>;
+	previousDefaultProfile: string | undefined;
+	previousPersistedDefaultProfile: string | undefined;
+	previousActiveModelProfile: string | undefined;
+}
+
+export async function materializeModelProfileForDeletion(
+	options: PrepareModelProfileActivationOptions & {
+		settings: Pick<Settings, "clearOverride" | "flush" | "get" | "getGlobal" | "override" | "set">;
+	},
+): Promise<MaterializeModelProfileForDeletionResult> {
+	const prepared = await prepareModelProfileActivation(options);
+	const previousDefaultProfile = prepared.settings.get("modelProfile.default");
+	const previousPersistedDefaultProfile = prepared.settings.getGlobal("modelProfile.default");
+	const nextModelRoles = {
+		...prepared.previousModelRoles,
+		...(prepared.defaultModel
+			? {
+					default: formatModelSelectorValue(
+						`${prepared.defaultModel.provider}/${prepared.defaultModel.id}`,
+						prepared.defaultThinkingLevel,
+					),
+				}
+			: {}),
+		...prepared.modelRoles,
+	};
+	const nextAgentModelOverrides = {
+		...prepared.previousAgentModelOverrides,
+		...prepared.agentModelOverrides,
+	};
+
+	try {
+		prepared.settings.set("modelRoles", nextModelRoles);
+		prepared.settings.set("task.agentModelOverrides", nextAgentModelOverrides);
+		prepared.settings.set("modelProfile.default", undefined);
+		prepared.settings.clearOverride("modelProfile.default");
+		prepared.settings.override("modelRoles", nextModelRoles);
+		prepared.settings.override("task.agentModelOverrides", nextAgentModelOverrides);
+		prepared.session.setActiveModelProfile?.(undefined);
+		await prepared.settings.flush();
+	} catch (error) {
+		prepared.settings.set("modelRoles", prepared.previousModelRoles);
+		prepared.settings.set("task.agentModelOverrides", prepared.previousAgentModelOverrides);
+		prepared.settings.set("modelProfile.default", previousPersistedDefaultProfile);
+		prepared.settings.override("modelRoles", prepared.previousModelRoles);
+		prepared.settings.override("task.agentModelOverrides", prepared.previousAgentModelOverrides);
+		prepared.settings.override("modelProfile.default", previousDefaultProfile);
+		prepared.session.setActiveModelProfile?.(prepared.previousActiveModelProfile);
+		throw error;
+	}
+
+	return {
+		modelRoles: nextModelRoles,
+		agentModelOverrides: nextAgentModelOverrides,
+		previousModelRoles: prepared.previousModelRoles,
+		previousAgentModelOverrides: prepared.previousAgentModelOverrides,
+		previousDefaultProfile,
+		previousPersistedDefaultProfile,
+		previousActiveModelProfile: prepared.previousActiveModelProfile,
+	};
+}
+
+export async function restoreMaterializedModelProfileForDeletion(options: {
+	settings: Pick<Settings, "flush" | "override" | "set">;
+	session: Pick<ModelProfileActivationSession, "setActiveModelProfile">;
+	snapshot: MaterializeModelProfileForDeletionResult;
+}): Promise<void> {
+	options.settings.set("modelRoles", options.snapshot.previousModelRoles);
+	options.settings.set("task.agentModelOverrides", options.snapshot.previousAgentModelOverrides);
+	options.settings.set("modelProfile.default", options.snapshot.previousPersistedDefaultProfile);
+	options.settings.override("modelRoles", options.snapshot.previousModelRoles);
+	options.settings.override("task.agentModelOverrides", options.snapshot.previousAgentModelOverrides);
+	options.settings.override("modelProfile.default", options.snapshot.previousDefaultProfile);
+	options.session.setActiveModelProfile?.(options.snapshot.previousActiveModelProfile);
+	await options.settings.flush();
+}
+
 export async function activateModelProfile(
 	options: PrepareModelProfileActivationOptions,
 	applyOptions: { persistDefault?: boolean } = {},

package/src/config/model-profiles.ts

@@ -1,3 +1,4 @@
+import { sanitizeText } from "@gajae-code/utils";
 import type { GjcModelAssignmentTargetId } from "./model-registry";
 import type { ModelsConfig } from "./models-config-schema";
 
@@ -98,7 +99,7 @@ export const BUILTIN_MODEL_PROFILES: readonly ModelProfileDefinition[] = [
 	}),
 	profile("claude-opus", ["anthropic"], {
 		default: "anthropic/claude-opus-4-8:xhigh",
-		executor: "anthropic/claude-sonnet-4-6",
+		executor: "anthropic/claude-sonnet-5",
 		planner: "anthropic/claude-opus-4-8:low",
 		critic: "anthropic/claude-opus-4-8:high",
 		architect: "anthropic/claude-opus-4-8:xhigh",
@@ -267,6 +268,10 @@ export interface ModelProfilePresentation {
 	providerGroup: string;
 }
 
+function sanitizeModelProfileLabel(value: string): string {
+	return sanitizeText(value).replace(/\s+/g, " ").trim();
+}
+
 const PROFILE_PRESENTATION: Record<string, ModelProfilePresentation> = {
 	"codex-eco": { displayName: "Codex Eco", providerGroup: "CODEX" },
 	"codex-medium": { displayName: "Codex Medium", providerGroup: "CODEX" },
@@ -332,7 +337,15 @@ export function getModelProfilePresentation(
 	const displayName = typeof profile === "string" ? undefined : profile.displayName;
 	const presentation = PROFILE_PRESENTATION[name];
 	if (presentation) return presentation;
-	return { displayName: displayName ?? name, providerGroup: "CUSTOM" };
+	return { displayName: formatModelProfileDisplayLabel({ name, displayName }), providerGroup: "CUSTOM" };
+}
+
+export function formatModelProfileDisplayLabel(profile: Pick<ModelProfileDefinition, "name" | "displayName">): string {
+	return (
+		sanitizeModelProfileLabel(profile.displayName ?? profile.name) ||
+		sanitizeModelProfileLabel(profile.name) ||
+		"Unnamed profile"
+	);
 }
 
 export function groupModelProfilesForPresetLanding(