multiclaws 0.4.1 → 0.4.2

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 = {
@@ -437,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;
@@ -77,7 +81,9 @@ export declare class MulticlawsService extends EventEmitter {
         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) {
@@ -297,49 +320,115 @@ class MulticlawsService extends node_events_1.EventEmitter {
         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) {
@@ -353,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,
             });
@@ -377,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 = [
@@ -586,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}`);
@@ -662,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`, {
@@ -785,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(/\/+$/, "");
@@ -804,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.1",
+  "version": "0.4.2",
   "description": "MultiClaws plugin for OpenClaw collaboration via A2A protocol",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",