@openagents-org/agent-launcher 0.2.135 → 0.2.138

package/package.json

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

package/registry.json

@@ -616,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';
 
@@ -332,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 {}
 
@@ -354,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',
@@ -362,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;
   }
 
@@ -427,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');
@@ -1009,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/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';
 
@@ -126,7 +127,18 @@ class OpenCodeAdapter extends BaseAdapter {
     const home = os.homedir();
     const ext = IS_WINDOWS ? '.cmd' : '';
 
-    // Tier 0: Isolated runtime prefix — where the launcher installs agents
+    // 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
@@ -139,15 +151,20 @@ class OpenCodeAdapter extends BaseAdapter {
     const legacyBin = path.join(home, '.openagents', 'nodejs', 'node_modules', '.bin', `opencode${ext}`);
     if (fs.existsSync(legacyBin)) return legacyBin;
 
-    // Tier 1: PATH
+    // 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 {}
 
@@ -167,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;
   }
 
@@ -198,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}`);
@@ -283,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.
    */
@@ -342,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';
@@ -353,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/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.
@@ -477,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) {

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');