dsh-auto-model-routing 0.4.1 → 0.5.0

package/lib/settings-host.d.ts

@@ -1,16 +1,11 @@
 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): {
-    catalog: (includeMagpie?: boolean) => Promise<RoutingCatalog>;
+export declare function settingsHost(ctx: Context, store: SettingsStore, registry?: Registry): {
+    catalog: () => Promise<RoutingCatalog>;
     read: () => Promise<{
-        criteria: {
-            simple: string;
-            standard: string;
-            complex: string;
-            escalated: string;
-        };
         models: readonly import("./settings-contract.js").RoutingModel[];
         childAllowlist: {
             status: "enabled" | "disabled" | "unavailable";
@@ -23,6 +18,7 @@ export declare function settingsHost(ctx: Context, store: SettingsStore): {
         defaults: Readonly<import("./settings-contract.js").Settings>;
         configStatus: "ok" | "missing" | "invalid";
         issues: import("./settings-contract.js").SettingsIssue[];
+        deprecated: string[];
         key: {
             available: boolean;
             configured: boolean;

package/lib/settings-host.js

@@ -1,16 +1,16 @@
 import { credentialRef } from '@deepseek-ai/dsh-credentials';
 import { launchEnvironmentOf } from '@deepseek-ai/dsh-launch-environment';
 import { DEFAULT_SETTINGS, SettingsValidationError } from './settings.js';
-import rubric from './rubric.json' with { type: 'json' };
+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) {
+export function settingsHost(ctx, store, registry = builtin) {
     const environment = launchEnvironmentOf(ctx);
     const credentials = () => ctx.get('credentials');
-    const catalog = async (includeMagpie = store.read().settings.policy === 'policy-v2') => {
-        const models = (await Promise.all(ctx.llm.listProviders().filter(p => p.id === 'claude' || p.id === 'codex' || (includeMagpie && p.id === 'dsh-magpie-connect')).map(async (provider) => {
+    const catalog = async () => {
+        const models = (await Promise.all(ctx.llm.listProviders().filter(p => registry.hasProvider(p.id)).map(async (provider) => {
             try {
                 return await Promise.all((await ctx.llm.listModels(provider.id)).map(async (model) => {
                     try {
@@ -31,7 +31,7 @@ export function settingsHost(ctx, store) {
         try {
             if (service) {
                 const current = service.current();
-                return { models, childAllowlist: { status: current.enabled ? 'enabled' : 'disabled', allowedModels: current.allowedModels.filter(r => r.provider === 'claude' || r.provider === 'codex' || (includeMagpie && r.provider === 'dsh-magpie-connect')) } };
+                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. */ }
@@ -52,20 +52,20 @@ export function settingsHost(ctx, store) {
     };
     const read = async () => {
         const current = await catalog();
-        const result = store.read(current);
-        return { settings: result.settings, defaults: DEFAULT_SETTINGS, configStatus: result.status, issues: result.issues, key: await keyStatus(), ...current, criteria: rubric.tier.criteria };
+        const result = store.read();
+        return { settings: result.settings, defaults: DEFAULT_SETTINGS, configStatus: result.status, issues: result.issues, deprecated: result.deprecated, key: await keyStatus(), ...current };
     };
     const endpoint = async (operation, body) => {
         if (operation === 'settings')
             return Response.json(await read());
         if (operation === 'testDecision') {
-            const client = new JevClient({ get: async (name) => credentials() ? credentials().resolve(credentialRef(name)) : environment.get(name) }, undefined, 4500, () => store.read().settings.decisionService);
+            const client = new JevClient({ get: async (name) => credentials() ? credentials().resolve(credentialRef(name)) : environment.get(name) }, undefined, 8000, () => store.read().settings.decisionService);
             const result = await client.judgePolicy('Public connection test: sort the numbers [3,1,2] in ascending order.', new AbortController().signal, 'child');
             return Response.json(result);
         }
         if (operation === 'saveSettings') {
             try {
-                store.save(body, await catalog());
+                store.save(body);
                 return Response.json(await read());
             }
             catch (error) {

package/lib/settings-validation.d.ts

@@ -1,10 +1,4 @@
-import { type AutomaticEffort, type RoutingCatalog, type RoutingModel, type SettingsIssue } from './settings-contract.js';
+import type { SettingsIssue } from './settings-contract.js';
 export declare const MODEL_ID_PATTERN: RegExp;
 export declare function isRecord(value: unknown): value is Record<string, unknown>;
 export declare function issue(path: string, code: string, message: string): SettingsIssue;
-export declare function supportedAutomaticEfforts(model: RoutingModel, cap: AutomaticEffort): AutomaticEffort[];
-export declare function selectableModels(catalog: RoutingCatalog, provider: string, kind: 'main' | 'child'): RoutingModel[];
-export declare function supportedFamilyEfforts(catalog: RoutingCatalog, provider: string, cap: AutomaticEffort): AutomaticEffort[];
-export declare function validateFamilyMainEffort(catalog: RoutingCatalog, provider: string, effort: unknown, cap: AutomaticEffort, path?: string): SettingsIssue[];
-export declare function validateMainRoute(catalog: RoutingCatalog, provider: string, model: string, effort: unknown, cap: AutomaticEffort, path?: string): SettingsIssue[];
-export declare function validateChildRoute(catalog: RoutingCatalog, provider: string, route: unknown, cap: AutomaticEffort, path?: string): SettingsIssue[];

package/lib/settings-validation.js

@@ -1,56 +1,5 @@
-import { AUTO_EFFORTS } from './settings-contract.js';
 export const MODEL_ID_PATTERN = /^[A-Za-z0-9._:-]{1,128}(?![\s\S])/;
 export function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 export function issue(path, code, message) { return { path, code, message }; }
-export function supportedAutomaticEfforts(model, cap) {
-    return AUTO_EFFORTS.filter((effort, index) => index <= AUTO_EFFORTS.indexOf(cap) && model.reasoningEfforts.includes(effort));
-}
-export function selectableModels(catalog, provider, kind) {
-    return catalog.models.filter(model => model.provider === provider && (kind === 'main' || (catalog.childAllowlist.status === 'enabled' && catalog.childAllowlist.allowedModels.some(route => route.provider === provider && route.model === model.model))));
-}
-export function supportedFamilyEfforts(catalog, provider, cap) {
-    const models = selectableModels(catalog, provider, 'main');
-    return models.length ? AUTO_EFFORTS.filter((effort, index) => index <= AUTO_EFFORTS.indexOf(cap) && models.every(model => model.reasoningEfforts.includes(effort))) : [];
-}
-export function validateFamilyMainEffort(catalog, provider, effort, cap, path = '') {
-    if (!['claude', 'codex'].includes(provider))
-        return [issue(path, 'invalid-route', 'Invalid provider')];
-    if (!AUTO_EFFORTS.includes(effort))
-        return [issue(path, 'invalid-effort', 'Choose an automatic effort from low through xhigh')];
-    if (AUTO_EFFORTS.indexOf(effort) > AUTO_EFFORTS.indexOf(cap))
-        return [issue(path, 'effort-cap', '超过推理强度上限')];
-    if (!selectableModels(catalog, provider, 'main').length)
-        return [issue(path, 'model-unavailable', '该体系没有当前可用模型')];
-    if (!supportedFamilyEfforts(catalog, provider, cap).includes(effort))
-        return [issue(path, 'unsupported-effort', '此推理等级并非该体系所有模型共同支持')];
-    return [];
-}
-export function validateMainRoute(catalog, provider, model, effort, cap, path = '') {
-    if (!['claude', 'codex'].includes(provider) || !MODEL_ID_PATTERN.test(model))
-        return [issue(path, 'invalid-route', 'Invalid provider or model id')];
-    if (!AUTO_EFFORTS.includes(effort))
-        return [issue(path, 'invalid-effort', 'Choose an automatic effort from low through xhigh')];
-    if (AUTO_EFFORTS.indexOf(effort) > AUTO_EFFORTS.indexOf(cap))
-        return [issue(path, 'effort-cap', '超过推理强度上限')];
-    const entry = catalog.models.find(entry => entry.provider === provider && entry.model === model);
-    if (!entry)
-        return [issue(path, 'model-unavailable', '模型不在当前可用目录中')];
-    if (!entry.reasoningEfforts.includes(effort))
-        return [issue(path, 'unsupported-effort', '模型不支持此推理等级')];
-    return [];
-}
-export function validateChildRoute(catalog, provider, route, cap, path = '') {
-    if (!isRecord(route) || typeof route.model !== 'string' || typeof route.reasoningEffort !== 'string' || Object.keys(route).some(key => !['model', 'reasoningEffort'].includes(key))) {
-        return [issue(path, 'invalid-route', '子会话推荐必须包含完整的模型和推理等级')];
-    }
-    const errors = validateMainRoute(catalog, provider, route.model, route.reasoningEffort, cap, path);
-    if (errors.length)
-        return errors;
-    if (catalog.childAllowlist.status !== 'enabled')
-        return [issue(path, 'allowlist-unavailable', '无法读取已启用的子智能体允许列表')];
-    if (!catalog.childAllowlist.allowedModels.some(entry => entry.provider === provider && entry.model === route.model))
-        return [issue(path, 'route-not-allowed', '模型不在子智能体允许列表中')];
-    return [];
-}

package/lib/settings.d.ts

@@ -1,18 +1,13 @@
-import { type Tier } from './effort.js';
-import { type AutomaticEffort, type RoutingCatalog, type Settings, type SettingsIssue, type SettingsRead } from './settings-contract.js';
+import { type SettingsIssue, type SettingsRead } from './settings-contract.js';
 export { DEFAULT_SETTINGS } from './settings-contract.js';
 export type { Settings, SettingsPatch, SettingsIssue, SettingsRead, RoutingCatalog } from './settings-contract.js';
 export declare class SettingsValidationError extends Error {
     readonly issues: SettingsIssue[];
     constructor(issues: SettingsIssue[]);
 }
-export declare function validateSettingsRoutes(settings: Settings, catalog: RoutingCatalog): SettingsIssue[];
-/** Returns undefined only for a genuinely absent cell; malformed containers/cells throw. */
-export declare function explicitMainEffort(settings: Settings, provider: string, model: string, tier: Tier, catalog: RoutingCatalog): AutomaticEffort | undefined;
-export declare function explicitChildRoute(settings: Settings, provider: string, tier: Tier, catalog: RoutingCatalog): import('./settings-contract.js').ChildRoute | undefined;
 export declare class SettingsStore {
     readonly path: string;
     constructor(path: string);
-    read(catalog?: RoutingCatalog): SettingsRead;
-    save(patch: unknown, catalog: RoutingCatalog): SettingsRead;
+    read(): SettingsRead;
+    save(patch: unknown): SettingsRead;
 }

package/lib/settings.js

@@ -3,9 +3,8 @@ import { dirname } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { z } from 'zod';
 import { resolveDecisionService } from './decision-service.js';
-import { tiers } from './effort.js';
-import { AUTO_EFFORTS, DEFAULT_SETTINGS } from './settings-contract.js';
-import { isRecord, issue, MODEL_ID_PATTERN, validateChildRoute, validateFamilyMainEffort, validateMainRoute } from './settings-validation.js';
+import { AUTO_EFFORTS, DEFAULT_SETTINGS, DEPRECATED_KEYS } from './settings-contract.js';
+import { isRecord, issue } from './settings-validation.js';
 export { DEFAULT_SETTINGS } from './settings-contract.js';
 const ordinary = {
     decisionService: z.object({ provider: z.enum(['openrouter', 'typesafe', 'concentrate', 'custom']), model: z.string().regex(/^[A-Za-z0-9._:/~-]{1,128}$/).optional(), endpoint: z.string().max(2048).optional() }).strict().refine(value => { try {
@@ -15,24 +14,10 @@ const ordinary = {
     catch {
         return false;
     } }, 'Invalid decision service'),
-    policy: z.enum(['legacy', 'policy-v2']),
     decisionToast: z.boolean(), defaultMode: z.enum(['MANUAL', 'AUTO']),
-    effortCap: z.enum(AUTO_EFFORTS), jevTimeoutMs: z.number().int().min(1000).max(4500),
-};
-const provider = z.enum(['claude', 'codex']);
-const tier = z.enum(['simple', 'standard', 'complex', 'escalated']);
-const model = z.string().regex(MODEL_ID_PATTERN);
-const effort = z.enum(AUTO_EFFORTS);
-const child = z.object({ model, reasoningEffort: effort }).strict();
-const patchSchema = z.object({
-    ...Object.fromEntries(Object.entries(ordinary).map(([key, schema]) => [key, schema.optional()])),
-    mainEfforts: z.partialRecord(provider, z.partialRecord(tier, effort.nullable()).nullable()).optional(),
-    childRoutes: z.partialRecord(provider, z.partialRecord(tier, child.nullable())).optional(),
-}).strict();
-const routeSchemas = {
-    mainEfforts: z.partialRecord(provider, z.partialRecord(tier, effort)),
-    childRoutes: z.partialRecord(provider, z.partialRecord(tier, child)),
+    effortCap: z.enum(AUTO_EFFORTS), jevTimeoutMs: z.number().int().min(1000).max(8000),
 };
+const patchSchema = z.object(Object.fromEntries(Object.entries(ordinary).map(([key, schema]) => [key, schema.optional()]))).strict();
 export class SettingsValidationError extends Error {
     issues;
     constructor(issues) {
@@ -42,15 +27,11 @@ export class SettingsValidationError extends Error {
     }
 }
 function schemaIssues(error, prefix = '') {
-    return error.issues.map(entry => issue([prefix, ...entry.path.map(String)].filter(Boolean).join('.'), 'invalid-setting', '设置字段无效'));
-}
-function mainKeyIssues(value) {
-    if (!isRecord(value) || !isRecord(value.mainEfforts))
-        return [];
-    return Object.entries(value.mainEfforts).flatMap(([provider, family]) => {
-        if (!['claude', 'codex'].includes(provider))
-            return [issue(`mainEfforts.${provider}`, 'invalid-setting', 'Invalid provider')];
-        return isRecord(family) ? Object.keys(family).filter(key => !tiers.includes(key)).map(key => issue(`mainEfforts.${provider}.${key}`, 'invalid-setting', 'Invalid tier')) : [];
+    return error.issues.flatMap(entry => {
+        // Unknown keys (retired mapping keys included) are reported by name.
+        if (entry.code === 'unrecognized_keys')
+            return entry.keys.map(key => issue([prefix, ...entry.path.map(String), key].filter(Boolean).join('.'), 'unknown-setting', '未知设置字段'));
+        return [issue([prefix, ...entry.path.map(String)].filter(Boolean).join('.'), 'invalid-setting', '设置字段无效')];
     });
 }
 function credentialFields(value, path = '') {
@@ -63,127 +44,22 @@ function credentialFields(value, path = '') {
         return credentialFields(entry, next);
     });
 }
-/** Visit identifiable cells, never filtering malformed containers into an empty/default map. */
-function cells(settings, visit) {
-    for (const kind of ['mainEfforts', 'childRoutes']) {
-        const map = settings[kind];
-        if (!isRecord(map))
-            continue;
-        for (const [provider, values] of Object.entries(map)) {
-            if (!isRecord(values))
-                continue;
-            for (const [tier, value] of Object.entries(values))
-                visit(kind, provider, tier, value, `${kind}.${provider}.${tier}`);
-        }
-    }
-}
-export function validateSettingsRoutes(settings, catalog) {
-    const issues = [];
-    cells(settings, (kind, provider, tier, value, path) => {
-        if (!tiers.includes(tier))
-            return;
-        const explicitEffort = kind === 'mainEfforts' ? value : isRecord(value) ? value.reasoningEffort : undefined;
-        if (AUTO_EFFORTS.includes(explicitEffort) && AUTO_EFFORTS.indexOf(explicitEffort) > AUTO_EFFORTS.indexOf(settings.effortCap)) {
-            issues.push(issue(path, 'effort-cap', '超过推理强度上限'));
-        }
-        else
-            issues.push(...(kind === 'mainEfforts' ? validateFamilyMainEffort(catalog, provider, value, settings.effortCap, path) : validateChildRoute(catalog, provider, value, settings.effortCap, path)));
-    });
-    const main = settings.mainEfforts;
-    if (isRecord(main))
-        for (const [provider, family] of Object.entries(main)) {
-            if (!isRecord(family))
-                continue;
-            for (const [model, legacy] of Object.entries(family)) {
-                if (!isRecord(legacy))
-                    continue;
-                for (const [tier, effort] of Object.entries(legacy))
-                    if (tiers.includes(tier) && AUTO_EFFORTS.includes(effort) && AUTO_EFFORTS.indexOf(effort) > AUTO_EFFORTS.indexOf(settings.effortCap))
-                        issues.push(issue(`mainEfforts.${provider}.${model}.${tier}`, 'effort-cap', '超过推理强度上限'));
-            }
-        }
-    return issues;
-}
-/** Returns undefined only for a genuinely absent cell; malformed containers/cells throw. */
-export function explicitMainEffort(settings, provider, model, tier, catalog) {
-    const family = explicitCell(settings.mainEfforts, [provider], 'mainEfforts');
-    if (family.present && (!isRecord(family.value) || Object.entries(family.value).some(([key, value]) => !tiers.includes(key) || isRecord(value)))) {
-        throw new SettingsValidationError([issue(`mainEfforts.${provider}`, 'invalid-route', '主会话映射必须按体系和档位配置，请替换旧模型映射或恢复默认')]);
-    }
-    const value = explicitCell(settings.mainEfforts, [provider, tier], 'mainEfforts');
-    if (!value.present)
-        return undefined;
-    const errors = validateMainRoute(catalog, provider, model, value.value, settings.effortCap, `mainEfforts.${provider}.${tier}`);
-    if (errors.length)
-        throw new SettingsValidationError(errors);
-    return value.value;
-}
-export function explicitChildRoute(settings, provider, tier, catalog) {
-    const value = explicitCell(settings.childRoutes, [provider, tier], 'childRoutes');
-    if (!value.present)
-        return undefined;
-    const errors = validateChildRoute(catalog, provider, value.value, settings.effortCap, `childRoutes.${provider}.${tier}`);
-    if (errors.length)
-        throw new SettingsValidationError(errors);
-    return value.value;
-}
-function explicitCell(root, keys, path) {
-    let value = root;
-    if (value === undefined)
-        return { present: false };
-    for (const key of keys) {
-        if (!isRecord(value))
-            throw new SettingsValidationError([issue(path, 'invalid-route', '显式路由配置格式无效')]);
-        if (!Object.hasOwn(value, key))
-            return { present: false };
-        value = value[key];
-        path += `.${key}`;
-    }
-    return { present: true, value };
-}
-function hasCellChanges(patch, depth) {
-    return Object.values(patch).some(value => depth === 1 || !isRecord(value) || hasCellChanges(value, depth - 1));
-}
-function mergeCells(current, patch, depth, path) {
-    if (!hasCellChanges(patch, depth))
-        return structuredClone(current);
-    if (current !== undefined && !isRecord(current))
-        throw new SettingsValidationError([issue(path, 'invalid-route', '显式路由容器格式无效，请先修复设置文件')]);
-    const merged = isRecord(current) ? structuredClone(current) : {};
-    for (const [key, value] of Object.entries(patch)) {
-        if (value === null)
-            delete merged[key];
-        else if (depth > 1 && isRecord(value)) {
-            const previous = Object.hasOwn(merged, key) ? merged[key] : undefined;
-            // A nonempty canonical family submission explicitly replaces a legacy/malformed family.
-            const replaceFamily = path === 'mainEfforts' && Object.keys(value).length > 0 && (!isRecord(previous) || Object.entries(previous).some(([entry, value]) => !tiers.includes(entry) || isRecord(value)));
-            const nested = mergeCells(replaceFamily ? undefined : previous, value, depth - 1, `${path}.${key}`);
-            if (nested !== undefined && (!isRecord(nested) || Object.keys(nested).length))
-                Object.defineProperty(merged, key, { value: nested, enumerable: true, configurable: true, writable: true });
-            else
-                delete merged[key];
-        }
-        else
-            Object.defineProperty(merged, key, { value: structuredClone(value), enumerable: true, configurable: true, writable: true });
-    }
-    return merged;
-}
 export class SettingsStore {
     path;
     constructor(path) {
         this.path = path;
     }
-    read(catalog) {
+    read() {
         let raw;
         try {
             raw = JSON.parse(readFileSync(this.path, 'utf8'));
         }
         catch (error) {
             const missing = error.code === 'ENOENT';
-            return { settings: { ...DEFAULT_SETTINGS }, status: missing ? 'missing' : 'invalid', issues: missing ? [] : [issue('', 'invalid-file', '设置文件无法读取或解析，保存将覆盖它')] };
+            return { settings: { ...DEFAULT_SETTINGS }, status: missing ? 'missing' : 'invalid', deprecated: [], issues: missing ? [] : [issue('', 'invalid-file', '设置文件无法读取或解析，保存将覆盖它')] };
         }
         if (!isRecord(raw))
-            return { settings: { ...DEFAULT_SETTINGS }, status: 'invalid', issues: [issue('', 'invalid-file', '设置文件必须是对象')] };
+            return { settings: { ...DEFAULT_SETTINGS }, status: 'invalid', deprecated: [], issues: [issue('', 'invalid-file', '设置文件必须是对象')] };
         const settings = { ...DEFAULT_SETTINGS };
         const issues = [];
         for (const [key, schema] of Object.entries(ordinary)) {
@@ -199,28 +75,18 @@ export class SettingsStore {
                     Object.assign(settings, { decisionService: { provider: 'custom', endpoint: '' } });
             }
         }
-        for (const kind of ['mainEfforts', 'childRoutes']) {
-            if (!Object.hasOwn(raw, kind))
-                continue;
-            Object.assign(settings, { [kind]: raw[kind] });
-            const parsed = routeSchemas[kind].safeParse(raw[kind]);
-            if (!parsed.success)
-                issues.push(...schemaIssues(parsed.error, kind));
-        }
-        issues.push(...mainKeyIssues(raw));
-        if (catalog)
-            issues.push(...validateSettingsRoutes(settings, catalog));
-        return { settings, issues, status: issues.length ? 'invalid' : 'ok' };
+        const deprecated = DEPRECATED_KEYS.filter(key => Object.hasOwn(raw, key));
+        return { settings, issues, status: issues.length ? 'invalid' : 'ok', deprecated };
     }
-    save(patch, catalog) {
+    save(patch) {
         const parsed = patchSchema.safeParse(patch);
-        const errors = [...credentialFields(patch), ...mainKeyIssues(patch), ...(!parsed.success ? schemaIssues(parsed.error) : [])];
+        const errors = [...credentialFields(patch), ...(!parsed.success ? schemaIssues(parsed.error) : [])];
         if (errors.length)
             throw new SettingsValidationError(errors);
         const submitted = patch;
         const before = this.read();
         const persisted = {};
-        // Only persist existing scalar fields; ordinary invalid values are normalized on an explicit save.
+        // Only ordinary fields already in the file or submitted now are written; retired keys are dropped.
         let disk;
         try {
             disk = JSON.parse(readFileSync(this.path, 'utf8'));
@@ -231,31 +97,6 @@ export class SettingsStore {
         for (const key of Object.keys(ordinary))
             if ((isRecord(disk) && Object.hasOwn(disk, key)) || Object.hasOwn(submitted, key))
                 persisted[key] = submitted[key] ?? before.settings[key];
-        for (const kind of ['mainEfforts', 'childRoutes']) {
-            const existing = before.settings[kind];
-            if (Object.hasOwn(submitted, kind)) {
-                const merged = mergeCells(existing, submitted[kind], 2, kind);
-                if (merged !== undefined && (!isRecord(merged) || Object.keys(merged).length))
-                    persisted[kind] = merged;
-            }
-            else if (existing !== undefined)
-                persisted[kind] = existing;
-        }
-        const next = { ...DEFAULT_SETTINGS, ...persisted };
-        const capChanged = next.effortCap !== before.settings.effortCap;
-        const touched = new Set();
-        const previous = new Map();
-        cells(before.settings, (_kind, _provider, _tier, value, path) => { previous.set(path, value); });
-        cells(submitted, (_kind, _provider, _tier, value, path) => {
-            const oldMain = before.settings.mainEfforts;
-            const oldFamily = isRecord(oldMain) ? oldMain[_provider] : undefined;
-            const replacesFamily = _kind === 'mainEfforts' && oldFamily !== undefined && (!isRecord(oldFamily) || Object.entries(oldFamily).some(([key, value]) => !tiers.includes(key) || isRecord(value)));
-            if (value !== null && (replacesFamily || JSON.stringify(value) !== JSON.stringify(previous.get(path))))
-                touched.add(path);
-        });
-        const validation = validateSettingsRoutes(next, catalog).filter(entry => touched.has(entry.path) || (capChanged && entry.code === 'effort-cap'));
-        if (validation.length)
-            throw new SettingsValidationError(validation);
         const directory = dirname(this.path);
         mkdirSync(directory, { recursive: true, mode: 0o700 });
         chmodSync(directory, 0o700);
@@ -272,6 +113,6 @@ export class SettingsStore {
             catch { }
             throw error;
         }
-        return this.read(catalog);
+        return this.read();
     }
 }

package/lib/state.d.ts

@@ -1,4 +1,4 @@
-import type { Effort, Tier } from './effort.js';
+import type { Effort } from './effort.js';
 import type { JevCategory } from './jev.js';
 export type Mode = 'AUTO' | 'MANUAL';
 export interface Selection {
@@ -12,7 +12,7 @@ export interface Disabled {
 }
 export interface SessionState {
     mode: Mode;
-    previous?: Tier;
+    previous?: 'simple' | 'standard' | 'complex' | 'escalated';
     disabled?: Disabled;
 }
 export interface StateStore {
@@ -33,7 +33,5 @@ export declare class RoutingState {
     setMode(id: string, mode: Mode): SessionState;
     /** Jev failed: switch to MANUAL (no restore) and keep the visible reason. */
     disable(id: string, category: JevCategory, at?: number): SessionState;
-    /** Keep the latest user-turn tier (name only) so a restart still sends it to Jev as context. */
-    remember(id: string, tier: Tier): void;
     private save;
 }

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;