dsh-auto-model-routing 0.4.2 → 0.5.1

package/lib/state.js

@@ -2,7 +2,8 @@ import { mkdirSync, readFileSync, writeFileSync, renameSync } from 'node:fs';
 import { resolve, dirname } from 'node:path';
 import { createHash } from 'node:crypto';
 import { z } from 'zod';
-// Legacy files also carried `restore`/`anchor`; they are ignored (non-strict) and dropped on the next write.
+// Older files also carried `restore`/`anchor` (ignored, non-strict, dropped on the next write) and
+// `previous` (a retired tier name: still accepted and kept as is, never written anew).
 const stateSchema = z.object({
     mode: z.enum(['AUTO', 'MANUAL']),
     previous: z.enum(['simple', 'standard', 'complex', 'escalated']).optional(),
@@ -56,12 +57,6 @@ export class RoutingState {
         const state = this.read(id);
         return this.save(id, { mode: 'MANUAL', ...(state.previous ? { previous: state.previous } : {}), disabled: { category, at } });
     }
-    /** Keep the latest user-turn tier (name only) so a restart still sends it to Jev as context. */
-    remember(id, tier) {
-        const state = this.read(id);
-        if (state.previous !== tier)
-            this.save(id, { ...state, previous: tier });
-    }
     save(id, state) {
         this.store.set(id, structuredClone(state));
         return structuredClone(state);

package/lib/strategies/claude.d.ts

@@ -0,0 +1,21 @@
+export declare const claude: {
+    readonly id: "claude";
+    readonly label: "Claude";
+    readonly modelPrefixes: readonly ["claude-"];
+    readonly transports: {
+        readonly claude: "";
+        readonly 'dsh-magpie-connect': "claude/";
+        readonly 'dsh-magpie-connector': "claude/";
+    };
+    readonly effortStarts: {
+        readonly 'claude-opus-5-5': "medium";
+        readonly 'claude-sonnet-5-5': "medium";
+        readonly 'claude-haiku-5-5': "medium";
+        readonly 'claude-fable-5-1': "high";
+    };
+    readonly childModels: {
+        readonly bounded: "claude-haiku-5-5";
+        readonly analytical: "claude-sonnet-5-5";
+        readonly frontier: "claude-opus-5-5";
+    };
+};

package/lib/strategies/claude.js

@@ -0,0 +1,8 @@
+export const claude = {
+    id: 'claude',
+    label: 'Claude',
+    modelPrefixes: ['claude-'],
+    transports: { claude: '', 'dsh-magpie-connect': 'claude/', 'dsh-magpie-connector': 'claude/' },
+    effortStarts: { 'claude-opus-5-5': 'medium', 'claude-sonnet-5-5': 'medium', 'claude-haiku-5-5': 'medium', 'claude-fable-5-1': 'high' },
+    childModels: { bounded: 'claude-haiku-5-5', analytical: 'claude-sonnet-5-5', frontier: 'claude-opus-5-5' },
+};

package/lib/strategies/codex.d.ts

@@ -0,0 +1,21 @@
+/** GPT family; the id stays `codex` (the local transport name). */
+export declare const codex: {
+    readonly id: "codex";
+    readonly label: "GPT";
+    readonly modelPrefixes: readonly ["gpt-"];
+    readonly transports: {
+        readonly codex: "";
+        readonly 'dsh-magpie-connect': "codex/";
+        readonly 'dsh-magpie-connector': "codex/";
+    };
+    readonly effortStarts: {
+        readonly 'gpt-6.1-sol': "medium";
+        readonly 'gpt-6-luna': "high";
+        readonly 'gpt-6-astra': "low";
+    };
+    readonly childModels: {
+        readonly bounded: "gpt-6-luna";
+        readonly analytical: "gpt-6.1-sol";
+        readonly frontier: "gpt-6.1-sol";
+    };
+};

package/lib/strategies/codex.js

@@ -0,0 +1,9 @@
+/** GPT family; the id stays `codex` (the local transport name). */
+export const codex = {
+    id: 'codex',
+    label: 'GPT',
+    modelPrefixes: ['gpt-'],
+    transports: { codex: '', 'dsh-magpie-connect': 'codex/', 'dsh-magpie-connector': 'codex/' },
+    effortStarts: { 'gpt-6.1-sol': 'medium', 'gpt-6-luna': 'high', 'gpt-6-astra': 'low' },
+    childModels: { bounded: 'gpt-6-luna', analytical: 'gpt-6.1-sol', frontier: 'gpt-6.1-sol' },
+};

package/lib/strategies/index.d.ts

@@ -0,0 +1,22 @@
+import type { Capability, FamilyStrategy, StartEffort } from './types.js';
+export type { Capability, FamilyStrategy, StartEffort } from './types.js';
+export interface Registry {
+    readonly strategies: readonly FamilyStrategy[];
+    /** Main-model support decision; undefined means AUTO does not manage this model. */
+    familyOfMainModel(model: string | undefined): FamilyStrategy | undefined;
+    /** Family of a child model on an exact transport provider. */
+    familyOfChild(provider: string, model: string): FamilyStrategy | undefined;
+    /** Child model id for a family on a transport: transport prefix + capability slot. */
+    childModel(familyId: string, provider: string, capability: Capability): string | undefined;
+    effortStart(model: string): StartEffort | undefined;
+    hasProvider(provider: string): boolean;
+    get(familyId: string): FamilyStrategy | undefined;
+    providers(): string[];
+    ids(): string[];
+    labels(): string[];
+}
+/** Validates the whole list up front; any conflict throws and no partial registry exists. */
+export declare function createRegistry(input: readonly FamilyStrategy[]): Registry;
+export declare const BUILTIN_STRATEGIES: readonly FamilyStrategy[];
+/** The registry every module uses unless a test injects strategies through `apply(ctx, { strategies })`. */
+export declare const registry: Registry;

package/lib/strategies/index.js

@@ -0,0 +1,85 @@
+import { claude } from './claude.js';
+import { codex } from './codex.js';
+const CAPABILITIES = ['bounded', 'analytical', 'frontier'];
+const START_EFFORTS = ['low', 'medium', 'high', 'xhigh'];
+const bare = (model) => model.slice(model.lastIndexOf('/') + 1);
+const overlaps = (a, b) => a.startsWith(b) || b.startsWith(a);
+/** Validates the whole list up front; any conflict throws and no partial registry exists. */
+export function createRegistry(input) {
+    const strategies = input.map(s => structuredClone(s));
+    const ids = new Set();
+    const starts = new Map();
+    const prefixes = [];
+    const childPrefixes = new Map();
+    for (const s of strategies) {
+        if (!s.id)
+            throw new Error('策略缺少 id');
+        if (ids.has(s.id))
+            throw new Error(`策略 id 重复：${s.id}`);
+        ids.add(s.id);
+        for (const prefix of s.modelPrefixes) {
+            const lower = prefix.toLowerCase();
+            if (!lower)
+                throw new Error(`策略 ${s.id} 的模型前缀为空`);
+            const clash = prefixes.find(p => overlaps(p.prefix.toLowerCase(), lower));
+            if (clash)
+                throw new Error(`模型前缀重叠：${prefix}（${s.id}）与 ${clash.prefix}（${clash.id}）`);
+            prefixes.push({ prefix, id: s.id });
+        }
+        for (const [model, effort] of Object.entries(s.effortStarts)) {
+            if (!START_EFFORTS.includes(effort))
+                throw new Error(`策略 ${s.id} 的起点 effort 非法：${model}=${String(effort)}`);
+            if (starts.has(model))
+                throw new Error(`起点键重复：${model}（${starts.get(model)} 与 ${s.id}）`);
+            starts.set(model, s.id);
+        }
+        for (const capability of CAPABILITIES)
+            if (typeof s.childModels?.[capability] !== 'string' || !s.childModels[capability])
+                throw new Error(`策略 ${s.id} 缺少能力槽：${capability}`);
+        for (const [provider, prefix] of Object.entries(s.transports)) {
+            const existing = childPrefixes.get(provider) ?? [];
+            const clash = existing.find(p => p.prefix === '' || prefix === '' ? true : overlaps(p.prefix, prefix));
+            if (clash) {
+                if (clash.prefix === '' || prefix === '')
+                    throw new Error(`provider ${provider} 的空前缀只能属于一个策略（${clash.id} 与 ${s.id} 冲突）`);
+                throw new Error(`provider ${provider} 下子模型前缀重叠：${prefix}（${s.id}）与 ${clash.prefix}（${clash.id}）`);
+            }
+            childPrefixes.set(provider, [...existing, { prefix, id: s.id }]);
+        }
+    }
+    const byId = new Map(strategies.map(s => [s.id, s]));
+    return Object.freeze({
+        strategies,
+        familyOfMainModel: (model) => {
+            if (typeof model !== 'string' || !model)
+                return undefined;
+            const name = bare(model).toLowerCase();
+            return strategies.find(s => s.modelPrefixes.some(p => name.startsWith(p.toLowerCase())));
+        },
+        familyOfChild: (provider, model) => {
+            const entries = childPrefixes.get(provider) ?? [];
+            const hit = entries.find(e => e.prefix !== '' && model.startsWith(e.prefix)) ?? (entries.length === 1 && entries[0].prefix === '' ? entries[0] : undefined);
+            return hit ? byId.get(hit.id) : undefined;
+        },
+        childModel: (familyId, provider, capability) => {
+            const s = byId.get(familyId);
+            const prefix = s?.transports[provider];
+            return s && prefix !== undefined ? `${prefix}${s.childModels[capability]}` : undefined;
+        },
+        effortStart: (model) => {
+            const name = bare(model);
+            for (const s of strategies)
+                if (Object.hasOwn(s.effortStarts, name))
+                    return s.effortStarts[name];
+            return undefined;
+        },
+        hasProvider: (provider) => childPrefixes.has(provider),
+        get: (familyId) => byId.get(familyId),
+        providers: () => [...childPrefixes.keys()],
+        ids: () => strategies.map(s => s.id),
+        labels: () => strategies.map(s => s.label),
+    });
+}
+export const BUILTIN_STRATEGIES = [claude, codex];
+/** The registry every module uses unless a test injects strategies through `apply(ctx, { strategies })`. */
+export const registry = createRegistry(BUILTIN_STRATEGIES);

package/lib/strategies/types.d.ts

@@ -0,0 +1,14 @@
+export type Capability = 'bounded' | 'analytical' | 'frontier';
+export type StartEffort = 'low' | 'medium' | 'high' | 'xhigh';
+/** Everything AUTO knows about one model family. Pure data: engine rules (depth offsets, caps) stay out. */
+export interface FamilyStrategy {
+    readonly id: string;
+    readonly label: string;
+    /** Main-model support: matched case-insensitively against the id after its last `/`. */
+    readonly modelPrefixes: readonly string[];
+    /** Transport provider → model-id prefix for this family's child models on that transport. */
+    readonly transports: Readonly<Record<string, string>>;
+    /** Exact bare model id → recommended starting effort. */
+    readonly effortStarts: Readonly<Record<string, StartEffort>>;
+    readonly childModels: Readonly<Record<Capability, string>>;
+}

package/lib/strategies/types.js

@@ -0,0 +1 @@
+export {};

package/lib/subagent-tool.d.ts

@@ -1,7 +1,7 @@
-import { type Settings, type RoutingCatalog } from './settings-contract.js';
-import { type JevClient } from './jev.js';
-import type { Judgement } from './router.js';
+import type { Settings, RoutingCatalog } from './settings-contract.js';
+import type { JevClient } from './jev.js';
 import type { RoutingState } from './state.js';
+import { type Registry } from './strategies/index.js';
 interface SessionLike {
     id: string;
     session: {
@@ -17,10 +17,10 @@ export interface ToolDeps {
         get(id: string): SessionLike | undefined;
     };
     state: RoutingState;
-    readSettings?: () => Settings;
-    catalog?: () => RoutingCatalog | Promise<RoutingCatalog>;
-    judged?: (sessionId: string, value: Omit<Judgement, 'id'>) => void;
+    readSettings: () => Settings;
+    catalog: () => RoutingCatalog | Promise<RoutingCatalog>;
+    registry?: Registry;
 }
-/** Sub-agent decision tool: same Jev judgment as the main session, only while the root session is AUTO. Writes no state. */
+/** Preview only: the same Jev judgment AUTO uses, while the root session is AUTO. Writes no state. */
 export declare function routeSubagentTool(jev: JevClient, deps: ToolDeps): import("@deepseek-ai/dsh-tools").ToolDefinition;
 export {};

package/lib/subagent-tool.js

@@ -1,12 +1,7 @@
 import { defineTool } from '@deepseek-ai/dsh-tools';
-import { CHILD_MODELS, mapEffort, tiers } from './effort.js';
-import { explicitChildRoute, SettingsValidationError } from './settings.js';
-import { DEFAULT_SETTINGS } from './settings-contract.js';
-import { validateChildRoute } from './settings-validation.js';
-import { CATEGORY_HINTS } from './jev.js';
 import { buildState } from './context.js';
-import { choosePolicyRoute, magpieProvider, modelFamily, POLICY_PROVIDERS } from './policy-v2.js';
-import { policyVersion } from './jev.js';
+import { choosePolicyRoute, modelFamily } from './routing.js';
+import { registry as builtin } from './strategies/index.js';
 /** The ordinary session a caller belongs to; undefined when any link is no longer live (treated as MANUAL). */
 function rootOf(caller, agents) {
     let current = caller;
@@ -18,20 +13,21 @@ function rootOf(caller, agents) {
     }
     return undefined;
 }
-const MANUAL_TEXT = '主会话为 MANUAL：不判档，按官方默认委派；只传用户或 lead 指定的值（例如指定的模型），不传其它 provider/model/reasoning_effort。';
-/** Sub-agent decision tool: same Jev judgment as the main session, only while the root session is AUTO. Writes no state. */
+const MANUAL_TEXT = '主会话为 MANUAL：不判断，按官方默认委派；只传用户或 lead 指定的值（例如指定的模型），不传其它 provider/model/reasoning_effort。';
+/** Preview only: the same Jev judgment AUTO uses, while the root session is AUTO. Writes no state. */
 export function routeSubagentTool(jev, deps) {
+    const registry = deps.registry ?? builtin;
     return defineTool({
         name: 'route_subagent',
-        description: 'When policy-v2 is selected, this tool is an optional preview only: use the official fresh creation tool directly for exact-child automatic routing, do not turn preview output into explicit user constraints; fork is unsupported. Under the legacy policy: Call before every sub-agent delegation, whatever the task size. Picks provider/model/reasoning_effort with the Jev decision model; pass provider, model and reasoning_effort explicitly to the sub-agent tool, or the sub-agent inherits this session\'s effort. Sends the task text (redacted, up to 8000 characters) to OpenRouter/TypeSafe only while the main session is AUTO; otherwise returns routed=false: delegate with the official defaults. If the user or lead already chose the sub-agent model, pass it as model: only reasoning_effort is routed and the model is kept. On error: pause delegation and ask the user; never guess a tier.',
-        timeoutMs: 5000,
+        description: 'Optional preview of the AUTO sub-agent route: returns a recommendation only, never an applied route. Automatic routing happens when the official fresh creation tool creates the exact child, before its first request; use that tool directly and do not turn this recommendation into an explicit user constraint. Fork is unsupported. Sends the task text (redacted, up to 8000 characters) to the decision service chosen in settings only while the main session is AUTO; otherwise returns routed=false: delegate with the official defaults. If the user or lead already chose the model or effort, pass it: only the missing dimension is judged. On error: pause delegation and ask the user; never guess or switch models.',
+        timeoutMs: 10000,
         parameters: {
             task: { type: 'string', required: true, description: 'The task the sub-agent will do.' },
-            provider: { type: 'string', required: true, enum: [...POLICY_PROVIDERS], description: 'Exact transport provider. Magpie is available only under policy-v2.' },
-            model: { type: 'string', description: 'Sub-agent model already chosen by the user or lead; when given, only reasoning_effort is routed.' },
-            reasoning_effort: { type: 'string', description: 'Explicit effort constraint for policy-v2; preserved and validated, never silently replaced.' },
-            family: { type: 'string', enum: ['claude', 'codex'], description: 'Magpie automatic capability family; required when no model is explicitly supplied.' },
-            path: { type: 'string', enum: ['ordinary', 'fork', 'teammate'], description: 'policy-v2 creation path; fork remains unsupported until real history compatibility is verified.' },
+            provider: { type: 'string', required: true, enum: registry.providers(), description: 'Exact transport provider of the sub-agent.' },
+            model: { type: 'string', description: 'Sub-agent model already chosen by the user or lead; when given, only reasoning_effort is judged.' },
+            reasoning_effort: { type: 'string', description: 'Effort already chosen by the user or lead; preserved and validated, never silently replaced.' },
+            family: { type: 'string', enum: registry.ids(), description: 'Model family for an automatic model on a transport shared by several families; required there when no model is supplied.' },
+            path: { type: 'string', enum: ['ordinary', 'fork', 'teammate'], description: 'Creation path; fork is unsupported.' },
         },
         output: {
             schema: {
@@ -40,82 +36,43 @@ export function routeSubagentTool(jev, deps) {
                 properties: {
                     routed: { type: 'boolean' },
                     status: { type: 'string' },
-                    policyVersion: { type: 'string' },
                     capability: { type: 'string' },
                     depth: { type: 'string' },
                     reason: { type: 'string' },
-                    tier: { type: 'string' },
                     provider: { type: 'string' },
                     model: { type: 'string' },
                     reasoning_effort: { type: 'string' },
                 },
             },
-            render: (_args, v) => [{ type: 'text', text: v.status ? (v.status === 'recommended'
-                        ? `policy-v2 recommended only (not applied): ${v.provider}/${v.model}/${v.reasoning_effort}. Use the official creation tool; AUTO judges and binds the exact child before its first request. Do not copy this recommendation as a new explicit user constraint. Query the child routing status for applied evidence.`
-                        : `policy-v2 ${v.status}: ${v.reason}. 暂停委派并询问用户；不将推荐冒充实际应用。`)
-                        : v.routed === false
-                            ? MANUAL_TEXT
-                            : `Delegate with provider=${v.provider} model=${v.model} reasoning_effort=${v.reasoning_effort} (tier ${v.tier}); label the description [${v.model}·${v.reasoning_effort}].` }],
+            render: (_args, v) => [{ type: 'text', text: v.status === 'recommended'
+                        ? `Recommended only (not applied): ${v.provider}/${v.model}/${v.reasoning_effort}. Use the official creation tool; AUTO judges and binds the exact child before its first request. Do not copy this recommendation as a new explicit user constraint. Query the child routing status for applied evidence.`
+                        : v.status ? `${v.status}: ${v.reason}. 暂停委派并询问用户；不将推荐冒充实际应用。`
+                            : MANUAL_TEXT }],
         },
         execute: async (args, exec) => {
-            const caller = exec.agent;
-            const root = rootOf(caller, deps.agents);
+            const root = rootOf(exec.agent, deps.agents);
             // MANUAL (or disabled, or an unreachable root): no judgement and nothing leaves the machine.
             if (!root || deps.state.read(root.id).mode !== 'AUTO')
                 return { routed: false, reason: 'manual' };
-            if (deps.readSettings?.().policy === 'policy-v2') {
-                if (args.path === 'fork')
-                    return { routed: false, status: 'unsupported', policyVersion, reason: 'fork 真实历史兼容尚未验证；选择 fresh 或由用户关闭试验后继承' };
-                const explicit = { ...(args.model ? { model: args.model } : {}), ...(args.reasoning_effort ? { reasoningEffort: args.reasoning_effort } : {}) };
-                const result = explicit.model && explicit.reasoningEffort ? { kind: 'ok', depth: 'baseline', capability: 'bounded' }
-                    : await jev.judgePolicy(buildState({ text: args.task }), exec.signal, 'child', explicit.model ? 'depth' : explicit.reasoningEffort ? 'capability' : 'both');
-                if (result.kind !== 'ok')
-                    throw new Error('policy-v2 Jev 判断失败或取消；暂停委派并询问用户');
-                if (result.capability === 'insufficient_context')
-                    return { routed: false, status: 'needs-context', policyVersion, reason: '请补充任务目标与范围' };
-                const route = choosePolicyRoute(args.provider, result.capability ?? 'bounded', result.depth, await deps.catalog(), deps.readSettings().effortCap, explicit, args.family ?? (args.model ? modelFamily(args.provider, args.model) : undefined));
-                return { status: 'recommended', policyVersion, ...(result.capability ? { capability: result.capability } : {}), depth: result.depth, provider: route.provider, model: route.model, reasoning_effort: route.reasoningEffort };
-            }
-            if (magpieProvider(args.provider))
-                throw new Error('Magpie 路由需显式选择 policy-v2；原策略不变');
-            const result = await jev.judge(buildState({ text: args.task }), exec.signal);
-            if (result.kind === 'cancelled')
-                throw new Error('route_subagent 已取消。');
-            if (result.kind === 'failed')
-                throw new Error(`Jev 判档失败：${CATEGORY_HINTS[result.category]}（${result.category}）。请暂停委派并询问用户，不要自行猜测档位或换用其它模型。`);
-            const provider = args.provider;
-            const defaultModel = CHILD_MODELS[provider][tiers.indexOf(result.tier)];
-            let model;
-            let effort;
+            if (args.path === 'fork')
+                return { routed: false, status: 'unsupported', reason: 'fork 的真实历史兼容尚未验证；请改用 fresh' };
+            const explicit = { ...(args.model ? { model: args.model } : {}), ...(args.reasoning_effort ? { reasoningEffort: args.reasoning_effort } : {}) };
+            const result = explicit.model && explicit.reasoningEffort ? { kind: 'ok', depth: 'baseline', capability: 'bounded' }
+                : await jev.judgePolicy(buildState({ text: args.task }), exec.signal, 'child', explicit.model ? 'depth' : explicit.reasoningEffort ? 'capability' : 'both');
+            if (result.kind !== 'ok')
+                throw new Error('Jev 判断失败或已取消；暂停委派并询问用户');
+            if (result.capability === 'insufficient_context')
+                return { routed: false, status: 'needs-context', reason: '请补充任务目标与范围' };
+            let route;
             try {
-                // Legacy callers without settings/catalog keep the original table; the Host always supplies both.
-                const catalog = deps.catalog ? await deps.catalog() : {
-                    models: deps.readSettings ? [] : [{ provider, model: defaultModel, name: defaultModel, reasoningEfforts: ['low', 'medium', 'high', 'xhigh'] }],
-                    childAllowlist: { status: 'enabled', allowedModels: deps.readSettings ? [] : [{ provider, model: defaultModel }] },
-                };
-                if (exec.signal.aborted)
-                    throw new Error('cancelled');
-                const settings = deps.readSettings?.() ?? DEFAULT_SETTINGS;
-                // A caller-chosen model skips the tier→model table entirely (childRoutes included); only effort is routed.
-                const explicit = args.model ? undefined : explicitChildRoute(settings, provider, result.tier, catalog);
-                model = args.model || (explicit?.model ?? defaultModel);
-                const supported = catalog.models.find(entry => entry.provider === provider && entry.model === model)?.reasoningEfforts ?? [];
-                const mapped = explicit?.reasoningEffort ?? mapEffort(model, result.tier, supported, settings.effortCap);
-                if (!mapped || validateChildRoute(catalog, provider, { model, reasoningEffort: mapped }, settings.effortCap).length)
-                    throw new SettingsValidationError([]);
-                effort = mapped;
-            }
-            catch {
-                if (exec.signal.aborted)
-                    throw new Error('route_subagent 已取消。');
-                throw new Error('自动模型路由设置无效。请暂停委派并询问用户，修复设置后重试，不要自行换路由。');
+                route = choosePolicyRoute(args.provider, result.capability ?? 'bounded', result.depth, await deps.catalog(), deps.readSettings().effortCap, explicit, args.family ?? (args.model ? modelFamily(args.provider, args.model, registry) : undefined), registry);
             }
-            // Shown on the caller's chip; a child caller has none, so only ordinary callers are recorded.
-            if (caller === root) {
-                const { kind: _, ...measure } = result;
-                deps.judged?.(root.id, { source: 'subagent', model, effort, ...measure });
+            catch (error) {
+                // No usable route: never substitute another model or effort.
+                const reason = error instanceof Error ? error.message : String(error);
+                throw new Error(reason.includes('暂停委派并询问用户') ? reason : `${reason}；暂停委派并询问用户`);
             }
-            return { tier: result.tier, provider, model, reasoning_effort: effort };
+            return { status: 'recommended', ...(result.capability ? { capability: result.capability } : {}), depth: result.depth, provider: route.provider, model: route.model, reasoning_effort: route.reasoningEffort };
         },
     });
 }

package/lib/support.d.ts

@@ -1,21 +1,20 @@
 import type { Context } from '@deepseek-ai/cordis';
 import type { Agent } from '@deepseek-ai/dsh-agent';
+import { type Registry } from './strategies/index.js';
 /** One main-session model selection as the AUTO support gate needs it. */
 export interface MainSelection {
     provider: string;
     model: string;
 }
 /**
- * AUTO only manages the Claude / GPT model families.
- *
- * The transport prefix (`claude/...`, `codex/...` on Magpie) is not part of the
- * family name, so it is stripped before matching. Every other family — DeepSeek,
- * GLM, Grok, Gemini, Kimi, Qwen, ... — is explicitly out of scope and locks the
- * session to MANUAL instead of being guessed at.
+ * AUTO only manages models whose family has a registered strategy. The transport
+ * prefix (e.g. a gateway's `<family>/`) is not part of the family name, so only the
+ * part after the last `/` is matched. Other families lock the session to MANUAL
+ * instead of being guessed at.
  */
-export declare function autoSupportedModel(model: string | undefined): boolean;
+export declare function autoSupportedModel(model: string | undefined, registry?: Registry): boolean;
 /** An unknown selection must never lock a session: only a proven mismatch does. */
-export declare function mainSupported(selection: MainSelection | undefined): boolean;
+export declare function mainSupported(selection: MainSelection | undefined, registry?: Registry): boolean;
 /**
  * The main session's current model selection, most-authoritative signal first:
  * the official pending pick (`model/selection` projection), then the last actual

package/lib/support.js

@@ -1,20 +1,16 @@
+import { registry as builtin } from './strategies/index.js';
 /**
- * AUTO only manages the Claude / GPT model families.
- *
- * The transport prefix (`claude/...`, `codex/...` on Magpie) is not part of the
- * family name, so it is stripped before matching. Every other family — DeepSeek,
- * GLM, Grok, Gemini, Kimi, Qwen, ... — is explicitly out of scope and locks the
- * session to MANUAL instead of being guessed at.
+ * AUTO only manages models whose family has a registered strategy. The transport
+ * prefix (e.g. a gateway's `<family>/`) is not part of the family name, so only the
+ * part after the last `/` is matched. Other families lock the session to MANUAL
+ * instead of being guessed at.
  */
-export function autoSupportedModel(model) {
-    if (typeof model !== 'string' || model.length === 0)
-        return false;
-    const bare = model.includes('/') ? model.slice(model.lastIndexOf('/') + 1) : model;
-    return /^(?:claude|gpt)-/i.test(bare);
+export function autoSupportedModel(model, registry = builtin) {
+    return registry.familyOfMainModel(model) !== undefined;
 }
 /** An unknown selection must never lock a session: only a proven mismatch does. */
-export function mainSupported(selection) {
-    return selection === undefined || autoSupportedModel(selection.model);
+export function mainSupported(selection, registry = builtin) {
+    return selection === undefined || autoSupportedModel(selection.model, registry);
 }
 /**
  * The main session's current model selection, most-authoritative signal first:

package/lib/usage-report.d.ts

@@ -2,7 +2,6 @@ type Failure = 'decode-failed' | 'tail-incomplete' | 'parse-failed' | 'missing-l
 export declare function buildReport(home: string, options?: {
     since?: string;
 }): {
-    schema: number;
     since: string | null;
     failures: Record<Failure, number>;
     excluded: {
@@ -16,7 +15,8 @@ export declare function buildReport(home: string, options?: {
         autoSessionsWithoutRecord: number;
     };
     groups: {
-        version: string;
+        group: string;
+        historical: boolean;
         subgroups: {
             model: string;
             depth: string;

package/lib/usage-report.js

@@ -184,6 +184,14 @@ function median(values) {
     const s = [...values].sort((a, b) => a - b), mid = Math.floor(s.length / 2);
     return s.length % 2 ? s[mid] : (s[mid - 1] + s[mid]) / 2;
 }
+/** Group key: the strategy family; for snapshots written before 0.5.0 the original fields, verbatim (historical); else `unknown`. */
+function groupOf(snapshot) {
+    if (snapshot?.strategy)
+        return { group: snapshot.strategy, historical: false };
+    if (snapshot?.policyVersion !== undefined || snapshot?.mappingVersion !== undefined)
+        return { group: `${snapshot.policyVersion ?? ''}/${snapshot.mappingVersion ?? ''}`, historical: true };
+    return { group: 'unknown', historical: false };
+}
 export function buildReport(home, options = {}) {
     const failures = { 'decode-failed': 0, 'tail-incomplete': 0, 'parse-failed': 0, 'missing-log': 0 };
     const state = join(home, 'state/auto-model-routing');
@@ -193,13 +201,14 @@ export function buildReport(home, options = {}) {
     lines(feedbackFile, failures); // counts unparsable lines; FeedbackBook skips them silently
     const book = new FeedbackBook(feedbackFile);
     const bindings = book.entries();
-    const legacyFirst = new Map();
+    // Historical four-tier ledger: read only to locate each session's first AUTO record.
+    const tierFirst = new Map();
     for (const line of lines(join(state, 'judgements.jsonl'), failures)) {
         if (typeof line?.sessionId !== 'string' || !Number.isInteger(line.turn) || typeof line.tier !== 'string')
             continue;
-        legacyFirst.set(line.sessionId, Math.min(legacyFirst.get(line.sessionId) ?? Infinity, line.turn));
+        tierFirst.set(line.sessionId, Math.min(tierFirst.get(line.sessionId) ?? Infinity, line.turn));
     }
-    const ledgerSessions = [...new Set([...bindings.map(b => b.sessionId), ...legacyFirst.keys()])].sort();
+    const ledgerSessions = [...new Set([...bindings.map(b => b.sessionId), ...tierFirst.keys()])].sort();
     const paths = logPaths(home);
     const excluded = { child: 0, seeded: 0 };
     const decisions = new Map();
@@ -233,18 +242,18 @@ export function buildReport(home, options = {}) {
                 next = log.userStarts.get(turn);
         }
         const linked = new Set();
-        let v2First;
+        let bindingFirst;
         for (const call of log.calls) {
             const b = book.lookup(session, call.id);
             if (!b)
                 continue;
             linked.add(call.id);
             if (call.userTurn !== undefined)
-                v2First = Math.min(v2First ?? Infinity, call.userTurn);
+                bindingFirst = Math.min(bindingFirst ?? Infinity, call.userTurn);
             const key = JSON.stringify([session, b.decisionId]);
             let d = decisions.get(key);
             if (!d) {
-                d = { session, id: b.decisionId, version: b.snapshot ? `${b.snapshot.policyVersion}/${b.snapshot.mappingVersion}` : 'unknown', model: b.model, depth: b.depth, effort: b.effort, calls: [], feedback: new Set() };
+                d = { session, id: b.decisionId, ...groupOf(b.snapshot), model: b.model, depth: b.depth, effort: b.effort, calls: [], feedback: new Set() };
                 decisions.set(key, d);
             }
             d.calls.push(call);
@@ -254,11 +263,11 @@ export function buildReport(home, options = {}) {
                 d.feedback.add(b.feedback);
         }
         unlinkedBindings += bindings.filter(b => b.sessionId === session && !linked.has(b.messageId)).length;
-        // Coverage: user turns from the first v2 record on, with calls in range but none linked.
-        if (v2First !== undefined) {
+        // Coverage: user turns from the first allocation binding on (any snapshot format), with calls in range but none linked.
+        if (bindingFirst !== undefined) {
             const turns = new Map();
             for (const call of log.calls) {
-                if (call.userTurn === undefined || call.userTurn < v2First || !after(call.time))
+                if (call.userTurn === undefined || call.userTurn < bindingFirst || !after(call.time))
                     continue;
                 turns.set(call.userTurn, (turns.get(call.userTurn) ?? false) || linked.has(call.id));
             }
@@ -266,7 +275,7 @@ export function buildReport(home, options = {}) {
             turnsWithoutRecord += [...turns.values()].filter(v => !v).length;
         }
         // Reference: calls before the earliest record in either ledger (effort only, never tokens).
-        const first = Math.min(legacyFirst.get(session) ?? Infinity, v2First ?? Infinity);
+        const first = Math.min(tierFirst.get(session) ?? Infinity, bindingFirst ?? Infinity);
         for (const call of log.calls) {
             if (call.userTurn === undefined || call.userTurn >= first || !after(call.time) || !call.model)
                 continue;
@@ -279,15 +288,15 @@ export function buildReport(home, options = {}) {
     const kept = [...decisions.values()].filter(d => after(Math.min(...d.calls.map(c => c.time))));
     for (const d of kept)
         bump((autoEffort[d.model] ??= {}), d.effort, d.calls.length);
-    const versions = new Map();
+    const byGroup = new Map();
     for (const d of kept) {
-        const byVersion = versions.get(d.version) ?? new Map();
-        versions.set(d.version, byVersion);
+        const entry = byGroup.get(d.group) ?? { historical: d.historical, subs: new Map() };
+        byGroup.set(d.group, entry);
         const key = JSON.stringify([d.model, d.depth]);
-        byVersion.set(key, [...(byVersion.get(key) ?? []), d]);
+        entry.subs.set(key, [...(entry.subs.get(key) ?? []), d]);
     }
-    const groups = [...versions].sort(([a], [b]) => a.localeCompare(b)).map(([version, subs]) => ({
-        version,
+    const groups = [...byGroup].sort(([a], [b]) => a.localeCompare(b)).map(([group, { historical, subs }]) => ({
+        group, historical,
         subgroups: [...subs].sort(([a], [b]) => a.localeCompare(b)).map(([key, list]) => {
             const [model, depth] = JSON.parse(key);
             const calls = list.flatMap(d => d.calls);
@@ -359,7 +368,6 @@ export function buildReport(home, options = {}) {
             autoSessionsWithoutRecord++;
     }
     return {
-        schema: 1,
         since: since?.label ?? null,
         failures, excluded,
         coverage: { userTurns, turnsWithoutRecord, unlinkedBindings, autoSessionsWithoutRecord },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-auto-model-routing",
-  "version": "0.4.2",
+  "version": "0.5.1",
   "description": "DeepSeek Harness plugin: independent Jev capability and effort decisions, enforced fresh-child routes, decision visibility and allocation feedback",
   "license": "MIT",
   "author": "prgrmrwy",
@@ -41,8 +41,7 @@
     "CHANGELOG.md",
     "skills",
     "docs",
-    "screenshots.json",
-    "scripts/label-report.mjs"
+    "screenshots.json"
   ],
   "dsh": {
     "bundle": {
@@ -59,7 +58,7 @@
     }
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json && tsdown",
+    "build": "node -e \"require('node:fs').rmSync('lib',{recursive:true,force:true})\" && tsc -p tsconfig.json && tsdown",
     "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.test.json",
     "test": "vitest run",
     "prepare": "npm run build",