dsh-auto-model-routing 0.4.0 → 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

@@ -0,0 +1,78 @@
+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>;
+            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;
+        }[];
+    }[];
+    referenceBeforeAuto: {
+        model: string;
+        calls: number;
+        sessions: number;
+        effort: {
+            [k: string]: number;
+        };
+        autoEffort: {
+            [k: string]: number;
+        };
+    }[];
+    caveats: string[];
+};
+export {};