@sayknow-cli/coding-agent 0.5.25 → 0.6.0

package/src/decisions/llm-backend.ts

@@ -154,11 +154,21 @@ export interface LlmBackendDeps {
 	maxInputCostPerMTok?: number;
 	/** Injected in tests to make the local-runtime probe deterministic. */
 	fetchImpl?: typeof fetch;
+	/** Injected in tests to script provider answers without a network. */
+	completeImpl?: typeof completeSimple;
+	/** Per-candidate deadline; injected in tests so a hung provider does not cost real seconds. */
+	attemptTimeoutMs?: number;
 	registry: ModelRegistry;
 	settings: Settings;
 	sessionId?: string;
 	/** Overrides role resolution; used by callers that already picked a model. */
 	model?: Model<Api>;
+	/**
+	 * Provider of the model the caller is already talking to. Its small model is tried
+	 * first when nothing was configured; see `rankSmallModels` for why. A thunk is
+	 * accepted so a long-lived backend follows the session when the user switches model.
+	 */
+	preferredProvider?: string | (() => string | undefined);
 }
 
 /**
@@ -188,6 +198,23 @@ function isTextOnly(model: Model<Api>): boolean {
 	return (model.input ?? ["text"]).includes("text") && !(model.output ?? ["text"]).includes("image");
 }
 
+/**
+ * Local runtimes list embedding models next to chat models with identical metadata.
+ * Measured: `ollama/nomic-embed-text:latest` was ranked as a candidate and answered
+ * HTTP 400 "does not support chat". Nothing in `Model` says so; the id does.
+ */
+const EMBEDDING_MODEL_ID = /embed/i;
+
+/**
+ * Parameter count from a local model id (`qwen3:1.7b`, `gemma4:e4b`, `lfm2-24b-a2b`),
+ * used only to order local candidates: smaller loads faster and answers faster, and a
+ * five-way choice does not need a 30b model. Unparseable ids sort last.
+ */
+function localModelSize(id: string): number {
+	const match = /(\d+(?:\.\d+)?)b(?![a-z])/i.exec(id);
+	return match ? Number(match[1]) : Number.POSITIVE_INFINITY;
+}
+
 /**
  * Locally hosted runtimes. A decision answered here costs no tokens at all and the
  * state never leaves the machine, which is the strongest possible fit for this feature.
@@ -236,7 +263,50 @@ async function isLocalRuntimeAlive(baseUrl: string, fetchImpl: typeof fetch = fe
 }
 
 /**
- * Pick a small, fast text model.
+ * A model that answered a decision with an error or a timeout, skipped for a while.
+ *
+ * The catalog lists models the provider no longer serves — `claude-3-haiku-20240307`
+ * was the cheapest Anthropic entry and answered 404 on every call — and it lists
+ * "free" reasoning tiers that ignore `disableReasoning` and take ~9s to answer. Either
+ * one, chosen blindly, turned the fallback into a fixed ~1-9s stall that answered
+ * nothing, on every turn, forever. Remembering the failure means one bad turn per
+ * model per TTL, not one per prompt.
+ */
+const DEAD_MODEL_TTL_MS = 10 * 60_000;
+const deadModels = new Map<string, { at: number; reason: string }>();
+
+/** Reset between tests. */
+export function clearDeadModelCache(): void {
+	deadModels.clear();
+}
+
+function modelKey(model: Model<Api>): string {
+	return `${model.provider}/${model.id}`;
+}
+
+function isDead(model: Model<Api>): boolean {
+	const entry = deadModels.get(modelKey(model));
+	if (!entry) return false;
+	if (Date.now() - entry.at < DEAD_MODEL_TTL_MS) return true;
+	deadModels.delete(modelKey(model));
+	return false;
+}
+
+/**
+ * Candidates tried per decision when nothing was configured. Two attempts of
+ * `ATTEMPT_TIMEOUT_MS` fit inside the service's 8s deadline with room for the
+ * liveness probe; a third only runs when the earlier ones failed fast (404, auth).
+ */
+const MAX_AUTO_ATTEMPTS = 3;
+/**
+ * Per-attempt budget. The hosted small models measured here answer in 0.3-1.3s; the
+ * ones that blow this are reasoning tiers that think despite being told not to, and
+ * the right response to those is the next candidate, not a longer wait.
+ */
+const ATTEMPT_TIMEOUT_MS = 3_500;
+
+/**
+ * Rank small, fast text models, best first.
  *
  * Sorting by price alone is a trap, and it was measured: the cheapest qualifying model
  * on this registry is free but took **4.8s** per routing decision — three times slower
@@ -244,29 +314,44 @@ async function isLocalRuntimeAlive(baseUrl: string, fetchImpl: typeof fetch = fe
  * are dominated by reasoning models. A decision service that is cheap and slow has
  * missed the point twice over.
  *
- * So non-reasoning wins first, price second. Ties break by id so the choice is stable
- * across runs; a backend that silently changed model between turns would make routing
- * non-reproducible, which is most of what this feature is for.
+ * The provider the user is already chatting with goes first. Measured on a registry
+ * with Anthropic, Codex and Z.ai keys: price order put four `zai/glm-*` tiers ahead of
+ * `claude-haiku-4-5`, and the first of them took 8.9s — past the service deadline, so
+ * the answer was nothing. The user's own provider is the credential known to work, the
+ * bill they expect to see, and (Haiku next to Opus, mini next to GPT) the small model
+ * they would have picked by hand. Within a provider, non-reasoning wins, then price.
+ * Ties break by id so the choice is stable across runs; a backend that silently changed
+ * model between turns would make routing non-reproducible, which is most of what this
+ * feature is for.
  */
-async function pickSmallModel(
+async function rankSmallModels(
 	available: Model<Api>[],
 	costCeiling: number,
+	preferredProvider: string | undefined,
 	fetchImpl?: typeof fetch,
-): Promise<Model<Api> | undefined> {
-	// A local runtime that is actually up wins outright: zero tokens, zero egress. Its
-	// size is not screened the way hosted models are — if the user loaded it, they chose
-	// it, and trying costs nothing.
+): Promise<Model<Api>[]> {
+	// A live local runtime goes first: zero tokens, zero egress. One candidate only —
+	// measured with Ollama on CPU, every loaded model blew the attempt budget on a cold
+	// start, and with five of them ranked ahead of every hosted model the hosted
+	// fallback was never reached before the service deadline. One local miss now costs
+	// one attempt, after which the dead-model cache sends the next ten minutes of
+	// decisions straight to the hosted candidate.
+	const ranked: Model<Api>[] = [];
 	const local = available
-		.filter(model => LOCAL_PROVIDERS.has(model.provider) && isTextOnly(model))
-		.sort((a, b) => a.id.localeCompare(b.id));
+		.filter(model => LOCAL_PROVIDERS.has(model.provider) && isTextOnly(model) && !EMBEDDING_MODEL_ID.test(model.id))
+		.sort((a, b) => localModelSize(a.id) - localModelSize(b.id) || a.id.localeCompare(b.id));
 	for (const model of local) {
+		// The smallest one missing parks the whole runtime for the TTL; trying the next
+		// size up would only repeat the cold-start stall on the next turn.
+		if (isDead(model)) break;
 		if (await isLocalRuntimeAlive(model.baseUrl, fetchImpl)) {
-			logger.debug("decisions/llm: using local runtime", { id: `${model.provider}/${model.id}` });
-			return model;
+			logger.debug("decisions/llm: using local runtime", { id: modelKey(model) });
+			ranked.push(model);
+			break;
 		}
 	}
 
-	return available
+	const hosted = available
 		.filter(
 			model =>
 				isTextOnly(model) &&
@@ -276,12 +361,18 @@ async function pickSmallModel(
 		)
 		.sort(
 			(a, b) =>
-				Number(!!a.reasoning) - Number(!!b.reasoning) || a.cost.input - b.cost.input || a.id.localeCompare(b.id),
-		)[0];
+				Number(b.provider === preferredProvider) - Number(a.provider === preferredProvider) ||
+				Number(!!a.reasoning) - Number(!!b.reasoning) ||
+				a.cost.input - b.cost.input ||
+				a.id.localeCompare(b.id),
+		);
+	return ranked.concat(hosted);
 }
 
 export function createLlmDecisionBackend(deps: LlmBackendDeps): DecisionBackend {
 	const costCeiling = deps.maxInputCostPerMTok ?? DEFAULT_MAX_INPUT_COST_PER_MTOK;
+	const complete = deps.completeImpl ?? completeSimple;
+	const attemptTimeoutMs = deps.attemptTimeoutMs ?? ATTEMPT_TIMEOUT_MS;
 	return {
 		name: "llm",
 		async decide(request: DecisionRequest): Promise<DecisionResult | null> {
@@ -290,67 +381,122 @@ export function createLlmDecisionBackend(deps: LlmBackendDeps): DecisionBackend
 			// Resolution order, cheapest intent first:
 			//   1. an explicit override — the caller already decided
 			//   2. the `smol` role — the user already decided
-			//   3. the cheapest small model on hand — nobody decided, so decide safely
+			//   3. the ranked small models on hand — nobody decided, so decide safely,
+			//      and move on when one is dead or slow
 			// `default` is deliberately absent: it is whatever the user chats with, which is
 			// exactly the frontier model this feature exists to avoid spending on.
-			const chosen =
-				deps.model ??
-				resolveRoleSelection(["smol"], deps.settings, available, deps.registry)?.model ??
-				(await pickSmallModel(available, costCeiling, deps.fetchImpl));
-			if (!chosen) {
+			const configured =
+				deps.model ?? resolveRoleSelection(["smol"], deps.settings, available, deps.registry)?.model;
+			const preferredProvider =
+				typeof deps.preferredProvider === "function" ? deps.preferredProvider() : deps.preferredProvider;
+			const candidates = configured
+				? [configured]
+				: (await rankSmallModels(available, costCeiling, preferredProvider, deps.fetchImpl))
+						.filter(model => !isDead(model))
+						.slice(0, MAX_AUTO_ATTEMPTS);
+			if (candidates.length === 0) {
 				logger.debug("decisions/llm: no small model available; leaving the decision to existing behaviour");
 				return null;
 			}
-			const model = chosen;
-			// The ceiling still applies to an explicitly configured `smol` role — a role can
-			// point anywhere, including at a frontier model.
-			if (!deps.model && model.cost.input > costCeiling) {
-				logger.debug("decisions/llm: declining, model too expensive for a decision", {
-					id: `${model.provider}/${model.id}`,
-					inputCostPerMTok: model.cost.input,
-					ceiling: costCeiling,
-				});
-				return null;
-			}
-			const apiKey = await deps.registry.getApiKey(model, deps.sessionId);
-			if (!apiKey) {
-				logger.debug("decisions/llm: no credential", { provider: model.provider, id: model.id });
-				return null;
-			}
 
 			const text = stateToText(request.state);
 			const state = text.length > MAX_STATE_CHARS ? `${text.slice(0, MAX_STATE_CHARS)}…` : text;
-			const started = Date.now();
-			const response = await completeSimple(
-				model,
-				{
-					systemPrompt: [SYSTEM_PROMPT],
-					messages: [{ role: "user", content: `<state>\n${state}\n</state>`, timestamp: Date.now() }],
-					tools: [buildTool(request.questions)],
-				},
-				{
-					apiKey,
-					maxTokens: model.reasoning ? Math.max(MAX_TOKENS, REASONING_SAFE_MAX_TOKENS) : MAX_TOKENS,
-					disableReasoning: true,
-					toolChoice: { type: "tool", name: TOOL_NAME },
-					signal: request.signal,
-				},
-			);
 
-			const args = readToolArguments(response.content);
-			if (!args) {
-				logger.debug("decisions/llm: model did not emit the forced tool call");
-				return null;
+			for (const model of candidates) {
+				if (request.signal?.aborted) return null;
+				// The ceiling still applies to an explicitly configured `smol` role — a role can
+				// point anywhere, including at a frontier model.
+				if (!deps.model && model.cost.input > costCeiling) {
+					logger.debug("decisions/llm: declining, model too expensive for a decision", {
+						id: modelKey(model),
+						inputCostPerMTok: model.cost.input,
+						ceiling: costCeiling,
+					});
+					return null;
+				}
+				const apiKey = await deps.registry.getApiKey(model, deps.sessionId);
+				if (!apiKey) {
+					logger.debug("decisions/llm: no credential", { provider: model.provider, id: model.id });
+					return null;
+				}
+				// The credential lookup awaited; an abort in that window would be missed by
+				// the listener registered below.
+				if (request.signal?.aborted) return null;
+
+				const controller = new AbortController();
+				const abortOnCaller = () => controller.abort();
+				request.signal?.addEventListener("abort", abortOnCaller, { once: true });
+				let timedOut = false;
+				const timer = setTimeout(() => {
+					timedOut = true;
+					controller.abort();
+				}, attemptTimeoutMs);
+				const started = Date.now();
+				let response: AssistantMessage;
+				try {
+					response = await complete(
+						model,
+						{
+							systemPrompt: [SYSTEM_PROMPT],
+							messages: [{ role: "user", content: `<state>\n${state}\n</state>`, timestamp: Date.now() }],
+							tools: [buildTool(request.questions)],
+						},
+						{
+							apiKey,
+							maxTokens: model.reasoning ? Math.max(MAX_TOKENS, REASONING_SAFE_MAX_TOKENS) : MAX_TOKENS,
+							disableReasoning: true,
+							toolChoice: { type: "tool", name: TOOL_NAME },
+							signal: controller.signal,
+						},
+					);
+				} catch (error) {
+					// A thrown transport error is as dead as a 404 for our purposes.
+					response = {
+						role: "assistant",
+						content: [],
+						stopReason: "error",
+						errorMessage: String(error),
+					} as unknown as AssistantMessage;
+				} finally {
+					clearTimeout(timer);
+					request.signal?.removeEventListener("abort", abortOnCaller);
+				}
+
+				if (request.signal?.aborted) return null;
+				if (timedOut || response.stopReason === "error" || response.stopReason === "aborted") {
+					const reason = timedOut
+						? `timeout after ${attemptTimeoutMs}ms`
+						: `${response.errorStatus ?? response.stopReason}: ${(response.errorMessage ?? "").slice(0, 200)}`;
+					deadModels.set(modelKey(model), { at: Date.now(), reason });
+					logger.debug("decisions/llm: model failed, trying the next candidate", {
+						id: modelKey(model),
+						reason,
+						durationMs: Date.now() - started,
+					});
+					continue;
+				}
+
+				const args = readToolArguments(response.content);
+				if (!args) {
+					// The provider answered but ignored the forced tool: a model answer, not an
+					// availability problem, so it is neither retried nor remembered as dead.
+					logger.debug("decisions/llm: model did not emit the forced tool call", {
+						id: modelKey(model),
+						stopReason: response.stopReason,
+					});
+					return null;
+				}
+				const answers = toAnswers(request.questions, args);
+				if (Object.keys(answers).length === 0) return null;
+				return {
+					answers,
+					backend: "llm",
+					model: modelKey(model),
+					calibrated: false,
+					durationMs: Date.now() - started,
+				};
 			}
-			const answers = toAnswers(request.questions, args);
-			if (Object.keys(answers).length === 0) return null;
-			return {
-				answers,
-				backend: "llm",
-				model: `${model.provider}/${model.id}`,
-				calibrated: false,
-				durationMs: Date.now() - started,
-			};
+			return null;
 		},
 	};
 }

package/src/decisions/prompt-triage.ts

@@ -0,0 +1,163 @@
+/**
+ * One typed decision per user turn, answering every routing question SKC has.
+ *
+ * Typed decisions started out wired to exactly one question — a five-way
+ * workflow enum — while the thirteen bundled UI skills were still selected by
+ * twenty hand-written regexes whose own comment measured them at 5 of 8 real
+ * frontend prompts and described the result as "not activation, it is hope".
+ *
+ * Both questions are about the same sentence, so they belong in the same call.
+ * The decision API takes a map of questions and returns a map of answers, which
+ * means adding the UI question costs one extra criteria block in the prompt and
+ * **zero** extra round trips: same latency budget, same deadline, same backend.
+ *
+ * Each question is skipped when a free deterministic stage already answered it,
+ * so the call shrinks to whatever is genuinely unknown — and vanishes entirely
+ * when nothing is.
+ */
+import { logger } from "@sayknow-cli/utils";
+import { BUNDLED_SKC_UI_SKILL_NAMES, type BundledSkcUiSkillName } from "../defaults/skc-ui-skills";
+import { BUNDLED_UI_SKILL_MEANINGS } from "../hooks/ui-skill-keywords";
+import { CANONICAL_SKC_WORKFLOW_SKILLS, type CanonicalSkcWorkflowSkill } from "../skill-state/active-state";
+import type { DecisionService } from "./index";
+import {
+	buildRoutingCriteria,
+	MAX_PROMPT_CHARS,
+	MIN_CALIBRATED_CONFIDENCE,
+	MIN_PROMPT_CHARS,
+	NONE_CHOICE,
+	promptSignalLength,
+} from "./skill-routing";
+import type { Question } from "./types";
+
+const UI_INSTRUCTIONS =
+	"Which bundled UI craft skill should be loaded for this request? Choose none unless the request is about building, reviewing, or polishing a user-visible interface.";
+
+/** Exported so tests can assert the contract the model is actually given. */
+export function buildUiSkillCriteria(): Record<string, string> {
+	const criteria: Record<string, string> = {};
+	for (const skill of BUNDLED_SKC_UI_SKILL_NAMES) criteria[skill] = BUNDLED_UI_SKILL_MEANINGS[skill];
+	criteria[NONE_CHOICE] =
+		"Not interface work: backend, data, infrastructure, tooling, SKC's own terminal UI, or a question with no surface to build.";
+	return criteria;
+}
+
+export interface PromptTriage {
+	/** Null means the router deliberately chose no workflow, not that it failed. */
+	workflow: CanonicalSkcWorkflowSkill | null;
+	uiSkill: BundledSkcUiSkillName | null;
+	/** Only meaningful when {@link calibrated} is true. */
+	workflowConfidence: number | undefined;
+	calibrated: boolean;
+}
+
+export interface PromptTriageRequest {
+	text: string;
+	/** Skip the workflow question — the keyword table already answered it. */
+	skipWorkflow?: boolean;
+	/** Skip the UI question — the regex table already matched. */
+	skipUiSkill?: boolean;
+	signal?: AbortSignal | undefined;
+}
+
+export type PromptTriager = (request: PromptTriageRequest) => Promise<PromptTriage | null>;
+
+function resolveChoice<T extends string>(
+	answer: unknown,
+	allowed: readonly T[],
+	calibrated: boolean,
+	label: string,
+): { value: T | null; confidence: number | undefined } {
+	const choice = answer as { type?: string; choice?: string; confidence?: number } | undefined;
+	if (choice?.type !== "choice") return { value: null, confidence: undefined };
+	if (choice.choice === NONE_CHOICE) return { value: null, confidence: choice.confidence };
+	const match = allowed.find(candidate => candidate === choice.choice);
+	if (!match) return { value: null, confidence: choice.confidence };
+	if (calibrated && (choice.confidence ?? 0) < MIN_CALIBRATED_CONFIDENCE) {
+		// A floor is only meaningful against a calibrated probability; against an
+		// ordinal score it would reject answers that are simply scaled differently.
+		logger.debug("decisions/prompt-triage: below confidence floor", {
+			question: label,
+			choice: choice.choice,
+			confidence: choice.confidence,
+			floor: MIN_CALIBRATED_CONFIDENCE,
+		});
+		return { value: null, confidence: choice.confidence };
+	}
+	return { value: match, confidence: choice.confidence };
+}
+
+/**
+ * Build the per-turn triager.
+ *
+ * Returns null when the service is disabled, the prompt is too short to carry
+ * intent, every question was already answered for free, or the backend did not
+ * produce a usable result. Null means "no information", which is different from
+ * a result whose fields are all null — that one is the router saying "none", and
+ * the keyword learner treats it as a negative example.
+ */
+export function createPromptTriage(service: DecisionService): PromptTriager {
+	const workflowCriteria = buildRoutingCriteria();
+	const uiCriteria = buildUiSkillCriteria();
+	return async (request: PromptTriageRequest): Promise<PromptTriage | null> => {
+		if (!service.enabled) return null;
+		const trimmed = request.text.trim();
+		if (promptSignalLength(trimmed) < MIN_PROMPT_CHARS) return null;
+		const state = trimmed.length > MAX_PROMPT_CHARS ? trimmed.slice(0, MAX_PROMPT_CHARS) : trimmed;
+
+		const questions: Record<string, Question> = {};
+		if (!request.skipWorkflow) {
+			questions.workflow = {
+				type: "choice",
+				instructions:
+					"Which workflow should handle this user request? Choose none unless the request clearly calls for one of the workflows.",
+				criteria: workflowCriteria,
+			};
+		}
+		if (!request.skipUiSkill) {
+			questions.uiSkill = { type: "choice", instructions: UI_INSTRUCTIONS, criteria: uiCriteria };
+		}
+		if (Object.keys(questions).length === 0) return null;
+
+		const result = await service.decide({ state, questions, signal: request.signal });
+		if (!result) return null;
+
+		const workflow = request.skipWorkflow
+			? { value: null, confidence: undefined }
+			: resolveChoice(result.answers.workflow, CANONICAL_SKC_WORKFLOW_SKILLS, result.calibrated, "workflow");
+		const uiSkill = request.skipUiSkill
+			? { value: null, confidence: undefined }
+			: resolveChoice(result.answers.uiSkill, BUNDLED_SKC_UI_SKILL_NAMES, result.calibrated, "uiSkill");
+
+		logger.debug("decisions/prompt-triage: answered", {
+			workflow: workflow.value,
+			uiSkill: uiSkill.value,
+			backend: result.backend,
+			model: result.model,
+			calibrated: result.calibrated,
+			durationMs: result.durationMs,
+		});
+		return {
+			workflow: workflow.value,
+			uiSkill: uiSkill.value,
+			workflowConfidence: workflow.confidence,
+			calibrated: result.calibrated,
+		};
+	};
+}
+
+export type SkillRouter = (text: string, signal?: AbortSignal) => Promise<CanonicalSkcWorkflowSkill | null>;
+
+/**
+ * Workflow-only view of the triager.
+ *
+ * A few lines over the same implementation rather than a second one: the eval
+ * harness in `scripts/eval-skill-routing.ts` and the routing tests want
+ * text-in/skill-out and have no UI question to ask, and a parallel router would
+ * be free to drift away from the thresholds this one enforces.
+ */
+export function createSemanticSkillRouter(service: DecisionService): SkillRouter {
+	const triage = createPromptTriage(service);
+	return async (text: string, signal?: AbortSignal): Promise<CanonicalSkcWorkflowSkill | null> =>
+		(await triage({ text, skipUiSkill: true, signal }))?.workflow ?? null;
+}

package/src/decisions/skill-routing.ts

@@ -1,25 +1,29 @@
 /**
- * Semantic fallback for workflow-skill routing.
+ * The workflow-routing question: what the model is asked, and the thresholds the
+ * answer is held to.
  *
- * The keyword table in `hooks/skill-keywords.ts` is thirteen literal strings. It is
+ * The keyword table in `hooks/skill-keywords.ts` is a list of literal strings. It is
  * exact and free, and it is the right first stage — but measured against realistic
  * paraphrases it recalls 4/17, and **0/9 in Korean**, which is most of our users. A
  * miss is not fatal (the model still sees the routing rules in the system prompt), but
  * it means the deterministic gate simply does not exist for those prompts.
  *
- * This module fills that gap only where the keyword stage produced nothing:
+ * The staging that closes the gap lives in `prompt-triage.ts`:
  *
- *   keyword (exact, free) -> semantic (this, one cheap call) -> system prompt (as today)
+ *   keyword + learned (exact, free) -> one typed decision -> system prompt (as today)
  *
- * The two stages fail in opposite directions, which is why both are kept. Measured on
- * the same 22 prompts, the literal stage is the one that catches `ultragoal this` and
- * `consensus plan`; the semantic stage is the one that catches everything Korean.
+ * The stages fail in opposite directions, which is why all of them are kept. Measured
+ * on the same 22 prompts, the literal stage is the one that catches `ultragoal this`
+ * and `consensus plan`; the semantic stage is the one that catches everything Korean.
+ *
+ * This file holds only the contract and the numbers, so the criteria cannot drift away
+ * from the thresholds that judge answers against them.
  */
-import { logger } from "@sayknow-cli/utils";
 import { CANONICAL_SKC_WORKFLOW_SKILLS, type CanonicalSkcWorkflowSkill } from "../skill-state/active-state";
-import type { DecisionService } from "./index";
 
-const NONE = "none";
+/** Shared across every routing question so one answer shape covers them all. */
+export const NONE_CHOICE = "none";
+const NONE = NONE_CHOICE;
 
 /**
  * What each workflow is *for*, in the words a user would recognise. These descriptions
@@ -40,7 +44,7 @@ const WORKFLOW_MEANINGS: Record<CanonicalSkcWorkflowSkill, string> = {
 	team: "The work is large enough to split across several coordinated workers running in parallel.",
 };
 
-const ROUTING_INSTRUCTIONS =
+export const ROUTING_INSTRUCTIONS =
 	"Which workflow should handle this user request? Choose none unless the request clearly calls for one of the workflows.";
 
 /** Exported so tests can assert the contract the model is actually given. */
@@ -52,10 +56,30 @@ export function buildRoutingCriteria(): Record<string, string> {
 	return criteria;
 }
 
-/** Prompts below this length never carry enough signal to justify a model round-trip. */
-const MIN_PROMPT_CHARS = 12;
+/**
+ * Prompts below this length never carry enough signal to justify a model round-trip.
+ * Measured with {@link promptSignalLength}, not `String.length`: the floor was fitted
+ * to English and Korean, and in code units a complete Chinese request is shorter than
+ * "ok thanks".
+ */
+export const MIN_PROMPT_CHARS = 12;
 /** Only the opening of a prompt decides its workflow; the rest is payload. */
-const MAX_PROMPT_CHARS = 4_000;
+export const MAX_PROMPT_CHARS = 4_000;
+
+const DENSE_SCRIPT_PATTERN = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]/gu;
+
+/**
+ * Prompt length in Latin-letter equivalents.
+ *
+ * One Han character, kana or Hangul syllable carries what two or three Latin letters
+ * do, so each counts double. "先做架构设计" (6 code units) is a whole request; "谢谢" and
+ * "고마워요" still fall under the floor, which is the point of having one.
+ */
+export function promptSignalLength(text: string): number {
+	let dense = 0;
+	for (const _ of text.matchAll(DENSE_SCRIPT_PATTERN)) dense++;
+	return text.length + dense;
+}
 
 /**
  * Minimum calibrated confidence required to activate a workflow.
@@ -79,45 +103,4 @@ const MAX_PROMPT_CHARS = 4_000;
  * through a forced enum has no meaningful confidence to compare against, so gating on a
  * number it did not really produce would just be superstition.
  */
-const MIN_CALIBRATED_CONFIDENCE = 0.75;
-
-export type SkillRouter = (text: string) => Promise<CanonicalSkcWorkflowSkill | null>;
-
-/**
- * Build the semantic router. Returns null-resolving function when the service is
- * disabled so the caller keeps its existing behaviour with no branching.
- */
-export function createSemanticSkillRouter(service: DecisionService): SkillRouter {
-	const criteria = buildRoutingCriteria();
-	return async (text: string): Promise<CanonicalSkcWorkflowSkill | null> => {
-		if (!service.enabled) return null;
-		const trimmed = text.trim();
-		if (trimmed.length < MIN_PROMPT_CHARS) return null;
-		const state = trimmed.length > MAX_PROMPT_CHARS ? trimmed.slice(0, MAX_PROMPT_CHARS) : trimmed;
-
-		const result = await service.decide({
-			state,
-			questions: { workflow: { type: "choice", instructions: ROUTING_INSTRUCTIONS, criteria } },
-		});
-		const answer = result?.answers.workflow;
-		if (!result || answer?.type !== "choice" || answer.choice === NONE) return null;
-		const skill = CANONICAL_SKC_WORKFLOW_SKILLS.find(candidate => candidate === answer.choice);
-		if (!skill) return null;
-		if (result.calibrated && (answer.confidence ?? 0) < MIN_CALIBRATED_CONFIDENCE) {
-			logger.debug("decisions/skill-routing: below confidence floor, leaving routing alone", {
-				skill,
-				confidence: answer.confidence,
-				floor: MIN_CALIBRATED_CONFIDENCE,
-			});
-			return null;
-		}
-		logger.debug("decisions/skill-routing: semantic match", {
-			skill,
-			backend: result.backend,
-			confidence: answer.confidence,
-			calibrated: result.calibrated,
-			durationMs: result.durationMs,
-		});
-		return skill;
-	};
-}
+export const MIN_CALIBRATED_CONFIDENCE = 0.75;