dsh-auto-model-routing 0.4.2 → 0.5.1

package/lib/jev.d.ts

@@ -8,7 +8,6 @@ export interface PolicyMeasure {
     capabilityConfidence?: number;
     capabilityProbabilities?: Record<string, number>;
 }
-import { type Tier } from './effort.js';
 export type Depth = 'lower' | 'baseline' | 'higher';
 export type Capability = 'bounded' | 'analytical' | 'frontier';
 export type PolicyResult = ({
@@ -21,22 +20,8 @@ export type PolicyResult = ({
 } | {
     kind: 'cancelled';
 };
-export declare const policyVersion: string;
 import type { JevCategory } from './hints.js';
 export { CATEGORY_HINTS, type JevCategory } from './hints.js';
-export type Distribution = Partial<Record<Tier, number>>;
-export type JevResult = {
-    kind: 'ok';
-    tier: Tier;
-    confidence?: number;
-    probabilities?: Distribution;
-    ms: number;
-} | {
-    kind: 'failed';
-    category: JevCategory;
-} | {
-    kind: 'cancelled';
-};
 export interface CredentialSource {
     get(name: string): {
         value: string;
@@ -44,32 +29,35 @@ export interface CredentialSource {
         value: string;
     } | undefined>;
 }
-/** Shared by the main session and `route_subagent`; only `state` differs (design D4). Single source: rubric.json. */
-export declare const TIER_QUESTIONS: {
-    tier: {
+/** The only rule file: main and child questions are taken from it verbatim. */
+export declare const QUESTIONS: {
+    capability: {
+        type: string;
+        instructions: string;
+        criteria: {
+            bounded: string;
+            analytical: string;
+            frontier: string;
+            insufficient_context: string;
+        };
+    };
+    depth: {
         type: string;
         instructions: string;
         criteria: {
-            simple: string;
-            standard: string;
-            complex: string;
-            escalated: string;
+            lower: string;
+            baseline: string;
+            higher: string;
         };
     };
 };
-/** Content hash of the rubric, stored with each judgement so labels can be compared per rubric. */
-export declare const rubricVersion: string;
-/** One tier up (`escalated` stays): the only tier arithmetic in code; it never reads message text. */
-export declare function tierAbove(tier: Tier): Tier;
 export declare class JevClient {
     private readonly env;
     private readonly timeoutMs;
     private readonly service?;
     readonly url: string;
     constructor(env: CredentialSource, base?: string, timeoutMs?: number | (() => number), service?: (() => DecisionConfig | undefined) | undefined);
-    /** One request, no retry. Never throws; never returns the body or the key. */
-    /** `state` is assembled and redacted by the caller (`buildState`). */
-    judge(state: string, signal: AbortSignal): Promise<JevResult>;
+    /** One request, no retry. Never throws; never returns the body or the key. `state` comes from `buildState`. */
     judgePolicy(state: string, signal: AbortSignal, scope: 'main' | 'child', dimensions?: 'both' | 'capability' | 'depth'): Promise<PolicyResult>;
     private decide;
 }

package/lib/jev.js

@@ -1,19 +1,11 @@
-import { createHash } from 'node:crypto';
 import { resolveDecisionService } from './decision-service.js';
 const probability = (value) => typeof value === 'number' && Number.isFinite(value) && value >= 0 && value <= 1;
 const distribution = (value) => Object.fromEntries(Object.entries(value ?? {}).filter(([, v]) => probability(v)));
-import { tiers } from './effort.js';
-import rubric from './rubric.json' with { type: 'json' };
-import policyQuestions from './policy-v2-rubric.json' with { type: 'json' };
-export const policyVersion = `policy-v2-${createHash('sha256').update(JSON.stringify(policyQuestions)).digest('hex').slice(0, 8)}`;
+import policyQuestions from './rubric.json' with { type: 'json' };
 export { CATEGORY_HINTS } from './hints.js';
 const MAX_BODY = 64 * 1024;
-/** Shared by the main session and `route_subagent`; only `state` differs (design D4). Single source: rubric.json. */
-export const TIER_QUESTIONS = rubric;
-/** Content hash of the rubric, stored with each judgement so labels can be compared per rubric. */
-export const rubricVersion = createHash('sha256').update(JSON.stringify(TIER_QUESTIONS)).digest('hex').slice(0, 8);
-/** One tier up (`escalated` stays): the only tier arithmetic in code; it never reads message text. */
-export function tierAbove(tier) { return tiers[Math.min(tiers.indexOf(tier) + 1, tiers.length - 1)]; }
+/** The only rule file: main and child questions are taken from it verbatim. */
+export const QUESTIONS = policyQuestions;
 function byStatus(status) {
     if (status === 402)
         return 'insufficient-credits';
@@ -32,33 +24,13 @@ export class JevClient {
     timeoutMs;
     service;
     url;
-    constructor(env, base = 'https://openrouter.ai', timeoutMs = 3000, service) {
+    constructor(env, base = 'https://openrouter.ai', timeoutMs = 5000, service) {
         this.env = env;
         this.timeoutMs = timeoutMs;
         this.service = service;
         this.url = `${base}/api/alpha/decisions`;
     }
-    /** One request, no retry. Never throws; never returns the body or the key. */
-    /** `state` is assembled and redacted by the caller (`buildState`). */
-    async judge(state, signal) {
-        const result = await this.decide(state, signal, TIER_QUESTIONS);
-        if (result.kind !== 'ok')
-            return result;
-        const answer = result.answers?.tier;
-        const choice = answer?.choice;
-        if (!tiers.includes(choice))
-            return { kind: 'failed', category: 'invalid-response' };
-        const unit = (v) => typeof v === 'number' && v >= 0 && v <= 1;
-        const probabilities = {};
-        for (const t of tiers) {
-            const v = answer?.probabilities?.[t];
-            if (unit(v))
-                probabilities[t] = v;
-        }
-        return { kind: 'ok', tier: choice, ms: result.ms,
-            ...(unit(answer?.confidence) ? { confidence: answer.confidence } : {}),
-            ...(Object.keys(probabilities).length ? { probabilities } : {}) };
-    }
+    /** One request, no retry. Never throws; never returns the body or the key. `state` comes from `buildState`. */
     async judgePolicy(state, signal, scope, dimensions = 'both') {
         const questions = scope === 'main' || dimensions === 'depth' ? { depth: policyQuestions.depth }
             : dimensions === 'capability' ? { capability: policyQuestions.capability } : policyQuestions;
@@ -82,7 +54,7 @@ export class JevClient {
             return { kind: 'cancelled' };
         const configuredTimeout = typeof this.timeoutMs === 'function' ? this.timeoutMs() : this.timeoutMs;
         // Settings callbacks use the public range; numeric constructor overrides remain available to tests.
-        const timeout = typeof this.timeoutMs === 'function' && (!Number.isInteger(configuredTimeout) || configuredTimeout < 1000 || configuredTimeout > 4500) ? 3000 : configuredTimeout;
+        const timeout = typeof this.timeoutMs === 'function' && (!Number.isInteger(configuredTimeout) || configuredTimeout < 1000 || configuredTimeout > 8000) ? 5000 : configuredTimeout;
         const deadline = AbortSignal.timeout(timeout);
         const started = performance.now();
         try {

package/lib/policy-host.d.ts

@@ -1,6 +1,7 @@
 import type { FeedbackBook } from './feedback.js';
 import type { Context } from '@deepseek-ai/cordis';
 import type { JevClient, Depth } from './jev.js';
+import { type Registry } from './strategies/index.js';
 import { PolicyStore, type ChildDecision } from './policy-store.js';
 import type { RoutingState } from './state.js';
 import type { RoutingCatalog, Settings } from './settings-contract.js';
@@ -17,24 +18,22 @@ export declare function policyHost(ctx: Context, deps: {
     store: PolicyStore;
     settings: () => Settings;
     catalog: () => Promise<RoutingCatalog>;
+    registry?: Registry;
 }): {
     appliedDecision: (id: string) => number | undefined;
     invalidate: (id: string) => void;
     status: (id: string) => {
-        version: 1;
         childId: string;
         parentId: string;
         rootId: string;
-        policyVersion: string;
-        mappingVersion: string;
         status: "failed" | "recommended" | "unsupported" | "needs-context" | "applied";
         path: "ordinary" | "fork" | "teammate";
         explicit: {
-            provider: "claude" | "codex" | "dsh-magpie-connect" | "dsh-magpie-connector";
+            provider: string;
             model?: string | undefined;
             reasoningEffort?: string | undefined;
         };
-        family?: "claude" | "codex" | undefined;
+        family?: string | undefined;
         decision?: {
             id: number;
             source: "main" | "subagent";
@@ -54,12 +53,12 @@ export declare function policyHost(ctx: Context, deps: {
             capabilityProbabilities?: Record<string, number> | undefined;
         } | undefined;
         route?: {
-            provider: "claude" | "codex" | "dsh-magpie-connect" | "dsh-magpie-connector";
+            provider: string;
             model: string;
             reasoningEffort: "low" | "medium" | "high" | "xhigh";
         } | undefined;
         actual?: {
-            provider: "claude" | "codex" | "dsh-magpie-connect" | "dsh-magpie-connector";
+            provider: string;
             model: string;
             reasoningEffort: "low" | "medium" | "high" | "xhigh";
         } | undefined;
@@ -67,7 +66,6 @@ export declare function policyHost(ctx: Context, deps: {
     } | undefined;
     mainStatus: (id: string) => {
         decision?: NonNullable<ChildDecision["decision"]>;
-        policyVersion?: string;
         depth?: Depth;
         effort?: string;
         reason?: string;

package/lib/policy-host.js

@@ -1,12 +1,15 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { SessionId } from '@deepseek-ai/dsh-session';
-import { policyVersion, CATEGORY_HINTS } from './jev.js';
-import { choosePolicyRoute, mappingVersion, policyEffort, modelFamily, policyProvider, validatePolicyRoute } from './policy-v2.js';
+import { CATEGORY_HINTS } from './jev.js';
+import { choosePolicyRoute, policyEffort, modelFamily, validatePolicyRoute } from './routing.js';
+import { registry as builtin } from './strategies/index.js';
 import { userInput } from './input.js';
 import { buildState, previousTurn } from './context.js';
 import { isRecord } from './settings-validation.js';
 import { autoSupportedModel, currentMainSelection, mainSupported } from './support.js';
 export function policyHost(ctx, deps) {
+    const registry = deps.registry ?? builtin;
+    const familyOf = (model) => registry.familyOfMainModel(model)?.id;
     const delegation = new AsyncLocalStorage();
     const rootOf = (agent) => {
         let current = agent;
@@ -18,7 +21,7 @@ export function policyHost(ctx, deps) {
     };
     const epochs = new Map();
     const epoch = (id) => epochs.get(id) ?? 0;
-    const enabled = (rootId) => deps.settings().policy === 'policy-v2' && deps.state.read(rootId).mode === 'AUTO';
+    const enabled = (rootId) => deps.state.read(rootId).mode === 'AUTO';
     const pending = new Map();
     const main = new WeakMap();
     ctx.effect(() => () => { pending.clear(); delegation.disable(); });
@@ -28,7 +31,7 @@ export function policyHost(ctx, deps) {
     const decidedAt = new Map();
     const applied = new Map();
     const latest = new Map();
-    /** Fall back to MANUAL when the main model left AUTO's Claude/GPT scope. */
+    /** Fall back to MANUAL when the main model left AUTO's registered families. */
     const lockUnsupportedMain = (agent) => {
         deps.state.setMode(agent.id, 'MANUAL');
         mainStatus.delete(agent.id);
@@ -44,12 +47,12 @@ export function policyHost(ctx, deps) {
         const args = isRecord(exec.arguments) ? exec.arguments : {};
         const path = exec.name === 'subagent_fork' || (exec.name === 'spawn_teammate' && args.context === 'fork') ? 'fork' : exec.name === 'spawn_teammate' ? 'teammate' : 'ordinary';
         if (path === 'fork')
-            throw new Error('policy-v2 unsupported：fork 的真实历史兼容尚未验证；请暂停，改用 fresh 或由用户选择关闭试验策略后继承。');
+            throw new Error('unsupported：fork 的真实历史兼容尚未验证；请暂停，改用 fresh 创建，或由用户切到 MANUAL 后继承。');
         const provider = args.provider ?? exec.agent.session.requestHeader()?.config.provider ?? exec.agent.options.provider;
-        if (typeof provider !== 'string' || !policyProvider(provider))
-            throw new Error('policy-v2 unsupported：无法验证 provider；暂停委派并询问用户');
+        if (typeof provider !== 'string' || !registry.hasProvider(provider))
+            throw new Error('unsupported：无法验证 provider；暂停委派并询问用户');
         const parentModel = exec.agent.session.requestHeader()?.config.model ?? exec.agent.options.model;
-        const family = modelFamily(provider, typeof args.model === 'string' ? args.model : parentModel ?? '');
+        const family = modelFamily(provider, typeof args.model === 'string' ? args.model : parentModel ?? '', registry);
         const explicit = { provider,
             ...(typeof args.model === 'string' ? { model: args.model } : {}),
             ...(typeof args.reasoning_effort === 'string' ? { reasoningEffort: args.reasoning_effort } : {}) };
@@ -62,7 +65,7 @@ export function policyHost(ctx, deps) {
         if (!binding || binding.parentId !== agent.session.header.parentSession)
             return;
         // Creation is precisely inside this official tool's async lifetime, never matched by prompt.
-        const record = { version: 1, childId: agent.id, ...binding, policyVersion, mappingVersion, status: 'recommended' };
+        const record = { childId: agent.id, ...binding, status: 'recommended' };
         deps.store.set(record);
         deps.store.bind(agent.id);
         pending.set(agent.id, record);
@@ -70,7 +73,7 @@ export function policyHost(ctx, deps) {
     });
     const requireBindingRecord = (agent, record) => {
         if (deps.store.wasBound(agent.id) && !record)
-            throw new Error('policy-v2 已绑定子会话的决策记录缺失；停止请求，不恢复继承配置');
+            throw new Error('已绑定子会话的决策记录缺失，无法恢复；停止请求，不恢复继承配置');
     };
     ctx.on('agent/disposed', ({ agent }) => { pending.delete(agent.id); mainStatus.delete(agent.id); return undefined; });
     ctx.on('agent/pre-step', async (payload, next) => {
@@ -88,8 +91,8 @@ export function policyHost(ctx, deps) {
                     main.set(agent, { ...old, turn: payload.turn });
                 return decision;
             }
-            // The main model left AUTO's Claude/GPT scope: judge nothing, rewrite nothing.
-            if (!mainSupported(currentMainSelection(ctx, agent))) {
+            // The main model left AUTO's registered families: judge nothing, rewrite nothing.
+            if (!mainSupported(currentMainSelection(ctx, agent), registry)) {
                 lockUnsupportedMain(agent);
                 return decision;
             }
@@ -114,7 +117,7 @@ export function policyHost(ctx, deps) {
             main.set(agent, { turn: payload.turn, depth: result.depth, active: true, epoch: startedEpoch });
             const { kind: _kind, ...measurement } = result;
             latest.delete(agent.id);
-            mainStatus.set(agent.id, { policyVersion, depth: result.depth, reason: 'jev', decision: { ...measurement, id: ++decisionId, source: 'main', tier: result.depth, effort: '待应用', status: 'recommended' } });
+            mainStatus.set(agent.id, { depth: result.depth, reason: 'jev', decision: { ...measurement, id: ++decisionId, source: 'main', tier: result.depth, effort: '待应用', status: 'recommended' } });
             decidedAt.set(decisionId, Date.now());
             if (decidedAt.size > 200)
                 decidedAt.delete(decidedAt.keys().next().value);
@@ -127,23 +130,21 @@ export function policyHost(ctx, deps) {
         if (!record) {
             const root = rootOf(agent);
             if (root && enabled(root.id))
-                throw new Error('policy-v2 unsupported：创建没有官方工具身份绑定；该子请求未路由。请暂停并选择受支持创建路径或关闭试验后继承。');
+                throw new Error('unsupported：创建没有官方工具身份绑定；该子请求未路由。请暂停并改用受支持的创建路径，或由用户切到 MANUAL 后继承。');
             return decision;
         }
         if (record.parentId !== agent.session.header.parentSession)
-            throw new Error('policy-v2 子会话身份不匹配');
+            throw new Error('子会话身份不匹配');
         if (!record.route && !enabled(record.rootId)) {
             pending.delete(agent.id);
-            throw new Error('policy-v2 创建期间策略或模式已改变；请重新创建，不静默继承');
+            throw new Error('创建期间模式已改变；请重新创建，不静默继承');
         }
         if (!record.route && enabled(record.rootId)) {
             if (!pending.has(agent.id))
-                throw new Error('policy-v2 初始决策未完成且已恢复；不能用后续消息重新选模，请发起新资源决策');
+                throw new Error('初始决策未完成且已恢复；不能用后续消息重新选模，请重新创建子任务');
             if (record.status !== 'recommended')
-                throw new Error(`policy-v2 ${record.status}：${record.reason ?? '初始决策未完成'}；暂停并询问用户`);
+                throw new Error(`${record.status}：${record.reason ?? '初始决策未完成'}；暂停并询问用户`);
             const saveFailure = (status, reason) => { record = { ...record, status, reason }; deps.store.set(record); pending.delete(agent.id); };
-            if (record.policyVersion !== policyVersion || record.mappingVersion !== mappingVersion)
-                throw new Error('policy-v2 未完成决策版本不可恢复');
             const explicit = record.explicit;
             let measure;
             let capability = 'bounded', depth = 'baseline';
@@ -153,36 +154,36 @@ export function policyHost(ctx, deps) {
                 const result = await deps.jev.judgePolicy(buildState({ text }), payload.signal, 'child', explicit.model ? 'depth' : explicit.reasoningEffort ? 'capability' : 'both');
                 if (!enabled(record.rootId)) {
                     saveFailure('failed', '创建期间模式已变化');
-                    throw new Error('policy-v2 创建期间模式已变化；请重新创建');
+                    throw new Error('创建期间模式已变化；请重新创建');
                 }
                 if (result.kind === 'cancelled') {
                     saveFailure('failed', '初始判断已取消');
-                    throw new Error('policy-v2 已取消');
+                    throw new Error('子任务判断已取消');
                 }
                 if (result.kind === 'failed') {
                     saveFailure('failed', result.category);
-                    throw new Error(`policy-v2 Jev 失败：${CATEGORY_HINTS[result.category]}；暂停委派并询问用户`);
+                    throw new Error(`Jev 失败：${CATEGORY_HINTS[result.category]}；暂停委派并询问用户`);
                 }
                 if (result.capability === 'insufficient_context') {
                     saveFailure('needs-context', '任务目标或范围不足');
-                    throw new Error('policy-v2 needs-context：请补充任务目标与范围');
+                    throw new Error('needs-context：请补充任务目标与范围');
                 }
                 measure = result;
                 capability = result.capability ?? 'bounded';
                 depth = result.depth;
             }
             try {
-                const route = choosePolicyRoute(explicit.provider, capability, depth, await deps.catalog(), deps.settings().effortCap, explicit, record.family);
+                const route = choosePolicyRoute(explicit.provider, capability, depth, await deps.catalog(), deps.settings().effortCap, explicit, record.family, registry);
                 const parent = ctx.agents.get(SessionId(record.parentId));
                 const events = parent?.session.snapshotEvents() ?? [];
                 const captured = events.find(event => event.type === 'subagent/model-selection-policy');
                 if (captured) {
                     const allowed = captured.data.allowedModels;
                     if (!Array.isArray(allowed) || !allowed.some(item => item.provider === route.provider && item.model === route.model))
-                        throw new Error('policy-v2 路由不在父会话创建时的官方允许列表中；请新建会话');
+                        throw new Error('路由不在父会话创建时的官方允许列表中；请新建会话');
                 }
                 if (!enabled(record.rootId) || payload.signal.aborted)
-                    throw new Error('policy-v2 创建已取消或模式已变化');
+                    throw new Error('创建已取消或模式已变化');
                 record = { ...record, route, status: 'recommended', decision: { id: ++decisionId, source: 'subagent', tier: capability, depth, capability, effort: route.reasoningEffort, model: route.model, provider: route.provider, status: 'recommended', ms: measure?.ms ?? 0, decisionProvider: measure?.decisionProvider ?? 'explicit', decisionModel: measure?.decisionModel ?? '未调用', ...(measure?.confidence !== undefined ? { confidence: measure.confidence } : {}), ...(measure?.capabilityConfidence !== undefined ? { capabilityConfidence: measure.capabilityConfidence } : {}), ...(measure?.probabilities ? { probabilities: measure.probabilities } : {}), ...(measure?.capabilityProbabilities ? { capabilityProbabilities: measure.capabilityProbabilities } : {}) } };
                 deps.store.set(record);
                 pending.delete(agent.id);
@@ -193,7 +194,7 @@ export function policyHost(ctx, deps) {
             }
         }
         if (!record.route && enabled(record.rootId))
-            throw new Error('policy-v2 决策未完成；暂停子请求');
+            throw new Error('决策未完成；暂停子请求');
         return decision;
     });
     ctx.on('agent/request', async (payload, next) => {
@@ -204,13 +205,13 @@ export function policyHost(ctx, deps) {
             if (!runtime?.active || runtime.turn !== payload.turn || runtime.epoch !== epoch(agent.id) || !enabled(agent.id))
                 return config;
             // Authoritative gate: the request's actual model decides, whatever the picker showed earlier.
-            if (!autoSupportedModel(config.model)) {
+            if (!autoSupportedModel(config.model, registry)) {
                 lockUnsupportedMain(agent);
                 return config;
             }
             const unsupported = (effort = '模型不支持调整') => {
                 const old = mainStatus.get(agent.id);
-                mainStatus.set(agent.id, { ...old, policyVersion, depth: runtime.depth, reason: 'no-effort-support', ...(old?.decision ? { decision: { ...old.decision, status: 'unsupported', model: config.model, provider: config.provider, effort } } : {}) });
+                mainStatus.set(agent.id, { ...old, depth: runtime.depth, reason: 'no-effort-support', ...(old?.decision ? { decision: { ...old.decision, status: 'unsupported', model: config.model, provider: config.provider, effort } } : {}) });
             };
             const info = await ctx.llm.resolveModelInfo(config.provider, config.model, payload.signal);
             if (!enabled(agent.id) || runtime.epoch !== epoch(agent.id) || payload.signal.aborted)
@@ -222,7 +223,7 @@ export function policyHost(ctx, deps) {
             }
             let reasoningEffort;
             try {
-                reasoningEffort = policyEffort(config.model, runtime.depth, efforts, deps.settings().effortCap, info.reasoning?.defaultEffort ? String(info.reasoning.defaultEffort) : undefined);
+                reasoningEffort = policyEffort(config.model, runtime.depth, efforts, deps.settings().effortCap, info.reasoning?.defaultEffort ? String(info.reasoning.defaultEffort) : undefined, registry);
             }
             catch (error) {
                 // A supported model whose directory cannot produce an automatic effort must not fail the turn.
@@ -230,7 +231,7 @@ export function policyHost(ctx, deps) {
                 unsupported();
                 return config;
             }
-            mainStatus.set(agent.id, { ...mainStatus.get(agent.id), policyVersion, depth: runtime.depth, effort: reasoningEffort, reason: 'jev', ...(mainStatus.get(agent.id)?.decision ? { decision: { ...mainStatus.get(agent.id).decision, effort: reasoningEffort, model: config.model, provider: config.provider } } : {}) });
+            mainStatus.set(agent.id, { ...mainStatus.get(agent.id), depth: runtime.depth, effort: reasoningEffort, reason: 'jev', ...(mainStatus.get(agent.id)?.decision ? { decision: { ...mainStatus.get(agent.id).decision, effort: reasoningEffort, model: config.model, provider: config.provider } } : {}) });
             if (reasoningEffort !== config.reasoningEffort) {
                 try {
                     await deps.selectModel({ sessionId: agent.id, provider: config.provider, model: config.model, reasoningEffort });
@@ -245,15 +246,15 @@ export function policyHost(ctx, deps) {
         const record = deps.store.get(agent.id);
         requireBindingRecord(agent, record);
         if (record && !record.route)
-            throw new Error('policy-v2 初始路由未完成；不静默继承');
+            throw new Error('初始路由未完成；不静默继承');
         if (!record?.route)
             return config;
         if (record.status === 'failed')
-            throw new Error('policy-v2 实际应用失败；暂停子请求并询问用户');
+            throw new Error('实际应用失败；暂停子请求并询问用户');
         if (record.parentId !== agent.session.header.parentSession)
-            throw new Error('policy-v2 决策身份不匹配');
+            throw new Error('决策身份不匹配');
         // Existing routed instances keep their initial route even when AUTO stops making new decisions.
-        validatePolicyRoute(await deps.catalog(), record.route.provider, record.route.model, record.route.reasoningEffort, deps.settings().effortCap);
+        validatePolicyRoute(await deps.catalog(), record.route.provider, record.route.model, record.route.reasoningEffort, deps.settings().effortCap, registry);
         return { ...config, ...record.route };
     }, { prepend: true });
     const confirmMainRequest = (session, requestSeq, turn) => {
@@ -285,7 +286,7 @@ export function policyHost(ctx, deps) {
                 try {
                     deps.feedback.bind({ sessionId: session.id, messageId: data.message.id, decisionId: d.id, depth: d.depth, model: d.model, effort: d.effort,
                         ...(requestMetadata.has(session.id) && d.provider && decidedAt.has(d.id) ? { snapshot: {
-                                ...requestMetadata.get(session.id), decidedAt: decidedAt.get(d.id), policyVersion, mappingVersion,
+                                ...requestMetadata.get(session.id), decidedAt: decidedAt.get(d.id), ...(familyOf(d.model) ? { strategy: familyOf(d.model) } : {}),
                                 decisionProvider: d.decisionProvider, decisionModel: d.decisionModel, ms: d.ms, provider: d.provider,
                                 ...(d.confidence !== undefined ? { confidence: d.confidence } : {}), ...(d.probabilities ? { probabilities: d.probabilities } : {}),
                             } } : {}),
@@ -314,7 +315,7 @@ export function policyHost(ctx, deps) {
             latest.set(record.rootId, { ...record.decision, status: matches ? 'applied' : 'failed' });
         deps.store.set({ ...record, ...(record.decision ? { decision: { ...record.decision, status: matches ? 'applied' : 'failed' } } : {}), status: matches ? 'applied' : 'failed', ...(matches ? { actual: record.route } : { reason: '实际请求配置不匹配' }) });
         if (!matches)
-            throw new Error('policy-v2 实际请求配置不匹配');
+            throw new Error('实际请求配置不匹配');
     });
     return {
         appliedDecision: (id) => enabled(id) ? applied.get(id)?.id : undefined,

package/lib/policy-store.d.ts

@@ -1,11 +1,9 @@
 import { z } from 'zod';
-declare const schema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
+import { type Registry } from './strategies/index.js';
+declare function schemaFor(registry: Registry): z.ZodObject<{
     childId: z.ZodString;
     parentId: z.ZodString;
     rootId: z.ZodString;
-    policyVersion: z.ZodString;
-    mappingVersion: z.ZodString;
     status: z.ZodEnum<{
         failed: "failed";
         recommended: "recommended";
@@ -19,15 +17,11 @@ declare const schema: z.ZodObject<{
         teammate: "teammate";
     }>;
     family: z.ZodOptional<z.ZodEnum<{
-        claude: "claude";
-        codex: "codex";
+        [x: string]: string;
     }>>;
     explicit: z.ZodObject<{
         provider: z.ZodEnum<{
-            claude: "claude";
-            codex: "codex";
-            "dsh-magpie-connect": "dsh-magpie-connect";
-            "dsh-magpie-connector": "dsh-magpie-connector";
+            [x: string]: string;
         }>;
         model: z.ZodOptional<z.ZodString>;
         reasoningEffort: z.ZodOptional<z.ZodString>;
@@ -55,10 +49,7 @@ declare const schema: z.ZodObject<{
     }, z.core.$strict>>;
     route: z.ZodOptional<z.ZodObject<{
         provider: z.ZodEnum<{
-            claude: "claude";
-            codex: "codex";
-            "dsh-magpie-connect": "dsh-magpie-connect";
-            "dsh-magpie-connector": "dsh-magpie-connector";
+            [x: string]: string;
         }>;
         model: z.ZodString;
         reasoningEffort: z.ZodEnum<{
@@ -70,10 +61,7 @@ declare const schema: z.ZodObject<{
     }, z.core.$strict>>;
     actual: z.ZodOptional<z.ZodObject<{
         provider: z.ZodEnum<{
-            claude: "claude";
-            codex: "codex";
-            "dsh-magpie-connect": "dsh-magpie-connect";
-            "dsh-magpie-connector": "dsh-magpie-connector";
+            [x: string]: string;
         }>;
         model: z.ZodString;
         reasoningEffort: z.ZodEnum<{
@@ -85,11 +73,12 @@ declare const schema: z.ZodObject<{
     }, z.core.$strict>>;
     reason: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
-export type ChildDecision = z.infer<typeof schema>;
+export type ChildDecision = z.infer<ReturnType<typeof schemaFor>>;
 /** Strict per-child files: corrupt or mismatched records fail closed; no raw task or credentials. */
 export declare class PolicyStore {
     private readonly directory;
-    constructor(directory: string);
+    private readonly schema;
+    constructor(directory: string, registry?: Registry);
     private path;
     bind(id: string): void;
     wasBound(id: string): boolean;

package/lib/policy-store.js

@@ -2,23 +2,30 @@ import { createHash, randomUUID } from 'node:crypto';
 import { mkdirSync, readFileSync, writeFileSync, renameSync, chmodSync } from 'node:fs';
 import { join } from 'node:path';
 import { z } from 'zod';
-import { POLICY_PROVIDERS } from './policy-v2.js';
-const route = z.object({ provider: z.enum(POLICY_PROVIDERS), model: z.string().min(1).max(128), reasoningEffort: z.enum(['low', 'medium', 'high', 'xhigh']) }).strict();
-const schema = z.object({
-    version: z.literal(1), childId: z.string(), parentId: z.string(), rootId: z.string(),
-    policyVersion: z.string(), mappingVersion: z.string(),
-    status: z.enum(['recommended', 'applied', 'unsupported', 'needs-context', 'failed']),
-    path: z.enum(['ordinary', 'teammate', 'fork']),
-    family: z.enum(['claude', 'codex']).optional(),
-    explicit: z.object({ provider: z.enum(POLICY_PROVIDERS), model: z.string().optional(), reasoningEffort: z.string().optional() }).strict(),
-    decision: z.object({ id: z.number(), source: z.enum(['main', 'subagent']), tier: z.string(), depth: z.string(), capability: z.string().optional(), effort: z.string(), model: z.string().optional(), provider: z.string().optional(), status: z.string(), ms: z.number(), decisionProvider: z.string(), decisionModel: z.string(), confidence: z.number().min(0).max(1).optional(), capabilityConfidence: z.number().min(0).max(1).optional(), probabilities: z.record(z.string(), z.number().min(0).max(1)).optional(), capabilityProbabilities: z.record(z.string(), z.number().min(0).max(1)).optional() }).strict().optional(),
-    route: route.optional(), actual: route.optional(), reason: z.string().max(240).optional(),
-}).strict();
+import { registry as builtin } from './strategies/index.js';
+const enumOf = (values) => z.enum(values);
+function schemaFor(registry) {
+    const providers = enumOf(registry.providers());
+    const route = z.object({ provider: providers, model: z.string().min(1).max(128), reasoningEffort: z.enum(['low', 'medium', 'high', 'xhigh']) }).strict();
+    return z.object({
+        childId: z.string(), parentId: z.string(), rootId: z.string(),
+        status: z.enum(['recommended', 'applied', 'unsupported', 'needs-context', 'failed']),
+        path: z.enum(['ordinary', 'teammate', 'fork']),
+        family: enumOf(registry.ids()).optional(),
+        explicit: z.object({ provider: providers, model: z.string().optional(), reasoningEffort: z.string().optional() }).strict(),
+        decision: z.object({ id: z.number(), source: z.enum(['main', 'subagent']), tier: z.string(), depth: z.string(), capability: z.string().optional(), effort: z.string(), model: z.string().optional(), provider: z.string().optional(), status: z.string(), ms: z.number(), decisionProvider: z.string(), decisionModel: z.string(), confidence: z.number().min(0).max(1).optional(), capabilityConfidence: z.number().min(0).max(1).optional(), probabilities: z.record(z.string(), z.number().min(0).max(1)).optional(), capabilityProbabilities: z.record(z.string(), z.number().min(0).max(1)).optional() }).strict().optional(),
+        route: route.optional(), actual: route.optional(), reason: z.string().max(240).optional(),
+    }).strict();
+}
+/** Records written before 0.5.0 carried these keys; reads accept exactly these values, then drop them. */
+const historical = z.object({ version: z.literal(1).optional(), policyVersion: z.string().optional(), mappingVersion: z.string().optional() });
 /** Strict per-child files: corrupt or mismatched records fail closed; no raw task or credentials. */
 export class PolicyStore {
     directory;
-    constructor(directory) {
+    schema;
+    constructor(directory, registry = builtin) {
         this.directory = directory;
+        this.schema = schemaFor(registry);
     }
     path(id) { return join(this.directory, `${createHash('sha256').update(id).digest('hex')}.json`); }
     bind(id) {
@@ -39,7 +46,12 @@ export class PolicyStore {
     }
     get(id) {
         try {
-            const record = schema.parse(JSON.parse(readFileSync(this.path(id), 'utf8')));
+            const raw = JSON.parse(readFileSync(this.path(id), 'utf8'));
+            if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+                throw new Error('not an object');
+            const { version, policyVersion, mappingVersion, ...rest } = raw;
+            historical.parse({ version, policyVersion, mappingVersion });
+            const record = this.schema.parse(rest);
             if (record.childId !== id)
                 throw new Error('child identity mismatch');
             return record;
@@ -47,11 +59,11 @@ export class PolicyStore {
         catch (error) {
             if (error.code === 'ENOENT')
                 return undefined;
-            throw new Error('policy-v2 决策无法恢复；暂停该子会话');
+            throw new Error('子任务决策无法恢复；暂停该子会话');
         }
     }
     set(value) {
-        const checked = schema.parse(value);
+        const checked = this.schema.parse(value);
         mkdirSync(this.directory, { recursive: true, mode: 0o700 });
         chmodSync(this.directory, 0o700);
         const target = this.path(value.childId), temp = `${target}.${randomUUID()}.tmp`;

package/lib/routing.d.ts

@@ -0,0 +1,20 @@
+import type { Capability, Depth } from './jev.js';
+import { type AutomaticEffort, type RoutingCatalog } from './settings-contract.js';
+import { type Registry } from './strategies/index.js';
+/** Family of a child model on an exact transport; undefined when no registered strategy owns it. */
+export declare function modelFamily(provider: string, model: string, registry?: Registry): string | undefined;
+export declare function validatePolicyRoute(catalog: RoutingCatalog, provider: string, model: string, effort: string, cap: AutomaticEffort, registry?: Registry): void;
+export declare function policyEffort(model: string, depth: Depth, supported: readonly string[], cap: AutomaticEffort, defaultEffort?: string, registry?: Registry): AutomaticEffort;
+export interface PolicyRoute {
+    provider: string;
+    model: string;
+    reasoningEffort: AutomaticEffort;
+}
+/**
+ * Child route: explicit dimensions are kept; otherwise the family's capability slot on this transport.
+ * A transport owned by a single family (empty prefix) implies that family; others need `family`.
+ */
+export declare function choosePolicyRoute(provider: string, capability: Capability, depth: Depth, catalog: RoutingCatalog, cap: AutomaticEffort, explicit?: {
+    model?: string | undefined;
+    reasoningEffort?: string | undefined;
+}, family?: string, registry?: Registry): PolicyRoute;