dsh-auto-model-routing 0.4.2 → 0.5.0

package/lib/context.d.ts

@@ -1,4 +1,3 @@
-import type { Tier } from './effort.js';
 export declare function redact(text: string): string;
 interface HistoryMessage {
     role: string;
@@ -15,9 +14,8 @@ export declare function previousTurn(messages: readonly HistoryMessage[]): {
     user?: string;
     assistant?: string;
 };
-/** The Jev `state` for a main-session turn (spec "Jev 判断档位"); every section is redacted, then cut. */
+/** The Jev `state`; every section is redacted, then cut. The fixed first line keeps the request bytes stable. */
 export declare function buildState(input: {
-    previous?: Tier | undefined;
     prevUser?: string | undefined;
     prevAssistant?: string | undefined;
     text: string;

package/lib/context.js

@@ -1,5 +1,4 @@
-import { tierAbove } from './jev.js';
-/** Shape-based, best effort (design D4): applied to the whole text before any truncation. */
+/** Shape-based, best effort: applied to the whole text before any truncation. */
 const RULES = [
     [/-----BEGIN [A-Z ]+-----[\s\S]*?-----END [A-Z ]+-----/g, '<redacted>'],
     [/\bBearer\s+[A-Za-z0-9._~+/=-]{8,}/gi, 'Bearer <redacted>'],
@@ -19,9 +18,9 @@ export function previousTurn(messages) {
     return { ...(user ? { user: textOf(user) } : {}), ...(assistant ? { assistant: textOf(assistant) } : {}) };
 }
 const EXPLAIN = 'Earlier conversation is shown so you can tell what the new message asks for. Rate the work the assistant must do next in response to the new message, not the earlier work.';
-/** The Jev `state` for a main-session turn (spec "Jev 判断档位"); every section is redacted, then cut. */
+/** The Jev `state`; every section is redacted, then cut. The fixed first line keeps the request bytes stable. */
 export function buildState(input) {
-    const lines = [input.previous ? `Previous user-turn tier: ${input.previous} (one tier above: ${tierAbove(input.previous)})` : 'Previous user-turn tier: none'];
+    const lines = ['Previous user-turn tier: none'];
     const context = input.prevUser !== undefined || input.prevAssistant !== undefined;
     if (context)
         lines.push(EXPLAIN);

package/lib/effort.d.ts

@@ -1,11 +1,3 @@
-export type Tier = 'simple' | 'standard' | 'complex' | 'escalated';
 export type Effort = 'low' | 'medium' | 'high' | 'xhigh' | 'max';
-export type Reason = 'jev' | 'continued' | 'no-effort-support' | 'jev-failed';
-export declare const tiers: readonly Tier[];
-/** Target effort before clamping to what the model supports (also used for sub-agents, unclamped). */
-export declare function targetEffort(model: string, tier: Tier, cap?: Effort): Effort;
-/** Undefined when the model supports none of low..xhigh: the request is then left as is. */
-export declare function mapEffort(model: string, tier: Tier, supported: readonly Effort[], cap?: Effort): Effort | undefined;
-export type ChildProvider = 'claude' | 'codex';
-/** Sub-agent models by tier (design D9); the single source for `route_subagent`. Effort comes from `targetEffort`. */
-export declare const CHILD_MODELS: Readonly<Record<ChildProvider, readonly [simple: string, standard: string, complex: string, escalated: string]>>;
+/** Closed set of the reasons the state panel shows for a main request. */
+export type Reason = 'jev' | 'no-effort-support';

package/lib/effort.js

@@ -1,31 +1 @@
-export const tiers = ['simple', 'standard', 'complex', 'escalated'];
-/** Official starting points (design D9; sources in eval/README.md). Unlisted models start at medium. */
-const STARTING_POINTS = {
-    'claude-opus-5-5': 'medium',
-    'claude-sonnet-5-5': 'medium',
-    'claude-haiku-5-5': 'medium',
-    'gpt-6.1-sol': 'medium',
-    'claude-fable-5-1': 'high',
-    'gpt-6-luna': 'high',
-    'gpt-6-astra': 'low',
-};
-const OFFSET = { simple: -1, standard: 0, complex: 1, escalated: 2 };
-/** Automatic routing never goes above xhigh: `max` stays a manual choice. */
-const automatic = ['low', 'medium', 'high', 'xhigh'];
-/** Target effort before clamping to what the model supports (also used for sub-agents, unclamped). */
-export function targetEffort(model, tier, cap = 'xhigh') {
-    const start = automatic.indexOf(STARTING_POINTS[model] ?? 'medium');
-    const ceiling = cap === 'max' ? automatic.length - 1 : automatic.indexOf(cap);
-    return automatic[Math.max(0, Math.min(ceiling, start + OFFSET[tier]))];
-}
-/** Undefined when the model supports none of low..xhigh: the request is then left as is. */
-export function mapEffort(model, tier, supported, cap = 'xhigh') {
-    const target = targetEffort(model, tier, cap);
-    const candidates = automatic.filter(effort => supported.includes(effort) && automatic.indexOf(effort) <= (cap === 'max' ? automatic.length - 1 : automatic.indexOf(cap)));
-    return candidates.filter(effort => automatic.indexOf(effort) <= automatic.indexOf(target)).at(-1) ?? candidates[0];
-}
-/** Sub-agent models by tier (design D9); the single source for `route_subagent`. Effort comes from `targetEffort`. */
-export const CHILD_MODELS = {
-    claude: ['claude-haiku-5-5', 'claude-sonnet-5-5', 'claude-opus-5-5', 'claude-opus-5-5'],
-    codex: ['gpt-6-luna', 'gpt-6.1-sol', 'gpt-6.1-sol', 'gpt-6.1-sol'],
-};
+export {};

package/lib/endpoints.d.ts

@@ -1,13 +1,14 @@
 import { type FeedbackBook } from './feedback.js';
-import type { AgentRef, Router } from './router.js';
 import type { RoutingState } from './state.js';
-import { type Tier } from './effort.js';
-import type { TurnRecord } from './judgements.js';
-export declare function endpoint(operation: 'state' | 'setMode', body: unknown, resolveAgent: (id: string) => Promise<AgentRef | undefined>, router: Router, state: RoutingState, toastOn?: () => boolean): Promise<Response>;
-export declare function observeEndpoint(body: unknown, resolveAgent: (id: string) => Promise<AgentRef | undefined>, book: FeedbackBook, warn: () => void): Promise<Response>;
-export interface LabelBook {
-    lookup(sessionId: string, messageId: string): TurnRecord | undefined;
-    label(sessionId: string, turn: number, label: Tier): void;
+/** Identity of a live session as the endpoints need it. */
+export interface AgentRef {
+    id: string;
+    origin?: string;
 }
-/** Query (no `label`) or label the judged turn a reply belongs to (design D13). */
-export declare function labelEndpoint(body: unknown, resolveAgent: (id: string) => Promise<AgentRef | undefined>, book: LabelBook, feedbackBook?: FeedbackBook): Promise<Response>;
+type Resolve = (id: string) => Promise<AgentRef | undefined>;
+/** Validates the session and applies `setMode`; the caller adds the policy host's view to the response. */
+export declare function endpoint(operation: 'state' | 'setMode', body: unknown, resolveAgent: Resolve, state: RoutingState): Promise<Response>;
+export declare function observeEndpoint(body: unknown, resolveAgent: Resolve, book: FeedbackBook, warn: () => void): Promise<Response>;
+/** Query (no `feedback`) or change the allocation feedback of a reply. Unknown keys (e.g. a retired `label`) are rejected. */
+export declare function labelEndpoint(body: unknown, resolveAgent: Resolve, book: FeedbackBook): Promise<Response>;
+export {};

package/lib/endpoints.js

@@ -1,29 +1,29 @@
 import { allocationFeedback } from './feedback.js';
-import { tiers } from './effort.js';
-export async function endpoint(operation, body, resolveAgent, router, state, toastOn = () => false) {
+const invalid = () => Response.json({ error: 'invalid request' }, { status: 400 });
+const unknown = () => Response.json({ error: 'unknown ordinary session' }, { status: 404 });
+/** Validates the session and applies `setMode`; the caller adds the policy host's view to the response. */
+export async function endpoint(operation, body, resolveAgent, state) {
     if (typeof body !== 'object' || body === null)
-        return Response.json({ error: 'invalid request' }, { status: 400 });
+        return invalid();
     const { sessionId, mode } = body;
     if (typeof sessionId !== 'string' || !sessionId || (operation === 'setMode' && mode !== 'AUTO' && mode !== 'MANUAL'))
-        return Response.json({ error: 'invalid request' }, { status: 400 });
+        return invalid();
     const agent = await resolveAgent(sessionId);
     if (!agent || agent.origin === 'subagent')
-        return Response.json({ error: 'unknown ordinary session' }, { status: 404 });
+        return unknown();
     if (operation === 'setMode')
-        router.setMode(agent, mode);
-    // The latest decision is always returned (the hover panel shows it); the switch only asks for the pop-up hint.
-    const decision = router.judgement(sessionId);
-    return Response.json({ ...state.read(sessionId), ...router.status(agent), ...(decision ? { decision } : {}), ...(toastOn() ? { decisionToast: true } : {}) });
+        state.setMode(sessionId, mode);
+    return Response.json(state.read(sessionId));
 }
 export async function observeEndpoint(body, resolveAgent, book, warn) {
     if (typeof body !== 'object' || body === null)
-        return Response.json({ error: 'invalid request' }, { status: 400 });
+        return invalid();
     const { sessionId, messageId } = body;
     if (typeof sessionId !== 'string' || !sessionId || typeof messageId !== 'string' || !messageId)
-        return Response.json({ error: 'invalid request' }, { status: 400 });
+        return invalid();
     const agent = await resolveAgent(sessionId);
     if (!agent || agent.origin === 'subagent')
-        return Response.json({ error: 'unknown ordinary session' }, { status: 404 });
+        return unknown();
     const binding = book.lookup(sessionId, messageId);
     if (binding)
         try {
@@ -34,48 +34,31 @@ export async function observeEndpoint(body, resolveAgent, book, warn) {
         }
     return Response.json({});
 }
-/** Query (no `label`) or label the judged turn a reply belongs to (design D13). */
-export async function labelEndpoint(body, resolveAgent, book, feedbackBook) {
-    if (typeof body !== 'object' || body === null)
-        return Response.json({ error: 'invalid request' }, { status: 400 });
-    const { sessionId, messageId, label } = body;
-    if (typeof sessionId !== 'string' || !sessionId || typeof messageId !== 'string' || (label !== undefined && !tiers.includes(label)))
-        return Response.json({ error: 'invalid request' }, { status: 400 });
+/** Query (no `feedback`) or change the allocation feedback of a reply. Unknown keys (e.g. a retired `label`) are rejected. */
+export async function labelEndpoint(body, resolveAgent, book) {
+    if (typeof body !== 'object' || body === null || Array.isArray(body))
+        return invalid();
+    if (Object.keys(body).some(key => !['sessionId', 'messageId', 'feedback'].includes(key)))
+        return invalid();
+    const { sessionId, messageId } = body;
+    if (typeof sessionId !== 'string' || !sessionId || typeof messageId !== 'string')
+        return invalid();
     const agent = await resolveAgent(sessionId);
     if (!agent || agent.origin === 'subagent')
-        return Response.json({ error: 'unknown ordinary session' }, { status: 404 });
+        return unknown();
     const hasFeedback = Object.hasOwn(body, 'feedback');
     const feedback = body.feedback;
-    if (hasFeedback && (label !== undefined || (feedback !== null && !allocationFeedback.includes(feedback))))
+    if (hasFeedback && feedback !== null && !allocationFeedback.includes(feedback))
         return Response.json({ error: 'invalid feedback' }, { status: 400 });
-    const allocation = feedbackBook?.lookup(sessionId, messageId);
-    if (allocation) {
-        if (label !== undefined)
-            return Response.json({ error: 'use allocation feedback' }, { status: 400 });
-        if (hasFeedback) {
-            try {
-                feedbackBook.set(sessionId, messageId, feedback);
-            }
-            catch {
-                return Response.json({ error: 'could not record feedback' }, { status: 500 });
-            }
-        }
-        return Response.json({ policy: 'policy-v2', ...feedbackBook.lookup(sessionId, messageId) });
-    }
-    if (hasFeedback)
-        return Response.json({ error: 'no applied decision' }, { status: 404 });
-    const record = book.lookup(sessionId, messageId);
-    if (!record)
-        return Response.json({});
-    const { turn, ...view } = record;
-    if (label !== undefined) {
+    if (!book.lookup(sessionId, messageId))
+        return hasFeedback ? Response.json({ error: 'no applied decision' }, { status: 404 }) : Response.json({});
+    if (hasFeedback) {
         try {
-            book.label(sessionId, turn, label);
+            book.set(sessionId, messageId, feedback);
         }
         catch {
-            return Response.json({ error: 'could not record the label' }, { status: 500 });
+            return Response.json({ error: 'could not record feedback' }, { status: 500 });
         }
-        view.label = label;
     }
-    return Response.json(view);
+    return Response.json(book.view(sessionId, messageId));
 }

package/lib/feedback.d.ts

@@ -10,8 +10,9 @@ declare const schema: z.ZodObject<{
     snapshot: z.ZodOptional<z.ZodObject<{
         decidedAt: z.ZodNumber;
         appliedAt: z.ZodNumber;
-        policyVersion: z.ZodString;
-        mappingVersion: z.ZodString;
+        strategy: z.ZodOptional<z.ZodString>;
+        policyVersion: z.ZodOptional<z.ZodString>;
+        mappingVersion: z.ZodOptional<z.ZodString>;
         decisionProvider: z.ZodString;
         decisionModel: z.ZodString;
         ms: z.ZodNumber;
@@ -32,7 +33,7 @@ declare const schema: z.ZodObject<{
 }, z.core.$strict>;
 declare const factEvent: z.ZodObject<{
     type: z.ZodLiteral<"fact">;
-    version: z.ZodLiteral<1>;
+    version: z.ZodOptional<z.ZodLiteral<1>>;
     sessionId: z.ZodString;
     decisionId: z.ZodNumber;
     fact: z.ZodEnum<{
@@ -60,13 +61,14 @@ export declare class FeedbackBook {
         snapshot?: {
             decidedAt: number;
             appliedAt: number;
-            policyVersion: string;
-            mappingVersion: string;
             decisionProvider: string;
             decisionModel: string;
             ms: number;
             provider: string;
             requestSeq: number;
+            strategy?: string | undefined;
+            policyVersion?: string | undefined;
+            mappingVersion?: string | undefined;
             confidence?: number | undefined;
             probabilities?: Record<string, number> | undefined;
             requestTurn?: number | undefined;
@@ -75,6 +77,56 @@ export declare class FeedbackBook {
         feedback?: "appropriate" | "too-high" | "too-low" | "unknown" | null | undefined;
         feedbackAt?: number | undefined;
     } | undefined;
+    /** The binding as the `label` endpoint returns it: historical snapshot keys are left out, nothing is inferred. */
+    view(sessionId: string, messageId: string): {
+        sessionId: string;
+        messageId: string;
+        decisionId: number;
+        depth: string;
+        model: string;
+        effort: string;
+        snapshot?: {
+            decidedAt: number;
+            appliedAt: number;
+            decisionProvider: string;
+            decisionModel: string;
+            ms: number;
+            provider: string;
+            requestSeq: number;
+            strategy?: string | undefined;
+            policyVersion?: string | undefined;
+            mappingVersion?: string | undefined;
+            confidence?: number | undefined;
+            probabilities?: Record<string, number> | undefined;
+            requestTurn?: number | undefined;
+        } | undefined;
+        boundAt?: number | undefined;
+        feedback?: "appropriate" | "too-high" | "too-low" | "unknown" | null | undefined;
+        feedbackAt?: number | undefined;
+    } | {
+        snapshot: {
+            decidedAt: number;
+            appliedAt: number;
+            decisionProvider: string;
+            decisionModel: string;
+            ms: number;
+            provider: string;
+            requestSeq: number;
+            strategy?: string | undefined;
+            confidence?: number | undefined;
+            probabilities?: Record<string, number> | undefined;
+            requestTurn?: number | undefined;
+        };
+        sessionId: string;
+        messageId: string;
+        decisionId: number;
+        depth: string;
+        model: string;
+        effort: string;
+        boundAt?: number | undefined;
+        feedback?: "appropriate" | "too-high" | "too-low" | "unknown" | null | undefined;
+        feedbackAt?: number | undefined;
+    } | undefined;
     /** All folded bindings in file order (read-only; used by the usage report). */
     entries(): {
         sessionId: string;
@@ -86,13 +138,14 @@ export declare class FeedbackBook {
         snapshot?: {
             decidedAt: number;
             appliedAt: number;
-            policyVersion: string;
-            mappingVersion: string;
             decisionProvider: string;
             decisionModel: string;
             ms: number;
             provider: string;
             requestSeq: number;
+            strategy?: string | undefined;
+            policyVersion?: string | undefined;
+            mappingVersion?: string | undefined;
             confidence?: number | undefined;
             probabilities?: Record<string, number> | undefined;
             requestTurn?: number | undefined;

package/lib/feedback.js

@@ -3,15 +3,17 @@ import { dirname } from 'node:path';
 import { z } from 'zod';
 export const allocationFeedback = ['appropriate', 'too-high', 'too-low', 'unknown'];
 const probability = z.number().min(0).max(1);
+// `policyVersion`/`mappingVersion` exist only on bindings written before 0.5.0; new ones carry `strategy`.
 const snapshot = z.object({
-    decidedAt: z.number(), appliedAt: z.number(), policyVersion: z.string(), mappingVersion: z.string(),
+    decidedAt: z.number(), appliedAt: z.number(), strategy: z.string().optional(), policyVersion: z.string().optional(), mappingVersion: z.string().optional(),
     decisionProvider: z.string(), decisionModel: z.string(), ms: z.number(),
     confidence: probability.optional(), probabilities: z.record(z.string(), probability).optional(),
     provider: z.string(), requestSeq: z.number(), requestTurn: z.number().optional(),
 }).strict();
 const schema = z.object({ sessionId: z.string(), messageId: z.string(), decisionId: z.number(), depth: z.string(), model: z.string(), effort: z.string(), snapshot: snapshot.optional(), boundAt: z.number().optional(), feedback: z.enum(allocationFeedback).nullable().optional(), feedbackAt: z.number().optional() }).strict();
-const feedbackEvent = z.object({ type: z.literal('feedback'), version: z.literal(2), sessionId: z.string(), messageId: z.string(), decisionId: z.number(), at: z.number(), feedback: z.enum(allocationFeedback).nullable() }).strict();
-const factEvent = z.object({ type: z.literal('fact'), version: z.literal(1), sessionId: z.string().min(1), decisionId: z.number(), fact: z.enum(['exposed', 'manual-switch']), at: z.number().finite() }).strict();
+// Older events carried `version` (feedback 2, fact 1); new events have none.
+const feedbackEvent = z.object({ type: z.literal('feedback'), version: z.literal(2).optional(), sessionId: z.string(), messageId: z.string(), decisionId: z.number(), at: z.number(), feedback: z.enum(allocationFeedback).nullable() }).strict();
+const factEvent = z.object({ type: z.literal('fact'), version: z.literal(1).optional(), sessionId: z.string().min(1), decisionId: z.number(), fact: z.enum(['exposed', 'manual-switch']), at: z.number().finite() }).strict();
 /** Immutable decision bindings and separate feedback events; never includes task text or credentials. */
 export class FeedbackBook {
     file;
@@ -62,6 +64,14 @@ export class FeedbackBook {
     }
     key(sessionId, messageId) { return JSON.stringify([sessionId, messageId]); }
     lookup(sessionId, messageId) { const r = this.records.get(this.key(sessionId, messageId)); return r && structuredClone(r); }
+    /** The binding as the `label` endpoint returns it: historical snapshot keys are left out, nothing is inferred. */
+    view(sessionId, messageId) {
+        const r = this.lookup(sessionId, messageId);
+        if (!r?.snapshot)
+            return r;
+        const { policyVersion: _p, mappingVersion: _m, ...snapshot } = r.snapshot;
+        return { ...r, snapshot };
+    }
     /** All folded bindings in file order (read-only; used by the usage report). */
     entries() { return [...this.records.values()].map(r => structuredClone(r)); }
     bind(record) { if (this.lookup(record.sessionId, record.messageId))
@@ -70,7 +80,7 @@ export class FeedbackBook {
         const r = this.lookup(sessionId, messageId);
         if (!r)
             throw Error('No applied decision');
-        const event = feedbackEvent.parse({ type: 'feedback', version: 2, sessionId, messageId, decisionId: r.decisionId, at: Date.now(), feedback });
+        const event = feedbackEvent.parse({ type: 'feedback', sessionId, messageId, decisionId: r.decisionId, at: Date.now(), feedback });
         this.append(event);
         this.records.set(this.key(sessionId, messageId), { ...r, feedback, feedbackAt: event.at });
     }
@@ -80,7 +90,7 @@ export class FeedbackBook {
         const facts = this.factRecords.get(key) ?? {};
         if (facts[fact] !== undefined)
             return;
-        const event = factEvent.parse({ type: 'fact', version: 1, sessionId, decisionId, fact, at: Date.now() });
+        const event = factEvent.parse({ type: 'fact', sessionId, decisionId, fact, at: Date.now() });
         this.append(event);
         this.factRecords.set(key, { ...facts, [fact]: event.at });
     }

package/lib/index.d.ts

@@ -1,10 +1,14 @@
 import type { Context } from '@deepseek-ai/cordis';
+import { type FamilyStrategy } from './strategies/index.js';
 export declare const name = "dsh-auto-model-routing";
+/** Child decision records. The historical directory name is kept on purpose: records are not migrated. */
+export declare const CHILD_DECISIONS_DIR = "state/auto-model-routing/policy-v2";
 export declare const inject: string[];
 /** Test seams only; production uses the defaults. */
 export interface Config {
     home?: string;
     jevBase?: string;
     jevTimeoutMs?: number;
+    strategies?: readonly FamilyStrategy[];
 }
 export declare function apply(ctx: Context, config?: Config): void;

package/lib/index.js

@@ -3,54 +3,41 @@ import { SettingsStore } from './settings.js';
 import { settingsHost } from './settings-host.js';
 import { homedir } from 'node:os';
 import { FileStateStore, RoutingState } from './state.js';
-import { Router } from './router.js';
 import { endpoint, labelEndpoint, observeEndpoint } from './endpoints.js';
 import { FeedbackBook } from './feedback.js';
-import { JudgementBook } from './judgements.js';
-import { userInput } from './input.js';
-import { JevClient, rubricVersion } from './jev.js';
+import { JevClient } from './jev.js';
 import { routeSubagentTool } from './subagent-tool.js';
-import { buildState, previousTurn } from './context.js';
 import { policyHost } from './policy-host.js';
 import { PolicyStore } from './policy-store.js';
 import { currentMainSelection, mainSupported } from './support.js';
+import { createRegistry, registry as builtin } from './strategies/index.js';
 export const name = 'dsh-auto-model-routing';
+/** Child decision records. The historical directory name is kept on purpose: records are not migrated. */
+export const CHILD_DECISIONS_DIR = 'state/auto-model-routing/policy-v2';
 export const inject = ['llm', 'agents', 'tools'];
-const knownEfforts = new Set(['low', 'medium', 'high', 'xhigh', 'max']);
 export function apply(ctx, config = {}) {
     const home = config.home ?? process.env.DSH_HOME ?? resolve(homedir(), '.dsh');
+    const registry = config.strategies ? createRegistry(config.strategies) : builtin;
     const settings = new SettingsStore(resolve(home, 'plugins/dsh-auto-model-routing/config.json'));
-    const hostSettings = settingsHost(ctx, settings);
+    const hostSettings = settingsHost(ctx, settings, registry);
     const jev = new JevClient({ get: hostSettings.credential }, config.jevBase, config.jevTimeoutMs ?? (() => settings.read().settings.jevTimeoutMs), config.jevBase ? undefined : () => settings.read().settings.decisionService);
     const stateFiles = new FileStateStore(resolve(home, 'state/auto-model-routing/sessions'));
     const state = new RoutingState(stateFiles);
-    const book = new JudgementBook(resolve(home, 'state/auto-model-routing/judgements.jsonl'));
-    const router = new Router(state, (sessionId, turn, tier, model, effort) => {
-        const line = { sessionId, turn, tier, ...(effort ? { effort } : {}), model, rubricVersion };
-        book.judged(line);
-        // Recording is best effort: a failed append never touches the request or the mode.
-        try {
-            book.append(line);
-        }
-        catch (error) {
-            ctx.logger.warn(`auto-model-routing: could not record the judgement: ${String(error)}`);
-        }
-    }, () => settings.read().settings);
     const feedback = new FeedbackBook(resolve(home, 'state/auto-model-routing/allocation-feedback.jsonl'));
     // Official writer is available only while the session controller is mounted.
     let selectModel;
     const policy = policyHost(ctx, { feedback, jev, state, selectModel: async (request) => { if (!selectModel)
-            throw new Error('session controller is unavailable'); await selectModel(request); }, store: new PolicyStore(resolve(home, 'state/auto-model-routing/policy-v2')), settings: () => settings.read().settings, catalog: () => hostSettings.catalog(true) });
+            throw new Error('session controller is unavailable'); await selectModel(request); }, store: new PolicyStore(resolve(home, CHILD_DECISIONS_DIR), registry), settings: () => settings.read().settings, catalog: () => hostSettings.catalog(), registry });
     const toastOn = () => settings.read().settings.decisionToast;
-    ctx.effect(() => ctx.tools.register(routeSubagentTool(jev, { agents: ctx.agents, state, readSettings: () => settings.read().settings, catalog: hostSettings.catalog, judged: (sessionId, value) => router.judged(sessionId, value) })));
+    ctx.effect(() => ctx.tools.register(routeSubagentTool(jev, { agents: ctx.agents, state, readSettings: () => settings.read().settings, catalog: hostSettings.catalog, registry })));
     ctx.on('agent/created', ({ agent, source }) => {
         // Factory resume announces `resume`; a nonzero initial seed also excludes restored/forked histories.
         if (source !== 'startup' || agent.session.header.origin === 'subagent' || agent.session.firstLiveSeq !== 0 || agent.session.header.isSeeded || agent.session.snapshotEvents().some(event => event.type === 'session/end-seed') || stateFiles.get(agent.id))
             return;
         if (settings.read().settings.defaultMode !== 'AUTO')
             return;
-        // A new session whose default main model is outside AUTO's Claude/GPT scope starts in MANUAL.
-        if (!mainSupported(currentMainSelection(ctx, agent)))
+        // A new session whose default main model is outside AUTO's registered families starts in MANUAL.
+        if (!mainSupported(currentMainSelection(ctx, agent), registry))
             return;
         state.setMode(agent.id, 'AUTO');
         return undefined;
@@ -65,62 +52,6 @@ export function apply(ctx, config = {}) {
         }
         return value;
     };
-    ctx.on('agent/pre-step', async (payload, next) => {
-        const decision = await next();
-        // Judge only steps that actually enter, using the messages that enter (a rejected step sends nothing).
-        if (settings.read().settings.policy === 'policy-v2' || payload.step !== 1 || decision.kind !== 'enter')
-            return decision;
-        const agent = ref(payload.agent);
-        if (agent.origin !== 'subagent' && userInput(decision.messages).userTurn)
-            book.userTurn(agent.id, payload.turn);
-        const job = router.begin(agent, payload.turn, decision.messages);
-        if (!job)
-            return decision;
-        // History before this turn's messages enter: the previous user message and assistant reply.
-        const prior = previousTurn(payload.agent.session.deriveMessages());
-        const result = await jev.judge(buildState({ previous: job.previous, prevUser: prior.user, prevAssistant: prior.assistant, text: job.text }), payload.signal);
-        if (result.kind === 'ok') {
-            const { kind: _, tier, ...measure } = result;
-            router.resolve(agent, payload.turn, tier, measure);
-        }
-        else if (result.kind === 'failed')
-            router.fail(agent, payload.turn, result.category);
-        else
-            router.cancel(agent, payload.turn);
-        return decision;
-    });
-    // Reply → user turn, for the reply-bar tier button (memory only; empty after a restart).
-    ctx.on('session/event', (session, event) => {
-        if (event.type !== 'assistant/message')
-            return;
-        const data = event.data;
-        book.assistant(session.id, data.message.id, data.turn);
-    });
-    // Official selection writer, set while the session controller is available.
-    const inflight = new Map();
-    ctx.on('agent/request', async (payload, next) => {
-        const config = await next();
-        if (settings.read().settings.policy === 'policy-v2' || payload.agent.session.header.origin === 'subagent')
-            return config;
-        const model = router.needsModelInfo(ref(payload.agent)) ? await ctx.llm.resolveModelInfo(config.provider, config.model, payload.signal) : undefined;
-        const efforts = (model?.reasoning?.efforts ?? []).map(effort => effort.id).filter(id => knownEfforts.has(id));
-        const catalog = model && settings.read().settings.mainEfforts ? await hostSettings.catalog() : undefined;
-        const routed = router.request(ref(payload.agent), payload.turn, config, efforts, catalog);
-        // AUTO moved the effort away from the official selection: make that selection (and the picker) carry it.
-        // `config` is the official selection for this request, so a user pick made since the last sync is caught too.
-        // Not awaited and never fatal; `inflight` only stops repeat calls before the first one lands.
-        if (selectModel && routed.reasoningEffort && routed.reasoningEffort !== config.reasoningEffort) {
-            const key = `${routed.provider}\0${routed.model}\0${routed.reasoningEffort}`;
-            if (inflight.get(payload.agent.id) !== key) {
-                inflight.set(payload.agent.id, key);
-                selectModel({ sessionId: payload.agent.id, provider: routed.provider, model: routed.model, reasoningEffort: routed.reasoningEffort })
-                    .catch(error => ctx.logger.warn(`auto-model-routing: could not sync the model selection: ${String(error)}`))
-                    .finally(() => { if (inflight.get(payload.agent.id) === key)
-                    inflight.delete(payload.agent.id); });
-            }
-        }
-        return routed;
-    }, { prepend: true });
     ctx.inject(['sessionController'], child => {
         selectModel = request => child.sessionController.selectModel(request);
         child.effect(() => () => { selectModel = undefined; });
@@ -164,12 +95,12 @@ export function apply(ctx, config = {}) {
                     }
                     const response = operation === 'childRouting'
                         ? (typeof payload?.sessionId === 'string'
-                            ? Response.json(policy.status(payload.sessionId) ?? { status: 'unsupported', reason: '没有已绑定的 policy-v2 决策' })
+                            ? Response.json(policy.status(payload.sessionId) ?? { status: 'unsupported', reason: '没有已绑定的子任务决策' })
                             : Response.json({ error: 'invalid request' }, { status: 400 }))
                         : operation === 'settings' || operation === 'saveSettings' || operation === 'setKey' || operation === 'testDecision'
                             ? await hostSettings.endpoint(operation, payload)
                             : operation === 'observe' ? await observeEndpoint(payload, resolveAgent, feedback, () => ctx.logger.warn('auto-model-routing: could not record exposure'))
-                                : operation === 'label' ? await labelEndpoint(payload, resolveAgent, book, feedback) : await endpoint(operation, payload, resolveAgent, router, state, toastOn);
+                                : operation === 'label' ? await labelEndpoint(payload, resolveAgent, feedback) : await endpoint(operation, payload, resolveAgent, state);
                     if (manualDecision && response.ok) {
                         try {
                             feedback.fact(manualDecision.sessionId, manualDecision.decisionId, 'manual-switch');
@@ -178,20 +109,20 @@ export function apply(ctx, config = {}) {
                             ctx.logger.warn('auto-model-routing: could not record MANUAL switch');
                         }
                     }
-                    if ((operation === 'state' || operation === 'setMode') && response.ok && settings.read().settings.policy === 'policy-v2') {
+                    if ((operation === 'state' || operation === 'setMode') && response.ok) {
                         const sessionId = payload.sessionId;
                         const agent = await resolveSessionAgent(sessionId).catch(() => undefined);
                         const selection = agent ? currentMainSelection(ctx, agent) : undefined;
-                        const supported = mainSupported(selection);
-                        // Leaving AUTO is persisted: a pick outside the Claude/GPT scope must not keep judging turns.
+                        const supported = mainSupported(selection, registry);
+                        // Leaving AUTO is persisted: a pick outside the registered families must not keep judging turns.
                         if (!supported && state.read(sessionId).mode === 'AUTO') {
                             state.setMode(sessionId, 'MANUAL');
                             policy.invalidate(sessionId);
                         }
                         const value = await response.json();
                         const main = policy.mainStatus(sessionId);
-                        const { decision: _legacyDecision, effort: _legacyEffort, reason: _legacyReason, history: _legacyHistory, ...base } = value;
-                        const result = { ...base, mode: state.read(sessionId).mode, history: [], policy: 'policy-v2', ...main, autoSupport: { supported, ...(selection ? { provider: selection.provider, model: selection.model } : {}) } };
+                        const { previous: _previous, ...persisted } = value;
+                        const result = { ...persisted, mode: state.read(sessionId).mode, ...main, ...(toastOn() ? { decisionToast: true } : {}), autoSupport: { supported, ...(selection ? { provider: selection.provider, model: selection.model } : {}) } };
                         return Response.json(enveloped ? { type: 'server-response', rpcId: wire.rpcId, result: { ok: true, value: result } } : result);
                     }
                     if (!enveloped)