@openagents-org/agent-launcher 0.2.131 → 0.2.132

package/src/adapters/workspace-prompt.js

@@ -136,6 +136,7 @@ function buildApiSkillsPrompt({ endpoint, workspaceId, token, agentName, channel
   const caps = [];
   if (!disabled.has('files')) caps.push('share and read files with other agents and users');
   if (!disabled.has('browser')) caps.push('browse websites in a shared browser');
+  if (!disabled.has('knowledge')) caps.push('create and access a shared knowledge base');
   caps.push('discover other agents in the workspace');
 
   sections.push(
@@ -292,7 +293,7 @@ function buildApiSkillsPrompt({ endpoint, workspaceId, token, agentName, channel
   }
 
   // To-Dos (planning)
-  if (!isPlan) {
+  if (!isPlan && !disabled.has('todos')) {
     sections.push(
       '\n### To-Do List (Planning)\n\n' +
       'Create or update your to-do list to track progress. The entire list ' +
@@ -315,7 +316,7 @@ function buildApiSkillsPrompt({ endpoint, workspaceId, token, agentName, channel
   }
 
   // Timers
-  if (!isPlan) {
+  if (!isPlan && !disabled.has('timers')) {
     sections.push(
       '\n### Timers\n\n' +
       'Set a timer that will send you a message after a delay, waking you up ' +
@@ -336,7 +337,7 @@ function buildApiSkillsPrompt({ endpoint, workspaceId, token, agentName, channel
   }
 
   // Routines (recurring scheduled tasks)
-  if (!isPlan) {
+  if (!isPlan && !disabled.has('routines')) {
     sections.push(
       '\n### Routines (Recurring Tasks)\n\n' +
       'Create a recurring routine that fires on a schedule. Each routine gets ' +
@@ -366,6 +367,52 @@ function buildApiSkillsPrompt({ endpoint, workspaceId, token, agentName, channel
     );
   }
 
+  // Notifications / Inbox
+  if (!isPlan && !disabled.has('notifications')) {
+    sections.push(
+      '\n### Notifications (Inbox)\n\n' +
+      'Send notifications to the workspace inbox. Notifications appear in a ' +
+      'dedicated panel separate from the chat stream. Use for task completions, ' +
+      'important findings, or anything that needs human attention.\n\n' +
+      '**Send a notification:**\n' +
+      `\`${curl} -s -X POST -H "${h}" -H "Content-Type: application/json" ` +
+      `${baseUrl}/v1/notifications -d '{"title":"Task Complete","message":"The analysis is ready.",` +
+      `"priority":"normal","channel":"${channelName}",` +
+      `"network":"${workspaceId}",` +
+      `"source":"openagents:${agentName}"}'\`\n\n` +
+      '**Priority values:** `low`, `normal`, `high`\n\n' +
+      '**List notifications:**\n' +
+      `\`${curl} -s -H "${h}" "${baseUrl}/v1/notifications?network=${workspaceId}"\`\n`
+    );
+  }
+
+  // Knowledge Base
+  if (!isPlan && !disabled.has('knowledge')) {
+    sections.push(
+      '\n### Knowledge Base\n\n' +
+      'The workspace has a shared knowledge base of markdown documents. ' +
+      'Use it to store and retrieve shared information like API docs, ' +
+      'design decisions, project conventions, and other reference material. ' +
+      'Knowledge entries are accessible to all agents via @knowledge:slug mentions.\n\n' +
+      '**Create a knowledge entry:**\n' +
+      `\`${curl} -s -X POST -H "${h}" -H "Content-Type: application/json" ` +
+      `${baseUrl}/v1/knowledge -d '{"title":"API Design Patterns","content":"# API Design Patterns\\n\\n...",` +
+      `"description":"Common API patterns used in this project",` +
+      `"network":"${workspaceId}",` +
+      `"source":"openagents:${agentName}"}'\`\n\n` +
+      '**List knowledge entries:**\n' +
+      `\`${curl} -s -H "${h}" "${baseUrl}/v1/knowledge?network=${workspaceId}"\`\n\n` +
+      '**Read a knowledge entry by slug:**\n' +
+      `\`${curl} -s -H "${h}" "${baseUrl}/v1/knowledge/by-slug/api-design-patterns?network=${workspaceId}"\`\n\n` +
+      '**Update a knowledge entry:**\n' +
+      `\`${curl} -s -X PUT -H "${h}" -H "Content-Type: application/json" ` +
+      `${baseUrl}/v1/knowledge/ENTRY_ID -d '{"title":"Updated Title","content":"# Updated\\n\\n...",` +
+      `"network":"${workspaceId}","source":"openagents:${agentName}"}'\`\n\n` +
+      '**Delete a knowledge entry:**\n' +
+      `\`${curl} -s -X DELETE -H "${h}" "${baseUrl}/v1/knowledge/ENTRY_ID?network=${workspaceId}"\`\n`
+    );
+  }
+
   // Discovery
   sections.push(
     '\n### Discover Agents\n\n' +
@@ -408,7 +455,10 @@ function buildClaudeSystemPrompt({ agentName, workspaceId, channelName, mode = '
     'Use workspace_get_agents to see other agents.\n' +
     'Use workspace_put_todos to track your progress. ALWAYS create a to-do list when given multiple tasks or multi-step work.\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'
+    'Use workspace_create_routine to set up recurring scheduled tasks (e.g. daily reviews).\n' +
+    'Use workspace_send_notification to send a notification to the workspace inbox when you complete a task or have important results.\n' +
+    'Use workspace_write_knowledge to create or update shared knowledge base entries that persist across conversations.\n' +
+    'Use workspace_read_knowledge to read knowledge entries by ID or slug (from @knowledge:slug mentions).\n'
   );
   parts.push(buildBrowserDirective(browserEnabled));
   parts.push(buildCollaborationPrompt());

package/src/cli.js

@@ -502,6 +502,89 @@ async function cmdToolMode(connector, _flags, positional) {
   }
 }
 
+async function cmdSkills(connector, _flags, positional) {
+  const { SKILL_CATALOG, getSkillDefaults } = require('./skill-catalog');
+  const toggleable = SKILL_CATALOG.filter(s => s.toggleable);
+  const first = positional[0];
+  const second = positional[1];
+  const third = positional[2];
+
+  // agn skills → list skills for all agents
+  if (!first) {
+    const agents = connector.config.getAgents();
+    if (agents.length === 0) { print('No agents configured'); return; }
+    for (const a of agents) {
+      const defaults = getSkillDefaults();
+      const skills = a.skills || {};
+      const parts = toggleable.map(s => {
+        const enabled = skills[s.id] !== undefined ? skills[s.id] : defaults[s.id];
+        return `${enabled ? '+' : '-'}${s.id}`;
+      });
+      print(`  ${a.name}: ${parts.join(' ')}`);
+    }
+    print('\nUsage: agn skills <agent> [enable|disable <skill>]');
+    print('Available skills: ' + toggleable.map(s => s.id).join(', '));
+    return;
+  }
+
+  // agn skills catalog → show full catalog
+  if (first === 'catalog') {
+    print('Skill Hub — Available Skills:\n');
+    for (const s of SKILL_CATALOG) {
+      const tag = s.toggleable ? (s.defaultEnabled ? '[on]' : '[off]') : '[always]';
+      print(`  ${s.id.padEnd(16)} ${tag.padEnd(10)} ${s.name}`);
+      print(`  ${''.padEnd(16)} ${''.padEnd(10)} ${s.description}`);
+      print('');
+    }
+    return;
+  }
+
+  const agent = connector.config.getAgent(first);
+  if (!agent) { print(`Agent '${first}' not found`); process.exitCode = 1; return; }
+
+  // agn skills <agent> → show agent's skills
+  if (!second) {
+    const defaults = getSkillDefaults();
+    const skills = agent.skills || {};
+    print(`Skills for ${first}:\n`);
+    for (const s of toggleable) {
+      const enabled = skills[s.id] !== undefined ? skills[s.id] : defaults[s.id];
+      const marker = enabled ? '  ✓' : '  ✗';
+      print(`${marker} ${s.id.padEnd(14)} ${s.name} — ${s.description}`);
+    }
+    print('\nUsage: agn skills <agent> enable|disable <skill>');
+    return;
+  }
+
+  // agn skills <agent> enable|disable <skill>
+  if (second !== 'enable' && second !== 'disable') {
+    print(`Unknown action: ${second}. Use 'enable' or 'disable'.`);
+    process.exitCode = 1;
+    return;
+  }
+  if (!third) {
+    print(`Usage: agn skills ${first} ${second} <skill>`);
+    print('Available skills: ' + toggleable.map(s => s.id).join(', '));
+    process.exitCode = 1;
+    return;
+  }
+
+  const skillDef = toggleable.find(s => s.id === third);
+  if (!skillDef) {
+    print(`Unknown skill: ${third}`);
+    print('Available skills: ' + toggleable.map(s => s.id).join(', '));
+    process.exitCode = 1;
+    return;
+  }
+
+  const current = agent.skills || {};
+  const updated = { ...current, [third]: second === 'enable' };
+  connector.config.updateAgent(first, { skills: updated });
+  try { connector.sendDaemonCommand('reload'); } catch {}
+  const verb = second === 'enable' ? 'Enabled' : 'Disabled';
+  print(`${verb} '${skillDef.name}' for ${first}`);
+}
+
 async function cmdTestLLM(connector, _flags, positional) {
   const type = positional[0];
   if (!type) { print('Usage: agn test-llm <type>'); return; }
@@ -566,6 +649,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
+  skills [agent] [action]     Manage agent skills (enable/disable)
   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
@@ -652,6 +736,7 @@ async function main() {
     autostart: () => cmdAutostart(connector, flags),
     workspace: () => cmdWorkspace(connector, flags, positional),
     env: () => cmdEnv(connector, flags, positional),
+    skills: () => cmdSkills(connector, flags, positional),
     'tool-mode': () => cmdToolMode(connector, flags, positional),
     'test-llm': () => cmdTestLLM(connector, flags, positional),
     update: () => cmdUpdate(),

package/src/daemon.js

@@ -58,12 +58,20 @@ class Daemon {
     // Write PID file
     this._writePid();
 
-    // Periodic status + command check
+    // Periodic status (heavy: JSON serialize + write) every 5s.
     this._statusInterval = setInterval(() => {
       this._writeStatus();
-      this._processCommands();
     }, 5000);
 
+    // Command file poll (cheap: existsSync on a tiny file) every 200ms so
+    // start/stop/restart from the launcher feels responsive. With a 5s
+    // combined interval, users saw up to 5s before the daemon even noticed
+    // a Stop click — this was especially painful on Windows where there's
+    // no SIGHUP shortcut and Stop landed near the end of a tick.
+    this._cmdInterval = setInterval(() => {
+      this._processCommands();
+    }, 200);
+
     // Watch config file for hot-reload
     this._watchConfig();
 
@@ -429,6 +437,7 @@ class Daemon {
 
   async _adapterLoop(name, agentCfg, info, network) {
     const { createAdapter } = require('./adapters');
+    const { skillsToDisabledModules } = require('./skill-catalog');
     const agentType = agentCfg.type || 'openclaw';
     const endpoint = network.endpoint || 'https://workspace-endpoint.openagents.org';
 
@@ -442,7 +451,7 @@ class Daemon {
         endpoint,
         agentType,
         openclawAgentId: agentCfg.openclaw_agent_id || 'main',
-        disabledModules: new Set(),
+        disabledModules: skillsToDisabledModules(agentCfg.skills),
         agentEnv: this._buildAgentEnv(agentCfg),
         workingDir: agentCfg.path || undefined,
         toolMode: agentCfg.tool_mode || 'skills',

package/src/index.js

@@ -126,6 +126,17 @@ class AgentConnector {
     return { success: true };
   }
 
+  /**
+   * Delete the entire type-level env file (~/.openagents/env/<type>.env).
+   * Used by the launcher's "wipe saved credentials" path on uninstall so
+   * sensitive values (API keys) don't survive a reinstall as surprise
+   * pre-filled defaults in the setup wizard.
+   */
+  deleteAgentEnv(agentType) {
+    this.env.delete(agentType);
+    return { success: true };
+  }
+
   saveAgentInstanceEnv(agentName, env) {
     const agent = this.config.getAgent(agentName);
     if (!agent) throw new Error(`Agent '${agentName}' not found`);

package/src/mcp-server.js

@@ -235,111 +235,202 @@ 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)' },
+  // -- Todos --
+  if (!disabledModules.has('todos')) {
+    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'],
               },
-              required: ['content', 'status'],
+              description: 'Full to-do list with current statuses',
             },
-            description: 'Full to-do list with current statuses',
           },
+          required: ['todos'],
         },
-        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_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' },
+    );
+  }
+
+  // -- Timers --
+  if (!disabledModules.has('timers')) {
+    tools.push(
+      {
+        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'],
         },
-        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' },
+      {
+        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'],
         },
-        required: ['timer_id'],
       },
-    },
-    {
-      name: 'workspace_create_routine',
-      description: 'Create a recurring scheduled routine. Each routine gets its own dedicated thread with full context. Two schedule modes: daily (hour+minute, optional days) or interval (every N minutes).',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          name: { type: 'string', description: 'Human-readable label for the routine (e.g. "Daily PR Review")' },
-          message: { type: 'string', description: 'Short trigger message posted each time the routine fires' },
-          context: { type: 'string', description: 'Comprehensive context for the routine: what it should do, background info, goals, relevant details from the current conversation. This is posted at the start of the routine\'s dedicated thread so you have full background every time it fires. Be thorough — this is your only memory of why this routine exists.' },
-          hour: { type: 'integer', description: 'Daily mode: hour in UTC (0-23). Omit if using interval_minutes.' },
-          minute: { type: 'integer', description: 'Daily mode: minute (0-59). Omit if using interval_minutes.' },
-          days: {
-            type: 'array',
-            items: { type: 'integer' },
-            description: 'Daily mode: days of week to fire (0=Mon, 6=Sun). Omit for every day. Not allowed in interval mode.',
+    );
+  }
+
+  // -- Routines --
+  if (!disabledModules.has('routines')) {
+    tools.push(
+      {
+        name: 'workspace_create_routine',
+        description: 'Create a recurring scheduled routine. Each routine gets its own dedicated thread with full context. Two schedule modes: daily (hour+minute, optional days) or interval (every N minutes).',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            name: { type: 'string', description: 'Human-readable label for the routine (e.g. "Daily PR Review")' },
+            message: { type: 'string', description: 'Short trigger message posted each time the routine fires' },
+            context: { type: 'string', description: 'Comprehensive context for the routine: what it should do, background info, goals, relevant details from the current conversation. This is posted at the start of the routine\'s dedicated thread so you have full background every time it fires. Be thorough — this is your only memory of why this routine exists.' },
+            hour: { type: 'integer', description: 'Daily mode: hour in UTC (0-23). Omit if using interval_minutes.' },
+            minute: { type: 'integer', description: 'Daily mode: minute (0-59). Omit if using interval_minutes.' },
+            days: {
+              type: 'array',
+              items: { type: 'integer' },
+              description: 'Daily mode: days of week to fire (0=Mon, 6=Sun). Omit for every day. Not allowed in interval mode.',
+            },
+            interval_minutes: {
+              type: 'integer',
+              description: 'Interval mode: fire every N minutes (1-1440). Mutually exclusive with hour/minute.',
+            },
           },
-          interval_minutes: {
-            type: 'integer',
-            description: 'Interval mode: fire every N minutes (1-1440). Mutually exclusive with hour/minute.',
+          required: ['name', 'message', 'context'],
+        },
+      },
+      {
+        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'],
         },
-        required: ['name', 'message', 'context'],
       },
-    },
-    {
-      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' },
+    );
+  }
+
+  // -- Notifications --
+  if (!disabledModules.has('notifications')) {
+    tools.push(
+      {
+        name: 'workspace_send_notification',
+        description: 'Send a notification to the workspace inbox. Use this to alert humans about completed tasks, important findings, or anything that needs their attention outside the chat stream.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            title: { type: 'string', description: 'Short notification title (e.g. "News scan complete")' },
+            message: { type: 'string', description: 'Notification body with details' },
+            priority: { type: 'string', enum: ['low', 'normal', 'high'], description: 'Notification priority (default: normal)' },
+            channel: { type: 'string', description: 'Related channel/thread name (for navigation link)' },
+          },
+          required: ['title', 'message'],
         },
-        required: ['routine_id'],
       },
-    },
-  );
+      {
+        name: 'workspace_get_notifications',
+        description: 'List notifications you have sent to the workspace inbox.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            limit: { type: 'integer', description: 'Number of notifications to return (default 20)' },
+          },
+        },
+      },
+    );
+  }
+
+  // -- Knowledge Base --
+  if (!disabledModules.has('knowledge')) {
+    tools.push(
+      {
+        name: 'workspace_list_knowledge',
+        description: 'List knowledge base entries shared in the workspace.',
+        inputSchema: { type: 'object', properties: {} },
+      },
+      {
+        name: 'workspace_read_knowledge',
+        description: 'Read a knowledge base entry by ID or slug. Returns the full markdown content.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            entry_id: { type: 'string', description: 'Knowledge entry ID' },
+            slug: { type: 'string', description: 'Knowledge entry slug (alternative to entry_id)' },
+          },
+        },
+      },
+      {
+        name: 'workspace_write_knowledge',
+        description: 'Create or update a knowledge base entry. Knowledge entries are workspace-global markdown documents accessible to all agents via @knowledge:slug mentions.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            title: { type: 'string', description: 'Entry title' },
+            content: { type: 'string', description: 'Markdown content of the knowledge entry' },
+            description: { type: 'string', description: 'Short summary (optional)' },
+            entry_id: { type: 'string', description: 'Existing entry ID to update (omit to create new)' },
+          },
+          required: ['title', 'content'],
+        },
+      },
+      {
+        name: 'workspace_delete_knowledge',
+        description: 'Delete a knowledge base entry by ID.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            entry_id: { type: 'string', description: 'Knowledge entry ID to delete' },
+          },
+          required: ['entry_id'],
+        },
+      },
+    );
+  }
 
   return tools;
 }
@@ -808,6 +899,82 @@ class McpServer {
         return text(`Routine cancelled: ${args.routine_id}`);
       }
 
+      case 'workspace_send_notification': {
+        const result = await this.ws.createNotification(
+          this.workspaceId, this.token,
+          {
+            title: args.title,
+            message: args.message,
+            priority: args.priority || 'normal',
+            channel: args.channel || this.channelName,
+            source: `openagents:${this.agentName}`,
+          },
+        );
+        return text(`Notification sent: "${args.title}" (id: ${result.id})`);
+      }
+
+      case 'workspace_get_notifications': {
+        const data = await this.ws.listNotifications(this.workspaceId, this.token, {
+          limit: args.limit || 20,
+        });
+        const notifications = (data && data.notifications) || [];
+        if (!notifications.length) return text('No notifications.');
+        const lines = notifications.map((n) => {
+          const readStatus = n.is_read ? '[read]' : '[unread]';
+          const prio = n.priority !== 'normal' ? ` [${n.priority}]` : '';
+          return `- ${readStatus}${prio} ${n.title}: ${n.message.slice(0, 80)}${n.message.length > 80 ? '...' : ''} (${n.created_at})`;
+        });
+        return text(lines.join('\n'));
+      }
+
+      // ── Knowledge Base ──
+
+      case 'workspace_list_knowledge': {
+        const data = await this.ws.listKnowledge(this.workspaceId, this.token);
+        const entries = (data && data.entries) || [];
+        if (!entries.length) return text('No knowledge entries yet.');
+        const lines = entries.map((e) =>
+          `- ${e.title} (slug: ${e.slug}, id: ${e.id})`
+        );
+        return text(lines.join('\n'));
+      }
+
+      case 'workspace_read_knowledge': {
+        let data;
+        if (args.slug) {
+          data = await this.ws.getKnowledgeBySlug(this.workspaceId, this.token, args.slug);
+        } else if (args.entry_id) {
+          data = await this.ws.getKnowledge(this.workspaceId, this.token, args.entry_id);
+        } else {
+          throw new Error('Either entry_id or slug is required');
+        }
+        return text(`# ${data.title}\n\n${data.content || '(empty)'}`);
+      }
+
+      case 'workspace_write_knowledge': {
+        let result;
+        if (args.entry_id) {
+          result = await this.ws.updateKnowledge(
+            this.workspaceId, this.token, args.entry_id,
+            { title: args.title, content: args.content, description: args.description,
+              source: `openagents:${this.agentName}` },
+          );
+          return text(`Knowledge updated: "${result.title}" (slug: ${result.slug})`);
+        } else {
+          result = await this.ws.createKnowledge(
+            this.workspaceId, this.token,
+            { title: args.title, content: args.content, description: args.description,
+              source: `openagents:${this.agentName}` },
+          );
+          return text(`Knowledge created: "${result.title}" (slug: ${result.slug}, id: ${result.id})`);
+        }
+      }
+
+      case 'workspace_delete_knowledge': {
+        await this.ws.deleteKnowledge(this.workspaceId, this.token, args.entry_id);
+        return text(`Knowledge entry deleted: ${args.entry_id}`);
+      }
+
       default:
         throw new Error(`Unknown tool: ${name}`);
     }