@sayknow-cli/coding-agent 0.5.25 → 0.5.26

package/src/modes/components/model-selector.ts

@@ -35,6 +35,7 @@ import type { ModelProfileConfig } from "../../config/models-config-schema";
 import { getProviderAuthHealth } from "../../config/provider-auth-health";
 import { compareRankedProviders, type ProviderAuthState } from "../../config/provider-ranking";
 import type { Settings } from "../../config/settings";
+import { specialtiesForRole, type TaskModelSpecialty } from "../../config/task-model-specialties";
 import { t } from "../../i18n";
 import { type ThemeColor, theme } from "../../modes/theme/theme";
 import { formatModelOnboardingInlineHint } from "../../setup/model-onboarding-guidance";
@@ -111,6 +112,18 @@ export type ModelSelectorSelection =
 			profileName: string;
 			setDefault: boolean;
 	  }
+	| {
+			kind: "specialtyAssignment";
+			model: Model;
+			role: SkcModelAssignmentTargetId;
+			specialty: TaskModelSpecialty;
+			thinkingLevel?: ThinkingLevel;
+			selector?: string;
+	  }
+	| {
+			kind: "specialtyReset";
+			role: SkcModelAssignmentTargetId;
+	  }
 	| {
 			kind: "createProfile";
 			profile: ModelProfileConfig;
@@ -127,6 +140,34 @@ interface PendingThinkingChoice {
 	levels: ThinkingLevel[];
 }
 
+/** Role agents only — the bulk action that deliberately excludes `default`. */
+const ROLE_AGENT_TARGET_IDS = ["executor", "architect", "planner", "critic"] as const;
+
+/**
+ * A first-level row. Stable descriptors, never positions.
+ *
+ * `scope` distinguishes the two bulk rows rather than a boolean, because the
+ * difference between them is which targets they write, not a degree of anything.
+ */
+type ModelSelectorAction =
+	| { kind: "role"; role: SkcModelAssignmentTargetId }
+	| {
+			kind: "bulk";
+			roles: readonly SkcModelAssignmentTargetId[];
+			scope: "roleAgents" | "allTargets";
+	  };
+
+/** A second-level row under one canonical role. */
+type ModelSelectorDetailAction =
+	| { kind: "roleGeneral"; role: SkcModelAssignmentTargetId }
+	| { kind: "specialty"; role: SkcModelAssignmentTargetId; specialty: TaskModelSpecialty }
+	| { kind: "resetSpecialties"; role: SkcModelAssignmentTargetId };
+
+interface PendingDetailChoice {
+	item: ModelItem | CanonicalModelItem;
+	role: SkcModelAssignmentTargetId;
+}
+
 type RoleSelectCallback = (selection: ModelSelectorSelection) => void | Promise<void>;
 type CancelCallback = () => void;
 
@@ -315,6 +356,7 @@ export class ModelSelectorComponent extends Container {
 	#onSelectCallback = (() => {}) as RoleSelectCallback;
 	#onCancelCallback = (() => {}) as CancelCallback;
 	#errorMessage?: unknown;
+	#catalogRefreshGeneration = 0;
 	#tui: TUI;
 	#scopedModels: ReadonlyArray<ScopedModelItem>;
 	#temporaryOnly: boolean;
@@ -327,6 +369,8 @@ export class ModelSelectorComponent extends Container {
 	#isCurrentModelFastModeActive: () => boolean = () => false;
 	#pendingActionItem?: ModelItem | CanonicalModelItem;
 	#selectedActionIndex: number = 0;
+	#pendingDetailChoice?: PendingDetailChoice;
+	#selectedDetailIndex: number = 0;
 	#pendingThinkingChoice?: PendingThinkingChoice;
 	#selectedThinkingIndex: number = 0;
 
@@ -431,19 +475,42 @@ export class ModelSelectorComponent extends Container {
 		// Add bottom border
 		this.addChild(new DynamicBorder());
 
-		// Load models and do initial render
-		this.#loadModels().then(() => {
-			this.#buildProviderTabs();
-			if (this.#viewMode === "presets" && (this.#modelRegistry.getModelProfiles?.().size ?? 0) === 0) {
-				this.#viewMode = "models";
-			}
-			if (this.#viewMode === "presets") {
-				void this.#refreshProviderAuth();
-				this.#renderPresetLanding();
+		void this.#bootstrapCatalog();
+	}
+
+	async #bootstrapCatalog(): Promise<void> {
+		await this.#loadModels();
+		this.#buildProviderTabs();
+		if (this.#viewMode === "presets" && (this.#modelRegistry.getModelProfiles?.().size ?? 0) === 0) {
+			this.#viewMode = "models";
+		}
+		if (this.#viewMode === "presets") {
+			void this.#refreshProviderAuth();
+			this.#renderPresetLanding();
+		} else {
+			this.#updateTabBar();
+			const currentQuery = this.#searchInput.getValue();
+			if (currentQuery) {
+				this.#filterModels(currentQuery);
 			} else {
+				this.#updateList();
+			}
+			void this.#refreshLiveCatalog();
+		}
+		this.#tui.requestRender();
+	}
+
+	async #refreshLiveCatalog(): Promise<void> {
+		if (this.#scopedModels.length > 0) return;
+		const generation = ++this.#catalogRefreshGeneration;
+		try {
+			await this.#modelRegistry.refresh("online");
+			if (generation !== this.#catalogRefreshGeneration) return;
+			await this.#loadModels();
+			if (generation !== this.#catalogRefreshGeneration) return;
+			this.#buildProviderTabs();
+			if (this.#viewMode === "models") {
 				this.#updateTabBar();
-				// Always apply the current search query — the user may have typed
-				// while models were loading asynchronously.
 				const currentQuery = this.#searchInput.getValue();
 				if (currentQuery) {
 					this.#filterModels(currentQuery);
@@ -451,9 +518,13 @@ export class ModelSelectorComponent extends Container {
 					this.#updateList();
 				}
 			}
-			// Request re-render after models are loaded
 			this.#tui.requestRender();
-		});
+		} catch (error) {
+			if (generation !== this.#catalogRefreshGeneration) return;
+			this.#errorMessage = error instanceof Error ? error.message : String(error);
+			this.#updateList();
+			this.#tui.requestRender();
+		}
 	}
 
 	#isActiveDefaultFallback(): boolean {
@@ -1145,6 +1216,7 @@ export class ModelSelectorComponent extends Container {
 		this.#setSearchInputValue(seed ?? this.#searchInput.getValue());
 		this.#updateTabBar();
 		this.#filterModels(this.#searchInput.getValue());
+		void this.#refreshLiveCatalog();
 	}
 
 	/**
@@ -1475,33 +1547,114 @@ export class ModelSelectorComponent extends Container {
 			);
 			if (this.#pendingThinkingChoice) {
 				this.#renderThinkingMenu(this.#pendingThinkingChoice);
+			} else if (this.#pendingDetailChoice) {
+				this.#renderDetailMenu(this.#pendingDetailChoice);
 			} else if (this.#pendingActionItem) {
 				this.#renderActionMenu(this.#pendingActionItem);
 			}
 		}
 	}
 
+	/**
+	 * First-level actions, in a fixed order the tests and muscle memory both rely on.
+	 *
+	 * Built as descriptors rather than derived from an index so that adding a row
+	 * cannot silently renumber the ones below it — the previous index arithmetic
+	 * meant every new action was a chance to mis-assign a model to the wrong role.
+	 */
+	#getActions(): ModelSelectorAction[] {
+		const actions: ModelSelectorAction[] = SKC_MODEL_ASSIGNMENT_TARGET_IDS.map(role => ({ kind: "role", role }));
+		actions.push({ kind: "bulk", roles: ROLE_AGENT_TARGET_IDS, scope: "roleAgents" });
+		actions.push({ kind: "bulk", roles: SKC_MODEL_ASSIGNMENT_TARGET_IDS, scope: "allTargets" });
+		return actions;
+	}
+
+	/**
+	 * Second-level rows for one canonical role: General, then its specialties, then reset.
+	 *
+	 * `default` and the bulk actions never reach here. They write canonical role
+	 * models only, because a "set everything" action that also rewrote five
+	 * specialty overrides would be impossible to undo from this menu.
+	 */
+	#getDetailActions(role: SkcModelAssignmentTargetId): ModelSelectorDetailAction[] {
+		const rows: ModelSelectorDetailAction[] = [{ kind: "roleGeneral", role }];
+		for (const specialty of specialtiesForRole(role)) rows.push({ kind: "specialty", role, specialty });
+		if (rows.length > 1) rows.push({ kind: "resetSpecialties", role });
+		return rows;
+	}
+
+	#actionLabel(action: ModelSelectorAction): string {
+		if (action.kind === "bulk") {
+			return action.scope === "roleAgents"
+				? t("modelSelector.setForAllRoleAgents")
+				: t("modelSelector.setForAllTargets");
+		}
+		const target = SKC_MODEL_ASSIGNMENT_TARGETS[action.role];
+		const label = t("modelSelector.setAsTarget", {
+			tag: target.tag ?? action.role.toUpperCase(),
+			name: target.name,
+		});
+		const count = specialtiesForRole(action.role).length;
+		return count > 0 ? `${label} ${theme.fg("muted", t("modelSelector.hasDetailedUses"))}` : label;
+	}
+
+	#detailActionLabel(action: ModelSelectorDetailAction): string {
+		if (action.kind === "roleGeneral") return t("modelSelector.generalRole");
+		if (action.kind === "resetSpecialties") return t("modelSelector.resetSpecialties");
+		// Read through rather than caching: a row that states what it already holds
+		// is worse than useless if it states a stale value.
+		const assigned = this.#settings.get("task.modelRouting.specialtyModels")?.[action.specialty];
+		const current = selectorHead(assigned);
+		const label = t(`modelSelector.specialty.${action.specialty}`);
+		return current ? `${label} ${theme.fg("muted", `— ${current}`)}` : label;
+	}
+
 	#renderActionMenu(item: ModelItem | CanonicalModelItem): void {
 		this.#listContainer.addChild(new Spacer(1));
 		this.#listContainer.addChild(
 			new Text(theme.fg("muted", `  ${t("modelSelector.actionFor", { id: item.model.id })}`), 0, 0),
 		);
 		this.#listContainer.addChild(new Spacer(1));
-		const actionCount = this.#getActionCount(item.model);
-		for (let i = 0; i < actionCount; i++) {
+		const actions = this.#getActions();
+		for (let i = 0; i < actions.length; i++) {
+			const action = actions[i];
+			if (!action) continue;
 			const prefix = i === this.#selectedActionIndex ? theme.fg("accent", `${theme.nav.cursor} `) : "  ";
-			const role = SKC_MODEL_ASSIGNMENT_TARGET_IDS[i];
-			const label = role
-				? `Set as ${SKC_MODEL_ASSIGNMENT_TARGETS[role].tag ?? role.toUpperCase()} (${SKC_MODEL_ASSIGNMENT_TARGETS[role].name})`
-				: i === SKC_MODEL_ASSIGNMENT_TARGET_IDS.length
-					? "Set for all role agents"
-					: "Set for all targets";
+			const label = this.#actionLabel(action);
 			this.#listContainer.addChild(
 				new Text(`${prefix}${i === this.#selectedActionIndex ? theme.fg("accent", label) : label}`, 0, 0),
 			);
 		}
 	}
 
+	#renderDetailMenu(choice: PendingDetailChoice): void {
+		this.#listContainer.addChild(new Spacer(1));
+		this.#listContainer.addChild(
+			new Text(
+				theme.fg(
+					"muted",
+					`  ${t("modelSelector.detailedUseFor", {
+						target: SKC_MODEL_ASSIGNMENT_TARGETS[choice.role].name,
+						id: choice.item.model.id,
+					})}`,
+				),
+				0,
+				0,
+			),
+		);
+		this.#listContainer.addChild(new Spacer(1));
+		const rows = this.#getDetailActions(choice.role);
+		for (let i = 0; i < rows.length; i++) {
+			const action = rows[i];
+			if (!action) continue;
+			const prefix = i === this.#selectedDetailIndex ? theme.fg("accent", `${theme.nav.cursor} `) : "  ";
+			const label = this.#detailActionLabel(action);
+			this.#listContainer.addChild(
+				new Text(`${prefix}${i === this.#selectedDetailIndex ? theme.fg("accent", label) : label}`, 0, 0),
+			);
+		}
+	}
+
 	#renderThinkingMenu(choice: PendingThinkingChoice): void {
 		const targetLabel = choice.roles
 			? choice.roles.includes("default")
@@ -1537,7 +1690,7 @@ export class ModelSelectorComponent extends Container {
 		return this.#roles[role]?.thinkingLevel ?? ThinkingLevel.Inherit;
 	}
 	#getActionCount(_model: Model): number {
-		return SKC_MODEL_ASSIGNMENT_TARGET_IDS.length + 2;
+		return this.#getActions().length;
 	}
 
 	#getSelectedItem(): ModelItem | CanonicalModelItem | undefined {
@@ -1551,6 +1704,10 @@ export class ModelSelectorComponent extends Container {
 			this.#handleThinkingMenuInput(keyData);
 			return;
 		}
+		if (this.#pendingDetailChoice) {
+			this.#handleDetailMenuInput(keyData);
+			return;
+		}
 		if (this.#pendingActionItem) {
 			this.#handleActionMenuInput(keyData);
 			return;
@@ -1783,17 +1940,24 @@ export class ModelSelectorComponent extends Container {
 			return;
 		}
 		if (matchesKey(keyData, "enter") || matchesKey(keyData, "return") || keyData === "\n") {
-			this.#pendingActionItem = undefined;
-			const role = SKC_MODEL_ASSIGNMENT_TARGET_IDS[this.#selectedActionIndex];
-			if (role) {
-				this.#handleSelect(item, role);
+			const action = this.#getActions()[this.#selectedActionIndex];
+			if (!action) return;
+			if (action.kind === "bulk") {
+				this.#pendingActionItem = undefined;
+				this.#handleSelect(item, "default", undefined, action.roles);
+				return;
+			}
+			// A role with specialties opens the detail level instead of assigning
+			// straight away; a role without any keeps the old one-keystroke path.
+			if (this.#getDetailActions(action.role).length > 1) {
+				this.#pendingActionItem = undefined;
+				this.#pendingDetailChoice = { item, role: action.role };
+				this.#selectedDetailIndex = 0;
+				this.#updateList();
 				return;
 			}
-			const roles =
-				this.#selectedActionIndex === SKC_MODEL_ASSIGNMENT_TARGET_IDS.length
-					? (["executor", "architect", "planner", "critic"] as const)
-					: SKC_MODEL_ASSIGNMENT_TARGET_IDS;
-			this.#handleSelect(item, "default", undefined, roles);
+			this.#pendingActionItem = undefined;
+			this.#handleSelect(item, action.role);
 			return;
 		}
 		if (getKeybindings().matches(keyData, "tui.select.cancel")) {
@@ -1801,6 +1965,74 @@ export class ModelSelectorComponent extends Container {
 			this.#updateList();
 		}
 	}
+	/**
+	 * Second level: General, the role's specialties, and reset.
+	 *
+	 * Cancel steps back to the first level rather than closing outright, so a
+	 * wrong turn costs one keystroke instead of restarting the whole selection.
+	 */
+	#handleDetailMenuInput(keyData: string): void {
+		const choice = this.#pendingDetailChoice;
+		if (!choice) return;
+		const rows = this.#getDetailActions(choice.role);
+		if (matchesKey(keyData, "up")) {
+			this.#selectedDetailIndex = this.#selectedDetailIndex === 0 ? rows.length - 1 : this.#selectedDetailIndex - 1;
+			this.#updateList();
+			return;
+		}
+		if (matchesKey(keyData, "down")) {
+			this.#selectedDetailIndex = (this.#selectedDetailIndex + 1) % rows.length;
+			this.#updateList();
+			return;
+		}
+		if (matchesKey(keyData, "enter") || matchesKey(keyData, "return") || keyData === "\n") {
+			const action = rows[this.#selectedDetailIndex];
+			if (!action) return;
+			this.#pendingDetailChoice = undefined;
+			if (action.kind === "roleGeneral") {
+				this.#handleSelect(choice.item, action.role);
+				return;
+			}
+			if (action.kind === "resetSpecialties") {
+				this.#onSelectCallback({ kind: "specialtyReset", role: action.role });
+				return;
+			}
+			this.#handleSpecialtySelect(choice.item, action.role, action.specialty);
+			return;
+		}
+		if (getKeybindings().matches(keyData, "tui.select.cancel")) {
+			this.#pendingDetailChoice = undefined;
+			this.#pendingActionItem = choice.item;
+			this.#selectedActionIndex = Math.max(
+				0,
+				this.#getActions().findIndex(action => action.kind === "role" && action.role === choice.role),
+			);
+			this.#updateList();
+		}
+	}
+
+	/**
+	 * Assign a model to one specialty.
+	 *
+	 * Reuses the same explicit-thinking gate as a canonical assignment, because a
+	 * specialty override is dispatched exactly like a role model and would hit
+	 * the same "which effort?" ambiguity if it skipped it.
+	 */
+	#handleSpecialtySelect(
+		item: ModelItem | CanonicalModelItem,
+		role: SkcModelAssignmentTargetId,
+		specialty: TaskModelSpecialty,
+	): void {
+		const thinkingLevel = item.thinkingLevel ?? this.#getCurrentRoleThinkingLevel(role);
+		this.#onSelectCallback({
+			kind: "specialtyAssignment",
+			model: item.model,
+			role,
+			specialty,
+			thinkingLevel,
+			selector: formatModelSelectorValue(item.selector, thinkingLevel),
+		});
+	}
 
 	#handleThinkingMenuInput(keyData: string): void {
 		const choice = this.#pendingThinkingChoice;
@@ -1826,10 +2058,19 @@ export class ModelSelectorComponent extends Container {
 		if (getKeybindings().matches(keyData, "tui.select.cancel")) {
 			this.#pendingThinkingChoice = undefined;
 			if (choice.role !== null) {
+				// Step back one level, landing on the row that got us here. Located by
+				// descriptor rather than computed from lengths, so the two bulk rows
+				// cannot drift apart from the list that renders them.
 				this.#pendingActionItem = choice.item;
-				this.#selectedActionIndex = choice.roles
-					? SKC_MODEL_ASSIGNMENT_TARGET_IDS.length + (choice.roles.includes("default") ? 1 : 0)
-					: Math.max(0, SKC_MODEL_ASSIGNMENT_TARGET_IDS.indexOf(choice.role));
+				const actions = this.#getActions();
+				const bulkRoles = choice.roles;
+				const wanted = bulkRoles
+					? actions.findIndex(
+							action =>
+								action.kind === "bulk" && action.roles.includes("default") === bulkRoles.includes("default"),
+						)
+					: actions.findIndex(action => action.kind === "role" && action.role === choice.role);
+				this.#selectedActionIndex = Math.max(0, wanted);
 			}
 			this.#updateList();
 		}

package/src/modes/controllers/selector-controller.ts

@@ -14,9 +14,10 @@ import {
 import { formatModelProfileDisplayLabel, recommendModelProfileForProvider } from "../../config/model-profiles";
 import { SKC_MODEL_ASSIGNMENT_TARGETS, type SkcModelAssignmentTargetId } from "../../config/model-registry";
 import { formatModelSelectorValue } from "../../config/model-resolver";
-import { selectorHead } from "../../config/model-selector-value";
+import { type ModelSelectorValue, selectorHead } from "../../config/model-selector-value";
 import type { ModelProfileConfig } from "../../config/models-config-schema";
 import { type Settings, settings } from "../../config/settings";
+import { specialtiesForRole } from "../../config/task-model-specialties";
 import { DebugSelectorComponent } from "../../debug";
 import { disableProvider, enableProvider } from "../../discovery";
 import { clearPluginRootsAndCaches, resolveActiveProjectRegistryPath } from "../../discovery/helpers";
@@ -28,6 +29,7 @@ import {
 	MarketplaceManager,
 } from "../../extensibility/plugins/marketplace";
 import { INTERACTIVE_SELECTOR_RESUME_ORIGIN } from "../../extensibility/shared-events";
+import { t } from "../../i18n";
 import {
 	getAvailableThemes,
 	getCurrentThemeName,
@@ -1589,6 +1591,52 @@ export class SelectorController {
 							this.ctx.ui.requestRender();
 							return;
 						}
+						if (selection.kind === "specialtyAssignment") {
+							const value =
+								selection.selector ??
+								formatModelSelectorValue(
+									`${selection.model.provider}/${selection.model.id}`,
+									selection.thinkingLevel,
+								);
+							const current = this.ctx.settings.get("task.modelRouting.specialtyModels") ?? {};
+							this.ctx.settings.set("task.modelRouting.specialtyModels", {
+								...current,
+								[selection.specialty]: value,
+							});
+							this.ctx.settings
+								.getStorage()
+								?.recordModelUsage(`${selection.model.provider}/${selection.model.id}`);
+							await this.ctx.notifyConfigChanged?.();
+							// The assignment is live for declared work as soon as it is saved. The
+							// routing switch only governs auto-detection, so say that rather than
+							// auto-enabling a classifier the user did not ask for.
+							const specialtyLabel = t(`modelSelector.specialty.${selection.specialty}`);
+							this.ctx.showStatus(
+								this.ctx.settings.get("task.modelRouting.enabled")
+									? t("modelSelector.specialtySaved", { specialty: specialtyLabel, value })
+									: t("modelSelector.specialtySavedRoutingOff", { specialty: specialtyLabel, value }),
+							);
+							done();
+							this.ctx.ui.requestRender();
+							return;
+						}
+						if (selection.kind === "specialtyReset") {
+							const current = this.ctx.settings.get("task.modelRouting.specialtyModels") ?? {};
+							const remaining: Record<string, ModelSelectorValue> = {};
+							for (const [key, value] of Object.entries(current)) {
+								if (!specialtiesForRole(selection.role).includes(key as never)) remaining[key] = value;
+							}
+							this.ctx.settings.set("task.modelRouting.specialtyModels", remaining);
+							await this.ctx.notifyConfigChanged?.();
+							this.ctx.showStatus(
+								t("modelSelector.specialtyCleared", {
+									target: SKC_MODEL_ASSIGNMENT_TARGETS[selection.role].name,
+								}),
+							);
+							done();
+							this.ctx.ui.requestRender();
+							return;
+						}
 						const { model, role, thinkingLevel, selector: selectedSelector } = selection;
 						if (role === null) {
 							// Temporary: update agent state but don't persist to settings
@@ -2306,7 +2354,7 @@ export class SelectorController {
 				},
 				onManualCodeInput: useManualInput ? () => manualInput.waitForInput(providerId) : undefined,
 			});
-			await this.ctx.session.modelRegistry.refresh();
+			await this.ctx.session.modelRegistry.refresh("online");
 			this.ctx.chatContainer.addChild(new Spacer(1));
 			this.ctx.chatContainer.addChild(
 				new Text(theme.fg("success", `${theme.status.success} Successfully logged in to ${providerId}`), 1, 0),

package/src/modes/shared/agent-wire/command-dispatch.ts

@@ -454,7 +454,7 @@ export async function dispatchRpcCommand(
 							return new Promise<string>(() => {});
 						},
 					});
-					await session.modelRegistry.refresh();
+					await session.modelRegistry.refresh("online");
 					return rpcSuccess(id, "login", { providerId: command.providerId });
 				} catch (err: unknown) {
 					return rpcError(id, "login", err instanceof Error ? err.message : String(err));

package/src/prompts/tools/task.md

@@ -21,6 +21,7 @@ Subagents have no conversation history. Every fact, file path, and direction the
  - `.id`: filesystem-safe, ≤48 chars, matching `[A-Za-z0-9][A-Za-z0-9_-]*`; prefer CamelCase
  - `.description`: UI label only — subagent never sees it
  - `.assignment`: complete self-contained instructions; one-liners and missing acceptance criteria are PROHIBITED
+ - `.specialty` (optional): the kind of work — `backendArchitecture`, `frontendDesign`, `implementation`, `testing`, or `review`. When the user assigned a model to that specialty under `/model`, this child runs on it, deterministically: no classifier, no routing switch. It only leaves that model on a transport error (429, 5xx, auth, quota), falling back to the agent's role model. Declare it whenever the work clearly is one of these — a frontend build is `frontendDesign` even for `executor`. Omit to keep the role model or let auto-detection decide.
 {{#if contextEnabled}}- `context`: shared background prepended to every assignment; session-specific only{{/if}}
 {{#if contextEnabled}}
 - `.inheritContext` (optional): fork-context mode for seeding the subagent with sanitized parent conversation. Omit it or set `"none"` for no copied context. `"receipt"` copies a minimal receipt-sized snapshot, `"last-turn"` copies only the latest exchange, `"bounded"` copies the bounded default snapshot, and `"full"` copies a larger snapshot up to the configured/model token cap. Non-`none` modes work only when global `task.forkContext.enabled` is true and the target agent declares `forkContext: allowed`; otherwise the call is rejected. Bundled agents that support it: `executor`, `architect`. Use inherited context only when the subagent's value depends on parent context; cloned tokens are billed to the child as fresh input and surfaced in task receipts as fork-context cloned-token accounting.

package/src/slash-commands/builtin-registry.ts

@@ -360,9 +360,8 @@ async function resolveModelCommandSelection(
 	}
 
 	const providerRef = parseProviderQualifiedSelector(selector);
-	const discoverableProviders = runtime.session.modelRegistry?.getDiscoverableProviders?.() ?? [];
-	if (providerRef && discoverableProviders.includes(providerRef.provider)) {
-		await runtime.session.modelRegistry.refreshProvider?.(providerRef.provider, "online");
+	if (providerRef && runtime.session.modelRegistry?.refreshProvider) {
+		await runtime.session.modelRegistry.refreshProvider(providerRef.provider, "online");
 		availableModels = runtime.session.getAvailableModels?.() ?? [];
 		const refreshedSelection = resolveModelCommandSelectionFromAvailable(
 			runtime,
@@ -372,12 +371,15 @@ async function resolveModelCommandSelection(
 		if (refreshedSelection) {
 			return { ok: true, selection: refreshedSelection };
 		}
-		return {
-			ok: false,
-			failure: {
-				message: formatDiscoverableProviderFailure(selector, providerRef.provider, providerRef.modelId, runtime),
-			},
-		};
+		const discoverableProviders = runtime.session.modelRegistry.getDiscoverableProviders?.() ?? [];
+		if (discoverableProviders.includes(providerRef.provider)) {
+			return {
+				ok: false,
+				failure: {
+					message: formatDiscoverableProviderFailure(selector, providerRef.provider, providerRef.modelId, runtime),
+				},
+			};
+		}
 	}
 
 	return {