@getworkle/cli 0.2.4 → 0.2.5

package/dist/cli.js

@@ -8044,8 +8044,8 @@ import path3 from "path";
 import fs from "fs/promises";
 import os from "os";
 import path from "path";
-var CLAW_HOME = path.join(os.homedir(), ".workle-claw");
-var AUTH_FILE = path.join(CLAW_HOME, "auth.json");
+var WORKLE_HOME = path.join(os.homedir(), ".workle");
+var AUTH_FILE = path.join(WORKLE_HOME, "auth.json");
 async function loadAuth() {
   let raw;
   try {
@@ -8111,7 +8111,7 @@ function sanitizeAgentAssetFilename(filename, fallback) {
 }
 
 // src/agents/config-materializer.ts
-var CACHE_FILE = path3.join(os3.homedir(), ".workle-claw", "agent-cache.json");
+var CACHE_FILE = path3.join(os3.homedir(), ".workle", "agent-cache.json");
 var AgentConfigMaterializer = class {
   apiUrl;
   instanceId;
@@ -8251,26 +8251,17 @@ var AgentConfigMaterializer = class {
 // src/agents/runner.ts
 import { query } from "@anthropic-ai/claude-agent-sdk";
 async function runAgent(opts) {
-  const { agentDir, prompt, sessionId, mcpServers, onMessage } = opts;
+  const { agentDir, prompt, sessionId, maxTurns, mcpServers, onMessage, abortController } = opts;
   try {
     const stream = query({
       prompt,
       options: {
         cwd: agentDir,
         settingSources: ["project"],
-        permissionMode: "bypassPermissions",
-        allowDangerouslySkipPermissions: true,
-        allowedTools: [
-          "Read",
-          "Write",
-          "Edit",
-          "Bash",
-          "Glob",
-          "Grep",
-          "mcp__workle__*"
-        ],
         ...sessionId ? { resume: sessionId } : {},
-        ...mcpServers ? { mcpServers } : {}
+        ...typeof maxTurns === "number" ? { maxTurns } : {},
+        ...mcpServers ? { mcpServers } : {},
+        ...abortController ? { abortController } : {}
       }
     });
     let resultSessionId = sessionId ?? "";
@@ -21316,7 +21307,7 @@ import os4 from "os";
 import path4 from "path";
 var SESSIONS_FILE = path4.join(
   os4.homedir(),
-  ".workle-claw",
+  ".workle",
   "agent-sessions.json"
 );
 async function loadSessionId(agentId) {
@@ -21341,6 +21332,23 @@ async function saveSessionId(agentId, sessionId) {
 }
 
 // src/agents/service.ts
+function asRecord(value) {
+  return typeof value === "object" && value !== null ? value : null;
+}
+function getMessageSessionId(message) {
+  const record2 = asRecord(message);
+  return typeof record2?.session_id === "string" ? record2.session_id : void 0;
+}
+function stringifyProgressValue(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
 function deriveRelayUrl(apiUrl) {
   const url2 = new URL(apiUrl);
   url2.protocol = url2.protocol === "https:" ? "wss:" : "ws:";
@@ -21350,7 +21358,8 @@ function deriveRelayUrl(apiUrl) {
   }
   return url2.toString().replace(/\/$/, "");
 }
-var AgentService = class {
+var AgentService = class _AgentService {
+  static SCHEDULED_RUN_PROMPT = "Run your scheduled workflow for this agent.";
   apiUrl;
   token;
   instanceId;
@@ -21360,8 +21369,12 @@ var AgentService = class {
   unsubscribeRelay = null;
   /** Map of agentId -> agent stub (for name lookups). */
   agentMap = /* @__PURE__ */ new Map();
+  /** Map of agentId -> pulled config (for schedule + runtime settings). */
+  agentConfigMap = /* @__PURE__ */ new Map();
   /** Map of agentId -> currently running promise (prevents concurrent runs). */
   activeRuns = /* @__PURE__ */ new Map();
+  /** Map of executionId -> AbortController (for cancel support). */
+  activeAborts = /* @__PURE__ */ new Map();
   running = false;
   constructor(opts) {
     this.apiUrl = opts.apiUrl;
@@ -21396,6 +21409,7 @@ var AgentService = class {
           runtime: config2.runtime,
           updatedAt: config2.updatedAt
         });
+        this.agentConfigMap.set(config2.id, config2);
         configs.push(config2);
       } catch (err) {
         console.error(
@@ -21417,43 +21431,83 @@ var AgentService = class {
     });
     await this.relayClient.connect();
     console.log("[agents] Connected to relay");
+    this.refreshSchedules();
     this.running = true;
     console.log("[agents] AgentService running");
   }
   /**
    * Trigger an agent run. Prevents concurrent runs of the same agent.
    */
-  async triggerAgent(agentId, prompt) {
+  async triggerAgent(agentId, prompt, options) {
+    const executionId = options?.executionId;
+    const resumeSession = options?.resumeSession !== false;
     const existing = this.activeRuns.get(agentId);
     if (existing) {
       console.log(
         `[agents] Agent ${agentId} is already running \u2014 skipping trigger`
       );
+      if (executionId && this.relayClient?.connected) {
+        this.relayClient.send({
+          type: "agent.result",
+          payload: {
+            agentId,
+            executionId,
+            success: false,
+            error: "Agent is already running",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        });
+      }
       return {
         sessionId: "",
         success: false,
         error: "Agent is already running"
       };
     }
-    const executionId = randomUUID();
-    const sendProgress = (message) => {
+    const runExecutionId = executionId ?? randomUUID();
+    const sendProgressPart = (part, sessionId) => {
       if (this.relayClient?.connected) {
         this.relayClient.send({
           type: "agent.progress",
           payload: {
             agentId,
-            executionId,
-            message,
+            executionId: runExecutionId,
+            part,
+            ...sessionId ? { sessionId } : {},
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
           }
         });
       }
     };
-    sendProgress("started");
+    const abortController = new AbortController();
+    this.activeAborts.set(runExecutionId, abortController);
     const runPromise = (async () => {
-      await this.ensureAgentReady(agentId);
-      const previousSessionId = await loadSessionId(agentId);
+      const config2 = await this.ensureAgentReady(agentId);
+      if (!this.isAgentActive(config2)) {
+        return {
+          sessionId: "",
+          success: false,
+          error: "Agent is inactive"
+        };
+      }
+      const previousSessionId = resumeSession ? await loadSessionId(agentId) : void 0;
       const agentDir = getAgentDirPath(agentId);
+      const startedToolCalls = /* @__PURE__ */ new Set();
+      const toolCallIdsByContentBlock = /* @__PURE__ */ new Map();
+      let emittedVisibleProgress = false;
+      const emitProgressPart = (part, sessionId) => {
+        if (part.type !== "error") {
+          emittedVisibleProgress = true;
+        }
+        sendProgressPart(part, sessionId);
+      };
+      const emitToolCallStart = (toolCallId, toolName, sessionId) => {
+        if (!toolCallId || startedToolCalls.has(toolCallId)) {
+          return;
+        }
+        startedToolCalls.add(toolCallId);
+        emitProgressPart({ type: "tool-call-start", toolCallId, toolName }, sessionId);
+      };
       const mcpServer = createWorkleMcpServer({
         apiUrl: this.apiUrl,
         instanceId: this.instanceId,
@@ -21463,20 +21517,168 @@ var AgentService = class {
         agentDir,
         prompt,
         sessionId: previousSessionId,
+        maxTurns: typeof config2?.maxTurns === "number" ? config2.maxTurns : void 0,
         mcpServers: { workle: mcpServer },
+        abortController,
         onMessage: (message) => {
-          sendProgress(typeof message === "string" ? message : JSON.stringify(message));
+          const msg = asRecord(message);
+          const sessionId = getMessageSessionId(message);
+          if (msg?.type === "stream_event") {
+            const event = asRecord(msg.event);
+            const eventType = typeof event?.type === "string" ? event.type : "";
+            const eventIndex = typeof event?.index === "number" ? event.index : null;
+            if (eventType === "content_block_start") {
+              const contentBlock = asRecord(event?.content_block);
+              const contentType = typeof contentBlock?.type === "string" ? contentBlock.type : "";
+              if (contentType === "text" && typeof contentBlock?.text === "string") {
+                emitProgressPart({ type: "text-delta", text: contentBlock.text }, sessionId);
+                return;
+              }
+              if (contentType === "thinking" && typeof contentBlock?.thinking === "string") {
+                emitProgressPart(
+                  { type: "reasoning", text: contentBlock.thinking },
+                  sessionId
+                );
+                return;
+              }
+              if (contentType === "tool_use") {
+                const toolCallId = typeof contentBlock?.id === "string" ? contentBlock.id : typeof contentBlock?.tool_use_id === "string" ? contentBlock.tool_use_id : "";
+                const toolName = typeof contentBlock?.name === "string" ? contentBlock.name : "";
+                emitToolCallStart(toolCallId, toolName, sessionId);
+                if (contentBlock?.input !== void 0) {
+                  emitProgressPart(
+                    {
+                      type: "tool-call-delta",
+                      toolCallId,
+                      argsText: stringifyProgressValue(contentBlock.input)
+                    },
+                    sessionId
+                  );
+                }
+                if (eventIndex !== null && toolCallId) {
+                  toolCallIdsByContentBlock.set(eventIndex, toolCallId);
+                }
+                return;
+              }
+            }
+            if (eventType === "content_block_delta") {
+              const delta = asRecord(event?.delta);
+              const deltaType = typeof delta?.type === "string" ? delta.type : "";
+              if (deltaType === "text_delta" && typeof delta?.text === "string") {
+                emitProgressPart({ type: "text-delta", text: delta.text }, sessionId);
+                return;
+              }
+              if (deltaType === "thinking_delta" && typeof delta?.thinking === "string") {
+                emitProgressPart(
+                  { type: "reasoning", text: delta.thinking },
+                  sessionId
+                );
+                return;
+              }
+              if (deltaType === "input_json_delta" && typeof delta?.partial_json === "string") {
+                const toolCallId = eventIndex === null ? "" : toolCallIdsByContentBlock.get(eventIndex) ?? "";
+                if (toolCallId) {
+                  emitProgressPart(
+                    {
+                      type: "tool-call-delta",
+                      toolCallId,
+                      argsText: delta.partial_json
+                    },
+                    sessionId
+                  );
+                  return;
+                }
+              }
+            }
+          }
+          if (msg?.type === "assistant") {
+            const assistantMessage = asRecord(msg.message);
+            const content = assistantMessage?.content;
+            if (typeof content === "string") {
+              emitProgressPart({ type: "text-delta", text: content }, sessionId);
+              return;
+            }
+            if (Array.isArray(content)) {
+              for (const item of content) {
+                const block = asRecord(item);
+                const blockType = typeof block?.type === "string" ? block.type : "";
+                if (blockType === "text" && typeof block?.text === "string") {
+                  emitProgressPart({ type: "text-delta", text: block.text }, sessionId);
+                  continue;
+                }
+                if (blockType === "thinking" && typeof block?.thinking === "string") {
+                  emitProgressPart(
+                    { type: "reasoning", text: block.thinking },
+                    sessionId
+                  );
+                  continue;
+                }
+                if (blockType === "tool_use") {
+                  const toolCallId = typeof block?.id === "string" ? block.id : typeof block?.tool_use_id === "string" ? block.tool_use_id : "";
+                  const toolName = typeof block?.name === "string" ? block.name : "";
+                  emitToolCallStart(toolCallId, toolName, sessionId);
+                  if (block?.input !== void 0) {
+                    emitProgressPart(
+                      {
+                        type: "tool-call-delta",
+                        toolCallId,
+                        argsText: stringifyProgressValue(block.input)
+                      },
+                      sessionId
+                    );
+                  }
+                  continue;
+                }
+              }
+              return;
+            }
+          }
+          if (msg?.type === "tool_progress") {
+            const toolCallId = typeof msg.tool_use_id === "string" ? msg.tool_use_id : "";
+            const toolName = typeof msg.tool_name === "string" ? msg.tool_name : "";
+            emitToolCallStart(toolCallId, toolName, sessionId);
+            return;
+          }
+          if (msg?.type === "user" && typeof msg.parent_tool_use_id === "string" && msg.tool_use_result !== void 0) {
+            emitProgressPart(
+              {
+                type: "tool-result",
+                toolCallId: msg.parent_tool_use_id,
+                result: msg.tool_use_result
+              },
+              sessionId
+            );
+            return;
+          }
+          if (msg?.type === "system" && msg.subtype === "local_command_output" && typeof msg.content === "string") {
+            emitProgressPart({ type: "text-delta", text: msg.content }, sessionId);
+            return;
+          }
+          if (msg?.type === "result") {
+            if (msg.subtype === "success" && typeof msg.result === "string" && !emittedVisibleProgress) {
+              emitProgressPart({ type: "text-delta", text: msg.result }, sessionId);
+            }
+            return;
+          }
+          if (typeof message === "string" && message.trim().length > 0) {
+            emitProgressPart({ type: "text-delta", text: message }, sessionId);
+          }
         }
       });
-      if (result.sessionId) {
+      if (resumeSession && result.sessionId) {
         await saveSessionId(agentId, result.sessionId);
       }
+      return result;
+    })();
+    this.activeRuns.set(agentId, runPromise);
+    try {
+      const result = await runPromise;
       if (this.relayClient?.connected) {
         this.relayClient.send({
           type: "agent.result",
           payload: {
             agentId,
-            executionId,
+            executionId: runExecutionId,
             success: result.success,
             sessionId: result.sessionId || void 0,
             result: result.result,
@@ -21486,19 +21688,15 @@ var AgentService = class {
         });
       }
       return result;
-    })();
-    this.activeRuns.set(agentId, runPromise);
-    try {
-      return await runPromise;
     } catch (err) {
       const error46 = err instanceof Error ? err.message : String(err);
-      sendProgress(`error: ${error46}`);
+      sendProgressPart({ type: "error", message: error46 });
       if (this.relayClient?.connected) {
         this.relayClient.send({
           type: "agent.result",
           payload: {
             agentId,
-            executionId,
+            executionId: runExecutionId,
             success: false,
             error: error46,
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -21508,6 +21706,7 @@ var AgentService = class {
       return { sessionId: "", success: false, error: error46 };
     } finally {
       this.activeRuns.delete(agentId);
+      this.activeAborts.delete(runExecutionId);
     }
   }
   /**
@@ -21524,6 +21723,7 @@ var AgentService = class {
       this.relayClient.disconnect();
       this.relayClient = null;
     }
+    this.agentConfigMap.clear();
     this.running = false;
     console.log("[agents] AgentService stopped");
   }
@@ -21540,9 +21740,9 @@ var AgentService = class {
   handleRelayMessage(msg) {
     if (msg.type === "agent.trigger") {
       const frame = msg;
-      const { agentId, prompt } = frame.payload;
+      const { agentId, prompt, executionId, resumeSession } = frame.payload;
       console.log(`[agents] Received trigger for agent ${agentId}`);
-      void this.triggerAgent(agentId, prompt);
+      void this.triggerAgent(agentId, prompt, { executionId, resumeSession });
     }
     if (msg.type === "agent.config.updated") {
       const frame = msg;
@@ -21550,6 +21750,15 @@ var AgentService = class {
       console.log(`[agents] Config updated for agent ${agentId} \u2014 re-syncing`);
       void this.resyncAgent(agentId);
     }
+    if (msg.type === "agent.cancel") {
+      const frame = msg;
+      const { executionId } = frame.payload;
+      const controller = this.activeAborts.get(executionId);
+      if (controller) {
+        console.log(`[agents] Cancelling execution ${executionId}`);
+        controller.abort();
+      }
+    }
   }
   async resyncAgent(agentId) {
     try {
@@ -21563,10 +21772,15 @@ var AgentService = class {
     }
   }
   async ensureAgentReady(agentId) {
+    const cachedConfig = this.agentConfigMap.get(agentId);
+    if (!cachedConfig) {
+      return this.syncAgentConfig(agentId);
+    }
     try {
       await fs4.access(getAgentDirPath(agentId));
+      return cachedConfig;
     } catch {
-      await this.syncAgentConfig(agentId);
+      return this.syncAgentConfig(agentId);
     }
   }
   async syncAgentConfig(agentId) {
@@ -21577,9 +21791,25 @@ var AgentService = class {
       runtime: config2.runtime,
       updatedAt: config2.updatedAt
     });
+    this.agentConfigMap.set(config2.id, config2);
     await this.materializer.materializeOne(config2);
+    this.refreshSchedules();
     return config2;
   }
+  isAgentActive(config2) {
+    const isActive = config2?.settings && typeof config2.settings === "object" && "isActive" in config2.settings ? config2.settings.isActive : void 0;
+    return isActive !== false;
+  }
+  refreshSchedules() {
+    const schedules = Array.from(this.agentConfigMap.values()).filter(
+      (config2) => this.isAgentActive(config2) && typeof config2.schedule === "string" && config2.schedule.trim().length > 0
+    ).map((config2) => ({
+      agentId: config2.id,
+      schedule: config2.schedule.trim(),
+      prompt: _AgentService.SCHEDULED_RUN_PROMPT
+    }));
+    this.updateSchedules(schedules);
+  }
 };
 async function createAgentService() {
   const auth = await loadAuth();
@@ -21596,9 +21826,9 @@ import fs5 from "fs/promises";
 import http from "http";
 import os5 from "os";
 import path5 from "path";
-var CLAW_HOME2 = path5.join(os5.homedir(), ".workle-claw");
-var LOG_FILE = path5.join(CLAW_HOME2, "openclaw.log");
-var PID_FILE = path5.join(CLAW_HOME2, "openclaw.pid");
+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");
 var OPENCLAW_PORT = 18789;
 var HEALTH_CHECK_TIMEOUT = 5e3;
 var ProcessManager = class {
@@ -21609,14 +21839,14 @@ var ProcessManager = class {
    * 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-claw/openclaw.json)
+   * @param configPath - Path to openclaw.json config (defaults to ~/.workle/openclaw.json)
    */
-  async spawn(openclawBinary = "openclaw", configPath = path5.join(CLAW_HOME2, "openclaw.json")) {
+  async spawn(openclawBinary = "openclaw", configPath = path5.join(CLAW_HOME, "openclaw.json")) {
     if (this.process) {
       console.log("[claw] OpenClaw process already running");
       return;
     }
-    await fs5.mkdir(CLAW_HOME2, { recursive: true });
+    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], {
@@ -21744,7 +21974,7 @@ import { execSync } from "child_process";
 import fs6 from "fs/promises";
 import os6 from "os";
 import path6 from "path";
-var CLAW_HOME3 = path6.join(os6.homedir(), ".workle-claw");
+var WORKLE_HOME2 = path6.join(os6.homedir(), ".workle");
 var MIN_NODE_MAJOR = 22;
 async function runDoctor() {
   const checks = [];
@@ -21805,29 +22035,29 @@ function checkOpenClawInstalled() {
 }
 async function checkClawHome() {
   try {
-    const stat = await fs6.stat(CLAW_HOME3);
+    const stat = await fs6.stat(WORKLE_HOME2);
     if (stat.isDirectory()) {
       return {
         name: "Claw home directory",
         status: "pass",
-        message: CLAW_HOME3
+        message: WORKLE_HOME2
       };
     }
     return {
       name: "Claw home directory",
       status: "fail",
-      message: `${CLAW_HOME3} exists but is not a directory`
+      message: `${WORKLE_HOME2} exists but is not a directory`
     };
   } catch {
     return {
       name: "Claw home directory",
       status: "fail",
-      message: `${CLAW_HOME3} does not exist. Run 'workle-claw setup'`
+      message: `${WORKLE_HOME2} does not exist. Run 'workle setup'`
     };
   }
 }
 async function checkAuthFile() {
-  const authPath = path6.join(CLAW_HOME3, "auth.json");
+  const authPath = path6.join(WORKLE_HOME2, "auth.json");
   try {
     const raw = await fs6.readFile(authPath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -21852,7 +22082,7 @@ async function checkAuthFile() {
   }
 }
 async function checkConfigFile() {
-  const configPath = path6.join(CLAW_HOME3, "openclaw.json");
+  const configPath = path6.join(WORKLE_HOME2, "openclaw.json");
   try {
     const raw = await fs6.readFile(configPath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -21893,7 +22123,7 @@ async function checkGatewayReachable() {
     return {
       name: "OpenClaw gateway",
       status: "warn",
-      message: "Not reachable on :18789. Start with 'workle-claw start'"
+      message: "Not reachable on :18789. Start with 'workle start'"
     };
   }
 }
@@ -21902,30 +22132,30 @@ async function checkGatewayReachable() {
 import fs7 from "fs/promises";
 import os7 from "os";
 import path7 from "path";
-var CLAW_HOME4 = path7.join(os7.homedir(), ".workle-claw");
+var WORKLE_HOME3 = path7.join(os7.homedir(), ".workle");
 var LAUNCH_AGENTS_DIR = path7.join(os7.homedir(), "Library", "LaunchAgents");
-var STAGED_CLI_PATH = path7.join(CLAW_HOME4, "bin", "cli.js");
+var STAGED_CLI_PATH = path7.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 = [
-    CLAW_HOME4,
-    path7.join(CLAW_HOME4, "logs"),
-    path7.join(CLAW_HOME4, "bin")
+    WORKLE_HOME3,
+    path7.join(WORKLE_HOME3, "logs"),
+    path7.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(CLAW_HOME4, ".gitignore");
+  const gitignorePath = path7.join(WORKLE_HOME3, ".gitignore");
   try {
     await fs7.access(gitignorePath);
   } catch {
     await fs7.writeFile(gitignorePath, "*\n", "utf-8");
   }
-  console.log(`[claw] Directory structure created at ${CLAW_HOME4}`);
+  console.log(`[claw] Directory structure created at ${WORKLE_HOME3}`);
 }
 async function stageCliForDaemon(currentCliPath) {
   if (!currentCliPath) {
@@ -21963,13 +22193,13 @@ ${programArguments}
   </dict>
 
   <key>StandardOutPath</key>
-  <string>${path7.join(CLAW_HOME4, "logs", "stdout.log")}</string>
+  <string>${path7.join(WORKLE_HOME3, "logs", "stdout.log")}</string>
 
   <key>StandardErrorPath</key>
-  <string>${path7.join(CLAW_HOME4, "logs", "stderr.log")}</string>
+  <string>${path7.join(WORKLE_HOME3, "logs", "stderr.log")}</string>
 
   <key>WorkingDirectory</key>
-  <string>${CLAW_HOME4}</string>
+  <string>${WORKLE_HOME3}</string>
 
   <key>ThrottleInterval</key>
   <integer>10</integer>
@@ -21992,13 +22222,13 @@ import path17 from "path";
 // src/legacy/openclaw/gateway.ts
 import os8 from "os";
 import path8 from "path";
-var CLAW_HOME5 = path8.join(os8.homedir(), ".workle-claw");
+var CLAW_HOME2 = path8.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_HOME5, `workspace-${agent.agentKey}`),
+    workspace: path8.join(CLAW_HOME2, `workspace-${agent.agentKey}`),
     model: agent.model,
     toolProfile: agent.toolProfile,
     promptMode: agent.promptMode
@@ -22012,7 +22242,7 @@ function generateGatewayConfig(_instance, agents) {
 import fs8 from "fs/promises";
 import os9 from "os";
 import path9 from "path";
-var CLAW_HOME6 = path9.join(os9.homedir(), ".workle-claw");
+var CLAW_HOME3 = path9.join(os9.homedir(), ".workle");
 var DEFAULT_SOUL_MD = `# Soul
 
 You are a Workle agent. Follow your assigned skills and operational instructions.
@@ -22024,7 +22254,7 @@ async function writeSoulMd(agentKey, content, rpcCall) {
     await rpcCall(agentKey, "SOUL.md", body);
     return;
   }
-  const workspaceDir = path9.join(CLAW_HOME6, `workspace-${agentKey}`);
+  const workspaceDir = path9.join(CLAW_HOME3, `workspace-${agentKey}`);
   await fs8.mkdir(workspaceDir, { recursive: true });
   const filePath = path9.join(workspaceDir, "SOUL.md");
   await fs8.writeFile(filePath, body, "utf-8");
@@ -22034,7 +22264,7 @@ async function writeSoulMd(agentKey, content, rpcCall) {
 import fs9 from "fs/promises";
 import os10 from "os";
 import path10 from "path";
-var CLAW_HOME7 = path10.join(os10.homedir(), ".workle-claw");
+var CLAW_HOME4 = path10.join(os10.homedir(), ".workle");
 var DEFAULT_AGENTS_MD = `# Agents
 
 No additional agent configuration provided.
@@ -22045,7 +22275,7 @@ async function writeAgentsMd(agentKey, content, rpcCall) {
     await rpcCall(agentKey, "AGENTS.md", body);
     return;
   }
-  const workspaceDir = path10.join(CLAW_HOME7, `workspace-${agentKey}`);
+  const workspaceDir = path10.join(CLAW_HOME4, `workspace-${agentKey}`);
   await fs9.mkdir(workspaceDir, { recursive: true });
   const filePath = path10.join(workspaceDir, "AGENTS.md");
   await fs9.writeFile(filePath, body, "utf-8");
@@ -22055,7 +22285,7 @@ async function writeAgentsMd(agentKey, content, rpcCall) {
 import fs10 from "fs/promises";
 import os11 from "os";
 import path11 from "path";
-var CLAW_HOME8 = path11.join(os11.homedir(), ".workle-claw");
+var WORKLE_HOME4 = path11.join(os11.homedir(), ".workle");
 var DEFAULT_IDENTITY_MD = `# Identity
 
 No identity configuration provided.
@@ -22066,7 +22296,7 @@ async function writeIdentityMd(agentKey, content, rpcCall) {
     await rpcCall(agentKey, "IDENTITY.md", body);
     return;
   }
-  const workspaceDir = path11.join(CLAW_HOME8, `workspace-${agentKey}`);
+  const workspaceDir = path11.join(WORKLE_HOME4, `workspace-${agentKey}`);
   await fs10.mkdir(workspaceDir, { recursive: true });
   const filePath = path11.join(workspaceDir, "IDENTITY.md");
   await fs10.writeFile(filePath, body, "utf-8");
@@ -22076,7 +22306,7 @@ async function writeIdentityMd(agentKey, content, rpcCall) {
 import fs11 from "fs/promises";
 import os12 from "os";
 import path12 from "path";
-var CLAW_HOME9 = path12.join(os12.homedir(), ".workle-claw");
+var WORKLE_HOME5 = path12.join(os12.homedir(), ".workle");
 var DEFAULT_HEARTBEAT_MD = `# Heartbeat
 
 No heartbeat configuration provided.
@@ -22087,7 +22317,7 @@ async function writeHeartbeatMd(agentKey, content, rpcCall) {
     await rpcCall(agentKey, "HEARTBEAT.md", body);
     return;
   }
-  const workspaceDir = path12.join(CLAW_HOME9, `workspace-${agentKey}`);
+  const workspaceDir = path12.join(WORKLE_HOME5, `workspace-${agentKey}`);
   await fs11.mkdir(workspaceDir, { recursive: true });
   const filePath = path12.join(workspaceDir, "HEARTBEAT.md");
   await fs11.writeFile(filePath, body, "utf-8");
@@ -22097,7 +22327,7 @@ async function writeHeartbeatMd(agentKey, content, rpcCall) {
 import fs12 from "fs/promises";
 import os13 from "os";
 import path13 from "path";
-var CLAW_HOME10 = path13.join(os13.homedir(), ".workle-claw");
+var WORKLE_HOME6 = path13.join(os13.homedir(), ".workle");
 
 // src/legacy/openclaw/rpc.ts
 import crypto4 from "crypto";
@@ -22113,7 +22343,7 @@ var OPENCLAW_CONFIG_PATHS = [
   () => path14.join(os14.homedir(), ".openclaw", "openclaw.json"),
   () => path14.join(os14.homedir(), ".config", "openclaw", "openclaw.json")
 ];
-var CLAW_IDENTITY_DIR = path14.join(os14.homedir(), ".workle-claw");
+var CLAW_IDENTITY_DIR = path14.join(os14.homedir(), ".workle");
 var CLAW_IDENTITY_FILE = path14.join(CLAW_IDENTITY_DIR, "device-identity.json");
 var ED25519_SPKI_PREFIX = Buffer.from("302a300506032b6570032100", "hex");
 function base64UrlEncode(buf) {
@@ -22633,7 +22863,7 @@ var MAX_FILE_SIZE = 5e8;
 var PersistentEventQueue = class {
   filePath;
   constructor(customPath) {
-    this.filePath = customPath ?? path15.join(os15.homedir(), ".workle-claw", "pending-events.jsonl");
+    this.filePath = customPath ?? path15.join(os15.homedir(), ".workle", "pending-events.jsonl");
   }
   /**
    * Append a single entry to the queue file.
@@ -22728,7 +22958,7 @@ var PersistentEventQueue = class {
 };
 
 // src/sync/events.ts
-var CLAW_HOME11 = path16.join(os16.homedir(), ".workle-claw");
+var WORKLE_HOME7 = path16.join(os16.homedir(), ".workle");
 var EVENT_TYPE_MAP = {
   "agent.run": "agent.started",
   "agent.run.complete": "agent.completed",
@@ -22769,7 +22999,7 @@ function getQueue(instanceId) {
   const existing = sharedQueues.get(queueKey);
   if (existing) return existing;
   const queue = new PersistentEventQueue(
-    path16.join(CLAW_HOME11, `pending-events-${queueKey}.jsonl`)
+    path16.join(WORKLE_HOME7, `pending-events-${queueKey}.jsonl`)
   );
   sharedQueues.set(queueKey, queue);
   return queue;
@@ -22832,7 +23062,7 @@ async function replayPendingEvents(apiUrl, token, instanceId) {
 }
 
 // src/sync/service.ts
-var CLAW_HOME12 = path17.join(os17.homedir(), ".workle-claw");
+var WORKLE_HOME8 = path17.join(os17.homedir(), ".workle");
 function deriveRelayUrl2(apiUrl) {
   const url2 = new URL(apiUrl);
   url2.protocol = url2.protocol === "https:" ? "wss:" : "ws:";
@@ -23164,8 +23394,8 @@ var SyncService = class {
   }
   async writeConfigFiles(instance, agents) {
     const gatewayConfig = generateGatewayConfig(instance, agents);
-    const configPath = path17.join(CLAW_HOME12, "openclaw.json");
-    await fs15.mkdir(CLAW_HOME12, { recursive: true });
+    const configPath = path17.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) => {
@@ -23179,8 +23409,8 @@ var SyncService = class {
 };
 
 // src/cli.ts
-var CLAW_HOME13 = path18.join(os18.homedir(), ".workle-claw");
-var AUTH_FILE2 = path18.join(CLAW_HOME13, "auth.json");
+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 PLIST_LABEL = "com.workle.claw";
 var color = {
@@ -23399,7 +23629,7 @@ async function tokenAuth(setupToken, apiUrl) {
   }
   return await res.json();
 }
-var program2 = new Command().name("workle-claw").description("Workle Claw \u2014 connect your Mac to your Workle org").version(readPkgVersion(), "-v, --version", "Show version");
+var program2 = new Command().name("workle").description("Workle \u2014 connect your Mac to your Workle org").version(readPkgVersion(), "-v, --version", "Show version");
 program2.command("setup").alias("pair").description("Pair this Mac with a Workle instance").option("-t, --token <token>", "Setup token (skip browser, use headless pairing)").option("--api-url <url>", "Override API URL (defaults to https://getworkle.com)").action(async (opts) => {
   const apiUrl = opts.apiUrl ?? "https://getworkle.com";
   try {
@@ -23431,7 +23661,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(CLAW_HOME13, "logs/"))}`);
+      console.log(`  Logs:     ${color.dim(path18.join(WORKLE_HOME9, "logs/"))}`);
       console.log("");
       console.log(
         `To stop:    ${color.cyan("npx @getworkle/cli stop")}`
@@ -23495,7 +23725,7 @@ program2.command("stop").description("Stop the Workle Claw daemon").action(async
   } catch {
     console.log(color.dim("No launchd service loaded."));
   }
-  const pidFile = path18.join(CLAW_HOME13, "openclaw.pid");
+  const pidFile = path18.join(WORKLE_HOME9, "openclaw.pid");
   try {
     const pidStr = await fs16.readFile(pidFile, "utf-8");
     const pid = parseInt(pidStr.trim(), 10);
@@ -23567,8 +23797,8 @@ program2.command("logs").description("Tail the Workle Claw log files").option("-
     process.exit(1);
   }
   const logFiles = [
-    path18.join(CLAW_HOME13, "openclaw.log"),
-    path18.join(CLAW_HOME13, "logs", "stderr.log")
+    path18.join(WORKLE_HOME9, "openclaw.log"),
+    path18.join(WORKLE_HOME9, "logs", "stderr.log")
   ];
   const args = ["-n", String(lineCount)];
   if (opts.follow) args.push("-f");
@@ -23576,7 +23806,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: ${CLAW_HOME13}/logs/`);
+    console.error(`Expected log files at: ${WORKLE_HOME9}/logs/`);
   }
 });
 var agentCmd = program2.command("agent").description("Manage and run Workle AI agents locally");
@@ -23732,7 +23962,7 @@ 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(CLAW_HOME13, "agents");
+  const logsDir = path18.join(WORKLE_HOME9, "agents");
   let logFile;
   if (agentId) {
     logFile = path18.join(logsDir, agentId, "run.log");