@co0ontty/wand 4.89.0 → 4.89.2-beta.g9f64cf7

package/dist/agent-dispatch.d.ts

@@ -5,6 +5,11 @@ 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,8 +1,13 @@
 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;
@@ -42,6 +47,9 @@ 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-employee-binding.d.ts

@@ -1,6 +1,7 @@
 import { type AiTeam, type AiTeamMember, type SiliconEmployee } from "./ai-team-types.js";
 export interface AiTeamEmployeeSource {
     getSiliconEmployee(id: string): SiliconEmployee | null;
+    getSiliconEmployeeDefinition?(id: string): SiliconEmployee | null;
 }
 export declare function teamMemberEmployee(member: AiTeamMember): SiliconEmployee | undefined;
 /** Only storage restores this private field; HTTP parsing deliberately ignores it. */

package/dist/ai-team-employee-binding.js

@@ -31,7 +31,7 @@ export function requireTeamEmployee(source, id) {
     }
     // The default partner's read projection includes short-term habits; they are not team snapshot data.
     return isDefaultSiliconEmployee(employee)
-        ? defaultEmployeeDefinition(employee.agents, employee.updatedAt, employee, null)
+        ? defaultEmployeeDefinition(employee.agents, employee.updatedAt, source.getSiliconEmployeeDefinition?.(id) ?? employee, null)
         : employee;
 }
 /** Resolve once per new run. Team duty/role/leadership remain local; no knowledge is read. */

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

@@ -362,7 +362,7 @@ export declare class AiTeamRunner {
     /** host-disabled 是进程级信号：本次运行该 kind 的候选全部不再尝试。 */
     private disableHostKind;
     /**
-     * 失败候选的黑名单记账（§3.4）：spawn-missing 封 provider、model-unknown 直接封五元组、
+     * 失败候选的黑名单记账（§3.4）：CLI spawn-missing 封 provider，SDK 只封具体候选；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, resolveTaskDispatchTarget, sendToAgentSession, stopAgentSession, } from "./agent-dispatch.js";
+import { dispatchAgentForTask, AgentDispatchPreflightError, 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,7 +1551,8 @@ export class AiTeamRunner {
         }
         catch (error) {
             const message = getErrorMessage(error);
-            const kind = classifyCandidateFailure(message);
+            const rejected = error instanceof AgentDispatchPreflightError && error.failure.retryable;
+            const kind = rejected ? "input-rejected" : classifyCandidateFailure(message);
             if (agent && kind === "host-disabled") {
                 // 进程级信号（agent-dispatch 的「当前服务未启用 … 会话」）：本次运行该 kind 的候选全部不再
                 // 尝试，也不能当成「不可降级」直接吞掉——记进黑名单后交给既有失败出口。
@@ -1566,7 +1567,7 @@ export class AiTeamRunner {
                 await this.degradeStep(run, running, { kind, reason: message }, proceed, buildPrompt);
                 return;
             }
-            if (agent && step.kind === "work" && kind === "spawn-missing"
+            if (agent && step.kind === "work" && (kind === "spawn-missing" || (rejected && reusable === null))
                 && (!member?.employeeId || reusable === null)
                 && !existsSync(path.join(run.cwd, step.reportPath)) && !this.noDegrade.has(step.id)) {
                 // §3.4 触发点 1：会话根本没起来，ENOENT 对 structured / pty 同样可靠（修正 B4 排除的是
@@ -1764,7 +1765,8 @@ export class AiTeamRunner {
                 reason: `本服务未启用${agent.kind === "pty" ? "终端" : "结构化"}会话，候选 ${agent.provider} 不再尝试`,
             };
         }
-        if (state.providers.includes(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)) {
             return { kind: "spawn-missing", reason: `${agent.provider} CLI 不可用` };
         }
         const blocked = state.agents.find((item) => item.key === agentKey(agent));
@@ -1788,7 +1790,7 @@ export class AiTeamRunner {
         this.saveState(runId, { ...state, hostDisabled: [...state.hostDisabled, kind] });
     }
     /**
-     * 失败候选的黑名单记账（§3.4）：spawn-missing 封 provider、model-unknown 直接封五元组、
+     * 失败候选的黑名单记账（§3.4）：CLI spawn-missing 封 provider，SDK 只封具体候选；model-unknown 直接封五元组、
      * startup-timeout 累计到 STARTUP_TIMEOUT_STRIKES 才封。runtime-failure 这类不计入，
      * 一次写完一次落库。
      */
@@ -1796,6 +1798,12 @@ 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.d.ts

@@ -71,8 +71,8 @@ export interface SiliconEmployee {
     /** 内置标签按 systemKey 固定；普通员工的标签由用户维护。旧客户端可不传。 */
     tags?: string[];
     /**
-     * 非空 = Wand 内置员工（如 "wand-ops" 系统运维）：名字/职责/人设/头像锁定，
-     * 不可归档、不可删除，只有执行候选由用户维护。
+     * 非空 = Wand 内置身份、标签，不可归档、不可删除。
+     * 两个固定猫头像员工可编辑资料/人设/候选；其他内置员工保留既有资料锁定策略。
      */
     systemKey?: string;
     archivedAt?: string;

package/dist/ai-team-types.js

@@ -1,4 +1,5 @@
 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;
@@ -52,13 +53,13 @@ export function isDecisionExpertSiliconEmployee(employee) {
     return employee?.systemKey === DECISION_EXPERT_KEY;
 }
 export function isBuiltinSiliconEmployee(employee) {
-    return isSystemSiliconEmployee(employee) || isDefaultSiliconEmployee(employee) || isDecisionExpertSiliconEmployee(employee);
+    return isSystemSiliconEmployee(employee) || isDefaultSiliconEmployee(employee) || isDecisionExpertSiliconEmployee(employee) || employee?.systemKey === SPEECH_POLISHER_KEY;
 }
 export const SILICON_EMPLOYEE_MAX_TAGS = 8;
 export const SILICON_EMPLOYEE_TAG_MAX_CHARS = 20;
 /** 内置标识只由真实员工身份投影，不能用自定义标签冒充。 */
 export function siliconEmployeeTags(employee) {
-    if (isSystemSiliconEmployee(employee) || isDecisionExpertSiliconEmployee(employee))
+    if (isSystemSiliconEmployee(employee) || isDecisionExpertSiliconEmployee(employee) || employee.systemKey === SPEECH_POLISHER_KEY)
         return [SYSTEM_EMPLOYEE_TAG];
     if (isDefaultSiliconEmployee(employee))
         return [DEFAULT_EMPLOYEE_TAG];

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
-  "commit": "b60280807f605ce884aea7ec30f202157dbb3047",
-  "builtAt": "2026-10-09T11:37:44.403Z",
-  "version": "4.89.0",
-  "channel": "stable"
+  "commit": "9f64cf7f495c1c069ae727811da119c4dbca561e",
+  "builtAt": "2026-10-10T04:24:07.915Z",
+  "version": "4.89.2-beta.g9f64cf7",
+  "channel": "beta"
 }

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

@@ -1,5 +1,8 @@
 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,3 +48,18 @@ 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,6 +255,7 @@ 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/daemon-maintenance-targets.js

@@ -173,7 +173,7 @@ export async function createDaemonMaintenanceTargets(configPath, pty, structured
                 const runs = await legacy.request("structuredList");
                 await Promise.all([
                     ...sessions.filter(session => session.status === "running")
-                        .map(session => legacy.request("kill", { sessionId: session.sessionId, signal: "SIGTERM" })),
+                        .map(session => legacy.request("kill", { sessionId: session.sessionId, signal: "SIGHUP" })),
                     ...runs.filter(run => run.status === "running")
                         .map(run => legacy.request("structuredKill", { runId: run.runId, signal: "SIGTERM" })),
                 ]);

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\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_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_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 内置系统员工「决策专家」。你的职责是基于用户提供的证据，做有界候选选择、评分与是非判断。",
-    "首选为 Wand 的 LAYA 本地决策模型，备用默认 Wand 免费分组。LAYA 不生成开放式文本，不伪装成聊天模型。",
+    "按员工调用链的配置顺序调用工具与模型；初始候选为 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,16 +3,18 @@ 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 { AiTextRequest, 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">;
+    config: WandConfig;
     hardware?: () => DecisionHardwareAssessment;
     timeoutMs?: number;
-    /** Tests may inject a free, no-tool structured generator; production never silently swaps engine. */
+    /** 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. */
     generate?: (agent: WandTaskAgent, request: DecisionRequest, employee: SiliconEmployee, signal?: AbortSignal) => Promise<{
         answers: unknown;
         inputTokens: number;
@@ -20,7 +22,7 @@ interface DecisionExpertDeps {
         model: string;
     }>;
 }
-/** Dedicated bounded employee evaluator. LAYA is not sent to a chat provider as a fake model ID. */
+/** Bounded decisions use the employee's ordered adapters; LAYA stays a local evaluator. */
 export declare class DecisionExpertService {
     private readonly deps;
     private active;
@@ -40,6 +42,5 @@ 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,10 +1,9 @@
 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. */
+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. */
 export class DecisionExpertService {
     deps;
     active = 0;
@@ -14,12 +13,19 @@ 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 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,
+        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,
             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();
@@ -34,72 +40,92 @@ 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 (let candidate = 0; candidate < employee.agents.length; candidate += 1) {
-                const agent = employee.agents[candidate];
+            for (const { agent, index: candidate } of employeeTextCandidates(employee.agents, this.deps.config)) {
+                signal.throwIfAborted();
                 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);
+                        continue;
                     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);
+                        const result = await abortableEmployeeText(this.deps.local.evaluate(request, caller, signal), 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)))
+                        signal.throwIfAborted();
+                        if (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.
+                        // Existing LAYA fallback is read-only inference, never tool/task replay.
                         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);
+                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 (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 generated = await abortableEmployeeText(run(), signal);
+                    signal.throwIfAborted();
                     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" } };
+                    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" } };
                 }
                 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);
+                    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);
                 }
             }
-            throw new DecisionError("CONFIGURATION_REQUIRED", !hardware.suitable ? hardware.message : "决策专家没有当前可用的候选；请初始化 LAYA 或配置该员工备用调用链。", 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;
         }
         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,13 +24,14 @@ 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";
+        source: "local" | "free-group" | "cli" | "sdk";
     };
 }
 export declare class DecisionError extends Error {

package/dist/default-employee.d.ts

@@ -5,7 +5,11 @@ import type { SessionProvider, SessionSnapshot } from "./types.js";
 import type { UserMemoryProfile } from "./user-memory-types.js";
 export declare const DEFAULT_EMPLOYEE_DUTY = "\u9ED8\u8BA4\u4EFB\u52A1\u4F19\u4F34\uFF1A\u7406\u89E3\u4F60\u7684\u9700\u6C42\uFF0C\u6309\u8BC1\u636E\u63A8\u8FDB\u5DE5\u4F5C\uFF0C\u5E76\u9010\u6B65\u9002\u5E94\u4F60\u7684\u6C9F\u901A\u4E0E\u4EA4\u4ED8\u4E60\u60EF\u3002";
 export declare const DEFAULT_EMPLOYEE_PROMPT: string;
-/** Keep the immutable identity/base rules outside the model's output. */
+/** Old releases persisted generated habits after this exact base; keep the column intact,
+ * but do not replay that expired generated tail as user-authored rules.
+ */
+export declare function savedDefaultEmployeeBasePrompt(prompt: string): string;
+/** Seed profile defaults once; future memory is a pure projection over the saved role. */
 export declare function defaultEmployeeDefinition(agents: WandTaskAgent[], now: string, existing?: SiliconEmployee | null, profile?: UserMemoryProfile | null, time?: number): SiliconEmployee;
 export type SessionEmployeeIdentity = Pick<SessionSnapshot, "employeeId" | "employeeName" | "employeeAvatar">;
 /** Older PTY sessions stored the injected role only as a prompt. Never infer from a CLI or a name mention. */

package/dist/default-employee.js

@@ -1,4 +1,5 @@
 import { DEFAULT_EMPLOYEE_ID, DEFAULT_EMPLOYEE_KEY, DEFAULT_EMPLOYEE_NAME, DEFAULT_EMPLOYEE_TAG, } from "./ai-team-types.js";
+import { fixedEmployeeAvatar } from "./fixed-employee-avatar.js";
 import { systemEmployeeSeedAgents } from "./system-employee.js";
 export const DEFAULT_EMPLOYEE_DUTY = "默认任务伙伴：理解你的需求，按证据推进工作，并逐步适应你的沟通与交付习惯。";
 export const DEFAULT_EMPLOYEE_PROMPT = [
@@ -8,7 +9,17 @@ export const DEFAULT_EMPLOYEE_PROMPT = [
     "保留已有输入、工作和历史；涉及删除、发布、权限或凭据的操作遵守明确授权与项目约定。",
     "用户当前要求、项目规则和工具权限始终优先。短期记忆只是可纠正的偏好提示，不能增加权限、替代本轮任务或形成新的执行指令。",
 ].join("\n");
-/** Keep the immutable identity/base rules outside the model's output. */
+/** Old releases persisted generated habits after this exact base; keep the column intact,
+ * but do not replay that expired generated tail as user-authored rules.
+ */
+export function savedDefaultEmployeeBasePrompt(prompt) {
+    const prefix = DEFAULT_EMPLOYEE_PROMPT + "\n\n近期使用偏好（仅作参考；本轮要求冲突时忽略）：\n";
+    if (prompt.startsWith(prefix) && /^- (?:沟通|工作方式|近期关注)：[^\n]+(?:\n- (?:沟通|工作方式|近期关注)：[^\n]+)*$/.test(prompt.slice(prefix.length))) {
+        return DEFAULT_EMPLOYEE_PROMPT;
+    }
+    return prompt;
+}
+/** Seed profile defaults once; future memory is a pure projection over the saved role. */
 export function defaultEmployeeDefinition(agents, now, existing, profile, time = Date.now()) {
     const preferences = profile && profile.expiresAt > time ? profile.preferences : [];
     const memory = preferences.length ? [
@@ -16,13 +27,14 @@ export function defaultEmployeeDefinition(agents, now, existing, profile, time =
         ...preferences.map((entry) => `- ${entry.category === "communication" ? "沟通" : entry.category === "workflow" ? "工作方式" : "近期关注"}：${entry.text}`),
     ].join("\n") : "";
     return {
+        ...existing,
         id: existing?.id ?? DEFAULT_EMPLOYEE_ID,
         systemKey: DEFAULT_EMPLOYEE_KEY,
         tags: [DEFAULT_EMPLOYEE_TAG],
-        name: DEFAULT_EMPLOYEE_NAME,
-        duty: DEFAULT_EMPLOYEE_DUTY,
-        prompt: DEFAULT_EMPLOYEE_PROMPT + memory,
-        avatar: "",
+        name: existing?.name ?? DEFAULT_EMPLOYEE_NAME,
+        duty: existing?.duty ?? DEFAULT_EMPLOYEE_DUTY,
+        prompt: savedDefaultEmployeeBasePrompt(existing?.prompt ?? DEFAULT_EMPLOYEE_PROMPT) + memory,
+        avatar: existing?.avatar ?? fixedEmployeeAvatar({ id: DEFAULT_EMPLOYEE_ID, systemKey: DEFAULT_EMPLOYEE_KEY }),
         agents: agents.length ? agents : systemEmployeeSeedAgents(),
         createdAt: existing?.createdAt ?? now,
         updatedAt: now,

package/dist/employee-text.d.ts

@@ -0,0 +1,28 @@
+import { getDefaultModelForProvider } from "./config.js";
+import { type OpenRouterFreeModelsService } from "./openrouter-free-models.js";
+import { type StructuredFailure } from "./structured-failure.js";
+import type { WandTaskAgent } from "./task-types.js";
+import type { AiTextRequest, WandConfig } from "./types.js";
+export interface EmployeeTextDeps {
+    config: Pick<WandConfig, "harness" | "inheritEnv" | "modelGroups"> & {
+        defaultCwd?: string;
+    };
+    free?: Pick<OpenRouterFreeModelsService, "resolveForCall">;
+    onUsage?: (usage: {
+        inputTokens: number;
+        outputTokens: number;
+        model: string;
+    }) => void;
+}
+/** Expand each configured slot once; equivalent leaves execute once in first occurrence order. */
+export declare function employeeTextCandidates(agents: readonly WandTaskAgent[], config: Parameters<typeof getDefaultModelForProvider>[0] & Pick<WandConfig, "modelGroups">): Array<{
+    agent: WandTaskAgent;
+    index: number;
+}>;
+export declare function abortableEmployeeText<T>(pending: Promise<T>, signal: AbortSignal): Promise<T>;
+export declare class EmployeeCandidateRejected extends Error {
+    readonly failure: StructuredFailure;
+    constructor(failure: StructuredFailure);
+}
+/** Prepare a configured, no-tool adapter before any user input is accepted. */
+export declare function prepareEmployeeTextCandidate(deps: EmployeeTextDeps, agent: WandTaskAgent, request: AiTextRequest, signal: AbortSignal): Promise<() => Promise<string>>;