@sayknow-cli/coding-agent 0.5.26 → 0.6.0

package/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 ## [Unreleased]
 
+## [0.6.0] - 2026-09-24
+
+### Added
+
+- The 13 bundled UI skills are now part of the typed decision instead of 20 hand-written regexes. Measured recall of the pattern table on real Korean prompts was 5/8; a prompt like "이 부분 손보기 전에 어떻게 갈지부터 같이 정하고 넘어가자" matched nothing and the skill never activated. The picked skill still arrives as the same hidden `developer` reminder, now labelled `semantic match` when the model answered and `matched` when a pattern did.
+- Workflow routing and UI skill selection are **one** decision call, not two. The triage asks both questions in a single request (`questions: ["workflow", "uiSkill"]`), and a prompt the pattern table already answered drops that question from the request instead of paying for it — so adding UI routing cost zero extra round trips.
+- The skill keyword table now fills itself. Every answered routing decision mines ordered two-stem shingles from the prompt into `~/.skc/agent/learned-skill-keywords.json`. A shingle is promoted to a real keyword after 2 independent prompts when the backend reports calibrated confidence ≥ 0.9, or 3 when it only ranks; a single contradicting answer blocks that shingle permanently, so a coincidence cannot become a rule. Learned entries carry strictly negative priority — a hand-written keyword always wins — and a promoted pattern answers for free on the next matching prompt. `decisions.keywordLearning: false` turns the store off; `SKC_LEARNED_KEYWORDS_PATH` relocates it.
+- Routing and learning work in whatever language the prompt is written in. Mining uses the platform Unicode segmenter, so Chinese, Japanese and Thai prompts with no spaces come apart into words (Han runs the ICU dictionary misses fall back to character bigrams; hiragana-only tokens are dropped as grammar); non-ASCII alphabets are kept instead of discarded, and a learned stem gets a Unicode word boundary in spaced scripts and a bare substring match in unspaced ones. The length floor that skips the model on "ok thanks" is measured in signal rather than code units, so a six-character Chinese request is no longer thrown away. Measured against the hosted `jev` backend: 40/40 across ko, en, zh, ja, es and ru, and a ralplan phrasing repeated twice in Chinese, Japanese or Russian promotes a keyword that fires on an unseen sentence in that language.
+- The Codex host gets the same router. `skc codex-native-hook` ran the hand-written keyword table and nothing else: the semantic stage had a parameter waiting for it since it shipped, and learned keywords were never loaded there, so a phrasing learned in a CLI session did nothing under Codex. The hook now runs all three stages — hand-written keywords, learned keywords, then one typed decision for whatever those missed — on the same backend chain (TypeSafe key, else a running local runtime, else the small model of the provider you are logged into) and feeds the answer back into the learned table. Because the hook is a fresh process per prompt, credentials and the model registry are opened only on a prompt the tables did not fully answer and closed before it exits; a prompt they did answer still costs the same ~0.3s it did before. Measured through the real hook subprocess: a Chinese ralplan phrasing routed by the model on the first prompt fired from the learned table on the next one.
+
+### Changed
+
+- Typed decisions (`decisions.enabled`) are now **on by default**. The keyword stage of workflow routing still runs first and free; the model stage only spends a small-model call on turns the table did not answer. Set `decisions.enabled: false` to route on the keyword table alone.
+- The small-model fallback now ranks the **provider you are chatting with** first. Measured on a registry with Anthropic, Codex and Z.ai keys: price order put four free `zai/glm-*` reasoning tiers ahead of `claude-haiku-4-5`, and the first took 8.9s — past the 8s service deadline, so the answer was nothing. Haiku next to Opus, mini next to GPT is also the model you would have picked by hand.
+- The routing decision now goes through the session's own `streamFn` instead of a bare `completeSimple`, so it gets the same proxy, credential-invalidation and retry wrapping as the turn, and a host that injects a transport intercepts it. Hosts opt sessions in with `AgentSessionConfig.semanticWorkflowRouting` (`createAgentSession` does); a bare `AgentSession` never routes, so scripted transports are not consumed by a call they did not script. While the decision is in flight the session reports `isStreaming`, so a second `prompt()` queues or rejects as it would mid-turn, and `abort()` cancels the decision.
+- `task.modelRouting.enabled` now defaults to **true**. The tier lists it reads are empty until you set them, so nothing changes for anyone who has not configured them — but shipping it off meant a user who *had* configured tiers still got no routing, which made the whole feature dead code.
+
+### Fixed
+
+- The small-model fallback answered **nothing** on any registry with an Anthropic key: the cheapest qualifying entry, `claude-3-haiku-20240307`, is retired and returns 404, and the backend logged it as "model did not emit the forced tool call" and gave up. The three retired Claude 3.x ids are now dropped from the catalog *and* from stale on-disk cache rows, the backend logs the real status, and a candidate that errors or blows a 3.5s attempt budget is skipped for the next one and remembered for ten minutes so the stall is paid once, not per prompt.
+- A local runtime contributes **one** candidate — the smallest chat model — and embedding models (`nomic-embed-text`) are no longer offered a chat call. Measured with Ollama: five local models ranked ahead of every hosted one, each timed out on cold start, and the hosted model was never reached before the deadline.
+- A decision request whose caller had already aborted — measured: `abort()` landing during the previous backend's credential lookup — ran a full attempt budget of silence, because an abort listener added to a signal that has already fired never runs. Every backend now checks the signal after each await.
+
 ## [0.5.26] - 2026-09-23
 ### Added
 

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

@@ -2419,11 +2419,29 @@ export declare const SETTINGS_SCHEMA: {
     };
     readonly "decisions.enabled": {
         readonly type: "boolean";
-        readonly default: false;
+        readonly default: true;
         readonly ui: {
             readonly tab: "context";
             readonly label: "Typed decisions";
-            readonly description: "Add a model-backed second stage to workflow routing. The keyword table already runs on every turn and costs nothing; this handles the phrasings it cannot express, which is most wording that is not a literal match. Costs one small model call, and only on turns the keyword table did not already answer. Any failure falls back to keyword-only behaviour, but a successful answer can also select a different workflow than the deep-interview ambiguity detector would have.";
+            readonly description: "Model-backed second stage for workflow routing. The keyword table runs first on every turn and costs nothing; this handles the phrasings it cannot express, which is most wording that is not a literal match. Costs one small model call, only on turns the keyword table did not already answer, on the cheapest backend available: TypeSafe when a key is stored, else a local runtime that is running, else the small model of the provider you are chatting with. Any failure falls back to keyword-only behaviour, but a successful answer can also select a different workflow than the deep-interview ambiguity detector would have. Turn off to route on the keyword table alone.";
+        };
+    };
+    /**
+     * Feed routing answers back into the deterministic keyword table.
+     *
+     * The hand-written table cannot be grown by hand for Korean — measured recall
+     * was 0/9 — so it grows itself instead: a two-stem pattern that produced the
+     * same routing answer on two distinct prompts, and was never contradicted, is
+     * promoted and thereafter fires for free. One contradiction retracts it
+     * permanently. Stems and hashes are stored; prompt text never is.
+     */
+    readonly "decisions.keywordLearning": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "context";
+            readonly label: "Learn routing keywords";
+            readonly description: "Remember the phrasings the routing model resolves, so repeating one stops costing a model call. A pattern must give the same answer on two different prompts before it fires on its own, and a single disagreement removes it for good. Only word stems and hashes are written to disk, never your prompts. Turn off to keep the keyword table frozen at its built-in entries.";
         };
     };
     /**
@@ -2435,12 +2453,14 @@ export declare const SETTINGS_SCHEMA: {
      * mid-session invalidates the prompt cache, which on a long context costs
      * more than the cheaper tier saves.
      *
-     * Needs `decisions.enabled` and at least two tiers configured. Without both
-     * it never fires and the configured role models are used unchanged.
+     * Needs `decisions.enabled` and at least two tiers configured. The tiers are
+     * empty by default, so this is a no-op until the user sets them — which is why
+     * it defaults on: shipping it off meant the routing code existed and never ran
+     * even for users who had configured the tiers it needs.
      */
     readonly "task.modelRouting.enabled": {
         readonly type: "boolean";
-        readonly default: false;
+        readonly default: true;
         readonly ui: {
             readonly tab: "tasks";
             readonly label: "Route subagent models per task";

package/dist/types/decisions/keyword-learning.d.ts

@@ -0,0 +1,61 @@
+import type { SkillKeywordDefinition } from "../hooks/skill-keywords";
+import type { CanonicalSkcWorkflowSkill } from "../skill-state/active-state";
+export declare const LEARNED_KEYWORD_STORE_VERSION = 1;
+/** Test seam. Also lets a host keep the table out of the user's home. */
+export declare function setLearnedKeywordStorePath(value: string | undefined): void;
+export declare function resetLearnedKeywordCache(): void;
+/**
+ * Where the learned table lives.
+ *
+ * User-global on purpose: a phrasing you use is a phrasing you use, and making it
+ * per-repository would mean relearning the same rule in every checkout.
+ * `SKC_LEARNED_KEYWORDS_PATH` redirects it, so a test driving a real session under
+ * a temp agent dir cannot write into the developer's actual home.
+ */
+export declare function getLearnedKeywordStorePath(): string;
+/**
+ * Ordered stem pairs within a three-token window.
+ *
+ * The gap is what makes a learned pattern generalize where the literal table
+ * cannot: a prompt that says "make me a plan document" mines `plan … document`,
+ * which then also matches "make the plan into a document" — the phrasing that
+ * made the hand-written entry miss.
+ */
+export declare function mineShingles(text: string): string[];
+/**
+ * Promoted patterns, in the shape the deterministic stage consumes.
+ *
+ * Priority sits one below the hand-written entry for the same workflow: when a
+ * learned pattern and an enumerated keyword disagree, the human wins.
+ */
+export declare function loadLearnedKeywordDefinitions(): Promise<SkillKeywordDefinition[]>;
+export interface RoutingObservation {
+    text: string;
+    /** Null means the router deliberately chose no workflow — a negative example. */
+    skill: CanonicalSkcWorkflowSkill | null;
+    confidence?: number | undefined;
+    calibrated?: boolean | undefined;
+}
+export interface LearningOutcome {
+    promoted: SkillKeywordDefinition[];
+    retracted: number;
+}
+/**
+ * Feed one routing answer into the table.
+ *
+ * Best-effort by construction: it runs after the turn's routing decision is
+ * already made, so a failure here changes nothing the user can observe.
+ */
+export declare function observeRouting(observation: RoutingObservation): Promise<LearningOutcome>;
+export interface LearnedKeywordSummary {
+    entries: {
+        keyword: string;
+        skill: CanonicalSkcWorkflowSkill;
+        positives: number;
+        lastSeen: number;
+    }[];
+    candidates: number;
+    blocked: number;
+}
+/** What the table has actually learned, for `skc` surfaces and tests. */
+export declare function summarizeLearnedKeywords(): Promise<LearnedKeywordSummary>;

package/dist/types/decisions/llm-backend.d.ts

@@ -16,7 +16,7 @@
  * 2. Every question goes in **one** call. Splitting them multiplies cost and latency
  *    while the enum constraint already keeps each field independent.
  */
-import { type Api, type Model } from "@sayknow-cli/ai";
+import { type Api, completeSimple, type Model } from "@sayknow-cli/ai";
 import type { ModelRegistry } from "../config/model-registry";
 import type { Settings } from "../config/settings";
 import { type DecisionBackend } from "./types";
@@ -40,12 +40,24 @@ 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);
 }
 /** Reset between tests; also lets a caller force a fresh probe after starting a runtime. */
 export declare function clearLocalRuntimeLivenessCache(): void;
+/** Reset between tests. */
+export declare function clearDeadModelCache(): void;
 export declare function createLlmDecisionBackend(deps: LlmBackendDeps): DecisionBackend;

package/dist/types/decisions/prompt-triage.d.ts

@@ -0,0 +1,42 @@
+import { type BundledSkcUiSkillName } from "../defaults/skc-ui-skills";
+import { type CanonicalSkcWorkflowSkill } from "../skill-state/active-state";
+import type { DecisionService } from "./index";
+/** Exported so tests can assert the contract the model is actually given. */
+export declare function buildUiSkillCriteria(): Record<string, string>;
+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>;
+/**
+ * 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 declare function createPromptTriage(service: DecisionService): PromptTriager;
+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 declare function createSemanticSkillRouter(service: DecisionService): SkillRouter;

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

@@ -1,10 +1,45 @@
-import { type CanonicalSkcWorkflowSkill } from "../skill-state/active-state";
-import type { DecisionService } from "./index";
+/** Shared across every routing question so one answer shape covers them all. */
+export declare const NONE_CHOICE = "none";
+export declare 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. */
 export declare function buildRoutingCriteria(): Record<string, string>;
-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.
+ * 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 declare function createSemanticSkillRouter(service: DecisionService): SkillRouter;
+export declare const MIN_PROMPT_CHARS = 12;
+/** Only the opening of a prompt decides its workflow; the rest is payload. */
+export declare const MAX_PROMPT_CHARS = 4000;
+/**
+ * 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 declare function promptSignalLength(text: string): number;
+/**
+ * Minimum calibrated confidence required to activate a workflow.
+ *
+ * Activation is a strong move: it switches on the mutation guard, the Stop hook and the
+ * ask tool. Getting it wrong is worse than missing, because the user did not ask for any
+ * of that and has no obvious way to see why it appeared.
+ *
+ * Measured over ten routing prompts against the hosted model: every answer it reported
+ * at 1.00 was correct, and its single wrong answer reported 0.71. The lowest *correct*
+ * confidence was 0.67 — and that case was "none", so gating it out costs nothing. A
+ * floor here therefore removes the observed error without removing a real activation.
+ *
+ * One prompt sits close to this line. "추측하지 말고 모르는 건 다 물어봐" resolves to
+ * deep-interview in 8/8 samples but at 0.76-0.83, so the floor has roughly 0.01 of
+ * headroom on it. Raising the floor would drop a correct activation; lowering it would
+ * re-admit the 0.71 error. Treat 0.75 as fitted to a small sample and re-derive it from
+ * real usage rather than nudging it on a hunch.
+ *
+ * Only applied when the backend reports `calibrated: true`. An ordinary LLM answering
+ * 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.
+ */
+export declare const MIN_CALIBRATED_CONFIDENCE = 0.75;

package/dist/types/hooks/native-prompt-routing.d.ts

@@ -0,0 +1,21 @@
+import type { PromptTriager } from "../decisions/prompt-triage";
+import { type SkillActiveState } from "./skill-state";
+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;
+}
+export declare function routeNativePrompt(input: NativePromptRoutingInput): Promise<NativePromptRoutingResult>;

package/dist/types/hooks/native-skill-hook.d.ts

@@ -1,3 +1,4 @@
+import type { PromptTriager } from "../decisions/prompt-triage";
 import { type EffectiveSkillConfigInput } from "./skill-state";
 export type SkcNativeHookEventName = "UserPromptSubmit" | "Stop";
 export interface SkcNativeHookDispatchResult {
@@ -11,6 +12,8 @@ interface SkcNativeHookDispatchOptions {
     stateDir?: string;
     effectiveSkillConfig?: EffectiveSkillConfigInput;
     configPaths?: string[];
+    /** Injected in tests so the model stage runs without credentials or a network. */
+    triager?: PromptTriager;
 }
 export declare function clearSkcNativeSkillHookCachesForTesting(): void;
 export declare function getSkcNativeSkillHookCacheStatsForTesting(): {

package/dist/types/hooks/skill-keywords.d.ts

@@ -4,6 +4,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 declare const SKC_WORKFLOW_SKILLS: readonly ["deep-interview", "ralplan", "ultragoal", "team"];
 export type SkcWorkflowSkill = CanonicalSkcWorkflowSkill;

package/dist/types/hooks/skill-state.d.ts

@@ -2,7 +2,7 @@ import type { SkillDiscoverySettings } from "../config/skill-settings-defaults";
 import { type SkillActiveState } from "../skill-state/active-state";
 import { initialPhaseForSkill } from "../skill-state/initial-phase";
 export { initialPhaseForSkill };
-import { type SkcWorkflowSkill } from "./skill-keywords";
+import { type SkcWorkflowSkill, type SkillKeywordDefinition } from "./skill-keywords";
 export declare const SKC_STATE_DIR = ".skc";
 export declare const SKILL_ACTIVE_STATE_FILE = "skill-active-state.json";
 export interface EffectiveSkillConfigInput {
@@ -15,6 +15,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";
 export interface ModeState {
@@ -38,6 +40,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
@@ -60,8 +68,17 @@ export interface UserPromptSubmitStateInput {
     prompt?: string;
     sessionFile?: string;
 }
-export declare function detectSkillKeywords(text: string): SkillKeywordMatch[];
-export declare function detectPrimarySkillKeyword(text: string): SkillKeywordMatch | null;
+/**
+ * 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 declare function detectSkillKeywords(text: string, learned?: readonly SkillKeywordDefinition[]): SkillKeywordMatch[];
+export declare function detectPrimarySkillKeyword(text: string, learned?: readonly SkillKeywordDefinition[]): SkillKeywordMatch | null;
 export declare function resolveSkcStateDir(cwd: string, stateDir?: string): string;
 export interface StateRecoveryDiagnostic {
     kind: "skill-active-state" | "mode-state";

package/dist/types/hooks/ui-skill-keywords.d.ts

@@ -43,6 +43,21 @@ export declare function detectUiSkillKeywords(text: string): UiSkillKeywordMatch
  * UI/UX work.
  */
 export declare function buildUiSkillActivationContext(text: string): string | null;
+/**
+ * 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 declare function buildUiSkillDirectiveForSkill(skill: BundledSkcUiSkillName): string;
+/**
+ * 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 declare const BUNDLED_UI_SKILL_MEANINGS: Record<BundledSkcUiSkillName, string>;
 /**
  * Frontend skills SKC routes to but deliberately does NOT vendor.
  *

package/dist/types/sdk/session.d.ts

@@ -19,7 +19,8 @@ import { type LocalProtocolOptions } from "../internal-urls";
 import { AgentRegistry } from "../registry/agent-registry";
 import { MCPManager } from "../runtime-mcp";
 import { AgentSession, type ForkContextSeed } from "../session/agent-session";
-import { AuthStorage } from "../session/auth-storage";
+import type { AuthStorage } from "../session/auth-storage";
+import { discoverAuthStorage } from "../session/auth-storage-discovery";
 import { SessionManager } from "../session/session-manager";
 import { type BuildSystemPromptResult } from "../system-prompt";
 import { BashTool, BUILTIN_TOOLS, createTools, EditTool, EvalTool, FindTool, HIDDEN_TOOLS, type LspStartupServerInfo, loadSshTool, ReadTool, ResolveTool, SearchTool, type Tool, type ToolSession, WebSearchTool, WriteTool } from "../tools";
@@ -218,18 +219,7 @@ export type { FileSlashCommand } from "../extensibility/slash-commands";
 export type { Tool } from "../tools";
 export { buildDirectoryTree, buildWorkspaceTree, type DirectoryTree, type WorkspaceTree } from "../workspace-tree";
 export { BashTool, BUILTIN_TOOLS, createTools, EditTool, EvalTool, FindTool, HIDDEN_TOOLS, loadSshTool, ReadTool, ResolveTool, SearchTool, type ToolSession, WebSearchTool, WriteTool, };
-/**
- * Create an AuthStorage instance.
- *
- * Default: local SQLite store at `<agentDir>/agent.db`.
- *
- * Broker mode: when `SKC_AUTH_BROKER_URL` is set, credentials are pulled from
- * a remote auth-broker over the wire. Refresh tokens never leave the broker;
- * the client receives access tokens with `refresh = "__remote__"` and calls
- * back into the broker through the {@link AuthStorageOptions.refreshOAuthCredential}
- * override to re-mint access tokens when needed.
- */
-export declare function discoverAuthStorage(agentDir?: string): Promise<AuthStorage>;
+export { discoverAuthStorage };
 /**
  * Discover extensions from cwd.
  */

package/dist/types/session/agent-session.d.ts

@@ -223,6 +223,14 @@ export interface AgentSessionConfig {
     toolRegistry?: Map<string, AgentTool>;
     /** Tool-session factory context used to lazily attach workflow-gate-only tools. */
     workflowGateToolSession?: ToolSession;
+    /**
+     * Stage two of workflow routing: before a genuine user turn, ask a small model
+     * through the session's own transport which SKC workflow the prompt calls for.
+     * Hosts that own an interactive user (`createAgentSession`) turn this on; a bare
+     * session leaves it off so a scripted or injected transport is never consumed by a
+     * call the host did not script. `decisions.enabled` still governs the user side.
+     */
+    semanticWorkflowRouting?: boolean;
     /** Current session pre-LLM message transform pipeline */
     transformContext?: (messages: AgentMessage[], signal?: AbortSignal) => AgentMessage[] | Promise<AgentMessage[]>;
     /** Provider payload hook used by the active session request path */

package/dist/types/session/auth-storage-discovery.d.ts

@@ -0,0 +1,13 @@
+import { AuthStorage } from "./auth-storage";
+/**
+ * Create an AuthStorage instance.
+ *
+ * Default: local SQLite store at `<agentDir>/agent.db`.
+ *
+ * Broker mode: when `SKC_AUTH_BROKER_URL` is set, credentials are pulled from
+ * a remote auth-broker over the wire. Refresh tokens never leave the broker;
+ * the client receives access tokens with `refresh = "__remote__"` and calls
+ * back into the broker through the {@link AuthStorageOptions.refreshOAuthCredential}
+ * override to re-mint access tokens when needed.
+ */
+export declare function discoverAuthStorage(agentDir?: string): Promise<AuthStorage>;

package/dist/types/tools/browser.d.ts

@@ -8,9 +8,9 @@ export { extractReadableFromHtml, type ReadableFormat, type ReadableResult } fro
 export type { Observation, ObservationEntry } from "./browser/tab-protocol";
 declare const browserSchema: z.ZodObject<{
     action: z.ZodEnum<{
+        run: "run";
         open: "open";
         close: "close";
-        run: "run";
         act: "act";
     }>;
     name: z.ZodOptional<z.ZodString>;
@@ -122,9 +122,9 @@ export declare class BrowserTool implements AgentTool<typeof browserSchema, Brow
     readonly summary = "Control a headless browser to navigate and interact with web pages";
     readonly parameters: z.ZodObject<{
         action: z.ZodEnum<{
+            run: "run";
             open: "open";
             close: "close";
-            run: "run";
             act: "act";
         }>;
         name: z.ZodOptional<z.ZodString>;

package/package.json

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

package/scripts/eval-skill-routing.ts

@@ -19,7 +19,7 @@ import { ModelRegistry } from "../src/config/model-registry";
 import { resolveRoleSelection } from "../src/config/model-resolver";
 import { Settings } from "../src/config/settings";
 import { createDecisionService, createLlmDecisionBackend, createTypeSafeDecisionBackend } from "../src/decisions";
-import { createSemanticSkillRouter } from "../src/decisions/skill-routing";
+import { createSemanticSkillRouter } from "../src/decisions/prompt-triage";
 import { detectPrimarySkillKeyword } from "../src/hooks/skill-state";
 import { discoverAuthStorage } from "../src/sdk";
 
@@ -27,7 +27,8 @@ type Expected = "deep-interview" | "ralplan" | "ultragoal" | "team" | null;
 interface Case {
 	prompt: string;
 	expect: Expected;
-	lang: "ko" | "en";
+	/** BCP 47 primary subtag. The keyword table only knows ko and en; every other row measures the semantic stage alone. */
+	lang: string;
 }
 
 const CASES: Case[] = [
@@ -54,6 +55,25 @@ const CASES: Case[] = [
 	{ prompt: "우리 서비스에 이 모델 붙이면 뭐가 좋아?", expect: null, lang: "ko" },
 	{ prompt: "fix the failing lint rule in src/utils.ts", expect: null, lang: "en" },
 	{ prompt: "what does this regex do?", expect: null, lang: "en" },
+	// Languages the hand-written table has no entries for. Routing here is the
+	// semantic stage or nothing, which is what the per-language column shows.
+	{ prompt: "需求还不清楚，先通过提问把规格问出来", expect: "deep-interview", lang: "zh" },
+	{ prompt: "架构风险很大，先给我一个需要审批的详细计划", expect: "ralplan", lang: "zh" },
+	{ prompt: "把这个目标登记下来，持续跟踪直到全部交付验证完", expect: "ultragoal", lang: "zh" },
+	{ prompt: "任务太大了，拆成几个并行的工作者一起做", expect: "team", lang: "zh" },
+	{ prompt: "这个测试为什么会挂？", expect: null, lang: "zh" },
+	{ prompt: "修一下 README 里的错别字", expect: null, lang: "zh" },
+	{ prompt: "要件がまだ曖昧なので、質問して仕様を引き出して", expect: "deep-interview", lang: "ja" },
+	{ prompt: "実装前に設計案を比較した計画書を作って承認を待って", expect: "ralplan", lang: "ja" },
+	{ prompt: "この目標を最後まで追跡して、途中で忘れないで", expect: "ultragoal", lang: "ja" },
+	{ prompt: "作業が大きいのでワーカーを複数立てて並列で進めて", expect: "team", lang: "ja" },
+	{ prompt: "この関数は何をしているか説明して", expect: null, lang: "ja" },
+	{ prompt: "Hazme preguntas hasta que los requisitos estén claros", expect: "deep-interview", lang: "es" },
+	{ prompt: "Prepara un plan detallado y espera mi aprobación antes de tocar código", expect: "ralplan", lang: "es" },
+	{ prompt: "Arregla el error de lint en src/utils.ts", expect: null, lang: "es" },
+	{ prompt: "Составь согласованный план миграции и жди моего одобрения", expect: "ralplan", lang: "ru" },
+	{ prompt: "Разбей работу на несколько параллельных воркеров", expect: "team", lang: "ru" },
+	{ prompt: "Что делает эта регулярка?", expect: null, lang: "ru" },
 ];
 
 function pct(hit: number, total: number): string {
@@ -120,18 +140,23 @@ async function main(): Promise<void> {
 	};
 	const positives = (row: (typeof rows)[number]) => row.case.expect !== null;
 	const negatives = (row: (typeof rows)[number]) => row.case.expect === null;
-	const ko = (row: (typeof rows)[number]) => positives(row) && row.case.lang === "ko";
-	const en = (row: (typeof rows)[number]) => positives(row) && row.case.lang === "en";
+	const langs = [...new Set(CASES.map(testCase => testCase.lang))];
 	const hybrid = (row: (typeof rows)[number]) => row.keyword ?? row.semantic;
 
 	console.log("\n=== stage comparison ===");
+	// Both hosts ship the hybrid: the session in `AgentSession#routeWorkflowSemantically`,
+	// the Codex hook in `hooks/native-prompt-routing.ts`. The single-stage rows show
+	// what each stage contributes on its own.
 	for (const [label, pick] of [
-		["keyword only (Codex hook)", (row: (typeof rows)[number]) => row.keyword],
-		["semantic only (SHIPPED)", (row: (typeof rows)[number]) => row.semantic],
-		["keyword+semantic (upper bound)", hybrid],
+		["keyword only", (row: (typeof rows)[number]) => row.keyword],
+		["semantic only", (row: (typeof rows)[number]) => row.semantic],
+		["keyword+semantic (SHIPPED)", hybrid],
 	] as const) {
+		const perLang = langs
+			.map(lang => `${lang} ${pct(...score(pick, row => positives(row) && row.case.lang === lang))}`)
+			.join("  ");
 		console.log(
-			`${label.padEnd(32)} all ${pct(...score(pick, () => true))}  ko ${pct(...score(pick, ko))}  en ${pct(...score(pick, en))}  clean-negatives ${pct(...score(pick, negatives))}`,
+			`${label.padEnd(32)} all ${pct(...score(pick, () => true))}  ${perLang}  clean-negatives ${pct(...score(pick, negatives))}`,
 		);
 	}
 
@@ -140,13 +165,13 @@ async function main(): Promise<void> {
 		`\nlatency p50 ${latencies[Math.floor(latencies.length / 2)]}ms  p95 ${latencies[Math.max(0, Math.ceil(latencies.length * 0.95) - 1)]}ms  max ${latencies.at(-1)}ms`,
 	);
 
-	// Report against what actually ships in this host, not against the upper bound.
-	const misses = rows.filter(row => row.semantic !== row.case.expect);
+	// Report against what ships: keyword first, the model for what it missed.
+	const misses = rows.filter(row => hybrid(row) !== row.case.expect);
 	if (misses.length > 0) {
-		console.log("\n=== misses in shipped configuration (semantic only) ===");
+		console.log("\n=== misses in shipped configuration (keyword+semantic) ===");
 		for (const row of misses)
 			console.log(
-				`  [${row.case.lang}] want=${row.case.expect ?? "none"} got=${row.semantic ?? "none"} :: ${row.case.prompt}`,
+				`  [${row.case.lang}] want=${row.case.expect ?? "none"} got=${hybrid(row) ?? "none"} :: ${row.case.prompt}`,
 			);
 	}