multiclaws 0.4.40 → 0.4.42

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.42",
   "description": "MultiClaws plugin for OpenClaw collaboration via A2A protocol",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/skills/meeting-scheduler/SKILL.md

@@ -1,175 +1,182 @@
-# 会议调度 — 技能行为
+# 会议协商调度 — 全自动多人协商
 
-以下规则指导 AI 如何利用 MultiClaws 团队协作和 Google Calendar 完成会议调度。
+以下规则指导 AI 如何利用 MultiClaws 委派和 Google Calendar 实现多人自动协商会议。
+核心原则：**如果所有参与者的 OpenClaw 都有日历工具，则全程无需人类干预。**
 
 ---
 
-## 触发条件
+## 角色判断
 
-当用户的请求包含以下意图时激活此 Skill：
-- 约会议 / 安排会议 / 组织会议
-- 查询团队成员空闲时间
-- 找一个大家都有空的时间
+你在会议协商中扮演两种角色之一：
 
-**关键词示例：** 「约会议」「开会」「安排一个会」「找个时间碰一下」「schedule a meeting」
+| 触发条件 | 角色 |
+|----------|------|
+| 用户主动说「开会」「约会议」「安排会议」「schedule a meeting」等 | **组织者** |
+| 收到委派任务，任务文本包含 `[会议协商-查询]` | **参与者 — 查询模式** |
+| 收到委派任务，任务文本包含 `[会议协商-确认]` | **参与者 — 确认模式** |
 
 ---
 
-## 工作流
+## 组织者工作流
 
-### 步骤 1：解析会议需求
+当用户发起会议请求时，按以下步骤**自动执行**，不要在每一步停下来询问用户。
+
+### Step 1：解析需求
 
 从用户请求中提取：
-- **参会人**：指定的团队成员名单（如「小明和小红」）。若用户说「所有人」或「整个团队」，则查询全部成员
-- **时间范围**：用户期望的日期/时间段（如「明天下午」「本周五」「下周一到周三」）
-- **会议主题**：会议目的（可选）
+- **参会人**：指定的成员名单。「所有人」「整个团队」= 全部成员
+- **时间范围**：用户期望的日期和时间段（如「明天下午」「周五 2-4 点」）
+- **会议主题**：会议目的（可选，默认「团队会议」）
 - **会议时长**：默认 1 小时，用户可指定
 
-如果用户未指定时间范围，询问用户希望在什么时间段开会。
-
-### 步骤 2：查询本地日历
+**仅当用户未指定时间范围时，才询问用户。** 其他信息缺失可以使用默认值。
 
-使用 Google Calendar 工具读取**用户自己**在指定时间范围内的日程：
+### Step 2：查询自己的日历
 
-1. 获取指定时间范围内的所有事件
-2. 计算用户的空闲时段
-3. 如果用户在该时间范围内完全没空，提前告知用户并建议换个时间段
+检测你是否有 Google Calendar 相关工具可用：
+- **有日历工具** → 直接查询用户在指定时间范围内的事件，计算空闲时段。不要问用户是否要查，直接查
+- **无日历工具** → 跳过此步，假设用户在指定时间范围内全部可用
 
-### 步骤 3：获取团队成员信息
+### Step 3：获取团队成员
 
 ```
 multiclaws_agents()
 ```
 
-从返回的智能体列表中，根据用户指定的参会人名单匹配对应的智能体。
-
-**匹配规则：**
-- 优先按 `ownerName` 匹配
-- 如果用户说「所有人」，取团队全部成员（排除自己）
-- 找不到的成员告知用户
+从返回的智能体列表中匹配参会人。匹配规则：
+- 按 `ownerName` 或 `name` 模糊匹配
+- 「所有人」= 全部成员（排除自己）
+- 找不到的成员跳过并在最终汇报中说明
 
-### 步骤 4：并行委派查询空闲时间
+### Step 4：逐个委派查询可用时间
 
-对每个参会成员**分别**调用 `multiclaws_delegate`：
+对每个参会成员调用 `multiclaws_delegate`，发送结构化查询请求：
 
 ```
 multiclaws_delegate(
   agentUrl="成员的agentUrl",
-  task="请查询你的主人在 [时间范围] 的日程安排，告诉我哪些时段是空闲的。
-        请以如下格式回复：
-        - 空闲时段1：HH:MM - HH:MM
-        - 空闲时段2：HH:MM - HH:MM
-        如果完全没空，请说明。"
+  task="[会议协商-查询]\n会议主题：{主题}\n查询时间范围：{YYYY-MM-DD HH:MM} - {HH:MM} ({时区})\n会议时长：{N}小时\n发起人：{你的主人名字}\n\n请查看你主人的日历，回复 JSON 格式：\n{\"available\": true, \"freeSlots\": [\"HH:MM-HH:MM\", ...], \"timezone\": \"GMT+8\"}\n如果没有日历工具，请直接询问你的主人在该时间段是否有空。"
 )
 ```
 
-记录每个委派返回的 `taskId`。
+`multiclaws_delegate` 是同步阻塞的，会等待对方回复后才返回。逐个调用即可，无需轮询。
+
+### Step 5：汇总与决策
+
+收集所有成员的回复后，找出共同空闲时段：
+
+1. 解析每个成员返回的 JSON（或自然语言描述的空闲时段）
+2. 计算所有人（包括自己）的交集时段
+3. **自动决策**，不要询问用户选哪个：
+   - 有全员可行的时段 → 选**最早的**一个，自动确定
+   - 多个等价时段 → 选**最早的**
+   - 无全员可行时段但部分可行 → 选覆盖人数最多的最早时段，自动确定
+   - 完全无可行时段 → **自动扩大时间范围 ±2 小时**，回到 Step 4 重新查询（仅重试一次）
+   - 扩大后仍无 → **这时才询问用户**，建议换日期或缩减参会人
 
-### 步骤 5：收集回复（超时机制）
+### Step 6：创建日历事件
 
-**等待策略：手动检查 + 自动超时**
+时间确定后：
+- **有日历工具** → 直接创建事件（标题、时间、描述），不要询问用户是否创建
+- **无日历工具** → 跳过，告知用户需要手动添加
 
-1. 委派发出后告知用户：「已向 N 位成员查询空闲时间，等待回复中…」
-2. 设定超时：**3 分钟**
-3. 在超时前，如有结果通过子 agent 消息返回则自动收集
-4. 超时后检查各任务状态：
+### Step 7：通知所有参会者
+
+对每个参会成员调用 `multiclaws_delegate`，发送确认通知：
 
 ```
-multiclaws_task_status(taskId="xxx")
+multiclaws_delegate(
+  agentUrl="成员的agentUrl",
+  task="[会议协商-确认]\n会议已确定：\n- 主题：{主题}\n- 时间：{YYYY-MM-DD HH:MM} - {HH:MM} ({时区})\n- 发起人：{你的主人名字}\n\n请在你主人的日历上创建此事件。如果没有日历工具，请告知你的主人这个会议时间。"
+)
 ```
 
-**处理逻辑：**
-- ✅ **已回复**：提取空闲时段信息
-- ⏳ **未回复（超时）**：标记该成员为「未响应」
-- ❌ **失败**：标记该成员为「查询失败」
+### Step 8：汇报
 
-如果全部超时/失败，告知用户并建议：
-- 稍后重试
-- 直接问相关人员的空闲时间
-- 跳过未响应成员继续安排
+向用户简洁汇报结果：
 
-### 步骤 6：汇总与展示
+```
+✅ 会议已安排
+- 主题：{主题}
+- 时间：{日期} {时段}
+- 参会人：{名单}
+- 日历事件：已创建 / 请手动添加
+- 通知状态：全部已通知 / {某某}通知失败
+```
 
-将所有结果汇总为易读的表格，展示给用户：
+---
 
-```
-📅 会议空闲时段汇总（主题：xxx）
+## 参与者工作流 — 查询模式
+
+当你收到的委派任务包含 `[会议协商-查询]` 时，执行以下流程：
 
-| 时段           | 你   | 小明 | 小红 | 可行？ |
-|----------------|------|------|------|--------|
-| 14:00 - 15:00  | ✅   | ✅   | ✅   | ✅ 全员可行 |
-| 15:00 - 16:00  | ✅   | ❌   | ✅   | ⚠️ 小明不行 |
-| 16:00 - 17:00  | ✅   | ✅   | ⏳   | ⚠️ 小红未响应 |
+### 自动处理（有日历工具时）
 
-推荐时段：14:00 - 15:00（全员可行）
+1. 从任务文本中提取：时间范围、时区、会议时长
+2. 使用 Google Calendar 工具查询该时间范围内的已有事件
+3. 计算空闲时段（排除已有事件的时段，每个空闲段 ≥ 会议时长）
+4. **直接返回结果**（通过 `multiclaws_a2a_callback`），不要询问用户确认：
+
+```json
+{"available": true, "freeSlots": ["14:00-15:00", "15:30-16:00"], "timezone": "GMT+8"}
 ```
 
-**推荐逻辑：**
-1. 优先推荐全员都空闲的时段
-2. 若无全员空闲时段，推荐覆盖人数最多的时段
-3. 若有多个等价时段，推荐最早的
+如果完全没有空闲：
+```json
+{"available": false, "freeSlots": [], "reason": "该时段已有会议", "timezone": "GMT+8"}
+```
 
-### 步骤 7：用户确认
+### 需要人工介入（无日历工具时）
 
-询问用户：
-- 选择哪个时段？
-- 是否接受部分成员缺席？
-- 会议标题需要调整吗？
-- 是否需要添加会议描述或议程？
+1. 告知用户：「收到来自 {发起人} 的会议邀请，主题：{主题}，时间范围：{时间}。你在这个时间段有空吗？」
+2. 等待用户回复
+3. 将用户回答转换为结构化格式返回
 
-等待用户明确确认后才继续。
+---
 
-### 步骤 8：创建日历事件
+## 参与者工作流 — 确认模式
 
-用户确认后，使用 Google Calendar 工具：
-1. 创建日历事件（标题、时间、描述）
-2. 添加所有确认参会的成员为与会者（如果有邮箱信息）
-3. 发送日历邀请
+当你收到的委派任务包含 `[会议协商-确认]` 时：
 
-### 步骤 9：通知参会者
+### 自动处理（有日历工具时）
 
-对每个确认参会的远端成员调用 `multiclaws_delegate`，通知会议已确定：
+1. 从任务文本中提取：会议主题、确切时间、发起人
+2. 使用 Google Calendar 工具**直接创建事件**，不要询问用户
+3. 返回确认：`已将会议添加到日历`
 
-```
-multiclaws_delegate(
-  agentUrl="成员的agentUrl",
-  task="会议已确定：[主题]，时间：[日期] [时段]。
-        请在你主人的日历上创建这个事件。"
-)
-```
+### 需要人工介入（无日历工具时）
 
-向用户确认：「会议已创建，日历邀请已发送给所有参会者。」
+1. 告知用户：「{发起人} 安排了会议：{主题}，时间：{时间}。请记得参加。」
+2. 返回：`已通知用户`
 
 ---
 
-## 边界情况处理
+## 边界情况
 
 ### 跨时区
-- 委派查询时明确指定时区（如 GMT+8）
-- 汇总时统一转换为用户所在时区展示
+- 委派查询时**必须附带时区**（如 GMT+8）
+- 参与者回复时也附带自己的时区
+- 组织者汇总时统一转换为自己的时区
 
-### 只有一个参会者
-- 跳过汇总表格，直接展示双方都空闲的时段
-- 简化确认流程
+### 单人会议
+- 只有一个参会者时，直接查询+确定，不需要表格汇总
 
 ### 用户取消
-- 在任何步骤用户都可以说「算了」「取消」
-- 取消时不创建任何事件
+- 在任何步骤用户说「算了」「取消」→ 立即停止，不创建事件，不发通知
 
-### 成员无日历能力
-- 如果某成员的 bio 中没有提到日历相关能力，在委派时明确说明：
-  「请询问你的主人在 [时间范围] 是否有空，由主人口头回答即可」
+### 委派超时或失败
+- 某成员委派失败 → 跳过该成员，继续处理其他人
+- 在最终汇报中注明哪些成员未能联系上
 
 ### 紧急会议
-- 如果用户说「现在」「马上」「尽快」，将时间范围设为今天剩余时间
-- 缩短超时为 1 分钟
+- 用户说「现在」「马上」「尽快」→ 时间范围设为今天剩余时间，会议时长默认 30 分钟
 
 ---
 
-## 重要规则
+## 关键规则
 
-- **必须等用户确认后才创建事件**，永远不要自动创建
-- **委派查询时要说明会议主题**（如果有），让对方判断优先级
-- **汇总要直观**，用表格和 emoji 使结果一目了然
-- **尊重隐私**，不在委派消息中透露其他成员的具体日程细节
-- **保持礼貌**，委派消息用协商语气而非命令语气
+- **最小化人工干预**：有日历工具时，全程自动，不要停下来问用户"是否确认"
+- **只在必要时才问**：仅当缺少关键信息（时间范围）或协商彻底失败时才询问用户
+- **尊重隐私**：不在委派消息中透露其他成员的日程细节
+- **使用标记**：委派任务必须包含 `[会议协商-查询]` 或 `[会议协商-确认]` 标记，让接收方 AI 识别角色
+- **结构化通信**：查询回复使用 JSON 格式，便于组织者解析