aws-runtime-bridge 1.9.79 → 1.9.81

package/package/acode/dist/sub-agent-manager.js

@@ -1,1159 +1,2 @@
-import { randomUUID } from "node:crypto";
-import { ACodeRuntime } from "./runtime.js";
-/** 已完成 entry 在内存中的保留时长（30 分钟），超时后清理释放内存 */
-const COMPLETED_ENTRY_TTL_MS = 30 * 60 * 1000;
-/**
- * pending 子 agent 超过该时长仍未翻成 running，视为僵尸。
- * pending 本应在 spawn 后数秒内翻转（runEntryToCompletion* 立即设置 running），
- * 若长时间保持 pending，说明 startWithRecheck 抛错被静默吞掉、或启动函数从未执行，
- * 必须回收，否则 URIs 会被 runtime.pendingMemorySubAgents 永久锁死、永不重试。
- */
-const SUBAGENT_PENDING_ZOMBIE_MS = 2 * 60 * 1000;
-/**
- * running 子 agent 超过该时长仍未到达终态，视为僵尸。
- * 正常 LLM 子任务即便较长也应有上界；卡死多因 runtime.start()/submit() 挂起
- * （如复用的父 MCP 连接异常、模型调用无响应），需回收以释放资源并解除锁。
- *
- * ★ 设为 12min（> SUBAGENT_SUBMIT_TIMEOUT_MS=10min）：
- *   - 子 agent 卡死时，submit() 10min 超时会先触发，给出明确的错误信息
- *     （如 "runtime.submit() turn=1 timed out after 600000ms"）
- *   - zombie 兜底覆盖 submit 内部无超时保护的步骤（如 hookBus.dispatch）
- *   - 之前 5min 比 submit 10min 更早触发，导致用户永远看不到真正的 submit 超时错误
- *   - task 工具显式调用的 sub-agent 不走此自动路径，不受影响
- */
-const SUBAGENT_RUNNING_ZOMBIE_MS = 12 * 60 * 1000;
-/**
- * store 写入超时兜底（毫秒）。
- * SubAgentStore.write 使用 writeChain 串行化所有文件写入，若前一个 write 卡住
- * （磁盘 IO 慢、tmp 文件 rename 卡住、文件系统问题等），后续所有 write 都会
- * 被永久阻塞，导致 sub-agent 卡在 store.updateStatus 处无法继续 start()。
- * 5s 超时足够覆盖正常文件 IO（通常 < 100ms），超时后放弃落盘（不影响内存态）。
- *
- * ★ 仅用于 running 态写入（非阻塞路径不需要超时）。
- *   终态写入走 persistFinalStatus 的指数退避重试，不再使用 withTimeout。
- */
-const STORE_WRITE_TIMEOUT_MS = 5_000;
-/**
- * 终态落盘的指数退避序列（毫秒）。
- *
- * 终态写入失败时按此序列重试，覆盖以下瞬时错误场景：
- *   - Windows fs.rename EPERM（reader 持有 fd，退避后释放即可成功）
- *   - writeChain 临时拥堵（前一个 write 慢，退避后队列消化）
- *   - 磁盘瞬时不可用
- *
- * 总耗时 ≈ 100+500+2000+8000 = 10.6s，远大于 EPERM 退避窗口和 writeChain 排队时长，
- * 同时不至过长影响 bridge 关闭时的 dispose 流程。
- */
-const PERSIST_BACKOFF_MS = [100, 500, 2_000, 8_000];
-/**
- * 子 agent runtime.start() 整体超时兜底（毫秒）。
- * start() 内部正常路径秒级完成（loadSkills/resolveProvider/filterMcp/fetchProfile/emitStatus），
- * 超过此时长基本可判定为卡死（如 hookBus.dispatch 卡住、fetchProfile 的 MCP 调用挂起）。
- * fetchProfilePrompt 内部已有 withTimeout，但其他步骤无保护，需外层兜底。
- */
-const SUBAGENT_START_TIMEOUT_MS = 60_000;
-/**
- * 子 agent runtime.submit() 整体超时兜底（毫秒）。
- * submit 内部 fetch 已有 provider.requestTimeoutMs 保护，但 hookBus.dispatch /
- * materializeImageContent / truncateConversationIfNeeded 等步骤无超时；
- * 主动压缩路径（performCompaction → summarizeConversationWithLLM）亦独立有 withTimeout。
- * 此 10min 兜底覆盖极端长 LLM 响应 + 多轮工具调用，超此时长视为整体卡死。
- */
-const SUBAGENT_SUBMIT_TIMEOUT_MS = 10 * 60 * 1000;
-/**
- * SubAgentManager：管理独立 ACodeRuntime 实例池。
- *
- * 核心职责：
- *   1. spawn 创建独立 ACodeRuntime 实例（避免父 agent 的 submitQueue 死锁）
- *   2. start 异步启动子 agent（不阻塞），awaitCompletion 显式等待完成
- *   3. abort 取消运行中的 sub-agent
- *   4. 维护父子关系映射（parentAgentId -> subIds）
- *   5. SSE 事件订阅（subscribe/unsubscribe）
- *   6. 状态持久化到 SubAgentStore
- *
- * 线程模型：单进程 Node.js，所有 ACodeRuntime 实例共享事件循环。
- *   非阻塞模式：spawn 后调 start 立即返回，主 agent 可继续工作；
- *   主 agent 通过 awaitCompletion 显式阻塞等待指定 sub-agent 数组完成。
- *
- * 重要：ACodeRuntime.submit() 返回 Promise<void>，assistant 文本通过
- *   "event" 上的 "assistant_delta" 事件传递，turn 结束时发出 "turn_complete"。
- *   因此 start 内部注册事件监听器累积输出文本，awaitCompletion 通过 Promise 等待。
- *
- * Entry 生命周期：
- *   - pending: spawn 后未 start
- *   - running: start 后运行中
- *   - completed/failed/cancelled: 终态，entry 保留在内存中 TTL=30min，
- *     供 list/get_status 查询；超时后从内存清理（store 仍持久化）
- */
-export class SubAgentManager {
-    constructor(opts) {
-        this.subAgents = new Map();
-        this.parentToSubs = new Map();
-        this.subscribers = new Map(); // subId 或 "*" -> subs
-        /** 已完成 entry 的清理定时器 */
-        this.cleanupTimer = null;
-        /**
-         * 终态通知队列：子 agent 到达终态时入队，takeCompletedSubAgents 消费。
-         * 供 poll_message 在 ACode 运行时层检测子 agent 完成事件。
-         */
-        this.completionQueue = [];
-        /**
-         * waitForAnyCompletion 的 resolve 回调，终态事件到达时调用。
-         * null 表示当前没有等待者。
-         */
-        this.completionWaiterResolve = null;
-        /**
-         * 正在执行的异步终态落盘 Promise 集合。
-         *
-         * 用于：
-         *   - 测试等待异步落盘完成后再读取 store 验证状态
-         *   - dispose 时确保所有落盘完成后再清理（避免文件句柄占用导致目录非空）
-         *
-         * persistFinalStatus 启动时入集，resolve/reject 后出集。
-         */
-        this.pendingPersists = new Set();
-        this.store = opts.store;
-        this.maxConcurrent = opts.maxConcurrent ?? 5;
-        // 启动定期清理已完成 entry 的定时器（每 5 分钟扫一次）
-        this.cleanupTimer = setInterval(() => {
-            this.cleanupCompletedEntries();
-            this.recoverZombieEntries();
-        }, 5 * 60 * 1000);
-        // 不阻止进程退出
-        if (this.cleanupTimer.unref)
-            this.cleanupTimer.unref();
-        // 启动时回收上次进程异常退出留下的僵尸记录（reconcileZombies 此前未被任何调用方触发）
-        void this.store.reconcileZombies().catch(() => { });
-    }
-    /** 创建 sub-agent（不立即运行；调 start 才执行） */
-    async spawn(opts) {
-        // 并发上限检查（pending + running 都算占用配额）
-        const activeCount = this.countByStatus(opts.parentAgentId, "running", "pending");
-        if (activeCount >= this.maxConcurrent) {
-            throw new Error(`concurrent sub-agent limit reached (${this.maxConcurrent}) for agent ${opts.parentAgentId}`);
-        }
-        const subId = `sub-${randomUUID()}`;
-        const startedAt = Date.now();
-        const abortController = new AbortController();
-        // 构造子 agent 的 config（继承父 agent 的 model/prompt，但独立 sessionId）
-        // 若父 agent 配置了 subAgentModel/subAgentEffort，则覆盖子 agent 的 model/effort
-        const childConfig = {
-            ...opts.parentConfig,
-            sessionId: subId,
-            workingDirectory: opts.workingDirectory,
-            agentId: `${opts.parentAgentId}__sub__${subId}`,
-            // sub-agent 不继承 initialPrompt（用 submit 触发）
-            initialPrompt: undefined,
-            // sub-agent 不允许再 spawn 自己的子 agent（禁止递归嵌套）
-            subAgentManager: undefined,
-            // ★ 注入 subagentType：runtime.start() 据此过滤内建写入工具。
-            //   explore 类型仅暴露只读工具（read_file/grep/symbols 等），
-            //   防止 explore 子 agent 改写主工作区文件，违背只读语义。
-            subagentType: opts.subagentType,
-            // Sub Agent 模型/强度覆盖：有值则覆盖继承的 model/effort
-            ...(opts.parentConfig.subAgentModel
-                ? { model: opts.parentConfig.subAgentModel }
-                : {}),
-            ...(opts.parentConfig.subAgentEffort
-                ? { effort: opts.parentConfig.subAgentEffort }
-                : {}),
-            // 子 agent 不再继承 subAgent 专用覆盖字段（防止孙 agent 二次覆盖）
-            subAgentModel: undefined,
-            subAgentEffort: undefined,
-        };
-        const runtime = new ACodeRuntime(childConfig);
-        const entry = {
-            subId,
-            parentAgentId: opts.parentAgentId,
-            parentSessionId: opts.parentSessionId,
-            subagentType: opts.subagentType,
-            description: opts.description,
-            prompt: opts.prompt,
-            status: "pending",
-            startedAt,
-            runtime,
-            abortController,
-            silent: opts.silent,
-            contextSnapshot: {
-                tokenUsage: { input: 0, output: 0 },
-                messageCount: 0,
-                updatedAt: new Date().toISOString(),
-            },
-            availableTools: [],
-        };
-        this.subAgents.set(subId, entry);
-        this.addToParentMap(opts.parentAgentId, subId);
-        // 持久化初始记录
-        const record = this.toRecord(entry);
-        await this.store.upsert(opts.parentAgentId, record);
-        // 监听 runtime 事件以更新 contextSnapshot
-        runtime.on("event", (event) => {
-            this.handleRuntimeEvent(subId, event);
-        });
-        this.emitEvent(subId, "spawned", {});
-        return subId;
-    }
-    /**
-     * 异步启动 sub-agent（不阻塞，立即返回）。
-     *
-     * 内部创建 completionPromise 供后续 awaitCompletion 等待。
-     * 启动后立即返回，主 agent 可继续做其他事。
-     *
-     * 同一 sub-agent 只能 start 一次；重复 start 抛错。
-     */
-    async start(subId) {
-        const entry = this.subAgents.get(subId);
-        if (!entry) {
-            throw new Error(`sub-agent not found: ${subId}`);
-        }
-        if (entry.status !== "pending") {
-            throw new Error(`sub-agent ${subId} cannot start from status: ${entry.status}`);
-        }
-        // 创建 completionPromise（在 finally 中 settle）
-        entry.completionPromise = new Promise((resolve, reject) => {
-            entry.completionResolve = resolve;
-            entry.completionReject = reject;
-        });
-        // 异步启动，不阻塞调用方
-        void this.runEntryToCompletion(entry).catch(() => {
-            // runEntryToCompletion 内部已处理异常并更新状态；
-            // 这里捕获防止 unhandled rejection
-        });
-    }
-    /**
-     * 带 recheck 循环的异步启动（不阻塞，立即返回）。
-     *
-     * 与 start 的区别：每轮 submit 完成后调用 recheck 回调查询服务端真实状态。
-     * 若 recheck 返回 { done: false, continueMessage }，将 continueMessage 作为
-     * 下一轮 submit 注入同一 sub-agent（保持上下文连续性），最多重试 maxRetries 次。
-     *
-     * 适用场景：memory 过期整理 / 文件变更更新 / 容量整理等需要系统级硬保证
-     * "确实完成"的场景，不依赖 LLM 自报结果。
-     */
-    async startWithRecheck(subId, recheck, maxRetries = 3) {
-        const entry = this.subAgents.get(subId);
-        if (!entry) {
-            throw new Error(`sub-agent not found: ${subId}`);
-        }
-        if (entry.status !== "pending") {
-            throw new Error(`sub-agent ${subId} cannot start from status: ${entry.status}`);
-        }
-        // 创建 completionPromise（在 finally 中 settle）
-        entry.completionPromise = new Promise((resolve, reject) => {
-            entry.completionResolve = resolve;
-            entry.completionReject = reject;
-        });
-        // 异步启动，不阻塞调用方
-        void this.runEntryToCompletionWithRecheck(entry, recheck, maxRetries).catch(() => {
-            // 内部已处理异常并更新状态；这里捕获防止 unhandled rejection
-        });
-    }
-    /**
-     * 阻塞等待指定 sub-agent 数组全部完成（completed/failed/cancelled）。
-     *
-     * - 已完成的立即 resolve
-     * - 未 start 的会先 start（自动启动）
-     * - 返回每个 sub-agent 的最终结果
-     *
-     * 注意：本方法不取消 sub-agent，仅等待。如需取消用 abort。
-     */
-    async awaitCompletion(subIds, timeoutMs = 0) {
-        if (subIds.length === 0)
-            return [];
-        const results = [];
-        // 对每个 subId 准备等待 Promise
-        const waitPromises = subIds.map(async (subId) => {
-            const entry = this.subAgents.get(subId);
-            if (!entry) {
-                // entry 已从内存清理，从 store 查
-                const record = await this.findRecordInStore(subId);
-                if (record) {
-                    results.push({
-                        subId,
-                        output: record.result ?? "",
-                        error: record.errorMessage,
-                        status: record.status,
-                    });
-                }
-                else {
-                    results.push({
-                        subId,
-                        output: "",
-                        error: `sub-agent not found: ${subId}`,
-                        status: "failed",
-                    });
-                }
-                return;
-            }
-            // 标记为 awaited：防止 enqueueCompletion 将终态通知推入 completionQueue
-            // （避免后续 poll_message 重复返回已被 await 消费的结果）
-            entry.awaited = true;
-            // 如果还在 pending，自动 start
-            if (entry.status === "pending") {
-                await this.start(subId);
-            }
-            // 等待 completionPromise（可能已被 start 创建）
-            const promise = entry.completionPromise ?? Promise.resolve({ output: "", error: "not started" });
-            try {
-                const result = await promise;
-                results.push({
-                    subId,
-                    output: result.output,
-                    error: result.error,
-                    status: entry.status,
-                });
-            }
-            catch (err) {
-                results.push({
-                    subId,
-                    output: "",
-                    error: err instanceof Error ? err.message : String(err),
-                    status: entry.status,
-                });
-            }
-        });
-        // 等待全部完成后，清理 completionQueue 中可能已存在的这些 subId 的通知
-        // （处理子 agent 在 awaited 标记设置前已完成入队的情况）
-        const subIdSet = new Set(subIds);
-        for (let i = this.completionQueue.length - 1; i >= 0; i--) {
-            if (subIdSet.has(this.completionQueue[i].subId)) {
-                this.completionQueue.splice(i, 1);
-            }
-        }
-        if (timeoutMs > 0) {
-            await Promise.race([
-                Promise.allSettled(waitPromises),
-                new Promise((resolve) => setTimeout(() => resolve(), timeoutMs)),
-            ]);
-        }
-        else {
-            await Promise.allSettled(waitPromises);
-        }
-        return results;
-    }
-    /**
-     * 内部方法：执行 entry 直到完成。
-     *
-     * 实际 ACodeRuntime.submit() 返回 Promise<void>，assistant 文本通过
-     * assistant_delta 事件传递。本方法注册临时监听器累积输出文本，
-     * 同时检测 turn_complete 事件中的 failed 标志以处理运行时内部错误。
-     *
-     * 完成后：
-     *   - 更新 entry 状态（completed/failed）
-     *   - 持久化到 store
-     *   - settle completionPromise
-     *   - 清理 runtime 实例（释放内存）
-     *   - **不删除 entry**（保留在内存供 list/get_status 查询，30min 后由定时器清理）
-     */
-    async runEntryToCompletion(entry) {
-        // 收集 assistant_delta 文本 + 检测 turn 失败标志
-        const chunks = [];
-        let turnFailed = false;
-        let turnErrorMessage;
-        const onEvent = (event) => {
-            if (!event)
-                return;
-            switch (event.type) {
-                case "assistant_delta":
-                    if (typeof event.data?.text === "string") {
-                        chunks.push(event.data.text);
-                    }
-                    break;
-                case "turn_complete":
-                    if (event.data?.failed) {
-                        turnFailed = true;
-                    }
-                    break;
-                case "error":
-                    if (typeof event.data?.message === "string") {
-                        turnErrorMessage = event.data.message;
-                    }
-                    break;
-            }
-        };
-        entry.runtime.on("event", onEvent);
-        // ★ 状态 -> running：先同步设置 + emit + currentTool 标记，再异步落盘。
-        //   之前顺序是 status=running → await store.updateStatus → emit running，
-        //   若 store.updateStatus 因 writeChain 串行化卡住（前一个 write 卡死），
-        //   emit running 不会执行，start() 也不会被调用，前端 modal 永远显示
-        //   初始 snapshot（0消息 0tokens 当前工具-），与"从未运行"无法区分。
-        //   调整顺序后即使落盘卡住，前端也能立即看到 [starting] 标记。
-        entry.status = "running";
-        entry.contextSnapshot.currentTool = "[starting]";
-        entry.contextSnapshot.updatedAt = new Date().toISOString();
-        this.emitEvent(entry.subId, "running", { snapshot: { ...entry.contextSnapshot } });
-        // 落盘带超时保护：writeChain 串行化可能卡住，超时后放弃落盘（不影响内存态）
-        try {
-            await withTimeout(this.store.updateStatus(entry.parentAgentId, entry.subId, { status: "running" }), STORE_WRITE_TIMEOUT_MS, `sub-agent ${entry.subId} store.updateStatus(running)`);
-        }
-        catch (err) {
-            console.error(`[SubAgentManager] store.updateStatus(running) failed for subId=${entry.subId}: ` +
-                `${err instanceof Error ? err.message : String(err)}`);
-        }
-        try {
-            await entry.runtime.start();
-            // 记录启动后的可用工具列表
-            entry.availableTools = entry.runtime.getAvailableTools();
-            await entry.runtime.submit(entry.prompt);
-            // 实际 API 中 submit 解析后所有事件已同步触发完毕（EventEmitter.emit 是同步的）
-            // 若 turn_complete 标记 failed，抛错走 catch
-            if (turnFailed) {
-                throw new Error(turnErrorMessage ?? "sub-agent turn failed");
-            }
-            const output = chunks.join("");
-            entry.status = "completed";
-            entry.result = output;
-            entry.endedAt = Date.now();
-            entry.durationMs = entry.endedAt - entry.startedAt;
-            // ★ emit 前置：先把 completed 事件发出，让前端 modal 立即看到状态变化
-            //   （subscribers 同步执行，SSE 路由立即推送）。
-            this.emitEvent(entry.subId, "completed", { result: output });
-            // ★ 终态落盘改为非阻塞：内存已置 completed，立即 settle completionPromise
-            //   + 入队通知，磁盘写入走 persistFinalStatus 的指数退避重试，不阻塞主流程。
-            //   即使落盘最终失败，前端看到的仍是真实 completed 状态（内存态是真相源），
-            //   不会触发列表接口的 "status mismatch" 兜底（兜底逻辑已移除）。
-            entry.completionResolve?.({ output });
-            this.enqueueCompletion(entry, output, undefined);
-            void this.persistFinalStatus(entry, {
-                status: "completed",
-                result: output,
-                endedAt: entry.endedAt,
-                durationMs: entry.durationMs,
-                // ★ 持久化 availableTools：start() 后才填充，必须随终态落盘，
-                //   否则 entry 从内存清理后 store 永远是 spawn 时的空数组，
-                //   前端 modal "可用工具" tab 始终显示"暂无工具信息"。
-                availableTools: entry.availableTools,
-                contextSnapshot: undefined, // 完成后清空快照
-            });
-        }
-        catch (err) {
-            const errorMessage = err instanceof Error ? err.message : String(err);
-            entry.status = "failed";
-            entry.errorMessage = errorMessage;
-            entry.endedAt = Date.now();
-            entry.durationMs = entry.endedAt - entry.startedAt;
-            // ★ emit 前置 + 终态非阻塞落盘（同 completed 路径的设计理由）
-            this.emitEvent(entry.subId, "failed", { error: errorMessage });
-            entry.completionResolve?.({ output: "", error: errorMessage });
-            this.enqueueCompletion(entry, "", errorMessage);
-            void this.persistFinalStatus(entry, {
-                status: "failed",
-                errorMessage,
-                endedAt: entry.endedAt,
-                durationMs: entry.durationMs,
-                availableTools: entry.availableTools,
-                contextSnapshot: undefined,
-            });
-        }
-        finally {
-            // 移除临时监听器
-            try {
-                entry.runtime.removeListener?.("event", onEvent);
-            }
-            catch {
-                /* 忽略移除失败 */
-            }
-            // 完成后清理 runtime 实例（释放内存），但保留 entry 供查询
-            try {
-                await entry.runtime.stop();
-            }
-            catch {
-                /* 忽略 stop 失败 */
-            }
-        }
-    }
-    /**
-     * 带 recheck 循环的 entry 执行（多轮 submit）。
-     *
-     * 与 runEntryToCompletion 的区别：
-     *   1. 第一轮 submit(entry.prompt) 完成后，调用 recheck 回调查询服务端真实状态
-     *   2. 若 recheck 返回 { done: false, continueMessage }，将 continueMessage 注入下一轮 submit
-     *   3. 最多重试 maxRetries 次；超过后视为完成（不再继续）
-     *   4. onEvent 监听器跨所有轮次累积 assistant_delta，最终 output 包含全部轮次的文本
-     *
-     * turnFailed 标志在每轮 submit 前重置，确保上一轮的失败状态不影响下一轮判断。
-     * recheck 自身抛错时视为 done（不阻塞 sub-agent 结束），仅记录日志。
-     */
-    async runEntryToCompletionWithRecheck(entry, recheck, maxRetries) {
-        const chunks = [];
-        let turnFailed = false;
-        let turnErrorMessage;
-        const onEvent = (event) => {
-            if (!event)
-                return;
-            switch (event.type) {
-                case "assistant_delta":
-                    if (typeof event.data?.text === "string") {
-                        chunks.push(event.data.text);
-                    }
-                    break;
-                case "turn_complete":
-                    if (event.data?.failed) {
-                        turnFailed = true;
-                    }
-                    break;
-                case "error":
-                    if (typeof event.data?.message === "string") {
-                        turnErrorMessage = event.data.message;
-                    }
-                    break;
-            }
-        };
-        entry.runtime.on("event", onEvent);
-        // ★ 状态 -> running：先同步设置 + emit + currentTool 标记，再异步落盘。
-        //   之前顺序是 status=running → await store.updateStatus → emit running，
-        //   若 store.updateStatus 因 writeChain 串行化卡住（前一个 write 卡死），
-        //   emit running 不会执行，start() 也不会被调用，前端 modal 永远显示
-        //   初始 snapshot（0消息 0tokens 当前工具-），与"从未运行"无法区分。
-        //   调整顺序后即使落盘卡住，前端也能立即看到 [starting] 标记。
-        entry.status = "running";
-        entry.contextSnapshot.currentTool = "[starting]";
-        entry.contextSnapshot.updatedAt = new Date().toISOString();
-        this.emitEvent(entry.subId, "running", { snapshot: { ...entry.contextSnapshot } });
-        // 落盘带超时保护：writeChain 串行化可能卡住，超时后放弃落盘（不影响内存态）
-        try {
-            await withTimeout(this.store.updateStatus(entry.parentAgentId, entry.subId, { status: "running" }), STORE_WRITE_TIMEOUT_MS, `sub-agent ${entry.subId} store.updateStatus(running)`);
-        }
-        catch (err) {
-            console.error(`[SubAgentManager] store.updateStatus(running) failed for subId=${entry.subId}: ` +
-                `${err instanceof Error ? err.message : String(err)}`);
-        }
-        try {
-            // ★ 超时兜底：start() 通常秒级完成，超时说明卡在 hookBus/fetchProfile/loadCommands
-            //   等无超时保护的步骤。抛错后被外层 catch 标记为 failed，前端可见。
-            await withTimeout(entry.runtime.start(), SUBAGENT_START_TIMEOUT_MS, `sub-agent ${entry.subId} runtime.start()`);
-            // ★ 可见性修正：start() 完成后、submit() 之前显式标记，让 submit 早期阶段
-            //   （hookBus.dispatch("UserPromptSubmit")、materializeImageContent 等）的卡点可见。
-            //   之前 skill_status 标记会停留到 ai_request 覆盖，但若 submit 卡在 ai_request 之前，
-            //   前端会显示 "[skill_loaded]"——容易误判为卡在 start()。这里覆盖为 "[submitting]"
-            //   明确表示已进入 submit 阶段。
-            entry.contextSnapshot.currentTool = "[submitting]";
-            entry.contextSnapshot.updatedAt = new Date().toISOString();
-            entry.availableTools = entry.runtime.getAvailableTools();
-            this.emitEvent(entry.subId, "progress", { snapshot: { ...entry.contextSnapshot } });
-            // 第一轮：使用初始 prompt
-            // ★ 超时兜底：submit 内部 fetch/performCompaction 已有 withTimeout，
-            //   但 hookBus.dispatch/materializeImageContent 等无保护，整体 10min 兜底。
-            await withTimeout(entry.runtime.submit(entry.prompt), SUBAGENT_SUBMIT_TIMEOUT_MS, `sub-agent ${entry.subId} runtime.submit() turn=1`);
-            if (turnFailed) {
-                throw new Error(turnErrorMessage ?? "sub-agent turn failed");
-            }
-            let turn = 1;
-            // recheck 循环：最多 maxRetries 次
-            while (turn <= maxRetries) {
-                let recheckResult;
-                try {
-                    recheckResult = await recheck(chunks.join(""), turn);
-                }
-                catch (recheckErr) {
-                    // recheck 自身出错：不阻塞 sub-agent 结束，视为完成
-                    console.error(`[SubAgentManager] recheck threw error for subId=${entry.subId} turn=${turn}, treating as done:`, recheckErr instanceof Error ? recheckErr.message : String(recheckErr));
-                    break;
-                }
-                if (recheckResult.done) {
-                    break;
-                }
-                // 未完成：注入 continueMessage 进行下一轮
-                const continueMessage = recheckResult.continueMessage ?? "经检查，未完成处理，请继续。";
-                // 重置 turn 失败标记，确保本轮失败状态不影响下一轮判断
-                turnFailed = false;
-                turnErrorMessage = undefined;
-                console.error(`[SubAgentManager] recheck not done for subId=${entry.subId} turn=${turn}/${maxRetries}, ` +
-                    `injecting continue message (${continueMessage.length} chars)`);
-                // ★ 超时兜底：recheck 续轮 submit 同样需要保护，避免卡死
-                await withTimeout(entry.runtime.submit(continueMessage), SUBAGENT_SUBMIT_TIMEOUT_MS, `sub-agent ${entry.subId} runtime.submit() recheck turn=${turn + 1}`);
-                if (turnFailed) {
-                    throw new Error(turnErrorMessage ?? `sub-agent turn ${turn + 1} failed during recheck continuation`);
-                }
-                turn++;
-            }
-            if (turn > maxRetries) {
-                console.error(`[SubAgentManager] recheck reached maxRetries=${maxRetries} for subId=${entry.subId}, ` +
-                    `completing with potentially unfinished work`);
-            }
-            const output = chunks.join("");
-            entry.status = "completed";
-            entry.result = output;
-            entry.endedAt = Date.now();
-            entry.durationMs = entry.endedAt - entry.startedAt;
-            // ★ emit 前置 + 终态非阻塞落盘 + 立即 settle completionPromise
-            //   （设计理由同 runEntryToCompletion：内存态是真相源，磁盘写入不阻塞主流程）
-            this.emitEvent(entry.subId, "completed", { result: output });
-            entry.completionResolve?.({ output });
-            this.enqueueCompletion(entry, output, undefined);
-            void this.persistFinalStatus(entry, {
-                status: "completed",
-                result: output,
-                endedAt: entry.endedAt,
-                durationMs: entry.durationMs,
-                availableTools: entry.availableTools,
-                contextSnapshot: undefined,
-            });
-        }
-        catch (err) {
-            const errorMessage = err instanceof Error ? err.message : String(err);
-            entry.status = "failed";
-            entry.errorMessage = errorMessage;
-            entry.endedAt = Date.now();
-            entry.durationMs = entry.endedAt - entry.startedAt;
-            // ★ emit 前置 + 终态非阻塞落盘（同 completed 路径的设计理由）
-            this.emitEvent(entry.subId, "failed", { error: errorMessage });
-            entry.completionResolve?.({ output: "", error: errorMessage });
-            this.enqueueCompletion(entry, "", errorMessage);
-            void this.persistFinalStatus(entry, {
-                status: "failed",
-                errorMessage,
-                endedAt: entry.endedAt,
-                durationMs: entry.durationMs,
-                availableTools: entry.availableTools,
-                contextSnapshot: undefined,
-            });
-        }
-        finally {
-            // 移除临时监听器
-            try {
-                entry.runtime.removeListener?.("event", onEvent);
-            }
-            catch {
-                /* 忽略移除失败 */
-            }
-            // 完成后清理 runtime 实例（释放内存），但保留 entry 供查询
-            try {
-                await entry.runtime.stop();
-            }
-            catch {
-                /* 忽略 stop 失败 */
-            }
-        }
-    }
-    /**
-     * @deprecated 兼容旧接口：spawn + 阻塞等待完成。
-     * 新代码应使用 spawn + start + awaitCompletion。
-     */
-    async runToCompletion(subId) {
-        const entry = this.subAgents.get(subId);
-        if (!entry) {
-            throw new Error(`sub-agent not found: ${subId}`);
-        }
-        if (entry.status === "running") {
-            throw new Error(`sub-agent already running: ${subId}`);
-        }
-        // 重置 status 以便 runEntryToCompletion 能进入 running
-        if (entry.status !== "pending") {
-            entry.status = "pending";
-        }
-        await this.start(subId);
-        return (await entry.completionPromise) ?? { output: "", error: "not started" };
-    }
-    /** 取消运行中的 sub-agent */
-    async abort(subId) {
-        const entry = this.subAgents.get(subId);
-        if (!entry)
-            return;
-        if (entry.status === "completed" || entry.status === "failed" || entry.status === "cancelled") {
-            return;
-        }
-        entry.abortController.abort();
-        try {
-            await entry.runtime.abort();
-        }
-        catch {
-            /* 忽略 */
-        }
-        entry.status = "cancelled";
-        entry.endedAt = Date.now();
-        entry.durationMs = entry.endedAt - entry.startedAt;
-        // ★ emit 前置 + 终态非阻塞落盘 + 立即 settle completionPromise
-        //   （设计理由同 completed 路径：内存态是真相源，磁盘写入不阻塞主流程）
-        this.emitEvent(subId, "cancelled", {});
-        entry.completionResolve?.({ output: "", error: "aborted" });
-        this.enqueueCompletion(entry, "", "aborted");
-        void this.persistFinalStatus(entry, {
-            status: "cancelled",
-            endedAt: entry.endedAt,
-            durationMs: entry.durationMs,
-            availableTools: entry.availableTools,
-            contextSnapshot: undefined,
-        });
-    }
-    /** 获取内存中的 entry */
-    getSubAgent(subId) {
-        return this.subAgents.get(subId);
-    }
-    /** 列出某 agent 的全部内存中 sub-agent（含运行中和已完成未清理） */
-    listByParent(parentAgentId) {
-        const subIds = this.parentToSubs.get(parentAgentId);
-        if (!subIds)
-            return [];
-        return Array.from(subIds)
-            .map((id) => this.subAgents.get(id))
-            .filter((e) => e !== undefined);
-    }
-    /**
-     * 列出某父 agent 下处于活跃状态（pending / running）且对用户可见的 sub-agent。
-     *
-     * 已完成/失败/取消的 entry 在内存中仍保留 TTL=30min 供查询，但不应计入
-     * "进行中" 列表。前端 "进行中" tab 与 SSE snapshot 都应使用此方法。
-     *
-     * silent 子 agent（如 memory 自动整理的后台 explore 子代理）属于系统级后台任务，
-     * 不应展示给用户，否则会导致 tag 数量多于用户实际可见的子 agent，故此处一并过滤，
-     * 与 enqueueCompletion 对 silent 的语义保持一致。并发计数 countByParent 不受影响，
-     * 仍会统计 silent 子 agent 占用的并发槽位。
-     */
-    listActiveByParent(parentAgentId) {
-        return this.listByParent(parentAgentId).filter((e) => (e.status === "pending" || e.status === "running") && !e.silent);
-    }
-    /**
-     * 取走并清空终态通知队列。
-     *
-     * 主流程：返回 completionQueue 中的所有通知并清空队列。
-     * 供 ACode 运行时在 poll_message 调用前后检查子 agent 是否已完成。
-     * 每次 poll_message 调用前先调此方法，若有已完成子 agent 则直接返回，无需等待 MCP。
-     */
-    takeCompletedSubAgents() {
-        if (this.completionQueue.length === 0)
-            return [];
-        const drained = this.completionQueue.splice(0);
-        return drained;
-    }
-    /**
-     * 等待任意子 agent 到达终态（completed/failed/cancelled）。
-     *
-     * 主流程：如果 completionQueue 中已有通知，立即 resolve；
-     * 否则注册一个 resolve 回调，在下次子 agent 终态事件到达时触发。
-     * 供 ACode 运行时在 poll_message 期间 race 子 agent 完成事件。
-     *
-     * 返回 { promise, cancel }：
-     * - promise: 子 agent 终态时 resolve
-     * - cancel: 取消等待（poll_message 先返回时调用，清理 resolve 回调）
-     */
-    waitForAnyCompletion() {
-        // 如果队列中已有通知，立即返回
-        if (this.completionQueue.length > 0) {
-            const notif = this.completionQueue.shift();
-            return {
-                promise: Promise.resolve(notif),
-                cancel: () => { },
-            };
-        }
-        let cancelled = false;
-        const promise = new Promise((resolve) => {
-            this.completionWaiterResolve = (notif) => {
-                if (!cancelled)
-                    resolve(notif);
-            };
-        });
-        const cancel = () => {
-            cancelled = true;
-            this.completionWaiterResolve = null;
-        };
-        return { promise, cancel };
-    }
-    /** 订阅 sub-agent 事件（subId 或 "*" 全局） */
-    subscribe(subId, cb) {
-        let set = this.subscribers.get(subId);
-        if (!set) {
-            set = new Set();
-            this.subscribers.set(subId, set);
-        }
-        set.add(cb);
-        return () => {
-            set?.delete(cb);
-            if (set && set.size === 0)
-                this.subscribers.delete(subId);
-        };
-    }
-    /** 清理所有运行中的 sub-agent（bridge 关闭时调用） */
-    async dispose() {
-        if (this.cleanupTimer) {
-            clearInterval(this.cleanupTimer);
-            this.cleanupTimer = null;
-        }
-        const entries = Array.from(this.subAgents.values());
-        await Promise.allSettled(entries.map((e) => this.abort(e.subId)));
-        // 等待所有异步终态落盘完成（abort 触发的 cancelled 落盘是异步的），
-        // 避免文件句柄占用导致测试 cleanup 时目录非空
-        await this.flushPendingPersists();
-        this.subAgents.clear();
-        this.parentToSubs.clear();
-        this.subscribers.clear();
-    }
-    // ---------- 内部方法 ----------
-    /**
-     * 异步落盘终态记录（指数退避重试），不阻塞主流程。
-     *
-     * 设计要点：
-     *   - 内存态已是终态（completed/failed/cancelled），落盘只做历史归档
-     *   - 落盘失败不回滚内存态，前端看到的是真实终态
-     *   - 重试覆盖瞬时错误：Windows fs.rename EPERM、writeChain 拥堵、磁盘瞬时不可用
-     *   - 全部重试失败后仅打日志，下次 bridge 启动时 reconcileZombies 会清理残留
-     *
-     * 调用方约定：必须用 `void this.persistFinalStatus(...)` 触发，不 await。
-     * entry.completionResolve 与 enqueueCompletion 应在此调用之前完成，
-     * 保证主流程不被落盘 IO 阻塞。
-     *
-     * Promise 加入 pendingPersists 集合，供 flushPendingPersists / dispose 等待。
-     */
-    persistFinalStatus(entry, patch) {
-        const run = (async () => {
-            let lastErr;
-            for (let attempt = 0; attempt <= PERSIST_BACKOFF_MS.length; attempt++) {
-                try {
-                    await this.store.updateStatus(entry.parentAgentId, entry.subId, patch);
-                    return;
-                }
-                catch (err) {
-                    lastErr = err;
-                    if (attempt < PERSIST_BACKOFF_MS.length) {
-                        await new Promise((r) => setTimeout(r, PERSIST_BACKOFF_MS[attempt]));
-                    }
-                }
-            }
-            console.error(`[SubAgentManager] persistFinalStatus(${patch.status}) failed after ${PERSIST_BACKOFF_MS.length + 1} attempts ` +
-                `for subId=${entry.subId}: ${lastErr instanceof Error ? lastErr.message : String(lastErr)}`);
-        })();
-        // 入集供测试/dispose 等待
-        this.pendingPersists.add(run);
-        run.finally(() => this.pendingPersists.delete(run));
-        return run;
-    }
-    /**
-     * 等待所有正在执行的异步终态落盘完成。
-     *
-     * 主要用途：
-     *   - 测试在终态后读取 store 前调用，确保落盘已完成
-     *   - dispose 前调用，避免文件句柄占用导致目录清理失败
-     *
-     * 生产环境一般不需要调用——落盘失败不影响内存态正确性。
-     */
-    async flushPendingPersists() {
-        if (this.pendingPersists.size === 0)
-            return;
-        await Promise.allSettled(Array.from(this.pendingPersists));
-    }
-    /**
-     * 将子 agent 终态事件入队并通知等待者。
-     * 主流程：构建通知对象 -> 入队 completionQueue -> 若有 waitForAnyCompletion 等待者则立即 resolve。
-     */
-    enqueueCompletion(entry, output, error) {
-        // 静默完成或已被 awaitCompletion 消费的子 agent 不进入 completionQueue
-        if (entry.silent || entry.awaited) {
-            return;
-        }
-        const notif = {
-            subId: entry.subId,
-            subagentType: entry.subagentType,
-            description: entry.description,
-            status: entry.status,
-            output,
-            error,
-            durationMs: entry.durationMs,
-        };
-        this.completionQueue.push(notif);
-        // 如果有 poll_message 正在等待子 agent 完成事件，立即通知
-        if (this.completionWaiterResolve) {
-            const resolve = this.completionWaiterResolve;
-            this.completionWaiterResolve = null;
-            // 从队列中取出刚入队的通知（即此条）
-            const queued = this.completionQueue.pop();
-            resolve(queued ?? notif);
-        }
-    }
-    countByStatus(parentAgentId, ...statuses) {
-        return this.listByParent(parentAgentId).filter((e) => statuses.includes(e.status)).length;
-    }
-    addToParentMap(parentAgentId, subId) {
-        let set = this.parentToSubs.get(parentAgentId);
-        if (!set) {
-            set = new Set();
-            this.parentToSubs.set(parentAgentId, set);
-        }
-        set.add(subId);
-    }
-    removeFromParentMap(parentAgentId, subId) {
-        const set = this.parentToSubs.get(parentAgentId);
-        if (set) {
-            set.delete(subId);
-            if (set.size === 0)
-                this.parentToSubs.delete(parentAgentId);
-        }
-    }
-    /**
-     * 清理已超过 TTL 的终态 entry（completed/failed/cancelled）。
-     * 释放内存，store 仍保留历史记录供查询。
-     */
-    cleanupCompletedEntries() {
-        const now = Date.now();
-        for (const [subId, entry] of this.subAgents) {
-            if ((entry.status === "completed" || entry.status === "failed" || entry.status === "cancelled") &&
-                entry.endedAt &&
-                now - entry.endedAt > COMPLETED_ENTRY_TTL_MS) {
-                this.subAgents.delete(subId);
-                this.removeFromParentMap(entry.parentAgentId, subId);
-            }
-        }
-    }
-    /**
-     * 存活期僵尸回收：扫描卡在 pending / running 过久的子 agent 并标记为 failed。
-     *
-     * 背景：runEntryToCompletion* 会在启动后数秒内把状态翻成 running；若长时间保持
-     * pending，说明 startWithRecheck 抛错被调用方静默吞掉、或启动函数从未真正执行，
-     * 子 agent 成了孤儿却仍占着 runtime.pendingMemorySubAgents 的 URI 锁，导致该
-     * memory 的文件变更通知被永久抑制、永不重试（reconcileZombies 仅在 bridge 启动时跑）。
-     * running 卡死则多因 runtime.start()/submit() 挂起。
-     *
-     * 回收时复用与正常终态一致的处理（store 落盘 failed + emit failed 事件 +
-     * 释放 completion + 停 runtime）。runtime 订阅了 failed 事件，会据此清除
-     * pendingMemorySubAgents 中的 URI 并进入冷却，从而解除死锁、允许下次重新委托。
-     */
-    recoverZombieEntries() {
-        const now = Date.now();
-        for (const [subId, entry] of this.subAgents) {
-            if (entry.status === "pending" && now - entry.startedAt > SUBAGENT_PENDING_ZOMBIE_MS) {
-                void this.recoverZombie(entry, `stuck in pending >${SUBAGENT_PENDING_ZOMBIE_MS}ms (never started)`);
-            }
-            else if (entry.status === "running" && now - entry.startedAt > SUBAGENT_RUNNING_ZOMBIE_MS) {
-                void this.recoverZombie(entry, `stuck in running >${SUBAGENT_RUNNING_ZOMBIE_MS}ms (no completion)`);
-            }
-        }
-    }
-    /** 将孤儿/卡死子 agent 标记为 failed 并走正常终态流程（不依赖 LLM 自报） */
-    async recoverZombie(entry, reason) {
-        // 启动函数可能在扫描与执行之间恰好把状态翻成 running/终态，二次确认避免误杀
-        if (entry.status !== "pending" && entry.status !== "running")
-            return;
-        const errorMessage = `zombie recovered: ${reason}`;
-        entry.status = "failed";
-        entry.errorMessage = errorMessage;
-        entry.endedAt = Date.now();
-        entry.durationMs = entry.endedAt - entry.startedAt;
-        // ★ emit 前置 + 终态非阻塞落盘 + 立即 settle completionPromise
-        //   （与其他终态路径保持一致，zombie 回收路径若 writeChain 卡住，
-        //   也应保证 runtime 收到 failed 事件从而释放 pendingMemorySubAgents URI 锁）
-        this.emitEvent(entry.subId, "failed", { error: errorMessage });
-        entry.completionResolve?.({ output: "", error: errorMessage });
-        this.enqueueCompletion(entry, "", errorMessage);
-        void this.persistFinalStatus(entry, {
-            status: "failed",
-            errorMessage,
-            endedAt: entry.endedAt,
-            durationMs: entry.durationMs,
-            availableTools: entry.availableTools,
-            contextSnapshot: undefined,
-        });
-        try {
-            await entry.runtime.stop();
-        }
-        catch {
-            /* 忽略 stop 失败 */
-        }
-    }
-    /** 从 store 中查找记录（entry 已从内存清理时使用） */
-    async findRecordInStore(subId) {
-        // store 按父 agent 组织，无法直接按 subId 查；遍历所有 parent
-        // 注意：此方法仅在 awaitCompletion 时调用，频率低
-        for (const parentAgentId of this.parentToSubs.keys()) {
-            const doc = await this.store.read(parentAgentId);
-            const record = doc.subAgents.find((r) => r.subId === subId);
-            if (record)
-                return record;
-        }
-        return undefined;
-    }
-    handleRuntimeEvent(subId, event) {
-        const entry = this.subAgents.get(subId);
-        if (!entry)
-            return;
-        // 更新 contextSnapshot
-        const snapshot = entry.contextSnapshot;
-        snapshot.updatedAt = new Date().toISOString();
-        switch (event?.type) {
-            case "session_started":
-                // ★ 可见性修正：start() 早期阶段标记（runtime.ts start() 中的首个 emit）。
-                //   之前 session_started/mcp_status(状态报告)/skill_status 都不在 switch 中，
-                //   导致子 agent 卡在 start() 内部（如 hookBus.dispatch、fetchProfilePrompt、
-                //   loadAcodeCommands 等）时前端 snapshot 永远显示 0/0/"-"，与"子 agent 从未运行"
-                //   无法区分。加上阶段标记后可定位卡点位置。
-                snapshot.currentTool = "[starting]";
-                this.emitEvent(subId, "progress", { snapshot: { ...snapshot } });
-                break;
-            case "startup_phase":
-                // ★ 可见性修正：start() 内部细分阶段标记（session_started 之前 emit）。
-                //   子 agent 卡在 loadAcodeConfig/loadAllSkills/fetchProfilePrompt/
-                //   loadAcodeCommands/hookBus.dispatch("SessionStart") 等步骤时，
-                //   前端可精确定位卡点（currentTool 显示 "[startup:<phase>]"），
-                //   而非笼统的 "-"。
-                snapshot.currentTool = `[startup:${event.data?.phase ?? "unknown"}]`;
-                this.emitEvent(subId, "progress", { snapshot: { ...snapshot } });
-                break;
-            case "mcp_status":
-                // runtime 发射的 mcp_status 使用 action 字段（而非 phase）
-                if (event.data?.action === "call_tool") {
-                    snapshot.currentTool = event.data?.tool;
-                    this.emitEvent(subId, "tool_start", { tool: snapshot.currentTool, snapshot: { ...snapshot } });
-                }
-                else if (event.data?.action === "tool_result") {
-                    this.emitEvent(subId, "tool_end", { tool: snapshot.currentTool, snapshot: { ...snapshot } });
-                    snapshot.currentTool = undefined;
-                }
-                else {
-                    // ★ 可见性修正：start() 阶段 emit 的 mcp_status（无 action 字段，是连接状态报告），
-                    //   标记 MCP 初始化阶段。位于 session_started 之后、skill_status 之前。
-                    snapshot.currentTool = "[mcp_init]";
-                    this.emitEvent(subId, "progress", { snapshot: { ...snapshot } });
-                }
-                break;
-            case "skill_status":
-                // ★ 可见性修正：start() 末尾阶段标记。skill_status 是 start() 最后 emit 的事件，
-                //   之后 start() 完成、submit() 开始；submit 早期到 ai_request 之间无事件，
-                //   若卡在此区间，前端会显示 "[skill_loaded]"，可定位为 submit 早期卡死
-                //   （如 hookBus.dispatch("UserPromptSubmit")、materializeImageContent 等）。
-                snapshot.currentTool = "[skill_loaded]";
-                this.emitEvent(subId, "progress", { snapshot: { ...snapshot } });
-                break;
-            case "ai_request":
-                // estimatedContextTokens 是请求前的上下文估算，可作为 input 近似值
-                if (event.data?.estimatedContextTokens != null) {
-                    snapshot.tokenUsage.input = (event.data.estimatedContextTokens ?? snapshot.tokenUsage.input);
-                }
-                // ★ 可见性修正：标记当前处于模型请求阶段，便于前端区分"卡在模型请求"与"未启动"。
-                //   否则子 agent 卡在 fetch 时 snapshot.currentTool 仍为 undefined，前端显示"-"，
-                //   与"子 agent 从未运行"无法区分。
-                snapshot.currentTool = "[model_request]";
-                this.emitEvent(subId, "progress", { snapshot: { ...snapshot } });
-                break;
-            case "context_compaction":
-                // ★ 可见性修正：标记当前处于上下文压缩阶段。
-                //   子 agent 初始上下文触发主动压缩时，requestChatCompletion 会先执行 performCompaction
-                //   （调用 summarizeConversationWithLLM 发起摘要 LLM 请求），此时 ai_request 尚未发射，
-                //   前端 snapshot 会显示全 0。标记 currentTool 为压缩阶段，让"卡在压缩"可见。
-                if (event.data?.action === "start") {
-                    snapshot.currentTool = "[context_compaction]";
-                    this.emitEvent(subId, "progress", { snapshot: { ...snapshot } });
-                }
-                else if (event.data?.action === "end") {
-                    // 压缩结束后清除标记，后续 ai_request 会覆盖
-                    if (snapshot.currentTool === "[context_compaction]") {
-                        snapshot.currentTool = undefined;
-                        this.emitEvent(subId, "progress", { snapshot: { ...snapshot } });
-                    }
-                }
-                break;
-            case "turn_complete":
-                // turn_complete 携带实际的 token 用量，覆盖 ai_request 的估算值
-                if (event.data?.usage) {
-                    snapshot.tokenUsage.input = (event.data.usage.inputTokens ?? snapshot.tokenUsage.input);
-                    snapshot.tokenUsage.output = (event.data.usage.outputTokens ?? snapshot.tokenUsage.output);
-                    this.emitEvent(subId, "progress", { snapshot: { ...snapshot } });
-                }
-                else if (event.data?.failed || event.data?.aborted) {
-                    // 失败/中止路径不携带 usage，重置 output 避免残留上一轮值
-                    snapshot.tokenUsage.output = 0;
-                }
-                break;
-            case "assistant_delta":
-                // 累积文本，截断到最近 500 字符
-                snapshot.lastAssistantText = ((snapshot.lastAssistantText ?? "") + (event.data?.text ?? "")).slice(-500);
-                snapshot.messageCount += 1;
-                this.emitEvent(subId, "delta", { text: event.data?.text });
-                break;
-            case "session_complete":
-                snapshot.messageCount += 1;
-                break;
-        }
-    }
-    emitEvent(subId, type, data) {
-        const event = {
-            type,
-            subId,
-            timestamp: new Date().toISOString(),
-            data,
-        };
-        // 通知该 subId 的订阅者
-        const subs = this.subscribers.get(subId);
-        if (subs) {
-            for (const cb of subs) {
-                try {
-                    cb(event);
-                }
-                catch {
-                    /* 忽略订阅者错误 */
-                }
-            }
-        }
-        // 通知全局订阅者
-        const globalSubs = this.subscribers.get("*");
-        if (globalSubs) {
-            for (const cb of globalSubs) {
-                try {
-                    cb(event);
-                }
-                catch {
-                    /* 忽略 */
-                }
-            }
-        }
-        // tool_start / tool_end 异步落盘（fire-and-forget，不阻塞事件发射）
-        if (type === "tool_start" || type === "tool_end") {
-            const entry = this.subAgents.get(subId);
-            if (entry) {
-                console.error(`[SubAgentManager] appendEvent: subId=${subId} type=${type} tool=${data.tool ?? "?"} parentAgentId=${entry.parentAgentId}`);
-                void this.store.appendEvent(entry.parentAgentId, subId, event).catch((err) => {
-                    console.error(`[SubAgentManager] appendEvent FAILED: subId=${subId} error=${err instanceof Error ? err.message : String(err)}`);
-                });
-            }
-            else {
-                console.error(`[SubAgentManager] appendEvent SKIPPED (entry not found): subId=${subId} type=${type}`);
-            }
-        }
-    }
-    toRecord(entry) {
-        return {
-            subId: entry.subId,
-            parentAgentId: entry.parentAgentId,
-            parentSessionId: entry.parentSessionId,
-            subagentType: entry.subagentType,
-            description: entry.description,
-            prompt: entry.prompt,
-            status: entry.status,
-            result: entry.result,
-            errorMessage: entry.errorMessage,
-            startedAt: entry.startedAt,
-            endedAt: entry.endedAt,
-            durationMs: entry.durationMs,
-            contextSnapshot: entry.status === "running" ? entry.contextSnapshot : undefined,
-            availableTools: entry.availableTools,
-        };
-    }
-    /** 获取当前上下文快照（供 HTTP 路由调用） */
-    getContextSnapshot(subId) {
-        return this.subAgents.get(subId)?.contextSnapshot;
-    }
-}
-/**
- * 简易超时兜底，仅用于 sub-agent 的 start()/submit() 整体保护。
- *
- * 与 runtime.ts 中的 withTimeout 行为一致：
- *   - 超时后 reject，让外层 catch 把 sub-agent 标记为 failed（前端可见）
- *   - 不取消 underlying promise（runtime 内部的 fetch 已有自己的 AbortController）
- *   - timeoutMs <= 0 时跳过保护，直接 await
- *
- * 未抽到独立工具文件是因为仅此处使用；如未来有其他模块需要，再考虑提取到 shared。
- */
-async function withTimeout(operation, timeoutMs, label) {
-    if (timeoutMs <= 0) {
-        return await operation;
-    }
-    let timer;
-    try {
-        return await new Promise((resolve, reject) => {
-            timer = setTimeout(() => reject(new Error(`${label} timed out after ${timeoutMs}ms`)), timeoutMs);
-            operation.then(resolve, reject);
-        });
-    }
-    finally {
-        if (timer) {
-            clearTimeout(timer);
-        }
-    }
-}
+import{randomUUID as S}from"node:crypto";import{ACodeRuntime as w}from"./runtime.js";const T=30*60*1e3,m=2*60*1e3,f=12*60*1e3,b=5e3,d=[100,500,2e3,8e3],E=6e4,A=10*60*1e3;class _{constructor(t){this.subAgents=new Map,this.parentToSubs=new Map,this.subscribers=new Map,this.cleanupTimer=null,this.completionQueue=[],this.completionWaiterResolve=null,this.pendingPersists=new Set,this.store=t.store,this.maxConcurrent=t.maxConcurrent??5,this.cleanupTimer=setInterval(()=>{this.cleanupCompletedEntries(),this.recoverZombieEntries()},5*60*1e3),this.cleanupTimer.unref&&this.cleanupTimer.unref(),this.store.reconcileZombies().catch(()=>{})}async spawn(t){if(this.countByStatus(t.parentAgentId,"running","pending")>=this.maxConcurrent)throw new Error(`concurrent sub-agent limit reached (${this.maxConcurrent}) for agent ${t.parentAgentId}`);const s=`sub-${S()}`,n=Date.now(),i=new AbortController,o={...t.parentConfig,sessionId:s,workingDirectory:t.workingDirectory,agentId:`${t.parentAgentId}__sub__${s}`,initialPrompt:void 0,subAgentManager:void 0,subagentType:t.subagentType,...t.parentConfig.subAgentModel?{model:t.parentConfig.subAgentModel}:{},...t.parentConfig.subAgentEffort?{effort:t.parentConfig.subAgentEffort}:{},subAgentModel:void 0,subAgentEffort:void 0},r=new w(o),a={subId:s,parentAgentId:t.parentAgentId,parentSessionId:t.parentSessionId,subagentType:t.subagentType,description:t.description,prompt:t.prompt,status:"pending",startedAt:n,runtime:r,abortController:i,silent:t.silent,contextSnapshot:{tokenUsage:{input:0,output:0},messageCount:0,updatedAt:new Date().toISOString()},availableTools:[]};this.subAgents.set(s,a),this.addToParentMap(t.parentAgentId,s);const u=this.toRecord(a);return await this.store.upsert(t.parentAgentId,u),r.on("event",l=>{this.handleRuntimeEvent(s,l)}),this.emitEvent(s,"spawned",{}),s}async start(t){const e=this.subAgents.get(t);if(!e)throw new Error(`sub-agent not found: ${t}`);if(e.status!=="pending")throw new Error(`sub-agent ${t} cannot start from status: ${e.status}`);e.completionPromise=new Promise((s,n)=>{e.completionResolve=s,e.completionReject=n}),this.runEntryToCompletion(e).catch(()=>{})}async startWithRecheck(t,e,s=3){const n=this.subAgents.get(t);if(!n)throw new Error(`sub-agent not found: ${t}`);if(n.status!=="pending")throw new Error(`sub-agent ${t} cannot start from status: ${n.status}`);n.completionPromise=new Promise((i,o)=>{n.completionResolve=i,n.completionReject=o}),this.runEntryToCompletionWithRecheck(n,e,s).catch(()=>{})}async awaitCompletion(t,e=0){if(t.length===0)return[];const s=[],n=t.map(async o=>{const r=this.subAgents.get(o);if(!r){const u=await this.findRecordInStore(o);u?s.push({subId:o,output:u.result??"",error:u.errorMessage,status:u.status}):s.push({subId:o,output:"",error:`sub-agent not found: ${o}`,status:"failed"});return}r.awaited=!0,r.status==="pending"&&await this.start(o);const a=r.completionPromise??Promise.resolve({output:"",error:"not started"});try{const u=await a;s.push({subId:o,output:u.output,error:u.error,status:r.status})}catch(u){s.push({subId:o,output:"",error:u instanceof Error?u.message:String(u),status:r.status})}}),i=new Set(t);for(let o=this.completionQueue.length-1;o>=0;o--)i.has(this.completionQueue[o].subId)&&this.completionQueue.splice(o,1);return e>0?await Promise.race([Promise.allSettled(n),new Promise(o=>setTimeout(()=>o(),e))]):await Promise.allSettled(n),s}async runEntryToCompletion(t){const e=[];let s=!1,n;const i=o=>{if(o)switch(o.type){case"assistant_delta":typeof o.data?.text=="string"&&e.push(o.data.text);break;case"turn_complete":o.data?.failed&&(s=!0);break;case"error":typeof o.data?.message=="string"&&(n=o.data.message);break}};t.runtime.on("event",i),t.status="running",t.contextSnapshot.currentTool="[starting]",t.contextSnapshot.updatedAt=new Date().toISOString(),this.emitEvent(t.subId,"running",{snapshot:{...t.contextSnapshot}});try{await c(this.store.updateStatus(t.parentAgentId,t.subId,{status:"running"}),b,`sub-agent ${t.subId} store.updateStatus(running)`)}catch(o){console.error(`[SubAgentManager] store.updateStatus(running) failed for subId=${t.subId}: ${o instanceof Error?o.message:String(o)}`)}try{if(await t.runtime.start(),t.availableTools=t.runtime.getAvailableTools(),await t.runtime.submit(t.prompt),s)throw new Error(n??"sub-agent turn failed");const o=e.join("");t.status="completed",t.result=o,t.endedAt=Date.now(),t.durationMs=t.endedAt-t.startedAt,this.emitEvent(t.subId,"completed",{result:o}),t.completionResolve?.({output:o}),this.enqueueCompletion(t,o,void 0),this.persistFinalStatus(t,{status:"completed",result:o,endedAt:t.endedAt,durationMs:t.durationMs,availableTools:t.availableTools,contextSnapshot:void 0})}catch(o){const r=o instanceof Error?o.message:String(o);t.status="failed",t.errorMessage=r,t.endedAt=Date.now(),t.durationMs=t.endedAt-t.startedAt,this.emitEvent(t.subId,"failed",{error:r}),t.completionResolve?.({output:"",error:r}),this.enqueueCompletion(t,"",r),this.persistFinalStatus(t,{status:"failed",errorMessage:r,endedAt:t.endedAt,durationMs:t.durationMs,availableTools:t.availableTools,contextSnapshot:void 0})}finally{try{t.runtime.removeListener?.("event",i)}catch{}try{await t.runtime.stop()}catch{}}}async runEntryToCompletionWithRecheck(t,e,s){const n=[];let i=!1,o;const r=a=>{if(a)switch(a.type){case"assistant_delta":typeof a.data?.text=="string"&&n.push(a.data.text);break;case"turn_complete":a.data?.failed&&(i=!0);break;case"error":typeof a.data?.message=="string"&&(o=a.data.message);break}};t.runtime.on("event",r),t.status="running",t.contextSnapshot.currentTool="[starting]",t.contextSnapshot.updatedAt=new Date().toISOString(),this.emitEvent(t.subId,"running",{snapshot:{...t.contextSnapshot}});try{await c(this.store.updateStatus(t.parentAgentId,t.subId,{status:"running"}),b,`sub-agent ${t.subId} store.updateStatus(running)`)}catch(a){console.error(`[SubAgentManager] store.updateStatus(running) failed for subId=${t.subId}: ${a instanceof Error?a.message:String(a)}`)}try{if(await c(t.runtime.start(),E,`sub-agent ${t.subId} runtime.start()`),t.contextSnapshot.currentTool="[submitting]",t.contextSnapshot.updatedAt=new Date().toISOString(),t.availableTools=t.runtime.getAvailableTools(),this.emitEvent(t.subId,"progress",{snapshot:{...t.contextSnapshot}}),await c(t.runtime.submit(t.prompt),A,`sub-agent ${t.subId} runtime.submit() turn=1`),i)throw new Error(o??"sub-agent turn failed");let a=1;for(;a<=s;){let l;try{l=await e(n.join(""),a)}catch(g){console.error(`[SubAgentManager] recheck threw error for subId=${t.subId} turn=${a}, treating as done:`,g instanceof Error?g.message:String(g));break}if(l.done)break;const h=l.continueMessage??"\u7ECF\u68C0\u67E5\uFF0C\u672A\u5B8C\u6210\u5904\u7406\uFF0C\u8BF7\u7EE7\u7EED\u3002";if(i=!1,o=void 0,console.error(`[SubAgentManager] recheck not done for subId=${t.subId} turn=${a}/${s}, injecting continue message (${h.length} chars)`),await c(t.runtime.submit(h),A,`sub-agent ${t.subId} runtime.submit() recheck turn=${a+1}`),i)throw new Error(o??`sub-agent turn ${a+1} failed during recheck continuation`);a++}a>s&&console.error(`[SubAgentManager] recheck reached maxRetries=${s} for subId=${t.subId}, completing with potentially unfinished work`);const u=n.join("");t.status="completed",t.result=u,t.endedAt=Date.now(),t.durationMs=t.endedAt-t.startedAt,this.emitEvent(t.subId,"completed",{result:u}),t.completionResolve?.({output:u}),this.enqueueCompletion(t,u,void 0),this.persistFinalStatus(t,{status:"completed",result:u,endedAt:t.endedAt,durationMs:t.durationMs,availableTools:t.availableTools,contextSnapshot:void 0})}catch(a){const u=a instanceof Error?a.message:String(a);t.status="failed",t.errorMessage=u,t.endedAt=Date.now(),t.durationMs=t.endedAt-t.startedAt,this.emitEvent(t.subId,"failed",{error:u}),t.completionResolve?.({output:"",error:u}),this.enqueueCompletion(t,"",u),this.persistFinalStatus(t,{status:"failed",errorMessage:u,endedAt:t.endedAt,durationMs:t.durationMs,availableTools:t.availableTools,contextSnapshot:void 0})}finally{try{t.runtime.removeListener?.("event",r)}catch{}try{await t.runtime.stop()}catch{}}}async runToCompletion(t){const e=this.subAgents.get(t);if(!e)throw new Error(`sub-agent not found: ${t}`);if(e.status==="running")throw new Error(`sub-agent already running: ${t}`);return e.status!=="pending"&&(e.status="pending"),await this.start(t),await e.completionPromise??{output:"",error:"not started"}}async abort(t){const e=this.subAgents.get(t);if(e&&!(e.status==="completed"||e.status==="failed"||e.status==="cancelled")){e.abortController.abort();try{await e.runtime.abort()}catch{}e.status="cancelled",e.endedAt=Date.now(),e.durationMs=e.endedAt-e.startedAt,this.emitEvent(t,"cancelled",{}),e.completionResolve?.({output:"",error:"aborted"}),this.enqueueCompletion(e,"","aborted"),this.persistFinalStatus(e,{status:"cancelled",endedAt:e.endedAt,durationMs:e.durationMs,availableTools:e.availableTools,contextSnapshot:void 0})}}getSubAgent(t){return this.subAgents.get(t)}listByParent(t){const e=this.parentToSubs.get(t);return e?Array.from(e).map(s=>this.subAgents.get(s)).filter(s=>s!==void 0):[]}listActiveByParent(t){return this.listByParent(t).filter(e=>(e.status==="pending"||e.status==="running")&&!e.silent)}takeCompletedSubAgents(){return this.completionQueue.length===0?[]:this.completionQueue.splice(0)}waitForAnyCompletion(){if(this.completionQueue.length>0){const n=this.completionQueue.shift();return{promise:Promise.resolve(n),cancel:()=>{}}}let t=!1;return{promise:new Promise(n=>{this.completionWaiterResolve=i=>{t||n(i)}}),cancel:()=>{t=!0,this.completionWaiterResolve=null}}}subscribe(t,e){let s=this.subscribers.get(t);return s||(s=new Set,this.subscribers.set(t,s)),s.add(e),()=>{s?.delete(e),s&&s.size===0&&this.subscribers.delete(t)}}async dispose(){this.cleanupTimer&&(clearInterval(this.cleanupTimer),this.cleanupTimer=null);const t=Array.from(this.subAgents.values());await Promise.allSettled(t.map(e=>this.abort(e.subId))),await this.flushPendingPersists(),this.subAgents.clear(),this.parentToSubs.clear(),this.subscribers.clear()}persistFinalStatus(t,e){const s=(async()=>{let n;for(let i=0;i<=d.length;i++)try{await this.store.updateStatus(t.parentAgentId,t.subId,e);return}catch(o){n=o,i<d.length&&await new Promise(r=>setTimeout(r,d[i]))}console.error(`[SubAgentManager] persistFinalStatus(${e.status}) failed after ${d.length+1} attempts for subId=${t.subId}: ${n instanceof Error?n.message:String(n)}`)})();return this.pendingPersists.add(s),s.finally(()=>this.pendingPersists.delete(s)),s}async flushPendingPersists(){this.pendingPersists.size!==0&&await Promise.allSettled(Array.from(this.pendingPersists))}enqueueCompletion(t,e,s){if(t.silent||t.awaited)return;const n={subId:t.subId,subagentType:t.subagentType,description:t.description,status:t.status,output:e,error:s,durationMs:t.durationMs};if(this.completionQueue.push(n),this.completionWaiterResolve){const i=this.completionWaiterResolve;this.completionWaiterResolve=null;const o=this.completionQueue.pop();i(o??n)}}countByStatus(t,...e){return this.listByParent(t).filter(s=>e.includes(s.status)).length}addToParentMap(t,e){let s=this.parentToSubs.get(t);s||(s=new Set,this.parentToSubs.set(t,s)),s.add(e)}removeFromParentMap(t,e){const s=this.parentToSubs.get(t);s&&(s.delete(e),s.size===0&&this.parentToSubs.delete(t))}cleanupCompletedEntries(){const t=Date.now();for(const[e,s]of this.subAgents)(s.status==="completed"||s.status==="failed"||s.status==="cancelled")&&s.endedAt&&t-s.endedAt>T&&(this.subAgents.delete(e),this.removeFromParentMap(s.parentAgentId,e))}recoverZombieEntries(){const t=Date.now();for(const[e,s]of this.subAgents)s.status==="pending"&&t-s.startedAt>m?this.recoverZombie(s,`stuck in pending >${m}ms (never started)`):s.status==="running"&&t-s.startedAt>f&&this.recoverZombie(s,`stuck in running >${f}ms (no completion)`)}async recoverZombie(t,e){if(t.status!=="pending"&&t.status!=="running")return;const s=`zombie recovered: ${e}`;t.status="failed",t.errorMessage=s,t.endedAt=Date.now(),t.durationMs=t.endedAt-t.startedAt,this.emitEvent(t.subId,"failed",{error:s}),t.completionResolve?.({output:"",error:s}),this.enqueueCompletion(t,"",s),this.persistFinalStatus(t,{status:"failed",errorMessage:s,endedAt:t.endedAt,durationMs:t.durationMs,availableTools:t.availableTools,contextSnapshot:void 0});try{await t.runtime.stop()}catch{}}async findRecordInStore(t){for(const e of this.parentToSubs.keys()){const n=(await this.store.read(e)).subAgents.find(i=>i.subId===t);if(n)return n}}handleRuntimeEvent(t,e){const s=this.subAgents.get(t);if(!s)return;const n=s.contextSnapshot;switch(n.updatedAt=new Date().toISOString(),e?.type){case"session_started":n.currentTool="[starting]",this.emitEvent(t,"progress",{snapshot:{...n}});break;case"startup_phase":n.currentTool=`[startup:${e.data?.phase??"unknown"}]`,this.emitEvent(t,"progress",{snapshot:{...n}});break;case"mcp_status":e.data?.action==="call_tool"?(n.currentTool=e.data?.tool,this.emitEvent(t,"tool_start",{tool:n.currentTool,snapshot:{...n}})):e.data?.action==="tool_result"?(this.emitEvent(t,"tool_end",{tool:n.currentTool,snapshot:{...n}}),n.currentTool=void 0):(n.currentTool="[mcp_init]",this.emitEvent(t,"progress",{snapshot:{...n}}));break;case"skill_status":n.currentTool="[skill_loaded]",this.emitEvent(t,"progress",{snapshot:{...n}});break;case"ai_request":e.data?.estimatedContextTokens!=null&&(n.tokenUsage.input=e.data.estimatedContextTokens??n.tokenUsage.input),n.currentTool="[model_request]",this.emitEvent(t,"progress",{snapshot:{...n}});break;case"context_compaction":e.data?.action==="start"?(n.currentTool="[context_compaction]",this.emitEvent(t,"progress",{snapshot:{...n}})):e.data?.action==="end"&&n.currentTool==="[context_compaction]"&&(n.currentTool=void 0,this.emitEvent(t,"progress",{snapshot:{...n}}));break;case"turn_complete":e.data?.usage?(n.tokenUsage.input=e.data.usage.inputTokens??n.tokenUsage.input,n.tokenUsage.output=e.data.usage.outputTokens??n.tokenUsage.output,this.emitEvent(t,"progress",{snapshot:{...n}})):(e.data?.failed||e.data?.aborted)&&(n.tokenUsage.output=0);break;case"assistant_delta":n.lastAssistantText=((n.lastAssistantText??"")+(e.data?.text??"")).slice(-500),n.messageCount+=1,this.emitEvent(t,"delta",{text:e.data?.text});break;case"session_complete":n.messageCount+=1;break}}emitEvent(t,e,s){const n={type:e,subId:t,timestamp:new Date().toISOString(),data:s},i=this.subscribers.get(t);if(i)for(const r of i)try{r(n)}catch{}const o=this.subscribers.get("*");if(o)for(const r of o)try{r(n)}catch{}if(e==="tool_start"||e==="tool_end"){const r=this.subAgents.get(t);r?(console.error(`[SubAgentManager] appendEvent: subId=${t} type=${e} tool=${s.tool??"?"} parentAgentId=${r.parentAgentId}`),this.store.appendEvent(r.parentAgentId,t,n).catch(a=>{console.error(`[SubAgentManager] appendEvent FAILED: subId=${t} error=${a instanceof Error?a.message:String(a)}`)})):console.error(`[SubAgentManager] appendEvent SKIPPED (entry not found): subId=${t} type=${e}`)}}toRecord(t){return{subId:t.subId,parentAgentId:t.parentAgentId,parentSessionId:t.parentSessionId,subagentType:t.subagentType,description:t.description,prompt:t.prompt,status:t.status,result:t.result,errorMessage:t.errorMessage,startedAt:t.startedAt,endedAt:t.endedAt,durationMs:t.durationMs,contextSnapshot:t.status==="running"?t.contextSnapshot:void 0,availableTools:t.availableTools}}getContextSnapshot(t){return this.subAgents.get(t)?.contextSnapshot}}async function c(p,t,e){if(t<=0)return await p;let s;try{return await new Promise((n,i)=>{s=setTimeout(()=>i(new Error(`${e} timed out after ${t}ms`)),t),p.then(n,i)})}finally{s&&clearTimeout(s)}}export{_ as SubAgentManager};
+