@sayknow-cli/coding-agent 0.5.25 → 0.6.0

package/src/hooks/native-prompt-routing.ts

@@ -0,0 +1,190 @@
+/**
+ * Prompt routing for the Codex host: the same three stages the session runs in
+ * `AgentSession#routeWorkflowSemantically`, rebuilt for a process that lives for
+ * one prompt.
+ *
+ * The session holds settings, credentials and a model registry for its whole
+ * life, so its model stage is a few lines. The hook is spawned fresh on every
+ * `UserPromptSubmit`, already costs ~260ms to start, and answers most prompts
+ * from the keyword tables alone — so everything the model stage needs is loaded
+ * lazily, and only on a prompt that actually reaches it. Concretely:
+ *
+ * - `decisions.enabled` / `decisions.keywordLearning` are read from the same raw
+ *   `config.yml` files the hook already parses for skill discovery. Loading
+ *   `Settings` for two booleans costs ~200ms of module graph on every prompt.
+ * - Learned keywords are one small JSON read, so they are always consulted: a
+ *   pattern promoted in a CLI session must fire under Codex too.
+ * - Credentials, the registry and the decision service are opened only when the
+ *   keyword tables did not fully answer, then closed before the hook exits.
+ *
+ * Every failure resolves to "no activation", which is what the hook did before
+ * this stage existed.
+ */
+import { getAgentDir } from "@sayknow-cli/utils";
+import { YAML } from "bun";
+import { loadLearnedKeywordDefinitions, observeRouting } from "../decisions/keyword-learning";
+import type { PromptTriage, PromptTriageRequest, PromptTriager } from "../decisions/prompt-triage";
+import type { SkillKeywordDefinition } from "./skill-keywords";
+import { recordSkillActivation, type SkillActiveState } from "./skill-state";
+import { buildUiSkillDirectiveForSkill, detectUiSkillKeywords } from "./ui-skill-keywords";
+
+export interface NativePromptRoutingInput {
+	cwd: string;
+	text: string;
+	sessionId?: string;
+	threadId?: string;
+	turnId?: string;
+	stateDir?: string;
+	/** `config.yml` files in precedence order, lowest first; resolved by the hook. */
+	configPaths: readonly string[];
+	agentDir?: string;
+	/** Injected in tests so routing is exercised without credentials or a network. */
+	triager?: PromptTriager;
+}
+
+export interface NativePromptRoutingResult {
+	skillState: SkillActiveState | null;
+	/** Directive for a UI skill the model picked because the pattern table missed. */
+	uiSkillContext: string | null;
+}
+
+interface DecisionSettings {
+	enabled: boolean;
+	keywordLearning: boolean;
+}
+
+/**
+ * The two decision switches, read the way the hook reads `skills.*`: raw YAML,
+ * later files override earlier ones, absent means the schema default (`true`).
+ */
+async function readDecisionSettings(configPaths: readonly string[]): Promise<DecisionSettings> {
+	const settings: DecisionSettings = { enabled: true, keywordLearning: true };
+	for (const configPath of configPaths) {
+		let raw: unknown;
+		try {
+			raw = YAML.parse(await Bun.file(configPath).text());
+		} catch {
+			continue;
+		}
+		if (!raw || typeof raw !== "object" || Array.isArray(raw)) continue;
+		const decisions = (raw as Record<string, unknown>).decisions;
+		if (!decisions || typeof decisions !== "object" || Array.isArray(decisions)) continue;
+		const { enabled, keywordLearning } = decisions as Record<string, unknown>;
+		if (typeof enabled === "boolean") settings.enabled = enabled;
+		if (typeof keywordLearning === "boolean") settings.keywordLearning = keywordLearning;
+	}
+	return settings;
+}
+
+/**
+ * Open credentials and the registry, build the triager, and hand back the
+ * teardown. Imported lazily: this graph is what the fast path must never pay for.
+ */
+async function openTriager(input: NativePromptRoutingInput): Promise<{ triager: PromptTriager; close: () => void }> {
+	const [{ Settings }, { ModelRegistry }, { discoverAuthStorage }, { createDecisionService }, { createPromptTriage }] =
+		await Promise.all([
+			import("../config/settings"),
+			import("../config/model-registry"),
+			import("../session/auth-storage-discovery"),
+			import("../decisions"),
+			import("../decisions/prompt-triage"),
+		]);
+	const agentDir = input.agentDir ?? getAgentDir();
+	const settings = await Settings.loadForScope({ cwd: input.cwd, agentDir });
+	const authStorage = await discoverAuthStorage(agentDir);
+	try {
+		const registry = new ModelRegistry(authStorage);
+		registry.applyConfiguredModelBindings(settings);
+		// Offline: built-in providers are static, and a local runtime's model list
+		// comes from the 24h discovery cache the CLI maintains. A network refresh here
+		// would put an unbounded fetch in front of every Codex prompt.
+		await registry.refresh("offline");
+		const service = createDecisionService({
+			registry,
+			settings,
+			sessionId: input.sessionId,
+			// This hook only runs under the Codex host, so the provider the user is
+			// already talking to is Codex; its small model ranks first when the user
+			// has that credential, and the hint is inert when they do not.
+			preferredProvider: "openai-codex",
+			enabled: true,
+		});
+		return { triager: createPromptTriage(service), close: () => authStorage.close() };
+	} catch (error) {
+		authStorage.close();
+		throw error;
+	}
+}
+
+export async function routeNativePrompt(input: NativePromptRoutingInput): Promise<NativePromptRoutingResult> {
+	const decisions = await readDecisionSettings(input.configPaths);
+	const learned = await loadLearned(decisions.keywordLearning);
+	const uiMatched = detectUiSkillKeywords(input.text).length > 0;
+
+	let opened: { triager: PromptTriager; close: () => void } | undefined;
+	const triage = async (request: Omit<PromptTriageRequest, "text">): Promise<PromptTriage | null> => {
+		if (input.triager) return await input.triager({ text: input.text, ...request });
+		opened ??= await openTriager(input);
+		return await opened.triager({ text: input.text, ...request });
+	};
+
+	// Written from inside the semantic callback; a plain `let` would be narrowed
+	// to its initialiser by control-flow analysis and read as never-assigned here.
+	const seen: { semanticConsulted: boolean; result: PromptTriage | null } = { semanticConsulted: false, result: null };
+	try {
+		const skillState = await recordSkillActivation({
+			cwd: input.cwd,
+			text: input.text,
+			sessionId: input.sessionId,
+			threadId: input.threadId,
+			turnId: input.turnId,
+			stateDir: input.stateDir,
+			learned,
+			// Consulted only when no keyword matched — the same turn the session
+			// would spend a model call on, asking both questions at once.
+			resolveSkillSemantically: decisions.enabled
+				? async () => {
+						seen.semanticConsulted = true;
+						const result = await triage({ skipUiSkill: uiMatched });
+						seen.result = result;
+						// A null result is "no information" and teaches nothing; a result
+						// with a null workflow is the model saying "none", which is a
+						// negative example the learner needs.
+						if (decisions.keywordLearning && result) {
+							await observeRouting({
+								text: input.text,
+								skill: result.workflow,
+								confidence: result.workflowConfidence,
+								calibrated: result.calibrated,
+							});
+						}
+						return result?.workflow ?? null;
+					}
+				: undefined,
+		});
+		// A keyword answered the workflow question but the UI pattern table missed:
+		// the session still asks the UI question alone, and so does the hook.
+		if (decisions.enabled && !seen.semanticConsulted && !uiMatched) {
+			try {
+				seen.result = await triage({ skipWorkflow: true });
+			} catch {
+				seen.result = null;
+			}
+		}
+		return {
+			skillState,
+			uiSkillContext: seen.result?.uiSkill ? buildUiSkillDirectiveForSkill(seen.result.uiSkill) : null,
+		};
+	} finally {
+		opened?.close();
+	}
+}
+
+async function loadLearned(enabled: boolean): Promise<SkillKeywordDefinition[]> {
+	if (!enabled) return [];
+	try {
+		return await loadLearnedKeywordDefinitions();
+	} catch {
+		return [];
+	}
+}

package/src/hooks/native-skill-hook.ts

@@ -5,7 +5,9 @@ import { getAgentDir, getConfigDirName } from "@sayknow-cli/utils";
 import { YAML } from "bun";
 import type { SkillDiscoverySettings } from "../config/skill-settings-defaults";
 import { DEFAULT_DISABLED_EXTENSIONS, DEFAULT_SKILL_DISCOVERY_SETTINGS } from "../config/skill-settings-defaults";
+import type { PromptTriager } from "../decisions/prompt-triage";
 import { sessionLogsDir } from "../skc-runtime/session-layout";
+import { routeNativePrompt } from "./native-prompt-routing";
 import {
 	buildActiveUltragoalPromptContext,
 	buildSkillActivationAdditionalContext,
@@ -13,7 +15,6 @@ import {
 	buildStateRecoveryDiagnosticsContext,
 	collectUserPromptStateRecoveryDiagnostics,
 	type EffectiveSkillConfigInput,
-	recordSkillActivation,
 } from "./skill-state";
 import { buildExternalUiSkillContext, buildUiSkillActivationContext } from "./ui-skill-keywords";
 
@@ -32,6 +33,8 @@ interface SkcNativeHookDispatchOptions {
 	stateDir?: string;
 	effectiveSkillConfig?: EffectiveSkillConfigInput;
 	configPaths?: string[];
+	/** Injected in tests so the model stage runs without credentials or a network. */
+	triager?: PromptTriager;
 }
 
 interface ConfigCacheEntry {
@@ -337,19 +340,25 @@ async function dispatchSkcNativeSkillHookInner(
 		}
 
 		let skillState = null;
+		let semanticUiContext: string | null = null;
 		try {
-			skillState = prompt
-				? await recordSkillActivation({
-						cwd,
-						text: prompt,
-						sessionId: readSessionId(payload),
-						threadId: readThreadId(payload),
-						turnId: readTurnId(payload),
-						stateDir: options.stateDir,
-					})
-				: null;
+			if (prompt) {
+				const routed = await routeNativePrompt({
+					cwd,
+					text: prompt,
+					sessionId: readSessionId(payload),
+					threadId: readThreadId(payload),
+					turnId: readTurnId(payload),
+					stateDir: options.stateDir,
+					configPaths: resolveConfigPaths(cwd, options.configPaths),
+					triager: options.triager,
+				});
+				skillState = routed.skillState;
+				semanticUiContext = routed.uiSkillContext;
+			}
 		} catch {
 			skillState = null;
+			semanticUiContext = null;
 		}
 
 		let effectiveSkillConfig: EffectiveSkillConfigInput | undefined;
@@ -395,7 +404,7 @@ async function dispatchSkcNativeSkillHookInner(
 		}
 		const additionalContext = [
 			skillState ? buildSkillActivationAdditionalContext(skillState, effectiveSkillConfig) : activeUltragoalContext,
-			uiSkillContext,
+			uiSkillContext ?? semanticUiContext,
 			externalUiContext,
 			recoveryContext,
 			classifyQuestionOnlyPrompt(prompt),

package/src/hooks/skill-keywords.ts

@@ -5,6 +5,15 @@ export interface SkillKeywordDefinition {
 	skill: SkcWorkflowSkill;
 	priority: number;
 	guidance: string;
+	/**
+	 * Pre-compiled matcher, replacing the literal-substring compilation of
+	 * `keyword`. Only learned entries set it: they are two stems with a bounded
+	 * gap, which a literal string cannot express. `keyword` stays human-readable
+	 * for logs and for the guidance line.
+	 */
+	pattern?: RegExp;
+	/** Mined from routing answers rather than written by hand. */
+	learned?: boolean;
 }
 
 export const SKC_WORKFLOW_SKILLS = CANONICAL_SKC_WORKFLOW_SKILLS;

package/src/hooks/skill-state.ts

@@ -32,6 +32,7 @@ import {
 	isSkcWorkflowSkill,
 	SKC_SKILL_KEYWORD_DEFINITIONS,
 	type SkcWorkflowSkill,
+	type SkillKeywordDefinition,
 } from "./skill-keywords";
 
 export const SKC_STATE_DIR = ".skc";
@@ -95,6 +96,8 @@ export interface SkillKeywordMatch {
 	keyword: string;
 	skill: SkcWorkflowSkill;
 	priority: number;
+	/** Matched a pattern mined from routing answers, not a hand-written keyword. */
+	learned?: boolean;
 }
 
 export type { SkillActiveEntry, SkillActiveState } from "../skill-state/active-state";
@@ -121,6 +124,12 @@ export interface RecordSkillActivationInput {
 	turnId?: string;
 	nowIso?: string;
 	stateDir?: string;
+	/**
+	 * Patterns promoted by the keyword learner, appended after the hand-written
+	 * table. The caller loads them because it knows whether learning is on; see
+	 * `detectSkillKeywords`.
+	 */
+	learned?: readonly SkillKeywordDefinition[];
 	/**
 	 * Semantic fallback, consulted only when no keyword matched. Supplying it turns the
 	 * literal keyword table into a two-stage router; omitting it keeps the historical
@@ -161,10 +170,11 @@ function keywordToPattern(keyword: string): RegExp {
 	return new RegExp(`${prefix}${escaped}${suffix}`, "i");
 }
 
-const KEYWORD_PATTERNS = SKC_SKILL_KEYWORD_DEFINITIONS.map(definition => ({
-	...definition,
-	pattern: keywordToPattern(definition.keyword),
-}));
+function compileDefinition(definition: SkillKeywordDefinition): SkillKeywordDefinition & { pattern: RegExp } {
+	return { ...definition, pattern: definition.pattern ?? keywordToPattern(definition.keyword) };
+}
+
+const KEYWORD_PATTERNS = SKC_SKILL_KEYWORD_DEFINITIONS.map(compileDefinition);
 
 function parseExplicitSkillInvocations(text: string): {
 	matches: SkillKeywordMatch[];
@@ -192,16 +202,34 @@ function parseExplicitSkillInvocations(text: string): {
 	return { matches, sawExplicitLikeInvocation };
 }
 
-export function detectSkillKeywords(text: string): SkillKeywordMatch[] {
+/**
+ * Match a prompt against the keyword table.
+ *
+ * `learned` carries patterns mined from semantic routing answers (see
+ * `decisions/keyword-learning.ts`). It is a parameter rather than a module-level
+ * load because this file is imported by the hook process, where a synchronous
+ * disk read on every prompt is not acceptable and the caller already knows
+ * whether learning is enabled.
+ */
+export function detectSkillKeywords(
+	text: string,
+	learned: readonly SkillKeywordDefinition[] = [],
+): SkillKeywordMatch[] {
 	const explicit = parseExplicitSkillInvocations(text);
 	if (explicit.matches.length > 0) return explicit.matches;
 	if (explicit.sawExplicitLikeInvocation) return [];
 
 	const implicit: SkillKeywordMatch[] = [];
-	for (const definition of KEYWORD_PATTERNS) {
+	const definitions = learned.length > 0 ? [...KEYWORD_PATTERNS, ...learned.map(compileDefinition)] : KEYWORD_PATTERNS;
+	for (const definition of definitions) {
 		const match = text.match(definition.pattern);
 		if (!match) continue;
-		implicit.push({ keyword: match[0], skill: definition.skill, priority: definition.priority });
+		implicit.push({
+			keyword: match[0],
+			skill: definition.skill,
+			priority: definition.priority,
+			...(definition.learned ? { learned: true } : {}),
+		});
 	}
 
 	const merged: SkillKeywordMatch[] = [];
@@ -212,8 +240,11 @@ export function detectSkillKeywords(text: string): SkillKeywordMatch[] {
 	return merged;
 }
 
-export function detectPrimarySkillKeyword(text: string): SkillKeywordMatch | null {
-	return detectSkillKeywords(text)[0] ?? null;
+export function detectPrimarySkillKeyword(
+	text: string,
+	learned: readonly SkillKeywordDefinition[] = [],
+): SkillKeywordMatch | null {
+	return detectSkillKeywords(text, learned)[0] ?? null;
 }
 
 export function resolveSkcStateDir(cwd: string, stateDir?: string): string {
@@ -476,7 +507,7 @@ async function seedSkillActivationState(
 // Fallback for native-hook prompts when SkillPromptDetails.subskillActivation is absent;
 // real /skill dispatch paths resolve sub-skill activation before prompt construction.
 export async function recordSkillActivation(input: RecordSkillActivationInput): Promise<SkillActiveState | null> {
-	const match = detectPrimarySkillKeyword(input.text);
+	const match = detectPrimarySkillKeyword(input.text, input.learned);
 	if (match) return await seedSkillActivationState(match.skill, match.keyword, "skc-skill-state-hook", input);
 	if (!input.resolveSkillSemantically) return null;
 	// The semantic stage is advisory: any failure leaves routing to the system prompt,

package/src/hooks/ui-skill-keywords.ts

@@ -160,9 +160,29 @@ export function detectUiSkillKeywords(text: string): UiSkillKeywordMatch[] {
 	}
 	// Keep the lead skill plus the craft baseline; more than that is noise.
 	const lead = deduped[0]!;
-	if (lead.skill === UI_SKILL_BASE || SELF_SUFFICIENT_UI_SKILLS.has(lead.skill)) return [lead];
-	const base = deduped.find(item => item.skill === UI_SKILL_BASE);
-	return base ? [lead, base] : [lead];
+	return pairWithBaseline(lead.skill);
+}
+
+/**
+ * A specialized skill plus the craft baseline, which is the pairing the skills
+ * themselves assume. Skills that carry their own complete craft bar stand alone.
+ */
+function pairWithBaseline(skill: BundledSkcUiSkillName): UiSkillKeywordMatch[] {
+	const definition = UI_SKILL_KEYWORD_DEFINITIONS.find(item => item.skill === skill);
+	const lead: UiSkillKeywordMatch = { skill, keyword: skill, priority: definition?.priority ?? 0 };
+	if (skill === UI_SKILL_BASE || SELF_SUFFICIENT_UI_SKILLS.has(skill)) return [lead];
+	const base = UI_SKILL_KEYWORD_DEFINITIONS.find(item => item.skill === UI_SKILL_BASE);
+	return [lead, { skill: UI_SKILL_BASE, keyword: UI_SKILL_BASE, priority: base?.priority ?? 0 }];
+}
+
+function renderUiSkillDirective(skills: readonly BundledSkcUiSkillName[], evidence: string): string {
+	const names = skills.map(skill => `\`${skill}\``).join(" then ");
+	return [
+		`SKC detected frontend UI/UX work in this prompt (${evidence}).`,
+		`Before writing or reviewing that surface, load ${names} with the \`skill\` tool.`,
+		"These skills are bundled with SKC: never tell the user to install them, and never skip them because the task looks small.",
+		"They are not workflow skills and have no `skc state` mode state.",
+	].join(" ");
 }
 
 /**
@@ -173,15 +193,52 @@ export function detectUiSkillKeywords(text: string): UiSkillKeywordMatch[] {
 export function buildUiSkillActivationContext(text: string): string | null {
 	const matches = detectUiSkillKeywords(text);
 	if (matches.length === 0) return null;
-	const names = matches.map(match => `\`${match.skill}\``).join(" then ");
-	return [
-		`SKC detected frontend UI/UX work in this prompt (matched "${matches[0]!.keyword}").`,
-		`Before writing or reviewing that surface, load ${names} with the \`skill\` tool.`,
-		"These skills are bundled with SKC: never tell the user to install them, and never skip them because the task looks small.",
-		"They are not workflow skills and have no `skc state` mode state.",
-	].join(" ");
+	return renderUiSkillDirective(
+		matches.map(match => match.skill),
+		`matched "${matches[0]!.keyword}"`,
+	);
 }
 
+/**
+ * Same directive, for a skill chosen by the semantic stage rather than by a
+ * pattern. The regex table caught 5 of 8 real frontend prompts; this is the path
+ * for the other three, and it names its source so a wrong pick is traceable to
+ * the model rather than to a pattern nobody can find.
+ */
+export function buildUiSkillDirectiveForSkill(skill: BundledSkcUiSkillName): string {
+	return renderUiSkillDirective(
+		pairWithBaseline(skill).map(match => match.skill),
+		"semantic match",
+	);
+}
+
+/**
+ * What each bundled skill is *for*, in the words a user would recognise.
+ *
+ * This is the whole contract with the routing model — the skill ids alone carry
+ * almost no signal, and `appllama-app-design-skill` carries actively misleading
+ * signal. Kept next to the patterns so the two cannot drift apart.
+ */
+export const BUNDLED_UI_SKILL_MEANINGS: Record<BundledSkcUiSkillName, string> = {
+	"emil-design-eng":
+		"General web UI/UX craft: building or reviewing components, layout, spacing, typography, design systems, CSS. The default for frontend work with no more specific fit.",
+	animate:
+		"Adding new motion to a web UI: animations, transitions, easing, keyframes, hover effects, micro-interactions.",
+	"review-animations": "Reviewing motion that already exists and judging whether it is good.",
+	"improve-animations": "Auditing and fixing motion that already exists and is known to be wrong or cheap-looking.",
+	"find-animation-opportunities":
+		"Asking where motion could be added to a surface that currently has none, without naming a specific effect.",
+	"pick-ui-library": "Choosing between UI libraries, component kits, or frontend packages.",
+	prototype: "Exploring several visual variants or mockups of the same screen before committing to one.",
+	"mobile-native":
+		"Making a web page on a phone feel native: touch targets, safe areas, viewport and scroll behaviour, gestures.",
+	"animation-vocabulary": "Naming a motion effect the user described but could not name.",
+	"apple-design": "Apple-style motion, materials, and Human Interface Guidelines feel.",
+	"ask-sonner": "Toast notifications, specifically the Sonner library.",
+	"appllama-app-design-skill": "Native app screens built with Expo or React Native — not a website viewed on a phone.",
+	"react-bits": "Pre-built animated React components: animated text, animated backgrounds, cursor and scroll effects.",
+};
+
 /**
  * Frontend skills SKC routes to but deliberately does NOT vendor.
  *

package/src/i18n/messages/de.ts

@@ -75,6 +75,22 @@ export const de: Partial<Record<MsgKey, string>> = {
 	"modelSelector.noMatching": "Keine passenden Modelle.",
 	"modelSelector.modelName": "Modellname: {value}",
 	"modelSelector.actionFor": "Aktion für: {id}",
+	"modelSelector.setAsTarget": "Als {tag} ({name}) festlegen",
+	"modelSelector.setForAllRoleAgents": "Fur alle Rollen-Agenten setzen",
+	"modelSelector.setForAllTargets": "Fur alle Ziele setzen",
+	"modelSelector.hasDetailedUses": "(detaillierte Aufgaben)",
+	"modelSelector.detailedUseFor": "Detaillierte Aufgabe fur {target}: {id}",
+	"modelSelector.generalRole": "Allgemein (ganze Rolle)",
+	"modelSelector.resetSpecialties": "Detaillierte Aufgaben zurucksetzen",
+	"modelSelector.specialty.backendArchitecture": "Backend-Architektur",
+	"modelSelector.specialty.frontendDesign": "Frontend-Design",
+	"modelSelector.specialty.implementation": "Implementierung",
+	"modelSelector.specialty.testing": "Tests",
+	"modelSelector.specialty.review": "Review",
+	"modelSelector.specialtySaved": "{specialty} verwendet {value}.",
+	"modelSelector.specialtySavedRoutingOff":
+		"{specialty} verwendet {value}, sobald eine Aufgabe diese Arbeit deklariert. Automatische Erkennung aus dem Auftragstext bleibt aus, bis task.modelRouting.enabled aktiv ist.",
+	"modelSelector.specialtyCleared": "Detaillierte Aufgaben fur {target} zuruckgesetzt.",
 	"modelSelector.reasoningFor": "Reasoning für {target}: {id}",
 	"modelSelector.temporaryModel": "temporäres Modell",
 };

package/src/i18n/messages/en.ts

@@ -95,6 +95,22 @@ export const en = {
 	"modelSelector.noMatching": "No matching models.",
 	"modelSelector.modelName": "Model Name: {value}",
 	"modelSelector.actionFor": "Action for: {id}",
+	"modelSelector.setAsTarget": "Set as {tag} ({name})",
+	"modelSelector.setForAllRoleAgents": "Set for all role agents",
+	"modelSelector.setForAllTargets": "Set for all targets",
+	"modelSelector.hasDetailedUses": "(detailed uses)",
+	"modelSelector.detailedUseFor": "Detailed use for {target}: {id}",
+	"modelSelector.generalRole": "General (whole role)",
+	"modelSelector.resetSpecialties": "Clear detailed-use overrides",
+	"modelSelector.specialty.backendArchitecture": "Backend architecture",
+	"modelSelector.specialty.frontendDesign": "Frontend design",
+	"modelSelector.specialty.implementation": "Implementation",
+	"modelSelector.specialty.testing": "Testing",
+	"modelSelector.specialty.review": "Review",
+	"modelSelector.specialtySaved": "{specialty} will use {value}.",
+	"modelSelector.specialtySavedRoutingOff":
+		"{specialty} will use {value} whenever a task declares that work. Auto-detection from assignment text stays off until you enable task.modelRouting.enabled.",
+	"modelSelector.specialtyCleared": "Cleared detailed-use overrides for {target}.",
 	"modelSelector.reasoningFor": "Reasoning for {target}: {id}",
 	"modelSelector.temporaryModel": "temporary model",
 } as const;

package/src/i18n/messages/es.ts

@@ -75,6 +75,22 @@ export const es: Partial<Record<MsgKey, string>> = {
 	"modelSelector.noMatching": "No hay modelos coincidentes.",
 	"modelSelector.modelName": "Nombre del modelo: {value}",
 	"modelSelector.actionFor": "Acción para: {id}",
+	"modelSelector.setAsTarget": "Asignar como {tag} ({name})",
+	"modelSelector.setForAllRoleAgents": "Asignar a todos los agentes de rol",
+	"modelSelector.setForAllTargets": "Asignar a todos los destinos",
+	"modelSelector.hasDetailedUses": "(usos detallados)",
+	"modelSelector.detailedUseFor": "Uso detallado de {target}: {id}",
+	"modelSelector.generalRole": "General (todo el rol)",
+	"modelSelector.resetSpecialties": "Borrar los usos detallados",
+	"modelSelector.specialty.backendArchitecture": "Arquitectura de backend",
+	"modelSelector.specialty.frontendDesign": "Diseño de frontend",
+	"modelSelector.specialty.implementation": "Implementación",
+	"modelSelector.specialty.testing": "Pruebas",
+	"modelSelector.specialty.review": "Revisión",
+	"modelSelector.specialtySaved": "{specialty} usará {value}.",
+	"modelSelector.specialtySavedRoutingOff":
+		"{specialty} usará {value} cuando una tarea declare ese trabajo. La detección automática desde el texto de la tarea sigue desactivada hasta que actives task.modelRouting.enabled.",
+	"modelSelector.specialtyCleared": "Se borraron los usos detallados de {target}.",
 	"modelSelector.reasoningFor": "Razonamiento para {target}: {id}",
 	"modelSelector.temporaryModel": "modelo temporal",
 };

package/src/i18n/messages/fr.ts

@@ -75,6 +75,22 @@ export const fr: Partial<Record<MsgKey, string>> = {
 	"modelSelector.noMatching": "Aucun modèle correspondant.",
 	"modelSelector.modelName": "Nom du modèle : {value}",
 	"modelSelector.actionFor": "Action pour : {id}",
+	"modelSelector.setAsTarget": "Définir comme {tag} ({name})",
+	"modelSelector.setForAllRoleAgents": "Definir pour tous les agents de role",
+	"modelSelector.setForAllTargets": "Definir pour toutes les cibles",
+	"modelSelector.hasDetailedUses": "(usages detailles)",
+	"modelSelector.detailedUseFor": "Usage detaille pour {target} : {id}",
+	"modelSelector.generalRole": "General (tout le role)",
+	"modelSelector.resetSpecialties": "Effacer les usages detailles",
+	"modelSelector.specialty.backendArchitecture": "Architecture backend",
+	"modelSelector.specialty.frontendDesign": "Design frontend",
+	"modelSelector.specialty.implementation": "Implementation",
+	"modelSelector.specialty.testing": "Tests",
+	"modelSelector.specialty.review": "Revue",
+	"modelSelector.specialtySaved": "{specialty} utilisera {value}.",
+	"modelSelector.specialtySavedRoutingOff":
+		"{specialty} utilisera {value} des qu'une tache declare ce travail. La detection automatique depuis le texte reste inactive sans task.modelRouting.enabled.",
+	"modelSelector.specialtyCleared": "Usages detailles effaces pour {target}.",
 	"modelSelector.reasoningFor": "Raisonnement pour {target} : {id}",
 	"modelSelector.temporaryModel": "modèle temporaire",
 };

package/src/i18n/messages/ja.ts

@@ -79,6 +79,22 @@ export const ja: Partial<Record<MsgKey, string>> = {
 	"modelSelector.noMatching": "一致するモデルがありません。",
 	"modelSelector.modelName": "モデル名: {value}",
 	"modelSelector.actionFor": "操作対象: {id}",
+	"modelSelector.setAsTarget": "{tag} に設定",
+	"modelSelector.setForAllRoleAgents": "すべてのロールエージェントに設定",
+	"modelSelector.setForAllTargets": "すべての対象に設定",
+	"modelSelector.hasDetailedUses": "（詳細用途あり）",
+	"modelSelector.detailedUseFor": "{target} の詳細用途: {id}",
+	"modelSelector.generalRole": "一般（ロール全体）",
+	"modelSelector.resetSpecialties": "詳細用途の設定を解除",
+	"modelSelector.specialty.backendArchitecture": "バックエンド設計",
+	"modelSelector.specialty.frontendDesign": "フロントエンドデザイン",
+	"modelSelector.specialty.implementation": "実装",
+	"modelSelector.specialty.testing": "テスト",
+	"modelSelector.specialty.review": "レビュー",
+	"modelSelector.specialtySaved": "{specialty} には {value} を使用します。",
+	"modelSelector.specialtySavedRoutingOff":
+		"{specialty} として宣言されたタスクには {value} を使用します。指示文からの自動判定は task.modelRouting.enabled を有効にするまで無効です。",
+	"modelSelector.specialtyCleared": "{target} の詳細用途設定を解除しました。",
 	"modelSelector.reasoningFor": "{target} の推論レベル: {id}",
 	"modelSelector.temporaryModel": "一時モデル",
 };

package/src/i18n/messages/ko.ts

@@ -79,6 +79,22 @@ export const ko: Partial<Record<MsgKey, string>> = {
 	"modelSelector.noMatching": "일치하는 모델이 없습니다.",
 	"modelSelector.modelName": "모델 이름: {value}",
 	"modelSelector.actionFor": "작업 대상: {id}",
+	"modelSelector.setAsTarget": "{tag}에 설정",
+	"modelSelector.setForAllRoleAgents": "모든 역할 에이전트에 설정",
+	"modelSelector.setForAllTargets": "모든 대상에 설정",
+	"modelSelector.hasDetailedUses": "(세부 업무 있음)",
+	"modelSelector.detailedUseFor": "{target} 세부 업무: {id}",
+	"modelSelector.generalRole": "일반 (역할 전체)",
+	"modelSelector.resetSpecialties": "세부 업무 설정 해제",
+	"modelSelector.specialty.backendArchitecture": "백엔드 아키텍처",
+	"modelSelector.specialty.frontendDesign": "프런트엔드 디자인",
+	"modelSelector.specialty.implementation": "구현",
+	"modelSelector.specialty.testing": "테스트",
+	"modelSelector.specialty.review": "리뷰",
+	"modelSelector.specialtySaved": "{specialty} 작업에 {value}을(를) 사용합니다.",
+	"modelSelector.specialtySavedRoutingOff":
+		"{specialty} 작업으로 선언된 태스크는 {value}을(를) 사용합니다. 지시문에서 자동 감지하려면 task.modelRouting.enabled를 켜야 합니다.",
+	"modelSelector.specialtyCleared": "{target}의 세부 업무 설정을 해제했습니다.",
 	"modelSelector.reasoningFor": "{target} 추론 수준: {id}",
 	"modelSelector.temporaryModel": "임시 모델",
 };

package/src/i18n/messages/zh.ts

@@ -79,6 +79,22 @@ export const zh: Partial<Record<MsgKey, string>> = {
 	"modelSelector.noMatching": "没有匹配的模型。",
 	"modelSelector.modelName": "模型名称：{value}",
 	"modelSelector.actionFor": "操作对象：{id}",
+	"modelSelector.setAsTarget": "设为 {tag}",
+	"modelSelector.setForAllRoleAgents": "设为所有角色代理",
+	"modelSelector.setForAllTargets": "设为所有对象",
+	"modelSelector.hasDetailedUses": "（含细分用途）",
+	"modelSelector.detailedUseFor": "{target} 的细分用途：{id}",
+	"modelSelector.generalRole": "通用（整个角色）",
+	"modelSelector.resetSpecialties": "清除细分用途设置",
+	"modelSelector.specialty.backendArchitecture": "后端架构",
+	"modelSelector.specialty.frontendDesign": "前端设计",
+	"modelSelector.specialty.implementation": "实现",
+	"modelSelector.specialty.testing": "测试",
+	"modelSelector.specialty.review": "评审",
+	"modelSelector.specialtySaved": "{specialty} 将使用 {value}。",
+	"modelSelector.specialtySavedRoutingOff":
+		"声明为 {specialty} 的任务将使用 {value}。若要从任务文本自动识别，需开启 task.modelRouting.enabled。",
+	"modelSelector.specialtyCleared": "已清除 {target} 的细分用途设置。",
 	"modelSelector.reasoningFor": "{target} 的推理级别：{id}",
 	"modelSelector.temporaryModel": "临时模型",
 };