@co0ontty/wand 4.76.0 → 4.77.0-beta.g7fb0b70

package/dist/ai-team-prompts.js

@@ -0,0 +1,435 @@
+import { memberAgents } from "./ai-team-types.js";
+export const AI_TEAM_REPORT_DIR = ".wand-team";
+export const AI_TEAM_MAX_ASSIGN_STEPS = 5;
+const MESSAGE_MAX = 2000;
+const TITLE_MAX = 80;
+const INSTRUCTIONS_MAX = 8000;
+/**
+ * 团队这一轮要做的事。
+ * 指派框 / 群聊里刚输入的文字就是本轮任务，不再把任务卡上的旧描述静默拼进去。
+ * 没有单独输入时（创建任务后立刻交给团队）才用标题 + 描述。
+ */
+export function buildAiTeamObjective(task, note) {
+    const assignment = note?.trim() ?? "";
+    if (assignment) {
+        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") || "完成这张任务";
+}
+export function leaderOf(team) {
+    return team.members.find((member) => member.isLeader) ?? team.members[0];
+}
+export function workersOf(team) {
+    return team.members.filter((member) => !member.isLeader);
+}
+/** 每步的约定报告文件（相对 cwd）。所有 CLI 都能写文件，因此是通用的交接方式。 */
+export function aiTeamReportPath(runId, seq, kind, memberId) {
+    const name = kind === "leader" ? `${seq}-leader.json` : `${seq}-${memberId}.md`;
+    return `${AI_TEAM_REPORT_DIR}/${runId}/${name}`;
+}
+/**
+ * 交接文件（相对 cwd）：上一批步骤的报告全文汇总，服务端在派发前写好，
+ * 下一步的提示词只给这条路径，让执行者自己去读，不再把报告贴进提示词。
+ */
+export function aiTeamHandoffPath(runId, seq, kind) {
+    return `${AI_TEAM_REPORT_DIR}/${runId}/handoff-${seq}-${kind}.md`;
+}
+/**
+ * 群聊续跑的上下文文件（相对 cwd）：用户在同一个群聊里接着说话时，服务端把之前几轮的
+ * 步骤摘要与群聊原文写在这里，新一轮的负责人与成员先读它再动手，不从零重来。
+ * 文件名由运行 id 决定，所以在库里不用额外记一列；「文件在不在」就是「是不是续跑」。
+ */
+export function aiTeamChatHistoryPath(runId) {
+    return `${AI_TEAM_REPORT_DIR}/${runId}/chat-history.md`;
+}
+const STEP_STATUS_LABEL = {
+    queued: "排队",
+    running: "进行中",
+    done: "完成",
+    failed: "失败",
+    skipped: "已跳过",
+};
+const RUN_STATUS_LABEL = {
+    running: "进行中",
+    awaiting_approval: "等你批准计划",
+    waiting_user: "等你回复",
+    done: "已完成",
+    failed: "失败",
+    stopped: "已停止",
+};
+/** 交接文件正文（Markdown）。纯函数，便于单测。 */
+export function renderHandoffFile(entries, generatedAt) {
+    const lines = [
+        "# 上游交接",
+        "",
+        `> 生成时间：${generatedAt}。下面是上游步骤的原始报告，动手前请读完与本次相关的部分。`,
+        "",
+    ];
+    for (const entry of entries) {
+        lines.push(`## 第${entry.seq}步 · ${entry.memberName} · ${entry.title} · ${STEP_STATUS_LABEL[entry.status]}`);
+        lines.push(`报告文件：${entry.reportPath}`, "", entry.report.trim() || "（没有报告）", "");
+    }
+    return lines.join("\n");
+}
+/** 提示词里只列一行元信息；正文在交接文件里，避免把长报告整段塞进上下文。 */
+function handoffStepLine(step) {
+    return `- 第${step.seq}步 · ${step.memberName} · ${step.title} · ${STEP_STATUS_LABEL[step.status]} · 报告文件：${step.reportPath}`;
+}
+/** 上下文文件里单条发言最多占的字节；整个文件另有总预算。 */
+const CHAT_HISTORY_MAX_BYTES = 64 * 1024;
+function byteLength(text) {
+    return Buffer.byteLength(text, "utf8");
+}
+function historyTurnSpeaker(turn) {
+    if (turn.role === "user")
+        return "用户";
+    if (!turn.author)
+        return "团队";
+    return turn.author.leader ? `${turn.author.name}（负责人）` : turn.author.name;
+}
+/** 一条群聊发言；提示行（notice）压成引用行，没有文字内容返回 null。 */
+function renderHistoryTurn(turn) {
+    const text = turn.content.map((block) => (block.type === "text" ? block.text : "")).join("\n").trim();
+    if (!text)
+        return null;
+    return turn.notice ? `> ${historyTurnSpeaker(turn)}：${text}` : `**${historyTurnSpeaker(turn)}**\n${text}`;
+}
+/** 从最新往回取到预算上限；一条都放不下时至少留最后一条，否则续跑就没有上下文可读。 */
+function tailWithinBudget(blocks, budget) {
+    let used = 0;
+    let start = blocks.length;
+    while (start > 0) {
+        const size = byteLength(blocks[start - 1]) + 2;
+        if (used + size > budget)
+            break;
+        used += size;
+        start -= 1;
+    }
+    if (start === blocks.length && blocks.length > 0)
+        start = blocks.length - 1;
+    return blocks.slice(start);
+}
+/**
+ * 群聊续跑的交接文件（Markdown，纯函数便于单测）：先列之前几轮的步骤摘要（含上一轮没做完的），
+ * 再给群聊原文；原文只留最近的这一段，超预算时从最早处丢并注明。
+ */
+export function renderChatHistoryFile(input) {
+    const lines = [
+        "# 本群聊之前的记录",
+        "",
+        `> 生成时间：${input.generatedAt}。用户在这个群聊里接着提了新要求，动手前先读完这份记录。`,
+        "> 已经完成的部分不要重做；上一轮没做完的步骤见下面的运行摘要，报告正文见群聊原文。",
+        "",
+    ];
+    if (input.runs.length > 0) {
+        lines.push("## 之前几轮运行", "");
+        for (const run of input.runs) {
+            lines.push(`- 状态：${RUN_STATUS_LABEL[run.status]}`);
+            for (const step of run.steps) {
+                lines.push(`  - 第${step.seq}步 · ${step.memberName} · ${step.title} · ${STEP_STATUS_LABEL[step.status]}`);
+            }
+        }
+        lines.push("");
+    }
+    const head = `${lines.join("\n")}\n## 群聊原文\n\n`;
+    // 预算只看群聊原文这一段；摘要与截断说明不参与取舍。
+    const budget = Math.max(0, (input.maxBytes ?? CHAT_HISTORY_MAX_BYTES) - byteLength(head) - 64);
+    const blocks = input.turns.map(renderHistoryTurn).filter((block) => block !== null);
+    const kept = tailWithinBudget(blocks, budget);
+    const dropped = blocks.length - kept.length;
+    return [
+        head.trimEnd(),
+        dropped > 0 ? `> （更早的 ${dropped} 条发言已省略）` : "",
+        ...kept,
+        "",
+    ].filter((part) => part !== "").join("\n\n");
+}
+/** 角色中文标签；any / 缺省不显示。 */
+const TEAM_ROLE_LABELS = {
+    plan: "制定计划",
+    work: "干活实现",
+    verify: "验收测试",
+};
+function memberLine(member) {
+    // 只渲染首选候选（§3.6）；备用候选不进提示词，降级由系统处理。
+    const preferred = memberAgents(member)[0] ?? member.agent;
+    const model = preferred.model === "default" ? "默认模型" : 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}`];
+    if (role)
+        parts.push(`角色: ${role}`);
+    parts.push(`CLI: ${preferred.provider}/${model}/${preferred.thinkingEffort}`, `职责: ${duty}`);
+    return `- ${parts.join(" | ")}`;
+}
+function leaderReplyFormat() {
+    return [
+        "## 回复方式（必须遵守）",
+        "每轮消息都会给出本次的报告文件路径；把决定写成 JSON 写入该文件，写完简短回复「已写入」。",
+        "格式三选一：",
+        '{"action":"assign","message":"给用户看的一句话说明","steps":[{"member":"成员 id","title":"简短标题","instructions":"具体要做什么、做到什么程度"}]}',
+        '{"action":"ask","message":"要问用户的问题"}',
+        '{"action":"finish","message":"最终总结：完成了什么、改了哪些文件、验收结论、遗留问题"}',
+        "",
+        "steps 里 `after` 写这一步要等哪几步完成（写本次 steps 内的序号，从 1 开始）：",
+        "- 省略 after：等上一步完成后开始（顺序执行）；",
+        "- \"after\": []：立刻开始，可以和别的成员并行；",
+        "- \"after\": [1, 2]：等第 1、2 步都做完再开始。",
+        "",
+        "instructions 的写法要求：",
+        "- 实现步骤的 instructions 必须列出允许改动的文件/目录范围；",
+        "- 验收步骤的 instructions 必须以「验收标准」清单收尾。",
+    ];
+}
+function teamInstructions(team) {
+    const text = team.instructions?.trim();
+    return text ? ["", "## 协作指令", text] : [];
+}
+/** 目标与用户补充都是用户原话（常带口述笔误），别按字面较真。 */
+const OBJECTIVE_INTENT_NOTE = "目标与用户补充都是用户原话，可能带口述笔误（例如把 CLI 写成 ci），按用户意图理解，不要照字面复述。";
+/**
+ * 接着同一个群聊跑的那一轮：负责人与成员先读上下文文件再动手。
+ * 负责人还要据此避免重做已经完成的步骤；成员只需在已有改动上继续。
+ */
+function chatHistoryBlock(path, audience) {
+    if (!path)
+        return [];
+    const shared = `用户是在这个群聊里接着提要求，之前几轮的步骤摘要与群聊原文在：${path}`;
+    return audience === "leader"
+        ? [
+            "## 接着这个群聊之前的几轮（动手前先读文件）",
+            shared,
+            "先读这个文件再安排：已经做完的不要重做，上一轮没做完的接着做；不要凭标题猜成员做过什么，也不要让他们复述历史。",
+            "",
+        ]
+        : [
+            "## 本群聊历史（动手前先读文件）",
+            shared,
+            "先读这个文件，在已有改动的基础上继续；已经完成的部分不要重做。",
+            "",
+        ];
+}
+function leaderSystemPrompt(run) {
+    const leader = leaderOf(run.team);
+    return [
+        `你是 AI 团队「${run.team.name}」的负责人（${leader.name}）。`,
+        `你的职责：${leader.duty.trim() || "拆分任务、派工、根据报告决定下一步。"}`,
+        "",
+        "## 成员（只能把工作派给下列成员；id 必须原样使用）",
+        "成员的名单行只列首选执行配置；执行配置由系统按候选顺序自动降级，你只按成员能力分派，不操心模型可用性。",
+        ...workersOf(run.team).map(memberLine),
+        ...teamInstructions(run.team),
+        "",
+        "## 工作方式",
+        "- 你不直接改代码：你负责拆分任务、派工，并根据成员报告决定下一步。",
+        `- 每次只安排接下来要做的几步（1–${AI_TEAM_MAX_ASSIGN_STEPS} 步）。互不依赖的工作派给不同成员可以并行；所有在跑的步骤结束后，我会把报告交回给你。`,
+        "- 并行成员共用同一个工作目录，不要让两个人同时改同一批文件。",
+        "- 实现与验收交给不同成员，不要让同一个成员验收自己的工作。",
+        "- 派工优先按角色：制定计划给 plan 成员，实现给 work 成员，验收给 verify 成员；没标角色的成员视为 any。",
+        "- 同一成员同一时间只有一个步骤；互不相干的步骤并行派出，有先后关系的用 after 声明。",
+        "- 需要用户拍板时就提问，不要猜。",
+        `- ${OBJECTIVE_INTENT_NOTE}`,
+        "",
+        ...leaderReplyFormat(),
+    ].join("\n");
+}
+function memberSystemPrompt(run, member) {
+    return [
+        `你是 AI 团队「${run.team.name}」的成员（${member.name}）。`,
+        `你的职责：${member.duty.trim() || "（未填写）"}`,
+        ...teamInstructions(run.team),
+        "",
+        "## 工作方式",
+        "- 只做本轮消息里指派给你的这一步，不要顺手改别的。",
+        "- 不要 git commit / push。",
+        "- 你的发言会以群聊气泡出现，署名是你的名字；报告仍写进报告文件。",
+        "",
+        "## 报告约定",
+        "每轮消息都会给出本次的报告文件路径；完成后把报告写进该文件（Markdown）：",
+        "第一行写 `状态: 完成`、`状态: 受阻` 或 `状态: 失败`，然后写做了什么、改了哪些文件、怎么验证的、还有什么问题。",
+    ].join("\n");
+}
+/** 会话是新建的时候才需要补目标：老会话的上下文里已经有目标了。 */
+function objectiveBlock(run, fresh) {
+    // 标签内联而不是单独的 `## 团队目标` 行：团队消息也会被会话标题 / 迭代提示词记录取首行，
+    // 单独一行的话标题会退化成「团队目标」这个空壳。
+    return fresh ? [`团队目标：${run.objective}`, ""] : [];
+}
+/** `chatHistoryPath` 有值时说明这一轮是同一个群聊的续跑（见 `aiTeamChatHistoryPath`）。 */
+export function buildLeaderKickoffPrompt(run, reportPath, fresh, chatHistoryPath) {
+    return {
+        system: leaderSystemPrompt(run),
+        message: [
+            ...objectiveBlock(run, fresh),
+            ...chatHistoryBlock(chatHistoryPath, "leader"),
+            "## 本轮要求",
+            `把计划决策写成 JSON 写入：${reportPath}`,
+        ].join("\n"),
+    };
+}
+export function buildLeaderFollowupPrompt(run, finished, reportPath, userNote, fresh, handoffPath, chatHistoryPath) {
+    // 续跑上下文只在新建的负责人会话里补一次：会话复用的时候，kickoff 那一轮已经给过路径。
+    const lines = [...objectiveBlock(run, fresh), ...chatHistoryBlock(fresh ? chatHistoryPath : null, "leader")];
+    if (finished.length > 0) {
+        lines.push("## 已结束的步骤", "");
+        for (const { step, memberName } of finished) {
+            lines.push(handoffStepLine({ ...step, memberName }));
+        }
+        if (handoffPath) {
+            lines.push("", `这些步骤的报告全文汇总在交接文件：${handoffPath}`, "先读这个文件再决定下一步；不要凭标题猜成员做了什么，也不要让他们把报告复述进消息里。");
+        }
+        lines.push("");
+    }
+    if (userNote?.trim())
+        lines.push("## 用户补充", userNote.trim(), "");
+    lines.push("## 本轮要求", `把下一步决定写成 JSON 写入：${reportPath}`);
+    return { system: leaderSystemPrompt(run), message: lines.join("\n") };
+}
+export function buildLeaderFormatRetryPrompt(run, error, reportPath, fresh, chatHistoryPath) {
+    return {
+        system: leaderSystemPrompt(run),
+        message: [
+            ...objectiveBlock(run, fresh),
+            ...chatHistoryBlock(fresh ? chatHistoryPath : null, "leader"),
+            `上次的回复没能解析：${error}`,
+            "",
+            "## 本轮要求",
+            `请严格按上面的 JSON 格式重新写入：${reportPath}`,
+        ].join("\n"),
+    };
+}
+/**
+ * fresh=false 时成员会话已有上下文，省掉目标段落。`upstream` 有值时只给交接文件路径与
+ * 各步报告文件，不在提示词里复述上游报告正文（上一个成员的信息走文件交接）。
+ */
+export function buildMemberPrompt(run, step, member, fresh, upstream, chatHistoryPath) {
+    const lines = [
+        ...objectiveBlock(run, fresh),
+        // 续跑上下文只在新建的成员会话里补一次：成员这一轮以前的信息都在文件里。
+        ...chatHistoryBlock(fresh ? chatHistoryPath : null, "member"),
+        `## 本步骤：${step.title}`,
+        step.instructions,
+        "",
+    ];
+    if (upstream && upstream.steps.length > 0) {
+        lines.push("## 上游交接（动手前先读文件）", "");
+        for (const item of upstream.steps)
+            lines.push(handoffStepLine(item));
+        lines.push("", `上游报告全文：${upstream.handoffPath}`, "先读这个文件，再开始本步骤；不要猜上游做了什么，也不要重复劳动。", "");
+    }
+    lines.push("## 报告", `写入文件：${step.reportPath}`);
+    return { system: memberSystemPrompt(run, member), message: lines.join("\n") };
+}
+/** 从 start 处的 `{` 找到配对的 `}`（跳过字符串里的括号）。 */
+function balancedObjectEnd(text, start) {
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let index = start; index < text.length; index += 1) {
+        const char = text[index];
+        if (inString) {
+            if (escaped)
+                escaped = false;
+            else if (char === "\\")
+                escaped = true;
+            else if (char === "\"")
+                inString = false;
+            continue;
+        }
+        if (char === "\"")
+            inString = true;
+        else if (char === "{")
+            depth += 1;
+        else if (char === "}") {
+            depth -= 1;
+            if (depth === 0)
+                return index;
+        }
+    }
+    return -1;
+}
+function extractDecisionObject(text) {
+    for (let start = text.indexOf("{"); start >= 0; start = text.indexOf("{", start + 1)) {
+        const end = balancedObjectEnd(text, start);
+        if (end < 0)
+            return null;
+        try {
+            const value = JSON.parse(text.slice(start, end + 1));
+            if (value && typeof value === "object" && !Array.isArray(value) && "action" in value) {
+                return value;
+            }
+        }
+        catch {
+            // 继续尝试下一个 `{`：前面可能是正文里的花括号。
+        }
+    }
+    return null;
+}
+function resolveMember(team, ref) {
+    if (typeof ref !== "string")
+        return null;
+    const key = ref.trim().toLowerCase();
+    if (!key)
+        return null;
+    const workers = workersOf(team);
+    return workers.find((member) => member.id.toLowerCase() === key)
+        ?? workers.find((member) => member.name.trim().toLowerCase() === key)
+        ?? null;
+}
+export function parseLeaderDecision(text, team) {
+    const raw = extractDecisionObject(text);
+    if (!raw)
+        return { ok: false, error: "没有找到包含 action 字段的 JSON 对象。" };
+    const action = raw.action;
+    if (typeof raw.message !== "string")
+        return { ok: false, error: "message 必须是字符串。" };
+    const message = raw.message.trim().slice(0, MESSAGE_MAX);
+    if (action === "ask" || action === "finish") {
+        if (!message)
+            return { ok: false, error: "message 不能为空。" };
+        return { ok: true, decision: { action, message } };
+    }
+    if (action !== "assign")
+        return { ok: false, error: "action 只能是 assign / ask / finish。" };
+    if (!Array.isArray(raw.steps) || raw.steps.length === 0) {
+        return { ok: false, error: "assign 需要至少一个 steps 项。" };
+    }
+    if (raw.steps.length > AI_TEAM_MAX_ASSIGN_STEPS) {
+        return { ok: false, error: `一次最多安排 ${AI_TEAM_MAX_ASSIGN_STEPS} 步。` };
+    }
+    const steps = [];
+    for (const [index, item] of raw.steps.entries()) {
+        const entry = item && typeof item === "object" ? item : {};
+        const member = resolveMember(team, entry.member);
+        if (!member) {
+            return { ok: false, error: `第 ${index + 1} 步的 member「${String(entry.member ?? "")}」不是可派工的成员 id。` };
+        }
+        const title = typeof entry.title === "string" ? entry.title.trim().slice(0, TITLE_MAX) : "";
+        const instructions = typeof entry.instructions === "string" ? entry.instructions.trim().slice(0, INSTRUCTIONS_MAX) : "";
+        if (!title)
+            return { ok: false, error: `第 ${index + 1} 步缺少 title。` };
+        if (!instructions)
+            return { ok: false, error: `第 ${index + 1} 步缺少 instructions。` };
+        let after;
+        if (entry.after === undefined || entry.after === null) {
+            after = index > 0 ? [index - 1] : [];
+        }
+        else if (Array.isArray(entry.after)) {
+            after = [];
+            for (const ref of entry.after) {
+                const position = Number(ref);
+                if (!Number.isInteger(position) || position < 1 || position > index) {
+                    return { ok: false, error: `第 ${index + 1} 步的 after 只能引用它前面的步骤序号（1–${index}）。` };
+                }
+                if (!after.includes(position - 1))
+                    after.push(position - 1);
+            }
+        }
+        else {
+            return { ok: false, error: `第 ${index + 1} 步的 after 必须是数组。` };
+        }
+        steps.push({ memberId: member.id, title, instructions, after });
+    }
+    return { ok: true, decision: { action: "assign", message, steps } };
+}

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

@@ -0,0 +1,241 @@
+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 { SessionRegistry } from "./session-registry.js";
+import type { WandStorage } from "./storage.js";
+import type { WandTask, WandTaskAgent } from "./task-types.js";
+import type { ConversationTurn, ProcessEvent, SessionSnapshot } from "./types.js";
+/** 群聊会话的 automationId 前缀；后面接运行 id。 */
+export declare const AI_TEAM_CHAT_PREFIX = "ai-team-chat:";
+/** 用户可见的冲突错误（路由转 409）。 */
+export declare class AiTeamConflictError extends Error {
+}
+/** 团队调度需要的会话操作。默认实现走 agent-dispatch；测试可整体替换。 */
+export interface AiTeamSessionOps {
+    open(input: {
+        task: WandTask;
+        agent: WandTaskAgent;
+        prompt: string;
+        automationId: string;
+        /** 角色与规则；走 provider 的系统提示通道，不拼进 prompt。 */
+        systemPrompt?: string;
+    }): Promise<string>;
+    send(sessionId: string, text: string): Promise<void>;
+    stop(sessionId: string): void;
+    snapshot(sessionId: string): SessionSnapshot | null;
+    ownerOf(sessionId: string): "structured" | "pty" | "storage" | null;
+}
+/** 群聊：一次运行一个转发会话，团队的决定、派工和报告都以成员身份发在里面。 */
+export interface AiTeamChatOps {
+    open(input: {
+        task: WandTask;
+        run: AiTeamRun;
+        title: string;
+    }): string;
+    post(sessionId: string, turns: ConversationTurn[]): void;
+}
+export interface AiTeamRunnerOptions {
+    storage: WandStorage;
+    chat?: AiTeamChatOps;
+    /** 解析任务卡的执行目录；默认走 agent-dispatch 的规则。 */
+    resolveCwd: (task: WandTask) => string;
+    ops: AiTeamSessionOps;
+    notify?: (run: AiTeamRun) => void;
+    now?: () => number;
+    /**
+     * 某 provider 已发现的模型清单（§3.4 model-unknown 事前比对）。目录未就绪 / 清单为空时
+     * 返回空值即可，判定方向是「拿不准就放行」。
+     */
+    models?: (provider: WandTaskAgent["provider"]) => ModelCatalogView;
+}
+export declare function createAiTeamSessionOps(deps: AgentDispatchDeps & {
+    sessions: SessionRegistry;
+}): AiTeamSessionOps;
+export declare function createAiTeamChatOps(deps: AgentDispatchDeps): AiTeamChatOps | undefined;
+export declare function createAiTeamRunner(deps: AgentDispatchDeps & {
+    sessions: SessionRegistry;
+    notify?: (run: AiTeamRun) => void;
+    models?: (provider: WandTaskAgent["provider"]) => ModelCatalogView;
+}): AiTeamRunner;
+/** 遮蔽参照目录：家目录与激活配置目录（含 `/tmp/wand-dev` 这类隔离路径，按传入处理）。 */
+export interface RedactionDirs {
+    homeDir?: string;
+    configDir?: string;
+}
+/**
+ * 落库 / 进群聊前的脱敏（§4.5「全链路不写连接码 / token / home 路径」）。
+ * 纯函数、无 IO：目录由调用方传进来，同一个输入永远得到同一个输出，重复清洗结果不变。
+ * 顺序很关键：先把配置目录（在家目录下）整段换掉，再换家目录，否则 `~/.wand` 会漏半截。
+ * 方向是宁多勿漏：认不准的超长串一律隐藏，代价只是文案少一段可调试信息。
+ */
+export declare function redactAiTeamErrorText(text: string, dirs?: RedactionDirs): string;
+/**
+ * AI 团队调度器。状态全部在数据库里，会话事件驱动推进；同一运行的所有操作串行执行。
+ * 成员会话是普通 Wand 会话，服务端只负责传话：Leader 决定派谁做什么，成员交报告。
+ */
+export declare class AiTeamRunner {
+    private readonly storage;
+    private readonly ops;
+    private readonly chat?;
+    private readonly resolveCwd;
+    private readonly notifyListener?;
+    private readonly modelsOf?;
+    private readonly now;
+    private readonly chains;
+    private readonly outputTimers;
+    private readonly recheckTimers;
+    /** 已经确定「不降级、按既有路径记 failed」的步骤，防止 finishStep 再判一次形成回环。 */
+    private readonly noDegrade;
+    private sweepTimer;
+    /** 脱敏参照目录只算一次：os.homedir() 读 env，configDir 随 storage 定，运行期不变。 */
+    private redactionDirsValue;
+    constructor(options: AiTeamRunnerOptions);
+    /** 本 runner 的遮蔽参照目录（§4.5）。 */
+    private get redactionDirs();
+    /** 只脱敏、不改长度语义（用于本来就不截断的文案）。 */
+    private redact;
+    /** 先脱敏再头尾截断：截断会把中间的敏感串切出来，顺序不能反。 */
+    private cleanError;
+    start(input: {
+        teamId: string;
+        taskId: string;
+        note?: string;
+        chatSessionId?: string;
+    }): Promise<AiTeamRunDetail>;
+    approve(runId: string, options?: {
+        echo?: boolean;
+    }): Promise<AiTeamRunDetail>;
+    reject(runId: string, feedback: string, options?: {
+        echo?: boolean;
+    }): Promise<AiTeamRunDetail>;
+    reply(runId: string, text: string, options?: {
+        echo?: boolean;
+    }): Promise<AiTeamRunDetail>;
+    continueRun(runId: string, extraSteps: number): Promise<AiTeamRunDetail>;
+    completeStep(runId: string, stepId: string, report: string): Promise<AiTeamRunDetail>;
+    stop(runId: string): Promise<AiTeamRunDetail>;
+    /**
+     * 用户在群聊里说的话。等回复时转给负责人；等批准时「批准」类短语直接批准，其余当修改意见；
+     * 成员干活时先记下，负责人下一轮一起看到；运行已结束则接着开一轮新的。
+     */
+    chatInput(sessionId: string, text: string): Promise<void>;
+    detail(runId: string): AiTeamRunDetail;
+    listForTask(taskId: string): AiTeamRun[];
+    /** 团队页的运行记录；teamId 为空时列出所有团队（侧边栏计数用）。 */
+    listRuns(filter: {
+        teamId?: string;
+        activeOnly?: boolean;
+        limit?: number;
+    }): AiTeamRunSummary[];
+    /** 与 missions.ingest 并列调用。绝大多数事件与团队无关，必须廉价返回。 */
+    ingest(event: ProcessEvent): void;
+    /** 服务启动时调用：把重启前未结束的运行接回来，并开始兜底巡检。 */
+    reconcile(): void;
+    /** 兜底巡检：PTY 成员写完报告后可能不再产生事件。 */
+    startSweep(): void;
+    dispose(): void;
+    /** 等当前排队的所有操作跑完（测试用）。 */
+    idle(): Promise<void>;
+    private enqueue;
+    private act;
+    private requireStatus;
+    private evaluate;
+    private scheduleRecheck;
+    private stepOutcome;
+    /** proceed=false 时只记结果不推进，由调用方在记完一批之后统一 advance。 */
+    private finishStep;
+    /**
+     * 派出所有已就绪的成员步骤：依赖都已完成、且该成员手上没有活。不同成员并行，同一成员串行。
+     * 有成员失败、队列清空或依赖再也满足不了时，等在跑的都结束后交回 Leader。
+     */
+    private advance;
+    /** 开一轮 Leader：把上一轮 Leader 之后结束的成员报告交给他。 */
+    private startLeaderRound;
+    /** 一条交接条目：元信息 + 报告全文（全文只进交接文件，不进提示词）。 */
+    private handoffEntry;
+    /**
+     * 成员步骤的上游交接：把依赖步骤的报告写成一个交接文件，提示词只给路径。
+     * 没有依赖、或写文件失败时返回 null（提示词仍逐行列出上游报告文件）。
+     */
+    private memberUpstream;
+    /**
+     * 同一个群聊里接着开新运行时的续跑交接（§4.4 同一套文件交接）：把之前几轮的步骤摘要
+     * 与群聊原文写进 `.wand-team/<runId>/chat-history.md`，提示词只给路径。
+     * 不是续跑（没有群聊会话、之前没有运行、群聊也还是空的）返回 null，提示词就不带这一段。
+     */
+    private writeChatHistory;
+    /**
+     * 这次运行要接着的群聊上下文文件；文件不在（不是续跑、或写失败）就给 null。
+     * 续跑标记就落在文件本身，所以服务重启后同一路径依旧成立，不用额外存一列。
+     */
+    private chatHistoryFor;
+    /** 交接文件写到报告目录；失败只记日志，不阻断派发。 */
+    private writeHandoff;
+    private hasBudget;
+    private createLeaderStep;
+    /**
+     * 派出一个步骤：先把步骤标成 running 再发送；同一成员的活会话复用（上下文延续）。
+     * 提示词分两段：`system`（角色与规则）只在新建会话时交给系统提示通道，`message` 是本轮用户消息。
+     */
+    private dispatchStep;
+    /**
+     * 换候选 = 开新步（§3.4 五步），与 Leader 的格式重试同构。全程在调用方的 enqueue 链里；
+     * 只直接派出 A′，**不整轮 advance**（N1：advance 的 queued/byId/busyMembers 是进循环时的快照，
+     * 整轮调整会在同一栈里对同一步二次派发）。`proceed` 原样透传给 A′ 的 dispatchStep。
+     */
+    private degradeWorkStep;
+    /**
+     * 会话「起来又倒下」的启动期归因（§3.4 触发点 2）。判定核在 ai-team-availability，
+     * 这里只负责喂时钟、快照与报告产出；不满足降级条件返回 null，按既有路径记 failed。
+     */
+    private asyncStartupFailure;
+    /** run 级黑名单里这一层是谁封的、为什么封（§3.4 修正 B12 两层键值 + host-disabled 进程级）。 */
+    private blockedCandidate;
+    /** 黑名单从库里读（§3.4）：run 不存在或列里是脏值时退化成空黑名单。 */
+    private stateOf;
+    /** 每次黑名单变更立即落库，重启后已拉黑的候选与 strikes 计数都还在。 */
+    private saveState;
+    /** host-disabled 是进程级信号：本次运行该 kind 的候选全部不再尝试。 */
+    private disableHostKind;
+    /**
+     * 失败候选的黑名单记账（§3.4）：spawn-missing 封 provider、model-unknown 直接封五元组、
+     * startup-timeout 累计到 STARTUP_TIMEOUT_STRIKES 才封。runtime-failure 这类不计入，
+     * 一次写完一次落库。
+     */
+    private accountCandidateFailure;
+    /**
+     * 本步实际用的候选与累计跳过的候选（`dispatch_info_json`）；没有记录 = 首选、没跳过过任何候选。
+     * 读的是步骤行自己，重启后同一条恢复链继续从库里接着走。
+     */
+    private infoOf;
+    /** 该步实际使用的候选（§3.6 署名口径）：候选一律经 memberAgents 读，越界回退首选。 */
+    private actualAgent;
+    /**
+     * 运行停下来等用户时，用户可能刚在团队页换了成员的 CLI / 模型（比如额度用尽换一个）。
+     * 接着跑之前换成最新配置；成员被删了或没有负责人时保留原快照。
+     */
+    private refreshTeam;
+    /**
+     * 同一成员复用还活着的会话。比对基准是该成员**最近一步实际使用的候选**（§3.6），
+     * 降级之后不会因为「和首选不一致」而每步都另开会话；候选换了五元组就不复用。
+     */
+    private liveSessionFor;
+    private openChat;
+    private postTurn;
+    private postUser;
+    private postNotice;
+    /** 负责人的决定：说明 + 派工清单；等批准 / 等回复时告诉用户在群里怎么接话。 */
+    private postLeaderDecision;
+    /**
+     * 职责交叉只提示、不拦截（§3.3 修正 B13）：同一个成员既实现过又验收时，在群里提一句，
+     * 由用户决定是否让负责人调整。服务端不做任何职责硬校验，步骤照常派发。
+     */
+    private postVerifyOverlapNotices;
+    private member;
+    private nextSeq;
+    private setStatus;
+    private saveRun;
+    private saveStep;
+    private notify;
+    private iso;
+}