dsh-auto-model-routing 0.3.0 → 0.4.0

package/lib/decision-service.d.ts

@@ -0,0 +1,39 @@
+export declare const DECISION_SERVICES: {
+    readonly openrouter: {
+        readonly label: "OpenRouter";
+        readonly endpoint: "https://openrouter.ai/api/alpha/decisions";
+        readonly model: "typesafe/jev-1.13";
+        readonly credential: "OPENROUTER_API_KEY";
+    };
+    readonly typesafe: {
+        readonly label: "TypeSafe 官方";
+        readonly endpoint: "https://api.typesafe.ai/v1/systemone";
+        readonly model: "jev-1.13.0";
+        readonly credential: "TYPESAFE_API_KEY";
+    };
+    readonly concentrate: {
+        readonly label: "Concentrate";
+        readonly endpoint: "https://api.concentrate.ai/v1/systemone";
+        readonly model: "jev-1.13.0";
+        readonly credential: "CONCENTRATE_API_KEY";
+    };
+    readonly custom: {
+        readonly label: "自定义 System One";
+        readonly endpoint: "";
+        readonly model: "jev-1.13.0";
+        readonly credential: "AUTO_DECISION_CUSTOM_API_KEY";
+    };
+};
+export type DecisionProvider = keyof typeof DECISION_SERVICES;
+export interface DecisionConfig {
+    provider: DecisionProvider;
+    model?: string | undefined;
+    endpoint?: string | undefined;
+}
+export declare function validDecisionEndpoint(value: string): boolean;
+export declare function resolveDecisionService(config?: DecisionConfig): {
+    provider: "openrouter" | "typesafe" | "concentrate" | "custom";
+    endpoint: string;
+    model: string;
+    credential: "OPENROUTER_API_KEY" | "TYPESAFE_API_KEY" | "CONCENTRATE_API_KEY" | "AUTO_DECISION_CUSTOM_API_KEY";
+};

package/lib/decision-service.js

@@ -0,0 +1,28 @@
+export const DECISION_SERVICES = {
+    openrouter: { label: 'OpenRouter', endpoint: 'https://openrouter.ai/api/alpha/decisions', model: 'typesafe/jev-1.13', credential: 'OPENROUTER_API_KEY' },
+    typesafe: { label: 'TypeSafe 官方', endpoint: 'https://api.typesafe.ai/v1/systemone', model: 'jev-1.13.0', credential: 'TYPESAFE_API_KEY' },
+    concentrate: { label: 'Concentrate', endpoint: 'https://api.concentrate.ai/v1/systemone', model: 'jev-1.13.0', credential: 'CONCENTRATE_API_KEY' },
+    custom: { label: '自定义 System One', endpoint: '', model: 'jev-1.13.0', credential: 'AUTO_DECISION_CUSTOM_API_KEY' },
+};
+export function validDecisionEndpoint(value) {
+    try {
+        const u = new URL(value);
+        return !u.username && !u.password && !u.search && !u.hash && (u.protocol === 'https:' || (u.protocol === 'http:' && ['127.0.0.1', 'localhost', '[::1]'].includes(u.hostname)));
+    }
+    catch {
+        return false;
+    }
+}
+export function resolveDecisionService(config) {
+    const provider = config?.provider ?? 'openrouter';
+    const preset = DECISION_SERVICES[provider];
+    if (!preset)
+        throw new Error('Unknown decision service');
+    const endpoint = provider === 'custom' ? config?.endpoint ?? '' : preset.endpoint;
+    if (!validDecisionEndpoint(endpoint))
+        throw new Error('Invalid decision endpoint');
+    const model = config?.model ?? preset.model;
+    if (!/^[A-Za-z0-9._:/~-]{1,128}$/.test(model))
+        throw new Error('Invalid decision model');
+    return { provider, endpoint, model, credential: preset.credential };
+}

package/lib/endpoints.d.ts

@@ -1,3 +1,4 @@
+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';
@@ -8,4 +9,4 @@ export interface LabelBook {
     label(sessionId: string, turn: number, label: Tier): void;
 }
 /** 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): Promise<Response>;
+export declare function labelEndpoint(body: unknown, resolveAgent: (id: string) => Promise<AgentRef | undefined>, book: LabelBook, feedbackBook?: FeedbackBook): Promise<Response>;

package/lib/endpoints.js

@@ -1,3 +1,4 @@
+import { allocationFeedback } from './feedback.js';
 import { tiers } from './effort.js';
 export async function endpoint(operation, body, resolveAgent, router, state, toastOn = () => false) {
     if (typeof body !== 'object' || body === null)
@@ -15,7 +16,7 @@ export async function endpoint(operation, body, resolveAgent, router, state, toa
     return Response.json({ ...state.read(sessionId), ...router.status(agent), ...(decision ? { decision } : {}), ...(toastOn() ? { decisionToast: true } : {}) });
 }
 /** Query (no `label`) or label the judged turn a reply belongs to (design D13). */
-export async function labelEndpoint(body, resolveAgent, book) {
+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;
@@ -24,6 +25,26 @@ export async function labelEndpoint(body, resolveAgent, book) {
     const agent = await resolveAgent(sessionId);
     if (!agent || agent.origin === 'subagent')
         return Response.json({ error: 'unknown ordinary session' }, { status: 404 });
+    const hasFeedback = Object.hasOwn(body, 'feedback');
+    const feedback = body.feedback;
+    if (hasFeedback && (label !== undefined || (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({});

package/lib/feedback.d.ts

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+export declare const allocationFeedback: readonly ["appropriate", "too-high", "too-low", "unknown"];
+declare const schema: z.ZodObject<{
+    sessionId: z.ZodString;
+    messageId: z.ZodString;
+    decisionId: z.ZodNumber;
+    depth: z.ZodString;
+    model: z.ZodString;
+    effort: z.ZodString;
+    snapshot: z.ZodOptional<z.ZodObject<{
+        decidedAt: z.ZodNumber;
+        appliedAt: z.ZodNumber;
+        policyVersion: z.ZodString;
+        mappingVersion: z.ZodString;
+        decisionProvider: z.ZodString;
+        decisionModel: z.ZodString;
+        ms: z.ZodNumber;
+        confidence: z.ZodOptional<z.ZodNumber>;
+        probabilities: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        provider: z.ZodString;
+        requestSeq: z.ZodNumber;
+        requestTurn: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    boundAt: z.ZodOptional<z.ZodNumber>;
+    feedback: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        appropriate: "appropriate";
+        "too-high": "too-high";
+        "too-low": "too-low";
+        unknown: "unknown";
+    }>>>;
+    feedbackAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type FeedbackRecord = z.infer<typeof schema>;
+/** Immutable decision bindings and separate feedback events; never includes task text or credentials. */
+export declare class FeedbackBook {
+    private file;
+    private records;
+    constructor(file: string);
+    private key;
+    lookup(sessionId: string, messageId: string): {
+        sessionId: string;
+        messageId: string;
+        decisionId: number;
+        depth: string;
+        model: string;
+        effort: string;
+        snapshot?: {
+            decidedAt: number;
+            appliedAt: number;
+            policyVersion: string;
+            mappingVersion: string;
+            decisionProvider: string;
+            decisionModel: string;
+            ms: number;
+            provider: string;
+            requestSeq: number;
+            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;
+    } | undefined;
+    bind(record: FeedbackRecord): void;
+    set(sessionId: string, messageId: string, feedback: typeof allocationFeedback[number] | null): void;
+    private append;
+}
+export {};

package/lib/feedback.js

@@ -0,0 +1,65 @@
+import { appendFileSync, mkdirSync, readFileSync } from 'node:fs';
+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);
+const snapshot = z.object({
+    decidedAt: z.number(), appliedAt: z.number(), policyVersion: z.string(), mappingVersion: z.string(),
+    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();
+/** Immutable decision bindings and separate feedback events; never includes task text or credentials. */
+export class FeedbackBook {
+    file;
+    records = new Map();
+    constructor(file) {
+        this.file = file;
+        let text;
+        try {
+            text = readFileSync(file, 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return;
+            throw error;
+        }
+        for (const line of text.split('\n'))
+            try {
+                const raw = JSON.parse(line);
+                const event = feedbackEvent.safeParse(raw);
+                if (event.success) {
+                    const e = event.data;
+                    const key = this.key(e.sessionId, e.messageId);
+                    const r = this.records.get(key);
+                    if (r?.decisionId === e.decisionId)
+                        this.records.set(key, { ...r, feedback: e.feedback, feedbackAt: e.at });
+                    continue;
+                }
+                const r = schema.parse(raw);
+                const key = this.key(r.sessionId, r.messageId);
+                const existing = this.records.get(key);
+                // Old full-record feedback lines remain readable, but cannot replace the original decision.
+                if (!existing)
+                    this.records.set(key, r);
+                else if (existing.decisionId === r.decisionId && Object.hasOwn(r, 'feedback'))
+                    this.records.set(key, { ...existing, feedback: r.feedback });
+            }
+            catch { /* incomplete/corrupt lines cannot create a binding */ }
+    }
+    key(sessionId, messageId) { return JSON.stringify([sessionId, messageId]); }
+    lookup(sessionId, messageId) { const r = this.records.get(this.key(sessionId, messageId)); return r && structuredClone(r); }
+    bind(record) { if (this.lookup(record.sessionId, record.messageId))
+        return; const r = schema.parse({ ...record, boundAt: Date.now() }); this.append(r); this.records.set(this.key(r.sessionId, r.messageId), r); }
+    set(sessionId, messageId, feedback) {
+        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 });
+        this.append(event);
+        this.records.set(this.key(sessionId, messageId), { ...r, feedback, feedbackAt: event.at });
+    }
+    append(record) { mkdirSync(dirname(this.file), { recursive: true }); appendFileSync(this.file, JSON.stringify(record) + '\n', { mode: 0o600 }); }
+}

package/lib/hints.js

@@ -1,6 +1,6 @@
 /** Human-readable hint per category, shown on the chip, panel and tool errors. */
 export const CATEGORY_HINTS = {
-    'missing-credential': '未配置 OPENROUTER_API_KEY',
+    'missing-credential': '未配置所选决策服务的 API key',
     'insufficient-credits': '余额不足，请充值',
     unauthorized: 'key 无效或无权限',
     'rate-limited': '请求被限流',

package/lib/index.js

@@ -5,11 +5,14 @@ import { homedir } from 'node:os';
 import { FileStateStore, RoutingState } from './state.js';
 import { Router } from './router.js';
 import { endpoint, labelEndpoint } 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 { routeSubagentTool } from './subagent-tool.js';
 import { buildState, previousTurn } from './context.js';
+import { policyHost } from './policy-host.js';
+import { PolicyStore } from './policy-store.js';
 export const name = 'dsh-auto-model-routing';
 export const inject = ['llm', 'agents', 'tools'];
 const knownEfforts = new Set(['low', 'medium', 'high', 'xhigh', 'max']);
@@ -17,7 +20,7 @@ export function apply(ctx, config = {}) {
     const home = config.home ?? process.env.DSH_HOME ?? resolve(homedir(), '.dsh');
     const settings = new SettingsStore(resolve(home, 'plugins/dsh-auto-model-routing/config.json'));
     const hostSettings = settingsHost(ctx, settings);
-    const jev = new JevClient({ get: hostSettings.credential }, config.jevBase, config.jevTimeoutMs ?? (() => settings.read().settings.jevTimeoutMs));
+    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'));
@@ -32,6 +35,8 @@ export function apply(ctx, config = {}) {
             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'));
+    const policy = policyHost(ctx, { feedback, jev, state, store: new PolicyStore(resolve(home, 'state/auto-model-routing/policy-v2')), settings: () => settings.read().settings, catalog: () => hostSettings.catalog(true) });
     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.on('agent/created', ({ agent, source }) => {
@@ -55,7 +60,7 @@ export function apply(ctx, config = {}) {
     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 (payload.step !== 1 || decision.kind !== 'enter')
+        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)
@@ -88,7 +93,7 @@ export function apply(ctx, config = {}) {
     const inflight = new Map();
     ctx.on('agent/request', async (payload, next) => {
         const config = await next();
-        if (payload.agent.session.header.origin === 'subagent')
+        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));
@@ -114,7 +119,7 @@ export function apply(ctx, config = {}) {
         child.effect(() => () => { selectModel = undefined; });
     });
     ctx.inject(['connection', 'sessionController'], child => {
-        for (const operation of ['state', 'setMode', 'label', 'settings', 'saveSettings', 'setKey']) {
+        for (const operation of ['state', 'setMode', 'label', 'settings', 'saveSettings', 'setKey', 'testDecision', 'childRouting']) {
             child.effect(() => child.connection.fetch.register({
                 path: `/api/auto-model-routing.${operation}`,
                 methods: ['POST'], requestBody: 'buffered',
@@ -135,9 +140,26 @@ export function apply(ctx, config = {}) {
                         return 'agent' in result ? ref(result.agent) : undefined;
                     };
                     const payload = enveloped ? wire.payload : body;
-                    const response = operation === 'settings' || operation === 'saveSettings' || operation === 'setKey'
-                        ? await hostSettings.endpoint(operation, payload)
-                        : operation === 'label' ? await labelEndpoint(payload, resolveAgent, book) : await endpoint(operation, payload, resolveAgent, router, state, toastOn);
+                    if (operation === 'setMode' && typeof payload?.sessionId === 'string') {
+                        const id = payload.sessionId;
+                        const mode = payload.mode;
+                        if ((mode === 'AUTO' || mode === 'MANUAL') && state.read(id).mode !== mode && await resolveAgent(id))
+                            policy.invalidate(id);
+                    }
+                    const response = operation === 'childRouting'
+                        ? (typeof payload?.sessionId === 'string'
+                            ? Response.json(policy.status(payload.sessionId) ?? { status: 'unsupported', reason: '没有已绑定的 policy-v2 决策' })
+                            : Response.json({ error: 'invalid request' }, { status: 400 }))
+                        : operation === 'settings' || operation === 'saveSettings' || operation === 'setKey' || operation === 'testDecision'
+                            ? await hostSettings.endpoint(operation, payload)
+                            : operation === 'label' ? await labelEndpoint(payload, resolveAgent, book, feedback) : await endpoint(operation, payload, resolveAgent, router, state, toastOn);
+                    if ((operation === 'state' || operation === 'setMode') && response.ok && settings.read().settings.policy === 'policy-v2') {
+                        const value = await response.json();
+                        const main = policy.mainStatus(payload.sessionId);
+                        const { decision: _legacyDecision, effort: _legacyEffort, reason: _legacyReason, history: _legacyHistory, ...base } = value;
+                        const result = { ...base, history: [], policy: 'policy-v2', ...main };
+                        return Response.json(enveloped ? { type: 'server-response', rpcId: wire.rpcId, result: { ok: true, value: result } } : result);
+                    }
                     if (!enveloped)
                         return response;
                     const value = await response.json();

package/lib/jev.d.ts

@@ -1,4 +1,27 @@
+import { type DecisionConfig } from './decision-service.js';
+export interface PolicyMeasure {
+    ms: number;
+    decisionProvider: string;
+    decisionModel: string;
+    confidence?: number;
+    probabilities?: Record<string, number>;
+    capabilityConfidence?: number;
+    capabilityProbabilities?: Record<string, number>;
+}
 import { type Tier } from './effort.js';
+export type Depth = 'lower' | 'baseline' | 'higher';
+export type Capability = 'bounded' | 'analytical' | 'frontier';
+export type PolicyResult = ({
+    kind: 'ok';
+    depth: Depth;
+    capability?: Capability | 'insufficient_context';
+} & PolicyMeasure) | {
+    kind: 'failed';
+    category: JevCategory;
+} | {
+    kind: 'cancelled';
+};
+export declare const policyVersion: string;
 import type { JevCategory } from './hints.js';
 export { CATEGORY_HINTS, type JevCategory } from './hints.js';
 export type Distribution = Partial<Record<Tier, number>>;
@@ -41,9 +64,12 @@ export declare function tierAbove(tier: Tier): Tier;
 export declare class JevClient {
     private readonly env;
     private readonly timeoutMs;
+    private readonly service?;
     readonly url: string;
-    constructor(env: CredentialSource, base?: string, timeoutMs?: number | (() => number));
+    constructor(env: CredentialSource, base?: string, timeoutMs?: number | (() => number), service?: (() => DecisionConfig | undefined) | undefined);
     /** One request, no retry. Never throws; never returns the body or the key. */
     /** `state` is assembled and redacted by the caller (`buildState`). */
     judge(state: string, signal: AbortSignal): Promise<JevResult>;
+    judgePolicy(state: string, signal: AbortSignal, scope: 'main' | 'child', dimensions?: 'both' | 'capability' | 'depth'): Promise<PolicyResult>;
+    private decide;
 }

package/lib/jev.js

@@ -1,8 +1,12 @@
 import { createHash } from 'node:crypto';
+import { resolveDecisionService } from './decision-service.js';
+const probability = (value) => typeof value === 'number' && Number.isFinite(value) && value >= 0 && value <= 1;
+const distribution = (value) => Object.fromEntries(Object.entries(value ?? {}).filter(([, v]) => probability(v)));
 import { tiers } from './effort.js';
 import rubric from './rubric.json' with { type: 'json' };
+import policyQuestions from './policy-v2-rubric.json' with { type: 'json' };
+export const policyVersion = `policy-v2-${createHash('sha256').update(JSON.stringify(policyQuestions)).digest('hex').slice(0, 8)}`;
 export { CATEGORY_HINTS } from './hints.js';
-const MODEL = 'typesafe/jev-1.13';
 const MAX_BODY = 64 * 1024;
 /** Shared by the main session and `route_subagent`; only `state` differs (design D4). Single source: rubric.json. */
 export const TIER_QUESTIONS = rubric;
@@ -26,15 +30,54 @@ function byStatus(status) {
 export class JevClient {
     env;
     timeoutMs;
+    service;
     url;
-    constructor(env, base = 'https://openrouter.ai', timeoutMs = 3000) {
+    constructor(env, base = 'https://openrouter.ai', timeoutMs = 3000, service) {
         this.env = env;
         this.timeoutMs = timeoutMs;
+        this.service = service;
         this.url = `${base}/api/alpha/decisions`;
     }
     /** One request, no retry. Never throws; never returns the body or the key. */
     /** `state` is assembled and redacted by the caller (`buildState`). */
     async judge(state, signal) {
+        const result = await this.decide(state, signal, TIER_QUESTIONS);
+        if (result.kind !== 'ok')
+            return result;
+        const answer = result.answers?.tier;
+        const choice = answer?.choice;
+        if (!tiers.includes(choice))
+            return { kind: 'failed', category: 'invalid-response' };
+        const unit = (v) => typeof v === 'number' && v >= 0 && v <= 1;
+        const probabilities = {};
+        for (const t of tiers) {
+            const v = answer?.probabilities?.[t];
+            if (unit(v))
+                probabilities[t] = v;
+        }
+        return { kind: 'ok', tier: choice, ms: result.ms,
+            ...(unit(answer?.confidence) ? { confidence: answer.confidence } : {}),
+            ...(Object.keys(probabilities).length ? { probabilities } : {}) };
+    }
+    async judgePolicy(state, signal, scope, dimensions = 'both') {
+        const questions = scope === 'main' || dimensions === 'depth' ? { depth: policyQuestions.depth }
+            : dimensions === 'capability' ? { capability: policyQuestions.capability } : policyQuestions;
+        const result = await this.decide(state, signal, questions);
+        if (result.kind !== 'ok')
+            return result;
+        const depth = result.answers?.depth?.choice;
+        const capability = result.answers?.capability?.choice;
+        if (Object.hasOwn(questions, 'depth') && (typeof depth !== 'string' || !Object.hasOwn(policyQuestions.depth.criteria, depth)))
+            return { kind: 'failed', category: 'invalid-response' };
+        if (Object.hasOwn(questions, 'capability') && (typeof capability !== 'string' || !Object.hasOwn(policyQuestions.capability.criteria, capability)))
+            return { kind: 'failed', category: 'invalid-response' };
+        return { kind: 'ok', depth: (Object.hasOwn(questions, 'depth') ? depth : 'baseline'), ...(Object.hasOwn(questions, 'capability') ? { capability: capability } : {}), ms: result.ms, decisionProvider: result.decisionProvider, decisionModel: result.decisionModel,
+            ...(probability(result.answers.depth?.confidence) ? { confidence: result.answers.depth.confidence } : {}),
+            ...(result.answers.depth?.probabilities ? { probabilities: distribution(result.answers.depth.probabilities) } : {}),
+            ...(probability(result.answers.capability?.confidence) ? { capabilityConfidence: result.answers.capability.confidence } : {}),
+            ...(result.answers.capability?.probabilities ? { capabilityProbabilities: distribution(result.answers.capability.probabilities) } : {}) };
+    }
+    async decide(state, signal, questions) {
         if (signal.aborted)
             return { kind: 'cancelled' };
         const configuredTimeout = typeof this.timeoutMs === 'function' ? this.timeoutMs() : this.timeoutMs;
@@ -43,6 +86,7 @@ export class JevClient {
         const deadline = AbortSignal.timeout(timeout);
         const started = performance.now();
         try {
+            const service = resolveDecisionService(this.service?.());
             const abort = AbortSignal.any([signal, deadline]);
             let onAbort = () => { };
             const cancelled = new Promise((_, reject) => {
@@ -51,7 +95,7 @@ export class JevClient {
             });
             let credential;
             try {
-                credential = await Promise.race([Promise.resolve(this.env.get('OPENROUTER_API_KEY')), cancelled]);
+                credential = await Promise.race([Promise.resolve(this.env.get(service.credential)), cancelled]);
             }
             finally {
                 abort.removeEventListener('abort', onAbort);
@@ -63,12 +107,12 @@ export class JevClient {
                 return { kind: 'failed', category: 'timeout' };
             if (!key)
                 return { kind: 'failed', category: 'missing-credential' };
-            const response = await fetch(this.url, {
+            const response = await fetch(this.service ? service.endpoint : this.url, {
                 method: 'POST',
                 redirect: 'error',
                 signal: AbortSignal.any([signal, deadline]),
                 headers: { Authorization: `Bearer ${key}`, 'Content-Type': 'application/json', 'X-Title': 'ohmydsh auto-model-routing' },
-                body: JSON.stringify({ model: MODEL, state, questions: TIER_QUESTIONS }),
+                body: JSON.stringify({ model: service.model, state, questions }),
             });
             if (!response.ok) {
                 await response.body?.cancel().catch(() => { });
@@ -105,25 +149,9 @@ export class JevClient {
             }
             if (typeof body?.error?.code === 'number')
                 return { kind: 'failed', category: byStatus(body.error.code) };
-            const choice = body?.answers?.tier?.choice;
-            if (!tiers.includes(choice))
+            if (!body?.answers || typeof body.answers !== 'object' || Array.isArray(body.answers))
                 return { kind: 'failed', category: 'invalid-response' };
-            const confidence = body.answers?.tier?.confidence;
-            const spread = body.answers?.tier?.probabilities;
-            // Keep only the four tiers' values in [0, 1]; anything else in the reply is ignored.
-            const unit = (v) => typeof v === 'number' && v >= 0 && v <= 1;
-            const probabilities = {};
-            for (const t of tiers) {
-                const v = spread?.[t];
-                if (unit(v))
-                    probabilities[t] = v;
-            }
-            const ms = Math.round(performance.now() - started);
-            return {
-                kind: 'ok', tier: choice, ms,
-                ...(unit(confidence) ? { confidence } : {}),
-                ...(Object.keys(probabilities).length ? { probabilities } : {}),
-            };
+            return { kind: 'ok', answers: body.answers, ms: Math.round(performance.now() - started), decisionProvider: service.provider, decisionModel: service.model };
         }
         catch (error) {
             if (signal.aborted)

package/lib/policy-host.d.ts

@@ -0,0 +1,68 @@
+import type { FeedbackBook } from './feedback.js';
+import type { Context } from '@deepseek-ai/cordis';
+import type { JevClient, Depth } from './jev.js';
+import { PolicyStore, type ChildDecision } from './policy-store.js';
+import type { RoutingState } from './state.js';
+import type { RoutingCatalog, Settings } from './settings-contract.js';
+export declare function policyHost(ctx: Context, deps: {
+    feedback: FeedbackBook;
+    jev: JevClient;
+    state: RoutingState;
+    store: PolicyStore;
+    settings: () => Settings;
+    catalog: () => Promise<RoutingCatalog>;
+}): {
+    invalidate: (id: string) => void;
+    status: (id: string) => {
+        version: 1;
+        childId: string;
+        parentId: string;
+        rootId: string;
+        policyVersion: string;
+        mappingVersion: string;
+        status: "failed" | "recommended" | "unsupported" | "needs-context" | "applied";
+        path: "ordinary" | "fork" | "teammate";
+        explicit: {
+            provider: "claude" | "codex" | "dsh-magpie-connect";
+            model?: string | undefined;
+            reasoningEffort?: string | undefined;
+        };
+        family?: "claude" | "codex" | undefined;
+        decision?: {
+            id: number;
+            source: "main" | "subagent";
+            tier: string;
+            depth: string;
+            effort: string;
+            status: string;
+            ms: number;
+            decisionProvider: string;
+            decisionModel: string;
+            capability?: string | undefined;
+            model?: string | undefined;
+            provider?: string | undefined;
+            confidence?: number | undefined;
+            capabilityConfidence?: number | undefined;
+            probabilities?: Record<string, number> | undefined;
+            capabilityProbabilities?: Record<string, number> | undefined;
+        } | undefined;
+        route?: {
+            provider: "claude" | "codex" | "dsh-magpie-connect";
+            model: string;
+            reasoningEffort: "low" | "medium" | "high" | "xhigh";
+        } | undefined;
+        actual?: {
+            provider: "claude" | "codex" | "dsh-magpie-connect";
+            model: string;
+            reasoningEffort: "low" | "medium" | "high" | "xhigh";
+        } | undefined;
+        reason?: string | undefined;
+    } | undefined;
+    mainStatus: (id: string) => {
+        decision?: NonNullable<ChildDecision["decision"]>;
+        policyVersion?: string;
+        depth?: Depth;
+        effort?: string;
+        reason?: string;
+    } | undefined;
+};