@sayknow-cli/coding-agent 0.5.25 → 0.5.26

package/CHANGELOG.md

@@ -2,7 +2,19 @@
 
 ## [Unreleased]
 
-## [0.5.25] - 2026-09-21
+## [0.5.26] - 2026-09-23
+### Added
+
+- `/model` role rows now open a second level so a model can be assigned to a *detailed use* rather than only to a whole role. `planner`/`architect` offer backend architecture and frontend design, `executor` offers implementation and testing, `critic` offers review; `default` has none and still assigns in one keystroke. The two bulk rows deliberately stay canonical-only — an action that also rewrote five detailed-use overrides could not be undone from the same menu. Assignments persist to the new `task.modelRouting.specialtyModels` record, whose keys are allowlisted to those five ids. Saving one while `task.modelRouting.enabled` is off persists it and says so instead of silently enabling a feature you did not ask for. First-level rows are now stable descriptors rather than positional index arithmetic, which is what previously made every added row a chance to assign a model to the wrong role.
+- Subagent model routing now runs **one classification per child task** instead of one per `task` call. A batch shares an agent but not a workload, so an implementation slice and a test slice in the same call no longer have to share a single verdict. Each child dispatches its own ordered chain — detailed-use model, then tier model, then the role's configured chain — so a detailed-use model that cannot authenticate still falls through to something the role can actually run. A high-risk assignment skips the detailed-use axis entirely, because a lateral swap can move sideways into something weaker.
+- Receipts and progress now carry what the router **requested** separately from what the spawn ran on. Because the dispatched value is a fallback chain, conflating the two would let a receipt claim a detailed-use model was used when the chain actually fell through to the baseline. When the decision backend is an ordinary LLM it returns no probabilities at all, so the record carries an ordinal clarity score and `calibrated: false` rather than a fabricated confidence.
+- The `task` tool accepts `.specialty` per task. Declaring the kind of work is the deterministic path to a detailed-use model: no classifier runs, `task.modelRouting.enabled` is not consulted, and no confidence bar applies — if the user assigned a model to that specialty under `/model`, the child runs on it and leaves it only on a transport error (429, 5xx, auth, quota), when the child session's fallback chain advances to the role baseline composed behind it. A declared specialty ignores the menu's role grouping on purpose: the setting is one flat map, and a frontend build delegated to `executor` should get the frontend model. Receipts mark these `declared: true` so they cannot be mistaken for a classifier verdict. Auto-detection from assignment text is unchanged and still opt-in.
+
+### Fixed
+
+- Model-selector suites that assert UI copy now pin the locale — and restore it. They previously inherited whatever `language` the developer had configured, because a sibling suite restores the real agent directory and reloads real settings, and one suite pinned Korean without putting it back — so whether they passed depended on test file ordering.
+- The first-level `/model` role rows (`Set as EXECUTOR (Executor)`) were hardcoded English inside an otherwise localized menu. They now go through i18n in all seven locales; the redundant `(Name)` suffix is dropped where the locale does not need it, and the role tag stays verbatim because it is the same identifier receipts and `/model` arguments use.
+- Login, `--list-models`, `/model`, and `/model provider/id` now refresh provider catalogs online so newly published Kimi/Grok (and other OpenAI-compatible) ids appear without waiting for a bundled `models.json` regen or a 2h cache TTL.
 
 ## [0.5.22] - 2026-09-19
 

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

@@ -104,6 +104,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;
 }
 type SettingDef = BooleanDef | StringDef | NumberDef | EnumDef<readonly string[]> | ArrayDef<unknown> | RecordDef<unknown>;
@@ -2471,6 +2476,27 @@ export declare const SETTINGS_SCHEMA: {
         readonly type: "string";
         readonly 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.
+     */
+    readonly "task.modelRouting.specialtyModels": {
+        readonly type: "record";
+        readonly default: Record<string, ModelSelectorValue>;
+        readonly valueSchema: {
+            readonly type: "model-selector-value";
+        };
+        readonly keys: readonly ["backendArchitecture", "frontendDesign", "implementation", "testing", "review"];
+    };
     readonly "ttsr.enabled": {
         readonly type: "boolean";
         readonly default: true;

package/dist/types/config/task-model-specialties.d.ts

@@ -0,0 +1,55 @@
+/** Stable configuration/routing identifiers. Display strings are localized separately. */
+export declare const TASK_MODEL_SPECIALTY_IDS: readonly ["backendArchitecture", "frontendDesign", "implementation", "testing", "review"];
+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 declare const TASK_MODEL_SPECIALTY_ROLES: Readonly<Record<TaskModelSpecialty, readonly string[]>>;
+/** Neutral classifier outcome: the work does not clearly belong to one specialty. */
+export declare const TASK_MODEL_SPECIALTY_NONE: "none";
+/** Bounded-key predicate for the `task.modelRouting.specialtyModels` record. */
+export declare function isTaskModelSpecialty(value: unknown): value is TaskModelSpecialty;
+/** Specialties a given canonical role agent is allowed to receive, in declaration order. */
+export declare function specialtiesForRole(agentName: string): TaskModelSpecialty[];
+/** Whether a specialty may be applied to work routed to this canonical role agent. */
+export declare function specialtySupportsRole(specialty: TaskModelSpecialty, agentName: string): boolean;
+/** 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 declare function specialtySelectorIdentity(selector: string): string;
+/** The `provider/model` part, ignoring any thinking suffix. Used for "same model" checks. */
+export declare function specialtySelectorHead(selector: string): string;
+/** Expand a configured selector value into normalized candidates tagged with their origin. */
+export declare function toRoutingCandidates(value: string | readonly string[] | undefined, source: TaskRoutingSource, extra?: {
+    specialty?: TaskModelSpecialty;
+    tier?: string;
+}): TaskRoutingCandidate[];
+/**
+ * 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 declare function dedupeRoutingCandidates(segments: readonly TaskRoutingCandidate[][]): TaskRoutingCandidate[];

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

@@ -1,3 +1,6 @@
+import type { ModelSelectorValue } from "../config/model-selector-value";
+import type { Settings } from "../config/settings";
+import { type TaskModelSpecialty, type TaskRoutingCandidate, type TaskRoutingSource } from "../config/task-model-specialties";
 import type { DecisionService } from "./index";
 /** Ordered cheapest to most capable. The order *is* the policy's direction. */
 export declare const TASK_TIERS: readonly ["fast", "balanced", "deep"];
@@ -22,26 +25,57 @@ export interface TaskRoutingPolicy {
     /**
      * 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.
+     * Superseded by `specialtyModels.frontendDesign`; kept as the fallback source
+     * so an existing configuration keeps working untouched until it is migrated.
      */
     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.
+     * Per-specialty models — the work-kind axis.
+     *
+     * Absent entries inherit the role's own chain, which is why an unset specialty
+     * is not an error and does not suppress the difficulty ladder.
+     */
+    specialtyModels?: Partial<Record<TaskModelSpecialty, ModelSelectorValue>>;
+    /**
+     * Bar for a lateral swap on a **calibrated** backend. 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;
+    /**
+     * Bar for a lateral swap on an **uncalibrated** backend.
+     *
+     * The ordinary logged-in model cannot report a probability, and asking it for
+     * one measurably degrades the answer, so its choice carries no `confidence`.
+     * What it *can* report is an ordinal strength. Requiring a high ordinal is not
+     * the same guarantee as a calibrated threshold, and the result is recorded as
+     * uncalibrated — but refusing to route at all would make a user's explicit
+     * specialty selection silently inert on the default backend.
+     */
+    minSpecialtyOrdinal: number;
 }
 export declare const DEFAULT_TASK_ROUTING_POLICY: Omit<TaskRoutingPolicy, "tiers">;
+/**
+ * The settings surface this module reads.
+ *
+ * Narrowed to `get` so the router cannot quietly start writing settings, and so
+ * a caller only has to supply a reader rather than a whole `Settings` instance.
+ */
+export type TaskRoutingSettingsReader = Pick<Settings, "get">;
+/**
+ * Build the routing policy from settings, or null when routing must not run.
+ *
+ * Null is returned for two distinct reasons that both mean "leave the configured
+ * model alone": the feature is off, or it is on but nothing is configured to
+ * route *to*. A lone tier is not an axis — there is nowhere to move from it —
+ * so two tiers is the floor unless a specialty or the legacy frontend model
+ * supplies a lateral target instead.
+ */
+export declare function buildTaskRoutingPolicyFromSettings(settings: TaskRoutingSettingsReader): TaskRoutingPolicy | null;
 /**
  * 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.
+ * Derived from the specialty compatibility map so the two never drift apart.
  */
 export declare const PLANNING_ROLES: ReadonlySet<string>;
 export interface TaskRoutingRequest {
@@ -50,14 +84,65 @@ export interface TaskRoutingRequest {
     assignment: string;
     /** Whatever the role is configured to use today, used as the direction baseline. */
     currentModel: string | undefined;
+    /**
+     * The role's fully resolved chain, in order. The composed candidate list ends
+     * with this, so a specialty or tier that cannot be authenticated falls through
+     * to the model the role would have used anyway.
+     */
+    baselineChain?: readonly string[];
     signal?: AbortSignal;
 }
 export interface TaskRoutingResult {
+    /** Head of the composed chain — what the spawn runs on if it authenticates. */
     model: string;
-    /** Null when the move was a domain swap — that axis has no ladder. */
+    /** Null when the move was a specialty swap — that axis has no ladder. */
     tier: TaskTier | null;
     reason: string;
+    /** Ordered, provenance-tagged chain for the existing auth-aware resolver. */
+    candidates: TaskRoutingCandidate[];
+    /** What the classifier asked for. The *effective* source is only known after resolution. */
+    requestedSource: TaskRoutingSource;
+    requestedSpecialty?: TaskModelSpecialty;
+    requestedTier?: TaskTier;
+    /**
+     * True when the caller named the specialty on the spawn itself. No classifier
+     * ran, so `calibrated`/`confidence`/`ordinalStrength` describe nothing here.
+     */
+    declared: boolean;
+    /** False means `ordinalStrength` ranks, and no probability was available. */
+    calibrated: boolean;
+    confidence?: number;
+    ordinalStrength?: number;
+}
+export interface DeclaredSpecialtyRequest {
+    agentName: string;
+    specialty: TaskModelSpecialty;
+    /** Whatever the role is configured to use today. */
+    currentModel: string | undefined;
+    /** The role's fully resolved chain; always the tail so a dead specialty model falls through. */
+    baselineChain?: readonly string[];
 }
+/**
+ * Route a spawn whose caller *declared* the kind of work.
+ *
+ * This is the deterministic half of the specialty axis. Nothing here asks a
+ * classifier, reads `task.modelRouting.enabled`, or applies a confidence bar:
+ * the user put a model on this specialty in `/model`, the caller says this is
+ * that work, and the only remaining reason not to run on it is that it fails —
+ * which the child session's fallback chain handles at the transport boundary
+ * (429, 5xx, auth, quota) by advancing to the role's baseline behind it.
+ *
+ * Role eligibility is deliberately not checked. The menu groups specialties
+ * under the roles that usually do that work, but the setting is one flat map:
+ * a frontend model the user chose for design is the same frontend model they
+ * expect when the *implementation* of that frontend is delegated. Refusing
+ * here would make "frontend uses a different model" false for exactly the
+ * spawns where it matters most.
+ *
+ * Returns null only when nothing is configured for the specialty, or when the
+ * configured model is already what the role would run on anyway.
+ */
+export declare function resolveDeclaredSpecialtyRouting(settings: TaskRoutingSettingsReader, request: DeclaredSpecialtyRequest): TaskRoutingResult | null;
 /**
  * Decide the model for one subagent spawn, or null to leave the configured one alone.
  *

package/dist/types/i18n/messages/en.d.ts

@@ -76,6 +76,21 @@ export declare const en: {
     readonly "modelSelector.noMatching": "No matching models.";
     readonly "modelSelector.modelName": "Model Name: {value}";
     readonly "modelSelector.actionFor": "Action for: {id}";
+    readonly "modelSelector.setAsTarget": "Set as {tag} ({name})";
+    readonly "modelSelector.setForAllRoleAgents": "Set for all role agents";
+    readonly "modelSelector.setForAllTargets": "Set for all targets";
+    readonly "modelSelector.hasDetailedUses": "(detailed uses)";
+    readonly "modelSelector.detailedUseFor": "Detailed use for {target}: {id}";
+    readonly "modelSelector.generalRole": "General (whole role)";
+    readonly "modelSelector.resetSpecialties": "Clear detailed-use overrides";
+    readonly "modelSelector.specialty.backendArchitecture": "Backend architecture";
+    readonly "modelSelector.specialty.frontendDesign": "Frontend design";
+    readonly "modelSelector.specialty.implementation": "Implementation";
+    readonly "modelSelector.specialty.testing": "Testing";
+    readonly "modelSelector.specialty.review": "Review";
+    readonly "modelSelector.specialtySaved": "{specialty} will use {value}.";
+    readonly "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.";
+    readonly "modelSelector.specialtyCleared": "Cleared detailed-use overrides for {target}.";
     readonly "modelSelector.reasoningFor": "Reasoning for {target}: {id}";
     readonly "modelSelector.temporaryModel": "temporary model";
 };

package/dist/types/lsp/index.d.ts

@@ -95,6 +95,7 @@ export declare class LspTool implements AgentTool<typeof lspSchema, LspToolDetai
     readonly description: string;
     readonly parameters: import("zod").ZodObject<{
         action: import("zod").ZodEnum<{
+            implementation: "implementation";
             status: "status";
             diagnostics: "diagnostics";
             definition: "definition";
@@ -105,7 +106,6 @@ export declare class LspTool implements AgentTool<typeof lspSchema, LspToolDetai
             rename_file: "rename_file";
             code_actions: "code_actions";
             type_definition: "type_definition";
-            implementation: "implementation";
             reload: "reload";
             capabilities: "capabilities";
             request: "request";

package/dist/types/lsp/types.d.ts

@@ -3,6 +3,7 @@ import * as z from "zod/v4";
 import type { OwnedProcess } from "../runtime/process-lifecycle";
 export declare const lspSchema: z.ZodObject<{
     action: z.ZodEnum<{
+        implementation: "implementation";
         status: "status";
         diagnostics: "diagnostics";
         definition: "definition";
@@ -13,7 +14,6 @@ export declare const lspSchema: z.ZodObject<{
         rename_file: "rename_file";
         code_actions: "code_actions";
         type_definition: "type_definition";
-        implementation: "implementation";
         reload: "reload";
         capabilities: "capabilities";
         request: "request";

package/dist/types/modes/components/model-selector.d.ts

@@ -5,6 +5,7 @@ import type { ModelRegistry, SkcModelAssignmentTargetId } from "../../config/mod
 import { type ScopedModelSelection } from "../../config/model-resolver";
 import type { ModelProfileConfig } from "../../config/models-config-schema";
 import type { Settings } from "../../config/settings";
+import { type TaskModelSpecialty } from "../../config/task-model-specialties";
 type ScopedModelItem = ScopedModelSelection;
 export type ModelSelectorSelection = {
     kind: "assignment";
@@ -17,6 +18,16 @@ export type ModelSelectorSelection = {
     kind: "profile";
     profileName: string;
     setDefault: boolean;
+} | {
+    kind: "specialtyAssignment";
+    model: Model;
+    role: SkcModelAssignmentTargetId;
+    specialty: TaskModelSpecialty;
+    thinkingLevel?: ThinkingLevel;
+    selector?: string;
+} | {
+    kind: "specialtyReset";
+    role: SkcModelAssignmentTargetId;
 } | {
     kind: "createProfile";
     profile: ModelProfileConfig;

package/dist/types/task/index.d.ts

@@ -12,7 +12,7 @@ export { isValidAllocatedTaskId, isValidTaskId, TASK_ID_DESCRIPTION, TASK_ID_PAT
 export { AgentOutputManager } from "./output-manager";
 export type { TaskResultReceipt } from "./receipt";
 export { assertNoRawTaskFields, buildTaskReceipt, buildTaskRoi, buildTaskRoiSummary, findRawTaskLeakKeys, sanitizeTaskToolDetails, } from "./receipt";
-export type { AgentDefinition, AgentProgress, SingleResult, SubagentLifecyclePayload, SubagentProgressPayload, TaskParams, TaskToolDetails, } from "./types";
+export type { AgentDefinition, AgentProgress, SingleResult, SubagentLifecyclePayload, SubagentProgressPayload, TaskParams, TaskRoutingAttribution, TaskToolDetails, } from "./types";
 export { TASK_SUBAGENT_EVENT_CHANNEL, TASK_SUBAGENT_LIFECYCLE_CHANNEL, TASK_SUBAGENT_PROGRESS_CHANNEL, taskSchema, } from "./types";
 export declare function resolveForkContextMaxTokens(configured: number, model: Model | undefined): number;
 /**

package/dist/types/task/receipt.d.ts

@@ -28,6 +28,8 @@ export interface TaskResultReceipt {
     contextTokens?: number;
     contextWindow?: number;
     modelOverride?: string | string[];
+    /** What the router asked for, kept separate from what the spawn ran on. */
+    routing?: SingleResult["routing"];
     modelSubstitutionWarning?: SingleResult["modelSubstitutionWarning"];
     usage?: SingleResult["usage"];
     cost?: number;

package/dist/types/task/types.d.ts

@@ -1,6 +1,8 @@
 import type { ThinkingLevel } from "@sayknow-cli/agent-core";
 import type { Usage } from "@sayknow-cli/ai";
 import * as z from "zod/v4";
+import { type TaskModelSpecialty, type TaskRoutingSource } from "../config/task-model-specialties";
+import type { TaskTier } from "../decisions/task-routing";
 import type { TaskResultReceipt } from "./receipt";
 import type { SpawnRoiReconciliation } from "./roi-reconciliation";
 import { type TaskSimpleMode } from "./simple-mode";
@@ -49,12 +51,19 @@ export declare const taskItemSchema: z.ZodObject<{
         default: "default";
         "ultragoal-red-team": "ultragoal-red-team";
     }>>;
+    specialty: z.ZodOptional<z.ZodEnum<{
+        backendArchitecture: "backendArchitecture";
+        frontendDesign: "frontendDesign";
+        implementation: "implementation";
+        testing: "testing";
+        review: "review";
+    }>>;
     inheritContext: z.ZodOptional<z.ZodEnum<{
         none: "none";
-        receipt: "receipt";
+        full: "full";
         "last-turn": "last-turn";
+        receipt: "receipt";
         bounded: "bounded";
-        full: "full";
     }>>;
     repositoryBinding: z.ZodOptional<z.ZodObject<{
         schema: z.ZodLiteral<"skc.repository_binding.v1">;
@@ -77,12 +86,19 @@ export declare const taskSchema: z.ZodObject<{
             default: "default";
             "ultragoal-red-team": "ultragoal-red-team";
         }>>;
+        specialty: z.ZodOptional<z.ZodEnum<{
+            backendArchitecture: "backendArchitecture";
+            frontendDesign: "frontendDesign";
+            implementation: "implementation";
+            testing: "testing";
+            review: "review";
+        }>>;
         inheritContext: z.ZodOptional<z.ZodEnum<{
             none: "none";
-            receipt: "receipt";
+            full: "full";
             "last-turn": "last-turn";
+            receipt: "receipt";
             bounded: "bounded";
-            full: "full";
         }>>;
         repositoryBinding: z.ZodOptional<z.ZodObject<{
             schema: z.ZodLiteral<"skc.repository_binding.v1">;
@@ -112,12 +128,19 @@ export declare const taskSchemaNoIsolation: z.ZodObject<{
             default: "default";
             "ultragoal-red-team": "ultragoal-red-team";
         }>>;
+        specialty: z.ZodOptional<z.ZodEnum<{
+            backendArchitecture: "backendArchitecture";
+            frontendDesign: "frontendDesign";
+            implementation: "implementation";
+            testing: "testing";
+            review: "review";
+        }>>;
         inheritContext: z.ZodOptional<z.ZodEnum<{
             none: "none";
-            receipt: "receipt";
+            full: "full";
             "last-turn": "last-turn";
+            receipt: "receipt";
             bounded: "bounded";
-            full: "full";
         }>>;
         repositoryBinding: z.ZodOptional<z.ZodObject<{
             schema: z.ZodLiteral<"skc.repository_binding.v1">;
@@ -147,12 +170,19 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
             default: "default";
             "ultragoal-red-team": "ultragoal-red-team";
         }>>;
+        specialty: z.ZodOptional<z.ZodEnum<{
+            backendArchitecture: "backendArchitecture";
+            frontendDesign: "frontendDesign";
+            implementation: "implementation";
+            testing: "testing";
+            review: "review";
+        }>>;
         inheritContext: z.ZodOptional<z.ZodEnum<{
             none: "none";
-            receipt: "receipt";
+            full: "full";
             "last-turn": "last-turn";
+            receipt: "receipt";
             bounded: "bounded";
-            full: "full";
         }>>;
         repositoryBinding: z.ZodOptional<z.ZodObject<{
             schema: z.ZodLiteral<"skc.repository_binding.v1">;
@@ -181,12 +211,19 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
             default: "default";
             "ultragoal-red-team": "ultragoal-red-team";
         }>>;
+        specialty: z.ZodOptional<z.ZodEnum<{
+            backendArchitecture: "backendArchitecture";
+            frontendDesign: "frontendDesign";
+            implementation: "implementation";
+            testing: "testing";
+            review: "review";
+        }>>;
         inheritContext: z.ZodOptional<z.ZodEnum<{
             none: "none";
-            receipt: "receipt";
+            full: "full";
             "last-turn": "last-turn";
+            receipt: "receipt";
             bounded: "bounded";
-            full: "full";
         }>>;
         repositoryBinding: z.ZodOptional<z.ZodObject<{
             schema: z.ZodLiteral<"skc.repository_binding.v1">;
@@ -215,12 +252,19 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
             default: "default";
             "ultragoal-red-team": "ultragoal-red-team";
         }>>;
+        specialty: z.ZodOptional<z.ZodEnum<{
+            backendArchitecture: "backendArchitecture";
+            frontendDesign: "frontendDesign";
+            implementation: "implementation";
+            testing: "testing";
+            review: "review";
+        }>>;
         inheritContext: z.ZodOptional<z.ZodEnum<{
             none: "none";
-            receipt: "receipt";
+            full: "full";
             "last-turn": "last-turn";
+            receipt: "receipt";
             bounded: "bounded";
-            full: "full";
         }>>;
         repositoryBinding: z.ZodOptional<z.ZodObject<{
             schema: z.ZodLiteral<"skc.repository_binding.v1">;
@@ -249,12 +293,19 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
             default: "default";
             "ultragoal-red-team": "ultragoal-red-team";
         }>>;
+        specialty: z.ZodOptional<z.ZodEnum<{
+            backendArchitecture: "backendArchitecture";
+            frontendDesign: "frontendDesign";
+            implementation: "implementation";
+            testing: "testing";
+            review: "review";
+        }>>;
         inheritContext: z.ZodOptional<z.ZodEnum<{
             none: "none";
-            receipt: "receipt";
+            full: "full";
             "last-turn": "last-turn";
+            receipt: "receipt";
             bounded: "bounded";
-            full: "full";
         }>>;
         repositoryBinding: z.ZodOptional<z.ZodObject<{
             schema: z.ZodLiteral<"skc.repository_binding.v1">;
@@ -283,12 +334,19 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
             default: "default";
             "ultragoal-red-team": "ultragoal-red-team";
         }>>;
+        specialty: z.ZodOptional<z.ZodEnum<{
+            backendArchitecture: "backendArchitecture";
+            frontendDesign: "frontendDesign";
+            implementation: "implementation";
+            testing: "testing";
+            review: "review";
+        }>>;
         inheritContext: z.ZodOptional<z.ZodEnum<{
             none: "none";
-            receipt: "receipt";
+            full: "full";
             "last-turn": "last-turn";
+            receipt: "receipt";
             bounded: "bounded";
-            full: "full";
         }>>;
         repositoryBinding: z.ZodOptional<z.ZodObject<{
             schema: z.ZodLiteral<"skc.repository_binding.v1">;
@@ -317,12 +375,19 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
             default: "default";
             "ultragoal-red-team": "ultragoal-red-team";
         }>>;
+        specialty: z.ZodOptional<z.ZodEnum<{
+            backendArchitecture: "backendArchitecture";
+            frontendDesign: "frontendDesign";
+            implementation: "implementation";
+            testing: "testing";
+            review: "review";
+        }>>;
         inheritContext: z.ZodOptional<z.ZodEnum<{
             none: "none";
-            receipt: "receipt";
+            full: "full";
             "last-turn": "last-turn";
+            receipt: "receipt";
             bounded: "bounded";
-            full: "full";
         }>>;
         repositoryBinding: z.ZodOptional<z.ZodObject<{
             schema: z.ZodLiteral<"skc.repository_binding.v1">;
@@ -402,6 +467,33 @@ export interface ModelSubstitutionWarning {
     effective: string;
     reason: "auth_unavailable" | "assistant_model_mismatch";
 }
+/**
+ * What the model router *asked for* on one child — deliberately not what it ran on.
+ *
+ * The dispatched value is a fallback chain, so the head can lose to a later
+ * candidate when it fails to authenticate. Recording the request separately is
+ * what keeps a receipt from claiming a specialty model was used when the spawn
+ * actually fell through to the role's baseline. `ModelSubstitutionWarning`
+ * covers the disagreement; this covers the intent.
+ */
+export interface TaskRoutingAttribution {
+    /** Axis the head came from. `baseline` means the router declined to move. */
+    source: TaskRoutingSource;
+    /** Bounded specialty id, present only when the specialty axis won. */
+    specialty?: TaskModelSpecialty;
+    /** Tier the classifier settled on. Null for a specialty swap, which has no ladder. */
+    tier?: TaskTier;
+    /** True when the caller declared the specialty on the spawn; no classifier ran. */
+    declared: boolean;
+    /** False for ordinary LLM backends, which return no probabilities at all. */
+    calibrated: boolean;
+    /** Probability. Present only when `calibrated` is true — never synthesised. */
+    confidence?: number;
+    /** Ordinal clarity in [0,1], recorded in place of a probability when uncalibrated. */
+    ordinalStrength?: number;
+    /** Router's own explanation, surfaced verbatim on the receipt. */
+    reason: string;
+}
 /** Progress tracking for a single agent */
 export interface AgentProgress {
     index: number;
@@ -439,6 +531,8 @@ export interface AgentProgress {
     durationMs: number;
     modelOverride?: string | string[];
     modelSubstitutionWarning?: ModelSubstitutionWarning;
+    /** What the router asked for on this child. See {@link TaskRoutingAttribution}. */
+    routing?: TaskRoutingAttribution;
     /** Data extracted by registered subprocess tool handlers (keyed by tool name) */
     extractedToolData?: Record<string, unknown[]>;
     /**
@@ -500,6 +594,8 @@ export interface SingleResult {
     /** Model's context window in tokens, when known. */
     contextWindow?: number;
     modelOverride?: string | string[];
+    /** What the router asked for on this child. See {@link TaskRoutingAttribution}. */
+    routing?: TaskRoutingAttribution;
     modelSubstitutionWarning?: ModelSubstitutionWarning;
     error?: string;
     aborted?: boolean;

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

@@ -19,8 +19,8 @@ declare const subagentSchema: z.ZodObject<{
     timeout_ms: z.ZodOptional<z.ZodNumber>;
     limit: z.ZodOptional<z.ZodNumber>;
     verbosity: z.ZodOptional<z.ZodEnum<{
-        receipt: "receipt";
         full: "full";
+        receipt: "receipt";
         preview: "preview";
     }>>;
 }, z.core.$strip>;
@@ -88,8 +88,8 @@ export declare class SubagentTool implements AgentTool<typeof subagentSchema, Su
         timeout_ms: z.ZodOptional<z.ZodNumber>;
         limit: z.ZodOptional<z.ZodNumber>;
         verbosity: z.ZodOptional<z.ZodEnum<{
-            receipt: "receipt";
             full: "full";
+            receipt: "receipt";
             preview: "preview";
         }>>;
     }, z.core.$strip>;