@getworkle/cli 0.2.12 → 0.3.0

package/dist/cli.js

@@ -1209,8 +1209,8 @@ var require_command = __commonJS({
     "use strict";
     var EventEmitter = __require("events").EventEmitter;
     var childProcess = __require("child_process");
-    var path20 = __require("path");
-    var fs17 = __require("fs");
+    var path11 = __require("path");
+    var fs8 = __require("fs");
     var process2 = __require("process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -2204,7 +2204,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} subcommandName
        */
       _checkForMissingExecutable(executableFile, executableDir, subcommandName) {
-        if (fs17.existsSync(executableFile)) return;
+        if (fs8.existsSync(executableFile)) return;
         const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
         const executableMissing = `'${executableFile}' does not exist
  - if '${subcommandName}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
@@ -2222,11 +2222,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path20.resolve(baseDir, baseName);
-          if (fs17.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path20.extname(baseName))) return void 0;
+          const localBin = path11.resolve(baseDir, baseName);
+          if (fs8.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path11.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs17.existsSync(`${localBin}${ext}`)
+            (ext) => fs8.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -2238,21 +2238,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs17.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs8.realpathSync(this._scriptPath);
           } catch {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path20.resolve(
-            path20.dirname(resolvedScriptPath),
+          executableDir = path11.resolve(
+            path11.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path20.basename(
+            const legacyName = path11.basename(
               this._scriptPath,
-              path20.extname(this._scriptPath)
+              path11.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -2263,7 +2263,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path20.extname(executableFile));
+        launchWithNode = sourceExt.includes(path11.extname(executableFile));
         let proc;
         if (process2.platform !== "win32") {
           if (launchWithNode) {
@@ -3178,7 +3178,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path20.basename(filename, path20.extname(filename));
+        this._name = path11.basename(filename, path11.extname(filename));
         return this;
       }
       /**
@@ -3192,9 +3192,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path21) {
-        if (path21 === void 0) return this._executableDir;
-        this._executableDir = path21;
+      executableDir(path12) {
+        if (path12 === void 0) return this._executableDir;
+        this._executableDir = path12;
         return this;
       }
       /**
@@ -4285,7 +4285,7 @@ var require_background_scheduled_task = __commonJS({
   "../../node_modules/node-cron/src/background-scheduled-task/index.js"(exports, module) {
     "use strict";
     var EventEmitter = __require("events");
-    var path20 = __require("path");
+    var path11 = __require("path");
     var { fork } = __require("child_process");
     var uuid3 = (init_esm_node(), __toCommonJS(esm_node_exports));
     var daemonPath = `${__dirname}/daemon.js`;
@@ -4320,7 +4320,7 @@ var require_background_scheduled_task = __commonJS({
         options.scheduled = true;
         this.forkProcess.send({
           type: "register",
-          path: path20.resolve(this.taskPath),
+          path: path11.resolve(this.taskPath),
           cron: this.cronExpression,
           options
         });
@@ -6600,7 +6600,7 @@ var require_websocket = __commonJS({
     "use strict";
     var EventEmitter = __require("events");
     var https = __require("https");
-    var http3 = __require("http");
+    var http2 = __require("http");
     var net = __require("net");
     var tls = __require("tls");
     var { randomBytes: randomBytes2, createHash: createHash2 } = __require("crypto");
@@ -7131,7 +7131,7 @@ var require_websocket = __commonJS({
       }
       const defaultPort = isSecure ? 443 : 80;
       const key = randomBytes2(16).toString("base64");
-      const request = isSecure ? https.request : http3.request;
+      const request = isSecure ? https.request : http2.request;
       const protocolSet = /* @__PURE__ */ new Set();
       let perMessageDeflate;
       opts.createConnection = opts.createConnection || (isSecure ? tlsConnect : netConnect);
@@ -7625,7 +7625,7 @@ var require_websocket_server = __commonJS({
   "../../node_modules/ws/lib/websocket-server.js"(exports, module) {
     "use strict";
     var EventEmitter = __require("events");
-    var http3 = __require("http");
+    var http2 = __require("http");
     var { Duplex } = __require("stream");
     var { createHash: createHash2 } = __require("crypto");
     var extension = require_extension();
@@ -7696,8 +7696,8 @@ var require_websocket_server = __commonJS({
           );
         }
         if (options.port != null) {
-          this._server = http3.createServer((req, res) => {
-            const body = http3.STATUS_CODES[426];
+          this._server = http2.createServer((req, res) => {
+            const body = http2.STATUS_CODES[426];
             res.writeHead(426, {
               "Content-Length": body.length,
               "Content-Type": "text/plain"
@@ -7984,7 +7984,7 @@ var require_websocket_server = __commonJS({
       this.destroy();
     }
     function abortHandshake(socket, code, message, headers) {
-      message = message || http3.STATUS_CODES[code];
+      message = message || http2.STATUS_CODES[code];
       headers = {
         Connection: "close",
         "Content-Type": "text/html",
@@ -7993,7 +7993,7 @@ var require_websocket_server = __commonJS({
       };
       socket.once("finish", socket.destroy);
       socket.end(
-        `HTTP/1.1 ${code} ${http3.STATUS_CODES[code]}\r
+        `HTTP/1.1 ${code} ${http2.STATUS_CODES[code]}\r
 ` + Object.keys(headers).map((h) => `${h}: ${headers[h]}`).join("\r\n") + "\r\n\r\n" + message
       );
     }
@@ -8027,13 +8027,13 @@ var {
 } = import_index.default;
 
 // src/cli.ts
-import { execSync as execSync2, spawnSync } from "child_process";
+import { execSync, spawnSync } from "child_process";
 import { createHash, randomBytes } from "crypto";
-import { readFileSync } from "fs";
-import fs16 from "fs/promises";
-import http2 from "http";
-import os18 from "os";
-import path19 from "path";
+import { readFileSync as readFileSync2 } from "fs";
+import fs7 from "fs/promises";
+import http from "http";
+import os7 from "os";
+import path10 from "path";
 
 // src/agents/config-materializer.ts
 import fs2 from "fs/promises";
@@ -8151,7 +8151,7 @@ var AgentConfigMaterializer = class {
    */
   async listAgents() {
     const res = await fetch(
-      `${this.apiUrl}/api/claw/instances/${this.instanceId}/runtime/agents`,
+      `${this.apiUrl}/api/local/instances/${this.instanceId}/runtime/agents`,
       { headers: { ...this.headers, "Content-Type": "application/json" } }
     );
     if (!res.ok) {
@@ -8165,7 +8165,7 @@ var AgentConfigMaterializer = class {
    */
   async pullAgent(agentId) {
     const res = await fetch(
-      `${this.apiUrl}/api/claw/instances/${this.instanceId}/runtime/agents/${agentId}/pull`,
+      `${this.apiUrl}/api/local/instances/${this.instanceId}/runtime/agents/${agentId}/pull`,
       { headers: { ...this.headers, "Content-Type": "application/json" } }
     );
     if (!res.ok) {
@@ -8291,19 +8291,27 @@ var AgentConfigMaterializer = class {
 
 // src/agents/runner.ts
 import { query } from "@anthropic-ai/claude-agent-sdk";
-function resolveClaudeCodeExecutable() {
-  const sdkUrl = import.meta.resolve("@anthropic-ai/claude-agent-sdk");
-  const sdkPath = new URL(sdkUrl).pathname;
-  const sdkDir = sdkPath.substring(0, sdkPath.lastIndexOf("/"));
-  return `${sdkDir}/cli.js`;
+import path4 from "path";
+import { fileURLToPath } from "url";
+async function resolveClaudeCodeExecutable() {
+  let sdkEntryPath;
+  try {
+    sdkEntryPath = fileURLToPath(import.meta.resolve("@anthropic-ai/claude-agent-sdk"));
+  } catch {
+    const { createRequire } = await import("module");
+    const localRequire = createRequire(import.meta.url);
+    sdkEntryPath = localRequire.resolve("@anthropic-ai/claude-agent-sdk");
+  }
+  return path4.join(path4.dirname(sdkEntryPath), "cli.js");
 }
 async function runAgent(opts) {
   const { agentDir, prompt, sessionId, maxTurns, permissionMode, model, allowedTools, mcpServers, onMessage, abortController } = opts;
   try {
+    const pathToClaudeCodeExecutable = await resolveClaudeCodeExecutable();
     const stream = query({
       prompt,
       options: {
-        pathToClaudeCodeExecutable: resolveClaudeCodeExecutable(),
+        pathToClaudeCodeExecutable,
         executable: process.execPath,
         // Full path to node — launchd doesn't have node in PATH
         cwd: agentDir,
@@ -9112,10 +9120,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path20) {
-  if (!path20)
+function getElementAtPath(obj, path11) {
+  if (!path11)
     return obj;
-  return path20.reduce((acc, key) => acc?.[key], obj);
+  return path11.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -9481,11 +9489,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path20, issues) {
+function prefixIssues(path11, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path20);
+    iss.path.unshift(path11);
     return iss;
   });
 }
@@ -9647,7 +9655,7 @@ function formatError(error46, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error46, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error47, path20 = []) => {
+  const processError = (error47, path11 = []) => {
     var _a2, _b;
     for (const issue2 of error47.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -9657,7 +9665,7 @@ function treeifyError(error46, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path20, ...issue2.path];
+        const fullpath = [...path11, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -9689,8 +9697,8 @@ function treeifyError(error46, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path20 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path20) {
+  const path11 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path11) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -21026,23 +21034,23 @@ function date4(params) {
 config(en_default());
 
 // src/agents/mcp-server.ts
-async function apiGet(apiUrl, path20, headers) {
-  const res = await fetch(`${apiUrl}${path20}`, {
+async function apiGet(apiUrl, path11, headers) {
+  const res = await fetch(`${apiUrl}${path11}`, {
     headers: { ...headers, "Content-Type": "application/json" }
   });
   if (!res.ok) {
-    throw new Error(`API GET ${path20} failed: HTTP ${res.status}`);
+    throw new Error(`API GET ${path11} failed: HTTP ${res.status}`);
   }
   return res.json();
 }
-async function apiPost(apiUrl, path20, body, headers) {
-  const res = await fetch(`${apiUrl}${path20}`, {
+async function apiPost(apiUrl, path11, body, headers) {
+  const res = await fetch(`${apiUrl}${path11}`, {
     method: "POST",
     headers: { ...headers, "Content-Type": "application/json" },
     body: JSON.stringify(body)
   });
   if (!res.ok) {
-    throw new Error(`API POST ${path20} failed: HTTP ${res.status}`);
+    throw new Error(`API POST ${path11} failed: HTTP ${res.status}`);
   }
   return res.json();
 }
@@ -21063,7 +21071,7 @@ function createWorkleMcpServer(opts) {
       });
       const data = await apiGet(
         apiUrl,
-        `/api/claw/instances/${instanceId}/mcp/contacts?${params.toString()}`,
+        `/api/local/instances/${instanceId}/mcp/contacts?${params.toString()}`,
         headers
       );
       return { content: [{ type: "text", text: JSON.stringify(data) }] };
@@ -21081,7 +21089,7 @@ function createWorkleMcpServer(opts) {
     async (input) => {
       const data = await apiPost(
         apiUrl,
-        `/api/claw/instances/${instanceId}/mcp/activity`,
+        `/api/local/instances/${instanceId}/mcp/activity`,
         input,
         headers
       );
@@ -21102,7 +21110,7 @@ function createWorkleMcpServer(opts) {
       });
       const data = await apiGet(
         apiUrl,
-        `/api/claw/instances/${instanceId}/mcp/documents?${params.toString()}`,
+        `/api/local/instances/${instanceId}/mcp/documents?${params.toString()}`,
         headers
       );
       return { content: [{ type: "text", text: JSON.stringify(data) }] };
@@ -21168,7 +21176,12 @@ var AgentScheduler = class {
 // src/agents/service.ts
 import { randomUUID } from "crypto";
 import fs4 from "fs/promises";
+import path7 from "path";
+
+// src/sync/relay.ts
+import { readFileSync } from "fs";
 import path5 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
 // ../../node_modules/ws/wrapper.mjs
 var import_stream = __toESM(require_stream(), 1);
@@ -21182,6 +21195,39 @@ var wrapper_default = import_websocket.default;
 var MAX_BACKOFF = 3e4;
 var INITIAL_BACKOFF = 1e3;
 var MAX_QUEUE_SIZE = 1e3;
+function readVersionFromJson(pathOrUrl) {
+  try {
+    const raw = readFileSync(pathOrUrl, "utf-8");
+    const parsed = JSON.parse(raw);
+    return typeof parsed.version === "string" ? parsed.version : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function readVersionFromNearestPackageJson(entryPath) {
+  let currentDir = path5.dirname(entryPath);
+  const rootDir = path5.parse(currentDir).root;
+  while (true) {
+    const version3 = readVersionFromJson(path5.join(currentDir, "package.json"));
+    if (version3) {
+      return version3;
+    }
+    if (currentDir === rootDir) {
+      return void 0;
+    }
+    currentDir = path5.dirname(currentDir);
+  }
+}
+var SYNC_VERSION = readVersionFromJson(new URL("../../package.json", import.meta.url));
+var AGENT_SDK_VERSION = (() => {
+  try {
+    return readVersionFromNearestPackageJson(
+      fileURLToPath2(import.meta.resolve("@anthropic-ai/claude-agent-sdk"))
+    );
+  } catch {
+    return void 0;
+  }
+})();
 var RelayClient = class {
   constructor(relayUrl, instanceId, token, options) {
     this.relayUrl = relayUrl;
@@ -21250,7 +21296,7 @@ var RelayClient = class {
   doConnect() {
     return new Promise((resolve, reject) => {
       const url2 = `${this.relayUrl}/${this.instanceId}`;
-      console.log(`[claw] Connecting to relay: ${url2}`);
+      console.log(`[local] Connecting to relay: ${url2}`);
       this.ws = new wrapper_default(url2, {
         headers: {
           Authorization: `Bearer ${this.token}`
@@ -21262,7 +21308,9 @@ var RelayClient = class {
         this.backoff = INITIAL_BACKOFF;
         const hello = {
           type: "hello",
-          instanceId: this.instanceId
+          instanceId: this.instanceId,
+          ...SYNC_VERSION ? { syncVersion: SYNC_VERSION } : {},
+          ...AGENT_SDK_VERSION ? { agentSdkVersion: AGENT_SDK_VERSION } : {}
         };
         this.ws.send(JSON.stringify(hello));
         this.flushQueue();
@@ -21270,7 +21318,7 @@ var RelayClient = class {
           try {
             this.onConnectCallback();
           } catch (err) {
-            console.error("[claw] onConnect callback error:", err);
+            console.error("[local] onConnect callback error:", err);
           }
         }
         if (!resolved) {
@@ -21286,7 +21334,7 @@ var RelayClient = class {
             try {
               handler(msg);
             } catch (err) {
-              console.error("[claw] Relay message handler error:", err);
+              console.error("[local] Relay message handler error:", err);
             }
           }
         } catch {
@@ -21296,20 +21344,20 @@ var RelayClient = class {
       this.ws.on("close", (code, reason) => {
         if (closeHandled) return;
         closeHandled = true;
-        const reasonStr = reason ? Buffer.from(reason).toString("utf-8") : "";
+        const reasonStr = typeof reason === "string" ? reason : reason instanceof Buffer ? reason.toString("utf-8") : "";
         console.log(
-          `[claw] Relay WebSocket closed: code=${code} reason="${reasonStr}"`
+          `[local] Relay WebSocket closed: code=${code} reason="${reasonStr}"`
         );
         this._connected = false;
         this.cleanupWs();
         if (code === 4e3) {
-          console.log("[claw] Connection replaced \u2014 not reconnecting");
+          console.log("[local] Connection replaced \u2014 not reconnecting");
           return;
         }
         this.scheduleReconnect();
       });
       this.ws.on("error", (err) => {
-        console.error("[claw] Relay WebSocket error:", err.message);
+        console.error("[local] Relay WebSocket error:", err.message);
         this._connected = false;
         if (!resolved) {
           resolved = true;
@@ -21332,12 +21380,12 @@ var RelayClient = class {
       clearTimeout(this.reconnectTimer);
     }
     console.log(
-      `[claw] Relay disconnected. Reconnecting in ${this.backoff}ms...`
+      `[local] Relay disconnected. Reconnecting in ${this.backoff}ms...`
     );
     this.reconnectTimer = setTimeout(() => {
       this.reconnectTimer = null;
       this.doConnect().catch((err) => {
-        console.error("[claw] Relay reconnect failed:", err);
+        console.error("[local] Relay reconnect failed:", err);
       });
     }, this.backoff);
     const jitter = Math.random() * 0.3 * this.backoff;
@@ -21351,7 +21399,7 @@ var RelayClient = class {
       this.ws.send(JSON.stringify(msg));
     }
     if (queued.length > 0) {
-      console.log(`[claw] Flushed ${queued.length} queued messages to relay`);
+      console.log(`[local] Flushed ${queued.length} queued messages to relay`);
     }
   }
 };
@@ -21359,8 +21407,8 @@ var RelayClient = class {
 // src/agents/sessions.ts
 import fs3 from "fs/promises";
 import os4 from "os";
-import path4 from "path";
-var SESSIONS_FILE = path4.join(
+import path6 from "path";
+var SESSIONS_FILE = path6.join(
   os4.homedir(),
   ".workle",
   "agent-sessions.json"
@@ -21382,7 +21430,7 @@ async function saveSessionId(agentId, sessionId) {
   } catch {
   }
   map2[agentId] = sessionId;
-  await fs3.mkdir(path4.dirname(SESSIONS_FILE), { recursive: true });
+  await fs3.mkdir(path6.dirname(SESSIONS_FILE), { recursive: true });
   await fs3.writeFile(SESSIONS_FILE, JSON.stringify(map2, null, 2), "utf-8");
 }
 
@@ -21407,7 +21455,7 @@ function stringifyProgressValue(value) {
 function deriveRelayUrl(apiUrl) {
   const url2 = new URL(apiUrl);
   url2.protocol = url2.protocol === "https:" ? "wss:" : "ws:";
-  url2.pathname = "/api/claw/relay";
+  url2.pathname = "/api/local/relay";
   if (url2.hostname !== "localhost") {
     url2.hostname = `relay.${url2.hostname}`;
   }
@@ -21905,12 +21953,12 @@ var AgentService = class _AgentService {
     if (mdFiles.length === 0) return;
     const files = [];
     for (const filename of mdFiles) {
-      const content = await fs4.readFile(path5.join(memoryDir, filename), "utf-8");
+      const content = await fs4.readFile(path7.join(memoryDir, filename), "utf-8");
       files.push({ filename, content });
     }
     const headers = createAuthHeaders(this.token);
     const res = await fetch(
-      `${this.apiUrl}/api/claw/instances/${this.instanceId}/runtime/agents/${agentId}/push-memory`,
+      `${this.apiUrl}/api/local/instances/${this.instanceId}/runtime/agents/${agentId}/push-memory`,
       {
         method: "POST",
         headers: { ...headers, "Content-Type": "application/json" },
@@ -22013,171 +22061,18 @@ async function createAgentService() {
   });
 }
 
-// src/legacy/openclaw/process.ts
-import { spawn } from "child_process";
+// src/lifecycle/doctor.ts
 import fs5 from "fs/promises";
-import http from "http";
 import os5 from "os";
-import path6 from "path";
-var CLAW_HOME = path6.join(os5.homedir(), ".workle");
-var LOG_FILE = path6.join(CLAW_HOME, "openclaw.log");
-var PID_FILE = path6.join(CLAW_HOME, "openclaw.pid");
-var OPENCLAW_PORT = 18789;
-var HEALTH_CHECK_TIMEOUT = 5e3;
-var ProcessManager = class {
-  process = null;
-  logHandle = null;
-  /**
-   * Spawn the OpenClaw gateway process.
-   * Pipes stdout/stderr to a log file and writes PID to disk.
-   *
-   * @param openclawBinary - Path to the openclaw binary (defaults to "openclaw" in PATH)
-   * @param configPath - Path to openclaw.json config (defaults to ~/.workle/openclaw.json)
-   */
-  async spawn(openclawBinary = "openclaw", configPath = path6.join(CLAW_HOME, "openclaw.json")) {
-    if (this.process) {
-      console.log("[claw] OpenClaw process already running");
-      return;
-    }
-    await fs5.mkdir(CLAW_HOME, { recursive: true });
-    this.logHandle = await fs5.open(LOG_FILE, "a");
-    const logFd = this.logHandle.fd;
-    this.process = spawn(openclawBinary, ["--config", configPath], {
-      stdio: ["ignore", logFd, logFd],
-      detached: false,
-      // eslint-disable-next-line no-restricted-properties -- CLI tool needs access to process.env
-      env: { ...process.env }
-    });
-    if (this.process.pid) {
-      await fs5.writeFile(PID_FILE, String(this.process.pid), "utf-8");
-    }
-    this.process.on("exit", (code, signal) => {
-      console.log(
-        `[claw] OpenClaw process exited (code=${code}, signal=${signal})`
-      );
-      this.process = null;
-      if (this.logHandle) {
-        void this.logHandle.close().catch(() => {
-        });
-        this.logHandle = null;
-      }
-      fs5.unlink(PID_FILE).catch(() => {
-      });
-    });
-    this.process.on("error", (err) => {
-      console.error("[claw] Failed to spawn OpenClaw:", err);
-      this.process = null;
-    });
-    console.log(`[claw] OpenClaw spawned (PID: ${this.process.pid})`);
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    if (!this.process) {
-      throw new Error(
-        "OpenClaw process exited immediately. Check logs at " + LOG_FILE
-      );
-    }
-  }
-  /**
-   * Stop the OpenClaw gateway process.
-   */
-  async stop() {
-    if (!this.process) {
-      try {
-        const pidStr = await fs5.readFile(PID_FILE, "utf-8");
-        const pid = parseInt(pidStr.trim(), 10);
-        if (!isNaN(pid)) {
-          process.kill(pid, "SIGTERM");
-          await fs5.unlink(PID_FILE).catch(() => {
-          });
-          console.log(`[claw] Sent SIGTERM to OpenClaw (PID: ${pid})`);
-          return;
-        }
-      } catch {
-      }
-      console.log("[claw] No OpenClaw process to stop");
-      return;
-    }
-    this.process.kill("SIGTERM");
-    console.log("[claw] Sent SIGTERM to OpenClaw");
-    await new Promise((resolve) => {
-      const timer = setTimeout(() => {
-        if (this.process && !this.process.killed) {
-          this.process.kill("SIGKILL");
-          console.log("[claw] Force-killed OpenClaw (SIGKILL)");
-        }
-        resolve();
-      }, 5e3);
-      if (this.process) {
-        this.process.once("exit", () => {
-          clearTimeout(timer);
-          resolve();
-        });
-      } else {
-        clearTimeout(timer);
-        resolve();
-      }
-    });
-    this.process = null;
-    if (this.logHandle) {
-      await this.logHandle.close().catch(() => {
-      });
-      this.logHandle = null;
-    }
-    await fs5.unlink(PID_FILE).catch(() => {
-    });
-  }
-  /**
-   * Restart the OpenClaw gateway process.
-   */
-  async restart(openclawBinary, configPath) {
-    await this.stop();
-    await this.spawn(openclawBinary, configPath);
-  }
-  /**
-   * Check if the OpenClaw gateway is healthy by pinging the loopback port.
-   */
-  async isHealthy() {
-    return new Promise((resolve) => {
-      const req = http.request(
-        {
-          hostname: "127.0.0.1",
-          port: OPENCLAW_PORT,
-          path: "/",
-          method: "GET",
-          timeout: HEALTH_CHECK_TIMEOUT
-        },
-        (res) => {
-          res.resume();
-          resolve(true);
-        }
-      );
-      req.on("error", () => {
-        resolve(false);
-      });
-      req.on("timeout", () => {
-        req.destroy();
-        resolve(false);
-      });
-      req.end();
-    });
-  }
-};
-
-// src/lifecycle/doctor.ts
-import { execSync } from "child_process";
-import fs6 from "fs/promises";
-import os6 from "os";
-import path7 from "path";
-var WORKLE_HOME2 = path7.join(os6.homedir(), ".workle");
+import path8 from "path";
+var WORKLE_HOME2 = path8.join(os5.homedir(), ".workle");
 var MIN_NODE_MAJOR = 22;
 async function runDoctor() {
   const checks = [];
   checks.push(checkNodeVersion());
-  checks.push(checkOpenClawInstalled());
-  checks.push(await checkClawHome());
+  checks.push(await checkLocalHome());
   checks.push(await checkAuthFile());
-  checks.push(await checkConfigFile());
-  checks.push(await checkGatewayReachable());
-  console.log("\n  Workle Claw Doctor\n");
+  console.log("\n  Workle Local Doctor\n");
   for (const check2 of checks) {
     const icon = check2.status === "pass" ? "[OK]" : check2.status === "warn" ? "[WARN]" : "[FAIL]";
     console.log(`  ${icon} ${check2.name}: ${check2.message}`);
@@ -22207,52 +22102,33 @@ function checkNodeVersion() {
     message: `${process.version} \u2014 Node >= ${MIN_NODE_MAJOR} is required`
   };
 }
-function checkOpenClawInstalled() {
-  try {
-    const version3 = execSync("openclaw --version", {
-      encoding: "utf-8",
-      timeout: 5e3
-    }).trim();
-    return {
-      name: "OpenClaw binary",
-      status: "pass",
-      message: `Found: ${version3}`
-    };
-  } catch {
-    return {
-      name: "OpenClaw binary",
-      status: "fail",
-      message: "openclaw not found in PATH. Install from https://openclaw.dev"
-    };
-  }
-}
-async function checkClawHome() {
+async function checkLocalHome() {
   try {
-    const stat = await fs6.stat(WORKLE_HOME2);
+    const stat = await fs5.stat(WORKLE_HOME2);
     if (stat.isDirectory()) {
       return {
-        name: "Claw home directory",
+        name: "Home directory",
         status: "pass",
         message: WORKLE_HOME2
       };
     }
     return {
-      name: "Claw home directory",
+      name: "Home directory",
       status: "fail",
       message: `${WORKLE_HOME2} exists but is not a directory`
     };
   } catch {
     return {
-      name: "Claw home directory",
+      name: "Home directory",
       status: "fail",
       message: `${WORKLE_HOME2} does not exist. Run 'workle setup'`
     };
   }
 }
 async function checkAuthFile() {
-  const authPath = path7.join(WORKLE_HOME2, "auth.json");
+  const authPath = path8.join(WORKLE_HOME2, "auth.json");
   try {
-    const raw = await fs6.readFile(authPath, "utf-8");
+    const raw = await fs5.readFile(authPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.instanceId && parsed.token && parsed.apiUrl) {
       return {
@@ -22274,99 +22150,53 @@ async function checkAuthFile() {
     };
   }
 }
-async function checkConfigFile() {
-  const configPath = path7.join(WORKLE_HOME2, "openclaw.json");
-  try {
-    const raw = await fs6.readFile(configPath, "utf-8");
-    const parsed = JSON.parse(raw);
-    if (parsed.agents) {
-      return {
-        name: "Gateway config",
-        status: "pass",
-        message: configPath
-      };
-    }
-    return {
-      name: "Gateway config",
-      status: "warn",
-      message: "openclaw.json exists but has no agents section"
-    };
-  } catch {
-    return {
-      name: "Gateway config",
-      status: "warn",
-      message: `${configPath} not found. Will be created on first sync`
-    };
-  }
-}
-async function checkGatewayReachable() {
-  try {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), 3e3);
-    const res = await fetch("http://127.0.0.1:18789/", {
-      signal: controller.signal
-    });
-    clearTimeout(timer);
-    return {
-      name: "OpenClaw gateway",
-      status: "pass",
-      message: `Reachable on :18789 (HTTP ${res.status})`
-    };
-  } catch {
-    return {
-      name: "OpenClaw gateway",
-      status: "warn",
-      message: "Not reachable on :18789. Start with 'workle start'"
-    };
-  }
-}
 
 // src/lifecycle/install.ts
-import fs7 from "fs/promises";
-import os7 from "os";
-import path8 from "path";
-var WORKLE_HOME3 = path8.join(os7.homedir(), ".workle");
-var LAUNCH_AGENTS_DIR = path8.join(os7.homedir(), "Library", "LaunchAgents");
-var STAGED_CLI_PATH = path8.join(WORKLE_HOME3, "bin", "cli.js");
+import fs6 from "fs/promises";
+import os6 from "os";
+import path9 from "path";
+var WORKLE_HOME3 = path9.join(os6.homedir(), ".workle");
+var LAUNCH_AGENTS_DIR = path9.join(os6.homedir(), "Library", "LaunchAgents");
+var STAGED_CLI_PATH = path9.join(WORKLE_HOME3, "bin", "cli.js");
 function escapeXml(value) {
   return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
 }
-async function setupClawDirectory() {
+async function setupLocalDirectory() {
   const dirs = [
     WORKLE_HOME3,
-    path8.join(WORKLE_HOME3, "logs"),
-    path8.join(WORKLE_HOME3, "bin")
+    path9.join(WORKLE_HOME3, "logs"),
+    path9.join(WORKLE_HOME3, "bin")
   ];
   for (const dir of dirs) {
-    await fs7.mkdir(dir, { recursive: true, mode: 448 });
-    await fs7.chmod(dir, 448).catch(() => {
+    await fs6.mkdir(dir, { recursive: true, mode: 448 });
+    await fs6.chmod(dir, 448).catch(() => {
     });
   }
-  const gitignorePath = path8.join(WORKLE_HOME3, ".gitignore");
+  const gitignorePath = path9.join(WORKLE_HOME3, ".gitignore");
   try {
-    await fs7.access(gitignorePath);
+    await fs6.access(gitignorePath);
   } catch {
-    await fs7.writeFile(gitignorePath, "*\n", "utf-8");
+    await fs6.writeFile(gitignorePath, "*\n", "utf-8");
   }
-  console.log(`[claw] Directory structure created at ${WORKLE_HOME3}`);
+  console.log(`[local] Directory structure created at ${WORKLE_HOME3}`);
 }
 async function stageCliForDaemon(currentCliPath) {
   if (!currentCliPath) {
     throw new Error("Cannot determine the current CLI path for daemon install.");
   }
-  await setupClawDirectory();
+  await setupLocalDirectory();
   const isNpxCache = currentCliPath.includes("/_npx/") || currentCliPath.includes("\\_npx\\");
   if (!isNpxCache) {
     return currentCliPath;
   }
-  await fs7.copyFile(currentCliPath, STAGED_CLI_PATH);
-  await fs7.chmod(STAGED_CLI_PATH, 448).catch(() => {
+  await fs6.copyFile(currentCliPath, STAGED_CLI_PATH);
+  await fs6.chmod(STAGED_CLI_PATH, 448).catch(() => {
   });
   return STAGED_CLI_PATH;
 }
-async function writeLaunchdPlist(serviceName = "com.workle.claw", executable = process.execPath, args = [STAGED_CLI_PATH, "start"]) {
-  await fs7.mkdir(LAUNCH_AGENTS_DIR, { recursive: true });
-  const plistPath = path8.join(LAUNCH_AGENTS_DIR, `${serviceName}.plist`);
+async function writeLaunchdPlist(serviceName = "com.workle.local", executable = process.execPath, args = [STAGED_CLI_PATH, "start"]) {
+  await fs6.mkdir(LAUNCH_AGENTS_DIR, { recursive: true });
+  const plistPath = path9.join(LAUNCH_AGENTS_DIR, `${serviceName}.plist`);
   const programArguments = [executable, ...args].map((arg) => `    <string>${escapeXml(arg)}</string>`).join("\n");
   const plist = `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
@@ -22390,10 +22220,10 @@ ${programArguments}
   </dict>
 
   <key>StandardOutPath</key>
-  <string>${path8.join(WORKLE_HOME3, "logs", "stdout.log")}</string>
+  <string>${path9.join(WORKLE_HOME3, "logs", "stdout.log")}</string>
 
   <key>StandardErrorPath</key>
-  <string>${path8.join(WORKLE_HOME3, "logs", "stderr.log")}</string>
+  <string>${path9.join(WORKLE_HOME3, "logs", "stderr.log")}</string>
 
   <key>WorkingDirectory</key>
   <string>${WORKLE_HOME3}</string>
@@ -22403,867 +22233,19 @@ ${programArguments}
 </dict>
 </plist>
 `;
-  await fs7.writeFile(plistPath, plist, "utf-8");
-  console.log(`[claw] Launchd plist written to ${plistPath}`);
+  await fs6.writeFile(plistPath, plist, "utf-8");
+  console.log(`[local] Launchd plist written to ${plistPath}`);
   console.log(
-    `[claw] To enable: launchctl load ${plistPath}`
+    `[local] To enable: launchctl load ${plistPath}`
   );
   return plistPath;
 }
 
 // src/sync/service.ts
-import fs15 from "fs/promises";
-import os17 from "os";
-import path18 from "path";
-
-// src/legacy/openclaw/gateway.ts
-import os8 from "os";
-import path9 from "path";
-var CLAW_HOME2 = path9.join(os8.homedir(), ".workle");
-function generateGatewayConfig(_instance, agents) {
-  const sorted = [...agents].sort((a, b) => a.sortOrder - b.sortOrder);
-  const list = sorted.map((agent) => ({
-    id: agent.id,
-    default: !agent.isSubAgent,
-    workspace: path9.join(CLAW_HOME2, `workspace-${agent.agentKey}`),
-    model: agent.model,
-    toolProfile: agent.toolProfile,
-    promptMode: agent.promptMode
-  }));
-  return {
-    agents: { list }
-  };
-}
-
-// src/legacy/openclaw/soul.ts
-import fs8 from "fs/promises";
-import os9 from "os";
-import path10 from "path";
-var CLAW_HOME3 = path10.join(os9.homedir(), ".workle");
-var DEFAULT_SOUL_MD = `# Soul
-
-You are a Workle agent. Follow your assigned skills and operational instructions.
-Be helpful, accurate, and concise. Always use available tools before guessing.
-`;
-async function writeSoulMd(agentKey, content, rpcCall) {
-  const body = content?.trim() ? content : DEFAULT_SOUL_MD;
-  if (rpcCall) {
-    await rpcCall(agentKey, "SOUL.md", body);
-    return;
-  }
-  const workspaceDir = path10.join(CLAW_HOME3, `workspace-${agentKey}`);
-  await fs8.mkdir(workspaceDir, { recursive: true });
-  const filePath = path10.join(workspaceDir, "SOUL.md");
-  await fs8.writeFile(filePath, body, "utf-8");
-}
-
-// src/legacy/openclaw/agents.ts
-import fs9 from "fs/promises";
-import os10 from "os";
-import path11 from "path";
-var CLAW_HOME4 = path11.join(os10.homedir(), ".workle");
-var DEFAULT_AGENTS_MD = `# Agents
-
-No additional agent configuration provided.
-`;
-async function writeAgentsMd(agentKey, content, rpcCall) {
-  const body = content?.trim() ? content : DEFAULT_AGENTS_MD;
-  if (rpcCall) {
-    await rpcCall(agentKey, "AGENTS.md", body);
-    return;
-  }
-  const workspaceDir = path11.join(CLAW_HOME4, `workspace-${agentKey}`);
-  await fs9.mkdir(workspaceDir, { recursive: true });
-  const filePath = path11.join(workspaceDir, "AGENTS.md");
-  await fs9.writeFile(filePath, body, "utf-8");
-}
-
-// src/config/identity.ts
-import fs10 from "fs/promises";
-import os11 from "os";
-import path12 from "path";
-var WORKLE_HOME4 = path12.join(os11.homedir(), ".workle");
-var DEFAULT_IDENTITY_MD = `# Identity
-
-No identity configuration provided.
-`;
-async function writeIdentityMd(agentKey, content, rpcCall) {
-  const body = content?.trim() ? content : DEFAULT_IDENTITY_MD;
-  if (rpcCall) {
-    await rpcCall(agentKey, "IDENTITY.md", body);
-    return;
-  }
-  const workspaceDir = path12.join(WORKLE_HOME4, `workspace-${agentKey}`);
-  await fs10.mkdir(workspaceDir, { recursive: true });
-  const filePath = path12.join(workspaceDir, "IDENTITY.md");
-  await fs10.writeFile(filePath, body, "utf-8");
-}
-
-// src/config/heartbeat.ts
-import fs11 from "fs/promises";
-import os12 from "os";
-import path13 from "path";
-var WORKLE_HOME5 = path13.join(os12.homedir(), ".workle");
-var DEFAULT_HEARTBEAT_MD = `# Heartbeat
-
-No heartbeat configuration provided.
-`;
-async function writeHeartbeatMd(agentKey, content, rpcCall) {
-  const body = content?.trim() ? content : DEFAULT_HEARTBEAT_MD;
-  if (rpcCall) {
-    await rpcCall(agentKey, "HEARTBEAT.md", body);
-    return;
-  }
-  const workspaceDir = path13.join(WORKLE_HOME5, `workspace-${agentKey}`);
-  await fs11.mkdir(workspaceDir, { recursive: true });
-  const filePath = path13.join(workspaceDir, "HEARTBEAT.md");
-  await fs11.writeFile(filePath, body, "utf-8");
-}
-
-// src/config/skills.ts
-import fs12 from "fs/promises";
-import os13 from "os";
-import path14 from "path";
-var WORKLE_HOME6 = path14.join(os13.homedir(), ".workle");
-
-// src/legacy/openclaw/rpc.ts
-import crypto4 from "crypto";
-import fs13 from "fs";
-import os14 from "os";
-import path15 from "path";
-var OPENCLAW_PORT2 = 18789;
-var OPENCLAW_URL = `ws://127.0.0.1:${OPENCLAW_PORT2}`;
-var RPC_TIMEOUT = 3e4;
-var MAX_RECONNECT_BACKOFF = 1e4;
-var CLAW_VERSION = "0.1.16";
-var OPENCLAW_CONFIG_PATHS = [
-  () => path15.join(os14.homedir(), ".openclaw", "openclaw.json"),
-  () => path15.join(os14.homedir(), ".config", "openclaw", "openclaw.json")
-];
-var CLAW_IDENTITY_DIR = path15.join(os14.homedir(), ".workle");
-var CLAW_IDENTITY_FILE = path15.join(CLAW_IDENTITY_DIR, "device-identity.json");
-var ED25519_SPKI_PREFIX = Buffer.from("302a300506032b6570032100", "hex");
-function base64UrlEncode(buf) {
-  return buf.toString("base64").replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/g, "");
-}
-function derivePublicKeyRaw(publicKeyPem) {
-  const key = crypto4.createPublicKey(publicKeyPem);
-  const spki = key.export({ type: "spki", format: "der" });
-  if (spki.length === ED25519_SPKI_PREFIX.length + 32 && spki.subarray(0, ED25519_SPKI_PREFIX.length).equals(ED25519_SPKI_PREFIX)) {
-    return spki.subarray(ED25519_SPKI_PREFIX.length);
-  }
-  return spki;
-}
-function fingerprintPublicKey(publicKeyPem) {
-  const raw = derivePublicKeyRaw(publicKeyPem);
-  return crypto4.createHash("sha256").update(raw).digest("hex");
-}
-function loadOrCreateDeviceIdentity() {
-  try {
-    if (fs13.existsSync(CLAW_IDENTITY_FILE)) {
-      const raw = fs13.readFileSync(CLAW_IDENTITY_FILE, "utf8");
-      const parsed = JSON.parse(raw);
-      if (parsed?.version === 1 && typeof parsed.deviceId === "string" && typeof parsed.publicKeyPem === "string" && typeof parsed.privateKeyPem === "string") {
-        const derivedId = fingerprintPublicKey(parsed.publicKeyPem);
-        const deviceId2 = derivedId === parsed.deviceId ? parsed.deviceId : derivedId;
-        console.log(`[claw] Loaded device identity: ${deviceId2.slice(0, 12)}...`);
-        return {
-          deviceId: deviceId2,
-          publicKeyPem: parsed.publicKeyPem,
-          privateKeyPem: parsed.privateKeyPem
-        };
-      }
-    }
-  } catch {
-  }
-  const { publicKey, privateKey } = crypto4.generateKeyPairSync("ed25519");
-  const publicKeyPem = publicKey.export({ type: "spki", format: "pem" }).toString();
-  const privateKeyPem = privateKey.export({ type: "pkcs8", format: "pem" }).toString();
-  const deviceId = fingerprintPublicKey(publicKeyPem);
-  fs13.mkdirSync(CLAW_IDENTITY_DIR, { recursive: true });
-  const stored = {
-    version: 1,
-    deviceId,
-    publicKeyPem,
-    privateKeyPem,
-    createdAtMs: Date.now()
-  };
-  fs13.writeFileSync(CLAW_IDENTITY_FILE, `${JSON.stringify(stored, null, 2)}
-`, { mode: 384 });
-  try {
-    fs13.chmodSync(CLAW_IDENTITY_FILE, 384);
-  } catch {
-  }
-  console.log(`[claw] Generated new device identity: ${deviceId.slice(0, 12)}...`);
-  return { deviceId, publicKeyPem, privateKeyPem };
-}
-function buildDeviceAuthPayload(params) {
-  return [
-    "v2",
-    params.deviceId,
-    params.clientId,
-    params.clientMode,
-    params.role,
-    params.scopes.join(","),
-    String(params.signedAtMs),
-    params.token,
-    params.nonce
-  ].join("|");
-}
-function signPayload(privateKeyPem, payload) {
-  const key = crypto4.createPrivateKey(privateKeyPem);
-  const sig = crypto4.sign(null, Buffer.from(payload, "utf8"), key);
-  return base64UrlEncode(sig);
-}
-function readGatewayAuth() {
-  const envToken = process.env.OPENCLAW_GATEWAY_TOKEN?.trim() || process.env.CLAWDBOT_GATEWAY_TOKEN?.trim();
-  if (envToken) {
-    console.log("[claw] Using gateway token from environment variable");
-    return { token: envToken };
-  }
-  const envPassword = process.env.OPENCLAW_GATEWAY_PASSWORD?.trim() || process.env.CLAWDBOT_GATEWAY_PASSWORD?.trim();
-  if (envPassword) {
-    console.log("[claw] Using gateway password from environment variable");
-    return { password: envPassword };
-  }
-  for (const getPath of OPENCLAW_CONFIG_PATHS) {
-    try {
-      const configPath = getPath();
-      const raw = fs13.readFileSync(configPath, "utf-8");
-      const config2 = JSON.parse(raw);
-      const token = config2.gateway?.auth?.token?.trim();
-      const password = config2.gateway?.auth?.password?.trim();
-      if (token || password) {
-        console.log(
-          `[claw] Using gateway ${token ? "token" : "password"} from ${configPath}`
-        );
-        return { token: token || void 0, password: password || void 0 };
-      }
-    } catch {
-    }
-  }
-  console.warn(
-    "[claw] \u26A0 No gateway auth found! Set OPENCLAW_GATEWAY_TOKEN or configure gateway.auth.token in ~/.openclaw/openclaw.json"
-  );
-  return void 0;
-}
-var OpenClawRpcClient = class {
-  ws = null;
-  pendingCalls = /* @__PURE__ */ new Map();
-  eventHandlers = [];
-  callCounter = 0;
-  _connected = false;
-  /** True after the connect handshake completes (hello-ok received) */
-  _handshakeComplete = false;
-  shouldReconnect = false;
-  reconnectTimer = null;
-  reconnectBackoff = 1e3;
-  get connected() {
-    return this._connected && this._handshakeComplete;
-  }
-  /**
-   * Connect to the OpenClaw gateway WebSocket and complete the handshake.
-   */
-  async connect() {
-    if (this.ws && this._connected && this._handshakeComplete) return;
-    this.shouldReconnect = true;
-    return this.doConnect();
-  }
-  doConnect() {
-    return new Promise((resolve, reject) => {
-      let resolved = false;
-      this._handshakeComplete = false;
-      let challengeNonce;
-      this.ws = new wrapper_default(OPENCLAW_URL);
-      this.ws.on("open", () => {
-        console.log("[claw] OpenClaw RPC WebSocket opened");
-        this._connected = true;
-        this.reconnectBackoff = 1e3;
-      });
-      this.ws.on("message", (data) => {
-        try {
-          const text = typeof data === "string" ? data : Buffer.from(data).toString("utf-8");
-          const frame = JSON.parse(text);
-          if (frame.type === "res") {
-            if (!this._handshakeComplete && frame.ok) {
-              this._handshakeComplete = true;
-              console.log("[claw] OpenClaw handshake complete");
-              if (!resolved) {
-                resolved = true;
-                resolve();
-              }
-              return;
-            }
-            if (!this._handshakeComplete && !frame.ok) {
-              const errMsg = frame.error?.message ?? "handshake rejected";
-              console.error(`[claw] OpenClaw handshake failed: ${errMsg}`);
-              if (!resolved) {
-                resolved = true;
-                reject(new Error(`Gateway handshake failed: ${errMsg}`));
-              }
-              return;
-            }
-            this.handleResponse(frame);
-          } else if (frame.type === "event") {
-            if (frame.event === "connect.challenge" && !this._handshakeComplete) {
-              const payload = frame.payload;
-              challengeNonce = payload?.nonce;
-              console.log("[claw] Received connect.challenge, sending handshake...");
-              this.sendConnectHandshake(challengeNonce);
-              return;
-            }
-            this.handleEvent(frame);
-          }
-        } catch {
-        }
-      });
-      this.ws.on("close", (code, reason) => {
-        const reasonStr = reason ? Buffer.from(reason).toString("utf-8") : "";
-        console.log(
-          `[claw] OpenClaw RPC WebSocket closed: code=${code} reason="${reasonStr}"`
-        );
-        this._connected = false;
-        this._handshakeComplete = false;
-        this.rejectAllPending(new Error("WebSocket connection closed"));
-        if (!resolved) {
-          resolved = true;
-          reject(new Error(`Gateway closed during handshake: ${reasonStr}`));
-        }
-        this.scheduleReconnect();
-      });
-      this.ws.on("error", (err) => {
-        this._connected = false;
-        this._handshakeComplete = false;
-        if (!resolved) {
-          resolved = true;
-          reject(err);
-        }
-      });
-    });
-  }
-  /**
-   * Send the connect handshake required by the OpenClaw gateway protocol.
-   *
-   * Flow:
-   * 1. Gateway sends connect.challenge with { nonce, ts }
-   * 2. Client builds device identity + signs the nonce
-   * 3. Client sends connect request with device, auth, role, and scopes
-   * 4. Gateway auto-approves pairing for loopback connections (silent)
-   * 5. Gateway responds with hello-ok including granted scopes
-   *
-   * CRITICAL: The gateway strips ALL self-declared scopes from connections
-   * that lack a signed device identity, even if the auth token is valid.
-   * The device identity is what binds scopes to a connection.
-   */
-  sendConnectHandshake(challengeNonce) {
-    const gatewayAuth = readGatewayAuth();
-    const identity = loadOrCreateDeviceIdentity();
-    const role = "operator";
-    const scopes = ["operator.admin"];
-    const signedAtMs = Date.now();
-    const authToken = gatewayAuth?.token ?? "";
-    const payload = buildDeviceAuthPayload({
-      deviceId: identity.deviceId,
-      clientId: "gateway-client",
-      clientMode: "backend",
-      role,
-      scopes,
-      signedAtMs,
-      token: authToken,
-      nonce: challengeNonce ?? ""
-    });
-    const signature = signPayload(identity.privateKeyPem, payload);
-    const publicKeyBase64Url = base64UrlEncode(derivePublicKeyRaw(identity.publicKeyPem));
-    const connectFrame = {
-      type: "req",
-      id: `rpc_connect_${Date.now()}`,
-      method: "connect",
-      params: {
-        minProtocol: 3,
-        maxProtocol: 3,
-        client: {
-          id: "gateway-client",
-          displayName: "Workle Claw",
-          version: CLAW_VERSION,
-          platform: "node",
-          mode: "backend"
-        },
-        role,
-        scopes,
-        device: {
-          id: identity.deviceId,
-          publicKey: publicKeyBase64Url,
-          signature,
-          signedAt: signedAtMs,
-          nonce: challengeNonce ?? void 0
-        },
-        ...gatewayAuth ? { auth: gatewayAuth } : {}
-      }
-    };
-    const authKind = gatewayAuth?.token ? "token" : gatewayAuth?.password ? "password" : "none";
-    console.log(
-      `[claw] Sending connect handshake (auth=${authKind}, device=${identity.deviceId.slice(0, 12)}..., scopes=operator.admin)`
-    );
-    this.ws.send(JSON.stringify(connectFrame));
-  }
-  scheduleReconnect() {
-    if (!this.shouldReconnect) return;
-    if (this.reconnectTimer) return;
-    this.reconnectTimer = setTimeout(() => {
-      this.reconnectTimer = null;
-      this.doConnect().catch(() => {
-      });
-    }, this.reconnectBackoff);
-    this.reconnectBackoff = Math.min(
-      this.reconnectBackoff * 2,
-      MAX_RECONNECT_BACKOFF
-    );
-  }
-  /**
-   * Disconnect from the OpenClaw gateway.
-   */
-  disconnect() {
-    this.shouldReconnect = false;
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-    if (this.ws) {
-      this.ws.close();
-      this.ws = null;
-      this._connected = false;
-      this._handshakeComplete = false;
-      this.rejectAllPending(new Error("Client disconnected"));
-    }
-  }
-  /**
-   * Get the current gateway configuration.
-   */
-  async configGet() {
-    return this.call("config.get", {});
-  }
-  /**
-   * Patch the gateway configuration.
-   */
-  async configPatch(patch, baseHash) {
-    return this.call("config.patch", { patch, baseHash });
-  }
-  /**
-   * List all agents known to the gateway.
-   */
-  async agentsList() {
-    return this.call("agents.list", {});
-  }
-  /**
-   * Send a chat message to an agent.
-   */
-  async chatSend(message, agentId) {
-    return this.call("chat.send", { message, agentId });
-  }
-  /**
-   * Get chat history for an agent.
-   */
-  async chatHistory(agentId) {
-    return this.call("chat.history", { agentId });
-  }
-  /**
-   * Get a file from an agent's workspace.
-   */
-  async agentFilesGet(agentId, name) {
-    return this.call("agents.files.get", { agentId, name });
-  }
-  /**
-   * Set (write) a file in an agent's workspace.
-   */
-  async agentFilesSet(agentId, name, content) {
-    return this.call("agents.files.set", { agentId, name, content });
-  }
-  /**
-   * Create a new agent.
-   */
-  async agentsCreate(name, workspace) {
-    return this.call("agents.create", { name, workspace });
-  }
-  /**
-   * Update an existing agent.
-   */
-  async agentsUpdate(agentId, patch) {
-    return this.call("agents.update", { agentId, ...patch });
-  }
-  /**
-   * Delete an agent.
-   */
-  async agentsDelete(agentId) {
-    return this.call("agents.delete", { agentId });
-  }
-  /**
-   * List cron jobs.
-   */
-  async cronList(params) {
-    return this.call("cron.list", params ?? {});
-  }
-  /**
-   * Add a cron job.
-   */
-  async cronAdd(params) {
-    return this.call("cron.add", params);
-  }
-  /**
-   * Update a cron job.
-   */
-  async cronUpdate(id, patch) {
-    return this.call("cron.update", { id, ...patch });
-  }
-  /**
-   * Remove a cron job.
-   */
-  async cronRemove(id) {
-    return this.call("cron.remove", { id });
-  }
-  /**
-   * Run a cron job immediately.
-   */
-  async cronRun(id, mode) {
-    return this.call("cron.run", { id, ...mode ? { mode } : {} });
-  }
-  /**
-   * Get skills status for an agent (or all agents).
-   */
-  async skillsStatus(agentId) {
-    return this.call("skills.status", agentId ? { agentId } : {});
-  }
-  /**
-   * Update skills configuration.
-   */
-  async skillsUpdate(params) {
-    return this.call("skills.update", params);
-  }
-  /**
-   * Get the tool catalog for an agent (or all agents).
-   */
-  async toolsCatalog(agentId) {
-    return this.call("tools.catalog", agentId ? { agentId } : {});
-  }
-  /**
-   * List available models.
-   */
-  async modelsList() {
-    return this.call("models.list", {});
-  }
-  /**
-   * Subscribe to OpenClaw events. The handler receives all events.
-   */
-  subscribeEvents(handler) {
-    this.eventHandlers.push(handler);
-    return () => {
-      this.eventHandlers = this.eventHandlers.filter((h) => h !== handler);
-    };
-  }
-  // --- Internal ---
-  async call(method, params) {
-    if (!this.ws || !this._connected || !this._handshakeComplete) {
-      throw new Error("Not connected to OpenClaw gateway");
-    }
-    const id = `rpc_${++this.callCounter}_${Date.now()}`;
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        this.pendingCalls.delete(id);
-        reject(new Error(`RPC call ${method} timed out after ${RPC_TIMEOUT}ms`));
-      }, RPC_TIMEOUT);
-      this.pendingCalls.set(id, { resolve, reject, timer });
-      const frame = { type: "req", id, method, params };
-      this.ws.send(JSON.stringify(frame));
-    });
-  }
-  handleResponse(frame) {
-    const pending = this.pendingCalls.get(frame.id);
-    if (!pending) return;
-    clearTimeout(pending.timer);
-    this.pendingCalls.delete(frame.id);
-    if (!frame.ok || frame.error) {
-      pending.reject(
-        new Error(
-          `RPC error ${frame.error?.code ?? "unknown"}: ${frame.error?.message ?? "Unknown error"}`
-        )
-      );
-    } else {
-      pending.resolve(frame.payload);
-    }
-  }
-  handleEvent(frame) {
-    const event = {
-      type: "event",
-      name: frame.event,
-      data: frame.payload ?? {}
-    };
-    for (const handler of this.eventHandlers) {
-      try {
-        handler(event);
-      } catch (err) {
-        console.error("[claw] Event handler error:", err);
-      }
-    }
-  }
-  rejectAllPending(error46) {
-    for (const [id, pending] of this.pendingCalls) {
-      clearTimeout(pending.timer);
-      pending.reject(error46);
-      this.pendingCalls.delete(id);
-    }
-  }
-};
-
-// src/sync/discovery.ts
-async function agentDiscovery(rpc, apiUrl, instanceId, token) {
-  const result = await rpc.agentsList();
-  console.log(
-    `[claw] agents.list returned ${result.agents?.length ?? 0} agents (default=${result.defaultId})`
-  );
-  const agents = (result.agents ?? []).map((agent) => ({
-    name: agent.id,
-    // OpenClaw agent id IS the agent key/name
-    isDefault: agent.id === result.defaultId
-  }));
-  const res = await fetch(
-    `${apiUrl}/api/claw/instances/${instanceId}/sync-agents`,
-    {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${token}`
-      },
-      body: JSON.stringify({ agents })
-    }
-  );
-  if (!res.ok) {
-    const body = await res.text().catch(() => "");
-    throw new Error(
-      `Agent discovery sync failed: ${res.status} ${res.statusText} \u2014 ${body}`
-    );
-  }
-  const syncResult = await res.json();
-  console.log(
-    `[claw] Agent discovery: ${syncResult.created} created, ${syncResult.deleted} deleted`
-  );
-  return syncResult;
-}
-
-// src/sync/events.ts
-import os16 from "os";
-import path17 from "path";
-
-// src/sync/queue.ts
-import fs14 from "fs/promises";
-import os15 from "os";
-import path16 from "path";
-var MAX_FILE_SIZE = 5e8;
-var PersistentEventQueue = class {
-  filePath;
-  constructor(customPath) {
-    this.filePath = customPath ?? path16.join(os15.homedir(), ".workle", "pending-events.jsonl");
-  }
-  /**
-   * Append a single entry to the queue file.
-   */
-  async append(entry) {
-    await this.ensureDir();
-    const currentSize = await this.size();
-    if (currentSize > MAX_FILE_SIZE) {
-      await this.evictOldestHalf();
-    }
-    const line = JSON.stringify(entry) + "\n";
-    await fs14.appendFile(this.filePath, line, "utf-8");
-  }
-  /**
-   * Read and return all entries in chronological order.
-   */
-  async replay() {
-    let raw;
-    try {
-      raw = await fs14.readFile(this.filePath, "utf-8");
-    } catch {
-      return [];
-    }
-    const lines = raw.split("\n").filter((l) => l.trim().length > 0);
-    const entries = [];
-    for (const line of lines) {
-      try {
-        entries.push(JSON.parse(line));
-      } catch {
-      }
-    }
-    return entries;
-  }
-  /**
-   * Remove the first `upToIndex` entries from the file (0-based exclusive).
-   * E.g., truncate(3) removes entries at index 0, 1, 2.
-   */
-  async truncate(upToIndex) {
-    if (upToIndex <= 0) return;
-    let raw;
-    try {
-      raw = await fs14.readFile(this.filePath, "utf-8");
-    } catch {
-      return;
-    }
-    const lines = raw.split("\n").filter((l) => l.trim().length > 0);
-    const remaining = lines.slice(upToIndex);
-    if (remaining.length === 0) {
-      await fs14.writeFile(this.filePath, "", "utf-8");
-    } else {
-      await fs14.writeFile(this.filePath, remaining.join("\n") + "\n", "utf-8");
-    }
-  }
-  /**
-   * Return the current file size in bytes, or 0 if the file does not exist.
-   */
-  async size() {
-    try {
-      const stats = await fs14.stat(this.filePath);
-      return stats.size;
-    } catch {
-      return 0;
-    }
-  }
-  // --- Internal ---
-  async ensureDir() {
-    const dir = path16.dirname(this.filePath);
-    await fs14.mkdir(dir, { recursive: true });
-  }
-  /**
-   * Evict the oldest half of entries when the file exceeds the size cap.
-   */
-  async evictOldestHalf() {
-    let raw;
-    try {
-      raw = await fs14.readFile(this.filePath, "utf-8");
-    } catch {
-      return;
-    }
-    const lines = raw.split("\n").filter((l) => l.trim().length > 0);
-    const halfIndex = Math.ceil(lines.length / 2);
-    const remaining = lines.slice(halfIndex);
-    if (remaining.length === 0) {
-      await fs14.writeFile(this.filePath, "", "utf-8");
-    } else {
-      await fs14.writeFile(this.filePath, remaining.join("\n") + "\n", "utf-8");
-    }
-    console.log(
-      `[claw] Queue size exceeded ${MAX_FILE_SIZE} bytes. Evicted ${halfIndex} oldest entries.`
-    );
-  }
-};
-
-// src/sync/events.ts
-var WORKLE_HOME7 = path17.join(os16.homedir(), ".workle");
-var EVENT_TYPE_MAP = {
-  "agent.run": "agent.started",
-  "agent.run.complete": "agent.completed",
-  tool: "tool.executed",
-  "tool.error": "tool.errored",
-  turn: "agent.turn",
-  "turn.complete": "agent.turn.complete",
-  "session.start": "session.lifecycle",
-  "session.end": "session.lifecycle",
-  "session.pause": "session.lifecycle",
-  "session.resume": "session.lifecycle",
-  "config.changed": "config.synced",
-  "config.reload": "config.synced"
-};
-function mapOpenClawEvent(event, instanceId) {
-  const eventType = EVENT_TYPE_MAP[event.name];
-  if (!eventType) return null;
-  const agentId = typeof event.data.agentId === "string" ? event.data.agentId : void 0;
-  const summary = typeof event.data.summary === "string" ? event.data.summary : void 0;
-  return {
-    eventType,
-    subjectType: agentId ? "claw.agent" : "claw.instance",
-    subjectId: agentId ?? instanceId,
-    summary,
-    actorType: "device",
-    actorId: `claw_${instanceId}`,
-    metadata: {
-      ...event.data,
-      clawInstanceId: instanceId,
-      sourceEvent: event.name,
-      occurredAt: (/* @__PURE__ */ new Date()).toISOString()
-    }
-  };
-}
-var sharedQueues = /* @__PURE__ */ new Map();
-function getQueue(instanceId) {
-  const queueKey = instanceId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  const existing = sharedQueues.get(queueKey);
-  if (existing) return existing;
-  const queue = new PersistentEventQueue(
-    path17.join(WORKLE_HOME7, `pending-events-${queueKey}.jsonl`)
-  );
-  sharedQueues.set(queueKey, queue);
-  return queue;
-}
-async function deliverPayload(endpoint, token, payload) {
-  try {
-    const res = await fetch(endpoint, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${token}`
-      },
-      body: JSON.stringify(payload)
-    });
-    return res.ok || res.status === 400;
-  } catch {
-    return false;
-  }
-}
-function createEventForwarder(apiUrl, token, instanceId) {
-  const endpoint = `${apiUrl}/api/claw/instances/${instanceId}/activity`;
-  const queue = getQueue(instanceId);
-  return (event) => {
-    const payload = mapOpenClawEvent(event, instanceId);
-    if (!payload) return;
-    const entry = {
-      ts: (/* @__PURE__ */ new Date()).toISOString(),
-      event: event.name,
-      payload,
-      instanceId
-    };
-    void (async () => {
-      const success2 = await deliverPayload(endpoint, token, payload);
-      if (!success2) {
-        await queue.append(entry);
-      }
-    })();
-  };
-}
-async function replayPendingEvents(apiUrl, token, instanceId) {
-  const endpoint = `${apiUrl}/api/claw/instances/${instanceId}/activity`;
-  const queue = getQueue(instanceId);
-  const entries = await queue.replay();
-  if (entries.length === 0) return;
-  console.log(`[claw] Replaying ${entries.length} pending events...`);
-  let deliveredCount = 0;
-  for (const entry of entries) {
-    const payload = entry.payload;
-    const success2 = await deliverPayload(endpoint, token, payload);
-    if (success2) {
-      deliveredCount++;
-    } else {
-      break;
-    }
-  }
-  if (deliveredCount > 0) {
-    await queue.truncate(deliveredCount);
-    console.log(`[claw] Replayed ${deliveredCount}/${entries.length} events`);
-  }
-}
-
-// src/sync/service.ts
-var WORKLE_HOME8 = path18.join(os17.homedir(), ".workle");
 function deriveRelayUrl2(apiUrl) {
   const url2 = new URL(apiUrl);
   url2.protocol = url2.protocol === "https:" ? "wss:" : "ws:";
-  url2.pathname = "/api/claw/relay";
+  url2.pathname = "/api/local/relay";
   if (url2.hostname !== "localhost") {
     url2.hostname = `relay.${url2.hostname}`;
   }
@@ -23274,9 +22256,7 @@ var SyncService = class {
     this.options = options;
   }
   auth = null;
-  rpcClient = null;
   relayClient = null;
-  unsubscribeEvents = null;
   unsubscribeRelayMessages = null;
   running = false;
   externalMessageHandler = null;
@@ -23312,30 +22292,14 @@ var SyncService = class {
    */
   async start() {
     if (this.running) {
-      console.log("[claw] SyncService already running");
+      console.log("[local] SyncService already running");
       return;
     }
-    console.log("[claw] Starting SyncService...");
+    console.log("[local] Starting SyncService...");
     this.auth = await loadAuth();
     console.log(
-      `[claw] Authenticated as instance ${this.auth.instanceId}`
+      `[local] Authenticated as instance ${this.auth.instanceId}`
     );
-    const { instance, agents } = await this.fetchCloudData();
-    console.log(
-      `[claw] Fetched ${agents.length} agents for instance "${instance.name}"`
-    );
-    await this.writeConfigFiles(instance, agents);
-    console.log("[claw] Config files written to disk");
-    this.rpcClient = new OpenClawRpcClient();
-    try {
-      await this.rpcClient.connect();
-      console.log("[claw] Connected to OpenClaw gateway");
-    } catch (err) {
-      console.warn(
-        "[claw] Could not connect to OpenClaw gateway (is it running?):",
-        err
-      );
-    }
     if (!this.options.localOnly) {
       const relayUrl = this.options.relayUrl ?? deriveRelayUrl2(this.auth.apiUrl);
       this.relayClient = new RelayClient(
@@ -23345,51 +22309,11 @@ var SyncService = class {
         {
           onConnect: () => {
             void (async () => {
-              const MAX_RETRIES = 3;
-              const RETRY_DELAY_MS = 2e3;
-              for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
-                try {
-                  if (!this.auth) break;
-                  if (!this.rpcClient?.connected) {
-                    console.log(
-                      `[claw] RPC client not connected, waiting ${RETRY_DELAY_MS}ms (attempt ${attempt}/${MAX_RETRIES})`
-                    );
-                    await new Promise((r) => setTimeout(r, RETRY_DELAY_MS));
-                    if (!this.rpcClient?.connected) continue;
-                  }
-                  await agentDiscovery(
-                    this.rpcClient,
-                    this.auth.apiUrl,
-                    this.auth.instanceId,
-                    this.auth.token
-                  );
-                  break;
-                } catch (err) {
-                  console.error(
-                    `[claw] Agent discovery failed (attempt ${attempt}/${MAX_RETRIES}):`,
-                    err instanceof Error ? err.message : err
-                  );
-                  if (attempt < MAX_RETRIES) {
-                    await new Promise((r) => setTimeout(r, RETRY_DELAY_MS));
-                  }
-                }
-              }
-              try {
-                if (this.auth) {
-                  await replayPendingEvents(
-                    this.auth.apiUrl,
-                    this.auth.token,
-                    this.auth.instanceId
-                  );
-                }
-              } catch (err) {
-                console.error("[claw] Event replay on connect failed:", err);
-              }
               if (this.reconnectHandler) {
                 try {
                   await this.reconnectHandler();
                 } catch (err) {
-                  console.error("[claw] Agent config re-sync on reconnect failed:", err);
+                  console.error("[local] Agent config re-sync on reconnect failed:", err);
                 }
               }
             })();
@@ -23398,200 +22322,29 @@ var SyncService = class {
       );
       try {
         await this.relayClient.connect();
-        console.log("[claw] Connected to relay server");
+        console.log("[local] Connected to relay server");
       } catch (err) {
         console.warn(
-          "[claw] Could not connect to relay (will retry):",
+          "[local] Could not connect to relay (will retry):",
           err
         );
       }
       this.unsubscribeRelayMessages = this.relayClient.onMessage((msg) => {
-        if (msg.type !== "rpc.request") {
-          console.log(`[claw] Relay message received: type=${msg.type}`, JSON.stringify(msg).slice(0, 200));
-          if (this.externalMessageHandler) {
-            this.externalMessageHandler(msg);
-          }
-          return;
+        console.log(`[local] Relay message received: type=${msg.type}`, JSON.stringify(msg).slice(0, 200));
+        if (this.externalMessageHandler) {
+          this.externalMessageHandler(msg);
         }
-        const rpcId = typeof msg.id === "string" ? msg.id : null;
-        const method = typeof msg.method === "string" ? msg.method : null;
-        const params = msg.params && typeof msg.params === "object" ? msg.params : {};
-        if (!rpcId || !method) return;
-        void (async () => {
-          try {
-            if (!this.rpcClient?.connected) {
-              throw new Error("OpenClaw gateway is not connected");
-            }
-            let result;
-            switch (method) {
-              case "config.get":
-                result = await this.rpcClient.configGet();
-                break;
-              case "agents.list":
-                result = await this.rpcClient.agentsList();
-                break;
-              case "chat.send": {
-                const message = typeof params.message === "string" ? params.message : "";
-                const agentId = typeof params.agentId === "string" ? params.agentId : typeof params.agentKey === "string" ? params.agentKey : "main";
-                if (!message.trim()) {
-                  throw new Error("Missing chat message");
-                }
-                result = await this.rpcClient.chatSend(message, agentId);
-                break;
-              }
-              case "chat.abort":
-                result = { ok: true };
-                break;
-              case "config.patch": {
-                const patch = params.patch && typeof params.patch === "object" ? params.patch : {};
-                const baseHash = typeof params.baseHash === "string" ? params.baseHash : "";
-                if (!baseHash) {
-                  throw new Error("Missing config baseHash");
-                }
-                result = await this.rpcClient.configPatch(patch, baseHash);
-                break;
-              }
-              case "config.push":
-                result = { accepted: true };
-                break;
-              case "agents.files.get": {
-                const agentId = typeof params.agentId === "string" ? params.agentId : "";
-                const name = typeof params.name === "string" ? params.name : "";
-                if (!agentId || !name) {
-                  throw new Error("Missing agentId or name");
-                }
-                result = await this.rpcClient.agentFilesGet(agentId, name);
-                break;
-              }
-              case "agents.files.set": {
-                const agentId = typeof params.agentId === "string" ? params.agentId : "";
-                const name = typeof params.name === "string" ? params.name : "";
-                const content = typeof params.content === "string" ? params.content : "";
-                if (!agentId || !name) {
-                  throw new Error("Missing agentId or name");
-                }
-                result = await this.rpcClient.agentFilesSet(
-                  agentId,
-                  name,
-                  content
-                );
-                break;
-              }
-              case "agents.create": {
-                const name = typeof params.name === "string" ? params.name : "";
-                const workspace = typeof params.workspace === "string" ? params.workspace : "";
-                if (!name || !workspace) {
-                  throw new Error("Missing name or workspace");
-                }
-                result = await this.rpcClient.agentsCreate(name, workspace);
-                break;
-              }
-              case "agents.update": {
-                const agentId = typeof params.agentId === "string" ? params.agentId : "";
-                if (!agentId) {
-                  throw new Error("Missing agentId");
-                }
-                const { agentId: _, ...patch } = params;
-                result = await this.rpcClient.agentsUpdate(agentId, patch);
-                break;
-              }
-              case "agents.delete": {
-                const agentId = typeof params.agentId === "string" ? params.agentId : "";
-                if (!agentId) {
-                  throw new Error("Missing agentId");
-                }
-                result = await this.rpcClient.agentsDelete(agentId);
-                break;
-              }
-              case "cron.list":
-                result = await this.rpcClient.cronList(params);
-                break;
-              case "cron.add":
-                result = await this.rpcClient.cronAdd(params);
-                break;
-              case "cron.update": {
-                const id = typeof params.id === "string" ? params.id : "";
-                if (!id) {
-                  throw new Error("Missing cron id");
-                }
-                const { id: _cronId, ...cronPatch } = params;
-                result = await this.rpcClient.cronUpdate(id, cronPatch);
-                break;
-              }
-              case "cron.remove": {
-                const id = typeof params.id === "string" ? params.id : "";
-                if (!id) {
-                  throw new Error("Missing cron id");
-                }
-                result = await this.rpcClient.cronRemove(id);
-                break;
-              }
-              case "cron.run": {
-                const id = typeof params.id === "string" ? params.id : "";
-                if (!id) {
-                  throw new Error("Missing cron id");
-                }
-                const mode = typeof params.mode === "string" ? params.mode : void 0;
-                result = await this.rpcClient.cronRun(id, mode);
-                break;
-              }
-              case "skills.status": {
-                const agentId = typeof params.agentId === "string" ? params.agentId : void 0;
-                result = await this.rpcClient.skillsStatus(agentId);
-                break;
-              }
-              case "skills.update":
-                result = await this.rpcClient.skillsUpdate(params);
-                break;
-              case "tools.catalog": {
-                const agentId = typeof params.agentId === "string" ? params.agentId : void 0;
-                result = await this.rpcClient.toolsCatalog(agentId);
-                break;
-              }
-              case "models.list":
-                result = await this.rpcClient.modelsList();
-                break;
-              default:
-                throw new Error(`Unsupported RPC method: ${method}`);
-            }
-            this.relayClient?.send({
-              type: "rpc.response",
-              id: rpcId,
-              result
-            });
-          } catch (err) {
-            this.relayClient?.send({
-              type: "rpc.response",
-              id: rpcId,
-              error: {
-                code: "rpc_error",
-                message: err instanceof Error ? err.message : String(err)
-              }
-            });
-          }
-        })();
       });
     }
-    const forwarder = createEventForwarder(
-      this.auth.apiUrl,
-      this.auth.token,
-      this.auth.instanceId
-    );
-    this.unsubscribeEvents = this.rpcClient.subscribeEvents(forwarder);
-    console.log("[claw] Event forwarding registered");
     this.running = true;
-    console.log("[claw] SyncService started");
+    console.log("[local] SyncService started");
   }
   /**
    * Gracefully stop the sync service.
    */
   stop() {
     if (!this.running) return;
-    console.log("[claw] Stopping SyncService...");
-    if (this.unsubscribeEvents) {
-      this.unsubscribeEvents();
-      this.unsubscribeEvents = null;
-    }
+    console.log("[local] Stopping SyncService...");
     if (this.unsubscribeRelayMessages) {
       this.unsubscribeRelayMessages();
       this.unsubscribeRelayMessages = null;
@@ -23600,54 +22353,16 @@ var SyncService = class {
       this.relayClient.disconnect();
       this.relayClient = null;
     }
-    if (this.rpcClient) {
-      this.rpcClient.disconnect();
-      this.rpcClient = null;
-    }
     this.running = false;
-    console.log("[claw] SyncService stopped");
-  }
-  // --- Internal ---
-  async fetchCloudData() {
-    if (!this.auth) throw new Error("Not authenticated");
-    const res = await fetch(
-      `${this.auth.apiUrl}/api/claw/instances/${this.auth.instanceId}/sync`,
-      {
-        headers: {
-          Authorization: `Bearer ${this.auth.token}`,
-          "Content-Type": "application/json"
-        }
-      }
-    );
-    if (!res.ok) {
-      throw new Error(
-        `Failed to fetch cloud data: ${res.status} ${res.statusText}`
-      );
-    }
-    const data = await res.json();
-    return data;
-  }
-  async writeConfigFiles(instance, agents) {
-    const gatewayConfig = generateGatewayConfig(instance, agents);
-    const configPath = path18.join(WORKLE_HOME8, "openclaw.json");
-    await fs15.mkdir(WORKLE_HOME8, { recursive: true });
-    await fs15.writeFile(configPath, JSON.stringify(gatewayConfig, null, 2), "utf-8");
-    await Promise.all(
-      agents.map(async (agent) => {
-        await writeSoulMd(agent.agentKey, agent.soulMd);
-        await writeAgentsMd(agent.agentKey, agent.agentsMd);
-        await writeIdentityMd(agent.agentKey, agent.identityMd);
-        await writeHeartbeatMd(agent.agentKey, agent.heartbeatMd);
-      })
-    );
+    console.log("[local] SyncService stopped");
   }
 };
 
 // src/cli.ts
-var WORKLE_HOME9 = path19.join(os18.homedir(), ".workle");
-var AUTH_FILE2 = path19.join(WORKLE_HOME9, "auth.json");
-var LAUNCH_AGENTS_DIR2 = path19.join(os18.homedir(), "Library", "LaunchAgents");
-var PLIST_LABEL = "com.workle.claw";
+var WORKLE_HOME4 = path10.join(os7.homedir(), ".workle");
+var AUTH_FILE2 = path10.join(WORKLE_HOME4, "auth.json");
+var LAUNCH_AGENTS_DIR2 = path10.join(os7.homedir(), "Library", "LaunchAgents");
+var PLIST_LABEL = "com.workle.local";
 var color = {
   green: (s) => `\x1B[32m${s}\x1B[0m`,
   red: (s) => `\x1B[31m${s}\x1B[0m`,
@@ -23659,7 +22374,7 @@ var color = {
 function readPkgVersion() {
   try {
     const pkgPath = new URL("../package.json", import.meta.url);
-    const raw = readFileSync(pkgPath, "utf-8");
+    const raw = readFileSync2(pkgPath, "utf-8");
     return JSON.parse(raw).version;
   } catch {
     return "0.0.0";
@@ -23684,16 +22399,16 @@ function pairingErrorMessage(status, fallback) {
   return fallback;
 }
 async function saveAuth(data) {
-  await setupClawDirectory();
+  await setupLocalDirectory();
   const authData = {
     instanceId: data.instanceId,
     token: data.token,
     apiUrl: data.apiUrl
   };
-  await fs16.writeFile(AUTH_FILE2, JSON.stringify(authData, null, 2), {
+  await fs7.writeFile(AUTH_FILE2, JSON.stringify(authData, null, 2), {
     mode: 384
   });
-  await fs16.chmod(AUTH_FILE2, 384).catch(() => {
+  await fs7.chmod(AUTH_FILE2, 384).catch(() => {
   });
   console.log("");
   console.log(color.green("\u2713 Paired successfully!"));
@@ -23710,7 +22425,7 @@ async function saveAuth(data) {
   console.log(`  ${color.cyan("npx @getworkle/cli doctor")}         Run health checks`);
 }
 async function exchangeBrowserCode(code, codeVerifier, apiUrl) {
-  const res = await fetch(`${apiUrl}/api/claw/pair/exchange`, {
+  const res = await fetch(`${apiUrl}/api/local/pair/exchange`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({ code, codeVerifier })
@@ -23728,7 +22443,7 @@ function browserAuth(apiUrl) {
     const codeVerifier = createPairingCodeVerifier();
     const codeChallenge = createPairingCodeChallenge(codeVerifier);
     let settled = false;
-    const server = http2.createServer((req, res) => {
+    const server = http.createServer((req, res) => {
       void (async () => {
         const url2 = new URL(req.url ?? "/", "http://127.0.0.1");
         if (url2.pathname !== "/callback") {
@@ -23758,7 +22473,7 @@ function browserAuth(apiUrl) {
           res.end(
             [
               "<!DOCTYPE html>",
-              "<html><head><title>Workle Claw</title>",
+              "<html><head><title>Workle Local</title>",
               "<style>body{font-family:system-ui;display:flex;justify-content:center;align-items:center;min-height:100vh;margin:0;background:#fafafa;color:#111}",
               ".card{text-align:center;padding:3rem;border-radius:12px;background:#fff;box-shadow:0 1px 3px rgba(0,0,0,.1)}",
               "h1{font-size:1.5rem;margin:0 0 .5rem}p{color:#666;margin:0}</style></head>",
@@ -23775,7 +22490,7 @@ function browserAuth(apiUrl) {
           res.end(
             [
               "<!DOCTYPE html>",
-              "<html><head><title>Workle Claw</title>",
+              "<html><head><title>Workle Local</title>",
               "<style>body{font-family:system-ui;display:flex;justify-content:center;align-items:center;min-height:100vh;margin:0;background:#fafafa;color:#111}",
               ".card{text-align:center;padding:3rem;border-radius:12px;background:#fff;box-shadow:0 1px 3px rgba(0,0,0,.1)}",
               "h1{font-size:1.5rem;margin:0 0 .5rem}p{color:#666;margin:0 0 1rem}</style></head>",
@@ -23807,12 +22522,12 @@ function browserAuth(apiUrl) {
         return;
       }
       const port = addr.port;
-      const pairUrl = `${apiUrl}/claw/pair?port=${port}&state=${encodeURIComponent(callbackState)}&codeChallenge=${encodeURIComponent(codeChallenge)}`;
+      const pairUrl = `${apiUrl}/local/pair?port=${port}&state=${encodeURIComponent(callbackState)}&codeChallenge=${encodeURIComponent(codeChallenge)}`;
       console.log(color.dim("Opening browser to authenticate..."));
       console.log(color.dim(`  ${pairUrl}
 `));
       try {
-        execSync2(`open "${pairUrl}"`, { stdio: "ignore" });
+        execSync(`open "${pairUrl}"`, { stdio: "ignore" });
       } catch {
         console.log(color.yellow("Could not open browser automatically."));
         console.log("Open this URL in your browser:\n");
@@ -23841,7 +22556,7 @@ function browserAuth(apiUrl) {
 }
 async function tokenAuth(setupToken, apiUrl) {
   console.log(color.dim("Activating with Workle..."));
-  const res = await fetch(`${apiUrl}/api/claw/activate`, {
+  const res = await fetch(`${apiUrl}/api/local/activate`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({ setupToken })
@@ -23882,7 +22597,7 @@ program2.command("setup").alias("pair").description("Pair this Mac with a Workle
     process.exit(1);
   }
 });
-program2.command("start").description("Start the Workle Claw sync service").option("-d, --daemon", "Run as a background daemon via launchd").action(async (opts) => {
+program2.command("start").description("Start the Workle Local sync service").option("-d, --daemon", "Run as a background daemon via launchd").action(async (opts) => {
   if (opts.daemon) {
     console.log(color.dim("Installing launchd service..."));
     const stagedCliPath = await stageCliForDaemon(process.argv[1] ?? "");
@@ -23891,12 +22606,12 @@ program2.command("start").description("Start the Workle Claw sync service").opti
       "start"
     ]);
     try {
-      execSync2(`launchctl load -w "${plistPath}"`, { stdio: "inherit" });
+      execSync(`launchctl load -w "${plistPath}"`, { stdio: "inherit" });
       console.log(color.green("\u2713 Daemon started"));
       console.log("");
       console.log(`  Service:  ${color.dim(PLIST_LABEL)}`);
       console.log(`  Plist:    ${color.dim(plistPath)}`);
-      console.log(`  Logs:     ${color.dim(path19.join(WORKLE_HOME9, "logs/"))}`);
+      console.log(`  Logs:     ${color.dim(path10.join(WORKLE_HOME4, "logs/"))}`);
       console.log("");
       console.log(
         `To stop:    ${color.cyan("npx @getworkle/cli stop")}`
@@ -23908,36 +22623,19 @@ program2.command("start").description("Start the Workle Claw sync service").opti
     }
     return;
   }
-  console.log(color.bold("Workle Claw"));
+  console.log(color.bold("Workle Local"));
   console.log(color.dim("Starting sync service... (Ctrl+C to stop)\n"));
-  const processManager = new ProcessManager();
   const syncService = new SyncService();
   let agentService = null;
-  let weSpawnedGateway = false;
   const shutdown = () => {
     console.log("\n" + color.dim("Shutting down..."));
     agentService?.stop();
     syncService.stop();
-    if (weSpawnedGateway) {
-      void processManager.stop().then(() => {
-        process.exit(0);
-      });
-    } else {
-      process.exit(0);
-    }
+    process.exit(0);
   };
   process.on("SIGINT", shutdown);
   process.on("SIGTERM", shutdown);
   try {
-    const alreadyRunning = await processManager.isHealthy();
-    if (alreadyRunning) {
-      console.log(
-        color.dim("OpenClaw gateway already running on :18789 \u2014 skipping spawn")
-      );
-    } else {
-      await processManager.spawn();
-      weSpawnedGateway = true;
-    }
     await syncService.start();
     try {
       agentService = await createAgentService();
@@ -23962,41 +22660,26 @@ program2.command("start").description("Start the Workle Claw sync service").opti
       )
     );
     syncService.stop();
-    if (weSpawnedGateway) {
-      await processManager.stop();
-    }
     process.exit(1);
   }
 });
-program2.command("stop").description("Stop the Workle Claw daemon").action(async () => {
-  const plistPath = path19.join(LAUNCH_AGENTS_DIR2, `${PLIST_LABEL}.plist`);
+program2.command("stop").description("Stop the Workle Local daemon").action(async () => {
+  const plistPath = path10.join(LAUNCH_AGENTS_DIR2, `${PLIST_LABEL}.plist`);
   try {
-    execSync2(`launchctl unload "${plistPath}"`, { stdio: "inherit" });
+    execSync(`launchctl unload "${plistPath}"`, { stdio: "inherit" });
     console.log(color.green("\u2713 Daemon stopped"));
   } catch {
     console.log(color.dim("No launchd service loaded."));
   }
-  const pidFile = path19.join(WORKLE_HOME9, "openclaw.pid");
-  try {
-    const pidStr = await fs16.readFile(pidFile, "utf-8");
-    const pid = parseInt(pidStr.trim(), 10);
-    if (!isNaN(pid)) {
-      process.kill(pid, "SIGTERM");
-      await fs16.unlink(pidFile).catch(() => {
-      });
-      console.log(color.dim(`Sent SIGTERM to OpenClaw (PID: ${pid})`));
-    }
-  } catch {
-  }
 });
-program2.command("doctor").description("Run health checks for the Workle Claw environment").action(async () => {
+program2.command("doctor").description("Run health checks for the Workle Local environment").action(async () => {
   const checks = await runDoctor();
   const failures = checks.filter((c) => c.status === "fail");
   process.exit(failures.length > 0 ? 1 : 0);
 });
 program2.command("status").description("Show connection state and instance info").action(async () => {
   console.log("");
-  console.log(color.bold("  Workle Claw Status"));
+  console.log(color.bold("  Workle Local Status"));
   console.log("");
   try {
     const auth = await loadAuth();
@@ -24008,24 +22691,11 @@ program2.command("status").description("Show connection state and instance info"
     console.log("");
     return;
   }
+  const plistPath = path10.join(LAUNCH_AGENTS_DIR2, `${PLIST_LABEL}.plist`);
   try {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), 3e3);
-    const res = await fetch("http://127.0.0.1:18789/", {
-      signal: controller.signal
-    });
-    clearTimeout(timer);
-    console.log(
-      `  Gateway:  ${color.green("reachable")} (HTTP ${res.status})`
-    );
-  } catch {
-    console.log(`  Gateway:  ${color.yellow("unreachable")}`);
-  }
-  const plistPath = path19.join(LAUNCH_AGENTS_DIR2, `${PLIST_LABEL}.plist`);
-  try {
-    await fs16.access(plistPath);
+    await fs7.access(plistPath);
     try {
-      const output = execSync2(`launchctl list ${PLIST_LABEL} 2>&1`, {
+      const output = execSync(`launchctl list ${PLIST_LABEL} 2>&1`, {
         encoding: "utf-8"
       });
       if (output.includes(PLIST_LABEL)) {
@@ -24041,15 +22711,15 @@ program2.command("status").description("Show connection state and instance info"
   }
   console.log("");
 });
-program2.command("logs").description("Tail the Workle Claw log files").option("-n, --lines <count>", "Number of lines to show", "50").option("-f, --follow", "Follow log output").action((opts) => {
+program2.command("logs").description("Tail the Workle Local log files").option("-n, --lines <count>", "Number of lines to show", "50").option("-f, --follow", "Follow log output").action((opts) => {
   const lineCount = parseInt(opts.lines, 10);
   if (!Number.isFinite(lineCount) || lineCount < 1) {
     console.error(color.red("Error: --lines must be a positive integer."));
     process.exit(1);
   }
   const logFiles = [
-    path19.join(WORKLE_HOME9, "openclaw.log"),
-    path19.join(WORKLE_HOME9, "logs", "stderr.log")
+    path10.join(WORKLE_HOME4, "logs", "stdout.log"),
+    path10.join(WORKLE_HOME4, "logs", "stderr.log")
   ];
   const args = ["-n", String(lineCount)];
   if (opts.follow) args.push("-f");
@@ -24057,7 +22727,7 @@ program2.command("logs").description("Tail the Workle Claw log files").option("-
   const result = spawnSync("tail", args, { stdio: "inherit" });
   if (result.error && !opts.follow) {
     console.error(color.red(`Failed to read logs: ${result.error.message}`));
-    console.error(`Expected log files at: ${WORKLE_HOME9}/logs/`);
+    console.error(`Expected log files at: ${WORKLE_HOME4}/logs/`);
   }
 });
 var agentCmd = program2.command("agent").description("Manage and run Workle AI agents locally");
@@ -24213,12 +22883,12 @@ agentCmd.command("logs [agentId]").description("Tail agent run logs").option("-n
     console.error(color.red("Error: --lines must be a positive integer."));
     process.exit(1);
   }
-  const logsDir = path19.join(WORKLE_HOME9, "agents");
+  const logsDir = path10.join(WORKLE_HOME4, "agents");
   let logFile;
   if (agentId) {
-    logFile = path19.join(logsDir, agentId, "run.log");
+    logFile = path10.join(logsDir, agentId, "run.log");
   } else {
-    logFile = path19.join(logsDir, "*", "run.log");
+    logFile = path10.join(logsDir, "*", "run.log");
   }
   const args = ["-n", String(lineCount)];
   if (opts.follow) args.push("-f");