hyacinth-ai 0.9.19 → 0.9.20

package/dist/agents/delegate-tool.d.ts

@@ -25,6 +25,14 @@ export interface SubAgentContext {
     sandboxRoot?: string;
     /** 创建带独立 userId 的 Provider（子Agent 之间 + 与主Agent 的 KVCache 隔离） */
     createSubProvider(userId: string): Provider;
+    /** 异步子Agent 结果推送队列（主 loop 的 pendingAsyncResults，完成后自动注入对话） */
+    pendingAsyncResults?: Array<{
+        handle: string;
+        agentName: string;
+        status: 'completed' | 'failed';
+        result?: string;
+        error?: string;
+    }>;
 }
 /** 注册正在运行的子 Agent loop */
 export declare function registerRunningLoop(instanceId: string, loop: AgentLoop): void;
@@ -32,6 +40,29 @@ export declare function registerRunningLoop(instanceId: string, loop: AgentLoop)
 export declare function unregisterRunningLoop(instanceId: string): void;
 /** 中断指定子 Agent */
 export declare function interruptSubAgentLoop(instanceId: string): boolean;
+export interface AsyncSubAgentTask {
+    handle: string;
+    agentName: string;
+    instanceId: string;
+    task: string;
+    status: 'running' | 'completed' | 'failed';
+    startTime: string;
+    endTime?: string;
+    result?: string;
+    error?: string;
+}
+/** 注册异步子 Agent 任务，返回 handle */
+export declare function registerAsyncTask(agentName: string, instanceId: string, task: string): string;
+/** 标记异步任务为已完成 */
+export declare function completeAsyncTask(handle: string, result: string): void;
+/** 标记异步任务为失败 */
+export declare function failAsyncTask(handle: string, error: string): void;
+/** 获取所有异步任务列表 */
+export declare function listAsyncTasks(): AsyncSubAgentTask[];
+/** 按 handle 获取异步任务 */
+export declare function getAsyncTask(handle: string): AsyncSubAgentTask | undefined;
+/** 等待所有运行中的异步子 Agent 任务完成（用于优雅关闭） */
+export declare function waitForAsyncTasks(timeoutMs?: number): Promise<void>;
 /** 销毁子 Agent session 目录（清理 conversation/events/stats/meta） */
 export declare function destroySubAgentSession(parentSessionDir: string, instanceId: string): Promise<boolean>;
 /**
@@ -73,6 +104,14 @@ export declare class DelegateToAgentTool implements Tool {
                 type: "string";
                 description: string;
             };
+            async: {
+                type: "boolean";
+                description: string;
+            };
+            across_turns: {
+                type: "boolean";
+                description: string;
+            };
         };
         required: string[];
     };
@@ -81,7 +120,14 @@ export declare class DelegateToAgentTool implements Tool {
     constructor(agentRegistry: AgentRegistry, parentContext: SubAgentContext);
     execute(args: Record<string, unknown>): Promise<string>;
     /**
-     * 委托模式：单个子 Agent 执行任务
+     * 异步委托：在后台启动子 Agent，立即返回任务句柄。
+     * 子 Agent 的 loop.run() 在后台 Promise 中执行，完成后结果写入 AsyncSubAgentTask。
+     */
+    private executeAsync;
+    /** 后台执行子 Agent 任务 */
+    private runAsyncInBackground;
+    /**
+     * 委托模式：单个子 Agent 执行任务（同步阻塞）
      */
     private executeDelegate;
     /**

package/dist/agents/delegate-tool.js

@@ -33,6 +33,57 @@ export function interruptSubAgentLoop(instanceId) {
     loop.interrupt();
     return true;
 }
+const asyncTasks = new Map();
+let asyncTaskCounter = 0;
+/** 注册异步子 Agent 任务，返回 handle */
+export function registerAsyncTask(agentName, instanceId, task) {
+    const handle = `sub_${String(++asyncTaskCounter).padStart(3, '0')}`;
+    asyncTasks.set(handle, {
+        handle,
+        agentName,
+        instanceId,
+        task,
+        status: 'running',
+        startTime: new Date().toISOString(),
+    });
+    return handle;
+}
+/** 标记异步任务为已完成 */
+export function completeAsyncTask(handle, result) {
+    const t = asyncTasks.get(handle);
+    if (t) {
+        t.status = 'completed';
+        t.endTime = new Date().toISOString();
+        t.result = result;
+    }
+}
+/** 标记异步任务为失败 */
+export function failAsyncTask(handle, error) {
+    const t = asyncTasks.get(handle);
+    if (t) {
+        t.status = 'failed';
+        t.endTime = new Date().toISOString();
+        t.error = error;
+    }
+}
+/** 获取所有异步任务列表 */
+export function listAsyncTasks() {
+    return [...asyncTasks.values()];
+}
+/** 按 handle 获取异步任务 */
+export function getAsyncTask(handle) {
+    return asyncTasks.get(handle);
+}
+/** 等待所有运行中的异步子 Agent 任务完成（用于优雅关闭） */
+export async function waitForAsyncTasks(timeoutMs = 5000) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        const running = listAsyncTasks().filter(t => t.status === 'running');
+        if (running.length === 0)
+            return;
+        await new Promise(resolve => setTimeout(resolve, 200));
+    }
+}
 /** 销毁子 Agent session 目录（清理 conversation/events/stats/meta） */
 export async function destroySubAgentSession(parentSessionDir, instanceId) {
     const subDir = path.join(parentSessionDir, 'sub-agents', instanceId);
@@ -57,6 +108,11 @@ export async function createSubAgentLoop(agentDef, task, parentContext) {
     const instanceId = agentDef.instanceId ?? `${agentDef.name}-default`;
     const subSessionDir = path.join(parentContext.sessionDir, 'sub-agents', instanceId);
     const ttlMinutes = agentDef.sessionTtlMinutes ?? 10;
+    // 并发保护：同一 instanceId 已有活跃 loop 时拒绝，防止会话文件并发写入冲突
+    if (runningLoops.has(instanceId)) {
+        throw new Error(`子 Agent "${agentDef.name}" (${instanceId}) 正在执行中，不能同时委派第二个任务。` +
+            '等待当前任务完成后重试，或使用 spawn_sub_agent 创建独立实例来并行执行。');
+    }
     // TTL 检查：过期则清理重建
     let isNew = false;
     try {
@@ -163,6 +219,7 @@ export class DelegateToAgentTool {
         '"parallel"（并行分工）：同时启动多个子 Agent 并行执行，汇总结果。' +
         '编排场景：当你有一个复杂计划时，自己负责规划和决策，将其中可并行的子任务分别委派给多个子 Agent 同步执行——spawn_sub_agent 可克隆多份实例，配合不同的 instance_id 并发调度，大幅缩短总耗时。' +
         '会话复用：子 Agent 会话在 TTL 窗口内持久化（默认 10 分钟），相同 instance_id 再次委派时自动恢复完整对话记忆，无需重新交代背景。' +
+        '异步执行：设置 async=true 后子 Agent 在后台运行，主 Agent 立即获得任务句柄（如 sub_001）并可继续其他工作。之后用 list_sub_agent_tasks 查看所有异步任务状态，get_sub_agent_result <handle> 获取已完成任务的结果。默认 async=false（同步阻塞，等待结果返回）。' +
         '使用 list_sub_agents 查看可用 Agent 及其实例 ID，create_sub_agent 创建新 Agent，spawn_sub_agent 克隆以支持并行，destroy_sub_agent 清理不再需要的实例。';
     inputSchema = {
         type: 'object',
@@ -183,6 +240,14 @@ export class DelegateToAgentTool {
                 type: 'string',
                 description: '可选的附加上下文（如相关代码片段、文件路径、背景信息）。',
             },
+            async: {
+                type: 'boolean',
+                description: '是否异步执行。默认 false（阻塞等待结果）。设为 true 时立即返回任务句柄（如 sub_001），子 Agent 在后台执行，主 Agent 可继续其他工具调用。',
+            },
+            across_turns: {
+                type: 'boolean',
+                description: '异步结果是否允许跨 turn。默认 false——子Agent完成后结果在当前 turn 内自动注入对话，LLM 立即看到并继续处理。设为 true 时结果不自动注入，需手动用 get_sub_agent_result 获取（适用于需要跨多轮对话的后台任务）。仅在 async=true 时生效。',
+            },
         },
         required: ['task'],
     };
@@ -197,6 +262,8 @@ export class DelegateToAgentTool {
         const agentName = args.agent_name;
         const task = args.task;
         const context = args.context;
+        const runAsync = args.async === true;
+        const acrossTurns = args.across_turns === true;
         if (!agentName && !instanceId) {
             return 'Error: either agent_name or instance_id is required. Use list_sub_agents to see available agents and their instance IDs.';
         }
@@ -219,19 +286,23 @@ export class DelegateToAgentTool {
         if (!agentDef) {
             return 'Error: no sub-agent found matching the provided criteria.';
         }
+        // 异步模式下不支持 adversarial 和 parallel（这两种本身就是多Agent协同，异步应逐个个委派）
+        if (runAsync && agentDef.collaborationMode !== 'delegate') {
+            return `错误：异步模式仅支持 collaborationMode="delegate"。当前模式为 "${agentDef.collaborationMode}"。请用 spawn_sub_agent 克隆独立实例，然后对每个实例分别用 async=true 委派。`;
+        }
         // 构造完整任务描述
         const fullTask = context ? `${task}\n\nAdditional Context:\n${context}` : task;
         try {
+            if (runAsync) {
+                return await this.executeAsync(agentDef, fullTask, acrossTurns);
+            }
             if (agentDef.collaborationMode === 'adversarial') {
-                // 对抗审查模式：找一个不同角色的子 Agent 同时审查
                 return await this.executeAdversarial(agentDef, fullTask);
             }
             else if (agentDef.collaborationMode === 'parallel') {
-                // 并行分工模式：所有 parallel 模式的子 Agent 并行执行
                 return await this.executeParallel(agentDef, fullTask);
             }
             else {
-                // 委托模式：直接委托给子 Agent
                 return await this.executeDelegate(agentDef, fullTask);
             }
         }
@@ -241,7 +312,54 @@ export class DelegateToAgentTool {
         }
     }
     /**
-     * 委托模式：单个子 Agent 执行任务
+     * 异步委托：在后台启动子 Agent，立即返回任务句柄。
+     * 子 Agent 的 loop.run() 在后台 Promise 中执行，完成后结果写入 AsyncSubAgentTask。
+     */
+    async executeAsync(agentDef, task, acrossTurns) {
+        const instanceId = agentDef.instanceId;
+        const handle = registerAsyncTask(agentDef.name, instanceId, task);
+        // 在后台启动子 Agent，不阻塞。catch 兜底防止未处理的 Promise rejection
+        this.runAsyncInBackground(handle, agentDef, task, acrossTurns).catch((err) => {
+            const message = err instanceof Error ? err.message : String(err);
+            failAsyncTask(handle, message);
+            if (!acrossTurns) {
+                this.parentContext.pendingAsyncResults?.push({ handle, agentName: agentDef.name, status: 'failed', error: message });
+            }
+        });
+        const hint = acrossTurns
+            ? `跨 turn 模式——任务完成后需手动用 get_sub_agent_result ${handle} 获取结果。`
+            : '回合内模式——子Agent完成后结果将自动注入当前对话。';
+        return `异步子 Agent 任务已启动。\n句柄: ${handle}\nAgent: ${agentDef.name} (${instanceId})\n${hint}\n任务: ${task.slice(0, 100)}${task.length > 100 ? '...' : ''}`;
+    }
+    /** 后台执行子 Agent 任务 */
+    async runAsyncInBackground(handle, agentDef, task, acrossTurns) {
+        const instanceId = agentDef.instanceId;
+        try {
+            const { loop, sessionDir, isNew } = await createSubAgentLoop(agentDef, task, this.parentContext);
+            registerRunningLoop(instanceId, loop);
+            if (!isNew) {
+                await fs.utimes(path.join(sessionDir, 'meta.json'), new Date(), new Date()).catch(() => { });
+            }
+            await loop.run(task);
+            unregisterRunningLoop(instanceId);
+            const result = await this.collectResult(agentDef, task);
+            completeAsyncTask(handle, result);
+            if (!acrossTurns) {
+                // 回合内模式：推送到主 loop 队列，当前 turn 自动注入结果
+                this.parentContext.pendingAsyncResults?.push({ handle, agentName: agentDef.name, status: 'completed', result });
+            }
+        }
+        catch (error) {
+            unregisterRunningLoop(instanceId);
+            const message = error instanceof Error ? error.message : String(error);
+            failAsyncTask(handle, message);
+            if (!acrossTurns) {
+                this.parentContext.pendingAsyncResults?.push({ handle, agentName: agentDef.name, status: 'failed', error: message });
+            }
+        }
+    }
+    /**
+     * 委托模式：单个子 Agent 执行任务（同步阻塞）
      */
     async executeDelegate(agentDef, task) {
         const instanceId = agentDef.instanceId;

package/dist/gateway/factory.js

@@ -424,12 +424,15 @@ export async function createAgent(options, supervisor) {
     for (const agent of agents) {
         agentRegistry.register(agent);
     }
+    // 异步子Agent 结果队列——先创建引用，后续赋给 loop
+    const pendingAsyncResults = [];
     const delegateTool = new DelegateToAgentTool(agentRegistry, {
         modelRouter,
         toolRegistry,
         sessionDir,
         maxContextTokens: maxContext,
         dependencyAnalyzer,
+        pendingAsyncResults,
         createSubProvider: (userId) => {
             if (!subProviderApiKey || !subProviderBaseType) {
                 throw new Error('Cannot create sub-agent provider: main provider not configured.');
@@ -517,6 +520,7 @@ export async function createAgent(options, supervisor) {
     const loop = new AgentLoop(provider, contextComposer, compressor, orchestrator, toolExecutor, toolRegistry, conversationStore, eventStore, statsManager, sessionDir, summaryStore, effectiveMaxTurns, maxContext, outputHandler, skillRegistry, mcpSystem.getBridge(), dependencyAnalyzer, agentRegistry, effectivePersonaDir, flowRegistry, providerRouter, new Set(config.safety?.dangerousTools ?? ['write', 'bash']), new Set(), configCenter, modelRouter, turnRecorder);
     // 注入知识库状态引用
     loop.kbState = kbState;
+    loop.pendingAsyncResults = pendingAsyncResults; // 异步子Agent结果队列（和 delegateTool 共享引用）
     loopRef = loop; // wire fallback notification
     // 注入旁路 Provider 引用（供模式切换时 setBypassUserId 使用）
     if (bypassProvider)

package/dist/lifecycle/supervisor.js

@@ -1,5 +1,6 @@
 import { ProcessManager } from './manager.js';
 import { LocalModelManager } from './local-model.js';
+import { waitForAsyncTasks } from '../agents/delegate-tool.js';
 /**
  * LifecycleSupervisor — 统一管理所有受管进程的生命周期。
  *
@@ -184,6 +185,8 @@ export class LifecycleSupervisor {
         if (this.backgroundRegistry) {
             await this.backgroundRegistry.shutdownAll().catch(() => { });
         }
+        // 等待异步子 Agent 任务完成（最多等 5 秒）
+        await waitForAsyncTasks(5000).catch(() => { });
         const results = this.entities.map((e) => e.manager.stop().catch(() => {
             // 单个关闭失败不影响其他
         }));

package/dist/orchestrator/loop.d.ts

@@ -151,6 +151,14 @@ export declare class AgentLoop {
         name: string;
         firedAt: string;
     }>;
+    /** 异步子Agent 完成后的结果队列（delegate-tool 写入，主循环消费） */
+    pendingAsyncResults: Array<{
+        handle: string;
+        agentName: string;
+        status: 'completed' | 'failed';
+        result?: string;
+        error?: string;
+    }>;
     /** 当前正在执行的定时任务名（供 TUI 显示上下文），run 前设置，run 后清除 */
     pendingTaskName: string | null;
     /** 知识库状态引用（factory 注入） */

package/dist/orchestrator/loop.js

@@ -203,6 +203,8 @@ export class AgentLoop {
     schedulerInitialized = false;
     /** 定时任务触发后待注入对话的通知 */
     pendingTaskNotifications = [];
+    /** 异步子Agent 完成后的结果队列（delegate-tool 写入，主循环消费） */
+    pendingAsyncResults = [];
     /** 当前正在执行的定时任务名（供 TUI 显示上下文），run 前设置，run 后清除 */
     pendingTaskName = null;
     /** 知识库状态引用（factory 注入） */
@@ -1159,6 +1161,23 @@ export class AgentLoop {
                 turnCount++;
                 if (result.toolCalled)
                     toolWasCalled = true;
+                // ── 异步子Agent 结果回合内注入 ─────────────────────────
+                // delegate-tool 中异步任务完成后会将结果推送到此队列。
+                // 本轮迭代结束后检查：有已完成的结果→注入对话→强制继续迭代，
+                // 让 LLM 在当前 turn 内拿到结果并做出反应，无需跨 turn 手动查。
+                if (this.pendingAsyncResults.length > 0) {
+                    const results = this.pendingAsyncResults.splice(0);
+                    for (const r of results) {
+                        const content = r.status === 'completed'
+                            ? `[异步子Agent ${r.handle} (${r.agentName}) 已完成]\n${r.result ?? ''}`
+                            : `[异步子Agent ${r.handle} (${r.agentName}) 执行失败]\n${r.error ?? ''}`;
+                        await this.conversationStore.append(this.sessionDir, {
+                            role: 'user',
+                            content: [{ type: 'text', text: content }],
+                        });
+                    }
+                    result.stop = false; // 强制继续迭代，让 LLM 看到注入的异步结果
+                }
                 // 更新 stats
                 await this.statsManager.increment(this.sessionDir, 'turn_count', 1);
                 // ── 旁路Agent 迭代审查（每次 LLM 回复后） ──────────

package/dist/registry/tool.registry.js

@@ -3,7 +3,7 @@ import { getActiveRouterName } from '../context/profiles.js';
 import path from 'node:path';
 import fs from 'node:fs';
 import { createGetConfigTool, createUpdateConfigTool, createConfigSchemaTool, createResetConfigTool, } from '../tools/config.js';
-import { createSwitchProviderTool, createListProvidersTool, createProviderInfoTool, createSwitchToAutoRouteTool, createToggleToolTool, createListToolsTool, createToggleSkillTool, createListSkillsTool, createToggleSubAgentTool, createListSubAgentsTool, createSpawnSubAgentTool, createCreateSubAgentTool, createUpdateSubAgentTool, createInterruptTool, createSessionStatsTool, createCurrentSessionTool, createListSessionsTool, createNewSessionTool, createSwitchSessionTool, createDeleteSessionTool, createAllowToolTool, createDisallowToolTool, createListAllowlistTool, createAddTaskTool, createRemoveTaskTool, createListTasksTool, createToggleTaskTool, createMcpStatusTool, createListModelChannelsTool, createAddModelChannelTool, createRemoveModelChannelTool, createSetChannelRoleTool, createSetChannelModelTool, createResetChannelModelTool, createChannelInfoTool, } from '../tools/runtime-control.js';
+import { createSwitchProviderTool, createListProvidersTool, createProviderInfoTool, createSwitchToAutoRouteTool, createToggleToolTool, createListToolsTool, createToggleSkillTool, createListSkillsTool, createToggleSubAgentTool, createListSubAgentsTool, createSpawnSubAgentTool, createCreateSubAgentTool, createUpdateSubAgentTool, createListSubAgentTasksTool, createGetSubAgentResultTool, createInterruptTool, createSessionStatsTool, createCurrentSessionTool, createListSessionsTool, createNewSessionTool, createSwitchSessionTool, createDeleteSessionTool, createAllowToolTool, createDisallowToolTool, createListAllowlistTool, createAddTaskTool, createRemoveTaskTool, createListTasksTool, createToggleTaskTool, createMcpStatusTool, createListModelChannelsTool, createAddModelChannelTool, createRemoveModelChannelTool, createSetChannelRoleTool, createSetChannelModelTool, createResetChannelModelTool, createChannelInfoTool, } from '../tools/runtime-control.js';
 /**
  * 工具注册表
  * 负责注册、查询工具，以及生成 LLM 格式的工具定义
@@ -110,6 +110,9 @@ export class ToolRegistry extends GenericRegistry {
         this.register(createSpawnSubAgentTool(agentRegistry));
         this.register(createCreateSubAgentTool(agentRegistry, cwd));
         this.register(createUpdateSubAgentTool(agentRegistry));
+        // ── 异步子 Agent 任务工具 (2) ─────────────────────────────────
+        this.register(createListSubAgentTasksTool());
+        this.register(createGetSubAgentResultTool());
         // destroy_sub_agent needs factory.ts sessionDir; register in factory.ts after loop is created
         // (handled by importing and registering createDestroySubAgentTool directly in factory.ts)
         // ── Session control tools (7) ────────────────────────

package/dist/tools/runtime-control.d.ts

@@ -51,6 +51,14 @@ export declare function createToggleSubAgentTool(agentRegistry: AgentRegistry, c
  * list_sub_agents — list all registered sub-agents with their enabled/disabled status and instance IDs.
  */
 export declare function createListSubAgentsTool(agentRegistry: any): Tool;
+/**
+ * list_sub_agent_tasks — 列出所有异步子 Agent 任务及其状态。
+ */
+export declare function createListSubAgentTasksTool(): Tool;
+/**
+ * get_sub_agent_result — 获取异步子 Agent 任务的执行结果。
+ */
+export declare function createGetSubAgentResultTool(): Tool;
 /**
  * spawn_sub_agent — clone an existing sub-agent to create a parallel instance (分身).
  */

package/dist/tools/runtime-control.js

@@ -1,5 +1,6 @@
 import { clearPromptCache } from '../prompts/loader.js';
 import { switchRouter } from '../context/profiles.js';
+import { listAsyncTasks, getAsyncTask } from '../agents/delegate-tool.js';
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
@@ -359,6 +360,69 @@ export function createListSubAgentsTool(agentRegistry) {
         },
     };
 }
+// ── 异步子 Agent 任务管理工具 ──
+/**
+ * list_sub_agent_tasks — 列出所有异步子 Agent 任务及其状态。
+ */
+export function createListSubAgentTasksTool() {
+    return {
+        name: 'list_sub_agent_tasks',
+        description: '列出所有通过 delegate_to_agent(async=true) 启动的异步子 Agent 任务。包含句柄、Agent 名称、任务描述、状态（running/completed/failed）、启动时间和结果摘要。',
+        inputSchema: { type: 'object', properties: {} },
+        async execute(_args) {
+            const tasks = listAsyncTasks();
+            if (tasks.length === 0) {
+                return '暂无异步子 Agent 任务。使用 delegate_to_agent 并设置 async=true 来启动异步任务。';
+            }
+            const lines = [`异步子 Agent 任务（共 ${tasks.length} 个）：`];
+            for (const t of tasks) {
+                const statusLabel = t.status === 'running' ? '执行中' : t.status === 'completed' ? '已完成' : '失败';
+                const statusIcon = t.status === 'running' ? '🔄' : t.status === 'completed' ? '✅' : '❌';
+                lines.push(`  ${statusIcon} ${t.handle} [${statusLabel}] ${t.agentName} (instance: ${t.instanceId}): ${t.task.slice(0, 60)}${t.task.length > 60 ? '...' : ''}`);
+                if (t.status !== 'running' && t.result) {
+                    const summary = t.result.split('\n').find(l => l.trim())?.slice(0, 80) ?? '';
+                    lines.push(`     ↳ ${summary}${summary.length >= 80 ? '...' : ''}`);
+                }
+            }
+            lines.push('');
+            lines.push('使用 get_sub_agent_result <handle> 获取已完成任务的完整结果。');
+            return lines.join('\n');
+        },
+    };
+}
+/**
+ * get_sub_agent_result — 获取异步子 Agent 任务的执行结果。
+ */
+export function createGetSubAgentResultTool() {
+    return {
+        name: 'get_sub_agent_result',
+        description: '获取指定异步子 Agent 任务的执行结果。running 时返回仍在执行中，completed 时返回完整结果，failed 时返回错误信息。句柄从 list_sub_agent_tasks 获取。',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                handle: {
+                    type: 'string',
+                    description: '异步任务句柄（如 sub_001），从 list_sub_agent_tasks 获取。',
+                },
+            },
+            required: ['handle'],
+        },
+        async execute(args) {
+            const handle = args.handle;
+            const task = getAsyncTask(handle);
+            if (!task) {
+                return `错误：未找到异步任务 "${handle}"。使用 list_sub_agent_tasks 查看所有任务及其句柄。`;
+            }
+            if (task.status === 'running') {
+                return `任务 ${handle}（${task.agentName}）仍在执行中。任务：${task.task.slice(0, 100)}${task.task.length > 100 ? '...' : ''}\n启动时间：${task.startTime}\n请稍后再次调用 get_sub_agent_result 查询。`;
+            }
+            if (task.status === 'failed') {
+                return `任务 ${handle}（${task.agentName}）执行失败。\n错误：${task.error}\n任务：${task.task}`;
+            }
+            return `任务 ${handle}（${task.agentName}）已完成。\n\n${task.result}`;
+        },
+    };
+}
 /**
  * spawn_sub_agent — clone an existing sub-agent to create a parallel instance (分身).
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hyacinth-ai",
-  "version": "0.9.19",
+  "version": "0.9.20",
   "description": "Hyacinth 🪻 — multi-provider AI agent with tool system and context management",
   "type": "module",
   "main": "dist/index.js",