dsh-auto-model-routing 0.3.0 → 0.4.1

package/lib/settings-host.js

@@ -2,18 +2,20 @@ import { credentialRef } from '@deepseek-ai/dsh-credentials';
 import { launchEnvironmentOf } from '@deepseek-ai/dsh-launch-environment';
 import { DEFAULT_SETTINGS, SettingsValidationError } from './settings.js';
 import rubric from './rubric.json' with { type: 'json' };
-const keyRef = credentialRef('OPENROUTER_API_KEY');
+import { JevClient } from './jev.js';
+import { DECISION_SERVICES } from './decision-service.js';
+const keyRef = (provider = 'openrouter') => credentialRef(DECISION_SERVICES[provider].credential);
 /** Only the fixed credential reference and public catalog metadata cross this adapter. */
 export function settingsHost(ctx, store) {
     const environment = launchEnvironmentOf(ctx);
     const credentials = () => ctx.get('credentials');
-    const catalog = async () => {
-        const models = (await Promise.all(ctx.llm.listProviders().filter(p => p.id === 'claude' || p.id === 'codex').map(async (provider) => {
+    const catalog = async (includeMagpie = store.read().settings.policy === 'policy-v2') => {
+        const models = (await Promise.all(ctx.llm.listProviders().filter(p => p.id === 'claude' || p.id === 'codex' || (includeMagpie && p.id === 'dsh-magpie-connect')).map(async (provider) => {
             try {
                 return await Promise.all((await ctx.llm.listModels(provider.id)).map(async (model) => {
                     try {
                         const info = await ctx.llm.resolveModelInfo(provider.id, model.id);
-                        return { provider: provider.id, model: model.id, name: model.name, reasoningEfforts: (info.reasoning?.efforts ?? []).map(e => String(e.id)) };
+                        return { provider: provider.id, model: model.id, name: model.name, reasoningEfforts: (info.reasoning?.efforts ?? []).map(e => String(e.id)), ...(info.reasoning?.defaultEffort ? { defaultEffort: String(info.reasoning.defaultEffort) } : {}) };
                     }
                     catch {
                         return undefined;
@@ -29,23 +31,24 @@ export function settingsHost(ctx, store) {
         try {
             if (service) {
                 const current = service.current();
-                return { models, childAllowlist: { status: current.enabled ? 'enabled' : 'disabled', allowedModels: current.allowedModels.filter(r => r.provider === 'claude' || r.provider === 'codex') } };
+                return { models, childAllowlist: { status: current.enabled ? 'enabled' : 'disabled', allowedModels: current.allowedModels.filter(r => r.provider === 'claude' || r.provider === 'codex' || (includeMagpie && r.provider === 'dsh-magpie-connect')) } };
             }
         }
         catch { /* An unavailable policy must never broaden the allowed routes. */ }
         return { models, childAllowlist: { status: 'unavailable', allowedModels: [] } };
     };
-    const keyStatus = async () => {
+    const keyStatus = async (provider = store.read().settings.decisionService?.provider ?? 'openrouter') => {
+        const ref = keyRef(provider);
         const service = credentials();
         if (service) {
             try {
-                return { ...await service.describe(keyRef), available: true };
+                return { ...await service.describe(ref), available: true };
             }
             catch {
                 return { configured: false, writable: false, available: false };
             }
         }
-        return { configured: Boolean(environment.get('OPENROUTER_API_KEY')?.value), writable: false, available: false };
+        return { configured: Boolean(environment.get(ref)?.value), writable: false, available: false };
     };
     const read = async () => {
         const current = await catalog();
@@ -55,6 +58,11 @@ export function settingsHost(ctx, store) {
     const endpoint = async (operation, body) => {
         if (operation === 'settings')
             return Response.json(await read());
+        if (operation === 'testDecision') {
+            const client = new JevClient({ get: async (name) => credentials() ? credentials().resolve(credentialRef(name)) : environment.get(name) }, undefined, 4500, () => store.read().settings.decisionService);
+            const result = await client.judgePolicy('Public connection test: sort the numbers [3,1,2] in ascending order.', new AbortController().signal, 'child');
+            return Response.json(result);
+        }
         if (operation === 'saveSettings') {
             try {
                 store.save(body, await catalog());
@@ -69,19 +77,23 @@ export function settingsHost(ctx, store) {
         const service = credentials();
         if (!service)
             return Response.json({ error: '凭据服务不可用' }, { status: 503 });
-        if (typeof body !== 'object' || body === null || Array.isArray(body) || Object.keys(body).length !== 1 || !('value' in body))
+        if (typeof body !== 'object' || body === null || Array.isArray(body) || Object.keys(body).some(k => !['value', 'provider'].includes(k)) || !('value' in body))
             return Response.json({ error: '无效的凭据请求' }, { status: 400 });
+        const provider = 'provider' in body ? body.provider : 'openrouter';
+        if (typeof provider !== 'string' || !Object.hasOwn(DECISION_SERVICES, provider))
+            return Response.json({ error: '无效的服务商' }, { status: 400 });
+        const ref = keyRef(provider);
         const value = body.value;
         if (value !== null && (typeof value !== 'string' || !value || value.length > 512 || /\s/.test(value)))
             return Response.json({ error: 'API key 必须为不含空白的非空字符串，且不超过 512 字符' }, { status: 400 });
         try {
-            if (!(await service.describe(keyRef)).writable)
+            if (!(await service.describe(ref)).writable)
                 return Response.json({ error: '该 key 来自启动环境，需先从启动环境移除并重启才能在此管理' }, { status: 409 });
             if (value === null)
-                await service.unset(keyRef);
+                await service.unset(ref);
             else
-                await service.set(keyRef, value);
-            return Response.json({ key: await keyStatus() });
+                await service.set(ref, value);
+            return Response.json({ key: await keyStatus(provider) });
         }
         catch {
             return Response.json({ error: '无法更新 API key；请检查凭据服务与只读来源' }, { status: 500 });
@@ -91,7 +103,7 @@ export function settingsHost(ctx, store) {
         catalog, read, endpoint,
         credential: async (name) => {
             const service = credentials();
-            return service ? service.resolve(keyRef) : environment.get(name);
+            return service ? service.resolve(credentialRef(name)) : environment.get(name);
         },
     };
 }

package/lib/settings.js

@@ -2,11 +2,20 @@ import { chmodSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSy
 import { dirname } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { z } from 'zod';
+import { resolveDecisionService } from './decision-service.js';
 import { tiers } from './effort.js';
 import { AUTO_EFFORTS, DEFAULT_SETTINGS } from './settings-contract.js';
 import { isRecord, issue, MODEL_ID_PATTERN, validateChildRoute, validateFamilyMainEffort, validateMainRoute } from './settings-validation.js';
 export { DEFAULT_SETTINGS } from './settings-contract.js';
 const ordinary = {
+    decisionService: z.object({ provider: z.enum(['openrouter', 'typesafe', 'concentrate', 'custom']), model: z.string().regex(/^[A-Za-z0-9._:/~-]{1,128}$/).optional(), endpoint: z.string().max(2048).optional() }).strict().refine(value => { try {
+        resolveDecisionService(value);
+        return true;
+    }
+    catch {
+        return false;
+    } }, 'Invalid decision service'),
+    policy: z.enum(['legacy', 'policy-v2']),
     decisionToast: z.boolean(), defaultMode: z.enum(['MANUAL', 'AUTO']),
     effortCap: z.enum(AUTO_EFFORTS), jevTimeoutMs: z.number().int().min(1000).max(4500),
 };
@@ -183,8 +192,12 @@ export class SettingsStore {
             const parsed = schema.safeParse(raw[key]);
             if (parsed.success)
                 Object.assign(settings, { [key]: parsed.data });
-            else
+            else {
                 issues.push(...schemaIssues(parsed.error, key));
+                // A malformed explicit transport must never fall back to OpenRouter.
+                if (key === 'decisionService')
+                    Object.assign(settings, { decisionService: { provider: 'custom', endpoint: '' } });
+            }
         }
         for (const kind of ['mainEfforts', 'childRoutes']) {
             if (!Object.hasOwn(raw, kind))

package/lib/subagent-tool.js

@@ -5,6 +5,8 @@ import { DEFAULT_SETTINGS } from './settings-contract.js';
 import { validateChildRoute } from './settings-validation.js';
 import { CATEGORY_HINTS } from './jev.js';
 import { buildState } from './context.js';
+import { choosePolicyRoute, modelFamily } from './policy-v2.js';
+import { policyVersion } from './jev.js';
 /** The ordinary session a caller belongs to; undefined when any link is no longer live (treated as MANUAL). */
 function rootOf(caller, agents) {
     let current = caller;
@@ -21,12 +23,15 @@ const MANUAL_TEXT = '主会话为 MANUAL：不判档，按官方默认委派；
 export function routeSubagentTool(jev, deps) {
     return defineTool({
         name: 'route_subagent',
-        description: 'Call before every sub-agent delegation, whatever the task size. Picks provider/model/reasoning_effort with the Jev decision model; pass provider, model and reasoning_effort explicitly to the sub-agent tool, or the sub-agent inherits this session\'s effort. Sends the task text (redacted, up to 8000 characters) to OpenRouter/TypeSafe only while the main session is AUTO; otherwise returns routed=false: delegate with the official defaults. If the user or lead already chose the sub-agent model, pass it as model: only reasoning_effort is routed and the model is kept. On error: pause delegation and ask the user; never guess a tier.',
+        description: 'When policy-v2 is selected, this tool is an optional preview only: use the official fresh creation tool directly for exact-child automatic routing, do not turn preview output into explicit user constraints; fork is unsupported. Under the legacy policy: Call before every sub-agent delegation, whatever the task size. Picks provider/model/reasoning_effort with the Jev decision model; pass provider, model and reasoning_effort explicitly to the sub-agent tool, or the sub-agent inherits this session\'s effort. Sends the task text (redacted, up to 8000 characters) to OpenRouter/TypeSafe only while the main session is AUTO; otherwise returns routed=false: delegate with the official defaults. If the user or lead already chose the sub-agent model, pass it as model: only reasoning_effort is routed and the model is kept. On error: pause delegation and ask the user; never guess a tier.',
         timeoutMs: 5000,
         parameters: {
             task: { type: 'string', required: true, description: 'The task the sub-agent will do.' },
-            provider: { type: 'string', required: true, enum: ['claude', 'codex'], description: 'Provider family for the sub-agent.' },
+            provider: { type: 'string', required: true, enum: ['claude', 'codex', 'dsh-magpie-connect'], description: 'Exact transport provider. Magpie is available only under policy-v2.' },
             model: { type: 'string', description: 'Sub-agent model already chosen by the user or lead; when given, only reasoning_effort is routed.' },
+            reasoning_effort: { type: 'string', description: 'Explicit effort constraint for policy-v2; preserved and validated, never silently replaced.' },
+            family: { type: 'string', enum: ['claude', 'codex'], description: 'Magpie automatic capability family; required when no model is explicitly supplied.' },
+            path: { type: 'string', enum: ['ordinary', 'fork', 'teammate'], description: 'policy-v2 creation path; fork remains unsupported until real history compatibility is verified.' },
         },
         output: {
             schema: {
@@ -34,6 +39,10 @@ export function routeSubagentTool(jev, deps) {
                 additionalProperties: false,
                 properties: {
                     routed: { type: 'boolean' },
+                    status: { type: 'string' },
+                    policyVersion: { type: 'string' },
+                    capability: { type: 'string' },
+                    depth: { type: 'string' },
                     reason: { type: 'string' },
                     tier: { type: 'string' },
                     provider: { type: 'string' },
@@ -41,9 +50,12 @@ export function routeSubagentTool(jev, deps) {
                     reasoning_effort: { type: 'string' },
                 },
             },
-            render: (_args, v) => [{ type: 'text', text: v.routed === false
-                        ? MANUAL_TEXT
-                        : `Delegate with provider=${v.provider} model=${v.model} reasoning_effort=${v.reasoning_effort} (tier ${v.tier}); label the description [${v.model}·${v.reasoning_effort}].` }],
+            render: (_args, v) => [{ type: 'text', text: v.status ? (v.status === 'recommended'
+                        ? `policy-v2 recommended only (not applied): ${v.provider}/${v.model}/${v.reasoning_effort}. Use the official creation tool; AUTO judges and binds the exact child before its first request. Do not copy this recommendation as a new explicit user constraint. Query the child routing status for applied evidence.`
+                        : `policy-v2 ${v.status}: ${v.reason}. 暂停委派并询问用户；不将推荐冒充实际应用。`)
+                        : v.routed === false
+                            ? MANUAL_TEXT
+                            : `Delegate with provider=${v.provider} model=${v.model} reasoning_effort=${v.reasoning_effort} (tier ${v.tier}); label the description [${v.model}·${v.reasoning_effort}].` }],
         },
         execute: async (args, exec) => {
             const caller = exec.agent;
@@ -51,6 +63,21 @@ export function routeSubagentTool(jev, deps) {
             // MANUAL (or disabled, or an unreachable root): no judgement and nothing leaves the machine.
             if (!root || deps.state.read(root.id).mode !== 'AUTO')
                 return { routed: false, reason: 'manual' };
+            if (deps.readSettings?.().policy === 'policy-v2') {
+                if (args.path === 'fork')
+                    return { routed: false, status: 'unsupported', policyVersion, reason: 'fork 真实历史兼容尚未验证；选择 fresh 或由用户关闭试验后继承' };
+                const explicit = { ...(args.model ? { model: args.model } : {}), ...(args.reasoning_effort ? { reasoningEffort: args.reasoning_effort } : {}) };
+                const result = explicit.model && explicit.reasoningEffort ? { kind: 'ok', depth: 'baseline', capability: 'bounded' }
+                    : await jev.judgePolicy(buildState({ text: args.task }), exec.signal, 'child', explicit.model ? 'depth' : explicit.reasoningEffort ? 'capability' : 'both');
+                if (result.kind !== 'ok')
+                    throw new Error('policy-v2 Jev 判断失败或取消；暂停委派并询问用户');
+                if (result.capability === 'insufficient_context')
+                    return { routed: false, status: 'needs-context', policyVersion, reason: '请补充任务目标与范围' };
+                const route = choosePolicyRoute(args.provider, result.capability ?? 'bounded', result.depth, await deps.catalog(), deps.readSettings().effortCap, explicit, args.family ?? (args.model ? modelFamily(args.provider, args.model) : undefined));
+                return { status: 'recommended', policyVersion, ...(result.capability ? { capability: result.capability } : {}), depth: result.depth, provider: route.provider, model: route.model, reasoning_effort: route.reasoningEffort };
+            }
+            if (args.provider === 'dsh-magpie-connect')
+                throw new Error('Magpie 路由需显式选择 policy-v2；原策略不变');
             const result = await jev.judge(buildState({ text: args.task }), exec.signal);
             if (result.kind === 'cancelled')
                 throw new Error('route_subagent 已取消。');

package/lib/usage-report.d.ts

@@ -0,0 +1,59 @@
+type Failure = 'decode-failed' | 'tail-incomplete' | 'parse-failed' | 'missing-log';
+export declare function buildReport(home: string, options?: {
+    since?: string;
+}): {
+    schema: number;
+    since: string | null;
+    failures: Record<Failure, number>;
+    excluded: {
+        child: number;
+        seeded: number;
+    };
+    coverage: {
+        userTurns: number;
+        turnsWithoutRecord: number;
+        unlinkedBindings: number;
+        autoSessionsWithoutRecord: number;
+    };
+    groups: {
+        version: string;
+        subgroups: {
+            model: string;
+            depth: string;
+            decisions: number;
+            sessions: number;
+            calls: number;
+            callsPerDecision: {
+                median: number;
+                max: number;
+            };
+            tokens: Record<string, {
+                sum: number | null;
+                mean: number | null;
+                present: number;
+                calls: number;
+            }>;
+            byEffort: {
+                [k: string]: {
+                    decisions: number;
+                    calls: number;
+                };
+            };
+            feedback: Record<string, number>;
+            conclusion: string;
+        }[];
+    }[];
+    referenceBeforeAuto: {
+        model: string;
+        calls: number;
+        sessions: number;
+        effort: {
+            [k: string]: number;
+        };
+        autoEffort: {
+            [k: string]: number;
+        };
+    }[];
+    caveats: string[];
+};
+export {};

package/lib/usage-report.js

@@ -0,0 +1,332 @@
+// Read-only, on-demand AUTO usage report (change auto-routing-usage-report).
+// Never writes, spawns, or touches the network; never echoes message text, paths or session ids.
+import { createHash } from 'node:crypto';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { parseArgs } from 'node:util';
+import { zstdDecompressSync } from 'node:zlib';
+import { FeedbackBook } from './feedback.js';
+const MAGIC = Buffer.from([0x28, 0xb5, 0x2f, 0xfd]);
+const FIELDS = ['inputTokens', 'outputTokens', 'cacheReadTokens', 'cacheWriteTokens', 'reasoningTokens'];
+const FEEDBACK = ['appropriate', 'too-high', 'too-low', 'unknown'];
+const CAVEATS = [
+    'observational-not-controlled',
+    'scope-main-session-assistant-calls-only',
+    'only-applied-decisions-recorded',
+    'token-semantics-differ-by-provider',
+    'reference-before-auto-effort-only-confounded',
+    'mode-history-not-persisted',
+];
+const sorted = (record) => Object.fromEntries(Object.entries(record).sort(([a], [b]) => a.localeCompare(b)));
+const round = (n) => Math.round(n * 100) / 100;
+const bump = (record, key, by = 1) => { record[key] = (record[key] ?? 0) + by; };
+/** Split concatenated zstd frames; only a failing last segment counts as an unfinished tail. */
+function decode(bytes) {
+    const starts = [];
+    for (let i = bytes.indexOf(MAGIC); i !== -1; i = bytes.indexOf(MAGIC, i + 1))
+        starts.push(i);
+    if (starts[0] !== 0)
+        return undefined;
+    let text = '';
+    for (let i = 0; i < starts.length; i++) {
+        try {
+            text += zstdDecompressSync(bytes.subarray(starts[i], starts[i + 1])).toString('utf8');
+        }
+        catch {
+            if (i === starts.length - 1)
+                return { text, tail: true };
+            return undefined;
+        }
+    }
+    return { text, tail: false };
+}
+function lines(file, failures) {
+    let text;
+    try {
+        text = readFileSync(file, 'utf8');
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const line of text.split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            out.push(JSON.parse(line));
+        }
+        catch {
+            failures['parse-failed']++;
+        }
+    }
+    return out;
+}
+function logPaths(home) {
+    const paths = new Map();
+    const root = join(home, 'sessions');
+    let dirs = [];
+    try {
+        dirs = readdirSync(root);
+    }
+    catch {
+        return paths;
+    }
+    for (const dir of dirs) {
+        let ids = [];
+        try {
+            ids = readdirSync(join(root, dir));
+        }
+        catch {
+            continue;
+        }
+        for (const id of ids) {
+            const file = join(root, dir, id, 'session.v4.jsonl.zstd');
+            if (existsSync(file))
+                paths.set(id, file);
+        }
+    }
+    return paths;
+}
+/** Calls in one session log, with the user turn each belongs to and the config in effect. */
+function readSession(file, failures) {
+    let decoded;
+    try {
+        decoded = decode(readFileSync(file));
+    }
+    catch {
+        decoded = undefined;
+    }
+    if (!decoded) {
+        failures['decode-failed']++;
+        return undefined;
+    }
+    if (decoded.tail)
+        failures['tail-incomplete']++;
+    const events = [];
+    for (const line of decoded.text.split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            events.push(JSON.parse(line));
+        }
+        catch {
+            failures['parse-failed']++;
+        }
+    }
+    const header = events.shift();
+    if (header?.type !== 'session') {
+        failures['decode-failed']++;
+        return undefined;
+    }
+    const calls = [];
+    const seen = new Set();
+    let turn, userTurn;
+    let config = {};
+    for (const event of events) {
+        const data = event.data ?? {};
+        if (event.type === 'turn/start')
+            turn = data.turn;
+        else if (event.type === 'user/message' && data.source?.kind === 'user' && turn !== undefined)
+            userTurn = turn;
+        else if (event.type === 'request/header' && data.header?.config)
+            config = data.header.config;
+        else if (event.type === 'assistant/message') {
+            const op = event.surfaceOp;
+            const append = op === undefined || op === 'append' || (typeof op === 'object' && op?.op === 'append');
+            const id = data.message?.id;
+            if (!append || typeof id !== 'string' || seen.has(id))
+                continue;
+            seen.add(id);
+            const usage = {};
+            for (const field of FIELDS)
+                if (typeof data.usage?.[field] === 'number')
+                    usage[field] = data.usage[field];
+            calls.push({ id, ...(userTurn === undefined ? {} : { userTurn }), time: event.time, usage, ...(config.model ? { model: config.model } : {}), ...(config.reasoningEffort ? { effort: config.reasoningEffort } : {}) });
+        }
+    }
+    return { header, calls };
+}
+function localMidnight(date) {
+    const [y, m, d] = date.split('-').map(Number);
+    const at = new Date(y, m - 1, d);
+    const offset = -at.getTimezoneOffset();
+    const sign = offset >= 0 ? '+' : '-';
+    const hh = String(Math.floor(Math.abs(offset) / 60)).padStart(2, '0'), mm = String(Math.abs(offset) % 60).padStart(2, '0');
+    return { ms: at.getTime(), label: `${date}T00:00:00${sign}${hh}:${mm}` };
+}
+function tokens(calls) {
+    const out = {};
+    for (const field of FIELDS) {
+        const values = calls.map(c => c.usage[field]).filter((v) => v !== undefined);
+        const sum = values.reduce((a, b) => a + b, 0);
+        out[field] = values.length ? { sum, mean: round(sum / values.length), present: values.length, calls: calls.length } : { sum: null, mean: null, present: 0, calls: calls.length };
+    }
+    return out;
+}
+function median(values) {
+    const s = [...values].sort((a, b) => a - b), mid = Math.floor(s.length / 2);
+    return s.length % 2 ? s[mid] : (s[mid - 1] + s[mid]) / 2;
+}
+export function buildReport(home, options = {}) {
+    const failures = { 'decode-failed': 0, 'tail-incomplete': 0, 'parse-failed': 0, 'missing-log': 0 };
+    const state = join(home, 'state/auto-model-routing');
+    const since = options.since ? localMidnight(options.since) : undefined;
+    const after = (time) => !since || time >= since.ms;
+    const feedbackFile = join(state, 'allocation-feedback.jsonl');
+    lines(feedbackFile, failures); // counts unparsable lines; FeedbackBook skips them silently
+    const book = new FeedbackBook(feedbackFile);
+    const bindings = book.entries();
+    const legacyFirst = new Map();
+    for (const line of lines(join(state, 'judgements.jsonl'), failures)) {
+        if (typeof line?.sessionId !== 'string' || !Number.isInteger(line.turn) || typeof line.tier !== 'string')
+            continue;
+        legacyFirst.set(line.sessionId, Math.min(legacyFirst.get(line.sessionId) ?? Infinity, line.turn));
+    }
+    const ledgerSessions = [...new Set([...bindings.map(b => b.sessionId), ...legacyFirst.keys()])].sort();
+    const paths = logPaths(home);
+    const excluded = { child: 0, seeded: 0 };
+    const decisions = new Map();
+    const reference = {};
+    const autoEffort = {};
+    let unlinkedBindings = 0, userTurns = 0, turnsWithoutRecord = 0;
+    for (const session of ledgerSessions) {
+        const path = paths.get(session);
+        if (!path) {
+            failures['missing-log']++;
+            continue;
+        }
+        const log = readSession(path, failures);
+        if (!log)
+            continue;
+        if (log.header.origin) {
+            excluded.child++;
+            continue;
+        }
+        if (log.header.isSeeded === true) {
+            excluded.seeded++;
+            continue;
+        }
+        const linked = new Set();
+        let v2First;
+        for (const call of log.calls) {
+            const b = book.lookup(session, call.id);
+            if (!b)
+                continue;
+            linked.add(call.id);
+            if (call.userTurn !== undefined)
+                v2First = Math.min(v2First ?? Infinity, call.userTurn);
+            const key = JSON.stringify([session, b.decisionId]);
+            let d = decisions.get(key);
+            if (!d) {
+                d = { session, version: b.snapshot ? `${b.snapshot.policyVersion}/${b.snapshot.mappingVersion}` : 'unknown', model: b.model, depth: b.depth, effort: b.effort, calls: [], feedback: new Set() };
+                decisions.set(key, d);
+            }
+            d.calls.push(call);
+            if (b.feedback)
+                d.feedback.add(b.feedback);
+        }
+        unlinkedBindings += bindings.filter(b => b.sessionId === session && !linked.has(b.messageId)).length;
+        // Coverage: user turns from the first v2 record on, with calls in range but none linked.
+        if (v2First !== undefined) {
+            const turns = new Map();
+            for (const call of log.calls) {
+                if (call.userTurn === undefined || call.userTurn < v2First || !after(call.time))
+                    continue;
+                turns.set(call.userTurn, (turns.get(call.userTurn) ?? false) || linked.has(call.id));
+            }
+            userTurns += turns.size;
+            turnsWithoutRecord += [...turns.values()].filter(v => !v).length;
+        }
+        // Reference: calls before the earliest record in either ledger (effort only, never tokens).
+        const first = Math.min(legacyFirst.get(session) ?? Infinity, v2First ?? Infinity);
+        for (const call of log.calls) {
+            if (call.userTurn === undefined || call.userTurn >= first || !after(call.time) || !call.model)
+                continue;
+            const r = (reference[call.model] ??= { calls: 0, sessions: new Set(), effort: {} });
+            r.calls++;
+            r.sessions.add(session);
+            bump(r.effort, call.effort ?? 'unknown');
+        }
+    }
+    const kept = [...decisions.values()].filter(d => after(Math.min(...d.calls.map(c => c.time))));
+    for (const d of kept)
+        bump((autoEffort[d.model] ??= {}), d.effort, d.calls.length);
+    const versions = new Map();
+    for (const d of kept) {
+        const byVersion = versions.get(d.version) ?? new Map();
+        versions.set(d.version, byVersion);
+        const key = JSON.stringify([d.model, d.depth]);
+        byVersion.set(key, [...(byVersion.get(key) ?? []), d]);
+    }
+    const groups = [...versions].sort(([a], [b]) => a.localeCompare(b)).map(([version, subs]) => ({
+        version,
+        subgroups: [...subs].sort(([a], [b]) => a.localeCompare(b)).map(([key, list]) => {
+            const [model, depth] = JSON.parse(key);
+            const calls = list.flatMap(d => d.calls);
+            const sessions = new Set(list.map(d => d.session)).size;
+            const feedback = { ...Object.fromEntries(FEEDBACK.map(f => [f, 0])), conflict: 0, unrated: 0 };
+            for (const d of list)
+                bump(feedback, d.feedback.size === 0 ? 'unrated' : d.feedback.size > 1 ? 'conflict' : [...d.feedback][0]);
+            const byEffort = {};
+            for (const d of list) {
+                const e = (byEffort[d.effort] ??= { decisions: 0, calls: 0 });
+                e.decisions++;
+                e.calls += d.calls.length;
+            }
+            return {
+                model, depth, decisions: list.length, sessions, calls: calls.length,
+                callsPerDecision: { median: median(list.map(d => d.calls.length)), max: Math.max(...list.map(d => d.calls.length)) },
+                tokens: tokens(calls), byEffort: sorted(byEffort), feedback,
+                conclusion: list.length >= 20 && sessions >= 3 ? 'observed' : 'insufficient-sample',
+            };
+        }),
+    }));
+    const recorded = new Set(ledgerSessions.map(s => createHash('sha256').update(s).digest('hex')));
+    let autoSessionsWithoutRecord = 0;
+    let stateFiles = [];
+    try {
+        stateFiles = readdirSync(join(state, 'sessions')).filter(f => f.endsWith('.json')).sort();
+    }
+    catch { /* none */ }
+    for (const file of stateFiles) {
+        let mode;
+        try {
+            mode = JSON.parse(readFileSync(join(state, 'sessions', file), 'utf8'))?.mode;
+        }
+        catch {
+            failures['parse-failed']++;
+            continue;
+        }
+        if (mode === 'AUTO' && !recorded.has(file.slice(0, -5)))
+            autoSessionsWithoutRecord++;
+    }
+    return {
+        schema: 1,
+        since: since?.label ?? null,
+        failures, excluded,
+        coverage: { userTurns, turnsWithoutRecord, unlinkedBindings, autoSessionsWithoutRecord },
+        groups,
+        referenceBeforeAuto: Object.keys(reference).sort().map(model => ({
+            model, calls: reference[model].calls, sessions: reference[model].sessions.size,
+            effort: sorted(reference[model].effort), autoEffort: sorted(autoEffort[model] ?? {}),
+        })),
+        caveats: CAVEATS,
+    };
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    try {
+        const { values } = parseArgs({ options: { since: { type: 'string' } } });
+        if (values.since !== undefined && !/^\d{4}-\d{2}-\d{2}$/.test(values.since)) {
+            process.stderr.write('usage-report: --since must be YYYY-MM-DD\n');
+            process.exit(2);
+        }
+        const home = process.env.DSH_HOME ?? join(homedir(), '.dsh');
+        process.stdout.write(`${JSON.stringify(buildReport(home, values.since ? { since: values.since } : {}), null, 2)}\n`);
+    }
+    catch {
+        process.stderr.write('usage-report: failed\n');
+        process.exit(1);
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-auto-model-routing",
-  "version": "0.3.0",
-  "description": "DeepSeek Harness plugin: use Jev to adjust reasoning effort per turn without changing the selected model, with configurable subagent routing",
+  "version": "0.4.1",
+  "description": "DeepSeek Harness plugin: independent Jev capability and effort decisions, enforced fresh-child routes, decision visibility and allocation feedback",
   "license": "MIT",
   "author": "prgrmrwy",
   "repository": { "type": "git", "url": "git+https://github.com/prgrmrwy/dsh-auto-model-routing.git" },
@@ -99,7 +99,7 @@
     "@deepseek-ai/dsh-credentials": "^0.2.0-rc.2",
     "@deepseek-ai/dsh-llm": "^0.2.0-rc.2",
     "@deepseek-ai/dsh-session-projection": "^0.2.0-rc.2",
-    "react": "^19.0.0",
+    "react": "^18.3.1 || ^19.0.0",
     "@deepseek-ai/dsh-launch-environment": "^0.2.0-rc.2",
     "@deepseek-ai/dsh-skill-filesystem": "^0.2.0-rc.2",
     "@deepseek-ai/dsh-tools": "^0.2.0-rc.2"