@openagents-org/agent-launcher 0.2.130 → 0.2.131

package/package.json

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

package/registry.json

@@ -209,14 +209,16 @@
     "order": 4,
     "builtin": true,
     "install": {
-      "binary": "agent",
-      "verify": "agent --version 2>/dev/null | head -1",
-      "verify_win": "agent --version 2>nul",
+      "binary": "cursor-agent",
+      "binary_aliases": [
+        "agent"
+      ],
+      "verify": "cursor-agent --version 2>/dev/null | head -1",
+      "verify_win": "cursor-agent --version 2>nul",
       "requires": [],
       "macos": "curl https://cursor.com/install -fsSL | bash",
       "linux": "curl https://cursor.com/install -fsSL | bash",
-      "windows": "irm 'https://cursor.com/install?win32=true' | iex",
-      "npm": "npm install -g @cursor/cli"
+      "windows": "\"%SystemRoot%\\System32\\WindowsPowerShell\\v1.0\\powershell.exe\" -NoProfile -ExecutionPolicy Bypass -Command \"Invoke-RestMethod -UseBasicParsing 'https://cursor.com/install?win32=true' | Invoke-Expression\""
     },
     "adapter": {
       "module": "openagents.adapters.cursor",

package/src/adapters/base.js

@@ -53,6 +53,11 @@ class BaseAdapter {
     // Per-channel task tracking for parallel execution
     this._channelBusy = new Set();
     this._channelQueues = {};
+    // Cached workspace.browser_enabled. Populated lazily on first read so we
+    // don't pay an HTTP roundtrip per message — adapters that toggle the
+    // workspace flag must reconnect/restart to pick up the change (matches
+    // the Python adapter behavior in workspace_prompt.py).
+    this._browserEnabledCache = null;
     // 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
@@ -210,6 +215,8 @@ class BaseAdapter {
   async _onControlAction(action, payload) {
     if (action === 'status') {
       await this._postStatusReport(payload);
+    } else if (action === 'routines') {
+      await this._postRoutinesReport(payload);
     }
   }
 
@@ -262,6 +269,74 @@ class BaseAdapter {
     }
   }
 
+  /**
+   * Post a markdown table of the agent's active routines back to the
+   * requesting channel. Used by the `/routines` slash command. Each agent
+   * reports only routines it owns (created_by === openagents:<agentName>)
+   * so the user sees a clear "my routines" view per agent, mirroring how
+   * /status reports per-agent uptime.
+   */
+  async _postRoutinesReport(payload) {
+    const channel = (payload && typeof payload === 'object') ? payload.channel : null;
+    if (!channel) return;
+
+    let routines = [];
+    try {
+      const data = await this.client.listRoutines(this.workspaceId, channel, this.token);
+      // Accept both the canonical `openagents:<name>` source and the bare
+      // `<name>` form. Agents that follow the workspace prompt verbatim
+      // produce the prefixed form, but some agents send the bare name when
+      // they construct the POST body themselves.
+      const prefixed = `openagents:${this.agentName}`;
+      routines = ((data && data.routines) || []).filter(
+        (r) => r.created_by === prefixed || r.created_by === this.agentName,
+      );
+    } catch (e) {
+      this._log(`Routines: failed to list: ${e && e.message ? e.message : e}`);
+      try {
+        await this.client.sendMessage(
+          this.workspaceId, channel, this.token,
+          `**Routines for \`${this.agentName}\`**\n\n_Failed to fetch routines._`,
+          { senderType: 'agent', senderName: this.agentName, messageType: 'chat', sessionId: this._sessionId },
+        );
+      } catch {}
+      return;
+    }
+
+    let content;
+    if (!routines.length) {
+      content = `**Routines for \`${this.agentName}\`**\n\n_No active routines._`;
+    } else {
+      const rows = routines.map((r) => {
+        const schedule = (r.schedule_interval_minutes != null)
+          ? `every ${r.schedule_interval_minutes} min`
+          : `${String(r.schedule_hour ?? 0).padStart(2, '0')}:${String(r.schedule_minute ?? 0).padStart(2, '0')} UTC` +
+            (r.schedule_days ? ` (days [${r.schedule_days.join(',')}])` : ' daily');
+        const next = r.next_fires_at || '—';
+        const name = String(r.name || '').replace(/\|/g, '\\|');
+        const id = String(r.id || '').slice(0, 8);
+        return `| \`${id}\` | ${name} | ${schedule} | ${next} |`;
+      });
+      content =
+        `**Routines for \`${this.agentName}\`** (${routines.length})\n\n` +
+        '| ID | Name | Schedule | Next fires |\n' +
+        '|---|---|---|---|\n' +
+        rows.join('\n');
+    }
+
+    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(`Routines: failed to post: ${e && e.message ? e.message : e}`);
+    }
+  }
+
   _hasActiveWork() {
     return this._channelBusy.size > 0;
   }
@@ -306,7 +381,7 @@ class BaseAdapter {
 
     while (this._running) {
       pollCount++;
-      let messages, rawCursor;
+      let messages, rawCursor, composingActive = false;
       try {
         const result = await this.client.pollPending(
           this.workspaceId, this.agentName, this.token,
@@ -314,8 +389,9 @@ class BaseAdapter {
         );
         messages = result.messages;
         rawCursor = result.cursor;
+        composingActive = !!result.composing;
         if (pollCount <= 3 || pollCount % 20 === 0) {
-          this._log(`Poll #${pollCount}: ${messages.length} messages, cursor=${rawCursor || 'none'}`);
+          this._log(`Poll #${pollCount}: ${messages.length} messages, cursor=${rawCursor || 'none'}${composingActive ? ' composing' : ''}`);
         }
       } catch (e) {
         this._log(`Poll #${pollCount} failed: ${e.message} \nStack: ${e.stack}`);
@@ -384,11 +460,26 @@ class BaseAdapter {
         }
       }
 
-      // Adaptive polling: 2s active, up to 15s idle.
-      // Each connected agent runs this loop, so faster rates multiply across
-      // every workspace member — keep this conservative and tune separately
-      // with a load-impact analysis on workspace-endpoint.
-      const delay = incoming.length > 0 ? 2000 : Math.min(2000 + idleCount * 1000, 15000);
+      // Adaptive polling with warm plateau:
+      //   Active (messages incoming):  2s
+      //   Warm (≤5 min since last msg): 5s
+      //   Cooldown (5-7 min):          5s → 15s (ramp 1s per idle poll)
+      //   Cold (>7 min):              15s
+      // The warm plateau keeps the agent responsive during typical user
+      // think-time between messages without hammering the backend.
+      const WARM_INTERVAL = 5000;
+      const WARM_POLLS = 60;  // 60 × 5s = 5 minutes warm plateau
+      let delay;
+      if (incoming.length > 0) {
+        delay = 2000;
+      } else if (composingActive) {
+        delay = 2000;
+        idleCount = Math.min(idleCount, WARM_POLLS);
+      } else if (idleCount <= WARM_POLLS) {
+        delay = WARM_INTERVAL;
+      } else {
+        delay = Math.min(WARM_INTERVAL + (idleCount - WARM_POLLS) * 1000, 15000);
+      }
       await this._sleep(delay);
     }
   }
@@ -636,6 +727,25 @@ class BaseAdapter {
   _sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
   }
+
+  /**
+   * Return whether the workspace has the Browser Fabric viewer toggle on.
+   * Cached for the lifetime of the adapter — restart to pick up a flip.
+   * Falls back to false on error so the prompt builders don't accidentally
+   * inject the strong directive against an older backend that can't route
+   * to Browser Fabric.
+   */
+  async getBrowserEnabled() {
+    if (this._browserEnabledCache === null) {
+      try {
+        const meta = await this.client.getWorkspaceMetadata(this.workspaceId, this.token);
+        this._browserEnabledCache = !!(meta && meta.browserEnabled);
+      } catch (e) {
+        this._browserEnabledCache = false;
+      }
+    }
+    return this._browserEnabledCache;
+  }
 }
 
 // ------------------------------------------------------------------

package/src/adapters/claude.js

@@ -358,7 +358,7 @@ class ClaudeAdapter extends BaseAdapter {
     return null;
   }
 
-  _buildClaudeCmd(prompt, channelName, { skipResume = false } = {}) {
+  _buildClaudeCmd(prompt, channelName, { skipResume = false, browserEnabled = false } = {}) {
     const claudeBin = this._findClaudeBinary();
     if (!claudeBin) {
       throw new Error('claude CLI not found. Install with: curl -fsSL https://claude.ai/install.sh | bash');
@@ -369,6 +369,7 @@ class ClaudeAdapter extends BaseAdapter {
       workspaceId: this.workspaceId,
       channelName,
       mode: this._mode,
+      browserEnabled,
     });
 
     // In skills mode, replace MCP tool references with curl-based instructions
@@ -432,6 +433,7 @@ class ClaudeAdapter extends BaseAdapter {
       agentName: this.agentName,
       channelName,
       disabledModules: this.disabledModules,
+      browserEnabled: this._browserEnabledCache === true,
     });
     fs.writeFileSync(skillFile, skillContent, 'utf-8');
     this._log(`Wrote workspace skill to ${skillFile}`);
@@ -648,7 +650,11 @@ class ClaudeAdapter extends BaseAdapter {
       }
 
       try {
-        const built = this._buildClaudeCmd(effectiveContent, msgChannel, { skipResume: attempt > 0 });
+        const browserEnabled = await this.getBrowserEnabled();
+        const built = this._buildClaudeCmd(effectiveContent, msgChannel, {
+          skipResume: attempt > 0,
+          browserEnabled,
+        });
         cmd = built.cmd;
         mcpConfigFile = built.mcpConfigFile;
       } catch (e) {
@@ -853,6 +859,27 @@ class ClaudeAdapter extends BaseAdapter {
             }
           }
 
+          // In plan mode, read the plan file and include it in the response
+          if (this._mode === 'plan') {
+            try {
+              const planDir = path.join(this.workingDir || process.cwd(), '.claude', 'plans');
+              if (fs.existsSync(planDir)) {
+                const planFiles = fs.readdirSync(planDir)
+                  .filter((f) => f.endsWith('.md'))
+                  .map((f) => ({ name: f, mtime: fs.statSync(path.join(planDir, f)).mtimeMs }))
+                  .sort((a, b) => b.mtime - a.mtime);
+                if (planFiles.length > 0) {
+                  const planContent = fs.readFileSync(path.join(planDir, planFiles[0].name), 'utf-8').trim();
+                  if (planContent) {
+                    lastResponseText.push('\n\n---\n\n**Plan:**\n\n' + planContent);
+                  }
+                }
+              }
+            } catch (e) {
+              this._log(`Failed to read plan file: ${e.message}`);
+            }
+          }
+
           if (lastResponseText.length > 0) {
             const fullResponse = lastResponseText.join('\n').trim();
             // "Prompt is too long" means the resumed session's context

package/src/adapters/cursor.js

@@ -171,40 +171,59 @@ class CursorAdapter extends BaseAdapter {
   _findCursorBinary() {
     const home = os.homedir();
     const ext = IS_WINDOWS ? '.cmd' : '';
+    const names = ['cursor-agent', 'agent'];
 
     // Tier 0: Isolated runtime prefix
-    const runtimeCandidate = path.join(home, '.openagents', 'runtimes', 'cursor', 'node_modules', '.bin', `agent${ext}`);
-    if (fs.existsSync(runtimeCandidate)) return runtimeCandidate;
+    for (const name of names) {
+      const runtimeCandidate = path.join(home, '.openagents', 'runtimes', 'cursor', 'node_modules', '.bin', `${name}${ext}`);
+      if (fs.existsSync(runtimeCandidate)) return runtimeCandidate;
+    }
 
     // Tier 0b: Legacy portable install
-    const portableCandidate = path.join(home, '.openagents', 'nodejs', 'node_modules', '.bin', `agent${ext}`);
-    if (fs.existsSync(portableCandidate)) return portableCandidate;
+    for (const name of names) {
+      const portableCandidate = path.join(home, '.openagents', 'nodejs', 'node_modules', '.bin', `${name}${ext}`);
+      if (fs.existsSync(portableCandidate)) return portableCandidate;
+    }
 
     // Tier 1: PATH search
     try {
       if (IS_WINDOWS) {
-        const r = execSync('where agent.cmd 2>nul || where agent.exe 2>nul || where agent 2>nul', {
+        const r = execSync('where cursor-agent.cmd 2>nul || where cursor-agent.exe 2>nul || where cursor-agent 2>nul || where agent.cmd 2>nul || where agent.exe 2>nul || where agent 2>nul', {
           encoding: 'utf-8', timeout: 5000,
         });
         return r.split(/\r?\n/)[0].trim();
       } else {
-        return execSync('which agent', { encoding: 'utf-8', timeout: 5000 }).trim();
+        return execSync('which cursor-agent || which agent', { encoding: 'utf-8', timeout: 5000 }).trim();
       }
     } catch {}
 
     // Tier 2: Next to current Node.js interpreter (npm global)
     const nodeBinDir = path.dirname(process.execPath);
-    const nearNode = path.join(nodeBinDir, `agent${ext}`);
-    if (fs.existsSync(nearNode)) return nearNode;
+    for (const name of names) {
+      const nearNode = path.join(nodeBinDir, `${name}${ext}`);
+      if (fs.existsSync(nearNode)) return nearNode;
+    }
 
     // Tier 3: Common install locations
     const candidates = IS_WINDOWS ? [
+      path.join(home, '.cursor', 'bin', 'cursor-agent.cmd'),
+      path.join(home, '.cursor', 'bin', 'cursor-agent.exe'),
+      path.join(home, '.cursor', 'bin', 'cursor-agent'),
+      path.join(home, '.cursor', 'bin', 'agent.cmd'),
+      path.join(home, '.cursor', 'bin', 'agent.exe'),
+      path.join(home, '.cursor', 'bin', 'agent'),
+      path.join(process.env.APPDATA || '', 'npm', 'cursor-agent.cmd'),
       path.join(process.env.APPDATA || '', 'npm', 'agent.cmd'),
     ] : [
+      path.join(home, '.local', 'bin', 'cursor-agent'),
       path.join(home, '.local', 'bin', 'agent'),
+      path.join(home, '.npm-global', 'bin', 'cursor-agent'),
       path.join(home, '.npm-global', 'bin', 'agent'),
+      path.join(home, '.cursor', 'bin', 'cursor-agent'),
       path.join(home, '.cursor', 'bin', 'agent'),
+      '/opt/homebrew/bin/cursor-agent',
       '/opt/homebrew/bin/agent',
+      '/usr/local/bin/cursor-agent',
       '/usr/local/bin/agent',
     ];
     for (const c of candidates) {

package/src/adapters/workspace-prompt.js

@@ -11,6 +11,51 @@
 
 'use strict';
 
+/**
+ * Strong directive forcing agents to use the workspace browser when the
+ * workspace has Browser Fabric enabled. Emitted high in the system prompt
+ * so it wins against any earlier guidance that suggests local browsing
+ * tools.
+ *
+ * Returns '' when the toggle is off; the caller can unconditionally
+ * concatenate the result.
+ *
+ * Mirrors `build_browser_directive` in
+ * sdk/src/openagents/adapters/workspace_prompt.py.
+ */
+function buildBrowserDirective(browserEnabled) {
+  if (!browserEnabled) return '';
+  return (
+    '\n## Browser Use (MANDATORY)\n' +
+    'This workspace has the **shared Browser Fabric session** enabled. ' +
+    'All web browsing MUST go through it so the user can watch the ' +
+    'session live in their right-side panel and so cookies / state ' +
+    'persist across agents.\n\n' +
+    '**Use ONLY these tools for any web browsing:**\n' +
+    '- `mcp__openagents-workspace__workspace_browser_open`\n' +
+    '- `mcp__openagents-workspace__workspace_browser_navigate`\n' +
+    '- `mcp__openagents-workspace__workspace_browser_click`\n' +
+    '- `mcp__openagents-workspace__workspace_browser_type`\n' +
+    '- `mcp__openagents-workspace__workspace_browser_snapshot`\n' +
+    '- `mcp__openagents-workspace__workspace_browser_screenshot`\n' +
+    '- `mcp__openagents-workspace__workspace_browser_list_tabs`\n' +
+    '- `mcp__openagents-workspace__workspace_browser_close`\n' +
+    '\n' +
+    'If you don\'t have these MCP tools, use `Bash` + `curl` against ' +
+    '`/v1/browser/tabs` (documented below in Shared Browser).\n\n' +
+    '**FORBIDDEN — do NOT call any of these:**\n' +
+    '- `mcp__browsermcp__*` (any local Browser MCP extension tool)\n' +
+    '- `mcp__playwright__*`, `mcp__puppeteer__*`, `mcp__chrome-devtools__*`, or any other local-browser MCP\n' +
+    '- `WebFetch`, `WebSearch`, `web_fetch`, `web_search`, or any built-in network/browser tool\n' +
+    '\n' +
+    'If a local browser tool errors with "extension isn\'t connected" or ' +
+    '"connect your browser", do NOT ask the user to connect anything — ' +
+    'the local extension is irrelevant here. Immediately switch to the ' +
+    'workspace browser tools above. The Browser Fabric session is already ' +
+    'running on the backend.\n'
+  );
+}
+
 /**
  * Build the identity section common to all adapters.
  */
@@ -294,25 +339,28 @@ function buildApiSkillsPrompt({ endpoint, workspaceId, token, agentName, channel
   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' +
+      'Create a recurring routine that fires on a schedule. Each routine gets ' +
+      '**its own dedicated thread** (`routine:<id>`) so different routines never ' +
+      'interfere, and the full context is preserved.\n\n' +
+      '**`context` is required** — provide a thorough description of what the ' +
+      'routine should do, any background info, and relevant details from the ' +
+      'current conversation. This context is posted at the start of the routine\'s ' +
+      'thread every time it fires, so you have full background.\n\n' +
+      '**Two schedule modes:**\n' +
+      '- **Daily**: `hour` (0-23 UTC) + `minute` (0-59), optional `days` ' +
+      'array (0=Mon, 6=Sun). Omit `days` for every day.\n' +
+      '- **Interval**: `interval_minutes` (1-1440). Fires every N minutes. ' +
+      'Mutually exclusive with `hour`/`minute`.\n\n' +
+      '**Create a daily 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",` +
+      `"context":"Review all open pull requests on the main repo. Check for merge conflicts, ` +
+      `CI failures, and stale PRs older than 3 days. Post a summary to the workspace.",` +
       `"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}",` +
+      `"network":"${workspaceId}",` +
       `"source":"openagents:${agentName}"}'\`\n\n` +
       '**List active routines:**\n' +
-      `\`${curl} -s -H "${h}" "${baseUrl}/v1/routines?network=${workspaceId}&channel=${channelName}"\`\n\n` +
+      `\`${curl} -s -H "${h}" "${baseUrl}/v1/routines?network=${workspaceId}"\`\n\n` +
       '**Cancel a routine:**\n' +
       `\`${curl} -s -X DELETE -H "${h}" ${baseUrl}/v1/routines/ROUTINE_ID\`\n`
     );
@@ -352,7 +400,7 @@ function buildGuardrails() {
  * Build the system prompt for Claude adapter (MCP-based).
  * Claude gets identity + collaboration instructions but NOT API skills.
  */
-function buildClaudeSystemPrompt({ agentName, workspaceId, channelName, mode = 'execute' }) {
+function buildClaudeSystemPrompt({ agentName, workspaceId, channelName, mode = 'execute', browserEnabled = false }) {
   const parts = [];
   parts.push(buildWorkspaceIdentity(agentName, workspaceId, channelName, mode));
   parts.push(
@@ -362,6 +410,7 @@ function buildClaudeSystemPrompt({ agentName, workspaceId, channelName, mode = '
     '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(buildBrowserDirective(browserEnabled));
   parts.push(buildCollaborationPrompt());
   parts.push(buildA2UIPrompt());
 
@@ -457,9 +506,10 @@ function buildA2UIPrompt() {
 /**
  * Build the full system prompt for OpenClaw/non-MCP agents.
  */
-function buildOpenclawSystemPrompt({ agentName, workspaceId, channelName, endpoint, token, mode = 'execute', disabledModules }) {
+function buildOpenclawSystemPrompt({ agentName, workspaceId, channelName, endpoint, token, mode = 'execute', disabledModules, browserEnabled = false }) {
   const parts = [];
   parts.push(buildWorkspaceIdentity(agentName, workspaceId, channelName, mode));
+  parts.push(buildBrowserDirective(browserEnabled));
   parts.push(buildCollaborationPrompt());
   parts.push(buildA2UIPrompt());
   parts.push(buildModePrompt(mode));
@@ -473,12 +523,13 @@ function buildOpenclawSystemPrompt({ agentName, workspaceId, channelName, endpoi
 /**
  * Build a SKILL.md file for OpenClaw's skill auto-discovery.
  */
-function buildOpenclawSkillMd({ endpoint, workspaceId, token, agentName, channelName, disabledModules }) {
+function buildOpenclawSkillMd({ endpoint, workspaceId, token, agentName, channelName, disabledModules, browserEnabled = false }) {
   const body = buildApiSkillsPrompt({
     endpoint, workspaceId, token, agentName, channelName, disabledModules, mode: 'execute',
   });
 
   const identity = buildWorkspaceIdentity(agentName, workspaceId, channelName, 'execute');
+  const directive = buildBrowserDirective(browserEnabled);
   const collab = buildCollaborationPrompt();
 
   const frontmatter = (
@@ -495,18 +546,19 @@ function buildOpenclawSkillMd({ endpoint, workspaceId, token, agentName, channel
     '---\n\n'
   );
 
-  return frontmatter + identity + '\n' + collab + '\n' + body + '\n' + buildGuardrails();
+  return frontmatter + identity + directive + '\n' + collab + '\n' + body + '\n' + buildGuardrails();
 }
 
 /**
  * Build system prompt for OpenCode adapter.
  */
-function buildOpenCodeSystemPrompt({ agentName, workspaceId, channelName, endpoint, token, mode = 'execute', disabledModules }) {
+function buildOpenCodeSystemPrompt({ agentName, workspaceId, channelName, endpoint, token, mode = 'execute', disabledModules, browserEnabled = false }) {
   const identity = buildWorkspaceIdentity(agentName, workspaceId, channelName, mode);
+  const directive = buildBrowserDirective(browserEnabled);
   const collab = buildCollaborationPrompt();
   const modePrompt = buildModePrompt(mode);
   const api = buildApiSkillsPrompt({ endpoint, workspaceId, token, agentName, channelName, disabledModules, mode });
-  return identity + '\n' + collab + '\n' + modePrompt + '\n' + api + '\n' + buildGuardrails();
+  return identity + directive + '\n' + collab + '\n' + modePrompt + '\n' + api + '\n' + buildGuardrails();
 }
 
 /**
@@ -540,7 +592,7 @@ function buildOpenCodeSkillMd({ endpoint, workspaceId, token, agentName, channel
  * 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 }) {
+function buildClaudeSkillMd({ endpoint, workspaceId, token, agentName, channelName, disabledModules, browserEnabled = false }) {
   const api = buildApiSkillsPrompt({
     endpoint, workspaceId, token, agentName,
     channelName: channelName || 'general',
@@ -549,6 +601,7 @@ function buildClaudeSkillMd({ endpoint, workspaceId, token, agentName, channelNa
   });
 
   const identity = buildWorkspaceIdentity(agentName, workspaceId, channelName, 'execute');
+  const directive = buildBrowserDirective(browserEnabled);
   const collab = buildCollaborationPrompt();
 
   const frontmatter =
@@ -561,7 +614,7 @@ function buildClaudeSkillMd({ endpoint, workspaceId, token, agentName, channelNa
     '  or collaborating with other agents via @mentions.\n' +
     '---\n\n';
 
-  return frontmatter + identity + '\n' + collab + '\n' + api + '\n' + buildGuardrails();
+  return frontmatter + identity + directive + '\n' + collab + '\n' + api + '\n' + buildGuardrails();
 }
 
 /**
@@ -570,7 +623,7 @@ function buildClaudeSkillMd({ endpoint, workspaceId, token, agentName, channelNa
  * Written to .cursor/skills/openagents-workspace.md before each CLI spawn.
  * Cursor discovers skills from the .cursor/skills/ directory automatically.
  */
-function buildCursorSkillMd({ endpoint, workspaceId, token, agentName, channelName, disabledModules }) {
+function buildCursorSkillMd({ endpoint, workspaceId, token, agentName, channelName, disabledModules, browserEnabled = false }) {
   const api = buildApiSkillsPrompt({
     endpoint, workspaceId, token, agentName,
     channelName: channelName || 'general',
@@ -579,6 +632,7 @@ function buildCursorSkillMd({ endpoint, workspaceId, token, agentName, channelNa
   });
 
   const identity = buildWorkspaceIdentity(agentName, workspaceId, channelName, 'execute');
+  const directive = buildBrowserDirective(browserEnabled);
   const collab = buildCollaborationPrompt();
 
   const frontmatter =
@@ -591,11 +645,12 @@ function buildCursorSkillMd({ endpoint, workspaceId, token, agentName, channelNa
     '  or collaborating with other agents via @mentions.\n' +
     '---\n\n';
 
-  return frontmatter + identity + '\n' + collab + '\n' + api + '\n' + buildGuardrails();
+  return frontmatter + identity + directive + '\n' + collab + '\n' + api + '\n' + buildGuardrails();
 }
 
 module.exports = {
   buildWorkspaceIdentity,
+  buildBrowserDirective,
   buildCollaborationPrompt,
   buildModePrompt,
   buildGuardrails,

package/src/github-client.js

@@ -0,0 +1,165 @@
+'use strict';
+
+const https = require('https');
+
+const DEFAULT_BASE_URL = 'https://api.github.com';
+const USER_AGENT = '@openagents-org/agent-launcher';
+
+/**
+ * Thin GitHub REST API client used by the launcher's GitHub integration.
+ *
+ * Auth is via a personal access token (classic or fine-grained) or GitHub
+ * App installation token. Each call accepts an explicit token so the caller
+ * can resolve it from the launcher's credentials store at request time.
+ */
+class GitHubClient {
+  constructor(opts = {}) {
+    this.baseUrl = (opts.baseUrl || DEFAULT_BASE_URL).replace(/\/$/, '');
+  }
+
+  /**
+   * Verify a token and return identity / rate-limit info.
+   * Mirrors `GET /user` + `GET /rate_limit`.
+   */
+  async probe(token) {
+    if (!token) throw new Error('Missing GitHub token');
+    const user = await this._get('/user', token);
+    const rate = await this._get('/rate_limit', token).catch(() => null);
+    return {
+      ok: true,
+      login: user.login,
+      name: user.name,
+      avatarUrl: user.avatar_url,
+      scopes: user.__scopes || [],
+      rate: rate ? rate.rate : null,
+    };
+  }
+
+  async getRepo(owner, name, token) {
+    return this._get(`/repos/${encodeURIComponent(owner)}/${encodeURIComponent(name)}`, token);
+  }
+
+  /**
+   * @param {string} owner
+   * @param {string} name
+   * @param {{ state?: 'open'|'closed'|'all', perPage?: number, page?: number }} opts
+   * @param {string} token
+   */
+  async listIssues(owner, name, opts = {}, token) {
+    const state = opts.state || 'open';
+    const perPage = opts.perPage || 20;
+    const page = opts.page || 1;
+    // GitHub's /issues endpoint returns PRs too — filter to issue-only.
+    const items = await this._get(
+      `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(name)}/issues?state=${state}&per_page=${perPage}&page=${page}`,
+      token,
+    );
+    return items.filter((i) => !i.pull_request);
+  }
+
+  async listPullRequests(owner, name, opts = {}, token) {
+    const state = opts.state || 'open';
+    const perPage = opts.perPage || 20;
+    const page = opts.page || 1;
+    return this._get(
+      `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(name)}/pulls?state=${state}&per_page=${perPage}&page=${page}`,
+      token,
+    );
+  }
+
+  async createIssueComment(owner, name, issueNumber, body, token) {
+    return this._post(
+      `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(name)}/issues/${issueNumber}/comments`,
+      { body },
+      token,
+    );
+  }
+
+  /**
+   * Parse a GitHub-ish input into { owner, name }.
+   * Accepts: "owner/name", "https://github.com/owner/name", "git@github.com:owner/name.git".
+   */
+  static parseRepo(input) {
+    if (!input) return null;
+    const v = String(input).trim();
+    if (!v) return null;
+    // SSH form: git@github.com:owner/name(.git)
+    const ssh = v.match(/^git@github\.com:([^/]+)\/([^/]+?)(?:\.git)?$/);
+    if (ssh) return { owner: ssh[1], name: ssh[2] };
+    // URL form
+    try {
+      const u = new URL(v);
+      if (/github\.com$/i.test(u.hostname)) {
+        const parts = u.pathname.replace(/^\//, '').replace(/\.git$/, '').split('/');
+        if (parts.length >= 2 && parts[0] && parts[1]) {
+          return { owner: parts[0], name: parts[1] };
+        }
+      }
+    } catch {
+      // not a URL — fall through
+    }
+    // Plain "owner/name"
+    const plain = v.match(/^([^/\s]+)\/([^/\s]+?)(?:\.git)?$/);
+    if (plain) return { owner: plain[1], name: plain[2] };
+    return null;
+  }
+
+  _headers(token, extra = {}) {
+    return {
+      Accept: 'application/vnd.github+json',
+      'X-GitHub-Api-Version': '2022-11-28',
+      'User-Agent': USER_AGENT,
+      Authorization: `Bearer ${token}`,
+      ...extra,
+    };
+  }
+
+  _get(urlPath, token, timeout = 20000) {
+    return this._request('GET', urlPath, null, token, timeout);
+  }
+
+  _post(urlPath, body, token, timeout = 30000) {
+    return this._request('POST', urlPath, body, token, timeout);
+  }
+
+  _request(method, urlPath, body, token, timeout) {
+    const fullUrl = this.baseUrl + urlPath;
+    const jsonBody = body == null ? null : JSON.stringify(body);
+    const headers = this._headers(token);
+    if (jsonBody != null) headers['Content-Type'] = 'application/json';
+
+    return new Promise((resolve, reject) => {
+      const req = https.request(fullUrl, { method, headers, timeout }, (res) => {
+        let data = '';
+        res.on('data', (chunk) => { data += chunk; });
+        res.on('end', () => {
+          const status = res.statusCode || 0;
+          let parsed = null;
+          try { parsed = data ? JSON.parse(data) : null; } catch { parsed = null; }
+          if (status >= 400) {
+            const msg = (parsed && (parsed.message || parsed.error)) || `HTTP ${status}`;
+            const err = new Error(`GitHub ${method} ${urlPath} failed: ${msg}`);
+            err.status = status;
+            err.body = parsed;
+            return reject(err);
+          }
+          // Attach OAuth scopes for /user probe convenience.
+          if (parsed && method === 'GET' && urlPath === '/user') {
+            const scopes = res.headers['x-oauth-scopes'];
+            if (typeof scopes === 'string') {
+              parsed.__scopes = scopes.split(',').map((s) => s.trim()).filter(Boolean);
+            }
+          }
+          resolve(parsed);
+        });
+      });
+
+      req.on('error', reject);
+      req.on('timeout', () => { req.destroy(); reject(new Error('GitHub request timed out')); });
+      if (jsonBody != null) req.write(jsonBody);
+      req.end();
+    });
+  }
+}
+
+module.exports = { GitHubClient };

package/src/index.js

@@ -6,6 +6,7 @@ const { Registry } = require('./registry');
 const { Installer } = require('./installer');
 const { Daemon } = require('./daemon');
 const { WorkspaceClient } = require('./workspace-client');
+const { GitHubClient } = require('./github-client');
 
 /**
  * Main entry point for the agent-connector library.
@@ -274,4 +275,4 @@ class AgentConnector {
 const adapters = require('./adapters');
 
 const paths = require('./paths');
-module.exports = { AgentConnector, Daemon, WorkspaceClient, adapters, paths };
+module.exports = { AgentConnector, Daemon, WorkspaceClient, GitHubClient, adapters, paths };

package/src/installer.js

@@ -433,8 +433,15 @@ class Installer {
       if (proc.stdout) proc.stdout.setEncoding('utf-8');
       if (proc.stderr) proc.stderr.setEncoding('utf-8');
 
-      if (proc.stdout) proc.stdout.on('data', (d) => { if (onData) onData(d); });
-      if (proc.stderr) proc.stderr.on('data', (d) => { if (onData) onData(d); });
+      let outputTail = '';
+      const captureOutput = (d) => {
+        const text = String(d);
+        outputTail = (outputTail + text).slice(-4000);
+        if (onData) onData(text);
+      };
+
+      if (proc.stdout) proc.stdout.on('data', captureOutput);
+      if (proc.stderr) proc.stderr.on('data', captureOutput);
 
       proc.on('error', (err) => reject(err));
       proc.on('close', (code) => {
@@ -443,7 +450,21 @@ class Installer {
           if (onData) onData(`\nDone! ${agentType} is now installed.\n`);
           resolve({ success: true, command: cmd });
         } else {
-          const msg = `Install failed with exit code ${code}`;
+          // A partial install can leave a placeholder stub at
+          // bin/<binary>.exe and npm-generated cmd-shims under
+          // node_modules/.bin/<name>{,.cmd,.ps1} that point to it. On
+          // Windows, anything that later tries to run the binary (a health
+          // check, a shell open) triggers a "this app can't run on your PC"
+          // dialog because the stub isn't a real PE executable. Sweep them
+          // up so the next install (or uninstall+reinstall) starts clean.
+          try {
+            this._cleanStaleShims(agentType);
+            this._cleanStubBinary(agentType);
+          } catch {}
+          const tail = outputTail.trim();
+          const msg = tail
+            ? `Install failed with exit code ${code}\nCommand: ${cmd}\n\n${tail}`
+            : `Install failed with exit code ${code}\nCommand: ${cmd}`;
           if (onData) onData(`\n${msg}\n`);
           reject(new Error(msg));
         }
@@ -451,6 +472,35 @@ class Installer {
     });
   }
 
+  /**
+   * Remove the placeholder bin/<binary>.exe (and the npm package directory
+   * if it's effectively empty) left over from a failed postinstall.
+   */
+  _cleanStubBinary(agentType) {
+    const entry = this.registry.getEntry(agentType);
+    const install = entry && entry.install;
+    if (!install) return;
+    const binary = install.binary || agentType;
+    const npmPkg = install.npm_package
+      || (() => {
+          const cmd = this._getInstallCommand(install);
+          if (!cmd || !cmd.includes('npm install')) return null;
+          const m = cmd.match(/npm install\s+(?:-g\s+)?(@?[\w-]+(?:\/[\w-]+)?)(?:@\S*)?$/);
+          return m ? m[1] : null;
+        })();
+    if (!npmPkg) return;
+
+    const prefix = getRuntimePrefix(agentType);
+    const pkgDir = path.join(prefix, 'node_modules', npmPkg);
+    const stubDir = path.join(pkgDir, 'bin');
+    for (const ext of ['', '.exe', '.cmd', '.ps1']) {
+      try {
+        const f = path.join(stubDir, binary + ext);
+        if (fs.existsSync(f) && fs.statSync(f).size < 4096) fs.unlinkSync(f);
+      } catch {}
+    }
+  }
+
   /**
    * Uninstall an agent runtime.
    * @returns {Promise<{success: boolean, output: string}>}
@@ -566,7 +616,7 @@ class Installer {
    */
   _getInstallCommand(installCfg) {
     const plat = Installer.platform();
-    return installCfg[plat] || installCfg.command || null;
+    return installCfg[plat] || installCfg.command || installCfg.npm || null;
   }
 
   /**
@@ -608,7 +658,14 @@ class Installer {
   _whichBinary(agentType) {
     const entry = this.registry.getEntry(agentType);
     const binary = entry && entry.install ? entry.install.binary : agentType;
-    return whichBinary(binary);
+    const aliases = entry && entry.install && Array.isArray(entry.install.binary_aliases)
+      ? entry.install.binary_aliases
+      : [];
+    for (const candidate of [binary, ...aliases]) {
+      const found = whichBinary(candidate);
+      if (found) return found;
+    }
+    return null;
   }
 
   // -- Markers --
@@ -680,28 +737,58 @@ class Installer {
     const extraDirs = [];
     try { extraDirs.push(path.dirname(process.execPath)); } catch {}
 
-    // Check for bundled Node.js in ~/.openagents/nodejs/
+    // Whether a usable `node` is already reachable WITHOUT the bundled
+    // standalone node.exe. We must avoid shadowing a working system node with
+    // the launcher's bundled exe: that file is an unsigned standalone
+    // node.exe and on some Windows machines Defender/SmartScreen blocks
+    // CreateProcess on it, which surfaces as `cmd: 拒绝访问` ("Access
+    // Denied") when npm runs `node install.cjs` for packages like
+    // @anthropic-ai/claude-code, plus a "this app can't run on your PC"
+    // dialog.
+    const bundledDir = path.join(this.configDir, 'nodejs');
+    const hasSystemNode = this._hasSystemNode(bundledDir);
+
     if (process.platform === 'win32') {
-      try {
-        const bundledDir = path.join(this.configDir, 'nodejs');
-        if (fs.existsSync(bundledDir)) {
-          // Node.js may be directly in nodejs/ (launcher symlink style) or in nodejs/node-v*/
-          if (fs.existsSync(path.join(bundledDir, 'node.exe'))) {
-            extraDirs.push(bundledDir);
-          }
-          const entries = fs.readdirSync(bundledDir).filter(e => e.startsWith('node-'));
-          if (entries.length > 0) {
-            extraDirs.push(path.join(bundledDir, entries[0]));
-          }
-        }
-      } catch {}
       const appData = env.APPDATA || '';
       if (appData) extraDirs.push(path.join(appData, 'npm'));
       extraDirs.push(env.ProgramFiles ? path.join(env.ProgramFiles, 'nodejs') : 'C:\\Program Files\\nodejs');
       extraDirs.push(env.SystemRoot ? path.join(env.SystemRoot, 'System32') : 'C:\\Windows\\System32');
       extraDirs.push(env.ProgramFiles ? path.join(env.ProgramFiles, 'Git', 'cmd') : 'C:\\Program Files\\Git\\cmd');
+
+      // Bundled node — fallback only. Skip if system node works, otherwise
+      // verify the bundled exe can actually launch before exposing it.
+      if (!hasSystemNode) {
+        try {
+          if (fs.existsSync(bundledDir)) {
+            const directExe = path.join(bundledDir, 'node.exe');
+            if (fs.existsSync(directExe) && this._canExecute(directExe)) {
+              extraDirs.unshift(bundledDir);
+            }
+            for (const entry of fs.readdirSync(bundledDir).filter(e => e.startsWith('node-'))) {
+              const nested = path.join(bundledDir, entry);
+              if (fs.existsSync(path.join(nested, 'node.exe')) && this._canExecute(path.join(nested, 'node.exe'))) {
+                extraDirs.unshift(nested);
+              }
+            }
+          }
+        } catch {}
+      }
     } else {
       extraDirs.push('/usr/local/bin', '/opt/homebrew/bin');
+      if (!hasSystemNode) {
+        try {
+          const candidates = [
+            path.join(bundledDir, 'bin', 'node'),
+            path.join(bundledDir, 'node'),
+          ];
+          for (const bin of candidates) {
+            if (fs.existsSync(bin) && this._canExecute(bin)) {
+              extraDirs.unshift(path.dirname(bin));
+              break;
+            }
+          }
+        } catch {}
+      }
     }
     for (const d of extraDirs) {
       if (d && !(env.PATH || '').includes(d)) {
@@ -711,6 +798,51 @@ class Installer {
     return env;
   }
 
+  /**
+   * True if `node` exists outside the bundled launcher directory. Uses raw
+   * process.env.PATH (no enhancement) so we don't accidentally detect the
+   * bundled node and conclude that "system node exists".
+   */
+  _hasSystemNode(bundledDir) {
+    try {
+      const { execFileSync } = require('child_process');
+      const cmd = process.platform === 'win32' ? 'where' : 'which';
+      const args = process.platform === 'win32' ? ['node'] : ['node'];
+      const out = execFileSync(cmd, args, {
+        encoding: 'utf-8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+        timeout: 5000,
+        windowsHide: true,
+        env: { ...process.env },
+      });
+      const prefix = (bundledDir || '').toLowerCase();
+      for (const line of out.split(/\r?\n/).map(s => s.trim()).filter(Boolean)) {
+        if (!prefix || !line.toLowerCase().startsWith(prefix)) return true;
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Smoke-test a node binary by running `--version`. Returns false on any
+   * failure (missing exe, blocked by AV, arch mismatch, signature policy).
+   */
+  _canExecute(binaryPath) {
+    try {
+      const { spawnSync } = require('child_process');
+      const r = spawnSync(binaryPath, ['--version'], {
+        timeout: 5000,
+        windowsHide: true,
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+      return r.status === 0 && !r.error;
+    } catch {
+      return false;
+    }
+  }
+
   /**
    * Check if Node.js/npm is available on the system.
    */

package/src/mcp-server.js

@@ -301,21 +301,26 @@ function buildToolDefs(disabledModules) {
     },
     {
       name: 'workspace_create_routine',
-      description: 'Create a recurring scheduled routine that posts a message on a repeating schedule.',
+      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: 'Message to post each time the routine fires' },
-          hour: { type: 'integer', description: 'Hour in UTC (0-23)' },
-          minute: { type: 'integer', description: 'Minute (0-59)' },
+          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: 'Days of week to fire (0=Mon, 6=Sun). Omit for every day.',
+            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.',
           },
         },
-        required: ['name', 'message', 'hour', 'minute'],
+        required: ['name', 'message', 'context'],
       },
     },
     {
@@ -760,25 +765,41 @@ class McpServer {
           {
             name: args.name,
             message: args.message,
+            context: args.context,
             hour: args.hour,
             minute: args.minute,
             days: args.days,
+            interval_minutes: args.interval_minutes,
             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})`);
+        let scheduleStr;
+        if (args.interval_minutes != null) {
+          scheduleStr = `every ${args.interval_minutes} min`;
+        } else {
+          const daysStr = args.days ? `days [${args.days.join(',')}]` : 'every day';
+          scheduleStr = `at ${String(args.hour).padStart(2,'0')}:${String(args.minute).padStart(2,'0')} UTC, ${daysStr}`;
+        }
+        const channel = (result && result.channel_name) || `routine:${result.id}`;
+        return text(
+          `Routine created: "${args.name}" ${scheduleStr} in dedicated thread \`${channel}\` (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})`
-        );
+        const lines = routines.map((r) => {
+          let when;
+          if (r.schedule_interval_minutes != null) {
+            when = `every ${r.schedule_interval_minutes} min`;
+          } else {
+            when = `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)');
+          }
+          return `- ${r.id}: "${r.name}" ${when} — next: ${r.next_fires_at} (by ${r.created_by})`;
+        });
         return text(lines.join('\n'));
       }
 

package/src/paths.js

@@ -16,12 +16,25 @@ const IS_WINDOWS = process.platform === 'win32';
 const IS_MACOS = process.platform === 'darwin';
 const SEP = IS_WINDOWS ? ';' : ':';
 const HOME = process.env.HOME || process.env.USERPROFILE || '';
+const PATH_LOOKUP_CACHE_TTL_MS = 30 * 1000;
+
+let extraBinDirsCache = { value: null, at: 0, path: '' };
+const whichBinaryCache = new Map();
 
 /**
  * Get all extra binary directories that should be checked beyond process.env.PATH.
  * Returns deduplicated list of existing directories.
  */
 function getExtraBinDirs() {
+  const currentPATH = process.env.PATH || '';
+  if (
+    extraBinDirsCache.value &&
+    extraBinDirsCache.path === currentPATH &&
+    Date.now() - extraBinDirsCache.at < PATH_LOOKUP_CACHE_TTL_MS
+  ) {
+    return [...extraBinDirsCache.value];
+  }
+
   const dirs = [];
 
   if (IS_WINDOWS) {
@@ -62,8 +75,7 @@ function getExtraBinDirs() {
 
   // Filter to existing directories only, deduplicate
   const seen = new Set();
-  const currentPATH = process.env.PATH || '';
-  return dirs.filter(d => {
+  const value = dirs.filter(d => {
     if (!d || seen.has(d)) return false;
     // Skip if already in PATH (case-insensitive on Windows)
     if (IS_WINDOWS ? currentPATH.toLowerCase().includes(d.toLowerCase()) : currentPATH.includes(d)) return false;
@@ -74,6 +86,8 @@ function getExtraBinDirs() {
       return false;
     }
   });
+  extraBinDirsCache = { value, at: Date.now(), path: currentPATH };
+  return [...value];
 }
 
 /**
@@ -114,6 +128,13 @@ function getEnhancedEnv(baseEnv) {
  */
 function whichBinary(name) {
   if (!name) return null;
+  const currentPATH = process.env.PATH || '';
+  const cacheKey = `${name}\0${currentPATH}`;
+  const cached = whichBinaryCache.get(cacheKey);
+  if (cached && Date.now() - cached.at < PATH_LOOKUP_CACHE_TTL_MS) {
+    return cached.value;
+  }
+
   const cmd = IS_WINDOWS ? `where ${name}` : `which ${name}`;
   try {
     const result = execSync(cmd, {
@@ -121,9 +142,13 @@ function whichBinary(name) {
       stdio: ['pipe', 'pipe', 'pipe'],
       env: { ...process.env, PATH: getEnhancedPATH() },
       timeout: 5000,
+      windowsHide: true,
     }).trim();
-    return result.split(/\r?\n/)[0] || null;
+    const value = result.split(/\r?\n/)[0] || null;
+    whichBinaryCache.set(cacheKey, { value, at: Date.now() });
+    return value;
   } catch {
+    whichBinaryCache.set(cacheKey, { value: null, at: Date.now() });
     return null;
   }
 }
@@ -154,6 +179,9 @@ function _addWindowsPaths(dirs) {
   // Portable Node.js installed by OpenAgents Launcher
   _push(dirs, path.join(HOME, '.openagents', 'nodejs'));
 
+  // Cursor CLI native installer
+  _push(dirs, path.join(HOME, '.cursor', 'bin'));
+
   // Node.js install
   _push(dirs, path.join(programFiles, 'nodejs'));
 

package/src/registry.js

@@ -85,7 +85,7 @@ class Registry {
 
   /**
    * Merge bundled env_config/resolve_env/install into catalog entries.
-   * Remote/cached entries may lack these fields.
+   * Remote/cached entries may lack these fields or carry stale install data.
    */
   _mergeBundled(catalog) {
     const bundled = this._loadBundled();
@@ -94,7 +94,7 @@ class Registry {
       if (b) {
         if ((!entry.env_config || entry.env_config.length === 0) && b.env_config && b.env_config.length > 0) entry.env_config = b.env_config;
         if (!entry.resolve_env && b.resolve_env) entry.resolve_env = b.resolve_env;
-        if (!entry.install && b.install) entry.install = b.install;
+        if (b.install) entry.install = { ...b.install };
         if (!entry.check_ready && b.check_ready) entry.check_ready = b.check_ready;
         if (!entry.launch && b.launch) entry.launch = b.launch;
         // Always take featured/order/support from bundled (source of truth for ordering)
@@ -136,11 +136,11 @@ class Registry {
     const catalog = this.getCatalogSync();
     const entry = catalog.find((e) => e.name === agentType) || null;
     if (!entry) return null;
-    // Merge missing fields from bundled registry
+    // Merge bundled registry fields into cached/remote entries.
     const bundled = this._loadBundled();
     const b = bundled.find((e) => e.name === agentType);
     if (b) {
-      if (!entry.install && b.install) entry.install = b.install;
+      if (b.install) entry.install = { ...b.install };
       if (!entry.check_ready && b.check_ready) entry.check_ready = b.check_ready;
       if (!entry.launch && b.launch) entry.launch = b.launch;
       if ((!entry.env_config || !entry.env_config.length) && b.env_config?.length) entry.env_config = b.env_config;

package/src/tui.js

@@ -120,25 +120,10 @@ function describeHealth(health) {
 }
 
 function loadCatalog(connector) {
-  const { execSync } = require('child_process');
   const entries = connector.registry.getCatalogSync();
   return entries.map(e => {
     let installed = false;
-
-    // If a verify command exists, use it for accurate detection
-    const verifyCmd = IS_WINDOWS ? (e.install && e.install.verify_win) : (e.install && e.install.verify);
-    if (verifyCmd) {
-      try { execSync(verifyCmd, { stdio: 'ignore', timeout: 5000 }); installed = true; } catch {}
-    } else {
-      try { const { whichBinary } = require('./paths'); installed = !!whichBinary((e.install && e.install.binary) || e.name); } catch {}
-    }
-
-    if (!installed) {
-      try {
-        const f = path.join(connector._configDir, 'installed_agents.json');
-        if (fs.existsSync(f)) installed = !!JSON.parse(fs.readFileSync(f, 'utf-8'))[e.name];
-      } catch {}
-    }
+    try { installed = !!connector.installer.getInstallInfo(e.name).installed; } catch {}
     return {
       name: e.name,
       label: e.label || e.name,

package/src/workspace-client.js

@@ -271,7 +271,7 @@ class WorkspaceClient {
    * Poll for pending messages targeted at an agent via GET /v1/events.
    * Returns { messages, cursor } where cursor is the last event ID.
    */
-  async pollPending(workspaceId, agentName, token, { after, limit = 50 } = {}) {
+  async pollPending(workspaceId, agentName, token, { after, limit = 500 } = {}) {
     const params = new URLSearchParams({
       network: workspaceId,
       type: 'workspace.message.posted',
@@ -333,7 +333,28 @@ class WorkspaceClient {
       }
     }
 
-    return { messages, cursor };
+    const composing = !!(result && result.composing);
+    return { messages, cursor, composing };
+  }
+
+  /**
+   * Get the workspace's top-level metadata via GET /v1/workspaces/{id}.
+   *
+   * Returns the full data block from the backend — adapters care about
+   * `browserEnabled` today, but more keys may be surfaced over time. On
+   * error, returns null so callers can fall back to defaults rather than
+   * crashing.
+   */
+  async getWorkspaceMetadata(workspaceId, token) {
+    try {
+      const data = await this._get(
+        `/v1/workspaces/${workspaceId}`,
+        this._wsHeaders(token),
+      );
+      return data.data || data || {};
+    } catch {
+      return null;
+    }
   }
 
   /**
@@ -606,17 +627,22 @@ class WorkspaceClient {
 
   // ── Routines ──
 
-  async createRoutine(workspaceId, channelName, token, { name, message, hour, minute, days, source } = {}) {
+  async createRoutine(workspaceId, channelName, token, { name, message, context, hour, minute, days, interval_minutes, source } = {}) {
     const body = {
       name,
       message,
-      hour,
-      minute,
+      context: context || '',
       network: workspaceId,
       channel: channelName,
       source: source || 'openagents:unknown',
     };
-    if (days) body.days = days;
+    if (interval_minutes != null) {
+      body.interval_minutes = interval_minutes;
+    } else {
+      body.hour = hour;
+      body.minute = minute;
+      if (days) body.days = days;
+    }
     const data = await this._post('/v1/routines', body, this._wsHeaders(token));
     return data.data || data;
   }