@code4bug/jarvis-agent 1.0.4 → 1.1.5

package/dist/core/query.js

@@ -3,15 +3,82 @@ import { Worker } from 'worker_threads';
 import { fileURLToPath } from 'url';
 import path from 'path';
 import { findToolMerged as findTool } from '../tools/index.js';
-import { MAX_ITERATIONS } from '../config/constants.js';
+import { MAX_ITERATIONS, CONTEXT_TOKEN_LIMIT } from '../config/constants.js';
 import { sanitizeOutput, validateCommand, authorizeCommand, authorizeRule } from './safeguard.js';
+import { logError, logInfo, logWarn } from './logger.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：推理 → 工具调用 → 循环
  */
 export async function executeQuery(userInput, transcript, _tools, service, callbacks, abortSignal) {
+    logInfo('agent_loop.start', {
+        inputLength: userInput.length,
+        initialTranscriptLength: transcript.length,
+    });
     const localTranscript = [...transcript];
     localTranscript.push({ role: 'user', content: userInput });
     const loopState = {
@@ -23,8 +90,19 @@ export async function executeQuery(userInput, transcript, _tools, service, callb
     callbacks.onLoopStateChange({ ...loopState });
     while (loopState.iteration < MAX_ITERATIONS && !abortSignal.aborted) {
         loopState.iteration++;
+        logInfo('agent_loop.iteration.start', {
+            iteration: loopState.iteration,
+            transcriptLength: localTranscript.length,
+        });
         callbacks.onLoopStateChange({ ...loopState });
-        const result = await runOneIteration(localTranscript, _tools, service, callbacks, abortSignal);
+        const result = await runOneIteration(compressTranscript(localTranscript), _tools, service, callbacks, abortSignal);
+        logInfo('agent_loop.iteration.result', {
+            iteration: loopState.iteration,
+            textLength: result.text.length,
+            toolCallCount: result.toolCalls.length,
+            duration: result.duration,
+            tokenCount: result.tokenCount,
+        });
         // 构建 assistant transcript 块
         const assistantBlocks = [];
         if (result.text)
@@ -40,6 +118,10 @@ export async function executeQuery(userInput, transcript, _tools, service, callb
             break;
         // 中断发生在推理阶段
         if (abortSignal.aborted) {
+            logWarn('agent_loop.aborted_before_tool_execution', {
+                iteration: loopState.iteration,
+                toolCallCount: result.toolCalls.length,
+            });
             for (const tc of result.toolCalls) {
                 const skippedResult = `[用户中断] 工具 ${tc.name} 未执行（用户按下 ESC 中断）`;
                 localTranscript.push({ role: 'tool_result', toolUseId: tc.id, content: skippedResult });
@@ -58,6 +140,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) {
@@ -79,11 +165,20 @@ export async function executeQuery(userInput, transcript, _tools, service, callb
     loopState.aborted = abortSignal.aborted;
     callbacks.onLoopStateChange({ ...loopState });
     if (abortSignal.aborted) {
+        logWarn('agent_loop.aborted', {
+            finalIteration: loopState.iteration,
+            transcriptLength: localTranscript.length,
+        });
         localTranscript.push({
             role: 'user',
             content: '[系统提示] 用户中断了上一轮回复（按下 ESC）。上一条助手消息可能不完整，请在后续回复中注意这一点。',
         });
     }
+    logInfo('agent_loop.done', {
+        finalIteration: loopState.iteration,
+        aborted: abortSignal.aborted,
+        transcriptLength: localTranscript.length,
+    });
     return localTranscript;
 }
 /** 执行一次 LLM 调用 */
@@ -95,6 +190,10 @@ async function runOneIteration(transcript, tools, service, callbacks, abortSigna
     let tokenCount = 0;
     let firstTokenTime = null;
     const thinkingId = uuid();
+    logInfo('llm.iteration.requested', {
+        transcriptLength: transcript.length,
+        toolCount: tools.length,
+    });
     callbacks.onMessage({
         id: thinkingId,
         type: 'thinking',
@@ -202,11 +301,23 @@ async function runOneIteration(transcript, tools, service, callbacks, abortSigna
         });
     }
     const effectiveText = accumulatedText || (accumulatedThinking && toolCalls.length === 0 ? accumulatedThinking : '');
+    logInfo('llm.iteration.completed', {
+        duration,
+        tokenCount,
+        firstTokenLatency,
+        tokensPerSecond,
+        textLength: effectiveText.length,
+        thinkingLength: accumulatedThinking.length,
+        toolCallCount: toolCalls.length,
+    });
     return { text: effectiveText, toolCalls, duration, tokenCount, firstTokenLatency, tokensPerSecond };
 }
 // ===== 并行执行判断 =====
 /** 判断一组工具调用是否可以并行执行（无写-写冲突、无读-写冲突） */
 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 +339,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) {
@@ -281,17 +400,27 @@ export async function runToolDirect(tc, abortSignal) {
     if (!tool)
         return `错误: 未知工具 ${tc.name}`;
     try {
+        logInfo('tool.direct.start', { toolName: tc.name, toolArgs: tc.input });
         const result = await tool.execute(tc.input, abortSignal);
         const { sanitizeOutput } = await import('./safeguard.js');
+        logInfo('tool.direct.done', {
+            toolName: tc.name,
+            resultLength: String(result).length,
+        });
         return sanitizeOutput(result);
     }
     catch (err) {
+        logError('tool.direct.failed', err, { toolName: tc.name, toolArgs: tc.input });
         return `错误: ${err.message || '工具执行失败'}`;
     }
 }
 /** 并行执行多个工具，每个工具在独立 Worker 线程中运行，实时更新 UI */
 async function executeToolsInParallel(calls, callbacks, abortSignal) {
     const groupId = uuid();
+    logInfo('tool.parallel_group.start', {
+        groupId,
+        toolNames: calls.map((call) => call.name),
+    });
     // 为每个工具预先创建 pending 消息节点（TUI 立即渲染占位）
     const msgIds = calls.map((tc) => {
         const msgId = uuid();
@@ -356,11 +485,18 @@ async function executeToolsInParallel(calls, callbacks, abortSignal) {
         }
         catch (err) {
             const errMsg = err.message || '工具执行失败';
+            logError('tool.parallel.failed', err, { groupId, toolName: tc.name, toolArgs: tc.input });
             callbacks.onUpdateMessage(msgId, { status: 'error', content: errMsg, toolResult: errMsg });
             return { tc, content: `错误: ${errMsg}`, isError: false };
         }
     });
-    return Promise.all(tasks);
+    const results = await Promise.all(tasks);
+    logInfo('tool.parallel_group.done', {
+        groupId,
+        toolNames: calls.map((call) => call.name),
+        errorCount: results.filter((item) => item.isError).length,
+    });
+    return results;
 }
 /** 执行工具并返回结果 */
 async function executeTool(tc, callbacks, abortSignal) {
@@ -385,6 +521,11 @@ async function executeTool(tc, callbacks, abortSignal) {
         toolName: tc.name,
         toolArgs: tc.input,
     });
+    logInfo('tool.execute.start', {
+        toolName: tc.name,
+        toolArgs: tc.input,
+        toolExecId,
+    });
     // ===== 安全围栏：Bash 命令拦截 + 交互式确认 =====
     if (tc.name === 'Bash' && tc.input.command) {
         const command = tc.input.command;
@@ -393,6 +534,7 @@ async function executeTool(tc, callbacks, abortSignal) {
             if (!check.canOverride) {
                 // critical 级别：直接禁止
                 const errMsg = `${check.reason}\n🚫 该命令已被永久禁止，无法通过授权绕过。\n命令: ${command}`;
+                logWarn('tool.execute.blocked', { toolName: tc.name, command, reason: check.reason });
                 callbacks.onUpdateMessage(toolExecId, { status: 'error', content: errMsg, toolResult: errMsg });
                 return { content: `错误: ${errMsg}`, isError: true };
             }
@@ -403,6 +545,7 @@ async function executeTool(tc, callbacks, abortSignal) {
                 const userChoice = await callbacks.onConfirmDangerousCommand(command, reason, ruleName);
                 if (userChoice === 'cancel') {
                     const cancelMsg = `⛔ 用户取消执行危险命令: ${command}`;
+                    logWarn('tool.execute.cancelled_by_user', { toolName: tc.name, command, reason });
                     callbacks.onUpdateMessage(toolExecId, { status: 'error', content: cancelMsg, toolResult: cancelMsg });
                     return { content: cancelMsg, isError: true };
                 }
@@ -425,12 +568,22 @@ async function executeTool(tc, callbacks, abortSignal) {
     const tool = findTool(tc.name);
     if (!tool) {
         const errMsg = `未知工具: ${tc.name}`;
+        logWarn('tool.execute.unknown', { toolName: tc.name });
         callbacks.onUpdateMessage(toolExecId, { status: 'error', content: errMsg });
         return { content: errMsg, isError: true };
     }
     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);
         // 工具执行期间被中断
@@ -453,10 +606,22 @@ async function executeTool(tc, callbacks, abortSignal) {
             duration: Date.now() - start,
             ...(wasAborted ? { abortHint: '命令已中断（ESC）' } : {}),
         });
+        logInfo('tool.execute.done', {
+            toolName: tc.name,
+            toolExecId,
+            duration: Date.now() - start,
+            aborted: Boolean(wasAborted),
+            resultLength: safeResult.length,
+        });
         return { content: safeResult, isError: false };
     }
     catch (err) {
         const errMsg = err.message || '工具执行失败';
+        logError('tool.execute.failed', err, {
+            toolName: tc.name,
+            toolArgs: tc.input,
+            toolExecId,
+        });
         callbacks.onUpdateMessage(toolExecId, {
             status: 'error',
             content: errMsg,

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,8 +8,12 @@ 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';
+import { logError, logInfo, logWarn } from './logger.js';
 if (!parentPort)
     throw new Error('queryWorker must run inside worker_threads');
+logInfo('query_worker.ready');
 // ===== 初始化 LLM 服务 =====
 const config = loadConfig();
 const activeModel = getActiveModel(config);
@@ -28,6 +32,7 @@ const pendingConfirms = new Map();
 parentPort.on('message', async (msg) => {
     if (msg.type === 'abort') {
         abortSignal.aborted = true;
+        logWarn('query_worker.abort_received');
         return;
     }
     if (msg.type === 'danger_confirm_result') {
@@ -38,8 +43,43 @@ 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;
+        logInfo('query_worker.run.start', {
+            inputLength: msg.userInput.length,
+            transcriptLength: msg.transcript.length,
+        });
         const send = (out) => parentPort.postMessage(out);
         const callbacks = {
             onMessage: (m) => send({ type: 'message', msg: m }),
@@ -54,12 +94,18 @@ 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);
+            logInfo('query_worker.run.done', {
+                transcriptLength: newTranscript.length,
+            });
             send({ type: 'done', transcript: newTranscript });
         }
         catch (err) {
+            logError('query_worker.run.failed', err);
             send({ type: 'error', message: err.message ?? '未知错误' });
         }
     }

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;

package/dist/core/spawnRegistry.js

@@ -0,0 +1,32 @@
+/**
+ * spawnRegistry — spawn_subagent IPC 挂起请求注册表
+ *
+ * 独立模块，避免 spawnAgent.ts ↔ queryWorker.ts 循环依赖。
+ * queryWorker.ts 和 spawnAgent.ts 都可以安全 import 此模块。
+ */
+/** 等待主线程完成 SubAgent 启动的挂起 Promise，key = requestId */
+export const pendingSpawnRequests = new Map();
+// ===== 运行中 SubAgent 计数器 =====
+/** 当前运行中的 SubAgent 数量 */
+let _activeAgentCount = 0;
+/** 计数变更订阅者列表 */
+const _countListeners = new Set();
+/** 增加运行中 SubAgent 计数 */
+export function incrementActiveAgents() {
+    _activeAgentCount++;
+    _countListeners.forEach((fn) => fn(_activeAgentCount));
+}
+/** 减少运行中 SubAgent 计数 */
+export function decrementActiveAgents() {
+    _activeAgentCount = Math.max(0, _activeAgentCount - 1);
+    _countListeners.forEach((fn) => fn(_activeAgentCount));
+}
+/** 获取当前运行中 SubAgent 数量 */
+export function getActiveAgentCount() {
+    return _activeAgentCount;
+}
+/** 订阅计数变更，返回取消订阅函数 */
+export function subscribeAgentCount(listener) {
+    _countListeners.add(listener);
+    return () => _countListeners.delete(listener);
+}

package/dist/core/subAgentWorker.d.ts

@@ -0,0 +1,89 @@
+import { DangerConfirmResult } from './query.js';
+import { TranscriptMessage, Message, LoopState, SubAgentTask } from '../types/index.js';
+import { BusMessage } from './AgentMessageBus.js';
+export type SubAgentInbound = {
+    type: 'run';
+    task: SubAgentTask;
+} | {
+    type: 'abort';
+} | {
+    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[];
+};
+export type SubAgentOutbound = {
+    type: 'message';
+    taskId: string;
+    msg: Message;
+} | {
+    type: 'update_message';
+    taskId: string;
+    id: string;
+    updates: Partial<Message>;
+} | {
+    type: 'stream_text';
+    taskId: string;
+    text: string;
+} | {
+    type: 'loop_state';
+    taskId: string;
+    state: LoopState;
+} | {
+    type: 'danger_confirm_request';
+    taskId: string;
+    requestId: string;
+    command: string;
+    reason: string;
+    ruleName: string;
+} | {
+    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: 'done';
+    taskId: string;
+    transcript: TranscriptMessage[];
+} | {
+    type: 'error';
+    taskId: string;
+    message: string;
+};