@getworkle/cli 0.2.10 → 0.2.12

package/dist/cli.js

@@ -1209,7 +1209,7 @@ var require_command = __commonJS({
     "use strict";
     var EventEmitter = __require("events").EventEmitter;
     var childProcess = __require("child_process");
-    var path19 = __require("path");
+    var path20 = __require("path");
     var fs17 = __require("fs");
     var process2 = __require("process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
@@ -2222,9 +2222,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path19.resolve(baseDir, baseName);
+          const localBin = path20.resolve(baseDir, baseName);
           if (fs17.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path19.extname(baseName))) return void 0;
+          if (sourceExt.includes(path20.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
             (ext) => fs17.existsSync(`${localBin}${ext}`)
           );
@@ -2242,17 +2242,17 @@ Expecting one of '${allowedValues.join("', '")}'`);
           } catch {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path19.resolve(
-            path19.dirname(resolvedScriptPath),
+          executableDir = path20.resolve(
+            path20.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path19.basename(
+            const legacyName = path20.basename(
               this._scriptPath,
-              path19.extname(this._scriptPath)
+              path20.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -2263,7 +2263,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path19.extname(executableFile));
+        launchWithNode = sourceExt.includes(path20.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 = path19.basename(filename, path19.extname(filename));
+        this._name = path20.basename(filename, path20.extname(filename));
         return this;
       }
       /**
@@ -3192,9 +3192,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path20) {
-        if (path20 === void 0) return this._executableDir;
-        this._executableDir = path20;
+      executableDir(path21) {
+        if (path21 === void 0) return this._executableDir;
+        this._executableDir = path21;
         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 path19 = __require("path");
+    var path20 = __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: path19.resolve(this.taskPath),
+          path: path20.resolve(this.taskPath),
           cron: this.cronExpression,
           options
         });
@@ -8033,7 +8033,7 @@ import { readFileSync } from "fs";
 import fs16 from "fs/promises";
 import http2 from "http";
 import os18 from "os";
-import path18 from "path";
+import path19 from "path";
 
 // src/agents/config-materializer.ts
 import fs2 from "fs/promises";
@@ -8106,12 +8106,37 @@ function getAgentDirPath(agentId) {
   const safeId = sanitizePathSegment(agentId, "agent");
   return path2.join(AGENTS_HOME, `id-${safeId}`);
 }
+function getSdkMemoryPath(agentId) {
+  const agentDir = getAgentDirPath(agentId);
+  const encoded = agentDir.replace(/[^a-zA-Z0-9]/g, "-");
+  return path2.join(os2.homedir(), ".claude", "projects", encoded, "memory");
+}
 function sanitizeAgentAssetFilename(filename, fallback) {
-  return sanitizePathSegment(filename, fallback);
+  const sanitized = sanitizePathSegment(filename, fallback);
+  return sanitized.endsWith(".md") ? sanitized : `${sanitized}.md`;
 }
 
 // src/agents/config-materializer.ts
 var CACHE_FILE = path3.join(os3.homedir(), ".workle", "agent-cache.json");
+function buildSdkSettings(settings) {
+  if (!settings) return {};
+  const sdk = {};
+  const perms = settings.permissions;
+  if (perms && typeof perms === "object" && perms !== null) {
+    const p = perms;
+    const sdkPerms = {};
+    if (Array.isArray(p.allow) && p.allow.length > 0) {
+      sdkPerms.allow = p.allow;
+    }
+    if (Array.isArray(p.deny) && p.deny.length > 0) {
+      sdkPerms.deny = p.deny;
+    }
+    if (Object.keys(sdkPerms).length > 0) {
+      sdk.permissions = sdkPerms;
+    }
+  }
+  return sdk;
+}
 var AgentConfigMaterializer = class {
   apiUrl;
   instanceId;
@@ -8215,10 +8240,26 @@ var AgentConfigMaterializer = class {
         "utf-8"
       );
     }
-    if (agent.settings) {
+    if (agent.memory && agent.memory.length > 0) {
+      const sdkMemoryDir = getSdkMemoryPath(agent.id);
+      await fs2.mkdir(sdkMemoryDir, { recursive: true });
+      for (const [index, mem] of agent.memory.entries()) {
+        const filename = sanitizeAgentAssetFilename(
+          mem.filename,
+          `memory-${index + 1}.md`
+        );
+        await fs2.writeFile(
+          path3.join(sdkMemoryDir, filename),
+          mem.content,
+          "utf-8"
+        );
+      }
+    }
+    const sdkSettings = buildSdkSettings(agent.settings);
+    if (Object.keys(sdkSettings).length > 0) {
       await fs2.writeFile(
         settingsPath,
-        JSON.stringify(agent.settings, null, 2),
+        JSON.stringify(sdkSettings, null, 2),
         "utf-8"
       );
     } else {
@@ -8257,14 +8298,20 @@ function resolveClaudeCodeExecutable() {
   return `${sdkDir}/cli.js`;
 }
 async function runAgent(opts) {
-  const { agentDir, prompt, sessionId, maxTurns, mcpServers, onMessage, abortController } = opts;
+  const { agentDir, prompt, sessionId, maxTurns, permissionMode, model, allowedTools, mcpServers, onMessage, abortController } = opts;
   try {
     const stream = query({
       prompt,
       options: {
         pathToClaudeCodeExecutable: resolveClaudeCodeExecutable(),
+        executable: process.execPath,
+        // Full path to node — launchd doesn't have node in PATH
         cwd: agentDir,
         settingSources: ["project"],
+        ...permissionMode ? { permissionMode } : {},
+        ...permissionMode === "bypassPermissions" ? { allowDangerouslySkipPermissions: true } : {},
+        ...model ? { model } : {},
+        ...allowedTools && allowedTools.length > 0 ? { allowedTools } : {},
         ...sessionId ? { resume: sessionId } : {},
         ...typeof maxTurns === "number" ? { maxTurns } : {},
         ...mcpServers ? { mcpServers } : {},
@@ -9065,10 +9112,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path19) {
-  if (!path19)
+function getElementAtPath(obj, path20) {
+  if (!path20)
     return obj;
-  return path19.reduce((acc, key) => acc?.[key], obj);
+  return path20.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -9434,11 +9481,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path19, issues) {
+function prefixIssues(path20, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path19);
+    iss.path.unshift(path20);
     return iss;
   });
 }
@@ -9600,7 +9647,7 @@ function formatError(error46, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error46, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error47, path19 = []) => {
+  const processError = (error47, path20 = []) => {
     var _a2, _b;
     for (const issue2 of error47.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -9610,7 +9657,7 @@ function treeifyError(error46, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path19, ...issue2.path];
+        const fullpath = [...path20, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -9642,8 +9689,8 @@ function treeifyError(error46, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path19 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path19) {
+  const path20 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path20) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -20979,23 +21026,23 @@ function date4(params) {
 config(en_default());
 
 // src/agents/mcp-server.ts
-async function apiGet(apiUrl, path19, headers) {
-  const res = await fetch(`${apiUrl}${path19}`, {
+async function apiGet(apiUrl, path20, headers) {
+  const res = await fetch(`${apiUrl}${path20}`, {
     headers: { ...headers, "Content-Type": "application/json" }
   });
   if (!res.ok) {
-    throw new Error(`API GET ${path19} failed: HTTP ${res.status}`);
+    throw new Error(`API GET ${path20} failed: HTTP ${res.status}`);
   }
   return res.json();
 }
-async function apiPost(apiUrl, path19, body, headers) {
-  const res = await fetch(`${apiUrl}${path19}`, {
+async function apiPost(apiUrl, path20, body, headers) {
+  const res = await fetch(`${apiUrl}${path20}`, {
     method: "POST",
     headers: { ...headers, "Content-Type": "application/json" },
     body: JSON.stringify(body)
   });
   if (!res.ok) {
-    throw new Error(`API POST ${path19} failed: HTTP ${res.status}`);
+    throw new Error(`API POST ${path20} failed: HTTP ${res.status}`);
   }
   return res.json();
 }
@@ -21121,6 +21168,7 @@ var AgentScheduler = class {
 // src/agents/service.ts
 import { randomUUID } from "crypto";
 import fs4 from "fs/promises";
+import path5 from "path";
 
 // ../../node_modules/ws/wrapper.mjs
 var import_stream = __toESM(require_stream(), 1);
@@ -21561,11 +21609,15 @@ var AgentService = class _AgentService {
         instanceId: this.instanceId,
         token: this.token
       });
+      const { permissionMode, model, allowedTools } = extractSdkOptions(config2);
       const result = await runAgent({
         agentDir,
         prompt,
         sessionId: previousSessionId,
         maxTurns: typeof config2?.maxTurns === "number" ? config2.maxTurns : void 0,
+        permissionMode,
+        model,
+        allowedTools,
         mcpServers: { workle: mcpServer },
         abortController,
         onMessage: (message) => {
@@ -21716,6 +21768,12 @@ var AgentService = class _AgentService {
       if (resumeSession && result.sessionId) {
         await saveSessionId(agentId, result.sessionId);
       }
+      void this.pushMemoryFiles(agentId).catch((err) => {
+        console.error(
+          `[agents] Failed to push memory for ${agentId}:`,
+          err instanceof Error ? err.message : err
+        );
+      });
       return result;
     })();
     this.activeRuns.set(agentId, runPromise);
@@ -21757,6 +21815,28 @@ var AgentService = class _AgentService {
       this.activeAborts.delete(runExecutionId);
     }
   }
+  /**
+   * Re-sync all agent configs from the cloud.
+   * Called on relay reconnect to catch any config.updated events
+   * that were missed while the relay was disconnected.
+   */
+  async resyncAllConfigs() {
+    console.log("[agents] Re-syncing all agent configs...");
+    const stubs = await this.materializer.listAgents();
+    let synced = 0;
+    for (const stub of stubs) {
+      try {
+        await this.syncAgentConfig(stub.id);
+        synced++;
+      } catch (err) {
+        console.error(
+          `[agents] Failed to re-sync agent ${stub.id}:`,
+          err instanceof Error ? err.message : err
+        );
+      }
+    }
+    console.log(`[agents] Re-synced ${synced}/${stubs.length} agent config(s)`);
+  }
   /**
    * Graceful shutdown.
    */
@@ -21786,6 +21866,7 @@ var AgentService = class _AgentService {
   }
   // ── Internal ────────────────────────────────────────────────────────────
   handleRelayMessage(msg) {
+    console.log(`[agents] handleRelayMessage: type=${msg.type}`);
     if (msg.type === "agent.trigger") {
       const frame = msg;
       const { agentId, prompt, executionId, resumeSession } = frame.payload;
@@ -21808,6 +21889,39 @@ var AgentService = class _AgentService {
       }
     }
   }
+  /**
+   * Scan the SDK auto-memory directory and push files back to the cloud.
+   * The SDK writes auto-memory to ~/.claude/projects/{encoded-cwd}/memory/.
+   */
+  async pushMemoryFiles(agentId) {
+    const memoryDir = getSdkMemoryPath(agentId);
+    let entries;
+    try {
+      entries = await fs4.readdir(memoryDir);
+    } catch {
+      return;
+    }
+    const mdFiles = entries.filter((f) => f.endsWith(".md"));
+    if (mdFiles.length === 0) return;
+    const files = [];
+    for (const filename of mdFiles) {
+      const content = await fs4.readFile(path5.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`,
+      {
+        method: "POST",
+        headers: { ...headers, "Content-Type": "application/json" },
+        body: JSON.stringify({ files })
+      }
+    );
+    if (!res.ok) {
+      throw new Error(`Push memory failed: HTTP ${res.status}`);
+    }
+    console.log(`[agents] Pushed ${files.length} memory file(s) for agent ${agentId}`);
+  }
   async resyncAgent(agentId) {
     try {
       await this.syncAgentConfig(agentId);
@@ -21859,6 +21973,37 @@ var AgentService = class _AgentService {
     this.updateSchedules(schedules);
   }
 };
+var VALID_PERMISSION_MODES = /* @__PURE__ */ new Set([
+  "default",
+  "acceptEdits",
+  "bypassPermissions",
+  "plan",
+  "dontAsk"
+]);
+function extractSdkOptions(config2) {
+  const settings = config2?.settings;
+  if (!settings || typeof settings !== "object") {
+    return { permissionMode: void 0, model: void 0, allowedTools: void 0 };
+  }
+  const s = settings;
+  let permissionMode;
+  const perms = s.permissions;
+  if (perms && typeof perms === "object" && perms !== null) {
+    const defaultMode = perms.defaultMode;
+    if (typeof defaultMode === "string" && VALID_PERMISSION_MODES.has(defaultMode)) {
+      permissionMode = defaultMode;
+    }
+  }
+  const model = typeof s.model === "string" && s.model.length > 0 ? s.model : void 0;
+  let allowedTools;
+  if (perms && typeof perms === "object" && perms !== null) {
+    const allow = perms.allow;
+    if (Array.isArray(allow) && allow.length > 0) {
+      allowedTools = allow.filter((t) => typeof t === "string");
+    }
+  }
+  return { permissionMode, model, allowedTools };
+}
 async function createAgentService() {
   const auth = await loadAuth();
   return new AgentService({
@@ -21873,10 +22018,10 @@ import { spawn } from "child_process";
 import fs5 from "fs/promises";
 import http from "http";
 import os5 from "os";
-import path5 from "path";
-var CLAW_HOME = path5.join(os5.homedir(), ".workle");
-var LOG_FILE = path5.join(CLAW_HOME, "openclaw.log");
-var PID_FILE = path5.join(CLAW_HOME, "openclaw.pid");
+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 {
@@ -21889,7 +22034,7 @@ var ProcessManager = class {
    * @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 = path5.join(CLAW_HOME, "openclaw.json")) {
+  async spawn(openclawBinary = "openclaw", configPath = path6.join(CLAW_HOME, "openclaw.json")) {
     if (this.process) {
       console.log("[claw] OpenClaw process already running");
       return;
@@ -22021,8 +22166,8 @@ var ProcessManager = class {
 import { execSync } from "child_process";
 import fs6 from "fs/promises";
 import os6 from "os";
-import path6 from "path";
-var WORKLE_HOME2 = path6.join(os6.homedir(), ".workle");
+import path7 from "path";
+var WORKLE_HOME2 = path7.join(os6.homedir(), ".workle");
 var MIN_NODE_MAJOR = 22;
 async function runDoctor() {
   const checks = [];
@@ -22105,7 +22250,7 @@ async function checkClawHome() {
   }
 }
 async function checkAuthFile() {
-  const authPath = path6.join(WORKLE_HOME2, "auth.json");
+  const authPath = path7.join(WORKLE_HOME2, "auth.json");
   try {
     const raw = await fs6.readFile(authPath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -22130,7 +22275,7 @@ async function checkAuthFile() {
   }
 }
 async function checkConfigFile() {
-  const configPath = path6.join(WORKLE_HOME2, "openclaw.json");
+  const configPath = path7.join(WORKLE_HOME2, "openclaw.json");
   try {
     const raw = await fs6.readFile(configPath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -22179,25 +22324,25 @@ async function checkGatewayReachable() {
 // src/lifecycle/install.ts
 import fs7 from "fs/promises";
 import os7 from "os";
-import path7 from "path";
-var WORKLE_HOME3 = path7.join(os7.homedir(), ".workle");
-var LAUNCH_AGENTS_DIR = path7.join(os7.homedir(), "Library", "LaunchAgents");
-var STAGED_CLI_PATH = path7.join(WORKLE_HOME3, "bin", "cli.js");
+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");
 function escapeXml(value) {
   return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
 }
 async function setupClawDirectory() {
   const dirs = [
     WORKLE_HOME3,
-    path7.join(WORKLE_HOME3, "logs"),
-    path7.join(WORKLE_HOME3, "bin")
+    path8.join(WORKLE_HOME3, "logs"),
+    path8.join(WORKLE_HOME3, "bin")
   ];
   for (const dir of dirs) {
     await fs7.mkdir(dir, { recursive: true, mode: 448 });
     await fs7.chmod(dir, 448).catch(() => {
     });
   }
-  const gitignorePath = path7.join(WORKLE_HOME3, ".gitignore");
+  const gitignorePath = path8.join(WORKLE_HOME3, ".gitignore");
   try {
     await fs7.access(gitignorePath);
   } catch {
@@ -22221,7 +22366,7 @@ async function stageCliForDaemon(currentCliPath) {
 }
 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 = path7.join(LAUNCH_AGENTS_DIR, `${serviceName}.plist`);
+  const plistPath = path8.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">
@@ -22245,10 +22390,10 @@ ${programArguments}
   </dict>
 
   <key>StandardOutPath</key>
-  <string>${path7.join(WORKLE_HOME3, "logs", "stdout.log")}</string>
+  <string>${path8.join(WORKLE_HOME3, "logs", "stdout.log")}</string>
 
   <key>StandardErrorPath</key>
-  <string>${path7.join(WORKLE_HOME3, "logs", "stderr.log")}</string>
+  <string>${path8.join(WORKLE_HOME3, "logs", "stderr.log")}</string>
 
   <key>WorkingDirectory</key>
   <string>${WORKLE_HOME3}</string>
@@ -22269,18 +22414,18 @@ ${programArguments}
 // src/sync/service.ts
 import fs15 from "fs/promises";
 import os17 from "os";
-import path17 from "path";
+import path18 from "path";
 
 // src/legacy/openclaw/gateway.ts
 import os8 from "os";
-import path8 from "path";
-var CLAW_HOME2 = path8.join(os8.homedir(), ".workle");
+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: path8.join(CLAW_HOME2, `workspace-${agent.agentKey}`),
+    workspace: path9.join(CLAW_HOME2, `workspace-${agent.agentKey}`),
     model: agent.model,
     toolProfile: agent.toolProfile,
     promptMode: agent.promptMode
@@ -22293,8 +22438,8 @@ function generateGatewayConfig(_instance, agents) {
 // src/legacy/openclaw/soul.ts
 import fs8 from "fs/promises";
 import os9 from "os";
-import path9 from "path";
-var CLAW_HOME3 = path9.join(os9.homedir(), ".workle");
+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.
@@ -22306,17 +22451,17 @@ async function writeSoulMd(agentKey, content, rpcCall) {
     await rpcCall(agentKey, "SOUL.md", body);
     return;
   }
-  const workspaceDir = path9.join(CLAW_HOME3, `workspace-${agentKey}`);
+  const workspaceDir = path10.join(CLAW_HOME3, `workspace-${agentKey}`);
   await fs8.mkdir(workspaceDir, { recursive: true });
-  const filePath = path9.join(workspaceDir, "SOUL.md");
+  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 path10 from "path";
-var CLAW_HOME4 = path10.join(os10.homedir(), ".workle");
+import path11 from "path";
+var CLAW_HOME4 = path11.join(os10.homedir(), ".workle");
 var DEFAULT_AGENTS_MD = `# Agents
 
 No additional agent configuration provided.
@@ -22327,17 +22472,17 @@ async function writeAgentsMd(agentKey, content, rpcCall) {
     await rpcCall(agentKey, "AGENTS.md", body);
     return;
   }
-  const workspaceDir = path10.join(CLAW_HOME4, `workspace-${agentKey}`);
+  const workspaceDir = path11.join(CLAW_HOME4, `workspace-${agentKey}`);
   await fs9.mkdir(workspaceDir, { recursive: true });
-  const filePath = path10.join(workspaceDir, "AGENTS.md");
+  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 path11 from "path";
-var WORKLE_HOME4 = path11.join(os11.homedir(), ".workle");
+import path12 from "path";
+var WORKLE_HOME4 = path12.join(os11.homedir(), ".workle");
 var DEFAULT_IDENTITY_MD = `# Identity
 
 No identity configuration provided.
@@ -22348,17 +22493,17 @@ async function writeIdentityMd(agentKey, content, rpcCall) {
     await rpcCall(agentKey, "IDENTITY.md", body);
     return;
   }
-  const workspaceDir = path11.join(WORKLE_HOME4, `workspace-${agentKey}`);
+  const workspaceDir = path12.join(WORKLE_HOME4, `workspace-${agentKey}`);
   await fs10.mkdir(workspaceDir, { recursive: true });
-  const filePath = path11.join(workspaceDir, "IDENTITY.md");
+  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 path12 from "path";
-var WORKLE_HOME5 = path12.join(os12.homedir(), ".workle");
+import path13 from "path";
+var WORKLE_HOME5 = path13.join(os12.homedir(), ".workle");
 var DEFAULT_HEARTBEAT_MD = `# Heartbeat
 
 No heartbeat configuration provided.
@@ -22369,34 +22514,34 @@ async function writeHeartbeatMd(agentKey, content, rpcCall) {
     await rpcCall(agentKey, "HEARTBEAT.md", body);
     return;
   }
-  const workspaceDir = path12.join(WORKLE_HOME5, `workspace-${agentKey}`);
+  const workspaceDir = path13.join(WORKLE_HOME5, `workspace-${agentKey}`);
   await fs11.mkdir(workspaceDir, { recursive: true });
-  const filePath = path12.join(workspaceDir, "HEARTBEAT.md");
+  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 path13 from "path";
-var WORKLE_HOME6 = path13.join(os13.homedir(), ".workle");
+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 path14 from "path";
+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 = [
-  () => path14.join(os14.homedir(), ".openclaw", "openclaw.json"),
-  () => path14.join(os14.homedir(), ".config", "openclaw", "openclaw.json")
+  () => path15.join(os14.homedir(), ".openclaw", "openclaw.json"),
+  () => path15.join(os14.homedir(), ".config", "openclaw", "openclaw.json")
 ];
-var CLAW_IDENTITY_DIR = path14.join(os14.homedir(), ".workle");
-var CLAW_IDENTITY_FILE = path14.join(CLAW_IDENTITY_DIR, "device-identity.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, "");
@@ -22905,17 +23050,17 @@ async function agentDiscovery(rpc, apiUrl, instanceId, token) {
 
 // src/sync/events.ts
 import os16 from "os";
-import path16 from "path";
+import path17 from "path";
 
 // src/sync/queue.ts
 import fs14 from "fs/promises";
 import os15 from "os";
-import path15 from "path";
+import path16 from "path";
 var MAX_FILE_SIZE = 5e8;
 var PersistentEventQueue = class {
   filePath;
   constructor(customPath) {
-    this.filePath = customPath ?? path15.join(os15.homedir(), ".workle", "pending-events.jsonl");
+    this.filePath = customPath ?? path16.join(os15.homedir(), ".workle", "pending-events.jsonl");
   }
   /**
    * Append a single entry to the queue file.
@@ -22982,7 +23127,7 @@ var PersistentEventQueue = class {
   }
   // --- Internal ---
   async ensureDir() {
-    const dir = path15.dirname(this.filePath);
+    const dir = path16.dirname(this.filePath);
     await fs14.mkdir(dir, { recursive: true });
   }
   /**
@@ -23010,7 +23155,7 @@ var PersistentEventQueue = class {
 };
 
 // src/sync/events.ts
-var WORKLE_HOME7 = path16.join(os16.homedir(), ".workle");
+var WORKLE_HOME7 = path17.join(os16.homedir(), ".workle");
 var EVENT_TYPE_MAP = {
   "agent.run": "agent.started",
   "agent.run.complete": "agent.completed",
@@ -23051,7 +23196,7 @@ function getQueue(instanceId) {
   const existing = sharedQueues.get(queueKey);
   if (existing) return existing;
   const queue = new PersistentEventQueue(
-    path16.join(WORKLE_HOME7, `pending-events-${queueKey}.jsonl`)
+    path17.join(WORKLE_HOME7, `pending-events-${queueKey}.jsonl`)
   );
   sharedQueues.set(queueKey, queue);
   return queue;
@@ -23114,7 +23259,7 @@ async function replayPendingEvents(apiUrl, token, instanceId) {
 }
 
 // src/sync/service.ts
-var WORKLE_HOME8 = path17.join(os17.homedir(), ".workle");
+var WORKLE_HOME8 = path18.join(os17.homedir(), ".workle");
 function deriveRelayUrl2(apiUrl) {
   const url2 = new URL(apiUrl);
   url2.protocol = url2.protocol === "https:" ? "wss:" : "ws:";
@@ -23135,6 +23280,7 @@ var SyncService = class {
   unsubscribeRelayMessages = null;
   running = false;
   externalMessageHandler = null;
+  reconnectHandler = null;
   /**
    * Register a handler for relay messages that SyncService doesn't handle
    * (e.g. agent.trigger, agent.cancel, agent.config.updated).
@@ -23143,6 +23289,14 @@ var SyncService = class {
   onRelayMessage(handler) {
     this.externalMessageHandler = handler;
   }
+  /**
+   * Register a handler called after relay reconnects.
+   * Used by AgentService to re-sync all agent configs on reconnect,
+   * catching any agent.config.updated events missed during disconnect.
+   */
+  onReconnect(handler) {
+    this.reconnectHandler = handler;
+  }
   /**
    * Send a message through the relay WebSocket connection.
    * Used by AgentService in embedded mode to send progress/result frames.
@@ -23231,6 +23385,13 @@ var SyncService = class {
               } 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);
+                }
+              }
             })();
           }
         }
@@ -23246,6 +23407,7 @@ var SyncService = class {
       }
       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);
           }
@@ -23467,7 +23629,7 @@ var SyncService = class {
   }
   async writeConfigFiles(instance, agents) {
     const gatewayConfig = generateGatewayConfig(instance, agents);
-    const configPath = path17.join(WORKLE_HOME8, "openclaw.json");
+    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(
@@ -23482,9 +23644,9 @@ var SyncService = class {
 };
 
 // src/cli.ts
-var WORKLE_HOME9 = path18.join(os18.homedir(), ".workle");
-var AUTH_FILE2 = path18.join(WORKLE_HOME9, "auth.json");
-var LAUNCH_AGENTS_DIR2 = path18.join(os18.homedir(), "Library", "LaunchAgents");
+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 color = {
   green: (s) => `\x1B[32m${s}\x1B[0m`,
@@ -23734,7 +23896,7 @@ program2.command("start").description("Start the Workle Claw sync service").opti
       console.log("");
       console.log(`  Service:  ${color.dim(PLIST_LABEL)}`);
       console.log(`  Plist:    ${color.dim(plistPath)}`);
-      console.log(`  Logs:     ${color.dim(path18.join(WORKLE_HOME9, "logs/"))}`);
+      console.log(`  Logs:     ${color.dim(path19.join(WORKLE_HOME9, "logs/"))}`);
       console.log("");
       console.log(
         `To stop:    ${color.cyan("npx @getworkle/cli stop")}`
@@ -23779,7 +23941,12 @@ program2.command("start").description("Start the Workle Claw sync service").opti
     await syncService.start();
     try {
       agentService = await createAgentService();
-      syncService.onRelayMessage((msg) => agentService.ingestRelayMessage(msg));
+      syncService.onRelayMessage((msg) => agentService?.ingestRelayMessage(msg));
+      syncService.onReconnect(async () => {
+        if (agentService) {
+          await agentService.resyncAllConfigs();
+        }
+      });
       await agentService.startEmbedded((msg) => syncService.sendRelayMessage(msg));
     } catch (err) {
       console.error(
@@ -23802,14 +23969,14 @@ program2.command("start").description("Start the Workle Claw sync service").opti
   }
 });
 program2.command("stop").description("Stop the Workle Claw daemon").action(async () => {
-  const plistPath = path18.join(LAUNCH_AGENTS_DIR2, `${PLIST_LABEL}.plist`);
+  const plistPath = path19.join(LAUNCH_AGENTS_DIR2, `${PLIST_LABEL}.plist`);
   try {
     execSync2(`launchctl unload "${plistPath}"`, { stdio: "inherit" });
     console.log(color.green("\u2713 Daemon stopped"));
   } catch {
     console.log(color.dim("No launchd service loaded."));
   }
-  const pidFile = path18.join(WORKLE_HOME9, "openclaw.pid");
+  const pidFile = path19.join(WORKLE_HOME9, "openclaw.pid");
   try {
     const pidStr = await fs16.readFile(pidFile, "utf-8");
     const pid = parseInt(pidStr.trim(), 10);
@@ -23854,7 +24021,7 @@ program2.command("status").description("Show connection state and instance info"
   } catch {
     console.log(`  Gateway:  ${color.yellow("unreachable")}`);
   }
-  const plistPath = path18.join(LAUNCH_AGENTS_DIR2, `${PLIST_LABEL}.plist`);
+  const plistPath = path19.join(LAUNCH_AGENTS_DIR2, `${PLIST_LABEL}.plist`);
   try {
     await fs16.access(plistPath);
     try {
@@ -23881,8 +24048,8 @@ program2.command("logs").description("Tail the Workle Claw log files").option("-
     process.exit(1);
   }
   const logFiles = [
-    path18.join(WORKLE_HOME9, "openclaw.log"),
-    path18.join(WORKLE_HOME9, "logs", "stderr.log")
+    path19.join(WORKLE_HOME9, "openclaw.log"),
+    path19.join(WORKLE_HOME9, "logs", "stderr.log")
   ];
   const args = ["-n", String(lineCount)];
   if (opts.follow) args.push("-f");
@@ -24046,12 +24213,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 = path18.join(WORKLE_HOME9, "agents");
+  const logsDir = path19.join(WORKLE_HOME9, "agents");
   let logFile;
   if (agentId) {
-    logFile = path18.join(logsDir, agentId, "run.log");
+    logFile = path19.join(logsDir, agentId, "run.log");
   } else {
-    logFile = path18.join(logsDir, "*", "run.log");
+    logFile = path19.join(logsDir, "*", "run.log");
   }
   const args = ["-n", String(lineCount)];
   if (opts.follow) args.push("-f");