dsh-auto-model-routing 0.5.2 → 0.5.3

package/lib/policy-host.js

@@ -1,7 +1,6 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { SessionId } from '@deepseek-ai/dsh-session';
-import { CATEGORY_HINTS } from './jev.js';
-import { choosePolicyRoute, policyEffort, modelFamily, validatePolicyRoute } from './routing.js';
+import { chooseChildRoute, policyEffort, validatePolicyRoute } from './routing.js';
 import { registry as builtin } from './strategies/index.js';
 import { userInput } from './input.js';
 import { buildState, previousTurn } from './context.js';
@@ -38,37 +37,67 @@ export function policyHost(ctx, deps) {
         latest.delete(agent.id);
         applied.delete(agent.id);
     };
+    const childEpochs = new Map();
+    const notices = new Map();
+    let noticeId = 0;
+    /** Visible fallback: the child request runs with DSH defaults, the root learns why. */
+    const fallback = (record, reason) => {
+        const next = { childId: record.childId, parentId: record.parentId, rootId: record.rootId, path: record.path, explicit: record.explicit,
+            ...(record.family ? { family: record.family } : {}), ...(record.parentSelection ? { parentSelection: record.parentSelection } : {}), status: 'unsupported', reason };
+        deps.store.set(next);
+        pending.delete(record.childId);
+        childEpochs.delete(record.childId);
+        notices.set(record.rootId, { id: ++noticeId, childId: record.childId, reason, at: Date.now() });
+        ctx.logger.warn(`auto-model-routing: child ${record.childId} not routed (${reason}); running with DSH defaults`);
+        return next;
+    };
+    const capturedAllowlist = (parentId) => {
+        const events = ctx.agents.get(SessionId(parentId))?.session.snapshotEvents() ?? [];
+        const captured = events.find(event => event.type === 'subagent/model-selection-policy');
+        if (!captured)
+            return undefined;
+        const allowed = captured.data.allowedModels;
+        return Array.isArray(allowed) ? allowed : [];
+    };
     ctx.on('tools/execute', async (exec, next) => {
-        if (!['subagent', 'subagent_fork', 'spawn_teammate'].includes(exec.name) || !exec.agent)
+        if (!['subagent', 'spawn_teammate'].includes(exec.name) || !exec.agent)
+            return next();
+        const args = isRecord(exec.arguments) ? exec.arguments : {};
+        // Fork copies the parent: AUTO does not manage it and opens no binding window.
+        if (exec.name === 'spawn_teammate' && args.context === 'fork')
             return next();
         const root = rootOf(exec.agent);
         if (!root || !enabled(root.id))
             return next();
-        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('unsupported：fork 的真实历史兼容尚未验证；请暂停，改用 fresh 创建，或由用户切到 MANUAL 后继承。');
-        const provider = args.provider ?? exec.agent.session.requestHeader()?.config.provider ?? exec.agent.options.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 ?? '', registry);
-        const explicit = { provider,
+        const explicit = { ...(typeof args.provider === 'string' && args.provider ? { provider: args.provider } : {}),
             ...(typeof args.model === 'string' ? { model: args.model } : {}),
             ...(typeof args.reasoning_effort === 'string' ? { reasoningEffort: args.reasoning_effort } : {}) };
-        return delegation.run({ parentId: exec.agent.id, rootId: root.id, path, explicit, ...(family ? { family } : {}) }, next);
+        return delegation.run({ parentId: exec.agent.id, rootId: root.id, path: exec.name === 'spawn_teammate' ? 'teammate' : 'ordinary', explicit }, next);
     });
-    ctx.on('agent/created', ({ agent }) => {
-        if (agent.session.header.origin !== 'subagent')
+    ctx.on('agent/created', ({ agent, source }) => {
+        if (agent.session.header.origin !== 'subagent' || source !== 'startup')
             return;
         const binding = delegation.getStore();
-        if (!binding || binding.parentId !== agent.session.header.parentSession)
+        // shortcut: same-window plugin children under this parent are indistinguishable (accepted 2026-10-28), until DSH exposes tool-call→child identity.
+        if (!binding || binding.parentId !== agent.session.header.parentSession || !enabled(binding.rootId) || deps.store.wasBound(agent.id))
             return;
-        // Creation is precisely inside this official tool's async lifetime, never matched by prompt.
-        const record = { childId: agent.id, ...binding, status: 'recommended' };
-        deps.store.set(record);
-        deps.store.bind(agent.id);
+        const parent = ctx.agents.get(SessionId(binding.parentId));
+        if (!parent)
+            return;
+        const config = parent.session.requestHeader()?.config;
+        const provider = config?.provider ?? parent.options.provider;
+        const model = config?.model ?? parent.options.model;
+        const effort = config?.reasoningEffort ?? parent.options.reasoningEffort;
+        const routeProvider = binding.explicit.provider ?? provider;
+        if (typeof provider !== 'string' || !provider || typeof routeProvider !== 'string' || !routeProvider)
+            return;
+        const family = registry.familyOfMainModel(binding.explicit.model ?? (typeof model === 'string' ? model : undefined))?.id;
+        const record = { childId: agent.id, parentId: binding.parentId, rootId: binding.rootId, path: binding.path, status: 'recommended',
+            explicit: { ...binding.explicit, provider: routeProvider }, ...(family ? { family } : {}),
+            parentSelection: { provider, ...(typeof model === 'string' ? { model } : {}), ...(typeof effort === 'string' ? { reasoningEffort: effort } : {}) } };
+        deps.store.create(record);
         pending.set(agent.id, record);
+        childEpochs.set(agent.id, epoch(binding.rootId));
         return undefined;
     });
     const requireBindingRecord = (agent, record) => {
@@ -127,74 +156,66 @@ export function policyHost(ctx, deps) {
         }
         let record = pending.get(agent.id) ?? deps.store.get(agent.id);
         requireBindingRecord(agent, record);
-        if (!record) {
-            const root = rootOf(agent);
-            if (root && enabled(root.id))
-                throw new Error('unsupported：创建没有官方工具身份绑定；该子请求未路由。请暂停并改用受支持的创建路径，或由用户切到 MANUAL 后继承。');
+        // Unbound children (plugin-created, MANUAL-created, fork) pass through untouched.
+        if (!record)
             return decision;
-        }
         if (record.parentId !== agent.session.header.parentSession)
             throw new Error('子会话身份不匹配');
-        if (!record.route && !enabled(record.rootId)) {
-            pending.delete(agent.id);
-            throw new Error('创建期间模式已改变；请重新创建，不静默继承');
+        if (record.route || record.status !== 'recommended')
+            return decision;
+        if (!pending.has(agent.id)) {
+            fallback(record, 'interrupted');
+            return decision;
         }
-        if (!record.route && enabled(record.rootId)) {
-            if (!pending.has(agent.id))
-                throw new Error('初始决策未完成且已恢复；不能用后续消息重新选模，请重新创建子任务');
-            if (record.status !== 'recommended')
-                throw new Error(`${record.status}：${record.reason ?? '初始决策未完成'}；暂停并询问用户`);
-            const saveFailure = (status, reason) => { record = { ...record, status, reason }; deps.store.set(record); pending.delete(agent.id); };
-            const explicit = record.explicit;
-            let measure;
-            let capability = 'bounded', depth = 'baseline';
-            if (!explicit.model || !explicit.reasoningEffort) {
-                // This is the exact child's entering message, not a parent-history/prompt similarity match.
-                const text = userInput(decision.messages).text;
-                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('创建期间模式已变化；请重新创建');
-                }
-                if (result.kind === 'cancelled') {
-                    saveFailure('failed', '初始判断已取消');
-                    throw new Error('子任务判断已取消');
-                }
-                if (result.kind === 'failed') {
-                    saveFailure('failed', result.category);
-                    throw new Error(`Jev 失败：${CATEGORY_HINTS[result.category]}；暂停委派并询问用户`);
-                }
-                if (result.capability === 'insufficient_context') {
-                    saveFailure('needs-context', '任务目标或范围不足');
-                    throw new Error('needs-context：请补充任务目标与范围');
-                }
-                measure = result;
-                capability = result.capability ?? 'bounded';
-                depth = result.depth;
+        const startedEpoch = childEpochs.get(agent.id) ?? epoch(record.rootId);
+        const current = () => enabled(record.rootId) && epoch(record.rootId) === startedEpoch;
+        if (!current()) {
+            fallback(record, 'mode-changed');
+            return decision;
+        }
+        const explicit = record.explicit;
+        let measure;
+        let capability = 'bounded', depth = 'baseline';
+        if (!explicit.model || !explicit.reasoningEffort) {
+            // This is the exact child's entering message, not a parent-history/prompt similarity match.
+            const text = userInput(decision.messages).text;
+            const result = await deps.jev.judgePolicy(buildState({ text }), payload.signal, 'child', explicit.model ? 'depth' : explicit.reasoningEffort ? 'capability' : 'both');
+            if (!current()) {
+                fallback(record, 'mode-changed');
+                return decision;
             }
-            try {
-                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('路由不在父会话创建时的官方允许列表中；请新建会话');
-                }
-                if (!enabled(record.rootId) || payload.signal.aborted)
-                    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);
+            if (result.kind === 'cancelled') {
+                fallback(record, 'jev-cancelled');
+                return decision;
             }
-            catch (error) {
-                saveFailure('failed', '配置不可用');
-                throw error;
+            if (result.kind === 'failed') {
+                fallback(record, `jev-${result.category}`);
+                return decision;
+            }
+            if (result.capability === 'insufficient_context') {
+                fallback(record, 'needs-context');
+                return decision;
             }
+            measure = result;
+            capability = result.capability ?? 'bounded';
+            depth = result.depth;
+        }
+        const catalog = await deps.catalog(explicit.provider);
+        if (!current()) {
+            fallback(record, 'mode-changed');
+            return decision;
+        }
+        const parent = record.parentSelection ?? { provider: explicit.provider };
+        const chosen = chooseChildRoute({ provider: explicit.provider, parent, explicit, capability, depth, catalog, cap: deps.settings().effortCap, captured: capturedAllowlist(record.parentId) }, registry);
+        if ('fallback' in chosen) {
+            fallback(record, chosen.fallback);
+            return decision;
         }
-        if (!record.route && enabled(record.rootId))
-            throw new Error('决策未完成；暂停子请求');
+        const route = chosen.route;
+        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);
+        childEpochs.delete(agent.id);
         return decision;
     });
     ctx.on('agent/request', async (payload, next) => {
@@ -245,16 +266,14 @@ export function policyHost(ctx, deps) {
         }
         const record = deps.store.get(agent.id);
         requireBindingRecord(agent, record);
-        if (record && !record.route)
-            throw new Error('初始路由未完成；不静默继承');
         if (!record?.route)
             return config;
         if (record.status === 'failed')
             throw new Error('实际应用失败；暂停子请求并询问用户');
         if (record.parentId !== agent.session.header.parentSession)
             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, registry);
+        // Existing routed instances keep their initial route; live gates are re-checked on every request.
+        validatePolicyRoute(await deps.catalog(record.route.provider), record.route.provider, record.route.model, record.route.reasoningEffort, deps.settings().effortCap, capturedAllowlist(record.parentId));
         return { ...config, ...record.route };
     }, { prepend: true });
     const confirmMainRequest = (session, requestSeq, turn) => {
@@ -320,6 +339,7 @@ export function policyHost(ctx, deps) {
     return {
         appliedDecision: (id) => enabled(id) ? applied.get(id)?.id : undefined,
         invalidate: (id) => { epochs.set(id, epoch(id) + 1); mainStatus.delete(id); latest.delete(id); applied.delete(id); },
+        childNotice: (rootId) => notices.get(rootId),
         status: (id) => deps.store.get(id), mainStatus: (id) => enabled(id) ? { ...mainStatus.get(id), ...(latest.get(id) ? { decision: latest.get(id) } : {}) } : undefined,
     };
 }

package/lib/policy-store.d.ts

@@ -1,5 +1,8 @@
 import { z } from 'zod';
 import { type Registry } from './strategies/index.js';
+export declare const FALLBACK_REASONS: readonly ["jev-cancelled", "needs-context", "mode-changed", "interrupted", "no-usable-route", "explicit-unavailable"];
+/** New `unsupported` writes use a closed reason set; `jev-<category>` carries the failure category. */
+export declare const closedReason: (reason: string | undefined) => boolean;
 declare function schemaFor(registry: Registry): z.ZodObject<{
     childId: z.ZodString;
     parentId: z.ZodString;
@@ -7,8 +10,8 @@ declare function schemaFor(registry: Registry): z.ZodObject<{
     status: z.ZodEnum<{
         failed: "failed";
         recommended: "recommended";
-        unsupported: "unsupported";
         "needs-context": "needs-context";
+        unsupported: "unsupported";
         applied: "applied";
     }>;
     path: z.ZodEnum<{
@@ -20,12 +23,15 @@ declare function schemaFor(registry: Registry): z.ZodObject<{
         [x: string]: string;
     }>>;
     explicit: z.ZodObject<{
-        provider: z.ZodEnum<{
-            [x: string]: string;
-        }>;
+        provider: z.ZodString;
         model: z.ZodOptional<z.ZodString>;
         reasoningEffort: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>;
+    parentSelection: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodOptional<z.ZodString>;
+        reasoningEffort: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
     decision: z.ZodOptional<z.ZodObject<{
         id: z.ZodNumber;
         source: z.ZodEnum<{
@@ -48,9 +54,7 @@ declare function schemaFor(registry: Registry): z.ZodObject<{
         capabilityProbabilities: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
     }, z.core.$strict>>;
     route: z.ZodOptional<z.ZodObject<{
-        provider: z.ZodEnum<{
-            [x: string]: string;
-        }>;
+        provider: z.ZodString;
         model: z.ZodString;
         reasoningEffort: z.ZodEnum<{
             low: "low";
@@ -60,9 +64,7 @@ declare function schemaFor(registry: Registry): z.ZodObject<{
         }>;
     }, z.core.$strict>>;
     actual: z.ZodOptional<z.ZodObject<{
-        provider: z.ZodEnum<{
-            [x: string]: string;
-        }>;
+        provider: z.ZodString;
         model: z.ZodString;
         reasoningEffort: z.ZodEnum<{
             low: "low";
@@ -83,6 +85,8 @@ export declare class PolicyStore {
     bind(id: string): void;
     wasBound(id: string): boolean;
     get(id: string): ChildDecision | undefined;
+    /** Initial binding of a new managed child: the parent snapshot is mandatory, then the marker. */
+    create(value: ChildDecision): void;
     set(value: ChildDecision): void;
 }
 export {};

package/lib/policy-store.js

@@ -4,18 +4,32 @@ import { join } from 'node:path';
 import { z } from 'zod';
 import { registry as builtin } from './strategies/index.js';
 const enumOf = (values) => z.enum(values);
+export const FALLBACK_REASONS = ['jev-cancelled', 'needs-context', 'mode-changed', 'interrupted', 'no-usable-route', 'explicit-unavailable'];
+/** New `unsupported` writes use a closed reason set; `jev-<category>` carries the failure category. */
+export const closedReason = (reason) => !!reason && (FALLBACK_REASONS.includes(reason) || /^jev-[a-z-]+$/.test(reason));
 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();
+    const provider = z.string().min(1).max(128);
+    const route = z.object({ provider, 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(),
+        explicit: z.object({ provider, model: z.string().optional(), reasoningEffort: z.string().optional() }).strict(),
+        parentSelection: z.object({ provider, model: z.string().max(128).optional(), reasoningEffort: z.string().max(32).optional() }).strict().optional(),
         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();
+    }).strict().superRefine((r, ctx) => {
+        const bad = (message) => ctx.addIssue({ code: 'custom', message });
+        if (r.status === 'recommended' && r.actual)
+            bad('recommended 不能含 actual');
+        if (r.status === 'applied' && (!r.route || !r.actual))
+            bad('applied 需要 route 与 actual');
+        if (r.status === 'unsupported' && (r.route || r.actual))
+            bad('unsupported 不能含 route');
+        if (r.status === 'needs-context' && r.route)
+            bad('needs-context 不能含 route');
+    });
 }
 /** 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() });
@@ -62,8 +76,17 @@ export class PolicyStore {
             throw new Error('子任务决策无法恢复；暂停该子会话');
         }
     }
+    /** Initial binding of a new managed child: the parent snapshot is mandatory, then the marker. */
+    create(value) {
+        if (!value.parentSelection)
+            throw new Error('新建初始记录缺少 parentSelection');
+        this.set(value);
+        this.bind(value.childId);
+    }
     set(value) {
         const checked = this.schema.parse(value);
+        if (checked.status === 'unsupported' && !closedReason(checked.reason))
+            throw new Error(`未知的未路由原因：${checked.reason ?? ''}`);
         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

@@ -1,20 +1,44 @@
 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;
+type Allowed = readonly {
+    provider: string;
+    model: string;
+}[];
+/** Whether a route is usable now: live catalog, enabled official allowlist, captured allowlist (if any) and the effort cap. */
+export declare function routeUsable(catalog: RoutingCatalog, provider: string, model: string, effort: string, cap: AutomaticEffort, captured?: Allowed): boolean;
+/** Bound routes are re-checked on every request; any gate failure rejects that request. */
+export declare function validatePolicyRoute(catalog: RoutingCatalog, provider: string, model: string, effort: string, cap: AutomaticEffort, captured?: Allowed): 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;
 }
+export type RouteFallback = 'no-usable-route' | 'explicit-unavailable';
+export interface ChildRouteInput {
+    provider: string;
+    parent: {
+        model?: string | undefined;
+        reasoningEffort?: string | undefined;
+    };
+    explicit: {
+        model?: string | undefined;
+        reasoningEffort?: string | undefined;
+    };
+    capability: Capability;
+    depth: Depth;
+    catalog: RoutingCatalog;
+    cap: AutomaticEffort;
+    captured?: Allowed | undefined;
+}
 /**
- * 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`.
+ * Fallback chain: capability slot → keep model with depth effort → parent effort (automatic effort only) → no rewrite.
+ * Provider never changes; explicit dimensions are never replaced.
  */
-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;
+export declare function chooseChildRoute(input: ChildRouteInput, registry?: Registry): {
+    route: PolicyRoute;
+} | {
+    fallback: RouteFallback;
+};
+export {};

package/lib/routing.js

@@ -1,19 +1,17 @@
 import { AUTO_EFFORTS } from './settings-contract.js';
-import { MODEL_ID_PATTERN } from './settings-validation.js';
 import { registry as builtin } from './strategies/index.js';
-/** Family of a child model on an exact transport; undefined when no registered strategy owns it. */
-export function modelFamily(provider, model, registry = builtin) {
-    return registry.familyOfChild(provider, model)?.id;
-}
-/** A transport whose model ids carry a family prefix (`<family>/<model>`), e.g. a gateway. */
-function prefixedTransport(provider, registry) {
-    return registry.strategies.some(s => (s.transports[provider] ?? '') !== '');
-}
-export function validatePolicyRoute(catalog, provider, model, effort, cap, registry = builtin) {
+const listed = (list, provider, model) => list.some(m => m.provider === provider && m.model === model);
+/** Whether a route is usable now: live catalog, enabled official allowlist, captured allowlist (if any) and the effort cap. */
+export function routeUsable(catalog, provider, model, effort, cap, captured) {
     const entry = catalog.models.find(m => m.provider === provider && m.model === model);
-    const validId = prefixedTransport(provider, registry) ? /^[A-Za-z0-9._:-]+(?:\/[A-Za-z0-9._:-]+)+$/.test(model) && model.length <= 128 : MODEL_ID_PATTERN.test(model);
-    if (!registry.hasProvider(provider) || !validId || !entry || !AUTO_EFFORTS.includes(effort) || AUTO_EFFORTS.indexOf(effort) > AUTO_EFFORTS.indexOf(cap) || !entry.reasoningEfforts.includes(effort) || catalog.childAllowlist.status !== 'enabled' || !catalog.childAllowlist.allowedModels.some(m => m.provider === provider && m.model === model))
-        throw new Error('子任务路由不在当前目录/允许列表或 effort 上限内；暂停委派并询问用户');
+    return !!entry && model.length <= 128 && AUTO_EFFORTS.includes(effort) && AUTO_EFFORTS.indexOf(effort) <= AUTO_EFFORTS.indexOf(cap)
+        && entry.reasoningEfforts.includes(effort) && catalog.childAllowlist.status === 'enabled' && listed(catalog.childAllowlist.allowedModels, provider, model)
+        && (!captured || listed(captured, provider, model));
+}
+/** Bound routes are re-checked on every request; any gate failure rejects that request. */
+export function validatePolicyRoute(catalog, provider, model, effort, cap, captured) {
+    if (!routeUsable(catalog, provider, model, effort, cap, captured))
+        throw new Error('子任务路由不在当前目录/允许列表或 effort 上限内；拒绝本次请求');
 }
 export function policyEffort(model, depth, supported, cap, defaultEffort, registry = builtin) {
     const start = registry.effortStart(model) ?? defaultEffort;
@@ -32,20 +30,33 @@ export function policyEffort(model, depth, supported, cap, defaultEffort, regist
     return AUTO_EFFORTS.indexOf(chosen) > AUTO_EFFORTS.indexOf(cap) ? allowed.at(-1) : chosen;
 }
 /**
- * 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`.
+ * Fallback chain: capability slot → keep model with depth effort → parent effort (automatic effort only) → no rewrite.
+ * Provider never changes; explicit dimensions are never replaced.
  */
-export function choosePolicyRoute(provider, capability, depth, catalog, cap, explicit = {}, family, registry = builtin) {
-    if (!registry.hasProvider(provider))
-        throw new Error('unsupported：provider 不在已注册家族中；暂停委派并询问用户');
-    const implied = registry.familyOfChild(provider, '')?.id;
-    const selectedFamily = implied ?? family;
-    const slot = selectedFamily ? registry.childModel(selectedFamily, provider, capability) : undefined;
-    if (!explicit.model && !slot)
-        throw new Error('unsupported：没有已定义的模型能力家族；请显式指定模型');
-    const model = explicit.model ?? slot;
-    const entry = catalog.models.find(m => m.provider === provider && m.model === model);
-    const reasoningEffort = explicit.reasoningEffort ?? policyEffort(model, depth, entry?.reasoningEfforts ?? [], cap, entry?.defaultEffort, registry);
-    validatePolicyRoute(catalog, provider, model, reasoningEffort, cap, registry);
-    return { provider, model, reasoningEffort: reasoningEffort };
+export function chooseChildRoute(input, registry = builtin) {
+    const { provider, parent, explicit, depth, catalog, cap, captured } = input;
+    const entry = (model) => catalog.models.find(m => m.provider === provider && m.model === model);
+    const depthEffort = (model) => { try {
+        const e = entry(model);
+        return e ? policyEffort(model, depth, e.reasoningEfforts, cap, e.defaultEffort, registry) : undefined;
+    }
+    catch {
+        return undefined;
+    } };
+    const take = (model, effort) => model && effort && routeUsable(catalog, provider, model, effort, cap, captured) ? { route: { provider, model, reasoningEffort: effort } } : undefined;
+    const family = parent.model ? registry.familyOfMainModel(parent.model)?.id : undefined;
+    if (!explicit.model && family && parent.model) {
+        const slot = registry.resolveSlot(family, input.capability, parent.model, catalog.models.filter(m => m.provider === provider).map(m => m.model));
+        const hit = slot && take(slot, explicit.reasoningEffort ?? depthEffort(slot));
+        if (hit)
+            return hit;
+    }
+    const model = explicit.model ?? parent.model;
+    const kept = model && take(model, explicit.reasoningEffort ?? depthEffort(model));
+    if (kept)
+        return kept;
+    const inherited = !explicit.reasoningEffort && take(model, parent.reasoningEffort);
+    if (inherited)
+        return inherited;
+    return { fallback: explicit.model || explicit.reasoningEffort ? 'explicit-unavailable' : 'no-usable-route' };
 }

package/lib/settings-host.d.ts

@@ -1,10 +1,9 @@
 import type { Context } from '@deepseek-ai/cordis';
 import { SettingsStore } from './settings.js';
 import type { RoutingCatalog } from './settings-contract.js';
-import { type Registry } from './strategies/index.js';
 /** Only the fixed credential reference and public catalog metadata cross this adapter. */
-export declare function settingsHost(ctx: Context, store: SettingsStore, registry?: Registry): {
-    catalog: () => Promise<RoutingCatalog>;
+export declare function settingsHost(ctx: Context, store: SettingsStore): {
+    catalog: (only?: string) => Promise<RoutingCatalog>;
     read: () => Promise<{
         models: readonly import("./settings-contract.js").RoutingModel[];
         childAllowlist: {

package/lib/settings-host.js

@@ -1,16 +1,30 @@
 import { credentialRef } from '@deepseek-ai/dsh-credentials';
 import { launchEnvironmentOf } from '@deepseek-ai/dsh-launch-environment';
 import { DEFAULT_SETTINGS, SettingsValidationError } from './settings.js';
-import { registry as builtin } from './strategies/index.js';
 import { JevClient } from './jev.js';
 import { DECISION_SERVICES } from './decision-service.js';
 const keyRef = (provider = 'openrouter') => credentialRef(DECISION_SERVICES[provider].credential);
 /** Only the fixed credential reference and public catalog metadata cross this adapter. */
-export function settingsHost(ctx, store, registry = builtin) {
+export function settingsHost(ctx, store) {
     const environment = launchEnvironmentOf(ctx);
     const credentials = () => ctx.get('credentials');
-    const catalog = async () => {
-        const models = (await Promise.all(ctx.llm.listProviders().filter(p => registry.hasProvider(p.id)).map(async (provider) => {
+    const allowlist = () => {
+        // The optional provider is owned by dsh-tool-subagent, not this package.
+        const service = ctx.get('subagentModelSelection');
+        try {
+            if (service) {
+                const current = service.current();
+                return { status: current.enabled ? 'enabled' : 'disabled', allowedModels: current.allowedModels };
+            }
+        }
+        catch { /* An unavailable policy must never broaden the allowed routes. */ }
+        return { status: 'unavailable', allowedModels: [] };
+    };
+    /** One provider when routing; otherwise only the providers the allowlist names (never every host provider). */
+    const catalog = async (only) => {
+        const childAllowlist = allowlist();
+        const wanted = new Set(only ? [only] : childAllowlist.allowedModels.map(r => r.provider));
+        const models = (await Promise.all(ctx.llm.listProviders().filter(p => wanted.has(p.id)).map(async (provider) => {
             try {
                 return await Promise.all((await ctx.llm.listModels(provider.id)).map(async (model) => {
                     try {
@@ -26,16 +40,7 @@ export function settingsHost(ctx, store, registry = builtin) {
                 return [];
             }
         }))).flat();
-        // The optional provider is owned by dsh-tool-subagent, not this package.
-        const service = ctx.get('subagentModelSelection');
-        try {
-            if (service) {
-                const current = service.current();
-                return { models, childAllowlist: { status: current.enabled ? 'enabled' : 'disabled', allowedModels: current.allowedModels.filter(r => registry.hasProvider(r.provider)) } };
-            }
-        }
-        catch { /* An unavailable policy must never broaden the allowed routes. */ }
-        return { models, childAllowlist: { status: 'unavailable', allowedModels: [] } };
+        return { models, childAllowlist };
     };
     const keyStatus = async (provider = store.read().settings.decisionService?.provider ?? 'openrouter') => {
         const ref = keyRef(provider);

package/lib/strategies/claude.d.ts

@@ -2,11 +2,6 @@ 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";

package/lib/strategies/claude.js

@@ -2,7 +2,6 @@ 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

@@ -3,11 +3,6 @@ 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";

package/lib/strategies/codex.js

@@ -3,7 +3,6 @@ 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' },
 };