@co0ontty/wand 4.68.1 → 4.69.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
-  "commit": "8d5c20f13265b4217eb6ab6196bc97c1f3b03702",
-  "builtAt": "2026-09-17T03:16:25.802Z",
-  "version": "4.68.1",
+  "commit": "249c98c050191ae67009c35602ab9c133caf0378",
+  "builtAt": "2026-09-17T11:29:15.968Z",
+  "version": "4.69.0",
   "channel": "stable"
 }

package/dist/process-manager.d.ts

@@ -125,6 +125,7 @@ export declare class ProcessManager extends EventEmitter {
     /** Lightweight snapshot for list views — omits output and messages. */
     private snapshotSlim;
     private isPermissionBlocked;
+    setSessionWorkspace(id: string, membership: Pick<SessionSnapshot, "workspaceId" | "workspaceTaskId">): void;
     setSessionTopic(id: string, title: string, description: string): SessionSnapshot;
     private setSessionTopicGenerating;
     /**

package/dist/process-manager.js

@@ -1669,6 +1669,10 @@ export class ProcessManager extends EventEmitter {
             record.ptyBridge = null;
         }
         this.flushPersist(record, true);
+        // handleTerminalExit 会因为 ptyProcess 已被清空而把这次异步退出判定为过期回调并
+        // return，所以主动停止必须自己广播 ended。少了这一步，各端会一直以为会话还在跑：
+        // 直通输入框不关闭，附件/发送全都打进已经死掉的 PTY。结构化 stop() 同样发 ended。
+        this.emitEvent({ type: "ended", sessionId: record.id, data: this.snapshot(record) });
         return this.snapshot(record);
     }
     cleanupRecord(record, terminateTerminal = true) {
@@ -1880,6 +1884,10 @@ export class ProcessManager extends EventEmitter {
     isPermissionBlocked(record) {
         return record.ptyPermissionBlocked || record.pendingEscalation !== null;
     }
+    setSessionWorkspace(id, membership) {
+        Object.assign(this.mustGet(id), membership);
+        this.emitEvent({ type: "status", sessionId: id, data: membership });
+    }
     setSessionTopic(id, title, description) {
         const record = this.mustGet(id);
         record.title = title;

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

@@ -24,4 +24,18 @@ export interface TaskRouteDependencies {
 export declare function parseTaskAgent(value: unknown, fallbackMode?: WandTaskAgentMode): WandTaskAgent | null;
 /** 等待排队中的标题生成全部结束；只有测试用，避免用例轮询。 */
 export declare function whenWandTaskTitlesSettled(): Promise<void>;
+export interface AutoTaskTitleOptions {
+    config?: WandConfig;
+    /** 可注入的标题生成器；测试里换成同步桩，避免真的起 CLI。 */
+    generateTitle?: typeof generateWandTaskTitle;
+    /** 未从任务所属工作区解析到目录时的兜底 cwd。 */
+    cwd?: string;
+}
+/**
+ * 扫描标题仍可自动命名的看板任务（titleSource=auto，或仍是占位名的历史卡片）：
+ * 先用任务描述 + 所有绑定会话的内容立即改掉占位名，再交给后台模型总结更贴切的标题。
+ * 同一个输入指纹只处理一次：内容没变就跳过，也避免自动标题与模型结果来回震荡。
+ * 用户建任务时写了名字、或事后改过名（titleSource=user 且不是占位名）的任务永不进入这里。
+ */
+export declare function refreshAutoBoardTaskTitles(storage: WandStorage, options?: AutoTaskTitleOptions): void;
 export declare function registerTaskRoutes(app: Express, deps: TaskRouteDependencies): void;

package/dist/server-task-routes.js

@@ -6,7 +6,7 @@ import { parseWandTaskAgent } from "./storage.js";
 import { generateWandTaskTitle, provisionalTaskTitleFromDescription, TASK_TITLE_MAX_LENGTH } from "./task-title.js";
 import { resolveSystemAiContext } from "./session-ai-context.js";
 import { DEFAULT_WAND_TASK_AGENT_MODE, isWandTaskAgentMode, normalizeWandTaskAgentMode, WAND_MILESTONE_NAME_MAX_LENGTH } from "./task-types.js";
-import { archiveBoardTask, syncClosedBoardTask, syncUngroupedSessionsToBoard } from "./wand-task-sync.js";
+import { archiveBoardTask, ensureWorkspaceTaskForBoardTask, isAutoNameableBoardTask, moveSessionToWorkspaceTask, syncClosedBoardTask, syncUngroupedSessionsToBoard, taskAutoNameSignature, taskAutoNameSourceText } from "./wand-task-sync.js";
 import { isSessionProvider } from "./session-provider.js";
 const STATUSES = new Set(["todo", "doing", "done", "archived"]);
 const PRIORITIES = new Set(["none", "low", "medium", "high", "urgent"]);
@@ -130,20 +130,24 @@ function taskSessionSummary(session) {
     };
 }
 /**
- * 用户没写标题时，先用描述首行当占位标题，再由后台模型总结一个更好的。
+ * 用户没写标题时，先用描述/会话内容当占位标题，再由后台模型总结一个更好的。
  * 全程不阻塞创建请求：失败只是保留占位标题，不返回错误、也不覆盖用户后来改的标题。
- * 多次建任务会排队而不是丢弃，保证每张卡片最终都会拿到标题。
+ * 多次总结会排队而不是丢弃，保证每张卡片最终都会拿到标题。
  */
 let titleGenerationChain = Promise.resolve();
-function scheduleWandTaskTitleGeneration(storage, taskId, description, options) {
+function scheduleWandTaskTitleGeneration(storage, taskId, source, signature, options) {
+    const generateTitle = options.generateTitle ?? generateWandTaskTitle;
     const cwd = options.cwd || options.config?.defaultCwd || process.cwd();
     const run = async () => {
         try {
-            const title = await options.generateTitle(description, cwd, options.config?.language ?? "", taskTitleAiOptions(options.config));
+            const title = await generateTitle(source, cwd, options.config?.language ?? "", taskTitleAiOptions(options.config));
             const current = storage.getWandTask(taskId);
             // 用户已经自己写了标题（原生端 / 面板编辑）就不要覆盖。
             if (!current || current.titleSource !== "auto")
                 return;
+            // 命名输入已经变了（新增会话 / 会话内容更新）：这次是过期结果，交给下一轮。
+            if (current.autoTitleSignature !== signature)
+                return;
             const clipped = title.slice(0, TASK_TITLE_MAX_LENGTH);
             if (!clipped || clipped === current.title)
                 return;
@@ -159,6 +163,40 @@ function scheduleWandTaskTitleGeneration(storage, taskId, description, options)
 export function whenWandTaskTitlesSettled() {
     return titleGenerationChain;
 }
+/**
+ * 扫描标题仍可自动命名的看板任务（titleSource=auto，或仍是占位名的历史卡片）：
+ * 先用任务描述 + 所有绑定会话的内容立即改掉占位名，再交给后台模型总结更贴切的标题。
+ * 同一个输入指纹只处理一次：内容没变就跳过，也避免自动标题与模型结果来回震荡。
+ * 用户建任务时写了名字、或事后改过名（titleSource=user 且不是占位名）的任务永不进入这里。
+ */
+export function refreshAutoBoardTaskTitles(storage, options = {}) {
+    for (const card of storage.listWandTasks()) {
+        if (!isAutoNameableBoardTask(card))
+            continue;
+        const source = taskAutoNameSourceText(storage, card);
+        if (!source)
+            continue;
+        const signature = taskAutoNameSignature(source);
+        if (card.autoTitleSignature === signature)
+            continue;
+        const provisional = provisionalTaskTitleFromDescription(source);
+        storage.updateWandTask(card.id, {
+            titleSource: "auto",
+            autoTitleSignature: signature,
+            ...(provisional && provisional !== card.title ? { title: provisional } : {}),
+        });
+        // 未启用模型（如部分只验证占位改名的单测）时只保留立即生效的占位标题。
+        if (!options.generateTitle && !options.config)
+            continue;
+        const cwd = options.cwd
+            || (card.workspaceId ? storage.getWorkspace(card.workspaceId)?.cwd : undefined);
+        scheduleWandTaskTitleGeneration(storage, card.id, source, signature, {
+            cwd,
+            config: options.config,
+            generateTitle: options.generateTitle,
+        });
+    }
+}
 /** 自动生成标题没有会话上下文，按「默认 provider + 默认模型」解析，与提示词优化一致。 */
 function taskTitleAiOptions(config) {
     if (!config)
@@ -185,6 +223,13 @@ export function registerTaskRoutes(app, deps) {
         catch (error) {
             console.error("[WandTask] Failed to sync ungrouped sessions onto the board:", getErrorMessage(error));
         }
+        try {
+            // 侧栏建的任务 / 后续新增的会话都会在这里补上自动标题。
+            refreshAutoBoardTaskTitles(storage, { config, generateTitle: deps.generateTitle });
+        }
+        catch (error) {
+            console.error("[WandTask] Failed to refresh auto task titles:", getErrorMessage(error));
+        }
         const workspaceId = typeof req.query.workspaceId === "string" ? req.query.workspaceId : undefined;
         // 数组顺序即展示顺序：created_at 倒序，新创建的在上面。
         res.json(storage.listWandTasks(workspaceId).map((task) => dto(task)));
@@ -282,26 +327,30 @@ export function registerTaskRoutes(app, deps) {
             const labels = labelsFrom(body.labels);
             const dueDate = dateValue(body.dueDate) ?? null;
             const milestoneId = milestoneIdFrom(storage, body.milestoneId);
-            const task = storage.createWandTask({
-                workspaceId,
-                title,
-                titleSource,
-                description,
-                status,
-                priority,
-                labels,
-                dueDate,
-                milestoneId,
-                agent,
+            const task = storage.transaction(() => {
+                const card = storage.createWandTask({
+                    workspaceId,
+                    title,
+                    titleSource,
+                    description,
+                    status,
+                    priority,
+                    labels,
+                    dueDate,
+                    milestoneId,
+                    agent,
+                });
+                ensureWorkspaceTaskForBoardTask(storage, card);
+                return storage.getWandTask(card.id);
             });
             if (titleSource === "auto") {
-                scheduleWandTaskTitleGeneration(storage, task.id, description, {
+                refreshAutoBoardTaskTitles(storage, {
                     cwd: workspaceId ? storage.getWorkspace(workspaceId)?.cwd : undefined,
                     config,
-                    generateTitle: deps.generateTitle ?? generateWandTaskTitle,
+                    generateTitle: deps.generateTitle,
                 });
             }
-            res.status(201).json(dto(task));
+            res.status(201).json(dto(storage.getWandTask(task.id) ?? task));
         }
         catch (error) {
             sendRouteError(res, error, "无法创建任务。");
@@ -381,7 +430,14 @@ export function registerTaskRoutes(app, deps) {
                 throw new Error("缺少 sessionId。");
             if (sessions && !sessions.get(sessionId))
                 throw new Error("未找到该会话。");
-            storage.bindWandTaskSession(req.params.id, sessionId);
+            const card = storage.getWandTask(req.params.id);
+            if (!card) {
+                res.status(404).json({ error: "未找到该任务。" });
+                return;
+            }
+            const task = ensureWorkspaceTaskForBoardTask(storage, card);
+            moveSessionToWorkspaceTask(storage, sessionId, task.id);
+            sessions?.refreshSessionWorkspace(sessionId);
             res.status(201).json(dto(storage.getWandTask(req.params.id)));
         }
         catch (error) {
@@ -389,7 +445,15 @@ export function registerTaskRoutes(app, deps) {
         }
     });
     app.delete("/api/wand-tasks/:id/sessions/:sessionId", (req, res) => {
-        storage.unbindWandTaskSession(req.params.id, req.params.sessionId);
+        const card = storage.getWandTask(req.params.id);
+        const session = storage.getSession(req.params.sessionId);
+        if (card?.workspaceTaskId && session?.workspaceTaskId === card.workspaceTaskId) {
+            moveSessionToWorkspaceTask(storage, session.id, null);
+            sessions?.refreshSessionWorkspace(session.id);
+        }
+        else {
+            storage.unbindWandTaskSession(req.params.id, req.params.sessionId);
+        }
         res.json({ ok: true });
     });
     /**
@@ -421,7 +485,9 @@ export function registerTaskRoutes(app, deps) {
             const workspace = task.workspaceId ? storage.getWorkspace(task.workspaceId) : null;
             if (task.workspaceId && !workspace)
                 throw new Error("任务所属项目已被删除，请重新指定。");
-            const cwd = workspace?.cwd || config.defaultCwd;
+            const group = ensureWorkspaceTaskForBoardTask(storage, task);
+            task = storage.getWandTask(task.id);
+            const cwd = group.worktree?.path || group.cwd || workspace?.cwd || config.defaultCwd;
             const requestedPrompt = text(body.prompt);
             const existingSessions = storage.listWandTaskSessionIds(task.id).length;
             if (existingSessions > 0 && !requestedPrompt)
@@ -437,8 +503,8 @@ export function registerTaskRoutes(app, deps) {
                 worktreeEnabled: false,
                 sessionSource: "automation",
                 automationId: `wand-task:${task.id}`,
-                workspaceId: task.workspaceId ?? undefined,
-                workspaceTaskId: task.workspaceTaskId ?? undefined,
+                workspaceId: group.workspaceId,
+                workspaceTaskId: group.id,
             });
             storage.updateWandTask(task.id, { agent, status: task.status === "todo" ? "doing" : task.status });
             storage.bindWandTaskSession(task.id, session.id);

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

@@ -2,6 +2,7 @@ import type { Express } from "express";
 import type { SessionRegistry } from "./session-registry.js";
 import type { WandStorage } from "./storage.js";
 import { type LayoutNode, type TaskWindowLayout } from "./types.js";
+import { type AutoTaskTitleOptions } from "./server-task-routes.js";
 /** 校验并清洗前端提交的布局树；非法输入返回 null（空工作空间）。 */
 export declare function sanitizeLayout(value: unknown): LayoutNode | null;
 /** 校验任务级工作窗口集合；旧版单棵布局会兼容升级成一个 window。 */
@@ -13,4 +14,4 @@ export declare function sanitizeTaskLayout(value: unknown): TaskWindowLayout | n
  * - POST 只建项目实体，**不启动任何会话**；会话由工作空间内「+」标签按需创建并绑定 workspaceId。
  * - 布局树由前端 allotment 构造，PUT 时经 sanitizeLayout 校验/规整后落库。
  */
-export declare function registerWorkspaceRoutes(app: Express, storage: WandStorage, sessions?: SessionRegistry): void;
+export declare function registerWorkspaceRoutes(app: Express, storage: WandStorage, sessions?: SessionRegistry, titleOptions?: AutoTaskTitleOptions): void;

package/dist/server-workspace-routes.js

@@ -9,9 +9,10 @@ import { checkSessionWorktreeMergeabilityAsync, cleanupWorktreeSync, prepareSess
 import { collectSessionTopicBlocklist } from "./session-topic.js";
 import { resolveSessionDisplayTitle } from "./session-transport.js";
 import { attachUnboundSessionsToWorkspace, backfillSessionWorkspaces, normalizeProjectCwd, projectCwdForSession, isGlobalWorkspace, syncDirectoryNameForWorkspace } from "./workspace-binding.js";
-import { archiveBoardTaskForWorkspaceTask, ensureBoardTaskForWorkspaceTask } from "./wand-task-sync.js";
+import { archiveBoardTaskForWorkspaceTask, archiveWorkspaceTask, ensureBoardTaskForWorkspaceTask, isUnnamedWorkspaceTaskName, moveSessionToWorkspaceTask, syncSidebarTasksFromBoard, UNNAMED_WORKSPACE_TASK_NAME } from "./wand-task-sync.js";
 import { isSessionProvider } from "./session-provider.js";
 import { firstLayoutTabId } from "./layout-tree.js";
+import { refreshAutoBoardTaskTitles } from "./server-task-routes.js";
 function workspaceSessionTitle(session, names = {}) {
     return resolveSessionDisplayTitle(session, collectSessionTopicBlocklist({
         taskName: names.taskName,
@@ -96,12 +97,24 @@ function deleteSessions(storage, sessions, sessionIds) {
             storage.deleteSession(sessionId);
     }
 }
+function worktreeUsedOutsideTasks(storage, tasks) {
+    const deleting = new Set(tasks.map((task) => task.id));
+    return storage.loadSessionsSlim().some((session) => !deleting.has(session.workspaceTaskId ?? "")
+        && tasks.some((task) => {
+            if (!task.worktree)
+                return false;
+            const relative = path.relative(task.worktree.path, session.cwd);
+            return !relative || (!relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative));
+        }));
+}
 function taskRuntimeCwd(task, workspace) {
     return task.worktree?.path ?? task.cwd ?? workspace?.cwd ?? "";
 }
 function createTaskForWorkspace(storage, workspace, body) {
     const name = typeof body.name === "string" ? body.name.trim() : "";
-    const taskName = name || "未命名任务";
+    // 留空（或老客户端回传的占位名）走自动命名：先用占位名建组，会话内容一到位就改名。
+    const named = name.length > 0 && !isUnnamedWorkspaceTaskName(name);
+    const taskName = named ? name : UNNAMED_WORKSPACE_TASK_NAME;
     // 里程碑是全局列表；建任务时可选，非法 id 直接报错而不是静默丢掉。
     const requestedMilestoneId = typeof body.milestoneId === "string" ? body.milestoneId.trim() : "";
     if (requestedMilestoneId && !storage.getWandMilestone(requestedMilestoneId)) {
@@ -118,25 +131,14 @@ function createTaskForWorkspace(storage, workspace, body) {
     }
     const baseRef = typeof body.baseRef === "string" && body.baseRef.trim() ? body.baseRef.trim() : undefined;
     const runCwd = mountedCwd ?? workspace.cwd;
-    const requireWorktree = body.worktree === true;
-    const wantWorktree = requireWorktree || (body.worktree !== false && !isGlobalWorkspace(workspace));
     let worktree = null;
-    let worktreeError;
-    if (wantWorktree) {
-        try {
-            const setup = prepareSessionWorktree({
-                cwd: runCwd,
-                sessionId: crypto.randomUUID(),
-                spec: { taskName, baseRef },
-            });
-            worktree = setup.worktree;
-        }
-        catch (error) {
-            if (requireWorktree) {
-                throw new Error(getErrorMessage(error, "无法创建隔离 worktree。"));
-            }
-            worktreeError = getErrorMessage(error, "无法创建 worktree，将在项目目录直接运行。");
-        }
+    if (body.worktree === true) {
+        const setup = prepareSessionWorktree({
+            cwd: runCwd,
+            sessionId: crypto.randomUUID(),
+            spec: { taskName, baseRef },
+        });
+        worktree = setup.worktree;
     }
     const storedCwd = mountedCwd && mountedCwd !== workspace.cwd ? mountedCwd : undefined;
     const task = storage.createWorkspaceTask({
@@ -146,12 +148,11 @@ function createTaskForWorkspace(storage, workspace, body) {
         worktree,
         milestoneId,
     });
-    ensureBoardTaskForWorkspaceTask(storage, task, workspace);
+    ensureBoardTaskForWorkspaceTask(storage, task, workspace, { titleSource: named ? "user" : "auto" });
     return {
         task,
         cwd: taskRuntimeCwd(task, workspace),
         isolated: worktree !== null,
-        worktreeError,
     };
 }
 function workspaceWithCounts(storage, workspace, sessionCounts) {
@@ -267,7 +268,7 @@ export function sanitizeTaskLayout(value) {
  * - POST 只建项目实体，**不启动任何会话**；会话由工作空间内「+」标签按需创建并绑定 workspaceId。
  * - 布局树由前端 allotment 构造，PUT 时经 sanitizeLayout 校验/规整后落库。
  */
-export function registerWorkspaceRoutes(app, storage, sessions) {
+export function registerWorkspaceRoutes(app, storage, sessions, titleOptions = {}) {
     // 列出所有项目（按创建时间降序：新建在前，打开不会改位置）
     app.get("/api/workspaces", (_req, res) => {
         backfillSessionWorkspaces(storage);
@@ -368,6 +369,10 @@ export function registerWorkspaceRoutes(app, storage, sessions) {
             return;
         }
         const tasks = storage.listWorkspaceTasks(existing.id);
+        if (worktreeUsedOutsideTasks(storage, tasks)) {
+            res.status(409).json({ error: "该 Worktree 仍被已移出的会话使用，请先结束并删除这些会话。" });
+            return;
+        }
         if (cascade) {
             deleteSessions(storage, sessions, [
                 ...storage.listSessionsByWorkspace(existing.id).map((session) => session.id),
@@ -384,6 +389,9 @@ export function registerWorkspaceRoutes(app, storage, sessions) {
         for (const task of tasks) {
             if (cascade || task.worktree)
                 cleanupWorktreeSync(task.worktree);
+            const card = storage.getWandTaskByWorkspaceTaskId(task.id);
+            if (card)
+                storage.updateWandTask(card.id, { status: "archived", workspaceTaskId: null });
         }
         storage.deleteWorkspace(existing.id, { cascade });
         res.json({ ok: true });
@@ -419,6 +427,14 @@ export function registerWorkspaceRoutes(app, storage, sessions) {
     }));
     // 目录组为一级容器的任务聚合列表，供侧栏「任务」视图一次拉全。
     app.get("/api/tasks", (req, res) => {
+        syncSidebarTasksFromBoard(storage);
+        // 侧栏轮询也在补自动标题：不打开看板的任务（以及新增会话后的改名）也要吃到。
+        try {
+            refreshAutoBoardTaskTitles(storage, titleOptions);
+        }
+        catch (error) {
+            console.error("[WandTask] Failed to refresh auto task titles:", getErrorMessage(error));
+        }
         // 查询参数：workspaceId 过滤单目录；limit 截断每目录任务数；
         // maxSessions 截断每任务内嵌会话数（大数据量时控制响应体积）。
         const hasRevisionQuery = typeof req.query.revision === "string";
@@ -686,8 +702,7 @@ export function registerWorkspaceRoutes(app, storage, sessions) {
             worktrees,
         });
     }));
-    // 新建任务：命名 + 可选独立 worktree（默认尝试创建，非 git 仓库时退化为直接用项目目录；
-    // 显式 worktree:false 跳过隔离；显式 worktree:true 失败则 400，不静默降级）。
+    // 默认只创建逻辑分组；仅显式 worktree:true 才创建隔离目录。
     app.post("/api/workspaces/:id/tasks", asyncRoute(async (req, res) => {
         const workspace = storage.getWorkspace(req.params.id);
         if (!workspace) {
@@ -728,6 +743,22 @@ export function registerWorkspaceRoutes(app, storage, sessions) {
             })),
         });
     });
+    // 移动会话只改变归属，不修改运行目录，也不重启 CLI。
+    app.post("/api/workspace-tasks/:taskId/sessions", (req, res) => {
+        const sessionId = typeof req.body?.sessionId === "string" ? req.body.sessionId.trim() : "";
+        if (!storage.getWorkspaceTask(req.params.taskId) || !storage.getSession(sessionId)) {
+            res.status(404).json({ error: "未找到任务或会话。" });
+            return;
+        }
+        try {
+            moveSessionToWorkspaceTask(storage, sessionId, req.params.taskId);
+            sessions?.refreshSessionWorkspace(sessionId);
+            res.json({ ok: true });
+        }
+        catch (error) {
+            sendRouteError(res, error, "无法移动会话。");
+        }
+    });
     // 改名 / 状态
     app.patch("/api/workspace-tasks/:taskId", (req, res) => {
         const existing = storage.getWorkspaceTask(req.params.taskId);
@@ -754,6 +785,16 @@ export function registerWorkspaceRoutes(app, storage, sessions) {
             archiveBoardTaskForWorkspaceTask(storage, existing.id);
         res.json(storage.getWorkspaceTask(existing.id));
     });
+    // 归档任务：软删除。终端继续运行、worktree 与卡片历史都保留，只是侧栏不再显示。
+    app.post("/api/workspace-tasks/:taskId/archive", (req, res) => {
+        const existing = storage.getWorkspaceTask(req.params.taskId);
+        if (!existing) {
+            res.status(404).json({ error: "未找到该任务。" });
+            return;
+        }
+        archiveWorkspaceTask(storage, existing);
+        res.json(storage.getWorkspaceTask(existing.id));
+    });
     // 删除任务；cascade=true 连带删会话，否则仅解绑；尽力清理 worktree
     app.delete("/api/workspace-tasks/:taskId", (req, res) => {
         const existing = storage.getWorkspaceTask(req.params.taskId);
@@ -761,6 +802,10 @@ export function registerWorkspaceRoutes(app, storage, sessions) {
             res.status(404).json({ error: "未找到该任务。" });
             return;
         }
+        if (worktreeUsedOutsideTasks(storage, [existing])) {
+            res.status(409).json({ error: "该 Worktree 仍被已移出的会话使用，请先结束并删除这些会话。" });
+            return;
+        }
         // 删除隔离任务必然会移除其 cwd，因此即使调用方没有显式传 cascade，
         // 也必须同步删除会话；非隔离任务仍保留旧的“默认解绑”API 语义。
         const cascade = req.query.cascade === "1"
@@ -775,7 +820,7 @@ export function registerWorkspaceRoutes(app, storage, sessions) {
         archiveBoardTaskForWorkspaceTask(storage, existing.id);
         const board = storage.getWandTaskByWorkspaceTaskId(existing.id);
         if (board)
-            storage.updateWandTask(board.id, { workspaceTaskId: null });
+            storage.updateWandTask(board.id, { workspaceTaskId: null, status: "archived" });
         storage.deleteWorkspaceTask(existing.id, { cascade });
         res.json({ ok: true });
     });

package/dist/server.js

@@ -654,7 +654,7 @@ export async function startServer(config, configPath, options = {}) {
         recordRecentPath(storage, cwd);
     });
     registerClaudeHistoryRoutes(app, processes, storage);
-    registerWorkspaceRoutes(app, storage, sessionRegistry);
+    registerWorkspaceRoutes(app, storage, sessionRegistry, { config });
     registerMissionRoutes(app, missions);
     registerUploadRoutes(app, processes);
     app.post("/api/optimize-prompt", asyncRoute(async (req, res) => {

package/dist/session-registry.d.ts

@@ -25,6 +25,8 @@ export declare class SessionRegistry {
     get(id: string): SessionSnapshot | null;
     getLatest(id: string): SessionSnapshot | null;
     listSlim(): SessionSnapshot[];
+    /** Membership belongs to storage; both runners only refresh their live projection. */
+    refreshSessionWorkspace(id: string): void;
     setSessionModel(id: string, model: string | null): SessionSnapshot | null;
     setSessionThinkingEffort(id: string, effort: SessionSnapshot["thinkingEffort"]): SessionSnapshot | null;
     setSessionMode(id: string, mode: ExecutionMode): SessionSnapshot | null;

package/dist/session-registry.js

@@ -65,7 +65,9 @@ export class SessionRegistry {
         return this.storage.getSession(id) ? "storage" : null;
     }
     get(id) {
-        return this.structured.get(id) ?? this.processes.getOwned(id) ?? this.storage.getSession(id);
+        const snapshot = this.structured.get(id) ?? this.processes.getOwned(id) ?? this.storage.getSession(id);
+        const membership = this.storage.getSessionWorkspace(id);
+        return snapshot && membership ? { ...snapshot, ...membership } : snapshot;
     }
     getLatest(id) {
         return this.get(id);
@@ -79,11 +81,24 @@ export class SessionRegistry {
                 byId.set(snapshot.id, snapshot);
         }
         for (const snapshot of this.storage.loadSessionsSlim()) {
-            if (!byId.has(snapshot.id))
-                byId.set(snapshot.id, snapshot);
+            const live = byId.get(snapshot.id);
+            byId.set(snapshot.id, live ? {
+                ...live, workspaceId: snapshot.workspaceId, workspaceTaskId: snapshot.workspaceTaskId,
+            } : snapshot);
         }
         return Array.from(byId.values()).sort((a, b) => b.startedAt.localeCompare(a.startedAt));
     }
+    /** Membership belongs to storage; both runners only refresh their live projection. */
+    refreshSessionWorkspace(id) {
+        const membership = this.storage.getSessionWorkspace(id);
+        if (!membership)
+            return;
+        const owner = this.ownerOf(id);
+        if (owner === "structured")
+            this.structured.setSessionWorkspace(id, membership);
+        else if (owner === "pty")
+            this.processes.setSessionWorkspace(id, membership);
+    }
     setSessionModel(id, model) {
         const owner = this.ownerOf(id);
         if (owner === "structured")

package/dist/storage.d.ts

@@ -75,6 +75,7 @@ export declare class WandStorage {
     }): void;
     listSessionsByWorkspace(workspaceId: string): SessionSnapshot[];
     /** 显式更新某会话的工作空间归属（用于创建时绑定）。 */
+    getSessionWorkspace(sessionId: string): Pick<SessionSnapshot, "workspaceId" | "workspaceTaskId"> | null;
     setSessionWorkspaceId(sessionId: string, workspaceId: string | null): void;
     /** Lightweight count of persisted sessions grouped by workspace. */
     countSessionsByWorkspace(): Map<string, number>;
@@ -100,6 +101,7 @@ export declare class WandStorage {
         status?: WorkspaceTaskStatus;
         worktree?: WorkspaceTaskWorktree | null;
         milestoneId?: string | null;
+        workspaceId?: string;
     }): void;
     saveWorkspaceTaskLayout(id: string, layout: TaskWindowLayout | null, expectedRevision?: number): {
         ok: true;
@@ -120,7 +122,6 @@ export declare class WandStorage {
     private mapWandTaskRow;
     getWandTask(id: string): import("./task-types.js").WandTask | null;
     getWandTaskByWorkspaceTaskId(workspaceTaskId: string): import("./task-types.js").WandTask | null;
-    findUnlinkedWandTask(workspaceId: string, title: string): import("./task-types.js").WandTask | null;
     createWandTask(input: {
         workspaceId?: string | null;
         workspaceTaskId?: string | null;
@@ -134,7 +135,7 @@ export declare class WandStorage {
         milestoneId?: string | null;
         agent?: import("./task-types.js").WandTaskAgent | null;
     }): import("./task-types.js").WandTask;
-    updateWandTask(id: string, patch: Partial<Pick<import("./task-types.js").WandTask, "workspaceId" | "workspaceTaskId" | "title" | "titleSource" | "description" | "status" | "priority" | "labels" | "dueDate" | "milestoneId" | "sortOrder" | "agent">>): import("./task-types.js").WandTask | null;
+    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[];
     getWandMilestone(id: string): import("./task-types.js").WandTaskMilestone | null;