multiclaws 0.4.40 → 0.4.41

package/dist/service/a2a-adapter.d.ts

@@ -16,16 +16,16 @@ export type A2AAdapterOptions = {
     };
 };
 /**
- * Bridges the A2A protocol to OpenClaw's sessions_spawn gateway tool.
+ * Bridges the A2A protocol to OpenClaw's session injection mechanism.
  *
  * When a remote agent sends a task via A2A `message/send`,
  * this executor:
  * 1. Classifies the task risk (safe vs risky)
- * 2. Notifies the local human owner
- * 3. For risky tasks: waits for explicit human approval
- *    For safe tasks: executes immediately
- * 4. Calls OpenClaw's `sessions_spawn` (run mode) to start execution
- * 5. Waits for the sub-agent to call back via `multiclaws_a2a_callback`
+ * 2. For risky tasks: pushes approval request to the user's active session and waits
+ *    For safe tasks: proceeds immediately
+ * 3. Finds the target session (where user last sent a message, or main session)
+ * 4. Injects the task into that session via sessions_send — no isolated sub-session created
+ * 5. Waits for the session AI to call back via `multiclaws_a2a_callback`
  * 6. Returns the final result as a Message
  */
 export declare class OpenClawAgentExecutor implements AgentExecutor {
@@ -61,6 +61,13 @@ export declare class OpenClawAgentExecutor implements AgentExecutor {
      * or rejects on timeout or cancellation.
      */
     private createApprovalCallback;
+    /**
+     * Find the best target session for task injection:
+     * 1. Prefer the session where the user most recently sent a message (role === "user")
+     * 2. Fall back to the first non-internal active session (typically the main webchat session)
+     * Never returns internal sessions (delegate-*, a2a-*).
+     */
+    private findTargetSession;
     /**
      * Discover the most recently active non-internal session via sessions_list.
      * Used as fallback when no notification targets have been registered yet

package/dist/service/a2a-adapter.js

@@ -58,16 +58,16 @@ function extractTextFromMessage(message) {
         .join("\n");
 }
 /**
- * Bridges the A2A protocol to OpenClaw's sessions_spawn gateway tool.
+ * Bridges the A2A protocol to OpenClaw's session injection mechanism.
  *
  * When a remote agent sends a task via A2A `message/send`,
  * this executor:
  * 1. Classifies the task risk (safe vs risky)
- * 2. Notifies the local human owner
- * 3. For risky tasks: waits for explicit human approval
- *    For safe tasks: executes immediately
- * 4. Calls OpenClaw's `sessions_spawn` (run mode) to start execution
- * 5. Waits for the sub-agent to call back via `multiclaws_a2a_callback`
+ * 2. For risky tasks: pushes approval request to the user's active session and waits
+ *    For safe tasks: proceeds immediately
+ * 3. Finds the target session (where user last sent a message, or main session)
+ * 4. Injects the task into that session via sessions_send — no isolated sub-session created
+ * 5. Waits for the session AI to call back via `multiclaws_a2a_callback`
  * 6. Returns the final result as a Message
  */
 class OpenClawAgentExecutor {
@@ -114,24 +114,25 @@ class OpenClawAgentExecutor {
             eventBus.finished();
             return;
         }
-        // Classify risk and gate accordingly
+        // ── Step 1: Risk classification ──
         const risk = classifyTaskRisk(taskText);
-        this.logger.info(`[a2a-adapter] task ${taskId} risk=${risk}`);
+        this.logger.info(`[a2a-adapter] task ${taskId} [step:risk-classify] risk=${risk}, text="${taskText.slice(0, 60)}"`);
         if (risk === "risky") {
-            // Notify with approval request and wait
+            // ── Step 2a: Approval gate (risky tasks only) ──
             const approvalTimeoutMs = 5 * 60 * 1000; // 5 minutes
             const approvalPromise = this.createApprovalCallback(taskId, approvalTimeoutMs);
-            this.logger.info(`[a2a-adapter] task ${taskId} requesting human approval (timeout=${approvalTimeoutMs / 1000}s)`);
+            this.logger.info(`[a2a-adapter] task ${taskId} [step:approval-request] sending approval request to user (timeout=${approvalTimeoutMs / 1000}s)`);
             void this.notifyUser(buildApprovalRequest(taskId, fromAgentName, taskText));
             let approved;
             try {
                 approved = await approvalPromise;
+                this.logger.info(`[a2a-adapter] task ${taskId} [step:approval-result] user responded: approved=${approved}`);
             }
             catch (err) {
+                const errMsg = err instanceof Error ? err.message : String(err);
                 const isCanceled = err instanceof Error && err.message === "canceled";
                 if (isCanceled) {
-                    // Task was explicitly canceled — use the canonical "canceled" message
-                    this.logger.info(`[a2a-adapter] task ${taskId} canceled during approval wait`);
+                    this.logger.info(`[a2a-adapter] task ${taskId} [step:approval-result] caught "canceled" error → aborting task`);
                     this.taskTracker.update(taskId, { status: "failed", error: "canceled" });
                     this.publishMessage(eventBus, "Task was canceled.");
                     eventBus.finished();
@@ -139,61 +140,66 @@ class OpenClawAgentExecutor {
                 }
                 // Approval timed out → auto-reject
                 approved = false;
-                this.logger.warn(`[a2a-adapter] task ${taskId} approval timed out — auto-rejected`);
+                this.logger.warn(`[a2a-adapter] task ${taskId} [step:approval-result] caught error: ${errMsg} → treating as auto-reject`);
             }
             if (!approved) {
                 const reason = "用户拒绝或未在超时时间内授权。";
-                this.logger.info(`[a2a-adapter] task ${taskId} rejected`);
+                this.logger.info(`[a2a-adapter] task ${taskId} [step:approval-rejected] → aborting task, reason: ${reason}`);
                 this.taskTracker.update(taskId, { status: "failed", error: reason });
                 this.publishMessage(eventBus, `任务已被拒绝：${reason}`);
                 eventBus.finished();
                 return;
             }
-            this.logger.info(`[a2a-adapter] task ${taskId} approved by user`);
-            void this.notifyUser(`✅ 已授权，开始执行来自 **${fromAgentName}** 的任务…`);
+            this.logger.info(`[a2a-adapter] task ${taskId} [step:approval-passed] → proceeding to find target session`);
         }
         else {
-            // Safe task: notify but auto-execute
-            this.logger.info(`[a2a-adapter] task ${taskId} safe query — auto-executing`);
-            void this.notifyUser(`📨 收到来自 **${fromAgentName}** 的查询任务（安全，自动执行）：\n\n${taskText.slice(0, 300)}`);
+            this.logger.info(`[a2a-adapter] task ${taskId} [step:auto-execute] safe query, skipping approval → proceeding to find target session`);
         }
+        // ── Step 3: Find target session ──
+        this.logger.info(`[a2a-adapter] task ${taskId} [step:find-session] calling findTargetSession()`);
+        const targetSessionKey = await this.findTargetSession();
+        if (!targetSessionKey) {
+            const errMsg = "无法找到用户活跃 session，任务未执行。请确保至少有一个活跃的对话 session。";
+            this.logger.error(`[a2a-adapter] task ${taskId} [step:find-session] ✗ no target session found → aborting task`);
+            this.taskTracker.update(taskId, { status: "failed", error: errMsg });
+            this.publishMessage(eventBus, errMsg);
+            eventBus.finished();
+            return;
+        }
+        this.logger.info(`[a2a-adapter] task ${taskId} [step:find-session] ✓ target session = ${targetSessionKey}`);
         try {
-            // Create a promise that resolves when sub-agent calls multiclaws_a2a_callback
+            // ── Step 4: Register callback ──
             const timeoutMs = 180_000;
             const resultPromise = this.createCallback(taskId, timeoutMs);
-            this.logger.info(`[a2a-adapter] task ${taskId} callback registered (timeout=${timeoutMs / 1000}s)`);
-            // Spawn the subagent with instructions to call back when done
-            const prompt = buildA2ASubagentPrompt(taskId, taskText);
-            this.logger.info(`[a2a-adapter] task ${taskId} spawning sub-agent via sessions_spawn (cwd=${this.cwd}, sessionKey=a2a-${taskId})`);
-            const spawnResult = await (0, gateway_client_1.invokeGatewayTool)({
+            this.logger.info(`[a2a-adapter] task ${taskId} [step:register-callback] callback registered (timeout=${timeoutMs / 1000}s, pending total=${this.pendingCallbacks.size})`);
+            // ── Step 5: Inject task into target session ──
+            const prompt = buildA2AMainSessionPrompt(taskId, fromAgentName, taskText);
+            this.logger.info(`[a2a-adapter] task ${taskId} [step:inject-task] calling sessions_send(sessionKey=${targetSessionKey}, promptLen=${prompt.length})`);
+            await (0, gateway_client_1.invokeGatewayTool)({
                 gateway: this.gatewayConfig,
-                tool: "sessions_spawn",
-                args: {
-                    task: prompt,
-                    mode: "run",
-                    cwd: this.cwd,
-                },
-                sessionKey: `a2a-${taskId}`,
+                tool: "sessions_send",
+                args: { sessionKey: targetSessionKey, message: prompt },
                 timeoutMs: 15_000,
             });
-            this.logger.info(`[a2a-adapter] task ${taskId} sub-agent spawned — result=${JSON.stringify(spawnResult).slice(0, 200)}`);
-            this.logger.info(`[a2a-adapter] task ${taskId} waiting for callback from sub-agent...`);
-            // Wait for the sub-agent to call back
+            this.logger.info(`[a2a-adapter] task ${taskId} [step:inject-task] ✓ sessions_send succeeded → waiting for callback...`);
+            // ── Step 6: Wait for callback ──
             const output = await resultPromise;
-            // Return result and notify user
+            // ── Step 7: Return result ──
             this.taskTracker.update(taskId, { status: "completed", result: output });
-            this.logger.info(`[a2a-adapter] ✓ task ${taskId} completed — resultLen=${output.length}, preview=${output.slice(0, 120)}`);
-            void this.notifyUser(`✅ **来自 ${fromAgentName} 的任务已完成**\n\n${output.slice(0, 800)}`);
+            this.logger.info(`[a2a-adapter] task ${taskId} [step:completed] ✓ resultLen=${output.length}, preview="${output.slice(0, 120)}"`);
             this.publishMessage(eventBus, output || "Task completed with no output.");
         }
         catch (err) {
             const errorMsg = err instanceof Error ? err.message : String(err);
-            this.logger.error(`[a2a-adapter] ✗ task ${taskId} failed: ${errorMsg}`);
+            const isCanceled = err instanceof Error && err.message === "canceled";
+            const isTimeout = errorMsg.includes("timed out");
+            const errorType = isCanceled ? "canceled" : isTimeout ? "timeout" : "error";
+            this.logger.error(`[a2a-adapter] task ${taskId} [step:catch] ✗ type=${errorType}, reason: ${errorMsg} → marking failed, notifying user`);
             this.taskTracker.update(taskId, { status: "failed", error: errorMsg });
             void this.notifyUser(`❌ 来自 **${fromAgentName}** 的任务执行失败：${errorMsg}`);
             this.publishMessage(eventBus, `Error: ${errorMsg}`);
         }
-        this.logger.info(`[a2a-adapter] task ${taskId} eventBus.finished()`);
+        this.logger.info(`[a2a-adapter] task ${taskId} [step:finished] eventBus.finished()`);
         eventBus.finished();
     }
     /**
@@ -281,15 +287,81 @@ class OpenClawAgentExecutor {
             this.pendingApprovals.set(taskId, { resolve, reject, timer });
         });
     }
+    /**
+     * Find the best target session for task injection:
+     * 1. Prefer the session where the user most recently sent a message (role === "user")
+     * 2. Fall back to the first non-internal active session (typically the main webchat session)
+     * Never returns internal sessions (delegate-*, a2a-*).
+     */
+    async findTargetSession() {
+        if (!this.gatewayConfig) {
+            this.logger.warn(`[a2a-adapter] findTargetSession: skipped — no gateway config`);
+            return null;
+        }
+        try {
+            this.logger.info(`[a2a-adapter] findTargetSession: calling sessions_list (limit=20, activeMinutes=1440)`);
+            const raw = await (0, gateway_client_1.invokeGatewayTool)({
+                gateway: this.gatewayConfig,
+                tool: "sessions_list",
+                args: { limit: 20, activeMinutes: 1440, messageLimit: 3 },
+                timeoutMs: 5_000,
+            });
+            this.logger.info(`[a2a-adapter] findTargetSession: raw result = ${JSON.stringify(raw).slice(0, 500)}`);
+            // Unwrap gateway tool standard response: { content: [{ type: "text", text: "..." }] }
+            let parsed = raw;
+            if (raw?.content?.[0]?.type === "text") {
+                try {
+                    parsed = JSON.parse(raw.content[0].text);
+                    this.logger.info(`[a2a-adapter] findTargetSession: unwrapped gateway response successfully`);
+                }
+                catch (parseErr) {
+                    this.logger.warn(`[a2a-adapter] findTargetSession: failed to parse content[0].text as JSON — ${parseErr instanceof Error ? parseErr.message : String(parseErr)}, using raw object`);
+                }
+            }
+            const INTERNAL_PREFIXES = ["delegate-", "a2a-"];
+            const sessions = parsed?.sessions ?? [];
+            this.logger.info(`[a2a-adapter] findTargetSession: ${sessions.length} total sessions from gateway`);
+            const filtered = sessions.filter((s) => {
+                const k = (s.key ?? s.sessionKey);
+                return k && !INTERNAL_PREFIXES.some((p) => k.startsWith(p));
+            });
+            this.logger.info(`[a2a-adapter] findTargetSession: ${filtered.length} non-internal sessions after filtering`);
+            // Prefer sessions that have at least one user-originated message
+            const withUserMsg = filtered.filter((s) => Array.isArray(s.messages) && s.messages.some((m) => m.role === "user"));
+            // Fall back to any non-internal session (likely the main webchat session)
+            const target = withUserMsg[0] ?? filtered[0];
+            const targetKey = (target?.key ?? target?.sessionKey);
+            if (targetKey) {
+                const source = withUserMsg.length > 0 ? "user-message session" : "fallback non-internal session";
+                this.logger.info(`[a2a-adapter] findTargetSession: ✓ matched ${targetKey} (${source}, ${withUserMsg.length} with user msgs, ${filtered.length} total)`);
+            }
+            else {
+                this.logger.warn(`[a2a-adapter] findTargetSession: ✗ no target found (${sessions.length} raw, ${filtered.length} after filter, ${withUserMsg.length} with user msgs)`);
+                sessions.forEach((s, i) => {
+                    const k = (s.key ?? s.sessionKey) ?? "(no key)";
+                    const msgCount = Array.isArray(s.messages) ? s.messages.length : 0;
+                    this.logger.info(`[a2a-adapter] findTargetSession:   session[${i}]: key=${k}, messages=${msgCount}`);
+                });
+            }
+            return targetKey ?? null;
+        }
+        catch (err) {
+            this.logger.error(`[a2a-adapter] findTargetSession: ✗ caught error — ${err instanceof Error ? err.message : String(err)}, returning null`);
+            return null;
+        }
+    }
     /**
      * Discover the most recently active non-internal session via sessions_list.
      * Used as fallback when no notification targets have been registered yet
      * (e.g. right after a gateway restart before the user sends their first message).
      */
     async discoverActiveSession() {
-        if (!this.gatewayConfig)
+        if (!this.gatewayConfig) {
+            this.logger.warn(`[a2a-adapter] discoverActiveSession: skipped — no gateway config`);
             return null;
+        }
         try {
+            this.logger.info(`[a2a-adapter] discoverActiveSession: calling sessions_list (limit=10, activeMinutes=120)`);
             const raw = await (0, gateway_client_1.invokeGatewayTool)({
                 gateway: this.gatewayConfig,
                 tool: "sessions_list",
@@ -302,8 +374,11 @@ class OpenClawAgentExecutor {
             if (raw?.content?.[0]?.type === "text") {
                 try {
                     parsed = JSON.parse(raw.content[0].text);
+                    this.logger.info(`[a2a-adapter] discoverActiveSession: unwrapped gateway response successfully`);
+                }
+                catch (parseErr) {
+                    this.logger.warn(`[a2a-adapter] discoverActiveSession: failed to parse content[0].text as JSON — ${parseErr instanceof Error ? parseErr.message : String(parseErr)}, using raw object`);
                 }
-                catch { /* use raw */ }
             }
             const sessions = parsed?.sessions ?? [];
             this.logger.info(`[a2a-adapter] discoverActiveSession: found ${sessions.length} sessions`);
@@ -315,33 +390,34 @@ class OpenClawAgentExecutor {
             });
             const matchedKey = (session?.key ?? session?.sessionKey);
             if (matchedKey) {
-                this.logger.info(`[a2a-adapter] discoverActiveSession: matched session ${matchedKey}`);
+                this.logger.info(`[a2a-adapter] discoverActiveSession: ✓ matched session ${matchedKey}`);
             }
             else {
-                this.logger.warn(`[a2a-adapter] discoverActiveSession: all ${sessions.length} sessions filtered or empty`);
-                sessions.forEach((s) => this.logger.info(`[a2a-adapter]   session: ${(s.key ?? s.sessionKey) ?? "(no key)"}`));
+                this.logger.warn(`[a2a-adapter] discoverActiveSession: ✗ all ${sessions.length} sessions filtered or empty`);
+                sessions.forEach((s, i) => this.logger.info(`[a2a-adapter] discoverActiveSession:   session[${i}]: key=${(s.key ?? s.sessionKey) ?? "(no key)"}`));
             }
             return matchedKey ?? null;
         }
         catch (err) {
-            this.logger.warn(`[a2a-adapter] discoverActiveSession failed: ${err instanceof Error ? err.message : String(err)}`);
+            this.logger.error(`[a2a-adapter] discoverActiveSession: ✗ caught error — ${err instanceof Error ? err.message : String(err)}, returning null`);
             return null;
         }
     }
     /** Send a notification to all known targets. Individual failures are silently ignored. */
     async notifyUser(message) {
         const targets = this.getNotificationTargets();
+        this.logger.info(`[a2a-adapter] notifyUser: targets=${targets.size}, msgLen=${message.length}, preview="${message.slice(0, 80)}"`);
         if (!this.gatewayConfig) {
-            this.logger.info(`[a2a-adapter] notifyUser: skipped (no gateway config)`);
+            this.logger.warn(`[a2a-adapter] notifyUser: skipped — no gateway config, message lost`);
             return;
         }
         // Fallback: no registered targets yet (e.g. right after gateway restart).
         // Discover the active session and send directly via sessions_send.
         if (targets.size === 0) {
-            this.logger.info(`[a2a-adapter] notifyUser: no registered targets — attempting session discovery`);
-            const sessionKey = await this.discoverActiveSession();
+            this.logger.info(`[a2a-adapter] notifyUser: no registered targets → falling back to findTargetSession()`);
+            const sessionKey = await this.findTargetSession();
             if (sessionKey) {
-                this.logger.info(`[a2a-adapter] notifyUser: discovered session ${sessionKey}, sending via sessions_send`);
+                this.logger.info(`[a2a-adapter] notifyUser: fallback discovered session ${sessionKey} → calling sessions_send`);
                 try {
                     await (0, gateway_client_1.invokeGatewayTool)({
                         gateway: this.gatewayConfig,
@@ -349,22 +425,25 @@ class OpenClawAgentExecutor {
                         args: { sessionKey, message },
                         timeoutMs: 5_000,
                     });
+                    this.logger.info(`[a2a-adapter] notifyUser: ✓ fallback sessions_send to ${sessionKey} succeeded`);
                     // Also register this session for future notifications
                     if (this.registerDiscoveredTarget) {
                         this.registerDiscoveredTarget(sessionKey);
+                        this.logger.info(`[a2a-adapter] notifyUser: registered ${sessionKey} as notification target for future use`);
                     }
                 }
                 catch (err) {
-                    this.logger.warn(`[a2a-adapter] notifyUser: sessions_send to ${sessionKey} failed: ${err instanceof Error ? err.message : String(err)}`);
+                    this.logger.error(`[a2a-adapter] notifyUser: ✗ fallback sessions_send to ${sessionKey} failed: ${err instanceof Error ? err.message : String(err)}`);
                 }
             }
             else {
-                this.logger.warn(`[a2a-adapter] notifyUser: no active session found, message lost`);
+                this.logger.warn(`[a2a-adapter] notifyUser: ✗ findTargetSession returned null — no active session found, message lost`);
             }
             return;
         }
+        this.logger.info(`[a2a-adapter] notifyUser: sending to ${targets.size} registered target(s): [${[...targets.keys()].join(", ")}]`);
         const results = await Promise.allSettled([...targets.entries()].map(async ([key, target]) => {
-            this.logger.info(`[a2a-adapter] notifyUser: sending to ${key} (type=${target.type})`);
+            this.logger.info(`[a2a-adapter] notifyUser: → ${key} (type=${target.type})`);
             try {
                 await (target.type === "channel"
                     ? (0, gateway_client_1.invokeGatewayTool)({
@@ -374,23 +453,26 @@ class OpenClawAgentExecutor {
                         timeoutMs: 5_000,
                     })
                     : (0, gateway_client_1.invokeGatewayTool)({
-                        // sessions_send injects a message into the session so the AI
-                        // can relay it to the human (correct tool; was "chat.send" before)
                         gateway: this.gatewayConfig,
                         tool: "sessions_send",
                         args: { sessionKey: target.sessionKey, message },
                         timeoutMs: 5_000,
                     }));
-                this.logger.info(`[a2a-adapter] notifyUser: sent to ${key} ✓`);
+                this.logger.info(`[a2a-adapter] notifyUser: ✓ ${key} (${target.type}) succeeded`);
             }
             catch (err) {
-                this.logger.warn(`[a2a-adapter] notifyUser: failed to send to ${key}: ${err instanceof Error ? err.message : String(err)}`);
+                this.logger.error(`[a2a-adapter] notifyUser: ✗ ${key} (${target.type}) failed: ${err instanceof Error ? err.message : String(err)}`);
                 throw err;
             }
         }));
         const ok = results.filter((r) => r.status === "fulfilled").length;
         const fail = results.filter((r) => r.status === "rejected").length;
-        this.logger.info(`[a2a-adapter] notifyUser: done (${ok} ok, ${fail} failed)`);
+        if (fail === 0) {
+            this.logger.info(`[a2a-adapter] notifyUser: ✓ all ${ok} targets succeeded`);
+        }
+        else {
+            this.logger.error(`[a2a-adapter] notifyUser: done — ${ok} ok, ${fail} FAILED out of ${ok + fail} targets`);
+        }
     }
     publishMessage(eventBus, text) {
         const message = {
@@ -426,27 +508,18 @@ ${preview}
 授权等待时间：5 分钟，超时自动拒绝。`;
 }
 /**
- * Build the prompt for the sub-agent that handles an incoming A2A task.
- * The sub-agent must call `multiclaws_a2a_callback` to report its result.
+ * Build the prompt injected into the user's active main session for an incoming A2A task.
+ * The AI in that session processes the task naturally and must call multiclaws_a2a_callback.
  */
-function buildA2ASubagentPrompt(taskId, taskText) {
-    return `你收到了一个来自远端智能体的委派任务。请完成任务并汇报结果。
-
-## 任务内容
+function buildA2AMainSessionPrompt(taskId, fromAgentName, taskText) {
+    return `[MultiClaws 委派任务] 来自 **${fromAgentName}**：
 
 ${taskText}
 
-## 完成后必做
-
-完成任务后，你**必须**调用 \`multiclaws_a2a_callback\` 工具汇报结果：
-
-\`\`\`
-multiclaws_a2a_callback(taskId="${taskId}", result="你的完整回复内容")
-\`\`\`
+---
+完成后请调用 \`multiclaws_a2a_callback\` 汇报结果：
+- taskId: "${taskId}"
+- result: 你的完整回复内容
 
-**重要**：
-- 无论任务成功还是失败，都必须调用 \`multiclaws_a2a_callback\`
-- result 参数填写你的完整回复文本
-- 如果任务失败，在 result 中说明失败原因
-- 这是唯一的结果回传方式，不调用则结果会丢失`;
+无论成功还是失败都必须调用，这是结果回传给委派方的唯一方式。`;
 }

package/dist/service/multiclaws-service.d.ts

@@ -143,7 +143,6 @@ export declare class MulticlawsService extends EventEmitter {
     addNotificationTarget(key: string, target: NotificationTarget): void;
     /** Consistent name for this agent: AgentCard.name or fallback. */
     private getFormattedName;
-    /** Send a notification to all known targets with detailed logging. */
     /** Discover the most recently active non-internal session via sessions_list. */
     private discoverActiveSession;
     notifyUser(message: string): Promise<void>;

package/dist/service/multiclaws-service.js

@@ -256,31 +256,41 @@ class MulticlawsService extends node_events_1.EventEmitter {
     /* ---------------------------------------------------------------- */
     async delegateTask(params) {
         this.log("info", `[delegate] ▶ delegateTask(agentUrl=${params.agentUrl}, taskLen=${params.task.length})`);
-        this.log("info", `[delegate] task preview: ${params.task.slice(0, 120)}`);
-        await this.requireCompleteProfile();
+        this.log("info", `[delegate] task preview: "${params.task.slice(0, 120)}"`);
+        // Step 1: Check profile
+        this.log("info", `[delegate] [step:profile-check] verifying profile completeness`);
+        try {
+            await this.requireCompleteProfile();
+        }
+        catch (err) {
+            this.log("error", `[delegate] [step:profile-check] ✗ profile incomplete: ${err instanceof Error ? err.message : String(err)}`);
+            return { status: "failed", error: err instanceof Error ? err.message : String(err) };
+        }
+        // Step 2: Look up agent
+        this.log("info", `[delegate] [step:agent-lookup] looking up agent: ${params.agentUrl}`);
         const agentRecord = await this.agentRegistry.get(params.agentUrl);
         if (!agentRecord) {
-            this.log("warn", `[delegate] ✗ unknown agent: ${params.agentUrl}`);
+            this.log("warn", `[delegate] [step:agent-lookup] ✗ unknown agent: ${params.agentUrl} → aborting`);
             return { status: "failed", error: `unknown agent: ${params.agentUrl}` };
         }
-        this.log("info", `[delegate] agent found: ${agentRecord.name} (${agentRecord.url})`);
+        this.log("info", `[delegate] [step:agent-lookup] ✓ found: ${agentRecord.name} (${agentRecord.url})`);
+        // Step 3: Track task
         const track = this.taskTracker.create({
             fromPeerId: "local",
             toPeerId: params.agentUrl,
             task: params.task,
         });
         this.taskTracker.update(track.taskId, { status: "running" });
-        this.log("info", `[delegate] task tracked: ${track.taskId}, status=running`);
+        this.log("info", `[delegate] [step:track] taskId=${track.taskId}, status=running`);
         try {
-            this.log("info", `[delegate] ${track.taskId} creating A2A client for ${agentRecord.url}`);
+            // Step 4: Create A2A client
+            this.log("info", `[delegate] ${track.taskId} [step:create-client] creating A2A client for ${agentRecord.url}`);
             const client = await this.createA2AClient(agentRecord);
-            this.log("info", `[delegate] ${track.taskId} A2A client created, starting fire-and-forget send`);
-            // Fire-and-forget execution: keep running in the background so that
-            // the gateway call can return quickly and the task can outlive
-            // the gateway's HTTP timeout.
+            this.log("info", `[delegate] ${track.taskId} [step:create-client] ✓ client created → starting fire-and-forget send`);
+            // Step 5: Fire-and-forget execution
             void (async () => {
                 try {
-                    this.log("info", `[delegate] ${track.taskId} sending A2A message (background)...`);
+                    this.log("info", `[delegate] ${track.taskId} [step:background-send] sending A2A message to ${agentRecord.name}...`);
                     const result = await client.sendMessage({
                         message: {
                             kind: "message",
@@ -289,24 +299,22 @@ class MulticlawsService extends node_events_1.EventEmitter {
                             messageId: track.taskId,
                         },
                     });
-                    this.log("info", `[delegate] ${track.taskId} A2A response received (background)`);
+                    this.log("info", `[delegate] ${track.taskId} [step:background-send] ✓ A2A response received → processing result`);
                     this.processTaskResult(track.taskId, result);
                 }
                 catch (err) {
                     const errorMsg = err instanceof Error ? err.message : String(err);
                     this.taskTracker.update(track.taskId, { status: "failed", error: errorMsg });
-                    this.log("error", `[delegate] ✗ ${track.taskId} background send failed: ${errorMsg}`);
+                    this.log("error", `[delegate] ${track.taskId} [step:background-send] ✗ caught error: ${errorMsg} → task marked failed`);
                 }
             })();
-            // Return immediately so that gateway tool invocations are fast and
-            // do not depend on the remote agent's total execution time.
-            this.log("info", `[delegate] ${track.taskId} returned immediately (fire-and-forget)`);
+            this.log("info", `[delegate] ${track.taskId} [step:return] returned immediately (fire-and-forget), background send in progress`);
             return { taskId: track.taskId, status: "running" };
         }
         catch (err) {
             const errorMsg = err instanceof Error ? err.message : String(err);
             this.taskTracker.update(track.taskId, { status: "failed", error: errorMsg });
-            this.log("error", `[delegate] ✗ ${track.taskId} failed: ${errorMsg}`);
+            this.log("error", `[delegate] ${track.taskId} [step:catch] ✗ caught error during client creation: ${errorMsg} → task marked failed`);
             return { taskId: track.taskId, status: "failed", error: errorMsg };
         }
     }
@@ -316,25 +324,38 @@ class MulticlawsService extends node_events_1.EventEmitter {
      */
     async delegateTaskSync(params) {
         this.log("info", `[delegate-sync] ▶ delegateTaskSync(agentUrl=${params.agentUrl}, taskLen=${params.task.length})`);
-        this.log("info", `[delegate-sync] task preview: ${params.task.slice(0, 120)}`);
-        await this.requireCompleteProfile();
+        this.log("info", `[delegate-sync] task preview: "${params.task.slice(0, 120)}"`);
+        // Step 1: Check profile
+        this.log("info", `[delegate-sync] [step:profile-check] verifying profile completeness`);
+        try {
+            await this.requireCompleteProfile();
+        }
+        catch (err) {
+            this.log("error", `[delegate-sync] [step:profile-check] ✗ profile incomplete: ${err instanceof Error ? err.message : String(err)}`);
+            return { status: "failed", error: err instanceof Error ? err.message : String(err) };
+        }
+        // Step 2: Look up agent
+        this.log("info", `[delegate-sync] [step:agent-lookup] looking up agent: ${params.agentUrl}`);
         const agentRecord = await this.agentRegistry.get(params.agentUrl);
         if (!agentRecord) {
-            this.log("warn", `[delegate-sync] ✗ unknown agent: ${params.agentUrl}`);
+            this.log("warn", `[delegate-sync] [step:agent-lookup] ✗ unknown agent: ${params.agentUrl} → aborting`);
             return { status: "failed", error: `unknown agent: ${params.agentUrl}` };
         }
-        this.log("info", `[delegate-sync] agent found: ${agentRecord.name} (${agentRecord.url})`);
+        this.log("info", `[delegate-sync] [step:agent-lookup] ✓ found: ${agentRecord.name} (${agentRecord.url})`);
+        // Step 3: Track task
         const track = this.taskTracker.create({
             fromPeerId: "local",
             toPeerId: params.agentUrl,
             task: params.task,
         });
         this.taskTracker.update(track.taskId, { status: "running" });
-        this.log("info", `[delegate-sync] task tracked: ${track.taskId}, status=running`);
+        this.log("info", `[delegate-sync] [step:track] taskId=${track.taskId}, status=running`);
         try {
-            this.log("info", `[delegate-sync] ${track.taskId} creating A2A client for ${agentRecord.url}`);
+            // Step 4: Create A2A client
+            this.log("info", `[delegate-sync] ${track.taskId} [step:create-client] creating A2A client for ${agentRecord.url}`);
             const client = await this.createA2AClient(agentRecord);
-            this.log("info", `[delegate-sync] ${track.taskId} sending A2A message (sync, with metadata: selfUrl=${this.selfUrl}, selfName=${this.agentCard?.name ?? "unknown"})...`);
+            // Step 5: Send A2A message (synchronous — blocks until response)
+            this.log("info", `[delegate-sync] ${track.taskId} [step:send] sending A2A message (sync, metadata: selfUrl=${this.selfUrl}, selfName=${this.agentCard?.name ?? "unknown"})...`);
             const result = await client.sendMessage({
                 message: {
                     kind: "message",
@@ -347,15 +368,16 @@ class MulticlawsService extends node_events_1.EventEmitter {
                     },
                 },
             });
-            this.log("info", `[delegate-sync] ${track.taskId} A2A response received`);
+            this.log("info", `[delegate-sync] ${track.taskId} [step:send] ✓ A2A response received → processing result`);
+            // Step 6: Process result
             const taskResult = this.processTaskResult(track.taskId, result);
-            this.log("info", `[delegate-sync] ✓ ${track.taskId} completed — status=${taskResult.status}, outputLen=${taskResult.output?.length ?? 0}`);
+            this.log("info", `[delegate-sync] ${track.taskId} [step:completed] ✓ status=${taskResult.status}, outputLen=${taskResult.output?.length ?? 0}, preview="${(taskResult.output ?? "").slice(0, 120)}"`);
             return taskResult;
         }
         catch (err) {
             const errorMsg = err instanceof Error ? err.message : String(err);
             this.taskTracker.update(track.taskId, { status: "failed", error: errorMsg });
-            this.log("error", `[delegate-sync] ✗ ${track.taskId} failed: ${errorMsg}`);
+            this.log("error", `[delegate-sync] ${track.taskId} [step:catch] ✗ caught error: ${errorMsg} → task marked failed`);
             return { taskId: track.taskId, status: "failed", error: errorMsg };
         }
     }
@@ -366,30 +388,48 @@ class MulticlawsService extends node_events_1.EventEmitter {
      */
     async spawnDelegation(params) {
         this.log("info", `[spawn-delegate] ▶ spawnDelegation(agentUrl=${params.agentUrl}, taskLen=${params.task.length})`);
-        this.log("info", `[spawn-delegate] task preview: ${params.task.slice(0, 120)}`);
-        await this.requireCompleteProfile();
+        this.log("info", `[spawn-delegate] task preview: "${params.task.slice(0, 120)}"`);
+        // Step 1: Check profile
+        this.log("info", `[spawn-delegate] [step:profile-check] verifying profile completeness`);
+        try {
+            await this.requireCompleteProfile();
+        }
+        catch (err) {
+            this.log("error", `[spawn-delegate] [step:profile-check] ✗ profile incomplete: ${err instanceof Error ? err.message : String(err)}`);
+            throw err;
+        }
+        // Step 2: Look up agent
+        this.log("info", `[spawn-delegate] [step:agent-lookup] looking up agent: ${params.agentUrl}`);
         const agent = await this.agentRegistry.get(params.agentUrl);
         if (!agent) {
-            this.log("warn", `[spawn-delegate] ✗ unknown agent: ${params.agentUrl}`);
+            this.log("warn", `[spawn-delegate] [step:agent-lookup] ✗ unknown agent: ${params.agentUrl} → aborting`);
             throw new Error(`unknown agent: ${params.agentUrl}`);
         }
-        this.log("info", `[spawn-delegate] agent found: ${agent.name} (${agent.url})`);
+        this.log("info", `[spawn-delegate] [step:agent-lookup] ✓ found: ${agent.name} (${agent.url})`);
+        // Step 3: Check gateway config
         if (!this.gatewayConfig) {
-            this.log("error", `[spawn-delegate] ✗ gateway config not available`);
+            this.log("error", `[spawn-delegate] [step:gateway-check] ✗ gateway config not available → aborting`);
             throw new Error("gateway config not available — cannot spawn sub-agent");
         }
+        // Step 4: Spawn sub-agent
         const prompt = buildDelegationPrompt(agent, params.task);
         const sessionKey = `delegate-${Date.now()}`;
-        this.log("info", `[spawn-delegate] spawning sub-agent via sessions_spawn (cwd=${this.resolvedCwd}, sessionKey=${sessionKey}, promptLen=${prompt.length})`);
-        const spawnResult = await (0, gateway_client_1.invokeGatewayTool)({
-            gateway: this.gatewayConfig,
-            tool: "sessions_spawn",
-            args: { task: prompt, mode: "run", cwd: this.resolvedCwd },
-            sessionKey,
-            timeoutMs: 15_000,
-        });
-        this.log("info", `[spawn-delegate] ✓ sub-agent spawned for ${agent.name} — result=${JSON.stringify(spawnResult).slice(0, 200)}`);
-        return { message: `已启动子 agent 向 ${agent.name} 委派任务` };
+        this.log("info", `[spawn-delegate] [step:spawn] calling sessions_spawn (cwd=${this.resolvedCwd}, sessionKey=${sessionKey}, promptLen=${prompt.length})`);
+        try {
+            const spawnResult = await (0, gateway_client_1.invokeGatewayTool)({
+                gateway: this.gatewayConfig,
+                tool: "sessions_spawn",
+                args: { task: prompt, mode: "run", cwd: this.resolvedCwd },
+                sessionKey,
+                timeoutMs: 15_000,
+            });
+            this.log("info", `[spawn-delegate] [step:spawn] ✓ sub-agent spawned for ${agent.name} — result=${JSON.stringify(spawnResult).slice(0, 200)}`);
+            return { message: `已启动子 agent 向 ${agent.name} 委派任务` };
+        }
+        catch (err) {
+            this.log("error", `[spawn-delegate] [step:spawn] ✗ sessions_spawn failed: ${err instanceof Error ? err.message : String(err)} → aborting`);
+            throw err;
+        }
     }
     getTaskStatus(taskId) {
         return this.taskTracker.get(taskId);
@@ -871,7 +911,16 @@ class MulticlawsService extends node_events_1.EventEmitter {
         }
     }
     async createA2AClient(agent) {
-        return await this.clientFactory.createFromUrl(agent.url);
+        this.log("info", `[a2a-client] creating client for ${agent.name} (${agent.url})`);
+        try {
+            const client = await this.clientFactory.createFromUrl(agent.url);
+            this.log("info", `[a2a-client] ✓ client created for ${agent.name} (${agent.url})`);
+            return client;
+        }
+        catch (err) {
+            this.log("error", `[a2a-client] ✗ failed to create client for ${agent.name} (${agent.url}): ${err instanceof Error ? err.message : String(err)}`);
+            throw err;
+        }
     }
     /**
      * Send a message using A2A streaming to minimize latency.
@@ -979,12 +1028,14 @@ class MulticlawsService extends node_events_1.EventEmitter {
     getFormattedName() {
         return this.agentCard?.name ?? "OpenClaw Agent";
     }
-    /** Send a notification to all known targets with detailed logging. */
     /** Discover the most recently active non-internal session via sessions_list. */
     async discoverActiveSession() {
-        if (!this.gatewayConfig)
+        if (!this.gatewayConfig) {
+            this.log("warn", `discoverActiveSession: skipped — no gateway config`);
             return null;
+        }
         try {
+            this.log("info", `discoverActiveSession: calling sessions_list (limit=10, activeMinutes=120)`);
             const raw = await (0, gateway_client_1.invokeGatewayTool)({
                 gateway: this.gatewayConfig,
                 tool: "sessions_list",
@@ -997,11 +1048,14 @@ class MulticlawsService extends node_events_1.EventEmitter {
             if (raw?.content?.[0]?.type === "text") {
                 try {
                     parsed = JSON.parse(raw.content[0].text);
+                    this.log("info", `discoverActiveSession: unwrapped gateway response successfully`);
+                }
+                catch (parseErr) {
+                    this.log("warn", `discoverActiveSession: failed to parse content[0].text as JSON — ${parseErr instanceof Error ? parseErr.message : String(parseErr)}, using raw object`);
                 }
-                catch { /* use raw */ }
             }
             const sessions = parsed?.sessions ?? [];
-            this.log("info", `discoverActiveSession: found ${sessions.length} sessions`);
+            this.log("info", `discoverActiveSession: found ${sessions.length} sessions from gateway`);
             const INTERNAL_PREFIXES = ["delegate-", "a2a-"];
             // sessions_list returns "key" not "sessionKey"
             const session = sessions.find((s) => {
@@ -1010,31 +1064,31 @@ class MulticlawsService extends node_events_1.EventEmitter {
             });
             const matchedKey = (session?.key ?? session?.sessionKey);
             if (matchedKey) {
-                this.log("info", `discoverActiveSession: matched session ${matchedKey}`);
+                this.log("info", `discoverActiveSession: ✓ matched session ${matchedKey}`);
             }
             else {
-                this.log("warn", `discoverActiveSession: all ${sessions.length} sessions filtered or empty`);
-                sessions.forEach((s) => this.log("info", `  session: ${(s.key ?? s.sessionKey) ?? "(no key)"}`));
+                this.log("warn", `discoverActiveSession: ✗ all ${sessions.length} sessions filtered or empty`);
+                sessions.forEach((s, i) => this.log("info", `discoverActiveSession:   session[${i}]: key=${(s.key ?? s.sessionKey) ?? "(no key)"}`));
             }
             return matchedKey ?? null;
         }
         catch (err) {
-            this.log("warn", `discoverActiveSession failed: ${err instanceof Error ? err.message : String(err)}`);
+            this.log("error", `discoverActiveSession: ✗ caught error — ${err instanceof Error ? err.message : String(err)}, returning null`);
             return null;
         }
     }
     async notifyUser(message) {
-        this.log("info", `notifyUser: targets=${this.notificationTargets.size}, msg=${message.slice(0, 80)}`);
+        this.log("info", `notifyUser: targets=${this.notificationTargets.size}, msgLen=${message.length}, preview="${message.slice(0, 80)}"`);
         if (!this.gatewayConfig) {
-            this.log("warn", "notifyUser: skipped — no gatewayConfig");
+            this.log("warn", "notifyUser: skipped — no gatewayConfig, message lost");
             return;
         }
         // Fallback: no registered targets yet (e.g. right after gateway restart)
         if (this.notificationTargets.size === 0) {
-            this.log("warn", "notifyUser: no registered targets — attempting session discovery");
+            this.log("info", "notifyUser: no registered targets → falling back to discoverActiveSession()");
             const sessionKey = await this.discoverActiveSession();
             if (sessionKey) {
-                this.log("info", `notifyUser: discovered session ${sessionKey}`);
+                this.log("info", `notifyUser: fallback discovered session ${sessionKey} → calling sessions_send`);
                 try {
                     await (0, gateway_client_1.invokeGatewayTool)({
                         gateway: this.gatewayConfig,
@@ -1042,20 +1096,23 @@ class MulticlawsService extends node_events_1.EventEmitter {
                         args: { sessionKey, message },
                         timeoutMs: 5_000,
                     });
+                    this.log("info", `notifyUser: ✓ fallback sessions_send to ${sessionKey} succeeded`);
                     this.addNotificationTarget(`web:${sessionKey}`, { type: "web", sessionKey });
+                    this.log("info", `notifyUser: registered ${sessionKey} as notification target for future use`);
                 }
                 catch (err) {
-                    this.log("warn", `notifyUser: sessions_send to ${sessionKey} failed: ${err instanceof Error ? err.message : String(err)}`);
+                    this.log("error", `notifyUser: ✗ fallback sessions_send to ${sessionKey} failed: ${err instanceof Error ? err.message : String(err)}`);
                 }
             }
             else {
-                this.log("warn", "notifyUser: no active session found, message lost");
+                this.log("warn", "notifyUser: ✗ discoverActiveSession returned null — no active session found, message lost");
             }
             return;
         }
         const entries = [...this.notificationTargets.entries()];
+        this.log("info", `notifyUser: sending to ${entries.length} registered target(s): [${entries.map(([k]) => k).join(", ")}]`);
         const results = await Promise.allSettled(entries.map(async ([key, target]) => {
-            this.log("info", `notifyUser: sending to ${key} (type=${target.type})`);
+            this.log("info", `notifyUser: → ${key} (type=${target.type})`);
             try {
                 await (target.type === "channel"
                     ? (0, gateway_client_1.invokeGatewayTool)({
@@ -1065,26 +1122,28 @@ class MulticlawsService extends node_events_1.EventEmitter {
                         timeoutMs: 5_000,
                     })
                     : (0, gateway_client_1.invokeGatewayTool)({
-                        // sessions_send injects a message into the session so the AI
-                        // can relay it to the human (correct tool; was "chat.send" before)
                         gateway: this.gatewayConfig,
                         tool: "sessions_send",
                         args: { sessionKey: target.sessionKey, message },
                         timeoutMs: 5_000,
                     }));
-                this.log("info", `notifyUser: ${key} (${target.type}) succeeded`);
+                this.log("info", `notifyUser: ✓ ${key} (${target.type}) succeeded`);
             }
             catch (err) {
-                this.log("warn", `notifyUser: ${key} (${target.type}) failed: ${err instanceof Error ? err.message : String(err)}`);
+                this.log("error", `notifyUser: ✗ ${key} (${target.type}) failed: ${err instanceof Error ? err.message : String(err)}`);
                 throw err;
             }
         }));
+        const okCount = results.filter((r) => r.status === "fulfilled").length;
         const failCount = results.filter((r) => r.status === "rejected").length;
-        if (failCount === entries.length) {
-            this.log("error", `notifyUser: ALL ${failCount} targets failed`);
+        if (failCount === 0) {
+            this.log("info", `notifyUser: ✓ all ${okCount} targets succeeded`);
+        }
+        else if (failCount === entries.length) {
+            this.log("error", `notifyUser: ✗ ALL ${failCount} targets failed`);
         }
-        else if (failCount > 0) {
-            this.log("warn", `notifyUser: ${failCount}/${entries.length} targets failed`);
+        else {
+            this.log("warn", `notifyUser: ${okCount} ok, ${failCount} FAILED out of ${entries.length} targets`);
         }
     }
     log(level, message) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "multiclaws",
-  "version": "0.4.40",
+  "version": "0.4.41",
   "description": "MultiClaws plugin for OpenClaw collaboration via A2A protocol",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",