multiclaws 0.4.33 → 0.4.35

package/dist/index.js

@@ -625,16 +625,25 @@ const plugin = {
         api.on("gateway_stop", () => {
             structured.logger.info("[multiclaws] gateway_stop observed");
         });
-        // Collect notification targets from incoming messages (external channels)
+        // Collect notification targets from incoming messages
         api.on("message_received", (_event, ctx) => {
-            if (service && ctx.channelId && ctx.channelId !== "webchat" && ctx.conversationId) {
+            if (!service || !ctx.channelId)
+                return;
+            if (ctx.channelId === "webchat" && ctx.conversationId) {
+                // WebChat: use conversationId with the message tool
+                service.addNotificationTarget(`webchat:${ctx.conversationId}`, { type: "channel", conversationId: ctx.conversationId });
+            }
+            else if (ctx.channelId !== "webchat" && ctx.conversationId) {
+                // External channels (Telegram, etc.)
                 service.addNotificationTarget(`${ctx.channelId}:${ctx.conversationId}`, { type: "channel", conversationId: ctx.conversationId });
             }
         });
         // Inject onboarding prompt when profile is pending first-run setup
-        // Also capture web session targets for notifications
+        // Also capture web session targets for notifications (skip internal sub-agent sessions)
+        const INTERNAL_SESSION_PREFIXES = ["delegate-", "a2a-"];
         api.on("before_prompt_build", async (_event, ctx) => {
-            if (service && ctx.sessionKey) {
+            if (service && ctx.sessionKey &&
+                !INTERNAL_SESSION_PREFIXES.some((p) => ctx.sessionKey.startsWith(p))) {
                 service.addNotificationTarget(`web:${ctx.sessionKey}`, { type: "web", sessionKey: ctx.sessionKey });
             }
             if (!service)
@@ -648,22 +657,32 @@ const plugin = {
 
 multiclaws 插件刚安装，需要在本次对话中完成以下初始化流程（优先处理，不管用户说了什么）：
 
-1. **扫描当前环境**，自动生成 bio（markdown 格式），内容包括：
-   - 用户角色和职责
-   - 可处理的任务类型（基于已安装 skills、工具、连接的渠道）
-   - 可访问的数据/系统（git 仓库、邮件、日历、Notion 等）
-   - 时区和语言
+1. **确认用户名**（需要用户明确回答）：
+   - 询问用户希望使用什么名字
+   - 这个名字会以「{名字} 的 OpenClaw」格式展示给团队其他成员
+   - 例如用户叫「小明」，则其他成员看到的是「小明 的 OpenClaw」
 
-2. 向用户展示生成的档案，并逐一确认以下三项（名字和 bio 需要用户明确回答）：
-   - **名字**：展示推断出的名字，询问是否需要修改
-   - **Bio**：展示生成的 bio，询问是否需要修改
-   - **网络情况**：告知用户「所有实例通过 FRP 隧道通信，需在插件配置中设置 tunnel 字段（包含 frps 服务器地址、端口、token 和可用端口范围），frpc 会自动下载安装」，无需用户回答
+2. **自动生成 bio**（无需用户确认，直接生成并保存）：
+   扫描当前环境，生成详细的 bio（markdown 格式）。bio 是给其他 AI 智能体看的，用来判断这个智能体能做什么任务、能访问什么数据。必须准确反映实际能力，具体检查：
 
-3. 根据用户对名字和 bio 的回答更新档案内容（如需修改），然后调用 \`multiclaws_profile_set(ownerName="...", bio="...")\` 保存。
+   - **已安装的工具（tools）**：列出所有可用的工具名称，说明能执行哪些类型的操作（如文件读写、代码执行、网络请求等）
+   - **已安装的 skills**：列出 skill 名称和功能描述
+   - **已连接的渠道（channels）**：检查是否连接了 Telegram、Discord、Gmail、Slack、微信等，列出具体渠道名称
+   - **已安装的插件（plugins）**：列出所有已加载的插件及其主要功能
+   - **工作区内容**：检查当前工作目录（pwd）下的项目结构，包括：
+     - git 仓库信息（仓库名、分支）
+     - 主要编程语言和框架
+     - 项目名称和用途（从 README 或 package.json 推断）
+   - **可访问的数据源**：检查是否有日历（Google Calendar 等）、邮件（Gmail 等）、Notion、数据库、API 等数据访问能力
+   - **系统信息**：时区、操作系统、语言偏好
+
+3. 用户确认名字后，立即调用 \`multiclaws_profile_set(ownerName="确认后的名字", bio="生成的bio")\` 保存。
 
 4. 调用 \`multiclaws_profile_clear_pending_review()\` 完成初始化。
 
-**注意**：名字和 bio 需要用户明确确认；网络情况仅告知无需回答。`,
+5. **网络情况告知**（无需用户回答）：告知用户「所有实例通过 FRP 隧道通信，需在插件配置中设置 tunnel 字段（包含 frps 服务器地址、端口、token 和可用端口范围），frpc 会自动下载安装」
+
+**注意**：只有名字需要用户明确确认；bio 自动生成直接保存无需确认；网络情况仅告知无需回答。`,
                 };
             }
             catch (err) {

package/dist/service/a2a-adapter.js

@@ -37,33 +37,43 @@ class OpenClawAgentExecutor {
     async execute(context, eventBus) {
         const taskText = extractTextFromMessage(context.userMessage);
         const taskId = context.taskId;
+        this.logger.info(`[a2a-adapter] ▶ execute() called — taskId=${taskId}, textLen=${taskText.length}`);
         if (!taskText.trim()) {
+            this.logger.warn(`[a2a-adapter] ✗ empty task text, rejecting — taskId=${taskId}`);
             this.publishMessage(eventBus, "Error: empty task received.");
             eventBus.finished();
             return;
         }
-        const fromAgent = context.userMessage.metadata?.agentUrl ?? "unknown";
+        const meta = context.userMessage.metadata ?? {};
+        const fromAgentUrl = meta.agentUrl ?? "unknown";
+        const fromAgentName = meta.agentName || fromAgentUrl;
+        this.logger.info(`[a2a-adapter] task ${taskId} from ${fromAgentName} (${fromAgentUrl}): ${taskText.slice(0, 120)}`);
         this.taskTracker.create({
-            fromPeerId: fromAgent,
+            fromPeerId: fromAgentUrl,
             toPeerId: "local",
             task: taskText,
         });
+        this.logger.info(`[a2a-adapter] task ${taskId} tracked`);
         if (!this.gatewayConfig) {
-            this.logger.error("[a2a-adapter] gateway config not available, cannot execute task");
+            this.logger.error(`[a2a-adapter] ✗ gateway config not available — taskId=${taskId}`);
             this.taskTracker.update(taskId, { status: "failed", error: "gateway config not available" });
             this.publishMessage(eventBus, "Error: gateway config not available, cannot execute task.");
             eventBus.finished();
             return;
         }
         // Notify local user about incoming task
-        void this.notifyUser(`📨 收到来自 **${fromAgent}** 的委派任务：${taskText.slice(0, 200)}`);
+        const notifyTargets = this.getNotificationTargets();
+        this.logger.info(`[a2a-adapter] task ${taskId} notifying user (${notifyTargets.size} targets)`);
+        void this.notifyUser(`📨 收到来自 **${fromAgentName}** 的委派任务：${taskText.slice(0, 200)}`);
         try {
-            this.logger.info(`[a2a-adapter] executing task ${taskId}: ${taskText.slice(0, 100)}`);
             // Create a promise that resolves when sub-agent calls multiclaws_a2a_callback
-            const resultPromise = this.createCallback(taskId, 180_000);
+            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);
-            await (0, gateway_client_1.invokeGatewayTool)({
+            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)({
                 gateway: this.gatewayConfig,
                 tool: "sessions_spawn",
                 args: {
@@ -74,20 +84,22 @@ class OpenClawAgentExecutor {
                 sessionKey: `a2a-${taskId}`,
                 timeoutMs: 15_000,
             });
-            this.logger.info(`[a2a-adapter] task ${taskId} spawned, waiting for callback...`);
+            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
             const output = await resultPromise;
             // Return result
             this.taskTracker.update(taskId, { status: "completed", result: output });
-            this.logger.info(`[a2a-adapter] task ${taskId} completed, resultLen=${output.length}`);
+            this.logger.info(`[a2a-adapter] ✓ task ${taskId} 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 execution failed: ${errorMsg}`);
+            this.logger.error(`[a2a-adapter] ✗ task ${taskId} failed: ${errorMsg}`);
             this.taskTracker.update(taskId, { status: "failed", error: errorMsg });
             this.publishMessage(eventBus, `Error: ${errorMsg}`);
         }
+        this.logger.info(`[a2a-adapter] task ${taskId} eventBus.finished()`);
         eventBus.finished();
     }
     /**
@@ -96,10 +108,13 @@ class OpenClawAgentExecutor {
      */
     resolveCallback(taskId, result) {
         const pending = this.pendingCallbacks.get(taskId);
-        if (!pending)
+        if (!pending) {
+            this.logger.warn(`[a2a-adapter] resolveCallback: no pending callback for taskId=${taskId} (may have timed out)`);
             return false;
+        }
         clearTimeout(pending.timer);
         this.pendingCallbacks.delete(taskId);
+        this.logger.info(`[a2a-adapter] resolveCallback: taskId=${taskId} resolved — resultLen=${result.length}`);
         pending.resolve(result);
         return true;
     }
@@ -111,6 +126,7 @@ class OpenClawAgentExecutor {
             clearTimeout(pending.timer);
             this.pendingCallbacks.delete(taskId);
             pending.reject(new Error("canceled"));
+            this.logger.info(`[a2a-adapter] cancelTask: pending callback rejected for taskId=${taskId}`);
         }
         this.taskTracker.update(taskId, { status: "failed", error: "canceled" });
         this.publishMessage(eventBus, "Task was canceled.");
@@ -127,6 +143,7 @@ class OpenClawAgentExecutor {
         return new Promise((resolve, reject) => {
             const timer = setTimeout(() => {
                 this.pendingCallbacks.delete(taskId);
+                this.logger.error(`[a2a-adapter] ✗ task ${taskId} callback timed out after ${timeoutMs / 1000}s — pending callbacks remaining: ${this.pendingCallbacks.size}`);
                 reject(new Error(`task timed out after ${timeoutMs / 1000}s waiting for sub-agent callback`));
             }, timeoutMs);
             this.pendingCallbacks.set(taskId, { resolve, reject, timer });
@@ -135,21 +152,36 @@ class OpenClawAgentExecutor {
     /** Send a notification to all known targets. Individual failures are silently ignored. */
     async notifyUser(message) {
         const targets = this.getNotificationTargets();
-        if (!this.gatewayConfig || targets.size === 0)
+        if (!this.gatewayConfig || targets.size === 0) {
+            this.logger.info(`[a2a-adapter] notifyUser: skipped (gateway=${!!this.gatewayConfig}, targets=${targets.size})`);
             return;
-        await Promise.allSettled([...targets.values()].map((target) => target.type === "channel"
-            ? (0, gateway_client_1.invokeGatewayTool)({
-                gateway: this.gatewayConfig,
-                tool: "message",
-                args: { action: "send", target: target.conversationId, message },
-                timeoutMs: 5_000,
-            })
-            : (0, gateway_client_1.invokeGatewayTool)({
-                gateway: this.gatewayConfig,
-                tool: "chat.send",
-                args: { sessionKey: target.sessionKey, message },
-                timeoutMs: 5_000,
-            })));
+        }
+        const results = await Promise.allSettled([...targets.entries()].map(async ([key, target]) => {
+            this.logger.info(`[a2a-adapter] notifyUser: sending to ${key} (type=${target.type})`);
+            try {
+                await (target.type === "channel"
+                    ? (0, gateway_client_1.invokeGatewayTool)({
+                        gateway: this.gatewayConfig,
+                        tool: "message",
+                        args: { action: "send", target: target.conversationId, message },
+                        timeoutMs: 5_000,
+                    })
+                    : (0, gateway_client_1.invokeGatewayTool)({
+                        gateway: this.gatewayConfig,
+                        tool: "chat.send",
+                        args: { sessionKey: target.sessionKey, message },
+                        timeoutMs: 5_000,
+                    }));
+                this.logger.info(`[a2a-adapter] notifyUser: sent to ${key} ✓`);
+            }
+            catch (err) {
+                this.logger.warn(`[a2a-adapter] notifyUser: failed to send to ${key}: ${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)`);
     }
     publishMessage(eventBus, text) {
         const message = {

package/dist/service/agent-profile.d.ts

@@ -5,6 +5,7 @@ export type AgentProfile = {
     bio: string;
 };
 export declare function renderProfileDescription(profile: AgentProfile): string;
+export declare function formatAgentCardName(ownerName: string): string;
 export declare class ProfileStore {
     private readonly filePath;
     private readonly logger?;

package/dist/service/agent-profile.js

@@ -2,17 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProfileStore = void 0;
 exports.renderProfileDescription = renderProfileDescription;
+exports.formatAgentCardName = formatAgentCardName;
 const json_store_1 = require("../infra/json-store");
 function emptyProfile() {
     return { ownerName: "", bio: "" };
 }
 function renderProfileDescription(profile) {
-    const parts = [];
-    if (profile.ownerName)
-        parts.push(profile.ownerName);
-    if (profile.bio)
-        parts.push(profile.bio);
-    return parts.join("\n\n") || "OpenClaw agent";
+    return profile.bio?.trim() || "OpenClaw agent";
+}
+function formatAgentCardName(ownerName) {
+    return `${ownerName} 的 OpenClaw`;
 }
 class ProfileStore {
     filePath;

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

@@ -133,10 +133,12 @@ export declare class MulticlawsService extends EventEmitter {
     private extractArtifactText;
     /** Fetch with up to 2 retries and exponential backoff. */
     private fetchWithRetry;
-    /** Register a channel ID for notifications. */
+    /** Resolve a pending A2A callback from sub-agent. */
     resolveA2ACallback(taskId: string, result: string): boolean;
     addNotificationTarget(key: string, target: NotificationTarget): void;
-    /** Send a notification to all known targets. Individual failures are silently ignored. */
+    /** Consistent name for this agent: AgentCard.name or fallback. */
+    private getFormattedName;
+    /** Send a notification to all known targets with detailed logging. */
     notifyUser(message: string): Promise<void>;
     private log;
 }

package/dist/service/multiclaws-service.js

@@ -109,13 +109,8 @@ class MulticlawsService extends node_events_1.EventEmitter {
                 this.log("info", `FRP tunnel ready: ${publicUrl}`);
             }
             // Load profile for AgentCard description
-            let profile = await this.profileStore.load();
-            const isIncompleteProfile = !profile.ownerName?.trim() || !profile.bio?.trim();
+            const profile = await this.profileStore.load();
             if (!profile.ownerName?.trim()) {
-                profile.ownerName = this.options.displayName ?? node_os_1.default.hostname();
-                await this.profileStore.save(profile);
-            }
-            if (isIncompleteProfile) {
                 await this.setPendingProfileReview();
             }
             this.profileDescription = (0, agent_profile_1.renderProfileDescription)(profile);
@@ -128,7 +123,7 @@ class MulticlawsService extends node_events_1.EventEmitter {
                 logger,
             });
             this.agentCard = {
-                name: this.options.displayName ?? (profile.ownerName || "OpenClaw Agent"),
+                name: profile.ownerName?.trim() ? (0, agent_profile_1.formatAgentCardName)(profile.ownerName.trim()) : "OpenClaw Agent",
                 description: this.profileDescription,
                 url: this.selfUrl,
                 version: "0.3.0",
@@ -256,26 +251,32 @@ class MulticlawsService extends node_events_1.EventEmitter {
     /*  Task delegation                                                  */
     /* ---------------------------------------------------------------- */
     async delegateTask(params) {
-        this.log("info", `delegateTask(agentUrl=${params.agentUrl}, task=${params.task.slice(0, 80)})`);
+        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();
         const agentRecord = await this.agentRegistry.get(params.agentUrl);
         if (!agentRecord) {
-            this.log("warn", `delegateTask: unknown agent ${params.agentUrl}`);
+            this.log("warn", `[delegate] ✗ unknown agent: ${params.agentUrl}`);
             return { status: "failed", error: `unknown agent: ${params.agentUrl}` };
         }
+        this.log("info", `[delegate] agent found: ${agentRecord.name} (${agentRecord.url})`);
         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`);
         try {
+            this.log("info", `[delegate] ${track.taskId} 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.
             void (async () => {
                 try {
+                    this.log("info", `[delegate] ${track.taskId} sending A2A message (background)...`);
                     const result = await client.sendMessage({
                         message: {
                             kind: "message",
@@ -284,22 +285,24 @@ class MulticlawsService extends node_events_1.EventEmitter {
                             messageId: track.taskId,
                         },
                     });
+                    this.log("info", `[delegate] ${track.taskId} A2A response received (background)`);
                     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("warn", `delegateTask background execution for ${track.taskId} failed: ${errorMsg}`);
+                    this.log("error", `[delegate] ✗ ${track.taskId} background send failed: ${errorMsg}`);
                 }
             })();
             // 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)`);
             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", `delegateTask failed for ${track.taskId}: ${errorMsg}`);
+            this.log("error", `[delegate] ✗ ${track.taskId} failed: ${errorMsg}`);
             return { taskId: track.taskId, status: "failed", error: errorMsg };
         }
     }
@@ -308,37 +311,47 @@ class MulticlawsService extends node_events_1.EventEmitter {
      * Used by sub-agents internally via the multiclaws_delegate_send tool.
      */
     async delegateTaskSync(params) {
-        this.log("info", `delegateTaskSync(agentUrl=${params.agentUrl}, task=${params.task.slice(0, 80)})`);
+        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();
         const agentRecord = await this.agentRegistry.get(params.agentUrl);
         if (!agentRecord) {
-            this.log("warn", `delegateTaskSync: unknown agent ${params.agentUrl}`);
+            this.log("warn", `[delegate-sync] ✗ unknown agent: ${params.agentUrl}`);
             return { status: "failed", error: `unknown agent: ${params.agentUrl}` };
         }
+        this.log("info", `[delegate-sync] agent found: ${agentRecord.name} (${agentRecord.url})`);
         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`);
         try {
+            this.log("info", `[delegate-sync] ${track.taskId} 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"})...`);
             const result = await client.sendMessage({
                 message: {
                     kind: "message",
                     role: "user",
                     parts: [{ kind: "text", text: params.task }],
                     messageId: track.taskId,
+                    metadata: {
+                        agentUrl: this.selfUrl,
+                        agentName: this.agentCard?.name ?? "unknown",
+                    },
                 },
             });
+            this.log("info", `[delegate-sync] ${track.taskId} A2A response received`);
             const taskResult = this.processTaskResult(track.taskId, result);
-            this.log("debug", `delegateTaskSync completed for ${track.taskId}`);
+            this.log("info", `[delegate-sync] ✓ ${track.taskId} completed — status=${taskResult.status}, outputLen=${taskResult.output?.length ?? 0}`);
             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", `delegateTaskSync failed for ${track.taskId}: ${errorMsg}`);
+            this.log("error", `[delegate-sync] ✗ ${track.taskId} failed: ${errorMsg}`);
             return { taskId: track.taskId, status: "failed", error: errorMsg };
         }
     }
@@ -348,26 +361,30 @@ class MulticlawsService extends node_events_1.EventEmitter {
      * reports results back to the user via the message tool.
      */
     async spawnDelegation(params) {
-        this.log("info", `spawnDelegation(agentUrl=${params.agentUrl}, task=${params.task.slice(0, 80)})`);
+        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();
         const agent = await this.agentRegistry.get(params.agentUrl);
         if (!agent) {
-            this.log("warn", `spawnDelegation: unknown agent ${params.agentUrl}`);
+            this.log("warn", `[spawn-delegate] ✗ unknown agent: ${params.agentUrl}`);
             throw new Error(`unknown agent: ${params.agentUrl}`);
         }
+        this.log("info", `[spawn-delegate] agent found: ${agent.name} (${agent.url})`);
         if (!this.gatewayConfig) {
-            this.log("error", "spawnDelegation: gateway config not available");
+            this.log("error", `[spawn-delegate] ✗ gateway config not available`);
             throw new Error("gateway config not available — cannot spawn sub-agent");
         }
         const prompt = buildDelegationPrompt(agent, params.task);
-        await (0, gateway_client_1.invokeGatewayTool)({
+        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: `delegate-${Date.now()}`,
+            sessionKey,
             timeoutMs: 15_000,
         });
-        this.log("info", `spawnDelegation completed: sub-agent spawned for ${agent.name}`);
+        this.log("info", `[spawn-delegate] ✓ sub-agent spawned for ${agent.name} — result=${JSON.stringify(spawnResult).slice(0, 200)}`);
         return { message: `已启动子 agent 向 ${agent.name} 委派任务` };
     }
     getTaskStatus(taskId) {
@@ -385,8 +402,8 @@ class MulticlawsService extends node_events_1.EventEmitter {
      */
     async requireCompleteProfile() {
         const profile = await this.profileStore.load();
-        if (!profile.ownerName?.trim() || !profile.bio?.trim()) {
-            throw new Error("档案未完成设置。请先调用 multiclaws_profile_set(ownerName=\"你的名字\", bio=\"你的介绍\") 完成设置后再继续。");
+        if (!profile.ownerName?.trim()) {
+            throw new Error("档案未完成设置。请先调用 multiclaws_profile_set(ownerName=\"你的名字\") 设置用户名后再继续。");
         }
     }
     async setProfile(patch) {
@@ -408,7 +425,7 @@ class MulticlawsService extends node_events_1.EventEmitter {
         if (this.agentCard) {
             this.agentCard.description = this.profileDescription;
             if (profile.ownerName?.trim()) {
-                this.agentCard.name = profile.ownerName.trim();
+                this.agentCard.name = (0, agent_profile_1.formatAgentCardName)(profile.ownerName.trim());
             }
         }
     }
@@ -462,7 +479,7 @@ class MulticlawsService extends node_events_1.EventEmitter {
             const team = await this.teamStore.createTeam({
                 teamName: name,
                 selfUrl: this.selfUrl,
-                selfName: this.options.displayName ?? node_os_1.default.hostname(),
+                selfName: this.getFormattedName(),
                 selfDescription: this.profileDescription,
             });
             this.log("info", `team created: ${team.teamId} (${team.teamName})`);
@@ -512,7 +529,7 @@ class MulticlawsService extends node_events_1.EventEmitter {
             // 2. Announce self to seed (seed broadcasts to others)
             const selfMember = {
                 url: this.selfUrl,
-                name: this.options.displayName ?? node_os_1.default.hostname(),
+                name: this.getFormattedName(),
                 description: this.profileDescription,
                 joinedAtMs: Date.now(),
             };
@@ -566,7 +583,7 @@ class MulticlawsService extends node_events_1.EventEmitter {
             const selfNormalized = this.selfUrl.replace(/\/+$/, "");
             const selfMember = {
                 url: this.selfUrl,
-                name: this.options.displayName ?? node_os_1.default.hostname(),
+                name: this.getFormattedName(),
                 joinedAtMs: 0,
             };
             const others = team.members.filter((m) => m.url.replace(/\/+$/, "") !== selfNormalized);
@@ -772,12 +789,12 @@ class MulticlawsService extends node_events_1.EventEmitter {
         try {
             const teams = await this.teamStore.listTeams();
             const selfNormalized = this.selfUrl.replace(/\/+$/, "");
-            const displayName = this.options.displayName ?? node_os_1.default.hostname();
+            const agentName = this.getFormattedName();
             for (const team of teams) {
                 // Update self in team store
                 await this.teamStore.addMember(team.teamId, {
                     url: this.selfUrl,
-                    name: displayName,
+                    name: agentName,
                     description: this.profileDescription,
                     joinedAtMs: Date.now(),
                 });
@@ -789,7 +806,7 @@ class MulticlawsService extends node_events_1.EventEmitter {
                         headers: { "Content-Type": "application/json" },
                         body: JSON.stringify({
                             url: this.selfUrl,
-                            name: displayName,
+                            name: agentName,
                             description: this.profileDescription,
                         }),
                     }).catch(() => {
@@ -858,24 +875,27 @@ class MulticlawsService extends node_events_1.EventEmitter {
      * return the final Task or Message as soon as B signals completion.
      */
     processTaskResult(trackId, result) {
-        this.log("debug", `processTaskResult(trackId=${trackId})`);
+        this.log("info", `[process-result] processing result for ${trackId}, resultType=${("status" in result && result.status) ? "Task" : "Message"}`);
         try {
             if ("status" in result && result.status) {
                 const task = result;
                 const state = task.status?.state ?? "unknown";
                 const output = this.extractArtifactText(task);
+                this.log("info", `[process-result] ${trackId} Task response — state=${state}, outputLen=${output.length}, preview=${output.slice(0, 120)}`);
                 if (state === "completed") {
                     this.taskTracker.update(trackId, { status: "completed", result: output });
+                    this.log("info", `[process-result] ✓ ${trackId} marked completed`);
                 }
                 else if (state === "failed") {
                     this.taskTracker.update(trackId, { status: "failed", error: output || "remote task failed" });
+                    this.log("warn", `[process-result] ✗ ${trackId} marked failed — error=${output || "remote task failed"}`);
                 }
                 else {
                     // For any other state (unknown, working, etc.), mark as failed to avoid
                     // tasks stuck in "running" forever until TTL prune.
                     this.taskTracker.update(trackId, { status: "failed", error: `unexpected remote state: ${state}` });
+                    this.log("warn", `[process-result] ✗ ${trackId} unexpected state=${state}, marked failed`);
                 }
-                this.log("debug", `processTaskResult completed, status=${state}`);
                 return { taskId: task.id, output, status: state };
             }
             const msg = result;
@@ -884,11 +904,11 @@ class MulticlawsService extends node_events_1.EventEmitter {
                 .map((p) => p.text)
                 .join("\n") ?? "";
             this.taskTracker.update(trackId, { status: "completed", result: text });
-            this.log("debug", "processTaskResult completed, status=completed (message)");
+            this.log("info", `[process-result] ✓ ${trackId} Message response — completed, textLen=${text.length}, preview=${text.slice(0, 120)}`);
             return { taskId: trackId, output: text, status: "completed" };
         }
         catch (err) {
-            this.log("error", `processTaskResult failed for ${trackId}: ${err instanceof Error ? err.message : String(err)}`);
+            this.log("error", `[process-result] ✗ ${trackId} processing failed: ${err instanceof Error ? err.message : String(err)}`);
             throw err;
         }
     }
@@ -920,11 +940,16 @@ class MulticlawsService extends node_events_1.EventEmitter {
         }
         throw lastError;
     }
-    /** Register a channel ID for notifications. */
+    /** Resolve a pending A2A callback from sub-agent. */
     resolveA2ACallback(taskId, result) {
-        if (!this.agentExecutor)
+        this.log("info", `[a2a-callback] resolveA2ACallback(taskId=${taskId}, resultLen=${result.length})`);
+        if (!this.agentExecutor) {
+            this.log("warn", `[a2a-callback] ✗ no agentExecutor available for taskId=${taskId}`);
             return false;
-        return this.agentExecutor.resolveCallback(taskId, result);
+        }
+        const resolved = this.agentExecutor.resolveCallback(taskId, result);
+        this.log("info", `[a2a-callback] ${resolved ? "✓" : "✗"} taskId=${taskId} ${resolved ? "resolved" : "no pending callback found"}`);
+        return resolved;
     }
     addNotificationTarget(key, target) {
         if (!this.notificationTargets.has(key)) {
@@ -932,23 +957,48 @@ class MulticlawsService extends node_events_1.EventEmitter {
             this.log("debug", `notification target registered: ${key} (total: ${this.notificationTargets.size})`);
         }
     }
-    /** Send a notification to all known targets. Individual failures are silently ignored. */
+    /** Consistent name for this agent: AgentCard.name or fallback. */
+    getFormattedName() {
+        return this.agentCard?.name ?? "OpenClaw Agent";
+    }
+    /** Send a notification to all known targets with detailed logging. */
     async notifyUser(message) {
-        if (!this.gatewayConfig || this.notificationTargets.size === 0)
+        this.log("info", `notifyUser: targets=${this.notificationTargets.size}, msg=${message.slice(0, 80)}`);
+        if (!this.gatewayConfig || this.notificationTargets.size === 0) {
+            this.log("warn", "notifyUser: skipped — no gatewayConfig or no targets");
             return;
-        await Promise.allSettled([...this.notificationTargets.values()].map((target) => target.type === "channel"
-            ? (0, gateway_client_1.invokeGatewayTool)({
-                gateway: this.gatewayConfig,
-                tool: "message",
-                args: { action: "send", target: target.conversationId, message },
-                timeoutMs: 5_000,
-            })
-            : (0, gateway_client_1.invokeGatewayTool)({
-                gateway: this.gatewayConfig,
-                tool: "chat.send",
-                args: { sessionKey: target.sessionKey, message },
-                timeoutMs: 5_000,
-            })));
+        }
+        const entries = [...this.notificationTargets.entries()];
+        const results = await Promise.allSettled(entries.map(async ([key, target]) => {
+            this.log("info", `notifyUser: sending to ${key} (type=${target.type})`);
+            try {
+                await (target.type === "channel"
+                    ? (0, gateway_client_1.invokeGatewayTool)({
+                        gateway: this.gatewayConfig,
+                        tool: "message",
+                        args: { action: "send", target: target.conversationId, message },
+                        timeoutMs: 5_000,
+                    })
+                    : (0, gateway_client_1.invokeGatewayTool)({
+                        gateway: this.gatewayConfig,
+                        tool: "chat.send",
+                        args: { sessionKey: target.sessionKey, message },
+                        timeoutMs: 5_000,
+                    }));
+                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)}`);
+                throw err;
+            }
+        }));
+        const failCount = results.filter((r) => r.status === "rejected").length;
+        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`);
+        }
     }
     log(level, message) {
         this.options.logger?.[level]?.(`[multiclaws] ${message}`);

package/package.json

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

package/skills/multiclaws/SKILL.md

@@ -13,35 +13,43 @@ MultiClaws 让多个 OpenClaw 实例通过 [A2A（Agent-to-Agent）](https://goo
 
 当 hook 注入了初始化任务时，按以下步骤执行：
 
-1. **扫描当前环境**，自动生成 bio（markdown 格式），包含：
-   - 可用的工具和 skills（推断能力）
-   - 已连接的渠道（Telegram、Discord、Gmail 等）
-   - 工作区内容（git 仓库、关键文件、项目目录）
-   - 已安装的插件
-   - 时区、语言等上下文
+1. **确认用户名**（需用户明确回答）：
+   询问用户希望使用什么名字。名字会以「{名字} 的 OpenClaw」格式展示给团队成员。
 
-2. 向用户展示生成的档案，并逐一确认以下三项：
-   - **名字**：展示推断出的名字，询问是否需要修改（需用户明确回答）
-   - **Bio**：展示生成的 bio，询问是否需要修改（需用户明确回答）
-   - **网络情况**：告知用户「所有实例通过 FRP 隧道通信，需在插件配置中设置 tunnel 字段（frps 地址、端口、token、可用端口范围），frpc 会自动下载安装」，无需用户回答
+2. **自动生成 bio**（无需用户确认，直接保存），扫描并检查：
+   - **可用工具（tools）**：列出所有工具名称，说明能执行的操作类型
+   - **已安装 skills**：列出 skill 名称和功能
+   - **已连接渠道**：Telegram、Discord、Gmail、Slack、微信等，列出具体渠道
+   - **已安装插件**：列出所有插件及主要功能
+   - **工作区**：当前目录下的项目（git 仓库名、语言、框架、项目用途）
+   - **数据访问**：日历、邮件、Notion、数据库等
+   - **系统信息**：时区、OS、语言
 
-3. 根据用户对名字和 bio 的回答更新内容后，调用 `multiclaws_profile_set(ownerName="...", bio="...")` 保存档案。
+   Bio 是给其他 AI 智能体看的，用来判断这个智能体能做什么、能访问什么数据。必须准确反映实际能力。
+
+3. 用户确认名字后，调用 `multiclaws_profile_set(ownerName="...", bio="...")` 保存。
 
 4. 调用 `multiclaws_profile_clear_pending_review()` 完成初始化。
 
+5. 告知网络情况（无需用户回答）。
+
 **示例 bio：**
 ```markdown
 后端工程师，负责 API 服务开发与维护。
 
-**可处理：**
-- 代码审查、调试、重构（Node.js / Go / Python）
-- API 文档编写与接口设计
-- 数据库查询与优化（PostgreSQL）
+**可用工具：** exec, read, write, edit, glob, grep, process, git, message
+
+**已连接渠道：** Telegram, Gmail
+
+**工作区：**
+- `/Users/eric/Project/api-service` — Node.js API 服务（Express, TypeScript, ~50k LOC）
 
 **数据访问：**
-- Codebase: `/Users/eric/Project/api-service`（Node.js，~50k LOC）
-- Email: Gmail
-- Calendar: Google Calendar
+- Email: Gmail（收发邮件）
+- Calendar: Google Calendar（查看日程）
+- Database: PostgreSQL（只读查询）
+
+**已安装插件：** multiclaws, calendar-sync
 
 **时区：** GMT+8
 ```
@@ -56,12 +64,16 @@ MultiClaws 让多个 OpenClaw 实例通过 [A2A（Agent-to-Agent）](https://goo
 multiclaws_profile_show()
 ```
 
-如果 `bio` 为空或 `ownerName` 为空：
-1. 自动生成 bio（同上）
-2. 询问用户确认名字和 bio
+如果 `ownerName` 为空：
+1. 询问用户确认名字
+2. 自动生成 bio（无需用户确认）
 3. 调用 `multiclaws_profile_set(...)` 设置
 4. 然后继续团队操作
 
+如果 `ownerName` 已设置但 `bio` 为空：
+1. 自动生成 bio 并保存（无需用户确认）
+2. 继续团队操作
+
 ---
 
 ## 3. 保持档案更新
@@ -114,7 +126,7 @@ multiclaws_profile_show()
 - **只使用上面列出的工具。** 没有 `multiclaws_status` 工具。
 - **Bio 是自由格式的 markdown。** 写得让另一个 AI 能读懂这个智能体能做什么。
 - **每个智能体就像一个 skill。** 委派时读每个智能体的 bio，选最匹配的。
-- **名字和 bio 必须用户明确确认**；网络情况仅告知，无需用户回答。
+- **只有名字需要用户明确确认**；bio 自动生成无需确认；网络情况仅告知无需回答。
 
 ---
 
@@ -124,7 +136,7 @@ multiclaws_profile_show()
 
 ```
 1. multiclaws_profile_show()              — 检查档案
-2.（如果为空）自动生成并设置 bio，确认名字和 bio
+2.（如果 ownerName 为空）确认名字，自动生成 bio
 3. multiclaws_team_create(name="...")     — 返回 inviteCode (mc:xxxx)
 4. 告诉用户把邀请码分享给队友
 ```
@@ -133,7 +145,7 @@ multiclaws_profile_show()
 
 ```
 1. multiclaws_profile_show()              — 检查档案
-2.（如果为空）自动生成并设置 bio，确认名字和 bio
+2.（如果 ownerName 为空）确认名字，自动生成 bio
 3. multiclaws_team_join(inviteCode="mc:xxxx")
    → 自动同步所有团队成员
 ```