@openagents-org/agent-launcher 0.2.134 → 0.2.136

package/icons/hermes.svg

@@ -0,0 +1 @@
+<svg fill="currentColor" viewBox="0 0 24 24" width="1em" height="1em" xmlns="http://www.w3.org/2000/svg"><title>Hermes</title><circle cx="12" cy="3.5" r="1.75"/><path d="M11 6h2v16h-2z"/><path d="M13 7.5c2.5 0 4.5-1.2 5.8-2.8l1.4 1c-1.6 2-4.2 3.5-7.2 3.5V7.5zM11 7.5c-2.5 0-4.5-1.2-5.8-2.8l-1.4 1C5.4 7.7 8 9.2 11 9.2V7.5z"/><path d="M13 12.5c2.2 0 4-1 5.3-2.5l1.4 1c-1.6 1.8-3.8 3.2-6.7 3.2v-1.7zM11 12.5c-2.2 0-4-1-5.3-2.5l-1.4 1C5.9 13.3 8.1 14.7 11 14.7v-1.7z"/></svg>

package/package.json

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

package/registry.json

@@ -537,23 +537,6 @@
       "not_ready_message": "Not configured \u2014 press e to configure"
     }
   },
-  {
-    "name": "swebench",
-    "label": "SWE-bench Agent",
-    "description": "Language model agent for software engineering tasks",
-    "homepage": "https://swe-agent.com",
-    "tags": [
-      "coding",
-      "benchmarks",
-      "research"
-    ],
-    "install": {
-      "binary": "sweagent",
-      "macos": "pip install sweagent",
-      "linux": "pip install sweagent",
-      "windows": "pip install sweagent"
-    }
-  },
   {
     "name": "kimi",
     "label": "Kimi",
@@ -633,7 +616,7 @@
       "requires": ["python3"],
       "macos": "curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash -s -- --skip-setup",
       "linux": "curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash -s -- --skip-setup",
-      "windows": "echo 'Hermes requires WSL2 on Windows — see https://github.com/NousResearch/hermes-agent'"
+      "windows": "wsl.exe -e bash -lc \"curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash -s -- --skip-setup\""
     },
     "launch": {
       "args": []

package/src/adapters/base.js

@@ -19,6 +19,7 @@
 
 const { WorkspaceClient, SessionRevokedError } = require('../workspace-client');
 const { generateSessionTitle, SESSION_DEFAULT_RE } = require('./utils');
+const { defaultAgentWorkdir } = require('../paths');
 
 const DEFAULT_ENDPOINT = 'https://workspace-endpoint.openagents.org';
 
@@ -82,7 +83,7 @@ class BaseAdapter {
         network: this.workspaceId,
         agentType: this.agentType || 'agent',
         serverHost: require('os').hostname(),
-        workingDir: this.workingDir || process.cwd(),
+        workingDir: this.workingDir || defaultAgentWorkdir(this.agentName),
       });
       this._sessionId = (joinResult && joinResult.session_id) || null;
       this._log(`Joined workspace ${this.workspaceId}${this._sessionId ? ` (session ${this._sessionId.slice(0, 8)})` : ''}`);
@@ -253,7 +254,7 @@ class BaseAdapter {
       this._log('skill.install: missing skill metadata in payload — ignoring');
       return;
     }
-    this._log(`skill.install: starting install of "${skillId}" (type=${this.agentType}, dir=${this.workingDir || process.cwd()})`);
+    this._log(`skill.install: starting install of "${skillId}" (type=${this.agentType}, dir=${this.workingDir || defaultAgentWorkdir(this.agentName)})`);
 
     // Best-effort "installing" ping so the UI flips immediately even if the
     // initial DB write from the request hasn't propagated to this client.

package/src/adapters/claude.js

@@ -19,6 +19,7 @@ const { execSync, spawn } = require('child_process');
 const BaseAdapter = require('./base');
 const { formatAttachmentsForPrompt, SESSION_DEFAULT_RE, generateSessionTitle } = require('./utils');
 const { buildClaudeSystemPrompt, buildClaudeSkillMd } = require('./workspace-prompt');
+const { defaultAgentWorkdir, whichBinary, getEnhancedEnv } = require('../paths');
 
 const IS_WINDOWS = process.platform === 'win32';
 
@@ -38,6 +39,8 @@ class ClaudeAdapter extends BaseAdapter {
     this._stoppingChannels = new Set();
     this._persistentProcs = {}; // channel → { proc, lineBuffer, pendingLines, idleTimer, messageResolve }
     this._IDLE_TIMEOUT_MS = 60 * 60 * 1000; // 1 hour
+    this._WATCHDOG_INTERVAL_MS = 15_000; // 15s between checks
+    this._WATCHDOG_MAX_TIMEOUTS = 20;    // 20 * 15s = 5 min of silence → kill
     this._sessionsFile = path.join(
       os.homedir(), '.openagents', 'sessions',
       `${this.workspaceId}_${this.agentName}.json`
@@ -330,15 +333,22 @@ class ClaudeAdapter extends BaseAdapter {
     const portableCandidate = path.join(portableBin, `claude${ext}`);
     if (fs.existsSync(portableCandidate)) return portableCandidate;
 
-    // Tier 1: PATH search
+    // Tier 1: PATH search. Use the ENRICHED env so the lookup sees the same
+    // node-version-manager / homebrew / npm-global dirs the launcher adds —
+    // a packaged Electron daemon's own PATH is minimal, which is why `which
+    // claude` came up empty and the agent reported "claude CLI not found".
+    // windowsHide stops a console window from flashing.
     try {
+      const env = getEnhancedEnv();
       if (IS_WINDOWS) {
         const r = execSync('where claude.cmd 2>nul || where claude.exe 2>nul || where claude 2>nul', {
-          encoding: 'utf-8', timeout: 5000,
+          encoding: 'utf-8', timeout: 5000, windowsHide: true, env,
         });
-        return r.split(/\r?\n/)[0].trim();
+        const hit = r.split(/\r?\n/)[0].trim();
+        if (hit) return hit;
       } else {
-        return execSync('which claude', { encoding: 'utf-8', timeout: 5000 }).trim();
+        const hit = execSync('which claude', { encoding: 'utf-8', timeout: 5000, windowsHide: true, env }).trim();
+        if (hit) return hit;
       }
     } catch {}
 
@@ -352,6 +362,7 @@ class ClaudeAdapter extends BaseAdapter {
       path.join(process.env.APPDATA || '', 'npm', 'claude.cmd'),
     ] : [
       path.join(home, '.local', 'bin', 'claude'),
+      path.join(home, '.claude', 'local', 'claude'),
       path.join(home, '.npm-global', 'bin', 'claude'),
       '/opt/homebrew/bin/claude',
       '/usr/local/bin/claude',
@@ -360,6 +371,13 @@ class ClaudeAdapter extends BaseAdapter {
       if (fs.existsSync(c)) return c;
     }
 
+    // Tier 4: Deep scan of every known bin dir (nvm/fnm/volta node-global,
+    // homebrew, cargo, pip, …). This is what catches a `claude` installed as a
+    // global npm package under a version-managed Node — the most common setup,
+    // and the one the fixed-PATH tiers above miss.
+    const viaWhich = whichBinary('claude');
+    if (viaWhich) return viaWhich;
+
     return null;
   }
 
@@ -425,8 +443,10 @@ class ClaudeAdapter extends BaseAdapter {
       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();
+    // Write SKILL.md to .claude/skills/ in the working directory. Never use
+    // process.cwd() as the fallback — on a packaged Windows daemon that is
+    // C:\WINDOWS\system32 and mkdir there throws EPERM.
+    const workDir = this.workingDir || defaultAgentWorkdir(this.agentName);
     const skillDir = path.join(workDir, '.claude', 'skills');
     fs.mkdirSync(skillDir, { recursive: true });
     const skillFile = path.join(skillDir, 'openagents-workspace.md');
@@ -579,6 +599,7 @@ class ClaudeAdapter extends BaseAdapter {
     const pp = this._persistentProcs[channel];
     if (!pp) return;
     if (pp.idleTimer) clearTimeout(pp.idleTimer);
+    this._stopWatchdog(pp);
     this._stopProcess(pp.proc).catch(() => {});
     delete this._persistentProcs[channel];
   }
@@ -597,6 +618,49 @@ class ClaudeAdapter extends BaseAdapter {
     }, this._IDLE_TIMEOUT_MS);
   }
 
+  /**
+   * Start a watchdog that kills the persistent process if stdout goes
+   * silent for too long while a message is in flight.  Pauses during
+   * tool execution (awaitingToolResult) since long-running commands
+   * like builds or sleep produce no stdout legitimately.
+   */
+  _startWatchdog(pp) {
+    this._stopWatchdog(pp);
+    pp.lastStdoutTime = Date.now();
+    let consecutiveTimeouts = 0;
+
+    pp.watchdogTimer = setInterval(async () => {
+      if (!pp.messageResolve) { consecutiveTimeouts = 0; return; }
+      if (pp.awaitingToolResult) { consecutiveTimeouts = 0; return; }
+
+      const elapsed = Date.now() - pp.lastStdoutTime;
+      if (elapsed < this._WATCHDOG_INTERVAL_MS) { consecutiveTimeouts = 0; return; }
+
+      consecutiveTimeouts++;
+      pp.lastStdoutTime = Date.now();
+
+      if (consecutiveTimeouts === 2) {
+        try { await this.sendStatus(pp.msgChannel, 'Still processing...'); } catch {}
+      }
+
+      if (consecutiveTimeouts >= this._WATCHDOG_MAX_TIMEOUTS) {
+        this._log(`Watchdog: process unresponsive for ${consecutiveTimeouts * 15}s on ${pp.msgChannel} — killing`);
+        this._stopWatchdog(pp);
+        try { await this.sendError(pp.msgChannel, 'Agent process became unresponsive and was restarted.'); } catch {}
+        if (pp.messageResolve) {
+          const resolve = pp.messageResolve;
+          pp.messageResolve = null;
+          resolve({ exited: true, error: new Error('watchdog timeout') });
+        }
+        this._killPersistentProc(pp.msgChannel);
+      }
+    }, this._WATCHDOG_INTERVAL_MS);
+  }
+
+  _stopWatchdog(pp) {
+    if (pp.watchdogTimer) { clearInterval(pp.watchdogTimer); pp.watchdogTimer = null; }
+  }
+
   /**
    * Spawn a persistent Claude process for a channel that accepts messages
    * via stdin (--input-format stream-json). Returns the persistent proc entry.
@@ -651,6 +715,9 @@ class ClaudeAdapter extends BaseAdapter {
       everPostedAnything: false,
       stderrBuf: '',
       alive: true,
+      lastStdoutTime: Date.now(),
+      watchdogTimer: null,
+      awaitingToolResult: false,
     };
 
     if (proc.stderr) {
@@ -665,6 +732,7 @@ class ClaudeAdapter extends BaseAdapter {
       const eventType = event.type;
 
       if (eventType === 'assistant') {
+        pp.awaitingToolResult = false;
         const blocks = (event.message || {}).content || [];
         for (const block of blocks) {
           if (block.type === 'text' && block.text && block.text.trim()) {
@@ -680,6 +748,7 @@ class ClaudeAdapter extends BaseAdapter {
             pp.hasToolUseSinceLastText = true;
             pp.postedThinking = false;
             pp.lastResponseText.length = 0;
+            pp.awaitingToolResult = true;
             const toolName = block.name || '';
             if (toolName === 'TodoWrite' && block.input && block.input.todos) {
               try {
@@ -707,6 +776,7 @@ class ClaudeAdapter extends BaseAdapter {
           }
         }
       } else if (eventType === 'result') {
+        pp.awaitingToolResult = false;
         const sessionId = event.session_id;
         if (sessionId) {
           this._channelSessions[pp.msgChannel] = sessionId;
@@ -732,6 +802,7 @@ class ClaudeAdapter extends BaseAdapter {
 
     proc.stdout.on('data', (chunk) => {
       pp.lineBuffer += chunk.toString('utf-8');
+      pp.lastStdoutTime = Date.now();
       const lines = pp.lineBuffer.split('\n');
       pp.lineBuffer = lines.pop();
       for (const line of lines) {
@@ -743,6 +814,7 @@ class ClaudeAdapter extends BaseAdapter {
       this._log(`Persistent process exited: channel=${channel} code=${code}`);
       pp.alive = false;
       if (pp.idleTimer) clearTimeout(pp.idleTimer);
+      this._stopWatchdog(pp);
       if (pp.messageResolve) {
         pp.messageResolve({ exited: true, code });
         pp.messageResolve = null;
@@ -754,6 +826,7 @@ class ClaudeAdapter extends BaseAdapter {
     proc.on('error', (err) => {
       this._log(`Persistent process error: ${err.message}`);
       pp.alive = false;
+      this._stopWatchdog(pp);
       if (pp.messageResolve) {
         pp.messageResolve({ exited: true, error: err });
         pp.messageResolve = null;
@@ -777,6 +850,7 @@ class ClaudeAdapter extends BaseAdapter {
     pp.hasToolUseSinceLastText = false;
     pp.postedThinking = false;
     pp.everPostedAnything = false;
+    pp.awaitingToolResult = false;
 
     const stdinMsg = JSON.stringify({
       type: 'user',
@@ -787,11 +861,18 @@ class ClaudeAdapter extends BaseAdapter {
     }) + '\n';
 
     return new Promise((resolve) => {
-      pp.messageResolve = resolve;
+      pp.messageResolve = (result) => {
+        this._stopWatchdog(pp);
+        resolve(result);
+      };
+      pp.lastStdoutTime = Date.now();
+      this._startWatchdog(pp);
       try {
         pp.proc.stdin.write(stdinMsg);
       } catch (e) {
         this._log(`stdin write failed: ${e.message}`);
+        this._stopWatchdog(pp);
+        pp.messageResolve = null;
         resolve({ exited: true, error: e });
       }
     });
@@ -946,7 +1027,7 @@ class ClaudeAdapter extends BaseAdapter {
 
         if (this._mode === 'plan') {
           try {
-            const planDir = path.join(this.workingDir || process.cwd(), '.claude', 'plans');
+            const planDir = path.join(this.workingDir || defaultAgentWorkdir(this.agentName), '.claude', 'plans');
             if (fs.existsSync(planDir)) {
               const planFiles = fs.readdirSync(planDir)
                 .filter((f) => f.endsWith('.md'))

package/src/adapters/cursor.js

@@ -17,6 +17,7 @@ const { execSync, spawn } = require('child_process');
 const BaseAdapter = require('./base');
 const { formatAttachmentsForPrompt, SESSION_DEFAULT_RE, generateSessionTitle } = require('./utils');
 const { buildCursorSkillMd } = require('./workspace-prompt');
+const { defaultAgentWorkdir, whichBinary, getEnhancedEnv } = require('../paths');
 
 const IS_WINDOWS = process.platform === 'win32';
 
@@ -185,15 +186,22 @@ class CursorAdapter extends BaseAdapter {
       if (fs.existsSync(portableCandidate)) return portableCandidate;
     }
 
-    // Tier 1: PATH search
+    // Tier 1: PATH search. Use the ENRICHED env so the lookup sees the dirs the
+    // launcher adds — a freshly-run cursor installer updates the *user* PATH,
+    // which the daemon's already-running process won't see, so `where` against
+    // the daemon's own PATH comes up empty even though cursor-agent is installed.
+    // windowsHide stops a console window from flashing.
     try {
+      const env = getEnhancedEnv();
       if (IS_WINDOWS) {
         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,
+          encoding: 'utf-8', timeout: 5000, windowsHide: true, env,
         });
-        return r.split(/\r?\n/)[0].trim();
+        const hit = r.split(/\r?\n/)[0].trim();
+        if (hit) return hit;
       } else {
-        return execSync('which cursor-agent || which agent', { encoding: 'utf-8', timeout: 5000 }).trim();
+        const hit = execSync('which cursor-agent || which agent', { encoding: 'utf-8', timeout: 5000, windowsHide: true, env }).trim();
+        if (hit) return hit;
       }
     } catch {}
 
@@ -207,6 +215,17 @@ class CursorAdapter extends BaseAdapter {
     // Tier 3: Common install locations
     const localAppData = process.env.LOCALAPPDATA || path.join(home, 'AppData', 'Local');
     const candidates = IS_WINDOWS ? [
+      // The Windows installer (install?win32=true) drops cursor-agent under the
+      // user home's .local/bin — the same place the Unix installer uses. This
+      // was missing, so a successful install was invisible to the launcher.
+      path.join(home, '.local', 'bin', 'cursor-agent.exe'),
+      path.join(home, '.local', 'bin', 'cursor-agent.cmd'),
+      path.join(home, '.local', 'bin', 'cursor-agent'),
+      path.join(home, '.local', 'bin', 'agent.exe'),
+      path.join(home, '.local', 'bin', 'agent.cmd'),
+      // Older/alternate layout: %LOCALAPPDATA%\Programs\cursor-agent\.
+      path.join(localAppData, 'Programs', 'cursor-agent', 'cursor-agent.exe'),
+      path.join(localAppData, 'Programs', 'cursor-agent', 'agent.exe'),
       // Windows native installer (install?win32=true) drops the CLI here.
       path.join(localAppData, 'cursor-agent', 'cursor-agent.cmd'),
       path.join(localAppData, 'cursor-agent', 'cursor-agent.exe'),
@@ -236,6 +255,12 @@ class CursorAdapter extends BaseAdapter {
       if (fs.existsSync(c)) return c;
     }
 
+    // Tier 4: Deep scan of every known bin dir (nvm/fnm/volta, homebrew, …).
+    for (const name of names) {
+      const viaWhich = whichBinary(name);
+      if (viaWhich) return viaWhich;
+    }
+
     return null;
   }
 
@@ -277,7 +302,9 @@ class CursorAdapter extends BaseAdapter {
   // ── Skill file writing ──
 
   _writeSkillFile(channelName) {
-    const workDir = this.workingDir || process.cwd();
+    // Never fall back to process.cwd() (C:\WINDOWS\system32 on a packaged
+    // Windows daemon → EPERM); use a writable per-agent dir under ~/.openagents.
+    const workDir = this.workingDir || defaultAgentWorkdir(this.agentName);
     const skillDir = path.join(workDir, '.cursor', 'skills');
     fs.mkdirSync(skillDir, { recursive: true });
     const skillFile = path.join(skillDir, 'openagents-workspace.md');

package/src/adapters/hermes.js

@@ -21,6 +21,7 @@ const { execSync, spawn } = require('child_process');
 
 const BaseAdapter = require('./base');
 const { buildOpenclawSystemPrompt } = require('./workspace-prompt');
+const { whichBinary, getEnhancedEnv } = require('../paths');
 
 const IS_WINDOWS = process.platform === 'win32';
 const SESSION_ID_RE = /session_id:\s*(\S+)/;
@@ -65,22 +66,39 @@ class HermesAdapter extends BaseAdapter {
 
   _findHermesBinary() {
     const home = os.homedir();
+    // Reset each call. When set, this._hermesBin is a path INSIDE WSL and must
+    // be invoked as `wsl -e <path> …` rather than spawned natively.
+    this._hermesViaWsl = false;
 
-    // Tier 1: PATH
+    // Tier 1: PATH (enriched env so we see the dirs the launcher adds; a fresh
+    // install updates the user PATH, which the running daemon won't pick up).
+    // windowsHide stops a console window from flashing.
     try {
+      const env = getEnhancedEnv();
       if (IS_WINDOWS) {
         // Native Windows unsupported upstream — we try anyway for WSL cases
-        const r = execSync('where hermes 2>nul', { encoding: 'utf-8', timeout: 5000 });
+        const r = execSync('where hermes.exe 2>nul || where hermes.cmd 2>nul || where hermes 2>nul', {
+          encoding: 'utf-8', timeout: 5000, windowsHide: true, env,
+        });
         const found = r.split(/\r?\n/)[0].trim();
         if (found) return found;
       } else {
-        const found = execSync('which hermes', { encoding: 'utf-8', timeout: 5000 }).trim();
+        const found = execSync('which hermes', { encoding: 'utf-8', timeout: 5000, windowsHide: true, env }).trim();
         if (found) return found;
       }
     } catch {}
 
-    // Tier 2: Common install locations (hermes installer uses ~/.local/bin)
-    const candidates = IS_WINDOWS ? [] : [
+    // Tier 2: Common install locations. The installer drops `hermes` in
+    // ~/.local/bin and (on Windows) ~/.hermes/bin.
+    const candidates = IS_WINDOWS ? [
+      path.join(home, '.hermes', 'bin', 'hermes.exe'),
+      path.join(home, '.hermes', 'bin', 'hermes.cmd'),
+      path.join(home, '.hermes', 'bin', 'hermes'),
+      path.join(home, '.local', 'bin', 'hermes.exe'),
+      path.join(home, '.local', 'bin', 'hermes.cmd'),
+      path.join(home, '.local', 'bin', 'hermes'),
+    ] : [
+      path.join(home, '.hermes', 'bin', 'hermes'),
       path.join(home, '.local', 'bin', 'hermes'),
       '/opt/homebrew/bin/hermes',
       '/usr/local/bin/hermes',
@@ -89,6 +107,40 @@ class HermesAdapter extends BaseAdapter {
       if (fs.existsSync(c)) return c;
     }
 
+    // Tier 3: Deep scan of every known bin dir.
+    const viaWhich = whichBinary('hermes');
+    if (viaWhich) return viaWhich;
+
+    // Tier 4 (Windows only): Hermes is not supported natively on Windows — it
+    // installs and runs inside WSL2. If a WSL distro has hermes on its login
+    // PATH, resolve its absolute in-WSL path; _runHermes then invokes it as
+    // `wsl -e <path> …`.
+    if (IS_WINDOWS) {
+      const wslPath = this._resolveWslHermes();
+      if (wslPath) {
+        this._hermesViaWsl = true;
+        return wslPath;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Resolve hermes's absolute path inside the default WSL distro, or null.
+   * Uses a login shell (`bash -lc`) so the installer's PATH additions
+   * (~/.local/bin) are visible. Returns an absolute Linux path like
+   * /home/<user>/.local/bin/hermes.
+   */
+  _resolveWslHermes() {
+    if (!IS_WINDOWS) return null;
+    try {
+      const out = execSync('wsl.exe -e bash -lc "command -v hermes"', {
+        encoding: 'utf-8', timeout: 8000, windowsHide: true,
+      }).trim();
+      const p = out.split(/\r?\n/).map((s) => s.trim()).find(Boolean);
+      if (p && p.startsWith('/')) return p;
+    } catch {}
     return null;
   }
 
@@ -255,10 +307,25 @@ class HermesAdapter extends BaseAdapter {
     this._log(`Running hermes (profile=${this.hermesProfile}, channel=${channelName}, resume=${!!resumeId})`);
 
     const env = { ...(this.agentEnv || process.env) };
-    const proc = spawn(this._hermesBin, args, {
+
+    // On Windows hermes lives inside WSL: invoke `wsl -e <wsl-hermes-path> …`.
+    // `-e` runs the binary directly (no shell), so every arg — including the
+    // multi-line prompt in `-q` — passes through verbatim with no quoting hazard.
+    // hermes then uses its own config (~/.hermes inside WSL) for model/keys.
+    let spawnBin = this._hermesBin;
+    let spawnArgs = args;
+    if (this._hermesViaWsl) {
+      spawnBin = 'wsl.exe';
+      spawnArgs = ['-e', this._hermesBin, ...args];
+    }
+
+    const proc = spawn(spawnBin, spawnArgs, {
       env,
       stdio: ['ignore', 'pipe', 'pipe'],
-      detached: !IS_WINDOWS,
+      // No process group on Windows / WSL (can't signal a group); windowsHide
+      // keeps the wsl.exe console from flashing up.
+      detached: !IS_WINDOWS && !this._hermesViaWsl,
+      windowsHide: true,
     });
     this._channelProcesses[channelName] = proc;
 

package/src/adapters/openclaw.js

@@ -354,22 +354,38 @@ class OpenClawAdapter extends BaseAdapter {
         } catch {}
       }, 500);
 
+      // 'error' and 'exit' can BOTH fire for a single failed spawn. Closing
+      // stderrFd twice throws EBADF from inside the event callback, which —
+      // with no daemon-level handler — used to crash the entire daemon. Guard
+      // so the fd is closed once and the promise settles once.
+      let settled = false;
+      const closeFd = () => { try { fs.closeSync(stderrFd); } catch {} };
+
       const killTimeout = setTimeout(() => {
-        proc.kill();
+        if (settled) return;
+        settled = true;
+        clearInterval(pollInterval);
+        closeFd();
+        try { fs.unlinkSync(stderrFile); } catch {}
+        try { proc.kill(); } catch {}
         reject(new Error('CLI timed out after 600 seconds'));
       }, 600000);
 
       proc.on('error', (err) => {
+        if (settled) return;
+        settled = true;
         clearInterval(pollInterval);
         clearTimeout(killTimeout);
-        fs.closeSync(stderrFd);
+        closeFd();
         try { fs.unlinkSync(stderrFile); } catch {}
         reject(err);
       });
       proc.on('exit', (code) => {
+        if (settled) return;
+        settled = true;
         clearInterval(pollInterval);
         clearTimeout(killTimeout);
-        fs.closeSync(stderrFd);
+        closeFd();
         // Read full stderr content (contains JSON output + trace lines)
         let stderrContent = '';
         try {

package/src/adapters/opencode.js

@@ -18,6 +18,7 @@ const { execSync, spawn } = require('child_process');
 const BaseAdapter = require('./base');
 const { formatAttachmentsForPrompt } = require('./utils');
 const { buildOpenCodeSkillMd, buildOpenCodeSystemPrompt } = require('./workspace-prompt');
+const { whichBinary, getEnhancedEnv } = require('../paths');
 
 const IS_WINDOWS = process.platform === 'win32';
 
@@ -123,25 +124,55 @@ class OpenCodeAdapter extends BaseAdapter {
   // ------------------------------------------------------------------
 
   _findOpencodeBinary() {
-    // Tier 1: PATH
+    const home = os.homedir();
+    const ext = IS_WINDOWS ? '.cmd' : '';
+
+    // Tier 0: the actual native binary the opencode-ai package ships, NOT the
+    // npm `.cmd`/`.bin` shim. opencode-ai's `bin` is a single self-contained
+    // executable named `opencode.exe` on every platform (on macOS/Linux it's
+    // the native Mach-O/ELF binary — the .exe suffix is just how the package
+    // names it). Returning it directly lets us spawn it without going through
+    // `cmd.exe /C opencode.cmd`, which on Windows is what flashed a console
+    // window — and an attached console makes opencode drop into its interactive
+    // TUI instead of non-interactive `run`, so it hung waiting for keypresses.
+    const nativeExe = path.join(home, '.openagents', 'runtimes', 'opencode', 'node_modules', 'opencode-ai', 'bin', 'opencode.exe');
+    if (fs.existsSync(nativeExe)) return nativeExe;
+
+    // Tier 0b: Isolated runtime prefix shim — where the launcher installs agents
+    // (~/.openagents/runtimes/opencode/node_modules/.bin). Every other adapter
+    // checks this first; opencode was the lone exception, so a launcher-managed
+    // install was invisible unless its .bin happened to be on PATH — which is
+    // exactly why the workspace failed with "opencode CLI not found" even though
+    // the marketplace showed it installed.
+    const runtimeBin = path.join(home, '.openagents', 'runtimes', 'opencode', 'node_modules', '.bin', `opencode${ext}`);
+    if (fs.existsSync(runtimeBin)) return runtimeBin;
+
+    // Tier 0b: Legacy shared portable prefix.
+    const legacyBin = path.join(home, '.openagents', 'nodejs', 'node_modules', '.bin', `opencode${ext}`);
+    if (fs.existsSync(legacyBin)) return legacyBin;
+
+    // Tier 1: PATH. Use the ENRICHED env (node-version-manager/homebrew/npm
+    // dirs the launcher adds) so the lookup matches a packaged daemon's real
+    // reach; windowsHide stops a console window from flashing on Windows.
     try {
+      const env = getEnhancedEnv();
       if (IS_WINDOWS) {
-        const r = execSync('where opencode.cmd 2>nul || where opencode.exe 2>nul || where opencode 2>nul', {
-          encoding: 'utf-8', timeout: 5000,
+        const r = execSync('where opencode.exe 2>nul || where opencode.cmd 2>nul || where opencode 2>nul', {
+          encoding: 'utf-8', timeout: 5000, windowsHide: true, env,
         });
-        return r.split(/\r?\n/)[0].trim();
+        const hit = r.split(/\r?\n/)[0].trim();
+        if (hit) return hit;
       } else {
-        return execSync('which opencode', { encoding: 'utf-8', timeout: 5000 }).trim();
+        const hit = execSync('which opencode', { encoding: 'utf-8', timeout: 5000, windowsHide: true, env }).trim();
+        if (hit) return hit;
       }
     } catch {}
 
     // Tier 2: Next to Node.js
-    const ext = IS_WINDOWS ? '.cmd' : '';
     const nearNode = path.join(path.dirname(process.execPath), `opencode${ext}`);
     if (fs.existsSync(nearNode)) return nearNode;
 
     // Tier 3: Common locations
-    const home = os.homedir();
     const candidates = IS_WINDOWS ? [
       path.join(process.env.APPDATA || '', 'npm', 'opencode.cmd'),
     ] : [
@@ -153,6 +184,13 @@ class OpenCodeAdapter extends BaseAdapter {
     for (const c of candidates) {
       if (fs.existsSync(c)) return c;
     }
+
+    // Tier 4: Deep scan of every known bin dir (nvm/fnm/volta node-global,
+    // homebrew, …) — catches an `opencode` installed as a global npm package
+    // under a version-managed Node, which the fixed-PATH tiers above miss.
+    const viaWhich = whichBinary('opencode');
+    if (viaWhich) return viaWhich;
+
     return null;
   }
 
@@ -184,7 +222,12 @@ class OpenCodeAdapter extends BaseAdapter {
       if (responseText) {
         await this.sendResponse(msgChannel, responseText);
       } else {
-        await this.sendResponse(msgChannel, 'No response generated. Please try again.');
+        // Exit 0 with no assistant text almost always means OpenCode has no
+        // model/provider configured (it emits only step_start then stops).
+        await this.sendResponse(
+          msgChannel,
+          'OpenCode ran but produced no response. This usually means no model/provider is configured — set one up (e.g. `opencode auth login` or configure a provider/API key) and try again.'
+        );
       }
     } catch (e) {
       this._log(`Error handling message: ${e.message}`);
@@ -269,6 +312,23 @@ class OpenCodeAdapter extends BaseAdapter {
     return texts.length ? texts.join('\n').trim() : raw.trim();
   }
 
+  /**
+   * True when `raw` is opencode JSON that carries ONLY control events
+   * (step_start / step_finish / tool_use) and no assistant text — which is what
+   * opencode emits when no model/provider is configured. In that case
+   * _extractTextFromJson falls back to returning the raw event JSON, which we
+   * must NOT post to the channel as if it were a reply. Non-JSON output (real
+   * plain text) returns false so it is kept.
+   */
+  static _isOnlyControlJson(raw) {
+    const events = OpenCodeAdapter._splitJsonObjects(raw);
+    if (!events.length) return false;
+    for (const ev of events) {
+      if (OpenCodeAdapter._extractTextFromEvent(ev)) return false;
+    }
+    return true;
+  }
+
   /**
    * Extract and persist session_id from OpenCode JSON events.
    */
@@ -328,6 +388,8 @@ class OpenCodeAdapter extends BaseAdapter {
 
     let spawnBinary = cmd[0];
     let spawnArgs = cmd.slice(1);
+    // Only the npm `.cmd` shim needs a cmd.exe host. The native opencode.exe
+    // (preferred by _findOpencodeBinary) is spawned directly — no console host.
     if (IS_WINDOWS && spawnBinary.toLowerCase().endsWith('.cmd')) {
       spawnArgs = ['/C', spawnBinary, ...spawnArgs];
       spawnBinary = process.env.COMSPEC || 'cmd.exe';
@@ -339,38 +401,62 @@ class OpenCodeAdapter extends BaseAdapter {
         env: spawnEnv,
         cwd: this.agentHome,
         timeout: 300000, // 5 minutes
+        // Never let a console window appear. Besides being ugly, an attached
+        // console makes opencode start its interactive TUI and hang instead of
+        // running headless — the root cause of "stuck on thinking…" on Windows.
+        windowsHide: true,
       });
 
       let stdout = '';
       let stderr = '';
+      let settled = false;
+      const finish = (fn, arg) => { if (!settled) { settled = true; fn(arg); } };
 
       if (proc.stdout) proc.stdout.on('data', (d) => { stdout += d; });
       if (proc.stderr) proc.stderr.on('data', (d) => { stderr += d; });
 
-      // Send the prompt via stdin
+      // Send the prompt via stdin, then close it so opencode knows the message
+      // is complete and never blocks waiting for more input. Guard the write:
+      // if the child already died, writing to its stdin throws EPIPE.
       if (proc.stdin) {
-        proc.stdin.write(fullPrompt, 'utf-8');
-        proc.stdin.end();
+        proc.stdin.on('error', () => {});
+        try {
+          proc.stdin.write(fullPrompt, 'utf-8');
+          proc.stdin.end();
+        } catch { /* child gone — the exit/error handler reports it */ }
       }
 
-      proc.on('error', (err) => reject(err));
-      proc.on('exit', (code) => {
+      proc.on('error', (err) => finish(reject, err));
+      // 'close' (not 'exit') fires after stdout/stderr have fully drained, so we
+      // never parse a truncated response.
+      proc.on('close', (code) => {
         stdout = stdout.trim();
         stderr = stderr.trim();
 
         if (code !== 0) {
           this._log(`opencode exited with code ${code}: ${stderr.slice(0, 300)}`);
+          // Surface the real failure instead of a generic "No response" so the
+          // user can see (e.g.) a missing model/provider or auth error.
+          return finish(reject, new Error(
+            stderr ? stderr.slice(0, 500) : `opencode exited with code ${code}`
+          ));
         }
 
         if (stdout) {
           this._persistSessionId(msgChannel, stdout);
-          resolve(OpenCodeAdapter._extractTextFromJson(stdout));
-        } else {
-          if (stderr) {
-            this._log(`opencode stderr: ${stderr.slice(0, 300)}`);
+          const text = OpenCodeAdapter._extractTextFromJson(stdout);
+          // Exit 0 but no assistant text usually means no model/provider is
+          // configured (opencode emits only step_start then stops). Tell the
+          // user how to fix it rather than echoing raw event JSON.
+          if (!text || OpenCodeAdapter._isOnlyControlJson(stdout)) {
+            this._log(`opencode produced no assistant text. stdout head: ${stdout.slice(0, 300)}`);
+            return finish(resolve, '');
           }
-          resolve('');
+          return finish(resolve, text);
         }
+
+        if (stderr) this._log(`opencode stderr: ${stderr.slice(0, 300)}`);
+        finish(resolve, '');
       });
     });
   }

package/src/cli.js

@@ -64,9 +64,18 @@ function table(rows, headers) {
 
 async function cmdUp(connector, flags) {
   if (flags.foreground) {
-    // Run in foreground (used by daemonize child) — skip PID check
-    // because the parent already wrote our PID to the file.
+    // Run in foreground. daemonize() already guards its own child, but the
+    // launcher spawns `up --foreground` DIRECTLY — bypassing that guard — so a
+    // stale/empty pid file used to let it pile up dozens of daemons that each
+    // join the workspace as the same agents (session wars, duplicate replies).
+    // Enforce the singleton here using process-liveness from the pid OR status
+    // file, so a clobbered pid file can't defeat it.
     const daemon = connector.createDaemon();
+    const other = Daemon.runningDaemonPid(daemon.config.configDir);
+    if (other) {
+      print(`Daemon already running (PID ${other}); not starting another.`);
+      return;
+    }
     await daemon.start();
   } else {
     const pid = connector.getDaemonPid();
@@ -172,7 +181,15 @@ async function cmdRemove(connector, _flags, positional) {
 async function cmdStart(connector, _flags, positional) {
   const name = positional[0];
   if (!name) { print('Usage: agn start <name>'); return; }
-  connector.sendDaemonCommand(`restart:${name}`);
+  // `start` must be idempotent — it ensures the agent is running, it does NOT
+  // forcibly restart one that already is. Send `start:` (which the daemon
+  // guards: relaunch only when not already running) rather than `restart:`.
+  // A blind `restart:` tears down the workspace session the daemon already
+  // joined on launch and re-joins as the same agent; the server revokes the
+  // first session, so the agent stops the moment it next touches the workspace
+  // (first user message → "thinking..." then silence). The launcher already
+  // sends `start:`; this aligns the CLI with it.
+  connector.sendDaemonCommand(`start:${name}`);
   print(`Sent start command for '${name}'`);
 }
 

package/src/daemon.js

@@ -5,7 +5,7 @@ const path = require('path');
 const { spawn, execSync, execFileSync } = require('child_process');
 const os = require('os');
 const { WorkspaceClient } = require('./workspace-client');
-const { getEnhancedEnv, whichBinary, IS_WINDOWS } = require('./paths');
+const { getEnhancedEnv, whichBinary, IS_WINDOWS, defaultAgentWorkdir } = require('./paths');
 
 /**
  * Agent process lifecycle manager.
@@ -55,6 +55,25 @@ class Daemon {
       try { process.on('SIGHUP', () => this._reload()); } catch {}
     }
 
+    // Crash guards. A bug in one adapter — a rejected fire-and-forget promise,
+    // an EBADF from a double fs.closeSync in a child-process callback, a throw
+    // inside a stream/'exit' handler — must NEVER take down the whole daemon
+    // and every other agent with it. Node ≥15 terminates the process on an
+    // unhandled rejection by default, so without these the daemon silently
+    // dies and the launcher shows "Daemon stopped". Log loudly, keep
+    // supervising; per-agent failures are already isolated in _adapterLoop.
+    if (!this._crashGuardsInstalled) {
+      this._crashGuardsInstalled = true;
+      process.on('unhandledRejection', (reason) => {
+        const msg = reason && reason.stack ? reason.stack : String(reason);
+        this._log(`UNHANDLED REJECTION (daemon kept alive): ${msg}`);
+      });
+      process.on('uncaughtException', (err) => {
+        const msg = err && err.stack ? err.stack : String(err);
+        this._log(`UNCAUGHT EXCEPTION (daemon kept alive): ${msg}`);
+      });
+    }
+
     // Write PID file
     this._writePid();
 
@@ -444,7 +463,12 @@ class Daemon {
     let adapter;
     try {
       adapter = createAdapter(agentType, {
-        workspaceId: network.id,
+        // Networks created via the launcher can be persisted with id: null
+        // (the workspace service returns only a slug). The server identifies
+        // a workspace by its slug — the same value the web UI uses in its URL —
+        // so fall back to it. Joining with a null id makes every poll/heartbeat
+        // fail "Network not found", which spins the adapter in an error loop.
+        workspaceId: network.id || network.slug,
         channelName: 'general',
         token: network.token,
         agentName: name,
@@ -453,7 +477,11 @@ class Daemon {
         openclawAgentId: agentCfg.openclaw_agent_id || 'main',
         disabledModules: skillsToDisabledModules(agentCfg.skills),
         agentEnv: this._buildAgentEnv(agentCfg),
-        workingDir: agentCfg.path || undefined,
+        // Always give the agent a real, writable working directory. Without an
+        // explicit `path`, adapters used to fall back to process.cwd(), which on
+        // a packaged Windows launcher is C:\WINDOWS\system32 — so writing
+        // .claude/skills there failed with EPERM. Root it under ~/.openagents.
+        workingDir: agentCfg.path || defaultAgentWorkdir(name),
         toolMode: agentCfg.tool_mode || 'skills',
       });
     } catch (e) {
@@ -657,8 +685,24 @@ class Daemon {
           this.stopAgent(agentName);
         } else if (cmd.startsWith('start:')) {
           const agentName = cmd.slice(6).trim();
-          this._log(`Command: start ${agentName}`);
-          this.restartAgent(agentName);
+          // 'start' must be idempotent. The launcher sends start:<name> right
+          // after (re)spawning the daemon, but the daemon's own start() already
+          // launched every configured agent. A blind restart here tears down
+          // the just-joined workspace session and re-joins as the same agent;
+          // the server revokes the first session and the agent then stops the
+          // moment it next touches the workspace (e.g. the first user message →
+          // "thinking..." status). Only (re)launch when it isn't running.
+          const running =
+            (this._adapters && this._adapters[agentName]) ||
+            ['running', 'starting'].includes(
+              this._processes[agentName] && this._processes[agentName].state
+            );
+          if (running) {
+            this._log(`Command: start ${agentName} — already running, skipping`);
+          } else {
+            this._log(`Command: start ${agentName}`);
+            this.restartAgent(agentName);
+          }
         } else if (cmd.startsWith('restart:')) {
           const agentName = cmd.slice(8).trim();
           this._log(`Command: restart ${agentName}`);
@@ -831,6 +875,38 @@ class Daemon {
       return false;
     }
   }
+
+  /**
+   * Return the PID of another live daemon for this configDir, or null.
+   *
+   * Used to enforce the singleton even on the `up --foreground` path, which the
+   * launcher spawns directly (bypassing daemonize's guard). Trusts BOTH the pid
+   * file and the status file (a live daemon rewrites the latter every 5s with
+   * its own pid), because the pid file gets emptied/clobbered under races. Uses
+   * real process-liveness — not just file age — so a daemon that was just
+   * stopped for a legitimate restart doesn't block the replacement.
+   */
+  static runningDaemonPid(configDir) {
+    const self = process.pid;
+    const isOtherAlive = (pid) =>
+      pid && pid !== self && Daemon._isAlive(pid);
+
+    const pidFromFile = Daemon._readPid(path.join(configDir, 'daemon.pid'));
+    if (isOtherAlive(pidFromFile)) return pidFromFile;
+
+    try {
+      const statusFile = path.join(configDir, 'daemon.status.json');
+      const age = Date.now() - fs.statSync(statusFile).mtimeMs;
+      // Bound the age so a long-dead daemon whose pid got reused by an
+      // unrelated process can't masquerade as a live daemon.
+      if (age < 30000) {
+        const raw = JSON.parse(fs.readFileSync(statusFile, 'utf-8'));
+        const pid = raw && raw.pid;
+        if (isOtherAlive(pid)) return pid;
+      }
+    } catch {}
+    return null;
+  }
 }
 
 module.exports = { Daemon };

package/src/installer.js

@@ -941,7 +941,7 @@ class Installer {
     const { spawn: spawnProc } = require('child_process');
     const https = require('https');
     const os = require('os');
-    const nodeVersion = 'v22.16.0';
+    const nodeVersion = 'v22.22.3';
     const plat = Installer.platform();
 
     if (onData) onData(`Node.js not found. Installing Node.js ${nodeVersion}...\n\n`);

package/src/paths.js

@@ -10,6 +10,7 @@
 
 const path = require('path');
 const fs = require('fs');
+const os = require('os');
 const { execSync } = require('child_process');
 
 const IS_WINDOWS = process.platform === 'win32';
@@ -353,6 +354,28 @@ function getCorePrefix() {
   return path.join(HOME, '.openagents', 'core');
 }
 
+/**
+ * A guaranteed-writable working directory for an agent that has no explicit
+ * `path` configured.
+ *
+ * NEVER fall back to process.cwd() for this: on a packaged Windows launcher the
+ * daemon (and the agent CLIs it spawns) inherit a cwd of C:\WINDOWS\system32
+ * (or the app's Program Files dir), so writing .claude/skills, .claude/plans,
+ * etc. relative to cwd fails with `EPERM: operation not permitted, mkdir`.
+ *
+ * Rooted under ~/.openagents — the same writable tree the daemon already uses
+ * for its pid/status/log files — with one isolated subdir per agent. Uses
+ * os.homedir() (OS-account based, reliable even when HOME/USERPROFILE are
+ * stripped from a child process's environment) rather than the env-derived
+ * HOME above.
+ */
+function defaultAgentWorkdir(agentName) {
+  const safe = String(agentName || 'default').replace(/[^A-Za-z0-9._-]/g, '_') || 'default';
+  const dir = path.join(os.homedir(), '.openagents', 'workspaces', safe);
+  try { fs.mkdirSync(dir, { recursive: true }); } catch {}
+  return dir;
+}
+
 /**
  * Reset the two 30s caches that back binary detection. Call this after
  * install / uninstall so a freshly-created bin dir (e.g. ~/.cursor/bin)
@@ -372,6 +395,7 @@ module.exports = {
   clearBinaryLookupCache,
   getRuntimePrefix,
   getCorePrefix,
+  defaultAgentWorkdir,
   IS_WINDOWS,
   IS_MACOS,
   SEP,

package/src/skill-installer.js

@@ -25,6 +25,7 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const { execFileSync } = require('child_process');
+const { defaultAgentWorkdir } = require('./paths');
 
 /**
  * Resolve the skills directory for a given agent type, rooted at the agent's
@@ -40,7 +41,10 @@ const { execFileSync } = require('child_process');
  * @returns {string} absolute path to the skills directory
  */
 function skillsDirForAgentType(agentType, workingDir) {
-  const base = workingDir || process.cwd();
+  // Never root skills at process.cwd(): a packaged Windows daemon's cwd is
+  // C:\WINDOWS\system32, so installing there throws EPERM. Fall back to a
+  // writable per-agent dir under ~/.openagents instead.
+  const base = workingDir || defaultAgentWorkdir(agentType);
   switch ((agentType || '').toLowerCase()) {
     case 'claude':
       return path.join(base, '.claude', 'skills');

package/icons/swebench.svg

@@ -1 +0,0 @@
-<svg viewBox="0 0 24 24" width="1em" height="1em" xmlns="http://www.w3.org/2000/svg"><circle cx="12" cy="12" r="11" fill="#6366f1" /><text x="12" y="17" text-anchor="middle" font-family="system-ui" font-weight="700" font-size="14" fill="#fff">S</text></svg>