too-many-claw 1.0.7 → 1.0.9

package/dist/cli.js

@@ -20,7 +20,7 @@ var AGENT_DEFINITIONS = [
     name: "Base",
     emoji: "\u{1F3E0}",
     category: "CORE" /* CORE */,
-    model: "claude-opus-4-5" /* OPUS */,
+    model: "anthropic/claude-opus-4-5" /* OPUS */,
     role: "Team Coordinator. Always active. Receives and analyzes user requests, then summons appropriate agents. Orchestrates team conversations and synthesizes results for the user upon task completion. Can dismiss agents when necessary.",
     alwaysActive: true
   },
@@ -32,7 +32,7 @@ var AGENT_DEFINITIONS = [
     name: "Search Specialist",
     emoji: "\u{1F50D}",
     category: "RESEARCH" /* RESEARCH */,
-    model: "claude-sonnet-4-5" /* SONNET */,
+    model: "anthropic/claude-sonnet-4-5" /* SONNET */,
     role: "Information search and resource collection specialist. Finds necessary information through web searches, document searches, and database queries. Organizes and shares search results with the team."
   },
   {
@@ -40,7 +40,7 @@ var AGENT_DEFINITIONS = [
     name: "Technology Research Specialist",
     emoji: "\u{1F52C}",
     category: "RESEARCH" /* RESEARCH */,
-    model: "claude-sonnet-4-5" /* SONNET */,
+    model: "anthropic/claude-sonnet-4-5" /* SONNET */,
     role: "Latest technology trends research specialist. Investigates new technologies, frameworks, libraries, and industry trends. Provides comparative analysis of pros and cons for technology selection."
   },
   {
@@ -48,7 +48,7 @@ var AGENT_DEFINITIONS = [
     name: "Trend Analysis Specialist",
     emoji: "\u{1F4C8}",
     category: "RESEARCH" /* RESEARCH */,
-    model: "claude-sonnet-4-5" /* SONNET */,
+    model: "anthropic/claude-sonnet-4-5" /* SONNET */,
     role: "Market and trend analyst. Analyzes current trends, popular topics, and market dynamics. Provides insights on timing and strategic direction."
   },
   {
@@ -56,7 +56,7 @@ var AGENT_DEFINITIONS = [
     name: "Data Preparation Specialist",
     emoji: "\u{1F4CA}",
     category: "RESEARCH" /* RESEARCH */,
-    model: "claude-sonnet-4-5" /* SONNET */,
+    model: "anthropic/claude-sonnet-4-5" /* SONNET */,
     role: "Data collection and refinement specialist. Collects, cleanses, and processes data into usable formats. Handles statistics, metrics, and data preparation."
   },
   // ============================================================================
@@ -67,7 +67,7 @@ var AGENT_DEFINITIONS = [
     name: "Psychological Counselor",
     emoji: "\u{1F49A}",
     category: "PSYCHOLOGY" /* PSYCHOLOGY */,
-    model: "claude-sonnet-4-5" /* SONNET */,
+    model: "anthropic/claude-sonnet-4-5" /* SONNET */,
     role: "Emotional support and counseling specialist. Provides emotional support when users or team members are struggling or stressed. Offers comfort, empathy, and psychological stability."
   },
   {
@@ -75,7 +75,7 @@ var AGENT_DEFINITIONS = [
     name: "User Psychology Analyst",
     emoji: "\u{1F9E0}",
     category: "PSYCHOLOGY" /* PSYCHOLOGY */,
-    model: "claude-opus-4-5" /* OPUS */,
+    model: "anthropic/claude-opus-4-5" /* OPUS */,
     role: "User intent and psychology analysis specialist. Analyzes what users truly want and the hidden intentions behind their words. Identifies underlying needs beyond stated requirements."
   },
   {
@@ -83,7 +83,7 @@ var AGENT_DEFINITIONS = [
     name: "Questioning Specialist",
     emoji: "\u2753",
     category: "PSYCHOLOGY" /* PSYCHOLOGY */,
-    model: "claude-sonnet-4-5" /* SONNET */,
+    model: "anthropic/claude-sonnet-4-5" /* SONNET */,
     role: "Core questioning and clarification specialist. Asks questions to clarify ambiguous requirements. Identifies missing information and unclear aspects to seek clarification."
   },
   {
@@ -91,7 +91,7 @@ var AGENT_DEFINITIONS = [
     name: "Rational Persuasion Specialist",
     emoji: "\u{1F3AF}",
     category: "PSYCHOLOGY" /* PSYCHOLOGY */,
-    model: "claude-sonnet-4-5" /* SONNET */,
+    model: "anthropic/claude-sonnet-4-5" /* SONNET */,
     role: "Logical persuasion and perspective-shifting specialist. Changes or persuades others' views through rational arguments and logic. Also mediates in conflict situations."
   },
   {
@@ -99,7 +99,7 @@ var AGENT_DEFINITIONS = [
     name: "Education Specialist",
     emoji: "\u{1F4DA}",
     category: "PSYCHOLOGY" /* PSYCHOLOGY */,
-    model: "claude-sonnet-4-5" /* SONNET */,
+    model: "anthropic/claude-sonnet-4-5" /* SONNET */,
     role: "Explanation and education specialist. Explains complex concepts in simple terms. Teaches and educates users or team members on topics they don't understand."
   },
   // ============================================================================
@@ -110,7 +110,7 @@ var AGENT_DEFINITIONS = [
     name: "Professional Planning Specialist",
     emoji: "\u{1F4CB}",
     category: "PLANNING" /* PLANNING */,
-    model: "claude-opus-4-5" /* OPUS */,
+    model: "anthropic/claude-opus-4-5" /* OPUS */,
     role: "Planning and roadmap specialist. Breaks down tasks into steps, establishes schedules, and sets priorities. Presents systematic plans and roadmaps."
   },
   {
@@ -118,7 +118,7 @@ var AGENT_DEFINITIONS = [
     name: "Agent Team Composition Specialist",
     emoji: "\u{1F465}",
     category: "PLANNING" /* PLANNING */,
-    model: "claude-sonnet-4-5" /* SONNET */,
+    model: "anthropic/claude-sonnet-4-5" /* SONNET */,
     role: "Optimal team composition recommendation specialist. Analyzes and recommends which agents are needed for a given task. Optimizes team composition efficiency."
   },
   {
@@ -126,7 +126,7 @@ var AGENT_DEFINITIONS = [
     name: "Promotion Specialist",
     emoji: "\u{1F4E2}",
     category: "PLANNING" /* PLANNING */,
-    model: "claude-sonnet-4-5" /* SONNET */,
+    model: "anthropic/claude-sonnet-4-5" /* SONNET */,
     role: "Marketing and promotion specialist. Handles how to publicize deliverables, branding, and marketing strategies. Refines messaging and positioning."
   },
   {
@@ -134,7 +134,7 @@ var AGENT_DEFINITIONS = [
     name: "Uploader",
     emoji: "\u2B06\uFE0F",
     category: "PLANNING" /* PLANNING */,
-    model: "claude-haiku-4-5" /* HAIKU */,
+    model: "anthropic/claude-haiku-3-5" /* HAIKU */,
     role: "Deployment and upload specialist. Deploys and uploads completed deliverables. Handles launches, releases, and publishing."
   },
   // ============================================================================
@@ -145,7 +145,7 @@ var AGENT_DEFINITIONS = [
     name: "Backend Developer",
     emoji: "\u2699\uFE0F",
     category: "DEVELOPMENT" /* DEVELOPMENT */,
-    model: "claude-sonnet-4-5" /* SONNET */,
+    model: "anthropic/claude-sonnet-4-5" /* SONNET */,
     role: "Server and backend development specialist. Handles server logic, APIs, databases, and infrastructure-related development."
   },
   {
@@ -153,7 +153,7 @@ var AGENT_DEFINITIONS = [
     name: "Frontend Developer",
     emoji: "\u{1F3A8}",
     category: "DEVELOPMENT" /* DEVELOPMENT */,
-    model: "claude-sonnet-4-5" /* SONNET */,
+    model: "anthropic/claude-sonnet-4-5" /* SONNET */,
     role: "Frontend and UI development specialist. Handles web/app user interface, screen, and interaction development."
   },
   {
@@ -161,7 +161,7 @@ var AGENT_DEFINITIONS = [
     name: "Professional Designer",
     emoji: "\u{1F58C}\uFE0F",
     category: "DEVELOPMENT" /* DEVELOPMENT */,
-    model: "claude-sonnet-4-5" /* SONNET */,
+    model: "anthropic/claude-sonnet-4-5" /* SONNET */,
     role: "Design and visual specialist. Handles UI/UX design, visual design, layout, color, and typography."
   },
   {
@@ -169,7 +169,7 @@ var AGENT_DEFINITIONS = [
     name: "Code Reviewer",
     emoji: "\u{1F440}",
     category: "DEVELOPMENT" /* DEVELOPMENT */,
-    model: "claude-sonnet-4-5" /* SONNET */,
+    model: "anthropic/claude-sonnet-4-5" /* SONNET */,
     role: "Code quality review specialist. Reviews written code, suggests improvements, and identifies bugs or issues."
   },
   {
@@ -177,7 +177,7 @@ var AGENT_DEFINITIONS = [
     name: "Documentation Specialist",
     emoji: "\u{1F4DD}",
     category: "DEVELOPMENT" /* DEVELOPMENT */,
-    model: "claude-sonnet-4-5" /* SONNET */,
+    model: "anthropic/claude-sonnet-4-5" /* SONNET */,
     role: "Documentation specialist. Handles writing all types of documentation including README, guides, API documentation, and user manuals."
   },
   {
@@ -185,7 +185,7 @@ var AGENT_DEFINITIONS = [
     name: "Automation Specialist",
     emoji: "\u{1F916}",
     category: "DEVELOPMENT" /* DEVELOPMENT */,
-    model: "claude-sonnet-4-5" /* SONNET */,
+    model: "anthropic/claude-sonnet-4-5" /* SONNET */,
     role: "Automation and workflow specialist. Automates repetitive tasks, creates scripts, and designs efficient workflows."
   },
   {
@@ -193,7 +193,7 @@ var AGENT_DEFINITIONS = [
     name: "Prompt Engineer",
     emoji: "\u{1F4AC}",
     category: "DEVELOPMENT" /* DEVELOPMENT */,
-    model: "claude-sonnet-4-5" /* SONNET */,
+    model: "anthropic/claude-sonnet-4-5" /* SONNET */,
     role: "AI prompt optimization specialist. Optimizes prompts sent to LLMs and develops AI utilization strategies."
   },
   {
@@ -201,7 +201,7 @@ var AGENT_DEFINITIONS = [
     name: "AI Illustration Generation Specialist",
     emoji: "\u{1F3AD}",
     category: "DEVELOPMENT" /* DEVELOPMENT */,
-    model: "claude-sonnet-4-5" /* SONNET */,
+    model: "anthropic/claude-sonnet-4-5" /* SONNET */,
     role: "AI image generation specialist. Handles image generation prompt writing and creation using Midjourney, DALL-E, Stable Diffusion, and similar tools."
   },
   // ============================================================================
@@ -212,7 +212,7 @@ var AGENT_DEFINITIONS = [
     name: "Program Testing Specialist",
     emoji: "\u{1F9EA}",
     category: "TESTING" /* TESTING */,
-    model: "claude-sonnet-4-5" /* SONNET */,
+    model: "anthropic/claude-sonnet-4-5" /* SONNET */,
     role: "Technical testing and QA specialist. Handles code testing, unit testing, integration testing, and bug discovery."
   },
   {
@@ -220,7 +220,7 @@ var AGENT_DEFINITIONS = [
     name: "General User Testing Specialist",
     emoji: "\u{1F464}",
     category: "TESTING" /* TESTING */,
-    model: "claude-sonnet-4-5" /* SONNET */,
+    model: "anthropic/claude-sonnet-4-5" /* SONNET */,
     role: "User perspective testing specialist. Validates usability, intuitiveness, and UX from the perspective of a general user without technical knowledge."
   },
   {
@@ -228,7 +228,7 @@ var AGENT_DEFINITIONS = [
     name: "Security Check Specialist",
     emoji: "\u{1F6E1}\uFE0F",
     category: "TESTING" /* TESTING */,
-    model: "claude-sonnet-4-5" /* SONNET */,
+    model: "anthropic/claude-sonnet-4-5" /* SONNET */,
     role: "Security audit specialist. Reviews basic security checklists, confirms compliance, and verifies adherence to security policies."
   },
   {
@@ -236,7 +236,7 @@ var AGENT_DEFINITIONS = [
     name: "Vulnerability Discovery Specialist",
     emoji: "\u{1F513}",
     category: "TESTING" /* TESTING */,
-    model: "claude-sonnet-4-5" /* SONNET */,
+    model: "anthropic/claude-sonnet-4-5" /* SONNET */,
     role: "Vulnerability analysis specialist. Identifies security vulnerabilities and weaknesses in code, systems, and designs."
   },
   {
@@ -244,7 +244,7 @@ var AGENT_DEFINITIONS = [
     name: "Penetration Testing Specialist",
     emoji: "\u{1F480}",
     category: "TESTING" /* TESTING */,
-    model: "claude-opus-4-5" /* OPUS */,
+    model: "anthropic/claude-opus-4-5" /* OPUS */,
     role: "Penetration testing specialist. Tests systems from an actual attacker's perspective and performs hacking simulations."
   },
   // ============================================================================
@@ -255,7 +255,7 @@ var AGENT_DEFINITIONS = [
     name: "Fact Check Specialist",
     emoji: "\u{1F4A3}",
     category: "CRITIQUE" /* CRITIQUE */,
-    model: "claude-sonnet-4-5" /* SONNET */,
+    model: "anthropic/claude-sonnet-4-5" /* SONNET */,
     role: `Fact-checking specialist. Demands evidence for claims, verifies factual accuracy, and points out flaws. The one who asks "What's your evidence?"`
   },
   {
@@ -263,7 +263,7 @@ var AGENT_DEFINITIONS = [
     name: "Blunt Critic",
     emoji: "\u{1F525}",
     category: "CRITIQUE" /* CRITIQUE */,
-    model: "claude-sonnet-4-5" /* SONNET */,
+    model: "anthropic/claude-sonnet-4-5" /* SONNET */,
     role: "Sharp direct feedback specialist. Points out problems directly without beating around the bush. Speaks uncomfortable but necessary truths."
   },
   {
@@ -271,7 +271,7 @@ var AGENT_DEFINITIONS = [
     name: "Critic",
     emoji: "\u{1F9D0}",
     category: "CRITIQUE" /* CRITIQUE */,
-    model: "claude-opus-4-5" /* OPUS */,
+    model: "anthropic/claude-opus-4-5" /* OPUS */,
     role: "Logical criticism specialist. Logically analyzes and critiques problems in plans or deliverables. Provides improvement suggestions alongside criticism."
   },
   {
@@ -279,7 +279,7 @@ var AGENT_DEFINITIONS = [
     name: "Negative Agent",
     emoji: "\u{1F44E}",
     category: "CRITIQUE" /* CRITIQUE */,
-    model: "claude-sonnet-4-5" /* SONNET */,
+    model: "anthropic/claude-sonnet-4-5" /* SONNET */,
     role: "Devil's advocate. Intentionally views things from a negative perspective. Raises worst-case scenarios, failure possibilities, and risks. Prevents the team from falling into blind optimism."
   },
   {
@@ -287,7 +287,7 @@ var AGENT_DEFINITIONS = [
     name: "Praise Specialist",
     emoji: "\u{1F44F}",
     category: "CRITIQUE" /* CRITIQUE */,
-    model: "claude-haiku-4-5" /* HAIKU */,
+    model: "anthropic/claude-haiku-3-5" /* HAIKU */,
     role: "Positive feedback specialist. Finds and praises what was done well, boosts morale, and provides motivation. Balances against critical agents."
   },
   // ============================================================================
@@ -298,7 +298,7 @@ var AGENT_DEFINITIONS = [
     name: "Loophole Discovery Specialist",
     emoji: "\u{1F573}\uFE0F",
     category: "SPECIAL" /* SPECIAL */,
-    model: "claude-sonnet-4-5" /* SONNET */,
+    model: "anthropic/claude-sonnet-4-5" /* SONNET */,
     role: 'Within-rules optimization specialist. Finds workarounds, shortcuts, and clever solutions within established rules or constraints. Answers the question "Is there a way?"'
   },
   {
@@ -306,7 +306,7 @@ var AGENT_DEFINITIONS = [
     name: "Pressure Specialist",
     emoji: "\u26A1",
     category: "SPECIAL" /* SPECIAL */,
-    model: "claude-sonnet-4-5" /* SONNET */,
+    model: "anthropic/claude-sonnet-4-5" /* SONNET */,
     role: "Urgency and pressure specialist. Creates urgency by emphasizing deadline pressure, time limits, and severity of consequences. Pressures agents who are slacking or reluctant to work properly. The team's whip."
   },
   {
@@ -314,7 +314,7 @@ var AGENT_DEFINITIONS = [
     name: "Dirty Worker",
     emoji: "\u{1FAA0}",
     category: "SPECIAL" /* SPECIAL */,
-    model: "claude-haiku-4-5" /* HAIKU */,
+    model: "anthropic/claude-haiku-3-5" /* HAIKU */,
     role: "Undesirable tasks handler. Takes on work that other agents dislike or refuse. Performs boring, repetitive, or tasks nobody wants to do."
   }
 ];
@@ -1925,6 +1925,811 @@ var DiscordAdapter = class {
   }
 };
 
+// src/daemon/OpenClawDaemon.ts
+import { EventEmitter as EventEmitter2 } from "events";
+import { execSync } from "child_process";
+
+// src/openclaw/GatewayClient.ts
+import WebSocket from "ws";
+import { EventEmitter } from "events";
+var DEFAULT_CONFIG2 = {
+  url: "ws://127.0.0.1:18789",
+  reconnect: {
+    enabled: true,
+    maxAttempts: 10,
+    baseDelay: 1e3,
+    maxDelay: 3e4
+  },
+  heartbeatInterval: 3e4,
+  connectionTimeout: 1e4
+};
+var GatewayClient = class extends EventEmitter {
+  ws = null;
+  config;
+  state = "disconnected" /* DISCONNECTED */;
+  reconnectAttempts = 0;
+  reconnectTimer = null;
+  heartbeatTimer = null;
+  connectionTimeoutTimer = null;
+  intentionalClose = false;
+  lastPongTime = 0;
+  constructor(config = {}) {
+    super();
+    this.config = {
+      ...DEFAULT_CONFIG2,
+      ...config,
+      reconnect: {
+        ...DEFAULT_CONFIG2.reconnect,
+        ...config.reconnect
+      }
+    };
+  }
+  /**
+   * Get current connection state
+   */
+  get connectionState() {
+    return this.state;
+  }
+  /**
+   * Check if connected to gateway
+   */
+  get isConnected() {
+    return this.state === "connected" /* CONNECTED */ && this.ws?.readyState === WebSocket.OPEN;
+  }
+  /**
+   * Connect to the OpenClaw Gateway
+   */
+  async connect() {
+    if (this.state === "connected" /* CONNECTED */ || this.state === "connecting" /* CONNECTING */) {
+      return;
+    }
+    this.intentionalClose = false;
+    await this.doConnect();
+  }
+  /**
+   * Disconnect from the gateway
+   */
+  async disconnect() {
+    this.intentionalClose = true;
+    this.clearTimers();
+    this.setState("closed" /* CLOSED */);
+    if (this.ws) {
+      this.ws.close(1e3, "Client disconnect");
+      this.ws = null;
+    }
+  }
+  /**
+   * Send a message to the gateway
+   */
+  send(message) {
+    if (!this.isConnected || !this.ws) {
+      return false;
+    }
+    try {
+      this.ws.send(JSON.stringify(message));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Send a ping to the gateway
+   */
+  ping() {
+    return this.send({ type: "ping", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+  }
+  /**
+   * Request gateway status
+   */
+  requestStatus() {
+    return this.send({ type: "status" });
+  }
+  /**
+   * Request gateway health
+   */
+  requestHealth() {
+    return this.send({ type: "health" });
+  }
+  // ============================================
+  // Private Methods
+  // ============================================
+  async doConnect() {
+    return new Promise((resolve, reject) => {
+      this.setState("connecting" /* CONNECTING */);
+      try {
+        this.ws = new WebSocket(this.config.url);
+      } catch (error) {
+        this.setState("disconnected" /* DISCONNECTED */);
+        reject(error);
+        return;
+      }
+      this.connectionTimeoutTimer = setTimeout(() => {
+        if (this.state === "connecting" /* CONNECTING */) {
+          this.ws?.close();
+          this.ws = null;
+          this.setState("disconnected" /* DISCONNECTED */);
+          reject(new Error(`Connection timeout after ${this.config.connectionTimeout}ms`));
+        }
+      }, this.config.connectionTimeout);
+      this.ws.on("open", () => {
+        this.clearConnectionTimeout();
+        this.reconnectAttempts = 0;
+        this.lastPongTime = Date.now();
+        this.setState("connected" /* CONNECTED */);
+        this.startHeartbeat();
+        this.emit("connect");
+        resolve();
+      });
+      this.ws.on("message", (data) => {
+        this.handleMessage(data);
+      });
+      this.ws.on("close", (code, reason) => {
+        this.clearTimers();
+        const reasonStr = reason.toString() || "Unknown reason";
+        this.emit("disconnect", code, reasonStr);
+        if (!this.intentionalClose && this.config.reconnect.enabled) {
+          this.scheduleReconnect();
+        } else {
+          this.setState("disconnected" /* DISCONNECTED */);
+        }
+      });
+      this.ws.on("error", (error) => {
+        this.emit("error", error);
+      });
+      this.ws.on("pong", () => {
+        this.lastPongTime = Date.now();
+      });
+    });
+  }
+  handleMessage(data) {
+    let message;
+    try {
+      const str = data.toString();
+      message = JSON.parse(str);
+    } catch {
+      return;
+    }
+    this.emit("message", message);
+    switch (message.type) {
+      case "shutdown" /* SHUTDOWN */:
+        this.emit("shutdown");
+        break;
+      case "pong" /* PONG */:
+        this.lastPongTime = Date.now();
+        break;
+      case "agent_response" /* AGENT_RESPONSE */:
+      case "assistant":
+        this.emit("agent_response", message);
+        break;
+      case "agent_delta" /* AGENT_DELTA */:
+      case "delta":
+        this.emit("agent_delta", message);
+        break;
+      case "agent_start" /* AGENT_START */:
+      case "start":
+        this.emit("agent_start", message);
+        break;
+      case "agent_end" /* AGENT_END */:
+      case "end":
+      case "complete":
+        this.emit("agent_end", message);
+        break;
+      case "message" /* MESSAGE */:
+      case "channel_message" /* CHANNEL_MESSAGE */:
+      case "discord":
+        this.emit("channel_message", message);
+        break;
+      case "error" /* ERROR */:
+        this.emit("error", new Error(message.error || "Unknown gateway error"));
+        break;
+      default:
+        break;
+    }
+  }
+  scheduleReconnect() {
+    const { maxAttempts = 10, baseDelay = 1e3, maxDelay = 3e4 } = this.config.reconnect;
+    if (maxAttempts !== -1 && this.reconnectAttempts >= maxAttempts) {
+      this.setState("disconnected" /* DISCONNECTED */);
+      this.emit("reconnect_failed");
+      return;
+    }
+    this.setState("reconnecting" /* RECONNECTING */);
+    this.reconnectAttempts++;
+    const delay = Math.min(
+      baseDelay * Math.pow(2, this.reconnectAttempts - 1),
+      maxDelay
+    );
+    this.emit("reconnecting", this.reconnectAttempts, maxAttempts);
+    this.reconnectTimer = setTimeout(async () => {
+      try {
+        await this.doConnect();
+      } catch {
+      }
+    }, delay);
+  }
+  startHeartbeat() {
+    if (this.config.heartbeatInterval <= 0) {
+      return;
+    }
+    this.heartbeatTimer = setInterval(() => {
+      if (!this.isConnected) {
+        return;
+      }
+      const timeSinceLastPong = Date.now() - this.lastPongTime;
+      if (timeSinceLastPong > this.config.heartbeatInterval * 2) {
+        this.ws?.close(4e3, "Heartbeat timeout");
+        return;
+      }
+      try {
+        this.ws?.ping();
+      } catch {
+      }
+    }, this.config.heartbeatInterval);
+  }
+  setState(state) {
+    if (this.state !== state) {
+      this.state = state;
+      this.emit("state_change", state);
+    }
+  }
+  clearTimers() {
+    this.clearConnectionTimeout();
+    this.clearReconnectTimer();
+    this.clearHeartbeat();
+  }
+  clearConnectionTimeout() {
+    if (this.connectionTimeoutTimer) {
+      clearTimeout(this.connectionTimeoutTimer);
+      this.connectionTimeoutTimer = null;
+    }
+  }
+  clearReconnectTimer() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+  clearHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+};
+
+// src/daemon/AgentMapper.ts
+var AgentMapper = class {
+  idMap = /* @__PURE__ */ new Map();
+  nameMap = /* @__PURE__ */ new Map();
+  aliasMap = /* @__PURE__ */ new Map();
+  constructor() {
+    this.buildMaps();
+  }
+  /**
+   * Build lookup maps for efficient agent resolution
+   */
+  buildMaps() {
+    for (const agent of AGENT_DEFINITIONS) {
+      this.idMap.set(agent.id, agent);
+      this.idMap.set(agent.id.toLowerCase(), agent);
+      const normalizedName = this.normalizeName(agent.name);
+      this.nameMap.set(normalizedName, agent);
+      this.buildAliases(agent);
+    }
+  }
+  /**
+   * Build common aliases for an agent
+   */
+  buildAliases(agent) {
+    const { id, name } = agent;
+    this.aliasMap.set(id.replace(/-/g, "_"), agent);
+    const camelCase = id.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+    this.aliasMap.set(camelCase, agent);
+    this.aliasMap.set(camelCase.toLowerCase(), agent);
+    this.aliasMap.set(name.replace(/\s+/g, "").toLowerCase(), agent);
+    this.aliasMap.set(name.replace(/\s+/g, "_").toLowerCase(), agent);
+    const specialAliases = {
+      "base": ["coordinator", "main", "primary", "default", "openclaw"],
+      "backend-dev": ["backend", "server", "api"],
+      "frontend-dev": ["frontend", "ui", "web"],
+      "code-reviewer": ["reviewer", "review"],
+      "program-tester": ["tester", "qa", "testing"],
+      "security-checker": ["security", "securitycheck"],
+      "vuln-finder": ["vulnerability", "vulnscanner"],
+      "tech-researcher": ["researcher", "research"],
+      "doc-writer": ["documentation", "docs", "writer"],
+      "prompt-engineer": ["prompter", "prompt"],
+      "ai-illustrator": ["illustrator", "artist", "image"],
+      "user-psychologist": ["psychologist", "psychology"],
+      "fact-bomber": ["factcheck", "factchecker"],
+      "dirty-worker": ["worker", "grunt"]
+    };
+    if (specialAliases[id]) {
+      for (const alias of specialAliases[id]) {
+        this.aliasMap.set(alias, agent);
+      }
+    }
+  }
+  /**
+   * Normalize a name for comparison
+   */
+  normalizeName(name) {
+    return name.toLowerCase().replace(/[^a-z0-9]/g, "").trim();
+  }
+  /**
+   * Resolve an OpenClaw agent identifier to a TMC agent
+   * Tries multiple matching strategies
+   */
+  resolve(identifier) {
+    if (!identifier) {
+      return this.getDefaultAgent();
+    }
+    const normalized = identifier.toLowerCase().trim();
+    const byId = this.idMap.get(normalized);
+    if (byId) return byId;
+    const byName = this.nameMap.get(this.normalizeName(identifier));
+    if (byName) return byName;
+    const byAlias = this.aliasMap.get(normalized);
+    if (byAlias) return byAlias;
+    const partial = this.partialMatch(normalized);
+    if (partial) return partial;
+    return this.getDefaultAgent();
+  }
+  /**
+   * Try partial/fuzzy matching
+   */
+  partialMatch(query) {
+    for (const agent of AGENT_DEFINITIONS) {
+      if (agent.id.includes(query) || query.includes(agent.id)) {
+        return agent;
+      }
+    }
+    const normalizedQuery = this.normalizeName(query);
+    for (const agent of AGENT_DEFINITIONS) {
+      const normalizedAgentName = this.normalizeName(agent.name);
+      if (normalizedAgentName.includes(normalizedQuery) || normalizedQuery.includes(normalizedAgentName)) {
+        return agent;
+      }
+    }
+    return null;
+  }
+  /**
+   * Get the default agent (base/coordinator)
+   */
+  getDefaultAgent() {
+    return getAgentById("base") || AGENT_DEFINITIONS[0];
+  }
+  /**
+   * Check if an identifier maps to a known agent
+   */
+  isKnownAgent(identifier) {
+    return this.resolve(identifier) !== null;
+  }
+  /**
+   * Get all registered agent IDs
+   */
+  getAllAgentIds() {
+    return AGENT_DEFINITIONS.map((a) => a.id);
+  }
+};
+
+// src/daemon/OpenClawDaemon.ts
+var DEFAULT_CONFIG3 = {
+  gatewayUrl: "ws://127.0.0.1:18789",
+  autoStart: true,
+  processCheckInterval: 5e3,
+  verbose: false
+};
+var OpenClawDaemon = class extends EventEmitter2 {
+  config;
+  gatewayClient;
+  webhookManager;
+  configManager;
+  agentMapper;
+  running = false;
+  startTime = null;
+  processCheckTimer = null;
+  openclawDetected = false;
+  // Stats
+  messagesProcessed = 0;
+  messagesForwarded = 0;
+  webhookErrors = 0;
+  lastMessageAt = null;
+  reconnectAttempts = 0;
+  // Track active agents in conversation
+  activeAgents = /* @__PURE__ */ new Set();
+  // Buffer for accumulating streaming responses
+  responseBuffers = /* @__PURE__ */ new Map();
+  bufferCleanupTimer = null;
+  // Buffer stale threshold in ms (60 seconds)
+  BUFFER_STALE_THRESHOLD = 6e4;
+  constructor(config = {}) {
+    super();
+    this.config = { ...DEFAULT_CONFIG3, ...config };
+    this.configManager = new ConfigManager();
+    this.webhookManager = new WebhookManager();
+    this.agentMapper = new AgentMapper();
+    this.gatewayClient = new GatewayClient({
+      url: this.config.gatewayUrl,
+      reconnect: {
+        enabled: true,
+        maxAttempts: -1,
+        // Infinite reconnection
+        baseDelay: 1e3,
+        maxDelay: 3e4
+      }
+    });
+    this.setupEventHandlers();
+    this.loadWebhooks();
+  }
+  /**
+   * Start the daemon
+   */
+  async start() {
+    if (this.running) {
+      return;
+    }
+    this.running = true;
+    this.startTime = /* @__PURE__ */ new Date();
+    this.emit("start");
+    this.forceLog("Daemon starting...");
+    this.startBufferCleanup();
+    if (this.config.autoStart) {
+      this.startProcessDetection();
+    }
+    await this.connect();
+  }
+  /**
+   * Stop the daemon
+   */
+  async stop() {
+    if (!this.running) {
+      return;
+    }
+    this.running = false;
+    this.forceLog("Daemon stopping...");
+    this.stopProcessDetection();
+    this.stopBufferCleanup();
+    await this.gatewayClient.disconnect();
+    this.webhookManager.destroy();
+    this.emit("stop");
+  }
+  /**
+   * Connect to OpenClaw Gateway
+   */
+  async connect() {
+    try {
+      await this.gatewayClient.connect();
+      return true;
+    } catch (error) {
+      this.log(`Connection failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+      return false;
+    }
+  }
+  /**
+   * Get daemon statistics
+   */
+  getStats() {
+    return {
+      connected: this.gatewayClient.isConnected,
+      connectionState: this.gatewayClient.connectionState,
+      messagesProcessed: this.messagesProcessed,
+      messagesForwarded: this.messagesForwarded,
+      webhookErrors: this.webhookErrors,
+      lastMessageAt: this.lastMessageAt,
+      uptimeMs: this.startTime ? Date.now() - this.startTime.getTime() : 0,
+      reconnectAttempts: this.reconnectAttempts
+    };
+  }
+  /**
+   * Check if daemon is running
+   */
+  get isRunning() {
+    return this.running;
+  }
+  /**
+   * Check if connected to OpenClaw
+   */
+  get isConnected() {
+    return this.gatewayClient.isConnected;
+  }
+  /**
+   * Get list of active agents
+   */
+  getActiveAgents() {
+    return Array.from(this.activeAgents);
+  }
+  // ============================================
+  // Private Methods
+  // ============================================
+  /**
+   * Set up event handlers for the gateway client
+   */
+  setupEventHandlers() {
+    this.gatewayClient.on("connect", () => {
+      this.forceLog("Connected to OpenClaw Gateway");
+      this.openclawDetected = true;
+      this.emit("connected");
+      this.emit("openclaw_detected");
+    });
+    this.gatewayClient.on("disconnect", (code, reason) => {
+      this.forceLog(`Disconnected from Gateway: ${code} - ${reason}`);
+      this.emit("disconnected", reason);
+    });
+    this.gatewayClient.on("reconnecting", (attempt) => {
+      this.reconnectAttempts = attempt;
+      this.forceLog(`Reconnecting... (attempt ${attempt})`);
+      this.emit("reconnecting", attempt);
+    });
+    this.gatewayClient.on("reconnect_failed", () => {
+      this.forceLog("Reconnection failed - max attempts reached");
+      if (this.openclawDetected) {
+        this.openclawDetected = false;
+        this.emit("openclaw_lost");
+      }
+    });
+    this.gatewayClient.on("error", (error) => {
+      this.forceLog(`Gateway error: ${error.message}`);
+      this.emit("error", error);
+    });
+    this.gatewayClient.on("shutdown", () => {
+      this.forceLog("Gateway shutdown signal received");
+      this.openclawDetected = false;
+      this.emit("openclaw_lost");
+    });
+    this.gatewayClient.on("message", (message) => {
+      this.handleRawMessage(message);
+    });
+    this.gatewayClient.on("agent_response", (message) => {
+      this.handleAgentResponse(message);
+    });
+    this.gatewayClient.on("agent_delta", (message) => {
+      this.handleAgentDelta(message);
+    });
+    this.gatewayClient.on("agent_start", (message) => {
+      this.handleAgentStart(message);
+    });
+    this.gatewayClient.on("agent_end", (message) => {
+      this.handleAgentEnd(message);
+    });
+    this.gatewayClient.on("channel_message", (message) => {
+      this.handleChannelMessage(message);
+    });
+  }
+  /**
+   * Load webhooks from configuration
+   */
+  loadWebhooks() {
+    const webhooks = this.configManager.getAllWebhooks();
+    if (Object.keys(webhooks).length > 0) {
+      this.webhookManager.setWebhooks(webhooks);
+      this.log(`Loaded ${Object.keys(webhooks).length} webhooks`);
+    } else {
+      this.log("No webhooks configured - messages will not be forwarded to Discord");
+    }
+  }
+  /**
+   * Handle raw message from gateway (for debugging/logging)
+   */
+  handleRawMessage(message) {
+    this.messagesProcessed++;
+    this.lastMessageAt = /* @__PURE__ */ new Date();
+    if (this.config.verbose) {
+      this.log(`Raw message: ${JSON.stringify(message).substring(0, 200)}...`);
+    }
+  }
+  /**
+   * Handle agent response (complete response)
+   */
+  async handleAgentResponse(message) {
+    const agentIdentifier = message.agentId || message.agentName || message.agent;
+    const content = message.content || message.text || message.message;
+    if (!content) {
+      return;
+    }
+    const agent = this.agentMapper.resolve(agentIdentifier);
+    if (!agent) {
+      this.log(`Unknown agent: ${agentIdentifier}`);
+      return;
+    }
+    this.emit("message_received", agent.id, content);
+    await this.forwardToWebhook(agent, content);
+  }
+  /**
+   * Handle streaming delta (partial response)
+   */
+  handleAgentDelta(message) {
+    const agentIdentifier = message.agentId || message.agentName || message.agent;
+    const delta = message.delta || message.content || message.text;
+    const messageId = message.id || agentIdentifier || "default";
+    if (!delta) {
+      return;
+    }
+    const existing = this.responseBuffers.get(messageId);
+    if (existing) {
+      existing.content += delta;
+      existing.lastUpdate = Date.now();
+    } else {
+      const agent = this.agentMapper.resolve(agentIdentifier);
+      this.responseBuffers.set(messageId, {
+        agentId: agent?.id || "base",
+        content: delta,
+        lastUpdate: Date.now()
+      });
+    }
+  }
+  /**
+   * Handle agent start event
+   */
+  handleAgentStart(message) {
+    const agentIdentifier = message.agentId || message.agentName || message.agent;
+    const agent = this.agentMapper.resolve(agentIdentifier);
+    if (agent && !this.activeAgents.has(agent.id)) {
+      this.activeAgents.add(agent.id);
+      this.emit("agent_enter", agent);
+      this.log(`Agent entered: ${agent.emoji} ${agent.name}`);
+    }
+  }
+  /**
+   * Handle agent end event (flush buffer and send)
+   */
+  async handleAgentEnd(message) {
+    const messageId = message.id || message.agentId || message.agentName || "default";
+    const agentIdentifier = message.agentId || message.agentName || message.agent;
+    const buffered = this.responseBuffers.get(messageId);
+    if (buffered && buffered.content) {
+      const agent2 = this.agentMapper.resolve(buffered.agentId) || this.agentMapper.getDefaultAgent();
+      this.emit("message_received", agent2.id, buffered.content);
+      await this.forwardToWebhook(agent2, buffered.content);
+      this.responseBuffers.delete(messageId);
+    }
+    const content = message.content || message.text;
+    if (content) {
+      const agent2 = this.agentMapper.resolve(agentIdentifier);
+      if (agent2) {
+        this.emit("message_received", agent2.id, content);
+        await this.forwardToWebhook(agent2, content);
+      }
+    }
+    const agent = this.agentMapper.resolve(agentIdentifier);
+    if (agent && message.complete !== false) {
+    }
+  }
+  /**
+   * Handle channel message (user messages from Discord)
+   */
+  handleChannelMessage(message) {
+    if (this.config.verbose) {
+      this.log(`Channel message from ${message.author?.name || "unknown"}: ${message.content?.substring(0, 50)}...`);
+    }
+  }
+  /**
+   * Forward a message to Discord via webhook
+   */
+  async forwardToWebhook(agent, content) {
+    let webhookAgentId = agent.id;
+    if (!this.webhookManager.hasWebhook(agent.id)) {
+      if (!this.webhookManager.hasWebhook("base")) {
+        this.log(`No webhook available for agent: ${agent.id}`);
+        return;
+      }
+      webhookAgentId = "base";
+      this.log(`Using base webhook for agent: ${agent.id}`);
+    }
+    try {
+      await this.webhookManager.sendAsAgent(webhookAgentId, content);
+      this.messagesForwarded++;
+      this.emit("message_forwarded", agent.id, content);
+      this.log(`Forwarded message from ${agent.emoji} ${agent.name}`);
+    } catch (error) {
+      this.webhookErrors++;
+      this.log(`Failed to forward message: ${error instanceof Error ? error.message : "Unknown error"}`);
+      this.emit("error", error instanceof Error ? error : new Error("Webhook send failed"));
+    }
+  }
+  /**
+   * Start process detection loop
+   */
+  startProcessDetection() {
+    if (this.processCheckTimer) {
+      return;
+    }
+    this.processCheckTimer = setInterval(() => {
+      this.checkOpenClawProcess();
+    }, this.config.processCheckInterval);
+  }
+  /**
+   * Stop process detection loop
+   */
+  stopProcessDetection() {
+    if (this.processCheckTimer) {
+      clearInterval(this.processCheckTimer);
+      this.processCheckTimer = null;
+    }
+  }
+  /**
+   * Check if OpenClaw process is running
+   */
+  checkOpenClawProcess() {
+    const isRunning = this.isOpenClawRunning();
+    if (isRunning && !this.gatewayClient.isConnected) {
+      this.log("OpenClaw process detected, attempting to connect...");
+      this.connect();
+    } else if (!isRunning && this.openclawDetected) {
+      this.openclawDetected = false;
+      this.emit("openclaw_lost");
+    }
+  }
+  /**
+   * Start periodic cleanup of stale response buffers
+   */
+  startBufferCleanup() {
+    if (this.bufferCleanupTimer) {
+      return;
+    }
+    this.bufferCleanupTimer = setInterval(() => {
+      const now = Date.now();
+      let cleanedCount = 0;
+      for (const [id, buffer] of this.responseBuffers) {
+        if (now - buffer.lastUpdate > this.BUFFER_STALE_THRESHOLD) {
+          if (buffer.content.trim()) {
+            const agent = this.agentMapper.resolve(buffer.agentId) || this.agentMapper.getDefaultAgent();
+            this.forwardToWebhook(agent, buffer.content).catch(() => {
+            });
+          }
+          this.responseBuffers.delete(id);
+          cleanedCount++;
+        }
+      }
+      if (cleanedCount > 0 && this.config.verbose) {
+        this.log(`Cleaned ${cleanedCount} stale response buffer(s)`);
+      }
+    }, 3e4);
+  }
+  /**
+   * Stop buffer cleanup interval
+   */
+  stopBufferCleanup() {
+    if (this.bufferCleanupTimer) {
+      clearInterval(this.bufferCleanupTimer);
+      this.bufferCleanupTimer = null;
+    }
+  }
+  /**
+   * Check if OpenClaw process is running on the system
+   */
+  isOpenClawRunning() {
+    try {
+      const platform = process.platform;
+      if (platform === "win32") {
+        const result = execSync('tasklist /FI "IMAGENAME eq node.exe" /FO CSV', { encoding: "utf8", timeout: 5e3 });
+        return result.toLowerCase().includes("openclaw");
+      } else {
+        const result = execSync("ps aux", { encoding: "utf8", timeout: 5e3 });
+        return result.toLowerCase().includes("openclaw");
+      }
+    } catch {
+      return true;
+    }
+  }
+  /**
+   * Log a message (if verbose mode or important)
+   */
+  log(message) {
+    if (this.config.verbose) {
+      const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+      console.log(`[${timestamp}] [TMC Daemon] ${message}`);
+    }
+  }
+  /**
+   * Force log regardless of verbose setting
+   */
+  forceLog(message) {
+    const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+    console.log(`[${timestamp}] [TMC Daemon] ${message}`);
+  }
+};
+
 // src/cli.ts
 var program = new Command();
 program.name("tmc").description("Too Many Claw - 35 AI agents collaborating via Discord").version("1.0.4");
@@ -2666,6 +3471,131 @@ program.command("debug").description("Debug OpenClaw configuration detection").o
     console.log(chalk3.gray("   Check the paths above to see where Discord settings are stored.\n"));
   }
 });
+program.command("daemon").description("Run daemon mode to auto-connect to OpenClaw and forward agent messages via webhooks").option("-v, --verbose", "Enable verbose logging").option("--url <url>", "OpenClaw Gateway URL", "ws://127.0.0.1:18789").action(async (options) => {
+  console.log(chalk3.cyan(`
+\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+\u2551                                                            \u2551
+\u2551   \u{1F980} Too Many Claw - Daemon Mode                           \u2551
+\u2551                                                            \u2551
+\u2551   Auto-connects to OpenClaw and forwards agent messages    \u2551
+\u2551   through Discord webhooks                                 \u2551
+\u2551                                                            \u2551
+\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+`));
+  const config = new ConfigManager();
+  const webhooks = config.getAllWebhooks();
+  if (Object.keys(webhooks).length === 0) {
+    console.log(chalk3.yellow("\u26A0 No webhooks configured."));
+    console.log(chalk3.gray("  Agent messages will not be forwarded to Discord."));
+    console.log(chalk3.gray("  Run `tmc setup` to configure webhooks.\n"));
+  } else {
+    console.log(chalk3.green(`\u2713 ${Object.keys(webhooks).length} webhooks loaded
+`));
+  }
+  const daemon = new OpenClawDaemon({
+    gatewayUrl: options.url,
+    verbose: options.verbose || false,
+    autoStart: true
+  });
+  let statusSpinner = ora("Connecting to OpenClaw Gateway...").start();
+  let statsInterval = null;
+  let isShuttingDown = false;
+  daemon.on("connected", () => {
+    statusSpinner.succeed("Connected to OpenClaw Gateway");
+    console.log(chalk3.green("\n\u{1F99E} Daemon is now running!"));
+    console.log(chalk3.gray("  Listening for agent responses..."));
+    console.log(chalk3.gray("  Press Ctrl+C to stop.\n"));
+    statsInterval = setInterval(() => {
+      const stats = daemon.getStats();
+      if (stats.messagesProcessed > 0 || options.verbose) {
+        const uptime = formatUptime(stats.uptimeMs);
+        console.log(chalk3.gray(
+          `[Stats] Uptime: ${uptime} | Messages: ${stats.messagesProcessed} processed, ${stats.messagesForwarded} forwarded | Errors: ${stats.webhookErrors}`
+        ));
+      }
+    }, 3e4);
+  });
+  daemon.on("disconnected", (reason) => {
+    if (!isShuttingDown) {
+      console.log(chalk3.yellow(`
+\u26A0 Disconnected: ${reason}`));
+      statusSpinner = ora("Waiting for OpenClaw Gateway...").start();
+    }
+  });
+  daemon.on("reconnecting", (attempt) => {
+    statusSpinner.text = `Reconnecting to OpenClaw Gateway... (attempt ${attempt})`;
+  });
+  daemon.on("openclaw_detected", () => {
+    if (options.verbose) {
+      console.log(chalk3.green("\n\u2713 OpenClaw process detected"));
+    }
+  });
+  daemon.on("openclaw_lost", () => {
+    console.log(chalk3.yellow("\n\u26A0 OpenClaw process no longer detected"));
+    console.log(chalk3.gray("  Daemon will auto-reconnect when OpenClaw starts.\n"));
+    statusSpinner = ora("Waiting for OpenClaw...").start();
+  });
+  daemon.on("message_forwarded", (agentId, content) => {
+    if (options.verbose) {
+      const preview = content.length > 50 ? content.substring(0, 50) + "..." : content;
+      console.log(chalk3.blue(`  \u2192 Forwarded from ${agentId}: ${preview}`));
+    }
+  });
+  daemon.on("error", (error) => {
+    if (options.verbose) {
+      console.log(chalk3.red(`  \u2717 Error: ${error.message}`));
+    }
+  });
+  const shutdown = async () => {
+    if (isShuttingDown) return;
+    isShuttingDown = true;
+    statusSpinner.stop();
+    console.log(chalk3.yellow("\n\nShutting down daemon..."));
+    if (statsInterval) {
+      clearInterval(statsInterval);
+    }
+    const stats = daemon.getStats();
+    console.log(chalk3.cyan("\n\u2501\u2501\u2501 Final Statistics \u2501\u2501\u2501"));
+    console.log(chalk3.white(`  Uptime: ${formatUptime(stats.uptimeMs)}`));
+    console.log(chalk3.white(`  Messages processed: ${stats.messagesProcessed}`));
+    console.log(chalk3.white(`  Messages forwarded: ${stats.messagesForwarded}`));
+    console.log(chalk3.white(`  Webhook errors: ${stats.webhookErrors}`));
+    console.log(chalk3.cyan("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\n"));
+    await daemon.stop();
+    console.log(chalk3.green("Daemon stopped. Goodbye! \u{1F44B}\n"));
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  try {
+    await daemon.start();
+    if (!daemon.isConnected) {
+      statusSpinner.warn("OpenClaw Gateway not found");
+      console.log(chalk3.yellow("\n\u26A0 Could not connect to OpenClaw Gateway."));
+      console.log(chalk3.gray("\nMake sure OpenClaw is running:"));
+      console.log(chalk3.white("  $ openclaw gateway run\n"));
+      console.log(chalk3.gray("The daemon will keep trying to connect..."));
+      statusSpinner = ora("Waiting for OpenClaw Gateway...").start();
+    }
+  } catch (error) {
+    statusSpinner.fail("Failed to start daemon");
+    console.error(chalk3.red(`
+Error: ${error instanceof Error ? error.message : "Unknown error"}`));
+    process.exit(1);
+  }
+});
+function formatUptime(ms) {
+  const seconds = Math.floor(ms / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  if (hours > 0) {
+    return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
+  } else if (minutes > 0) {
+    return `${minutes}m ${seconds % 60}s`;
+  } else {
+    return `${seconds}s`;
+  }
+}
 program.command("agents").description("List all available agents").option("-c, --category <category>", "Filter by category").action((options) => {
   console.log(chalk3.cyan("\n\u{1F980} Too Many Claw - Agent Directory\n"));
   let agents = AGENT_DEFINITIONS;