@co0ontty/wand 4.89.0 → 4.89.2-beta.gd071c20

package/dist/storage.js

@@ -1,4 +1,5 @@
 import crypto from "node:crypto";
+import { FIXED_EMPLOYEE_AVATARS, fixedEmployeeAvatar, isFixedAvatarEmployee } from "./fixed-employee-avatar.js";
 import { CONVERSATION_OWNER } from "./conversation-types.js";
 import { chmodSync, existsSync, mkdirSync } from "node:fs";
 import path from "node:path";
@@ -20,6 +21,8 @@ import { isThinkingEffort } from "./structured-provider-common.js";
 import { DEFAULT_EMPLOYEE_KEY } from "./ai-team-types.js";
 import { defaultEmployeeDefinition, legacyPtyRoleIdentity } from "./default-employee.js";
 import { DECISION_EXPERT_KEY } from "./decision-expert-identity.js";
+import { SPEECH_POLISHER_KEY } from "./speech-polisher-identity.js";
+import { speechPolisherDefinition } from "./speech-polisher-employee.js";
 import { decisionExpertDefinition } from "./decision-expert-employee.js";
 import { normalizeEmployeeKnowledge } from "./employee-knowledge-content.js";
 import { EMPLOYEE_KNOWLEDGE_MAX_ENTRIES } from "./employee-knowledge-types.js";
@@ -322,7 +325,11 @@ function parseQueuedMessages(raw) {
 function parseWorktreeInfo(raw) {
     const parsed = safeJsonParse(raw);
     if (parsed && typeof parsed.branch === "string" && typeof parsed.path === "string") {
-        return { branch: parsed.branch, path: parsed.path };
+        return {
+            branch: parsed.branch, path: parsed.path,
+            ...(typeof parsed.baseRef === "string" ? { baseRef: parsed.baseRef } : {}),
+            ...(typeof parsed.repoRoot === "string" ? { repoRoot: parsed.repoRoot } : {}),
+        };
     }
     return undefined;
 }
@@ -2713,9 +2720,14 @@ export class WandStorage {
         const state = this.getUserMemoryState();
         return defaultEmployeeDefinition(employee.agents, employee.updatedAt, employee, state.enabled ? state.profile : null);
     }
-    getSiliconEmployee(id) {
+    /** Saved definition without generated short-term preferences. */
+    getSiliconEmployeeDefinition(id) {
         const row = this.db.prepare("SELECT * FROM silicon_employees WHERE id = ?").get(id);
-        return row ? this.projectDefaultEmployee(mapSiliconEmployeeRow(row)) : null;
+        return row ? mapSiliconEmployeeRow(row) : null;
+    }
+    getSiliconEmployee(id) {
+        const employee = this.getSiliconEmployeeDefinition(id);
+        return employee ? this.projectDefaultEmployee(employee) : null;
     }
     getDefaultSiliconEmployee() {
         const employee = this.getSystemSiliconEmployee(DEFAULT_EMPLOYEE_KEY);
@@ -2724,43 +2736,25 @@ export class WandStorage {
     /** Seed once, preserve execution choices, and never reset learned preferences on restart. */
     ensureDefaultSiliconEmployee(provider) {
         const existing = this.getSystemSiliconEmployee(DEFAULT_EMPLOYEE_KEY);
-        const state = this.getUserMemoryState();
-        const definition = defaultEmployeeDefinition(existing?.agents ?? systemEmployeeSeedAgents({ provider }), new Date().toISOString(), existing, state.enabled ? state.profile : null);
-        if (!existing || existing.name !== definition.name || existing.duty !== definition.duty
-            || existing.prompt !== definition.prompt || existing.avatar !== definition.avatar
-            || existing.archivedAt || !existing.agents.length) {
-            this.saveSiliconEmployee(definition);
-            return definition;
-        }
-        return existing;
+        if (existing)
+            return this.projectDefaultEmployee(existing);
+        const definition = defaultEmployeeDefinition(systemEmployeeSeedAgents({ provider }), new Date().toISOString());
+        this.saveSiliconEmployee(definition);
+        return this.projectDefaultEmployee(definition);
     }
     /** 内置「系统运维」员工；未创建（或被删除过）时返回 null。 */
     getSystemSiliconEmployee(key = SYSTEM_EMPLOYEE_KEY) {
         const row = this.db.prepare("SELECT * FROM silicon_employees WHERE system_key = ?").get(key);
         return row ? mapSiliconEmployeeRow(row) : null;
     }
-    /**
-     * 幂等地保证内置员工存在。已存在时只补齐锁定字段（防止旧的同名定义漂移），
-     * 候选保留用户当下的设置；不存在时按 seed 建首条候选。
-     */
+    /** Seed only when missing; restart never overwrites user profile, candidates, or legacy avatars. */
     ensureSystemSiliconEmployee(seed = {}) {
         const existing = this.getSystemSiliconEmployee();
-        if (!existing) {
-            const employee = systemEmployeeDefinition(systemEmployeeSeedAgents(seed), new Date().toISOString());
-            this.saveSiliconEmployee(employee);
-            return employee;
-        }
-        const locked = systemEmployeeDefinition(existing.agents, new Date().toISOString(), existing);
-        if (existing.name !== locked.name
-            || existing.duty !== locked.duty
-            || existing.prompt !== locked.prompt
-            || existing.avatar !== locked.avatar
-            || existing.archivedAt !== undefined
-            || existing.agents.length === 0) {
-            this.saveSiliconEmployee(locked);
-            return locked;
-        }
-        return existing;
+        if (existing)
+            return existing;
+        const employee = systemEmployeeDefinition(systemEmployeeSeedAgents(seed), new Date().toISOString());
+        this.saveSiliconEmployee(employee);
+        return employee;
     }
     /** Stable built-in decision employee; seed once and retain the user's ordered call chain. */
     ensureDecisionExpertEmployee() {
@@ -2773,7 +2767,32 @@ export class WandStorage {
         }
         return existing;
     }
+    /** Seed the SDK free group once, then preserve independent user choices. */
+    ensureSpeechPolisherEmployee() {
+        const existing = this.getSystemSiliconEmployee(SPEECH_POLISHER_KEY);
+        const definition = speechPolisherDefinition(new Date().toISOString(), existing);
+        if (!existing || existing.name !== definition.name || existing.duty !== definition.duty || existing.prompt !== definition.prompt
+            || existing.avatar !== definition.avatar || existing.archivedAt || !existing.agents.length) {
+            this.saveSiliconEmployee(definition);
+            return definition;
+        }
+        return existing;
+    }
     saveSiliconEmployee(employee) {
+        const existing = this.getSiliconEmployeeDefinition(employee.id);
+        const target = FIXED_EMPLOYEE_AVATARS.find((entry) => entry.id === employee.id || entry.systemKey === employee.systemKey);
+        if (target) {
+            if (employee.id !== target.id || employee.systemKey !== target.systemKey)
+                throw new Error("内置员工身份不可修改或冒用。");
+            if (existing && !isFixedAvatarEmployee(existing))
+                throw new Error("内置员工身份冲突，不能覆盖已有记录。");
+            if (employee.avatar !== (existing?.avatar ?? target.avatar))
+                throw new Error("该员工是内置的，头像不可修改。");
+            if (existing && JSON.stringify(employee.tags) !== JSON.stringify(existing.tags))
+                throw new Error("该员工是内置的，标签不可修改。");
+            if (employee.archivedAt !== existing?.archivedAt)
+                throw new Error("内置员工不可归档。");
+        }
         const tags = isBuiltinSiliconEmployee(employee)
             ? siliconEmployeeTags(employee)
             : parseSiliconEmployeeTags(employee.tags ?? []);
@@ -2791,13 +2810,46 @@ export class WandStorage {
          archived_at = excluded.archived_at,
          updated_at = excluded.updated_at`).run(employee.id, employee.name, employee.duty, employee.prompt, employee.avatar, JSON.stringify(employee.agents), employee.systemKey ?? null, employee.archivedAt ?? null, employee.createdAt, employee.updatedAt, JSON.stringify(tags));
     }
+    /** Explicit, atomic migration; not called from GET, config load, seeds, or ordinary saves.
+     * Compare all expected avatar values first; change only avatar, including preserving timestamps.
+     */
+    migrateFixedEmployeeAvatars(expected) {
+        return this.transaction(() => {
+            if (expected.length !== FIXED_EMPLOYEE_AVATARS.length || new Set(expected.map((entry) => entry.id)).size !== expected.length) {
+                throw new Error("固定头像迁移需要两个精确且不同的目标。");
+            }
+            const rows = FIXED_EMPLOYEE_AVATARS.map((target) => {
+                const prior = expected.find((entry) => entry.id === target.id && entry.systemKey === target.systemKey);
+                const employee = this.getSiliconEmployeeDefinition(target.id);
+                if (!prior || !employee || fixedEmployeeAvatar(employee) !== target.avatar)
+                    throw new Error("固定头像迁移目标不存在或身份冲突。");
+                if (employee.avatar !== prior.avatar && employee.avatar !== target.avatar)
+                    throw new Error("固定头像迁移检测到头像已变化，请重新核对。");
+                return { target, employee };
+            });
+            let changed = 0;
+            for (const { target, employee } of rows) {
+                if (employee.avatar === target.avatar)
+                    continue;
+                changed += Number(this.db.prepare("UPDATE silicon_employees SET avatar = ? WHERE id = ? AND system_key = ? AND avatar = ?")
+                    .run(target.avatar, target.id, target.systemKey, employee.avatar).changes);
+            }
+            return changed;
+        });
+    }
     archiveSiliconEmployee(id, archivedAt = new Date().toISOString()) {
+        if (isFixedAvatarEmployee(this.getSiliconEmployeeDefinition(id) ?? {}))
+            throw new Error("内置员工不可归档。");
         this.db.prepare("UPDATE silicon_employees SET archived_at = ?, updated_at = ? WHERE id = ?").run(archivedAt, new Date().toISOString(), id);
     }
     unarchiveSiliconEmployee(id) {
+        if (isFixedAvatarEmployee(this.getSiliconEmployeeDefinition(id) ?? {}))
+            throw new Error("内置员工不能恢复归档。");
         this.db.prepare("UPDATE silicon_employees SET archived_at = NULL, updated_at = ? WHERE id = ?").run(new Date().toISOString(), id);
     }
     deleteSiliconEmployee(id) {
+        if (isFixedAvatarEmployee(this.getSiliconEmployeeDefinition(id) ?? {}))
+            throw new Error("内置员工不可删除。");
         this.db.prepare("DELETE FROM silicon_employees WHERE id = ?").run(id);
     }
     // ============ Employee-owned explicit knowledge ============

package/dist/structured-session-manager.d.ts

@@ -86,6 +86,7 @@ export declare class StructuredSessionManager {
     private readonly logger;
     private readonly execHost?;
     private readonly decisionRuntime;
+    private readonly openRouter?;
     /** 「智能分配」专用的本地决策入口：只有真正能跑时才注入，没注入则用系统员工回退。 */
     private readonly autoAssignEvaluate;
     private readonly sessions;
@@ -140,7 +141,7 @@ export declare class StructuredSessionManager {
     private detachedRecoveryRetryTimer;
     private detachedRecoveryFailureLogged;
     private disposed;
-    constructor(storage: WandStorage, config: WandConfig, logger?: SessionLogger | null, runners?: StructuredSessionManagerRunners, execHost?: StructuredExecHost | undefined, decisionRuntime?: () => DecisionRuntimeAccess | null, openRouter?: OpenRouterFreeModelsService, 
+    constructor(storage: WandStorage, config: WandConfig, logger?: SessionLogger | null, runners?: StructuredSessionManagerRunners, execHost?: StructuredExecHost | undefined, decisionRuntime?: () => DecisionRuntimeAccess | null, openRouter?: OpenRouterFreeModelsService | undefined, 
     /** 「智能分配」专用的本地决策入口：只有真正能跑时才注入，没注入则用系统员工回退。 */
     autoAssignEvaluate?: () => DecisionRuntimeAccess["evaluate"]);
     private archiveExpiredSessions;
@@ -173,7 +174,7 @@ export declare class StructuredSessionManager {
     get(id: string): SessionSnapshot | null;
     setSessionWorkspace(id: string, membership: Pick<SessionSnapshot, "workspaceId" | "workspaceTaskId">): void;
     setSessionTopic(id: string, title: string, description: string): SessionSnapshot;
-    /** 归档会先停掉还在跑的回合，会话 ID 和 provider session id 都留着。 */
+    /** 归档只写标记，正在执行的回合和历史继续保留。 */
     setSessionArchived(id: string, archived: boolean): SessionSnapshot;
     private setSessionTopicGenerating;
     /**

package/dist/structured-session-manager.js

@@ -10,6 +10,7 @@ import { stampNewToolUseTimes } from "./tool-use-timestamps.js";
 import { buildChildEnv } from "./env-utils.js";
 import { getErrorMessage } from "./error-utils.js";
 import { getDefaultModelForProvider } from "./config.js";
+import { isLocalDecisionModel } from "./decision-expert-identity.js";
 import { recordIterationPrompt } from "./iteration-log.js";
 import { startEmployeeKnowledgeRunner } from "./employee-knowledge.js";
 import { CoreRunner } from "./core-runner.js";
@@ -436,6 +437,7 @@ export class StructuredSessionManager {
     logger;
     execHost;
     decisionRuntime;
+    openRouter;
     autoAssignEvaluate;
     sessions = new Map();
     // Both freshly started runners and adopted daemon runs own the same input gate.
@@ -500,6 +502,7 @@ export class StructuredSessionManager {
         this.logger = logger;
         this.execHost = execHost;
         this.decisionRuntime = decisionRuntime;
+        this.openRouter = openRouter;
         this.autoAssignEvaluate = autoAssignEvaluate;
         const wrap = (runner) => withModelGroups(withDecisionAccess(runner, storage, decisionRuntime), config);
         this.claudeCliRunner = wrap(runners.claudeCli ?? new ClaudeCliRunner({ language: () => this.config.language }, this.execHost));
@@ -1238,11 +1241,9 @@ export class StructuredSessionManager {
         this.emitStructuredSnapshot(updated);
         return updated;
     }
-    /** 归档会先停掉还在跑的回合，会话 ID 和 provider session id 都留着。 */
+    /** 归档只写标记，正在执行的回合和历史继续保留。 */
     setSessionArchived(id, archived) {
-        const current = archived && this.requireSession(id).status === "running"
-            ? this.stop(id)
-            : this.requireSession(id);
+        const current = this.requireSession(id);
         const archivedAt = archived ? new Date().toISOString() : null;
         const updated = { ...current, archived, archivedAt };
         this.sessions.set(id, updated);
@@ -1309,7 +1310,7 @@ export class StructuredSessionManager {
             input,
             cwd: session.cwd,
             language: this.config.language,
-            ai: resolveSystemAiContext(session, this.config, this.storage.getSystemSiliconEmployee()),
+            ai: resolveSystemAiContext(session, this.config, this.storage.getSystemSiliconEmployee(), this.openRouter),
             readNativeTitle: () => readNativeSessionTitle(resolveSessionProvider(session), session.claudeSessionId, session.cwd),
             hasNativeTitle,
             onGenerating: (generating) => {
@@ -1499,7 +1500,10 @@ export class StructuredSessionManager {
             return null;
         const candidates = original.employeeCandidates ?? [];
         const index = original.employeeCandidateIndex ?? 0;
-        const nextIndex = index + 1;
+        let nextIndex = index + 1;
+        // LAYA has no chat adapter; keep original candidate indices while skipping bounded-only models.
+        while (nextIndex < candidates.length && isLocalDecisionModel(candidates[nextIndex].model))
+            nextIndex += 1;
         if (!original.employeeId || (original.messages?.length ?? 0) !== 0 || original.claudeSessionId
             || !error.failure.retryable || nextIndex >= candidates.length)
             return null;
@@ -1688,7 +1692,7 @@ export class StructuredSessionManager {
                     prompt,
                     groups: this.config.modelGroups,
                     evaluate: this.autoAssignEvaluate(),
-                    ai: resolveSystemAiContext(session, this.config, this.storage.getSystemSiliconEmployee()),
+                    ai: resolveSystemAiContext(session, this.config, this.storage.getSystemSiliconEmployee(), this.openRouter),
                     cwd: session.cwd,
                     language: this.config.language,
                 });

package/dist/system-employee.d.ts

@@ -6,8 +6,8 @@ export { SYSTEM_EMPLOYEE_ID, SYSTEM_EMPLOYEE_KEY, SYSTEM_EMPLOYEE_NAME, SYSTEM_E
  * 内置的「系统运维」员工。
  *
  * Wand 自己的 AI 调用（commit message / tag、提示词优化、会话与任务标题、
- * 员工起草）都通过这位员工的 CLI 候选链执行：名字、职责与人设写死在代码里，不可编辑、不可归档、
- * 不可删除；只有执行候选（CLI 工具 + 模型 + 思考深度，按顺序降级）由用户维护。候选中的 SDK 会被系统应用跳过。
+ * 员工起草）都通过这位员工的候选链执行：身份和头像固定，不可归档、不可删除；
+ * 名字、职责、人设与执行候选（工具 + 引擎 + 模型 + 思考深度）由用户维护。
  */
 export declare const SYSTEM_EMPLOYEE_DUTY = "Wand \u7CFB\u7EDF\u8FD0\u7EF4\uFF1A\u670D\u52A1\u4E0E CLI \u7EBF\u8DEF\u3001\u66F4\u65B0\u5206\u53D1\u3001\u4ED3\u5E93\u4E0E\u4F1A\u8BDD\u64CD\u4F5C\uFF0CWand \u81EA\u6709 AI \u4EFB\u52A1\u7684\u6267\u884C\u8005\u3002";
 /**
@@ -29,6 +29,8 @@ export declare function systemEmployeeSeedAgents(seed?: SystemEmployeeSeed): Wan
 export declare function systemEmployeeDefinition(agents: WandTaskAgent[], now: string, existing?: SiliconEmployee | null): SiliconEmployee;
 export declare function isSdkEmployeeAgent(agent: Pick<WandTaskAgent, "engine">): boolean;
 /**
- * 系统应用只走员工的 CLI 渠道：员工候选里可以保存 SDK，但这里明确跳过。
+ * 系统应用沿用员工配置顺序和引擎；不按触发来源过滤工具。
  */
-export declare function systemEmployeeCliCandidates(employee: Pick<SiliconEmployee, "agents"> | null | undefined): AiCliCandidate[];
+export declare function systemEmployeeCandidates(employee: Pick<SiliconEmployee, "agents"> | null | undefined): AiCliCandidate[];
+/** Compatibility name for existing callers; the chain also includes Wand Agent. */
+export declare const systemEmployeeCliCandidates: typeof systemEmployeeCandidates;

package/dist/system-employee.js

@@ -1,4 +1,5 @@
 import { SYSTEM_EMPLOYEE_ID, SYSTEM_EMPLOYEE_KEY, SYSTEM_EMPLOYEE_NAME, SYSTEM_EMPLOYEE_TAG, isSystemSiliconEmployee, } from "./ai-team-types.js";
+import { fixedEmployeeAvatar } from "./fixed-employee-avatar.js";
 import { isSessionProvider } from "./session-provider.js";
 import { DEFAULT_WAND_TASK_AGENT_KIND, DEFAULT_WAND_TASK_AGENT_MODE, normalizeWandTaskAgentMode } from "./task-types.js";
 // 常量与判定定义在 ai-team-types（浏览器也要用），这里再导出一次，服务端只从一个地方引用。
@@ -7,8 +8,8 @@ export { SYSTEM_EMPLOYEE_ID, SYSTEM_EMPLOYEE_KEY, SYSTEM_EMPLOYEE_NAME, SYSTEM_E
  * 内置的「系统运维」员工。
  *
  * Wand 自己的 AI 调用（commit message / tag、提示词优化、会话与任务标题、
- * 员工起草）都通过这位员工的 CLI 候选链执行：名字、职责与人设写死在代码里，不可编辑、不可归档、
- * 不可删除；只有执行候选（CLI 工具 + 模型 + 思考深度，按顺序降级）由用户维护。候选中的 SDK 会被系统应用跳过。
+ * 员工起草）都通过这位员工的候选链执行：身份和头像固定，不可归档、不可删除；
+ * 名字、职责、人设与执行候选（工具 + 引擎 + 模型 + 思考深度）由用户维护。
  */
 export const SYSTEM_EMPLOYEE_DUTY = "Wand 系统运维：服务与 CLI 线路、更新分发、仓库与会话操作，Wand 自有 AI 任务的执行者。";
 /**
@@ -45,11 +46,10 @@ export function systemEmployeeSeedAgents(seed = {}) {
 export function systemEmployeeDefinition(agents, now, existing) {
     return {
         id: existing?.id ?? SYSTEM_EMPLOYEE_ID,
-        name: SYSTEM_EMPLOYEE_NAME,
-        duty: SYSTEM_EMPLOYEE_DUTY,
-        prompt: SYSTEM_EMPLOYEE_PROMPT,
-        // 空头像 = 按 id/name 稳定派生一只像素猫，与用户员工同一套。
-        avatar: "",
+        name: existing?.name ?? SYSTEM_EMPLOYEE_NAME,
+        duty: existing?.duty ?? SYSTEM_EMPLOYEE_DUTY,
+        prompt: existing?.prompt ?? SYSTEM_EMPLOYEE_PROMPT,
+        avatar: existing?.avatar ?? fixedEmployeeAvatar({ id: SYSTEM_EMPLOYEE_ID, systemKey: SYSTEM_EMPLOYEE_KEY }),
         agents: agents.length ? agents : systemEmployeeSeedAgents(),
         systemKey: SYSTEM_EMPLOYEE_KEY,
         tags: [SYSTEM_EMPLOYEE_TAG],
@@ -61,19 +61,22 @@ export function isSdkEmployeeAgent(agent) {
     return agent.engine === "sdk";
 }
 /**
- * 系统应用只走员工的 CLI 渠道：员工候选里可以保存 SDK，但这里明确跳过。
+ * 系统应用沿用员工配置顺序和引擎；不按触发来源过滤工具。
  */
-export function systemEmployeeCliCandidates(employee) {
+export function systemEmployeeCandidates(employee) {
     if (!employee)
         return [];
     return employee.agents
-        .filter((agent) => agent.kind === "structured" && !isSdkEmployeeAgent(agent))
+        .filter((agent) => agent.kind === "structured")
         .map((agent) => {
         const model = (agent.model ?? "").trim();
         return {
             provider: agent.provider,
+            ...(agent.engine ? { engine: agent.engine } : {}),
             model: !model || model === "default" ? undefined : model,
             thinkingEffort: agent.thinkingEffort,
         };
     });
 }
+/** Compatibility name for existing callers; the chain also includes Wand Agent. */
+export const systemEmployeeCliCandidates = systemEmployeeCandidates;

package/dist/types.d.ts

@@ -226,11 +226,13 @@ export interface AiTextRequest {
     prompt: string;
 }
 /**
- * Wand 自有 AI 调用（commit message、标题、提示词优化…）的一条 CLI 执行候选。
+ * Wand 自有 AI 调用（commit message、标题、提示词优化…）的一条执行候选。
  * 候选顺序即降级顺序；由内置「系统运维」员工维护。
  */
 export interface AiCliCandidate {
     provider: SessionProvider;
+    /** 缺省为 CLI；显式 sdk 保持 Wand Agent 引擎身份。 */
+    engine?: "cli" | "sdk";
     /** 具体模型 ID；未设置表示跟随 provider 默认模型。 */
     model?: string;
     thinkingEffort?: ThinkingEffort;

package/dist/user-memory.d.ts

@@ -1,3 +1,4 @@
+import type { EmployeeTextDeps } from "./employee-text.js";
 import type { WandStorage } from "./storage.js";
 import type { WandConfig } from "./types.js";
 import { type UserMemoryEvent, type UserMemoryPreference, type UserMemoryView } from "./user-memory-types.js";
@@ -18,6 +19,7 @@ export declare class UserMemoryService {
     constructor(deps: {
         storage: WandStorage;
         config: WandConfig;
+        free?: EmployeeTextDeps["free"];
         notifyChanged?: (id: string) => void;
         now?: () => number;
         generate?: (events: UserMemoryEvent[]) => Promise<UserMemoryPreference[]>;

package/dist/user-memory.js

@@ -160,7 +160,7 @@ export class UserMemoryService {
             }, config.defaultCwd, config.language ?? "", resolveSystemAiContext({
                 provider: config.defaultProvider ?? "claude", command: config.defaultProvider ?? "claude",
                 selectedModel: null, thinkingEffort: config.defaultThinkingEffort,
-            }, config, storage.getSystemSiliconEmployee()), (raw) => parseUserMemoryPreferences(raw, events));
+            }, config, storage.getSystemSiliconEmployee(), this.deps.free), (raw) => parseUserMemoryPreferences(raw, events));
         // Test seam and production share the exact same validator.
         const validated = parseUserMemoryPreferences(JSON.stringify({ preferences }), events);
         const referenced = new Set(validated.flatMap((entry) => entry.evidenceIds));

package/dist/wand-task-sync.js

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { isSessionProvider } from "./session-provider.js";
 import { provisionalTaskTitleFromDescription } from "./task-title.js";
 /** 未命名任务的占位名；服务端新建时写入，自动命名成功后被真实标题覆盖。 */
 export const UNNAMED_WORKSPACE_TASK_NAME = "未命名任务";
@@ -10,6 +11,8 @@ export function isUnnamedWorkspaceTaskName(name) {
 }
 /** Legacy title helper; prompts name sessions, not their containing task. */
 export function boardTitleFromSession(session) {
+    if (isBlankTerminal(session))
+        return "";
     const title = session.title?.trim();
     if (title && !isUnnamedWorkspaceTaskName(title))
         return provisionalTaskTitleFromDescription(title);
@@ -26,6 +29,9 @@ export function boardTitleFromSession(session) {
     }
     return "";
 }
+function isBlankTerminal(session) {
+    return session.sessionKind !== "structured" && !isSessionProvider(session.provider);
+}
 /**
  * 自动命名只覆盖「还没有人为名字」的任务：标题来源是 auto，或仍是占位名的历史卡片
  * （老版本把未命名任务写成了 titleSource=user）。用户在面板 / 侧栏改过名后此处为 false。
@@ -46,8 +52,9 @@ function taskNamingSessions(storage, card) {
             return;
         add(session);
         // boardTitleFromSession 只在 title/description 都缺时才翻 messages 找首条用户输入。
-        if (!session.title?.trim() && !session.description?.trim())
+        if (!isBlankTerminal(session) && !session.title?.trim() && !session.description?.trim()) {
             needsMessageFallback.push(session.id);
+        }
     };
     if (card.workspaceTaskId) {
         for (const session of storage.listSessionsByWorkspaceTaskSlim(card.workspaceTaskId))
@@ -68,6 +75,10 @@ function taskNamingSessions(storage, card) {
  * 为空表示这个任务还没有可命名的内容，调用方应保留占位标题。
  */
 export function taskAutoNameSourceText(storage, card) {
+    const sessions = taskNamingSessions(storage, card);
+    // 只有空白终端的任务不总结；后来加入 Agent 时再按真实任务内容命名。
+    if (sessions.length > 0 && sessions.every(isBlankTerminal))
+        return "";
     const parts = [];
     for (const line of card.description.split(/\r?\n/)) {
         const trimmed = line.trim();
@@ -75,7 +86,7 @@ export function taskAutoNameSourceText(storage, card) {
             continue;
         parts.push(trimmed);
     }
-    for (const session of taskNamingSessions(storage, card)) {
+    for (const session of sessions) {
         const candidate = boardTitleFromSession(session);
         if (candidate)
             parts.push(candidate);