@sayknow-cli/coding-agent 0.3.9 → 0.3.11

package/src/cli/update-cli.ts

@@ -14,10 +14,9 @@ import { installDefaultSkcDefinitions } from "../defaults/skc-defaults";
 import { theme } from "../modes/theme/theme";
 
 const RELEASE_REPO = "jaybeyond/Sayknow_CLI";
-const RELEASE_TAG_PREFIX = "sayknow-v";
-const PACKAGE = "sayknow-cli";
-const SCOPED_CLI_PACKAGE = "@sayknow-cli/coding-agent";
-const NPM_MANAGED_PACKAGES = [PACKAGE, SCOPED_CLI_PACKAGE] as const;
+const PACKAGE = "@sayknow-cli/coding-agent";
+const NPM_WRAPPER_PACKAGE = "sayknow-cli";
+const NPM_MANAGED_PACKAGES = [NPM_WRAPPER_PACKAGE, PACKAGE] as const;
 
 interface ReleaseInfo {
 	tag: string;
@@ -137,79 +136,35 @@ function defaultPackageExists(_packageName: string, packageRoot: string): boolea
 	return fs.existsSync(path.join(packageRoot, "package.json"));
 }
 
-function npmPackageRootForWindowsShim(binPath: string, packageName: string, platform: PathPlatform): string {
+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 packageRootFromNodeModulesPath(
-	binPath: string,
-	packageName: string,
-	platform: PathPlatform,
-): string | undefined {
-	const pathApi = pathApiForPlatform(platform);
-	const packageSegments = packageName.split("/");
-	const parts = pathApi.normalize(binPath).split(pathApi.sep).filter(Boolean);
-	for (let index = 0; index < parts.length; index++) {
-		if (parts[index] !== "node_modules") continue;
-		const packageStart = index + 1;
-		const matched = packageSegments.every((segment, offset) => parts[packageStart + offset] === segment);
-		if (!matched) continue;
-		const prefix = binPath.startsWith(pathApi.sep) ? pathApi.sep : "";
-		return pathApi.join(prefix, ...parts.slice(0, packageStart + packageSegments.length));
-	}
-	return undefined;
-}
-
-function npmPackageRootsForPosixShim(binPath: string, packageName: string): string[] {
-	const pathApi = path.posix;
-	const binDir = pathApi.dirname(binPath);
-	const packageSegments = packageName.split("/");
-	return [
-		pathApi.join(pathApi.dirname(binDir), "lib", "node_modules", ...packageSegments),
-		pathApi.join(binDir, "node_modules", ...packageSegments),
-	];
-}
-
 function resolveNpmManagedTarget(
 	ompPath: string,
 	platform: PathPlatform = process.platform,
 	packageExists: PackageExists = defaultPackageExists,
 ): PackageManagerTarget | undefined {
+	if (platform !== "win32") return undefined;
 	const pathApi = pathApiForPlatform(platform);
-	const basename = pathApi.basename(ompPath, pathApi.extname(ompPath)).toLowerCase();
-	const resolvedPath = tryRealpath(ompPath);
-	const candidatePaths = resolvedPath ? [resolvedPath, ompPath] : [ompPath];
-
-	if (platform === "win32") {
-		const extension = pathApi.extname(ompPath).toLowerCase();
-		if (extension !== ".cmd" && extension !== ".ps1") return undefined;
-		if (basename !== APP_NAME.toLowerCase()) return undefined;
-		for (const packageName of NPM_MANAGED_PACKAGES) {
-			const packageRoot = npmPackageRootForWindowsShim(ompPath, packageName, platform);
-			if (packageExists(packageName, packageRoot)) return { manager: "npm", packageName };
-		}
-		return undefined;
-	}
-
+	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;
+
 	for (const packageName of NPM_MANAGED_PACKAGES) {
-		for (const candidatePath of candidatePaths) {
-			const packageRoot = packageRootFromNodeModulesPath(candidatePath, packageName, platform);
-			if (packageRoot && packageExists(packageName, packageRoot)) return { manager: "npm", packageName };
-		}
-		for (const packageRoot of npmPackageRootsForPosixShim(ompPath, packageName)) {
-			if (packageExists(packageName, packageRoot)) return { manager: "npm", packageName };
-		}
+		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 (bunBinDir && isPathInDirectory(ompPath, bunBinDir)) return "bun";
 	if (resolveNpmManagedTarget(ompPath)) return "npm";
-	return "binary";
+	if (!bunBinDir) return "binary";
+	return isPathInDirectory(ompPath, bunBinDir) ? "bun" : "binary";
 }
 
 export function resolveUpdateMethodForTest(ompPath: string, bunBinDir: string | undefined): "bun" | "npm" | "binary" {
@@ -228,10 +183,16 @@ async function resolveUpdateTarget(): Promise<UpdateTarget> {
 	const ompPath = resolveSkcPath();
 
 	if (ompPath) {
-		if (bunBinDir && isPathInDirectory(ompPath, bunBinDir)) return { method: "bun" };
 		const npmTarget = resolveNpmManagedTarget(ompPath);
 		if (npmTarget) return { method: "npm", packageName: npmTarget.packageName };
-		return { method: "binary", path: ompPath };
+		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 };
 	}
 
 	if (bunBinDir) return { method: "bun" };
@@ -251,7 +212,7 @@ async function getLatestRelease(): Promise<ReleaseInfo> {
 
 	const data = (await response.json()) as { version: string };
 	const version = data.version;
-	const tag = `${RELEASE_TAG_PREFIX}${version}`;
+	const tag = `v${version}`;
 
 	return {
 		tag,
@@ -389,7 +350,7 @@ function formatBinaryInstallInstruction(platform: NodeJS.Platform = process.plat
 function formatManualUpdateInstructions(platform: NodeJS.Platform = process.platform): string {
 	return [
 		`If ${APP_NAME} was installed with Bun, run: bun install -g ${PACKAGE}@latest`,
-		`If ${APP_NAME} was installed with npm, pnpm, or another package manager, run: npm install -g ${PACKAGE}@latest`,
+		`If ${APP_NAME} was installed with npm, pnpm, or another package manager, update it with that same manager.`,
 		formatBinaryInstallInstruction(platform),
 	].join("\n");
 }
@@ -404,7 +365,7 @@ function buildReleaseBinaryUrl(
 	arch: string = process.arch,
 ): string {
 	const binaryName = getBinaryName(platform, arch);
-	const tag = `${RELEASE_TAG_PREFIX}${version}`;
+	const tag = `v${version}`;
 	return `https://github.com/${RELEASE_REPO}/releases/download/${tag}/${binaryName}`;
 }
 

package/src/cli.ts

@@ -146,6 +146,10 @@ export class RootHelpCommand extends Command {
 		default: Flags.boolean({ description: "Persist --mpreset as the default model profile" }),
 		provider: Flags.string({ description: "Provider to use (legacy; prefer --model)" }),
 		"api-key": Flags.string({ description: "API key (defaults to env vars)" }),
+		credential: Flags.string({
+			description:
+				"Stored credential selector: email:<addr>, id:<n>, account:<id>, project:<id>, or provider/email:<addr>",
+		}),
 		"system-prompt": Flags.string({ description: "System prompt (default: coding assistant prompt)" }),
 		"append-system-prompt": Flags.string({ description: "Append text or file contents to the system prompt" }),
 		"allow-home": Flags.boolean({ description: "Allow starting in ~ without auto-switching to a temp dir" }),
@@ -191,6 +195,7 @@ export class RootHelpCommand extends Command {
 		`# Launch in a sibling git worktree\n  ${APP_NAME} --worktree`,
 		`# Use different model (fuzzy matching)\n  ${APP_NAME} --model opus "Help me refactor this code"`,
 		`# Limit model cycling to specific models\n  ${APP_NAME} --models claude-sonnet,claude-haiku,gpt-4o`,
+		`# Pin a stored credential for this session\n  ${APP_NAME} --credential email:me@example.com`,
 		`# Activate a model profile for this session\n  ${APP_NAME} --mpreset codex-medium`,
 		`# Persist a model profile as the default\n  ${APP_NAME} --mpreset opencodego --default`,
 		`# Export a session file to HTML\n  ${APP_NAME} --export ~/.skc/agent/sessions/--path--/session.jsonl`,

package/src/commands/launch.ts

@@ -87,6 +87,10 @@ export default class Index extends Command {
 		"api-key": Flags.string({
 			description: "API key (defaults to env vars)",
 		}),
+		credential: Flags.string({
+			description:
+				"Stored credential selector: email:<addr>, id:<n>, account:<id>, project:<id>, or provider/email:<addr>",
+		}),
 		"system-prompt": Flags.string({
 			description: "System prompt (default: coding assistant prompt)",
 		}),
@@ -181,6 +185,7 @@ export default class Index extends Command {
 		`# Launch in a sibling git worktree\n  ${APP_NAME} --worktree`,
 		`# Use different model (fuzzy matching)\n  ${APP_NAME} --model opus "Help me refactor this code"`,
 		`# Limit model cycling to specific models\n  ${APP_NAME} --models claude-sonnet,claude-haiku,gpt-4o`,
+		`# Pin a stored credential for this session\n  ${APP_NAME} --credential email:me@example.com`,
 		`# Activate a model profile for this session\n  ${APP_NAME} --mpreset codex-medium`,
 		`# Persist a model profile as the default\n  ${APP_NAME} --mpreset opencodego --default`,
 		`# Export a session file to HTML\n  ${APP_NAME} --export ~/.skc/agent/sessions/--path--/session.jsonl`,

package/src/commands/notify.ts

@@ -2,7 +2,7 @@
  * Configure Telegram notifications.
  */
 import { Args, Command, Flags } from "@sayknow-cli/utils/cli";
-import { type NotifyAction, type NotifyCommandArgs, runNotifyCommand } from "../cli/notify-cli";
+import { type NotifyAction, type NotifyCommandArgs, runNotifyCliCommand } from "../cli/notify-cli";
 import { initTheme } from "../modes/theme/theme";
 
 const ACTIONS: NotifyAction[] = ["setup", "status", "daemon-internal"];
@@ -56,6 +56,6 @@ export default class Notify extends Command {
 		};
 
 		if (action !== "daemon-internal") await initTheme();
-		await runNotifyCommand(cmd);
+		await runNotifyCliCommand(cmd);
 	}
 }

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

@@ -1,4 +1,4 @@
-import type { ThinkingLevel } from "@sayknow-cli/agent-core";
+import { ThinkingLevel } from "@sayknow-cli/agent-core";
 import type { Api, Model } from "@sayknow-cli/ai";
 import type { AgentSession } from "../session/agent-session";
 import { formatClampedModelSelector } from "../thinking";
@@ -43,7 +43,10 @@ export interface PrepareModelProfileActivationOptions {
 	settings: Pick<Settings, "get">;
 	profileName: string;
 }
-
+export interface ApplyModelProfileActivationOptions {
+	persistDefault?: boolean;
+	thinkingLevelOverride?: ThinkingLevel;
+}
 export interface PreparedModelProfileActivation {
 	profileName: string;
 	session: ModelProfileActivationSession & { setModelTemporary: AgentSession["setModelTemporary"] };
@@ -351,25 +354,31 @@ export async function prepareModelProfileActivation(
 
 export async function applyPreparedModelProfileActivation(
 	prepared: PreparedModelProfileActivation,
-	options: { persistDefault?: boolean } = {},
+	options: ApplyModelProfileActivationOptions = {},
 ): Promise<void> {
 	const previousModel = prepared.previousModel;
 	const previousThinkingLevel = prepared.previousThinkingLevel;
 	const previousAgentModelOverrides = prepared.previousAgentModelOverrides;
 	const previousModelRoles = prepared.previousModelRoles;
 	const previousPersistedDefault = prepared.settings.get("modelProfile.default");
+	const previousDefaultThinkingLevel = prepared.settings.get("defaultThinkingLevel");
 	const previousActiveModelProfile = prepared.previousActiveModelProfile;
 	const previousSessionDefaultModel = prepared.previousSessionDefaultModel;
 	let modelChanged = false;
 	let overridesChanged = false;
 	let defaultChanged = false;
 	let modelRolesChanged = false;
+	let defaultThinkingChanged = false;
 
 	try {
 		if (prepared.defaultModel) {
-			await prepared.session.setModelTemporary(prepared.defaultModel, prepared.defaultThinkingLevel, {
-				persistAsSessionDefault: true,
-			});
+			await prepared.session.setModelTemporary(
+				prepared.defaultModel,
+				options.thinkingLevelOverride ?? prepared.defaultThinkingLevel,
+				{
+					persistAsSessionDefault: true,
+				},
+			);
 			modelChanged = true;
 		}
 		if (Object.keys(prepared.modelRoles).length > 0) {
@@ -386,6 +395,10 @@ export async function applyPreparedModelProfileActivation(
 		if (options.persistDefault) {
 			prepared.settings.set("modelRoles", {});
 			prepared.settings.set("task.agentModelOverrides", {});
+			if (prepared.defaultThinkingLevel !== undefined && prepared.defaultThinkingLevel !== ThinkingLevel.Inherit) {
+				prepared.settings.set("defaultThinkingLevel", prepared.defaultThinkingLevel);
+				defaultThinkingChanged = true;
+			}
 			prepared.settings.set("modelProfile.default", prepared.profileName);
 			defaultChanged = true;
 			await prepared.settings.flush();
@@ -396,6 +409,9 @@ export async function applyPreparedModelProfileActivation(
 			prepared.settings.set("modelProfile.default", previousPersistedDefault);
 			prepared.settings.set("modelRoles", previousModelRoles);
 			prepared.settings.set("task.agentModelOverrides", previousAgentModelOverrides);
+			if (defaultThinkingChanged) {
+				prepared.settings.set("defaultThinkingLevel", previousDefaultThinkingLevel);
+			}
 		}
 		if (modelRolesChanged) {
 			prepared.settings.override("modelRoles", previousModelRoles);
@@ -430,7 +446,7 @@ export async function applyPreparedModelProfileActivation(
 
 export async function activateModelProfile(
 	options: PrepareModelProfileActivationOptions,
-	applyOptions: { persistDefault?: boolean } = {},
+	applyOptions: ApplyModelProfileActivationOptions = {},
 ): Promise<void> {
 	const prepared = await prepareModelProfileActivation(options);
 	await applyPreparedModelProfileActivation(prepared, applyOptions);

package/src/config/model-registry.ts

@@ -3,6 +3,7 @@ import * as path from "node:path";
 import {
 	type Api,
 	type AssistantMessageEventStream,
+	type AuthCredentialSelector,
 	type CacheRetention,
 	type Context,
 	createModelManager,
@@ -83,7 +84,8 @@ export const MODEL_ROLES: Record<ModelRole, ModelRoleInfo> = {
 };
 
 export const MODEL_ROLE_IDS: ModelRole[] = ["default"];
-
+export const MODEL_PROFILE_NAME_PATTERN = /^[a-z0-9][a-z0-9._-]*$/;
+export const MODEL_PROFILE_NAME_PATTERN_DESCRIPTION = "lowercase letters, numbers, dots, underscores, or hyphens";
 export type SkcModelAssignmentTargetId = "default" | "executor" | "architect" | "planner" | "critic";
 
 export interface SkcModelAssignmentTargetInfo extends ModelRoleInfo {
@@ -922,10 +924,13 @@ function resolveCustomModelReference(modelId: string): Model<Api> | undefined {
 }
 
 function applyStandaloneCustomModelPolicies(model: CustomModelOverlay): CustomModelOverlay {
-	if (model.id !== "gpt-5.4" || model.provider === "github-copilot" || model.contextWindow !== undefined) {
+	if (model.contextWindow !== undefined) {
 		return model;
 	}
-	return { ...model, contextWindow: 1_000_000 };
+	if (model.id === "gpt-5.4" && model.provider !== "github-copilot") {
+		return { ...model, contextWindow: 1_000_000 };
+	}
+	return model;
 }
 
 function finalizeCustomModel(model: CustomModelOverlay, options: CustomModelBuildOptions): Model<Api> {
@@ -1590,10 +1595,7 @@ export class ModelRegistry {
 			const where = first?.path.length ? `/${first.path.map(String).join("/")}` : "root";
 			throw new Error(`Generated models config is invalid at ${where}: ${first?.message ?? "unknown schema error"}`);
 		}
-		await fs.mkdir(path.dirname(this.#modelsConfigFile.path()), { recursive: true });
-		await Bun.write(this.#modelsConfigFile.path(), Bun.YAML.stringify(checkedConfig.data, null, 2));
-		this.#modelsConfigFile.invalidate();
-		this.#reloadStaticModels();
+		await this.#writeCheckedModelsConfig(checkedConfig.data);
 		const modelMapping = { ...definition.model_mapping };
 		const profile: ModelProfileDefinition = {
 			name: normalizedName,
@@ -1604,6 +1606,84 @@ export class ModelRegistry {
 		};
 		return profile;
 	}
+
+	async renameCustomModelProfile(name: string, displayName: string): Promise<ModelProfileDefinition> {
+		const normalizedName = name.trim();
+		const nextDisplayName = displayName.trim();
+		if (!normalizedName) throw new Error("Profile name is required.");
+		if (!nextDisplayName) throw new Error("Profile display name is required.");
+		const { current, profile } = this.#loadCustomProfileForMutation(normalizedName, "rename");
+		const nextProfiles = {
+			...(current.profiles ?? {}),
+			[normalizedName]: {
+				...profile,
+				display_name: nextDisplayName,
+			},
+		};
+		const checkedConfig = ModelsConfigSchema.safeParse({ ...current, profiles: nextProfiles });
+		if (!checkedConfig.success) {
+			const first = checkedConfig.error.issues[0];
+			const where = first?.path.length ? `/${first.path.map(String).join("/")}` : "root";
+			throw new Error(`Generated models config is invalid at ${where}: ${first?.message ?? "unknown schema error"}`);
+		}
+		await this.#writeCheckedModelsConfig(checkedConfig.data);
+		const modelMapping = { ...profile.model_mapping };
+		return {
+			name: normalizedName,
+			displayName: nextDisplayName,
+			requiredProviders: aggregateModelProfileRequiredProviders(profile.required_providers, { modelMapping }),
+			modelMapping,
+			source: "user",
+		};
+	}
+
+	async deleteCustomModelProfile(name: string): Promise<ModelProfileConfig> {
+		const normalizedName = name.trim();
+		if (!normalizedName) throw new Error("Profile name is required.");
+		const { current, profile } = this.#loadCustomProfileForMutation(normalizedName, "delete");
+		const nextProfiles = { ...(current.profiles ?? {}) };
+		delete nextProfiles[normalizedName];
+		const checkedConfig = ModelsConfigSchema.safeParse({
+			...current,
+			profiles: Object.keys(nextProfiles).length > 0 ? nextProfiles : undefined,
+		});
+		if (!checkedConfig.success) {
+			const first = checkedConfig.error.issues[0];
+			const where = first?.path.length ? `/${first.path.map(String).join("/")}` : "root";
+			throw new Error(`Generated models config is invalid at ${where}: ${first?.message ?? "unknown schema error"}`);
+		}
+		await this.#writeCheckedModelsConfig(checkedConfig.data);
+		return profile;
+	}
+
+	#loadCustomProfileForMutation(
+		normalizedName: string,
+		action: "rename" | "delete",
+	): { current: ModelsConfig; profile: ModelProfileConfig } {
+		const loaded = this.#modelsConfigFile.tryLoad();
+		if (loaded.status === "error") {
+			throw new Error(
+				`Cannot ${action} custom model profile because ${this.#modelsConfigFile.path()} is invalid. Fix the existing config before modifying presets.`,
+			);
+		}
+		const current = loaded.value ?? this.#modelsConfigFile.createDefault();
+		const profile = current.profiles?.[normalizedName];
+		if (!profile) {
+			const existing = this.#modelProfiles.get(normalizedName);
+			if (existing && existing.source !== "user") {
+				throw new Error(`Cannot ${action} bundled model profile: ${normalizedName}.`);
+			}
+			throw new Error(`Custom model profile does not exist: ${normalizedName}.`);
+		}
+		return { current, profile };
+	}
+
+	async #writeCheckedModelsConfig(config: ModelsConfig): Promise<void> {
+		await fs.mkdir(path.dirname(this.#modelsConfigFile.path()), { recursive: true });
+		await Bun.write(this.#modelsConfigFile.path(), Bun.YAML.stringify(config, null, 2));
+		this.#modelsConfigFile.invalidate();
+		this.#reloadStaticModels();
+	}
 	applyConfiguredModelBindings(targetSettings: Settings): void {
 		this.#modelBindingsTargetSettings = targetSettings;
 		this.#applyConfiguredModelBindingsToTarget();
@@ -2579,21 +2659,37 @@ export class ModelRegistry {
 	/**
 	 * Get API key for a model.
 	 */
-	async getApiKey(model: Model<Api>, sessionId?: string): Promise<string | undefined> {
+	async getApiKey(
+		model: Model<Api>,
+		sessionId?: string,
+		options: { credentialSelector?: AuthCredentialSelector } = {},
+	): Promise<string | undefined> {
 		if (this.#keylessProviders.has(model.provider) && !this.authStorage.hasAuth(model.provider)) {
 			return kNoAuth;
 		}
-		return this.authStorage.getApiKey(model.provider, sessionId, { baseUrl: model.baseUrl, modelId: model.id });
+		return this.authStorage.getApiKey(model.provider, sessionId, {
+			baseUrl: model.baseUrl,
+			modelId: model.id,
+			credentialSelector: options.credentialSelector,
+		});
 	}
 
 	/**
 	 * Get API key for a provider (e.g., "openai").
 	 */
-	async getApiKeyForProvider(provider: string, sessionId?: string, baseUrl?: string): Promise<string | undefined> {
+	async getApiKeyForProvider(
+		provider: string,
+		sessionId?: string,
+		baseUrl?: string,
+		options: { credentialSelector?: AuthCredentialSelector } = {},
+	): Promise<string | undefined> {
 		if (this.#keylessProviders.has(provider) && !this.authStorage.hasAuth(provider)) {
 			return kNoAuth;
 		}
-		return this.authStorage.getApiKey(provider, sessionId, { baseUrl });
+		return this.authStorage.getApiKey(provider, sessionId, {
+			baseUrl,
+			credentialSelector: options.credentialSelector,
+		});
 	}
 
 	async #peekApiKeyForProvider(provider: string): Promise<string | undefined> {

package/src/config/model-resolver.ts

@@ -3,15 +3,7 @@
  */
 
 import { ThinkingLevel } from "@sayknow-cli/agent-core";
-import {
-	type Api,
-	clampThinkingLevelForModel,
-	DEFAULT_MODEL_PER_PROVIDER,
-	type Effort,
-	type KnownProvider,
-	type Model,
-	modelsAreEqual,
-} from "@sayknow-cli/ai";
+import { type Api, DEFAULT_MODEL_PER_PROVIDER, type KnownProvider, type Model, modelsAreEqual } from "@sayknow-cli/ai";
 import { fuzzyMatch } from "@sayknow-cli/tui";
 import { logger } from "@sayknow-cli/utils";
 import chalk from "chalk";
@@ -1197,7 +1189,7 @@ export async function findInitialModel(options: {
 	isContinuing: boolean;
 	defaultProvider?: string;
 	defaultModelId?: string;
-	defaultThinkingSelector?: Effort;
+	defaultThinkingSelector?: ThinkingLevel;
 	modelRegistry: InitialModelRegistry;
 }): Promise<InitialModelResult> {
 	const {
@@ -1212,7 +1204,7 @@ export async function findInitialModel(options: {
 	} = options;
 
 	let model: Model<Api> | undefined;
-	let thinkingLevel: Effort | undefined;
+	let thinkingLevel: ThinkingLevel | undefined;
 
 	// 1. CLI args take priority
 	if (cliProvider && cliModel) {
@@ -1233,10 +1225,7 @@ export async function findInitialModel(options: {
 				: (scoped.thinkingLevel ?? defaultThinkingSelector);
 		return {
 			model: scoped.model,
-			thinkingLevel:
-				scopedThinkingSelector === ThinkingLevel.Off
-					? ThinkingLevel.Off
-					: clampThinkingLevelForModel(scoped.model, scopedThinkingSelector),
+			thinkingLevel: resolveThinkingLevelForModel(scoped.model, scopedThinkingSelector),
 			fallbackMessage: undefined,
 		};
 	}
@@ -1246,7 +1235,7 @@ export async function findInitialModel(options: {
 		const found = modelRegistry.find(defaultProvider, defaultModelId);
 		if (found) {
 			model = found;
-			thinkingLevel = clampThinkingLevelForModel(found, defaultThinkingSelector);
+			thinkingLevel = resolveThinkingLevelForModel(found, defaultThinkingSelector);
 			return { model, thinkingLevel, fallbackMessage: undefined };
 		}
 	}

package/src/config/settings-schema.ts

@@ -5,6 +5,7 @@ import { EDIT_MODES } from "../utils/edit-mode";
 import { CONFIGURABLE_SEARCH_PROVIDER_IDS } from "../web/search/types";
 
 const THINKING_EFFORTS = ["minimal", "low", "medium", "high", "xhigh", "max"] as readonly Effort[];
+const DEFAULT_THINKING_LEVELS = ["off", ...THINKING_EFFORTS] as const;
 
 import {
 	DEFAULT_DISABLED_EXTENSIONS,
@@ -829,13 +830,13 @@ export const SETTINGS_SCHEMA = {
 	// Reasoning and prompts
 	defaultThinkingLevel: {
 		type: "enum",
-		values: THINKING_EFFORTS,
+		values: DEFAULT_THINKING_LEVELS,
 		default: THINKING_EFFORTS[3],
 		ui: {
 			tab: "model",
 			label: "Thinking Level",
 			description: "Reasoning depth for thinking-capable models",
-			options: [...THINKING_EFFORTS.map(getThinkingLevelMetadata)],
+			options: [...DEFAULT_THINKING_LEVELS.map(getThinkingLevelMetadata)],
 		},
 	},
 

package/src/config/settings.ts

@@ -375,6 +375,25 @@ export class Settings {
 		}
 	}
 
+	/**
+	 * Like {@link flush}, but rejects if the durable save fails instead of
+	 * swallowing the error. Use where the caller must confirm persistence before
+	 * reporting success (e.g. the Telegram `/rich` toggle). In-memory instances
+	 * ({@link isolated}) short-circuit in {@link #saveNow} and never throw.
+	 */
+	async flushOrThrow(): Promise<void> {
+		if (this.#saveTimer) {
+			clearTimeout(this.#saveTimer);
+			this.#saveTimer = undefined;
+		}
+		if (this.#savePromise) {
+			await this.#savePromise;
+		}
+		if (this.#modified.size > 0) {
+			await this.#saveNow({ throwOnError: true });
+		}
+	}
+
 	async cloneForCwd(cwd: string): Promise<Settings> {
 		const cloned = new Settings({
 			cwd,
@@ -818,7 +837,7 @@ export class Settings {
 		}, 100);
 	}
 
-	async #saveNow(): Promise<void> {
+	async #saveNow(options: { throwOnError?: boolean } = {}): Promise<void> {
 		if (!this.#persist || !this.#configPath || this.#modified.size === 0) return;
 
 		const configPath = this.#configPath;
@@ -847,6 +866,10 @@ export class Settings {
 			for (const p of modifiedPaths) {
 				this.#modified.add(p);
 			}
+			if (options.throwOnError) {
+				this.#rebuildMerged();
+				throw error;
+			}
 		}
 
 		this.#rebuildMerged();