@openagents-org/agent-launcher 0.2.119 → 0.2.121

package/icons/kimi.svg

@@ -0,0 +1,11 @@
+<svg viewBox="0 0 24 24" width="1em" height="1em" xmlns="http://www.w3.org/2000/svg">
+  <defs>
+    <linearGradient id="kimi-g" x1="4" y1="4" x2="20" y2="20" gradientUnits="userSpaceOnUse">
+      <stop stop-color="#141821"/>
+      <stop offset="0.52" stop-color="#2f6df6"/>
+      <stop offset="1" stop-color="#49d2ff"/>
+    </linearGradient>
+  </defs>
+  <rect x="2" y="2" width="20" height="20" rx="6" fill="url(#kimi-g)"/>
+  <path d="M7 6.5h2.6v4.1l4.2-4.1H17l-4.7 4.7 5 6.3h-3.2l-3.6-4.7-.9.9v3.8H7z" fill="#fff"/>
+</svg>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openagents-org/agent-launcher",
-  "version": "0.2.119",
+  "version": "0.2.121",
   "description": "OpenAgents Launcher — install, configure, and run AI coding agents from your terminal",
   "main": "src/index.js",
   "bin": {

package/registry.json

@@ -557,6 +557,65 @@
       "windows": "pip install sweagent"
     }
   },
+  {
+    "name": "kimi",
+    "label": "Kimi",
+    "description": "Kimi agent powered by Moonshot AI, OpenAI-compatible API.",
+    "homepage": "https://platform.moonshot.ai",
+    "tags": [
+      "coding",
+      "moonshot",
+      "open-source"
+    ],
+    "featured": true,
+    "order": 7,
+    "support": { "install": true, "workspace": true, "collaboration": true },
+    "builtin": true,
+    "install": {
+      "binary": "kimi",
+      "api_only": true,
+      "macos": "echo 'Kimi uses direct API mode — no binary install needed'",
+      "linux": "echo 'Kimi uses direct API mode — no binary install needed'",
+      "windows": "echo 'Kimi uses direct API mode — no binary install needed'"
+    },
+    "adapter": {
+      "module": "openagents.adapters.kimi",
+      "class": "KimiAdapter"
+    },
+    "launch": {
+      "args": []
+    },
+    "env_config": [
+      {
+        "name": "KIMI_API_KEY",
+        "description": "Moonshot/Kimi API key (also accepts MOONSHOT_API_KEY env var)",
+        "required": true,
+        "password": true
+      },
+      {
+        "name": "KIMI_BASE_URL",
+        "description": "Kimi API base URL (OpenAI-compatible endpoint)",
+        "required": false,
+        "default": "https://api.moonshot.ai/v1",
+        "placeholder": "https://api.moonshot.ai/v1"
+      },
+      {
+        "name": "KIMI_MODEL",
+        "description": "Kimi model name",
+        "required": false,
+        "default": "kimi-k2.6",
+        "placeholder": "kimi-k2.6"
+      }
+    ],
+    "check_ready": {
+      "env_vars": [
+        "KIMI_API_KEY",
+        "MOONSHOT_API_KEY"
+      ],
+      "saved_env_key": "KIMI_API_KEY",
+      "not_ready_message": "No API key — press e to configure"
+    }
+  },
   {
     "name": "hermes",
     "label": "Hermes Agent",

package/src/adapters/base.js

@@ -52,6 +52,11 @@ class BaseAdapter {
     // Per-channel task tracking for parallel execution
     this._channelBusy = new Set();
     this._channelQueues = {};
+    // Wall-clock timestamp of adapter init, used by the `status` control
+    // action to report uptime back to the channel. Reset on reinstantiation
+    // (e.g. after a `restart` IPC bounce) so uptime tracks "time since last
+    // restart" rather than the long-running daemon's process uptime.
+    this._startedAt = Date.now();
     this._log = (msg) => {
       const ts = new Date().toISOString();
       console.log(`${ts} INFO adapter [${this.agentName}]: ${msg}`);
@@ -79,8 +84,12 @@ class BaseAdapter {
       this._log(`Warning: join failed: ${e.message} \nStack: ${e.stack}`);
     }
 
-    await this._skipExistingEvents();
-
+    // Fast-path operations (control-event cursor + heartbeat + control poll)
+    // run BEFORE the message-cursor advance. Even though _skipExistingEvents
+    // is fast on a healthy backend, we don't want slash commands gated on
+    // its success — keeping these paths independent makes /restart and
+    // /status responsive immediately after join.
+    await this._skipExistingControlEvents();
     const heartbeatInterval = setInterval(() => this._heartbeat(), 30000);
     const controlPoller = this._controlPollerLoop();
 
@@ -89,6 +98,8 @@ class BaseAdapter {
       try { await this._heartbeat(); } catch (e) {
         this._log(`Heartbeat failed (non-fatal): ${e.message}`);
       }
+      // Slow path: only the message-poll loop waits for this.
+      await this._skipExistingEvents();
       this._log('Starting poll loop...');
       await this._pollLoop();
     } finally {
@@ -144,6 +155,26 @@ class BaseAdapter {
   // Control polling
   // ------------------------------------------------------------------
 
+  /**
+   * Advance `_lastControlId` past any pending control events for this agent
+   * so we don't re-process them after a respawn. Without this, /restart
+   * triggers a daemon bounce, the new adapter starts with _lastControlId=null,
+   * polls and re-finds the same /restart event, bounces again — restart loop.
+   */
+  async _skipExistingControlEvents() {
+    try {
+      const events = await this.client.pollControl(
+        this.workspaceId, this.agentName, this.token,
+        { after: null }
+      );
+      if (events.length > 0) {
+        // pollControl returns ascending-by-timestamp; take the latest.
+        this._lastControlId = events[events.length - 1].id;
+        this._log(`Skipped ${events.length} existing control event(s), cursor at ${this._lastControlId}`);
+      }
+    } catch {}
+  }
+
   async _pollControl() {
     try {
       const events = await this.client.pollControl(
@@ -169,9 +200,66 @@ class BaseAdapter {
   }
 
   /**
-   * Handle adapter-specific control actions. Override in subclasses.
+   * Handle adapter-specific control actions. Override in subclasses to add
+   * per-adapter actions (`stop`, `restart`, …); always call
+   * `await super._onControlAction(action, payload)` from the override for
+   * actions you don't recognize, so shared actions like `status` keep
+   * working uniformly across adapter types.
+   */
+  async _onControlAction(action, payload) {
+    if (action === 'status') {
+      await this._postStatusReport(payload);
+    }
+  }
+
+  /**
+   * Post a chat message back to the requesting channel summarizing agent
+   * name, type, agent-launcher version, uptime, and network. Used by the
+   * `/status` slash command.
    */
-  async _onControlAction(_action, _payload) {}
+  async _postStatusReport(payload) {
+    const channel = (payload && typeof payload === 'object') ? payload.channel : null;
+    if (!channel) return;
+
+    let pkgVersion = 'unknown';
+    try {
+      const path = require('path');
+      const pkg = require(path.join(__dirname, '..', '..', 'package.json'));
+      pkgVersion = pkg.version || 'unknown';
+    } catch {}
+
+    const uptimeMs = Math.max(0, Date.now() - this._startedAt);
+    const totalSec = Math.floor(uptimeMs / 1000);
+    const days = Math.floor(totalSec / 86400);
+    const hours = Math.floor((totalSec % 86400) / 3600);
+    const minutes = Math.floor((totalSec % 3600) / 60);
+    const seconds = totalSec % 60;
+    let uptime;
+    if (days > 0) uptime = `${days}d ${hours}h ${minutes}m`;
+    else if (hours > 0) uptime = `${hours}h ${minutes}m`;
+    else if (minutes > 0) uptime = `${minutes}m ${seconds}s`;
+    else uptime = `${seconds}s`;
+
+    const adapterType = this.agentType || 'unknown';
+    const content =
+      `**Agent status**\n` +
+      `- Name: \`${this.agentName}\` (${adapterType})\n` +
+      `- Version: agent-launcher \`${pkgVersion}\`\n` +
+      `- Uptime: ${uptime}\n` +
+      `- Network: \`${this.workspaceId}\``;
+
+    try {
+      await this.client.sendMessage(this.workspaceId, channel, this.token, content, {
+        senderType: 'agent',
+        senderName: this.agentName,
+        messageType: 'chat',
+        metadata: { agent_mode: this._mode },
+        sessionId: this._sessionId,
+      });
+    } catch (e) {
+      this._log(`Status: failed to post: ${e && e.message ? e.message : e}`);
+    }
+  }
 
   _hasActiveWork() {
     return this._channelBusy.size > 0;
@@ -412,6 +500,18 @@ class BaseAdapter {
     }
   }
 
+  async getRemainingTodos(channel) {
+    try {
+      const result = await this.client.getTodos(this.workspaceId, channel, this.token, {
+        all: false,
+      });
+      const todos = (result && result.todos) || [];
+      return todos.filter((t) => t.status === 'pending' || t.status === 'in_progress');
+    } catch {
+      return [];
+    }
+  }
+
   async sendTodos(channel, todos) {
     try {
       await this.client.putTodos(this.workspaceId, channel, this.token, todos, {

package/src/adapters/claude.js

@@ -65,10 +65,87 @@ class ClaudeAdapter extends BaseAdapter {
     } catch {}
   }
 
-  async _onControlAction(action, _payload) {
+  async _onControlAction(action, payload) {
     if (action === 'stop') {
-      await this._stopAllProcesses('Execution stopped by user.');
+      const channel = (payload && typeof payload === 'object') ? payload.channel : null;
+      if (channel && this._channelProcesses[channel]) {
+        this._log(`Stopping process for channel=${channel}`);
+        this._stoppingChannels.add(channel);
+        const proc = this._channelProcesses[channel];
+        await this._stopProcess(proc);
+        delete this._channelProcesses[channel];
+        delete this._channelQueues[channel];
+        try {
+          await this.sendResponse(channel, 'Execution stopped by user.');
+        } catch {}
+      } else {
+        await this._stopAllProcesses('Execution stopped by user.');
+      }
+      return;
+    }
+    if (action === 'restart') {
+      const channel = (payload && typeof payload === 'object') ? payload.channel : null;
+      if (channel) {
+        // Kill in-flight subprocess + clear the per-channel session BEFORE
+        // asking the daemon to bounce us. The new adapter spawned after
+        // the bounce loads sessions from disk, so the cleared state must
+        // be persisted first.
+        const proc = this._channelProcesses[channel];
+        if (proc) {
+          try { await this._stopProcess(proc); } catch {}
+          delete this._channelProcesses[channel];
+        }
+        if (this._channelSessions[channel]) {
+          delete this._channelSessions[channel];
+          try { this._saveSessions(); } catch {}
+          this._log(`Restart: cleared session for channel=${channel}`);
+        } else {
+          this._log(`Restart: no session to clear for channel=${channel}`);
+        }
+        // Post the status BEFORE the bounce so the message lands while
+        // we're still online.
+        try {
+          await this.client.sendMessage(this.workspaceId, channel, this.token,
+            'Session restarted — next message starts fresh.',
+            {
+              senderType: 'agent',
+              senderName: this.agentName,
+              messageType: 'status',
+              metadata: { agent_mode: this._mode },
+              sessionId: this._sessionId,
+            });
+        } catch (e) {
+          this._log(`Restart: failed to post status: ${e && e.message ? e.message : e}`);
+        }
+      } else {
+        // Defensive — no channel, clear everything before the bounce.
+        this._channelSessions = {};
+        try { this._saveSessions(); } catch {}
+        await this._stopAllProcesses('Execution stopped by user.');
+        this._log('Restart: cleared all sessions (no channel param)');
+      }
+      // Ask the daemon to bounce just THIS agent — true process-level
+      // restart. Daemon's command-file poller picks up `restart:<name>`
+      // within ~1s, calls restartAgent, our run() loop exits cleanly,
+      // and a fresh adapter is spawned with a new `_startedAt`. Sibling
+      // agents on the same daemon are untouched.
+      try {
+        const path = require('path');
+        const os = require('os');
+        const fs = require('fs');
+        const cmdFile = path.join(os.homedir(), '.openagents', 'daemon.cmd');
+        fs.writeFileSync(cmdFile, `restart:${this.agentName}\n`);
+        this._log(`Restart: requested daemon bounce for agent=${this.agentName}`);
+      } catch (e) {
+        this._log(`Restart: failed to write daemon.cmd: ${e && e.message ? e.message : e}`);
+        // Fallback: reset uptime in-place so the next /status reflects
+        // SOMETHING changed even if the daemon bounce didn't happen.
+        this._startedAt = Date.now();
+      }
+      return;
     }
+    // Fall through to base for shared actions (status, etc.).
+    await super._onControlAction(action, payload);
   }
 
   /**
@@ -301,7 +378,8 @@ class ClaudeAdapter extends BaseAdapter {
           'Use workspace_get_history to read previous messages.\n' +
           'Use workspace_get_agents to see other agents.\n',
           'Use the openagents-workspace skill (Bash + curl) for workspace operations:\n' +
-          'reading message history, discovering agents, sharing files, and browsing.\n' +
+          'reading message history, discovering agents, sharing files, browsing,\n' +
+          'managing to-do lists, setting timers, and creating routines.\n' +
           'Refer to the skill instructions for the exact curl commands.\n'
         );
     }
@@ -394,9 +472,9 @@ class ClaudeAdapter extends BaseAdapter {
       mcpWriteTools.push(`${pfx}tunnel_expose`, `${pfx}tunnel_close`);
     }
 
-    // Todos & Timers (always enabled)
-    mcpTools.push(`${pfx}workspace_get_todos`, `${pfx}workspace_list_timers`);
-    mcpWriteTools.push(`${pfx}workspace_put_todos`, `${pfx}workspace_create_timer`, `${pfx}workspace_cancel_timer`);
+    // Todos, Timers & Routines (always enabled)
+    mcpTools.push(`${pfx}workspace_get_todos`, `${pfx}workspace_list_timers`, `${pfx}workspace_list_routines`);
+    mcpWriteTools.push(`${pfx}workspace_put_todos`, `${pfx}workspace_create_timer`, `${pfx}workspace_cancel_timer`, `${pfx}workspace_create_routine`, `${pfx}workspace_cancel_routine`);
 
     if (this._mode === 'plan') {
       cmd.push('--permission-mode', 'plan');
@@ -720,10 +798,33 @@ class ClaudeAdapter extends BaseAdapter {
 
           delete this._channelProcesses[msgChannel];
 
-          // Clean up stale todos: mark pending/in_progress as cancelled
-          try { await this.cleanupTodos(msgChannel); } catch {}
-
           const stoppedByUser = this._stoppingChannels.has(msgChannel);
+
+          if (stoppedByUser) {
+            // User explicitly stopped — cancel all remaining todos
+            try { await this.cleanupTodos(msgChannel); } catch {}
+          } else if (!msg._todoNudge) {
+            // Normal exit (not already a nudge) — check for remaining pending todos
+            try {
+              const remaining = await this.getRemainingTodos(msgChannel);
+              if (remaining.length > 0) {
+                const items = remaining.map((t) => `- ${t.content}`).join('\n');
+                const nudge = `You have ${remaining.length} remaining task(s) from your plan:\n${items}\n\nPlease continue working on them.`;
+                if (!this._channelQueues[msgChannel]) this._channelQueues[msgChannel] = [];
+                this._channelQueues[msgChannel].push({
+                  content: nudge,
+                  senderType: 'system',
+                  senderName: 'system:todos',
+                  sessionId: msgChannel,
+                  messageType: 'chat',
+                  _todoNudge: true,
+                });
+              }
+            } catch {}
+          } else {
+            // Nudge response finished but todos still pending — cancel to avoid infinite loop
+            try { await this.cleanupTodos(msgChannel); } catch {}
+          }
           if (stoppedByUser) {
             this._stoppingChannels.delete(msgChannel);
             resolve(false);
@@ -739,10 +840,20 @@ class ClaudeAdapter extends BaseAdapter {
 
           if (lastResponseText.length > 0) {
             const fullResponse = lastResponseText.join('\n').trim();
-            if (fullResponse) {
+            // "Prompt is too long" means the resumed session's context
+            // exceeded the model's limit. Clear the session and retry
+            // fresh with a bounded recap instead of the full history.
+            if (/prompt is too long/i.test(fullResponse) && this._channelSessions[msgChannel]) {
+              this._log(`Prompt too long with resumed session for ${msgChannel}, clearing and retrying`);
+              delete this._channelSessions[msgChannel];
+              this._saveSessions();
+              resolve(true);
+            } else if (fullResponse) {
               try { await this.sendResponse(msgChannel, fullResponse); } catch {}
+              resolve(false);
+            } else {
+              resolve(false);
             }
-            resolve(false); // done, no retry
           } else if (this._channelSessions[msgChannel] && !everPostedAnything) {
             // No output + had a resume session → likely stale session, retry fresh.
             // Covers both error exits (code !== 0) and silent success (code === 0)

package/src/adapters/index.js

@@ -13,6 +13,7 @@ const NanoClawAdapter = require('./nanoclaw');
 const CursorAdapter = require('./cursor');
 const HermesAdapter = require('./hermes');
 const GeminiAdapter = require('./gemini');
+const KimiAdapter = require('./kimi');
 
 const ADAPTER_MAP = {
   openclaw: OpenClawAdapter,
@@ -23,11 +24,12 @@ const ADAPTER_MAP = {
   cursor: CursorAdapter,
   hermes: HermesAdapter,
   gemini: GeminiAdapter,
+  kimi: KimiAdapter,
 };
 
 /**
  * Create an adapter instance for the given agent type.
- * @param {string} type - Agent type (openclaw, claude, codex, opencode, nanoclaw, cursor, hermes)
+ * @param {string} type - Agent type (openclaw, claude, codex, opencode, nanoclaw, cursor, hermes, gemini, kimi)
  * @param {object} opts - Adapter constructor options
  * @returns {BaseAdapter}
  */
@@ -49,6 +51,7 @@ module.exports = {
   CursorAdapter,
   HermesAdapter,
   GeminiAdapter,
+  KimiAdapter,
   createAdapter,
   ADAPTER_MAP,
 };

package/src/adapters/kimi.js

@@ -0,0 +1,66 @@
+/**
+ * Kimi adapter — Moonshot AI OpenAI-compatible chat completions.
+ *
+ * Reuses LlmDirectAdapter's streaming chat-completions client, but:
+ *  - reads KIMI_API_KEY / MOONSHOT_API_KEY (also accepts LLM_API_KEY / OPENAI_API_KEY)
+ *  - reads KIMI_BASE_URL / LLM_BASE_URL / OPENAI_BASE_URL, defaulting to https://api.moonshot.ai/v1
+ *  - reads KIMI_MODEL / LLM_MODEL, defaulting to kimi-k2.6
+ *
+ * Priority for every value: UI-saved env > process env > default.
+ * Stop / status / control flow is inherited from BaseAdapter.
+ */
+
+'use strict';
+
+const LlmDirectAdapter = require('./llm-direct');
+
+const DEFAULT_BASE_URL = 'https://api.moonshot.ai/v1';
+const DEFAULT_MODEL = 'kimi-k2.6';
+
+class KimiAdapter extends LlmDirectAdapter {
+  constructor(opts) {
+    super({
+      ...opts,
+      adapterLabel: 'Kimi',
+      modelEnvVar: 'KIMI_MODEL',
+      suppressConfigLog: true,
+    });
+
+    const env = this.agentEnv || process.env;
+
+    const apiKey =
+      env.KIMI_API_KEY ||
+      env.MOONSHOT_API_KEY ||
+      env.LLM_API_KEY ||
+      env.OPENAI_API_KEY ||
+      '';
+
+    const baseUrl = (
+      env.KIMI_BASE_URL ||
+      env.LLM_BASE_URL ||
+      env.OPENAI_BASE_URL ||
+      DEFAULT_BASE_URL
+    ).replace(/\/$/, '');
+
+    const model =
+      env.KIMI_MODEL ||
+      env.LLM_MODEL ||
+      DEFAULT_MODEL;
+
+    this._apiKey = apiKey;
+    this._baseUrl = baseUrl;
+    this._model = model;
+    this._directMode = !!(this._apiKey && this._baseUrl);
+
+    if (this._directMode) {
+      this._log(`Kimi mode: ${this._baseUrl} model=${this._model}`);
+    } else {
+      this._log(
+        'Kimi adapter started without API key. ' +
+        'Set KIMI_API_KEY (or MOONSHOT_API_KEY) via the Launcher Configure screen.'
+      );
+    }
+  }
+}
+
+module.exports = KimiAdapter;

package/src/adapters/llm-direct.js

@@ -37,16 +37,36 @@ class LlmDirectAdapter extends BaseAdapter {
     this._model = env[this._modelEnvVar] || env.OPENCLAW_MODEL || '';
     this._directMode = !!(this._apiKey && this._baseUrl);
 
-    if (this._directMode) {
-      this._log(`Direct LLM mode: ${this._baseUrl} model=${this._model || 'gpt-4o'}`);
-    } else {
-      this._log(
-        `${this._adapterLabel} adapter started without direct API config. ` +
-        'Set OPENAI_API_KEY + OPENAI_BASE_URL for direct mode.'
-      );
+    if (!opts.suppressConfigLog) {
+      if (this._directMode) {
+        this._log(`Direct LLM mode: ${this._baseUrl} model=${this._model || 'gpt-4o'}`);
+      } else {
+        this._log(
+          `${this._adapterLabel} adapter started without direct API config. ` +
+          'Set OPENAI_API_KEY + OPENAI_BASE_URL for direct mode.'
+        );
+      }
     }
 
     this._conversationHistory = [];
+    this._activeRequests = new Set();
+  }
+
+  stop() {
+    super.stop();
+    for (const req of this._activeRequests) {
+      try { req.destroy(new Error('LLM API request stopped')); } catch {}
+    }
+    this._activeRequests.clear();
+  }
+
+  async _onControlAction(action, _payload) {
+    if (action === 'stop') {
+      for (const req of this._activeRequests) {
+        try { req.destroy(new Error('LLM API request stopped')); } catch {}
+      }
+      this._activeRequests.clear();
+    }
   }
 
   _buildSystemPrompt(channelName) {
@@ -133,10 +153,14 @@ class LlmDirectAdapter extends BaseAdapter {
         headers: { ...headers, 'Content-Length': Buffer.byteLength(payload) },
         timeout: 300000,
       }, (res) => {
+        const cleanup = () => this._activeRequests.delete(req);
         if (res.statusCode !== 200) {
           let body = '';
           res.on('data', (c) => { body += c; });
-          res.on('end', () => reject(new Error(`LLM API returned ${res.statusCode}: ${body.slice(0, 300)}`)));
+          res.on('end', () => {
+            cleanup();
+            reject(new Error(`LLM API returned ${res.statusCode}: ${body.slice(0, 300)}`));
+          });
           return;
         }
 
@@ -166,11 +190,20 @@ class LlmDirectAdapter extends BaseAdapter {
           }
         });
 
-        res.on('end', () => resolve(fullText.trim()));
+        res.on('end', () => {
+          cleanup();
+          resolve(fullText.trim());
+        });
       });
 
-      req.on('error', reject);
-      req.on('timeout', () => { req.destroy(); reject(new Error('LLM API request timed out')); });
+      this._activeRequests.add(req);
+      req.on('error', (err) => {
+        this._activeRequests.delete(req);
+        reject(err);
+      });
+      req.on('timeout', () => {
+        req.destroy(new Error('LLM API request timed out'));
+      });
       req.write(payload);
       req.end();
     });

package/src/adapters/workspace-prompt.js

@@ -268,6 +268,34 @@ function buildApiSkillsPrompt({ endpoint, workspaceId, token, agentName, channel
     );
   }
 
+  // Routines (recurring scheduled tasks)
+  if (!isPlan) {
+    sections.push(
+      '\n### Routines (Recurring Tasks)\n\n' +
+      'Create a recurring routine that fires on a schedule and posts a message ' +
+      'to the channel, waking you to do the work. Great for daily standups, ' +
+      'periodic reviews, scheduled checks.\n\n' +
+      '**Schedule:** Specify `hour` (0-23 UTC), `minute` (0-59), and optional ' +
+      '`days` array (0=Mon, 6=Sun). Omit `days` for every day.\n\n' +
+      '**Create a routine:**\n' +
+      `\`curl -s -X POST -H "${h}" -H "Content-Type: application/json" ` +
+      `${baseUrl}/v1/routines -d '{"name":"Daily PR Review","message":"Review open PRs",` +
+      `"hour":8,"minute":0,` +
+      `"network":"${workspaceId}","channel":"${channelName}",` +
+      `"source":"openagents:${agentName}"}'\`\n\n` +
+      '**Create a weekday-only routine (Mon-Fri):**\n' +
+      `\`curl -s -X POST -H "${h}" -H "Content-Type: application/json" ` +
+      `${baseUrl}/v1/routines -d '{"name":"Morning Standup","message":"Post standup summary",` +
+      `"hour":9,"minute":0,"days":[0,1,2,3,4],` +
+      `"network":"${workspaceId}","channel":"${channelName}",` +
+      `"source":"openagents:${agentName}"}'\`\n\n` +
+      '**List active routines:**\n' +
+      `\`curl -s -H "${h}" "${baseUrl}/v1/routines?network=${workspaceId}&channel=${channelName}"\`\n\n` +
+      '**Cancel a routine:**\n' +
+      `\`curl -s -X DELETE -H "${h}" ${baseUrl}/v1/routines/ROUTINE_ID\`\n`
+    );
+  }
+
   // Discovery
   sections.push(
     '\n### Discover Agents\n\n' +
@@ -287,7 +315,10 @@ function buildClaudeSystemPrompt({ agentName, workspaceId, channelName, mode = '
   parts.push(buildWorkspaceIdentity(agentName, workspaceId, channelName, mode));
   parts.push(
     'Use workspace_get_history to read previous messages.\n' +
-    'Use workspace_get_agents to see other agents.\n'
+    'Use workspace_get_agents to see other agents.\n' +
+    'Use workspace_put_todos to track your progress with a to-do list.\n' +
+    'Use workspace_create_timer to set a reminder that wakes you up later.\n' +
+    'Use workspace_create_routine to set up recurring scheduled tasks (e.g. daily reviews).\n'
   );
   parts.push(buildCollaborationPrompt());
 

package/src/daemon.js

@@ -138,6 +138,18 @@ class Daemon {
     }
 
     await this.stopAgent(agentName);
+
+    // stopAgent only waits 5s for `_adapters[name]` to disappear, but
+    // graceful adapter shutdown can take longer (control-poller cleanup,
+    // disconnect, in-flight CLI subprocess kill). If the adapter is still
+    // there when we reach _launchAgent, the duplicate-launch guard bails
+    // and the agent stays stuck in 'stopped'. Wait up to 20s so the
+    // launch sees a clean slate.
+    for (let i = 0; i < 40; i++) {
+      if (!this._adapters || !this._adapters[agentName]) break;
+      await new Promise(r => setTimeout(r, 500));
+    }
+
     this._stoppedAgents.delete(agentName);
 
     // Reload config in case it changed

package/src/installer.js

@@ -59,6 +59,14 @@ class Installer {
     const entry = this.registry.getEntry(agentType);
     const npmPkg = entry && entry.install ? entry.install.npm_package : null;
     const binary = entry && entry.install ? entry.install.binary : agentType;
+    if (entry?.install?.api_only) {
+      const installed = this._hasMarker(agentType);
+      return {
+        installed,
+        managed: installed,
+        location: installed ? 'api_only' : null,
+      };
+    }
     const installCmd = entry && entry.install ? this._getInstallCommand(entry.install) : null;
     let npmPkgFromCmd = null;
     if (!npmPkg && installCmd && installCmd.includes('npm install')) {
@@ -135,6 +143,29 @@ class Installer {
    * @returns {{ installed: boolean, binary: string|null, version: string|null }}
    */
   healthCheck(agentType) {
+    const entry = this.registry.getEntry(agentType);
+    if (entry?.install?.api_only) {
+      const info = this.getInstallInfo(agentType);
+      if (!info.installed) {
+        return {
+          installed: false,
+          binary: null,
+          version: null,
+          ready: false,
+          auth_mode: null,
+          execution_mode: 'unavailable',
+          message: 'Not installed',
+        };
+      }
+
+      return {
+        installed: true,
+        binary: null,
+        version: null,
+        ...this._evaluateReadiness(agentType, entry, null),
+      };
+    }
+
     const binary = this._whichBinary(agentType);
     if (!binary) {
       return {
@@ -148,7 +179,6 @@ class Installer {
       };
     }
 
-    const entry = this.registry.getEntry(agentType);
     const checkCmd = entry && entry.install ? entry.install.check_command : null;
     const versionCmd = checkCmd || `${entry && entry.install && entry.install.binary || agentType} --version`;
 
@@ -323,6 +353,11 @@ class Installer {
       throw new Error(`No install definition for agent type: ${agentType}`);
     }
 
+    if (entry.install.api_only) {
+      this._markInstalled(agentType);
+      return { success: true, output: `${entry.label || agentType} uses direct API mode; no binary install needed.` };
+    }
+
     let cmd = this._getInstallCommand(entry.install);
     if (!cmd) {
       throw new Error(`No install command for ${agentType} on ${Installer.platform()}`);
@@ -354,6 +389,13 @@ class Installer {
       throw new Error(`No install definition for agent type: ${agentType}`);
     }
 
+    if (entry.install.api_only) {
+      if (onData) onData(`${entry.label || agentType} uses direct API mode; no binary install needed.\n`);
+      this._markInstalled(agentType);
+      if (onData) onData(`\nDone! ${agentType} is now installed.\n`);
+      return { success: true, command: 'api-only' };
+    }
+
     let rawCmd = this._getInstallCommand(entry.install);
     if (!rawCmd) {
       throw new Error(`No install command for ${agentType} on ${Installer.platform()}`);
@@ -419,6 +461,11 @@ class Installer {
       throw new Error(`No install definition for agent type: ${agentType}`);
     }
 
+    if (entry.install.api_only) {
+      this._markUninstalled(agentType);
+      return { success: true, output: `${entry.label || agentType} API-only install marker removed.` };
+    }
+
     const installCmd = this._getInstallCommand(entry.install);
     const uninstallCmd = this._deriveUninstallCommand(installCmd, agentType);
     if (!uninstallCmd) {
@@ -462,6 +509,13 @@ class Installer {
       throw new Error(`No install definition for agent type: ${agentType}`);
     }
 
+    if (entry.install.api_only) {
+      if (onData) onData(`${entry.label || agentType} uses direct API mode; removing install marker.\n`);
+      this._markUninstalled(agentType);
+      if (onData) onData(`\nDone! ${agentType} has been uninstalled.\n`);
+      return { success: true, command: 'api-only' };
+    }
+
     const installCmd = this._getInstallCommand(entry.install);
     let rawCmd = this._deriveUninstallCommand(installCmd, agentType);
     if (!rawCmd) {

package/src/mcp-server.js

@@ -299,6 +299,41 @@ function buildToolDefs(disabledModules) {
         required: ['timer_id'],
       },
     },
+    {
+      name: 'workspace_create_routine',
+      description: 'Create a recurring scheduled routine that posts a message on a repeating schedule.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          name: { type: 'string', description: 'Human-readable label for the routine (e.g. "Daily PR Review")' },
+          message: { type: 'string', description: 'Message to post each time the routine fires' },
+          hour: { type: 'integer', description: 'Hour in UTC (0-23)' },
+          minute: { type: 'integer', description: 'Minute (0-59)' },
+          days: {
+            type: 'array',
+            items: { type: 'integer' },
+            description: 'Days of week to fire (0=Mon, 6=Sun). Omit for every day.',
+          },
+        },
+        required: ['name', 'message', 'hour', 'minute'],
+      },
+    },
+    {
+      name: 'workspace_list_routines',
+      description: 'List active routines in the current channel.',
+      inputSchema: { type: 'object', properties: {} },
+    },
+    {
+      name: 'workspace_cancel_routine',
+      description: 'Cancel a recurring routine by its ID.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          routine_id: { type: 'string', description: 'Routine ID to cancel' },
+        },
+        required: ['routine_id'],
+      },
+    },
   );
 
   return tools;
@@ -712,6 +747,39 @@ class McpServer {
         return text(`Timer cancelled: ${args.timer_id}`);
       }
 
+      case 'workspace_create_routine': {
+        const result = await this.ws.createRoutine(
+          this.workspaceId, this.channelName, this.token,
+          {
+            name: args.name,
+            message: args.message,
+            hour: args.hour,
+            minute: args.minute,
+            days: args.days,
+            source: `openagents:${this.agentName}`,
+          },
+        );
+        const daysStr = args.days ? `days [${args.days.join(',')}]` : 'every day';
+        return text(`Routine created: "${args.name}" at ${String(args.hour).padStart(2,'0')}:${String(args.minute).padStart(2,'0')} UTC, ${daysStr} (id: ${result.id})`);
+      }
+
+      case 'workspace_list_routines': {
+        const data = await this.ws.listRoutines(this.workspaceId, this.channelName, this.token);
+        const routines = (data && data.routines) || [];
+        if (!routines.length) return text('No active routines.');
+        const lines = routines.map((r) =>
+          `- ${r.id}: "${r.name}" at ${String(r.schedule_hour).padStart(2,'0')}:${String(r.schedule_minute).padStart(2,'0')} UTC` +
+          (r.schedule_days ? ` [days: ${r.schedule_days.join(',')}]` : ' (daily)') +
+          ` — next: ${r.next_fires_at} (by ${r.created_by})`
+        );
+        return text(lines.join('\n'));
+      }
+
+      case 'workspace_cancel_routine': {
+        await this.ws.cancelRoutine(this.workspaceId, this.token, args.routine_id);
+        return text(`Routine cancelled: ${args.routine_id}`);
+      }
+
       default:
         throw new Error(`Unknown tool: ${name}`);
     }

package/src/utils.js

@@ -12,11 +12,12 @@ function testLLMConnection(env) {
   const https = require('https');
   const http = require('http');
 
-  const apiKey = env.LLM_API_KEY || env.OPENAI_API_KEY || env.ANTHROPIC_API_KEY || '';
+  const hasKimiConfig = !!(env.KIMI_API_KEY || env.MOONSHOT_API_KEY || env.KIMI_BASE_URL || env.KIMI_MODEL);
+  const apiKey = env.KIMI_API_KEY || env.MOONSHOT_API_KEY || env.LLM_API_KEY || env.OPENAI_API_KEY || env.ANTHROPIC_API_KEY || '';
   if (!apiKey) return Promise.resolve({ success: false, error: 'No API key provided' });
 
-  let baseUrl = (env.LLM_BASE_URL || env.OPENAI_BASE_URL || 'https://api.openai.com/v1').replace(/\/$/, '');
-  const model = env.LLM_MODEL || env.OPENCLAW_MODEL || '';
+  let baseUrl = (env.KIMI_BASE_URL || env.LLM_BASE_URL || env.OPENAI_BASE_URL || (hasKimiConfig ? 'https://api.moonshot.ai/v1' : 'https://api.openai.com/v1')).replace(/\/$/, '');
+  const model = env.KIMI_MODEL || env.LLM_MODEL || env.OPENCLAW_MODEL || '';
   const isAnthropic = baseUrl.includes('anthropic');
 
   if (!isAnthropic && !baseUrl.endsWith('/v1')) {
@@ -44,11 +45,13 @@ function testLLMConnection(env) {
         'Authorization': `Bearer ${apiKey}`,
         'Content-Type': 'application/json',
       };
-      body = JSON.stringify({
-        model: model || 'gpt-4o-mini',
-        max_completion_tokens: 32,
+      const requestBody = {
+        model: model || (hasKimiConfig ? 'kimi-k2.6' : 'gpt-4o-mini'),
         messages: [{ role: 'user', content: 'Say hi in 5 words.' }],
-      });
+      };
+      if (hasKimiConfig) requestBody.max_tokens = 32;
+      else requestBody.max_completion_tokens = 32;
+      body = JSON.stringify(requestBody);
     }
 
     const parsedUrl = new URL(url);

package/src/workspace-client.js

@@ -356,16 +356,17 @@ class WorkspaceClient {
       const params = new URLSearchParams({
         network: workspaceId,
         type: 'workspace.agent.control',
+        target: `openagents:${agentName}`,
         limit: '10',
+        sort: 'desc',
       });
       if (after) params.set('after', after);
       const data = await this._get(`/v1/events?${params}`, this._wsHeaders(token));
       const result = data.data || data;
       const events = (result && result.events) || [];
-      return events.filter((e) => {
-        const target = e.target || '';
-        return target === `openagents:${agentName}`;
-      });
+      // Re-sort ascending by timestamp so callers process oldest-first.
+      events.sort((a, b) => (a.timestamp || 0) - (b.timestamp || 0));
+      return events;
     } catch {
       return [];
     }
@@ -576,6 +577,35 @@ class WorkspaceClient {
     return data.data || data;
   }
 
+  // ── Routines ──
+
+  async createRoutine(workspaceId, channelName, token, { name, message, hour, minute, days, source } = {}) {
+    const body = {
+      name,
+      message,
+      hour,
+      minute,
+      network: workspaceId,
+      channel: channelName,
+      source: source || 'openagents:unknown',
+    };
+    if (days) body.days = days;
+    const data = await this._post('/v1/routines', body, this._wsHeaders(token));
+    return data.data || data;
+  }
+
+  async listRoutines(workspaceId, channelName, token) {
+    const params = new URLSearchParams({ network: workspaceId });
+    if (channelName) params.set('channel', channelName);
+    const data = await this._get(`/v1/routines?${params}`, this._wsHeaders(token));
+    return data.data || data;
+  }
+
+  async cancelRoutine(workspaceId, token, routineId) {
+    const data = await this._delete(`/v1/routines/${routineId}`, this._wsHeaders(token));
+    return data.data || data;
+  }
+
   // ── Internal helpers ──
 
   /**