@co0ontty/wand 4.76.0 → 4.77.0-beta.g6c4df97

package/dist/server-ai-team-routes.js

@@ -0,0 +1,283 @@
+import { randomUUID } from "node:crypto";
+import { AiTeamConflictError } from "./ai-team-runner.js";
+import { AI_TEAM_AVATAR_MAX_CHARS, AI_TEAM_DEFAULT_MAX_STEPS, AI_TEAM_MAX_CANDIDATES, AI_TEAM_MAX_MEMBERS, AI_TEAM_MAX_STEPS, AI_TEAM_MIN_MEMBERS, AI_TEAM_MIN_STEPS, agentKey, isTeamMemberRole, memberAgents, } from "./ai-team-types.js";
+import { asyncRoute } from "./express-async.js";
+import { getErrorMessage } from "./error-utils.js";
+import { defaultMilestoneIdForWrite, scopedMilestoneId } from "./milestone-scope.js";
+import { bodyObject, sendRouteError, text } from "./server-request.js";
+import { parseTaskAgent } from "./server-task-routes.js";
+import { provisionalTaskTitleFromDescription } from "./task-title.js";
+import { ensureWorkspaceTaskForBoardTask } from "./wand-task-sync.js";
+const NOT_FOUND = /不存在/;
+/** 团队页「直接开工」自动建卡的标记（§4.2 / Q3）：看板靠它区分团队卡与手写卡。 */
+export const TEAM_DIRECT_LABEL = "team_direct";
+/** note 上限，与团队协作指令同口径（§4.2）。 */
+const TEAM_DIRECT_NOTE_MAX = 4000;
+/** `GET /api/ai-teams/:id` 附带多少个运行摘要（§4.1 B14）：面板只要最近这一段。 */
+const TEAM_DIRECT_RUNS_LIMIT = 50;
+function sendTeamError(res, error) {
+    const message = getErrorMessage(error, "团队操作失败。");
+    const status = error instanceof AiTeamConflictError ? 409 : NOT_FOUND.test(message) ? 404 : 400;
+    sendRouteError(res, error, "团队操作失败。", status);
+}
+function boundedText(value, label, min, max) {
+    const result = text(value);
+    if (result.length < min)
+        throw new Error(`${label}不能为空。`);
+    if (result.length > max)
+        throw new Error(`${label}不能超过 ${max} 个字符。`);
+    return result;
+}
+function parseAvatar(value, name) {
+    const avatar = text(value);
+    if (!avatar || /^cat:\d{1,2}$/.test(avatar))
+        return avatar;
+    if (!/^data:image\/(png|jpeg|webp);base64,[A-Za-z0-9+/=]+$/.test(avatar))
+        throw new Error(`成员「${name}」的头像格式无效。`);
+    if (avatar.length > AI_TEAM_AVATAR_MAX_CHARS)
+        throw new Error(`成员「${name}」的头像太大。`);
+    return avatar;
+}
+function parseMembers(value) {
+    if (!Array.isArray(value))
+        throw new Error("成员列表必须是数组。");
+    if (value.length < AI_TEAM_MIN_MEMBERS || value.length > AI_TEAM_MAX_MEMBERS) {
+        throw new Error(`团队需要 ${AI_TEAM_MIN_MEMBERS}–${AI_TEAM_MAX_MEMBERS} 名成员。`);
+    }
+    const names = new Set();
+    const ids = new Set();
+    const members = value.map((raw, index) => {
+        const body = bodyObject(raw);
+        const name = boundedText(body.name, `第 ${index + 1} 位成员的名字`, 1, 40);
+        const key = name.toLowerCase();
+        if (names.has(key))
+            throw new Error(`成员名字「${name}」重复。`);
+        names.add(key);
+        const rawId = text(body.id);
+        const id = /^m_[A-Za-z0-9]{1,32}$/.test(rawId) && !ids.has(rawId)
+            ? rawId
+            : `m_${randomUUID().replace(/-/g, "").slice(0, 8)}`;
+        ids.add(id);
+        const duty = text(body.duty);
+        if (duty.length > 2000)
+            throw new Error(`成员「${name}」的职责不能超过 2000 个字符。`);
+        let agents;
+        try {
+            if (Array.isArray(body.agents)) {
+                if (body.agents.length === 0)
+                    throw new Error("至少需要一个执行候选。");
+                if (body.agents.length > AI_TEAM_MAX_CANDIDATES)
+                    throw new Error(`最多 ${AI_TEAM_MAX_CANDIDATES} 个执行候选。`);
+                agents = body.agents.map((rawAgent) => {
+                    const parsed = parseTaskAgent(rawAgent ?? {});
+                    if (!parsed)
+                        throw new Error("请选择有效的 CLI 工具。");
+                    return parsed;
+                });
+            }
+            else if (body.agents !== undefined && body.agents !== null) {
+                throw new Error("候选执行配置必须是数组。");
+            }
+            else {
+                const agent = parseTaskAgent(body.agent ?? {});
+                if (!agent)
+                    throw new Error("没有选择 CLI 工具。");
+                agents = [agent];
+            }
+        }
+        catch (error) {
+            throw new Error(`成员「${name}」：${getErrorMessage(error)}`);
+        }
+        const seenKeys = new Set(agents.map(agentKey));
+        if (seenKeys.size !== agents.length)
+            throw new Error(`成员「${name}」的执行候选重复。`);
+        const member = {
+            id, name, duty, agents,
+            // 服务端强制兼容字段 = 首选候选，不信任客户端传来的 agent。
+            agent: agents[0],
+            isLeader: body.isLeader === true,
+            avatar: parseAvatar(body.avatar, name),
+        };
+        if (isTeamMemberRole(body.role))
+            member.role = body.role;
+        return member;
+    });
+    if (members.filter((member) => member.isLeader).length !== 1)
+        throw new Error("团队需要恰好一位负责人。");
+    return members;
+}
+export function parseAiTeamInput(value, existing, now) {
+    const body = bodyObject(value);
+    const maxSteps = body.maxSteps === undefined ? existing?.maxSteps ?? AI_TEAM_DEFAULT_MAX_STEPS : Number(body.maxSteps);
+    if (!Number.isInteger(maxSteps) || maxSteps < AI_TEAM_MIN_STEPS || maxSteps > AI_TEAM_MAX_STEPS) {
+        throw new Error(`步数上限需要是 ${AI_TEAM_MIN_STEPS}–${AI_TEAM_MAX_STEPS} 之间的整数。`);
+    }
+    const description = text(body.description);
+    if (description.length > 500)
+        throw new Error("说明不能超过 500 个字符。");
+    const instructions = body.instructions === undefined ? existing?.instructions ?? "" : text(body.instructions);
+    if (instructions.length > 4000)
+        throw new Error("协作指令不能超过 4000 个字符。");
+    return {
+        id: existing?.id ?? `team_${randomUUID().replace(/-/g, "").slice(0, 12)}`,
+        name: boundedText(body.name, "团队名", 1, 60),
+        description,
+        instructions,
+        members: parseMembers(body.members),
+        requirePlanApproval: typeof body.requirePlanApproval === "boolean"
+            ? body.requirePlanApproval
+            : existing?.requirePlanApproval ?? true,
+        maxSteps,
+        createdAt: existing?.createdAt ?? now,
+        updatedAt: now,
+    };
+}
+export function registerAiTeamRoutes(app, deps) {
+    const { storage, runner } = deps;
+    app.get("/api/ai-teams", (_req, res) => {
+        res.json(storage.listAiTeams());
+    });
+    app.post("/api/ai-teams", (req, res) => {
+        try {
+            const team = parseAiTeamInput(req.body, null, new Date().toISOString());
+            storage.saveAiTeam(team);
+            res.status(201).json(team);
+        }
+        catch (error) {
+            sendTeamError(res, error);
+        }
+    });
+    app.put("/api/ai-teams/:id", (req, res) => {
+        try {
+            const existing = storage.getAiTeam(req.params.id);
+            if (!existing)
+                throw new Error("团队不存在。");
+            const team = parseAiTeamInput(req.body, existing, new Date().toISOString());
+            storage.saveAiTeam(team);
+            res.json(team);
+        }
+        catch (error) {
+            sendTeamError(res, error);
+        }
+    });
+    app.delete("/api/ai-teams/:id", (req, res) => {
+        storage.deleteAiTeam(req.params.id);
+        res.json({ ok: true });
+    });
+    /** 团队详情：团队对象 + 该团队的运行摘要（修正 B14，Android AiTeamDetailScreen 与 Web 面板共用）。 */
+    app.get("/api/ai-teams/:id", (req, res) => {
+        try {
+            const team = storage.getAiTeam(req.params.id);
+            if (!team)
+                throw new Error("团队不存在。");
+            res.json({ team, runs: runner.listRuns({ teamId: team.id, limit: TEAM_DIRECT_RUNS_LIMIT }) });
+        }
+        catch (error) {
+            sendTeamError(res, error);
+        }
+    });
+    /**
+     * 直接开工（§4.2，需求 D）：服务端自己建一张 `team_direct` 卡再起 run，**没有 cwd 入参**。
+     * 工作目录只能来自已校验的非 global workspace —— 缺省 workspaceId 的卡不会在建卡时报错，
+     * 而是在派发时静默落到 `<configDir>/scratch`（N2），所以整条校验链必须卡在入口。
+     */
+    app.post("/api/ai-teams/:id/runs", asyncRoute(async (req, res) => {
+        try {
+            const body = bodyObject(req.body ?? {});
+            const workspaceId = text(body.workspaceId);
+            if (!workspaceId)
+                throw new Error("请选择工作项目。");
+            const workspace = storage.getWorkspace(workspaceId);
+            if (!workspace)
+                throw new Error("请选择工作项目。");
+            if (workspace.kind === "global") {
+                throw new Error("AI 团队不能在全局暂存工作区运行，请先选择或创建一个项目。");
+            }
+            if (!text(workspace.cwd))
+                throw new Error("这个项目还没有工作目录，请先选择一个项目。");
+            const note = boundedText(body.note, "开工说明", 1, TEAM_DIRECT_NOTE_MAX);
+            const team = storage.getAiTeam(req.params.id);
+            if (!team)
+                throw new Error("团队不存在。");
+            // 卡片上的执行配置取团队首选（负责人的第一个候选），看板与快捷提交都按它显示。
+            const preferredMember = team.members.find((member) => member.isLeader) ?? team.members[0];
+            const agent = preferredMember ? memberAgents(preferredMember)[0] ?? null : null;
+            const milestoneId = defaultMilestoneIdForWrite(storage);
+            const task = storage.transaction(() => {
+                const card = storage.createWandTask({
+                    workspaceId: workspace.id,
+                    title: provisionalTaskTitleFromDescription(note) || team.name,
+                    description: note,
+                    // 团队开工即进行中（§4.2 的 "processing" 对应看板列 doing；runner.start 不再回退它）。
+                    status: "doing",
+                    labels: [TEAM_DIRECT_LABEL],
+                    milestoneId: scopedMilestoneId(storage, milestoneId, workspace.id) ?? milestoneId,
+                    agent,
+                });
+                ensureWorkspaceTaskForBoardTask(storage, card);
+                return storage.getWandTask(card.id);
+            });
+            try {
+                const detail = await runner.start({ teamId: team.id, taskId: task.id, note });
+                res.status(202).json({ ...detail, taskId: task.id });
+            }
+            catch (error) {
+                // 不留空卡：起 run 失败就删掉刚建的卡；回滚本身失败只记日志，错误原样映射出去。
+                try {
+                    storage.deleteWandTask(task.id);
+                }
+                catch (rollbackError) {
+                    console.error(`[AiTeam] rollback direct task ${task.id} failed:`, getErrorMessage(rollbackError));
+                }
+                throw error;
+            }
+        }
+        catch (error) {
+            sendTeamError(res, error);
+        }
+    }));
+    app.get("/api/ai-team-runs", (req, res) => {
+        const teamId = typeof req.query.teamId === "string" ? req.query.teamId : undefined;
+        const limit = Math.min(200, Math.max(1, Number(req.query.limit) || 50));
+        res.json(runner.listRuns({ teamId, activeOnly: req.query.active === "1", limit }));
+    });
+    app.get("/api/wand-tasks/:id/team-runs", (req, res) => {
+        res.json(runner.listForTask(req.params.id));
+    });
+    app.post("/api/wand-tasks/:id/team-runs", asyncRoute(async (req, res) => {
+        try {
+            const body = bodyObject(req.body);
+            const teamId = text(body.teamId);
+            if (!teamId)
+                throw new Error("请选择团队。");
+            res.status(202).json(await runner.start({ teamId, taskId: req.params.id, note: text(body.note) }));
+        }
+        catch (error) {
+            sendTeamError(res, error);
+        }
+    }));
+    app.get("/api/ai-team-runs/:id", (req, res) => {
+        try {
+            res.json(runner.detail(req.params.id));
+        }
+        catch (error) {
+            sendTeamError(res, error);
+        }
+    });
+    const action = (path, handler) => {
+        app.post(path, asyncRoute(async (req, res) => {
+            try {
+                res.json(await handler(req.params.id, bodyObject(req.body ?? {}), req.params));
+            }
+            catch (error) {
+                sendTeamError(res, error);
+            }
+        }));
+    };
+    action("/api/ai-team-runs/:id/approve", (runId) => runner.approve(runId));
+    action("/api/ai-team-runs/:id/reject", (runId, body) => runner.reject(runId, text(body.feedback)));
+    action("/api/ai-team-runs/:id/reply", (runId, body) => runner.reply(runId, text(body.text)));
+    action("/api/ai-team-runs/:id/continue", (runId, body) => runner.continueRun(runId, Number(body.extraSteps) || 10));
+    action("/api/ai-team-runs/:id/steps/:stepId/complete", (runId, body, params) => (runner.completeStep(runId, params.stepId, text(body.report))));
+    action("/api/ai-team-runs/:id/stop", (runId) => runner.stop(runId));
+}

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

@@ -0,0 +1,9 @@
+import type { Express } from "express";
+import type { AiTeamRunner } from "./ai-team-runner.js";
+import type { SessionSnapshot } from "./types.js";
+export declare function registerAttentionRoutes(app: Express, deps: {
+    sessions: {
+        listSlim(): SessionSnapshot[];
+    };
+    runner: AiTeamRunner;
+}): void;

package/dist/server-attention-routes.js

@@ -0,0 +1,26 @@
+import { collectAttentionItems } from "./attention.js";
+export function registerAttentionRoutes(app, deps) {
+    app.get("/api/attention", (_req, res) => {
+        const runs = deps.runner.listRuns({ limit: 80 });
+        const teamRuns = runs.map((run) => ({
+            id: run.id,
+            status: run.status,
+            statusDetail: run.statusDetail,
+            taskTitle: run.taskTitle,
+            teamName: run.team.name,
+            chatSessionId: run.chatSessionId,
+            updatedAt: run.updatedAt,
+        }));
+        const sessions = deps.sessions.listSlim().map((session) => ({
+            id: session.id,
+            title: session.title?.trim() || session.description?.trim() || "",
+            archived: session.archived,
+            status: session.status,
+            lastError: session.structuredState?.lastError ?? null,
+            worktreeMergeStatus: session.worktreeMergeStatus ?? null,
+            automationId: session.automationId ?? null,
+            updatedAt: session.endedAt || session.startedAt,
+        }));
+        res.json({ items: collectAttentionItems({ runs: teamRuns, sessions }) });
+    });
+}

package/dist/server-file-routes.js

@@ -593,7 +593,7 @@ export function registerFileRoutes(app, deps) {
         const cwd = typeof req.query.cwd === "string" ? req.query.cwd : defaultCwd;
         const maxDepth = parseBoundedInteger(req.query.depth, 5, 0, 8);
         const maxResults = parseBoundedInteger(req.query.limit, 50, 1, 200);
-        const ignoredDirectories = new Set([".git", "node_modules", ".next", "dist", "build", "coverage", ".wand-uploads"]);
+        const ignoredDirectories = new Set([".git", "node_modules", ".next", "dist", "build", "coverage", ".wand-uploads", ".wand-team"]);
         const maxVisitedEntries = 20_000;
         let resolvedCwd;
         try {

package/dist/server-session-routes.js

@@ -1,13 +1,14 @@
 import { createHash } from "node:crypto";
 import { PtyInputDeliveryError, SessionInputError } from "./process-manager.js";
 import { getDefaultModelForProvider, isExecutionMode } from "./config.js";
-import { blockWindowMessagesForTransport, sliceTurnBlocksForTransport, truncateMessagesForTransport, windowMessagesForTransport } from "./message-truncator.js";
+import { alignedBlockStart, blockWindowMessagesForTransport, sliceTurnBlocksForTransport, truncateMessagesForTransport, visibleBlockCount, windowMessagesForTransport } from "./message-truncator.js";
 import { toSessionDetailDTO, toSessionListItemDTO } from "./session-transport.js";
 import { checkSessionWorktreeMergeabilityAsync, cleanupSessionWorktreeAsync, getWorktreeMergeErrorCode, mergeSessionWorktreeAsync, WorktreeMergeError, } from "./git-worktree.js";
 import { resolveSessionCwd } from "./session-cwd.js";
 import { resolveCommitAiContext } from "./session-ai-context.js";
 import { getGitStatusAsync, QuickCommitError, runQuickCommitWithFallback, runTagHead, runPush, generateCommitMessageOnly, } from "./git-quick-commit.js";
 import { getErrorMessage } from "./error-utils.js";
+import { archiveCommitTasks } from "./commit-task-archive.js";
 import { buildIterationCommitContext, COMMIT_CONTEXT_MODE_PREF_KEY, isCommitContextMode, readCommitContextMode, resolveCommitContextInput, } from "./iteration-log.js";
 import { inferProviderFromCommand, isSessionProvider, providerCliCommand, SESSION_PROVIDERS } from "./session-provider.js";
 import { buildProviderResumeCommand, isProviderSessionId } from "./resume-policy.js";
@@ -327,6 +328,8 @@ async function startResumedPtySession(processes, storage, existingSession, sessi
         provider,
         model: existingSession.selectedModel ?? undefined,
         thinkingEffort: existingSession.thinkingEffort ?? undefined,
+        // 恢复会话也要把角色与规则带回来（PTY 的指令是拼在启动命令上的）。
+        systemPrompt: existingSession.systemPrompt ?? undefined,
         workspaceId: existingSession.workspaceId
             ?? resolveWorkspaceIdForNewSession(storage, projectCwdForSession(existingSession) || existingSession.cwd),
         workspaceTaskId: existingSession.workspaceTaskId,
@@ -449,6 +452,9 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
     app.get("/api/sessions", (_req, res) => {
         res.json(sessions.listSlim().map(toSessionListItemDTO));
     });
+    app.get("/api/sessions/provider-usage", (_req, res) => {
+        res.json(storage.countInteractiveSessionsByProvider());
+    });
     app.post("/api/structured-sessions", asyncRoute(async (req, res) => {
         const body = req.body;
         try {
@@ -474,6 +480,8 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
                     : config.defaultThinkingEffort,
                 workspaceId: resolveWorkspaceIdForNewSession(storage, cwd, body.workspaceId),
                 workspaceTaskId: body.workspaceTaskId,
+                // 角色与规则走系统提示通道，不拼进 prompt（见 AGENTS.md「Session 输入契约」）。
+                systemPrompt: body.systemPrompt,
                 ...origin,
             });
             onSessionCreated?.(snapshot.cwd);
@@ -876,8 +884,23 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
             const consumed = result.ok && result.commit?.hash && context.entryIds.length > 0
                 ? storage.markIterationPromptsConsumed(context.entryIds, result.commit.hash)
                 : 0;
+            let archivedTaskIds = [];
+            let archiveError;
+            if (body.archiveRelatedTasks === true && result.ok && result.commit?.hash) {
+                try {
+                    // A commit is already durable, even when push failed. Archiving must not turn that
+                    // successful commit into a retryable HTTP error (which would duplicate the commit).
+                    archivedTaskIds = archiveCommitTasks(storage, snapshot, context.entryIds);
+                }
+                catch (error) {
+                    archiveError = getErrorMessage(error, "归档关联任务失败。");
+                    console.error("[QuickCommit] Failed to archive related tasks:", archiveError);
+                }
+            }
             res.json({
                 ...result,
+                archivedTaskIds,
+                ...(archiveError ? { archiveError } : {}),
                 commitContext: {
                     source: commitMessageFromIteration(body) && context.digest ? "iteration" : "diff",
                     entryIds: context.entryIds,
@@ -1111,6 +1134,7 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
                     messageTotal: windowed.messageTotal,
                     leadingBlockOffset: windowed.leadingBlockOffset,
                     leadingBlockTotal: windowed.leadingBlockTotal,
+                    leadingVisibleCount: windowed.leadingVisibleCount,
                 }));
                 return;
             }
@@ -1149,14 +1173,16 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
                 offset: windowed.messageOffset, total });
             return;
         }
-        // 块级翻页（iOS）：?turn=<i>&blockOffset=<当前 leading 偏移>&blockLimit=<N>
+        // 块级翻页（iOS / Android）：?turn=<i>&blockOffset=<当前 leading 偏移>&blockLimit=<N>
         // 取该 turn 的 [start, blockOffset) 段（start = max(0, blockOffset - blockLimit)）。
+        // 起点同样吸附到干净边界（不切开折叠的工具段、不留下无头 tool_result），并回一份
+        // blockVisible：被切掉的头部里还剩多少条用户可感知的块（默认收起的工具块不计入）。
         const rawTurn = parseInt(String(req.query.turn ?? ""), 10);
         if (Number.isFinite(rawTurn)) {
             const turnIndex = Math.min(Math.max(rawTurn, 0), Math.max(total - 1, 0));
             const turn = all[turnIndex];
             if (!turn) {
-                res.json({ turnIndex, blocks: [], blockOffset: 0, blockTotal: 0 });
+                res.json({ turnIndex, blocks: [], blockOffset: 0, blockTotal: 0, blockVisible: 0 });
                 return;
             }
             const blockTotal = turn.content.length;
@@ -1165,11 +1191,20 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
             const blockLimit = Math.min(Math.max(Number.isFinite(rawBlockLimit) ? rawBlockLimit : 40, 1), 200);
             const blockEnd = Math.min(Math.max(Number.isFinite(rawBlockOffset) ? rawBlockOffset : blockTotal, 0), blockTotal);
             const blockStart = Math.max(0, blockEnd - blockLimit);
+            const cardDefaults = config.cardDefaults ?? {};
+            const startOffset = alignedBlockStart(turn.content, cardDefaults, blockStart, blockEnd);
             const blocks = enrichStructuredMessages([{
                     ...turn,
-                    content: sliceTurnBlocksForTransport(turn, blockStart, blockEnd, config.cardDefaults ?? {}),
+                    content: sliceTurnBlocksForTransport(turn, startOffset, blockEnd, cardDefaults),
                 }], snapshot.id)[0].content;
-            res.json({ wandProtocolVersion: WAND_PROTOCOL_VERSION, turnIndex, blocks, blockOffset: blockStart, blockTotal });
+            res.json({
+                wandProtocolVersion: WAND_PROTOCOL_VERSION,
+                turnIndex,
+                blocks,
+                blockOffset: startOffset,
+                blockTotal,
+                blockVisible: visibleBlockCount(turn.content, cardDefaults, startOffset),
+            });
             return;
         }
         const rawLimit = parseInt(String(req.query.limit ?? ""), 10);
@@ -1240,6 +1275,7 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
                     reuseId: existingSession.id,
                     cols: reqCols,
                     rows: reqRows,
+                    systemPrompt: existingSession.systemPrompt ?? undefined,
                     workspaceId: existingSession.workspaceId
                         ?? resolveWorkspaceIdForNewSession(storage, projectCwdForSession(existingSession) || existingSession.cwd),
                     workspaceTaskId: existingSession.workspaceTaskId,

package/dist/server-settings-routes.js

@@ -210,7 +210,7 @@ export function registerSettingsRoutes(app, deps) {
         }
         const startedAt = Date.now();
         try {
-            const text = await callSystemAiText("这是 Wand 系统 API 线路验收。请只回复 WAND_API_OK。", route, 30_000);
+            const text = await callSystemAiText({ system: "你是 Wand 的系统 API 线路探针。", prompt: "这是 Wand 系统 API 线路验收。请只回复 WAND_API_OK。" }, route, 30_000);
             if (!text.trim())
                 throw new Error("系统 AI API 返回了空结果。");
             res.json({

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

@@ -19,6 +19,8 @@ export interface TaskRouteDependencies {
     /** 可注入的任务标题生成器；测试里换成同步桩，避免真的起 CLI。 */
     generateTitle?: typeof generateWandTaskTitle;
 }
+/** 新认领只能挂到同项目且正在处理的任务；历史归属在父任务完成后仍保留。 */
+export declare function parentTaskIdFrom(storage: WandStorage, value: unknown, workspaceId: string | null, childId?: string | null, existingParentId?: string | null): string | null;
 /**
  * 任务派发配置：provider / model / thinkingEffort 必须合法；mode 缺省时用 `fallbackMode`。
  * 老客户端（Android / iOS 尚未发 mode）不传 mode，PATCH / dispatch 时传任务当前值，

package/dist/server-task-routes.js

@@ -1,4 +1,4 @@
-import { getDefaultModelForProvider } from "./config.js";
+import { dispatchAgentForTask } from "./agent-dispatch.js";
 import { asyncRoute } from "./express-async.js";
 import { getErrorMessage } from "./error-utils.js";
 import { bodyObject, sendRouteError, text } from "./server-request.js";
@@ -9,7 +9,7 @@ import { recordIterationPromptForTask } from "./iteration-log.js";
 import { resolveSystemAiContext } from "./session-ai-context.js";
 import { DEFAULT_WAND_TASK_AGENT_KIND, DEFAULT_WAND_TASK_AGENT_MODE, DEFAULT_WAND_TASK_PRIORITY, isWandTaskAgentKind, isWandTaskAgentMode, normalizeWandTaskAgentMode, WAND_MILESTONE_NAME_MAX_LENGTH } from "./task-types.js";
 import { archiveBoardTask, ensureWorkspaceTaskForBoardTask, isAutoNameableBoardTask, moveSessionToWorkspaceTask, syncClosedBoardTask, syncUngroupedSessionsToBoard, syncWorkspaceTaskToBoard, taskAutoNameSignature, taskAutoNameSourceText } from "./wand-task-sync.js";
-import { isSessionProvider, providerCliCommand } from "./session-provider.js";
+import { isSessionProvider } from "./session-provider.js";
 import { isThinkingEffort } from "./structured-provider-common.js";
 const STATUSES = new Set(["todo", "doing", "done", "archived"]);
 const PRIORITIES = new Set(["none", "low", "medium", "high", "urgent"]);
@@ -54,7 +54,7 @@ function labelsFrom(value) {
     return value.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean).slice(0, 20);
 }
 /** 新认领只能挂到同项目且正在处理的任务；历史归属在父任务完成后仍保留。 */
-function parentTaskIdFrom(storage, value, workspaceId, childId = null, existingParentId = null) {
+export function parentTaskIdFrom(storage, value, workspaceId, childId = null, existingParentId = null) {
     if (value === null || value === "")
         return null;
     if (typeof value !== "string" || !value.trim())
@@ -588,59 +588,25 @@ export function registerTaskRoutes(app, deps) {
                     assertTaskWorkspaceMove(storage, task.id, workspaceId);
                 task = storage.updateWandTask(task.id, { workspaceId }) ?? task;
             }
-            const workspace = task.workspaceId ? storage.getWorkspace(task.workspaceId) : null;
-            if (task.workspaceId && !workspace)
-                throw new Error("任务所属项目已被删除，请重新指定。");
-            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)
                 throw new Error("请输入提示词。");
             const prompt = requestedPrompt || task.description.trim() || task.title || "执行此任务";
-            const model = agent.model === "default" ? "" : agent.model;
-            const provider = agent.provider;
-            const resolvedModel = model || getDefaultModelForProvider(config, provider) || undefined;
-            const session = agent.kind === "pty"
-                ? await processes.start(providerCliCommand(provider), cwd, agent.mode, prompt, {
-                    provider,
-                    model: resolvedModel,
-                    thinkingEffort: agent.thinkingEffort,
-                    sessionSource: "automation",
-                    automationId: `wand-task:${task.id}`,
-                    workspaceId: group.workspaceId,
-                    workspaceTaskId: group.id,
-                })
-                : structured.createSession({
-                    cwd,
-                    mode: agent.mode,
-                    provider,
-                    model: resolvedModel,
-                    thinkingEffort: agent.thinkingEffort,
-                    worktreeEnabled: false,
-                    sessionSource: "automation",
-                    automationId: `wand-task:${task.id}`,
-                    workspaceId: group.workspaceId,
-                    workspaceTaskId: group.id,
-                });
+            const { session, cwd, workspaceId } = await dispatchAgentForTask({ storage, config, structured: structured ?? null, processes: processes ?? null }, { task, agent, prompt, automationId: `wand-task:${task.id}` });
+            task = storage.getWandTask(task.id);
             storage.updateWandTask(task.id, { agent, status: task.status === "todo" ? "doing" : task.status });
-            storage.bindWandTaskSession(task.id, session.id);
             // 派发也算一轮迭代里的改动意图：直接把任务的标题 / 描述记进迭代记录。
             recordIterationPromptForTask(storage, {
                 sessionId: session.id,
                 cwd,
-                workspaceId: group.workspaceId,
+                workspaceId,
                 milestoneId: task.milestoneId,
                 taskId: task.id,
                 title: task.title,
                 detail: task.description || prompt,
                 source: "dispatch",
             });
-            if (agent.kind !== "pty") {
-                const completion = structured.sendMessage(session.id, prompt);
-                completion.catch((error) => console.error(`[WandTask] Agent dispatch failed for ${task.id}:`, error));
-            }
             res.status(202).json({
                 ok: true,
                 taskId: task.id,

package/dist/server-workspace-routes.js

@@ -13,7 +13,7 @@ import { defaultMilestoneIdForWrite, resolvedMilestoneFields, scopedMilestoneId
 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";
+import { parentTaskIdFrom, refreshAutoBoardTaskTitles } from "./server-task-routes.js";
 import { provisionalTaskTitleFromDescription } from "./task-title.js";
 function workspaceSessionTitle(session, names = {}) {
     return resolveSessionDisplayTitle(session, collectSessionTopicBlocklist({
@@ -25,7 +25,7 @@ function workspaceSessionTitle(session, names = {}) {
 function liveSession(session, registry) {
     return registry?.getLatest(session.id) ?? session;
 }
-function workspaceSessionSummary(session, names = {}, registry) {
+function workspaceSessionSummary(session, names = {}, registry, teamChat) {
     const live = liveSession(session, registry);
     return {
         id: live.id,
@@ -40,6 +40,7 @@ function workspaceSessionSummary(session, names = {}, registry) {
         inFlight: live.structuredState?.inFlight === true,
         cwd: live.cwd,
         startedAt: live.startedAt,
+        ...(teamChat ? { teamChat } : {}),
     };
 }
 function cheapTasksRevision(storage, registry) {
@@ -150,6 +151,8 @@ function createTaskForWorkspace(storage, workspace, body) {
     const name = typeof body.name === "string" ? body.name.trim() : "";
     // 首个会话的提示词：任务没起名时用它先总结一个标题，不再留「未命名任务」占位。
     const description = typeof body.description === "string" ? body.description.trim() : "";
+    // 在建 workspace task / worktree 前校验，避免父任务失效时留下孤立任务。
+    const parentTaskId = parentTaskIdFrom(storage, body.parentTaskId ?? null, isGlobalWorkspace(workspace) ? null : workspace.id);
     // 留空（或老客户端回传的占位名）走自动命名：先用提示词总结，再交给模型改写。
     const named = name.length > 0 && !isUnnamedWorkspaceTaskName(name);
     const provisional = named ? "" : provisionalTaskTitleFromDescription(description);
@@ -193,6 +196,7 @@ function createTaskForWorkspace(storage, workspace, body) {
     ensureBoardTaskForWorkspaceTask(storage, task, workspace, {
         titleSource: named ? "user" : "auto",
         description,
+        parentTaskId,
     });
     return {
         task,
@@ -353,10 +357,11 @@ export function registerWorkspaceRoutes(app, storage, sessions, titleOptions = {
             return;
         }
         storage.touchWorkspace(workspace.id);
+        const teamChatMarkers = storage.listAiTeamRunChatMarkers();
         res.json({
             ...workspaceWithCounts(storage, workspace),
             sessions: storage.listSessionsByWorkspace(workspace.id).map((session) => ({
-                ...workspaceSessionSummary(session, { workspaceName: workspace.name }, sessions),
+                ...workspaceSessionSummary(session, { workspaceName: workspace.name }, sessions, teamChatMarkers.get(session.id)),
                 workspaceTaskId: session.workspaceTaskId,
             })),
         });
@@ -506,7 +511,9 @@ export function registerWorkspaceRoutes(app, storage, sessions, titleOptions = {
         // messages 大字段 JSON 解析一遍（单会话可达十几 MB，整表 ~30MB）。
         const allSessions = storage.loadSessionsSlim();
         const workspaces = storage.listWorkspaces();
-        const summarize = (session, names = {}) => workspaceSessionSummary(session, names, sessions);
+        // 群聊标记一次查全：列表里每条会话只做 Map 命中，不逐个查库。
+        const teamChatMarkers = storage.listAiTeamRunChatMarkers();
+        const summarize = (session, names = {}) => workspaceSessionSummary(session, names, sessions, teamChatMarkers.get(session.id));
         // 目录自定义名（工作区名称）：没有项目实体的合成目录也按这个名字显示。
         const directoryNames = storage.listSessionDirectoryNames();
         const customNameForCwd = (cwd) => {
@@ -804,6 +811,7 @@ export function registerWorkspaceRoutes(app, storage, sessions, titleOptions = {
         }
         storage.touchWorkspaceTask(task.id);
         const workspace = storage.getWorkspace(task.workspaceId);
+        const teamChatMarkers = storage.listAiTeamRunChatMarkers();
         res.json({
             ...task,
             ...resolvedMilestoneFields(storage, task.milestoneId),
@@ -812,7 +820,7 @@ export function registerWorkspaceRoutes(app, storage, sessions, titleOptions = {
                 ...workspaceSessionSummary(session, {
                     taskName: task.name,
                     workspaceName: workspace?.name,
-                }, sessions),
+                }, sessions, teamChatMarkers.get(session.id)),
                 workspaceTaskId: task.id,
             })),
         });