clawnexus 0.2.8 → 0.3.1

package/dist/api/server.js

@@ -10,6 +10,7 @@ exports.registerAgentRoutes = registerAgentRoutes;
 exports.registerRegistryRoutes = registerRegistryRoutes;
 exports.registerInstanceRoutes = registerInstanceRoutes;
 exports.registerDiagnosticsRoutes = registerDiagnosticsRoutes;
+exports.registerA2aRoutes = registerA2aRoutes;
 exports.startDaemon = startDaemon;
 const fastify_1 = __importDefault(require("fastify"));
 const store_js_1 = require("../registry/store.js");
@@ -21,15 +22,20 @@ 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");
 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 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) {
@@ -43,6 +49,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 };
     });
@@ -67,7 +84,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) => {
@@ -301,6 +344,31 @@ function registerDiagnosticsRoutes(app, deps) {
         };
     });
 }
+function registerA2aRoutes(app, store, daemonVersion, skillsRegistry) {
+    // 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, skillsRegistry?.getSkills());
+    });
+    // All instances as Agent Cards
+    app.get("/a2a/cards", async () => {
+        const instances = store.getAll();
+        const skills = skillsRegistry?.getSkills();
+        const cards = instances.map((i) => (0, card_js_1.buildAgentCard)(i, daemonVersion, skills));
+        return { count: cards.length, cards };
+    });
+    // Single instance Agent Card by name
+    app.get("/a2a/cards/:name", async (request, reply) => {
+        const inst = store.resolve(request.params.name);
+        if (!inst) {
+            return reply.status(404).send({ error: "Instance not found" });
+        }
+        return (0, card_js_1.buildAgentCard)(inst, daemonVersion, skillsRegistry?.getSkills());
+    });
+}
 async function startDaemon(options = {}) {
     const port = options.port ?? PORT;
     const host = options.host ?? HOST;
@@ -327,6 +395,13 @@ 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();
     // 7. Detect WireGuard interfaces
     const wgInfo = await (0, wireguard_js_1.detectWireGuard)();
     // 8. Create and configure Fastify app
@@ -350,7 +425,7 @@ async function startDaemon(options = {}) {
     app.get("/health", async () => ({
         status: "ok",
         service: "clawnexus-daemon",
-        version: "0.4.0",
+        version: "0.3.1",
         timestamp: new Date().toISOString(),
         components: {
             registry: { instances: store.size },
@@ -373,12 +448,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, {
@@ -390,6 +476,9 @@ 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, skillsRegistry);
     // 9. Initialize Registry integration (non-fatal — LAN must work without it)
     let identityKeys = null;
     let registryClient = null;
@@ -400,6 +489,8 @@ 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();
     });
     localProbe.on("local:unavailable", () => {
         app.log.info("No local OpenClaw instance on :18789");
@@ -416,10 +507,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}`);
@@ -447,7 +540,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 () => {
@@ -455,8 +549,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,
@@ -465,6 +567,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}`);
@@ -475,7 +586,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}`);
@@ -521,6 +632,8 @@ async function startDaemon(options = {}) {
     app.addHook("onClose", async () => {
         if (tokenRefreshTimer)
             clearInterval(tokenRefreshTimer);
+        skillsRegistry.stop();
+        await taskExecutor.close();
         autoRegister?.stop();
         agentRouter?.stop();
         taskManager.close();
@@ -532,6 +645,8 @@ async function startDaemon(options = {}) {
         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
@@ -541,9 +656,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 {
@@ -559,6 +682,7 @@ async function startDaemon(options = {}) {
         engine,
         tasks: taskManager,
         getRouter: () => agentRouter,
+        skillsRegistry,
         registryClient,
         autoRegister,
         remoteDiscovery,

package/dist/discovery/broadcast.js

@@ -46,7 +46,6 @@ const CDP_PORT = 17891;
 const TCP_PROBE_TIMEOUT = 2_000;
 const ANNOUNCE_INTERVAL_BASE = 60_000;
 const ANNOUNCE_JITTER = 10_000;
-const CONFIG_PATH = "/__openclaw/control-ui-config.json";
 class BroadcastDiscovery extends node_events_1.EventEmitter {
     store;
     getLocalInstance;
@@ -274,12 +273,14 @@ class BroadcastDiscovery extends node_events_1.EventEmitter {
         });
     }
     async _tcpProbe(address, port) {
-        const url = `http://${address}:${port}${CONFIG_PATH}`;
+        // Quick HTTP liveness check — just confirm the port is alive.
+        // Framework identification is left to HealthChecker / subsequent scans.
         try {
-            const res = await fetch(url, {
+            const res = await fetch(`http://${address}:${port}/`, {
                 signal: AbortSignal.timeout(TCP_PROBE_TIMEOUT),
             });
-            return res.ok;
+            // Any HTTP response (including 404, 500) means the port is alive
+            return res.status > 0;
         }
         catch {
             return false;

package/dist/health/checker.d.ts

@@ -11,4 +11,8 @@ export declare class HealthChecker extends EventEmitter {
     stop(): void;
     checkAll(): Promise<void>;
     private checkOne;
+    /** OpenClaw-specific health check with name updates */
+    private checkOpenClaw;
+    /** Fallback health check for instances without a known adapter */
+    private genericHttpCheck;
 }

package/dist/health/checker.js

@@ -1,9 +1,11 @@
 "use strict";
 // Health Checker — periodically pings known instances and updates status
 // Enhanced with dual-channel connectivity detection
+// Adapter-aware: uses framework-specific health checks for non-OpenClaw instances
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HealthChecker = void 0;
 const node_events_1 = require("node:events");
+const index_js_1 = require("../adapter/index.js");
 const CHECK_INTERVAL = 30_000;
 const PING_TIMEOUT = 5_000;
 const CONFIG_PATH = "/__openclaw/control-ui-config.json";
@@ -41,36 +43,51 @@ class HealthChecker extends node_events_1.EventEmitter {
         if (inst.is_self)
             return;
         const networkKey = this.store.networkKey(inst.address, inst.gateway_port);
-        const protocol = inst.tls ? "https" : "http";
-        const url = `${protocol}://${inst.address}:${inst.gateway_port}${CONFIG_PATH}`;
+        const impl = inst.implementation ?? "openclaw";
         const now = new Date().toISOString();
         let lanOk = false;
         let lanLatency;
         let unreachableReason;
-        try {
-            const start = performance.now();
-            const res = await fetch(url, {
-                signal: AbortSignal.timeout(PING_TIMEOUT),
-            });
-            lanLatency = Math.round(performance.now() - start);
-            if (res.ok) {
-                lanOk = true;
-                const config = (await res.json());
-                inst.last_seen = now;
-                if (config.assistantName) {
-                    inst.assistant_name = config.assistantName;
+        if (impl === "openclaw" || impl === "goclaw") {
+            // OpenClaw path: detailed check with name updates (original behavior)
+            const result = await this.checkOpenClaw(inst, now);
+            lanOk = result.ok;
+            lanLatency = result.latency;
+            unreachableReason = result.reason;
+        }
+        else {
+            // Non-OpenClaw: use adapter healthCheck
+            const adapter = (0, index_js_1.getAdapter)(impl);
+            if (adapter) {
+                try {
+                    const start = performance.now();
+                    // Use healthCheckLocal for port-0 instances (no HTTP server)
+                    if (inst.gateway_port === 0 && adapter.healthCheckLocal) {
+                        lanOk = await adapter.healthCheckLocal();
+                    }
+                    else {
+                        lanOk = await adapter.healthCheck(inst.address, inst.gateway_port);
+                    }
+                    lanLatency = Math.round(performance.now() - start);
+                    if (lanOk) {
+                        inst.last_seen = now;
+                    }
+                    else {
+                        unreachableReason = "Health check failed";
+                    }
                 }
-                if (config.displayName) {
-                    inst.display_name = config.displayName;
+                catch (err) {
+                    unreachableReason = err instanceof Error ? err.message : "Connection failed";
                 }
             }
             else {
-                unreachableReason = `HTTP ${res.status}`;
+                // Unknown implementation: generic HTTP check
+                const result = await this.genericHttpCheck(inst, now);
+                lanOk = result.ok;
+                lanLatency = result.latency;
+                unreachableReason = result.reason;
             }
         }
-        catch (err) {
-            unreachableReason = err instanceof Error ? err.message : "Connection failed";
-        }
         // Check relay availability
         const relayAvailable = this.relayChecker?.(inst.agent_id) ?? false;
         // Update connectivity
@@ -104,5 +121,52 @@ class HealthChecker extends node_events_1.EventEmitter {
             });
         }
     }
+    /** OpenClaw-specific health check with name updates */
+    async checkOpenClaw(inst, now) {
+        const protocol = inst.tls ? "https" : "http";
+        const url = `${protocol}://${inst.address}:${inst.gateway_port}${CONFIG_PATH}`;
+        try {
+            const start = performance.now();
+            const res = await fetch(url, {
+                signal: AbortSignal.timeout(PING_TIMEOUT),
+            });
+            const latency = Math.round(performance.now() - start);
+            if (res.ok) {
+                const config = (await res.json());
+                inst.last_seen = now;
+                if (config.assistantName) {
+                    inst.assistant_name = config.assistantName;
+                }
+                if (config.displayName) {
+                    inst.display_name = config.displayName;
+                }
+                return { ok: true, latency };
+            }
+            return { ok: false, latency, reason: `HTTP ${res.status}` };
+        }
+        catch (err) {
+            return { ok: false, reason: err instanceof Error ? err.message : "Connection failed" };
+        }
+    }
+    /** Fallback health check for instances without a known adapter */
+    async genericHttpCheck(inst, now) {
+        const protocol = inst.tls ? "https" : "http";
+        const url = `${protocol}://${inst.address}:${inst.gateway_port}/`;
+        try {
+            const start = performance.now();
+            const res = await fetch(url, {
+                signal: AbortSignal.timeout(PING_TIMEOUT),
+            });
+            const latency = Math.round(performance.now() - start);
+            if (res.ok) {
+                inst.last_seen = now;
+                return { ok: true, latency };
+            }
+            return { ok: false, latency, reason: `HTTP ${res.status}` };
+        }
+        catch (err) {
+            return { ok: false, reason: err instanceof Error ? err.message : "Connection failed" };
+        }
+    }
 }
 exports.HealthChecker = HealthChecker;

package/dist/local/probe.d.ts

@@ -11,5 +11,9 @@ export declare class LocalProbe extends EventEmitter {
     start(): Promise<void>;
     stop(): void;
     private _markOffline;
+    /** Mark offline any previously-known self instances that were not rediscovered this cycle */
+    private _markOfflineStaleSelf;
     probe(): Promise<ClawInstance | null>;
+    /** Original OpenClaw probe logic (kept as primary path for backward compatibility) */
+    private probeOpenClaw;
 }

package/dist/local/probe.js

@@ -1,6 +1,7 @@
 "use strict";
-// LocalProbe — detects OpenClaw instance on localhost and registers it
+// LocalProbe — detects AI instances on localhost and registers them
 // Runs on daemon startup, then periodically re-checks
+// Adapter-aware: tries all registered adapters on their default ports
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -38,6 +39,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalProbe = void 0;
 const node_events_1 = require("node:events");
 const os = __importStar(require("node:os"));
+const index_js_1 = require("../adapter/index.js");
 const LOCAL_HOST = "127.0.0.1";
 const DEFAULT_PORT = 18789;
 const CONFIG_PATH = "/__openclaw/control-ui-config.json";
@@ -71,8 +73,8 @@ class LocalProbe extends node_events_1.EventEmitter {
             this.timer = null;
         }
     }
-    _markOffline() {
-        const existing = this.store.getByNetworkKey(LOCAL_HOST, this.port);
+    _markOffline(port) {
+        const existing = this.store.getByNetworkKey(LOCAL_HOST, port);
         if (existing && existing.status !== "offline") {
             this.store.upsert({
                 ...existing,
@@ -81,21 +83,135 @@ class LocalProbe extends node_events_1.EventEmitter {
             });
         }
     }
+    /** Mark offline any previously-known self instances that were not rediscovered this cycle */
+    _markOfflineStaleSelf(staleKeys) {
+        for (const key of staleKeys) {
+            const [address, portStr] = key.split(":");
+            this._markOffline(Number(portStr));
+        }
+    }
     async probe() {
-        const url = `http://${LOCAL_HOST}:${this.port}${CONFIG_PATH}`;
+        // Snapshot all current is_self instances so we can mark stale ones offline later
+        const previousSelfKeys = new Set(this.store
+            .getAll()
+            .filter((inst) => inst.is_self)
+            .map((inst) => `${inst.address}:${inst.gateway_port}`));
+        // 1. Try OpenClaw on the configured port (backward-compatible primary path)
+        const openClawResult = await this.probeOpenClaw(this.port);
+        if (openClawResult) {
+            previousSelfKeys.delete(`${LOCAL_HOST}:${this.port}`);
+            this._markOfflineStaleSelf(previousSelfKeys);
+            return openClawResult;
+        }
+        // 2. Try all adapters on their default ports (skip OpenClaw on this.port, already tried)
+        let found = null;
+        for (const adapter of index_js_1.ADAPTERS) {
+            if (adapter.name === "openclaw")
+                continue; // already tried above
+            // Try probeLocal first (for frameworks without HTTP servers, e.g. NanoClaw)
+            if (adapter.probeLocal) {
+                const probeResult = await adapter.probeLocal();
+                if (probeResult) {
+                    const now = new Date().toISOString();
+                    const partial = adapter.toClawInstance(LOCAL_HOST, 0, probeResult);
+                    const instance = {
+                        agent_id: partial.agent_id ?? `${adapter.name}@localhost`,
+                        auto_name: "",
+                        assistant_name: partial.assistant_name ?? "",
+                        display_name: partial.display_name ?? adapter.name,
+                        lan_host: os.hostname(),
+                        address: LOCAL_HOST,
+                        gateway_port: partial.gateway_port ?? 0,
+                        tls: false,
+                        discovery_source: "local",
+                        network_scope: "local",
+                        status: "online",
+                        last_seen: now,
+                        discovered_at: now,
+                        implementation: partial.implementation,
+                        connectivity: {
+                            lan_reachable: false,
+                            relay_available: false,
+                            preferred_channel: "local",
+                            last_lan_check: now,
+                        },
+                        is_self: true,
+                        labels: partial.labels,
+                    };
+                    this.store.upsert(instance);
+                    this.emit("local:discovered", instance);
+                    previousSelfKeys.delete(`${LOCAL_HOST}:${instance.gateway_port}`);
+                    found = instance;
+                    break;
+                }
+            }
+            // Then try HTTP probe on default ports
+            if (!found) {
+                for (const port of adapter.defaultPorts) {
+                    const probeResult = await adapter.probe(LOCAL_HOST, port);
+                    if (probeResult) {
+                        const now = new Date().toISOString();
+                        const partial = adapter.toClawInstance(LOCAL_HOST, port, probeResult);
+                        const instance = {
+                            agent_id: partial.agent_id ?? `${adapter.name}@localhost`,
+                            auto_name: "",
+                            assistant_name: partial.assistant_name ?? "",
+                            display_name: partial.display_name ?? adapter.name,
+                            lan_host: os.hostname(),
+                            address: LOCAL_HOST,
+                            gateway_port: port,
+                            tls: false,
+                            discovery_source: "local",
+                            network_scope: "local",
+                            status: "online",
+                            last_seen: now,
+                            discovered_at: now,
+                            implementation: partial.implementation,
+                            connectivity: {
+                                lan_reachable: true,
+                                relay_available: false,
+                                preferred_channel: "local",
+                                last_lan_check: now,
+                            },
+                            is_self: true,
+                        };
+                        this.store.upsert(instance);
+                        this.emit("local:discovered", instance);
+                        previousSelfKeys.delete(`${LOCAL_HOST}:${port}`);
+                        found = instance;
+                        break;
+                    }
+                }
+            }
+            if (found)
+                break;
+        }
+        if (found) {
+            this._markOfflineStaleSelf(previousSelfKeys);
+            return found;
+        }
+        // Nothing found
+        this.localAgentId = null;
+        this._markOfflineStaleSelf(previousSelfKeys);
+        this.emit("local:unavailable");
+        return null;
+    }
+    /** Original OpenClaw probe logic (kept as primary path for backward compatibility) */
+    async probeOpenClaw(port) {
+        const url = `http://${LOCAL_HOST}:${port}${CONFIG_PATH}`;
         try {
             const res = await fetch(url, {
                 signal: AbortSignal.timeout(PROBE_TIMEOUT),
             });
             if (!res.ok) {
-                this._markOffline();
-                this.emit("local:unreachable", { reason: `HTTP ${res.status}` });
+                // Port responded but not valid OpenClaw — don't mark offline or emit unreachable,
+                // because another adapter may be occupying this port. Let the adapter loop try.
                 return null;
             }
             const config = (await res.json());
             if (!config.assistantAgentId) {
-                this._markOffline();
-                this.emit("local:unreachable", { reason: "missing assistantAgentId" });
+                // Has an HTTP server but no assistantAgentId — not a valid OpenClaw instance.
+                // Don't mark offline; another adapter may match this endpoint.
                 return null;
             }
             this.localAgentId = config.assistantAgentId;
@@ -107,7 +223,7 @@ class LocalProbe extends node_events_1.EventEmitter {
                 display_name: config.displayName ?? config.assistantName ?? "",
                 lan_host: os.hostname(),
                 address: LOCAL_HOST,
-                gateway_port: this.port,
+                gateway_port: port,
                 tls: false,
                 discovery_source: "local",
                 network_scope: "local",
@@ -128,9 +244,7 @@ class LocalProbe extends node_events_1.EventEmitter {
             return instance;
         }
         catch {
-            this.localAgentId = null;
-            this._markOffline();
-            this.emit("local:unavailable");
+            // OpenClaw not running on this port — don't emit yet, try adapters first
             return null;
         }
     }