multiclaws 0.4.0 → 0.4.2

package/dist/gateway/handlers.js

@@ -18,6 +18,10 @@ const sessionReplySchema = zod_1.z.object({
 });
 const sessionStatusSchema = zod_1.z.object({ sessionId: zod_1.z.string().trim().min(1).optional() });
 const sessionEndSchema = zod_1.z.object({ sessionId: nonEmptyString });
+const sessionWaitAllSchema = zod_1.z.object({
+    sessionIds: zod_1.z.array(nonEmptyString).min(1),
+    timeoutMs: zod_1.z.number().positive().optional(),
+});
 const profileSetSchema = zod_1.z.object({
     ownerName: zod_1.z.string().trim().optional(),
     bio: zod_1.z.string().optional(),
@@ -106,6 +110,17 @@ function createGatewayHandlers(getService) {
                 safeHandle(respond, "session_status_failed", error);
             }
         },
+        "multiclaws.session.wait_all": async ({ params, respond }) => {
+            try {
+                const parsed = sessionWaitAllSchema.parse(params);
+                const service = getService();
+                const result = await service.waitForSessions(parsed);
+                respond(true, result);
+            }
+            catch (error) {
+                safeHandle(respond, "session_wait_all_failed", error);
+            }
+        },
         "multiclaws.session.end": async ({ params, respond }) => {
             try {
                 const parsed = sessionEndSchema.parse(params);

package/dist/index.js

@@ -64,7 +64,10 @@ function createTools(getService) {
                 throw new Error("url is required");
             const apiKey = typeof args.apiKey === "string" ? args.apiKey.trim() : undefined;
             const agent = await service.addAgent({ url, apiKey });
-            return textResult(`Agent added: ${agent.name} (${agent.url})`, agent);
+            const status = agent.reachable
+                ? `Agent added: ${agent.name} (${agent.url})`
+                : `⚠️ Agent added but NOT reachable: ${agent.url} — agent card could not be fetched. Verify the URL and ensure the agent is running.`;
+            return textResult(status, agent);
         },
     };
     const multiclawsRemoveAgent = {
@@ -155,6 +158,30 @@ function createTools(getService) {
             return textResult(JSON.stringify({ sessions }, null, 2), { sessions });
         },
     };
+    const multiclawsSessionWaitAll = {
+        name: "multiclaws_session_wait_all",
+        description: "Wait for multiple sessions to complete, then return all results at once. Use this when you have started multiple sessions concurrently and need all results before synthesizing an answer. Returns early if any session needs input (input-required). Default timeout: 5 minutes.",
+        parameters: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                sessionIds: { type: "array", items: { type: "string" } },
+                timeoutMs: { type: "number" },
+            },
+            required: ["sessionIds"],
+        },
+        execute: async (_toolCallId, args) => {
+            const service = requireService(getService());
+            const sessionIds = Array.isArray(args.sessionIds)
+                ? args.sessionIds.map((s) => String(s).trim()).filter(Boolean)
+                : [];
+            if (!sessionIds.length)
+                throw new Error("sessionIds must be a non-empty array");
+            const timeoutMs = typeof args.timeoutMs === "number" ? args.timeoutMs : undefined;
+            const result = await service.waitForSessions({ sessionIds, timeoutMs });
+            return textResult(JSON.stringify(result, null, 2), result);
+        },
+    };
     const multiclawsSessionEnd = {
         name: "multiclaws_session_end",
         description: "Cancel and close a collaboration session.",
@@ -327,6 +354,7 @@ function createTools(getService) {
         multiclawsSessionStart,
         multiclawsSessionReply,
         multiclawsSessionStatus,
+        multiclawsSessionWaitAll,
         multiclawsSessionEnd,
         multiclawsTeamCreate,
         multiclawsTeamJoin,
@@ -412,6 +440,17 @@ const plugin = {
         });
         api.on("gateway_start", () => {
             structured.logger.info("[multiclaws] gateway_start observed");
+            // Re-read gateway config in case token became available after initial registration
+            if (service && !gatewayConfig) {
+                const gw = api.config?.gateway;
+                const port = typeof gw?.port === "number" ? gw.port : 18789;
+                const token = typeof gw?.auth?.token === "string" ? gw.auth.token : null;
+                if (token) {
+                    const newConfig = { port, token };
+                    service.updateGatewayConfig(newConfig);
+                    structured.logger.info("[multiclaws] gateway config updated from gateway_start event");
+                }
+            }
         });
         api.on("gateway_stop", () => {
             structured.logger.info("[multiclaws] gateway_stop observed");

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

@@ -24,6 +24,7 @@ export declare class OpenClawAgentExecutor implements AgentExecutor {
     private gatewayConfig;
     private readonly taskTracker;
     private readonly logger;
+    private readonly a2aToTracker;
     constructor(options: A2AAdapterOptions);
     execute(context: RequestContext, eventBus: ExecutionEventBus): Promise<void>;
     /**

package/dist/service/a2a-adapter.js

@@ -10,6 +10,34 @@ function extractTextFromMessage(message) {
         .map((p) => p.text)
         .join("\n");
 }
+function buildTaskWithHistory(context) {
+    const currentText = extractTextFromMessage(context.userMessage);
+    const history = context.task?.history ?? [];
+    if (history.length <= 1) {
+        // First message — no prior context
+        return currentText;
+    }
+    // Build context from previous exchanges (exclude the last message, that's currentText)
+    const prior = history
+        .slice(0, -1)
+        .slice(-8) // keep last 8 messages max to avoid huge prompts
+        .map((m) => {
+        const text = extractTextFromMessage(m);
+        const role = m.role === "agent" ? "[agent]" : "[user]";
+        return `[${role}]: ${text}`;
+    })
+        .filter((line) => line.length > 10)
+        .join("\n");
+    if (!prior)
+        return currentText;
+    return [
+        "[conversation history]",
+        prior,
+        "",
+        "[latest message]",
+        currentText,
+    ].join("\n");
+}
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -42,13 +70,15 @@ class OpenClawAgentExecutor {
     gatewayConfig;
     taskTracker;
     logger;
+    // Map A2A task IDs → internal tracker IDs so cancelTask can find the right record
+    a2aToTracker = new Map();
     constructor(options) {
         this.gatewayConfig = options.gatewayConfig;
         this.taskTracker = options.taskTracker;
         this.logger = options.logger;
     }
     async execute(context, eventBus) {
-        const taskText = extractTextFromMessage(context.userMessage);
+        const taskText = buildTaskWithHistory(context);
         const taskId = context.taskId;
         if (!taskText.trim()) {
             this.publishMessage(eventBus, "Error: empty task received.");
@@ -56,14 +86,16 @@ class OpenClawAgentExecutor {
             return;
         }
         const fromAgent = context.userMessage.metadata?.agentUrl ?? "unknown";
-        this.taskTracker.create({
+        const tracked = this.taskTracker.create({
             fromPeerId: fromAgent,
             toPeerId: "local",
             task: taskText,
         });
+        const trackedId = tracked.taskId;
+        this.a2aToTracker.set(taskId, trackedId);
         if (!this.gatewayConfig) {
             this.logger.error("[a2a-adapter] gateway config not available, cannot execute task");
-            this.taskTracker.update(taskId, { status: "failed", error: "gateway config not available" });
+            this.taskTracker.update(trackedId, { status: "failed", error: "gateway config not available" });
             this.publishMessage(eventBus, "Error: gateway config not available, cannot execute task.");
             eventBus.finished();
             return;
@@ -90,16 +122,19 @@ class OpenClawAgentExecutor {
             this.logger.info(`[a2a-adapter] task ${taskId} spawned as ${childSessionKey}, waiting for result...`);
             const output = await this.waitForCompletion(childSessionKey, 180_000);
             // 3. Return result
-            this.taskTracker.update(taskId, { status: "completed", result: output });
+            this.taskTracker.update(trackedId, { status: "completed", result: output });
             this.logger.info(`[a2a-adapter] task ${taskId} completed`);
             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.taskTracker.update(taskId, { status: "failed", error: errorMsg });
+            this.taskTracker.update(trackedId, { status: "failed", error: errorMsg });
             this.publishMessage(eventBus, `Error: ${errorMsg}`);
         }
+        finally {
+            this.a2aToTracker.delete(taskId);
+        }
         eventBus.finished();
     }
     /**
@@ -155,14 +190,21 @@ class OpenClawAgentExecutor {
         const messages = (details.messages ?? []);
         if (messages.length === 0)
             return null;
-        // If no explicit flag, check the last message for signs of ongoing execution
+        // If no explicit flag, use conservative heuristic: only consider
+        // complete if the last message is an assistant message with text
+        // and NO tool calls (tool calls indicate ongoing work)
         if (details.isComplete === undefined) {
             const lastMsg = messages[messages.length - 1];
-            if (lastMsg && Array.isArray(lastMsg.content)) {
+            if (!lastMsg || lastMsg.role !== "assistant")
+                return null;
+            if (Array.isArray(lastMsg.content)) {
                 const content = lastMsg.content;
                 const hasToolCalls = content.some((c) => c?.type === "toolCall" || c?.type === "tool_use");
+                // If there are ANY tool calls, assume still running
+                if (hasToolCalls)
+                    return null;
                 const hasText = content.some((c) => c?.type === "text" && typeof c.text === "string" && c.text.trim());
-                if (hasToolCalls && !hasText)
+                if (!hasText)
                     return null;
             }
         }
@@ -188,7 +230,9 @@ class OpenClawAgentExecutor {
         return null;
     }
     async cancelTask(taskId, eventBus) {
-        this.taskTracker.update(taskId, { status: "failed", error: "canceled" });
+        const trackedId = this.a2aToTracker.get(taskId) ?? taskId;
+        this.taskTracker.update(trackedId, { status: "failed", error: "canceled" });
+        this.a2aToTracker.delete(taskId);
         this.publishMessage(eventBus, "Task was canceled.");
         eventBus.finished();
     }

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

@@ -6,6 +6,8 @@ export type AgentRecord = {
     apiKey?: string;
     addedAtMs: number;
     lastSeenAtMs: number;
+    /** Which teams synced this agent. Empty or undefined = manually added. */
+    teamIds?: string[];
 };
 export declare class AgentRegistry {
     private readonly filePath;
@@ -21,6 +23,13 @@ export declare class AgentRegistry {
     remove(url: string): Promise<boolean>;
     list(): Promise<AgentRecord[]>;
     get(url: string): Promise<AgentRecord | null>;
+    addTeamSource(url: string, teamId: string): Promise<void>;
+    /**
+     * Remove a team source from an agent. Returns true if the agent
+     * was fully removed (no remaining sources), false otherwise.
+     * Manually-added agents (no teamIds) are never removed by this method.
+     */
+    removeTeamSource(url: string, teamId: string): Promise<boolean>;
     updateDescription(url: string, description: string): Promise<void>;
     updateLastSeen(url: string): Promise<void>;
 }

package/dist/service/agent-registry.js

@@ -73,6 +73,47 @@ class AgentRegistry {
         const normalizedUrl = url.replace(/\/+$/, "");
         return store.agents.find((a) => a.url === normalizedUrl) ?? null;
     }
+    async addTeamSource(url, teamId) {
+        await (0, json_store_1.withJsonLock)(this.filePath, emptyStore(), async () => {
+            const store = await this.readStore();
+            const normalizedUrl = url.replace(/\/+$/, "");
+            const agent = store.agents.find((a) => a.url === normalizedUrl);
+            if (agent) {
+                const teams = new Set(agent.teamIds ?? []);
+                teams.add(teamId);
+                agent.teamIds = [...teams];
+                await (0, json_store_1.writeJsonAtomically)(this.filePath, store);
+            }
+        });
+    }
+    /**
+     * Remove a team source from an agent. Returns true if the agent
+     * was fully removed (no remaining sources), false otherwise.
+     * Manually-added agents (no teamIds) are never removed by this method.
+     */
+    async removeTeamSource(url, teamId) {
+        return await (0, json_store_1.withJsonLock)(this.filePath, emptyStore(), async () => {
+            const store = await this.readStore();
+            const normalizedUrl = url.replace(/\/+$/, "");
+            const agent = store.agents.find((a) => a.url === normalizedUrl);
+            if (!agent)
+                return false;
+            // Agent was manually added (no team tracking) — never auto-remove
+            if (!agent.teamIds || agent.teamIds.length === 0)
+                return false;
+            const teams = new Set(agent.teamIds);
+            teams.delete(teamId);
+            if (teams.size === 0) {
+                // No team sources remain — remove entirely
+                store.agents = store.agents.filter((a) => a.url !== normalizedUrl);
+                await (0, json_store_1.writeJsonAtomically)(this.filePath, store);
+                return true;
+            }
+            agent.teamIds = [...teams];
+            await (0, json_store_1.writeJsonAtomically)(this.filePath, store);
+            return false;
+        });
+    }
     async updateDescription(url, description) {
         await (0, json_store_1.withJsonLock)(this.filePath, emptyStore(), async () => {
             const store = await this.readStore();

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

@@ -36,6 +36,8 @@ export declare class MulticlawsService extends EventEmitter {
     private readonly profileStore;
     private readonly taskTracker;
     private readonly sessionStore;
+    private readonly sessionLocks;
+    private readonly sessionAborts;
     private agentExecutor;
     private a2aRequestHandler;
     private agentCard;
@@ -51,7 +53,9 @@ export declare class MulticlawsService extends EventEmitter {
     addAgent(params: {
         url: string;
         apiKey?: string;
-    }): Promise<AgentRecord>;
+    }): Promise<AgentRecord & {
+        reachable: boolean;
+    }>;
     removeAgent(url: string): Promise<boolean>;
     startSession(params: {
         agentUrl: string;
@@ -63,8 +67,23 @@ export declare class MulticlawsService extends EventEmitter {
     }): Promise<SessionReplyResult>;
     getSession(sessionId: string): ConversationSession | null;
     listSessions(): ConversationSession[];
+    waitForSessions(params: {
+        sessionIds: string[];
+        timeoutMs?: number;
+    }): Promise<{
+        results: Array<{
+            sessionId: string;
+            status: string;
+            agentName: string;
+            lastMessage?: string;
+            error?: string;
+        }>;
+        timedOut: boolean;
+    }>;
     endSession(sessionId: string): boolean;
+    private acquireSessionLock;
     private runSession;
+    private extractResultState;
     private handleSessionResult;
     private notifySessionUpdate;
     getProfile(): Promise<AgentProfile>;

package/dist/service/multiclaws-service.js

@@ -37,6 +37,10 @@ class MulticlawsService extends node_events_1.EventEmitter {
     profileStore;
     taskTracker;
     sessionStore;
+    // Fix #5: per-session lock to prevent concurrent runSession calls
+    sessionLocks = new Map();
+    // Per-session AbortController so endSession can cancel in-flight runSession
+    sessionAborts = new Map();
     agentExecutor = null;
     a2aRequestHandler = null;
     agentCard = null;
@@ -153,6 +157,18 @@ class MulticlawsService extends node_events_1.EventEmitter {
         if (!this.started)
             return;
         this.started = false;
+        // Abort all in-flight sessions so they don't hang
+        for (const [, abort] of this.sessionAborts) {
+            abort.abort();
+        }
+        // Wait for session locks to drain (with a cap)
+        if (this.sessionLocks.size > 0) {
+            const pending = [...this.sessionLocks.values()];
+            await Promise.race([
+                Promise.allSettled(pending),
+                new Promise((r) => setTimeout(r, 5_000)),
+            ]);
+        }
         this.taskTracker.destroy();
         this.httpRateLimiter.destroy();
         await new Promise((resolve) => {
@@ -165,6 +181,7 @@ class MulticlawsService extends node_events_1.EventEmitter {
         this.httpServer = null;
     }
     updateGatewayConfig(config) {
+        this.options.gatewayConfig = config;
         this.agentExecutor?.updateGatewayConfig(config);
     }
     /* ---------------------------------------------------------------- */
@@ -178,20 +195,23 @@ class MulticlawsService extends node_events_1.EventEmitter {
         try {
             const client = await this.clientFactory.createFromUrl(normalizedUrl);
             const card = await client.getAgentCard();
-            return await this.agentRegistry.add({
+            const record = await this.agentRegistry.add({
                 url: normalizedUrl,
                 name: card.name ?? normalizedUrl,
                 description: card.description ?? "",
                 skills: card.skills?.map((s) => s.name ?? s.id) ?? [],
                 apiKey: params.apiKey,
             });
+            return { ...record, reachable: true };
         }
         catch {
-            return await this.agentRegistry.add({
+            this.log("warn", `agent at ${normalizedUrl} is not reachable, adding with limited info`);
+            const record = await this.agentRegistry.add({
                 url: normalizedUrl,
                 name: normalizedUrl,
                 apiKey: params.apiKey,
             });
+            return { ...record, reachable: false };
         }
     }
     async removeAgent(url) {
@@ -205,27 +225,29 @@ class MulticlawsService extends node_events_1.EventEmitter {
     /* ---------------------------------------------------------------- */
     async startSession(params) {
         const agentRecord = await this.agentRegistry.get(params.agentUrl);
+        // Fix #3: throw instead of returning empty sessionId
         if (!agentRecord) {
-            return { sessionId: "", status: "failed", error: `unknown agent: ${params.agentUrl}` };
+            throw new Error(`unknown agent: ${params.agentUrl}`);
         }
-        const contextId = (0, node_crypto_1.randomUUID)();
+        // Fix #4: don't pre-generate contextId; let server assign it.
+        // Use a local placeholder that gets replaced after first response.
         const session = this.sessionStore.create({
             agentUrl: params.agentUrl,
             agentName: agentRecord.name,
-            contextId,
+            contextId: "", // will be filled in from server response
         });
         this.sessionStore.appendMessage(session.sessionId, {
             role: "user",
             content: params.message,
             timestampMs: Date.now(),
         });
-        void this.runSession({
+        void this.acquireSessionLock(session.sessionId, () => this.runSession({
             sessionId: session.sessionId,
             agentRecord,
             message: params.message,
-            contextId,
+            contextId: undefined, // first message: no contextId
             taskId: undefined,
-        });
+        }));
         return { sessionId: session.sessionId, status: "running" };
     }
     async sendSessionMessage(params) {
@@ -247,13 +269,14 @@ class MulticlawsService extends node_events_1.EventEmitter {
             this.sessionStore.update(params.sessionId, { status: "failed", error: "agent no longer registered" });
             return { sessionId: params.sessionId, status: "failed", error: "agent no longer registered" };
         }
-        void this.runSession({
+        // Fix #5: acquire lock to prevent concurrent runSession on same session
+        void this.acquireSessionLock(params.sessionId, () => this.runSession({
             sessionId: params.sessionId,
             agentRecord,
             message: params.message,
-            contextId: session.contextId,
+            contextId: session.contextId || undefined,
             taskId: session.currentTaskId,
-        });
+        }));
         return { sessionId: params.sessionId, status: "ok" };
     }
     getSession(sessionId) {
@@ -262,54 +285,150 @@ class MulticlawsService extends node_events_1.EventEmitter {
     listSessions() {
         return this.sessionStore.list();
     }
+    async waitForSessions(params) {
+        const timeout = params.timeoutMs ?? 5 * 60 * 1000;
+        const deadline = Date.now() + timeout;
+        const terminalStates = new Set(["completed", "failed", "canceled"]);
+        const getResults = () => params.sessionIds.map((id) => {
+            const session = this.sessionStore.get(id);
+            if (!session)
+                return { sessionId: id, agentName: "unknown", status: "not_found" };
+            const lastAgent = [...session.messages].reverse().find((m) => m.role === "agent");
+            return {
+                sessionId: id,
+                agentName: session.agentName,
+                status: session.status,
+                lastMessage: lastAgent?.content,
+                error: session.error,
+            };
+        });
+        while (Date.now() < deadline) {
+            const results = getResults();
+            const allSettled = results.every((r) => terminalStates.has(r.status) || r.status === "not_found");
+            if (allSettled)
+                return { results, timedOut: false };
+            // Return early if any session needs input — AI must handle it before continuing
+            const needsInput = results.some((r) => r.status === "input-required");
+            if (needsInput)
+                return { results, timedOut: false };
+            await new Promise((r) => setTimeout(r, 1_000));
+        }
+        return { results: getResults(), timedOut: true };
+    }
     endSession(sessionId) {
         const session = this.sessionStore.get(sessionId);
         if (!session)
             return false;
         this.sessionStore.update(sessionId, { status: "canceled" });
+        // Signal the in-flight runSession to abort
+        const abort = this.sessionAborts.get(sessionId);
+        if (abort)
+            abort.abort();
         return true;
     }
+    // Fix #5: serialise concurrent calls on the same session
+    async acquireSessionLock(sessionId, fn) {
+        const prev = this.sessionLocks.get(sessionId) ?? Promise.resolve();
+        let release;
+        const next = new Promise((r) => { release = r; });
+        this.sessionLocks.set(sessionId, next);
+        try {
+            await prev;
+            await fn();
+        }
+        finally {
+            release();
+            if (this.sessionLocks.get(sessionId) === next) {
+                this.sessionLocks.delete(sessionId);
+            }
+        }
+    }
     async runSession(params) {
-        const timeout = params.timeoutMs ?? 5 * 60 * 1000; // 5 min default
-        const timeoutController = new AbortController();
-        const timer = setTimeout(() => timeoutController.abort(), timeout);
+        const timeout = params.timeoutMs ?? 5 * 60 * 1000;
+        const deadline = Date.now() + timeout;
+        const abortController = new AbortController();
+        this.sessionAborts.set(params.sessionId, abortController);
+        const timer = setTimeout(() => abortController.abort(), timeout);
         try {
             const client = await this.createA2AClient(params.agentRecord);
-            const result = await Promise.race([
-                client.sendMessage({
-                    message: {
-                        kind: "message",
-                        role: "user",
-                        parts: [{ kind: "text", text: params.message }],
-                        messageId: (0, node_crypto_1.randomUUID)(),
-                        contextId: params.contextId,
-                        ...(params.taskId ? { taskId: params.taskId } : {}),
-                    },
+            const withAbort = (p) => Promise.race([
+                p,
+                new Promise((_, reject) => {
+                    if (abortController.signal.aborted) {
+                        reject(new Error("session canceled"));
+                        return;
+                    }
+                    abortController.signal.addEventListener("abort", () => reject(new Error(this.sessionStore.get(params.sessionId)?.status === "canceled"
+                        ? "session canceled"
+                        : "session timeout")));
                 }),
-                new Promise((_, reject) => timeoutController.signal.addEventListener("abort", () => reject(new Error("session timeout")))),
             ]);
+            let result = await withAbort(client.sendMessage({
+                message: {
+                    kind: "message",
+                    role: "user",
+                    parts: [{ kind: "text", text: params.message }],
+                    messageId: (0, node_crypto_1.randomUUID)(),
+                    // Fix #4: only pass contextId if we have a server-assigned one
+                    ...(params.contextId ? { contextId: params.contextId } : {}),
+                    ...(params.taskId ? { taskId: params.taskId } : {}),
+                },
+            }));
+            // Fix #1: poll until terminal state if server returns working/submitted
+            const POLL_DELAYS = [1000, 2000, 3000, 5000];
+            let pollAttempt = 0;
+            while (true) {
+                const state = this.extractResultState(result);
+                const remoteTaskId = "id" in result ? result.id : undefined;
+                if (state !== "working" && state !== "submitted")
+                    break;
+                if (!remoteTaskId)
+                    break; // can't poll without task id
+                if (Date.now() >= deadline)
+                    throw new Error("session timeout");
+                const delay = POLL_DELAYS[Math.min(pollAttempt, POLL_DELAYS.length - 1)];
+                await new Promise((r) => setTimeout(r, delay));
+                pollAttempt++;
+                result = await withAbort(client.getTask({ id: remoteTaskId, historyLength: 10 }));
+            }
+            // Check if session was canceled while we were running
+            const current = this.sessionStore.get(params.sessionId);
+            if (current?.status === "canceled")
+                return;
             await this.handleSessionResult(params.sessionId, result);
         }
         catch (err) {
+            // Don't overwrite a user-initiated cancel
+            const current = this.sessionStore.get(params.sessionId);
+            if (current?.status === "canceled")
+                return;
             const errorMsg = err instanceof Error ? err.message : String(err);
             this.sessionStore.update(params.sessionId, { status: "failed", error: errorMsg });
             await this.notifySessionUpdate(params.sessionId, "failed");
         }
         finally {
             clearTimeout(timer);
+            this.sessionAborts.delete(params.sessionId);
+        }
+    }
+    extractResultState(result) {
+        if ("status" in result && result.status) {
+            return result.status?.state ?? "unknown";
         }
+        return "completed"; // plain Message = completed
     }
     async handleSessionResult(sessionId, result) {
-        // Extract content
         let content = "";
         let state = "completed";
         let remoteTaskId;
+        let serverContextId;
         if ("status" in result && result.status) {
             const task = result;
             state = task.status?.state ?? "completed";
             remoteTaskId = task.id;
+            // Fix #4: capture server-assigned contextId
+            serverContextId = task.contextId;
             content = this.extractArtifactText(task);
-            // Also try to get text from task messages if artifacts empty
             if (!content && task.history?.length) {
                 const lastAgentMsg = [...task.history].reverse().find((m) => m.role === "agent");
                 if (lastAgentMsg) {
@@ -323,23 +442,24 @@ class MulticlawsService extends node_events_1.EventEmitter {
         else {
             const msg = result;
             remoteTaskId = msg.taskId;
+            serverContextId = msg.contextId;
             content = msg.parts
                 ?.filter((p) => p.kind === "text")
                 .map((p) => p.text)
                 .join("\n") ?? "";
         }
-        // Append agent message to history
-        if (content) {
-            this.sessionStore.appendMessage(sessionId, {
-                role: "agent",
-                content,
-                timestampMs: Date.now(),
-                taskId: remoteTaskId,
-            });
-        }
-        // Update session state
+        // Fix #6: always record agent message, use placeholder when content is empty
+        this.sessionStore.appendMessage(sessionId, {
+            role: "agent",
+            content: content || "(no text output)",
+            timestampMs: Date.now(),
+            taskId: remoteTaskId,
+        });
+        // Fix #4: update contextId with server-assigned value
+        const contextUpdate = serverContextId ? { contextId: serverContextId } : {};
         if (state === "input-required" || state === "auth-required") {
             this.sessionStore.update(sessionId, {
+                ...contextUpdate,
                 status: "input-required",
                 currentTaskId: remoteTaskId,
             });
@@ -347,36 +467,54 @@ class MulticlawsService extends node_events_1.EventEmitter {
         }
         else if (state === "failed" || state === "rejected") {
             this.sessionStore.update(sessionId, {
+                ...contextUpdate,
                 status: "failed",
                 currentTaskId: remoteTaskId,
                 error: content || "remote task failed",
             });
             await this.notifySessionUpdate(sessionId, "failed");
         }
-        else if (state === "completed" || state === "canceled") {
+        else if (state === "completed") {
             this.sessionStore.update(sessionId, {
+                ...contextUpdate,
                 status: "completed",
                 currentTaskId: remoteTaskId,
             });
             await this.notifySessionUpdate(sessionId, "completed");
         }
+        else if (state === "canceled") {
+            // Fix #2: canceled remote task → local status "canceled", not "completed"
+            this.sessionStore.update(sessionId, {
+                ...contextUpdate,
+                status: "canceled",
+                currentTaskId: remoteTaskId,
+                error: "remote task was canceled",
+            });
+            await this.notifySessionUpdate(sessionId, "failed");
+        }
         else {
-            // working / submitted / unknown — still in progress, no notification
-            this.sessionStore.update(sessionId, { currentTaskId: remoteTaskId });
+            // working / submitted / unknown: runSession's polling loop handles these
+            this.sessionStore.update(sessionId, { ...contextUpdate, currentTaskId: remoteTaskId });
         }
     }
     async notifySessionUpdate(sessionId, event) {
-        if (!this.options.gatewayConfig)
+        if (!this.options.gatewayConfig) {
+            this.log("warn", `session ${sessionId} ${event} but gateway config unavailable — user won't be notified. Check gateway.auth.token in config.`);
             return;
+        }
         const session = this.sessionStore.get(sessionId);
         if (!session)
             return;
         const lastAgentMsg = [...session.messages].reverse().find((m) => m.role === "agent");
-        const content = lastAgentMsg?.content ?? "";
+        const rawContent = lastAgentMsg?.content ?? "";
+        // Don't show the placeholder text in user-facing notifications
+        const content = rawContent === "(no text output)" ? "" : rawContent;
         const agentName = session.agentName;
         let message;
         if (event === "completed") {
-            message = [`✅ **${agentName} 任务完成** (session: \`${sessionId}\`)`, "", content].join("\n");
+            message = content
+                ? [`✅ **${agentName} 任务完成** (session: \`${sessionId}\`)`, "", content].join("\n")
+                : `✅ **${agentName} 任务完成** (session: \`${sessionId}\`) — 任务已执行但无文本输出，可能产生了 artifacts。`;
         }
         else if (event === "input-required") {
             message = [
@@ -556,7 +694,7 @@ class MulticlawsService extends node_events_1.EventEmitter {
             }
         }));
         for (const m of others) {
-            await this.agentRegistry.remove(m.url);
+            await this.agentRegistry.removeTeamSource(m.url, team.teamId);
         }
         await this.teamStore.deleteTeam(team.teamId);
         this.log("info", `left team ${team.teamId}`);
@@ -632,10 +770,14 @@ class MulticlawsService extends node_events_1.EventEmitter {
                     name: member.name,
                     description: member.description,
                 });
+                await this.agentRegistry.addTeamSource(normalizedUrl, team.teamId);
                 // Broadcast to other members if new
                 if (!alreadyKnown) {
                     const selfNormalized = this.selfUrl.replace(/\/+$/, "");
-                    const others = team.members.filter((m) => m.url.replace(/\/+$/, "") !== normalizedUrl &&
+                    // Re-read team after addMember to get the latest member list,
+                    // avoiding missed broadcasts when multiple members join concurrently
+                    const freshTeam = await this.teamStore.getTeam(team.teamId);
+                    const others = (freshTeam?.members ?? team.members).filter((m) => m.url.replace(/\/+$/, "") !== normalizedUrl &&
                         m.url.replace(/\/+$/, "") !== selfNormalized);
                     for (const other of others) {
                         void this.fetchWithRetry(`${other.url}/team/${team.teamId}/announce`, {
@@ -755,14 +897,20 @@ class MulticlawsService extends node_events_1.EventEmitter {
                 const client = await this.clientFactory.createFromUrl(m.url);
                 const card = await client.getAgentCard();
                 if (card.description) {
-                    m.description = card.description;
+                    // Use addMember (which uses withJsonLock) instead of saveTeam
+                    // to avoid overwriting concurrent member additions
+                    await this.teamStore.addMember(team.teamId, {
+                        url: m.url,
+                        name: m.name,
+                        description: card.description,
+                        joinedAtMs: m.joinedAtMs,
+                    });
                 }
             }
             catch {
                 this.log("warn", `failed to fetch Agent Card from ${m.url}`);
             }
         }));
-        await this.teamStore.saveTeam(team);
     }
     async syncTeamToRegistry(team) {
         const selfNormalized = this.selfUrl.replace(/\/+$/, "");
@@ -774,6 +922,7 @@ class MulticlawsService extends node_events_1.EventEmitter {
                 name: member.name,
                 description: member.description,
             });
+            await this.agentRegistry.addTeamSource(member.url, team.teamId);
         }
     }
     async createA2AClient(agent) {

package/dist/service/session-store.js

@@ -10,6 +10,7 @@ const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
 const DEFAULT_TTL_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
 const MAX_SESSIONS = 1_000;
+const MAX_MESSAGES_PER_SESSION = 200;
 function emptyStore() {
     return { version: 1, sessions: [] };
 }
@@ -66,9 +67,12 @@ class SessionStore {
         const session = this.get(sessionId);
         if (!session)
             return null;
-        return this.update(sessionId, {
-            messages: [...session.messages, msg],
-        });
+        let messages = [...session.messages, msg];
+        // Truncate old messages, keeping the most recent ones
+        if (messages.length > MAX_MESSAGES_PER_SESSION) {
+            messages = messages.slice(-MAX_MESSAGES_PER_SESSION);
+        }
+        return this.update(sessionId, { messages });
     }
     loadSync() {
         node_fs_1.default.mkdirSync(node_path_1.default.dirname(this.filePath), { recursive: true });

package/package.json

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

package/skills/multiclaws/SKILL.md

@@ -49,13 +49,19 @@ multiclaws_session_status(sessionId="...") → 查看单个会话及消息历史
 multiclaws_session_end(sessionId="...")  → 取消并关闭会话
 ```
 
-### 并发协作
-可同时开启多个 session，各自独立运行：
+### 并发协作（自动汇总）
+同时开启多个 session，等所有结果后汇总：
 ```
-multiclaws_session_start(agentUrl=B, message="任务1") → sessionId_1
-multiclaws_session_start(agentUrl=C, message="任务2") → sessionId_2
+id1 = multiclaws_session_start(agentUrl=B, message="子任务1")
+id2 = multiclaws_session_start(agentUrl=C, message="子任务2")
+results = multiclaws_session_wait_all(sessionIds=[id1, id2])
+→ 阻塞直到全部完成，返回所有结果
+→ AI 汇总后回复用户
 ```
 
+**注意**：若任何 session 变为 `input-required`，`wait_all` 会提前返回，
+AI 应先用 `session_reply` 处理，再继续等待剩余 session。
+
 ### 链式协作（A→B→C）
 B 内部可以自己调用 `multiclaws_session_start` 委派给 C，结果自然冒泡回 A。
 
@@ -99,6 +105,7 @@ multiclaws_profile_show()
 | `multiclaws_session_start` | 开始协作会话（替代旧 delegate） | `agentUrl`, `message` |
 | `multiclaws_session_reply` | 在会话中发送后续消息 | `sessionId`, `message` |
 | `multiclaws_session_status` | 查看会话状态和消息历史 | `sessionId`（可选，不传返回全部） |
+| `multiclaws_session_wait_all` | 等待多个会话全部完成，返回所有结果 | `sessionIds[]`, `timeoutMs`（可选） |
 | `multiclaws_session_end` | 取消/关闭会话 | `sessionId` |
 
 ### 档案