squad-openclaw 2026.2.2020 → 2026.2.2021

package/dist/index.js

@@ -1,2488 +1,2577 @@
-// src/agents.ts
-import { execSync } from "child_process";
-function registerAgentMethods(api) {
-  api.registerGatewayMethod(
-    "squad.agents.add",
-    async ({ params, respond }) => {
-      const name = params?.name;
-      const model = params?.model;
-      if (!name || typeof name !== "string" || !name.trim()) {
-        respond(false, { error: "Missing or empty 'name' parameter" });
-        return;
-      }
-      const safeName = name.trim();
-      if (!/^[a-zA-Z0-9][a-zA-Z0-9 _-]*$/.test(safeName)) {
-        respond(false, { error: "Agent name must start with a letter/number and contain only letters, numbers, spaces, hyphens, or underscores" });
-        return;
-      }
-      try {
-        let cmd = `openclaw agents add ${JSON.stringify(safeName)} --non-interactive`;
-        if (model) {
-          cmd += ` --model ${JSON.stringify(model)}`;
-        }
-        const output = execSync(cmd, {
-          timeout: 3e4,
-          encoding: "utf-8",
-          stdio: ["pipe", "pipe", "pipe"]
-        });
-        respond(true, { ok: true, output: output.slice(0, 1e3) });
-      } catch (err2) {
-        const msg = err2 instanceof Error ? err2.message : String(err2);
-        const stderr = err2?.stderr;
-        respond(false, {
-          error: `Failed to add agent: ${stderr || msg}`.slice(0, 500)
-        });
-      }
+// src/relay-client.ts
+import { WebSocket as NodeWebSocket } from "ws";
+import crypto3 from "crypto";
+import fs3 from "fs";
+import path3 from "path";
+
+// src/e2e-crypto.ts
+import crypto from "crypto";
+var CURVE = "prime256v1";
+var HKDF_SALT = "squad-e2e-v1";
+var HKDF_INFO = "aes-gcm-key";
+var AES_KEY_LENGTH = 32;
+var IV_LENGTH = 12;
+var E2ECrypto = class {
+  ecdh = null;
+  aesKey = null;
+  publicKeyB64 = null;
+  /** Generate an ephemeral ECDH keypair. Returns the public key as base64. */
+  async generateKeyPair() {
+    this.ecdh = crypto.createECDH(CURVE);
+    const publicKey = this.ecdh.generateKeys();
+    this.publicKeyB64 = publicKey.toString("base64");
+    return this.publicKeyB64;
+  }
+  /** Derive the shared secret from the peer's public key. */
+  async deriveSharedSecret(peerPublicKeyB64) {
+    if (!this.ecdh) {
+      throw new Error("Must call generateKeyPair() first");
     }
-  );
-  api.registerGatewayMethod(
-    "squad.agents.delete",
-    async ({ params, respond }) => {
-      const agentId = params?.agentId;
-      if (!agentId || typeof agentId !== "string" || !agentId.trim()) {
-        respond(false, { error: "Missing or empty 'agentId' parameter" });
-        return;
-      }
-      if (agentId === "main") {
-        respond(false, { error: "Cannot delete the main agent" });
-        return;
-      }
-      if (!/^[a-z0-9][a-z0-9-]*$/.test(agentId)) {
-        respond(false, { error: "Invalid agent ID format" });
-        return;
-      }
-      try {
-        const output = execSync(
-          `openclaw agents delete ${JSON.stringify(agentId)} --non-interactive 2>&1`,
-          { timeout: 3e4, encoding: "utf-8" }
-        );
-        respond(true, { ok: true, output: output.slice(0, 1e3) });
-      } catch (err2) {
-        const msg = err2 instanceof Error ? err2.message : String(err2);
-        const stderr = err2?.stderr;
-        respond(false, {
-          error: `Failed to delete agent: ${stderr || msg}`.slice(0, 500)
-        });
-      }
+    const peerPublicKey = Buffer.from(peerPublicKeyB64, "base64");
+    const sharedSecret = this.ecdh.computeSecret(peerPublicKey);
+    this.aesKey = crypto.hkdfSync(
+      "sha256",
+      sharedSecret,
+      Buffer.from(HKDF_SALT),
+      Buffer.from(HKDF_INFO),
+      AES_KEY_LENGTH
+    );
+  }
+  /** Encrypt a plaintext string. Returns base64-encoded ciphertext + iv + tag. */
+  encrypt(plaintext) {
+    if (!this.aesKey) {
+      throw new Error("E2E not established \u2014 call deriveSharedSecret() first");
     }
-  );
-  api.registerGatewayMethod(
-    "squad.agents.set-identity",
-    async ({ params, respond }) => {
-      const agentId = params?.agentId;
-      const name = params?.name;
-      const emoji = params?.emoji;
-      const theme = params?.theme;
-      if (!agentId || typeof agentId !== "string") {
-        respond(false, { error: "Missing 'agentId' parameter" });
-        return;
-      }
-      const args = [`--agent`, JSON.stringify(agentId)];
-      if (name) args.push(`--name`, JSON.stringify(name));
-      if (emoji) args.push(`--emoji`, JSON.stringify(emoji));
-      if (theme) args.push(`--theme`, JSON.stringify(theme));
-      if (args.length <= 2) {
-        respond(false, { error: "No identity fields provided (name, emoji, or theme)" });
-        return;
-      }
-      try {
-        const output = execSync(
-          `openclaw agents set-identity ${args.join(" ")} 2>&1`,
-          { timeout: 15e3, encoding: "utf-8" }
-        );
-        respond(true, { ok: true, output: output.slice(0, 1e3) });
-      } catch (err2) {
-        const msg = err2 instanceof Error ? err2.message : String(err2);
-        const stderr = err2?.stderr;
-        respond(false, {
-          error: `Failed to set identity: ${stderr || msg}`.slice(0, 500)
-        });
-      }
+    const iv = crypto.randomBytes(IV_LENGTH);
+    const cipher = crypto.createCipheriv("aes-256-gcm", this.aesKey, iv);
+    const encrypted = Buffer.concat([
+      cipher.update(plaintext, "utf-8"),
+      cipher.final()
+    ]);
+    const tag = cipher.getAuthTag();
+    return {
+      ciphertext: encrypted.toString("base64"),
+      iv: iv.toString("base64"),
+      tag: tag.toString("base64")
+    };
+  }
+  /** Decrypt a payload. Returns the plaintext string. */
+  decrypt(payload) {
+    if (!this.aesKey) {
+      throw new Error("E2E not established \u2014 call deriveSharedSecret() first");
     }
-  );
-}
-
-// src/entities.ts
-import { Type as T } from "@sinclair/typebox";
-import path5 from "path";
-import fs5 from "fs";
+    const ciphertext = Buffer.from(payload.ciphertext, "base64");
+    const iv = Buffer.from(payload.iv, "base64");
+    const tag = Buffer.from(payload.tag, "base64");
+    const decipher = crypto.createDecipheriv("aes-256-gcm", this.aesKey, iv);
+    decipher.setAuthTag(tag);
+    const decrypted = Buffer.concat([
+      decipher.update(ciphertext),
+      decipher.final()
+    ]);
+    return decrypted.toString("utf-8");
+  }
+  /** Whether E2E encryption has been established */
+  get isEstablished() {
+    return this.aesKey !== null;
+  }
+  /** Get the local public key (base64) */
+  get publicKey() {
+    return this.publicKeyB64;
+  }
+};
 
-// src/watcher.ts
+// src/paths.ts
 import path from "path";
+import os from "os";
 import fs from "fs";
-import chokidar from "chokidar";
-var debounceTimers = /* @__PURE__ */ new Map();
-var DEBOUNCE_MS = 500;
-function debounced(key, fn) {
-  const existing = debounceTimers.get(key);
-  if (existing) clearTimeout(existing);
-  debounceTimers.set(
-    key,
-    setTimeout(() => {
-      debounceTimers.delete(key);
-      fn();
-    }, DEBOUNCE_MS)
-  );
-}
-var fsDebounceTimers = /* @__PURE__ */ new Map();
-var FS_DEBOUNCE_MS = 300;
-function debouncedFs(relPath, action, fn) {
-  const key = `fs:${action}:${relPath}`;
-  const existing = fsDebounceTimers.get(key);
-  if (existing) clearTimeout(existing);
-  fsDebounceTimers.set(
-    key,
-    setTimeout(() => {
-      fsDebounceTimers.delete(key);
-      fn();
-    }, FS_DEBOUNCE_MS)
-  );
-}
-function isWorkspaceIdentity(filePath, configDir) {
-  const rel = path.relative(configDir, filePath);
-  const match = rel.match(/^(workspace(?:-([^/]+))?)\/IDENTITY\.md$/);
-  if (!match) return null;
-  const dirName = match[1];
-  const agentId = match[2] ?? "main";
-  return { agentId, workspacePath: path.join(configDir, dirName) };
+function getOpenclawStateDir() {
+  if (process.env.OPENCLAW_STATE_DIR) {
+    return process.env.OPENCLAW_STATE_DIR;
+  }
+  if (process.env.OPENCLAW_CONFIG_PATH) {
+    return path.dirname(process.env.OPENCLAW_CONFIG_PATH);
+  }
+  const legacyDir = process.env.OPENCLAW_DIR;
+  if (legacyDir) {
+    const resolvedLegacyDir = path.resolve(legacyDir);
+    const configPath = path.join(resolvedLegacyDir, "openclaw.json");
+    const hasStateMarkers = fs.existsSync(configPath) || fs.existsSync(path.join(resolvedLegacyDir, "agents")) || fs.existsSync(path.join(resolvedLegacyDir, "workspace"));
+    const looksLikeStateDir = resolvedLegacyDir.endsWith(`${path.sep}.openclaw`);
+    if (hasStateMarkers || looksLikeStateDir) {
+      return resolvedLegacyDir;
+    }
+  }
+  return path.join(os.homedir(), ".openclaw");
 }
-function isWorkspaceAgentJson(filePath, configDir) {
-  const rel = path.relative(configDir, filePath);
-  const match = rel.match(/^(workspace(?:-([^/]+))?)\/agent\.json$/);
-  if (!match) return null;
-  const dirName = match[1];
-  const agentId = match[2] ?? "main";
-  return { agentId, workspacePath: path.join(configDir, dirName) };
+
+// src/device-keys.ts
+import crypto2 from "crypto";
+import fs2 from "fs";
+import path2 from "path";
+var RELAY_DATA_DIR = path2.join(getOpenclawStateDir(), "squad-ceo-data", "relay");
+var RELAY_STATE_PATH = path2.join(RELAY_DATA_DIR, "squad-relay.json");
+var PENDING_APPROVAL_PATH = path2.join(RELAY_DATA_DIR, "pending-approval.json");
+function readRelayState() {
+  try {
+    const raw = fs2.readFileSync(RELAY_STATE_PATH, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
 }
-function isGlobalSkillDir(filePath, configDir) {
-  const rel = path.relative(configDir, filePath);
-  const match = rel.match(/^skills\/([^/]+)\/?$/);
-  if (!match) return null;
-  return { skillKey: match[1] };
+function writeRelayState(state) {
+  if (!fs2.existsSync(RELAY_DATA_DIR)) {
+    fs2.mkdirSync(RELAY_DATA_DIR, { recursive: true });
+  }
+  fs2.writeFileSync(RELAY_STATE_PATH, JSON.stringify(state, null, 2), { mode: 384 });
 }
-function isWorkspaceSkillDir(filePath, configDir) {
-  const rel = path.relative(configDir, filePath);
-  const match = rel.match(
-    /^workspace(?:-([^/]+))?\/skills\/([^/]+)\/?$/
-  );
-  if (!match) return null;
-  return { agentId: match[1] ?? "main", skillKey: match[2] };
+function toBase64Url(buf) {
+  return buf.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
 }
-function isPluginManifest(filePath, configDir) {
-  const rel = path.relative(configDir, filePath);
-  const match = rel.match(/^extensions\/([^/]+)\/openclaw\.plugin\.json$/);
-  if (!match) return null;
-  return { pluginDirName: match[1] };
+function loadOrCreateRelayDeviceKeys() {
+  const state = readRelayState();
+  if (state.deviceKeys) {
+    return state.deviceKeys;
+  }
+  const { publicKey, privateKey } = crypto2.generateKeyPairSync("ed25519");
+  const pubDer = publicKey.export({ type: "spki", format: "der" });
+  const rawPub = pubDer.subarray(pubDer.length - 32);
+  const deviceId = crypto2.createHash("sha256").update(rawPub).digest("hex");
+  const publicKeyB64 = toBase64Url(rawPub);
+  const privateKeyPem = privateKey.export({ type: "pkcs8", format: "pem" });
+  const keys = { deviceId, publicKey: publicKeyB64, privateKeyPem };
+  writeRelayState({ ...state, deviceKeys: keys });
+  console.log(`[device-keys] Generated relay device identity: ${deviceId.substring(0, 12)}...`);
+  return keys;
 }
-function isOpenClawConfig(filePath, configDir) {
-  return path.relative(configDir, filePath) === "openclaw.json";
+function writeDeviceInfoFile(keys) {
+  const stateDir = getOpenclawStateDir();
+  const infoPath = path2.join(stateDir, "squad-ceo-data", "relay", "relay-device-info.json");
+  const info = {
+    deviceId: keys.deviceId,
+    publicKey: keys.publicKey,
+    displayName: "squad-relay",
+    platform: process.platform,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  try {
+    fs2.writeFileSync(infoPath, JSON.stringify(info, null, 2));
+  } catch (err2) {
+    console.error("[device-keys] Failed to write relay-device-info.json:", err2);
+  }
 }
-function updateAgent(agentId, workspacePath) {
-  const now = Date.now();
-  let name = agentId;
-  const metadata = { workspacePath };
+
+// src/relay-client.ts
+function readOperatorToken() {
+  const stateDir = getOpenclawStateDir();
+  const configPath = path3.join(stateDir, "openclaw.json");
   try {
-    const content = fs.readFileSync(
-      path.join(workspacePath, "IDENTITY.md"),
-      "utf-8"
-    );
-    const parsed = parseIdentityName(content);
-    if (parsed) name = parsed;
+    const raw = fs3.readFileSync(configPath, "utf-8");
+    const config = JSON.parse(raw);
+    return config?.gateway?.auth?.token ?? config?.gateway?.remote?.token ?? config?.gateway?.token ?? null;
   } catch {
+    return null;
   }
-  if (name === agentId) {
-    try {
-      const raw = fs.readFileSync(
-        path.join(workspacePath, "agent.json"),
-        "utf-8"
-      );
-      const config = JSON.parse(raw);
-      if (config.displayName) name = config.displayName;
-      if (config.model) metadata.model = config.model;
-    } catch {
-    }
-  }
-  registrySet({
-    id: agentId,
-    type: "agent",
-    name,
-    title: name,
-    description: null,
-    metadata,
-    source: "filesystem",
-    source_key: workspacePath,
-    created_at: now,
-    updated_at: now
-  });
 }
-function updatePlugin(pluginDirName, configDir) {
-  const now = Date.now();
-  const manifestPath = path.join(
-    configDir,
-    "extensions",
-    pluginDirName,
-    "openclaw.plugin.json"
-  );
+function readGatewayLocalWsConfig() {
+  const defaults = {
+    port: 18789,
+    // Try IPv4, hostname, then IPv6 loopback.
+    hosts: ["127.0.0.1", "localhost", "[::1]"]
+  };
+  const stateDir = getOpenclawStateDir();
+  const configPath = path3.join(stateDir, "openclaw.json");
   try {
-    const raw = fs.readFileSync(manifestPath, "utf-8");
-    const manifest = JSON.parse(raw);
-    const pluginId = manifest.id || pluginDirName;
-    const name = manifest.name || pluginId;
-    registrySet({
-      id: `plugin:${pluginId}`,
-      type: "plugin",
-      name,
-      title: name,
-      description: manifest.description || null,
-      metadata: { pluginId, pluginDir: path.dirname(manifestPath) },
-      source: "filesystem",
-      source_key: manifestPath,
-      created_at: now,
-      updated_at: now
-    });
+    const raw = fs3.readFileSync(configPath, "utf-8");
+    const config = JSON.parse(raw);
+    const parsedPort = Number(config?.gateway?.port);
+    if (Number.isFinite(parsedPort) && parsedPort > 0) {
+      defaults.port = parsedPort;
+    }
   } catch {
-    registryDelete(`plugin:${pluginDirName}`);
   }
+  return defaults;
 }
-function startWatcher(configDir, onFsChange) {
-  const watcher = chokidar.watch(configDir, {
-    persistent: true,
-    usePolling: false,
-    ignoreInitial: true,
-    awaitWriteFinish: { stabilityThreshold: 300 },
-    depth: 4,
-    ignored: [
-      // Ignore heavy directories that aren't relevant
-      "**/node_modules/**",
-      "**/dist/**",
-      "**/.git/**",
-      "**/data/**"
-    ]
-  });
-  const emitFsChange = (action, filePath) => {
-    if (!onFsChange) return;
-    const rel = path.relative(configDir, filePath);
-    debouncedFs(rel, action, () => {
-      onFsChange({ action, path: rel });
-    });
+function signDeviceIdentity(keys, clientId, clientMode, role, scopes, token, challengeNonce) {
+  const signedAtMs = Date.now();
+  const nonce = challengeNonce || crypto3.randomBytes(16).toString("hex");
+  const scopeStr = scopes.join(",");
+  const payload = `v2|${keys.deviceId}|${clientId}|${clientMode}|${role}|${scopeStr}|${signedAtMs}|${token ?? ""}|${nonce}`;
+  const privateKey = crypto3.createPrivateKey(keys.privateKeyPem);
+  const signature = crypto3.sign(null, Buffer.from(payload), privateKey);
+  return {
+    id: keys.deviceId,
+    publicKey: keys.publicKey,
+    signature: toBase64Url(signature),
+    signedAt: signedAtMs,
+    nonce
   };
-  const handleChange = (filePath, action) => {
-    emitFsChange(action, filePath);
-    const identity = isWorkspaceIdentity(filePath, configDir);
-    if (identity) {
-      debounced(
-        `agent:${identity.agentId}`,
-        () => updateAgent(identity.agentId, identity.workspacePath)
-      );
+}
+var RelayClient = class {
+  config;
+  relayWs = null;
+  userConnections = /* @__PURE__ */ new Map();
+  localConnectAttempts = /* @__PURE__ */ new Map();
+  reconnectAttempts = 0;
+  maxReconnectAttempts = 100;
+  reconnectTimer = null;
+  shouldReconnect = true;
+  destroyed = false;
+  /** Pending claim token — sent on first successful connect, then cleared */
+  pendingClaimToken = null;
+  /** Device keys for authenticating local WS connections to the gateway */
+  deviceKeys;
+  constructor(config) {
+    const state = readRelayState();
+    const localWs = readGatewayLocalWsConfig();
+    this.config = {
+      relayUrl: config.relayUrl,
+      localGatewayPort: config.localGatewayPort ?? localWs.port,
+      localGatewayHosts: config.localGatewayHosts ?? localWs.hosts,
+      operatorToken: config.operatorToken ?? readOperatorToken(),
+      claimToken: config.claimToken ?? state.claimToken ?? null,
+      roomId: config.roomId ?? state.roomId ?? null
+    };
+    this.pendingClaimToken = this.config.roomId ? null : this.config.claimToken;
+    this.deviceKeys = loadOrCreateRelayDeviceKeys();
+    writeDeviceInfoFile(this.deviceKeys);
+    console.log(`[relay-client] Device ID: ${this.deviceKeys.deviceId}`);
+  }
+  /** Start connecting to the relay */
+  start() {
+    if (!this.config.roomId && !this.pendingClaimToken) {
+      console.log("[relay-client] No room ID or claim token found.");
+      console.log("[relay-client] Complete the setup from the Squad web app to generate a claim token.");
       return;
     }
-    const agentJson = isWorkspaceAgentJson(filePath, configDir);
-    if (agentJson) {
-      debounced(
-        `agent:${agentJson.agentId}`,
-        () => updateAgent(agentJson.agentId, agentJson.workspacePath)
-      );
-      return;
+    console.log(`[relay-client] Starting relay connection to ${this.config.relayUrl}`);
+    if (this.config.roomId) {
+      console.log(`[relay-client] Room ID: ${this.config.roomId.substring(0, 8)}...`);
+    } else {
+      console.log(`[relay-client] Using claim token for first connect`);
     }
-    const plugin = isPluginManifest(filePath, configDir);
-    if (plugin) {
-      debounced(
-        `plugin:${plugin.pluginDirName}`,
-        () => updatePlugin(plugin.pluginDirName, configDir)
-      );
-      return;
+    this.connectToRelay();
+  }
+  /** Stop the relay client and close all connections */
+  destroy() {
+    this.destroyed = true;
+    this.shouldReconnect = false;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
     }
-    if (isOpenClawConfig(filePath, configDir)) {
-      debounced("tools", () => scanTools(configDir));
-      return;
+    for (const [userId, conn] of this.userConnections) {
+      try {
+        conn.localWs.close(1e3, "Relay client shutting down");
+      } catch {
+      }
+      this.userConnections.delete(userId);
     }
-  };
-  const handleAddDir = (dirPath) => {
-    emitFsChange("addDir", dirPath);
-    const globalSkill = isGlobalSkillDir(dirPath, configDir);
-    if (globalSkill) {
-      debounced(
-        `skill:${globalSkill.skillKey}`,
-        () => scanSkills(configDir)
-      );
-      return;
+    if (this.relayWs) {
+      try {
+        this.relayWs.close(1e3, "Relay client shutting down");
+      } catch {
+      }
+      this.relayWs = null;
     }
-    const wsSkill = isWorkspaceSkillDir(dirPath, configDir);
-    if (wsSkill) {
-      debounced(
-        `skill:${wsSkill.agentId}:${wsSkill.skillKey}`,
-        () => scanSkills(configDir)
-      );
+  }
+  // ── Relay Connection ──
+  connectToRelay() {
+    if (this.destroyed) return;
+    let wsUrl;
+    if (this.pendingClaimToken) {
+      wsUrl = `${this.config.relayUrl}/gw?claim=${encodeURIComponent(this.pendingClaimToken)}`;
+      console.log(`[relay-client] Connecting with claim token`);
+    } else if (this.config.roomId) {
+      wsUrl = `${this.config.relayUrl}/gw?room=${encodeURIComponent(this.config.roomId)}`;
+      console.log(`[relay-client] Reconnecting with room ID`);
+    } else {
+      console.error("[relay-client] No claim token or room ID \u2014 cannot connect");
       return;
     }
-    const rel = path.relative(configDir, dirPath);
-    if (/^workspace(-[^/]+)?$/.test(rel)) {
-      debounced("agents", () => scanAgents(configDir));
+    try {
+      this.relayWs = new NodeWebSocket(wsUrl);
+    } catch (err2) {
+      console.error("[relay-client] Failed to create WebSocket:", err2);
+      this.scheduleReconnect();
       return;
     }
-  };
-  const handleUnlinkDir = (dirPath) => {
-    emitFsChange("unlinkDir", dirPath);
-    const rel = path.relative(configDir, dirPath);
-    const wsMatch = rel.match(/^workspace(?:-([^/]+))?$/);
-    if (wsMatch) {
-      const agentId = wsMatch[1] ?? "main";
-      registryDelete(agentId);
+    this.relayWs.on("open", () => {
+      console.log("[relay-client] Connected to relay");
+      this.reconnectAttempts = 0;
+      this.sendToRelay({
+        type: "relay.hello",
+        deviceId: this.deviceKeys.deviceId,
+        publicKey: this.deviceKeys.publicKey
+      });
+    });
+    this.relayWs.on("message", (data) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        this.handleRelayMessage(msg);
+      } catch {
+      }
+    });
+    this.relayWs.on("close", (code, reason) => {
+      const reasonStr = reason.toString();
+      console.log(`[relay-client] Relay connection closed: ${code} ${reasonStr}`);
+      this.relayWs = null;
+      if (code === 1e3 && reasonStr.includes("Replaced")) {
+        console.log("[relay-client] Replaced by newer instance, stopping reconnect");
+        this.shouldReconnect = false;
+        this.destroyed = true;
+      }
+      for (const [userId, conn] of this.userConnections) {
+        try {
+          conn.localWs.close(1001, "Relay disconnected");
+        } catch {
+        }
+        this.userConnections.delete(userId);
+      }
+      if (this.shouldReconnect) {
+        this.scheduleReconnect();
+      }
+    });
+    this.relayWs.on("error", (err2) => {
+      console.error("[relay-client] Relay WebSocket error:", err2.message);
+    });
+    this.relayWs.on("unexpected-response", (_req, res) => {
+      console.warn(`[relay-client] Unexpected response: ${res.statusCode}`);
+      if (res.statusCode === 401 && this.pendingClaimToken) {
+        console.log("[relay-client] Claim token rejected \u2014 checking for stored room ID");
+        this.pendingClaimToken = null;
+        const state = readRelayState();
+        if (state.roomId) {
+          this.config.roomId = state.roomId;
+          console.log(`[relay-client] Found stored room ID, will use on next reconnect`);
+        }
+      }
+      this.relayWs = null;
+      this.scheduleReconnect();
+    });
+  }
+  scheduleReconnect() {
+    if (this.destroyed || !this.shouldReconnect) return;
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      console.error("[relay-client] Max reconnect attempts reached");
       return;
     }
-    const globalSkill = isGlobalSkillDir(dirPath, configDir);
-    if (globalSkill) {
-      registryDelete(`skill:${globalSkill.skillKey}`);
+    const delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts), 6e4);
+    this.reconnectAttempts++;
+    console.log(`[relay-client] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.connectToRelay();
+    }, delay);
+  }
+  // ── Message Handling ──
+  handleRelayMessage(msg) {
+    switch (msg.type) {
+      case "relay.welcome":
+        this.handleWelcome(msg);
+        break;
+      case "relay.forward":
+        if (msg.userId && msg.inner) {
+          this.routeToUser(msg.userId, msg.inner);
+        }
+        break;
+      case "relay.pair.request":
+        if (msg.userId && msg.email) {
+          this.handlePairingRequest(msg.userId, msg.email);
+        }
+        break;
+      case "relay.e2e.exchange":
+        if (msg.userId && msg.publicKey) {
+          this.handleE2EExchange(msg.userId, msg.publicKey);
+        }
+        break;
+      case "relay.ping":
+        this.sendToRelay({ type: "relay.pong" });
+        break;
+      default:
+        console.log(`[relay-client] Unknown relay message type: ${msg.type}`);
+    }
+  }
+  /** Handle relay.welcome — store room ID for reconnection */
+  handleWelcome(msg) {
+    if (msg.roomId) {
+      console.log(`[relay-client] Received room ID: ${msg.roomId.substring(0, 8)}...`);
+      this.config.roomId = msg.roomId;
+      this.pendingClaimToken = null;
+      const state = readRelayState();
+      state.roomId = msg.roomId;
+      writeRelayState(state);
+    }
+  }
+  /** Route a message from the relay to the appropriate user's local WS */
+  routeToUser(userId, innerMsg) {
+    let msg = innerMsg;
+    if (msg.type === "event" && typeof msg.event === "string" && msg.event.startsWith("relay.")) {
+      if (msg.event === "relay.user.connected") {
+        console.log(`[relay-client] User ${userId} connected via relay \u2014 creating local WS`);
+        this.createUserConnection(userId);
+      }
       return;
     }
-    const wsSkill = isWorkspaceSkillDir(dirPath, configDir);
-    if (wsSkill) {
-      registryDelete(`skill:${wsSkill.agentId}:${wsSkill.skillKey}`);
+    if (typeof msg.type === "string" && msg.type.startsWith("relay.")) {
+      if (msg.type === "relay.e2e.exchange" && msg.publicKey) {
+        this.handleE2EExchange(userId, msg.publicKey);
+      }
       return;
     }
-  };
-  watcher.on("add", (fp) => handleChange(fp, "add"));
-  watcher.on("change", (fp) => handleChange(fp, "change"));
-  watcher.on("unlink", (fp) => handleChange(fp, "unlink"));
-  watcher.on("addDir", handleAddDir);
-  watcher.on("unlinkDir", handleUnlinkDir);
-  return () => {
-    for (const timer of debounceTimers.values()) {
-      clearTimeout(timer);
+    let conn = this.userConnections.get(userId);
+    if (!conn || conn.localWs.readyState >= NodeWebSocket.CLOSING) {
+      this.createUserConnection(userId);
+      conn = this.userConnections.get(userId);
+      if (!conn) return;
     }
-    debounceTimers.clear();
-    for (const timer of fsDebounceTimers.values()) {
-      clearTimeout(timer);
+    if (msg._e2e && conn.e2e) {
+      try {
+        const plaintext = conn.e2e.decrypt({
+          ciphertext: msg.ciphertext,
+          iv: msg.iv,
+          tag: msg.tag
+        });
+        msg = JSON.parse(plaintext);
+      } catch (err2) {
+        console.error(`[relay-client] E2E decrypt error for ${userId}:`, err2);
+        return;
+      }
     }
-    fsDebounceTimers.clear();
-    watcher.close();
-  };
-}
-
-// src/filesystem.ts
-import fs4 from "fs";
-import path4 from "path";
-
-// src/paths.ts
-import path2 from "path";
-import os from "os";
-import fs2 from "fs";
-function getOpenclawStateDir() {
-  if (process.env.OPENCLAW_STATE_DIR) {
-    return process.env.OPENCLAW_STATE_DIR;
-  }
-  if (process.env.OPENCLAW_CONFIG_PATH) {
-    return path2.dirname(process.env.OPENCLAW_CONFIG_PATH);
+    if (msg.type === "req" && msg.method === "connect") {
+      if (conn.connectHandshakeComplete) {
+        console.log(`[relay-client] New connect from ${userId} \u2014 creating fresh local WS for handshake`);
+        this.createUserConnection(userId);
+        conn = this.userConnections.get(userId);
+        if (!conn) return;
+      }
+      if (!conn.challengeNonce) {
+        console.log(`[relay-client] Connect request for ${userId} deferred \u2014 waiting for challenge nonce`);
+        conn.pendingConnect = msg;
+        return;
+      }
+      this.injectDeviceIdentity(conn, msg);
+      if (conn.localWs.readyState === NodeWebSocket.CONNECTING) {
+        conn.localWs.once("open", () => {
+          conn.localWs.send(JSON.stringify(msg));
+        });
+      } else {
+        conn.localWs.send(JSON.stringify(msg));
+      }
+      return;
+    }
+    if (!conn.connectHandshakeComplete) {
+      conn.pendingMessages.push(msg);
+      return;
+    }
+    if (conn.localWs.readyState === NodeWebSocket.CONNECTING) {
+      conn.localWs.once("open", () => {
+        conn.localWs.send(JSON.stringify(msg));
+      });
+      return;
+    }
+    conn.localWs.send(JSON.stringify(msg));
   }
-  const legacyDir = process.env.OPENCLAW_DIR;
-  if (legacyDir) {
-    const resolvedLegacyDir = path2.resolve(legacyDir);
-    const configPath = path2.join(resolvedLegacyDir, "openclaw.json");
-    const hasStateMarkers = fs2.existsSync(configPath) || fs2.existsSync(path2.join(resolvedLegacyDir, "agents")) || fs2.existsSync(path2.join(resolvedLegacyDir, "workspace"));
-    const looksLikeStateDir = resolvedLegacyDir.endsWith(`${path2.sep}.openclaw`);
-    if (hasStateMarkers || looksLikeStateDir) {
-      return resolvedLegacyDir;
+  /**
+   * Inject auth token and device identity into a connect request.
+   *
+   * SECURITY: The token is added to the message IN MEMORY, then sent to the
+   * LOCAL gateway WebSocket (localhost:18789). It NEVER traverses the relay —
+   * the relay only sees the outer relay.forward envelope. A compromised relay
+   * server cannot intercept this token.
+   */
+  injectDeviceIdentity(conn, msg) {
+    const params = msg.params ?? {};
+    if (this.config.operatorToken) {
+      params.auth = { token: this.config.operatorToken };
     }
+    const client = params.client ?? {};
+    const role = params.role ?? "operator";
+    const scopes = params.scopes ?? [];
+    params.device = signDeviceIdentity(
+      this.deviceKeys,
+      client.id ?? "cli",
+      client.mode ?? "ui",
+      role,
+      scopes,
+      this.config.operatorToken,
+      conn.challengeNonce
+    );
+    msg.params = params;
+    conn.connectHandshakeComplete = false;
+    console.log(`[relay-client] Injected device identity for ${conn.userId}: nonce=${conn.challengeNonce?.substring(0, 12)}...`);
   }
-  return path2.join(os.homedir(), ".openclaw");
-}
-
-// src/layout.ts
-import fs3 from "fs";
-import path3 from "path";
-function resolveMaybeRelativePath(stateDir, p) {
-  if (path3.isAbsolute(p)) return path3.resolve(p);
-  return path3.resolve(stateDir, p);
-}
-function listWorkspaceFallbacks(stateDir) {
-  let entries;
-  try {
-    entries = fs3.readdirSync(stateDir, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-  return entries.filter((entry) => entry.isDirectory() && (entry.name === "workspace" || entry.name.startsWith("workspace-"))).map((entry) => {
-    const agentId = entry.name === "workspace" ? "main" : entry.name.replace("workspace-", "");
-    const workspacePath = path3.join(stateDir, entry.name);
-    return {
-      agentId,
-      path: workspacePath,
-      source: "filesystem",
-      exists: true
-    };
-  });
-}
-function readOpenclawConfig(configPath) {
-  try {
-    const raw = fs3.readFileSync(configPath, "utf-8");
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-function resolveGatewayLayout() {
-  const stateDir = getOpenclawStateDir();
-  const configPath = path3.join(stateDir, "openclaw.json");
-  const config = readOpenclawConfig(configPath);
-  const workspaces = [];
-  if (config?.agents?.main?.workspace || config?.agents?.main?.workspacePath) {
-    const rawPath = config.agents.main.workspace ?? config.agents.main.workspacePath;
-    if (rawPath) {
-      const resolvedPath = resolveMaybeRelativePath(stateDir, rawPath);
-      workspaces.push({
-        agentId: "main",
-        path: resolvedPath,
-        source: "config",
-        exists: fs3.existsSync(resolvedPath)
-      });
+  /** Create a local WS connection to the gateway for a specific user */
+  createUserConnection(userId, carry) {
+    const existing = this.userConnections.get(userId);
+    if (existing) {
+      try {
+        existing.localWs.close(1e3, "Replaced");
+      } catch {
+      }
     }
-  }
-  for (const agent of config?.agents?.list ?? []) {
-    const agentId = typeof agent.id === "string" && agent.id.trim() ? agent.id : null;
-    const rawPath = agent.workspace ?? agent.workspacePath;
-    if (!agentId || !rawPath) continue;
-    const resolvedPath = resolveMaybeRelativePath(stateDir, rawPath);
-    workspaces.push({
-      agentId,
-      path: resolvedPath,
-      source: "config",
-      exists: fs3.existsSync(resolvedPath)
+    const attempt = this.localConnectAttempts.get(userId) ?? 0;
+    const host = this.config.localGatewayHosts[attempt % this.config.localGatewayHosts.length];
+    const localUrl = `ws://${host}:${this.config.localGatewayPort}`;
+    console.log(`[relay-client] Creating local WS for user ${userId} \u2192 ${localUrl}`);
+    const localWs = new NodeWebSocket(localUrl);
+    const conn = {
+      localWs,
+      userId,
+      e2e: carry?.e2e ?? null,
+      connectHandshakeComplete: false,
+      challengeNonce: null,
+      pendingConnect: carry?.pendingConnect ?? null,
+      pendingMessages: carry?.pendingMessages ?? []
+    };
+    this.userConnections.set(userId, conn);
+    localWs.on("open", () => {
+      console.log(`[relay-client] Local WS for user ${userId} connected`);
+      this.localConnectAttempts.delete(userId);
     });
-  }
-  const deduped = /* @__PURE__ */ new Map();
-  for (const ws of [...workspaces, ...listWorkspaceFallbacks(stateDir)]) {
-    if (!deduped.has(ws.agentId)) {
-      deduped.set(ws.agentId, ws);
-    }
-  }
-  const resolvedWorkspaces = Array.from(deduped.values());
-  const mainWorkspace = resolvedWorkspaces.find((ws) => ws.agentId === "main");
-  const defaultFileBrowserRoot = mainWorkspace?.path ?? stateDir;
-  return {
-    stateDir,
-    configPath,
-    mediaDir: path3.join(stateDir, "media"),
-    skillsDir: path3.join(stateDir, "skills"),
-    extensionsDir: path3.join(stateDir, "extensions"),
-    defaultFileBrowserRoot,
-    workspaces: resolvedWorkspaces
-  };
-}
-
-// src/filesystem.ts
-var HOME_DIR = process.env.HOME ?? "/root";
-var OPENCLAW_DIR = getOpenclawStateDir();
-var SENSITIVE_BLOCKED_DIRS = [
-  path4.join(OPENCLAW_DIR, "credentials"),
-  path4.join(OPENCLAW_DIR, "devices"),
-  path4.join(OPENCLAW_DIR, "identity")
-];
-var SENSITIVE_BLOCKED_FILES = [
-  path4.join(OPENCLAW_DIR, "squad-ceo-data", "relay", "squad-relay.json")
-];
-function isSensitivePath(resolvedPath) {
-  for (const blocked of SENSITIVE_BLOCKED_DIRS) {
-    if (resolvedPath === blocked || resolvedPath.startsWith(blocked + path4.sep)) {
-      return true;
-    }
-  }
-  for (const blocked of SENSITIVE_BLOCKED_FILES) {
-    if (resolvedPath === blocked) {
-      return true;
-    }
-  }
-  if (path4.dirname(resolvedPath) === OPENCLAW_DIR && resolvedPath.endsWith(".bak")) {
-    return true;
-  }
-  return false;
-}
-var OPENCLAW_JSON_FILENAME = "openclaw.json";
-function redactOpenclawJson(rawContent) {
-  let config;
-  try {
-    config = JSON.parse(rawContent);
-  } catch {
-    return rawContent;
-  }
-  let redactedCount = 0;
-  const channels = config.channels;
-  if (channels && typeof channels === "object") {
-    for (const channelKey of Object.keys(channels)) {
-      const channel = channels[channelKey];
-      if (channel && typeof channel === "object" && "botToken" in channel) {
-        channel.botToken = "[REDACTED]";
-        redactedCount++;
+    localWs.on("message", (data) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        this.routeFromGateway(userId, msg);
+      } catch {
       }
-    }
+    });
+    localWs.on("close", (code, reason) => {
+      const reasonStr = reason.toString();
+      console.log(`[relay-client] Local WS for user ${userId} closed: ${code} ${reasonStr}`);
+      if (code === 1008) {
+        console.error(
+          `[relay-client] Gateway rejected device identity (code 1008). The gateway auto-pairs devices with a valid operator token, so this usually means the operator token is missing, expired, or incorrect.
+Check: ~/.openclaw/openclaw.json \u2192 gateway.auth.token
+Device ID: ${this.deviceKeys.deviceId}`
+        );
+      }
+      const current = this.userConnections.get(userId);
+      if (current && current.localWs === localWs) {
+        this.userConnections.delete(userId);
+        const nextAttempt = (this.localConnectAttempts.get(userId) ?? 0) + 1;
+        const shouldRetryLocalConnect = code === 1006 && !conn.connectHandshakeComplete && nextAttempt <= 8 && this.relayWs?.readyState === NodeWebSocket.OPEN;
+        if (shouldRetryLocalConnect) {
+          this.localConnectAttempts.set(userId, nextAttempt);
+          const delay = Math.min(300 * nextAttempt, 2e3);
+          console.log(
+            `[relay-client] Local WS unavailable for ${userId}, retrying in ${delay}ms (attempt ${nextAttempt}/8)`
+          );
+          const carry2 = {
+            pendingConnect: conn.pendingConnect,
+            pendingMessages: conn.pendingMessages,
+            e2e: conn.e2e
+          };
+          setTimeout(() => {
+            if (this.destroyed) return;
+            if (this.relayWs?.readyState !== NodeWebSocket.OPEN) return;
+            if (!this.userConnections.has(userId)) {
+              this.createUserConnection(userId, carry2);
+            }
+          }, delay);
+          return;
+        }
+        this.localConnectAttempts.delete(userId);
+        this.sendToRelay({
+          type: "relay.forward",
+          userId,
+          inner: {
+            type: "event",
+            event: "relay.gateway.connection.closed",
+            payload: { code }
+          }
+        });
+      }
+    });
+    localWs.on("error", (err2) => {
+      console.error(`[relay-client] Local WS error for user ${userId}:`, err2.message);
+    });
   }
-  const gateway = config.gateway;
-  if (gateway && typeof gateway === "object") {
-    if (gateway.auth && typeof gateway.auth === "object") {
-      const auth = gateway.auth;
-      for (const key of Object.keys(auth)) {
-        auth[key] = "[REDACTED]";
-        redactedCount++;
+  /** Route a message from the gateway back through the relay to the user */
+  routeFromGateway(userId, msg) {
+    const conn = this.userConnections.get(userId);
+    if (!conn) return;
+    const parsed = msg;
+    if (parsed.type === "event" && parsed.event === "connect.challenge") {
+      const payload = parsed.payload;
+      if (payload?.nonce) {
+        conn.challengeNonce = payload.nonce;
+        console.log(`[relay-client] Captured challenge nonce for ${userId}: ${conn.challengeNonce.substring(0, 12)}...`);
+        if (conn.pendingConnect) {
+          const pending = conn.pendingConnect;
+          conn.pendingConnect = null;
+          console.log(`[relay-client] Flushing deferred connect for ${userId}`);
+          this.injectDeviceIdentity(conn, pending);
+          if (conn.localWs.readyState === NodeWebSocket.OPEN) {
+            conn.localWs.send(JSON.stringify(pending));
+          }
+        }
       }
     }
-    if ("token" in gateway) {
-      gateway.token = "[REDACTED]";
-      redactedCount++;
+    if (parsed.type === "res" && parsed.id === "connect-1" && parsed.ok) {
+      conn.connectHandshakeComplete = true;
+      if (conn.pendingMessages.length > 0) {
+        console.log(`[relay-client] Flushing ${conn.pendingMessages.length} buffered messages for ${userId}`);
+        for (const queued of conn.pendingMessages) {
+          conn.localWs.send(JSON.stringify(queued));
+        }
+        conn.pendingMessages = [];
+      }
     }
-    const remote = gateway.remote;
-    if (remote && typeof remote === "object" && "token" in remote) {
-      remote.token = "[REDACTED]";
-      redactedCount++;
+    let innerMsg = msg;
+    if (conn.e2e) {
+      try {
+        const encrypted = conn.e2e.encrypt(JSON.stringify(msg));
+        innerMsg = { _e2e: true, ...encrypted };
+      } catch (err2) {
+        console.error(`[relay-client] E2E encrypt failed for ${userId} \u2014 dropping message:`, err2);
+        return;
+      }
     }
+    this.sendToRelay({
+      type: "relay.forward",
+      userId,
+      inner: innerMsg
+    });
   }
-  if (redactedCount > 0) {
-    console.log(`[security] Redacted ${redactedCount} sensitive field(s) from openclaw.json before returning to client`);
+  // ── Pairing ──
+  handlePairingRequest(userId, email) {
+    console.log(`[relay-client] Pairing request from ${email} (${userId})`);
+    this.sendToRelay({
+      type: "relay.pair.status",
+      userId,
+      status: "pending"
+    });
+    console.log(
+      `[relay-client] Pairing request pending for ${email}. The gateway will auto-pair this device if the operator token is valid.`
+    );
   }
-  return JSON.stringify(config, null, 2);
-}
-function isOpenclawJson(resolvedPath) {
-  return path4.basename(resolvedPath) === OPENCLAW_JSON_FILENAME && resolvedPath.startsWith(OPENCLAW_DIR);
-}
-function expandHome(p) {
-  if (p.startsWith("~/") || p === "~") {
-    return path4.join(HOME_DIR, p.slice(1));
-  }
-  return p;
-}
-function validatePath(p, allowedRoots) {
-  const resolved = path4.resolve(expandHome(p));
-  if (!allowedRoots || allowedRoots.length === 0) return resolved;
-  const allowed = allowedRoots.some((root) => {
-    const resolvedRoot = path4.resolve(expandHome(root));
-    return resolved === resolvedRoot || resolved.startsWith(resolvedRoot + path4.sep);
-  });
-  if (!allowed) {
-    throw new Error(`Path "${p}" is outside allowed roots`);
-  }
-  return resolved;
-}
-function validateAndBlockSensitive(p, allowedRoots) {
-  const resolved = validatePath(p, allowedRoots);
-  if (isSensitivePath(resolved)) {
-    throw new Error(
-      `Access denied: path "${p}" is inside a protected directory (credentials/devices/identity)`
-    );
-  }
-  return resolved;
-}
-function validateWritePath(p, allowedRoots) {
-  const resolved = validateAndBlockSensitive(p, allowedRoots);
-  if (isOpenclawJson(resolved)) {
-    throw new Error(
-      `Write denied: "${p}" is a protected configuration file (openclaw.json)`
-    );
+  // ── E2E Key Exchange ──
+  async handleE2EExchange(userId, browserPublicKey) {
+    console.log(`[relay-client] E2E key exchange with user ${userId}`);
+    const conn = this.userConnections.get(userId);
+    if (!conn) return;
+    try {
+      const e2e = new E2ECrypto();
+      const gatewayPublicKey = await e2e.generateKeyPair();
+      await e2e.deriveSharedSecret(browserPublicKey);
+      conn.e2e = e2e;
+      this.sendToRelay({
+        type: "relay.forward",
+        userId,
+        inner: {
+          type: "relay.e2e.exchange",
+          publicKey: gatewayPublicKey
+        }
+      });
+      console.log(`[relay-client] E2E established for user ${userId}`);
+    } catch (err2) {
+      console.error(`[relay-client] E2E exchange failed for ${userId}:`, err2);
+    }
   }
-  return resolved;
-}
-function ok(data) {
-  return {
-    content: [{ type: "text", text: JSON.stringify(data) }]
-  };
-}
-function err(message) {
-  return {
-    content: [{ type: "text", text: JSON.stringify({ error: message }) }],
-    isError: true
-  };
-}
-function listDir(dirPath, opts) {
-  const dirents = fs4.readdirSync(dirPath, { withFileTypes: true });
-  const results = [];
-  for (const dirent of dirents) {
-    if (!opts.includeHidden && dirent.name.startsWith(".")) continue;
-    const entryPath = path4.join(dirPath, dirent.name);
-    let type = "other";
-    if (dirent.isFile()) type = "file";
-    else if (dirent.isDirectory()) type = "directory";
-    else if (dirent.isSymbolicLink()) type = "symlink";
-    const entry = { name: dirent.name, path: entryPath, type };
+  // ── Send to Relay ──
+  sendToRelay(msg) {
+    if (!this.relayWs || this.relayWs.readyState !== NodeWebSocket.OPEN) return;
     try {
-      const stat = fs4.statSync(entryPath);
-      entry.size = stat.size;
-      entry.modified = stat.mtime.toISOString();
+      this.relayWs.send(JSON.stringify(msg));
     } catch {
     }
-    if (type === "directory" && opts.recursive && opts.depth < opts.maxDepth) {
-      try {
-        entry.children = listDir(entryPath, { ...opts, depth: opts.depth + 1 });
-      } catch {
+  }
+  /** Broadcast an event to all connected users, E2E encrypted per-user */
+  broadcastToUsers(event, payload) {
+    const msg = { type: "event", event, payload };
+    for (const [userId, conn] of this.userConnections) {
+      if (!conn.connectHandshakeComplete) continue;
+      let innerMsg = msg;
+      if (conn.e2e) {
+        try {
+          const encrypted = conn.e2e.encrypt(JSON.stringify(msg));
+          innerMsg = { _e2e: true, ...encrypted };
+        } catch (err2) {
+          console.error(`[relay-client] E2E encrypt failed for broadcast to ${userId} \u2014 skipping:`, err2);
+          continue;
+        }
       }
+      this.sendToRelay({
+        type: "relay.forward",
+        userId,
+        inner: innerMsg
+      });
     }
-    results.push(entry);
   }
-  return results;
-}
-function filterSensitiveEntries(entries) {
-  return entries.filter((entry) => !isSensitivePath(entry.path)).map((entry) => {
-    if (entry.children) {
-      return { ...entry, children: filterSensitiveEntries(entry.children) };
-    }
-    return entry;
+};
+var relayClient = null;
+function startRelayClient(api, relayUrl) {
+  relayClient = new RelayClient({
+    relayUrl
   });
+  relayClient.start();
+  api.registerGatewayMethod(
+    "squad.relay.status",
+    async ({ respond }) => {
+      respond(true, {
+        connected: relayClient !== null,
+        relayUrl
+      });
+    }
+  );
+  const cleanup = () => {
+    if (relayClient) {
+      relayClient.destroy();
+      relayClient = null;
+    }
+  };
+  process.on("SIGTERM", cleanup);
+  process.on("SIGINT", cleanup);
 }
-function registerFilesystemTools(api) {
-  const layout = resolveGatewayLayout();
-  const DEFAULT_ALLOWED_ROOTS = Array.from(/* @__PURE__ */ new Set([
-    OPENCLAW_DIR,
-    ...layout.workspaces.map((ws) => ws.path)
-  ]));
-  const allowedRoots = api.pluginConfig?.["fs.allowedRoots"] ?? DEFAULT_ALLOWED_ROOTS;
-  api.registerTool({
-    name: "fs_read",
-    label: "Read File",
-    description: "Read a file from the server filesystem. Returns the file contents as text. Supports ~ for home directory expansion. Sensitive directories (credentials, devices, identity) are blocked. Config files are returned with auth tokens redacted.",
-    parameters: {
-      type: "object",
-      properties: {
-        path: {
-          type: "string",
-          description: "Absolute or ~-prefixed path to the file to read"
-        },
-        encoding: {
-          type: "string",
-          description: "File encoding (default: utf-8)",
-          enum: ["utf-8", "base64", "ascii", "latin1"]
-        }
-      },
-      required: ["path"]
-    },
-    async execute(_id, params) {
-      try {
-        const filePath = validateAndBlockSensitive(params.path, allowedRoots);
-        const encoding = params.encoding ?? "utf-8";
-        let content = fs4.readFileSync(filePath, encoding);
-        const stat = fs4.statSync(filePath);
-        if (isOpenclawJson(filePath) && encoding === "utf-8") {
-          content = redactOpenclawJson(content);
-        }
-        return ok({
-          path: filePath,
-          content,
-          size: stat.size,
-          modified: stat.mtime.toISOString()
-        });
-      } catch (e) {
-        const msg = e instanceof Error ? e.message : String(e);
-        return err(`fs_read failed: ${msg}`);
+function broadcastToUsers(event, payload) {
+  relayClient?.broadcastToUsers(event, payload);
+}
+
+// src/agents.ts
+import { execSync } from "child_process";
+function registerAgentMethods(api) {
+  const callGateway = async (ctx, method, params = {}) => {
+    const ctxRequest = ctx.request;
+    if (typeof ctxRequest === "function") return ctxRequest(method, params);
+    const apiRequest = api?.request;
+    if (typeof apiRequest === "function") return apiRequest(method, params);
+    const apiCallGatewayMethod = api?.callGatewayMethod;
+    if (typeof apiCallGatewayMethod === "function") return apiCallGatewayMethod(method, params);
+    throw new Error("Gateway method invocation API unavailable in plugin context");
+  };
+  api.registerGatewayMethod(
+    "squad.agents.add",
+    async ({ params, respond }) => {
+      const name = params?.name;
+      const model = params?.model;
+      if (!name || typeof name !== "string" || !name.trim()) {
+        respond(false, { error: "Missing or empty 'name' parameter" });
+        return;
+      }
+      const safeName = name.trim();
+      if (!/^[a-zA-Z0-9][a-zA-Z0-9 _-]*$/.test(safeName)) {
+        respond(false, { error: "Agent name must start with a letter/number and contain only letters, numbers, spaces, hyphens, or underscores" });
+        return;
       }
-    }
-  });
-  api.registerTool({
-    name: "fs_write",
-    label: "Write File",
-    description: "Write content to a file on the server filesystem. Creates parent directories if they don't exist. Supports ~ for home directory expansion. Writes to protected directories (credentials, devices, identity) and config files (openclaw.json) are denied.",
-    parameters: {
-      type: "object",
-      properties: {
-        path: {
-          type: "string",
-          description: "Absolute or ~-prefixed path to the file to write"
-        },
-        content: {
-          type: "string",
-          description: "Content to write to the file"
-        },
-        encoding: {
-          type: "string",
-          description: "File encoding (default: utf-8)",
-          enum: ["utf-8", "base64", "ascii", "latin1"]
-        },
-        mkdir: {
-          type: "boolean",
-          description: "Create parent directories if they don't exist (default: true)"
-        }
-      },
-      required: ["path", "content"]
-    },
-    async execute(_id, params) {
       try {
-        const filePath = validateWritePath(params.path, allowedRoots);
-        const content = params.content;
-        const encoding = params.encoding ?? "utf-8";
-        const mkdir = params.mkdir !== false;
-        if (mkdir) {
-          fs4.mkdirSync(path4.dirname(filePath), { recursive: true });
+        let cmd = `openclaw agents add ${JSON.stringify(safeName)} --non-interactive`;
+        if (model) {
+          cmd += ` --model ${JSON.stringify(model)}`;
         }
-        fs4.writeFileSync(filePath, content, encoding);
-        const stat = fs4.statSync(filePath);
-        return ok({
-          path: filePath,
-          size: stat.size,
-          written: true
+        const output = execSync(cmd, {
+          timeout: 3e4,
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        respond(true, { ok: true, output: output.slice(0, 1e3) });
+      } catch (err2) {
+        const msg = err2 instanceof Error ? err2.message : String(err2);
+        const stderr = err2?.stderr;
+        respond(false, {
+          error: `Failed to add agent: ${stderr || msg}`.slice(0, 500)
         });
-      } catch (e) {
-        const msg = e instanceof Error ? e.message : String(e);
-        return err(`fs_write failed: ${msg}`);
       }
     }
-  });
-  api.registerTool({
-    name: "fs_list",
-    label: "List Directory",
-    description: "List contents of a directory on the server filesystem. Returns file metadata including name, type, size, and modification time. Supports ~ for home directory expansion. Protected directories (credentials, devices, identity) are excluded from results.",
-    parameters: {
-      type: "object",
-      properties: {
-        path: {
-          type: "string",
-          description: "Absolute or ~-prefixed path to the directory to list"
-        },
-        recursive: {
-          type: "boolean",
-          description: "List recursively (default: false, max depth 3)"
-        },
-        includeHidden: {
-          type: "boolean",
-          description: "Include hidden files/directories starting with . (default: false)"
-        }
-      },
-      required: ["path"]
-    },
-    async execute(_id, params) {
-      try {
-        const dirPath = validateAndBlockSensitive(params.path, allowedRoots);
-        const recursive = params.recursive === true;
-        const includeHidden = params.includeHidden === true;
-        let entries = listDir(dirPath, { recursive, includeHidden, depth: 0, maxDepth: 3 });
-        entries = filterSensitiveEntries(entries);
-        return ok({
-          path: dirPath,
-          count: entries.length,
-          entries
-        });
-      } catch (e) {
-        const msg = e instanceof Error ? e.message : String(e);
-        return err(`fs_list failed: ${msg}`);
+  );
+  api.registerGatewayMethod(
+    "squad.agents.delete",
+    async ({ params, respond }) => {
+      const agentId = params?.agentId;
+      if (!agentId || typeof agentId !== "string" || !agentId.trim()) {
+        respond(false, { error: "Missing or empty 'agentId' parameter" });
+        return;
+      }
+      if (agentId === "main") {
+        respond(false, { error: "Cannot delete the main agent" });
+        return;
+      }
+      if (!/^[a-z0-9][a-z0-9-]*$/.test(agentId)) {
+        respond(false, { error: "Invalid agent ID format" });
+        return;
       }
-    }
-  });
-  api.registerTool({
-    name: "fs_mkdir",
-    label: "Create Directory",
-    description: "Create a directory on the server filesystem. Creates parent directories as needed. Supports ~ for home directory expansion. Cannot create directories inside protected paths (credentials, devices, identity).",
-    parameters: {
-      type: "object",
-      properties: {
-        path: {
-          type: "string",
-          description: "Absolute or ~-prefixed path of the directory to create"
-        }
-      },
-      required: ["path"]
-    },
-    async execute(_id, params) {
       try {
-        const targetPath = validateWritePath(params.path, allowedRoots);
-        fs4.mkdirSync(targetPath, { recursive: true });
-        return ok({
-          path: targetPath,
-          created: true
+        const output = execSync(
+          `openclaw agents delete ${JSON.stringify(agentId)} --non-interactive 2>&1`,
+          { timeout: 3e4, encoding: "utf-8" }
+        );
+        respond(true, { ok: true, output: output.slice(0, 1e3) });
+      } catch (err2) {
+        const msg = err2 instanceof Error ? err2.message : String(err2);
+        const stderr = err2?.stderr;
+        respond(false, {
+          error: `Failed to delete agent: ${stderr || msg}`.slice(0, 500)
         });
-      } catch (e) {
-        const msg = e instanceof Error ? e.message : String(e);
-        return err(`fs_mkdir failed: ${msg}`);
       }
     }
-  });
-  api.registerTool({
-    name: "fs_rename",
-    label: "Rename / Move",
-    description: "Rename or move a file or directory on the server filesystem. Supports ~ for home directory expansion. Cannot move files into or out of protected directories.",
-    parameters: {
-      type: "object",
-      properties: {
-        oldPath: {
-          type: "string",
-          description: "Current absolute or ~-prefixed path"
-        },
-        newPath: {
-          type: "string",
-          description: "New absolute or ~-prefixed path"
-        }
-      },
-      required: ["oldPath", "newPath"]
-    },
-    async execute(_id, params) {
+  );
+  api.registerGatewayMethod(
+    "squad.agents.set-identity",
+    async (ctx) => {
+      const { params, respond } = ctx;
+      const agentId = params?.agentId;
+      const name = params?.name;
+      const emoji = params?.emoji;
+      const theme = params?.theme;
+      if (!agentId || typeof agentId !== "string") {
+        respond(false, { error: "Missing 'agentId' parameter" });
+        return;
+      }
+      const identity = {};
+      const trimmedName = typeof name === "string" ? name.trim() : "";
+      const trimmedEmoji = typeof emoji === "string" ? emoji.trim() : "";
+      const trimmedTheme = typeof theme === "string" ? theme.trim() : "";
+      if (trimmedName) identity.name = trimmedName;
+      if (trimmedEmoji) identity.emoji = trimmedEmoji;
+      if (trimmedTheme) identity.theme = trimmedTheme;
+      if (Object.keys(identity).length === 0) {
+        respond(false, { error: "No identity fields provided (name, emoji, or theme)" });
+        return;
+      }
       try {
-        const resolvedOld = validateWritePath(params.oldPath, allowedRoots);
-        const resolvedNew = validateWritePath(params.newPath, allowedRoots);
-        fs4.renameSync(resolvedOld, resolvedNew);
-        return ok({
-          oldPath: resolvedOld,
-          newPath: resolvedNew,
-          renamed: true
+        const doPatch = async (baseHash) => {
+          await callGateway(ctx, "config.patch", {
+            ...baseHash ? { baseHash } : {},
+            raw: JSON.stringify({
+              agents: {
+                list: [{ id: agentId, identity }]
+              }
+            })
+          });
+        };
+        let snapshot = await callGateway(ctx, "config.get", {});
+        try {
+          await doPatch(snapshot?.hash);
+        } catch (firstErr) {
+          const msg = firstErr instanceof Error ? firstErr.message : String(firstErr);
+          if (!/config changed since last load/i.test(msg)) throw firstErr;
+          snapshot = await callGateway(ctx, "config.get", {});
+          await doPatch(snapshot?.hash);
+        }
+        respond(true, { ok: true, identity });
+      } catch (err2) {
+        const msg = err2 instanceof Error ? err2.message : String(err2);
+        respond(false, {
+          error: `Failed to set identity: ${msg}`.slice(0, 500)
         });
-      } catch (e) {
-        const msg = e instanceof Error ? e.message : String(e);
-        return err(`fs_rename failed: ${msg}`);
       }
     }
-  });
-  api.registerTool({
-    name: "fs_delete",
-    label: "Delete File or Directory",
-    description: "Delete a file or directory from the server filesystem. For directories, removes recursively. Supports ~ for home directory expansion. Cannot delete protected directories or config files.",
-    parameters: {
-      type: "object",
-      properties: {
-        path: {
-          type: "string",
-          description: "Absolute or ~-prefixed path to the file or directory to delete"
-        }
-      },
-      required: ["path"]
-    },
-    async execute(_id, params) {
+  );
+  api.registerGatewayMethod(
+    "squad.agents.patch-config",
+    async (ctx) => {
+      const { params, respond } = ctx;
+      const agentId = params?.agentId;
+      const fields = params?.fields ?? {};
+      if (!agentId || typeof agentId !== "string") {
+        respond(false, { error: "Missing 'agentId' parameter" });
+        return;
+      }
+      const allowedFieldNames = /* @__PURE__ */ new Set(["tools", "skills", "default", "model"]);
+      const filteredFields = {};
+      for (const [k, v] of Object.entries(fields)) {
+        if (allowedFieldNames.has(k) && v !== void 0) filteredFields[k] = v;
+      }
+      if (Object.keys(filteredFields).length === 0) {
+        respond(false, { error: "No patchable fields provided (tools, skills, default, model)" });
+        return;
+      }
       try {
-        const targetPath = validateWritePath(params.path, allowedRoots);
-        const stat = fs4.statSync(targetPath);
-        const wasDirectory = stat.isDirectory();
-        if (wasDirectory) {
-          fs4.rmSync(targetPath, { recursive: true });
-        } else {
-          fs4.unlinkSync(targetPath);
+        const doPatch = async (baseHash) => {
+          await callGateway(ctx, "config.patch", {
+            ...baseHash ? { baseHash } : {},
+            raw: JSON.stringify({
+              agents: {
+                list: [{ id: agentId, ...filteredFields }]
+              }
+            })
+          });
+        };
+        let snapshot = await callGateway(ctx, "config.get", {});
+        try {
+          await doPatch(snapshot?.hash);
+        } catch (firstErr) {
+          const msg = firstErr instanceof Error ? firstErr.message : String(firstErr);
+          if (!/config changed since last load/i.test(msg)) throw firstErr;
+          snapshot = await callGateway(ctx, "config.get", {});
+          await doPatch(snapshot?.hash);
         }
-        return ok({
-          path: targetPath,
-          deleted: true,
-          type: wasDirectory ? "directory" : "file"
+        respond(true, { ok: true, fields: filteredFields });
+      } catch (err2) {
+        const msg = err2 instanceof Error ? err2.message : String(err2);
+        respond(false, {
+          error: `Failed to patch agent config: ${msg}`.slice(0, 500)
         });
-      } catch (e) {
-        const msg = e instanceof Error ? e.message : String(e);
-        return err(`fs_delete failed: ${msg}`);
       }
     }
-  });
+  );
 }
 
 // src/entities.ts
-var EntityType = T.Union([
-  T.Literal("agent"),
-  T.Literal("skill"),
-  T.Literal("tool"),
-  T.Literal("plugin"),
-  T.Literal("session"),
-  T.Literal("file"),
-  T.Literal("directory"),
-  T.Literal("url"),
-  T.Literal("memory"),
-  T.Literal("asset")
-]);
-var registry = /* @__PURE__ */ new Map();
-function registrySet(entity) {
-  registry.set(entity.id, entity);
-}
-function registryDelete(id) {
-  registry.delete(id);
+import { Type as T } from "@sinclair/typebox";
+import path7 from "path";
+import fs7 from "fs";
+
+// src/watcher.ts
+import path4 from "path";
+import fs4 from "fs";
+import chokidar from "chokidar";
+var debounceTimers = /* @__PURE__ */ new Map();
+var DEBOUNCE_MS = 500;
+function debounced(key, fn) {
+  const existing = debounceTimers.get(key);
+  if (existing) clearTimeout(existing);
+  debounceTimers.set(
+    key,
+    setTimeout(() => {
+      debounceTimers.delete(key);
+      fn();
+    }, DEBOUNCE_MS)
+  );
 }
-function registryList(type) {
-  const all = Array.from(registry.values());
-  if (!type) return all;
-  return all.filter((e) => e.type === type);
+var fsDebounceTimers = /* @__PURE__ */ new Map();
+var FS_DEBOUNCE_MS = 300;
+function debouncedFs(relPath, action, fn) {
+  const key = `fs:${action}:${relPath}`;
+  const existing = fsDebounceTimers.get(key);
+  if (existing) clearTimeout(existing);
+  fsDebounceTimers.set(
+    key,
+    setTimeout(() => {
+      fsDebounceTimers.delete(key);
+      fn();
+    }, FS_DEBOUNCE_MS)
+  );
 }
-var IDENTITY_NAME_RE = /\*\*Name:\*\*\s*\n?\s*(.+?)(?=\n|$)/;
-function parseIdentityName(content) {
-  const match = content.match(IDENTITY_NAME_RE);
-  const name = match?.[1]?.trim();
-  if (!name) return null;
-  if (/^_\(.+\)_$/.test(name)) return null;
-  return name;
+function isWorkspaceIdentity(filePath, configDir) {
+  const rel = path4.relative(configDir, filePath);
+  const match = rel.match(/^(workspace(?:-([^/]+))?)\/IDENTITY\.md$/);
+  if (!match) return null;
+  const dirName = match[1];
+  const agentId = match[2] ?? "main";
+  return { agentId, workspacePath: path4.join(configDir, dirName) };
 }
-function scanAgents(configDir) {
-  const now = Date.now();
-  let entries;
+function isWorkspaceAgentJson(filePath, configDir) {
+  const rel = path4.relative(configDir, filePath);
+  const match = rel.match(/^(workspace(?:-([^/]+))?)\/agent\.json$/);
+  if (!match) return null;
+  const dirName = match[1];
+  const agentId = match[2] ?? "main";
+  return { agentId, workspacePath: path4.join(configDir, dirName) };
+}
+function isGlobalSkillDir(filePath, configDir) {
+  const rel = path4.relative(configDir, filePath);
+  const match = rel.match(/^skills\/([^/]+)\/?$/);
+  if (!match) return null;
+  return { skillKey: match[1] };
+}
+function isWorkspaceSkillDir(filePath, configDir) {
+  const rel = path4.relative(configDir, filePath);
+  const match = rel.match(
+    /^workspace(?:-([^/]+))?\/skills\/([^/]+)\/?$/
+  );
+  if (!match) return null;
+  return { agentId: match[1] ?? "main", skillKey: match[2] };
+}
+function isPluginManifest(filePath, configDir) {
+  const rel = path4.relative(configDir, filePath);
+  const match = rel.match(/^extensions\/([^/]+)\/openclaw\.plugin\.json$/);
+  if (!match) return null;
+  return { pluginDirName: match[1] };
+}
+function isOpenClawConfig(filePath, configDir) {
+  return path4.relative(configDir, filePath) === "openclaw.json";
+}
+function updateAgent(agentId, workspacePath) {
+  const now = Date.now();
+  let name = agentId;
+  const metadata = { workspacePath };
   try {
-    entries = fs5.readdirSync(configDir, { withFileTypes: true });
+    const content = fs4.readFileSync(
+      path4.join(workspacePath, "IDENTITY.md"),
+      "utf-8"
+    );
+    const parsed = parseIdentityName(content);
+    if (parsed) name = parsed;
   } catch {
-    return;
   }
-  const workspaceDirs = entries.filter(
-    (e) => e.isDirectory() && (e.name === "workspace" || e.name.startsWith("workspace-"))
-  );
-  for (const dir of workspaceDirs) {
-    const agentId = dir.name === "workspace" ? "main" : dir.name.replace("workspace-", "");
-    const workspacePath = path5.join(configDir, dir.name);
-    let name = agentId;
-    const metadata = { workspacePath };
-    const identityPath = path5.join(workspacePath, "IDENTITY.md");
+  if (name === agentId) {
     try {
-      const content = fs5.readFileSync(identityPath, "utf-8");
-      const parsed = parseIdentityName(content);
-      if (parsed) name = parsed;
+      const raw = fs4.readFileSync(
+        path4.join(workspacePath, "agent.json"),
+        "utf-8"
+      );
+      const config = JSON.parse(raw);
+      if (config.displayName) name = config.displayName;
+      if (config.model) metadata.model = config.model;
     } catch {
     }
-    if (name === agentId) {
-      const agentJsonPath = path5.join(workspacePath, "agent.json");
-      try {
-        const raw = fs5.readFileSync(agentJsonPath, "utf-8");
-        const config = JSON.parse(raw);
-        if (config.displayName) name = config.displayName;
-        if (config.model) metadata.model = config.model;
-        if (config.tools) metadata.tools = config.tools;
-        if (config.skills) metadata.skills = config.skills;
-      } catch {
-      }
-    }
+  }
+  registrySet({
+    id: agentId,
+    type: "agent",
+    name,
+    title: name,
+    description: null,
+    metadata,
+    source: "filesystem",
+    source_key: workspacePath,
+    created_at: now,
+    updated_at: now
+  });
+}
+function updatePlugin(pluginDirName, configDir) {
+  const now = Date.now();
+  const manifestPath = path4.join(
+    configDir,
+    "extensions",
+    pluginDirName,
+    "openclaw.plugin.json"
+  );
+  try {
+    const raw = fs4.readFileSync(manifestPath, "utf-8");
+    const manifest = JSON.parse(raw);
+    const pluginId = manifest.id || pluginDirName;
+    const name = manifest.name || pluginId;
     registrySet({
-      id: agentId,
-      type: "agent",
+      id: `plugin:${pluginId}`,
+      type: "plugin",
       name,
       title: name,
-      description: null,
-      metadata,
+      description: manifest.description || null,
+      metadata: { pluginId, pluginDir: path4.dirname(manifestPath) },
       source: "filesystem",
-      source_key: workspacePath,
+      source_key: manifestPath,
       created_at: now,
       updated_at: now
     });
+  } catch {
+    registryDelete(`plugin:${pluginDirName}`);
   }
 }
-function scanSkills(configDir) {
-  const now = Date.now();
-  const globalSkillsDir = path5.join(configDir, "skills");
-  scanSkillsDir(globalSkillsDir, "global", now);
+function startWatcher(configDir, onFsChange) {
+  const watcher = chokidar.watch(configDir, {
+    persistent: true,
+    usePolling: false,
+    ignoreInitial: true,
+    awaitWriteFinish: { stabilityThreshold: 300 },
+    depth: 4,
+    ignored: [
+      // Ignore heavy directories that aren't relevant
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/.git/**",
+      "**/data/**"
+    ]
+  });
+  const emitFsChange = (action, filePath) => {
+    if (!onFsChange) return;
+    const rel = path4.relative(configDir, filePath);
+    debouncedFs(rel, action, () => {
+      onFsChange({ action, path: rel });
+    });
+  };
+  const handleChange = (filePath, action) => {
+    emitFsChange(action, filePath);
+    const identity = isWorkspaceIdentity(filePath, configDir);
+    if (identity) {
+      debounced(
+        `agent:${identity.agentId}`,
+        () => updateAgent(identity.agentId, identity.workspacePath)
+      );
+      return;
+    }
+    const agentJson = isWorkspaceAgentJson(filePath, configDir);
+    if (agentJson) {
+      debounced(
+        `agent:${agentJson.agentId}`,
+        () => updateAgent(agentJson.agentId, agentJson.workspacePath)
+      );
+      return;
+    }
+    const plugin = isPluginManifest(filePath, configDir);
+    if (plugin) {
+      debounced(
+        `plugin:${plugin.pluginDirName}`,
+        () => updatePlugin(plugin.pluginDirName, configDir)
+      );
+      return;
+    }
+    if (isOpenClawConfig(filePath, configDir)) {
+      debounced("tools", () => scanTools(configDir));
+      return;
+    }
+  };
+  const handleAddDir = (dirPath) => {
+    emitFsChange("addDir", dirPath);
+    const globalSkill = isGlobalSkillDir(dirPath, configDir);
+    if (globalSkill) {
+      debounced(
+        `skill:${globalSkill.skillKey}`,
+        () => scanSkills(configDir)
+      );
+      return;
+    }
+    const wsSkill = isWorkspaceSkillDir(dirPath, configDir);
+    if (wsSkill) {
+      debounced(
+        `skill:${wsSkill.agentId}:${wsSkill.skillKey}`,
+        () => scanSkills(configDir)
+      );
+      return;
+    }
+    const rel = path4.relative(configDir, dirPath);
+    if (/^workspace(-[^/]+)?$/.test(rel)) {
+      debounced("agents", () => scanAgents(configDir));
+      return;
+    }
+  };
+  const handleUnlinkDir = (dirPath) => {
+    emitFsChange("unlinkDir", dirPath);
+    const rel = path4.relative(configDir, dirPath);
+    const wsMatch = rel.match(/^workspace(?:-([^/]+))?$/);
+    if (wsMatch) {
+      const agentId = wsMatch[1] ?? "main";
+      registryDelete(agentId);
+      return;
+    }
+    const globalSkill = isGlobalSkillDir(dirPath, configDir);
+    if (globalSkill) {
+      registryDelete(`skill:${globalSkill.skillKey}`);
+      return;
+    }
+    const wsSkill = isWorkspaceSkillDir(dirPath, configDir);
+    if (wsSkill) {
+      registryDelete(`skill:${wsSkill.agentId}:${wsSkill.skillKey}`);
+      return;
+    }
+  };
+  watcher.on("add", (fp) => handleChange(fp, "add"));
+  watcher.on("change", (fp) => handleChange(fp, "change"));
+  watcher.on("unlink", (fp) => handleChange(fp, "unlink"));
+  watcher.on("addDir", handleAddDir);
+  watcher.on("unlinkDir", handleUnlinkDir);
+  return () => {
+    for (const timer of debounceTimers.values()) {
+      clearTimeout(timer);
+    }
+    debounceTimers.clear();
+    for (const timer of fsDebounceTimers.values()) {
+      clearTimeout(timer);
+    }
+    fsDebounceTimers.clear();
+    watcher.close();
+  };
+}
+
+// src/filesystem.ts
+import fs6 from "fs";
+import path6 from "path";
+
+// src/layout.ts
+import fs5 from "fs";
+import path5 from "path";
+function resolveMaybeRelativePath(stateDir, p) {
+  if (path5.isAbsolute(p)) return path5.resolve(p);
+  return path5.resolve(stateDir, p);
+}
+function listWorkspaceFallbacks(stateDir) {
   let entries;
   try {
-    entries = fs5.readdirSync(configDir, { withFileTypes: true });
+    entries = fs5.readdirSync(stateDir, { withFileTypes: true });
   } catch {
-    return;
-  }
-  for (const dir of entries) {
-    if (!dir.isDirectory() || !(dir.name === "workspace" || dir.name.startsWith("workspace-"))) {
-      continue;
-    }
-    const agentId = dir.name === "workspace" ? "main" : dir.name.replace("workspace-", "");
-    const agentSkillsDir = path5.join(configDir, dir.name, "skills");
-    scanSkillsDir(agentSkillsDir, agentId, now);
+    return [];
   }
+  return entries.filter((entry) => entry.isDirectory() && (entry.name === "workspace" || entry.name.startsWith("workspace-"))).map((entry) => {
+    const agentId = entry.name === "workspace" ? "main" : entry.name.replace("workspace-", "");
+    const workspacePath = path5.join(stateDir, entry.name);
+    return {
+      agentId,
+      path: workspacePath,
+      source: "filesystem",
+      exists: true
+    };
+  });
 }
-function scanSkillsDir(skillsDir, scope, now) {
-  let entries;
+function readOpenclawConfig(configPath) {
   try {
-    entries = fs5.readdirSync(skillsDir, { withFileTypes: true });
+    const raw = fs5.readFileSync(configPath, "utf-8");
+    return JSON.parse(raw);
   } catch {
-    return;
+    return null;
   }
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    const skillKey = entry.name;
-    const skillPath = path5.join(skillsDir, skillKey);
-    let name = skillKey;
-    for (const manifestName of ["manifest.json", "package.json"]) {
-      try {
-        const raw = fs5.readFileSync(
-          path5.join(skillPath, manifestName),
-          "utf-8"
-        );
-        const manifest = JSON.parse(raw);
-        if (manifest.name) name = manifest.name;
-        break;
-      } catch {
-        continue;
-      }
+}
+function resolveGatewayLayout() {
+  const stateDir = getOpenclawStateDir();
+  const configPath = path5.join(stateDir, "openclaw.json");
+  const config = readOpenclawConfig(configPath);
+  const workspaces = [];
+  if (config?.agents?.main?.workspace || config?.agents?.main?.workspacePath) {
+    const rawPath = config.agents.main.workspace ?? config.agents.main.workspacePath;
+    if (rawPath) {
+      const resolvedPath = resolveMaybeRelativePath(stateDir, rawPath);
+      workspaces.push({
+        agentId: "main",
+        path: resolvedPath,
+        source: "config",
+        exists: fs5.existsSync(resolvedPath)
+      });
     }
-    const entityId = scope === "global" ? `skill:${skillKey}` : `skill:${scope}:${skillKey}`;
-    registrySet({
-      id: entityId,
-      type: "skill",
-      name,
-      title: name,
-      description: null,
-      metadata: { skillKey, scope, skillPath },
-      source: "filesystem",
-      source_key: skillPath,
-      created_at: now,
-      updated_at: now
-    });
   }
-}
-function scanPlugins2(configDir) {
-  const now = Date.now();
-  const extensionsDir = path5.join(configDir, "extensions");
-  let entries;
-  try {
-    entries = fs5.readdirSync(extensionsDir, { withFileTypes: true });
-  } catch {
-    return;
+  for (const agent of config?.agents?.list ?? []) {
+    const agentId = typeof agent.id === "string" && agent.id.trim() ? agent.id : null;
+    const rawPath = agent.workspace ?? agent.workspacePath;
+    if (!agentId || !rawPath) continue;
+    const resolvedPath = resolveMaybeRelativePath(stateDir, rawPath);
+    workspaces.push({
+      agentId,
+      path: resolvedPath,
+      source: "config",
+      exists: fs5.existsSync(resolvedPath)
+    });
   }
-  for (const dir of entries) {
-    if (!dir.isDirectory()) continue;
-    const pluginDir = path5.join(extensionsDir, dir.name);
-    const manifestPath = path5.join(pluginDir, "openclaw.plugin.json");
-    try {
-      const raw = fs5.readFileSync(manifestPath, "utf-8");
-      const manifest = JSON.parse(raw);
-      const pluginId = manifest.id || dir.name;
-      const name = manifest.name || pluginId;
-      registrySet({
-        id: `plugin:${pluginId}`,
-        type: "plugin",
-        name,
-        title: name,
-        description: manifest.description || null,
-        metadata: { pluginId, pluginDir },
-        source: "filesystem",
-        source_key: manifestPath,
-        created_at: now,
-        updated_at: now
-      });
-    } catch {
+  const deduped = /* @__PURE__ */ new Map();
+  for (const ws of [...workspaces, ...listWorkspaceFallbacks(stateDir)]) {
+    if (!deduped.has(ws.agentId)) {
+      deduped.set(ws.agentId, ws);
     }
   }
+  const resolvedWorkspaces = Array.from(deduped.values());
+  const mainWorkspace = resolvedWorkspaces.find((ws) => ws.agentId === "main");
+  const defaultFileBrowserRoot = mainWorkspace?.path ?? stateDir;
+  return {
+    stateDir,
+    configPath,
+    mediaDir: path5.join(stateDir, "media"),
+    skillsDir: path5.join(stateDir, "skills"),
+    extensionsDir: path5.join(stateDir, "extensions"),
+    defaultFileBrowserRoot,
+    workspaces: resolvedWorkspaces
+  };
 }
-function scanTools(configDir) {
-  const now = Date.now();
-  try {
-    const raw = fs5.readFileSync(
-      path5.join(configDir, "openclaw.json"),
-      "utf-8"
-    );
-    const config = JSON.parse(raw);
-    const allowedTools = config?.tools?.allow ?? [];
-    for (const toolName of allowedTools) {
-      registrySet({
-        id: `tool:${toolName}`,
-        type: "tool",
-        name: toolName,
-        title: toolName,
-        description: null,
-        metadata: { tool_name: toolName },
-        source: "filesystem",
-        source_key: "openclaw.json:tools.allow",
-        created_at: now,
-        updated_at: now
-      });
+
+// src/filesystem.ts
+var HOME_DIR = process.env.HOME ?? "/root";
+var OPENCLAW_DIR = getOpenclawStateDir();
+var SENSITIVE_BLOCKED_DIRS = [
+  path6.join(OPENCLAW_DIR, "credentials"),
+  path6.join(OPENCLAW_DIR, "devices"),
+  path6.join(OPENCLAW_DIR, "identity")
+];
+var SENSITIVE_BLOCKED_FILES = [
+  path6.join(OPENCLAW_DIR, "squad-ceo-data", "relay", "squad-relay.json")
+];
+function isSensitivePath(resolvedPath) {
+  for (const blocked of SENSITIVE_BLOCKED_DIRS) {
+    if (resolvedPath === blocked || resolvedPath.startsWith(blocked + path6.sep)) {
+      return true;
     }
-  } catch {
   }
+  for (const blocked of SENSITIVE_BLOCKED_FILES) {
+    if (resolvedPath === blocked) {
+      return true;
+    }
+  }
+  if (path6.dirname(resolvedPath) === OPENCLAW_DIR && resolvedPath.endsWith(".bak")) {
+    return true;
+  }
+  return false;
 }
-var MIME_MAP = {
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gif": "image/gif",
-  ".webp": "image/webp",
-  ".svg": "image/svg+xml",
-  ".bmp": "image/bmp",
-  ".ico": "image/x-icon",
-  ".mp4": "video/mp4",
-  ".webm": "video/webm",
-  ".mov": "video/quicktime",
-  ".avi": "video/x-msvideo",
-  ".mkv": "video/x-matroska",
-  ".mp3": "audio/mpeg",
-  ".wav": "audio/wav",
-  ".ogg": "audio/ogg",
-  ".flac": "audio/flac",
-  ".aac": "audio/aac",
-  ".pdf": "application/pdf",
-  ".json": "application/json",
-  ".txt": "text/plain",
-  ".md": "text/markdown",
-  ".csv": "text/csv",
-  ".zip": "application/zip",
-  ".tar": "application/x-tar",
-  ".gz": "application/gzip"
-};
-function getMimeType(filename) {
-  const ext = path5.extname(filename).toLowerCase();
-  return MIME_MAP[ext] ?? "application/octet-stream";
-}
-function scanMedia(configDir) {
-  const now = Date.now();
-  const mediaDir = path5.join(configDir, "media");
-  scanMediaDir(mediaDir, now);
-}
-function scanMediaDir(dirPath, now) {
-  let entries;
+var OPENCLAW_JSON_FILENAME = "openclaw.json";
+function redactOpenclawJson(rawContent) {
+  let config;
   try {
-    entries = fs5.readdirSync(dirPath, { withFileTypes: true });
+    config = JSON.parse(rawContent);
   } catch {
-    return;
+    return rawContent;
   }
-  for (const entry of entries) {
-    if (entry.name.startsWith(".")) continue;
-    const entryPath = path5.join(dirPath, entry.name);
-    if (isSensitivePath(entryPath)) continue;
-    if (entry.isDirectory()) {
-      registrySet({
-        id: entryPath,
-        type: "directory",
-        name: entry.name,
-        title: entry.name,
-        description: null,
-        metadata: { path: entryPath },
-        source: "filesystem",
-        source_key: entryPath,
-        created_at: now,
-        updated_at: now
-      });
-      scanMediaDir(entryPath, now);
-    } else if (entry.isFile()) {
-      const mimeType = getMimeType(entry.name);
-      let size;
-      let mtime = now;
-      try {
-        const stat = fs5.statSync(entryPath);
-        size = stat.size;
-        mtime = stat.mtimeMs;
-      } catch {
+  let redactedCount = 0;
+  const channels = config.channels;
+  if (channels && typeof channels === "object") {
+    for (const channelKey of Object.keys(channels)) {
+      const channel = channels[channelKey];
+      if (channel && typeof channel === "object" && "botToken" in channel) {
+        channel.botToken = "[REDACTED]";
+        redactedCount++;
       }
-      registrySet({
-        id: entryPath,
-        type: "asset",
-        name: entry.name,
-        title: entry.name,
-        description: null,
-        metadata: { path: entryPath, size, mime_type: mimeType, original_name: entry.name },
-        source: "filesystem",
-        source_key: entryPath,
-        created_at: mtime,
-        updated_at: mtime
-      });
     }
   }
+  const gateway = config.gateway;
+  if (gateway && typeof gateway === "object") {
+    if (gateway.auth && typeof gateway.auth === "object") {
+      const auth = gateway.auth;
+      for (const key of Object.keys(auth)) {
+        auth[key] = "[REDACTED]";
+        redactedCount++;
+      }
+    }
+    if ("token" in gateway) {
+      gateway.token = "[REDACTED]";
+      redactedCount++;
+    }
+    const remote = gateway.remote;
+    if (remote && typeof remote === "object" && "token" in remote) {
+      remote.token = "[REDACTED]";
+      redactedCount++;
+    }
+  }
+  if (redactedCount > 0) {
+    console.log(`[security] Redacted ${redactedCount} sensitive field(s) from openclaw.json before returning to client`);
+  }
+  return JSON.stringify(config, null, 2);
 }
-function fullScan(configDir) {
-  registry.clear();
-  scanAgents(configDir);
-  scanSkills(configDir);
-  scanPlugins2(configDir);
-  scanTools(configDir);
-  scanMedia(configDir);
+function isOpenclawJson(resolvedPath) {
+  return path6.basename(resolvedPath) === OPENCLAW_JSON_FILENAME && resolvedPath.startsWith(OPENCLAW_DIR);
 }
-function registerEntityTools(api, onFsChange) {
-  const configDir = getOpenclawStateDir();
-  api.registerTool({
-    name: "entity_list",
-    description: "List all entities in the registry, optionally filtered by type. Returns lightweight entity data for @mention autocomplete.",
-    parameters: T.Object({
-      type: T.Optional(EntityType),
-      limit: T.Optional(
-        T.Number({ description: "Max results (default 500)" })
-      )
-    }),
-    async execute(_id, params, _ctx) {
-      const results = registryList(params.type);
-      const limit = params.limit ?? 500;
-      return {
-        content: [
-          { type: "text", text: JSON.stringify(results.slice(0, limit)) }
-        ]
-      };
-    }
-  });
-  api.registerTool({
-    name: "entity_search",
-    description: "Search entities by name/title substring match for @mention autocomplete.",
-    parameters: T.Object({
-      query: T.String({ description: "Search query text" }),
-      type: T.Optional(
-        T.String({ description: "Filter results by entity type" })
-      ),
-      limit: T.Optional(
-        T.Number({ description: "Max results (default 20)" })
-      )
-    }),
-    async execute(_id, params, _ctx) {
-      const q = (params.query ?? "").toLowerCase();
-      const limit = params.limit ?? 20;
-      let results = Array.from(registry.values());
-      if (params.type) {
-        results = results.filter((e) => e.type === params.type);
-      }
-      if (q) {
-        results = results.filter(
-          (e) => e.name.toLowerCase().includes(q) || (e.title ?? "").toLowerCase().includes(q)
-        );
-      }
-      return {
-        content: [
-          { type: "text", text: JSON.stringify(results.slice(0, limit)) }
-        ]
-      };
-    }
-  });
-  api.registerTool({
-    name: "entity_sync",
-    description: "Re-scan the filesystem to refresh the entity registry. Call after configuration changes for immediate updates.",
-    parameters: T.Object({}),
-    async execute(_id, _params, _ctx) {
-      const before = registry.size;
-      fullScan(configDir);
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify({ synced: registry.size, previous: before })
-          }
-        ]
-      };
-    }
-  });
-  try {
-    fullScan(configDir);
-  } catch (err2) {
-    console.error("[squad-openclaw] Initial scan failed:", err2);
+function expandHome(p) {
+  if (p.startsWith("~/") || p === "~") {
+    return path6.join(HOME_DIR, p.slice(1));
   }
-  let stopWatcher = null;
-  try {
-    stopWatcher = startWatcher(configDir, onFsChange);
-  } catch (err2) {
-    console.error("[squad-openclaw] Watcher failed to start:", err2);
+  return p;
+}
+function validatePath(p, allowedRoots) {
+  const resolved = path6.resolve(expandHome(p));
+  if (!allowedRoots || allowedRoots.length === 0) return resolved;
+  const allowed = allowedRoots.some((root) => {
+    const resolvedRoot = path6.resolve(expandHome(root));
+    return resolved === resolvedRoot || resolved.startsWith(resolvedRoot + path6.sep);
+  });
+  if (!allowed) {
+    throw new Error(`Path "${p}" is outside allowed roots`);
   }
-  const cleanup = () => {
-    stopWatcher?.();
-  };
-  process.on("SIGTERM", cleanup);
-  process.on("SIGINT", cleanup);
+  return resolved;
 }
-
-// src/sql.ts
-import { execFile } from "child_process";
-import path6 from "path";
-import fs6 from "fs";
-import { Type as T2 } from "@sinclair/typebox";
-var HOME_DIR2 = process.env.HOME ?? "/root";
-var ALLOWED_DATA_DIR = path6.join(getOpenclawStateDir(), "squad-ceo-data");
-function validateDbPath(dbPath) {
-  let expanded = dbPath;
-  if (expanded.startsWith("~/") || expanded === "~") {
-    expanded = path6.join(HOME_DIR2, expanded.slice(1));
+function validateAndBlockSensitive(p, allowedRoots) {
+  const resolved = validatePath(p, allowedRoots);
+  if (isSensitivePath(resolved)) {
+    throw new Error(
+      `Access denied: path "${p}" is inside a protected directory (credentials/devices/identity)`
+    );
   }
-  const resolved = path6.resolve(expanded);
-  if (resolved !== ALLOWED_DATA_DIR && !resolved.startsWith(ALLOWED_DATA_DIR + path6.sep)) {
+  return resolved;
+}
+function validateWritePath(p, allowedRoots) {
+  const resolved = validateAndBlockSensitive(p, allowedRoots);
+  if (isOpenclawJson(resolved)) {
     throw new Error(
-      `Access denied: database path must be within ~/.openclaw/squad-ceo-data/`
+      `Write denied: "${p}" is a protected configuration file (openclaw.json)`
     );
   }
-  try {
-    const stat = fs6.statSync(resolved);
-    if (!stat.isFile()) {
-      throw new Error(`Not a file: ${dbPath}`);
+  return resolved;
+}
+function ok(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data) }]
+  };
+}
+function err(message) {
+  return {
+    content: [{ type: "text", text: JSON.stringify({ error: message }) }],
+    isError: true
+  };
+}
+function listDir(dirPath, opts) {
+  const dirents = fs6.readdirSync(dirPath, { withFileTypes: true });
+  const results = [];
+  for (const dirent of dirents) {
+    if (!opts.includeHidden && dirent.name.startsWith(".")) continue;
+    const entryPath = path6.join(dirPath, dirent.name);
+    let type = "other";
+    if (dirent.isFile()) type = "file";
+    else if (dirent.isDirectory()) type = "directory";
+    else if (dirent.isSymbolicLink()) type = "symlink";
+    const entry = { name: dirent.name, path: entryPath, type };
+    try {
+      const stat = fs6.statSync(entryPath);
+      entry.size = stat.size;
+      entry.modified = stat.mtime.toISOString();
+    } catch {
     }
-  } catch (e) {
-    if (e.code === "ENOENT") {
-      throw new Error(`Database file not found: ${dbPath}`);
+    if (type === "directory" && opts.recursive && opts.depth < opts.maxDepth) {
+      try {
+        entry.children = listDir(entryPath, { ...opts, depth: opts.depth + 1 });
+      } catch {
+      }
     }
-    throw e;
+    results.push(entry);
   }
-  return resolved;
+  return results;
 }
-function runSqlite3(dbPath, args) {
-  return new Promise((resolve, reject) => {
-    execFile(
-      "sqlite3",
-      [dbPath, ...args],
-      { timeout: 3e4, maxBuffer: 10 * 1024 * 1024 },
-      (error, stdout, stderr) => {
-        if (error) {
-          reject(new Error(stderr || error.message));
-          return;
-        }
-        resolve(stdout);
-      }
-    );
+function filterSensitiveEntries(entries) {
+  return entries.filter((entry) => !isSensitivePath(entry.path)).map((entry) => {
+    if (entry.children) {
+      return { ...entry, children: filterSensitiveEntries(entry.children) };
+    }
+    return entry;
   });
 }
-function registerSqlTools(api) {
+function registerFilesystemTools(api) {
+  const layout = resolveGatewayLayout();
+  const DEFAULT_ALLOWED_ROOTS = Array.from(/* @__PURE__ */ new Set([
+    OPENCLAW_DIR,
+    ...layout.workspaces.map((ws) => ws.path)
+  ]));
+  const allowedRoots = api.pluginConfig?.["fs.allowedRoots"] ?? DEFAULT_ALLOWED_ROOTS;
   api.registerTool({
-    name: "sql_query",
-    label: "SQL Query",
-    description: "Execute a sqlite3 query on a database file within ~/.openclaw/squad-ceo-data/. Only sqlite3 is allowed \u2014 no arbitrary shell commands. Use jsonOutput: true for structured JSON results.",
-    parameters: T2.Object({
-      dbPath: T2.String({
-        description: "Path to the SQLite database file (must be within ~/.openclaw/squad-ceo-data/)"
-      }),
-      query: T2.String({ description: "SQL query to execute" }),
-      jsonOutput: T2.Optional(
-        T2.Boolean({
-          description: "Return results as JSON (sqlite3 -json flag)"
-        })
-      )
-    }),
+    name: "fs_read",
+    label: "Read File",
+    description: "Read a file from the server filesystem. Returns the file contents as text. Supports ~ for home directory expansion. Sensitive directories (credentials, devices, identity) are blocked. Config files are returned with auth tokens redacted.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Absolute or ~-prefixed path to the file to read"
+        },
+        encoding: {
+          type: "string",
+          description: "File encoding (default: utf-8)",
+          enum: ["utf-8", "base64", "ascii", "latin1"]
+        }
+      },
+      required: ["path"]
+    },
     async execute(_id, params) {
       try {
-        const resolvedDb = validateDbPath(params.dbPath);
-        const args = [];
-        if (params.jsonOutput) args.push("-json");
-        args.push(params.query);
-        const output = await runSqlite3(resolvedDb, args);
-        return {
-          content: [{ type: "text", text: output }]
-        };
+        const filePath = validateAndBlockSensitive(params.path, allowedRoots);
+        const encoding = params.encoding ?? "utf-8";
+        let content = fs6.readFileSync(filePath, encoding);
+        const stat = fs6.statSync(filePath);
+        if (isOpenclawJson(filePath) && encoding === "utf-8") {
+          content = redactOpenclawJson(content);
+        }
+        return ok({
+          path: filePath,
+          content,
+          size: stat.size,
+          modified: stat.mtime.toISOString()
+        });
       } catch (e) {
         const msg = e instanceof Error ? e.message : String(e);
-        return {
-          content: [{ type: "text", text: JSON.stringify({ error: msg }) }],
-          isError: true
-        };
+        return err(`fs_read failed: ${msg}`);
       }
     }
   });
-}
-
-// src/version.ts
-import { execSync as execSync2 } from "child_process";
-import fs7 from "fs";
-import path7 from "path";
-import { fileURLToPath } from "url";
-var PACKAGE_NAME = "squad-openclaw";
-var CONFIG_PATH = path7.join(getOpenclawStateDir(), "openclaw.json");
-var updateInProgress = false;
-var VERIFY_TIMEOUT_MS = 2e4;
-var VERIFY_INTERVAL_MS = 500;
-var RESTART_BUFFER_MS = 5e3;
-function readInstalledVersionFromConfig() {
-  try {
-    const raw = fs7.readFileSync(CONFIG_PATH, "utf-8");
-    const cfg = JSON.parse(raw);
-    const v = cfg?.plugins?.installs?.[PACKAGE_NAME]?.version;
-    return typeof v === "string" ? v : null;
-  } catch {
-    return null;
-  }
-}
-function reconcileInstallMetadata(verification) {
-  if (!verification.installPath || !verification.packageVersion) return;
-  try {
-    const raw = fs7.readFileSync(CONFIG_PATH, "utf-8");
-    const config = JSON.parse(raw);
-    if (!config.plugins || typeof config.plugins !== "object") config.plugins = {};
-    if (!config.plugins.installs || typeof config.plugins.installs !== "object") {
-      config.plugins.installs = {};
-    }
-    if (!config.plugins.entries || typeof config.plugins.entries !== "object") {
-      config.plugins.entries = {};
-    }
-    const current = config.plugins.installs[PACKAGE_NAME] ?? {};
-    config.plugins.installs[PACKAGE_NAME] = {
-      ...current,
-      source: "npm",
-      spec: PACKAGE_NAME,
-      installPath: verification.installPath,
-      version: verification.packageVersion,
-      installedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    const entry = config.plugins.entries[PACKAGE_NAME] ?? {};
-    config.plugins.entries[PACKAGE_NAME] = {
-      ...entry,
-      enabled: true
-    };
-    fs7.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), "utf-8");
-  } catch {
-  }
-}
-function getCurrentVersion() {
-  const thisFile = fileURLToPath(import.meta.url);
-  const pkgPath = path7.resolve(path7.dirname(thisFile), "..", "package.json");
-  try {
-    const pkg = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
-    return pkg.version ?? "0.0.0";
-  } catch {
-    return "0.0.0";
-  }
-}
-async function fetchLatestVersion() {
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), 1e4);
-  try {
-    const res = await fetch(`https://registry.npmjs.org/${PACKAGE_NAME}`, {
-      signal: controller.signal
-    });
-    if (!res.ok) throw new Error(`npm registry returned ${res.status}`);
-    const data = await res.json();
-    return data["dist-tags"]?.latest ?? "0.0.0";
-  } finally {
-    clearTimeout(timeout);
-  }
-}
-function runDoctorFixSilently() {
-  try {
-    execSync2("openclaw doctor --fix 2>/dev/null || true", {
-      timeout: 3e4,
-      encoding: "utf-8"
-    });
-  } catch {
-  }
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function compareVersions(a, b) {
-  const pa = a.split(".").map((x) => Number(x) || 0);
-  const pb = b.split(".").map((x) => Number(x) || 0);
-  const len = Math.max(pa.length, pb.length);
-  for (let i = 0; i < len; i++) {
-    const d = (pa[i] ?? 0) - (pb[i] ?? 0);
-    if (d !== 0) return d;
-  }
-  return 0;
-}
-function verifyInstalledPluginState() {
-  let configRaw;
-  try {
-    configRaw = fs7.readFileSync(CONFIG_PATH, "utf-8");
-  } catch (err2) {
-    const msg = err2 instanceof Error ? err2.message : String(err2);
-    return {
-      ok: false,
-      reason: `Could not read openclaw.json: ${msg}`,
-      installPath: null,
-      configVersion: null,
-      packageVersion: null,
-      requiredFilesMissing: []
-    };
-  }
-  let config;
-  try {
-    config = JSON.parse(configRaw);
-  } catch (err2) {
-    const msg = err2 instanceof Error ? err2.message : String(err2);
-    return {
-      ok: false,
-      reason: `Could not parse openclaw.json: ${msg}`,
-      installPath: null,
-      configVersion: null,
-      packageVersion: null,
-      requiredFilesMissing: []
-    };
-  }
-  const installMeta = config?.plugins?.installs?.[PACKAGE_NAME];
-  const installPath = typeof installMeta?.installPath === "string" ? installMeta.installPath : null;
-  const configVersion = typeof installMeta?.version === "string" ? installMeta.version : null;
-  if (!installPath) {
-    return {
-      ok: false,
-      reason: "Missing plugins.installs entry or installPath for squad-openclaw",
-      installPath: null,
-      configVersion,
-      packageVersion: null,
-      requiredFilesMissing: []
-    };
-  }
-  const requiredFiles = [
-    path7.join(installPath, "package.json"),
-    path7.join(installPath, "openclaw.plugin.json"),
-    path7.join(installPath, "dist", "index.js")
-  ];
-  const requiredFilesMissing = requiredFiles.filter((p) => !fs7.existsSync(p));
-  if (requiredFilesMissing.length > 0) {
-    return {
-      ok: false,
-      reason: "Missing required installed plugin files",
-      installPath,
-      configVersion,
-      packageVersion: null,
-      requiredFilesMissing
-    };
-  }
-  let installedPackage;
-  try {
-    installedPackage = JSON.parse(
-      fs7.readFileSync(path7.join(installPath, "package.json"), "utf-8")
-    );
-  } catch (err2) {
-    const msg = err2 instanceof Error ? err2.message : String(err2);
-    return {
-      ok: false,
-      reason: `Could not parse installed package.json: ${msg}`,
-      installPath,
-      configVersion,
-      packageVersion: null,
-      requiredFilesMissing: []
-    };
-  }
-  try {
-    JSON.parse(
-      fs7.readFileSync(path7.join(installPath, "openclaw.plugin.json"), "utf-8")
-    );
-  } catch (err2) {
-    const msg = err2 instanceof Error ? err2.message : String(err2);
-    return {
-      ok: false,
-      reason: `Could not parse installed openclaw.plugin.json: ${msg}`,
-      installPath,
-      configVersion,
-      packageVersion: null,
-      requiredFilesMissing: []
-    };
-  }
-  const packageVersion = typeof installedPackage?.version === "string" ? installedPackage.version : null;
-  if (!packageVersion) {
-    return {
-      ok: false,
-      reason: "Installed package.json missing version",
-      installPath,
-      configVersion,
-      packageVersion,
-      requiredFilesMissing: []
-    };
-  }
-  return {
-    ok: true,
-    installPath,
-    configVersion,
-    packageVersion,
-    requiredFilesMissing: []
-  };
-}
-async function waitForVerifiedInstall() {
-  const deadline = Date.now() + VERIFY_TIMEOUT_MS;
-  let last = verifyInstalledPluginState();
-  while (!last.ok && Date.now() < deadline) {
-    await sleep(VERIFY_INTERVAL_MS);
-    last = verifyInstalledPluginState();
-  }
-  return last;
-}
-function registerVersionMethods(api) {
-  api.registerGatewayMethod(
-    "squad.version.check",
-    async ({ respond }) => {
+  api.registerTool({
+    name: "fs_write",
+    label: "Write File",
+    description: "Write content to a file on the server filesystem. Creates parent directories if they don't exist. Supports ~ for home directory expansion. Writes to protected directories (credentials, devices, identity) and config files (openclaw.json) are denied.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Absolute or ~-prefixed path to the file to write"
+        },
+        content: {
+          type: "string",
+          description: "Content to write to the file"
+        },
+        encoding: {
+          type: "string",
+          description: "File encoding (default: utf-8)",
+          enum: ["utf-8", "base64", "ascii", "latin1"]
+        },
+        mkdir: {
+          type: "boolean",
+          description: "Create parent directories if they don't exist (default: true)"
+        }
+      },
+      required: ["path", "content"]
+    },
+    async execute(_id, params) {
       try {
-        const current = getCurrentVersion();
-        let latest;
-        try {
-          latest = await fetchLatestVersion();
-        } catch {
-          respond(true, {
-            current,
-            latest: null,
-            updateAvailable: false,
-            registryError: "Could not reach npm registry"
-          });
-          return;
+        const filePath = validateWritePath(params.path, allowedRoots);
+        const content = params.content;
+        const encoding = params.encoding ?? "utf-8";
+        const mkdir = params.mkdir !== false;
+        if (mkdir) {
+          fs6.mkdirSync(path6.dirname(filePath), { recursive: true });
         }
-        respond(true, {
-          current,
-          latest,
-          updateAvailable: latest !== current && latest !== "0.0.0"
+        fs6.writeFileSync(filePath, content, encoding);
+        const stat = fs6.statSync(filePath);
+        return ok({
+          path: filePath,
+          size: stat.size,
+          written: true
         });
       } catch (e) {
         const msg = e instanceof Error ? e.message : String(e);
-        respond(false, { error: msg });
+        return err(`fs_write failed: ${msg}`);
       }
     }
-  );
-  api.registerGatewayMethod(
-    "squad.version.update",
-    async ({ respond }) => {
-      if (updateInProgress) {
-        respond(false, { error: "Update already in progress" });
-        return;
-      }
-      updateInProgress = true;
-      try {
-        const before = getCurrentVersion();
-        const beforeInstalledVersion = readInstalledVersionFromConfig();
-        let latestVersion = null;
-        try {
-          latestVersion = await fetchLatestVersion();
-        } catch {
-          latestVersion = null;
-        }
-        let updateOutput = "";
-        let configBackup = null;
-        try {
-          configBackup = fs7.readFileSync(CONFIG_PATH, "utf-8");
-        } catch {
-        }
-        runDoctorFixSilently();
-        try {
-          updateOutput = execSync2(
-            `openclaw plugins update ${PACKAGE_NAME} 2>&1`,
-            { timeout: 12e4, encoding: "utf-8" }
-          );
-        } catch (firstErr) {
-          runDoctorFixSilently();
-          try {
-            updateOutput = execSync2(
-              `openclaw plugins update ${PACKAGE_NAME} 2>&1`,
-              { timeout: 12e4, encoding: "utf-8" }
-            );
-          } catch (installErr) {
-            if (configBackup) {
-              try {
-                fs7.writeFileSync(CONFIG_PATH, configBackup, "utf-8");
-              } catch {
-              }
-            }
-            const firstMsg = firstErr instanceof Error ? firstErr.message : String(firstErr);
-            const retryMsg = installErr instanceof Error ? installErr.message : String(installErr);
-            respond(false, {
-              error: `Update failed after doctor fix retry: ${retryMsg}`,
-              output: updateOutput,
-              firstError: firstMsg
-            });
-            return;
-          }
+  });
+  api.registerTool({
+    name: "fs_list",
+    label: "List Directory",
+    description: "List contents of a directory on the server filesystem. Returns file metadata including name, type, size, and modification time. Supports ~ for home directory expansion. Protected directories (credentials, devices, identity) are excluded from results.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Absolute or ~-prefixed path to the directory to list"
+        },
+        recursive: {
+          type: "boolean",
+          description: "List recursively (default: false, max depth 3)"
+        },
+        includeHidden: {
+          type: "boolean",
+          description: "Include hidden files/directories starting with . (default: false)"
         }
-        const verification = await waitForVerifiedInstall();
-        if (!verification.ok) {
-          if (configBackup) {
-            try {
-              fs7.writeFileSync(CONFIG_PATH, configBackup, "utf-8");
-            } catch {
-            }
-          }
-          respond(false, {
-            error: `Update verification failed: ${verification.reason ?? "unknown error"}`,
-            output: updateOutput.slice(0, 500),
-            verification
-          });
-          return;
+      },
+      required: ["path"]
+    },
+    async execute(_id, params) {
+      try {
+        const dirPath = validateAndBlockSensitive(params.path, allowedRoots);
+        const recursive = params.recursive === true;
+        const includeHidden = params.includeHidden === true;
+        let entries = listDir(dirPath, { recursive, includeHidden, depth: 0, maxDepth: 3 });
+        entries = filterSensitiveEntries(entries);
+        return ok({
+          path: dirPath,
+          count: entries.length,
+          entries
+        });
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return err(`fs_list failed: ${msg}`);
+      }
+    }
+  });
+  api.registerTool({
+    name: "fs_mkdir",
+    label: "Create Directory",
+    description: "Create a directory on the server filesystem. Creates parent directories as needed. Supports ~ for home directory expansion. Cannot create directories inside protected paths (credentials, devices, identity).",
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Absolute or ~-prefixed path of the directory to create"
         }
-        reconcileInstallMetadata(verification);
-        const verificationAfterReconcile = verifyInstalledPluginState();
-        if (beforeInstalledVersion && verificationAfterReconcile.packageVersion && beforeInstalledVersion === verificationAfterReconcile.packageVersion) {
-          const alreadyLatest = !!latestVersion && compareVersions(verificationAfterReconcile.packageVersion, latestVersion) >= 0;
-          respond(false, {
-            error: alreadyLatest ? `Already at latest version (${verificationAfterReconcile.packageVersion}).` : `Update command completed but installed version did not change (${verificationAfterReconcile.packageVersion}).`,
-            output: updateOutput.slice(0, 500),
-            verification: verificationAfterReconcile,
-            latestVersion
-          });
-          return;
+      },
+      required: ["path"]
+    },
+    async execute(_id, params) {
+      try {
+        const targetPath = validateWritePath(params.path, allowedRoots);
+        fs6.mkdirSync(targetPath, { recursive: true });
+        return ok({
+          path: targetPath,
+          created: true
+        });
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return err(`fs_mkdir failed: ${msg}`);
+      }
+    }
+  });
+  api.registerTool({
+    name: "fs_rename",
+    label: "Rename / Move",
+    description: "Rename or move a file or directory on the server filesystem. Supports ~ for home directory expansion. Cannot move files into or out of protected directories.",
+    parameters: {
+      type: "object",
+      properties: {
+        oldPath: {
+          type: "string",
+          description: "Current absolute or ~-prefixed path"
+        },
+        newPath: {
+          type: "string",
+          description: "New absolute or ~-prefixed path"
         }
-        const after = getCurrentVersion();
-        respond(true, {
-          previousVersion: before,
-          currentVersion: after,
-          updated: true,
-          restartRequired: true,
-          restartInMs: RESTART_BUFFER_MS,
-          verification: verificationAfterReconcile,
-          latestVersion,
-          output: updateOutput.slice(0, 500)
+      },
+      required: ["oldPath", "newPath"]
+    },
+    async execute(_id, params) {
+      try {
+        const resolvedOld = validateWritePath(params.oldPath, allowedRoots);
+        const resolvedNew = validateWritePath(params.newPath, allowedRoots);
+        fs6.renameSync(resolvedOld, resolvedNew);
+        return ok({
+          oldPath: resolvedOld,
+          newPath: resolvedNew,
+          renamed: true
         });
-        await sleep(RESTART_BUFFER_MS);
-        console.log(
-          `[version] Plugin update verified (was ${before}), restarting gateway...`
-        );
-        try {
-          execSync2("openclaw gateway restart 2>&1", {
-            timeout: 3e4,
-            encoding: "utf-8"
-          });
-        } catch {
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return err(`fs_rename failed: ${msg}`);
+      }
+    }
+  });
+  api.registerTool({
+    name: "fs_delete",
+    label: "Delete File or Directory",
+    description: "Delete a file or directory from the server filesystem. For directories, removes recursively. Supports ~ for home directory expansion. Cannot delete protected directories or config files.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Absolute or ~-prefixed path to the file or directory to delete"
         }
+      },
+      required: ["path"]
+    },
+    async execute(_id, params) {
+      try {
+        const targetPath = validateWritePath(params.path, allowedRoots);
+        const stat = fs6.statSync(targetPath);
+        const wasDirectory = stat.isDirectory();
+        if (wasDirectory) {
+          fs6.rmSync(targetPath, { recursive: true });
+        } else {
+          fs6.unlinkSync(targetPath);
+        }
+        return ok({
+          path: targetPath,
+          deleted: true,
+          type: wasDirectory ? "directory" : "file"
+        });
       } catch (e) {
         const msg = e instanceof Error ? e.message : String(e);
-        respond(false, { error: msg });
-      } finally {
-        updateInProgress = false;
+        return err(`fs_delete failed: ${msg}`);
       }
     }
-  );
+  });
 }
 
-// src/relay-client.ts
-import { WebSocket as NodeWebSocket } from "ws";
-import crypto3 from "crypto";
-import fs9 from "fs";
-import path9 from "path";
-
-// src/e2e-crypto.ts
-import crypto from "crypto";
-var CURVE = "prime256v1";
-var HKDF_SALT = "squad-e2e-v1";
-var HKDF_INFO = "aes-gcm-key";
-var AES_KEY_LENGTH = 32;
-var IV_LENGTH = 12;
-var E2ECrypto = class {
-  ecdh = null;
-  aesKey = null;
-  publicKeyB64 = null;
-  /** Generate an ephemeral ECDH keypair. Returns the public key as base64. */
-  async generateKeyPair() {
-    this.ecdh = crypto.createECDH(CURVE);
-    const publicKey = this.ecdh.generateKeys();
-    this.publicKeyB64 = publicKey.toString("base64");
-    return this.publicKeyB64;
-  }
-  /** Derive the shared secret from the peer's public key. */
-  async deriveSharedSecret(peerPublicKeyB64) {
-    if (!this.ecdh) {
-      throw new Error("Must call generateKeyPair() first");
-    }
-    const peerPublicKey = Buffer.from(peerPublicKeyB64, "base64");
-    const sharedSecret = this.ecdh.computeSecret(peerPublicKey);
-    this.aesKey = crypto.hkdfSync(
-      "sha256",
-      sharedSecret,
-      Buffer.from(HKDF_SALT),
-      Buffer.from(HKDF_INFO),
-      AES_KEY_LENGTH
-    );
-  }
-  /** Encrypt a plaintext string. Returns base64-encoded ciphertext + iv + tag. */
-  encrypt(plaintext) {
-    if (!this.aesKey) {
-      throw new Error("E2E not established \u2014 call deriveSharedSecret() first");
-    }
-    const iv = crypto.randomBytes(IV_LENGTH);
-    const cipher = crypto.createCipheriv("aes-256-gcm", this.aesKey, iv);
-    const encrypted = Buffer.concat([
-      cipher.update(plaintext, "utf-8"),
-      cipher.final()
-    ]);
-    const tag = cipher.getAuthTag();
-    return {
-      ciphertext: encrypted.toString("base64"),
-      iv: iv.toString("base64"),
-      tag: tag.toString("base64")
-    };
-  }
-  /** Decrypt a payload. Returns the plaintext string. */
-  decrypt(payload) {
-    if (!this.aesKey) {
-      throw new Error("E2E not established \u2014 call deriveSharedSecret() first");
-    }
-    const ciphertext = Buffer.from(payload.ciphertext, "base64");
-    const iv = Buffer.from(payload.iv, "base64");
-    const tag = Buffer.from(payload.tag, "base64");
-    const decipher = crypto.createDecipheriv("aes-256-gcm", this.aesKey, iv);
-    decipher.setAuthTag(tag);
-    const decrypted = Buffer.concat([
-      decipher.update(ciphertext),
-      decipher.final()
-    ]);
-    return decrypted.toString("utf-8");
-  }
-  /** Whether E2E encryption has been established */
-  get isEstablished() {
-    return this.aesKey !== null;
-  }
-  /** Get the local public key (base64) */
-  get publicKey() {
-    return this.publicKeyB64;
-  }
-};
-
-// src/device-keys.ts
-import crypto2 from "crypto";
-import fs8 from "fs";
-import path8 from "path";
-var RELAY_DATA_DIR = path8.join(getOpenclawStateDir(), "squad-ceo-data", "relay");
-var RELAY_STATE_PATH = path8.join(RELAY_DATA_DIR, "squad-relay.json");
-var PENDING_APPROVAL_PATH = path8.join(RELAY_DATA_DIR, "pending-approval.json");
-function readRelayState() {
+// src/entities.ts
+var EntityType = T.Union([
+  T.Literal("agent"),
+  T.Literal("skill"),
+  T.Literal("tool"),
+  T.Literal("plugin"),
+  T.Literal("session"),
+  T.Literal("file"),
+  T.Literal("directory"),
+  T.Literal("url"),
+  T.Literal("memory"),
+  T.Literal("asset")
+]);
+var registry = /* @__PURE__ */ new Map();
+function registrySet(entity) {
+  registry.set(entity.id, entity);
+}
+function registryDelete(id) {
+  registry.delete(id);
+}
+function registryList(type) {
+  const all = Array.from(registry.values());
+  if (!type) return all;
+  return all.filter((e) => e.type === type);
+}
+var IDENTITY_NAME_RE = /\*\*Name:\*\*\s*\n?\s*(.+?)(?=\n|$)/;
+function parseIdentityName(content) {
+  const match = content.match(IDENTITY_NAME_RE);
+  const name = match?.[1]?.trim();
+  if (!name) return null;
+  if (/^_\(.+\)_$/.test(name)) return null;
+  return name;
+}
+function scanAgents(configDir) {
+  const now = Date.now();
+  let entries;
   try {
-    const raw = fs8.readFileSync(RELAY_STATE_PATH, "utf-8");
-    return JSON.parse(raw);
+    entries = fs7.readdirSync(configDir, { withFileTypes: true });
   } catch {
-    return {};
+    return;
   }
-}
-function writeRelayState(state) {
-  if (!fs8.existsSync(RELAY_DATA_DIR)) {
-    fs8.mkdirSync(RELAY_DATA_DIR, { recursive: true });
+  const workspaceDirs = entries.filter(
+    (e) => e.isDirectory() && (e.name === "workspace" || e.name.startsWith("workspace-"))
+  );
+  for (const dir of workspaceDirs) {
+    const agentId = dir.name === "workspace" ? "main" : dir.name.replace("workspace-", "");
+    const workspacePath = path7.join(configDir, dir.name);
+    let name = agentId;
+    const metadata = { workspacePath };
+    const identityPath = path7.join(workspacePath, "IDENTITY.md");
+    try {
+      const content = fs7.readFileSync(identityPath, "utf-8");
+      const parsed = parseIdentityName(content);
+      if (parsed) name = parsed;
+    } catch {
+    }
+    if (name === agentId) {
+      const agentJsonPath = path7.join(workspacePath, "agent.json");
+      try {
+        const raw = fs7.readFileSync(agentJsonPath, "utf-8");
+        const config = JSON.parse(raw);
+        if (config.displayName) name = config.displayName;
+        if (config.model) metadata.model = config.model;
+        if (config.tools) metadata.tools = config.tools;
+        if (config.skills) metadata.skills = config.skills;
+      } catch {
+      }
+    }
+    registrySet({
+      id: agentId,
+      type: "agent",
+      name,
+      title: name,
+      description: null,
+      metadata,
+      source: "filesystem",
+      source_key: workspacePath,
+      created_at: now,
+      updated_at: now
+    });
   }
-  fs8.writeFileSync(RELAY_STATE_PATH, JSON.stringify(state, null, 2), { mode: 384 });
 }
-function toBase64Url(buf) {
-  return buf.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-}
-function loadOrCreateRelayDeviceKeys() {
-  const state = readRelayState();
-  if (state.deviceKeys) {
-    return state.deviceKeys;
+function scanSkills(configDir) {
+  const now = Date.now();
+  const globalSkillsDir = path7.join(configDir, "skills");
+  scanSkillsDir(globalSkillsDir, "global", now);
+  let entries;
+  try {
+    entries = fs7.readdirSync(configDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const dir of entries) {
+    if (!dir.isDirectory() || !(dir.name === "workspace" || dir.name.startsWith("workspace-"))) {
+      continue;
+    }
+    const agentId = dir.name === "workspace" ? "main" : dir.name.replace("workspace-", "");
+    const agentSkillsDir = path7.join(configDir, dir.name, "skills");
+    scanSkillsDir(agentSkillsDir, agentId, now);
   }
-  const { publicKey, privateKey } = crypto2.generateKeyPairSync("ed25519");
-  const pubDer = publicKey.export({ type: "spki", format: "der" });
-  const rawPub = pubDer.subarray(pubDer.length - 32);
-  const deviceId = crypto2.createHash("sha256").update(rawPub).digest("hex");
-  const publicKeyB64 = toBase64Url(rawPub);
-  const privateKeyPem = privateKey.export({ type: "pkcs8", format: "pem" });
-  const keys = { deviceId, publicKey: publicKeyB64, privateKeyPem };
-  writeRelayState({ ...state, deviceKeys: keys });
-  console.log(`[device-keys] Generated relay device identity: ${deviceId.substring(0, 12)}...`);
-  return keys;
 }
-function writeDeviceInfoFile(keys) {
-  const stateDir = getOpenclawStateDir();
-  const infoPath = path8.join(stateDir, "squad-ceo-data", "relay", "relay-device-info.json");
-  const info = {
-    deviceId: keys.deviceId,
-    publicKey: keys.publicKey,
-    displayName: "squad-relay",
-    platform: process.platform,
-    createdAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
+function scanSkillsDir(skillsDir, scope, now) {
+  let entries;
   try {
-    fs8.writeFileSync(infoPath, JSON.stringify(info, null, 2));
-  } catch (err2) {
-    console.error("[device-keys] Failed to write relay-device-info.json:", err2);
+    entries = fs7.readdirSync(skillsDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const skillKey = entry.name;
+    const skillPath = path7.join(skillsDir, skillKey);
+    let name = skillKey;
+    for (const manifestName of ["manifest.json", "package.json"]) {
+      try {
+        const raw = fs7.readFileSync(
+          path7.join(skillPath, manifestName),
+          "utf-8"
+        );
+        const manifest = JSON.parse(raw);
+        if (manifest.name) name = manifest.name;
+        break;
+      } catch {
+        continue;
+      }
+    }
+    const entityId = scope === "global" ? `skill:${skillKey}` : `skill:${scope}:${skillKey}`;
+    registrySet({
+      id: entityId,
+      type: "skill",
+      name,
+      title: name,
+      description: null,
+      metadata: { skillKey, scope, skillPath },
+      source: "filesystem",
+      source_key: skillPath,
+      created_at: now,
+      updated_at: now
+    });
   }
 }
-
-// src/relay-client.ts
-function readOperatorToken() {
-  const stateDir = getOpenclawStateDir();
-  const configPath = path9.join(stateDir, "openclaw.json");
+function scanPlugins2(configDir) {
+  const now = Date.now();
+  const extensionsDir = path7.join(configDir, "extensions");
+  let entries;
   try {
-    const raw = fs9.readFileSync(configPath, "utf-8");
-    const config = JSON.parse(raw);
-    return config?.gateway?.auth?.token ?? config?.gateway?.remote?.token ?? config?.gateway?.token ?? null;
+    entries = fs7.readdirSync(extensionsDir, { withFileTypes: true });
   } catch {
-    return null;
+    return;
+  }
+  for (const dir of entries) {
+    if (!dir.isDirectory()) continue;
+    const pluginDir = path7.join(extensionsDir, dir.name);
+    const manifestPath = path7.join(pluginDir, "openclaw.plugin.json");
+    try {
+      const raw = fs7.readFileSync(manifestPath, "utf-8");
+      const manifest = JSON.parse(raw);
+      const pluginId = manifest.id || dir.name;
+      const name = manifest.name || pluginId;
+      registrySet({
+        id: `plugin:${pluginId}`,
+        type: "plugin",
+        name,
+        title: name,
+        description: manifest.description || null,
+        metadata: { pluginId, pluginDir },
+        source: "filesystem",
+        source_key: manifestPath,
+        created_at: now,
+        updated_at: now
+      });
+    } catch {
+    }
   }
 }
-function readGatewayLocalWsConfig() {
-  const defaults = {
-    port: 18789,
-    // Try IPv4, hostname, then IPv6 loopback.
-    hosts: ["127.0.0.1", "localhost", "[::1]"]
-  };
-  const stateDir = getOpenclawStateDir();
-  const configPath = path9.join(stateDir, "openclaw.json");
+function scanTools(configDir) {
+  const now = Date.now();
   try {
-    const raw = fs9.readFileSync(configPath, "utf-8");
+    const raw = fs7.readFileSync(
+      path7.join(configDir, "openclaw.json"),
+      "utf-8"
+    );
     const config = JSON.parse(raw);
-    const parsedPort = Number(config?.gateway?.port);
-    if (Number.isFinite(parsedPort) && parsedPort > 0) {
-      defaults.port = parsedPort;
+    const allowedTools = config?.tools?.allow ?? [];
+    for (const toolName of allowedTools) {
+      registrySet({
+        id: `tool:${toolName}`,
+        type: "tool",
+        name: toolName,
+        title: toolName,
+        description: null,
+        metadata: { tool_name: toolName },
+        source: "filesystem",
+        source_key: "openclaw.json:tools.allow",
+        created_at: now,
+        updated_at: now
+      });
     }
   } catch {
   }
-  return defaults;
 }
-function signDeviceIdentity(keys, clientId, clientMode, role, scopes, token, challengeNonce) {
-  const signedAtMs = Date.now();
-  const nonce = challengeNonce || crypto3.randomBytes(16).toString("hex");
-  const scopeStr = scopes.join(",");
-  const payload = `v2|${keys.deviceId}|${clientId}|${clientMode}|${role}|${scopeStr}|${signedAtMs}|${token ?? ""}|${nonce}`;
-  const privateKey = crypto3.createPrivateKey(keys.privateKeyPem);
-  const signature = crypto3.sign(null, Buffer.from(payload), privateKey);
-  return {
-    id: keys.deviceId,
-    publicKey: keys.publicKey,
-    signature: toBase64Url(signature),
-    signedAt: signedAtMs,
-    nonce
-  };
-}
-var RelayClient = class {
-  config;
-  relayWs = null;
-  userConnections = /* @__PURE__ */ new Map();
-  localConnectAttempts = /* @__PURE__ */ new Map();
-  reconnectAttempts = 0;
-  maxReconnectAttempts = 100;
-  reconnectTimer = null;
-  shouldReconnect = true;
-  destroyed = false;
-  /** Pending claim token — sent on first successful connect, then cleared */
-  pendingClaimToken = null;
-  /** Device keys for authenticating local WS connections to the gateway */
-  deviceKeys;
-  constructor(config) {
-    const state = readRelayState();
-    const localWs = readGatewayLocalWsConfig();
-    this.config = {
-      relayUrl: config.relayUrl,
-      localGatewayPort: config.localGatewayPort ?? localWs.port,
-      localGatewayHosts: config.localGatewayHosts ?? localWs.hosts,
-      operatorToken: config.operatorToken ?? readOperatorToken(),
-      claimToken: config.claimToken ?? state.claimToken ?? null,
-      roomId: config.roomId ?? state.roomId ?? null
-    };
-    this.pendingClaimToken = this.config.roomId ? null : this.config.claimToken;
-    this.deviceKeys = loadOrCreateRelayDeviceKeys();
-    writeDeviceInfoFile(this.deviceKeys);
-    console.log(`[relay-client] Device ID: ${this.deviceKeys.deviceId}`);
-  }
-  /** Start connecting to the relay */
-  start() {
-    if (!this.config.roomId && !this.pendingClaimToken) {
-      console.log("[relay-client] No room ID or claim token found.");
-      console.log("[relay-client] Complete the setup from the Squad web app to generate a claim token.");
-      return;
-    }
-    console.log(`[relay-client] Starting relay connection to ${this.config.relayUrl}`);
-    if (this.config.roomId) {
-      console.log(`[relay-client] Room ID: ${this.config.roomId.substring(0, 8)}...`);
-    } else {
-      console.log(`[relay-client] Using claim token for first connect`);
-    }
-    this.connectToRelay();
+var MIME_MAP = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".bmp": "image/bmp",
+  ".ico": "image/x-icon",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".mov": "video/quicktime",
+  ".avi": "video/x-msvideo",
+  ".mkv": "video/x-matroska",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".ogg": "audio/ogg",
+  ".flac": "audio/flac",
+  ".aac": "audio/aac",
+  ".pdf": "application/pdf",
+  ".json": "application/json",
+  ".txt": "text/plain",
+  ".md": "text/markdown",
+  ".csv": "text/csv",
+  ".zip": "application/zip",
+  ".tar": "application/x-tar",
+  ".gz": "application/gzip"
+};
+function getMimeType(filename) {
+  const ext = path7.extname(filename).toLowerCase();
+  return MIME_MAP[ext] ?? "application/octet-stream";
+}
+function scanMedia(configDir) {
+  const now = Date.now();
+  const mediaDir = path7.join(configDir, "media");
+  scanMediaDir(mediaDir, now);
+}
+function scanMediaDir(dirPath, now) {
+  let entries;
+  try {
+    entries = fs7.readdirSync(dirPath, { withFileTypes: true });
+  } catch {
+    return;
   }
-  /** Stop the relay client and close all connections */
-  destroy() {
-    this.destroyed = true;
-    this.shouldReconnect = false;
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-    for (const [userId, conn] of this.userConnections) {
-      try {
-        conn.localWs.close(1e3, "Relay client shutting down");
-      } catch {
-      }
-      this.userConnections.delete(userId);
-    }
-    if (this.relayWs) {
+  for (const entry of entries) {
+    if (entry.name.startsWith(".")) continue;
+    const entryPath = path7.join(dirPath, entry.name);
+    if (isSensitivePath(entryPath)) continue;
+    if (entry.isDirectory()) {
+      registrySet({
+        id: entryPath,
+        type: "directory",
+        name: entry.name,
+        title: entry.name,
+        description: null,
+        metadata: { path: entryPath },
+        source: "filesystem",
+        source_key: entryPath,
+        created_at: now,
+        updated_at: now
+      });
+      scanMediaDir(entryPath, now);
+    } else if (entry.isFile()) {
+      const mimeType = getMimeType(entry.name);
+      let size;
+      let mtime = now;
       try {
-        this.relayWs.close(1e3, "Relay client shutting down");
+        const stat = fs7.statSync(entryPath);
+        size = stat.size;
+        mtime = stat.mtimeMs;
       } catch {
       }
-      this.relayWs = null;
+      registrySet({
+        id: entryPath,
+        type: "asset",
+        name: entry.name,
+        title: entry.name,
+        description: null,
+        metadata: { path: entryPath, size, mime_type: mimeType, original_name: entry.name },
+        source: "filesystem",
+        source_key: entryPath,
+        created_at: mtime,
+        updated_at: mtime
+      });
     }
   }
-  // ── Relay Connection ──
-  connectToRelay() {
-    if (this.destroyed) return;
-    let wsUrl;
-    if (this.pendingClaimToken) {
-      wsUrl = `${this.config.relayUrl}/gw?claim=${encodeURIComponent(this.pendingClaimToken)}`;
-      console.log(`[relay-client] Connecting with claim token`);
-    } else if (this.config.roomId) {
-      wsUrl = `${this.config.relayUrl}/gw?room=${encodeURIComponent(this.config.roomId)}`;
-      console.log(`[relay-client] Reconnecting with room ID`);
-    } else {
-      console.error("[relay-client] No claim token or room ID \u2014 cannot connect");
-      return;
-    }
-    try {
-      this.relayWs = new NodeWebSocket(wsUrl);
-    } catch (err2) {
-      console.error("[relay-client] Failed to create WebSocket:", err2);
-      this.scheduleReconnect();
-      return;
+}
+function fullScan(configDir) {
+  registry.clear();
+  scanAgents(configDir);
+  scanSkills(configDir);
+  scanPlugins2(configDir);
+  scanTools(configDir);
+  scanMedia(configDir);
+}
+function registerEntityTools(api, onFsChange) {
+  const configDir = getOpenclawStateDir();
+  api.registerTool({
+    name: "entity_list",
+    description: "List all entities in the registry, optionally filtered by type. Returns lightweight entity data for @mention autocomplete.",
+    parameters: T.Object({
+      type: T.Optional(EntityType),
+      limit: T.Optional(
+        T.Number({ description: "Max results (default 500)" })
+      )
+    }),
+    async execute(_id, params, _ctx) {
+      const results = registryList(params.type);
+      const limit = params.limit ?? 500;
+      return {
+        content: [
+          { type: "text", text: JSON.stringify(results.slice(0, limit)) }
+        ]
+      };
     }
-    this.relayWs.on("open", () => {
-      console.log("[relay-client] Connected to relay");
-      this.reconnectAttempts = 0;
-      this.sendToRelay({
-        type: "relay.hello",
-        deviceId: this.deviceKeys.deviceId,
-        publicKey: this.deviceKeys.publicKey
-      });
-    });
-    this.relayWs.on("message", (data) => {
-      try {
-        const msg = JSON.parse(data.toString());
-        this.handleRelayMessage(msg);
-      } catch {
-      }
-    });
-    this.relayWs.on("close", (code, reason) => {
-      const reasonStr = reason.toString();
-      console.log(`[relay-client] Relay connection closed: ${code} ${reasonStr}`);
-      this.relayWs = null;
-      if (code === 1e3 && reasonStr.includes("Replaced")) {
-        console.log("[relay-client] Replaced by newer instance, stopping reconnect");
-        this.shouldReconnect = false;
-        this.destroyed = true;
-      }
-      for (const [userId, conn] of this.userConnections) {
-        try {
-          conn.localWs.close(1001, "Relay disconnected");
-        } catch {
-        }
-        this.userConnections.delete(userId);
-      }
-      if (this.shouldReconnect) {
-        this.scheduleReconnect();
+  });
+  api.registerTool({
+    name: "entity_search",
+    description: "Search entities by name/title substring match for @mention autocomplete.",
+    parameters: T.Object({
+      query: T.String({ description: "Search query text" }),
+      type: T.Optional(
+        T.String({ description: "Filter results by entity type" })
+      ),
+      limit: T.Optional(
+        T.Number({ description: "Max results (default 20)" })
+      )
+    }),
+    async execute(_id, params, _ctx) {
+      const q = (params.query ?? "").toLowerCase();
+      const limit = params.limit ?? 20;
+      let results = Array.from(registry.values());
+      if (params.type) {
+        results = results.filter((e) => e.type === params.type);
       }
-    });
-    this.relayWs.on("error", (err2) => {
-      console.error("[relay-client] Relay WebSocket error:", err2.message);
-    });
-    this.relayWs.on("unexpected-response", (_req, res) => {
-      console.warn(`[relay-client] Unexpected response: ${res.statusCode}`);
-      if (res.statusCode === 401 && this.pendingClaimToken) {
-        console.log("[relay-client] Claim token rejected \u2014 checking for stored room ID");
-        this.pendingClaimToken = null;
-        const state = readRelayState();
-        if (state.roomId) {
-          this.config.roomId = state.roomId;
-          console.log(`[relay-client] Found stored room ID, will use on next reconnect`);
-        }
+      if (q) {
+        results = results.filter(
+          (e) => e.name.toLowerCase().includes(q) || (e.title ?? "").toLowerCase().includes(q)
+        );
       }
-      this.relayWs = null;
-      this.scheduleReconnect();
-    });
-  }
-  scheduleReconnect() {
-    if (this.destroyed || !this.shouldReconnect) return;
-    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
-      console.error("[relay-client] Max reconnect attempts reached");
-      return;
+      return {
+        content: [
+          { type: "text", text: JSON.stringify(results.slice(0, limit)) }
+        ]
+      };
     }
-    const delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts), 6e4);
-    this.reconnectAttempts++;
-    console.log(`[relay-client] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
-    this.reconnectTimer = setTimeout(() => {
-      this.reconnectTimer = null;
-      this.connectToRelay();
-    }, delay);
-  }
-  // ── Message Handling ──
-  handleRelayMessage(msg) {
-    switch (msg.type) {
-      case "relay.welcome":
-        this.handleWelcome(msg);
-        break;
-      case "relay.forward":
-        if (msg.userId && msg.inner) {
-          this.routeToUser(msg.userId, msg.inner);
-        }
-        break;
-      case "relay.pair.request":
-        if (msg.userId && msg.email) {
-          this.handlePairingRequest(msg.userId, msg.email);
-        }
-        break;
-      case "relay.e2e.exchange":
-        if (msg.userId && msg.publicKey) {
-          this.handleE2EExchange(msg.userId, msg.publicKey);
-        }
-        break;
-      case "relay.ping":
-        this.sendToRelay({ type: "relay.pong" });
-        break;
-      default:
-        console.log(`[relay-client] Unknown relay message type: ${msg.type}`);
+  });
+  api.registerTool({
+    name: "entity_sync",
+    description: "Re-scan the filesystem to refresh the entity registry. Call after configuration changes for immediate updates.",
+    parameters: T.Object({}),
+    async execute(_id, _params, _ctx) {
+      const before = registry.size;
+      fullScan(configDir);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ synced: registry.size, previous: before })
+          }
+        ]
+      };
     }
+  });
+  try {
+    fullScan(configDir);
+  } catch (err2) {
+    console.error("[squad-openclaw] Initial scan failed:", err2);
   }
-  /** Handle relay.welcome — store room ID for reconnection */
-  handleWelcome(msg) {
-    if (msg.roomId) {
-      console.log(`[relay-client] Received room ID: ${msg.roomId.substring(0, 8)}...`);
-      this.config.roomId = msg.roomId;
-      this.pendingClaimToken = null;
-      const state = readRelayState();
-      state.roomId = msg.roomId;
-      writeRelayState(state);
-    }
+  let stopWatcher = null;
+  try {
+    stopWatcher = startWatcher(configDir, onFsChange);
+  } catch (err2) {
+    console.error("[squad-openclaw] Watcher failed to start:", err2);
   }
-  /** Route a message from the relay to the appropriate user's local WS */
-  routeToUser(userId, innerMsg) {
-    let msg = innerMsg;
-    if (msg.type === "event" && typeof msg.event === "string" && msg.event.startsWith("relay.")) {
-      if (msg.event === "relay.user.connected") {
-        console.log(`[relay-client] User ${userId} connected via relay \u2014 creating local WS`);
-        this.createUserConnection(userId);
-      }
-      return;
-    }
-    if (typeof msg.type === "string" && msg.type.startsWith("relay.")) {
-      if (msg.type === "relay.e2e.exchange" && msg.publicKey) {
-        this.handleE2EExchange(userId, msg.publicKey);
-      }
-      return;
-    }
-    let conn = this.userConnections.get(userId);
-    if (!conn || conn.localWs.readyState >= NodeWebSocket.CLOSING) {
-      this.createUserConnection(userId);
-      conn = this.userConnections.get(userId);
-      if (!conn) return;
+  const cleanup = () => {
+    stopWatcher?.();
+  };
+  process.on("SIGTERM", cleanup);
+  process.on("SIGINT", cleanup);
+}
+
+// src/sql.ts
+import { execFile } from "child_process";
+import path8 from "path";
+import fs8 from "fs";
+import { Type as T2 } from "@sinclair/typebox";
+var HOME_DIR2 = process.env.HOME ?? "/root";
+var ALLOWED_DATA_DIR = path8.join(getOpenclawStateDir(), "squad-ceo-data");
+function validateDbPath(dbPath) {
+  let expanded = dbPath;
+  if (expanded.startsWith("~/") || expanded === "~") {
+    expanded = path8.join(HOME_DIR2, expanded.slice(1));
+  }
+  const resolved = path8.resolve(expanded);
+  if (resolved !== ALLOWED_DATA_DIR && !resolved.startsWith(ALLOWED_DATA_DIR + path8.sep)) {
+    throw new Error(
+      `Access denied: database path must be within ~/.openclaw/squad-ceo-data/`
+    );
+  }
+  try {
+    const stat = fs8.statSync(resolved);
+    if (!stat.isFile()) {
+      throw new Error(`Not a file: ${dbPath}`);
     }
-    if (msg._e2e && conn.e2e) {
-      try {
-        const plaintext = conn.e2e.decrypt({
-          ciphertext: msg.ciphertext,
-          iv: msg.iv,
-          tag: msg.tag
-        });
-        msg = JSON.parse(plaintext);
-      } catch (err2) {
-        console.error(`[relay-client] E2E decrypt error for ${userId}:`, err2);
-        return;
-      }
+  } catch (e) {
+    if (e.code === "ENOENT") {
+      throw new Error(`Database file not found: ${dbPath}`);
     }
-    if (msg.type === "req" && msg.method === "connect") {
-      if (conn.connectHandshakeComplete) {
-        console.log(`[relay-client] New connect from ${userId} \u2014 creating fresh local WS for handshake`);
-        this.createUserConnection(userId);
-        conn = this.userConnections.get(userId);
-        if (!conn) return;
-      }
-      if (!conn.challengeNonce) {
-        console.log(`[relay-client] Connect request for ${userId} deferred \u2014 waiting for challenge nonce`);
-        conn.pendingConnect = msg;
-        return;
+    throw e;
+  }
+  return resolved;
+}
+function runSqlite3(dbPath, args) {
+  return new Promise((resolve, reject) => {
+    execFile(
+      "sqlite3",
+      [dbPath, ...args],
+      { timeout: 3e4, maxBuffer: 10 * 1024 * 1024 },
+      (error, stdout, stderr) => {
+        if (error) {
+          reject(new Error(stderr || error.message));
+          return;
+        }
+        resolve(stdout);
       }
-      this.injectDeviceIdentity(conn, msg);
-      if (conn.localWs.readyState === NodeWebSocket.CONNECTING) {
-        conn.localWs.once("open", () => {
-          conn.localWs.send(JSON.stringify(msg));
-        });
-      } else {
-        conn.localWs.send(JSON.stringify(msg));
+    );
+  });
+}
+function registerSqlTools(api) {
+  api.registerTool({
+    name: "sql_query",
+    label: "SQL Query",
+    description: "Execute a sqlite3 query on a database file within ~/.openclaw/squad-ceo-data/. Only sqlite3 is allowed \u2014 no arbitrary shell commands. Use jsonOutput: true for structured JSON results.",
+    parameters: T2.Object({
+      dbPath: T2.String({
+        description: "Path to the SQLite database file (must be within ~/.openclaw/squad-ceo-data/)"
+      }),
+      query: T2.String({ description: "SQL query to execute" }),
+      jsonOutput: T2.Optional(
+        T2.Boolean({
+          description: "Return results as JSON (sqlite3 -json flag)"
+        })
+      )
+    }),
+    async execute(_id, params) {
+      try {
+        const resolvedDb = validateDbPath(params.dbPath);
+        const args = [];
+        if (params.jsonOutput) args.push("-json");
+        args.push(params.query);
+        const output = await runSqlite3(resolvedDb, args);
+        return {
+          content: [{ type: "text", text: output }]
+        };
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: msg }) }],
+          isError: true
+        };
       }
-      return;
     }
-    if (!conn.connectHandshakeComplete) {
-      conn.pendingMessages.push(msg);
-      return;
+  });
+}
+
+// src/version.ts
+import { execSync as execSync2 } from "child_process";
+import fs9 from "fs";
+import path9 from "path";
+import { fileURLToPath } from "url";
+var PACKAGE_NAME = "squad-openclaw";
+var CONFIG_PATH = path9.join(getOpenclawStateDir(), "openclaw.json");
+var updateInProgress = false;
+var VERIFY_TIMEOUT_MS = 2e4;
+var VERIFY_INTERVAL_MS = 500;
+var RESTART_BUFFER_MS = 5e3;
+function readInstalledVersionFromConfig() {
+  try {
+    const raw = fs9.readFileSync(CONFIG_PATH, "utf-8");
+    const cfg = JSON.parse(raw);
+    const v = cfg?.plugins?.installs?.[PACKAGE_NAME]?.version;
+    return typeof v === "string" ? v : null;
+  } catch {
+    return null;
+  }
+}
+function reconcileInstallMetadata(verification) {
+  if (!verification.installPath || !verification.packageVersion) return;
+  try {
+    const raw = fs9.readFileSync(CONFIG_PATH, "utf-8");
+    const config = JSON.parse(raw);
+    if (!config.plugins || typeof config.plugins !== "object") config.plugins = {};
+    if (!config.plugins.installs || typeof config.plugins.installs !== "object") {
+      config.plugins.installs = {};
     }
-    if (conn.localWs.readyState === NodeWebSocket.CONNECTING) {
-      conn.localWs.once("open", () => {
-        conn.localWs.send(JSON.stringify(msg));
-      });
-      return;
+    if (!config.plugins.entries || typeof config.plugins.entries !== "object") {
+      config.plugins.entries = {};
     }
-    conn.localWs.send(JSON.stringify(msg));
-  }
-  /**
-   * Inject auth token and device identity into a connect request.
-   *
-   * SECURITY: The token is added to the message IN MEMORY, then sent to the
-   * LOCAL gateway WebSocket (localhost:18789). It NEVER traverses the relay —
-   * the relay only sees the outer relay.forward envelope. A compromised relay
-   * server cannot intercept this token.
-   */
-  injectDeviceIdentity(conn, msg) {
-    const params = msg.params ?? {};
-    if (this.config.operatorToken) {
-      params.auth = { token: this.config.operatorToken };
-    }
-    const client = params.client ?? {};
-    const role = params.role ?? "operator";
-    const scopes = params.scopes ?? [];
-    params.device = signDeviceIdentity(
-      this.deviceKeys,
-      client.id ?? "cli",
-      client.mode ?? "ui",
-      role,
-      scopes,
-      this.config.operatorToken,
-      conn.challengeNonce
+    const current = config.plugins.installs[PACKAGE_NAME] ?? {};
+    config.plugins.installs[PACKAGE_NAME] = {
+      ...current,
+      source: "npm",
+      spec: PACKAGE_NAME,
+      installPath: verification.installPath,
+      version: verification.packageVersion,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const entry = config.plugins.entries[PACKAGE_NAME] ?? {};
+    config.plugins.entries[PACKAGE_NAME] = {
+      ...entry,
+      enabled: true
+    };
+    fs9.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), "utf-8");
+  } catch {
+  }
+}
+function getCurrentVersion() {
+  const thisFile = fileURLToPath(import.meta.url);
+  const pkgPath = path9.resolve(path9.dirname(thisFile), "..", "package.json");
+  try {
+    const pkg = JSON.parse(fs9.readFileSync(pkgPath, "utf-8"));
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+async function fetchLatestVersion() {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 1e4);
+  try {
+    const res = await fetch(`https://registry.npmjs.org/${PACKAGE_NAME}`, {
+      signal: controller.signal
+    });
+    if (!res.ok) throw new Error(`npm registry returned ${res.status}`);
+    const data = await res.json();
+    return data["dist-tags"]?.latest ?? "0.0.0";
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function runDoctorFixSilently() {
+  try {
+    execSync2("openclaw doctor --fix 2>/dev/null || true", {
+      timeout: 3e4,
+      encoding: "utf-8"
+    });
+  } catch {
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function compareVersions(a, b) {
+  const pa = a.split(".").map((x) => Number(x) || 0);
+  const pb = b.split(".").map((x) => Number(x) || 0);
+  const len = Math.max(pa.length, pb.length);
+  for (let i = 0; i < len; i++) {
+    const d = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (d !== 0) return d;
+  }
+  return 0;
+}
+function verifyInstalledPluginState() {
+  let configRaw;
+  try {
+    configRaw = fs9.readFileSync(CONFIG_PATH, "utf-8");
+  } catch (err2) {
+    const msg = err2 instanceof Error ? err2.message : String(err2);
+    return {
+      ok: false,
+      reason: `Could not read openclaw.json: ${msg}`,
+      installPath: null,
+      configVersion: null,
+      packageVersion: null,
+      requiredFilesMissing: []
+    };
+  }
+  let config;
+  try {
+    config = JSON.parse(configRaw);
+  } catch (err2) {
+    const msg = err2 instanceof Error ? err2.message : String(err2);
+    return {
+      ok: false,
+      reason: `Could not parse openclaw.json: ${msg}`,
+      installPath: null,
+      configVersion: null,
+      packageVersion: null,
+      requiredFilesMissing: []
+    };
+  }
+  const installMeta = config?.plugins?.installs?.[PACKAGE_NAME];
+  const installPath = typeof installMeta?.installPath === "string" ? installMeta.installPath : null;
+  const configVersion = typeof installMeta?.version === "string" ? installMeta.version : null;
+  if (!installPath) {
+    return {
+      ok: false,
+      reason: "Missing plugins.installs entry or installPath for squad-openclaw",
+      installPath: null,
+      configVersion,
+      packageVersion: null,
+      requiredFilesMissing: []
+    };
+  }
+  const requiredFiles = [
+    path9.join(installPath, "package.json"),
+    path9.join(installPath, "openclaw.plugin.json"),
+    path9.join(installPath, "dist", "index.js")
+  ];
+  const requiredFilesMissing = requiredFiles.filter((p) => !fs9.existsSync(p));
+  if (requiredFilesMissing.length > 0) {
+    return {
+      ok: false,
+      reason: "Missing required installed plugin files",
+      installPath,
+      configVersion,
+      packageVersion: null,
+      requiredFilesMissing
+    };
+  }
+  let installedPackage;
+  try {
+    installedPackage = JSON.parse(
+      fs9.readFileSync(path9.join(installPath, "package.json"), "utf-8")
     );
-    msg.params = params;
-    conn.connectHandshakeComplete = false;
-    console.log(`[relay-client] Injected device identity for ${conn.userId}: nonce=${conn.challengeNonce?.substring(0, 12)}...`);
+  } catch (err2) {
+    const msg = err2 instanceof Error ? err2.message : String(err2);
+    return {
+      ok: false,
+      reason: `Could not parse installed package.json: ${msg}`,
+      installPath,
+      configVersion,
+      packageVersion: null,
+      requiredFilesMissing: []
+    };
   }
-  /** Create a local WS connection to the gateway for a specific user */
-  createUserConnection(userId, carry) {
-    const existing = this.userConnections.get(userId);
-    if (existing) {
-      try {
-        existing.localWs.close(1e3, "Replaced");
-      } catch {
-      }
-    }
-    const attempt = this.localConnectAttempts.get(userId) ?? 0;
-    const host = this.config.localGatewayHosts[attempt % this.config.localGatewayHosts.length];
-    const localUrl = `ws://${host}:${this.config.localGatewayPort}`;
-    console.log(`[relay-client] Creating local WS for user ${userId} \u2192 ${localUrl}`);
-    const localWs = new NodeWebSocket(localUrl);
-    const conn = {
-      localWs,
-      userId,
-      e2e: carry?.e2e ?? null,
-      connectHandshakeComplete: false,
-      challengeNonce: null,
-      pendingConnect: carry?.pendingConnect ?? null,
-      pendingMessages: carry?.pendingMessages ?? []
+  try {
+    JSON.parse(
+      fs9.readFileSync(path9.join(installPath, "openclaw.plugin.json"), "utf-8")
+    );
+  } catch (err2) {
+    const msg = err2 instanceof Error ? err2.message : String(err2);
+    return {
+      ok: false,
+      reason: `Could not parse installed openclaw.plugin.json: ${msg}`,
+      installPath,
+      configVersion,
+      packageVersion: null,
+      requiredFilesMissing: []
     };
-    this.userConnections.set(userId, conn);
-    localWs.on("open", () => {
-      console.log(`[relay-client] Local WS for user ${userId} connected`);
-      this.localConnectAttempts.delete(userId);
-    });
-    localWs.on("message", (data) => {
+  }
+  const packageVersion = typeof installedPackage?.version === "string" ? installedPackage.version : null;
+  if (!packageVersion) {
+    return {
+      ok: false,
+      reason: "Installed package.json missing version",
+      installPath,
+      configVersion,
+      packageVersion,
+      requiredFilesMissing: []
+    };
+  }
+  return {
+    ok: true,
+    installPath,
+    configVersion,
+    packageVersion,
+    requiredFilesMissing: []
+  };
+}
+async function waitForVerifiedInstall() {
+  const deadline = Date.now() + VERIFY_TIMEOUT_MS;
+  let last = verifyInstalledPluginState();
+  while (!last.ok && Date.now() < deadline) {
+    await sleep(VERIFY_INTERVAL_MS);
+    last = verifyInstalledPluginState();
+  }
+  return last;
+}
+function registerVersionMethods(api) {
+  api.registerGatewayMethod(
+    "squad.version.check",
+    async ({ respond }) => {
       try {
-        const msg = JSON.parse(data.toString());
-        this.routeFromGateway(userId, msg);
-      } catch {
-      }
-    });
-    localWs.on("close", (code, reason) => {
-      const reasonStr = reason.toString();
-      console.log(`[relay-client] Local WS for user ${userId} closed: ${code} ${reasonStr}`);
-      if (code === 1008) {
-        console.error(
-          `[relay-client] Gateway rejected device identity (code 1008). The gateway auto-pairs devices with a valid operator token, so this usually means the operator token is missing, expired, or incorrect.
-Check: ~/.openclaw/openclaw.json \u2192 gateway.auth.token
-Device ID: ${this.deviceKeys.deviceId}`
-        );
-      }
-      const current = this.userConnections.get(userId);
-      if (current && current.localWs === localWs) {
-        this.userConnections.delete(userId);
-        const nextAttempt = (this.localConnectAttempts.get(userId) ?? 0) + 1;
-        const shouldRetryLocalConnect = code === 1006 && !conn.connectHandshakeComplete && nextAttempt <= 8 && this.relayWs?.readyState === NodeWebSocket.OPEN;
-        if (shouldRetryLocalConnect) {
-          this.localConnectAttempts.set(userId, nextAttempt);
-          const delay = Math.min(300 * nextAttempt, 2e3);
-          console.log(
-            `[relay-client] Local WS unavailable for ${userId}, retrying in ${delay}ms (attempt ${nextAttempt}/8)`
-          );
-          const carry2 = {
-            pendingConnect: conn.pendingConnect,
-            pendingMessages: conn.pendingMessages,
-            e2e: conn.e2e
-          };
-          setTimeout(() => {
-            if (this.destroyed) return;
-            if (this.relayWs?.readyState !== NodeWebSocket.OPEN) return;
-            if (!this.userConnections.has(userId)) {
-              this.createUserConnection(userId, carry2);
-            }
-          }, delay);
+        const current = getCurrentVersion();
+        let latest;
+        try {
+          latest = await fetchLatestVersion();
+        } catch {
+          respond(true, {
+            current,
+            latest: null,
+            updateAvailable: false,
+            registryError: "Could not reach npm registry"
+          });
           return;
         }
-        this.localConnectAttempts.delete(userId);
-        this.sendToRelay({
-          type: "relay.forward",
-          userId,
-          inner: {
-            type: "event",
-            event: "relay.gateway.connection.closed",
-            payload: { code }
-          }
-        });
-      }
-    });
-    localWs.on("error", (err2) => {
-      console.error(`[relay-client] Local WS error for user ${userId}:`, err2.message);
-    });
-  }
-  /** Route a message from the gateway back through the relay to the user */
-  routeFromGateway(userId, msg) {
-    const conn = this.userConnections.get(userId);
-    if (!conn) return;
-    const parsed = msg;
-    if (parsed.type === "event" && parsed.event === "connect.challenge") {
-      const payload = parsed.payload;
-      if (payload?.nonce) {
-        conn.challengeNonce = payload.nonce;
-        console.log(`[relay-client] Captured challenge nonce for ${userId}: ${conn.challengeNonce.substring(0, 12)}...`);
-        if (conn.pendingConnect) {
-          const pending = conn.pendingConnect;
-          conn.pendingConnect = null;
-          console.log(`[relay-client] Flushing deferred connect for ${userId}`);
-          this.injectDeviceIdentity(conn, pending);
-          if (conn.localWs.readyState === NodeWebSocket.OPEN) {
-            conn.localWs.send(JSON.stringify(pending));
-          }
-        }
-      }
-    }
-    if (parsed.type === "res" && parsed.id === "connect-1" && parsed.ok) {
-      conn.connectHandshakeComplete = true;
-      if (conn.pendingMessages.length > 0) {
-        console.log(`[relay-client] Flushing ${conn.pendingMessages.length} buffered messages for ${userId}`);
-        for (const queued of conn.pendingMessages) {
-          conn.localWs.send(JSON.stringify(queued));
-        }
-        conn.pendingMessages = [];
+        respond(true, {
+          current,
+          latest,
+          updateAvailable: latest !== current && latest !== "0.0.0"
+        });
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        respond(false, { error: msg });
       }
     }
-    let innerMsg = msg;
-    if (conn.e2e) {
-      try {
-        const encrypted = conn.e2e.encrypt(JSON.stringify(msg));
-        innerMsg = { _e2e: true, ...encrypted };
-      } catch (err2) {
-        console.error(`[relay-client] E2E encrypt failed for ${userId} \u2014 dropping message:`, err2);
+  );
+  api.registerGatewayMethod(
+    "squad.version.update",
+    async ({ respond }) => {
+      if (updateInProgress) {
+        respond(false, { error: "Update already in progress" });
         return;
       }
-    }
-    this.sendToRelay({
-      type: "relay.forward",
-      userId,
-      inner: innerMsg
-    });
-  }
-  // ── Pairing ──
-  handlePairingRequest(userId, email) {
-    console.log(`[relay-client] Pairing request from ${email} (${userId})`);
-    this.sendToRelay({
-      type: "relay.pair.status",
-      userId,
-      status: "pending"
-    });
-    console.log(
-      `[relay-client] Pairing request pending for ${email}. The gateway will auto-pair this device if the operator token is valid.`
-    );
-  }
-  // ── E2E Key Exchange ──
-  async handleE2EExchange(userId, browserPublicKey) {
-    console.log(`[relay-client] E2E key exchange with user ${userId}`);
-    const conn = this.userConnections.get(userId);
-    if (!conn) return;
-    try {
-      const e2e = new E2ECrypto();
-      const gatewayPublicKey = await e2e.generateKeyPair();
-      await e2e.deriveSharedSecret(browserPublicKey);
-      conn.e2e = e2e;
-      this.sendToRelay({
-        type: "relay.forward",
-        userId,
-        inner: {
-          type: "relay.e2e.exchange",
-          publicKey: gatewayPublicKey
+      updateInProgress = true;
+      try {
+        const before = getCurrentVersion();
+        const beforeInstalledVersion = readInstalledVersionFromConfig();
+        let latestVersion = null;
+        try {
+          latestVersion = await fetchLatestVersion();
+        } catch {
+          latestVersion = null;
         }
-      });
-      console.log(`[relay-client] E2E established for user ${userId}`);
-    } catch (err2) {
-      console.error(`[relay-client] E2E exchange failed for ${userId}:`, err2);
-    }
-  }
-  // ── Send to Relay ──
-  sendToRelay(msg) {
-    if (!this.relayWs || this.relayWs.readyState !== NodeWebSocket.OPEN) return;
-    try {
-      this.relayWs.send(JSON.stringify(msg));
-    } catch {
-    }
-  }
-  /** Broadcast an event to all connected users, E2E encrypted per-user */
-  broadcastToUsers(event, payload) {
-    const msg = { type: "event", event, payload };
-    for (const [userId, conn] of this.userConnections) {
-      if (!conn.connectHandshakeComplete) continue;
-      let innerMsg = msg;
-      if (conn.e2e) {
+        let updateOutput = "";
+        let configBackup = null;
         try {
-          const encrypted = conn.e2e.encrypt(JSON.stringify(msg));
-          innerMsg = { _e2e: true, ...encrypted };
-        } catch (err2) {
-          console.error(`[relay-client] E2E encrypt failed for broadcast to ${userId} \u2014 skipping:`, err2);
-          continue;
+          configBackup = fs9.readFileSync(CONFIG_PATH, "utf-8");
+        } catch {
+        }
+        runDoctorFixSilently();
+        try {
+          updateOutput = execSync2(
+            `openclaw plugins update ${PACKAGE_NAME} 2>&1`,
+            { timeout: 12e4, encoding: "utf-8" }
+          );
+        } catch (firstErr) {
+          runDoctorFixSilently();
+          try {
+            updateOutput = execSync2(
+              `openclaw plugins update ${PACKAGE_NAME} 2>&1`,
+              { timeout: 12e4, encoding: "utf-8" }
+            );
+          } catch (installErr) {
+            if (configBackup) {
+              try {
+                fs9.writeFileSync(CONFIG_PATH, configBackup, "utf-8");
+              } catch {
+              }
+            }
+            const firstMsg = firstErr instanceof Error ? firstErr.message : String(firstErr);
+            const retryMsg = installErr instanceof Error ? installErr.message : String(installErr);
+            respond(false, {
+              error: `Update failed after doctor fix retry: ${retryMsg}`,
+              output: updateOutput,
+              firstError: firstMsg
+            });
+            return;
+          }
+        }
+        const verification = await waitForVerifiedInstall();
+        if (!verification.ok) {
+          if (configBackup) {
+            try {
+              fs9.writeFileSync(CONFIG_PATH, configBackup, "utf-8");
+            } catch {
+            }
+          }
+          respond(false, {
+            error: `Update verification failed: ${verification.reason ?? "unknown error"}`,
+            output: updateOutput.slice(0, 500),
+            verification
+          });
+          return;
+        }
+        reconcileInstallMetadata(verification);
+        const verificationAfterReconcile = verifyInstalledPluginState();
+        if (beforeInstalledVersion && verificationAfterReconcile.packageVersion && beforeInstalledVersion === verificationAfterReconcile.packageVersion) {
+          const alreadyLatest = !!latestVersion && compareVersions(verificationAfterReconcile.packageVersion, latestVersion) >= 0;
+          respond(false, {
+            error: alreadyLatest ? `Already at latest version (${verificationAfterReconcile.packageVersion}).` : `Update command completed but installed version did not change (${verificationAfterReconcile.packageVersion}).`,
+            output: updateOutput.slice(0, 500),
+            verification: verificationAfterReconcile,
+            latestVersion
+          });
+          return;
+        }
+        const after = getCurrentVersion();
+        respond(true, {
+          previousVersion: before,
+          currentVersion: after,
+          updated: true,
+          restartRequired: true,
+          restartInMs: RESTART_BUFFER_MS,
+          verification: verificationAfterReconcile,
+          latestVersion,
+          output: updateOutput.slice(0, 500)
+        });
+        await sleep(RESTART_BUFFER_MS);
+        console.log(
+          `[version] Plugin update verified (was ${before}), restarting gateway...`
+        );
+        try {
+          execSync2("openclaw gateway restart 2>&1", {
+            timeout: 3e4,
+            encoding: "utf-8"
+          });
+        } catch {
         }
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        respond(false, { error: msg });
+      } finally {
+        updateInProgress = false;
       }
-      this.sendToRelay({
-        type: "relay.forward",
-        userId,
-        inner: innerMsg
-      });
-    }
-  }
-};
-var relayClient = null;
-function startRelayClient(api, relayUrl) {
-  relayClient = new RelayClient({
-    relayUrl
-  });
-  relayClient.start();
-  api.registerGatewayMethod(
-    "squad.relay.status",
-    async ({ respond }) => {
-      respond(true, {
-        connected: relayClient !== null,
-        relayUrl
-      });
     }
   );
-  const cleanup = () => {
-    if (relayClient) {
-      relayClient.destroy();
-      relayClient = null;
-    }
-  };
-  process.on("SIGTERM", cleanup);
-  process.on("SIGINT", cleanup);
-}
-function broadcastToUsers(event, payload) {
-  relayClient?.broadcastToUsers(event, payload);
 }
 
-// src/index.ts
-function squadAppPlugin(api) {
+// src/shared-api.ts
+var CORE_TOOLS = [
+  "exec",
+  "bash",
+  "process",
+  "read",
+  "write",
+  "edit",
+  "apply_patch",
+  "web_search",
+  "web_fetch",
+  "browser",
+  "canvas",
+  "nodes",
+  "image",
+  "message",
+  "cron",
+  "gateway",
+  "sessions_list",
+  "sessions_history",
+  "sessions_send",
+  "sessions_spawn",
+  "session_status",
+  "agents_list",
+  "memory_search"
+];
+var CORE_TOOL_GROUPS = [
+  "group:fs",
+  "group:runtime",
+  "group:sessions",
+  "group:memory",
+  "group:web",
+  "group:ui",
+  "group:automation",
+  "group:messaging",
+  "group:nodes"
+];
+function registerSquadSharedApi(api, onFsChange) {
   const toolExecutors = /* @__PURE__ */ new Map();
   const origRegisterTool = api.registerTool.bind(api);
   api.registerTool = (toolDef) => {
-    if (toolDef.name && typeof toolDef.execute === "function") {
+    if (typeof toolDef.name === "string" && typeof toolDef.execute === "function") {
       toolExecutors.set(toolDef.name, toolDef.execute);
     }
     return origRegisterTool(toolDef);
   };
-  const onFsChange = (evt) => broadcastToUsers("fs.change", evt);
   registerEntityTools(api, onFsChange);
   registerFilesystemTools(api);
   registerSqlTools(api);
   registerVersionMethods(api);
   registerAgentMethods(api);
-  api.registerGatewayMethod(
-    "tools.invoke",
-    async ({ params, respond }) => {
-      const tool = params?.tool;
-      const args = params?.args ?? {};
-      if (!tool) {
-        respond(false, { errorMessage: "Missing 'tool' parameter" });
-        return;
-      }
-      const executeFn = toolExecutors.get(tool);
-      if (!executeFn) {
-        respond(false, { errorMessage: `Unknown tool: ${tool}` });
-        return;
+  const invokeTool = async (tool, args) => {
+    const executeFn = toolExecutors.get(tool);
+    if (!executeFn) {
+      throw new Error(`Unknown tool: ${tool}`);
+    }
+    return executeFn(`internal-${Date.now()}`, args);
+  };
+  const listTools = () => [...CORE_TOOLS, ...CORE_TOOL_GROUPS, ...Array.from(toolExecutors.keys())];
+  const registerCoreGatewayMethods = () => {
+    api.registerGatewayMethod(
+      "tools.invoke",
+      async ({ params, respond }) => {
+        const tool = params?.tool;
+        const args = params?.args ?? {};
+        if (!tool) {
+          respond(false, { errorMessage: "Missing 'tool' parameter" });
+          return;
+        }
+        try {
+          const result = await invokeTool(tool, args);
+          respond(true, result);
+        } catch (err2) {
+          const msg = err2 instanceof Error ? err2.message : String(err2);
+          respond(false, { errorMessage: msg });
+        }
       }
-      try {
-        const result = await executeFn(`ws-${Date.now()}`, args);
-        respond(true, result);
-      } catch (err2) {
-        const msg = err2 instanceof Error ? err2.message : String(err2);
-        respond(false, { errorMessage: msg });
+    );
+    api.registerGatewayMethod(
+      "tools.list",
+      async ({ respond }) => {
+        respond(true, { tools: listTools() });
       }
-    }
-  );
-  api.registerGatewayMethod(
-    "tools.list",
-    async ({ respond }) => {
-      const coreTools = [
-        "exec",
-        "bash",
-        "process",
-        "read",
-        "write",
-        "edit",
-        "apply_patch",
-        "web_search",
-        "web_fetch",
-        "browser",
-        "canvas",
-        "nodes",
-        "image",
-        "message",
-        "cron",
-        "gateway",
-        "sessions_list",
-        "sessions_history",
-        "sessions_send",
-        "sessions_spawn",
-        "session_status",
-        "agents_list",
-        "memory_search"
-      ];
-      const groups = [
-        "group:fs",
-        "group:runtime",
-        "group:sessions",
-        "group:memory",
-        "group:web",
-        "group:ui",
-        "group:automation",
-        "group:messaging",
-        "group:nodes"
-      ];
-      const pluginTools = Array.from(toolExecutors.keys());
-      respond(true, { tools: [...coreTools, ...groups, ...pluginTools] });
-    }
-  );
-  api.registerGatewayMethod(
-    "squad.layout.get",
-    async ({ respond }) => {
-      try {
-        const layout = resolveGatewayLayout();
-        console.log("[squad-openclaw] squad.layout.get", JSON.stringify(layout));
-        respond(true, layout);
-      } catch (err2) {
-        const msg = err2 instanceof Error ? err2.message : String(err2);
-        respond(false, { errorMessage: msg });
+    );
+    api.registerGatewayMethod(
+      "squad.layout.get",
+      async ({ respond }) => {
+        try {
+          const layout = resolveGatewayLayout();
+          respond(true, layout);
+        } catch (err2) {
+          const msg = err2 instanceof Error ? err2.message : String(err2);
+          respond(false, { errorMessage: msg });
+        }
       }
-    }
-  );
+    );
+  };
+  return {
+    invokeTool,
+    listTools,
+    registerCoreGatewayMethods
+  };
+}
+
+// src/index.ts
+function squadAppPlugin(api) {
+  const onFsChange = (evt) => broadcastToUsers("fs.change", evt);
+  const sharedApi = registerSquadSharedApi(api, onFsChange);
+  sharedApi.registerCoreGatewayMethods();
   const relayState = readRelayState();
   const relayEnabled = !!(relayState.claimToken || relayState.roomId);
   if (relayEnabled) {