@code4bug/jarvis-agent 1.0.3 → 1.1.4

package/dist/core/SubAgentBridge.js

@@ -0,0 +1,191 @@
+/**
+ * SubAgentBridge — 单个 SubAgent 的 Worker 线程桥接
+ *
+ * 职责：
+ *   - 创建并管理 SubAgent Worker 线程
+ *   - 转发 Worker 事件到上层回调
+ *   - 处理危险命令确认的双向通信
+ *   - 代理 MessageBus publish/subscribe 请求（跨线程通讯）
+ *   - 支持中断
+ */
+import { Worker } from 'worker_threads';
+import { fileURLToPath } from 'url';
+import path from 'path';
+import { agentMessageBus } from './AgentMessageBus.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+/** 创建 SubAgent Worker（兼容 tsx 开发模式与编译后 .js） */
+function createSubAgentWorker() {
+    const workerTsPath = path.join(__dirname, 'subAgentWorker.ts');
+    const isTsx = __filename.endsWith('.ts');
+    if (isTsx) {
+        const inlineScript = `
+import { tsImport } from 'tsx/esm/api';
+import { workerData } from 'worker_threads';
+import { pathToFileURL } from 'url';
+await tsImport(workerData.__workerFile, pathToFileURL(workerData.__workerFile).href);
+`;
+        return new Worker(inlineScript, {
+            eval: true,
+            workerData: { __workerFile: workerTsPath },
+        });
+    }
+    return new Worker(workerTsPath.replace(/\.ts$/, '.js'));
+}
+export class SubAgentBridge {
+    worker = null;
+    /**
+     * 在独立 Worker 线程中执行 SubAgent 任务
+     * @returns SubAgentResult（包含最终输出、消息列表、transcript）
+     */
+    run(task, callbacks) {
+        return new Promise((resolve, reject) => {
+            const worker = createSubAgentWorker();
+            this.worker = worker;
+            // 收集 SubAgent 产生的所有消息，用于汇总结果
+            const collectedMessages = [];
+            let finalTranscript = [];
+            worker.on('message', async (msg) => {
+                switch (msg.type) {
+                    case 'message':
+                        collectedMessages.push(msg.msg);
+                        callbacks.onMessage(msg.taskId, msg.msg);
+                        break;
+                    case 'update_message':
+                        callbacks.onUpdateMessage(msg.taskId, msg.id, msg.updates);
+                        break;
+                    case 'stream_text':
+                        callbacks.onStreamText(msg.taskId, msg.text);
+                        break;
+                    case 'loop_state':
+                        callbacks.onLoopStateChange(msg.taskId, msg.state);
+                        break;
+                    case 'danger_confirm_request': {
+                        const choice = callbacks.onConfirmDangerousCommand
+                            ? await callbacks.onConfirmDangerousCommand(msg.taskId, msg.command, msg.reason, msg.ruleName)
+                            : 'cancel';
+                        const reply = {
+                            type: 'danger_confirm_result',
+                            requestId: msg.requestId,
+                            choice,
+                        };
+                        worker.postMessage(reply);
+                        break;
+                    }
+                    // ===== MessageBus IPC 代理 =====
+                    case 'bus_publish': {
+                        agentMessageBus.publish(msg.from, msg.channel, msg.payload);
+                        const ack = { type: 'bus_publish_ack', requestId: msg.requestId };
+                        worker.postMessage(ack);
+                        break;
+                    }
+                    case 'bus_subscribe': {
+                        // 在主线程侧等待消息，结果回传 Worker
+                        agentMessageBus.subscribe(msg.channel, msg.timeoutMs, msg.fromOffset).then((busMsg) => {
+                            const reply = {
+                                type: 'bus_subscribe_result',
+                                requestId: msg.requestId,
+                                message: busMsg,
+                            };
+                            worker.postMessage(reply);
+                        });
+                        break;
+                    }
+                    case 'bus_read_history': {
+                        const history = agentMessageBus.getHistory(msg.channel, msg.limit);
+                        const reply = {
+                            type: 'bus_read_history_result',
+                            requestId: msg.requestId,
+                            messages: history,
+                        };
+                        worker.postMessage(reply);
+                        break;
+                    }
+                    case 'bus_get_offset': {
+                        const offset = agentMessageBus.getOffset(msg.channel);
+                        const reply = {
+                            type: 'bus_get_offset_result',
+                            requestId: msg.requestId,
+                            offset,
+                        };
+                        worker.postMessage(reply);
+                        break;
+                    }
+                    case 'bus_list_channels': {
+                        const channels = agentMessageBus.listChannels();
+                        const reply = {
+                            type: 'bus_list_channels_result',
+                            requestId: msg.requestId,
+                            channels,
+                        };
+                        worker.postMessage(reply);
+                        break;
+                    }
+                    case 'done':
+                        finalTranscript = msg.transcript;
+                        this.worker = null;
+                        worker.terminate();
+                        // 从 transcript 中提取最终输出文本
+                        resolve({
+                            taskId: msg.taskId,
+                            status: 'done',
+                            output: extractFinalOutput(msg.transcript),
+                            messages: collectedMessages,
+                            transcript: finalTranscript,
+                        });
+                        break;
+                    case 'error':
+                        this.worker = null;
+                        worker.terminate();
+                        resolve({
+                            taskId: msg.taskId,
+                            status: 'error',
+                            output: '',
+                            messages: collectedMessages,
+                            transcript: finalTranscript,
+                            error: msg.message,
+                        });
+                        break;
+                }
+            });
+            worker.on('error', (err) => {
+                this.worker = null;
+                reject(err);
+            });
+            worker.on('exit', (code) => {
+                if (this.worker) {
+                    // Worker 退出但未发送 done/error，说明异常终止
+                    this.worker = null;
+                    reject(new Error(`SubAgent Worker 意外退出，code=${code}`));
+                }
+            });
+            const runMsg = { type: 'run', task };
+            worker.postMessage(runMsg);
+        });
+    }
+    /** 中断 SubAgent 执行 */
+    abort() {
+        if (this.worker) {
+            const msg = { type: 'abort' };
+            this.worker.postMessage(msg);
+        }
+    }
+}
+/** 从 transcript 中提取最后一条 assistant 文本作为最终输出 */
+function extractFinalOutput(transcript) {
+    for (let i = transcript.length - 1; i >= 0; i--) {
+        const msg = transcript[i];
+        if (msg.role === 'assistant') {
+            if (typeof msg.content === 'string')
+                return msg.content;
+            // ContentBlock[] — 取最后一个 text block
+            const blocks = msg.content;
+            for (let j = blocks.length - 1; j >= 0; j--) {
+                if (blocks[j].type === 'text' && blocks[j].text) {
+                    return blocks[j].text;
+                }
+            }
+        }
+    }
+    return '';
+}

package/dist/core/WorkerBridge.d.ts

@@ -1,5 +1,5 @@
-import { TranscriptMessage } from '../types/index';
-import { EngineCallbacks } from './QueryEngine';
+import { TranscriptMessage } from '../types/index.js';
+import { EngineCallbacks } from './QueryEngine.js';
 export declare class WorkerBridge {
     private worker;
     /** 在独立 Worker 线程中执行查询，返回更新后的 transcript */

package/dist/core/WorkerBridge.js

@@ -5,6 +5,8 @@
 import { Worker } from 'worker_threads';
 import { fileURLToPath } from 'url';
 import path from 'path';
+import { agentMessageBus } from './AgentMessageBus.js';
+import { spawnSubAgentInMainThread } from '../tools/spawnAgent.js';
 // 兼容 ESM __dirname
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -72,6 +74,72 @@ export class WorkerBridge {
                         worker.postMessage(reply);
                         break;
                     }
+                    case 'subagent_message':
+                        // SubAgent 消息：推送到 UI（已携带 subAgentId）
+                        callbacks.onSubAgentMessage?.(msg.msg);
+                        break;
+                    case 'subagent_update_message':
+                        callbacks.onSubAgentUpdateMessage?.(msg.id, msg.updates);
+                        break;
+                    // ===== MessageBus IPC 代理（queryWorker → 主线程） =====
+                    case 'bus_publish': {
+                        agentMessageBus.publish(msg.from, msg.channel, msg.payload);
+                        const ack = { type: 'bus_publish_ack', requestId: msg.requestId };
+                        worker.postMessage(ack);
+                        break;
+                    }
+                    case 'bus_subscribe': {
+                        agentMessageBus.subscribe(msg.channel, msg.timeoutMs, msg.fromOffset).then((busMsg) => {
+                            const reply = {
+                                type: 'bus_subscribe_result',
+                                requestId: msg.requestId,
+                                message: busMsg,
+                            };
+                            worker.postMessage(reply);
+                        });
+                        break;
+                    }
+                    case 'bus_read_history': {
+                        const history = agentMessageBus.getHistory(msg.channel, msg.limit);
+                        const reply = {
+                            type: 'bus_read_history_result',
+                            requestId: msg.requestId,
+                            messages: history,
+                        };
+                        worker.postMessage(reply);
+                        break;
+                    }
+                    case 'bus_get_offset': {
+                        const offset = agentMessageBus.getOffset(msg.channel);
+                        const reply = {
+                            type: 'bus_get_offset_result',
+                            requestId: msg.requestId,
+                            offset,
+                        };
+                        worker.postMessage(reply);
+                        break;
+                    }
+                    case 'bus_list_channels': {
+                        const channels = agentMessageBus.listChannels();
+                        const reply = {
+                            type: 'bus_list_channels_result',
+                            requestId: msg.requestId,
+                            channels,
+                        };
+                        worker.postMessage(reply);
+                        break;
+                    }
+                    // ===== spawn_subagent IPC（在主线程创建 SubAgentBridge）=====
+                    case 'spawn_subagent': {
+                        const result = spawnSubAgentInMainThread(msg.taskId, msg.instruction, msg.agentLabel, msg.allowedTools);
+                        const reply = {
+                            type: 'spawn_subagent_result',
+                            requestId: msg.requestId,
+                            result,
+                        };
+                        worker.postMessage(reply);
+                        break;
+                    }
                     case 'done':
                         this.worker = null;
                         worker.terminate();

package/dist/core/busAccess.d.ts

@@ -0,0 +1,9 @@
+import type { BusMessage } from './AgentMessageBus.js';
+export interface BusAccessor {
+    publish(from: string, channel: string, payload: string): Promise<void> | void;
+    subscribe(channel: string, timeoutMs?: number, fromOffset?: number): Promise<BusMessage | null>;
+    getHistory(channel: string, limit?: number): Promise<BusMessage[]> | BusMessage[];
+    getOffset(channel: string): Promise<number> | number;
+    listChannels(): Promise<string[]> | string[];
+}
+export declare function getBus(): Promise<BusAccessor>;

package/dist/core/busAccess.js

@@ -0,0 +1,32 @@
+/**
+ * busAccess — 统一的 MessageBus 访问入口
+ *
+ * 解决跨线程访问问题：
+ *   - 主线程：直接使用 agentMessageBus 单例
+ *   - SubAgent Worker 线程：使用 workerBusProxy（通过 IPC 代理到主线程）
+ *
+ * 工具层统一通过此模块访问，无需关心当前运行环境。
+ */
+import { isMainThread } from 'worker_threads';
+let _bus = null;
+export async function getBus() {
+    if (_bus)
+        return _bus;
+    if (isMainThread) {
+        // 主线程：直接使用单例
+        const { agentMessageBus } = await import('./AgentMessageBus.js');
+        _bus = {
+            publish: (from, channel, payload) => { agentMessageBus.publish(from, channel, payload); },
+            subscribe: (channel, timeoutMs, fromOffset) => agentMessageBus.subscribe(channel, timeoutMs, fromOffset),
+            getHistory: (channel, limit) => agentMessageBus.getHistory(channel, limit),
+            getOffset: (channel) => agentMessageBus.getOffset(channel),
+            listChannels: () => agentMessageBus.listChannels(),
+        };
+    }
+    else {
+        // Worker 线程：使用独立的 IPC 代理模块（避免循环依赖）
+        const { workerBusProxy } = await import('./workerBusProxy.js');
+        _bus = workerBusProxy;
+    }
+    return _bus;
+}

package/dist/core/hint.js

@@ -6,10 +6,10 @@
  */
 import fs from 'fs';
 import path from 'path';
-import { getAgent } from '../agents/index';
-import { DEFAULT_AGENT } from '../config/constants';
-import { loadConfig, getActiveModel } from '../config/loader';
-import { getDefaultConfig } from '../services/api/llm';
+import { getAgent } from '../agents/index.js';
+import { DEFAULT_AGENT } from '../config/constants.js';
+import { loadConfig, getActiveModel } from '../config/loader.js';
+import { getDefaultConfig } from '../services/api/llm.js';
 /** 安全读取 JSON 文件 */
 function readJsonSafe(filePath) {
     try {

package/dist/core/query.d.ts

@@ -15,6 +15,10 @@ export interface QueryCallbacks {
      * @param ruleName 匹配的规则名
      */
     onConfirmDangerousCommand?: (command: string, reason: string, ruleName: string) => Promise<DangerConfirmResult>;
+    /** SubAgent 产生消息时透传到主线程 UI（由 dispatch_subagent 工具触发） */
+    onSubAgentMessage?: (msg: Message) => void;
+    /** SubAgent 更新已有消息时透传 */
+    onSubAgentUpdateMessage?: (id: string, updates: Partial<Message>) => void;
 }
 /**
  * 单轮 Agentic Loop：推理 → 工具调用 → 循环

package/dist/core/query.js

@@ -2,12 +2,74 @@ import { v4 as uuid } from 'uuid';
 import { Worker } from 'worker_threads';
 import { fileURLToPath } from 'url';
 import path from 'path';
-import { findToolMerged as findTool } from '../tools/index';
-import { MAX_ITERATIONS } from '../config/constants';
-import { sanitizeOutput, validateCommand, authorizeCommand, authorizeRule } from './safeguard';
+import { findToolMerged as findTool } from '../tools/index.js';
+import { MAX_ITERATIONS, CONTEXT_TOKEN_LIMIT } from '../config/constants.js';
+import { sanitizeOutput, validateCommand, authorizeCommand, authorizeRule } from './safeguard.js';
 // 兼容 ESM __dirname
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
+// ===== Transcript 上下文压缩 =====
+/**
+ * 粗略估算字符串的 token 数（按 4 字符/token 估算，中文按 2 字符/token）
+ * 仅用于判断是否需要压缩，不要求精确
+ */
+function estimateTokens(text) {
+    // 中文字符占比高时每字约 1.5 token，英文约 0.25 token/char
+    const cjk = (text.match(/[\u4e00-\u9fff\u3400-\u4dbf]/g) || []).length;
+    const rest = text.length - cjk;
+    return Math.ceil(cjk * 1.5 + rest * 0.25);
+}
+/**
+ * 对 transcript 中的 tool_result 做滑动压缩：
+ * - 保留最近 N 条 tool_result 完整内容
+ * - 更早的 tool_result 截断到 maxOldChars 字符
+ * - 确保总估算 token 不超过 CONTEXT_TOKEN_LIMIT
+ */
+function compressTranscript(transcript) {
+    // 单条工具结果最大字符数
+    const MAX_TOOL_RESULT_CHARS = 3000;
+    // 旧条目压缩到的字符数
+    const MAX_OLD_TOOL_RESULT_CHARS = 800;
+    // 保留最近几条完整
+    const KEEP_RECENT = 2;
+    // 先对所有 tool_result 做单条截断
+    let result = transcript.map((msg) => {
+        if (msg.role !== 'tool_result')
+            return msg;
+        const content = msg.content;
+        if (content.length <= MAX_TOOL_RESULT_CHARS)
+            return msg;
+        return {
+            ...msg,
+            content: content.slice(0, MAX_TOOL_RESULT_CHARS) + `\n...[已截断，原始长度 ${content.length} 字符]`,
+        };
+    });
+    // 估算总 token，超限则压缩旧 tool_result
+    const totalTokens = estimateTokens(result.map((m) => {
+        if (typeof m.content === 'string')
+            return m.content;
+        return JSON.stringify(m.content);
+    }).join(''));
+    if (totalTokens <= CONTEXT_TOKEN_LIMIT)
+        return result;
+    // 找出所有 tool_result 的索引，保留最近 KEEP_RECENT 条，其余压缩
+    const toolResultIndices = result
+        .map((m, i) => (m.role === 'tool_result' ? i : -1))
+        .filter((i) => i >= 0);
+    const toCompress = toolResultIndices.slice(0, Math.max(0, toolResultIndices.length - KEEP_RECENT));
+    result = result.map((msg, i) => {
+        if (!toCompress.includes(i))
+            return msg;
+        const content = msg.content;
+        if (content.length <= MAX_OLD_TOOL_RESULT_CHARS)
+            return msg;
+        return {
+            ...msg,
+            content: content.slice(0, MAX_OLD_TOOL_RESULT_CHARS) + `\n...[已压缩]`,
+        };
+    });
+    return result;
+}
 /**
  * 单轮 Agentic Loop：推理 → 工具调用 → 循环
  */
@@ -24,7 +86,7 @@ export async function executeQuery(userInput, transcript, _tools, service, callb
     while (loopState.iteration < MAX_ITERATIONS && !abortSignal.aborted) {
         loopState.iteration++;
         callbacks.onLoopStateChange({ ...loopState });
-        const result = await runOneIteration(localTranscript, _tools, service, callbacks, abortSignal);
+        const result = await runOneIteration(compressTranscript(localTranscript), _tools, service, callbacks, abortSignal);
         // 构建 assistant transcript 块
         const assistantBlocks = [];
         if (result.text)
@@ -58,6 +120,10 @@ export async function executeQuery(userInput, transcript, _tools, service, callb
         if (result.toolCalls.length > 1 && canRunInParallel(result.toolCalls)) {
             toolResults = await executeToolsInParallel(result.toolCalls, callbacks, abortSignal);
         }
+        else if (result.toolCalls.length > 1 && canRunInParallelDirect(result.toolCalls)) {
+            // dispatch_subagent 等需要 toolCallbacks 的工具：用 executeTool 并行执行
+            toolResults = await Promise.all(result.toolCalls.map((tc) => executeTool(tc, callbacks, abortSignal).then((r) => ({ tc, ...r }))));
+        }
         else {
             toolResults = [];
             for (const tc of result.toolCalls) {
@@ -207,6 +273,9 @@ async function runOneIteration(transcript, tools, service, callbacks, abortSigna
 // ===== 并行执行判断 =====
 /** 判断一组工具调用是否可以并行执行（无写-写冲突、无读-写冲突） */
 function canRunInParallel(calls) {
+    // run_agent / spawn_agent 需要 toolCallbacks 传递消息，不能走 runToolInWorker 路径
+    if (calls.some((c) => c.name === 'run_agent' || c.name === 'spawn_agent'))
+        return false;
     // 写操作工具集合
     const WRITE_TOOLS = new Set(['WriteFile', 'Bash']);
     // 读操作工具集合
@@ -228,6 +297,14 @@ function canRunInParallel(calls) {
     // 其余情况（如多个只读 skill）允许并行
     return true;
 }
+/**
+ * 判断是否可以用 executeTool 直接并行（适用于 dispatch_subagent 等需要 toolCallbacks 的工具）
+ * 这些工具在主线程 Worker 里执行，可以正确传递 callbacks，但不能用 runToolInWorker
+ */
+function canRunInParallelDirect(calls) {
+    // 全部是 run_agent / spawn_agent 时，可以用 executeTool 并行（各自启动独立 SubAgent Worker）
+    return calls.every((c) => c.name === 'run_agent' || c.name === 'spawn_agent');
+}
 // ===== 并行工具执行（多 Worker 线程） =====
 /** 在独立 Worker 线程中执行单个工具，返回结果字符串 */
 function runToolInWorker(tc, abortSignal) {
@@ -430,7 +507,16 @@ async function executeTool(tc, callbacks, abortSignal) {
     }
     try {
         const start = Date.now();
-        const result = await tool.execute(tc.input, abortSignal);
+        const result = await tool.execute(tc.input, abortSignal, {
+            onSubAgentMessage: (msg) => {
+                // SubAgent 消息只走 onSubAgentMessage，避免与主 Agent 消息流混淆
+                callbacks.onSubAgentMessage?.(msg);
+            },
+            onSubAgentUpdateMessage: (id, updates) => {
+                // SubAgent 更新只走 onSubAgentUpdateMessage，跳过主 Agent 的节流逻辑
+                callbacks.onSubAgentUpdateMessage?.(id, updates);
+            },
+        });
         // 对工具输出统一脱敏
         const safeResult = sanitizeOutput(result);
         // 工具执行期间被中断

package/dist/core/queryWorker.d.ts

@@ -1,5 +1,6 @@
 import { DangerConfirmResult } from './query.js';
 import { TranscriptMessage, Message, LoopState, Session } from '../types/index.js';
+import { BusMessage } from './AgentMessageBus.js';
 export type WorkerInbound = {
     type: 'run';
     userInput: string;
@@ -10,6 +11,29 @@ export type WorkerInbound = {
     type: 'danger_confirm_result';
     requestId: string;
     choice: DangerConfirmResult;
+} | {
+    type: 'bus_publish_ack';
+    requestId: string;
+} | {
+    type: 'bus_subscribe_result';
+    requestId: string;
+    message: BusMessage | null;
+} | {
+    type: 'bus_read_history_result';
+    requestId: string;
+    messages: BusMessage[];
+} | {
+    type: 'bus_get_offset_result';
+    requestId: string;
+    offset: number;
+} | {
+    type: 'bus_list_channels_result';
+    requestId: string;
+    channels: string[];
+} | {
+    type: 'spawn_subagent_result';
+    requestId: string;
+    result: string;
 };
 export type WorkerOutbound = {
     type: 'message';
@@ -35,6 +59,44 @@ export type WorkerOutbound = {
     command: string;
     reason: string;
     ruleName: string;
+} | {
+    type: 'subagent_message';
+    msg: Message;
+} | {
+    type: 'subagent_update_message';
+    id: string;
+    updates: Partial<Message>;
+} | {
+    type: 'bus_publish';
+    requestId: string;
+    from: string;
+    channel: string;
+    payload: string;
+} | {
+    type: 'bus_subscribe';
+    requestId: string;
+    channel: string;
+    timeoutMs: number;
+    fromOffset?: number;
+} | {
+    type: 'bus_read_history';
+    requestId: string;
+    channel: string;
+    limit?: number;
+} | {
+    type: 'bus_get_offset';
+    requestId: string;
+    channel: string;
+} | {
+    type: 'bus_list_channels';
+    requestId: string;
+} | {
+    type: 'spawn_subagent';
+    requestId: string;
+    taskId: string;
+    instruction: string;
+    agentLabel: string;
+    allowedTools?: string[];
 } | {
     type: 'done';
     transcript: TranscriptMessage[];

package/dist/core/queryWorker.js

@@ -8,6 +8,8 @@ import { getAllTools } from '../tools/index.js';
 import { LLMServiceImpl } from '../services/api/llm.js';
 import { MockService } from '../services/api/mock.js';
 import { loadConfig, getActiveModel } from '../config/loader.js';
+import { pendingBusRequests } from './workerBusProxy.js';
+import { pendingSpawnRequests } from './spawnRegistry.js';
 if (!parentPort)
     throw new Error('queryWorker must run inside worker_threads');
 // ===== 初始化 LLM 服务 =====
@@ -38,6 +40,37 @@ parentPort.on('message', async (msg) => {
         }
         return;
     }
+    // MessageBus IPC 回复分发 → 转发给 workerBusProxy 的 pending map
+    if (msg.type === 'bus_publish_ack' ||
+        msg.type === 'bus_subscribe_result' ||
+        msg.type === 'bus_read_history_result' ||
+        msg.type === 'bus_get_offset_result' ||
+        msg.type === 'bus_list_channels_result') {
+        const resolve = pendingBusRequests.get(msg.requestId);
+        if (resolve) {
+            pendingBusRequests.delete(msg.requestId);
+            if (msg.type === 'bus_publish_ack')
+                resolve(undefined);
+            else if (msg.type === 'bus_subscribe_result')
+                resolve(msg.message);
+            else if (msg.type === 'bus_read_history_result')
+                resolve(msg.messages);
+            else if (msg.type === 'bus_get_offset_result')
+                resolve(msg.offset);
+            else if (msg.type === 'bus_list_channels_result')
+                resolve(msg.channels);
+        }
+        return;
+    }
+    // spawn_subagent IPC 回复 → 转发给 pendingSpawnRequests
+    if (msg.type === 'spawn_subagent_result') {
+        const resolve = pendingSpawnRequests.get(msg.requestId);
+        if (resolve) {
+            pendingSpawnRequests.delete(msg.requestId);
+            resolve(msg.result);
+        }
+        return;
+    }
     if (msg.type === 'run') {
         abortSignal.aborted = false;
         const send = (out) => parentPort.postMessage(out);
@@ -54,6 +87,8 @@ parentPort.on('message', async (msg) => {
                     send({ type: 'danger_confirm_request', requestId, command, reason, ruleName });
                 });
             },
+            onSubAgentMessage: (msg) => send({ type: 'subagent_message', msg }),
+            onSubAgentUpdateMessage: (id, updates) => send({ type: 'subagent_update_message', id, updates }),
         };
         try {
             const newTranscript = await executeQuery(msg.userInput, msg.transcript, getAllTools(), service, callbacks, abortSignal);

package/dist/core/spawnRegistry.d.ts

@@ -0,0 +1,16 @@
+/**
+ * spawnRegistry — spawn_subagent IPC 挂起请求注册表
+ *
+ * 独立模块，避免 spawnAgent.ts ↔ queryWorker.ts 循环依赖。
+ * queryWorker.ts 和 spawnAgent.ts 都可以安全 import 此模块。
+ */
+/** 等待主线程完成 SubAgent 启动的挂起 Promise，key = requestId */
+export declare const pendingSpawnRequests: Map<string, (result: string) => void>;
+/** 增加运行中 SubAgent 计数 */
+export declare function incrementActiveAgents(): void;
+/** 减少运行中 SubAgent 计数 */
+export declare function decrementActiveAgents(): void;
+/** 获取当前运行中 SubAgent 数量 */
+export declare function getActiveAgentCount(): number;
+/** 订阅计数变更，返回取消订阅函数 */
+export declare function subscribeAgentCount(listener: (count: number) => void): () => void;