@co0ontty/wand 4.70.0-beta.gff952fe → 4.71.0

package/dist/server.js

@@ -45,6 +45,7 @@ import { RuntimeConfigState } from "./runtime-config.js";
 import { safeServiceInstalled } from "./tui/runtime-utils.js";
 import { checkManagedServiceUpdatePreflight, } from "./update-helper.js";
 import { toSessionDetailDTO } from "./session-transport.js";
+import { syncWorkspaceTaskToBoard } from "./wand-task-sync.js";
 import { registerUploadRoutes } from "./upload-routes.js";
 import { optimizePrompt, PromptOptimizeError } from "./prompt-optimizer.js";
 import { resolveDatabasePath, WandStorage } from "./storage.js";
@@ -625,7 +626,7 @@ export async function startServer(config, configPath, options = {}) {
     });
     registerGithubRoutes(app, { storage, requireAdmin, sessions: sessionRegistry });
     // 任务管理与 Missions 一样只需登录：原生 connected-app 也要能列/建/派发。
-    registerTaskRoutes(app, { storage, sessions: sessionRegistry, structured: structuredSessions, config });
+    registerTaskRoutes(app, { storage, sessions: sessionRegistry, structured: structuredSessions, processes, config });
     registerAdminUpdateRoutes(app, {
         storage,
         config,
@@ -748,6 +749,8 @@ export async function startServer(config, configPath, options = {}) {
                     ...origin,
                 }));
             recordRecentPath(storage, snapshot.cwd);
+            // 会话一落地就挂到任务的看板卡片上，不等下一次看板列表的兜底同步。
+            syncWorkspaceTaskToBoard(storage, snapshot.workspaceTaskId);
             res.status(201).json(toSessionDetailDTO(snapshot));
         }
         catch (error) {

package/dist/storage.d.ts

@@ -137,15 +137,21 @@ export declare class WandStorage {
     }): import("./task-types.js").WandTask;
     updateWandTask(id: string, patch: Partial<Pick<import("./task-types.js").WandTask, "workspaceId" | "workspaceTaskId" | "title" | "titleSource" | "autoTitleSignature" | "description" | "status" | "priority" | "labels" | "dueDate" | "milestoneId" | "sortOrder" | "agent">>): import("./task-types.js").WandTask | null;
     deleteWandTask(id: string): void;
-    listWandMilestones(): import("./task-types.js").WandTaskMilestone[];
+    /**
+     * 里程碑列表。传工作区 id 时返回「该工作区 + 全局（workspace_id IS NULL）」；
+     * 未指定工作区（null / undefined / 空串）时返回全部。
+     */
+    listWandMilestones(workspaceId?: string | null): import("./task-types.js").WandTaskMilestone[];
     getWandMilestone(id: string): import("./task-types.js").WandTaskMilestone | null;
     createWandMilestone(input: {
         name: string;
         dueDate?: string | null;
+        workspaceId?: string | null;
     }): import("./task-types.js").WandTaskMilestone;
     updateWandMilestone(id: string, patch: {
         name?: string;
         dueDate?: string | null;
+        workspaceId?: string | null;
     }): import("./task-types.js").WandTaskMilestone | null;
     /** 删除里程碑只解绑任务（milestone_id 置空），绝不删除任务。 */
     deleteWandMilestone(id: string): boolean;

package/dist/storage.js

@@ -5,7 +5,7 @@ import { DatabaseSync } from "node:sqlite";
 import { GLOBAL_WORKSPACE_ID } from "./types.js";
 import { normalizeSessionDirectory } from "./session-directory-tree.js";
 import { inferProviderFromCommand, inferProviderFromRunner, isSessionProvider } from "./session-provider.js";
-import { normalizeWandTaskAgentMode } from "./task-types.js";
+import { DEFAULT_WAND_TASK_AGENT_KIND, DEFAULT_WAND_TASK_PRIORITY, isWandTaskAgentKind, normalizeWandTaskAgentMode } from "./task-types.js";
 import { firstLayoutTabId } from "./layout-tree.js";
 import { isThinkingEffort } from "./structured-provider-common.js";
 import { DEFAULT_PASSWORD_VAULT_ID, DEFAULT_PASSWORD_VAULT_NAME, decryptVaultSecret, encryptVaultSecret, itemMatchesFilter, normalizePasswordItemInput, normalizeVaultName, nowIso, } from "./password-manager.js";
@@ -38,7 +38,9 @@ export function parseWandTaskAgent(raw) {
         return null;
     // mode 是后加列：历史行没有该字段时按标准模式读取，不因此整条配置退化成 null。
     const mode = normalizeWandTaskAgentMode(provider, value.mode);
-    return { provider, model: model.trim(), thinkingEffort, mode };
+    // kind 同样是后加字段：老数据 / 老客户端没带时按结构化会话读取。
+    const kind = isWandTaskAgentKind(value.kind) ? value.kind : DEFAULT_WAND_TASK_AGENT_KIND;
+    return { provider, model: model.trim(), thinkingEffort, mode, kind };
 }
 /** `wand_milestones` 行 → 领域对象；名字必须非空，脏行直接跳过。 */
 function mapWandMilestoneRow(row) {
@@ -49,6 +51,7 @@ function mapWandMilestoneRow(row) {
         id: String(row.id),
         name,
         dueDate: typeof row.due_date === "string" && row.due_date ? row.due_date : null,
+        workspaceId: typeof row.workspace_id === "string" && row.workspace_id ? row.workspace_id : null,
         createdAt: String(row.created_at),
         updatedAt: String(row.updated_at),
     };
@@ -688,6 +691,7 @@ const INIT_SQL = `
     id TEXT PRIMARY KEY,
     name TEXT NOT NULL,
     due_date TEXT,
+    workspace_id TEXT,
     created_at TEXT NOT NULL,
     updated_at TEXT NOT NULL
   );
@@ -774,6 +778,19 @@ function ensureWorkspaceSchema(db) {
         db.exec("ALTER TABLE workspace_tasks ADD COLUMN milestone_id TEXT");
     }
 }
+function ensureWandMilestoneSchema(db) {
+    const columns = db.prepare("PRAGMA table_info(wand_milestones)").all();
+    const names = new Set(columns.map((column) => column.name));
+    // 里程碑归属工作区：只加列，历史行保持 NULL（读作全局里程碑，所有工作区可见）。
+    if (columns.length > 0 && !names.has("workspace_id")) {
+        db.exec("ALTER TABLE wand_milestones ADD COLUMN workspace_id TEXT");
+    }
+    if (columns.length > 0) {
+        // 索引必须等列存在后再建：老库的 CREATE TABLE IF NOT EXISTS 是空操作，
+        // 直接在 INIT_SQL 里建索引会因缺列报错。
+        db.exec("CREATE INDEX IF NOT EXISTS idx_wand_milestones_workspace ON wand_milestones(workspace_id, created_at DESC)");
+    }
+}
 function ensureConnectorSchema(db) {
     // The table is created by INIT_SQL for new databases; this repairs an
     // existing wand.db that predates the connector feature (additive-only).
@@ -802,6 +819,7 @@ export function ensureDatabaseFile(dbPath) {
     ensureCommandSessionSchema(db);
     ensureWorkspaceSchema(db);
     ensureWandTaskSchema(db);
+    ensureWandMilestoneSchema(db);
     ensureConnectorSchema(db);
     {
         const missionColumns = db.prepare("PRAGMA table_info(missions)").all();
@@ -832,6 +850,7 @@ export class WandStorage {
         ensureCommandSessionSchema(this.db);
         ensureWorkspaceSchema(this.db);
         ensureWandTaskSchema(this.db);
+        ensureWandMilestoneSchema(this.db);
         ensureConnectorSchema(this.db);
         this.ensureDefaultPasswordVault();
     }
@@ -1236,7 +1255,7 @@ export class WandStorage {
         const id = crypto.randomUUID();
         const now = nowIso();
         const status = input.status ?? "todo";
-        const priority = input.priority ?? "none";
+        const priority = input.priority ?? DEFAULT_WAND_TASK_PRIORITY;
         const max = this.db.prepare("SELECT COALESCE(MAX(sort_order), -1) AS value FROM wand_tasks WHERE workspace_id IS ? AND status = ?").get(input.workspaceId ?? null, status);
         const numberRow = this.db.prepare("SELECT COALESCE(MAX(CAST(substr(identifier, 6) AS INTEGER)), 0) AS value FROM wand_tasks WHERE identifier GLOB 'TASK-[0-9]*'").get();
         const identifier = `TASK-${(numberRow?.value ?? 0) + 1}`;
@@ -1259,19 +1278,29 @@ export class WandStorage {
         return next;
     }
     deleteWandTask(id) { this.db.prepare("DELETE FROM wand_tasks WHERE id = ?").run(id); }
-    // ── 里程碑（跨项目全局列表；任务只存 milestoneId）──
-    listWandMilestones() {
-        const rows = this.db.prepare(`SELECT id, name, due_date, created_at, updated_at FROM wand_milestones ORDER BY created_at DESC, rowid DESC`).all();
+    // ── 里程碑（迭代，归属工作区；任务只存 milestoneId）──
+    /**
+     * 里程碑列表。传工作区 id 时返回「该工作区 + 全局（workspace_id IS NULL）」；
+     * 未指定工作区（null / undefined / 空串）时返回全部。
+     */
+    listWandMilestones(workspaceId) {
+        const scoped = typeof workspaceId === "string" ? workspaceId.trim() : "";
+        const select = "SELECT id, name, due_date, workspace_id, created_at, updated_at FROM wand_milestones";
+        const order = " ORDER BY created_at DESC, rowid DESC";
+        const rows = (scoped
+            ? this.db.prepare(`${select} WHERE workspace_id = ? OR workspace_id IS NULL${order}`).all(scoped)
+            : this.db.prepare(`${select}${order}`).all());
         return rows.map(mapWandMilestoneRow).filter((item) => item !== null);
     }
     getWandMilestone(id) {
-        const row = this.db.prepare(`SELECT id, name, due_date, created_at, updated_at FROM wand_milestones WHERE id = ?`).get(id);
+        const row = this.db.prepare(`SELECT id, name, due_date, workspace_id, created_at, updated_at FROM wand_milestones WHERE id = ?`).get(id);
         return row ? mapWandMilestoneRow(row) : null;
     }
     createWandMilestone(input) {
         const id = crypto.randomUUID();
         const now = nowIso();
-        this.db.prepare(`INSERT INTO wand_milestones (id, name, due_date, created_at, updated_at) VALUES (?, ?, ?, ?, ?)`).run(id, input.name, input.dueDate ?? null, now, now);
+        const workspaceId = typeof input.workspaceId === "string" && input.workspaceId.trim() ? input.workspaceId.trim() : null;
+        this.db.prepare(`INSERT INTO wand_milestones (id, name, due_date, workspace_id, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)`).run(id, input.name, input.dueDate ?? null, workspaceId, now, now);
         return this.getWandMilestone(id);
     }
     updateWandMilestone(id, patch) {
@@ -1281,9 +1310,12 @@ export class WandStorage {
         const next = {
             name: patch.name ?? current.name,
             dueDate: patch.dueDate === undefined ? current.dueDate : patch.dueDate,
+            workspaceId: patch.workspaceId === undefined
+                ? current.workspaceId
+                : (typeof patch.workspaceId === "string" && patch.workspaceId.trim() ? patch.workspaceId.trim() : null),
             updatedAt: nowIso(),
         };
-        this.db.prepare(`UPDATE wand_milestones SET name = ?, due_date = ?, updated_at = ? WHERE id = ?`).run(next.name, next.dueDate, next.updatedAt, id);
+        this.db.prepare(`UPDATE wand_milestones SET name = ?, due_date = ?, workspace_id = ?, updated_at = ? WHERE id = ?`).run(next.name, next.dueDate, next.workspaceId, next.updatedAt, id);
         return this.getWandMilestone(id);
     }
     /** 删除里程碑只解绑任务（milestone_id 置空），绝不删除任务。 */

package/dist/structured-client-protocol.js

@@ -43,6 +43,77 @@ function questionsFromInput(input) {
     }
     return questions;
 }
+/** 派发子 Agent 的工具名：Claude Code 的 Task/Agent，以及 Wand pi 扩展的 subagent。 */
+const SUBAGENT_TOOL_NAMES = new Set(["Task", "Agent"]);
+const PI_SUBAGENT_TOOL_NAME = "Pi/subagent";
+/**
+ * 历史 turn / 非 Claude provider 的子 Agent 工具调用没有 `__subagent` 盖章，
+ * 按调用参数现场补一份，让「子 Agent」面板在所有端都拿得到同一份分组。
+ *
+ * 只认一次真正的派发：Claude 的 Task/Agent（`subagent_type` 可省），
+ * pi 扩展的 `Pi/subagent` 必须带 `agent`，避免把管理类调用误当子任务。
+ */
+function deriveSubagentMeta(block) {
+    const existing = block.__subagent;
+    if (existing?.taskId)
+        return existing;
+    const input = asRecord(block.input) ?? {};
+    if (block.name === PI_SUBAGENT_TOOL_NAME) {
+        const agent = text(input.agent);
+        const task = text(input.task);
+        if (!agent && !task)
+            return null;
+        return {
+            taskId: block.id,
+            ...(agent ? { agentType: agent } : {}),
+            ...(task ? { taskDescription: task } : {}),
+        };
+    }
+    const agentType = text(input.subagent_type);
+    // Claude 的 Task/Agent 允许省 `subagent_type`；其他工具只有在真给了 `subagent_type` 时才算派发。
+    if (!SUBAGENT_TOOL_NAMES.has(block.name) && !agentType)
+        return null;
+    const description = text(input.description);
+    return {
+        taskId: block.id,
+        ...(agentType ? { agentType } : {}),
+        ...(description ? { taskDescription: description } : {}),
+    };
+}
+/**
+ * 给没有盖章的子 Agent 调用打上 `__subagent`：派发用的 tool_use 自己带一份，
+ * 对应的 tool_result（`tool_use_id` 命中 taskId）带同一份，客户端才好判定完成态。
+ */
+function stampDerivedSubagents(messages) {
+    const byTaskId = new Map();
+    for (const turn of messages) {
+        for (const block of turn.content) {
+            if (block.type !== "tool_use")
+                continue;
+            const meta = deriveSubagentMeta(block);
+            if (meta)
+                byTaskId.set(meta.taskId, meta);
+        }
+    }
+    if (byTaskId.size === 0)
+        return messages;
+    return messages.map((turn) => ({
+        ...turn,
+        content: turn.content.map((block) => {
+            if (block.__subagent)
+                return block;
+            if (block.type === "tool_use") {
+                const meta = byTaskId.get(block.id);
+                return meta ? { ...block, __subagent: meta } : block;
+            }
+            if (block.type === "tool_result") {
+                const meta = byTaskId.get(block.tool_use_id);
+                return meta ? { ...block, __subagent: meta } : block;
+            }
+            return block;
+        }),
+    }));
+}
 function toolResultText(block) {
     if (block.type !== "tool_result")
         return "";
@@ -124,7 +195,7 @@ function tasksFromSegment(messages, start, end) {
  * This is the external interface consumed by every client.
  */
 export function enrichStructuredMessages(messages) {
-    const enriched = messages.map((turn) => ({
+    const enriched = stampDerivedSubagents(messages).map((turn) => ({
         ...turn,
         content: turn.content.map((block) => {
             if (block.type !== "tool_use" || block.name !== "AskUserQuestion")

package/dist/structured-session-manager.js

@@ -1278,7 +1278,7 @@ export class StructuredSessionManager {
                     provider: "pi",
                     commandLabel: "pi --mode json --print",
                     logKind: "pi-json",
-                    installHint: "请安装 @mariozechner/pi-coding-agent（或兼容的 Pi CLI），或重跑 `wand service:install` 刷新服务的 PATH",
+                    installHint: "请安装 @earendil-works/pi-coding-agent（或兼容的 Pi CLI），或重跑 `wand service:install` 刷新服务的 PATH",
                 });
             }
             else if (runner === "claude-sdk") {

package/dist/task-types.d.ts

@@ -2,6 +2,8 @@ export type WandTaskStatus = "todo" | "doing" | "done" | "archived";
 /** 已确认或已归档：不再算未完成，也不会被未分组会话同步重新打开。 */
 export declare function isClosedWandTaskStatus(status: WandTaskStatus): boolean;
 export type WandTaskPriority = "none" | "low" | "medium" | "high" | "urgent";
+/** 新建任务的默认优先级：用户没挑就是「低」，不再落成「无优先级」。 */
+export declare const DEFAULT_WAND_TASK_PRIORITY: WandTaskPriority;
 /** 任务派发时选择的 CLI 工具；空串表示尚未指定。 */
 export type WandTaskAgentProvider = "claude" | "codex" | "opencode" | "grok" | "qoder" | "pi";
 export type WandTaskAgentModel = string;
@@ -26,7 +28,18 @@ export declare function isWandTaskAgentMode(value: unknown): value is WandTaskAg
 export declare function supportedWandTaskAgentModes(provider: WandTaskAgentProvider): readonly WandTaskAgentMode[];
 /** 把任意（含旧数据 / 其它客户端缺省的）模式夹到该 provider 真正支持的值。 */
 export declare function normalizeWandTaskAgentMode(provider: WandTaskAgentProvider, mode: unknown): WandTaskAgentMode;
-/** 任务上的默认派发配置：先选工具 / 模型 / 思考深度 / 工作模式，再一键交给 Agent。 */
+/**
+ * 派发时创建的会话形态：
+ *   - structured：结构化对话，走 provider 的结构化 runner；
+ *   - pty：原始 CLI 终端，与「新建工作窗口」里的 PTY 一致。
+ */
+export type WandTaskAgentKind = "structured" | "pty";
+/** 合法会话形态清单；顺序即下拉顺序。 */
+export declare const WAND_TASK_AGENT_KINDS: readonly WandTaskAgentKind[];
+/** 历史行 / 老客户端没带 kind 时的兜底：结构化对话，与旧派发行为一致。 */
+export declare const DEFAULT_WAND_TASK_AGENT_KIND: WandTaskAgentKind;
+export declare function isWandTaskAgentKind(value: unknown): value is WandTaskAgentKind;
+/** 任务上的默认派发配置：先选工具 / 模型 / 思考深度 / 工作模式 / 会话形态，再一键交给 Agent。 */
 export interface WandTaskAgent {
     provider: WandTaskAgentProvider;
     /** 具体模型 ID；"default" 表示跟随服务端为该 provider 选择的默认模型。 */
@@ -34,13 +47,16 @@ export interface WandTaskAgent {
     thinkingEffort: WandTaskAgentEffort;
     /** 执行模式；缺省时按标准模式处理。 */
     mode: WandTaskAgentMode;
+    /** 派发出来的会话是结构化对话还是 PTY 终端；缺省时按结构化处理。 */
+    kind: WandTaskAgentKind;
 }
 /** 任务标题来源；标题是可选字段，留空时由服务端按描述自动生成。 */
 export type WandTaskTitleSource = "user" | "auto";
 /** 里程碑名上限；所有任务面板的新增入口共用同一约束。 */
 export declare const WAND_MILESTONE_NAME_MAX_LENGTH = 60;
 /**
- * 里程碑：跨项目的全局列表（不是每个目录一份），创建任务时从中选择或新增。
+ * 里程碑（迭代）：归属某个工作区，新建任务时按所选工作区过滤展示，也可以不选。
+ * workspaceId 为 null 表示全局里程碑（历史数据，或未指定工作区时创建），任何工作区都能选。
  * 任务只保存 milestoneId，删除里程碑时只解绑任务、不删除任务。
  */
 export interface WandTaskMilestone {
@@ -48,6 +64,8 @@ export interface WandTaskMilestone {
     name: string;
     /** YYYY-MM-DD，可为空。 */
     dueDate: string | null;
+    /** 所属工作区；null = 全局里程碑。 */
+    workspaceId: string | null;
     createdAt: string;
     updatedAt: string;
 }

package/dist/task-types.js

@@ -2,6 +2,8 @@
 export function isClosedWandTaskStatus(status) {
     return status === "done" || status === "archived";
 }
+/** 新建任务的默认优先级：用户没挑就是「低」，不再落成「无优先级」。 */
+export const DEFAULT_WAND_TASK_PRIORITY = "low";
 /** 合法执行模式清单；顺序即下拉顺序。 */
 export const WAND_TASK_AGENT_MODES = ["managed", "full-access", "default"];
 /** 历史行没有 mode 字段时的兜底：标准模式，与旧 `mode: "agent"` 的权限姿态一致。 */
@@ -28,5 +30,12 @@ export function normalizeWandTaskAgentMode(provider, mode) {
         ? DEFAULT_WAND_TASK_AGENT_MODE
         : supported[0];
 }
+/** 合法会话形态清单；顺序即下拉顺序。 */
+export const WAND_TASK_AGENT_KINDS = ["structured", "pty"];
+/** 历史行 / 老客户端没带 kind 时的兜底：结构化对话，与旧派发行为一致。 */
+export const DEFAULT_WAND_TASK_AGENT_KIND = "structured";
+export function isWandTaskAgentKind(value) {
+    return value === "structured" || value === "pty";
+}
 /** 里程碑名上限；所有任务面板的新增入口共用同一约束。 */
 export const WAND_MILESTONE_NAME_MAX_LENGTH = 60;

package/dist/wand-task-sync.d.ts

@@ -29,6 +29,16 @@ export declare function ensureWorkspaceTaskForBoardTask(storage: WandStorage, ca
 export declare function moveSessionToWorkspaceTask(storage: WandStorage, sessionId: string, taskId: string | null): void;
 /** Reconcile legacy records by explicit ids. Unassigned sessions remain unassigned. */
 export declare function syncSidebarTasksFromBoard(storage: WandStorage): void;
+/**
+ * 会话建立 / 移动后立刻把任务归属同步到看板卡片，卡片不必等下一次 `GET /api/wand-tasks`
+ * 的全量兜底同步，也不必等某个客户端碰巧拉了看板列表。
+ * 看板侧的写入失败只记日志：会话已经跑起来了，不能因为看板同步失败把创建请求打断。
+ */
+export declare function syncWorkspaceTaskToBoard(storage: WandStorage, workspaceTaskId: string | null | undefined): void;
+/**
+ * 兜底全量同步：只处理「会话带着 workspace_task_id 但卡片上还没有绑定」的历史 / 外部写入。
+ * 正常路径由 `syncWorkspaceTaskToBoard` 在会话建立时点完成。
+ */
 export declare function syncUngroupedSessionsToBoard(storage: WandStorage): void;
 /** Status and title projection is centralized in the storage writer. */
 export declare function syncClosedBoardTask(storage: WandStorage, task: WandTask): void;

package/dist/wand-task-sync.js

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { getErrorMessage } from "./error-utils.js";
 import { provisionalTaskTitleFromDescription } from "./task-title.js";
 import { isSessionProvider } from "./session-provider.js";
 import { isClosedWandTaskStatus, normalizeWandTaskAgentMode } from "./task-types.js";
@@ -83,6 +84,8 @@ function agentFromSession(session) {
         model: session.selectedModel || session.structuredState?.model || "default",
         thinkingEffort: effort === "standard" || effort === "deep" || effort === "max" ? effort : "off",
         mode: normalizeWandTaskAgentMode(session.provider, session.mode),
+        // 会话形态按会话自身的 sessionKind 还原，PTY 会话不会在「再指派」时被误当结构化。
+        kind: (session.sessionKind ?? "pty") === "structured" ? "structured" : "pty",
     };
 }
 /** Identity is the task id, never its title. Same-named tasks stay independent. */
@@ -195,28 +198,54 @@ export function syncSidebarTasksFromBoard(storage) {
         }
     });
 }
-export function syncUngroupedSessionsToBoard(storage) {
-    syncSidebarTasksFromBoard(storage);
+/** 单个任务的会话归属落到看板卡片：补卡片、按会话补 Agent、绑定会话、todo → doing。 */
+function syncTaskSessionsToBoard(storage, task, workspace) {
     storage.transaction(() => {
-        for (const workspace of storage.listWorkspaces()) {
-            for (const task of storage.listWorkspaceTasks(workspace.id)) {
-                let card = ensureBoardTaskForWorkspaceTask(storage, task, workspace);
-                const sessions = storage.listSessionsByWorkspaceTask(task.id);
-                const agent = sessions.map(agentFromSession).find((value) => value !== null);
-                const bound = new Set(storage.listWandTaskSessionIds(card.id));
-                const started = card.status === "todo" && sessions.some((session) => !bound.has(session.id));
-                if ((!card.agent && agent) || started) {
-                    card = storage.updateWandTask(card.id, {
-                        ...(!card.agent && agent ? { agent } : {}),
-                        ...(started ? { status: "doing" } : {}),
-                    }) ?? card;
-                }
-                for (const session of sessions)
-                    storage.bindWandTaskSession(card.id, session.id);
-            }
+        let card = ensureBoardTaskForWorkspaceTask(storage, task, workspace);
+        const sessions = storage.listSessionsByWorkspaceTask(task.id);
+        const agent = sessions.map(agentFromSession).find((value) => value !== null);
+        const bound = new Set(storage.listWandTaskSessionIds(card.id));
+        const started = card.status === "todo" && sessions.some((session) => !bound.has(session.id));
+        if ((!card.agent && agent) || started) {
+            card = storage.updateWandTask(card.id, {
+                ...(!card.agent && agent ? { agent } : {}),
+                ...(started ? { status: "doing" } : {}),
+            }) ?? card;
         }
+        for (const session of sessions)
+            storage.bindWandTaskSession(card.id, session.id);
     });
 }
+/**
+ * 会话建立 / 移动后立刻把任务归属同步到看板卡片，卡片不必等下一次 `GET /api/wand-tasks`
+ * 的全量兜底同步，也不必等某个客户端碰巧拉了看板列表。
+ * 看板侧的写入失败只记日志：会话已经跑起来了，不能因为看板同步失败把创建请求打断。
+ */
+export function syncWorkspaceTaskToBoard(storage, workspaceTaskId) {
+    if (!workspaceTaskId)
+        return;
+    try {
+        const task = storage.getWorkspaceTask(workspaceTaskId);
+        const workspace = task ? storage.getWorkspace(task.workspaceId) : null;
+        if (!task || !workspace)
+            return;
+        syncTaskSessionsToBoard(storage, task, workspace);
+    }
+    catch (error) {
+        console.error(`[WandTask] Failed to sync task ${workspaceTaskId} onto the board:`, getErrorMessage(error));
+    }
+}
+/**
+ * 兜底全量同步：只处理「会话带着 workspace_task_id 但卡片上还没有绑定」的历史 / 外部写入。
+ * 正常路径由 `syncWorkspaceTaskToBoard` 在会话建立时点完成。
+ */
+export function syncUngroupedSessionsToBoard(storage) {
+    syncSidebarTasksFromBoard(storage);
+    for (const workspace of storage.listWorkspaces()) {
+        for (const task of storage.listWorkspaceTasks(workspace.id))
+            syncTaskSessionsToBoard(storage, task, workspace);
+    }
+}
 /** Status and title projection is centralized in the storage writer. */
 export function syncClosedBoardTask(storage, task) {
     if (isClosedWandTaskStatus(task.status) && task.workspaceTaskId) {