@co0ontty/wand 4.87.0 → 4.88.0-beta.gb1ee942

package/README.md

@@ -271,7 +271,7 @@ wand config:set port 9443
 
 ### 语音识别
 
-Web、Android、iOS 可在语音输入设置中选择「服务端识别」或「客户端本地识别」。服务端使用按需安装的 whisper.cpp 多语言模型，支持无 GPU CPU 服务器、Mac mini Metal 与可选 CUDA；模型不随普通构建下载。部署、模型大小、鉴权和隐私边界见 [服务端语音识别](docs/server-speech.md)。
+Web、Android、iOS 可在语音输入设置中选择「服务端识别」或「客户端本地识别」。服务端使用按需安装的 whisper.cpp 多语言模型，支持无 GPU CPU 服务器、Mac mini Metal 与可选 CUDA；模型不随普通构建下载。部署、模型大小、鉴权和隐私边界见 [服务端语音识别](docs/server-speech.md)。设置内下载/初始化 LAYA 与语音模型，以及「决策专家」的本机性能检查和默认本地/免费调用链，见 [本地模型管理](docs/local-model-setup.md)。
 
 ### 可选本地决策（实验性）
 

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
-  "commit": "d2f0f8fd339f2c9b668c596b443fb8d1b0756783",
-  "builtAt": "2026-10-09T02:40:15.225Z",
-  "version": "4.87.0",
-  "channel": "stable"
+  "commit": "b1ee94297085a10acc1bd9b7da943e1a12435851",
+  "builtAt": "2026-10-09T07:09:46.631Z",
+  "version": "4.88.0-beta.gb1ee942",
+  "channel": "beta"
 }

package/dist/decision-expert-service.d.ts

@@ -0,0 +1,45 @@
+import { type DecisionHardwareAssessment } from "./decision-hardware.js";
+import { type DecisionRequest, type DecisionResult } from "./decision-types.js";
+import type { DecisionService } from "./decision-service.js";
+import type { SiliconEmployee } from "./ai-team-types.js";
+import { type OpenRouterFreeModelsService } from "./openrouter-free-models.js";
+import type { WandConfig } from "./types.js";
+import type { WandTaskAgent } from "./task-types.js";
+interface DecisionExpertDeps {
+    employee(): SiliconEmployee | null;
+    local: Pick<DecisionService, "status" | "evaluate">;
+    free: Pick<OpenRouterFreeModelsService, "status" | "resolveForCall">;
+    config: Pick<WandConfig, "modelGroups">;
+    hardware?: () => DecisionHardwareAssessment;
+    timeoutMs?: number;
+    /** Tests may inject a free, no-tool structured generator; production never silently swaps engine. */
+    generate?: (agent: WandTaskAgent, request: DecisionRequest, employee: SiliconEmployee, signal?: AbortSignal) => Promise<{
+        answers: unknown;
+        inputTokens: number;
+        outputTokens: number;
+        model: string;
+    }>;
+}
+/** Dedicated bounded employee evaluator. LAYA is not sent to a chat provider as a fake model ID. */
+export declare class DecisionExpertService {
+    private readonly deps;
+    private active;
+    constructor(deps: DecisionExpertDeps);
+    status(): {
+        enabled: boolean;
+        supported: boolean;
+        configured: boolean;
+        state: string;
+        queued: number;
+        completed: number;
+        failed: number;
+        experimental: true;
+        hardware: DecisionHardwareAssessment;
+        employeeId: string;
+        employeeName: string;
+        notice: string | null;
+    };
+    evaluate(value: unknown, caller: string, signal?: AbortSignal): Promise<DecisionResult>;
+    private generate;
+}
+export {};

package/dist/decision-expert-service.js

@@ -0,0 +1,105 @@
+import { DECISION_EXPERT_ID, DECISION_EXPERT_KEY, WAND_LOCAL_DECISION_MODEL } from "./decision-expert-identity.js";
+import { decisionHardware } from "./decision-hardware.js";
+import { DecisionError, parseDecisionRequest, parseDecisionResult } from "./decision-types.js";
+import { isOpenRouterFreeSelector, OPENROUTER_FREE_ROUTING } from "./openrouter-free-models.js";
+import { freeModelOrder } from "./model-groups.js";
+import { normalizeContext } from "@earendil-works/pi-ai";
+/** Dedicated bounded employee evaluator. LAYA is not sent to a chat provider as a fake model ID. */
+export class DecisionExpertService {
+    deps;
+    active = 0;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    status() {
+        const local = this.deps.local.status(), employee = this.deps.employee(), free = this.deps.free.status();
+        const hardware = (this.deps.hardware ?? decisionHardware)();
+        const backup = employee?.agents.some(agent => agent.provider === "pi" && agent.engine === "sdk" && agent.kind === "structured" && isOpenRouterFreeSelector(agent.model)) && free.configured && free.modelCount > 0;
+        const primary = employee?.agents.some(agent => agent.provider === "pi" && agent.engine === "sdk" && agent.kind === "structured" && agent.model === WAND_LOCAL_DECISION_MODEL);
+        return { enabled: !!employee, supported: true, configured: !!employee && ((!!primary && hardware.suitable && local.supported && local.enabled && local.configured) || !!backup),
+            state: local.state, queued: this.active, completed: local.completed, failed: local.failed, experimental: true,
+            hardware, employeeId: employee?.id ?? DECISION_EXPERT_ID, employeeName: employee?.name ?? "决策专家",
+            notice: !hardware.suitable ? hardware.message : !local.enabled || !local.configured ? "本地决策未就绪，可初始化 LAYA 或配置「决策专家」员工调用链使用备用免费分组。" : null };
+    }
+    async evaluate(value, caller, signal) {
+        const request = parseDecisionRequest(value), employee = this.deps.employee();
+        if (!employee || employee.systemKey !== DECISION_EXPERT_KEY)
+            throw new DecisionError("UNAVAILABLE", "请先配置「决策专家」员工调用链。", 503);
+        if (signal?.aborted)
+            throw new DecisionError("CANCELLED", "决策已取消。", 499);
+        if (this.active >= 8)
+            throw new DecisionError("BUSY", "决策专家队列已满，请稍后重试。", 429);
+        this.active += 1;
+        const deadline = new AbortController();
+        const timeout = new DecisionError("TIMEOUT", "决策专家请求超时，请稍后重试或调整该员工调用链。", 504);
+        const timer = setTimeout(() => deadline.abort(timeout), this.deps.timeoutMs ?? 45_000);
+        signal = signal ? AbortSignal.any([signal, deadline.signal]) : deadline.signal;
+        try {
+            const hardware = (this.deps.hardware ?? decisionHardware)();
+            for (let candidate = 0; candidate < employee.agents.length; candidate += 1) {
+                const agent = employee.agents[candidate];
+                if (agent.model === WAND_LOCAL_DECISION_MODEL) {
+                    if (agent.provider !== "pi" || agent.engine !== "sdk" || agent.kind !== "structured")
+                        throw new DecisionError("CONFIGURATION_REQUIRED", "本地 LAYA 候选需使用 Wand 决策执行入口；请核对「决策专家」调用链。", 503);
+                    const local = this.deps.local.status();
+                    if (!hardware.suitable || !local.enabled || !local.configured || !local.supported)
+                        continue;
+                    try {
+                        const result = await this.deps.local.evaluate(request, caller, signal);
+                        return { ...result, executor: { employeeId: employee.id, candidate, source: "local" } };
+                    }
+                    catch (error) {
+                        if (deadline.signal.aborted)
+                            throw timeout;
+                        if (signal?.aborted || (error instanceof DecisionError && ["CANCELLED", "INVALID_REQUEST", "RATE_LIMIT", "BUSY"].includes(error.code)))
+                            throw error;
+                        // This is read-only inference, never a replay of a tool/task side effect.
+                        continue;
+                    }
+                }
+                if (!isOpenRouterFreeSelector(agent.model)) {
+                    // A missing free pool never authorizes using an arbitrary/paid provider behind the user's back.
+                    throw new DecisionError("CONFIGURATION_REQUIRED", "此建议仅允许已配置的本地决策或 Wand 免费分组；请核对「决策专家」调用链与费用边界。", 503);
+                }
+                if (agent.provider !== "pi" || agent.engine !== "sdk")
+                    throw new DecisionError("CONFIGURATION_REQUIRED", "建议的免费分组候选需使用 Wand Agent；不会用另一引擎冒充，请配置「决策专家」调用链。", 503);
+                try {
+                    const generated = await (this.deps.generate ?? this.generate.bind(this))(agent, request, employee, signal);
+                    const result = parseDecisionResult({ answers: generated.answers, usage: { input_tokens: generated.inputTokens, output_tokens: generated.outputTokens, truncated: false } }, request, { model: generated.model, runtime: "decision-expert" });
+                    return { ...result, executor: { employeeId: employee.id, candidate, source: "free-group" } };
+                }
+                catch (error) {
+                    if (deadline.signal.aborted)
+                        throw timeout;
+                    if (signal?.aborted)
+                        throw new DecisionError("CANCELLED", "决策专家请求已取消。", 499);
+                    // Once a free model request was sent, don't silently repeat it via another candidate.
+                    throw new DecisionError("CONFIGURATION_REQUIRED", "决策专家免费分组调用失败或结果无效，请同步免费分组并配置该员工调用链。", 503);
+                }
+            }
+            throw new DecisionError("CONFIGURATION_REQUIRED", !hardware.suitable ? hardware.message : "决策专家没有当前可用的候选；请初始化 LAYA 或配置该员工备用调用链。", 503);
+        }
+        finally {
+            clearTimeout(timer);
+            this.active -= 1;
+        }
+    }
+    async generate(agent, request, employee, signal) {
+        const order = freeModelOrder(this.deps.config.modelGroups);
+        const checked = await this.deps.free.resolveForCall(agent.model, signal, order.length ? { allowedSelectors: order } : {});
+        const { streamSimple } = await import("@earendil-works/pi-ai/api/openai-completions");
+        const model = checked.model;
+        const message = await streamSimple(model, normalizeContext({
+            systemPrompt: `${employee.prompt}\n只输出JSON对象 {"answers":{...}}。对每题保留type；choice给choice和所有criteria的probabilities(总和1)，score给score和以0开始索引的probabilities(总和1)，noul给0到1的noul。不得输出工具调用、执行操作或增加候选。概率是实验性辅助而非授权。`,
+            messages: [{ role: "user", content: JSON.stringify(request), timestamp: Date.now() }], tools: [],
+        }), { apiKey: checked.apiKey, signal, maxTokens: Math.min(4096, model.maxTokens), toolChoice: "none",
+            onPayload: payload => ({ ...payload, provider: OPENROUTER_FREE_ROUTING }) }).result();
+        if (message.stopReason === "error" || message.stopReason === "aborted" || message.content.some(part => part.type === "toolCall"))
+            throw new Error("Decision expert failed");
+        const text = message.content.filter(part => part.type === "text").map(part => part.text).join("").trim();
+        if (text.length > 32768)
+            throw new Error("Decision expert output too large");
+        const body = JSON.parse(text);
+        return { answers: body.answers, inputTokens: message.usage.input, outputTokens: message.usage.output, model: `${model.provider}/${model.id}` };
+    }
+}

package/dist/decision-types.d.ts

@@ -26,7 +26,12 @@ export interface DecisionResult {
         truncated?: boolean;
     };
     experimental: true;
-    runtime: "laya-mlx";
+    runtime: "laya-mlx" | "decision-expert";
+    executor?: {
+        employeeId: string;
+        candidate: number;
+        source: "local" | "free-group";
+    };
 }
 export declare class DecisionError extends Error {
     readonly code: string;
@@ -34,4 +39,7 @@ export declare class DecisionError extends Error {
     constructor(code: string, message: string, status?: number);
 }
 export declare function parseDecisionRequest(value: unknown): DecisionRequest;
-export declare function parseDecisionResult(raw: unknown, request: DecisionRequest): DecisionResult;
+export declare function parseDecisionResult(raw: unknown, request: DecisionRequest, identity?: {
+    model: string;
+    runtime: DecisionResult["runtime"];
+}): DecisionResult;

package/dist/decision-types.js

@@ -93,7 +93,7 @@ export function parseDecisionRequest(value) {
     // Detach the accepted input from caller mutations while it waits in the queue.
     return JSON.parse(JSON.stringify({ state: value.state, questions }));
 }
-export function parseDecisionResult(raw, request) {
+export function parseDecisionResult(raw, request, identity = { model: DECISION_CHECKPOINT, runtime: "laya-mlx" }) {
     const fail = () => { throw new DecisionError("INVALID_RESULT", "决策引擎返回了无效结果。", 502); };
     if (!record(raw) || !record(raw.answers) || !record(raw.usage))
         return fail();
@@ -127,9 +127,10 @@ export function parseDecisionResult(raw, request) {
         }
     }
     if (!Number.isSafeInteger(raw.usage.input_tokens) || raw.usage.input_tokens < 0
-        || raw.usage.input_tokens > DECISION_MAX_QUESTIONS * 1024 || raw.usage.output_tokens !== 0
-        || raw.usage.truncated !== false)
+        || (identity.runtime === "laya-mlx" && raw.usage.input_tokens > DECISION_MAX_QUESTIONS * 1024)
+        || !Number.isSafeInteger(raw.usage.output_tokens) || raw.usage.output_tokens < 0
+        || (identity.runtime === "laya-mlx" && raw.usage.output_tokens !== 0) || raw.usage.truncated !== false)
         return fail();
-    return { model: DECISION_CHECKPOINT, answers: answers,
-        usage: raw.usage, experimental: true, runtime: "laya-mlx" };
+    return { model: identity.model, answers: answers,
+        usage: raw.usage, experimental: true, runtime: identity.runtime };
 }

package/dist/local-model-setup.js

@@ -8,6 +8,8 @@ import { ModelFileStore } from "./model-file-store.js";
 import { runModelSetup } from "./model-setup-process.js";
 import { speechModel } from "./speech-models.js";
 import { systemEnvValue } from "./env-utils.js";
+import { decisionHardware } from "./decision-hardware.js";
+import { DECISION_EXPERT_ID } from "./decision-expert-identity.js";
 /** Deployment jobs only; existing inference owners retain their protocols, rate limits and capabilities. */
 export class LocalModelSetupService {
     deps;
@@ -24,7 +26,7 @@ export class LocalModelSetupService {
         this.root = path.join(deps.configDir, "local-models", "laya");
         this.manifest = deps.layaFiles ?? LAYA_FILES;
     }
-    supported() { return (this.deps.supportedLaya ?? (() => process.platform === "darwin" && process.arch === "arm64"))(); }
+    supported() { return (this.deps.supportedLaya ?? (() => decisionHardware().suitable))(); }
     managedModel() { return path.join(this.root, "model"); }
     async layaModel() {
         const current = this.deps.decisionConfig().modelPath;
@@ -50,15 +52,16 @@ export class LocalModelSetupService {
         const [model, python, speech] = await Promise.all([this.layaModel(), this.python(), this.deps.speech.status()]);
         const decision = this.deps.decisions.status();
         const supported = this.supported();
+        const hardware = decisionHardware();
         const operation = this.operations.get("laya") ?? null;
         const selected = speech.models.find((value) => value.id === speech.settings.model);
         return {
             laya: { kind: "laya", label: "LAYA 本地决策", supported,
-                reason: !supported ? "LAYA-MLX 当前仅支持 Apple Silicon macOS / Metal；不是聊天或授权模型。"
+                reason: !supported ? hardware.message
                     : !model.downloaded ? "模型尚未下载或完整性校验失败。" : !python ? "独立 Python/MLX 运行时尚未初始化。" : null,
                 enabled: decision.enabled, model: LAYA_REPOSITORY, modelSize: this.manifest.reduce((sum, file) => sum + file.size, 0),
                 downloaded: model.downloaded, runtimeAvailable: !!python, initialized: decision.state === "ready", busy: this.jobs.has("laya") || decision.queued > 0 || decision.state === "loading",
-                operation: operation ? { ...operation } : null },
+                operation: operation ? { ...operation } : null, hardware, decisionEmployeeId: DECISION_EXPERT_ID },
             speech: { kind: "speech", label: "服务端语音识别", supported: ["darwin", "linux", "win32"].includes(process.platform), reason: speech.reason,
                 enabled: speech.settings.enabled, model: speech.settings.model, modelSize: selected?.size ?? 0,
                 downloaded: selected?.downloaded ?? false, runtimeAvailable: speech.runtime.available, initialized: speech.initialized === true,
@@ -86,7 +89,7 @@ export class LocalModelSetupService {
         if (this.disposed)
             throw new DecisionError("UNAVAILABLE", "模型管理已关闭。", 503);
         if (kind === "laya" && !this.supported())
-            throw new DecisionError("UNSUPPORTED", "LAYA-MLX 需要 Apple Silicon macOS 与 Metal。", 409);
+            throw new DecisionError("UNSUPPORTED", `LAYA-MLX 需要 Apple Silicon macOS 与 Metal；${decisionHardware().message}`, 409);
         const input = this.parse(kind, raw);
         if (this.jobs.has(kind))
             throw new DecisionError("BUSY", "该模型已有安装任务，请等待或取消。", 409);

package/dist/local-model-types.d.ts

@@ -23,6 +23,8 @@ export interface LocalModelStatus {
     initialized: boolean;
     busy: boolean;
     operation: ModelSetupOperation | null;
+    hardware?: import("./decision-hardware.js").DecisionHardwareAssessment;
+    decisionEmployeeId?: string;
 }
 export interface LocalModelsStatus {
     laya: LocalModelStatus;

package/dist/pi-session-settings.d.ts

@@ -123,6 +123,11 @@ export interface PiSettingsResponse {
     recommendationReason?: string;
     autoResourcesAvailable?: boolean;
     autoResourcesReason?: string;
+    decisionAdvisor?: {
+        notice: string | null;
+        employeeId: string;
+        hardware: import("./decision-hardware.js").DecisionHardwareAssessment;
+    };
     /** Older automatic-resource servers do not infer CodeMode. */
     autoCodemodeAvailable?: boolean;
     /** Absent on older servers; clients must not pretend skill locks are supported. */

package/dist/server-decision-routes.d.ts

@@ -4,7 +4,7 @@ import type { DecisionService } from "./decision-service.js";
 /** Mounted before generic /api auth so inference-only capabilities cannot authorize any other route. */
 export declare function registerDecisionRoutes(app: Express, deps: {
     storage: WandStorage;
-    decisions: DecisionService;
+    decisions: Pick<DecisionService, "status" | "evaluate">;
     requireAuth: RequestHandler;
     requireSessions: RequestHandler;
 }): void;

package/dist/server-employee-routes.js

@@ -1,6 +1,8 @@
 import { randomUUID } from "node:crypto";
 import { AI_TEAM_MAX_CANDIDATES, SILICON_EMPLOYEE_AVATAR_MAX_CHARS, agentKey, isBuiltinSiliconEmployee, parseSiliconEmployeeTags, siliconEmployeeTags, } from "./ai-team-types.js";
 import { getErrorMessage } from "./error-utils.js";
+import { DECISION_EXPERT_KEY, isLocalDecisionModel } from "./decision-expert-identity.js";
+import { OPENROUTER_FREE_SELECTOR, isOpenRouterFreeSelector } from "./openrouter-free-selection.js";
 import { asyncRoute } from "./express-async.js";
 import { bodyObject, sendRouteError, text } from "./server-request.js";
 import { parseTaskAgent } from "./server-task-routes.js";
@@ -110,6 +112,10 @@ export function parseSystemEmployeeAgents(value, existing) {
             throw new Error("请选择有效的 CLI 工具或 Wand Agent。");
         if (parsed.kind !== "structured")
             throw new Error("硅基员工只支持结构化会话。");
+        if (existing.systemKey === DECISION_EXPERT_KEY && (parsed.provider !== "pi" || parsed.engine !== "sdk"
+            || !(isLocalDecisionModel(parsed.model) || parsed.model === OPENROUTER_FREE_SELECTOR || isOpenRouterFreeSelector(parsed.model)))) {
+            throw new Error("决策专家仅支持 LAYA 或 Wand 免费分组的决策候选；请使用 Wand 内部执行入口。");
+        }
         return parsed;
     });
     if (new Set(agents.map(agentKey)).size !== agents.length) {

package/dist/server-pi-recommendation-routes.d.ts

@@ -3,7 +3,13 @@ import type { DecisionService } from "./decision-service.js";
 import type { StructuredSessionManager } from "./structured-session-manager.js";
 import type { SessionRegistry } from "./session-registry.js";
 import type { WandConfig } from "./types.js";
-export type PiRecommendationRuntime = Pick<DecisionService, "evaluate" | "status">;
+export type PiRecommendationRuntime = Pick<DecisionService, "evaluate"> & {
+    status(): ReturnType<DecisionService["status"]> & Partial<{
+        notice: string | null;
+        employeeId: string;
+        hardware: import("./decision-hardware.js").DecisionHardwareAssessment;
+    }>;
+};
 /** Uses the parent's login + sessions-scope middleware; inference-only tokens cannot enter this route. */
 export declare function registerPiRecommendationRoute(app: Express, deps: {
     structured: StructuredSessionManager;

package/dist/server-pi-recommendation-routes.js

@@ -26,7 +26,8 @@ export function registerPiRecommendationRoute(app, deps) {
             }
             const status = deps.decisions?.status();
             if (!deps.decisions || !status?.enabled || !status.supported || !status.configured || settings.localDecision === false) {
-                throw new DecisionError("UNAVAILABLE", "本地决策未启用或不可用，原选择未改变。", 503);
+                const notice = status && "notice" in status && typeof status.notice === "string" ? status.notice : "本地决策未启用或不可用，原选择未改变；请配置「决策专家」调用链。";
+                throw new DecisionError("UNAVAILABLE", notice, 503);
             }
             const input = parsePiRecommendationRequest(req.body);
             if (active.has(id))
@@ -46,8 +47,9 @@ export function registerPiRecommendationRoute(app, deps) {
             }
             if (abort.signal.aborted)
                 throw new DecisionError("TIMEOUT", "推荐已取消或超时，原选择未改变。", 504);
+            const advisor = deps.decisions.status();
             if (!res.destroyed)
-                res.json(result);
+                res.json({ ...result, ...("hardware" in advisor ? { decisionAdvisor: advisor } : {}) });
         }
         catch (error) {
             if (res.destroyed)

package/dist/server-session-routes.js

@@ -637,7 +637,7 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
         const archived = snapshot.archived;
         const modifiable = !archived;
         const goalAvailable = installed.some((item) => item.goal);
-        const localDecisionAvailable = config.localDecision?.enabled === true;
+        const localDecisionAvailable = config.localDecision?.enabled === true || decisions?.status().enabled === true;
         const inventory = await discoverPiResources(config, snapshot.cwd);
         const resourceCatalog = { ...inventory.catalog, supported: modifiable && !sdk && inventory.catalog.supported,
             reason: archived ? "请先恢复已归档的会话。" : sdk ? "Wand Agent 尚不支持 Skills / MCP 会话选择。" : inventory.catalog.reason };
@@ -657,10 +657,13 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
             && status?.enabled === true && status.supported && status.configured;
         const recommendationReason = !resourceCatalog.supported ? resourceCatalog.reason
             : settings.localDecision === false ? "本会话已关闭本地决策。"
-                : !recommendationAvailable ? "本地决策未启用或运行环境不可用。" : "";
+                : !recommendationAvailable ? status && "notice" in status && typeof status.notice === "string" ? status.notice : "本地决策未启用或运行环境不可用；请配置「决策专家」调用链。" : "";
         return { recommendationAvailable, recommendationReason,
             autoResourcesAvailable: recommendationAvailable, autoResourcesReason: recommendationReason,
             autoCodemodeAvailable: recommendationAvailable, skillLocksAvailable: resourceCatalog.supported,
+            ...(status?.hardware && typeof status.employeeId === "string" ? { decisionAdvisor: {
+                    notice: status.notice ?? null, employeeId: status.employeeId, hardware: status.hardware
+                } } : {}),
             settings: effectivePiSessionSettings(settings, resolution.engine), engine: resolution.engine,
             available: sdk && modifiable, toolsAvailable: !sdk && modifiable,
             reason: archived ? "请先恢复已归档的会话。" : resolution.reason,

package/dist/server.js

@@ -31,6 +31,8 @@ import { registerSettingsRoutes } from "./server-settings-routes.js";
 import { registerSpeechRoutes } from "./server-speech-routes.js";
 import { registerLocalModelRoutes } from "./server-local-model-routes.js";
 import { LocalModelSetupService } from "./local-model-setup.js";
+import { DecisionExpertService } from "./decision-expert-service.js";
+import { DECISION_EXPERT_KEY } from "./decision-expert-identity.js";
 import { SpeechService } from "./speech-service.js";
 import { appTokenLoginPayload, buildStructuredChatPersonaPayload, isBrowserExtensionOrigin, resolveAppConnectCode, resolveStructuredChatAvatarPath, verifyAppToken, } from "./server-app-connect.js";
 import { firstHeaderValue, sendRouteError } from "./server-request.js";
@@ -325,6 +327,8 @@ export async function startServer(config, configPath, options = {}) {
     const authService = new AuthService(storage);
     const settingsAccess = new SettingsWebAccess();
     const decisions = new DecisionService(config.localDecision);
+    const decisionExpert = new DecisionExpertService({ local: decisions, free: openRouter, config,
+        employee: () => storage.getSystemSiliconEmployee(DECISION_EXPERT_KEY) });
     // 默认模型优先读存储（UI 改设置后实时生效），未设置时由 getPreference 回落到 config。
     const getCurrentDefaultModels = () => ({
         claude: storage.getPreference("pref:defaultModel", config.defaultModel ?? ""),
@@ -689,7 +693,7 @@ export async function startServer(config, configPath, options = {}) {
         const { hasActiveTurns, activeTurnCount } = structuredSessions.getCoreTurnStatus();
         res.set("Cache-Control", "no-store").json({ hasActiveTurns, activeTurnCount });
     });
-    registerDecisionRoutes(app, { storage, decisions, requireAuth, requireSessions });
+    registerDecisionRoutes(app, { storage, decisions: decisionExpert, requireAuth, requireSessions });
     app.use("/api", requireAuth);
     app.get("/api/daemon-maintenance", (_req, res) => {
         res.set("Cache-Control", "no-store").json(daemonMaintenance.status());
@@ -829,7 +833,7 @@ export async function startServer(config, configPath, options = {}) {
         notifyTeamChanged: (teamId) => notifyAiTeamRun({ kind: "ai-team-definition", teamId }),
     });
     // 无指派派工：本地决策模型建议名单 → 确认开工（不自动派工，见 AGENTS）。
-    registerTeamDispatchRoutes(app, { storage, runner: aiTeams, decisions });
+    registerTeamDispatchRoutes(app, { storage, runner: aiTeams, decisions: decisionExpert });
     registerSiliconEmployeeRoutes(app, {
         storage,
         config,
@@ -863,7 +867,7 @@ export async function startServer(config, configPath, options = {}) {
     }
     registerSessionRoutes(app, processes, structuredSessions, storage, config.defaultMode, config, sessionRegistry, (cwd) => {
         recordRecentPath(storage, cwd);
-    }, (event) => wsManager.emitEvent(event), decisions);
+    }, (event) => wsManager.emitEvent(event), decisionExpert);
     registerClaudeHistoryRoutes(app, processes, storage);
     registerWorkspaceRoutes(app, storage, sessionRegistry, { config });
     registerMissionRoutes(app, missions);
@@ -1139,13 +1143,13 @@ export async function startServer(config, configPath, options = {}) {
     function refreshDecisionRuntime() {
         const address = server.address();
         const port = typeof address === "object" && address ? address.port : config.port;
-        const status = decisions.status();
+        const status = decisionExpert.status();
         const localHost = config.host === "::1" ? "[::1]" : config.host === "0.0.0.0" || config.host === "::" ? "127.0.0.1" : config.host;
-        decisionRuntime = config.localDecision?.enabled ? { url: `${protocol}://${localHost}:${port}`,
+        decisionRuntime = status.enabled ? { url: `${protocol}://${localHost}:${port}`,
             ...(activeSslCertPath ? { caPath: activeSslCertPath } : {}),
-            evaluate: (value, caller, signal) => decisions.evaluate(value, caller, signal) } : null;
-        autoAssignEvaluate = config.localDecision?.enabled && status.supported && status.configured
-            ? (value, caller, signal) => decisions.evaluate(value, caller, signal) : undefined;
+            evaluate: (value, caller, signal) => decisionExpert.evaluate(value, caller, signal) } : null;
+        autoAssignEvaluate = status.enabled
+            ? (value, caller, signal) => decisionExpert.evaluate(value, caller, signal) : undefined;
     }
     let bindAddr = config.host === "0.0.0.0" ? "0.0.0.0" : config.host;
     const collectedUrls = [];

package/dist/team-dispatch.d.ts

@@ -97,5 +97,6 @@ export declare function assertDispatchDecisionReady(decisions: {
         enabled: boolean;
         supported: boolean;
         configured: boolean;
+        notice?: string | null;
     };
 }): void;

package/dist/team-dispatch.js

@@ -260,6 +260,8 @@ export async function startTeamDispatch(request) {
 /** 决策服务可用性：不可用时明确报错，绝不编造名单。 */
 export function assertDispatchDecisionReady(decisions) {
     const status = decisions.status();
+    if ((!status.enabled || !status.supported || !status.configured) && status.notice)
+        throw new Error(status.notice);
     if (!status.enabled)
         throw new Error("本地决策未启用（localDecision.enabled=false），无法用决策模型选人。");
     if (!status.supported)