@co0ontty/wand 4.89.0-beta.gde0b3cd → 4.89.0

package/dist/agent-dispatch.d.ts

@@ -5,11 +5,6 @@ import type { StructuredSessionManager } from "./structured-session-manager.js";
 import type { WandTask, WandTaskAgent } from "./task-types.js";
 import { type SiliconEmployee } from "./ai-team-types.js";
 import type { SessionSnapshot, WandConfig } from "./types.js";
-import type { StructuredFailure } from "./structured-failure.js";
-/** A local capability check rejected the input before a session or provider request existed. */
-export declare class AgentDispatchPreflightError extends Error {
-    readonly failure: StructuredFailure;
-}
 export interface AgentDispatchDeps {
     storage: WandStorage;
     config: WandConfig;

package/dist/agent-dispatch.js

@@ -1,13 +1,8 @@
 import { getDefaultModelForProvider } from "./config.js";
-import { isLocalDecisionModel } from "./decision-expert-identity.js";
 import { defaultModelGroupSelector } from "./model-groups.js";
 import { defaultRoleForCli } from "./default-employee.js";
 import { providerCliCommand } from "./session-provider.js";
 import { agentKey } from "./ai-team-types.js";
-/** A local capability check rejected the input before a session or provider request existed. */
-export class AgentDispatchPreflightError extends Error {
-    failure = { kind: "preflight", delivery: "rejected", retryable: true };
-}
 /** 任务卡的执行目录：工作任务的 worktree / 目录 → 所属项目目录 → 全局默认目录。 */
 export function resolveTaskDispatchTarget(deps, task) {
     const workspace = task.workspaceId ? deps.storage.getWorkspace(task.workspaceId) : null;
@@ -47,9 +42,6 @@ export async function dispatchAgentForTask(deps, input) {
     const provider = agent.provider;
     const model = agent.model === "default" ? "" : agent.model;
     const resolvedModel = model || defaultModelGroupSelector(config.modelGroups, provider, getDefaultModelForProvider(config, provider)) || getDefaultModelForProvider(config, provider) || undefined;
-    if (isLocalDecisionModel(resolvedModel)) {
-        throw new AgentDispatchPreflightError("LAYA 仅支持有界决策，不能执行聊天或任务；该候选尚未接受输入。");
-    }
     const session = agent.kind === "pty"
         ? await processes.start(providerCliCommand(provider), cwd, agent.mode, input.prompt, {
             provider,

package/dist/ai-team-runner.d.ts

@@ -362,7 +362,7 @@ export declare class AiTeamRunner {
     /** host-disabled 是进程级信号：本次运行该 kind 的候选全部不再尝试。 */
     private disableHostKind;
     /**
-     * 失败候选的黑名单记账（§3.4）：CLI spawn-missing 封 provider，SDK 只封具体候选；model-unknown 直接封五元组、
+     * 失败候选的黑名单记账（§3.4）：spawn-missing 封 provider、model-unknown 直接封五元组、
      * startup-timeout 累计到 STARTUP_TIMEOUT_STRIKES 才封。runtime-failure 这类不计入，
      * 一次写完一次落库。
      */

package/dist/ai-team-runner.js

@@ -5,7 +5,7 @@ import os from "node:os";
 import path from "node:path";
 import { freezeTeamEmployees, projectTeamEmployees, teamMemberEmployee } from "./ai-team-employee-binding.js";
 import { buildAiTeamDeliverySummary } from "./ai-team-delivery.js";
-import { dispatchAgentForTask, AgentDispatchPreflightError, resolveTaskDispatchTarget, sendToAgentSession, stopAgentSession, } from "./agent-dispatch.js";
+import { dispatchAgentForTask, resolveTaskDispatchTarget, sendToAgentSession, stopAgentSession, } from "./agent-dispatch.js";
 import { AI_TEAM_REPORT_DIR, aiTeamChatHistoryPath, aiTeamHandoffPath, aiTeamReportPath, buildLeaderFollowupPrompt, buildLeaderFormatRetryPrompt, buildAiTeamObjective, buildLeaderKickoffPrompt, buildMemberPrompt, leaderOf, parseLeaderDecision, renderChatHistoryFile, renderHandoffFile, } from "./ai-team-prompts.js";
 import { AI_TEAM_STARTUP_WINDOW_MS, classifyCandidateFailure, classifyStartupFailure, isDegradableWorkFailure, isModelUnknownBeforeDispatch, } from "./ai-team-availability.js";
 import { AI_TEAM_ACTIVE_RUN_STATUSES, AI_TEAM_DETAIL_CHAT_TURNS, AI_TEAM_SILENCE_HEARTBEAT_MS, AI_TEAM_TERMINAL_RUN_STATUSES, agentKey, aiTeamChatTitle, memberAgents, } from "./ai-team-types.js";
@@ -1551,8 +1551,7 @@ export class AiTeamRunner {
         }
         catch (error) {
             const message = getErrorMessage(error);
-            const rejected = error instanceof AgentDispatchPreflightError && error.failure.retryable;
-            const kind = rejected ? "input-rejected" : classifyCandidateFailure(message);
+            const kind = classifyCandidateFailure(message);
             if (agent && kind === "host-disabled") {
                 // 进程级信号（agent-dispatch 的「当前服务未启用 … 会话」）：本次运行该 kind 的候选全部不再
                 // 尝试，也不能当成「不可降级」直接吞掉——记进黑名单后交给既有失败出口。
@@ -1567,7 +1566,7 @@ export class AiTeamRunner {
                 await this.degradeStep(run, running, { kind, reason: message }, proceed, buildPrompt);
                 return;
             }
-            if (agent && step.kind === "work" && (kind === "spawn-missing" || (rejected && reusable === null))
+            if (agent && step.kind === "work" && kind === "spawn-missing"
                 && (!member?.employeeId || reusable === null)
                 && !existsSync(path.join(run.cwd, step.reportPath)) && !this.noDegrade.has(step.id)) {
                 // §3.4 触发点 1：会话根本没起来，ENOENT 对 structured / pty 同样可靠（修正 B4 排除的是
@@ -1765,8 +1764,7 @@ export class AiTeamRunner {
                 reason: `本服务未启用${agent.kind === "pty" ? "终端" : "结构化"}会话，候选 ${agent.provider} 不再尝试`,
             };
         }
-        // Legacy provider entries mean a missing CLI executable, not every engine sharing its provider.
-        if (agent.engine !== "sdk" && state.providers.includes(agent.provider)) {
+        if (state.providers.includes(agent.provider)) {
             return { kind: "spawn-missing", reason: `${agent.provider} CLI 不可用` };
         }
         const blocked = state.agents.find((item) => item.key === agentKey(agent));
@@ -1790,7 +1788,7 @@ export class AiTeamRunner {
         this.saveState(runId, { ...state, hostDisabled: [...state.hostDisabled, kind] });
     }
     /**
-     * 失败候选的黑名单记账（§3.4）：CLI spawn-missing 封 provider，SDK 只封具体候选；model-unknown 直接封五元组、
+     * 失败候选的黑名单记账（§3.4）：spawn-missing 封 provider、model-unknown 直接封五元组、
      * startup-timeout 累计到 STARTUP_TIMEOUT_STRIKES 才封。runtime-failure 这类不计入，
      * 一次写完一次落库。
      */
@@ -1798,12 +1796,6 @@ export class AiTeamRunner {
         const state = this.stateOf(runId);
         const key = agentKey(agent);
         if (kind === "spawn-missing") {
-            if (agent.engine === "sdk") {
-                if (state.agents.some((item) => item.key === key))
-                    return;
-                this.saveState(runId, { ...state, agents: [...state.agents, { key, kind }] });
-                return;
-            }
             if (state.providers.includes(agent.provider))
                 return;
             this.saveState(runId, { ...state, providers: [...state.providers, agent.provider] });

package/dist/ai-team-types.js

@@ -1,5 +1,4 @@
 import { DECISION_EXPERT_KEY } from "./decision-expert-identity.js";
-import { SPEECH_POLISHER_KEY } from "./speech-polisher-identity.js";
 export const AI_TEAM_MIN_MEMBERS = 2;
 export const AI_TEAM_MAX_MEMBERS = 8;
 export const AI_TEAM_DEFAULT_MAX_STEPS = 30;
@@ -53,13 +52,13 @@ export function isDecisionExpertSiliconEmployee(employee) {
     return employee?.systemKey === DECISION_EXPERT_KEY;
 }
 export function isBuiltinSiliconEmployee(employee) {
-    return isSystemSiliconEmployee(employee) || isDefaultSiliconEmployee(employee) || isDecisionExpertSiliconEmployee(employee) || employee?.systemKey === SPEECH_POLISHER_KEY;
+    return isSystemSiliconEmployee(employee) || isDefaultSiliconEmployee(employee) || isDecisionExpertSiliconEmployee(employee);
 }
 export const SILICON_EMPLOYEE_MAX_TAGS = 8;
 export const SILICON_EMPLOYEE_TAG_MAX_CHARS = 20;
 /** 内置标识只由真实员工身份投影，不能用自定义标签冒充。 */
 export function siliconEmployeeTags(employee) {
-    if (isSystemSiliconEmployee(employee) || isDecisionExpertSiliconEmployee(employee) || employee.systemKey === SPEECH_POLISHER_KEY)
+    if (isSystemSiliconEmployee(employee) || isDecisionExpertSiliconEmployee(employee))
         return [SYSTEM_EMPLOYEE_TAG];
     if (isDefaultSiliconEmployee(employee))
         return [DEFAULT_EMPLOYEE_TAG];

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
-  "commit": "de0b3cdb66b742df1f9599c2ca9d73a89bb9c616",
-  "builtAt": "2026-10-10T00:44:20.852Z",
-  "version": "4.89.0-beta.gde0b3cd",
-  "channel": "beta"
+  "commit": "b60280807f605ce884aea7ec30f202157dbb3047",
+  "builtAt": "2026-10-09T11:37:44.403Z",
+  "version": "4.89.0",
+  "channel": "stable"
 }

package/dist/commit-task-archive.d.ts

@@ -1,8 +1,5 @@
 import type { WandStorage } from "./storage.js";
 import type { SessionSnapshot } from "./types.js";
-import type { SessionRegistry } from "./session-registry.js";
 export declare function archiveCommitTasks(storage: WandStorage, session: SessionSnapshot, entryIds: readonly string[], options?: {
     workspaceTaskId?: string | null;
 }): string[];
-/** Sweep standalone chats in this project, including those absent from commit prompts. */
-export declare function archiveCommitStandaloneSessions(storage: WandStorage, sessions: Pick<SessionRegistry, "listSlim" | "setArchived">, session: SessionSnapshot, archivedSessionIds: string[]): void;

package/dist/commit-task-archive.js

@@ -48,18 +48,3 @@ export function archiveCommitTasks(storage, session, entryIds, options = {}) {
     }
     return storage.archiveWandTasks(eligible);
 }
-/** Sweep standalone chats in this project, including those absent from commit prompts. */
-export function archiveCommitStandaloneSessions(storage, sessions, session, archivedSessionIds) {
-    const directory = projectCwdForSession(session);
-    if (!directory)
-        return;
-    for (const candidate of sessions.listSlim()) {
-        if (candidate.archived || projectCwdForSession(candidate) !== directory)
-            continue;
-        // A workspace task remains a task even if it has no corresponding board card.
-        if (candidate.workspaceTaskId || cardIdForSession(storage, candidate.id))
-            continue;
-        if (sessions.setArchived(candidate.id, true))
-            archivedSessionIds.push(candidate.id);
-    }
-}

package/dist/config.js

@@ -255,7 +255,6 @@ export async function loadConfigWithStorage(configPath, storage) {
     // 默认任务伙伴独立于系统运维；重启保留短期偏好与用户维护的候选。
     storage.ensureDefaultSiliconEmployee(config.defaultProvider);
     storage.ensureDecisionExpertEmployee();
-    storage.ensureSpeechPolisherEmployee();
     // 如果 JSON 里有偏好字段（说明是老版本配置或刚迁移），重写一次干净版本
     const hasLegacyPrefs = PREFERENCE_KEYS.some((key) => key in rawInput);
     const hasLegacySecrets = "password" in rawInput || "appSecret" in rawInput;

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

@@ -1,6 +1,6 @@
 import type { SiliconEmployee } from "./ai-team-types.js";
 import type { WandTaskAgent } from "./task-types.js";
-export declare const DECISION_EXPERT_DUTY = "Wand \u51B3\u7B56\u4E13\u5BB6\uFF1A\u6839\u636E\u6700\u5C11\u5FC5\u8981\u8BC1\u636E\u505A\u6709\u754C\u9009\u62E9\u3001\u8BC4\u5206\u4E0E\u662F\u975E\u5224\u65AD\uFF1B\u6309\u5DF2\u914D\u7F6E\u5DE5\u5177\u4E0E\u6A21\u578B\u987A\u5E8F\u8C03\u7528\uFF1B\u672C\u5730\u51B3\u7B56\u5148\u6838\u5BF9\u672C\u673A\u80FD\u529B\u3002";
+export declare const DECISION_EXPERT_DUTY = "Wand \u51B3\u7B56\u4E13\u5BB6\uFF1A\u6839\u636E\u6700\u5C11\u5FC5\u8981\u8BC1\u636E\u505A\u6709\u754C\u9009\u62E9\u3001\u8BC4\u5206\u4E0E\u662F\u975E\u5224\u65AD\uFF1B\u5148\u6838\u5BF9\u672C\u673A\u80FD\u529B\uFF0C\u4F18\u5148\u672C\u5730\u51B3\u7B56\uFF0C\u5907\u7528\u514D\u8D39\u6A21\u578B\u3002";
 export declare const DECISION_EXPERT_PROMPT: string;
 export declare function decisionExpertSeedAgents(): WandTaskAgent[];
 export declare function decisionExpertDefinition(now: string, existing?: SiliconEmployee | null): SiliconEmployee;

package/dist/decision-expert-employee.js

@@ -1,14 +1,14 @@
 import { SYSTEM_EMPLOYEE_TAG } from "./ai-team-types.js";
 import { DECISION_EXPERT_ID, DECISION_EXPERT_KEY, DECISION_EXPERT_NAME, WAND_LOCAL_DECISION_MODEL } from "./decision-expert-identity.js";
 import { OPENROUTER_FREE_SELECTOR } from "./openrouter-free-selection.js";
-export const DECISION_EXPERT_DUTY = "Wand 决策专家：根据最少必要证据做有界选择、评分与是非判断；按已配置工具与模型顺序调用；本地决策先核对本机能力。";
+export const DECISION_EXPERT_DUTY = "Wand 决策专家：根据最少必要证据做有界选择、评分与是非判断；先核对本机能力，优先本地决策，备用免费模型。";
 export const DECISION_EXPERT_PROMPT = [
     "你是 Wand 内置系统员工「决策专家」。你的职责是基于用户提供的证据，做有界候选选择、评分与是非判断。",
-    "按员工调用链的配置顺序调用工具与模型；初始候选为 LAYA 和 Wand 免费分组。LAYA 不生成开放式文本，不伪装成聊天模型。",
+    "首选为 Wand 的 LAYA 本地决策模型，备用默认 Wand 免费分组。LAYA 不生成开放式文本，不伪装成聊天模型。",
     "先核对机器的 CPU、内存、Apple Silicon / Metal 和运行时健康。性能/平台不足时明确说明原因，建议配置你的调用链，不能捏造可以运行。",
     "只使用输入中已授权的最少证据，不读取别人的知识/私聊。概率不是正确性保证，更不是权限、删除、发布或付款批准。",
     "严格输出任务要求的格式；不编造选项、解释、执行结果或事实。失败有明确原因，不盲目重复已执行/未知送达的工作。",
-    "免费分组在每次请求前重新核对价格；免费候选不可用时依调用链处理，不把免费选择器替换成付费模型。",
+    "免费分组在每次请求前重新核对价格；没有免费候选时停止并提示配置，不静默换付费模型。",
 ].join("\n");
 export function decisionExpertSeedAgents() {
     return [WAND_LOCAL_DECISION_MODEL, OPENROUTER_FREE_SELECTOR].map(model => ({ provider: "pi", engine: "sdk", model,

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

@@ -3,18 +3,16 @@ 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 { AiTextRequest, WandConfig } from "./types.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: WandConfig;
+    config: Pick<WandConfig, "modelGroups">;
     hardware?: () => DecisionHardwareAssessment;
     timeoutMs?: number;
-    /** A prepared adapter has accepted no input yet. Tests never call real models. */
-    prepare?: (agent: WandTaskAgent, request: AiTextRequest, signal: AbortSignal) => Promise<() => Promise<string>>;
-    /** Compatibility seam for existing bounded evaluator fixtures. */
+    /** 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;
@@ -22,7 +20,7 @@ interface DecisionExpertDeps {
         model: string;
     }>;
 }
-/** Bounded decisions use the employee's ordered adapters; LAYA stays a local evaluator. */
+/** 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;
@@ -42,5 +40,6 @@ export declare class DecisionExpertService {
         notice: string | null;
     };
     evaluate(value: unknown, caller: string, signal?: AbortSignal): Promise<DecisionResult>;
+    private generate;
 }
 export {};

package/dist/decision-expert-service.js

@@ -1,9 +1,10 @@
 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 } from "./openrouter-free-models.js";
-import { abortableEmployeeText, EmployeeCandidateRejected, employeeTextCandidates, prepareEmployeeTextCandidate } from "./employee-text.js";
-/** Bounded decisions use the employee's ordered adapters; LAYA stays a local evaluator. */
+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;
@@ -13,19 +14,12 @@ export class DecisionExpertService {
     status() {
         const local = this.deps.local.status(), employee = this.deps.employee(), free = this.deps.free.status();
         const hardware = (this.deps.hardware ?? decisionHardware)();
-        const configured = !!employee?.agents.some(agent => {
-            if (agent.model === WAND_LOCAL_DECISION_MODEL)
-                return agent.provider === "pi" && agent.engine === "sdk"
-                    && hardware.suitable && local.supported && local.enabled && local.configured;
-            if (isOpenRouterFreeSelector(agent.model))
-                return agent.provider === "pi" && agent.engine === "sdk" && free.configured && free.modelCount > 0;
-            return agent.kind === "structured";
-        });
-        return { enabled: !!employee, supported: true, configured, state: local.state, queued: this.active,
-            completed: local.completed, failed: local.failed, experimental: true,
+        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 };
+            notice: !hardware.suitable ? hardware.message : !local.enabled || !local.configured ? "本地决策未就绪，可初始化 LAYA 或配置「决策专家」员工调用链使用备用免费分组。" : null };
     }
     async evaluate(value, caller, signal) {
         const request = parseDecisionRequest(value), employee = this.deps.employee();
@@ -40,92 +34,72 @@ export class DecisionExpertService {
         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;
-        const prompt = {
-            system: `${employee.prompt}\n只输出JSON对象 {"answers":{...}}。对每题保留type；choice给choice和所有criteria的probabilities(总和1)，score给score和以0开始索引的probabilities(总和1)，noul给0到1的noul。不得执行操作或增加候选。概率是实验性辅助而非授权。`,
-            prompt: JSON.stringify(request),
-        };
         try {
             const hardware = (this.deps.hardware ?? decisionHardware)();
-            for (const { agent, index: candidate } of employeeTextCandidates(employee.agents, this.deps.config)) {
-                signal.throwIfAborted();
+            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")
-                        continue;
+                        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 abortableEmployeeText(this.deps.local.evaluate(request, caller, signal), signal);
+                        const result = await this.deps.local.evaluate(request, caller, signal);
                         return { ...result, executor: { employeeId: employee.id, candidate, source: "local" } };
                     }
                     catch (error) {
-                        signal.throwIfAborted();
-                        if (error instanceof DecisionError && ["CANCELLED", "INVALID_REQUEST", "RATE_LIMIT", "BUSY"].includes(error.code))
+                        if (deadline.signal.aborted)
+                            throw timeout;
+                        if (signal?.aborted || (error instanceof DecisionError && ["CANCELLED", "INVALID_REQUEST", "RATE_LIMIT", "BUSY"].includes(error.code)))
                             throw error;
-                        // Existing LAYA fallback is read-only inference, never tool/task replay.
+                        // This is read-only inference, never a replay of a tool/task side effect.
                         continue;
                     }
                 }
-                let run;
-                if (this.deps.generate) {
-                    run = () => this.deps.generate(agent, request, employee, signal);
-                }
-                else {
-                    const availability = new AbortController();
-                    const checkTimer = setTimeout(() => availability.abort(new Error("候选可用性检查超时。")), 8000);
-                    const check = AbortSignal.any([signal, availability.signal]);
-                    let generate;
-                    let usage;
-                    try {
-                        generate = await abortableEmployeeText((this.deps.prepare ?? ((next, text, checkedSignal) => prepareEmployeeTextCandidate({
-                            config: this.deps.config, free: this.deps.free, onUsage: value => { usage = value; },
-                        }, next, text, checkedSignal)))(agent, prompt, check), check);
-                    }
-                    catch {
-                        signal.throwIfAborted();
-                        continue;
-                    }
-                    finally {
-                        clearTimeout(checkTimer);
-                    }
-                    run = async () => {
-                        const raw = await abortableEmployeeText(generate(), signal);
-                        if (raw.length > 32768)
-                            throw new Error("决策结果超过32KiB。");
-                        const body = JSON.parse(raw.trim().replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/, ""));
-                        return { answers: body?.answers, inputTokens: usage?.inputTokens ?? 0, outputTokens: usage?.outputTokens ?? 0,
-                            model: usage?.model ?? agent.model, available: !!usage };
-                    };
+                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 abortableEmployeeText(run(), signal);
-                    signal.throwIfAborted();
+                    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" });
-                    if (generated.available === false)
-                        result.usage.available = false;
-                    return { ...result, executor: { employeeId: employee.id, candidate,
-                            source: isOpenRouterFreeSelector(agent.model) ? "free-group" : agent.engine === "sdk" ? "sdk" : "cli" } };
+                    return { ...result, executor: { employeeId: employee.id, candidate, source: "free-group" } };
                 }
                 catch (error) {
-                    signal.throwIfAborted();
-                    if (error instanceof EmployeeCandidateRejected && error.failure.retryable)
-                        continue;
-                    // Accepted/unknown delivery and invalid results never silently repeat a request.
-                    throw new DecisionError("EXECUTION_FAILED", "决策专家候选调用失败或结果无效，未自动重放；请检查该员工调用链。", 503);
+                    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", "决策专家没有当前可用的候选；请检查已配置工具、模型或初始化 LAYA。", 503);
-        }
-        catch (error) {
-            if (deadline.signal.aborted)
-                throw timeout;
-            if (signal.aborted)
-                throw new DecisionError("CANCELLED", "决策专家请求已取消。", 499);
-            throw error;
+            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

@@ -24,14 +24,13 @@ export interface DecisionResult {
         input_tokens: number;
         output_tokens: number;
         truncated?: boolean;
-        available?: boolean;
     };
     experimental: true;
     runtime: "laya-mlx" | "decision-expert";
     executor?: {
         employeeId: string;
         candidate: number;
-        source: "local" | "free-group" | "cli" | "sdk";
+        source: "local" | "free-group";
     };
 }
 export declare class DecisionError extends Error {

package/dist/git-quick-commit.d.ts

@@ -1,4 +1,3 @@
-import { type EmployeeTextDeps } from "./employee-text.js";
 import type { AiTextRequest } from "./types.js";
 import { GitStatusResult, PushResult, QuickCommitResult, SessionProvider, SessionSnapshot, TagHeadResult } from "./types.js";
 export type QuickCommitErrorCode = "CWD_MISSING" | "NO_CWD" | "NOT_A_GIT_REPO" | "NO_COMMIT" | "NOTHING_TO_COMMIT" | "NOTHING_TO_PUSH" | "EMPTY_MESSAGE" | "EMPTY_TAG" | "EMPTY_AI_MESSAGE" | "AI_FALLBACK_FAILED" | "INVALID_AI_TAG" | "TAG_EXISTS" | "GIT_ADD_FAILED" | "GIT_DIFF_FAILED" | "GIT_COMMIT_FAILED" | "GIT_TAG_FAILED" | "CLAUDE_CLI_MISSING" | "CLAUDE_CLI_FAILED" | "CLAUDE_TIMEOUT";
@@ -27,15 +26,12 @@ export interface QuickCommitAiOptions {
     inheritEnv?: boolean;
     /** 内置「系统运维」员工的角色设定：作为系统提示前缀注入。 */
     opsPersona?: string;
-    /** 员工候选链（按顺序）；未设置时只用 provider/model 这一次调用。 */
+    /** CLI 降级链（按顺序）；未设置时只用 provider/model 这一次调用。 */
     cliCandidates?: import("./types.js").AiCliCandidate[];
-    /** SDK 使用当前实例配置与现有免费分组服务，不创建其他执行渠道。 */
-    employeeText?: EmployeeTextDeps;
-    /** 系统应用必须经员工渠道；没有可用候选时直接失败，不退回默认 provider。 */
+    /** 系统应用必须经员工渠道；没有可用 CLI 候选时直接失败，不退回默认 provider。 */
     employeeChannelOnly?: boolean;
     /** 整条候选链的时间上限；默认 CLI_CHAIN_BUDGET_MS。第一条消息里的调用要短得多。 */
     budgetMs?: number;
-    signal?: AbortSignal;
 }
 export declare class QuickCommitError extends Error {
     readonly code: QuickCommitErrorCode;
@@ -51,16 +47,11 @@ export interface CommitInputOptions {
     iterationDigest?: string;
     includeDiff?: boolean;
 }
-type CliAiTextOptions = QuickCommitAiOptions & {
-    deadline?: number;
-};
-export declare function assertGeminiTextCapability(): void;
-export declare function callCliAiText(request: AiTextRequest, cwd: string, language: string, opts: CliAiTextOptions): Promise<string>;
 /** 角色设定走系统提示前缀；任务自己的输出格式与约束必须排在后面。 */
 export declare function withOpsPersona(request: AiTextRequest, persona?: string): AiTextRequest;
 /**
- * Run a lightweight AI request through the system employee's configured chain.
- * provider 与引擎由候选决定；SDK 与 CLI 均保留各自适配和身份。
+ * Run a lightweight AI request through the system employee's CLI chain.
+ * 所有 Wand 自有文本调用都走本机已安装的 CLI，没有任何直连 API 分支。
  * parseOutput 在候选链内解析/校验结果；失败后继续下一条，而非提前宣布成功。
  */
 export declare function callConfiguredAiText(request: AiTextRequest, cwd: string, language: string, opts: QuickCommitAiOptions): Promise<string>;