@sayknow-cli/coding-agent 0.5.24 → 0.5.25

package/CHANGELOG.md

@@ -2,7 +2,7 @@
 
 ## [Unreleased]
 
-## [0.5.24] - 2026-09-21
+## [0.5.25] - 2026-09-21
 
 ## [0.5.22] - 2026-09-19
 

package/dist/types/config/settings-schema.d.ts

@@ -2457,6 +2457,20 @@ export declare const SETTINGS_SCHEMA: {
         readonly type: "string";
         readonly 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.
+     */
+    readonly "task.modelRouting.frontendModel": {
+        readonly type: "string";
+        readonly default: "";
+    };
     readonly "ttsr.enabled": {
         readonly type: "boolean";
         readonly default: true;

package/dist/types/decisions/task-routing.d.ts

@@ -19,8 +19,31 @@ export interface TaskRoutingPolicy {
      * this bar sits higher than the upgrade bar on purpose.
      */
     minDowngradeConfidence: number;
+    /**
+     * Model for frontend planning, when the assignment reads as frontend work.
+     *
+     * This is the **domain** axis, not a rung on the ladder: a design-strong model
+     * is not "better" than a code-strong one, it is a different specialty. Only
+     * planning roles ever take it, and only laterally — the implementation roles
+     * stay on the difficulty ladder.
+     */
+    frontendModel?: string;
+    /**
+     * Bar for the lateral swap above. Directional bars do not apply here because
+     * neither direction is "spending more": being wrong either way costs quality,
+     * symmetrically, so one bar is the whole story.
+     */
+    minDomainConfidence: number;
 }
 export declare const DEFAULT_TASK_ROUTING_POLICY: Omit<TaskRoutingPolicy, "tiers">;
+/**
+ * Roles whose output is a plan or a design review.
+ *
+ * These are the only roles the domain swap applies to — the user's intent is
+ * "a design-strong model *plans* the frontend; implementation stays where it
+ * is". Executor keeps the difficulty ladder regardless of domain.
+ */
+export declare const PLANNING_ROLES: ReadonlySet<string>;
 export interface TaskRoutingRequest {
     agentName: string;
     /** The assignment text the subagent will act on. */
@@ -31,7 +54,8 @@ export interface TaskRoutingRequest {
 }
 export interface TaskRoutingResult {
     model: string;
-    tier: TaskTier;
+    /** Null when the move was a domain swap — that axis has no ladder. */
+    tier: TaskTier | null;
     reason: string;
 }
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@sayknow-cli/coding-agent",
-	"version": "0.5.24",
+	"version": "0.5.25",
 	"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.25",
+		"@sayknow-cli/agent-core": "0.5.25",
+		"@sayknow-cli/ai": "0.5.25",
+		"@sayknow-cli/natives": "0.5.25",
+		"@sayknow-cli/tui": "0.5.25",
+		"@sayknow-cli/utils": "0.5.25",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",

package/src/config/settings-schema.ts

@@ -2039,6 +2039,17 @@ 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: "" },
 
 	// TTSR
 	"ttsr.enabled": {

package/src/decisions/task-routing.ts

@@ -37,6 +37,21 @@ export interface TaskRoutingPolicy {
 	 * this bar sits higher than the upgrade bar on purpose.
 	 */
 	minDowngradeConfidence: number;
+	/**
+	 * Model for frontend planning, when the assignment reads as frontend work.
+	 *
+	 * This is the **domain** axis, not a rung on the ladder: a design-strong model
+	 * is not "better" than a code-strong one, it is a different specialty. Only
+	 * planning roles ever take it, and only laterally — the implementation roles
+	 * stay on the difficulty ladder.
+	 */
+	frontendModel?: string;
+	/**
+	 * Bar for the lateral swap above. Directional bars do not apply here because
+	 * neither direction is "spending more": being wrong either way costs quality,
+	 * symmetrically, so one bar is the whole story.
+	 */
+	minDomainConfidence: number;
 }
 
 export const DEFAULT_TASK_ROUTING_POLICY: Omit<TaskRoutingPolicy, "tiers"> = {
@@ -46,8 +61,18 @@ export const DEFAULT_TASK_ROUTING_POLICY: Omit<TaskRoutingPolicy, "tiers"> = {
 	// overriding one needs a stronger signal in either direction.
 	minUpgradeConfidence: 0.5,
 	minDowngradeConfidence: 0.75,
+	minDomainConfidence: 0.6,
 };
 
+/**
+ * Roles whose output is a plan or a design review.
+ *
+ * These are the only roles the domain swap applies to — the user's intent is
+ * "a design-strong model *plans* the frontend; implementation stays where it
+ * is". Executor keeps the difficulty ladder regardless of domain.
+ */
+export const PLANNING_ROLES: ReadonlySet<string> = new Set(["planner", "architect"]);
+
 /**
  * The questions describe the *work*, never a model name.
  *
@@ -71,6 +96,11 @@ function buildQuestions(): Record<string, Question> {
 			instructions:
 				"Does this assignment touch production, money, credentials, published releases, or state that cannot be undone?",
 		},
+		domain: {
+			type: "noul",
+			instructions:
+				"Is this assignment frontend/UI work — interfaces, components, visual design, styling or interaction — rather than data, APIs, infrastructure or business logic?",
+		},
 	};
 }
 
@@ -85,7 +115,8 @@ export interface TaskRoutingRequest {
 
 export interface TaskRoutingResult {
 	model: string;
-	tier: TaskTier;
+	/** Null when the move was a domain swap — that axis has no ladder. */
+	tier: TaskTier | null;
 	reason: string;
 }
 
@@ -140,9 +171,9 @@ export async function routeTaskModel(
 	request: TaskRoutingRequest,
 ): Promise<TaskRoutingResult | null> {
 	const configured = TASK_TIERS.filter(tier => policy.tiers[tier]);
-	// One tier is not a ladder; with nothing to move between there is no decision
-	// worth paying a model call for.
-	if (configured.length < 2) return null;
+	const frontendModel = policy.frontendModel?.trim() || undefined;
+	// Neither axis has anything to move on: no ladder and no domain model.
+	if (configured.length < 2 && !frontendModel) return null;
 
 	const assignment = request.assignment.trim();
 	if (assignment.length < 24) return null;
@@ -154,6 +185,37 @@ export async function routeTaskModel(
 	});
 	if (!result) return null;
 
+	// --- Domain axis: lateral swap for planning roles ---
+	//
+	// A design-strong model is not "more capable" than a code-strong one, so this
+	// is not a rung on the ladder and the directional bars do not apply. When the
+	// assignment clearly reads as frontend work and a frontend model is
+	// configured, planning roles take it — that is the whole of the user's
+	// intent: the design model *plans* the frontend, implementation stays put.
+	// When the swap fires, the difficulty ladder is skipped entirely for this
+	// spawn; for planning, design judgment is the point, not raw capability.
+	const domainAnswer = result.answers.domain;
+	if (
+		frontendModel &&
+		PLANNING_ROLES.has(request.agentName) &&
+		domainAnswer?.type === "noul" &&
+		domainAnswer.noul >= policy.minDomainConfidence
+	) {
+		if (request.currentModel && matchesModel(frontendModel, request.currentModel)) return null;
+		logger.debug("decisions/task-routing: routed", {
+			agent: request.agentName,
+			model: frontendModel,
+			reason: `frontend (domain ${domainAnswer.noul.toFixed(2)})`,
+		});
+		return {
+			model: frontendModel,
+			tier: null,
+			reason: `frontend (domain ${domainAnswer.noul.toFixed(2)})`,
+		};
+	}
+
+	// --- Difficulty axis: the ladder ---
+	if (configured.length < 2) return null;
 	const answer = result.answers.tier;
 	if (answer?.type !== "choice") return null;
 	let tier = TASK_TIERS.find(candidate => candidate === answer.choice);

package/src/task/index.ts

@@ -484,7 +484,8 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 			balanced: this.session.settings.get("task.modelRouting.balancedModel") || undefined,
 			deep: this.session.settings.get("task.modelRouting.deepModel") || undefined,
 		};
-		if (Object.values(tiers).filter(Boolean).length < 2) return undefined;
+		const frontendModel = this.session.settings.get("task.modelRouting.frontendModel") || undefined;
+		if (Object.values(tiers).filter(Boolean).length < 2 && !frontendModel) return undefined;
 
 		const assignment = (tasks ?? [])
 			.map(task => [task.description, task.assignment].filter(Boolean).join("\n"))
@@ -499,7 +500,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 			if (!registry) return undefined;
 			const routed = await routeTaskModel(
 				createDecisionService({ registry, settings: this.session.settings, enabled: true }),
-				{ ...DEFAULT_TASK_ROUTING_POLICY, tiers },
+				{ ...DEFAULT_TASK_ROUTING_POLICY, tiers, frontendModel },
 				// A role may be configured with a fallback chain; the first entry is what it
 				// actually runs on, so that is the baseline the direction is measured from.
 				{