dsh-auto-model-routing 0.4.1 → 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,12 +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 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,62 +1,64 @@
 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));
 }
-/** Query (no `label`) or label the judged turn a reply belongs to (design D13). */
-export async function labelEndpoint(body, resolveAgent, book, feedbackBook) {
+export async function observeEndpoint(body, resolveAgent, book, warn) {
     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 });
+        return invalid();
+    const { sessionId, messageId } = body;
+    if (typeof sessionId !== 'string' || !sessionId || typeof messageId !== 'string' || !messageId)
+        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 {
+            book.fact(sessionId, binding.decisionId, 'exposed');
+        }
+        catch {
+            warn();
+        }
+    return Response.json({});
+}
+/** 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 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;
@@ -30,11 +31,24 @@ declare const schema: z.ZodObject<{
     }>>>;
     feedbackAt: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
+declare const factEvent: z.ZodObject<{
+    type: z.ZodLiteral<"fact">;
+    version: z.ZodOptional<z.ZodLiteral<1>>;
+    sessionId: z.ZodString;
+    decisionId: z.ZodNumber;
+    fact: z.ZodEnum<{
+        exposed: "exposed";
+        "manual-switch": "manual-switch";
+    }>;
+    at: z.ZodNumber;
+}, z.core.$strict>;
+export type FeedbackFact = z.infer<typeof factEvent>['fact'];
 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;
+    private factRecords;
     constructor(file: string);
     private key;
     lookup(sessionId: string, messageId: string): {
@@ -47,13 +61,41 @@ 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;
+        } | undefined;
+        boundAt?: number | undefined;
+        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;
@@ -61,6 +103,29 @@ export declare class FeedbackBook {
         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(): {
@@ -73,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;
@@ -90,6 +156,11 @@ export declare class FeedbackBook {
     }[];
     bind(record: FeedbackRecord): void;
     set(sessionId: string, messageId: string, feedback: typeof allocationFeedback[number] | null): void;
+    facts(sessionId: string, decisionId: number): {
+        exposed?: number;
+        "manual-switch"?: number;
+    };
+    fact(sessionId: string, decisionId: number, fact: FeedbackFact): void;
     private append;
 }
 export {};

package/lib/feedback.js

@@ -3,18 +3,22 @@ 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();
+// 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;
     records = new Map();
+    factRecords = new Map();
     constructor(file) {
         this.file = file;
         let text;
@@ -29,6 +33,15 @@ export class FeedbackBook {
         for (const line of text.split('\n'))
             try {
                 const raw = JSON.parse(line);
+                const fact = factEvent.safeParse(raw);
+                if (fact.success) {
+                    const e = fact.data;
+                    const key = JSON.stringify([e.sessionId, e.decisionId]);
+                    const facts = this.factRecords.get(key) ?? {};
+                    facts[e.fact] ??= e.at;
+                    this.factRecords.set(key, facts);
+                    continue;
+                }
                 const event = feedbackEvent.safeParse(raw);
                 if (event.success) {
                     const e = event.data;
@@ -51,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))
@@ -59,9 +80,19 @@ 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 });
     }
+    facts(sessionId, decisionId) { return { ...this.factRecords.get(JSON.stringify([sessionId, decisionId])) }; }
+    fact(sessionId, decisionId, fact) {
+        const key = JSON.stringify([sessionId, decisionId]);
+        const facts = this.factRecords.get(key) ?? {};
+        if (facts[fact] !== undefined)
+            return;
+        const event = factEvent.parse({ type: 'fact', sessionId, decisionId, fact, at: Date.now() });
+        this.append(event);
+        this.factRecords.set(key, { ...facts, [fact]: event.at });
+    }
     append(record) { mkdirSync(dirname(this.file), { recursive: true }); appendFileSync(this.file, JSON.stringify(record) + '\n', { mode: 0o600 }); }
 }

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;