libp2p-mesh 2026.5.18 → 2026.5.20

package/dist/src/agent-tools.d.ts

@@ -310,11 +310,18 @@ export declare function buildP2PTools(mesh: MeshNetwork): ({
             text: string;
         }[];
         details: {
-            knownIdentities: ({
-                instanceId: any;
-                agentId: any;
-                channel: any;
-            } | null)[];
+            localPeerId: string;
+            localInstanceId: any;
+            connectedPeers: number;
+            knownPeers: {
+                peerId: string;
+                agentId: string;
+                channel: string;
+                instanceId?: string;
+                sessionKey: string;
+                status: string;
+                lastSeen?: number;
+            }[];
         };
     }>;
 })[];

package/dist/src/agent-tools.js

@@ -278,28 +278,59 @@ export function buildP2PTools(mesh) {
         {
             name: "p2p_relay_status",
             label: "P2P Relay Status",
-            description: "Get current P2P mesh connection status, known peers, and identity mapping.",
+            description: "Get full P2P mesh identity table: local node info, all known peers (connected or not), their instance IDs, channels, and last seen time.",
             parameters: { type: "object", properties: {} },
             async execute(_toolCallId, _params, _ctx) {
                 const peerIdentityMap = this.peerIdentityMap;
                 const localPeerId = mesh.getLocalPeerId();
                 const connectedPeers = mesh.getConnectedPeers();
-                const knownIdentities = connectedPeers
-                    .map((p) => {
-                    const identity = peerIdentityMap?.resolve(p);
-                    if (!identity)
-                        return null;
-                    return {
-                        instanceId: identity.instanceId || p.slice(0, 12) + "...",
+                const connectedSet = new Set(connectedPeers);
+                // Build full identity table from all known peers (not just connected)
+                const allPeers = [];
+                for (const [peerId, identity] of peerIdentityMap?.entries() ?? []) {
+                    if (peerId === localPeerId)
+                        continue; // skip local in peer list
+                    allPeers.push({
+                        peerId,
                         agentId: identity.agentId,
                         channel: identity.channel,
-                    };
-                })
-                    .filter(Boolean);
-                const text = `P2P Mesh Status:\nLocal Peer ID: ${localPeerId}\nConnected Peers: ${connectedPeers.length}\nKnown Identities: ${knownIdentities.length}`;
+                        instanceId: identity.instanceId,
+                        sessionKey: identity.sessionKey,
+                        status: connectedSet.has(peerId) ? "connected" : "known",
+                        lastSeen: identity.lastSeen,
+                    });
+                }
+                // Local identity
+                const localIdentity = peerIdentityMap?.getLocalIdentity();
+                const localInstanceId = localIdentity?.instanceId ?? "(not set)";
+                // Format output
+                const lines = [];
+                lines.push(`P2P Mesh Identity Table`);
+                lines.push(`Local: ${localPeerId.slice(0, 16)}... | Instance: ${localInstanceId}`);
+                lines.push(`Connected: ${connectedPeers.length} | Known total: ${allPeers.length}`);
+                lines.push("");
+                if (allPeers.length === 0) {
+                    lines.push("(no known peers yet)");
+                }
+                else {
+                    for (const p of allPeers) {
+                        const shortId = p.peerId.slice(0, 16) + "...";
+                        const time = p.lastSeen ? new Date(p.lastSeen).toLocaleTimeString() : "unknown";
+                        lines.push(`  [${p.status}] ${shortId}`);
+                        lines.push(`    Agent: ${p.agentId} | Channel: ${p.channel}`);
+                        lines.push(`    Instance: ${p.instanceId ?? "unknown"}`);
+                        lines.push(`    Last seen: ${time}`);
+                    }
+                }
+                const text = lines.join("\n");
                 return {
                     content: [{ type: "text", text }],
-                    details: { knownIdentities },
+                    details: {
+                        localPeerId,
+                        localInstanceId,
+                        connectedPeers: connectedPeers.length,
+                        knownPeers: allPeers,
+                    },
                 };
             },
         },

package/dist/src/mesh.js

@@ -77,6 +77,8 @@ export function createMeshNetwork(options) {
     const seenMessages = new Set();
     const messageHandlers = new Set();
     const topicHandlers = new Map();
+    const peerConnectHandlers = new Set();
+    const peerDisconnectHandlers = new Set();
     function getDHTService() {
         return state.node?.services?.dht;
     }
@@ -215,10 +217,22 @@ export function createMeshNetwork(options) {
         state.node.addEventListener("peer:connect", (evt) => {
             const peerIdStr = evt.detail.toString();
             logger?.info?.(`[libp2p-mesh] Peer connected: ${peerIdStr}`);
+            for (const handler of peerConnectHandlers) {
+                try {
+                    handler(peerIdStr);
+                }
+                catch { }
+            }
         });
         state.node.addEventListener("peer:disconnect", (evt) => {
             const peerIdStr = evt.detail.toString();
             logger?.info?.(`[libp2p-mesh] Peer disconnected: ${peerIdStr}`);
+            for (const handler of peerDisconnectHandlers) {
+                try {
+                    handler(peerIdStr);
+                }
+                catch { }
+            }
         });
         await state.node.handle(PROTOCOL, async ({ stream, connection }) => {
             try {
@@ -580,6 +594,14 @@ export function createMeshNetwork(options) {
         stop,
         sendToPeer,
         onMessage,
+        onPeerConnect(handler) {
+            peerConnectHandlers.add(handler);
+            return () => { peerConnectHandlers.delete(handler); };
+        },
+        onPeerDisconnect(handler) {
+            peerDisconnectHandlers.add(handler);
+            return () => { peerDisconnectHandlers.delete(handler); };
+        },
         publishToTopic,
         subscribeToTopic,
         getLocalPeerId,

package/dist/src/peer-identity.d.ts

@@ -3,8 +3,12 @@ export interface PeerIdentity {
     channel: string;
     accountId: string;
     sessionKey: string;
-    /** Human-readable Instance ID (e.g. "alice-mac@AQIDBAU.7a3f9e2b") */
+    /** Human-readable Instance ID */
     instanceId?: string;
+    /** When this identity was first registered (epoch ms) */
+    firstSeen?: number;
+    /** Last time we saw this peer (epoch ms) */
+    lastSeen?: number;
 }
 export interface PeerIdentityMap {
     register(peerId: string, identity: PeerIdentity): void;
@@ -19,5 +23,9 @@ export interface PeerIdentityMap {
     getLocalIdentity(): PeerIdentity | undefined;
     hasIdentity(peerId: string): boolean;
     entries(): IterableIterator<[string, PeerIdentity]>;
+    /** Persist current state to disk */
+    save(): Promise<void>;
 }
-export declare function createPeerIdentityMap(): PeerIdentityMap;
+export declare function createPeerIdentityMap(storePath?: string): PeerIdentityMap & {
+    load(): Promise<void>;
+};

package/dist/src/peer-identity.js

@@ -1,14 +1,66 @@
-export function createPeerIdentityMap() {
+import { homedir } from "node:os";
+import path from "node:path";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+const DEFAULT_STORE_PATH = path.join(homedir(), ".openclaw", "libp2p", "peer-identities.json");
+export function createPeerIdentityMap(storePath) {
     const peers = new Map();
     const byInstanceId = new Map();
     let localPeerId;
     let localIdentity;
+    const filePath = storePath ?? DEFAULT_STORE_PATH;
+    async function save() {
+        const entries = {};
+        for (const [peerId, identity] of peers.entries()) {
+            entries[peerId] = identity;
+        }
+        const payload = {
+            localPeerId,
+            localIdentity,
+            peers: entries,
+            savedAt: Date.now(),
+        };
+        try {
+            await mkdir(path.dirname(filePath), { recursive: true });
+            await writeFile(filePath, JSON.stringify(payload, null, 2), "utf-8");
+        }
+        catch {
+            // Best-effort persistence; non-critical
+        }
+    }
+    async function load() {
+        try {
+            const raw = await readFile(filePath, "utf-8");
+            const data = JSON.parse(raw);
+            if (data.localPeerId)
+                localPeerId = data.localPeerId;
+            if (data.localIdentity)
+                localIdentity = data.localIdentity;
+            if (data.peers) {
+                for (const [peerId, identity] of Object.entries(data.peers)) {
+                    peers.set(peerId, identity);
+                    const id = identity.instanceId;
+                    if (id)
+                        byInstanceId.set(id, { peerId, identity: identity });
+                }
+            }
+        }
+        catch {
+            // File doesn't exist yet or is corrupt — start fresh
+        }
+    }
     return {
+        async save() { await save(); },
+        async load() { await load(); },
         register(peerId, identity) {
+            const now = Date.now();
+            const existing = peers.get(peerId);
+            identity.firstSeen = existing?.firstSeen ?? now;
+            identity.lastSeen = now;
             peers.set(peerId, identity);
             if (identity.instanceId) {
                 byInstanceId.set(identity.instanceId, { peerId, identity });
             }
+            save().catch(() => { });
         },
         resolve(peerId) {
             return peers.get(peerId);
@@ -25,14 +77,22 @@ export function createPeerIdentityMap() {
                 byInstanceId.delete(identity.instanceId);
             }
             peers.delete(peerId);
+            // Note: intentionally NOT saving on unregister — peer disconnects are
+            // often temporary (NAT timeout, network blip). Persisting the deletion
+            // would cause identity re-exchange on every reconnect. The entry will
+            // be refreshed when the peer reconnects and sends a new identity.
         },
         setLocalIdentity(peerId, identity) {
             localPeerId = peerId;
             localIdentity = identity;
+            const now = Date.now();
+            identity.firstSeen = now;
+            identity.lastSeen = now;
             peers.set(peerId, identity);
             if (identity.instanceId) {
                 byInstanceId.set(identity.instanceId, { peerId, identity });
             }
+            save().catch(() => { });
         },
         getLocalIdentity() {
             return localIdentity;

package/dist/src/plugin.js

@@ -24,14 +24,17 @@ export function registerLibp2pMesh(api) {
         id: "libp2p-mesh",
         start: async () => {
             await mesh.start();
-            // Register local identity so remote peers can route messages back to us
+            // Load persisted peer identities from disk
+            await peerIdentityMap.load();
+            // Gather local relay identity info
             const config = api.pluginConfig;
             const relayChannel = config?.relayChannel;
             const relayAccountId = config?.relayAccountId;
             const instanceIdentity = mesh.getInstanceIdentity();
             const localInstanceId = instanceIdentity?.id;
+            const localPeerId = mesh.getLocalPeerId();
+            // Register local identity so remote peers can route messages back to us
             if (relayChannel && relayAccountId) {
-                const localPeerId = mesh.getLocalPeerId();
                 const { buildAgentSessionKey } = await import("openclaw/plugin-sdk/core");
                 const sessionKey = buildAgentSessionKey({
                     agentId: api.name,
@@ -48,8 +51,7 @@ export function registerLibp2pMesh(api) {
                 api.logger.info?.(`[libp2p-mesh] Local identity registered: agent=${api.name}, channel=${relayChannel}, account=${relayAccountId}, instanceId=${localInstanceId}`);
                 // Announce identity to all currently-connected peers
                 const identityMsg = buildIdentityMessage(localPeerId, api.name, relayChannel, relayAccountId, localInstanceId);
-                const connectedPeers = mesh.getConnectedPeers();
-                for (const peerId of connectedPeers) {
+                for (const peerId of mesh.getConnectedPeers()) {
                     try {
                         await mesh.sendToPeer(peerId, JSON.stringify(identityMsg));
                     }
@@ -57,13 +59,24 @@ export function registerLibp2pMesh(api) {
                         // Best-effort; peer may be stale in the connection list
                     }
                 }
+                // When a new peer connects, send our identity to them
+                mesh.onPeerConnect((peerId) => {
+                    const msg = buildIdentityMessage(localPeerId, api.name, relayChannel, relayAccountId, localInstanceId);
+                    mesh.sendToPeer(peerId, JSON.stringify(msg)).catch(() => {
+                        // Best-effort
+                    });
+                });
+                // When a peer disconnects, clean up the identity map
+                mesh.onPeerDisconnect((peerId) => {
+                    peerIdentityMap.unregister(peerId);
+                });
             }
             // Wire up relay-aware message handler
             mesh.onMessage((msg) => {
                 handleP2PInbound(msg, buildInboundDeps());
             });
             const identity = mesh.getInstanceIdentity();
-            api.logger.info?.(`[libp2p-mesh] Service started. Peer ID: ${mesh.getLocalPeerId()}`);
+            api.logger.info?.(`[libp2p-mesh] Service started. Peer ID: ${localPeerId}`);
             if (identity) {
                 api.logger.info?.(`[libp2p-mesh] Instance Identity: ${identity.id}`);
             }

package/dist/src/types.d.ts

@@ -106,6 +106,8 @@ export interface MeshNetwork {
     stop(): Promise<void>;
     sendToPeer(peerId: string, message: string): Promise<void>;
     onMessage(handler: (msg: P2PMessage) => void): () => void;
+    onPeerConnect(handler: (peerId: string) => void): () => void;
+    onPeerDisconnect(handler: (peerId: string) => void): () => void;
     publishToTopic(topic: string, message: string): Promise<void>;
     subscribeToTopic(topic: string, handler: (msg: string) => void): Promise<void>;
     getLocalPeerId(): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libp2p-mesh",
-  "version": "2026.5.18",
+  "version": "2026.5.20",
   "description": "OpenClaw libp2p P2P mesh network plugin for cross-instance agent communication",
   "type": "module",
   "main": "dist/index.js",

package/src/agent-tools.ts

@@ -278,27 +278,62 @@ export function buildP2PTools(mesh: MeshNetwork) {
     {
       name: "p2p_relay_status",
       label: "P2P Relay Status",
-      description: "Get current P2P mesh connection status, known peers, and identity mapping.",
+      description: "Get full P2P mesh identity table: local node info, all known peers (connected or not), their instance IDs, channels, and last seen time.",
       parameters: { type: "object" as const, properties: {} },
       async execute(_toolCallId: string, _params: {}, _ctx: any) {
         const peerIdentityMap = (this as any).peerIdentityMap;
         const localPeerId = mesh.getLocalPeerId();
         const connectedPeers = mesh.getConnectedPeers();
-        const knownIdentities = connectedPeers
-          .map((p) => {
-            const identity = peerIdentityMap?.resolve(p);
-            if (!identity) return null;
-            return {
-              instanceId: identity.instanceId || p.slice(0, 12) + "...",
-              agentId: identity.agentId,
-              channel: identity.channel,
-            };
-          })
-          .filter(Boolean);
-        const text = `P2P Mesh Status:\nLocal Peer ID: ${localPeerId}\nConnected Peers: ${connectedPeers.length}\nKnown Identities: ${knownIdentities.length}`;
+        const connectedSet = new Set(connectedPeers);
+
+        // Build full identity table from all known peers (not just connected)
+        const allPeers: { peerId: string; agentId: string; channel: string; instanceId?: string; sessionKey: string; status: string; lastSeen?: number }[] = [];
+        for (const [peerId, identity] of peerIdentityMap?.entries() ?? []) {
+          if (peerId === localPeerId) continue; // skip local in peer list
+          allPeers.push({
+            peerId,
+            agentId: identity.agentId,
+            channel: identity.channel,
+            instanceId: identity.instanceId,
+            sessionKey: identity.sessionKey,
+            status: connectedSet.has(peerId) ? "connected" : "known",
+            lastSeen: identity.lastSeen,
+          });
+        }
+
+        // Local identity
+        const localIdentity = peerIdentityMap?.getLocalIdentity();
+        const localInstanceId = localIdentity?.instanceId ?? "(not set)";
+
+        // Format output
+        const lines: string[] = [];
+        lines.push(`P2P Mesh Identity Table`);
+        lines.push(`Local: ${localPeerId.slice(0, 16)}... | Instance: ${localInstanceId}`);
+        lines.push(`Connected: ${connectedPeers.length} | Known total: ${allPeers.length}`);
+        lines.push("");
+
+        if (allPeers.length === 0) {
+          lines.push("(no known peers yet)");
+        } else {
+          for (const p of allPeers) {
+            const shortId = p.peerId.slice(0, 16) + "...";
+            const time = p.lastSeen ? new Date(p.lastSeen).toLocaleTimeString() : "unknown";
+            lines.push(`  [${p.status}] ${shortId}`);
+            lines.push(`    Agent: ${p.agentId} | Channel: ${p.channel}`);
+            lines.push(`    Instance: ${p.instanceId ?? "unknown"}`);
+            lines.push(`    Last seen: ${time}`);
+          }
+        }
+
+        const text = lines.join("\n");
         return {
           content: [{ type: "text" as const, text }],
-          details: { knownIdentities },
+          details: {
+            localPeerId,
+            localInstanceId,
+            connectedPeers: connectedPeers.length,
+            knownPeers: allPeers,
+          },
         };
       },
     },

package/src/mesh.ts

@@ -94,6 +94,8 @@ export function createMeshNetwork(options: {
   const seenMessages = new Set<string>();
   const messageHandlers = new Set<(msg: P2PMessage) => void>();
   const topicHandlers = new Map<string, Set<(msg: string) => void>>();
+  const peerConnectHandlers = new Set<(peerId: string) => void>();
+  const peerDisconnectHandlers = new Set<(peerId: string) => void>();
 
   function getDHTService(): ReturnType<typeof kadDHT> extends (components: infer C) => infer R ? R : never | undefined {
     return (state.node as any)?.services?.dht;
@@ -258,11 +260,17 @@ export function createMeshNetwork(options: {
     state.node.addEventListener("peer:connect", (evt) => {
       const peerIdStr = evt.detail.toString();
       logger?.info?.(`[libp2p-mesh] Peer connected: ${peerIdStr}`);
+      for (const handler of peerConnectHandlers) {
+        try { handler(peerIdStr); } catch {}
+      }
     });
 
     state.node.addEventListener("peer:disconnect", (evt) => {
       const peerIdStr = evt.detail.toString();
       logger?.info?.(`[libp2p-mesh] Peer disconnected: ${peerIdStr}`);
+      for (const handler of peerDisconnectHandlers) {
+        try { handler(peerIdStr); } catch {}
+      }
     });
 
     await state.node.handle(
@@ -667,6 +675,14 @@ export function createMeshNetwork(options: {
     stop,
     sendToPeer,
     onMessage,
+    onPeerConnect(handler: (peerId: string) => void): () => void {
+      peerConnectHandlers.add(handler);
+      return () => { peerConnectHandlers.delete(handler); };
+    },
+    onPeerDisconnect(handler: (peerId: string) => void): () => void {
+      peerDisconnectHandlers.add(handler);
+      return () => { peerDisconnectHandlers.delete(handler); };
+    },
     publishToTopic,
     subscribeToTopic,
     getLocalPeerId,

package/src/peer-identity.ts

@@ -1,10 +1,18 @@
+import { homedir } from "node:os";
+import path from "node:path";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+
 export interface PeerIdentity {
   agentId: string;
   channel: string;
   accountId: string;
   sessionKey: string;
-  /** Human-readable Instance ID (e.g. "alice-mac@AQIDBAU.7a3f9e2b") */
+  /** Human-readable Instance ID */
   instanceId?: string;
+  /** When this identity was first registered (epoch ms) */
+  firstSeen?: number;
+  /** Last time we saw this peer (epoch ms) */
+  lastSeen?: number;
 }
 
 export interface PeerIdentityMap {
@@ -17,20 +25,71 @@ export interface PeerIdentityMap {
   getLocalIdentity(): PeerIdentity | undefined;
   hasIdentity(peerId: string): boolean;
   entries(): IterableIterator<[string, PeerIdentity]>;
+  /** Persist current state to disk */
+  save(): Promise<void>;
 }
 
-export function createPeerIdentityMap(): PeerIdentityMap {
+const DEFAULT_STORE_PATH = path.join(homedir(), ".openclaw", "libp2p", "peer-identities.json");
+
+export function createPeerIdentityMap(storePath?: string): PeerIdentityMap & { load(): Promise<void> } {
   const peers = new Map<string, PeerIdentity>();
   const byInstanceId = new Map<string, { peerId: string; identity: PeerIdentity }>();
   let localPeerId: string | undefined;
   let localIdentity: PeerIdentity | undefined;
+  const filePath = storePath ?? DEFAULT_STORE_PATH;
+
+  async function save(): Promise<void> {
+    const entries: Record<string, PeerIdentity> = {};
+    for (const [peerId, identity] of peers.entries()) {
+      entries[peerId] = identity;
+    }
+    const payload = {
+      localPeerId,
+      localIdentity,
+      peers: entries,
+      savedAt: Date.now(),
+    };
+    try {
+      await mkdir(path.dirname(filePath), { recursive: true });
+      await writeFile(filePath, JSON.stringify(payload, null, 2), "utf-8");
+    } catch {
+      // Best-effort persistence; non-critical
+    }
+  }
+
+  async function load(): Promise<void> {
+    try {
+      const raw = await readFile(filePath, "utf-8");
+      const data = JSON.parse(raw);
+      if (data.localPeerId) localPeerId = data.localPeerId;
+      if (data.localIdentity) localIdentity = data.localIdentity;
+      if (data.peers) {
+        for (const [peerId, identity] of Object.entries(data.peers)) {
+          peers.set(peerId, identity as PeerIdentity);
+          const id = (identity as PeerIdentity).instanceId;
+          if (id) byInstanceId.set(id, { peerId, identity: identity as PeerIdentity });
+        }
+      }
+    } catch {
+      // File doesn't exist yet or is corrupt — start fresh
+    }
+  }
 
   return {
+    async save() { await save(); },
+
+    async load() { await load(); },
+
     register(peerId: string, identity: PeerIdentity): void {
+      const now = Date.now();
+      const existing = peers.get(peerId);
+      identity.firstSeen = existing?.firstSeen ?? now;
+      identity.lastSeen = now;
       peers.set(peerId, identity);
       if (identity.instanceId) {
         byInstanceId.set(identity.instanceId, { peerId, identity });
       }
+      save().catch(() => {});
     },
 
     resolve(peerId: string): PeerIdentity | undefined {
@@ -51,15 +110,23 @@ export function createPeerIdentityMap(): PeerIdentityMap {
         byInstanceId.delete(identity.instanceId);
       }
       peers.delete(peerId);
+      // Note: intentionally NOT saving on unregister — peer disconnects are
+      // often temporary (NAT timeout, network blip). Persisting the deletion
+      // would cause identity re-exchange on every reconnect. The entry will
+      // be refreshed when the peer reconnects and sends a new identity.
     },
 
     setLocalIdentity(peerId: string, identity: PeerIdentity): void {
       localPeerId = peerId;
       localIdentity = identity;
+      const now = Date.now();
+      identity.firstSeen = now;
+      identity.lastSeen = now;
       peers.set(peerId, identity);
       if (identity.instanceId) {
         byInstanceId.set(identity.instanceId, { peerId, identity });
       }
+      save().catch(() => {});
     },
 
     getLocalIdentity(): PeerIdentity | undefined {

package/src/plugin.ts

@@ -33,14 +33,19 @@ export function registerLibp2pMesh(api: OpenClawPluginApi) {
     start: async () => {
       await mesh.start();
 
-      // Register local identity so remote peers can route messages back to us
+      // Load persisted peer identities from disk
+      await peerIdentityMap.load();
+
+      // Gather local relay identity info
       const config = api.pluginConfig as MeshConfig | undefined;
       const relayChannel = config?.relayChannel;
       const relayAccountId = config?.relayAccountId;
       const instanceIdentity = mesh.getInstanceIdentity();
       const localInstanceId = instanceIdentity?.id;
+      const localPeerId = mesh.getLocalPeerId();
+
+      // Register local identity so remote peers can route messages back to us
       if (relayChannel && relayAccountId) {
-        const localPeerId = mesh.getLocalPeerId();
         const { buildAgentSessionKey } = await import("openclaw/plugin-sdk/core");
         const sessionKey = buildAgentSessionKey({
           agentId: api.name,
@@ -66,14 +71,32 @@ export function registerLibp2pMesh(api: OpenClawPluginApi) {
           relayAccountId,
           localInstanceId,
         );
-        const connectedPeers = mesh.getConnectedPeers();
-        for (const peerId of connectedPeers) {
+        for (const peerId of mesh.getConnectedPeers()) {
           try {
             await mesh.sendToPeer(peerId, JSON.stringify(identityMsg));
           } catch {
             // Best-effort; peer may be stale in the connection list
           }
         }
+
+        // When a new peer connects, send our identity to them
+        mesh.onPeerConnect((peerId: string) => {
+          const msg = buildIdentityMessage(
+            localPeerId,
+            api.name,
+            relayChannel,
+            relayAccountId,
+            localInstanceId,
+          );
+          mesh.sendToPeer(peerId, JSON.stringify(msg)).catch(() => {
+            // Best-effort
+          });
+        });
+
+        // When a peer disconnects, clean up the identity map
+        mesh.onPeerDisconnect((peerId: string) => {
+          peerIdentityMap.unregister(peerId);
+        });
       }
 
       // Wire up relay-aware message handler
@@ -82,7 +105,7 @@ export function registerLibp2pMesh(api: OpenClawPluginApi) {
       });
 
       const identity = mesh.getInstanceIdentity();
-      api.logger.info?.(`[libp2p-mesh] Service started. Peer ID: ${mesh.getLocalPeerId()}`);
+      api.logger.info?.(`[libp2p-mesh] Service started. Peer ID: ${localPeerId}`);
       if (identity) {
         api.logger.info?.(`[libp2p-mesh] Instance Identity: ${identity.id}`);
       }

package/src/types.ts

@@ -116,6 +116,8 @@ export interface MeshNetwork {
   stop(): Promise<void>;
   sendToPeer(peerId: string, message: string): Promise<void>;
   onMessage(handler: (msg: P2PMessage) => void): () => void;
+  onPeerConnect(handler: (peerId: string) => void): () => void;
+  onPeerDisconnect(handler: (peerId: string) => void): () => void;
   publishToTopic(topic: string, message: string): Promise<void>;
   subscribeToTopic(topic: string, handler: (msg: string) => void): Promise<void>;
   getLocalPeerId(): string;