dsh-auto-model-routing 0.4.1 → 0.4.2

package/lib/policy-host.js

@@ -5,6 +5,7 @@ import { choosePolicyRoute, mappingVersion, policyEffort, modelFamily, policyPro
 import { userInput } from './input.js';
 import { buildState, previousTurn } from './context.js';
 import { isRecord } from './settings-validation.js';
+import { autoSupportedModel, currentMainSelection, mainSupported } from './support.js';
 export function policyHost(ctx, deps) {
     const delegation = new AsyncLocalStorage();
     const rootOf = (agent) => {
@@ -27,6 +28,13 @@ export function policyHost(ctx, deps) {
     const decidedAt = new Map();
     const applied = new Map();
     const latest = new Map();
+    /** Fall back to MANUAL when the main model left AUTO's Claude/GPT scope. */
+    const lockUnsupportedMain = (agent) => {
+        deps.state.setMode(agent.id, 'MANUAL');
+        mainStatus.delete(agent.id);
+        latest.delete(agent.id);
+        applied.delete(agent.id);
+    };
     ctx.on('tools/execute', async (exec, next) => {
         if (!['subagent', 'subagent_fork', 'spawn_teammate'].includes(exec.name) || !exec.agent)
             return next();
@@ -80,6 +88,11 @@ export function policyHost(ctx, deps) {
                     main.set(agent, { ...old, turn: payload.turn });
                 return decision;
             }
+            // The main model left AUTO's Claude/GPT scope: judge nothing, rewrite nothing.
+            if (!mainSupported(currentMainSelection(ctx, agent))) {
+                lockUnsupportedMain(agent);
+                return decision;
+            }
             applied.delete(agent.id);
             mainStatus.delete(agent.id);
             const startedEpoch = epoch(agent.id);
@@ -190,17 +203,43 @@ export function policyHost(ctx, deps) {
             const runtime = main.get(agent);
             if (!runtime?.active || runtime.turn !== payload.turn || runtime.epoch !== epoch(agent.id) || !enabled(agent.id))
                 return config;
+            // Authoritative gate: the request's actual model decides, whatever the picker showed earlier.
+            if (!autoSupportedModel(config.model)) {
+                lockUnsupportedMain(agent);
+                return config;
+            }
+            const unsupported = (effort = '模型不支持调整') => {
+                const old = mainStatus.get(agent.id);
+                mainStatus.set(agent.id, { ...old, policyVersion, depth: runtime.depth, reason: 'no-effort-support', ...(old?.decision ? { decision: { ...old.decision, status: 'unsupported', model: config.model, provider: config.provider, effort } } : {}) });
+            };
             const info = await ctx.llm.resolveModelInfo(config.provider, config.model, payload.signal);
             if (!enabled(agent.id) || runtime.epoch !== epoch(agent.id) || payload.signal.aborted)
                 return config;
             const efforts = (info.reasoning?.efforts ?? []).map(e => String(e.id));
             if (!efforts.length) {
-                const old = mainStatus.get(agent.id);
-                mainStatus.set(agent.id, { ...old, policyVersion, depth: runtime.depth, reason: 'no-effort-support', ...(old?.decision ? { decision: { ...old.decision, status: 'unsupported', model: config.model, provider: config.provider, effort: '模型不支持调整' } } : {}) });
+                unsupported();
+                return config;
+            }
+            let reasoningEffort;
+            try {
+                reasoningEffort = policyEffort(config.model, runtime.depth, efforts, deps.settings().effortCap, info.reasoning?.defaultEffort ? String(info.reasoning.defaultEffort) : undefined);
+            }
+            catch (error) {
+                // A supported model whose directory cannot produce an automatic effort must not fail the turn.
+                ctx.logger.warn(`auto-model-routing: could not map the main reasoning effort: ${String(error)}`);
+                unsupported();
                 return config;
             }
-            const reasoningEffort = policyEffort(config.model, runtime.depth, efforts, deps.settings().effortCap, info.reasoning?.defaultEffort ? String(info.reasoning.defaultEffort) : undefined);
             mainStatus.set(agent.id, { ...mainStatus.get(agent.id), policyVersion, depth: runtime.depth, effort: reasoningEffort, reason: 'jev', ...(mainStatus.get(agent.id)?.decision ? { decision: { ...mainStatus.get(agent.id).decision, effort: reasoningEffort, model: config.model, provider: config.provider } } : {}) });
+            if (reasoningEffort !== config.reasoningEffort) {
+                try {
+                    await deps.selectModel({ sessionId: agent.id, provider: config.provider, model: config.model, reasoningEffort });
+                }
+                catch (error) {
+                    ctx.logger.warn(`auto-model-routing: could not sync the model selection: ${String(error)}`);
+                    return config;
+                }
+            }
             return { ...config, reasoningEffort };
         }
         const record = deps.store.get(agent.id);
@@ -217,8 +256,29 @@ export function policyHost(ctx, deps) {
         validatePolicyRoute(await deps.catalog(), record.route.provider, record.route.model, record.route.reasoningEffort, deps.settings().effortCap);
         return { ...config, ...record.route };
     }, { prepend: true });
+    const confirmMainRequest = (session, requestSeq, turn) => {
+        const status = mainStatus.get(session.id);
+        const actual = session.requestHeader()?.config;
+        if (!enabled(session.id) || !status?.decision || !actual)
+            return;
+        const d = { ...status.decision, status: status.decision.status === 'unsupported' ? 'unsupported' : actual.reasoningEffort === status.effort && actual.provider === status.decision.provider && actual.model === status.decision.model ? 'applied' : 'failed', ...(actual.model ? { model: actual.model } : {}), ...(actual.provider ? { provider: actual.provider } : {}) };
+        mainStatus.set(session.id, { ...status, decision: d });
+        latest.set(session.id, d);
+        if (d.status === 'applied') {
+            applied.set(session.id, d);
+            requestMetadata.set(session.id, { requestSeq, appliedAt: Date.now(), ...(turn !== undefined ? { requestTurn: turn } : {}) });
+        }
+        else
+            applied.delete(session.id);
+    };
     ctx.on('session/event', (session, event) => {
         if (event.type === 'assistant/message') {
+            // Unchanged requests reuse the durable header and emit no request/header event.
+            if (!applied.has(session.id) && mainStatus.get(session.id)?.decision?.status === 'recommended') {
+                const header = session.snapshotEvents().findLast(e => e.type === 'request/header');
+                if (header)
+                    confirmMainRequest(session, header.seq, event.data.turn);
+            }
             const d = applied.get(session.id);
             const data = event.data;
             if (d?.status === 'applied' && enabled(session.id) && data.message?.id && d.model) {
@@ -243,18 +303,7 @@ export function policyHost(ctx, deps) {
         requestMetadata.delete(session.id);
         const record = deps.store.get(session.id);
         if (!record?.route) {
-            const status = mainStatus.get(session.id);
-            const actual = event.data.header?.config;
-            if (enabled(session.id) && status?.decision && actual) {
-                const d = { ...status.decision, status: status.decision.status === 'unsupported' ? 'unsupported' : actual.reasoningEffort === status.effort && actual.provider === status.decision.provider && actual.model === status.decision.model ? 'applied' : 'failed', ...(actual.model ? { model: actual.model } : {}), ...(actual.provider ? { provider: actual.provider } : {}) };
-                mainStatus.set(session.id, { ...status, decision: d });
-                latest.set(session.id, d);
-                if (d.status === 'applied') {
-                    applied.set(session.id, d);
-                    const data = event.data;
-                    requestMetadata.set(session.id, { requestSeq: event.seq, appliedAt: Date.now(), ...(typeof data.turn === 'number' ? { requestTurn: data.turn } : {}) });
-                }
-            }
+            confirmMainRequest(session, event.seq, event.data.turn);
             return;
         }
         const actual = event.data.header?.config;
@@ -268,6 +317,7 @@ export function policyHost(ctx, deps) {
             throw new Error('policy-v2 实际请求配置不匹配');
     });
     return {
+        appliedDecision: (id) => enabled(id) ? applied.get(id)?.id : undefined,
         invalidate: (id) => { epochs.set(id, epoch(id) + 1); mainStatus.delete(id); latest.delete(id); applied.delete(id); },
         status: (id) => deps.store.get(id), mainStatus: (id) => enabled(id) ? { ...mainStatus.get(id), ...(latest.get(id) ? { decision: latest.get(id) } : {}) } : undefined,
     };

package/lib/policy-store.d.ts

@@ -27,6 +27,7 @@ declare const schema: z.ZodObject<{
             claude: "claude";
             codex: "codex";
             "dsh-magpie-connect": "dsh-magpie-connect";
+            "dsh-magpie-connector": "dsh-magpie-connector";
         }>;
         model: z.ZodOptional<z.ZodString>;
         reasoningEffort: z.ZodOptional<z.ZodString>;
@@ -57,6 +58,7 @@ declare const schema: z.ZodObject<{
             claude: "claude";
             codex: "codex";
             "dsh-magpie-connect": "dsh-magpie-connect";
+            "dsh-magpie-connector": "dsh-magpie-connector";
         }>;
         model: z.ZodString;
         reasoningEffort: z.ZodEnum<{
@@ -71,6 +73,7 @@ declare const schema: z.ZodObject<{
             claude: "claude";
             codex: "codex";
             "dsh-magpie-connect": "dsh-magpie-connect";
+            "dsh-magpie-connector": "dsh-magpie-connector";
         }>;
         model: z.ZodString;
         reasoningEffort: z.ZodEnum<{

package/lib/policy-store.js

@@ -2,14 +2,15 @@ import { createHash, randomUUID } from 'node:crypto';
 import { mkdirSync, readFileSync, writeFileSync, renameSync, chmodSync } from 'node:fs';
 import { join } from 'node:path';
 import { z } from 'zod';
-const route = z.object({ provider: z.enum(['claude', 'codex', 'dsh-magpie-connect']), model: z.string().min(1).max(128), reasoningEffort: z.enum(['low', 'medium', 'high', 'xhigh']) }).strict();
+import { POLICY_PROVIDERS } from './policy-v2.js';
+const route = z.object({ provider: z.enum(POLICY_PROVIDERS), model: z.string().min(1).max(128), reasoningEffort: z.enum(['low', 'medium', 'high', 'xhigh']) }).strict();
 const schema = z.object({
     version: z.literal(1), childId: z.string(), parentId: z.string(), rootId: z.string(),
     policyVersion: z.string(), mappingVersion: z.string(),
     status: z.enum(['recommended', 'applied', 'unsupported', 'needs-context', 'failed']),
     path: z.enum(['ordinary', 'teammate', 'fork']),
     family: z.enum(['claude', 'codex']).optional(),
-    explicit: z.object({ provider: z.enum(['claude', 'codex', 'dsh-magpie-connect']), model: z.string().optional(), reasoningEffort: z.string().optional() }).strict(),
+    explicit: z.object({ provider: z.enum(POLICY_PROVIDERS), model: z.string().optional(), reasoningEffort: z.string().optional() }).strict(),
     decision: z.object({ id: z.number(), source: z.enum(['main', 'subagent']), tier: z.string(), depth: z.string(), capability: z.string().optional(), effort: z.string(), model: z.string().optional(), provider: z.string().optional(), status: z.string(), ms: z.number(), decisionProvider: z.string(), decisionModel: z.string(), confidence: z.number().min(0).max(1).optional(), capabilityConfidence: z.number().min(0).max(1).optional(), probabilities: z.record(z.string(), z.number().min(0).max(1)).optional(), capabilityProbabilities: z.record(z.string(), z.number().min(0).max(1)).optional() }).strict().optional(),
     route: route.optional(), actual: route.optional(), reason: z.string().max(240).optional(),
 }).strict();

package/lib/policy-v2.d.ts

@@ -1,8 +1,9 @@
 import type { Capability, Depth } from './jev.js';
 import { type ChildProvider } from './effort.js';
 import { type AutomaticEffort, type RoutingCatalog } from './settings-contract.js';
-export declare const MAGPIE_PROVIDER = "dsh-magpie-connect";
-export type PolicyProvider = ChildProvider | typeof MAGPIE_PROVIDER;
+export declare const POLICY_PROVIDERS: readonly ["claude", "codex", "dsh-magpie-connect", "dsh-magpie-connector"];
+export type PolicyProvider = typeof POLICY_PROVIDERS[number];
+export declare function magpieProvider(value: string): value is 'dsh-magpie-connect' | 'dsh-magpie-connector';
 export declare function policyProvider(value: string): value is PolicyProvider;
 export declare function modelFamily(provider: string, model: string): ChildProvider | undefined;
 export declare function validatePolicyRoute(catalog: RoutingCatalog, provider: string, model: string, effort: string, cap: AutomaticEffort): void;

package/lib/policy-v2.js

@@ -1,19 +1,20 @@
 import { targetEffort } from './effort.js';
 import { AUTO_EFFORTS } from './settings-contract.js';
 import { MODEL_ID_PATTERN } from './settings-validation.js';
-export const MAGPIE_PROVIDER = 'dsh-magpie-connect';
-export function policyProvider(value) { return value === MAGPIE_PROVIDER || value === 'claude' || value === 'codex'; }
+export const POLICY_PROVIDERS = ['claude', 'codex', 'dsh-magpie-connect', 'dsh-magpie-connector'];
+export function magpieProvider(value) { return value === 'dsh-magpie-connect' || value === 'dsh-magpie-connector'; }
+export function policyProvider(value) { return POLICY_PROVIDERS.some(provider => provider === value); }
 export function modelFamily(provider, model) {
     if (provider === 'claude' || provider === 'codex')
         return provider;
-    if (provider !== MAGPIE_PROVIDER)
+    if (!magpieProvider(provider))
         return undefined;
     const family = model.split('/')[0];
     return family === 'claude' || family === 'codex' ? family : undefined;
 }
 export function validatePolicyRoute(catalog, provider, model, effort, cap) {
     const entry = catalog.models.find(m => m.provider === provider && m.model === model);
-    const validId = provider === MAGPIE_PROVIDER ? /^[A-Za-z0-9._:-]+(?:\/[A-Za-z0-9._:-]+)+$/.test(model) && model.length <= 128 : MODEL_ID_PATTERN.test(model);
+    const validId = magpieProvider(provider) ? /^[A-Za-z0-9._:-]+(?:\/[A-Za-z0-9._:-]+)+$/.test(model) && model.length <= 128 : MODEL_ID_PATTERN.test(model);
     if (!policyProvider(provider) || !validId || !entry || !AUTO_EFFORTS.includes(effort) || AUTO_EFFORTS.indexOf(effort) > AUTO_EFFORTS.indexOf(cap) || !entry.reasoningEfforts.includes(effort) || catalog.childAllowlist.status !== 'enabled' || !catalog.childAllowlist.allowedModels.some(m => m.provider === provider && m.model === model))
         throw new Error('策略路由不在当前目录/允许列表或 effort 上限内；暂停委派并询问用户');
 }
@@ -42,10 +43,10 @@ export function policyEffort(model, depth, supported, cap, defaultEffort) {
     return AUTO_EFFORTS.indexOf(chosen) > AUTO_EFFORTS.indexOf(cap) ? allowed.at(-1) : chosen;
 }
 export function choosePolicyRoute(provider, capability, depth, catalog, cap, explicit = {}, family) {
-    const selectedFamily = provider === MAGPIE_PROVIDER ? family : provider;
+    const selectedFamily = magpieProvider(provider) ? family : provider;
     if (!explicit.model && !selectedFamily)
         throw new Error('unsupported：没有已定义的模型能力家族；请显式指定模型');
-    const model = explicit.model ?? `${provider === MAGPIE_PROVIDER ? `${selectedFamily}/` : ''}${POLICY_MODELS[selectedFamily][capability]}`;
+    const model = explicit.model ?? `${magpieProvider(provider) ? `${selectedFamily}/` : ''}${POLICY_MODELS[selectedFamily][capability]}`;
     const entry = catalog.models.find(m => m.provider === provider && m.model === model);
     const reasoningEffort = explicit.reasoningEffort ?? policyEffort(model, depth, entry?.reasoningEfforts ?? [], cap, entry?.defaultEffort);
     validatePolicyRoute(catalog, provider, model, reasoningEffort, cap);

package/lib/settings-host.js

@@ -1,6 +1,7 @@
 import { credentialRef } from '@deepseek-ai/dsh-credentials';
 import { launchEnvironmentOf } from '@deepseek-ai/dsh-launch-environment';
 import { DEFAULT_SETTINGS, SettingsValidationError } from './settings.js';
+import { magpieProvider } from './policy-v2.js';
 import rubric from './rubric.json' with { type: 'json' };
 import { JevClient } from './jev.js';
 import { DECISION_SERVICES } from './decision-service.js';
@@ -10,7 +11,7 @@ export function settingsHost(ctx, store) {
     const environment = launchEnvironmentOf(ctx);
     const credentials = () => ctx.get('credentials');
     const catalog = async (includeMagpie = store.read().settings.policy === 'policy-v2') => {
-        const models = (await Promise.all(ctx.llm.listProviders().filter(p => p.id === 'claude' || p.id === 'codex' || (includeMagpie && p.id === 'dsh-magpie-connect')).map(async (provider) => {
+        const models = (await Promise.all(ctx.llm.listProviders().filter(p => p.id === 'claude' || p.id === 'codex' || (includeMagpie && magpieProvider(p.id))).map(async (provider) => {
             try {
                 return await Promise.all((await ctx.llm.listModels(provider.id)).map(async (model) => {
                     try {
@@ -31,7 +32,7 @@ export function settingsHost(ctx, store) {
         try {
             if (service) {
                 const current = service.current();
-                return { models, childAllowlist: { status: current.enabled ? 'enabled' : 'disabled', allowedModels: current.allowedModels.filter(r => r.provider === 'claude' || r.provider === 'codex' || (includeMagpie && r.provider === 'dsh-magpie-connect')) } };
+                return { models, childAllowlist: { status: current.enabled ? 'enabled' : 'disabled', allowedModels: current.allowedModels.filter(r => r.provider === 'claude' || r.provider === 'codex' || (includeMagpie && magpieProvider(r.provider))) } };
             }
         }
         catch { /* An unavailable policy must never broaden the allowed routes. */ }

package/lib/subagent-tool.js

@@ -5,7 +5,7 @@ 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 { choosePolicyRoute, magpieProvider, modelFamily, POLICY_PROVIDERS } 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) {
@@ -27,7 +27,7 @@ export function routeSubagentTool(jev, deps) {
         timeoutMs: 5000,
         parameters: {
             task: { type: 'string', required: true, description: 'The task the sub-agent will do.' },
-            provider: { type: 'string', required: true, enum: ['claude', 'codex', 'dsh-magpie-connect'], description: 'Exact transport provider. Magpie is available only under policy-v2.' },
+            provider: { type: 'string', required: true, enum: [...POLICY_PROVIDERS], 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.' },
@@ -76,7 +76,7 @@ export function routeSubagentTool(jev, deps) {
                 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')
+            if (magpieProvider(args.provider))
                 throw new Error('Magpie 路由需显式选择 policy-v2；原策略不变');
             const result = await jev.judge(buildState({ text: args.task }), exec.signal);
             if (result.kind === 'cancelled')

package/lib/support.d.ts

@@ -0,0 +1,25 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+/** One main-session model selection as the AUTO support gate needs it. */
+export interface MainSelection {
+    provider: string;
+    model: string;
+}
+/**
+ * AUTO only manages the Claude / GPT model families.
+ *
+ * The transport prefix (`claude/...`, `codex/...` on Magpie) is not part of the
+ * family name, so it is stripped before matching. Every other family — DeepSeek,
+ * GLM, Grok, Gemini, Kimi, Qwen, ... — is explicitly out of scope and locks the
+ * session to MANUAL instead of being guessed at.
+ */
+export declare function autoSupportedModel(model: string | undefined): boolean;
+/** An unknown selection must never lock a session: only a proven mismatch does. */
+export declare function mainSupported(selection: MainSelection | undefined): boolean;
+/**
+ * The main session's current model selection, most-authoritative signal first:
+ * the official pending pick (`model/selection` projection), then the last actual
+ * request header, then the creation-time agent options. Undefined when none can
+ * be read; callers treat that as "unknown, do not lock".
+ */
+export declare function currentMainSelection(ctx: Context, agent: Agent): MainSelection | undefined;

package/lib/support.js

@@ -0,0 +1,40 @@
+/**
+ * AUTO only manages the Claude / GPT model families.
+ *
+ * The transport prefix (`claude/...`, `codex/...` on Magpie) is not part of the
+ * family name, so it is stripped before matching. Every other family — DeepSeek,
+ * GLM, Grok, Gemini, Kimi, Qwen, ... — is explicitly out of scope and locks the
+ * session to MANUAL instead of being guessed at.
+ */
+export function autoSupportedModel(model) {
+    if (typeof model !== 'string' || model.length === 0)
+        return false;
+    const bare = model.includes('/') ? model.slice(model.lastIndexOf('/') + 1) : model;
+    return /^(?:claude|gpt)-/i.test(bare);
+}
+/** An unknown selection must never lock a session: only a proven mismatch does. */
+export function mainSupported(selection) {
+    return selection === undefined || autoSupportedModel(selection.model);
+}
+/**
+ * The main session's current model selection, most-authoritative signal first:
+ * the official pending pick (`model/selection` projection), then the last actual
+ * request header, then the creation-time agent options. Undefined when none can
+ * be read; callers treat that as "unknown, do not lock".
+ */
+export function currentMainSelection(ctx, agent) {
+    try {
+        const service = ctx.get('sessionProjections');
+        const pending = service?.stateOf(agent.session, 'modelSelection')?.pending;
+        if (pending && typeof pending.provider === 'string' && typeof pending.model === 'string')
+            return { provider: pending.provider, model: pending.model };
+    }
+    catch { /* optional projection: fall through to the durable header */ }
+    const header = agent.session.requestHeader()?.config;
+    if (header && typeof header.provider === 'string' && typeof header.model === 'string')
+        return { provider: header.provider, model: header.model };
+    const options = agent.options;
+    if (typeof options.provider === 'string' && typeof options.model === 'string')
+        return { provider: options.provider, model: options.model };
+    return undefined;
+}

package/lib/usage-report.d.ts

@@ -40,6 +40,25 @@ export declare function buildReport(home: string, options?: {
                 };
             };
             feedback: Record<string, number>;
+            implicit: {
+                counts: {
+                    explicit: number;
+                    negative: number;
+                    'implicit-ok': number;
+                    inconclusive: number;
+                    unobserved: number;
+                };
+                explicit: {
+                    conflict: number;
+                };
+                exposedExplicit: {
+                    conflict: number;
+                };
+                negative: {
+                    'aborted-user': number;
+                    'manual-switch': number;
+                };
+            };
             conclusion: string;
         }[];
     }[];

package/lib/usage-report.js

@@ -18,6 +18,10 @@ const CAVEATS = [
     'token-semantics-differ-by-provider',
     'reference-before-auto-effort-only-confounded',
     'mode-history-not-persisted',
+    'implicit-ok-not-appropriateness',
+    'exposure-not-proof-of-reading',
+    'historical-exposure-unknown',
+    'exposure-after-continuation-excluded',
 ];
 const sorted = (record) => Object.fromEntries(Object.entries(record).sort(([a], [b]) => a.localeCompare(b)));
 const round = (n) => Math.round(n * 100) / 100;
@@ -122,14 +126,25 @@ function readSession(file, failures) {
     }
     const calls = [];
     const seen = new Set();
+    const ends = new Map(), userStarts = new Map();
+    let startedAt;
     let turn, userTurn;
     let config = {};
     for (const event of events) {
         const data = event.data ?? {};
-        if (event.type === 'turn/start')
+        if (event.type === 'turn/start') {
             turn = data.turn;
-        else if (event.type === 'user/message' && data.source?.kind === 'user' && turn !== undefined)
+            startedAt = event.time;
+        }
+        else if (event.type === 'user/message' && data.source?.kind === 'user' && turn !== undefined) {
             userTurn = turn;
+            if (typeof startedAt === 'number')
+                userStarts.set(turn, startedAt);
+        }
+        else if (event.type === 'turn/end' && typeof data.turn === 'number') {
+            const reason = data.reason;
+            ends.set(data.turn, reason?.kind === 'aborted' ? reason.reason?.kind === 'user' ? 'aborted-user' : 'aborted-other' : ['completed', 'blocked'].includes(reason?.kind) ? reason.kind : 'other');
+        }
         else if (event.type === 'request/header' && data.header?.config)
             config = data.header.config;
         else if (event.type === 'assistant/message') {
@@ -143,10 +158,10 @@ function readSession(file, failures) {
             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 } : {}) });
+            calls.push({ id, ...(typeof data.turn === 'number' ? { turn: data.turn } : turn === undefined ? {} : { turn }), ...(userTurn === undefined ? {} : { userTurn }), time: event.time, usage, ...(config.model ? { model: config.model } : {}), ...(config.reasoningEffort ? { effort: config.reasoningEffort } : {}) });
         }
     }
-    return { header, calls };
+    return { header, calls, ends, userStarts };
 }
 function localMidnight(date) {
     const [y, m, d] = date.split('-').map(Number);
@@ -208,6 +223,15 @@ export function buildReport(home, options = {}) {
             excluded.seeded++;
             continue;
         }
+        const nextUserStart = new Map();
+        let next;
+        const turns = [...new Set([...log.calls.flatMap(call => call.turn === undefined ? [] : [call.turn]), ...log.userStarts.keys()])].sort((a, b) => b - a);
+        for (const turn of turns) {
+            if (next !== undefined)
+                nextUserStart.set(turn, next);
+            if (log.userStarts.has(turn))
+                next = log.userStarts.get(turn);
+        }
         const linked = new Set();
         let v2First;
         for (const call of log.calls) {
@@ -220,10 +244,12 @@ export function buildReport(home, options = {}) {
             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() };
+                d = { session, id: b.decisionId, 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);
+            d.end = call.turn === undefined ? 'unknown' : log.ends.get(call.turn) ?? 'unknown';
+            d.continuation = call.turn === undefined ? undefined : nextUserStart.get(call.turn);
             if (b.feedback)
                 d.feedback.add(b.feedback);
         }
@@ -269,6 +295,36 @@ export function buildReport(home, options = {}) {
             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 implicit = {
+                counts: { explicit: 0, negative: 0, 'implicit-ok': 0, inconclusive: 0, unobserved: 0 },
+                explicit: { ...Object.fromEntries(FEEDBACK.map(f => [f, 0])), conflict: 0 },
+                exposedExplicit: { ...Object.fromEntries(FEEDBACK.map(f => [f, 0])), conflict: 0 },
+                negative: { 'aborted-user': 0, 'manual-switch': 0 },
+            };
+            for (const d of list) {
+                const facts = book.facts(d.session, d.id);
+                const exposed = facts.exposed !== undefined && (d.continuation === undefined || facts.exposed < d.continuation);
+                const label = d.feedback.size > 1 ? 'conflict' : [...d.feedback][0];
+                if (label) {
+                    implicit.counts.explicit++;
+                    bump(implicit.explicit, label);
+                    if (exposed)
+                        bump(implicit.exposedExplicit, label);
+                }
+                else if (d.end === 'aborted-user' || facts['manual-switch'] !== undefined) {
+                    implicit.counts.negative++;
+                    if (d.end === 'aborted-user')
+                        implicit.negative['aborted-user']++;
+                    if (facts['manual-switch'] !== undefined)
+                        implicit.negative['manual-switch']++;
+                }
+                else if (exposed && d.end === 'completed' && d.continuation !== undefined)
+                    implicit.counts['implicit-ok']++;
+                else if (exposed)
+                    implicit.counts.inconclusive++;
+                else
+                    implicit.counts.unobserved++;
+            }
             const byEffort = {};
             for (const d of list) {
                 const e = (byEffort[d.effort] ??= { decisions: 0, calls: 0 });
@@ -278,7 +334,7 @@ export function buildReport(home, options = {}) {
             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,
+                tokens: tokens(calls), byEffort: sorted(byEffort), feedback, implicit,
                 conclusion: list.length >= 20 && sessions >= 3 ? 'observed' : 'insufficient-sample',
             };
         }),

package/package.json

@@ -1,13 +1,26 @@
 {
   "name": "dsh-auto-model-routing",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "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" },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/prgrmrwy/dsh-auto-model-routing.git"
+  },
   "homepage": "https://github.com/prgrmrwy/dsh-auto-model-routing#readme",
-  "bugs": { "url": "https://github.com/prgrmrwy/dsh-auto-model-routing/issues" },
-  "keywords": ["dsh", "dsh-plugin", "deepseek-harness", "reasoning-effort", "model-routing", "jev", "subagent"],
+  "bugs": {
+    "url": "https://github.com/prgrmrwy/dsh-auto-model-routing/issues"
+  },
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "deepseek-harness",
+    "reasoning-effort",
+    "model-routing",
+    "jev",
+    "subagent"
+  ],
   "type": "module",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",

package/skills/auto-model-routing-report/SKILL.md

@@ -39,6 +39,11 @@ description: 仅当用户明确要求评估 AUTO 效果、观察 AUTO 期间的
      - `token-semantics-differ-by-provider`：不同 provider 的 token 口径可能不同，不要跨模型比较。
      - `reference-before-auto-effort-only-confounded`：`referenceBeforeAuto` 只用于看 effort 起点的变化；它受会话阶段、任务类型、模型切换等因素混杂，不能当作对照组。
      - `mode-history-not-persisted`：会话模式的切换历史没有保存，会话计数只是粗略参考。
+     - `implicit-ok-not-appropriateness`：隐式无异议不等于分配合适，不能计作显式好评。
+     - `exposure-not-proof-of-reading`：前台可见 3 秒只是曝光，不证明用户读过。
+     - `historical-exposure-unknown`：上线前的曝光未知，不回填。
+     - `exposure-after-continuation-excluded`：下一用户回合之后才出现的曝光不算，避免翻看旧记录制造认可。
+   - `implicit.counts` 按优先级把决策分为显式评价、负向行为、隐式无异议、无定论、未曝光，五类合计为决策数；`implicit.negative` 的两个原因可重叠。`implicit.exposedExplicit` 是有效曝光且有显式评价的参照，不是准确率。
    - 不要自行计算节省百分比，不要说“质量不变”，也不要把“首个记录之前”称为 MANUAL。
    - token 均值的分母是**出现该字段的调用数**（`present`）；值为 `null` 表示该字段从未出现，不是 0。