@gajae-code/coding-agent 0.6.5 → 0.7.0

package/src/cli/setup-cli.ts

@@ -6,7 +6,7 @@
 
 import * as path from "node:path";
 import { createInterface } from "node:readline/promises";
-import { SqliteAuthCredentialStore } from "@gajae-code/ai";
+import { AuthStorage, SqliteAuthCredentialStore } from "@gajae-code/ai";
 import { $which, APP_NAME, getAgentDbPath, getPythonEnvDir } from "@gajae-code/utils";
 import { $ } from "bun";
 import chalk from "chalk";
@@ -17,13 +17,15 @@ import {
 	readGjcManagedCodexHooksStatus,
 } from "../hooks/codex-native-hooks-config";
 import { theme } from "../modes/theme/theme";
-import { discoverExternalCredentials, formatDiscoverySummary, importCredentials } from "../setup/credential-import";
+import { formatCredentialAutoImportResult, runExternalCredentialAutoImport } from "../setup/credential-auto-import";
+import { filterAutoImportOAuthCredentials, formatDiscoverySummary } from "../setup/credential-import";
 import {
 	formatHermesSetupResult,
 	type HermesSetupFlags,
 	hermesSetupExitCode,
 	runHermesSetup,
 } from "../setup/hermes-setup";
+import { buildHostPluginSetup, formatHostPluginSetup, type HostPluginKind } from "../setup/host-plugin-setup";
 import {
 	addApiCompatibleProvider,
 	formatProviderPresetList,
@@ -31,7 +33,16 @@ import {
 	parseProviderCompatibility,
 } from "../setup/provider-onboarding";
 
-export type SetupComponent = "credentials" | "defaults" | "hermes" | "hooks" | "provider" | "python" | "stt";
+export type SetupComponent =
+	| "claude"
+	| "codex"
+	| "credentials"
+	| "defaults"
+	| "hermes"
+	| "hooks"
+	| "provider"
+	| "python"
+	| "stt";
 
 export interface SetupCommandArgs {
 	component: SetupComponent;
@@ -63,10 +74,21 @@ export interface SetupCommandArgs {
 		profileDir?: string;
 		yes?: boolean;
 		dryRun?: boolean;
+		keychain?: boolean;
 	};
 }
 
-const VALID_COMPONENTS: SetupComponent[] = ["credentials", "defaults", "hermes", "hooks", "provider", "python", "stt"];
+const VALID_COMPONENTS: SetupComponent[] = [
+	"claude",
+	"codex",
+	"credentials",
+	"defaults",
+	"hermes",
+	"hooks",
+	"provider",
+	"python",
+	"stt",
+];
 
 function hasProviderSetupFlags(flags: SetupCommandArgs["flags"]): boolean {
 	return (
@@ -123,6 +145,8 @@ export function parseSetupArgs(args: string[]): SetupCommandArgs | undefined {
 			flags.yes = true;
 		} else if (arg === "--dry-run") {
 			flags.dryRun = true;
+		} else if (arg === "--keychain") {
+			flags.keychain = true;
 		} else if (arg === "--root") {
 			flags.root = [...(flags.root ?? []), args[++i] ?? ""];
 		} else if (arg === "--repo") {
@@ -235,6 +259,12 @@ async function checkPythonSetup(): Promise<PythonCheckResult> {
 export async function runSetupCommand(cmd: SetupCommandArgs): Promise<void> {
 	rejectProviderFlagsOutsideProvider(cmd.component, cmd.flags);
 	switch (cmd.component) {
+		case "claude":
+			handleHostPluginSetup("claude", cmd.flags);
+			break;
+		case "codex":
+			handleHostPluginSetup("codex", cmd.flags);
+			break;
 		case "defaults":
 			await handleDefaultsSetup(cmd.flags);
 			break;
@@ -279,6 +309,22 @@ async function handleHermesSetup(flags: HermesSetupFlags): Promise<void> {
 		process.exit(hermesSetupExitCode(error));
 	}
 }
+
+function handleHostPluginSetup(host: HostPluginKind, flags: SetupCommandArgs["flags"]): void {
+	const result = buildHostPluginSetup(host, {
+		json: flags.json,
+		check: flags.check,
+		root: flags.root,
+		repo: flags.repo,
+	});
+	if (flags.json) {
+		process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+		return;
+	}
+	const label = host === "claude" ? "Claude Code" : "Codex";
+	process.stdout.write(`${chalk.green(`${theme.status.success} ${label} plugin setup ready`)}\n`);
+	process.stdout.write(`${chalk.dim(formatHostPluginSetup(result))}\n`);
+}
 async function handleProviderSetup(flags: {
 	json?: boolean;
 	force?: boolean;
@@ -516,99 +562,141 @@ async function confirmImport(count: number): Promise<boolean> {
  * gjc credential store after a redacted preview + confirmation. Falls back to
  * manual-setup guidance when nothing importable is found.
  */
-async function handleCredentialsSetup(flags: { json?: boolean; yes?: boolean; dryRun?: boolean }): Promise<void> {
-	const result = await discoverExternalCredentials();
-	const redactedPlan = {
-		importable: result.importable.map(c => ({
-			provider: c.provider,
-			kind: c.kind,
-			source: c.source,
-			identity: c.identity,
-			expiresAt: c.expiresAt,
-			redactedToken: c.redactedToken,
-		})),
-		skipped: result.skipped,
-		environment: result.environment,
-	};
+export interface CredentialsSetupDependencies {
+	openStore?: typeof SqliteAuthCredentialStore.open;
+	createAuthStorage?: (store: Awaited<ReturnType<typeof SqliteAuthCredentialStore.open>>) => AuthStorage;
+	discover?: Parameters<typeof runExternalCredentialAutoImport>[0]["discover"];
+}
 
-	if (result.importable.length === 0) {
-		if (flags.json) {
-			process.stdout.write(`${JSON.stringify({ ...redactedPlan, imported: [] })}\n`);
+export async function handleCredentialsSetup(
+	flags: {
+		json?: boolean;
+		yes?: boolean;
+		dryRun?: boolean;
+		keychain?: boolean;
+	},
+	deps: CredentialsSetupDependencies = {},
+): Promise<void> {
+	const discoveryOptions = flags.keychain ? undefined : { readClaudeKeychain: async () => null };
+	const store = await (deps.openStore ?? SqliteAuthCredentialStore.open)(getAgentDbPath());
+	const authStorage = deps.createAuthStorage?.(store) ?? new AuthStorage(store);
+	await authStorage.reload();
+	try {
+		const preview = await runExternalCredentialAutoImport({
+			authStorage: {
+				importCredentialIfAbsent: async () => ({
+					inserted: false,
+					reason: "skipped-existing",
+					provider: "",
+					entries: [],
+				}),
+			},
+			discover: deps.discover,
+			discoveryOptions,
+			trigger: "setup-cli",
+		});
+		const result = preview.discovery ?? { importable: [], skipped: [], environment: [] };
+		const candidates = filterAutoImportOAuthCredentials(result.importable);
+		const filteredResult = { ...result, importable: candidates };
+		const redactedPlan = {
+			importable: candidates.map(c => ({
+				provider: c.provider,
+				kind: c.kind,
+				source: c.source,
+				identity: c.identity,
+				expiresAt: c.expiresAt,
+				redactedToken: c.redactedToken,
+			})),
+			skipped: result.skipped,
+			environment: result.environment,
+			keychainChecked: flags.keychain === true,
+		};
+
+		if (!flags.keychain && !flags.json) {
+			process.stdout.write(chalk.dim("Claude Keychain not checked (pass --keychain to include it)\n"));
+		}
+
+		if (candidates.length === 0) {
+			if (flags.json) {
+				process.stdout.write(`${JSON.stringify({ ...redactedPlan, imported: [] })}\n`);
+				return;
+			}
+			for (const line of formatDiscoverySummary(filteredResult)) process.stdout.write(`  ${line}\n`);
+			process.stdout.write(
+				chalk.yellow(
+					`\nNo importable Claude/Codex credentials found. Continue with manual setup:\n` +
+						`  ${APP_NAME} setup provider   (add an API-compatible provider)\n` +
+						`  ${APP_NAME} (then /login)     (interactive OAuth/subscription login)\n`,
+				),
+			);
 			return;
 		}
-		for (const line of formatDiscoverySummary(result)) process.stdout.write(`  ${line}\n`);
-		process.stdout.write(
-			chalk.yellow(
-				`\nNo importable Claude/Codex credentials found. Continue with manual setup:\n` +
-					`  ${APP_NAME} setup provider   (add an API-compatible provider)\n` +
-					`  ${APP_NAME} (then /login)     (interactive OAuth/subscription login)\n`,
-			),
-		);
-		return;
-	}
 
-	if (!flags.json) {
-		process.stdout.write(chalk.bold("Discovered credentials (redacted):\n"));
-		for (const line of formatDiscoverySummary(result)) process.stdout.write(`  ${line}\n`);
-	}
+		if (!flags.json) {
+			process.stdout.write(chalk.bold("Discovered credentials (redacted):\n"));
+			for (const line of formatDiscoverySummary(filteredResult)) process.stdout.write(`  ${line}\n`);
+		}
 
-	if (flags.dryRun) {
-		if (flags.json) process.stdout.write(`${JSON.stringify({ ...redactedPlan, dryRun: true, imported: [] })}\n`);
-		else process.stdout.write(chalk.dim(`\nDry run — no credentials imported.\n`));
-		return;
-	}
+		if (flags.dryRun) {
+			if (flags.json) process.stdout.write(`${JSON.stringify({ ...redactedPlan, dryRun: true, imported: [] })}\n`);
+			else process.stdout.write(chalk.dim(`\nDry run — no credentials imported.\n`));
+			return;
+		}
+
+		const confirmed = flags.yes || (await confirmImport(candidates.length));
+		if (!confirmed) {
+			if (flags.json) {
+				process.stdout.write(`${JSON.stringify({ ...redactedPlan, imported: [] })}\n`);
+				return;
+			}
+			process.stdout.write(chalk.dim(`\nImport cancelled. Re-run with --yes to import non-interactively.\n`));
+			return;
+		}
+
+		const summary = await runExternalCredentialAutoImport({
+			authStorage,
+			discover: deps.discover,
+			discoveryOptions,
+			trigger: "setup-cli",
+		});
 
-	const confirmed = flags.yes || (await confirmImport(result.importable.length));
-	if (!confirmed) {
 		if (flags.json) {
-			process.stdout.write(`${JSON.stringify({ ...redactedPlan, imported: [] })}\n`);
+			process.stdout.write(
+				`${JSON.stringify({
+					...redactedPlan,
+					imported: summary.imported.map(c => ({ provider: c.provider, kind: c.kind, source: c.source })),
+					skippedImport: summary.skipped.map(s => ({
+						provider: s.credential.provider,
+						source: s.credential.source,
+						reason: s.reason,
+					})),
+					failed: summary.failures.map(f => ({
+						provider: f.credential?.provider,
+						source: f.credential?.source ?? f.source,
+						error: f.failureClass,
+					})),
+				})}\n`,
+			);
+			if (summary.failures.length > 0) process.exitCode = 1;
 			return;
 		}
-		process.stdout.write(chalk.dim(`\nImport cancelled. Re-run with --yes to import non-interactively.\n`));
-		return;
-	}
 
-	const store = await SqliteAuthCredentialStore.open(getAgentDbPath());
-	let summary: Awaited<ReturnType<typeof importCredentials>>;
-	try {
-		summary = await importCredentials(result.importable, (provider, credential) =>
-			store.upsertAuthCredentialForProvider(provider, credential),
-		);
+		for (const credential of summary.imported) {
+			process.stdout.write(
+				`${chalk.green(`${theme.status.success} imported`)} ${formatCredentialSummaryLine(credential)}\n`,
+			);
+		}
+		for (const line of formatCredentialAutoImportResult({ ...summary, imported: [], skipped: [] })) {
+			process.stdout.write(`${chalk.dim(line)}\n`);
+		}
+		if (summary.failures.length > 0) {
+			process.exitCode = 1;
+			return;
+		}
+		process.stdout.write(chalk.dim(`\nCredentials saved to ${getAgentDbPath()}\n`));
 	} finally {
 		store.close();
 	}
-
-	if (flags.json) {
-		process.stdout.write(
-			`${JSON.stringify({
-				...redactedPlan,
-				imported: summary.imported.map(c => ({ provider: c.provider, kind: c.kind, source: c.source })),
-				failed: summary.failed.map(f => ({
-					provider: f.credential.provider,
-					source: f.credential.source,
-					error: f.error,
-				})),
-			})}\n`,
-		);
-		if (summary.failed.length > 0) process.exitCode = 1;
-		return;
-	}
-
-	for (const credential of summary.imported) {
-		process.stdout.write(
-			`${chalk.green(`${theme.status.success} imported`)} ${formatCredentialSummaryLine(credential)}\n`,
-		);
-	}
-	for (const failure of summary.failed) {
-		process.stdout.write(
-			`${chalk.red(`${theme.status.error} failed`)} ${failure.credential.provider} (${failure.credential.source}): ${failure.error}\n`,
-		);
-	}
-	if (summary.failed.length > 0) {
-		process.exitCode = 1;
-		return;
-	}
-	process.stdout.write(chalk.dim(`\nCredentials saved to ${getAgentDbPath()}\n`));
 }
 
 function formatCredentialSummaryLine(credential: { provider: string; kind: string; source: string }): string {
@@ -669,6 +757,7 @@ ${chalk.bold("Options:")}
   --profile-dir     Hermes profile directory for full setup install
   --dry-run         Preview discovered credentials without importing (credentials)
   -y, --yes         Import discovered credentials without an interactive prompt (credentials)
+  --keychain        Include Claude macOS Keychain when discovering credentials
 
 ${chalk.bold("Examples:")}
   ${APP_NAME} setup                  Install bundled GJC default workflow skills

package/src/cli.ts

@@ -35,6 +35,8 @@ const commands: CommandEntry[] = [
 	{ name: "gc", load: () => import("./commands/gc").then(m => m.default) },
 	{ name: "ralplan", load: () => import("./commands/ralplan").then(m => m.default) },
 	{ name: "config", load: () => import("./commands/config").then(m => m.default) },
+	{ 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: "mcp-serve", load: () => import("./commands/mcp-serve").then(m => m.default) },
 	{

package/src/commands/daemon.ts

@@ -0,0 +1,47 @@
+/**
+ * Manage GJC background daemons (status/list/stop/reload).
+ */
+import { Args, Command, Flags } from "@gajae-code/utils/cli";
+import { type DaemonCliAction, type DaemonCommandArgs, runDaemonCommand } from "../cli/daemon-cli";
+import type { DaemonKind } from "../daemon/control-types";
+import { initTheme } from "../modes/theme/theme";
+
+const ACTIONS: DaemonCliAction[] = ["list", "status", "stop", "reload"];
+
+export default class Daemon extends Command {
+	static description = "Manage GJC background daemons (status, list, stop, reload)";
+
+	static args = {
+		action: Args.string({ description: "Daemon action", required: false, options: ACTIONS }),
+		kind: Args.string({ description: "Daemon kind(s) to target", required: false, multiple: true }),
+	};
+
+	static flags = {
+		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" }),
+		"spawn-if-stopped": Flags.boolean({ description: "On reload, spawn even when no daemon is running" }),
+	};
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(Daemon);
+		const action = (args.action ?? "status") as DaemonCliAction;
+		const kinds = (Array.isArray(args.kind) ? args.kind : args.kind ? [args.kind] : []) as DaemonKind[];
+		const flagRec = flags as Record<string, unknown>;
+		const cmd: DaemonCommandArgs = {
+			action,
+			kinds,
+			all: Boolean(flags.all),
+			json: Boolean(flags.json),
+			force: Boolean(flags.force),
+			gracefulTimeoutMs: flagRec["graceful-timeout-ms"] as number | undefined,
+			killTimeoutMs: flagRec["kill-timeout-ms"] as number | undefined,
+			spawnIfStopped: flagRec["spawn-if-stopped"] as boolean | undefined,
+		};
+
+		await initTheme();
+		await runDaemonCommand(cmd);
+	}
+}

package/src/commands/notify.ts

@@ -0,0 +1,61 @@
+/**
+ * Configure Telegram notifications.
+ */
+import { Args, Command, Flags } from "@gajae-code/utils/cli";
+import { type NotifyAction, type NotifyCommandArgs, runNotifyCommand } from "../cli/notify-cli";
+import { initTheme } from "../modes/theme/theme";
+
+const ACTIONS: NotifyAction[] = ["setup", "status", "daemon-internal"];
+
+export default class Notify extends Command {
+	static description = "Configure Telegram notifications";
+
+	static args = {
+		action: Args.string({
+			description: "Notify action",
+			required: false,
+			options: ACTIONS,
+		}),
+		extra: Args.string({
+			description: "Additional internal args",
+			required: false,
+			multiple: true,
+		}),
+	};
+
+	static flags = {
+		smoke: Flags.boolean({ description: "Run hidden daemon smoke" }),
+		token: Flags.string({ description: "Telegram bot token (non-interactive setup)" }),
+		"chat-id": Flags.string({ description: "Telegram chat id to pair (non-interactive setup)" }),
+		redact: Flags.boolean({ description: "Enable redaction of remote notification content" }),
+		"owner-id": Flags.string({ description: "Internal: daemon owner id" }),
+		"agent-dir": Flags.string({ description: "Internal: agent dir for the daemon" }),
+	};
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(Notify);
+		const action = (args.action ?? "status") as NotifyAction;
+		const extra = Array.isArray(args.extra) ? args.extra : args.extra ? [args.extra] : [];
+		const flagRec = flags as Record<string, unknown>;
+		const ownerId = flagRec["owner-id"] as string | undefined;
+		const agentDir = flagRec["agent-dir"] as string | undefined;
+		const rawArgs = [
+			...(flags.smoke ? ["--smoke"] : []),
+			...(ownerId ? ["--owner-id", ownerId] : []),
+			...(agentDir ? ["--agent-dir", agentDir] : []),
+			...extra,
+		];
+
+		const cmd: NotifyCommandArgs = {
+			action,
+			smoke: flags.smoke,
+			rawArgs,
+			token: flags.token as string | undefined,
+			chatId: (flags as Record<string, unknown>)["chat-id"] as string | undefined,
+			redact: Boolean(flags.redact),
+		};
+
+		await initTheme();
+		await runNotifyCommand(cmd);
+	}
+}

package/src/commands/setup.ts

@@ -5,7 +5,17 @@ import { Args, Command, Flags } from "@gajae-code/utils/cli";
 import { runSetupCommand, type SetupCommandArgs, type SetupComponent } from "../cli/setup-cli";
 import { initTheme } from "../modes/theme/theme";
 
-const COMPONENTS: SetupComponent[] = ["credentials", "defaults", "hermes", "hooks", "provider", "python", "stt"];
+const COMPONENTS: SetupComponent[] = [
+	"claude",
+	"codex",
+	"credentials",
+	"defaults",
+	"hermes",
+	"hooks",
+	"provider",
+	"python",
+	"stt",
+];
 
 export default class Setup extends Command {
 	static description = "Install GJC defaults or optional feature dependencies";

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

@@ -17,6 +17,8 @@ type ModelProfileActivationSession = Pick<AgentSession, "model" | "thinkingLevel
 	setModelTemporary?: AgentSession["setModelTemporary"];
 	setActiveModelProfile?: (name: string | undefined) => void;
 	getActiveModelProfile?: () => string | undefined;
+	getSessionDefaultModelSelector?: () => string | undefined;
+	recordResumeDefaultModel?: (selector: string) => void;
 };
 
 export interface PrepareModelProfileActivationOptions {
@@ -43,10 +45,20 @@ export interface PreparedModelProfileActivation {
 	previousModel: Model<Api> | undefined;
 	previousThinkingLevel: ThinkingLevel | undefined;
 	previousAgentModelOverrides: Record<string, string>;
+	previousModelRoles: Record<string, string>;
 	defaultModel: Model<Api> | undefined;
 	defaultThinkingLevel: ThinkingLevel | undefined;
+	modelRoles: Record<string, string>;
 	agentModelOverrides: Record<string, string>;
 	previousActiveModelProfile: string | undefined;
+	/**
+	 * The session resume default ("provider/id") captured BEFORE activation —
+	 * the model resume would restore prior to this profile. Snapshotted
+	 * separately from `previousModel` (the live runtime model, which may be a
+	 * transient switch) so a failed-activation rollback restores the correct
+	 * resume default without promoting a transient model to it.
+	 */
+	previousSessionDefaultModel: string | undefined;
 }
 
 export function formatModelProfileCredentialError(profileName: string, providers: readonly string[]): string {
@@ -87,14 +99,24 @@ function rewriteSelectorProvider(
 }
 
 function rewriteBindingsProviders(
-	bindings: { defaultSelector?: string; agentModelOverrides: Record<string, string> },
+	bindings: {
+		defaultSelector?: string;
+		modelRoles: Record<string, string>;
+		agentModelOverrides: Record<string, string>;
+	},
 	authenticatedProviders: ReadonlySet<string>,
 	alternativeGroups: readonly (readonly string[])[],
-): { defaultSelector?: string; agentModelOverrides: Record<string, string> } {
+): { defaultSelector?: string; modelRoles: Record<string, string>; agentModelOverrides: Record<string, string> } {
 	return {
 		defaultSelector: bindings.defaultSelector
 			? rewriteSelectorProvider(bindings.defaultSelector, authenticatedProviders, alternativeGroups)
 			: undefined,
+		modelRoles: Object.fromEntries(
+			Object.entries(bindings.modelRoles).map(([role, sel]) => [
+				role,
+				rewriteSelectorProvider(sel, authenticatedProviders, alternativeGroups),
+			]),
+		),
 		agentModelOverrides: Object.fromEntries(
 			Object.entries(bindings.agentModelOverrides).map(([role, sel]) => [
 				role,
@@ -165,6 +187,18 @@ export async function prepareModelProfileActivation(
 		);
 	}
 
+	const modelRoles: Record<string, string> = {};
+	for (const [role, selector] of Object.entries(bindings.modelRoles) as [GjcModelAssignmentTargetId, string][]) {
+		const resolved = resolveModelRoleValue(selector, availableModels, {
+			settings: options.settings as Settings,
+			modelRegistry: options.modelRegistry,
+		});
+		if (!resolved.model) {
+			throw new Error(`Model profile "${options.profileName}" ${role} selector did not resolve: ${selector}`);
+		}
+		modelRoles[role] = formatClampedModelSelector(selector, resolved.model);
+	}
+
 	const agentModelOverrides: Record<string, string> = {};
 	for (const [role, selector] of Object.entries(bindings.agentModelOverrides) as [
 		GjcModelAssignmentTargetId,
@@ -187,10 +221,13 @@ export async function prepareModelProfileActivation(
 		previousModel: options.session.model,
 		previousThinkingLevel: options.session.thinkingLevel,
 		previousAgentModelOverrides: { ...options.settings.get("task.agentModelOverrides") },
+		previousModelRoles: { ...options.settings.get("modelRoles") },
 		defaultModel: resolvedDefault?.model,
 		defaultThinkingLevel: resolvedDefault?.thinkingLevel,
+		modelRoles,
 		agentModelOverrides,
 		previousActiveModelProfile: options.session.getActiveModelProfile?.(),
+		previousSessionDefaultModel: options.session.getSessionDefaultModelSelector?.(),
 	};
 }
 
@@ -201,17 +238,29 @@ export async function applyPreparedModelProfileActivation(
 	const previousModel = prepared.previousModel;
 	const previousThinkingLevel = prepared.previousThinkingLevel;
 	const previousAgentModelOverrides = prepared.previousAgentModelOverrides;
+	const previousModelRoles = prepared.previousModelRoles;
 	const previousPersistedDefault = prepared.settings.get("modelProfile.default");
 	const previousActiveModelProfile = prepared.previousActiveModelProfile;
+	const previousSessionDefaultModel = prepared.previousSessionDefaultModel;
 	let modelChanged = false;
 	let overridesChanged = false;
 	let defaultChanged = false;
+	let modelRolesChanged = false;
 
 	try {
 		if (prepared.defaultModel) {
-			await prepared.session.setModelTemporary(prepared.defaultModel, prepared.defaultThinkingLevel);
+			await prepared.session.setModelTemporary(prepared.defaultModel, prepared.defaultThinkingLevel, {
+				persistAsSessionDefault: true,
+			});
 			modelChanged = true;
 		}
+		if (Object.keys(prepared.modelRoles).length > 0) {
+			prepared.settings.override("modelRoles", {
+				...prepared.settings.get("modelRoles"),
+				...prepared.modelRoles,
+			});
+			modelRolesChanged = true;
+		}
 		if (Object.keys(prepared.agentModelOverrides).length > 0) {
 			prepared.settings.override("task.agentModelOverrides", {
 				...prepared.settings.get("task.agentModelOverrides"),
@@ -229,12 +278,32 @@ export async function applyPreparedModelProfileActivation(
 		if (defaultChanged) {
 			prepared.settings.set("modelProfile.default", previousPersistedDefault);
 		}
+		if (modelRolesChanged) {
+			prepared.settings.override("modelRoles", previousModelRoles);
+		}
 		if (overridesChanged) {
 			prepared.settings.override("task.agentModelOverrides", previousAgentModelOverrides);
 		}
 		prepared.session.setActiveModelProfile?.(previousActiveModelProfile);
-		if (modelChanged && previousModel) {
-			await prepared.session.setModelTemporary(previousModel, previousThinkingLevel);
+		if (modelChanged) {
+			// Runtime rolls back to the pre-activation live model. That model may
+			// itself be a transient retry/fallback/context-promotion/plan switch,
+			// so it is recorded as role:"temporary" (NOT the resume default) to
+			// preserve the issue #849 protection.
+			if (previousModel) {
+				await prepared.session.setModelTemporary(previousModel, previousThinkingLevel);
+			}
+			// The happy path already appended the profile main model as the resume
+			// default (role:"default"). Re-assert the pre-activation resume default
+			// so a failed activation does not poison future resume. Fall back to the
+			// live model only when there was no explicit pre-activation default
+			// (nothing to protect). Append-only — never touches the runtime model.
+			const restoreDefaultSelector =
+				previousSessionDefaultModel ??
+				(previousModel ? `${previousModel.provider}/${previousModel.id}` : undefined);
+			if (restoreDefaultSelector) {
+				prepared.session.recordResumeDefaultModel?.(restoreDefaultSelector);
+			}
 		}
 		throw error;
 	}

package/src/config/model-profiles.ts

@@ -23,7 +23,8 @@ export interface ModelProfileDefinition {
 
 export interface ResolvedProfileBinding {
 	defaultSelector?: string;
-	agentModelOverrides: Partial<Record<Exclude<ModelProfileRole, "default">, string>>;
+	modelRoles: Partial<Record<"vision", string>>;
+	agentModelOverrides: Partial<Record<Exclude<ModelProfileRole, "default" | "vision">, string>>;
 }
 
 function parseModelSelectorProvider(selector: string): string | undefined {
@@ -56,7 +57,7 @@ export function aggregateModelProfileRequiredProviders(
 const profile = (
 	name: string,
 	requiredProviders: string[],
-	modelMapping: Record<ModelProfileRole, string>,
+	modelMapping: Partial<Record<ModelProfileRole, string>>,
 	alternativeProviderGroups?: readonly (readonly string[])[],
 ): ModelProfileDefinition => ({
 	name,
@@ -382,13 +383,15 @@ export function mergeModelProfiles(userProfiles?: ModelsConfig["profiles"]): Map
 }
 
 export function resolveProfileBindings(definition: ModelProfileDefinition): ResolvedProfileBinding {
-	const { default: defaultSelector, executor, architect, planner, critic } = definition.modelMapping;
+	const { default: defaultSelector, vision, executor, architect, planner, critic } = definition.modelMapping;
+	const modelRoles: ResolvedProfileBinding["modelRoles"] = {};
+	if (vision !== undefined) modelRoles.vision = vision;
 	const agentModelOverrides: ResolvedProfileBinding["agentModelOverrides"] = {};
 	if (executor !== undefined) agentModelOverrides.executor = executor;
 	if (architect !== undefined) agentModelOverrides.architect = architect;
 	if (planner !== undefined) agentModelOverrides.planner = planner;
 	if (critic !== undefined) agentModelOverrides.critic = critic;
-	return { defaultSelector, agentModelOverrides };
+	return { defaultSelector, modelRoles, agentModelOverrides };
 }
 
 export function formatAvailableProfileNames(profiles: ReadonlyMap<string, ModelProfileDefinition>): string {