@sayknow-cli/coding-agent 0.4.6 → 0.5.0

package/src/commit/map-reduce/index.ts

@@ -1,6 +1,6 @@
 import type { ThinkingLevel } from "@sayknow-cli/agent-core";
 import type { Api, Model } from "@sayknow-cli/ai";
-import { $env } from "@sayknow-cli/utils";
+import { $pickenv } from "@sayknow-cli/utils";
 import { parseFileDiffs } from "../../commit/git/diff";
 import type { ConventionalAnalysis } from "../../commit/types";
 import { isExcludedFile } from "../../commit/utils/exclusions";
@@ -34,7 +34,7 @@ export interface MapReduceInput {
 }
 
 export function shouldUseMapReduce(diff: string, settings?: MapReduceSettings): boolean {
-	if ($env.PI_COMMIT_MAP_REDUCE?.toLowerCase() === "false") return false;
+	if ($pickenv("SKC_COMMIT_MAP_REDUCE", "PI_COMMIT_MAP_REDUCE")?.toLowerCase() === "false") return false;
 	if (settings?.enabled === false) return false;
 	const minFiles = settings?.minFiles ?? MIN_FILES_FOR_MAP_REDUCE;
 	const maxFileTokens = settings?.maxFileTokens ?? MAX_FILE_TOKENS;

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-contract.ts

@@ -0,0 +1,174 @@
+import { formatModelProfileDisplayLabel, type ModelProfileDefinition } from "./model-profiles";
+
+export const MODEL_PROFILE_DISCOVERY_QUERY = "models.profiles.list";
+export const MODEL_PROFILE_ERROR_DETAIL_MAX_BYTES = 2048;
+const REQUESTED_PROFILE_MAX_BYTES = 256;
+
+const LEGACY_MODEL_PROFILE_ALIASES: ReadonlyMap<string, string> = new Map([["codex-standard", "codex-medium"]]);
+
+export interface ModelProfileCatalogItem {
+	id: string;
+	displayName: string;
+	source: "builtin" | "configured";
+	available?: boolean;
+}
+
+export interface UnknownModelProfileDetails {
+	requestedProfile: string;
+	availableProfiles: string[];
+	discoveryQuery: typeof MODEL_PROFILE_DISCOVERY_QUERY;
+}
+
+export interface ModelProfileRegistryErrorDetails {
+	requestedProfile?: string;
+	availableProfiles: [];
+	discoveryQuery: typeof MODEL_PROFILE_DISCOVERY_QUERY;
+}
+
+export type ModelProfileErrorDetails = UnknownModelProfileDetails | ModelProfileRegistryErrorDetails;
+export type ModelProfileErrorCode = "unknown_model_profile" | "model_profile_registry_error";
+
+function truncateUtf8(value: string, maxBytes: number): string {
+	if (Buffer.byteLength(value) <= maxBytes) return value;
+	let end = value.length;
+	while (end > 0 && Buffer.byteLength(value.slice(0, end)) > maxBytes) end--;
+	return value.slice(0, end);
+}
+
+function diagnosticProfileEcho(value: string): string {
+	return truncateUtf8(value.normalize("NFKC").replace(/[\p{Cc}\p{Cf}]+/gu, " "), REQUESTED_PROFILE_MAX_BYTES);
+}
+
+function boundedAvailableProfiles(requestedProfile: string, profiles: ReadonlyMap<string, unknown>): string[] {
+	const availableProfiles: string[] = [];
+	for (const id of [...new Set(profiles.keys())].sort((left, right) => left.localeCompare(right))) {
+		const candidate: UnknownModelProfileDetails = {
+			requestedProfile,
+			availableProfiles: [...availableProfiles, id],
+			discoveryQuery: MODEL_PROFILE_DISCOVERY_QUERY,
+		};
+		if (Buffer.byteLength(JSON.stringify(candidate)) > MODEL_PROFILE_ERROR_DETAIL_MAX_BYTES) continue;
+		availableProfiles.push(id);
+	}
+	return availableProfiles;
+}
+
+export class UnknownModelProfileError extends Error {
+	readonly code = "unknown_model_profile" as const;
+	readonly details: UnknownModelProfileDetails;
+
+	constructor(requestedProfile: string, profiles: ReadonlyMap<string, unknown>) {
+		const echoed = diagnosticProfileEcho(requestedProfile);
+		const availableProfiles = boundedAvailableProfiles(echoed, profiles);
+		const available = availableProfiles.length > 0 ? availableProfiles.join(", ") : "none";
+		super(
+			truncateUtf8(
+				`Unknown model profile ${JSON.stringify(echoed)}. Available profiles: ${available}. Query ${MODEL_PROFILE_DISCOVERY_QUERY} for the complete catalog.`,
+				512,
+			),
+		);
+		this.name = "UnknownModelProfileError";
+		this.details = {
+			requestedProfile: echoed,
+			availableProfiles,
+			discoveryQuery: MODEL_PROFILE_DISCOVERY_QUERY,
+		};
+	}
+}
+
+export class ModelProfileRegistryError extends Error {
+	readonly code = "model_profile_registry_error" as const;
+	readonly details: ModelProfileRegistryErrorDetails;
+
+	constructor(requestedProfile?: string) {
+		super(
+			`The model profile registry is unavailable. Query ${MODEL_PROFILE_DISCOVERY_QUERY} after fixing models.yml.`,
+		);
+		this.name = "ModelProfileRegistryError";
+		const echoed = requestedProfile === undefined ? undefined : diagnosticProfileEcho(requestedProfile);
+		this.details = {
+			...(echoed ? { requestedProfile: echoed } : {}),
+			availableProfiles: [],
+			discoveryQuery: MODEL_PROFILE_DISCOVERY_QUERY,
+		};
+	}
+}
+
+export function resolveModelProfileName(profileName: string, profiles: ReadonlyMap<string, unknown>): string {
+	if (profiles.has(profileName)) return profileName;
+	const replacement = LEGACY_MODEL_PROFILE_ALIASES.get(profileName);
+	return replacement && profiles.has(replacement) ? replacement : profileName;
+}
+
+export function validateModelProfileName(
+	profileName: string,
+	profiles: ReadonlyMap<string, unknown>,
+	registryError?: unknown,
+): string {
+	if (registryError !== undefined) throw new ModelProfileRegistryError(profileName);
+	const resolved = resolveModelProfileName(profileName, profiles);
+	if (!profiles.has(resolved)) throw new UnknownModelProfileError(profileName, profiles);
+	return resolved;
+}
+
+export function projectModelProfileCatalog(
+	profiles: ReadonlyMap<string, ModelProfileDefinition>,
+	registryError?: unknown,
+): ModelProfileCatalogItem[] {
+	if (registryError !== undefined) throw new ModelProfileRegistryError();
+	return [...profiles.entries()]
+		.map(([id, definition]) => ({
+			id,
+			displayName: formatModelProfileDisplayLabel(definition),
+			source: definition.source === "user" ? ("configured" as const) : ("builtin" as const),
+		}))
+		.sort((left, right) => left.id.localeCompare(right.id));
+}
+
+export function isModelProfileProviderAvailable(
+	profile: ModelProfileDefinition,
+	authenticatedProviders: ReadonlySet<string>,
+): boolean {
+	const alternativeGroups = profile.alternativeProviderGroups ?? [];
+	const alternativeProviders = new Set(alternativeGroups.flat());
+	for (const provider of profile.requiredProviders) {
+		if (!alternativeProviders.has(provider) && !authenticatedProviders.has(provider)) return false;
+	}
+	return alternativeGroups.every(group => group.some(provider => authenticatedProviders.has(provider)));
+}
+
+export function isModelProfileError(value: unknown): value is {
+	code: ModelProfileErrorCode;
+	message: string;
+	details: ModelProfileErrorDetails;
+} {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	const error = value as Record<string, unknown>;
+	if (
+		(error.code !== "unknown_model_profile" && error.code !== "model_profile_registry_error") ||
+		typeof error.message !== "string" ||
+		!error.details ||
+		typeof error.details !== "object" ||
+		Array.isArray(error.details)
+	)
+		return false;
+	const details = error.details as Record<string, unknown>;
+	const detailKeys = Object.keys(details);
+	if (
+		!detailKeys.every(key => key === "requestedProfile" || key === "availableProfiles" || key === "discoveryQuery") ||
+		details.discoveryQuery !== MODEL_PROFILE_DISCOVERY_QUERY ||
+		!Array.isArray(details.availableProfiles) ||
+		!details.availableProfiles.every(id => typeof id === "string") ||
+		Buffer.byteLength(JSON.stringify(details)) > MODEL_PROFILE_ERROR_DETAIL_MAX_BYTES ||
+		(typeof details.requestedProfile === "string" &&
+			Buffer.byteLength(details.requestedProfile) > REQUESTED_PROFILE_MAX_BYTES)
+	)
+		return false;
+	if (error.code === "unknown_model_profile")
+		return detailKeys.length === 3 && typeof details.requestedProfile === "string";
+	return (
+		detailKeys.length === (details.requestedProfile === undefined ? 2 : 3) &&
+		details.availableProfiles.length === 0 &&
+		(details.requestedProfile === undefined || typeof details.requestedProfile === "string")
+	);
+}

package/src/config/model-profiles.ts

@@ -1,9 +1,8 @@
 import { sanitizeText } from "@sayknow-cli/utils";
-import type { SkcModelAssignmentTargetId } from "./model-registry";
 import { type ModelSelectorValue, normalizeModelSelectorValue } from "./model-selector-value";
-import type { ModelsConfig } from "./models-config-schema";
+import type { ModelsConfig, SKC_MODEL_ASSIGNMENT_TARGET_IDS } from "./models-config-schema";
 
-export type ModelProfileRole = SkcModelAssignmentTargetId;
+export type ModelProfileRole = (typeof SKC_MODEL_ASSIGNMENT_TARGET_IDS)[number];
 
 export interface ModelProfileDefinition {
 	name: string;
@@ -101,11 +100,11 @@ export const BUILTIN_MODEL_PROFILES: readonly ModelProfileDefinition[] = [
 		architect: "opencode-go/deepseek-v4-pro",
 	}),
 	profile("claude-opus", ["anthropic"], {
-		default: "anthropic/claude-opus-4-8:xhigh",
+		default: "anthropic/claude-opus-5:xhigh",
 		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",
+		planner: "anthropic/claude-opus-5:low",
+		critic: "anthropic/claude-opus-5:high",
+		architect: "anthropic/claude-opus-5:xhigh",
 	}),
 	profile("claude-fable", ["anthropic"], {
 		default: "anthropic/claude-fable-5:xhigh",
@@ -208,6 +207,27 @@ export const BUILTIN_MODEL_PROFILES: readonly ModelProfileDefinition[] = [
 		critic: "xai/grok-4.3:xhigh",
 		architect: "xai/grok-4.3:xhigh",
 	}),
+	profile("grok-45-eco", ["xai"], {
+		default: "xai/grok-4.5:low",
+		executor: "xai/grok-4.5:minimal",
+		planner: "xai/grok-4.5:low",
+		critic: "xai/grok-4.5:medium",
+		architect: "xai/grok-4.5:high",
+	}),
+	profile("grok-45-medium", ["xai"], {
+		default: "xai/grok-4.5:medium",
+		executor: "xai/grok-4.5:low",
+		planner: "xai/grok-4.5:medium",
+		critic: "xai/grok-4.5:high",
+		architect: "xai/grok-4.5:high",
+	}),
+	profile("grok-45-pro", ["xai"], {
+		default: "xai/grok-4.5:high",
+		executor: "xai/grok-4.5:medium",
+		planner: "xai/grok-4.5:high",
+		critic: "xai/grok-4.5:high",
+		architect: "xai/grok-4.5:high",
+	}),
 	profile("grok-build-pro", ["grok-build"], {
 		default: "grok-build/grok-composer-2.5-fast",
 		executor: "grok-build/grok-build",
@@ -257,8 +277,22 @@ export const BUILTIN_MODEL_PROFILES: readonly ModelProfileDefinition[] = [
 		critic: "minimax-code/minimax-m3:xhigh",
 		architect: "minimax-code/minimax-m3:xhigh",
 	}),
+	profile("alibaba-token-plan-balanced", ["alibaba-token-plan"], {
+		default: "alibaba-token-plan/qwen3.8-max-preview:medium",
+		executor: "alibaba-token-plan/deepseek-v4-pro:xhigh",
+		planner: "alibaba-token-plan/glm-5.2:high",
+		architect: "alibaba-token-plan/qwen3.8-max-preview:xhigh",
+		critic: "alibaba-token-plan/glm-5.2:high",
+	}),
+	profile("alibaba-token-plan-qwenmaxxing", ["alibaba-token-plan"], {
+		default: "alibaba-token-plan/qwen3.8-max-preview:medium",
+		executor: "alibaba-token-plan/qwen3.8-max-preview:low",
+		planner: "alibaba-token-plan/qwen3.8-max-preview:medium",
+		architect: "alibaba-token-plan/qwen3.8-max-preview:xhigh",
+		critic: "alibaba-token-plan/qwen3.8-max-preview:xhigh",
+	}),
 	profile("opus-codex", ["anthropic", "openai-codex"], {
-		default: "anthropic/claude-opus-4-8:xhigh",
+		default: "anthropic/claude-opus-5:xhigh",
 		executor: "openai-codex/gpt-5.6-terra:low",
 		planner: "anthropic/claude-sonnet-5",
 		critic: "openai-codex/gpt-5.6-sol:xhigh",
@@ -274,8 +308,8 @@ export const BUILTIN_MODEL_PROFILES: readonly ModelProfileDefinition[] = [
 	profile("fable-opus-codex", ["anthropic", "openai-codex"], {
 		default: "anthropic/claude-fable-5:high",
 		executor: "openai-codex/gpt-5.6-terra:medium",
-		planner: "anthropic/claude-opus-4-8:medium",
-		critic: "anthropic/claude-opus-4-8:high",
+		planner: "anthropic/claude-opus-5:medium",
+		critic: "anthropic/claude-opus-5:high",
 		architect: "openai-codex/gpt-5.6-sol:xhigh",
 	}),
 ];
@@ -308,6 +342,9 @@ const PROFILE_PRESENTATION: Record<string, ModelProfilePresentation> = {
 	"grok-eco": { displayName: "Grok Eco", providerGroup: "GROK" },
 	"grok-medium": { displayName: "Grok Medium", providerGroup: "GROK" },
 	"grok-pro": { displayName: "Grok Pro", providerGroup: "GROK" },
+	"grok-45-eco": { displayName: "Grok 4.5 Eco", providerGroup: "GROK" },
+	"grok-45-medium": { displayName: "Grok 4.5 Medium", providerGroup: "GROK" },
+	"grok-45-pro": { displayName: "Grok 4.5 Pro", providerGroup: "GROK" },
 	"grok-build-pro": { displayName: "Grok Build Pro", providerGroup: "GROK" },
 	"cursor-eco": { displayName: "Cursor Eco", providerGroup: "CURSOR" },
 	"cursor-medium": { displayName: "Cursor Medium", providerGroup: "CURSOR" },
@@ -315,6 +352,8 @@ const PROFILE_PRESENTATION: Record<string, ModelProfilePresentation> = {
 	"minimax-eco": { displayName: "MiniMax Eco", providerGroup: "MINIMAX" },
 	"minimax-medium": { displayName: "MiniMax Medium", providerGroup: "MINIMAX" },
 	"minimax-pro": { displayName: "MiniMax Pro", providerGroup: "MINIMAX" },
+	"alibaba-token-plan-balanced": { displayName: "Balanced", providerGroup: "ALIBABA TOKEN PLAN" },
+	"alibaba-token-plan-qwenmaxxing": { displayName: "QwenMaxxing", providerGroup: "ALIBABA TOKEN PLAN" },
 	"opus-codex": { displayName: "Opus + Codex", providerGroup: "COMBOS" },
 	"codex-opencodego": { displayName: "Codex + OpenCodeGo", providerGroup: "COMBOS" },
 	"fable-opus-codex": { displayName: "Fable + Opus + Codex", providerGroup: "COMBOS" },
@@ -330,6 +369,7 @@ const PROFILE_GROUP_ORDER = [
 	"GROK",
 	"CURSOR",
 	"MINIMAX",
+	"ALIBABA TOKEN PLAN",
 	"COMBOS",
 ];
 
@@ -347,6 +387,7 @@ const PROFILE_RECOMMENDATIONS: Record<string, string> = {
 	"grok-build": "grok-build-pro",
 	cursor: "cursor-medium",
 	"minimax-code": "minimax-medium",
+	"alibaba-token-plan": "alibaba-token-plan-balanced",
 };
 
 export function getModelProfilePresentation(

package/src/config/model-registry.ts

@@ -33,7 +33,7 @@ const DEFAULT_LOCAL_TOKEN = "lm-studio-local";
 
 import { registerOAuthProvider, unregisterOAuthProviders } from "@sayknow-cli/ai/utils/oauth";
 import type { OAuthCredentials, OAuthLoginCallbacks } from "@sayknow-cli/ai/utils/oauth/types";
-import { $pickenv, isRecord, logger } from "@sayknow-cli/utils";
+import { $pickCredentialEnv, isRecord, logger } from "@sayknow-cli/utils";
 import { parseModelString, resolveProviderModelReference } from "../config/model-resolver";
 import { isValidThemeColor, type ThemeColor } from "../modes/theme/theme";
 import type { AuthStorage, OAuthCredential } from "../session/auth-storage";
@@ -52,6 +52,7 @@ import {
 	type ModelProfileDefinition,
 	mergeModelProfiles,
 } from "./model-profiles";
+import type { ModelSelectorValue } from "./model-selector-value";
 import {
 	type ModelOverride,
 	type ModelProfileConfig,
@@ -61,7 +62,6 @@ import {
 	type ProviderAuthMode,
 	type ProviderDiscovery,
 } from "./models-config-schema";
-import { type ModelSelectorValue } from "./model-selector-value";
 import { type Settings, settings } from "./settings";
 
 export type { CanonicalModelIndex, CanonicalModelRecord, CanonicalModelVariant, ModelEquivalenceConfig };
@@ -438,8 +438,20 @@ function getProviderBaseUrlEnvKeys(provider: string): string[] {
 	return keys;
 }
 
+/**
+ * Provider base URL from the environment, trusted sources only.
+ *
+ * The result is baked into the provider override and reaches `model.baseUrl`,
+ * which the provider resolvers use as the request endpoint that carries the
+ * provider credential. `$env` (and therefore `$pickenv`) merges the caller's
+ * `cwd/.env`, so reading it there would let repository content redirect
+ * authenticated traffic for any provider — including re-admitting a redirect
+ * that the provider-level resolvers already reject. Resolve it the same way
+ * provider credentials are: launching shell plus SKC/user-owned `.env` files,
+ * never the project `.env`.
+ */
 function resolveProviderBaseUrlFromEnv(provider: string): string | undefined {
-	return $pickenv(...getProviderBaseUrlEnvKeys(provider));
+	return $pickCredentialEnv(...getProviderBaseUrlEnvKeys(provider));
 }
 
 function normalizeLocalOpenAICompatBaseUrl(baseUrl: string): string {
@@ -2613,6 +2625,13 @@ export class ModelRegistry {
 		return this.#keylessProviders.has(model.provider) || this.authStorage.hasAuth(model.provider);
 	}
 
+	/**
+	 * Check whether auth is configured for a provider.
+	 */
+	hasConfiguredProviderAuth(provider: string): boolean {
+		return this.#keylessProviders.has(provider) || this.authStorage.hasAuth(provider);
+	}
+
 	getDiscoverableProviders(): string[] {
 		const disabledProviders = getDisabledProviderIdsFromSettings();
 		return this.#discoverableProviders
@@ -2663,7 +2682,7 @@ export class ModelRegistry {
 	async getApiKey(
 		model: Model<Api>,
 		sessionId?: string,
-		options: { credentialSelector?: AuthCredentialSelector } = {},
+		options: { credentialSelector?: AuthCredentialSelector; signal?: AbortSignal } = {},
 	): Promise<string | undefined> {
 		if (this.#keylessProviders.has(model.provider) && !this.authStorage.hasAuth(model.provider)) {
 			return kNoAuth;
@@ -2672,6 +2691,7 @@ export class ModelRegistry {
 			baseUrl: model.baseUrl,
 			modelId: model.id,
 			credentialSelector: options.credentialSelector,
+			signal: options.signal,
 		});
 	}
 

package/src/config/model-resolver.ts

@@ -355,7 +355,7 @@ function findExactCanonicalModelMatch(
 	modelReference: string,
 	availableModels: Model<Api>[],
 	modelRegistry: CanonicalModelRegistry | undefined,
-	sessionId?: string,
+	_sessionId?: string,
 ): Model<Api> | undefined {
 	if (!modelRegistry) {
 		return undefined;
@@ -378,7 +378,7 @@ function findExactEquivalentModelMatch(
 	modelReference: string,
 	availableModels: Model<Api>[],
 	modelRegistry: CanonicalModelRegistry | undefined,
-	sessionId?: string,
+	_sessionId?: string,
 ): Model<Api> | undefined {
 	if (!modelRegistry?.getCanonicalId || !modelRegistry.resolveCanonicalModel) return undefined;
 	const trimmedReference = modelReference.trim();