@co0ontty/wand 4.77.0-beta.g7fb0b70 → 4.77.0-beta.gee68088

package/README.md

@@ -135,14 +135,20 @@ Use an isolated config for testing:
 npm run dev -- -c /tmp/wand-test/config.json
 ```
 
-The Android, iOS, and macOS clients are git submodules:
+For server development, check out only the pinned Render binaries. Native clients and
+Rust source are independent submodules; initialize the one you are changing:
 
 ```bash
-git clone --recurse-submodules https://github.com/co0ontty/wand.git
-# or, after cloning:
-git submodule update --init
+git clone https://github.com/co0ontty/wand.git
+cd wand
+git submodule update --init -- render-bin
+# Optional: git submodule update --init -- android  # or ios, macos, render
 ```
 
+The full cross-platform test suite reads native source contracts, so initialize
+`android ios macos render` before running `npm test`. To preview removable compiler
+caches, run `npm run clean:build-cache`; add `-- --apply` to remove them.
+
 Runtime data is stored under `~/.wand/`: `config.json`, `wand.db`, and `sessions/`.
 
 OpenCode structured sessions require the current `opencode-ai` CLI (0.1 or newer). Remove the unrelated legacy `opencode` 0.0.x package before installing it:
@@ -326,14 +332,20 @@ wand/
 └── docs/                         # 文档与截图
 ```
 
-三个客户端壳应用是独立仓库，以 git submodule 引用。克隆源码开发时需要带上：
+服务端开发只需检出固定版本的 Render 二进制。原生客户端和 Rust 源码都是独立子模块，修改哪个再检出哪个：
 
 ```bash
-git clone --recurse-submodules https://github.com/co0ontty/wand.git
-# 或已克隆后补拉：
-git submodule update --init
+git clone https://github.com/co0ontty/wand.git
+cd wand
+git submodule update --init -- render-bin
+# 按需：git submodule update --init -- android  # 或 ios、macos、render
 ```
 
+全量 `npm test` 包含跨端源码契约检查，运行前另检出 `android ios macos render`。
+`npm run clean:build-cache` 预览可清理的编译缓存，追加 `-- --apply` 才执行删除；
+保留分发包、Release Render 二进制、签名、依赖和会话数据。审计与续接记录见
+[`docs/repository-slimming.md`](docs/repository-slimming.md)。
+
 数据存储在 `~/.wand/` 下：`config.json`（配置）、`wand.db`（SQLite）、`sessions/`（日志）。
 
 ### License

package/dist/agent-dispatch.js

@@ -1,12 +1,13 @@
 import { getDefaultModelForProvider } from "./config.js";
 import { providerCliCommand } from "./session-provider.js";
-import { ensureWorkspaceTaskForBoardTask } from "./wand-task-sync.js";
 /** 任务卡的执行目录：工作任务的 worktree / 目录 → 所属项目目录 → 全局默认目录。 */
 export function resolveTaskDispatchTarget(deps, task) {
     const workspace = task.workspaceId ? deps.storage.getWorkspace(task.workspaceId) : null;
     if (task.workspaceId && !workspace)
         throw new Error("任务所属项目已被删除，请重新指定。");
-    const group = ensureWorkspaceTaskForBoardTask(deps.storage, task);
+    const group = task.workspaceTaskId ? deps.storage.getWorkspaceTask(task.workspaceTaskId) : null;
+    if (!group)
+        throw new Error("任务容器不存在，请恢复任务后再派发。");
     const cwd = group.worktree?.path || group.cwd || workspace?.cwd || deps.config.defaultCwd;
     return { cwd, workspaceId: group.workspaceId, workspaceTaskId: group.id };
 }

package/dist/ai-team-live.d.ts

@@ -0,0 +1,25 @@
+import type { ConversationTurn } from "./types.js";
+/**
+ * 运行中步骤的 live 文本渲染结果。`omittedChars` > 0 表示前面被截掉的字数，
+ * 客户端据此显示「已省略前面 N 字」。
+ */
+export interface LiveStepText {
+    text: string;
+    omittedChars: number;
+}
+/**
+ * 渲染「成员此刻干到哪儿了」的紧凑文本，给固定尺寸、内部滚动的 live 卡片用。
+ * 口径：从最后一条 user turn（没有就取最后一条 assistant turn）渲染到末尾；
+ * text 原样保留，tool_use 压成一行 `▸ 名称[ · 描述]`，tool_result 与 thinking 不渲染；
+ * 尾部保留最多 AI_TEAM_LIVE_TEXT_MAX_CHARS 字；渲染结果为空时回落原始 output 尾部
+ * （先按尾部截窗再剥 ANSI、同样截尾，见 `outputTailText`），保证 PTY 会话也有内容可显示。
+ * 纯函数、无 IO。
+ *
+ * `preferOutput`：以终端 output 尾部为唯一来源，完全不看 `messages`。给「PTY 但没有人把
+ * 流式输出解析成 messages」的会话用（判定在调用方，见 `ai-team-runner.ts` 的 `liveStep`）——
+ * 这类会话的 `messages` 在流式期不增长，里面若留着上一条 turn，按上面的口径会一直渲染那段
+ * 旧文本，卡片停在过期内容上。此时 output 为空也照实返回空串，不拿旧 messages 凑数。
+ */
+export declare function renderLiveStepText(messages: ConversationTurn[], output: string, options?: {
+    preferOutput?: boolean;
+}): LiveStepText;

package/dist/ai-team-live.js

@@ -0,0 +1,135 @@
+import { AI_TEAM_LIVE_TEXT_MAX_CHARS } from "./ai-team-types.js";
+/** tool_use 行的 description 单行截断长度。 */
+const TOOL_DESCRIPTION_MAX_CHARS = 60;
+/** CSI + OSC + 两字节转义，覆盖 PTY 输出里常见的控制序列。 */
+const ANSI_PATTERN = /\x1B(?:\[[0-?]*[ -/]*[@-~]|\][^\x07\x1B]*(?:\x07|\x1B\\)|[ @-Z\\-_])/g;
+function stripAnsi(text) {
+    return text.replace(ANSI_PATTERN, "");
+}
+/** 行尾空白清掉；连续空行（≥2 个）压成一个换行，单个空行保留，段落还在。 */
+function collapseBlankLines(text) {
+    return text.replace(/[ \t]+$/gm, "").replace(/\n{3,}/g, "\n");
+}
+/**
+ * 把切点往前挪一个 code unit，避开「半个 emoji」。
+ * `slice` 按 UTF-16 code unit 切，切点正好落在代理对中间（前一个是高代理、这一个是低代理）时，
+ * 尾巴会以一个孤立低代理开头 —— 下游渲染成 1 个 U+FFFD。往**前**挪（丢掉这一对的后半截，
+ * 整对归到被省略的前缀里）而不是往后挪，才能保证 `text.length <= AI_TEAM_LIVE_TEXT_MAX_CHARS`。
+ * 起点是 0（没切）或 `start - 1` 不是高代理时原样返回。
+ */
+function skipOrphanSurrogate(text, start) {
+    if (start <= 0 || start >= text.length)
+        return start;
+    const previous = text.charCodeAt(start - 1);
+    const current = text.charCodeAt(start);
+    const splitPair = previous >= 0xD800 && previous <= 0xDBFF && current >= 0xDC00 && current <= 0xDFFF;
+    return splitPair ? start + 1 : start;
+}
+function takeTail(text) {
+    if (text.length <= AI_TEAM_LIVE_TEXT_MAX_CHARS)
+        return { text, omittedChars: 0 };
+    const start = skipOrphanSurrogate(text, text.length - AI_TEAM_LIVE_TEXT_MAX_CHARS);
+    const tail = text.slice(start);
+    return { text: tail, omittedChars: text.length - tail.length };
+}
+/**
+ * output 回落的截窗宽度：只要保留上限的 8 倍。转义序列通常远少于正文，窗内可见文本一般仍 ≥
+ * AI_TEAM_LIVE_TEXT_MAX_CHARS，此时窗内显示的文本与「全量剥完再截尾」逐字相同；极端全是转义的
+ * 输出只会让显示的比全量少一截，省略字数仍按截窗点如实计入（是估算值，见 `outputTailText`）。
+ */
+const LIVE_OUTPUT_WINDOW_CHARS = AI_TEAM_LIVE_TEXT_MAX_CHARS * 8;
+/**
+ * 截窗点最多往前回退这么多字符去找转义序列的起点（ESC）。
+ * 宽度按能装下最长的常见序列给：OSC 标题/超链接可以横跨几 K（`ESC ] 0; <长标题> BEL`），
+ * 只回退 64 字会把这种序列从中间切开，残留裸 BEL 和标题片段当正文显示。
+ */
+const LIVE_OUTPUT_ESCAPE_LOOKBACK = 4096;
+/**
+ * 把截窗点挪到一个安全边界上：
+ * 1. 回退范围内有 ESC → 从该序列的起点开始，剥 ANSI 就能整条剥掉；
+ * 2. 退一步到最近的换行之后 → 至少不显示半行的残片；
+ * 3. 两者都找不到（超长转义负载里既没 ESC 也没换行）就不兜底，照原切点显示。
+ * 只在 `[start - LOOKBACK, start)` 这段里搜，不对整串（能到几 MB）跑 lastIndexOf。
+ */
+function safeTailStart(output, start) {
+    const from = Math.max(0, start - LIVE_OUTPUT_ESCAPE_LOOKBACK);
+    const window = output.slice(from, start);
+    const esc = window.lastIndexOf("\x1B");
+    if (esc >= 0)
+        return from + esc;
+    const newline = window.lastIndexOf("\n");
+    return newline >= 0 ? from + newline + 1 : start;
+}
+/**
+ * 终端原始输出的尾部：先按尾部截窗，再剥 ANSI / 换行归一 / 压缩空行 / 截尾。
+ * live 每 500ms 就可能算一遍，而 PTY 的 output 能长到几 MB —— 顺序反过来等于每半秒对全量
+ * 跑一遍正则。丢掉的前缀计入 omittedChars，是**估算值（可能偏大也可能偏小，用于量级提示）**：
+ * 按截窗点的原始字数计，含 ANSI 与控制字符，不精确到账。三条边界写进 docs/ai-teams.md。
+ */
+function outputTailText(output) {
+    const rawStart = Math.max(0, output.length - LIVE_OUTPUT_WINDOW_CHARS);
+    const start = rawStart > 0 ? skipOrphanSurrogate(output, safeTailStart(output, rawStart)) : 0;
+    const stripped = collapseBlankLines(stripAnsi(output.slice(start)).replace(/\r\n?/g, "\n")).trim();
+    // 窗内全是转义序列时 stripped 为空，但窗外的正文确实被丢了，省略字数照 start 记，不报 0。
+    const tail = takeTail(stripped);
+    return start > 0 ? { text: tail.text, omittedChars: tail.omittedChars + start } : tail;
+}
+/** 压成一行并截断到 max 字（省略号算在长度内）。 */
+function oneLine(text, max) {
+    const collapsed = text.replace(/\s+/g, " ").trim();
+    if (collapsed.length <= max)
+        return collapsed;
+    return `${collapsed.slice(0, max - 1)}…`;
+}
+/**
+ * 渲染「成员此刻干到哪儿了」的紧凑文本，给固定尺寸、内部滚动的 live 卡片用。
+ * 口径：从最后一条 user turn（没有就取最后一条 assistant turn）渲染到末尾；
+ * text 原样保留，tool_use 压成一行 `▸ 名称[ · 描述]`，tool_result 与 thinking 不渲染；
+ * 尾部保留最多 AI_TEAM_LIVE_TEXT_MAX_CHARS 字；渲染结果为空时回落原始 output 尾部
+ * （先按尾部截窗再剥 ANSI、同样截尾，见 `outputTailText`），保证 PTY 会话也有内容可显示。
+ * 纯函数、无 IO。
+ *
+ * `preferOutput`：以终端 output 尾部为唯一来源，完全不看 `messages`。给「PTY 但没有人把
+ * 流式输出解析成 messages」的会话用（判定在调用方，见 `ai-team-runner.ts` 的 `liveStep`）——
+ * 这类会话的 `messages` 在流式期不增长，里面若留着上一条 turn，按上面的口径会一直渲染那段
+ * 旧文本，卡片停在过期内容上。此时 output 为空也照实返回空串，不拿旧 messages 凑数。
+ */
+export function renderLiveStepText(messages, output, options = {}) {
+    if (options.preferOutput === true)
+        return outputTailText(output);
+    let start = -1;
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        if (messages[index].role === "user") {
+            start = index;
+            break;
+        }
+    }
+    if (start < 0) {
+        for (let index = messages.length - 1; index >= 0; index -= 1) {
+            if (messages[index].role === "assistant") {
+                start = index;
+                break;
+            }
+        }
+    }
+    const fragments = [];
+    for (const turn of start >= 0 ? messages.slice(start) : []) {
+        for (const block of turn.content) {
+            if (block.type === "text") {
+                const text = block.text?.trim();
+                if (text)
+                    fragments.push(text);
+            }
+            else if (block.type === "tool_use") {
+                const description = block.description?.trim();
+                fragments.push(description
+                    ? `▸ ${block.name} · ${oneLine(description, TOOL_DESCRIPTION_MAX_CHARS)}`
+                    : `▸ ${block.name}`);
+            }
+        }
+    }
+    const rendered = collapseBlankLines(fragments.join("\n")).trim();
+    if (rendered)
+        return takeTail(rendered);
+    return outputTailText(output);
+}

package/dist/ai-team-prompts.d.ts

@@ -1,4 +1,5 @@
 import { type AiTeam, type AiTeamMember, type AiTeamRun, type AiTeamRunStatus, type AiTeamStep } from "./ai-team-types.js";
+import type { WandTaskAgent } from "./task-types.js";
 import type { ConversationTurn } from "./types.js";
 export declare const AI_TEAM_REPORT_DIR = ".wand-team";
 export declare const AI_TEAM_MAX_ASSIGN_STEPS = 5;
@@ -23,7 +24,7 @@ export type AiTeamLeaderDecision = {
 /**
  * 团队这一轮要做的事。
  * 指派框 / 群聊里刚输入的文字就是本轮任务，不再把任务卡上的旧描述静默拼进去。
- * 没有单独输入时（创建任务后立刻交给团队）才用标题 + 描述。
+ * 没有单独输入时（创建任务后立刻交给团队）才用标题 + 描述，标题已被描述覆盖时不重复。
  */
 export declare function buildAiTeamObjective(task: {
     title: string;
@@ -84,21 +85,24 @@ export declare function renderChatHistoryFile(input: {
     maxBytes?: number;
 }): string;
 /**
- * 一轮提示词：`system` 交给 CLI 的系统提示通道（角色、规则、回复格式），`message` 是这一轮的
- * 用户消息（目标、指派、报告路径）。provider 支持系统提示时必须走 `system`，不要把规则塞进消息里。
+ * 一轮提示词：`system` 交给 CLI 的系统提示通道（角色、规则、回复格式、交接文件的用法），
+ * `message` 是这一轮的用户消息（目标、指派、文件路径）。
+ * provider 支持系统提示时一律走 `system`：规则不伪装成用户发言，也不每轮重复。
  */
 export interface AiTeamPrompt {
     system: string;
     message: string;
 }
+/** `default` 哨兵在提示词里怎么写：换成服务端为该 CLI 配置的默认模型名；没配就退回「默认」。 */
+export type AiTeamModelNameResolver = (provider: WandTaskAgent["provider"]) => string;
 /** `chatHistoryPath` 有值时说明这一轮是同一个群聊的续跑（见 `aiTeamChatHistoryPath`）。 */
-export declare function buildLeaderKickoffPrompt(run: AiTeamRun, reportPath: string, fresh: boolean, chatHistoryPath?: string | null): AiTeamPrompt;
+export declare function buildLeaderKickoffPrompt(run: AiTeamRun, reportPath: string, fresh: boolean, chatHistoryPath?: string | null, resolveModel?: AiTeamModelNameResolver): AiTeamPrompt;
 export interface AiTeamFinishedStepSummary {
     step: AiTeamStep;
     memberName: string;
 }
-export declare function buildLeaderFollowupPrompt(run: AiTeamRun, finished: AiTeamFinishedStepSummary[], reportPath: string, userNote: string | undefined, fresh: boolean, handoffPath?: string | null, chatHistoryPath?: string | null): AiTeamPrompt;
-export declare function buildLeaderFormatRetryPrompt(run: AiTeamRun, error: string, reportPath: string, fresh: boolean, chatHistoryPath?: string | null): AiTeamPrompt;
+export declare function buildLeaderFollowupPrompt(run: AiTeamRun, finished: AiTeamFinishedStepSummary[], reportPath: string, userNote: string | undefined, fresh: boolean, handoffPath?: string | null, chatHistoryPath?: string | null, resolveModel?: AiTeamModelNameResolver): AiTeamPrompt;
+export declare function buildLeaderFormatRetryPrompt(run: AiTeamRun, error: string, reportPath: string, fresh: boolean, chatHistoryPath?: string | null, resolveModel?: AiTeamModelNameResolver): AiTeamPrompt;
 /**
  * fresh=false 时成员会话已有上下文，省掉目标段落。`upstream` 有值时只给交接文件路径与
  * 各步报告文件，不在提示词里复述上游报告正文（上一个成员的信息走文件交接）。

package/dist/ai-team-prompts.js

@@ -4,10 +4,31 @@ export const AI_TEAM_MAX_ASSIGN_STEPS = 5;
 const MESSAGE_MAX = 2000;
 const TITLE_MAX = 80;
 const INSTRUCTIONS_MAX = 8000;
+/**
+ * 消息里引用文件用的固定标签：用户消息只给路径，怎么用写在系统提示的「交接文件」段
+ * （`leaderSystemPrompt` / `memberSystemPrompt`），每轮不重复同一句规则。
+ */
+const ROUND_REPORT_LABEL = "本轮报告文件";
+const HANDOFF_LABEL = "上游交接文件";
+const CHAT_HISTORY_LABEL = "本群聊之前的记录";
+/** 后一段已经完整包含前一段时只留后一段（任务标题常是描述开头被截断出来的前缀）。 */
+function mergeTaskTexts(title, description) {
+    const head = title.trim();
+    const tail = description.trim();
+    if (!head)
+        return tail;
+    if (!tail)
+        return head;
+    if (tail.includes(head))
+        return tail;
+    if (head.includes(tail))
+        return head;
+    return `${head}\n\n${tail}`;
+}
 /**
  * 团队这一轮要做的事。
  * 指派框 / 群聊里刚输入的文字就是本轮任务，不再把任务卡上的旧描述静默拼进去。
- * 没有单独输入时（创建任务后立刻交给团队）才用标题 + 描述。
+ * 没有单独输入时（创建任务后立刻交给团队）才用标题 + 描述，标题已被描述覆盖时不重复。
  */
 export function buildAiTeamObjective(task, note) {
     const assignment = note?.trim() ?? "";
@@ -15,7 +36,7 @@ export function buildAiTeamObjective(task, note) {
         const title = task.title.trim();
         return title && !assignment.includes(title) ? `任务：${title}\n\n${assignment}` : assignment;
     }
-    return [task.title.trim(), task.description.trim()].filter(Boolean).join("\n\n") || "完成这张任务";
+    return mergeTaskTexts(task.title, task.description) || "完成这张任务";
 }
 export function leaderOf(team) {
     return team.members.find((member) => member.isLeader) ?? team.members[0];
@@ -151,10 +172,12 @@ const TEAM_ROLE_LABELS = {
     work: "干活实现",
     verify: "验收测试",
 };
-function memberLine(member) {
+function memberLine(member, resolveModel) {
     // 只渲染首选候选（§3.6）；备用候选不进提示词，降级由系统处理。
     const preferred = memberAgents(member)[0] ?? member.agent;
-    const model = preferred.model === "default" ? "默认模型" : preferred.model;
+    const configured = preferred.model === "default" ? resolveModel?.(preferred.provider)?.trim() ?? "" : "";
+    // `default` 不是模型名，写真正会用的那个（拿不到名字才写「默认」）。
+    const model = preferred.model === "default" ? configured || "默认" : preferred.model;
     const role = member.role ? TEAM_ROLE_LABELS[member.role] : undefined;
     const duty = member.duty.trim().replace(/\s+/g, " ") || "（未填写）";
     const parts = [`id: ${member.id}`, `名字: ${member.name}`];
@@ -166,7 +189,7 @@ function memberLine(member) {
 function leaderReplyFormat() {
     return [
         "## 回复方式（必须遵守）",
-        "每轮消息都会给出本次的报告文件路径；把决定写成 JSON 写入该文件，写完简短回复「已写入」。",
+        `每轮消息末尾都给出这一轮的报告文件（标签「${ROUND_REPORT_LABEL}」）；把决定写成 JSON 写入该文件，写完只简短回复「已写入」，不要在消息里复述计划。`,
         "格式三选一：",
         '{"action":"assign","message":"给用户看的一句话说明","steps":[{"member":"成员 id","title":"简短标题","instructions":"具体要做什么、做到什么程度"}]}',
         '{"action":"ask","message":"要问用户的问题"}',
@@ -189,28 +212,25 @@ function teamInstructions(team) {
 /** 目标与用户补充都是用户原话（常带口述笔误），别按字面较真。 */
 const OBJECTIVE_INTENT_NOTE = "目标与用户补充都是用户原话，可能带口述笔误（例如把 CLI 写成 ci），按用户意图理解，不要照字面复述。";
 /**
- * 接着同一个群聊跑的那一轮：负责人与成员先读上下文文件再动手。
- * 负责人还要据此避免重做已经完成的步骤；成员只需在已有改动上继续。
+ * 交接文件怎么用，写在系统提示里（消息里只给路径，会话级规则只说一次）。
+ * 负责人用它决定下一步，成员用它接着上游干活。
  */
-function chatHistoryBlock(path, audience) {
-    if (!path)
-        return [];
-    const shared = `用户是在这个群聊里接着提要求，之前几轮的步骤摘要与群聊原文在：${path}`;
+function handoffRules(audience) {
     return audience === "leader"
         ? [
-            "## 接着这个群聊之前的几轮（动手前先读文件）",
-            shared,
-            "先读这个文件再安排：已经做完的不要重做，上一轮没做完的接着做；不要凭标题猜成员做过什么，也不要让他们复述历史。",
+            "## 交接文件（消息里出现下列标签时，先读文件再动手）",
+            `- ${HANDOFF_LABEL}：上一批步骤的报告全文汇总，先读它再决定下一步；不要凭标题猜成员做了什么，也不要让他们把报告复述进消息里。`,
+            `- ${CHAT_HISTORY_LABEL}：用户是在这个群聊里接着提要求；先读它，已经做完的不要重做，上一轮没做完的接着做。`,
             "",
         ]
         : [
-            "## 本群聊历史（动手前先读文件）",
-            shared,
-            "先读这个文件，在已有改动的基础上继续；已经完成的部分不要重做。",
+            "## 交接文件（消息里出现下列标签时，先读文件再动手）",
+            `- ${HANDOFF_LABEL}：上游步骤的报告全文汇总，先读它再开始本步骤；不要猜上游做了什么，也不要重复劳动。`,
+            `- ${CHAT_HISTORY_LABEL}：用户是在这个群聊里接着提要求；先读它，在已有改动的基础上继续，已经完成的部分不要重做。`,
             "",
         ];
 }
-function leaderSystemPrompt(run) {
+function leaderSystemPrompt(run, resolveModel) {
     const leader = leaderOf(run.team);
     return [
         `你是 AI 团队「${run.team.name}」的负责人（${leader.name}）。`,
@@ -218,7 +238,7 @@ function leaderSystemPrompt(run) {
         "",
         "## 成员（只能把工作派给下列成员；id 必须原样使用）",
         "成员的名单行只列首选执行配置；执行配置由系统按候选顺序自动降级，你只按成员能力分派，不操心模型可用性。",
-        ...workersOf(run.team).map(memberLine),
+        ...workersOf(run.team).map((member) => memberLine(member, resolveModel)),
         ...teamInstructions(run.team),
         "",
         "## 工作方式",
@@ -231,6 +251,7 @@ function leaderSystemPrompt(run) {
         "- 需要用户拍板时就提问，不要猜。",
         `- ${OBJECTIVE_INTENT_NOTE}`,
         "",
+        ...handoffRules("leader"),
         ...leaderReplyFormat(),
     ].join("\n");
 }
@@ -245,57 +266,66 @@ function memberSystemPrompt(run, member) {
         "- 不要 git commit / push。",
         "- 你的发言会以群聊气泡出现，署名是你的名字；报告仍写进报告文件。",
         "",
+        ...handoffRules("member"),
         "## 报告约定",
-        "每轮消息都会给出本次的报告文件路径；完成后把报告写进该文件（Markdown）：",
+        `每轮消息末尾都给出这一轮的报告文件（标签「${ROUND_REPORT_LABEL}」）；完成后把报告写进该文件（Markdown）：`,
         "第一行写 `状态: 完成`、`状态: 受阻` 或 `状态: 失败`，然后写做了什么、改了哪些文件、怎么验证的、还有什么问题。",
     ].join("\n");
 }
+/** 本轮报告文件的引用行；怎么用写在系统提示里（见 `leaderReplyFormat` / 「报告约定」）。 */
+function reportLine(reportPath) {
+    return `${ROUND_REPORT_LABEL}：${reportPath}`;
+}
 /** 会话是新建的时候才需要补目标：老会话的上下文里已经有目标了。 */
 function objectiveBlock(run, fresh) {
     // 标签内联而不是单独的 `## 团队目标` 行：团队消息也会被会话标题 / 迭代提示词记录取首行，
     // 单独一行的话标题会退化成「团队目标」这个空壳。
     return fresh ? [`团队目标：${run.objective}`, ""] : [];
 }
+/**
+ * 续跑（用户在同一个群聊里接着说话）的上下文文件（见 `aiTeamChatHistoryPath`）：
+ * 消息只给路径，「先读它、别重做已完成的」写在系统提示的「交接文件」段。
+ */
+function chatHistoryBlock(path) {
+    return path ? [`${CHAT_HISTORY_LABEL}：${path}`, ""] : [];
+}
 /** `chatHistoryPath` 有值时说明这一轮是同一个群聊的续跑（见 `aiTeamChatHistoryPath`）。 */
-export function buildLeaderKickoffPrompt(run, reportPath, fresh, chatHistoryPath) {
+export function buildLeaderKickoffPrompt(run, reportPath, fresh, chatHistoryPath, resolveModel) {
     return {
-        system: leaderSystemPrompt(run),
+        system: leaderSystemPrompt(run, resolveModel),
         message: [
             ...objectiveBlock(run, fresh),
-            ...chatHistoryBlock(chatHistoryPath, "leader"),
-            "## 本轮要求",
-            `把计划决策写成 JSON 写入：${reportPath}`,
+            ...chatHistoryBlock(chatHistoryPath),
+            reportLine(reportPath),
         ].join("\n"),
     };
 }
-export function buildLeaderFollowupPrompt(run, finished, reportPath, userNote, fresh, handoffPath, chatHistoryPath) {
+export function buildLeaderFollowupPrompt(run, finished, reportPath, userNote, fresh, handoffPath, chatHistoryPath, resolveModel) {
     // 续跑上下文只在新建的负责人会话里补一次：会话复用的时候，kickoff 那一轮已经给过路径。
-    const lines = [...objectiveBlock(run, fresh), ...chatHistoryBlock(fresh ? chatHistoryPath : null, "leader")];
+    const lines = [...objectiveBlock(run, fresh), ...chatHistoryBlock(fresh ? chatHistoryPath : null)];
     if (finished.length > 0) {
         lines.push("## 已结束的步骤", "");
         for (const { step, memberName } of finished) {
             lines.push(handoffStepLine({ ...step, memberName }));
         }
-        if (handoffPath) {
-            lines.push("", `这些步骤的报告全文汇总在交接文件：${handoffPath}`, "先读这个文件再决定下一步；不要凭标题猜成员做了什么，也不要让他们把报告复述进消息里。");
-        }
+        if (handoffPath)
+            lines.push("", `${HANDOFF_LABEL}：${handoffPath}`);
         lines.push("");
     }
     if (userNote?.trim())
         lines.push("## 用户补充", userNote.trim(), "");
-    lines.push("## 本轮要求", `把下一步决定写成 JSON 写入：${reportPath}`);
-    return { system: leaderSystemPrompt(run), message: lines.join("\n") };
+    lines.push(reportLine(reportPath));
+    return { system: leaderSystemPrompt(run, resolveModel), message: lines.join("\n") };
 }
-export function buildLeaderFormatRetryPrompt(run, error, reportPath, fresh, chatHistoryPath) {
+export function buildLeaderFormatRetryPrompt(run, error, reportPath, fresh, chatHistoryPath, resolveModel) {
     return {
-        system: leaderSystemPrompt(run),
+        system: leaderSystemPrompt(run, resolveModel),
         message: [
             ...objectiveBlock(run, fresh),
-            ...chatHistoryBlock(fresh ? chatHistoryPath : null, "leader"),
+            ...chatHistoryBlock(fresh ? chatHistoryPath : null),
             `上次的回复没能解析：${error}`,
             "",
-            "## 本轮要求",
-            `请严格按上面的 JSON 格式重新写入：${reportPath}`,
+            reportLine(reportPath),
         ].join("\n"),
     };
 }
@@ -307,18 +337,18 @@ export function buildMemberPrompt(run, step, member, fresh, upstream, chatHistor
     const lines = [
         ...objectiveBlock(run, fresh),
         // 续跑上下文只在新建的成员会话里补一次：成员这一轮以前的信息都在文件里。
-        ...chatHistoryBlock(fresh ? chatHistoryPath : null, "member"),
+        ...chatHistoryBlock(fresh ? chatHistoryPath : null),
         `## 本步骤：${step.title}`,
         step.instructions,
         "",
     ];
     if (upstream && upstream.steps.length > 0) {
-        lines.push("## 上游交接（动手前先读文件）", "");
+        lines.push("## 上游交接", "");
         for (const item of upstream.steps)
             lines.push(handoffStepLine(item));
-        lines.push("", `上游报告全文：${upstream.handoffPath}`, "先读这个文件，再开始本步骤；不要猜上游做了什么，也不要重复劳动。", "");
+        lines.push("", `${HANDOFF_LABEL}：${upstream.handoffPath}`, "");
     }
-    lines.push("## 报告", `写入文件：${step.reportPath}`);
+    lines.push(reportLine(step.reportPath));
     return { system: memberSystemPrompt(run, member), message: lines.join("\n") };
 }
 /** 从 start 处的 `{` 找到配对的 `}`（跳过字符串里的括号）。 */

package/dist/ai-team-runner.d.ts

@@ -1,6 +1,6 @@
 import { type AgentDispatchDeps } from "./agent-dispatch.js";
 import { type ModelCatalogView } from "./ai-team-availability.js";
-import { type AiTeamRun, type AiTeamRunDetail, type AiTeamRunSummary } from "./ai-team-types.js";
+import { type AiTeamLiveStep, type AiTeamLiveUpdate, type AiTeamRun, type AiTeamRunDetail, type AiTeamRunSummary } from "./ai-team-types.js";
 import type { SessionRegistry } from "./session-registry.js";
 import type { WandStorage } from "./storage.js";
 import type { WandTask, WandTaskAgent } from "./task-types.js";
@@ -41,12 +41,19 @@ export interface AiTeamRunnerOptions {
     resolveCwd: (task: WandTask) => string;
     ops: AiTeamSessionOps;
     notify?: (run: AiTeamRun) => void;
+    /** 运行中步骤的 live 文本推送（§4.9）：去抖后每 500ms 至多一次，stepId+text+omittedChars+state 全同不重复推。 */
+    notifyLive?: (update: AiTeamLiveUpdate) => void;
     now?: () => number;
     /**
      * 某 provider 已发现的模型清单（§3.4 model-unknown 事前比对）。目录未就绪 / 清单为空时
      * 返回空值即可，判定方向是「拿不准就放行」。
      */
     models?: (provider: WandTaskAgent["provider"]) => ModelCatalogView;
+    /**
+     * 该 provider 服务端配置的默认模型（拿不到返回空串）。只用于提示词里的成员名单：
+     * `default` 哨兵不是模型名，写真正会用的那个。
+     */
+    defaultModelOf?: (provider: WandTaskAgent["provider"]) => string;
 }
 export declare function createAiTeamSessionOps(deps: AgentDispatchDeps & {
     sessions: SessionRegistry;
@@ -55,7 +62,9 @@ export declare function createAiTeamChatOps(deps: AgentDispatchDeps): AiTeamChat
 export declare function createAiTeamRunner(deps: AgentDispatchDeps & {
     sessions: SessionRegistry;
     notify?: (run: AiTeamRun) => void;
+    notifyLive?: (update: AiTeamLiveUpdate) => void;
     models?: (provider: WandTaskAgent["provider"]) => ModelCatalogView;
+    defaultModelOf?: (provider: WandTaskAgent["provider"]) => string;
 }): AiTeamRunner;
 /** 遮蔽参照目录：家目录与激活配置目录（含 `/tmp/wand-dev` 这类隔离路径，按传入处理）。 */
 export interface RedactionDirs {
@@ -79,10 +88,16 @@ export declare class AiTeamRunner {
     private readonly chat?;
     private readonly resolveCwd;
     private readonly notifyListener?;
+    private readonly notifyLiveListener?;
     private readonly modelsOf?;
+    private readonly defaultModelOf?;
     private readonly now;
     private readonly chains;
     private readonly outputTimers;
+    /** live 推送的去抖计时器，按 runId 计（§4.9）。 */
+    private readonly liveTimers;
+    /** 上次推出去的 live 列表指纹（§4.9）：stepId + text + omittedChars + state 全同就不重复推。 */
+    private readonly lastLiveKey;
     private readonly recheckTimers;
     /** 已经确定「不降级、按既有路径记 failed」的步骤，防止 finishStep 再判一次形成回环。 */
     private readonly noDegrade;
@@ -90,6 +105,8 @@ export declare class AiTeamRunner {
     /** 脱敏参照目录只算一次：os.homedir() 读 env，configDir 随 storage 定，运行期不变。 */
     private redactionDirsValue;
     constructor(options: AiTeamRunnerOptions);
+    /** 提示词里的模型名解析器：`default` 哨兵交给服务端配置的默认模型。 */
+    private readonly defaultModelName;
     /** 本 runner 的遮蔽参照目录（§4.5）。 */
     private get redactionDirs();
     /** 只脱敏、不改长度语义（用于本来就不截断的文案）。 */
@@ -112,6 +129,8 @@ export declare class AiTeamRunner {
         echo?: boolean;
     }): Promise<AiTeamRunDetail>;
     continueRun(runId: string, extraSteps: number): Promise<AiTeamRunDetail>;
+    /** 已有运行的上限独立持久化；修改团队定义后，下次续跑至少采用新的团队上限。 */
+    private extendStepLimit;
     completeStep(runId: string, stepId: string, report: string): Promise<AiTeamRunDetail>;
     stop(runId: string): Promise<AiTeamRunDetail>;
     /**
@@ -121,6 +140,17 @@ export declare class AiTeamRunner {
     chatInput(sessionId: string, text: string): Promise<void>;
     detail(runId: string): AiTeamRunDetail;
     listForTask(taskId: string): AiTeamRun[];
+    /**
+     * 此刻正在干活的步骤的实时文本（§4.9）。只覆盖 running 且有会话的步骤，按 seq 升序；
+     * 快照拿不到的步骤跳过而不抛。run 不存在时与 detail() 同口径抛错。
+     */
+    live(runId: string): AiTeamLiveStep[];
+    private liveSteps;
+    private liveStep;
+    /** 挂一次 run 级 live 去抖：同一 run 每 500ms 至多算一遍、推一次，与 evaluate 的计时器互不干扰。 */
+    private scheduleLivePush;
+    /** 推一次 live 列表（§4.9）；指纹（stepId + text + omittedChars + state）没变就不重复推，推送失败只忽略。 */
+    private pushLive;
     /** 团队页的运行记录；teamId 为空时列出所有团队（侧边栏计数用）。 */
     listRuns(filter: {
         teamId?: string;
@@ -131,7 +161,12 @@ export declare class AiTeamRunner {
     ingest(event: ProcessEvent): void;
     /** 服务启动时调用：把重启前未结束的运行接回来，并开始兜底巡检。 */
     reconcile(): void;
-    /** 兜底巡检：PTY 成员写完报告后可能不再产生事件。 */
+    /**
+     * 兜底巡检：PTY 成员写完报告后可能不再产生事件。
+     * 顺带对每个 run 强制对账一次 live（§4.9）：registry 内部状态静默翻转时一条事件都不会进来，
+     * 状态芯片只能等客户端下一次重拉；这里在同一串里重算列表走 pushLive，指纹变了才推，
+     * 没变就什么都不发。巡检间隔与 evaluate 行为都不动。
+     */
     startSweep(): void;
     dispose(): void;
     /** 等当前排队的所有操作跑完（测试用）。 */
@@ -142,8 +177,10 @@ export declare class AiTeamRunner {
     private evaluate;
     private scheduleRecheck;
     private stepOutcome;
-    /** proceed=false 时只记结果不推进，由调用方在记完一批之后统一 advance。 */
+    /** 步骤落地后补推一次 live（§4.9）：让卡片收尾，列表可能已空。内部抛错时不推。 */
     private finishStep;
+    /** proceed=false 时只记结果不推进，由调用方在记完一批之后统一 advance。 */
+    private finishStepCore;
     /**
      * 派出所有已就绪的成员步骤：依赖都已完成、且该成员手上没有活。不同成员并行，同一成员串行。
      * 有成员失败、队列清空或依赖再也满足不了时，等在跑的都结束后交回 Leader。