@openagents-org/agent-launcher 0.2.115 → 0.2.118

package/package.json

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

package/src/adapters/base.js

@@ -391,6 +391,53 @@ class BaseAdapter {
     }
   }
 
+  async cleanupTodos(channel) {
+    try {
+      const result = await this.client.getTodos(this.workspaceId, channel, this.token, {
+        all: false,
+      });
+      const todos = (result && result.todos) || [];
+      const hasActive = todos.some((t) => t.status === 'pending' || t.status === 'in_progress');
+      if (!hasActive) return;
+      const updated = todos.map((t) => ({
+        content: t.content,
+        status: (t.status === 'pending' || t.status === 'in_progress') ? 'cancelled' : t.status,
+        assignee: t.assignee,
+      }));
+      await this.client.putTodos(this.workspaceId, channel, this.token, updated, {
+        source: `openagents:${this.agentName}`,
+      });
+    } catch {
+      // Best-effort cleanup
+    }
+  }
+
+  async sendTodos(channel, todos) {
+    try {
+      await this.client.putTodos(this.workspaceId, channel, this.token, todos, {
+        source: `openagents:${this.agentName}`,
+      });
+    } catch (e) {
+      if (e instanceof SessionRevokedError) { this._onSessionRevoked(); return; }
+      // Fallback to event-based approach for older backends
+      const lines = todos.map((t) => {
+        const icon = t.status === 'completed' ? '✅' : t.status === 'in_progress' ? '🔄' : '⬜';
+        return `${icon} ${t.content}`;
+      });
+      try {
+        await this.client.sendMessage(this.workspaceId, channel, this.token, lines.join('\n'), {
+          senderType: 'agent',
+          senderName: this.agentName,
+          messageType: 'todos',
+          metadata: { agent_mode: this._mode, todos },
+          sessionId: this._sessionId,
+        });
+      } catch (e2) {
+        if (e2 instanceof SessionRevokedError) this._onSessionRevoked();
+      }
+    }
+  }
+
   async sendError(channel, error) {
     try {
       await this.client.sendMessage(this.workspaceId, channel, this.token, error, {

package/src/adapters/claude.js

@@ -18,7 +18,7 @@ const { execSync, spawn } = require('child_process');
 
 const BaseAdapter = require('./base');
 const { formatAttachmentsForPrompt, SESSION_DEFAULT_RE, generateSessionTitle } = require('./utils');
-const { buildClaudeSystemPrompt } = require('./workspace-prompt');
+const { buildClaudeSystemPrompt, buildClaudeSkillMd } = require('./workspace-prompt');
 
 const IS_WINDOWS = process.platform === 'win32';
 
@@ -31,6 +31,8 @@ class ClaudeAdapter extends BaseAdapter {
   constructor(opts) {
     super(opts);
     this.disabledModules = opts.disabledModules || new Set();
+    /** @type {'mcp' | 'skills'} Tool integration mode */
+    this.toolMode = opts.toolMode || 'mcp';
     this._channelSessions = {}; // channel → Claude CLI session_id
     this._channelProcesses = {}; // channel → child process
     this._stoppingChannels = new Set();
@@ -128,6 +130,48 @@ class ClaudeAdapter extends BaseAdapter {
     } catch {}
   }
 
+  /**
+   * Build a short transcript of the channel's last chat exchanges, used to
+   * re-seed context when --resume fails and we have to start a fresh
+   * Claude Code session. Returns null when there's nothing useful to add.
+   *
+   * Excludes the user's current message (the for-loop will append it
+   * normally) and any status/thinking events, which are mostly tool-call
+   * noise and inflate the prompt without adding signal.
+   */
+  async _buildChannelRecap(channelName, currentMessage) {
+    const messages = await this.client.getRecentMessages(
+      this.workspaceId, channelName, this.token, 30
+    );
+    if (!messages || messages.length === 0) return null;
+
+    const lines = [];
+    for (const m of messages) {
+      const mt = m.messageType || 'chat';
+      if (mt === 'status' || mt === 'thinking' || mt === 'loading') continue;
+      const text = (m.content || '').trim();
+      if (!text) continue;
+      // Don't echo the user's current message back at them.
+      if (text === currentMessage) continue;
+      const who = m.senderType === 'human'
+        ? (m.senderName || 'user')
+        : (m.senderName || 'agent');
+      // Cap each line so a single huge paste doesn't blow up the prompt.
+      const truncated = text.length > 800 ? text.slice(0, 800) + '…' : text;
+      lines.push(`[${who}] ${truncated}`);
+    }
+    if (lines.length === 0) return null;
+
+    // Keep only the tail; older context has diminishing value and we
+    // don't want to balloon the system prompt.
+    const tail = lines.slice(-15).join('\n');
+    return (
+      'You previously worked in this channel but your prior session is no ' +
+      'longer available, so here is the recent conversation for context:\n\n' +
+      tail
+    );
+  }
+
   async _stopAllProcesses(completionMessage = 'Execution stopped.') {
     const entries = Object.entries(this._channelProcesses);
     if (!entries.length) return;
@@ -243,15 +287,81 @@ class ClaudeAdapter extends BaseAdapter {
       throw new Error('claude CLI not found. Install with: curl -fsSL https://claude.ai/install.sh | bash');
     }
 
-    const systemPrompt = '\n' + buildClaudeSystemPrompt({
+    let systemPrompt = '\n' + buildClaudeSystemPrompt({
       agentName: this.agentName,
       workspaceId: this.workspaceId,
       channelName,
       mode: this._mode,
     });
 
+    // In skills mode, replace MCP tool references with curl-based instructions
+    if (this.toolMode === 'skills') {
+      systemPrompt = systemPrompt
+        .replace(
+          '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' +
+          'Refer to the skill instructions for the exact curl commands.\n'
+        );
+    }
+
     const cmd = [claudeBin, '-p', prompt, '--output-format', 'stream-json', '--verbose'];
 
+    cmd.push('--append-system-prompt', systemPrompt);
+    cmd.push('--disallowedTools', 'AskUserQuestion');
+
+    // Resume existing conversation (skipped on retry after stale session)
+    const sessionId = this._channelSessions[channelName];
+    if (sessionId && !skipResume) {
+      cmd.push('--resume', sessionId);
+    }
+
+    // ── Skills mode: write SKILL.md, no MCP server ──
+    if (this.toolMode === 'skills') {
+      return this._buildSkillsCmd(cmd, channelName);
+    }
+
+    // ── MCP mode (default): spawn MCP server ──
+    return this._buildMcpCmd(cmd, channelName);
+  }
+
+  /**
+   * Skills mode: write a SKILL.md file and allow Bash + curl for workspace ops.
+   */
+  _buildSkillsCmd(cmd, channelName) {
+    if (this._mode === 'plan') {
+      cmd.push('--permission-mode', 'plan');
+      cmd.push('--allowedTools', 'Read', 'Glob', 'Grep', 'Bash');
+    } else {
+      cmd.push('--dangerously-skip-permissions');
+      cmd.push('--allowedTools', 'Read', 'Write', 'Edit', 'Bash', 'Glob', 'Grep');
+    }
+
+    // Write SKILL.md to .claude/skills/ in the working directory
+    const workDir = this.workingDir || process.cwd();
+    const skillDir = path.join(workDir, '.claude', 'skills');
+    fs.mkdirSync(skillDir, { recursive: true });
+    const skillFile = path.join(skillDir, 'openagents-workspace.md');
+
+    const skillContent = buildClaudeSkillMd({
+      endpoint: this.endpoint,
+      workspaceId: this.workspaceId,
+      token: this.token,
+      agentName: this.agentName,
+      channelName,
+      disabledModules: this.disabledModules,
+    });
+    fs.writeFileSync(skillFile, skillContent, 'utf-8');
+    this._log(`Wrote workspace skill to ${skillFile}`);
+
+    return { cmd, skillFile };
+  }
+
+  /**
+   * MCP mode (default): spawn MCP server subprocess for workspace tools.
+   */
+  _buildMcpCmd(cmd, channelName) {
     // Mode-dependent permission and tool flags
     const pfx = 'mcp__openagents-workspace__';
     const mcpTools = [
@@ -284,23 +394,16 @@ class ClaudeAdapter extends BaseAdapter {
       mcpWriteTools.push(`${pfx}tunnel_expose`, `${pfx}tunnel_close`);
     }
 
-    let allowed;
+    // 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`);
+
     if (this._mode === 'plan') {
       cmd.push('--permission-mode', 'plan');
-      allowed = [...mcpTools, 'Read', 'Glob', 'Grep'];
+      cmd.push('--allowedTools', ...mcpTools, 'Read', 'Glob', 'Grep');
     } else {
       cmd.push('--dangerously-skip-permissions');
-      allowed = [...mcpTools, ...mcpWriteTools, 'Read', 'Write', 'Edit', 'Bash', 'Glob', 'Grep'];
-    }
-
-    cmd.push('--append-system-prompt', systemPrompt);
-    cmd.push('--allowedTools', ...allowed);
-    cmd.push('--disallowedTools', 'AskUserQuestion');
-
-    // Resume existing conversation (skipped on retry after stale session)
-    const sessionId = this._channelSessions[channelName];
-    if (sessionId && !skipResume) {
-      cmd.push('--resume', sessionId);
+      cmd.push('--allowedTools', ...mcpTools, ...mcpWriteTools, 'Read', 'Write', 'Edit', 'Bash', 'Glob', 'Grep');
     }
 
     // MCP config for workspace tools
@@ -314,18 +417,13 @@ class ClaudeAdapter extends BaseAdapter {
     if (this.disabledModules.has('files')) mcpArgs.push('--disable-files');
     if (this.disabledModules.has('browser')) mcpArgs.push('--disable-browser');
 
-    // Resolve the MCP server entry point. Prefer the sibling bin inside this
-    // very package — it's guaranteed to exist whenever claude.js is executing,
-    // so it never falls through to a broken PATH lookup. If Claude Code can't
-    // spawn the MCP server, it silently hides every workspace tool and the
-    // agent reports "workspace_read_file isn't in my tool set".
+    // Resolve the MCP server entry point
     let mcpCommand = this._findNodeBin();
     let mcpFinalArgs = mcpArgs;
     const siblingBin = path.resolve(__dirname, '..', '..', 'bin', 'agent-connector.js');
     if (fs.existsSync(siblingBin)) {
       mcpFinalArgs = [siblingBin, ...mcpArgs];
     } else {
-      // Fallback: search installed locations (older layouts, global installs)
       let oaBin = null;
       const home3 = os.homedir();
       const oaExt = IS_WINDOWS ? '.cmd' : '';
@@ -433,26 +531,43 @@ class ClaudeAdapter extends BaseAdapter {
     let mcpConfigFile = null;
     let cmd;
 
-    // Clean env: strip every CLAUDE_* / AI_AGENT variable inherited from a
-    // parent Claude Code (or Claude Agent SDK) process. If we don't, the
-    // spawned `claude` thinks it's running under an SDK harness and picks
-    // an org-scoped auth path that returns 403 "Account is no longer a
-    // member of the organization" even when the user is logged in fine via
-    // `claude login`. We let the child rediscover auth from
-    // ~/.claude/.credentials.json (or ANTHROPIC_API_KEY if set).
+    // Clean env: strip CLAUDE_* / AI_AGENT variables that make the spawned
+    // `claude` think it's running under an SDK harness (org-scoped auth
+    // path → 403). But preserve config vars the child needs for cloud
+    // provider auth (Vertex, Bedrock) and model selection.
+    const CLAUDE_ENV_KEEP = new Set([
+      'CLAUDE_CODE_USE_VERTEX',
+      'CLAUDE_CODE_USE_BEDROCK',
+      'CLAUDE_MODEL',
+      'CLAUDE_API_KEY',
+      'CLAUDE_CODE_MAX_TURNS',
+    ]);
     const cleanEnv = { ...(this.agentEnv || process.env) };
     for (const k of Object.keys(cleanEnv)) {
-      if (k.startsWith('CLAUDE_') || k === 'CLAUDECODE' || k === 'AI_AGENT') {
+      if ((k.startsWith('CLAUDE_') && !CLAUDE_ENV_KEEP.has(k)) || k === 'CLAUDECODE' || k === 'AI_AGENT') {
         delete cleanEnv[k];
       }
     }
 
     // Run up to 2 attempts: first with session resume, then fresh if stale session detected
     let _shouldRetry = false;
+    let effectiveContent = content;
     for (let attempt = 0; attempt < 2; attempt++) {
       if (mcpConfigFile) { try { fs.unlinkSync(mcpConfigFile); } catch {} mcpConfigFile = null; }
+
+      // On the retry pass after a stale --resume, the spawned `claude`
+      // starts a brand-new session with no memory of prior turns. Replay
+      // the channel's recent chat history so the agent at least has a
+      // recap instead of saying "I don't see any previous messages."
+      if (attempt > 0) {
+        try {
+          const recap = await this._buildChannelRecap(msgChannel, content);
+          if (recap) effectiveContent = `${recap}\n\n---\n\n${content}`;
+        } catch {}
+      }
+
       try {
-        const built = this._buildClaudeCmd(content, msgChannel, { skipResume: attempt > 0 });
+        const built = this._buildClaudeCmd(effectiveContent, msgChannel, { skipResume: attempt > 0 });
         cmd = built.cmd;
         mcpConfigFile = built.mcpConfigFile;
       } catch (e) {
@@ -483,6 +598,7 @@ class ClaudeAdapter extends BaseAdapter {
       const lastResponseText = [];
       let hasToolUseSinceLastText = false;
       let postedThinking = false;
+      let everPostedAnything = false;
       let stderrBuf = '';
       let lineBuffer = '';
       let _pendingLines = Promise.resolve(); // chain of in-flight processLine calls
@@ -542,6 +658,7 @@ class ClaudeAdapter extends BaseAdapter {
                 }
                 lastResponseText.push(block.text.trim());
                 postedThinking = true;
+                everPostedAnything = true;
                 // Stream text in real-time as "thinking" (same as Python adapter)
                 try { await this.sendThinking(msgChannel, block.text.trim()); } catch {}
               } else if (block.type === 'tool_use') {
@@ -549,6 +666,7 @@ class ClaudeAdapter extends BaseAdapter {
                 postedThinking = false;
                 lastResponseText.length = 0;
                 const toolName = block.name || '';
+
                 // Format tool input as readable text
                 let inputPreview = '';
                 if (block.input && typeof block.input === 'object') {
@@ -565,6 +683,7 @@ class ClaudeAdapter extends BaseAdapter {
                   inputPreview = String(block.input || '').slice(0, 150);
                 }
                 await this.sendStatus(msgChannel, `${toolName} › ${inputPreview}`);
+                everPostedAnything = true;
               }
             }
           } else if (eventType === 'result') {
@@ -600,6 +719,10 @@ 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) {
             this._stoppingChannels.delete(msgChannel);
@@ -607,8 +730,8 @@ class ClaudeAdapter extends BaseAdapter {
             return;
           }
 
+          this._log(`CLI exited: code=${code}, lastResponseText=${lastResponseText.length} items, everPosted=${everPostedAnything}, hasSession=${!!this._channelSessions[msgChannel]}`);
           if (code !== 0) {
-            this._log(`CLI exited with code ${code}`);
             if (stderrBuf.trim()) {
               this._log(`stderr: ${stderrBuf.trim().slice(0, 500)}`);
             }
@@ -620,14 +743,16 @@ class ClaudeAdapter extends BaseAdapter {
               try { await this.sendResponse(msgChannel, fullResponse); } catch {}
             }
             resolve(false); // done, no retry
-          } else if (code !== 0 && this._channelSessions[msgChannel]) {
-            // No output + error exit + had a resume session → stale session, signal 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)
+            // where Claude produced no text output on a resumed conversation.
             this._log(`Stale session detected for ${msgChannel}, clearing and retrying without resume`);
             delete this._channelSessions[msgChannel];
             this._saveSessions();
             resolve(true); // retry=true
           } else {
-            if (!postedThinking) {
+            if (!everPostedAnything) {
               try { await this.sendResponse(msgChannel, 'No response generated. Please try again.'); } catch {}
             }
             resolve(false);

package/src/adapters/workspace-prompt.js

@@ -205,9 +205,73 @@ function buildApiSkillsPrompt({ endpoint, workspaceId, token, agentName, channel
     sections.push(s);
   }
 
+  // Message history
+  sections.push(
+    '\n### Message History\n\n' +
+    '**Get recent messages in the current channel:**\n' +
+    `\`curl -s -H "${h}" "${baseUrl}/v1/events?network=${workspaceId}&channel=${channelName}&type=workspace.message&limit=20"\`\n\n` +
+    '**Get messages from a specific channel:**\n' +
+    `\`curl -s -H "${h}" "${baseUrl}/v1/events?network=${workspaceId}&channel=CHANNEL_NAME&type=workspace.message&limit=20"\`\n`
+  );
+
+  // Post status update
+  if (!isPlan) {
+    sections.push(
+      '\n### Post Status Update\n\n' +
+      'Post a status/thinking message (visible in the workspace UI as an intermediate step):\n' +
+      `\`curl -s -X POST -H "${h}" -H "Content-Type: application/json" ` +
+      `${baseUrl}/v1/events -d '{"type":"workspace.message.posted",` +
+      `"source":"openagents:${agentName}","target":"channel/${channelName}",` +
+      `"payload":{"content":"YOUR_STATUS","message_type":"status"}}'\`\n`
+    );
+  }
+
+  // To-Dos (planning)
+  if (!isPlan) {
+    sections.push(
+      '\n### To-Do List (Planning)\n\n' +
+      'Create or update your to-do list to track progress. The entire list ' +
+      'is replaced each time (send the full list with current statuses).\n\n' +
+      '**Status values:** `pending`, `in_progress`, `completed`\n\n' +
+      '**Update your to-do list:**\n' +
+      `\`curl -s -X PUT -H "${h}" -H "Content-Type: application/json" ` +
+      `${baseUrl}/v1/todos -d '{"todos":[` +
+      `{"content":"First task","status":"in_progress"},` +
+      `{"content":"Second task","status":"pending"}` +
+      `],"network":"${workspaceId}","channel":"${channelName}",` +
+      `"source":"openagents:${agentName}"}'\`\n\n` +
+      '**Get your to-do list:**\n' +
+      `\`curl -s -H "${h}" "${baseUrl}/v1/todos?network=${workspaceId}&channel=${channelName}"\`\n\n` +
+      'Use to-dos to plan multi-step work. Update the list as you complete each step.\n' +
+      'You can assign items to other agents: `"assignee": "other-agent-name"`\n'
+    );
+  }
+
+  // Timers
+  if (!isPlan) {
+    sections.push(
+      '\n### Timers\n\n' +
+      'Set a timer that will send you a message after a delay, waking you up ' +
+      'to continue work. Use this instead of `sleep` — timers let you release ' +
+      'the session and get called back later.\n\n' +
+      'Use cases: check back on a deploy, retry after a rate limit, remind ' +
+      'yourself to follow up.\n\n' +
+      '**Create a timer:**\n' +
+      `\`curl -s -X POST -H "${h}" -H "Content-Type: application/json" ` +
+      `${baseUrl}/v1/timers -d '{"delay":300,"message":"Check the build",` +
+      `"network":"${workspaceId}","channel":"${channelName}",` +
+      `"source":"openagents:${agentName}"}'\`\n\n` +
+      '**List active timers:**\n' +
+      `\`curl -s -H "${h}" "${baseUrl}/v1/timers?network=${workspaceId}&channel=${channelName}"\`\n\n` +
+      '**Cancel a timer:**\n' +
+      `\`curl -s -X DELETE -H "${h}" ${baseUrl}/v1/timers/TIMER_ID\`\n`
+    );
+  }
+
   // Discovery
   sections.push(
-    '\n### Discover Agents\n' +
+    '\n### Discover Agents\n\n' +
+    '**List all agents in the workspace (with status and role):**\n' +
     `\`curl -s -H "${h}" ${baseUrl}/v1/discover?network=${workspaceId}\`\n`
   );
 
@@ -321,6 +385,37 @@ function buildOpenCodeSkillMd({ endpoint, workspaceId, token, agentName, channel
   return frontmatter + identity + api;
 }
 
+/**
+ * Build a SKILL.md file for Claude Code's skill auto-discovery.
+ *
+ * When tool_mode is 'skills', the Claude adapter writes this file instead
+ * of spawning an MCP server. Claude Code discovers the skill via its
+ * .claude/skills/ directory and uses Bash + curl to call workspace APIs.
+ */
+function buildClaudeSkillMd({ endpoint, workspaceId, token, agentName, channelName, disabledModules }) {
+  const api = buildApiSkillsPrompt({
+    endpoint, workspaceId, token, agentName,
+    channelName: channelName || 'general',
+    disabledModules,
+    mode: 'execute',
+  });
+
+  const identity = buildWorkspaceIdentity(agentName, workspaceId, channelName, 'execute');
+  const collab = buildCollaborationPrompt();
+
+  const frontmatter =
+    '---\n' +
+    'name: openagents-workspace\n' +
+    'description: |\n' +
+    '  OpenAgents Workspace collaboration tools — shared files, browser,\n' +
+    '  and multi-agent coordination. Use when: sharing files or reports,\n' +
+    '  browsing websites, reading shared files, checking workspace agents,\n' +
+    '  or collaborating with other agents via @mentions.\n' +
+    '---\n\n';
+
+  return frontmatter + identity + '\n' + collab + '\n' + api;
+}
+
 module.exports = {
   buildWorkspaceIdentity,
   buildCollaborationPrompt,
@@ -331,4 +426,5 @@ module.exports = {
   buildOpenclawSkillMd,
   buildOpenCodeSystemPrompt,
   buildOpenCodeSkillMd,
+  buildClaudeSkillMd,
 };

package/src/cli.js

@@ -440,6 +440,49 @@ async function cmdEnv(connector, flags, positional) {
   }
 }
 
+async function cmdToolMode(connector, _flags, positional) {
+  const agentName = positional[0];
+  const mode = positional[1];
+
+  if (!agentName) {
+    // Show tool mode for all agents
+    const agents = connector.config.getAgents();
+    if (agents.length === 0) {
+      print('No agents configured');
+      return;
+    }
+    for (const a of agents) {
+      print(`  ${a.name}: ${a.tool_mode || 'mcp'}`);
+    }
+    print('\nUsage: agn tool-mode <agent> <mcp|skills>');
+    return;
+  }
+
+  if (!mode) {
+    // Show tool mode for specific agent
+    const agent = connector.config.getAgent(agentName);
+    if (!agent) { print(`Agent '${agentName}' not found`); process.exitCode = 1; return; }
+    print(`${agentName}: ${agent.tool_mode || 'mcp'}`);
+    print('\nUsage: agn tool-mode <agent> <mcp|skills>');
+    return;
+  }
+
+  if (mode !== 'mcp' && mode !== 'skills') {
+    print(`Invalid mode: ${mode}. Must be 'mcp' or 'skills'.`);
+    process.exitCode = 1;
+    return;
+  }
+
+  connector.config.updateAgent(agentName, { tool_mode: mode });
+  try { connector.sendDaemonCommand('reload'); } catch {}
+  print(`Set tool mode for ${agentName} to '${mode}'`);
+  if (mode === 'skills') {
+    print('Agent will use SKILL.md (Bash + curl) instead of MCP server for workspace tools.');
+  } else {
+    print('Agent will use MCP server for workspace tools (default).');
+  }
+}
+
 async function cmdTestLLM(connector, _flags, positional) {
   const type = positional[0];
   if (!type) { print('Usage: agn test-llm <type>'); return; }
@@ -504,6 +547,7 @@ Commands:
   connect <agent> <token>     Connect agent to workspace
   disconnect <agent>          Disconnect agent from workspace
   env <type> [--set K=V]      View/set env vars for agent type
+  tool-mode [agent] [mode]    View/set tool mode (mcp or skills)
   autostart [--disable]       Enable/disable auto-start on login
   test-llm <type>             Test LLM connection
   logs [agent] [--lines N]    View daemon logs
@@ -589,6 +633,7 @@ async function main() {
     autostart: () => cmdAutostart(connector, flags),
     workspace: () => cmdWorkspace(connector, flags, positional),
     env: () => cmdEnv(connector, flags, positional),
+    'tool-mode': () => cmdToolMode(connector, flags, positional),
     'test-llm': () => cmdTestLLM(connector, flags, positional),
     update: () => cmdUpdate(),
     'mcp-server': () => {

package/src/daemon.js

@@ -433,6 +433,7 @@ class Daemon {
         disabledModules: new Set(),
         agentEnv: this._buildAgentEnv(agentCfg),
         workingDir: agentCfg.path || undefined,
+        toolMode: agentCfg.tool_mode || 'mcp',
       });
     } catch (e) {
       this._log(`${name} failed to create ${agentType} adapter: ${e.message}`);

package/src/mcp-server.js

@@ -235,6 +235,72 @@ function buildToolDefs(disabledModules) {
     );
   }
 
+  // -- Todos & Timers (always enabled) --
+  tools.push(
+    {
+      name: 'workspace_put_todos',
+      description: 'Update your to-do list. Replaces the entire list each time (send full list with current statuses). Channel is auto-resolved.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          todos: {
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: {
+                content: { type: 'string', description: 'Task description' },
+                status: { type: 'string', enum: ['pending', 'in_progress', 'completed'], description: 'Task status' },
+                assignee: { type: 'string', description: 'Agent name to assign to (defaults to self)' },
+              },
+              required: ['content', 'status'],
+            },
+            description: 'Full to-do list with current statuses',
+          },
+        },
+        required: ['todos'],
+      },
+    },
+    {
+      name: 'workspace_get_todos',
+      description: 'Get to-do items for the current channel. Use all=true to see all agents\' todos.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          agent: { type: 'string', description: 'Filter by agent name' },
+          all: { type: 'boolean', description: 'Get all agents\' todos (default: own only)' },
+        },
+      },
+    },
+    {
+      name: 'workspace_create_timer',
+      description: 'Set a timer that posts a message to the channel after the specified delay.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          delay: { type: 'integer', description: 'Seconds until the timer fires (1-86400)' },
+          message: { type: 'string', description: 'Message to post when the timer fires' },
+        },
+        required: ['delay', 'message'],
+      },
+    },
+    {
+      name: 'workspace_list_timers',
+      description: 'List active timers in the current channel.',
+      inputSchema: { type: 'object', properties: {} },
+    },
+    {
+      name: 'workspace_cancel_timer',
+      description: 'Cancel an active timer by its ID.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          timer_id: { type: 'string', description: 'Timer ID to cancel' },
+        },
+        required: ['timer_id'],
+      },
+    },
+  );
+
   return tools;
 }
 
@@ -596,6 +662,56 @@ class McpServer {
         return text(lines.join('\n'));
       }
 
+      // ── Todos & Timers ──
+
+      case 'workspace_put_todos': {
+        await this.ws.putTodos(this.workspaceId, this.channelName, this.token, args.todos, {
+          source: `openagents:${this.agentName}`,
+        });
+        const summary = (args.todos || []).map((t) => {
+          const icon = t.status === 'completed' ? '[x]' : t.status === 'in_progress' ? '[~]' : '[ ]';
+          return `${icon} ${t.content}${t.assignee ? ` → ${t.assignee}` : ''}`;
+        }).join('\n');
+        return text(`Todos updated:\n${summary}`);
+      }
+
+      case 'workspace_get_todos': {
+        const data = await this.ws.getTodos(this.workspaceId, this.channelName, this.token, {
+          agent: args.agent, all: args.all,
+        });
+        const todos = (data && data.todos) || [];
+        if (!todos.length) return text('No todos.');
+        const lines = todos.map((t) => {
+          const icon = t.status === 'completed' ? '[x]' : t.status === 'in_progress' ? '[~]' : '[ ]';
+          return `${icon} ${t.content} (${t.assignee || 'unassigned'})`;
+        });
+        return text(lines.join('\n'));
+      }
+
+      case 'workspace_create_timer': {
+        const result = await this.ws.createTimer(
+          this.workspaceId, this.channelName, this.token,
+          args.delay, args.message,
+          { source: `openagents:${this.agentName}` },
+        );
+        return text(`Timer set: "${args.message}" fires in ${args.delay}s (id: ${result.id})`);
+      }
+
+      case 'workspace_list_timers': {
+        const data = await this.ws.listTimers(this.workspaceId, this.channelName, this.token);
+        const timers = (data && data.timers) || [];
+        if (!timers.length) return text('No active timers.');
+        const lines = timers.map((t) =>
+          `- ${t.id}: "${t.message}" fires at ${t.fires_at} (by ${t.created_by})`
+        );
+        return text(lines.join('\n'));
+      }
+
+      case 'workspace_cancel_timer': {
+        await this.ws.cancelTimer(this.workspaceId, this.token, args.timer_id);
+        return text(`Timer cancelled: ${args.timer_id}`);
+      }
+
       default:
         throw new Error(`Unknown tool: ${name}`);
     }

package/src/workspace-client.js

@@ -191,6 +191,32 @@ class WorkspaceClient {
     return events.map((e) => this._eventToMessage(e));
   }
 
+  /**
+   * Fetch the most recent N messages in a channel, returned oldest-to-newest.
+   * Used by adapters to rebuild context for a fresh Claude Code session
+   * when --resume of the previous session fails (the channel's chat history
+   * is the only thing that survives a session-storage rotation).
+   */
+  async getRecentMessages(workspaceId, channelName, token, limit = 30) {
+    try {
+      const params = new URLSearchParams({
+        network: workspaceId,
+        channel: channelName,
+        type: 'workspace.message',
+        sort: 'desc',
+        limit: String(limit),
+      });
+      const data = await this._get(`/v1/events?${params}`, this._wsHeaders(token));
+      const result = data.data || data;
+      const events = (result && result.events) || [];
+      // Server returned newest-first; reverse so the caller can present them
+      // in chronological order without further fiddling.
+      return events.slice().reverse().map((e) => this._eventToMessage(e));
+    } catch {
+      return [];
+    }
+  }
+
   /**
    * Fetch the latest workspace.message.posted event id (head cursor).
    * Used by adapters to skip past existing events on join in O(1) instead
@@ -267,6 +293,11 @@ class WorkspaceClient {
           // Legacy server (no target_agents): broadcast for compat
           messages.push(this._eventToMessage(e));
         }
+      } else if (source.startsWith('system:')) {
+        // System messages (timers, notifications): pick up if targeted
+        if (hasTargetList && targetAgents.includes(agentName)) {
+          messages.push(this._eventToMessage(e));
+        }
       } else if (source.startsWith('openagents:')) {
         // Agent messages: only pick up if explicitly listed
         if (hasTargetList && targetAgents.includes(agentName)) {
@@ -498,6 +529,53 @@ class WorkspaceClient {
     return data.data || data;
   }
 
+  // ── Todos & Timers ──
+
+  async putTodos(workspaceId, channelName, token, todos, { source } = {}) {
+    const body = {
+      todos,
+      network: workspaceId,
+      channel: channelName,
+      source: source || 'openagents:unknown',
+    };
+    const data = await this._put('/v1/todos', body, this._wsHeaders(token));
+    return data.data || data;
+  }
+
+  async getTodos(workspaceId, channelName, token, { agent, all } = {}) {
+    const params = new URLSearchParams({ network: workspaceId });
+    if (channelName) params.set('channel', channelName);
+    if (agent) params.set('agent', agent);
+    if (all) params.set('all', 'true');
+    const data = await this._get(`/v1/todos?${params}`, this._wsHeaders(token));
+    return data.data || data;
+  }
+
+  async createTimer(workspaceId, channelName, token, delay, message, { source } = {}) {
+    const body = {
+      delay,
+      message,
+      network: workspaceId,
+      channel: channelName,
+      source: source || 'openagents:unknown',
+    };
+    const data = await this._post('/v1/timers', body, this._wsHeaders(token));
+    return data.data || data;
+  }
+
+  async listTimers(workspaceId, channelName, token) {
+    const params = new URLSearchParams({ network: workspaceId });
+    if (channelName) params.set('channel', channelName);
+    const data = await this._get(`/v1/timers?${params}`, this._wsHeaders(token));
+    return data.data || data;
+  }
+
+  async cancelTimer(workspaceId, token, timerId, network) {
+    const params = network ? `?network=${network}` : '';
+    const data = await this._delete(`/v1/timers/${timerId}`, this._wsHeaders(token));
+    return data.data || data;
+  }
+
   // ── Internal helpers ──
 
   /**
@@ -643,6 +721,48 @@ class WorkspaceClient {
     });
   }
 
+  _put(urlPath, body, headers = {}, timeout = 30000) {
+    if (!headers['Content-Type']) headers['Content-Type'] = 'application/json';
+    const jsonBody = JSON.stringify(body);
+    const fullUrl = this.endpoint + urlPath;
+
+    return new Promise((resolve, reject) => {
+      const parsedUrl = new URL(fullUrl);
+      const transport = parsedUrl.protocol === 'https:' ? https : http;
+
+      const req = transport.request(fullUrl, {
+        method: 'PUT',
+        headers: { ...headers, 'Content-Length': Buffer.byteLength(jsonBody) },
+        timeout,
+      }, (res) => {
+        let data = '';
+        res.on('data', (chunk) => { data += chunk; });
+        res.on('end', () => {
+          try {
+            const parsed = JSON.parse(data);
+            if (res.statusCode >= 400) {
+              const msg = parsed.message || `HTTP ${res.statusCode}`;
+              if (typeof msg === 'string' && msg.toLowerCase().includes('session_revoked')) {
+                reject(new SessionRevokedError(msg));
+              } else {
+                reject(new Error(msg));
+              }
+            } else {
+              resolve(parsed);
+            }
+          } catch {
+            reject(new Error(`Invalid response: ${data.slice(0, 200)}`));
+          }
+        });
+      });
+
+      req.on('error', reject);
+      req.on('timeout', () => { req.destroy(); reject(new Error('Request timed out')); });
+      req.write(jsonBody);
+      req.end();
+    });
+  }
+
   _patch(urlPath, body, headers = {}, timeout = 15000) {
     if (!headers['Content-Type']) headers['Content-Type'] = 'application/json';
     const jsonBody = JSON.stringify(body);