multiclaws 0.4.1 → 0.4.3

package/dist/gateway/handlers.js

@@ -40,9 +40,14 @@ function createGatewayHandlers(getService) {
     const handlers = {
         /* ── Agent handlers ─────────────────────────────────────────── */
         "multiclaws.agent.list": async ({ respond }) => {
-            const service = getService();
-            const agents = await service.listAgents();
-            respond(true, { agents });
+            try {
+                const service = getService();
+                const agents = await service.listAgents();
+                respond(true, { agents });
+            }
+            catch (error) {
+                safeHandle(respond, "agent_list_failed", error);
+            }
         },
         "multiclaws.agent.add": async ({ params, respond }) => {
             try {
@@ -187,19 +192,34 @@ function createGatewayHandlers(getService) {
         },
         /* ── Profile handlers ───────────────────────────────────────── */
         "multiclaws.profile.show": async ({ respond }) => {
-            const service = getService();
-            const profile = await service.getProfile();
-            respond(true, profile);
+            try {
+                const service = getService();
+                const profile = await service.getProfile();
+                respond(true, profile);
+            }
+            catch (error) {
+                safeHandle(respond, "profile_show_failed", error);
+            }
         },
         "multiclaws.profile.pending_review": async ({ respond }) => {
-            const service = getService();
-            const result = await service.getPendingProfileReview();
-            respond(true, result);
+            try {
+                const service = getService();
+                const result = await service.getPendingProfileReview();
+                respond(true, result);
+            }
+            catch (error) {
+                safeHandle(respond, "profile_pending_review_failed", error);
+            }
         },
         "multiclaws.profile.clear_pending_review": async ({ respond }) => {
-            const service = getService();
-            await service.clearPendingProfileReview();
-            respond(true, { cleared: true });
+            try {
+                const service = getService();
+                await service.clearPendingProfileReview();
+                respond(true, { cleared: true });
+            }
+            catch (error) {
+                safeHandle(respond, "profile_clear_pending_review_failed", error);
+            }
         },
         "multiclaws.profile.set": async ({ params, respond }) => {
             try {

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 = {
@@ -366,7 +369,7 @@ function createTools(getService) {
 const plugin = {
     id: "multiclaws",
     name: "MultiClaws",
-    version: "0.3.1",
+    version: "0.4.2",
     register(api) {
         const config = readConfig(api);
         (0, telemetry_1.initializeTelemetry)({ enableConsoleExporter: config.telemetry?.consoleExporter });
@@ -379,7 +382,7 @@ const plugin = {
             if (gw) {
                 const tools = (gw.tools ?? {});
                 const allow = Array.isArray(tools.allow) ? tools.allow : [];
-                const required = ["sessions_spawn", "sessions_history"];
+                const required = ["sessions_spawn", "sessions_history", "message"];
                 const missing = required.filter((t) => !allow.includes(t));
                 if (missing.length > 0) {
                     tools.allow = [...allow, ...missing];
@@ -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/infra/gateway-client.js

@@ -40,6 +40,7 @@ exports.invokeGatewayTool = invokeGatewayTool;
 const opossum_1 = __importDefault(require("opossum"));
 class NonRetryableError extends Error {
 }
+const MAX_BREAKERS = 50;
 const breakerCache = new Map();
 let pRetryModulePromise = null;
 async function loadPRetry() {
@@ -53,6 +54,15 @@ function getBreaker(key, timeoutMs) {
     if (existing) {
         return existing;
     }
+    // Evict oldest entries when cache is full
+    if (breakerCache.size >= MAX_BREAKERS) {
+        const oldest = breakerCache.keys().next().value;
+        if (oldest !== undefined) {
+            const old = breakerCache.get(oldest);
+            old?.shutdown();
+            breakerCache.delete(oldest);
+        }
+    }
     const breaker = new opossum_1.default((operation) => operation(), {
         timeout: false, // timeout handled by AbortController in the operation
         errorThresholdPercentage: 50,

package/dist/infra/tailscale.d.ts

@@ -10,7 +10,7 @@ export type TailscaleStatus = {
     status: "unavailable";
     reason: string;
 };
-/** Check network interfaces for a Tailscale IP (100.x.x.x) — exported for fast-path checks */
+/** Check network interfaces for a Tailscale IP (100.64.0.0/10) — exported for fast-path checks */
 export declare function getTailscaleIpFromInterfaces(): string | null;
 /**
  * Detect Tailscale status — does NOT install or modify system state.

package/dist/infra/tailscale.js

@@ -7,6 +7,7 @@ exports.getTailscaleIpFromInterfaces = getTailscaleIpFromInterfaces;
 exports.detectTailscale = detectTailscale;
 const node_child_process_1 = require("node:child_process");
 const node_os_1 = __importDefault(require("node:os"));
+const isWindows = process.platform === "win32";
 function run(cmd, timeoutMs = 5_000) {
     return (0, node_child_process_1.execSync)(cmd, { timeout: timeoutMs, stdio: ["ignore", "pipe", "pipe"] })
         .toString()
@@ -14,21 +15,30 @@ function run(cmd, timeoutMs = 5_000) {
 }
 function commandExists(cmd) {
     try {
-        run(`which ${cmd}`);
+        run(isWindows ? `where ${cmd}` : `which ${cmd}`);
         return true;
     }
     catch {
         return false;
     }
 }
-/** Check network interfaces for a Tailscale IP (100.x.x.x) — exported for fast-path checks */
+/** Check whether an IPv4 address falls within the Tailscale CGNAT range (100.64.0.0/10). */
+function isTailscaleCGNAT(ip) {
+    const parts = ip.split(".");
+    if (parts.length !== 4)
+        return false;
+    const first = parseInt(parts[0], 10);
+    const second = parseInt(parts[1], 10);
+    return first === 100 && second >= 64 && second <= 127;
+}
+/** Check network interfaces for a Tailscale IP (100.64.0.0/10) — exported for fast-path checks */
 function getTailscaleIpFromInterfaces() {
     const interfaces = node_os_1.default.networkInterfaces();
     for (const addrs of Object.values(interfaces)) {
         if (!addrs)
             continue;
         for (const addr of addrs) {
-            if (addr.family === "IPv4" && addr.address.startsWith("100.")) {
+            if (addr.family === "IPv4" && isTailscaleCGNAT(addr.address)) {
                 return addr.address;
             }
         }
@@ -61,8 +71,7 @@ async function getAuthUrl() {
     return new Promise((resolve) => {
         try {
             // tailscale up prints the auth URL to stderr
-            const { spawn } = require("node:child_process");
-            const proc = spawn("tailscale", ["up"], { stdio: ["ignore", "pipe", "pipe"] });
+            const proc = (0, node_child_process_1.spawn)("tailscale", ["up"], { stdio: ["ignore", "pipe", "pipe"] });
             let output = "";
             let resolved = false;
             const tryResolve = (text) => {

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenClawAgentExecutor = void 0;
+const node_crypto_1 = require("node:crypto");
 const gateway_client_1 = require("../infra/gateway-client");
 function extractTextFromMessage(message) {
     if (!message.parts)
@@ -10,6 +11,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 +71,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 +87,17 @@ 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.a2aToTracker.delete(taskId);
             this.publishMessage(eventBus, "Error: gateway config not available, cannot execute task.");
             eventBus.finished();
             return;
@@ -90,16 +124,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 +192,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 +232,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();
     }
@@ -199,7 +245,7 @@ class OpenClawAgentExecutor {
         const message = {
             kind: "message",
             role: "agent",
-            messageId: `msg-${Date.now()}`,
+            messageId: (0, node_crypto_1.randomUUID)(),
             parts: [{ kind: "text", text }],
         };
         eventBus.publish(message);

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

@@ -32,14 +32,17 @@ class AgentRegistry {
             const normalizedUrl = params.url.replace(/\/+$/, "");
             const existing = store.agents.findIndex((a) => a.url === normalizedUrl);
             const now = Date.now();
+            const prev = existing >= 0 ? store.agents[existing] : null;
             const record = {
                 url: normalizedUrl,
                 name: params.name,
                 description: params.description ?? "",
                 skills: params.skills ?? [],
                 apiKey: params.apiKey,
-                addedAtMs: existing >= 0 ? store.agents[existing].addedAtMs : now,
+                addedAtMs: prev?.addedAtMs ?? now,
                 lastSeenAtMs: now,
+                // Preserve existing teamIds so that team associations are not lost on upsert
+                ...(prev?.teamIds?.length ? { teamIds: prev.teamIds } : {}),
             };
             if (existing >= 0) {
                 store.agents[existing] = record;
@@ -73,6 +76,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;
@@ -106,7 +110,7 @@ class MulticlawsService extends node_events_1.EventEmitter {
             name: this.options.displayName ?? (profile.ownerName || "OpenClaw Agent"),
             description: this.profileDescription,
             url: this.selfUrl,
-            version: "0.3.0",
+            version: "0.4.2",
             protocolVersion: "0.2.2",
             defaultInputModes: ["text/plain"],
             defaultOutputModes: ["text/plain"],
@@ -145,7 +149,13 @@ class MulticlawsService extends node_events_1.EventEmitter {
         }));
         const listenPort = this.options.port ?? 3100;
         this.httpServer = node_http_1.default.createServer(app);
-        await new Promise((resolve) => this.httpServer.listen(listenPort, "0.0.0.0", resolve));
+        await new Promise((resolve, reject) => {
+            this.httpServer.once("error", reject);
+            this.httpServer.listen(listenPort, "0.0.0.0", () => {
+                this.httpServer.removeListener("error", reject);
+                resolve();
+            });
+        });
         this.started = true;
         this.log("info", `multiclaws A2A service listening on :${listenPort}`);
     }
@@ -153,6 +163,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 +187,7 @@ class MulticlawsService extends node_events_1.EventEmitter {
         this.httpServer = null;
     }
     updateGatewayConfig(config) {
+        this.options.gatewayConfig = config;
         this.agentExecutor?.updateGatewayConfig(config);
     }
     /* ---------------------------------------------------------------- */
@@ -178,20 +201,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 +231,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 +275,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 +326,117 @@ 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 } : {}),
-                    },
-                }),
-                new Promise((_, reject) => timeoutController.signal.addEventListener("abort", () => reject(new Error("session timeout")))),
-            ]);
+            const withAbort = (p) => {
+                if (abortController.signal.aborted) {
+                    return Promise.reject(new Error("session canceled"));
+                }
+                return new Promise((resolve, reject) => {
+                    const onAbort = () => {
+                        reject(new Error(this.sessionStore.get(params.sessionId)?.status === "canceled"
+                            ? "session canceled"
+                            : "session timeout"));
+                    };
+                    abortController.signal.addEventListener("abort", onAbort, { once: true });
+                    p.then((val) => { abortController.signal.removeEventListener("abort", onAbort); resolve(val); }, (err) => { abortController.signal.removeEventListener("abort", onAbort); reject(err); });
+                });
+            };
+            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 +450,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 +475,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 +702,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 +778,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`, {
@@ -702,7 +822,7 @@ class MulticlawsService extends node_events_1.EventEmitter {
                 }
                 const normalizedUrl = parsed.data.url.replace(/\/+$/, "");
                 await this.teamStore.removeMember(team.teamId, normalizedUrl);
-                await this.agentRegistry.remove(normalizedUrl);
+                await this.agentRegistry.removeTeamSource(normalizedUrl, team.teamId);
                 res.json({ ok: true });
             }
             catch (err) {
@@ -752,12 +872,13 @@ class MulticlawsService extends node_events_1.EventEmitter {
         const selfNormalized = this.selfUrl.replace(/\/+$/, "");
         const displayName = this.options.displayName ?? node_os_1.default.hostname();
         for (const team of teams) {
-            // Update self in team store
+            // Update self in team store, preserving original joinedAtMs
+            const selfMember = team.members.find((m) => m.url.replace(/\/+$/, "") === selfNormalized);
             await this.teamStore.addMember(team.teamId, {
                 url: this.selfUrl,
                 name: displayName,
                 description: this.profileDescription,
-                joinedAtMs: Date.now(),
+                joinedAtMs: selfMember?.joinedAtMs ?? Date.now(),
             });
             // Broadcast to other members
             const others = team.members.filter((m) => m.url.replace(/\/+$/, "") !== selfNormalized);
@@ -785,14 +906,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 +931,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,9 +10,24 @@ 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: [] };
 }
+function normalizeStore(raw) {
+    if (raw.version !== 1 || !Array.isArray(raw.sessions)) {
+        return emptyStore();
+    }
+    return {
+        version: 1,
+        sessions: raw.sessions.filter((s) => s &&
+            typeof s.sessionId === "string" &&
+            typeof s.agentUrl === "string" &&
+            typeof s.status === "string" &&
+            typeof s.createdAtMs === "number" &&
+            Array.isArray(s.messages)),
+    };
+}
 class SessionStore {
     filePath;
     ttlMs;
@@ -66,17 +81,18 @@ 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 });
         try {
             const raw = JSON.parse(node_fs_1.default.readFileSync(this.filePath, "utf8"));
-            if (raw.version !== 1 || !Array.isArray(raw.sessions))
-                return emptyStore();
-            return raw;
+            return normalizeStore(raw);
         }
         catch {
             const store = emptyStore();

package/package.json

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