@sayknow-cli/coding-agent 0.3.9 → 0.3.11

package/src/notifications/index.ts

@@ -24,11 +24,13 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { promisify } from "node:util";
+import { ThinkingLevel } from "@sayknow-cli/agent-core";
 import type { ImageContent, TextContent } from "@sayknow-cli/ai";
 import { NotificationServer } from "@sayknow-cli/natives";
 import { logger, postmortem } from "@sayknow-cli/utils";
 import { Settings } from "../config/settings";
 import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "../extensibility/extensions";
+import { parseThinkingLevel } from "../thinking";
 import { registerAskAnswerSource } from "../tools/ask-answer-registry";
 import { registerTelegramFileSink } from "./attachment-registry";
 import {
@@ -407,20 +409,18 @@ function streamIntervalMs(): number {
 	return Math.max(200, Number(process.env.SKC_NOTIFICATIONS_STREAM_INTERVAL_MS) || 500);
 }
 // Max chars of a turn's assistant text carried by the FINALIZED turn_stream (and
-// the pre-ask capture). Default 3500 keeps the mirror a glanceable per-turn
-// summary; a client that splits long messages (the Telegram daemon does so via
-// splitTelegramHtml, scheduling each chunk through the shared rate-limit pool so
-// the fan-out never bypasses the per-chat limit) can raise it with
-// SKC_NOTIFICATIONS_TURN_MAX to deliver full turns. The value is clamped to a
-// finite [280, TURN_TEXT_MAX_CEILING] range: a non-finite or non-positive env
-// (unset, NaN, Infinity, <= 0) falls back to the default, so the cap can never
-// be unbounded. Live frames are intentionally NOT raised — they stay one
+// the pre-ask capture). Finalized turns default to the bounded full-turn ceiling
+// because split-capable clients such as the Telegram daemon schedule each
+// splitTelegramHtml chunk through the shared rate-limit pool. Operators who want
+// glanceable summaries can lower this with SKC_NOTIFICATIONS_TURN_MAX. The value
+// is always clamped to a finite [280, TURN_TEXT_MAX_CEILING] range so the cap can
+// never be unbounded. Live frames are intentionally NOT raised — they stay one
 // editable preview message rather than fanning a long in-progress turn across
 // sends.
 const TURN_TEXT_MAX_CEILING = 40_000;
 function turnTextMax(): number {
 	const raw = Number(process.env.SKC_NOTIFICATIONS_TURN_MAX);
-	if (!Number.isFinite(raw) || raw <= 0) return 3500;
+	if (!Number.isFinite(raw) || raw <= 0) return TURN_TEXT_MAX_CEILING;
 	return Math.min(TURN_TEXT_MAX_CEILING, Math.max(280, raw));
 }
 function resolveSettings(settingsOverride?: Settings): ResolvedSettings {
@@ -487,6 +487,121 @@ function mapAnswerToGate(
 	return { selected: [] };
 }
 
+interface NotificationControlCommandPayload {
+	name?: unknown;
+	action?: unknown;
+	level?: unknown;
+	instructions?: unknown;
+}
+
+function parseControlCommandPayload(json: string | undefined): NotificationControlCommandPayload | undefined {
+	if (!json) return undefined;
+	try {
+		const parsed = JSON.parse(json) as unknown;
+		return parsed && typeof parsed === "object" ? (parsed as NotificationControlCommandPayload) : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function formatCompactTokenCount(value: number | null | undefined): string {
+	if (value == null) return "unknown";
+	if (value >= 1_000_000) return `${Number((value / 1_000_000).toFixed(value % 1_000_000 === 0 ? 0 : 1))}m`;
+	if (value >= 1_000) return `${Number((value / 1_000).toFixed(value % 1_000 === 0 ? 0 : 1))}k`;
+	return value.toLocaleString();
+}
+
+function formatContextUsageLine(ctx: ExtensionContext): string {
+	const usage = ctx.getContextUsage();
+	if (!usage) return "Context usage unavailable.";
+	const tokens = formatCompactTokenCount(usage.tokens);
+	const window = formatCompactTokenCount(usage.contextWindow);
+	const pct = usage.percent == null ? "unknown" : `${usage.percent.toFixed(1)}%`;
+	return `Context: ${tokens}/${window} ${pct}`;
+}
+
+function formatLocalUsage(ctx: ExtensionContext): string {
+	const stats = ctx.sessionManager.getUsageStatistics();
+	return [
+		"Usage",
+		`Input tokens: ${stats.input}`,
+		`Output tokens: ${stats.output}`,
+		`Cache read tokens: ${stats.cacheRead}`,
+		`Cache write tokens: ${stats.cacheWrite}`,
+		`Premium requests: ${stats.premiumRequests}`,
+		`Cost: $${stats.cost.toFixed(6)}`,
+	].join("\n");
+}
+
+function cycleTelegramThinking(api: ExtensionAPI): ThinkingLevel | undefined {
+	const levels = [
+		ThinkingLevel.Off,
+		ThinkingLevel.Minimal,
+		ThinkingLevel.Low,
+		ThinkingLevel.Medium,
+		ThinkingLevel.High,
+		ThinkingLevel.XHigh,
+		ThinkingLevel.Max,
+	];
+	const current = api.getThinkingLevel() ?? ThinkingLevel.Off;
+	const currentIndex = levels.indexOf(current as (typeof levels)[number]);
+	const next = levels[(currentIndex + 1) % levels.length];
+	if (!next) return undefined;
+	api.setThinkingLevel(next);
+	return api.getThinkingLevel() ?? next;
+}
+
+export async function executeNotificationControlCommand(
+	command: NotificationControlCommandPayload | undefined,
+	ctx: ExtensionContext,
+	api: ExtensionAPI,
+): Promise<{ status: "ok" | "error" | "unavailable"; message: string }> {
+	if (!command || typeof command.name !== "string") return { status: "error", message: "Invalid control command." };
+	switch (command.name) {
+		case "reasoning": {
+			const current = api.getThinkingLevel() ?? ThinkingLevel.Off;
+			if (command.action === "status") return { status: "ok", message: `Reasoning effort: ${current}` };
+			if (command.action === "cycle") {
+				const next = cycleTelegramThinking(api);
+				return next
+					? { status: "ok", message: `Reasoning effort set to ${next}.` }
+					: { status: "unavailable", message: "Reasoning effort unavailable for this session." };
+			}
+			if (command.action === "set" && typeof command.level === "string") {
+				const parsed = parseThinkingLevel(command.level);
+				if (!parsed) return { status: "error", message: "Invalid reasoning effort." };
+				api.setThinkingLevel(parsed);
+				return { status: "ok", message: `Reasoning effort set to ${api.getThinkingLevel() ?? ThinkingLevel.Off}.` };
+			}
+			return { status: "error", message: "Invalid reasoning command." };
+		}
+		case "usage":
+			return { status: "ok", message: formatLocalUsage(ctx) };
+		case "context":
+			return { status: "ok", message: formatContextUsageLine(ctx) };
+		case "compact": {
+			const before = ctx.getContextUsage()?.tokens;
+			try {
+				await ctx.compact(typeof command.instructions === "string" ? command.instructions : undefined);
+			} catch (err) {
+				return {
+					status: "error",
+					message: `Compaction failed: ${err instanceof Error ? err.message : String(err)}`,
+				};
+			}
+			const after = ctx.getContextUsage()?.tokens;
+			if (before != null && after != null)
+				return {
+					status: "ok",
+					message: `Compaction complete. Tokens: ${before} -> ${after} (saved ${before - after}).`,
+				};
+			return { status: "ok", message: "Compaction complete." };
+		}
+		default:
+			return { status: "error", message: "Unknown control command." };
+	}
+}
+
 /** Register the interactive `ask` answer source for a session (the ask tool
  * races the local UI against a remote reply). Returns the deregister disposer. */
 function registerInteractiveAnswerSource(
@@ -703,6 +818,38 @@ export function createNotificationsExtension(api: ExtensionAPI, options: { setti
 					}
 				}
 			}
+			if (inbound.kind === "control_command") {
+				if (!runtime || !inbound.requestId) return;
+				void executeNotificationControlCommand(parseControlCommandPayload(inbound.commandJson), ctx, api)
+					.then(result => {
+						runtime?.server.pushFrame(
+							JSON.stringify({
+								type: "control_command_result",
+								sessionId: id,
+								requestId: inbound.requestId,
+								updateId: inbound.updateId,
+								status: result.status,
+								message: result.message,
+							}),
+						);
+					})
+					.catch(err => {
+						try {
+							runtime?.server.pushFrame(
+								JSON.stringify({
+									type: "control_command_result",
+									sessionId: id,
+									requestId: inbound.requestId,
+									updateId: inbound.updateId,
+									status: "error",
+									message: `Control command failed: ${err instanceof Error ? err.message : String(err)}`,
+								}),
+							);
+						} catch (pushErr) {
+							logger.warn(`notifications: control_command_result failed: ${String(pushErr)}`);
+						}
+					});
+			}
 		});
 
 		try {

package/src/notifications/rich-render.ts

@@ -49,6 +49,7 @@ export function shouldPromoteRich(input: { enabled?: boolean; send: ThreadedSend
 		send.editable !== true &&
 		typeof send.richMarkdown === "string" &&
 		send.richMarkdown.trim().length > 0 &&
+		send.richMarkdown.length <= RICH_MESSAGE_LIMIT &&
 		typeof send.text === "string" &&
 		send.text.length > 0
 	);

package/src/notifications/telegram-daemon.ts

@@ -9,7 +9,7 @@ import type { Settings } from "../config/settings";
 import type { DaemonRuntimeInfo } from "../daemon/control-types";
 import { resolveSkcRuntimeSpawnInfo } from "../daemon/runtime";
 import { getNotificationConfig, isTelegramConfigured, tokenFingerprint } from "./config";
-import { parseInThreadConfigCommand, parseRichToggleCommand } from "./config-commands";
+import { parseInThreadConfigCommand, parseRichToggleCommand, parseTelegramControlCommand } from "./config-commands";
 import { daemonPaths } from "./daemon-paths";
 import {
 	buildCompactChoiceGrid,
@@ -111,6 +111,21 @@ export const CLIENT_PING_PONG_CAPABILITY = "client_ping_pong";
 export const NOTIFICATION_PROTOCOL_VERSION = 2;
 
 const nodeFs: TelegramDaemonFs = fs.promises as unknown as TelegramDaemonFs;
+
+/**
+ * Durably persist a `/rich` toggle. A real {@link Settings} exposes
+ * `flushOrThrow()`, which rejects on a failed config.yml write (its `set()` is a
+ * fire-and-forget whose background save swallows errors). The lightweight daemon
+ * settings has no `flushOrThrow` — its `set()` already wrote durably and throws
+ * on failure — so its plain `flush()` no-op drain is sufficient.
+ */
+async function flushRichToggleSettings(settings: Settings): Promise<void> {
+	if (typeof settings.flushOrThrow === "function") {
+		await settings.flushOrThrow();
+		return;
+	}
+	await settings.flush();
+}
 const RATE_LIMIT_FLUSH_INTERVAL_MS = 1_000;
 // How often the daemon rescans for newly-started sessions. This MUST run
 // independently of the Telegram getUpdates long-poll (up to 25s): otherwise a
@@ -1550,6 +1565,7 @@ export class TelegramNotificationDaemon {
 		"image_attachment",
 		"file_attachment",
 		"config_update",
+		"control_command_result",
 	]);
 
 	private topicNameFor(sessionId: string, msg: { title?: unknown; repo?: unknown; branch?: unknown }): string {
@@ -1913,7 +1929,7 @@ export class TelegramNotificationDaemon {
 					// upstream edit/send path, so off behavior is byte-identical.
 					if (
 						shouldPromoteRich({
-							enabled: this.opts.rich?.enabled === false ? false : true,
+							enabled: this.opts.rich?.enabled !== false,
 							send,
 						})
 					) {
@@ -2219,16 +2235,22 @@ export class TelegramNotificationDaemon {
 				// Rename the topic if the title changed (e.g. the session title was
 				// auto-generated after the topic was first created). This runs on
 				// every identity frame, but does NOT re-send the bulleted message.
+				// Only commit the new registry name after Telegram accepts the edit:
+				// a transient editForumTopic failure must remain retryable on the
+				// next identity re-assert instead of leaving the remote topic stuck
+				// at the provisional "SKC <id>" name forever.
 				const name = this.topicNameFor(session.sessionId, msg);
-				if (this.topics.applyName(session.sessionId, name)) {
+				if (this.topics.needsRename(session.sessionId, name)) {
 					try {
 						await this.botApi.call("editForumTopic", {
 							chat_id: this.opts.chatId,
 							message_thread_id: Number(topicId),
 							name,
 						});
+						this.topics.markNameApplied(session.sessionId, name);
 					} catch {
-						// Best-effort rename; never block delivery.
+						// Best-effort rename; never block delivery. Leave the old
+						// registry name intact so a later identity frame retries.
 					}
 				}
 				// Send the full bulleted identity header EXACTLY ONCE per topic.
@@ -2415,6 +2437,15 @@ export class TelegramNotificationDaemon {
 				}
 				try {
 					await this.opts.settings.set("notifications.telegram.rich.enabled", desired);
+					// Confirm success only after a DURABLE write. The real Settings.set is
+					// a synchronous fire-and-forget whose queued save (Settings.#saveNow)
+					// swallows write errors, and Settings.flush() inherits that — neither
+					// rejects on a failed config.yml write. flushOrThrow() rethrows the
+					// durable-write failure so it lands in the catch below (in-memory
+					// isolated Settings short-circuit and never throw). The lightweight
+					// daemon settings has no flushOrThrow: its set() already wrote durably
+					// (and throws on failure), so its flush() is only a no-op drain.
+					await flushRichToggleSettings(this.opts.settings);
 				} catch (err) {
 					logger.warn(
 						`notifications: /rich settings write failed (${err instanceof Error ? err.message : String(err)}); runtime unchanged`,
@@ -2468,6 +2499,45 @@ export class TelegramNotificationDaemon {
 					const injectedText = repliedOriginal
 						? `> replied-to message:\n${repliedOriginal}\n\n${baseInjectedText}`
 						: baseInjectedText;
+					const control = hasMedia
+						? { kind: "none" as const }
+						: parseTelegramControlCommand(inbound.text, this.botUsername);
+					if (control.kind !== "none") {
+						await this.rememberSeenUpdateId(inbound.updateId);
+						const sendControlNotice = async (body: string): Promise<void> => {
+							try {
+								await this.botApi.call("sendMessage", {
+									chat_id: this.opts.chatId,
+									message_thread_id: Number(inbound.threadId),
+									text: body,
+									parse_mode: TELEGRAM_PARSE_MODE,
+								});
+							} catch {
+								// Best-effort control feedback; never convert to user input.
+							}
+						};
+						if (control.kind === "ignored") return;
+						if (control.kind === "invalid") {
+							await sendControlNotice(control.usage);
+							return;
+						}
+						if (session?.ws.readyState !== WebSocket.OPEN) {
+							await sendControlNotice("Session control unavailable: session is disconnected.");
+							return;
+						}
+						session.ws.send(
+							JSON.stringify({
+								type: "control_command",
+								sessionId: inbound.sessionId,
+								token: session.token,
+								requestId: `tg:${inbound.updateId}`,
+								updateId: inbound.updateId,
+								threadId: inbound.threadId,
+								command: control.command,
+							}),
+						);
+						return;
+					}
 					const cfg = hasMedia ? undefined : parseInThreadConfigCommand(inbound.text);
 					// A plain (non-config) message while an ask is pending for this session
 					// answers that ask as free-input — instead of starting a new user turn.
@@ -2484,6 +2554,15 @@ export class TelegramNotificationDaemon {
 							}),
 						);
 						await this.rememberSeenUpdateId(inbound.updateId);
+						await this.botApi
+							.call("sendMessage", {
+								chat_id: this.opts.chatId,
+								message_thread_id: Number(inbound.threadId),
+								text: "Received as an answer to the pending ask.",
+							})
+							.catch(error => {
+								logger.warn(`telegram: failed to acknowledge pending ask reply: ${String(error)}`);
+							});
 						if (inbound.messageId !== undefined) await this.setReaction(inbound.messageId, QUEUED_REACTION);
 						return;
 					}
@@ -2548,6 +2627,10 @@ export class TelegramNotificationDaemon {
 					{ command: "lean", description: "Mirror assistant text + tool names only (default)" },
 					{ command: "redact", description: "Toggle redaction of streamed content: /redact <on|off>" },
 					{ command: "rich", description: "Toggle rich Telegram delivery: /rich <on|off>" },
+					{ command: "reasoning", description: "Show or change reasoning effort in this session" },
+					{ command: "usage", description: "Show provider/local usage for this session" },
+					{ command: "context", description: "Show current context usage for this session" },
+					{ command: "compact", description: "Compact this session: /compact [instructions]" },
 					{ command: "session_create", description: "Create a SKC session: path, worktree, or dir [--mpreset]" },
 					{ command: "session_recent", description: "List recent SKC sessions" },
 					{ command: "session_close", description: "Close a SKC-managed session" },

package/src/notifications/threaded-render.ts

@@ -77,6 +77,9 @@ interface ThreadedFrame {
 	// config_update
 	verbosity?: unknown;
 	redact?: unknown;
+	// control_command_result
+	status?: unknown;
+	message?: unknown;
 }
 
 function str(v: unknown): string | undefined {
@@ -218,6 +221,17 @@ export function renderThreadedFrame(frame: ThreadedFrame): ThreadedSend | undefi
 					}
 				: undefined;
 		}
+		case "control_command_result": {
+			const message = str(frame.message);
+			if (!message) return undefined;
+			const status = str(frame.status);
+			const prefix = status === "ok" ? "✅" : status === "unavailable" ? "⚠️" : "❌";
+			return {
+				method: "sendMessage",
+				lane: "idle",
+				text: finalizeTelegramHtml(`${prefix} ${escapeHtml(truncate(message, 1200))}`),
+			};
+		}
 		default:
 			return undefined;
 	}

package/src/notifications/topic-registry.ts

@@ -120,15 +120,16 @@ export class TopicRegistry {
 		return record ? !record.identitySent : true;
 	}
 
-	/**
-	 * Record the topic's applied title. Returns `true` when it changed (so the
-	 * caller should `editForumTopic`), `false` when already current or unknown.
-	 */
-	applyName(sessionId: string, name: string): boolean {
+	/** Whether a known session topic's applied title differs from `name`. */
+	needsRename(sessionId: string, name: string): boolean {
 		const record = this.topics.get(sessionId);
-		if (!record || record.name === name) return false;
-		record.name = name;
-		return true;
+		return record !== undefined && record.name !== name;
+	}
+
+	/** Commit a successfully-applied Telegram topic title. */
+	markNameApplied(sessionId: string, name: string): void {
+		const record = this.topics.get(sessionId);
+		if (record) record.name = name;
 	}
 
 	/** Remove a session topic record after Telegram deletes the topic. */

package/src/prompts/tools/skill-discovery.md

@@ -0,0 +1,13 @@
+Discover project and user runtime skills without loading full skill content.
+
+<instruction>
+- Searches only custom runtime skill locations: project `.skc/skills` and user `~/.skc/skills`.
+- Built-in, bundled, and internal workflow skills are intentionally excluded.
+- Returns thin metadata only: name, description, source scope, path, and use conditions when present.
+- To load a selected skill's full `SKILL.md`, invoke it through the existing `skill` tool with the exact `name` returned here.
+</instruction>
+
+Input:
+- `query` (optional): words to match against skill name, description, source, or use conditions.
+- `source` (optional): `all`, `project`, or `user`.
+- `limit` (optional): maximum results, 1-50.

package/src/runtime-credential-selector.ts

@@ -0,0 +1,35 @@
+import type { AuthCredentialSelector, AuthCredentialSelectorKind } from "@sayknow-cli/ai";
+
+export interface CliCredentialSelector {
+	provider?: string;
+	selector: AuthCredentialSelector;
+	raw: string;
+}
+
+const SELECTOR_KINDS = new Set<AuthCredentialSelectorKind>(["id", "email", "account", "project"]);
+
+function parseSelectorBody(body: string): AuthCredentialSelector | undefined {
+	const separator = body.indexOf(":");
+	if (separator === -1) {
+		if (body.includes("@")) return { kind: "email", value: body };
+		return undefined;
+	}
+	const rawKind = body.slice(0, separator);
+	const value = body.slice(separator + 1).trim();
+	if (!SELECTOR_KINDS.has(rawKind as AuthCredentialSelectorKind) || value.length === 0) return undefined;
+	return { kind: rawKind as AuthCredentialSelectorKind, value };
+}
+
+export function parseCliCredentialSelector(raw: string): CliCredentialSelector {
+	const trimmed = raw.trim();
+	const slash = trimmed.indexOf("/");
+	const provider = slash === -1 ? undefined : trimmed.slice(0, slash).trim();
+	const body = slash === -1 ? trimmed : trimmed.slice(slash + 1).trim();
+	const selector = parseSelectorBody(body);
+	if (!selector || provider === "") {
+		throw new Error(
+			`Invalid --credential selector "${raw}". Use email:name@example.com, id:123, account:<id>, project:<id>, or provider/email:name@example.com.`,
+		);
+	}
+	return { ...(provider ? { provider } : {}), selector, raw };
+}

package/src/sdk.ts

@@ -10,6 +10,7 @@ import {
 } from "@sayknow-cli/agent-core";
 import {
 	type Api,
+	type AuthCredentialSelector,
 	type CredentialDisabledEvent,
 	type Message,
 	type Model,
@@ -40,7 +41,7 @@ import {
 import { type AsyncJob, AsyncJobManager, isBackgroundJobSupportEnabled, jobElapsedMs } from "./async";
 import { loadCapability } from "./capability";
 import { type Rule, ruleCapability, setActiveRules } from "./capability/rule";
-import { ModelRegistry } from "./config/model-registry";
+import { kNoAuth, ModelRegistry } from "./config/model-registry";
 import {
 	defaultModelPerProvider,
 	formatModelString,
@@ -274,6 +275,8 @@ export interface CreateAgentSessionOptions {
 	/** Optional provider-facing session identifier for prompt caches and sticky auth selection.
 	 * Keeps persisted session files isolated while reusing provider-side caches. */
 	providerSessionId?: string;
+	/** Runtime credential selector for multi-account auth pools. */
+	credentialSelector?: { provider?: string; selector: AuthCredentialSelector; raw: string };
 
 	/** Custom tools to register (in addition to built-in tools). Accepts both CustomTool and ToolDefinition. */
 	customTools?: (CustomTool | ToolDefinition)[];
@@ -905,10 +908,22 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			startupCredentialDisabledEvents.push(event);
 		}
 	});
+	let runtimeCredentialSelectorInstalled = false;
+	const installRuntimeCredentialSelector = (provider: string): void => {
+		if (!options.credentialSelector || runtimeCredentialSelectorInstalled) return;
+		authStorage.setRuntimeCredentialSelector(provider, options.credentialSelector.selector);
+		runtimeCredentialSelectorInstalled = true;
+	};
+	const earlyCredentialSelectorProvider = options.credentialSelector?.provider ?? options.model?.provider;
+	if (earlyCredentialSelectorProvider) {
+		installRuntimeCredentialSelector(earlyCredentialSelectorProvider);
+	}
 	const settings = options.settings ?? (await logger.time("settings", Settings.init, { cwd, agentDir }));
 	modelRegistry.applyConfiguredModelBindings(settings);
 	logger.time("initializeWithSettings", initializeWithSettings, settings);
-	if (!options.modelRegistry) {
+	const canRefreshModelsBeforeCredentialSelector =
+		!options.credentialSelector || runtimeCredentialSelectorInstalled || options.modelRegistry !== undefined;
+	if (!options.modelRegistry && canRefreshModelsBeforeCredentialSelector) {
 		modelRegistry.refreshInBackground();
 	}
 	// Kick off workspace tree discovery early. The native workspace scan returns
@@ -974,7 +989,29 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			return cached;
 		}
 
-		const hasKey = !!(await modelRegistry.getApiKey(candidate, providerSessionId));
+		const credentialSelector =
+			options.credentialSelector && !runtimeCredentialSelectorInstalled
+				? options.credentialSelector.provider === undefined ||
+					options.credentialSelector.provider === candidate.provider
+					? options.credentialSelector.selector
+					: undefined
+				: undefined;
+		if (options.credentialSelector?.provider && options.credentialSelector.provider !== candidate.provider) {
+			modelApiKeyAvailability.set(availabilityKey, false);
+			return false;
+		}
+		const key = await modelRegistry.getApiKey(candidate, providerSessionId, { credentialSelector }).catch(error => {
+			if (credentialSelector) {
+				logger.debug("Credential selector did not match model availability candidate", {
+					provider: candidate.provider,
+					model: candidate.id,
+					error: error instanceof Error ? error.message : String(error),
+				});
+				return undefined;
+			}
+			throw error;
+		});
+		const hasKey = Boolean(key) && (!credentialSelector || key !== kNoAuth);
 		modelApiKeyAvailability.set(availabilityKey, hasKey);
 		return hasKey;
 	};
@@ -1049,6 +1086,8 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	const taskDepth = options.taskDepth ?? 0;
 
 	let thinkingLevel = options.thinkingLevel;
+	const hasExplicitDefaultThinkingLevel = settings.has("defaultThinkingLevel");
+	let thinkingLevelFromSchemaDefault = false;
 
 	// If session has data and includes a thinking entry, restore it
 	if (thinkingLevel === undefined && hasExistingSession && hasThinkingEntry) {
@@ -1059,13 +1098,20 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		thinkingLevel = defaultRoleSpec.thinkingLevel;
 	}
 
-	// Prefer the selected model's configured defaultLevel, otherwise fall back
-	// to the global settings default.
+	// An explicit user/project default should win over the model's bundled
+	// defaultLevel. The schema default is only a final fallback so model metadata
+	// can keep driving first-run behavior until the user chooses "Set as default".
+	if (thinkingLevel === undefined && hasExplicitDefaultThinkingLevel) {
+		thinkingLevel = settings.get("defaultThinkingLevel");
+	}
+
 	if (thinkingLevel === undefined && model?.thinking?.defaultLevel !== undefined) {
 		thinkingLevel = model.thinking.defaultLevel;
 	}
+
 	if (thinkingLevel === undefined) {
 		thinkingLevel = settings.get("defaultThinkingLevel");
+		thinkingLevelFromSchemaDefault = true;
 	}
 	if (model) {
 		const resolvedModel = model;
@@ -1610,6 +1656,11 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			if (resolved) {
 				model = resolved;
 				modelFallbackMessage = undefined;
+				if (thinkingLevelFromSchemaDefault && resolved.thinking?.defaultLevel !== undefined) {
+					thinkingLevel = resolved.thinking.defaultLevel;
+					thinkingLevelFromSchemaDefault = false;
+				}
+				thinkingLevel = resolveThinkingLevelForModel(resolved, thinkingLevel);
 			} else {
 				modelFallbackMessage = `Model "${options.modelPattern}" not found`;
 			}
@@ -1662,6 +1713,18 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			}
 		}
 
+		if (options.credentialSelector && !runtimeCredentialSelectorInstalled) {
+			const credentialProvider = options.credentialSelector.provider ?? model?.provider;
+			if (!credentialProvider) {
+				throw new Error(
+					`--credential ${options.credentialSelector.raw} requires a resolved model or an explicit provider prefix`,
+				);
+			}
+			installRuntimeCredentialSelector(credentialProvider);
+			if (!options.modelRegistry && !canRefreshModelsBeforeCredentialSelector) {
+				modelRegistry.refreshInBackground();
+			}
+		}
 		const customCommandsResult: CustomCommandsLoadResult = { commands: [], errors: [] };
 
 		let extensionRunner: ExtensionRunner | undefined;