@co0ontty/wand 4.77.0 → 4.78.0

package/dist/ai-team-runner.js

@@ -6,13 +6,16 @@ import path from "node:path";
 import { dispatchAgentForTask, resolveTaskDispatchTarget, sendToAgentSession, stopAgentSession, } from "./agent-dispatch.js";
 import { AI_TEAM_REPORT_DIR, aiTeamChatHistoryPath, aiTeamHandoffPath, aiTeamReportPath, buildLeaderFollowupPrompt, buildLeaderFormatRetryPrompt, buildAiTeamObjective, buildLeaderKickoffPrompt, buildMemberPrompt, leaderOf, parseLeaderDecision, renderChatHistoryFile, renderHandoffFile, } from "./ai-team-prompts.js";
 import { AI_TEAM_STARTUP_WINDOW_MS, classifyCandidateFailure, classifyStartupFailure, isDegradableWorkFailure, isModelUnknownBeforeDispatch, } from "./ai-team-availability.js";
-import { AI_TEAM_ACTIVE_RUN_STATUSES, AI_TEAM_DETAIL_CHAT_TURNS, agentKey, memberAgents, } from "./ai-team-types.js";
+import { AI_TEAM_ACTIVE_RUN_STATUSES, AI_TEAM_DETAIL_CHAT_TURNS, AI_TEAM_TERMINAL_RUN_STATUSES, agentKey, memberAgents, } from "./ai-team-types.js";
+import { renderLiveStepText } from "./ai-team-live.js";
 import { getErrorMessage } from "./error-utils.js";
 import { activityState } from "./missions.js";
 const REPORT_MAX_BYTES = 64 * 1024;
 /** 报告文件最后一次写入后要稳定这么久才读取，避免读到写了一半的文件。 */
 const REPORT_SETTLE_MS = 1500;
 const OUTPUT_DEBOUNCE_MS = 1000;
+/** live 文本推送的独立去抖（§4.9），与 evaluate 的 OUTPUT_DEBOUNCE_MS 互不干扰。 */
+const LIVE_NOTIFY_DEBOUNCE_MS = 500;
 const SWEEP_INTERVAL_MS = 5000;
 const MAX_FORMAT_RETRIES = 2;
 /** 同一个候选累计这么多次 startup-timeout 就按五元组拉黑（§3.4 黑名单 agents 层）。 */
@@ -22,6 +25,9 @@ export const AI_TEAM_CHAT_PREFIX = "ai-team-chat:";
 /** 等批准时，群里回复这些词就是批准，其余内容都当修改意见。 */
 const APPROVE_REPLY = /^(批准|同意|可以|开始|开干|好的?|ok|okay|yes|lgtm|approve)[。.!！]*$/i;
 const STOP_REPLY = /^(停止|停下|stop)[。.!！]*$/i;
+/** 步数用完后，纯「继续」保留尚未执行的计划；带新要求的回复交回负责人安排。 */
+const CONTINUE_REPLY = /^(继续|让团队继续|继续执行|接着做|接着干|continue)[。.!！]*$/i;
+const STEP_LIMIT_DETAIL = "已达到步数上限";
 /** 用户可见的冲突错误（路由转 409）。 */
 export class AiTeamConflictError extends Error {
 }
@@ -71,22 +77,42 @@ export function createAiTeamRunner(deps) {
         ops: createAiTeamSessionOps(deps),
         chat: createAiTeamChatOps(deps),
         notify: deps.notify,
+        notifyLive: deps.notifyLive,
         models: deps.models,
+        defaultModelOf: deps.defaultModelOf,
     });
     deps.structured?.registerRelay(AI_TEAM_CHAT_PREFIX, (sessionId, text) => runner.chatInput(sessionId, text));
     return runner;
 }
 /**
  * 群聊里的发言人。上传的头像是 data URL，每条消息都带一份太重，改用按 id 取的像素猫。
- * `provider` 传该步**实际使用候选**的 provider（§3.6/B15）；Leader 或没有步骤的场景回退首选。
+ * `agent` 传该步**实际使用候选**（§3.6/B15，降级换候选后跟着变），model / thinkingEffort 与
+ * provider 同源；Leader 或没有步骤的场景回退首选候选。只填真值，展示文案归客户端。
  */
-function chatAuthor(member, sessionId, provider) {
+export function displayAiTeam(snapshot, current) {
+    if (!current)
+        return snapshot;
+    const byId = new Map(current.members.map((member) => [member.id, member]));
+    return {
+        ...snapshot,
+        name: current.name,
+        updatedAt: current.updatedAt,
+        members: snapshot.members.map((member) => {
+            const live = byId.get(member.id);
+            return live ? { ...member, name: live.name, avatar: live.avatar } : member;
+        }),
+    };
+}
+function chatAuthor(member, sessionId, agent) {
+    const used = agent ?? memberAgents(member)[0] ?? member.agent;
     return {
         id: member.id,
         name: member.name,
         avatar: member.avatar && !member.avatar.startsWith("data:") ? member.avatar : undefined,
         leader: member.isLeader || undefined,
-        provider: provider ?? memberAgents(member)[0]?.provider ?? member.agent.provider,
+        provider: used?.provider ?? member.agent.provider,
+        model: used?.model?.trim() || undefined,
+        thinkingEffort: used?.thinkingEffort || undefined,
         sessionId: sessionId ?? undefined,
     };
 }
@@ -150,6 +176,73 @@ function turnText(turn) {
         .filter(Boolean)
         .join("\n\n");
 }
+// ── 群聊开场与协作流转的文案（设计 v2.1 S1–S5）──
+// 全部由服务端纯函数拼好：客户端只做 @ 高亮，不拼句子、不猜字段；也**不引任何 LLM 文本**。
+/** 每行邀请名单上限（S2/S3）：`邀请 @a、@b、@c、@d 加入群聊`。 */
+export const CHAT_INVITE_PER_LINE = 4;
+/** 开工发言与派工行共用的步骤说法：`第 2 步「实现 Web 端」`；标题空白时只剩步数。 */
+function chatStepLabel(seq, title) {
+    const label = title.trim();
+    return label ? `第 ${seq} 步「${label}」` : `第 ${seq} 步`;
+}
+/**
+ * 首次建群的入群序列（S1–S3）：负责人先入群，再按 `team.members` 原顺序邀请其余成员。
+ * 每行最多 [CHAT_INVITE_PER_LINE] 人，第二行起用 `继续邀请 …`；除负责人外没人时给
+ * `还没有邀请其他成员入群`（仍两条，不伪造成员）。
+ */
+export function chatIntroLines(team) {
+    const teamName = team.name.trim();
+    const lines = [teamName ? `创建了团队群聊「${teamName}」` : "创建了团队群聊"];
+    const invitees = team.members.filter((member) => !member.isLeader)
+        .map((member) => member.name.trim())
+        .filter(Boolean);
+    if (invitees.length === 0) {
+        lines.push("还没有邀请其他成员入群");
+        return lines;
+    }
+    for (let index = 0; index < invitees.length; index += CHAT_INVITE_PER_LINE) {
+        const names = invitees.slice(index, index + CHAT_INVITE_PER_LINE).map((name) => `@${name}`).join("、");
+        lines.push(`${index === 0 ? "邀请" : "继续邀请"} ${names} 加入群聊`);
+    }
+    return lines;
+}
+/**
+ * 开工发言正文（S4）：
+ * - 第 1 行 `我正在开始工作：第 N 步「标题」`；
+ * - 有依赖时第 2 行 `依据 @上游成员 第 M 步「上游标题」的产物 <reportPath>`，超过两条
+ *   只列前两条并在尾上 `等 N 步`（N = 依赖总数）；
+ * - 依赖解析不到（旧数据/步骤被删）→ `依据上游步骤的产物继续`。
+ */
+export function stepStartText(step, upstream = [], dependencyCount = upstream.length) {
+    const lines = [`我正在开始工作：${chatStepLabel(step.seq, step.title)}`];
+    if (dependencyCount > 0)
+        lines.push(stepBasisLine(upstream, dependencyCount));
+    return lines.join("\n");
+}
+function stepBasisLine(upstream, dependencyCount) {
+    const shown = upstream.slice(0, 2);
+    if (shown.length === 0)
+        return "依据上游步骤的产物继续";
+    const parts = shown.map((item) => {
+        const reportPath = item.reportPath.trim();
+        return `@${item.memberName} ${chatStepLabel(item.seq, item.title)}的产物${reportPath ? ` ${reportPath}` : ""}`;
+    });
+    return `依据 ${parts.join("、")}${dependencyCount > shown.length ? ` 等 ${dependencyCount} 步` : ""}`;
+}
+/**
+ * 派工行的依据括注（S5）：`（依据：第 1 步「设计规格」的产物）`，多个依赖用 `、` 连接。
+ * 位置 `at` 是**本批 steps 内**的 0-based 下标（展示成第 at+1 步）；没有依赖就是空串（首步无依据）。
+ * 它**取代**旧的 `（等第 N 项完成后）`：同一个依赖关系不写两遍。
+ */
+export function assignmentBasisNote(after, titles) {
+    if (after.length === 0)
+        return "";
+    const parts = after.map((at) => {
+        const label = (titles[at] ?? "").trim();
+        return `第 ${at + 1} 步${label ? `「${label}」` : ""}的产物`;
+    });
+    return `（依据：${parts.join("、")}）`;
+}
 /** 找到提示词（含 reportPath）那一轮之后的 assistant 文本；没有回复返回 null。 */
 function assistantReplyAfterPrompt(snapshot, reportPath) {
     const messages = snapshot.messages ?? [];
@@ -168,6 +261,28 @@ function assistantReplyAfterPrompt(snapshot, reportPath) {
         return null;
     return replies.map(turnText).filter(Boolean).join("\n\n");
 }
+/** 只看本步提示词之后的真实输出；structured 的失败提示是系统生成的，不是模型回答。 */
+function hasStepAssistantReply(snapshot, reportPath, errorMessage) {
+    const messages = snapshot.messages ?? [];
+    let promptIndex = -1;
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const turn = messages[index];
+        if (turn.role === "user" && turnText(turn).includes(reportPath)) {
+            promptIndex = index;
+            break;
+        }
+    }
+    // 无法确认本步起点时，不把历史会话误判成「启动失败」后再次派工。
+    if (promptIndex < 0)
+        return true;
+    const failureText = errorMessage ? `结构化会话执行失败：${errorMessage}` : null;
+    return messages.slice(promptIndex + 1).some((turn) => {
+        if (turn.role !== "assistant")
+            return false;
+        return !failureText || turn.content.length !== 1
+            || turn.content[0]?.type !== "text" || turn.content[0].text !== failureText;
+    });
+}
 function readReport(file) {
     const buffer = readFileSync(file);
     if (buffer.length <= REPORT_MAX_BYTES)
@@ -203,10 +318,16 @@ export class AiTeamRunner {
     chat;
     resolveCwd;
     notifyListener;
+    notifyLiveListener;
     modelsOf;
+    defaultModelOf;
     now;
     chains = new Map();
     outputTimers = new Map();
+    /** live 推送的去抖计时器，按 runId 计（§4.9）。 */
+    liveTimers = new Map();
+    /** 上次推出去的 live 列表指纹（§4.9）：stepId + text + omittedChars + state 全同就不重复推。 */
+    lastLiveKey = new Map();
     recheckTimers = new Map();
     /** 已经确定「不降级、按既有路径记 failed」的步骤，防止 finishStep 再判一次形成回环。 */
     noDegrade = new Set();
@@ -219,9 +340,13 @@ export class AiTeamRunner {
         this.chat = options.chat;
         this.resolveCwd = options.resolveCwd;
         this.notifyListener = options.notify;
+        this.notifyLiveListener = options.notifyLive;
         this.modelsOf = options.models;
+        this.defaultModelOf = options.defaultModelOf;
         this.now = options.now ?? Date.now;
     }
+    /** 提示词里的模型名解析器：`default` 哨兵交给服务端配置的默认模型。 */
+    defaultModelName = (provider) => this.defaultModelOf?.(provider)?.trim() ?? "";
     /** 本 runner 的遮蔽参照目录（§4.5）。 */
     get redactionDirs() {
         if (!this.redactionDirsValue) {
@@ -288,7 +413,7 @@ export class AiTeamRunner {
         excludeReportDir(cwd);
         await this.enqueue(run.id, async () => {
             const step = this.createLeaderStep(run, "制定计划");
-            await this.dispatchStep(run, step, (reportPath, fresh) => (buildLeaderKickoffPrompt(run, reportPath, fresh, chatHistory)));
+            await this.dispatchStep(run, step, (reportPath, fresh) => (buildLeaderKickoffPrompt(run, reportPath, fresh, chatHistory, this.defaultModelName)));
         });
         return this.detail(run.id);
     }
@@ -327,6 +452,16 @@ export class AiTeamRunner {
             if (options.echo !== false)
                 this.postUser(run, note);
             run.formatRetries = 0;
+            if (run.statusDetail === STEP_LIMIT_DETAIL) {
+                // 群聊的「继续」也要真正增加这次运行的预算，且不能作废尚未派出的计划。
+                this.extendStepLimit(run, 10);
+                this.setStatus(run, "running", "");
+                if (CONTINUE_REPLY.test(note))
+                    await this.advance(run);
+                else
+                    await this.startLeaderRound(run, note);
+                return;
+            }
             this.refreshTeam(run);
             this.setStatus(run, "running", "");
             await this.startLeaderRound(run, note);
@@ -335,14 +470,22 @@ export class AiTeamRunner {
     continueRun(runId, extraSteps) {
         return this.act(runId, async (run) => {
             this.requireStatus(run, "waiting_user", "团队当前没有在等你。");
-            const extra = Math.min(50, Math.max(5, Math.round(extraSteps) || 10));
-            this.refreshTeam(run);
-            run.stepLimit = Math.max(run.stepLimit, run.stepsUsed) + extra;
-            this.postNotice(run, `步数上限加到 ${run.stepLimit}，继续执行`);
+            if (run.statusDetail !== STEP_LIMIT_DETAIL) {
+                throw new AiTeamConflictError("团队正在等你回复，当前不是步数上限暂停。");
+            }
+            this.extendStepLimit(run, extraSteps);
             this.setStatus(run, "running", "");
             await this.advance(run);
         });
     }
+    /** 已有运行的上限独立持久化；修改团队定义后，下次续跑至少采用新的团队上限。 */
+    extendStepLimit(run, extraSteps) {
+        const extra = Math.min(50, Math.max(5, Math.round(extraSteps) || 10));
+        this.refreshTeam(run);
+        run.stepLimit = Math.max(run.stepLimit, run.stepsUsed) + extra;
+        run.stepLimit = Math.max(run.stepLimit, run.team.maxSteps);
+        this.postNotice(run, `步数上限加到 ${run.stepLimit}，继续执行`);
+    }
     completeStep(runId, stepId, report) {
         return this.act(runId, async (run) => {
             const step = this.storage.listAiTeamSteps(run.id).find((item) => item.id === stepId);
@@ -372,6 +515,8 @@ export class AiTeamRunner {
             }
             this.postNotice(run, "团队已停止。在群里发消息可以让团队接着处理。");
             this.setStatus(run, "stopped", "已由用户停止");
+            // 步骤全变 skipped：推一次空的 live 列表让卡片收尾（§4.9）。
+            this.pushLive(run.id);
         });
     }
     /**
@@ -429,16 +574,106 @@ export class AiTeamRunner {
         }
         // 群聊回合只给最近这一段（§4.4）；没有群聊会话的旧运行给空数组，前端不用判 null。
         const messages = run.chatSessionId ? this.ops.snapshot(run.chatSessionId)?.messages ?? [] : [];
+        const currentTeam = this.storage.getAiTeam(run.teamId);
         return {
             run,
             steps,
             memberStates,
+            // 别把展示字段写回 run.team：运行快照里的执行候选/职责由 runner 独立管理。
+            displayTeam: displayAiTeam(run.team, currentTeam),
             chatTurns: messages.slice(-AI_TEAM_DETAIL_CHAT_TURNS),
         };
     }
     listForTask(taskId) {
         return this.storage.listAiTeamRuns({ taskId });
     }
+    /**
+     * 此刻正在干活的步骤的实时文本（§4.9）。只覆盖 running 且有会话的步骤，按 seq 升序；
+     * 快照拿不到的步骤跳过而不抛。run 不存在时与 detail() 同口径抛错。
+     */
+    live(runId) {
+        const run = this.storage.getAiTeamRun(runId);
+        if (!run)
+            throw new Error("团队运行不存在。");
+        return this.liveSteps(run);
+    }
+    liveSteps(run) {
+        const steps = [];
+        for (const step of this.storage.listAiTeamSteps(run.id)) {
+            if (step.status !== "running" || !step.sessionId)
+                continue;
+            const snapshot = this.ops.snapshot(step.sessionId);
+            if (!snapshot)
+                continue;
+            steps.push(this.liveStep(run, step, snapshot));
+        }
+        return steps;
+    }
+    liveStep(run, step, snapshot) {
+        const member = this.member(run.team, step.memberId);
+        const agent = member ? this.actualAgent(member, step) : null;
+        const provider = agent?.provider ?? snapshot.provider ?? leaderOf(run.team).agent.provider;
+        const rendered = renderLiveStepText(snapshot.messages ?? [], snapshot.output ?? "", {
+            // pty bridge 只给「claude 且 CLI 已激活」的 PTY 会话挂载（`process-manager.ts` 的
+            // `initializeClaudeBridge` 首行 `record.provider !== "claude" || !record.providerCliActive`
+            // 就早退），其余 PTY 在流式期 `messages` 不增长，里面留着的是上一条 turn 的过期文本
+            // → 一律以终端 output 尾部为准。structured 有流式 messages，照旧。
+            preferOutput: this.ops.ownerOf(step.sessionId) === "pty"
+                && !(provider === "claude" && snapshot.providerCliActive === true),
+        });
+        return {
+            stepId: step.id,
+            seq: step.seq,
+            memberId: step.memberId,
+            memberName: member?.name ?? step.memberId,
+            provider,
+            model: agent?.model?.trim() || undefined,
+            thinkingEffort: agent?.thinkingEffort || undefined,
+            sessionId: step.sessionId,
+            state: activityState(snapshot),
+            text: rendered.text,
+            omittedChars: rendered.omittedChars,
+            updatedAt: this.iso(),
+        };
+    }
+    /** 挂一次 run 级 live 去抖：同一 run 每 500ms 至多算一遍、推一次，与 evaluate 的计时器互不干扰。 */
+    scheduleLivePush(runId) {
+        if (!this.notifyLiveListener || this.liveTimers.has(runId))
+            return;
+        const timer = setTimeout(() => {
+            this.liveTimers.delete(runId);
+            void this.enqueue(runId, async () => { this.pushLive(runId); });
+        }, LIVE_NOTIFY_DEBOUNCE_MS);
+        timer.unref?.();
+        this.liveTimers.set(runId, timer);
+    }
+    /** 推一次 live 列表（§4.9）；指纹（stepId + text + omittedChars + state）没变就不重复推，推送失败只忽略。 */
+    pushLive(runId) {
+        if (!this.notifyLiveListener)
+            return;
+        const run = this.storage.getAiTeamRun(runId);
+        if (!run)
+            return;
+        const steps = this.liveSteps(run);
+        const key = steps
+            .map((step) => `${step.stepId}\u0000${step.text}\u0000${step.omittedChars}\u0000${step.state}`)
+            .join("\u0001");
+        if (this.lastLiveKey.get(runId) === key)
+            return;
+        if (AI_TEAM_TERMINAL_RUN_STATUSES.includes(run.status)) {
+            // 终态的收尾推送之后不再留指纹：留着就没人清，长跑服务会按 run 数攒字符串（§4.9）。
+            this.lastLiveKey.delete(runId);
+        }
+        else {
+            this.lastLiveKey.set(runId, key);
+        }
+        try {
+            this.notifyLiveListener({ runId, taskId: run.taskId, steps });
+        }
+        catch {
+            // 通知失败不影响调度；客户端靠下一次事件或轮询端点补齐。
+        }
+    }
     /** 团队页的运行记录；teamId 为空时列出所有团队（侧边栏计数用）。 */
     listRuns(filter) {
         const runs = this.storage.listAiTeamRuns({
@@ -461,6 +696,9 @@ export class AiTeamRunner {
         const step = this.storage.getRunningAiTeamStepBySession(event.sessionId);
         if (!step)
             return;
+        // 四类事件都挂上 live 去抖：权限/提问这类状态变化是靠 status、task 事件进来的，
+        // 只挂在 output 上，芯片就只能等下一次 ai-team-run 重拉才更新（§4.9）。
+        this.scheduleLivePush(step.runId);
         if (event.type === "output") {
             if (this.outputTimers.has(event.sessionId))
                 return;
@@ -495,13 +733,21 @@ export class AiTeamRunner {
         }
         this.startSweep();
     }
-    /** 兜底巡检：PTY 成员写完报告后可能不再产生事件。 */
+    /**
+     * 兜底巡检：PTY 成员写完报告后可能不再产生事件。
+     * 顺带对每个 run 强制对账一次 live（§4.9）：registry 内部状态静默翻转时一条事件都不会进来，
+     * 状态芯片只能等客户端下一次重拉；这里在同一串里重算列表走 pushLive，指纹变了才推，
+     * 没变就什么都不发。巡检间隔与 evaluate 行为都不动。
+     */
     startSweep() {
         if (this.sweepTimer)
             return;
         this.sweepTimer = setInterval(() => {
             for (const run of this.storage.listAiTeamRuns({ statuses: ["running"] })) {
-                void this.enqueue(run.id, () => this.evaluate(run.id));
+                void this.enqueue(run.id, async () => {
+                    this.pushLive(run.id);
+                    await this.evaluate(run.id);
+                });
             }
         }, SWEEP_INTERVAL_MS);
         this.sweepTimer.unref?.();
@@ -514,8 +760,12 @@ export class AiTeamRunner {
             clearTimeout(timer);
         for (const timer of this.recheckTimers.values())
             clearTimeout(timer);
+        for (const timer of this.liveTimers.values())
+            clearTimeout(timer);
         this.outputTimers.clear();
         this.recheckTimers.clear();
+        this.liveTimers.clear();
+        this.lastLiveKey.clear();
         this.noDegrade.clear();
     }
     /** 等当前排队的所有操作跑完（测试用）。 */
@@ -628,8 +878,13 @@ export class AiTeamRunner {
         }
         return { kind: "pending" };
     }
-    /** proceed=false 时只记结果不推进，由调用方在记完一批之后统一 advance。 */
+    /** 步骤落地后补推一次 live（§4.9）：让卡片收尾，列表可能已空。内部抛错时不推。 */
     async finishStep(run, step, outcome, proceed = true) {
+        await this.finishStepCore(run, step, outcome, proceed);
+        this.pushLive(run.id);
+    }
+    /** proceed=false 时只记结果不推进，由调用方在记完一批之后统一 advance。 */
+    async finishStepCore(run, step, outcome, proceed = true) {
         const endedAt = this.iso();
         // §3.4 触发点 2（异步主通道）：必须在 stepsUsed 递增之前判，否则首个失败候选白扣一步预算。
         if (step.kind === "work" && outcome.kind === "failed" && outcome.sessionError
@@ -648,7 +903,7 @@ export class AiTeamRunner {
             if (member) {
                 this.postTurn(run, {
                     role: "assistant",
-                    author: chatAuthor(member, step.sessionId, this.actualAgent(member, step)?.provider),
+                    author: chatAuthor(member, step.sessionId, this.actualAgent(member, step)),
                     content: chatText(`${outcome.kind === "done" ? "✅ 完成" : "❌ 没完成"}「${step.title}」\n\n${report}`),
                 });
             }
@@ -662,7 +917,7 @@ export class AiTeamRunner {
         if (outcome.kind === "failed" && outcome.sessionError) {
             this.saveStep({ ...step, status: "failed", report: outcome.text, endedAt });
             this.postTurn(run, {
-                role: "assistant", notice: true, author: chatAuthor(leader, step.sessionId),
+                role: "assistant", notice: true, author: chatAuthor(leader, step.sessionId, this.actualAgent(leader, step)),
                 content: chatText(`负责人的模型出错：${outcome.text}\n可以去团队页换个模型，然后在群里回复一句让团队继续。`),
             });
             this.setStatus(run, "waiting_user", `负责人出错：${outcome.text}`);
@@ -683,7 +938,7 @@ export class AiTeamRunner {
             this.postNotice(run, `负责人的回复没能读懂，让他重答（${run.formatRetries}/${MAX_FORMAT_RETRIES}）`, step.sessionId);
             this.saveRun(run);
             const retry = this.createLeaderStep(run, "重新回复");
-            await this.dispatchStep(run, retry, (reportPath, fresh) => (buildLeaderFormatRetryPrompt(run, parsed.error, reportPath, fresh, this.chatHistoryFor(run))));
+            await this.dispatchStep(run, retry, (reportPath, fresh) => (buildLeaderFormatRetryPrompt(run, parsed.error, reportPath, fresh, this.chatHistoryFor(run), this.defaultModelName)));
             return;
         }
         run.formatRetries = 0;
@@ -796,7 +1051,7 @@ export class AiTeamRunner {
             .map((step) => ({ step, memberName: this.member(run.team, step.memberId)?.name ?? step.memberId }));
         const step = this.createLeaderStep(run, userNote ? "回应用户" : "安排下一步");
         const handoffPath = this.writeHandoff(run, step.seq, "leader", finished.map(({ step: item, memberName }) => this.handoffEntry(run, item, memberName)));
-        await this.dispatchStep(run, step, (reportPath, fresh) => (buildLeaderFollowupPrompt(run, finished, reportPath, userNote, fresh, handoffPath, this.chatHistoryFor(run))));
+        await this.dispatchStep(run, step, (reportPath, fresh) => (buildLeaderFollowupPrompt(run, finished, reportPath, userNote, fresh, handoffPath, this.chatHistoryFor(run), this.defaultModelName)));
     }
     /** 一条交接条目：元信息 + 报告全文（全文只进交接文件，不进提示词）。 */
     handoffEntry(run, step, memberName) {
@@ -813,6 +1068,35 @@ export class AiTeamRunner {
      * 成员步骤的上游交接：把依赖步骤的报告写成一个交接文件，提示词只给路径。
      * 没有依赖、或写文件失败时返回 null（提示词仍逐行列出上游报告文件）。
      */
+    /**
+     * 开工发言（S4）：成员**自己发的真实发言**（头像 + 名字 + 气泡），不是居中 notice；
+     * 文案由 [stepStartText] 拼（依据只来自 `step.dependsOn`，不引 `decision.message` / 报告正文 / 提示词文本）。
+     */
+    postStepStart(run, step, member, agent, reusable) {
+        this.postTurn(run, {
+            role: "assistant",
+            author: chatAuthor(member, reusable, agent),
+            content: chatText(stepStartText(step, this.upstreamBasis(run, step), step.dependsOn.length)),
+        });
+    }
+    /**
+     * 开工发言的依据：只看 `step.dependsOn`，按依赖顺序解析出上游步骤（没有依赖返回空数组）。
+     * 不调 `memberUpstream`：那个会顺手写交接文件，而这里只要读数据（设计 v2.1 强调不引 LLM 文本）。
+     */
+    upstreamBasis(run, step) {
+        if (step.dependsOn.length === 0)
+            return [];
+        const byId = new Map(this.storage.listAiTeamSteps(run.id).map((item) => [item.id, item]));
+        return step.dependsOn
+            .map((id) => byId.get(id))
+            .filter((item) => Boolean(item))
+            .map((item) => ({
+            seq: item.seq,
+            title: item.title,
+            memberName: this.member(run.team, item.memberId)?.name ?? item.memberId,
+            reportPath: item.reportPath,
+        }));
+    }
     memberUpstream(run, step) {
         if (step.dependsOn.length === 0)
             return null;
@@ -896,7 +1180,7 @@ export class AiTeamRunner {
         if (run.stepsUsed < run.stepLimit)
             return true;
         this.postNotice(run, `已用完 ${run.stepLimit} 步的上限，团队先停下。回复一句让团队继续，或在任务面板里加步数。`);
-        this.setStatus(run, "waiting_user", "已达到步数上限");
+        this.setStatus(run, "waiting_user", STEP_LIMIT_DETAIL);
         return false;
     }
     createLeaderStep(run, title) {
@@ -952,9 +1236,11 @@ export class AiTeamRunner {
         let running = { ...step, instructions: step.kind === "leader" ? prompt.message : step.instructions, status: "running", startedAt, sessionId: reusable };
         this.saveStep(running);
         this.notify(run);
-        if (member && step.kind === "work") {
-            this.postNotice(run, `${member.name} 开始「${step.title}」`, reusable, member, agent?.provider);
-        }
+        // 开工发言（S4）：就发在这个位置（原来那条居中 notice 的地方），所以候选起不来的那次尝试
+        // 也会留一句「我正在开始工作」+ 随后的降级/失败出口；作者署名与报告同一套口径，
+        // 复用会话时带真实 sessionId，新建在 open 前未知；若 open 失败，失败报告也可能无 ID。
+        if (member && step.kind === "work")
+            this.postStepStart(run, running, member, agent, reusable);
         try {
             if (!member)
                 throw new Error("成员不存在");
@@ -1078,7 +1364,7 @@ export class AiTeamRunner {
         this.saveStep(replacement);
         // 群聊降级行（§5.3/B15）：一次降级一行，署名用切过去的新候选；事前 model-unknown 跳过
         // 同样走 degradeWorkStep，所以这里也覆盖它。reason 已经过脱敏 + 头尾截断（§4.5）。
-        this.postNotice(run, `⚠️ ${member.name} 的首选配置不可用（${reason}），已切换到候选 ${next + 1}`, null, member, candidates[next]?.provider);
+        this.postNotice(run, `⚠️ ${member.name} 的首选配置不可用（${reason}），已切换到候选 ${next + 1}`, null, member, candidates[next]);
         // ④ 依赖重指向（R1）：排队步骤等的仍是「这件事做完」，只是换了承载候选的步骤。
         //    running / done 的历史步骤不改写。
         for (const queued of this.storage.listAiTeamSteps(run.id)) {
@@ -1116,7 +1402,9 @@ export class AiTeamRunner {
         const errorMessage = snapshot?.structuredState?.lastError ?? outcomeText;
         const kind = classifyStartupFailure({
             status: snapshot?.status ?? "failed",
-            hasAssistantReply: Boolean(snapshot?.messages?.some((turn) => turn.role === "assistant")),
+            hasAssistantReply: snapshot
+                ? hasStepAssistantReply(snapshot, step.reportPath, errorMessage)
+                : true,
             elapsedMs,
             errorMessage,
         });
@@ -1250,8 +1538,11 @@ export class AiTeamRunner {
     openChat(run, task, objective, chatHistory) {
         if (!this.chat)
             return;
+        // 「首次建群」只能在这一拍判定：`open()` 之后 run.chatSessionId 就有值了。
+        // 入群序列（S1–S3）只跟这个分支走，续跑/重启接回/同一个群里开新 run 都不重播（v2.1 规则 1）。
+        const firstChat = !run.chatSessionId;
         try {
-            if (!run.chatSessionId) {
+            if (firstChat) {
                 run.chatSessionId = this.chat.open({ task, run, title: `${run.team.name} · ${task.title}` });
             }
         }
@@ -1259,13 +1550,21 @@ export class AiTeamRunner {
             console.error(`[AiTeam] open chat for ${run.id} failed:`, getErrorMessage(error));
             return;
         }
-        const roster = run.team.members.map((member) => member.isLeader ? `${member.name}（负责人）` : member.name).join("、");
         if (objective)
             this.postUser(run, objective);
-        // 续跑时不说「接手」：用户看得出这是同一轮工作往下走，并把交给团队的历史文件摊开给他核。
-        this.postNotice(run, chatHistory
-            ? `接着这个群聊里上一轮的进度继续；交给负责人和成员的记录见 ${chatHistory}`
-            : `团队「${run.team.name}」接手了这个任务：${roster}`);
+        if (!firstChat) {
+            // 续跑时不说「接手」：用户看得出这是同一轮工作往下走，并把交给团队的历史文件摊开给他核。
+            if (chatHistory) {
+                this.postNotice(run, `接着这个群聊里上一轮的进度继续；交给负责人和成员的记录见 ${chatHistory}`);
+            }
+            return;
+        }
+        // 首次建群：负责人先入群，再按名单邀请其余成员（2–3 条系统行，作者都是负责人）。
+        const leader = leaderOf(run.team);
+        const leaderAgent = leader ? memberAgents(leader)[0] ?? leader.agent : undefined;
+        for (const line of chatIntroLines(run.team)) {
+            this.postNotice(run, line, run.chatSessionId, leader, leaderAgent);
+        }
     }
     postTurn(run, turn) {
         if (!this.chat || !run.chatSessionId)
@@ -1280,10 +1579,10 @@ export class AiTeamRunner {
     postUser(run, text) {
         this.postTurn(run, { role: "user", content: chatText(text) });
     }
-    postNotice(run, text, sessionId, member, provider) {
+    postNotice(run, text, sessionId, member, agent) {
         this.postTurn(run, {
             role: "assistant", notice: true, content: chatText(text),
-            author: member ? chatAuthor(member, sessionId, provider) : undefined,
+            author: member ? chatAuthor(member, sessionId, agent) : undefined,
         });
     }
     /** 负责人的决定：说明 + 派工清单；等批准 / 等回复时告诉用户在群里怎么接话。 */
@@ -1292,14 +1591,15 @@ export class AiTeamRunner {
         if (decision.action === "assign") {
             const assigned = decision.steps.map((item, index) => {
                 const name = this.member(run.team, item.memberId)?.name ?? item.memberId;
-                const after = item.after.length > 0 ? `（等第 ${item.after.map((at) => at + 1).join("、")} 项完成后）` : "";
-                return `${index + 1}. **@${name}** ${item.title}${after}`;
+                const basis = assignmentBasisNote(item.after, decision.steps.map((entry) => entry.title));
+                return `${index + 1}. **@${name}** ${item.title}${basis}`;
             });
             lines.push(assigned.join("\n"));
         }
+        const leader = leaderOf(run.team);
         this.postTurn(run, {
             role: "assistant",
-            author: chatAuthor(leaderOf(run.team), step.sessionId),
+            author: chatAuthor(leader, step.sessionId, this.actualAgent(leader, step)),
             content: chatText(lines.filter(Boolean).join("\n\n")),
         });
         if (decision.action === "assign" && !run.planApproved) {
@@ -1347,6 +1647,9 @@ export class AiTeamRunner {
         run.status = status;
         run.statusDetail = detail;
         this.saveRun(run);
+        // 进终态就不可能再有 live 变化，清掉该 run 的推送指纹：不然长跑的服务会按 run 数线性攒字符串。
+        if (AI_TEAM_TERMINAL_RUN_STATUSES.includes(status))
+            this.lastLiveKey.delete(run.id);
     }
     saveRun(run) {
         run.updatedAt = this.iso();