@sayknow-cli/coding-agent 0.5.24 → 0.5.26

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@sayknow-cli/coding-agent",
-	"version": "0.5.24",
+	"version": "0.5.26",
 	"description": "Sayknow-CLI CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://sayknow-cli.com",
 	"author": "jaybeyond",
@@ -54,12 +54,12 @@
 		"@agentclientprotocol/sdk": "1.3.0",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@sayknow-cli/stats": "0.5.24",
-		"@sayknow-cli/agent-core": "0.5.24",
-		"@sayknow-cli/ai": "0.5.24",
-		"@sayknow-cli/natives": "0.5.24",
-		"@sayknow-cli/tui": "0.5.24",
-		"@sayknow-cli/utils": "0.5.24",
+		"@sayknow-cli/stats": "0.5.26",
+		"@sayknow-cli/agent-core": "0.5.26",
+		"@sayknow-cli/ai": "0.5.26",
+		"@sayknow-cli/natives": "0.5.26",
+		"@sayknow-cli/tui": "0.5.26",
+		"@sayknow-cli/utils": "0.5.26",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",

package/src/config/settings-schema.ts

@@ -5,6 +5,7 @@ import { getThinkingLevelMetadata } from "../thinking-metadata";
 import { EDIT_MODES } from "../utils/edit-mode";
 import { CONFIGURABLE_SEARCH_PROVIDER_IDS } from "../web/search/types";
 import type { ModelSelectorValue } from "./model-selector-value";
+import { TASK_MODEL_SPECIALTY_IDS } from "./task-model-specialties";
 
 const THINKING_EFFORTS = ["minimal", "low", "medium", "high", "xhigh", "max"] as readonly Effort[];
 const DEFAULT_THINKING_LEVELS = ["off", ...THINKING_EFFORTS] as const;
@@ -192,6 +193,11 @@ interface RecordDef<T> {
 	type: "record";
 	default: Record<string, T>;
 	valueSchema?: RecordValueDef;
+	/**
+	 * Closed key set. When present, reconciliation rejects any other key instead of
+	 * silently carrying a typo that no consumer will ever read.
+	 */
+	keys?: readonly string[];
 	ui?: UiBase;
 }
 
@@ -2039,6 +2045,36 @@ export const SETTINGS_SCHEMA = {
 	"task.modelRouting.balancedModel": { type: "string", default: "" },
 	/** Most capable tier. Unclear cause, cross-cutting design, hard to undo. */
 	"task.modelRouting.deepModel": { type: "string", default: "" },
+	/**
+	 * Frontend planning model — the **domain** axis.
+	 *
+	 * When a planning role (planner/architect) is handed work that clearly reads
+	 * as frontend/UI, it takes this model instead of the ladder's answer. A
+	 * design-strong model is not "more capable" than a code-strong one; this is a
+	 * lateral swap. Unset disables it entirely, and implementation roles are
+	 * never swapped by domain — the user asked for the design model to plan the
+	 * frontend, not to write it.
+	 */
+	"task.modelRouting.frontendModel": { type: "string", default: "" },
+	/**
+	 * Per-specialty models — the **work-kind** axis.
+	 *
+	 * Keys are the bounded ids in `config/task-model-specialties.ts`; values use the
+	 * same selector grammar as any other model setting, so a chain is allowed. A
+	 * specialty with no entry inherits the role's resolved model unchanged, which is
+	 * why the default is empty rather than pre-populated.
+	 *
+	 * These are routing hints, never agents: nothing here widens the canonical role
+	 * roster, model-profile role keys, tool grants, or spawn permissions. Saving one
+	 * does not enable `task.modelRouting.enabled`; the assignment surface reports the
+	 * disabled state instead of silently turning routing on.
+	 */
+	"task.modelRouting.specialtyModels": {
+		type: "record",
+		default: {} as Record<string, ModelSelectorValue>,
+		valueSchema: MODEL_SELECTOR_VALUE_SCHEMA,
+		keys: TASK_MODEL_SPECIALTY_IDS,
+	},
 
 	// TTSR
 	"ttsr.enabled": {
@@ -4068,15 +4104,20 @@ export function reconcileSettingsSchema(raw: Record<string, unknown>): {
 		}
 		if (!validSettingValue(definition, next))
 			issues.push({ path, kind: "invalid", detail: `Expected ${definition.type}.` });
-		if (
-			definition.type === "record" &&
-			"valueSchema" in definition &&
-			definition.valueSchema &&
-			validSettingValue(definition, next)
-		) {
+		if (definition.type === "record" && validSettingValue(definition, next)) {
+			const allowedKeys = "keys" in definition && definition.keys ? new Set<string>(definition.keys) : undefined;
+			const valueSchema = "valueSchema" in definition ? definition.valueSchema : undefined;
 			for (const [key, entry] of Object.entries(next as Record<string, unknown>)) {
+				if (allowedKeys && !allowedKeys.has(key)) {
+					issues.push({
+						path: `${path}.${key}`,
+						kind: "invalid",
+						detail: `Unknown key. Expected one of: ${[...allowedKeys].join(", ")}.`,
+					});
+					continue;
+				}
 				if (
-					definition.valueSchema.type === "model-selector-value" &&
+					valueSchema?.type === "model-selector-value" &&
 					!(typeof entry === "string" || (Array.isArray(entry) && entry.every(item => typeof item === "string")))
 				) {
 					issues.push({ path: `${path}.${key}`, kind: "invalid", detail: "Expected model-selector-value." });

package/src/config/task-model-specialties.ts

@@ -0,0 +1,131 @@
+/**
+ * Bounded work-specialty axis for subagent model selection.
+ *
+ * A canonical role model is a standing guess about the *average* assignment that
+ * role gets. The difficulty ladder in `decisions/task-routing.ts` moves that guess
+ * when one assignment is unusually hard or unusually mechanical. This axis moves it
+ * for a different reason: the assignment belongs to a *kind of work* the user has
+ * deliberately picked a model for — backend architecture, frontend design, plain
+ * implementation, test work, or review.
+ *
+ * Specialties are **not agents**. They never appear in agent discovery, task `agent`
+ * values, prompts, tool grants, spawn allowlists, or model-profile role keys. The
+ * canonical roster stays exactly `executor`, `architect`, `planner`, `critic`, and
+ * `default` remains the main-model assignment target. A specialty only ever selects
+ * a model for work that is already being routed to one of those roles.
+ */
+import { normalizeModelSelectorValue } from "./model-selector-value";
+
+/** Stable configuration/routing identifiers. Display strings are localized separately. */
+export const TASK_MODEL_SPECIALTY_IDS = [
+	"backendArchitecture",
+	"frontendDesign",
+	"implementation",
+	"testing",
+	"review",
+] as const;
+
+export type TaskModelSpecialty = (typeof TASK_MODEL_SPECIALTY_IDS)[number];
+
+/**
+ * Which canonical role agents may receive each specialty.
+ *
+ * Planning roles share the two design specialties on purpose: the user's intent is
+ * "a backend-strong model plans backend work", not "planner and architect each get
+ * their own private backend model". Implementation roles never take a design
+ * specialty, mirroring the existing frontend-domain rule.
+ */
+export const TASK_MODEL_SPECIALTY_ROLES: Readonly<Record<TaskModelSpecialty, readonly string[]>> = {
+	backendArchitecture: ["planner", "architect"],
+	frontendDesign: ["planner", "architect"],
+	implementation: ["executor"],
+	testing: ["executor"],
+	review: ["critic"],
+};
+
+/** Neutral classifier outcome: the work does not clearly belong to one specialty. */
+export const TASK_MODEL_SPECIALTY_NONE = "none" as const;
+
+/** Bounded-key predicate for the `task.modelRouting.specialtyModels` record. */
+export function isTaskModelSpecialty(value: unknown): value is TaskModelSpecialty {
+	return typeof value === "string" && (TASK_MODEL_SPECIALTY_IDS as readonly string[]).includes(value);
+}
+
+/** Specialties a given canonical role agent is allowed to receive, in declaration order. */
+export function specialtiesForRole(agentName: string): TaskModelSpecialty[] {
+	return TASK_MODEL_SPECIALTY_IDS.filter(specialty => TASK_MODEL_SPECIALTY_ROLES[specialty].includes(agentName));
+}
+
+/** Whether a specialty may be applied to work routed to this canonical role agent. */
+export function specialtySupportsRole(specialty: TaskModelSpecialty, agentName: string): boolean {
+	return TASK_MODEL_SPECIALTY_ROLES[specialty].includes(agentName);
+}
+
+/** Where a composed candidate came from, so a receipt never overstates what was selected. */
+export type TaskRoutingSource = "specialty" | "legacy-frontend" | "tier" | "baseline";
+
+export interface TaskRoutingCandidate {
+	/** The configured selector, normalized but otherwise untouched. */
+	selector: string;
+	source: TaskRoutingSource;
+	/** Set when `source` is `specialty` or `legacy-frontend`. */
+	specialty?: TaskModelSpecialty;
+	/** Set when `source` is `tier`. */
+	tier?: string;
+}
+
+/**
+ * Identity used for deduplication.
+ *
+ * An explicit thinking suffix is part of the identity: `provider/model:high` and
+ * `provider/model:low` are different configured intents, and collapsing them would
+ * silently drop the user's effort choice from a chain.
+ */
+export function specialtySelectorIdentity(selector: string): string {
+	return selector.trim().toLowerCase();
+}
+
+/** The `provider/model` part, ignoring any thinking suffix. Used for "same model" checks. */
+export function specialtySelectorHead(selector: string): string {
+	return specialtySelectorIdentity(selector).split(":")[0]?.trim() ?? "";
+}
+
+/** Expand a configured selector value into normalized candidates tagged with their origin. */
+export function toRoutingCandidates(
+	value: string | readonly string[] | undefined,
+	source: TaskRoutingSource,
+	extra?: { specialty?: TaskModelSpecialty; tier?: string },
+): TaskRoutingCandidate[] {
+	return normalizeModelSelectorValue(value)
+		.map(selector => selector.trim())
+		.filter(selector => selector.length > 0)
+		.map(selector => ({ selector, source, ...extra }));
+}
+
+/**
+ * Concatenate candidate segments, keeping the first occurrence of each identity.
+ *
+ * A selector that also exists in the baseline segment is attributed to `baseline`
+ * even when an earlier specialty segment introduced it. Resolving that entry proves
+ * only that the role's own configured model was usable — reporting it as a specialty
+ * hit would claim a routing decision that never happened.
+ */
+export function dedupeRoutingCandidates(segments: readonly TaskRoutingCandidate[][]): TaskRoutingCandidate[] {
+	const flattened = segments.flat();
+	const baselineIdentities = new Set(
+		flattened.filter(candidate => candidate.source === "baseline").map(c => specialtySelectorIdentity(c.selector)),
+	);
+	const seen = new Set<string>();
+	const deduped: TaskRoutingCandidate[] = [];
+	for (const candidate of flattened) {
+		const identity = specialtySelectorIdentity(candidate.selector);
+		if (seen.has(identity)) continue;
+		seen.add(identity);
+		deduped.push(
+			candidate.source !== "baseline" && baselineIdentities.has(identity)
+				? { selector: candidate.selector, source: "baseline" }
+				: candidate,
+		);
+	}
+	return deduped;
+}