clawnexus 0.3.0 → 0.4.0

package/dist/api/server.d.ts

@@ -8,17 +8,23 @@ import type { UnreachableInstance } from "../types.js";
 import { PolicyEngine } from "../agent/engine.js";
 import { TaskManager } from "../agent/tasks.js";
 import { AgentRouter } from "../agent/router.js";
+import { TaskExecutor } from "../agent/executor.js";
 import { BroadcastDiscovery } from "../discovery/broadcast.js";
 import type { IdentityKeys } from "../crypto/keys.js";
 import { RegistryClient } from "../registry/client.js";
 import { AutoRegister } from "../registry/auto-register.js";
 import { RemoteDiscovery } from "../registry/discovery.js";
 import { RelayConnector } from "../relay/connector.js";
-export declare function registerRelayRoutes(app: FastifyInstance, getConnector: () => RelayConnector | null): void;
+import { CardFetcher } from "../a2a/fetcher.js";
+import { A2AHandler } from "../a2a/handler.js";
+import { SkillsRegistry } from "../agent/services.js";
+export declare function registerRelayRoutes(app: FastifyInstance, getConnector: () => RelayConnector | null, getTokenRefresher?: () => (() => Promise<string>) | null): void;
 export interface AgentDeps {
     engine: PolicyEngine;
     tasks: TaskManager;
     getRouter: () => AgentRouter | null;
+    getExecutor: () => TaskExecutor | null;
+    skillsRegistry?: SkillsRegistry;
 }
 export declare function registerAgentRoutes(app: FastifyInstance, deps: AgentDeps): void;
 export interface RegistryDeps {
@@ -39,7 +45,7 @@ export interface DiagnosticsDeps {
     unreachable: UnreachableInstance[];
 }
 export declare function registerDiagnosticsRoutes(app: FastifyInstance, deps: DiagnosticsDeps): void;
-export declare function registerA2aRoutes(app: FastifyInstance, store: RegistryStore, daemonVersion: string): void;
+export declare function registerA2aRoutes(app: FastifyInstance, store: RegistryStore, daemonVersion: string, skillsRegistry?: SkillsRegistry, a2aHandler?: A2AHandler): void;
 export interface DaemonOptions {
     port?: number;
     host?: string;
@@ -57,6 +63,8 @@ export interface DaemonHandle {
     engine: PolicyEngine;
     tasks: TaskManager;
     getRouter: () => AgentRouter | null;
+    skillsRegistry: SkillsRegistry;
+    cardFetcher: CardFetcher;
     registryClient: RegistryClient | null;
     autoRegister: AutoRegister | null;
     remoteDiscovery: RemoteDiscovery | null;

package/dist/api/server.js

@@ -22,6 +22,7 @@ const probe_js_1 = require("../local/probe.js");
 const engine_js_1 = require("../agent/engine.js");
 const tasks_js_1 = require("../agent/tasks.js");
 const router_js_1 = require("../agent/router.js");
+const executor_js_1 = require("../agent/executor.js");
 const broadcast_js_1 = require("../discovery/broadcast.js");
 const keys_js_1 = require("../crypto/keys.js");
 const client_js_1 = require("../registry/client.js");
@@ -29,11 +30,16 @@ const auto_register_js_1 = require("../registry/auto-register.js");
 const discovery_js_1 = require("../registry/discovery.js");
 const connector_js_1 = require("../relay/connector.js");
 const card_js_1 = require("../a2a/card.js");
+const fetcher_js_1 = require("../a2a/fetcher.js");
+const handler_js_1 = require("../a2a/handler.js");
+const store_js_2 = require("../a2a/store.js");
+const types_js_1 = require("../a2a/types.js");
+const services_js_1 = require("../agent/services.js");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const PORT = parseInt(process.env.CLAWNEXUS_PORT ?? "17890", 10);
 const HOST = process.env.CLAWNEXUS_HOST ?? "127.0.0.1";
-function registerRelayRoutes(app, getConnector) {
+function registerRelayRoutes(app, getConnector, getTokenRefresher) {
     app.post("/relay/connect", async (request, reply) => {
         const connector = getConnector();
         if (!connector) {
@@ -47,6 +53,17 @@ function registerRelayRoutes(app, getConnector) {
                 error: "Missing target_claw_id",
             });
         }
+        // Refresh auth token before JOIN (relay JWTs expire after 5 min)
+        const refresher = getTokenRefresher?.();
+        if (refresher) {
+            try {
+                const freshToken = await refresher();
+                connector.updateAuthToken(freshToken);
+            }
+            catch (err) {
+                app.log.warn(`Token refresh before JOIN failed: ${err}`);
+            }
+        }
         connector.join(target_claw_id);
         return { status: "connecting", target: target_claw_id };
     });
@@ -71,7 +88,33 @@ function registerRelayRoutes(app, getConnector) {
     });
 }
 function registerAgentRoutes(app, deps) {
-    const { engine, tasks, getRouter } = deps;
+    const { engine, tasks, getRouter, getExecutor, skillsRegistry } = deps;
+    // --- Skills ---
+    app.get("/agent/skills", async () => {
+        if (!skillsRegistry) {
+            return { skills: [], status: { source: "not_initialized" } };
+        }
+        return { skills: skillsRegistry.getSkills(), status: skillsRegistry.getStatus() };
+    });
+    app.post("/agent/skills/refresh", async () => {
+        if (!skillsRegistry) {
+            return { status: "error", message: "Skills registry not initialized" };
+        }
+        const ok = await skillsRegistry.refresh();
+        return {
+            status: ok ? "ok" : "error",
+            skills: skillsRegistry.getSkills(),
+            ...skillsRegistry.getStatus(),
+        };
+    });
+    // --- Executor status ---
+    app.get("/agent/executor/status", async () => {
+        const executor = getExecutor();
+        if (!executor) {
+            return { gw_state: "not_initialized", queue_length: 0, executing: [], max_concurrent: 0 };
+        }
+        return executor.getStatus();
+    });
     // --- Policy ---
     app.get("/agent/policy", async () => engine.getConfig());
     app.put("/agent/policy", async (request) => {
@@ -305,19 +348,20 @@ function registerDiagnosticsRoutes(app, deps) {
         };
     });
 }
-function registerA2aRoutes(app, store, daemonVersion) {
+function registerA2aRoutes(app, store, daemonVersion, skillsRegistry, a2aHandler) {
     // A2A standard well-known endpoint — returns card for the local (is_self) instance
     app.get("/.well-known/agent-card.json", async (_request, reply) => {
         const self = store.getAll().find((i) => i.is_self);
         if (!self) {
             return reply.status(404).send({ error: "No local instance discovered" });
         }
-        return (0, card_js_1.buildAgentCard)(self, daemonVersion);
+        return (0, card_js_1.buildAgentCard)(self, daemonVersion, skillsRegistry?.getSkills());
     });
     // All instances as Agent Cards
     app.get("/a2a/cards", async () => {
         const instances = store.getAll();
-        const cards = instances.map((i) => (0, card_js_1.buildAgentCard)(i, daemonVersion));
+        const localSkills = skillsRegistry?.getSkills();
+        const cards = instances.map((i) => (0, card_js_1.buildAgentCard)(i, daemonVersion, i.is_self ? localSkills : undefined));
         return { count: cards.length, cards };
     });
     // Single instance Agent Card by name
@@ -326,8 +370,69 @@ function registerA2aRoutes(app, store, daemonVersion) {
         if (!inst) {
             return reply.status(404).send({ error: "Instance not found" });
         }
-        return (0, card_js_1.buildAgentCard)(inst, daemonVersion);
-    });
+        const localSkills = inst.is_self ? skillsRegistry?.getSkills() : undefined;
+        return (0, card_js_1.buildAgentCard)(inst, daemonVersion, localSkills);
+    });
+    // A2A JSON-RPC 2.0 endpoint
+    if (a2aHandler) {
+        app.post("/a2a", async (request, reply) => {
+            const body = request.body;
+            if (!body || body.jsonrpc !== "2.0" || typeof body.method !== "string") {
+                const id = body?.id ?? null;
+                const resp = {
+                    jsonrpc: "2.0",
+                    id: id,
+                    error: { code: types_js_1.JSON_RPC_INVALID_REQUEST, message: "Invalid JSON-RPC 2.0 request" },
+                };
+                return reply.status(200).send(resp);
+            }
+            const req = body;
+            if (req.method === "tasks/send") {
+                const result = await a2aHandler.handleTaskSend(req.params);
+                // Check if result is an error
+                if ("code" in result && "message" in result && !("id" in result)) {
+                    return reply.status(200).send({
+                        jsonrpc: "2.0",
+                        id: req.id,
+                        error: result,
+                    });
+                }
+                return reply.status(200).send({
+                    jsonrpc: "2.0",
+                    id: req.id,
+                    result,
+                });
+            }
+            if (req.method === "tasks/get") {
+                const params = req.params;
+                if (!params?.id) {
+                    return reply.status(200).send({
+                        jsonrpc: "2.0",
+                        id: req.id,
+                        error: { code: -32602, message: "Missing task id" },
+                    });
+                }
+                const task = a2aHandler.getTask(params.id);
+                if (!task) {
+                    return reply.status(200).send({
+                        jsonrpc: "2.0",
+                        id: req.id,
+                        error: { code: -32001, message: "Task not found" },
+                    });
+                }
+                return reply.status(200).send({
+                    jsonrpc: "2.0",
+                    id: req.id,
+                    result: task,
+                });
+            }
+            return reply.status(200).send({
+                jsonrpc: "2.0",
+                id: req.id,
+                error: { code: types_js_1.JSON_RPC_METHOD_NOT_FOUND, message: `Method not found: ${req.method}` },
+            });
+        });
+    }
 }
 async function startDaemon(options = {}) {
     const port = options.port ?? PORT;
@@ -355,6 +460,15 @@ async function startDaemon(options = {}) {
     await engine.init();
     const taskManager = new tasks_js_1.TaskManager();
     await taskManager.init();
+    // 6b. Create TaskExecutor
+    const taskExecutor = new executor_js_1.TaskExecutor({
+        tasks: taskManager,
+        maxConcurrent: engine.getConfig().max_concurrent_tasks,
+    });
+    // 6c. Create SkillsRegistry
+    const skillsRegistry = new services_js_1.SkillsRegistry();
+    // 6d. Create CardFetcher (fetches remote Agent Cards from discovered instances)
+    const cardFetcher = new fetcher_js_1.CardFetcher(store);
     // 7. Detect WireGuard interfaces
     const wgInfo = await (0, wireguard_js_1.detectWireGuard)();
     // 8. Create and configure Fastify app
@@ -374,11 +488,12 @@ async function startDaemon(options = {}) {
     else {
         console.log("[clawnexus] [WireGuard] No WireGuard interfaces detected");
     }
+    const daemonPkg = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(__dirname, "../../package.json"), "utf-8"));
     // Health endpoint with component status
     app.get("/health", async () => ({
         status: "ok",
         service: "clawnexus-daemon",
-        version: "0.4.0",
+        version: daemonPkg.version,
         timestamp: new Date().toISOString(),
         components: {
             registry: { instances: store.size },
@@ -401,12 +516,23 @@ async function startDaemon(options = {}) {
     // Instance management routes
     registerInstanceRoutes(app, store, scanner);
     // Relay routes
-    registerRelayRoutes(app, () => connector);
+    registerRelayRoutes(app, () => connector, () => {
+        const rc = registryClient;
+        const clawName = autoRegister?.clawName;
+        if (!rc || !clawName)
+            return null;
+        return async () => {
+            const result = await rc.getToken(clawName);
+            return result.token;
+        };
+    });
     // Agent routes (Layer B)
     registerAgentRoutes(app, {
         engine,
         tasks: taskManager,
         getRouter: () => agentRouter,
+        getExecutor: () => taskExecutor,
+        skillsRegistry,
     });
     // Diagnostics routes
     registerDiagnosticsRoutes(app, {
@@ -418,9 +544,11 @@ async function startDaemon(options = {}) {
         getAutoRegister: () => autoRegister,
         unreachable,
     });
-    // A2A Agent Card routes
-    const daemonPkg = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(__dirname, "../../package.json"), "utf-8"));
-    registerA2aRoutes(app, store, daemonPkg.version);
+    // A2A Agent Card + JSON-RPC routes
+    const a2aTaskStore = new store_js_2.A2ATaskStore();
+    await a2aTaskStore.init();
+    const a2aHandler = new handler_js_1.A2AHandler({ store: a2aTaskStore });
+    registerA2aRoutes(app, store, daemonPkg.version, skillsRegistry, a2aHandler);
     // 9. Initialize Registry integration (non-fatal — LAN must work without it)
     let identityKeys = null;
     let registryClient = null;
@@ -431,15 +559,29 @@ async function startDaemon(options = {}) {
     localProbe.on("local:discovered", (instance) => {
         app.log.info({ agent_id: instance.agent_id }, "Local OpenClaw instance discovered");
         broadcast.sendAnnounce();
+        // Start skills registry once we know the local Gateway is available
+        skillsRegistry.start();
+        // Start fetching remote Agent Cards
+        cardFetcher.start();
     });
     localProbe.on("local:unavailable", () => {
         app.log.info("No local OpenClaw instance on :18789");
+        // Still start CardFetcher — remote cards are useful even without local instance
+        cardFetcher.start();
     });
     // Initialize registry after LocalProbe (needs agentId for registration)
     try {
         identityKeys = await (0, keys_js_1.loadOrCreateKeys)();
         registryClient = new client_js_1.RegistryClient(identityKeys);
-        autoRegister = new auto_register_js_1.AutoRegister(registryClient, store, localProbe, identityKeys);
+        autoRegister = new auto_register_js_1.AutoRegister(registryClient, store, localProbe, identityKeys, daemonPkg.version, () => {
+            const skills = skillsRegistry.getSkills();
+            if (!skills || skills.length === 0)
+                return null;
+            return {
+                skills_count: skills.length,
+                skills: skills.map((s) => s.name ?? s.id ?? "unknown"),
+            };
+        });
         remoteDiscovery = new discovery_js_1.RemoteDiscovery(registryClient, store);
         registerRegistryRoutes(app, {
             autoRegister,
@@ -447,10 +589,12 @@ async function startDaemon(options = {}) {
             registryClient,
             identityKeys,
         });
+        let relayInitializing = false;
         autoRegister.on("registered", async (info) => {
             console.log(`[clawnexus] [Registry] Registered as ${info.claw_name} (${info.action})`);
-            // Initialize relay connector after successful registration
-            if (!connector && registryClient && info.claw_name) {
+            // Initialize relay connector after successful registration (once only)
+            if (!connector && !relayInitializing && registryClient && info.claw_name) {
+                relayInitializing = true;
                 try {
                     const tokenResult = await registryClient.getToken(info.claw_name);
                     console.log(`[clawnexus] [Relay] Got auth token, relay_hint: ${tokenResult.relay_hint}`);
@@ -478,7 +622,8 @@ async function startDaemon(options = {}) {
                     });
                     newConnector.connect();
                     setConnector(newConnector);
-                    // Start token refresh — every 4 minutes (token expires in 5 min)
+                    // Start token refresh — every 55 minutes (relay keeps WebSocket alive after auth,
+                    // only need to refresh for reconnection scenarios)
                     if (tokenRefreshTimer)
                         clearInterval(tokenRefreshTimer);
                     tokenRefreshTimer = setInterval(async () => {
@@ -486,8 +631,16 @@ async function startDaemon(options = {}) {
                             return;
                         try {
                             const fresh = await registryClient.getToken(autoRegister.clawName);
-                            // Reconnect with fresh token
-                            connector?.disconnect();
+                            // Save peer claw_ids from existing rooms before reconnecting
+                            const previousPeers = [];
+                            const oldConnector = connector;
+                            if (oldConnector) {
+                                for (const room of oldConnector.getStatus().rooms) {
+                                    if (room.peer_claw_id)
+                                        previousPeers.push(room.peer_claw_id);
+                                }
+                            }
+                            // Connect new first, then disconnect old (relay server handles replacement)
                             const refreshed = new connector_js_1.RelayConnector({
                                 relayUrl: process.env.CLAWNEXUS_RELAY_URL ?? `wss://${fresh.relay_hint}/relay`,
                                 clawId: autoRegister.clawName,
@@ -496,6 +649,15 @@ async function startDaemon(options = {}) {
                             });
                             refreshed.on("registered", (clawId) => {
                                 console.log(`[clawnexus] [Relay] Reconnected (token refresh) as ${clawId}`);
+                                // Old connector is now replaced on server side — disconnect it locally
+                                if (oldConnector && oldConnector !== refreshed) {
+                                    oldConnector.disconnect();
+                                }
+                                // Re-join rooms with previous peers
+                                for (const peerId of previousPeers) {
+                                    console.log(`[clawnexus] [Relay] Re-joining peer ${peerId} after token refresh`);
+                                    refreshed.join(peerId);
+                                }
                             });
                             refreshed.on("relay_error", (code, message) => {
                                 console.log(`[clawnexus] [Relay] Error: ${code} — ${message}`);
@@ -506,7 +668,7 @@ async function startDaemon(options = {}) {
                         catch (err) {
                             console.log(`[clawnexus] [Relay] Token refresh failed (non-fatal): ${err}`);
                         }
-                    }, 4 * 60 * 1000);
+                    }, 55 * 60 * 1000);
                 }
                 catch (err) {
                     console.log(`[clawnexus] [Relay] Failed to initialize (non-fatal): ${err}`);
@@ -552,6 +714,9 @@ async function startDaemon(options = {}) {
     app.addHook("onClose", async () => {
         if (tokenRefreshTimer)
             clearInterval(tokenRefreshTimer);
+        cardFetcher.stop();
+        skillsRegistry.stop();
+        await taskExecutor.close();
         autoRegister?.stop();
         agentRouter?.stop();
         taskManager.close();
@@ -560,9 +725,13 @@ async function startDaemon(options = {}) {
         mdns.stop();
         await broadcast.stop();
         connector?.disconnect();
+        a2aHandler.close();
+        await a2aTaskStore.close();
         await store.close();
     });
     await app.listen({ port, host });
+    // Start task executor (independent of relay — connects to local OpenClaw Gateway)
+    taskExecutor.start();
     const setConnector = (c) => {
         connector = c;
         // When relay connector is set, create and start AgentRouter
@@ -572,9 +741,17 @@ async function startDaemon(options = {}) {
                 engine,
                 tasks: taskManager,
                 localClawId: c.getStatus().claw_id ?? "",
+                skillsRegistry,
             });
             agentRouter.start();
             app.log.info("Layer B agent router started");
+            // Give executor the router reference so it can send reports
+            taskExecutor.setRouter(agentRouter);
+        }
+        else {
+            // Update existing router with new connector (e.g. after token refresh)
+            agentRouter.setConnector(c);
+            app.log.info("Layer B agent router connector updated");
         }
     };
     return {
@@ -590,6 +767,8 @@ async function startDaemon(options = {}) {
         engine,
         tasks: taskManager,
         getRouter: () => agentRouter,
+        skillsRegistry,
+        cardFetcher,
         registryClient,
         autoRegister,
         remoteDiscovery,

package/dist/cli/index.js

@@ -434,6 +434,12 @@ async function cmdInfo(args) {
         if (inst.labels && Object.keys(inst.labels).length > 0) {
             console.log(`Labels:        ${JSON.stringify(inst.labels)}`);
         }
+        if (inst.remote_card?.skills?.length) {
+            const names = inst.remote_card.skills.map((s) => s.name || s.id).join(", ");
+            console.log(`Skills:        ${names} (${inst.remote_card.skills.length} skill${inst.remote_card.skills.length === 1 ? "" : "s"})`);
+            console.log(`Card URL:      ${inst.remote_card.card_url}`);
+            console.log(`Card Fetched:  ${new Date(inst.remote_card.fetched_at).toLocaleString()}`);
+        }
     }
 }
 async function cmdForget(args) {

package/dist/registry/auto-register.d.ts

@@ -1,5 +1,6 @@
 import { EventEmitter } from "node:events";
 import type { RegistryClient } from "./client.js";
+import type { AgentCardSummary } from "./client.js";
 import type { RegistryStore } from "./store.js";
 import type { LocalProbe } from "../local/probe.js";
 import type { IdentityKeys } from "../crypto/keys.js";
@@ -8,10 +9,13 @@ export declare class AutoRegister extends EventEmitter {
     private readonly store;
     private readonly localProbe;
     private readonly keys;
+    private readonly daemonVersion;
+    private readonly getCardSummary?;
     private heartbeatTimer;
     private initialTimer;
     private registeredClawName;
-    constructor(client: RegistryClient, store: RegistryStore, localProbe: LocalProbe, keys: IdentityKeys);
+    private readonly startedAt;
+    constructor(client: RegistryClient, store: RegistryStore, localProbe: LocalProbe, keys: IdentityKeys, daemonVersion?: string, getCardSummary?: (() => AgentCardSummary | null) | undefined);
     get clawName(): string | null;
     get publicKey(): string;
     start(): void;

package/dist/registry/auto-register.js

@@ -4,6 +4,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AutoRegister = void 0;
 const node_events_1 = require("node:events");
+const node_os_1 = require("node:os");
 const client_js_1 = require("./client.js");
 const keys_js_1 = require("../crypto/keys.js");
 const INITIAL_DELAY_MS = 5_000;
@@ -13,15 +14,20 @@ class AutoRegister extends node_events_1.EventEmitter {
     store;
     localProbe;
     keys;
+    daemonVersion;
+    getCardSummary;
     heartbeatTimer = null;
     initialTimer = null;
     registeredClawName = null;
-    constructor(client, store, localProbe, keys) {
+    startedAt = Date.now();
+    constructor(client, store, localProbe, keys, daemonVersion = "unknown", getCardSummary) {
         super();
         this.client = client;
         this.store = store;
         this.localProbe = localProbe;
         this.keys = keys;
+        this.daemonVersion = daemonVersion;
+        this.getCardSummary = getCardSummary;
     }
     get clawName() {
         return this.registeredClawName;
@@ -59,25 +65,51 @@ class AutoRegister extends node_events_1.EventEmitter {
             this.emit("skip", "No local OpenClaw instance detected");
             return;
         }
-        // Try agentId, then agentId-2, agentId-3, ... if name already taken by another owner
+        // Build list of base names to try: agentId first, then auto_name as fallback
+        const selfInstance = this.store.getAll().find((i) => i.is_self);
+        const autoName = selfInstance?.auto_name;
+        const bases = [agentId];
+        if (autoName && autoName !== agentId)
+            bases.push(autoName);
+        // Build metadata and card summary for this heartbeat
+        const uptimeHours = Math.round((Date.now() - this.startedAt) / 3_600_000 * 100) / 100;
+        const metadata = {
+            software_version: this.daemonVersion,
+            uptime_hours: uptimeHours,
+            os_platform: (0, node_os_1.platform)(),
+            instance_count: this.store.getAll().length,
+        };
+        const cardSummary = this.getCardSummary?.() ?? undefined;
+        // Try each base with suffixes -1, -2, ... up to MAX_SUFFIX if taken by another owner
         const MAX_SUFFIX = 10;
         let result = null;
-        for (let i = 0; i <= MAX_SUFFIX; i++) {
-            const clawId = i === 0 ? agentId : `${agentId}-${i}`;
-            try {
-                result = await this.client.register({ claw_id: clawId });
-                break;
-            }
-            catch (err) {
-                if (err instanceof client_js_1.RegistryError && err.statusCode === 409 && i < MAX_SUFFIX) {
-                    continue; // name taken by another owner, try next suffix
+        outer: for (const base of bases) {
+            for (let i = 0; i <= MAX_SUFFIX; i++) {
+                const clawId = i === 0 ? base : `${base}-${i}`;
+                try {
+                    result = await this.client.register({
+                        claw_id: clawId,
+                        metadata,
+                        agent_card: cardSummary,
+                    });
+                    break outer;
+                }
+                catch (err) {
+                    if (err instanceof client_js_1.RegistryError && err.statusCode === 409 && i < MAX_SUFFIX) {
+                        continue; // name taken by another owner, try next suffix
+                    }
+                    if (err instanceof client_js_1.RegistryError && err.statusCode === 409 && i === MAX_SUFFIX) {
+                        break; // exhausted suffixes for this base, try next base
+                    }
+                    this.emit("error", err);
+                    return;
                 }
-                this.emit("error", err);
-                return;
             }
         }
-        if (!result)
+        if (!result) {
+            this.emit("error", new Error(`All candidate names exhausted (bases: ${bases.join(", ")})`));
             return;
+        }
         this.registeredClawName = result.record.name;
         // Start heartbeat on first successful registration
         if (!this.heartbeatTimer) {
@@ -85,13 +117,12 @@ class AutoRegister extends node_events_1.EventEmitter {
                 this.tryRegister().catch(() => { });
             }, HEARTBEAT_INTERVAL_MS);
         }
-        // Write claw_name back to the local instance in store
-        const instances = this.store.getAll();
-        const selfInstance = instances.find((i) => i.is_self && i.agent_id === agentId);
-        if (selfInstance) {
-            selfInstance.claw_name = result.record.name;
-            selfInstance.owner_pubkey = result.record.ownerPubkey;
-            this.store.upsert(selfInstance);
+        // Write claw_name back to the local instance in store (re-fetch after possible state change)
+        const registeredSelf = this.store.getAll().find((i) => i.is_self && i.agent_id === agentId);
+        if (registeredSelf) {
+            registeredSelf.claw_name = result.record.name;
+            registeredSelf.owner_pubkey = result.record.ownerPubkey;
+            this.store.upsert(registeredSelf);
         }
         this.emit("registered", {
             action: result.action,

package/dist/registry/client.d.ts

@@ -33,11 +33,28 @@ export interface CheckNameResult {
     name: string;
     available: boolean;
 }
+export interface InstanceMetadata {
+    software_version: string;
+    openclaw_version?: string;
+    uptime_hours: number;
+    os_platform: string;
+    instance_count: number;
+}
+export interface AgentCardSummary {
+    skills_count: number;
+    skills: string[];
+    capabilities?: Record<string, unknown>;
+    input_modes?: string[];
+    output_modes?: string[];
+    card_url?: string;
+}
 export interface RegisterParams {
     claw_id: string;
     capabilities?: string[];
     relay_hint?: string;
     visibility?: "public" | "unlisted";
+    metadata?: InstanceMetadata;
+    agent_card?: AgentCardSummary;
 }
 export declare class RegistryClient {
     private readonly keys;

package/dist/registry/client.js

@@ -36,6 +36,8 @@ class RegistryClient {
             ...(params.capabilities && { capabilities: params.capabilities }),
             ...(params.relay_hint && { relay_hint: params.relay_hint }),
             ...(params.visibility && { visibility: params.visibility }),
+            ...(params.metadata && { metadata: params.metadata }),
+            ...(params.agent_card && { agent_card: params.agent_card }),
         };
         const body = {
             payload,

package/dist/registry/store.js

@@ -65,12 +65,16 @@ class RegistryStore extends node_events_1.EventEmitter {
             try {
                 const raw = await fs.promises.readFile(this.registryPath, "utf-8");
                 const data = JSON.parse(raw);
-                if (data.schema_version === "5" && Array.isArray(data.instances)) {
-                    // v5: current schema, load directly
+                if ((data.schema_version === "6" || data.schema_version === "5") && Array.isArray(data.instances)) {
+                    // v5/v6: compatible schemas (remote_card is optional), load directly
                     for (const inst of data.instances) {
                         const key = this.networkKey(inst.address, inst.gateway_port);
                         this.instances.set(key, inst);
                     }
+                    if (data.schema_version === "5") {
+                        // Bump to v6 on next flush
+                        this.scheduleDirtyFlush();
+                    }
                 }
                 else if (data.schema_version === "4" && Array.isArray(data.instances)) {
                     // v4 → v5 migration: no data changes, just bump version
@@ -203,6 +207,8 @@ class RegistryStore extends node_events_1.EventEmitter {
             instance.owner_pubkey = instance.owner_pubkey ?? existing.owner_pubkey;
             // Preserve implementation (prefer new value if provided)
             instance.implementation = instance.implementation ?? existing.implementation;
+            // Preserve remote_card (fetched by CardFetcher)
+            instance.remote_card = instance.remote_card ?? existing.remote_card;
             this.instances.set(key, instance);
             this.scheduleDirtyFlush();
             this.emit("upsert", instance);
@@ -318,6 +324,7 @@ class RegistryStore extends node_events_1.EventEmitter {
             connectivity: incoming.connectivity ?? existing.connectivity,
             is_self: existing.is_self || incoming.is_self,
             implementation: incoming.implementation ?? existing.implementation,
+            remote_card: existing.remote_card ?? incoming.remote_card,
         };
     }
     /** Numeric priority for network scope: local > vpn > public */
@@ -343,7 +350,7 @@ class RegistryStore extends node_events_1.EventEmitter {
     }
     async flushNow() {
         const data = {
-            schema_version: "5",
+            schema_version: "6",
             updated_at: new Date().toISOString(),
             instances: Array.from(this.instances.values()),
         };