@openagents-org/agent-launcher 0.2.180 → 0.2.182

package/src/adapters/kimi.js

@@ -29,7 +29,11 @@
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
-const { execSync, spawn } = require('child_process');
+const { execSync } = require('child_process');
+// spawn() here is the WSL bridge from ../wsl: same signature as
+// child_process.spawn, and a straight pass-through unless the resolved CLI
+// lives on the other side of the Windows/WSL boundary.
+const { spawn } = require('../wsl');
 
 const LlmDirectAdapter = require('./llm-direct');
 const { formatAttachmentsForPrompt, SESSION_DEFAULT_RE, generateSessionTitle } = require('./utils');

package/src/adapters/llm-direct.js

@@ -71,6 +71,11 @@ class LlmDirectAdapter extends BaseAdapter {
     }
   }
 
+  /** The model this runner actually calls with — see `_model` above. */
+  modelLabel() {
+    return String(this.workspaceModel || this._model || '').trim() || null;
+  }
+
   _buildSystemPrompt(channelName) {
     return buildOpenclawSystemPrompt({
       agentName: this.agentName,
@@ -79,6 +84,7 @@ class LlmDirectAdapter extends BaseAdapter {
       endpoint: this.endpoint,
       token: this.token,
       mode: this._mode,
+      model: this.modelLabel(),
       disabledModules: this.disabledModules,
       ...this.pinnedPromptOpts(channelName),
     });

package/src/adapters/mini.js

@@ -50,7 +50,11 @@
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
-const { execSync, spawn } = require('child_process');
+const { execSync } = require('child_process');
+// spawn() here is the WSL bridge from ../wsl: same signature as
+// child_process.spawn, and a straight pass-through unless the resolved CLI
+// lives on the other side of the Windows/WSL boundary.
+const { spawn, resolveWslBinary } = require('../wsl');
 
 const BaseAdapter = require('./base');
 const { whichBinary, getEnhancedEnv, aiderBinDirs } = require('../paths');
@@ -178,7 +182,7 @@ class MiniSweAgentAdapter extends BaseAdapter {
     // Shared cross-platform resolver runs `which`/`where` against an ENHANCED
     // PATH (nvm/fnm/volta/homebrew + pip/pipx/uv user-install dirs) — covers the
     // GUI/daemon "installed but not on PATH" case for a `pip install`.
-    const resolved = whichBinary('mini');
+    const resolved = whichBinary('mini', { allowWsl: false });
     if (resolved) return this._resolveExePreference(resolved, IS_WINDOWS);
 
     // Explicit fallback over the pip/pipx/uv user-install bin dirs plus the uv
@@ -201,7 +205,10 @@ class MiniSweAgentAdapter extends BaseAdapter {
         if (fs.existsSync(c)) return c;
       }
     }
-    return null;
+    // Nothing native anywhere. Last of all, look inside WSL: a CLI the user
+    // installed in their distro is a real install, and the marked path it comes
+    // back as is what the spawn bridge in ../wsl turns into a wsl.exe run.
+    return resolveWslBinary('mini');
   }
 
   /**

package/src/adapters/openclaw.js

@@ -14,7 +14,11 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
-const { spawn, execSync } = require('child_process');
+const { execSync } = require('child_process');
+// spawn() here is the WSL bridge from ../wsl: same signature as
+// child_process.spawn, and a straight pass-through unless the resolved CLI
+// lives on the other side of the Windows/WSL boundary.
+const { spawn } = require('../wsl');
 
 const BaseAdapter = require('./base');
 const { formatAttachmentsForPrompt } = require('./utils');

package/src/adapters/opencode.js

@@ -14,7 +14,11 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const crypto = require('crypto');
-const { execSync, spawn } = require('child_process');
+const { execSync } = require('child_process');
+// spawn() here is the WSL bridge from ../wsl: same signature as
+// child_process.spawn, and a straight pass-through unless the resolved CLI
+// lives on the other side of the Windows/WSL boundary.
+const { spawn } = require('../wsl');
 
 const BaseAdapter = require('./base');
 const { formatAttachmentsForPrompt, redactSecrets } = require('./utils');
@@ -250,6 +254,7 @@ class OpenCodeAdapter extends BaseAdapter {
       endpoint: this.endpoint,
       token: this.token,
       mode: this._mode,
+      model: this.modelLabel(),
       disabledModules: this.disabledModules,
       ...this.pinnedPromptOpts(channelName),
     });

package/src/adapters/openworker.js

@@ -42,7 +42,11 @@ const net = require('net');
 const os = require('os');
 const path = require('path');
 const crypto = require('crypto');
-const { spawn, execFileSync } = require('child_process');
+const { execFileSync } = require('child_process');
+// spawn() here is the WSL bridge from ../wsl: same signature as
+// child_process.spawn, and a straight pass-through unless the resolved CLI
+// lives on the other side of the Windows/WSL boundary.
+const { spawn } = require('../wsl');
 
 const BaseAdapter = require('./base');
 const { formatAttachmentsForPrompt, SESSION_DEFAULT_RE, generateSessionTitle } = require('./utils');
@@ -203,6 +207,15 @@ class OpenWorkerAdapter extends BaseAdapter {
     return String(this.agentEnv.OPENWORKER_API_KEY || '').trim();
   }
 
+  /**
+   * What to tell the agent it is running on. `_model()` is the id we hand the
+   * server, provider prefix and all — the honest answer to "what model are
+   * you?", which OpenWorker's own weights cannot give.
+   */
+  modelLabel() {
+    return this._model() || null;
+  }
+
   /** The model for a turn: the workspace's selection wins over the saved env. */
   _model() {
     const raw = String(this.workspaceModel || this.agentEnv.OPENWORKER_MODEL || '').trim();
@@ -587,6 +600,7 @@ class OpenWorkerAdapter extends BaseAdapter {
       endpoint: this.endpoint,
       token: this.token,
       mode: this._mode,
+      model: this.modelLabel(),
       disabledModules: this.disabledModules,
       browserEnabled,
     });

package/src/adapters/pi.js

@@ -34,7 +34,11 @@ const crypto = require('crypto');
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
-const { execFileSync, execSync, spawn } = require('child_process');
+const { execFileSync, execSync } = require('child_process');
+// spawn() here is the WSL bridge from ../wsl: same signature as
+// child_process.spawn, and a straight pass-through unless the resolved CLI
+// lives on the other side of the Windows/WSL boundary.
+const { spawn } = require('../wsl');
 
 const BaseAdapter = require('./base');
 const { formatAttachmentsForPrompt, SESSION_DEFAULT_RE, generateSessionTitle } = require('./utils');
@@ -1391,6 +1395,7 @@ class PiAdapter extends BaseAdapter {
       endpoint: this.endpoint,
       token: this.token,
       mode: this._mode,
+      model: this.modelLabel(),
       disabledModules: this.disabledModules,
       browserEnabled,
     });

package/src/adapters/workspace-prompt.js

@@ -121,7 +121,7 @@ function workspaceSkillName(agentName) {
  * - `'skills'` → points at the agent's workspace skill (Bash + curl),
  *   since no MCP server is spawned and that tool would not exist.
  */
-function buildWorkspaceIdentity(agentName, workspaceId, channelName, mode = 'execute', toolMode = 'mcp') {
+function buildWorkspaceIdentity(agentName, workspaceId, channelName, mode = 'execute', toolMode = 'mcp', model = null) {
   const priorContext = toolMode === 'skills'
     ? (
       `When you need prior context, use the ${workspaceSkillName(agentName)} skill to ` +
@@ -135,6 +135,15 @@ function buildWorkspaceIdentity(agentName, workspaceId, channelName, mode = 'exe
       'channel argument the tool falls back to a default channel that may ' +
       'be different from where you are.\n'
     );
+  // The model is the one fact about itself an agent cannot look up. Asked
+  // "what model are you?", a CLI-driven agent answers from whatever its
+  // weights remember about their own training — which is how an agent
+  // configured with deepseek came to tell a user it was Claude. The launcher
+  // knows the answer exactly (it is what was passed to the CLI), so state it
+  // rather than leaving the agent to guess.
+  const modelLine = String(model || '').trim()
+    ? `- Model: ${String(model).trim()}  (this is the model you are running on — do not guess otherwise)\n`
+    : '';
   return (
     `You are agent '${agentName}' connected to an OpenAgents workspace.\n` +
     'Your text responses are automatically posted to the workspace chat ' +
@@ -142,7 +151,9 @@ function buildWorkspaceIdentity(agentName, workspaceId, channelName, mode = 'exe
     '## Workspace Context\n' +
     `- Workspace ID: ${workspaceId}\n` +
     `- Channel: ${channelName}  (this is the channel you are currently speaking in)\n` +
-    `- Mode: ${mode}\n\n` +
+    `- Mode: ${mode}\n` +
+    modelLine +
+    '\n' +
     priorContext
   );
 }
@@ -931,10 +942,10 @@ function buildPinnedSections({ toolMode = 'mcp', channelName, mode = 'execute',
  * writeAccess? }. Both default to off — other adapters that reuse this
  * builder (e.g. Gemini) are unaffected unless they pass them.
  */
-function buildClaudeSystemPrompt({ agentName, workspaceId, channelName, mode = 'execute', browserEnabled = false, toolMode = 'mcp', decisionLog = null, glossary = null }) {
+function buildClaudeSystemPrompt({ agentName, workspaceId, channelName, mode = 'execute', browserEnabled = false, toolMode = 'mcp', decisionLog = null, glossary = null, model = null }) {
   const skillName = workspaceSkillName(agentName);
   const parts = [];
-  parts.push(buildWorkspaceIdentity(agentName, workspaceId, channelName, mode, toolMode));
+  parts.push(buildWorkspaceIdentity(agentName, workspaceId, channelName, mode, toolMode, model));
   parts.push(toolMode === 'skills' ? buildClaudeSkillsToolBlock(skillName) : buildClaudeMcpToolBlock());
   parts.push(buildBrowserDirective(browserEnabled));
   parts.push(buildCollaborationPrompt(toolMode, skillName));
@@ -960,9 +971,9 @@ function buildClaudeSystemPrompt({ agentName, workspaceId, channelName, mode = '
  * buildClaudeSystemPrompt (with skills-mode tool phrasing, since these
  * agents reach the knowledge API through curl commands).
  */
-function buildOpenclawSystemPrompt({ agentName, workspaceId, channelName, endpoint, token, mode = 'execute', disabledModules, browserEnabled = false, decisionLog = null, glossary = null }) {
+function buildOpenclawSystemPrompt({ agentName, workspaceId, channelName, endpoint, token, mode = 'execute', disabledModules, browserEnabled = false, decisionLog = null, glossary = null, model = null }) {
   const parts = [];
-  parts.push(buildWorkspaceIdentity(agentName, workspaceId, channelName, mode, 'skills'));
+  parts.push(buildWorkspaceIdentity(agentName, workspaceId, channelName, mode, 'skills', model));
   parts.push(buildBrowserDirective(browserEnabled));
   parts.push(buildCollaborationPrompt('skills', workspaceSkillName(agentName)));
   parts.push(buildModePrompt(mode));
@@ -1009,8 +1020,8 @@ function buildOpenclawSkillMd({ endpoint, workspaceId, token, agentName, channel
  * `decisionLog` / `glossary` opt in to knowledge pinning exactly as in
  * buildOpenclawSystemPrompt.
  */
-function buildOpenCodeSystemPrompt({ agentName, workspaceId, channelName, endpoint, token, mode = 'execute', disabledModules, browserEnabled = false, decisionLog = null, glossary = null, isWindows = process.platform === 'win32' }) {
-  const identity = buildWorkspaceIdentity(agentName, workspaceId, channelName, mode, 'skills');
+function buildOpenCodeSystemPrompt({ agentName, workspaceId, channelName, endpoint, token, mode = 'execute', disabledModules, browserEnabled = false, decisionLog = null, glossary = null, isWindows = process.platform === 'win32', model = null }) {
+  const identity = buildWorkspaceIdentity(agentName, workspaceId, channelName, mode, 'skills', model);
   const directive = buildBrowserDirective(browserEnabled);
   const collab = buildCollaborationPrompt('skills', workspaceSkillName(agentName));
   const modePrompt = buildModePrompt(mode) + buildWindowsShellHint(isWindows);
@@ -1031,8 +1042,8 @@ function buildOpenCodeSystemPrompt({ agentName, workspaceId, channelName, endpoi
  * NOTE: this is APPENDED, never passed via `--system-prompt` — that flag would
  * REPLACE Pi's own coding-assistant prompt and strip its tool instructions.
  */
-function buildPiSystemPrompt({ agentName, workspaceId, channelName, endpoint, token, mode = 'execute', disabledModules, browserEnabled = false }) {
-  const identity = buildWorkspaceIdentity(agentName, workspaceId, channelName, mode, 'skills');
+function buildPiSystemPrompt({ agentName, workspaceId, channelName, endpoint, token, mode = 'execute', disabledModules, browserEnabled = false, model = null }) {
+  const identity = buildWorkspaceIdentity(agentName, workspaceId, channelName, mode, 'skills', model);
   const directive = buildBrowserDirective(browserEnabled);
   const collab = buildCollaborationPrompt('skills', workspaceSkillName(agentName));
   const modePrompt = buildModePrompt(mode);
@@ -1060,8 +1071,8 @@ function buildPiSystemPrompt({ agentName, workspaceId, channelName, endpoint, to
  *     conversation, so it is sent once and still in context on every later turn
  *     — which is why it must read as a briefing, not as a system directive.
  */
-function buildOpenWorkerSystemPrompt({ agentName, workspaceId, channelName, endpoint, token, mode = 'execute', disabledModules, browserEnabled = false }) {
-  const identity = buildWorkspaceIdentity(agentName, workspaceId, channelName, mode, 'skills');
+function buildOpenWorkerSystemPrompt({ agentName, workspaceId, channelName, endpoint, token, mode = 'execute', disabledModules, browserEnabled = false, model = null }) {
+  const identity = buildWorkspaceIdentity(agentName, workspaceId, channelName, mode, 'skills', model);
   const directive = buildBrowserDirective(browserEnabled);
   const collab = buildCollaborationPrompt('skills', workspaceSkillName(agentName));
   const modePrompt = buildModePrompt(mode);

package/src/daemon.js

@@ -2,7 +2,11 @@
 
 const fs = require('fs');
 const path = require('path');
-const { spawn, execSync, execFileSync } = require('child_process');
+const { execSync, execFileSync } = require('child_process');
+// spawn() here is the WSL bridge from ./wsl: same signature as
+// child_process.spawn, and a straight pass-through unless the resolved CLI
+// lives on the other side of the Windows/WSL boundary.
+const { spawn } = require('./wsl');
 const os = require('os');
 const { WorkspaceClient } = require('./workspace-client');
 const { getEnhancedEnv, whichBinary, IS_WINDOWS, defaultAgentWorkdir } = require('./paths');
@@ -43,6 +47,7 @@ class Daemon {
     this._statusInterval = null;
     this._cmdInterval = null;
     this._nodeHeartbeatInterval = null;  // device-level heartbeat (connect-a-node)
+    this._displayNameInterval = null;    // pulls workspace-side renames back
     this._nodeClients = new Map();       // workspace_id -> WorkspaceClient, one per pairing
     this._runningCommands = new Set();   // node-command ids currently executing
     this._runtimes = [];                 // detected agent runtimes for the node view
@@ -225,6 +230,50 @@ class Daemon {
     }
   }
 
+  /**
+   * Reflect workspace-side renames back onto this device.
+   *
+   * The workspace is treated as authoritative for the label, which needs no
+   * timestamps to be correct: a rename started on the device writes to the
+   * workspace FIRST and only then to local config (see
+   * AgentConnector.setAgentDisplayName), so by the time this reads, the
+   * workspace already holds whatever the device just set. Anything different
+   * from local therefore came from the workspace and should win.
+   *
+   * Never throws — a workspace that is unreachable simply leaves the labels
+   * as they are until the next pass.
+   */
+  async _syncDisplayNames() {
+    let pairings = [];
+    try {
+      pairings = require('./node-config').listPairings();
+    } catch { return; }
+
+    for (const n of pairings) {
+      if (!n.workspace_id || !n.token) continue;
+      let members = [];
+      try {
+        members = await this._nodeClientFor(n).getAgents(n.workspace_id, n.token);
+      } catch { continue; }
+
+      const byName = new Map(members.map((m) => [m.agentName, m]));
+      for (const a of this.config.getAgents()) {
+        // Scoped to this pairing's workspace, like _buildRoster: an agent in
+        // another workspace must never be relabelled from this one.
+        if (!this._agentOnNodeWorkspace(a, n)) continue;
+        const remote = byName.get(a.name);
+        if (!remote) continue;
+        const local = a.display_name || null;
+        const wanted = remote.displayName || null;
+        if (local === wanted) continue;
+        try {
+          this.config.updateAgent(a.name, { display_name: wanted || undefined });
+          this._log(`display name for ${a.name} updated from workspace`);
+        } catch {}
+      }
+    }
+  }
+
   /**
    * True if agent `a` is bound to the node's currently-connected workspace.
    * A missing network never matches (guards against undefined === undefined
@@ -608,6 +657,15 @@ async _runNodeCommand(n, cmd) {
       15000,
     );
 
+    // Pull display-name renames made in the workspace back onto the device, so
+    // the two sides agree whichever one the user typed into. Separate from the
+    // 10s heartbeat on purpose: a label changes rarely and this is an extra
+    // request per paired workspace, so it runs a sixth as often.
+    this._displayNameInterval = setInterval(
+      () => this._syncDisplayNames(),
+      60000,
+    );
+
     // Detect installed/logged-in agent runtimes for the Add-agent gallery. Runs
     // in a child process (off the event loop), refreshed periodically.
     this._refreshRuntimes();
@@ -658,6 +716,7 @@ async _runNodeCommand(n, cmd) {
     if (this._nodeHeartbeatInterval) clearInterval(this._nodeHeartbeatInterval);
     if (this._credReconcileInterval) clearInterval(this._credReconcileInterval);
     if (this._runtimesInterval) clearInterval(this._runtimesInterval);
+    if (this._displayNameInterval) clearInterval(this._displayNameInterval);
     if (this._probeStartupTimer) clearTimeout(this._probeStartupTimer);
     if (this._probeInterval) clearInterval(this._probeInterval);
     if (this._configWatcher) { try { this._configWatcher.close(); } catch {} }

package/src/index.js

@@ -84,6 +84,10 @@ class AgentConnector {
       const network = networks.find((n) => n.slug === a.network || n.id === a.network);
       return {
         name: a.name,
+        // The label to show. `name` stays the identity — callers that key on
+        // it (sessions, working dirs, workspace membership) must keep using
+        // `name`, never this.
+        displayName: a.display_name || null,
         type,
         role: a.role || 'worker',
         network: a.network || null,
@@ -100,6 +104,95 @@ class AgentConnector {
     return { success: true };
   }
 
+  /**
+   * The workspace an agent is bound to, as a ready-to-use client — or null
+   * when it is local-only or its network is no longer configured.
+   *
+   * Each network carries its own endpoint (a self-hosted workspace is not the
+   * official one), so the client is built per call rather than reusing
+   * `this.workspace`, the same way removeWorkspace does.
+   */
+  _workspaceClientFor(agentName) {
+    const agent = this.config.getAgent(agentName);
+    if (!agent || !agent.network) return null;
+    const network = this.config
+      .getNetworks()
+      .find((n) => n.slug === agent.network || n.id === agent.network);
+    if (!network || !network.id) return null;
+    const endpoint = network.endpoint || (this.workspace && this.workspace.endpoint);
+    const { WorkspaceClient } = require('./workspace-client');
+    return { client: new WorkspaceClient(endpoint), network };
+  }
+
+  /**
+   * Set (or clear, with an empty value) an agent's display label.
+   *
+   * The agent's `name` is its identity — it keys daemon.yaml, the working
+   * directory under ~/.openagents/agents, its sessions and its workspace
+   * membership — so renaming NEVER touches it. What changes is the label the
+   * launcher and the workspace show, which is precisely what the workspace
+   * already models as `display_name` next to `agent_name`.
+   *
+   * When the agent is in a workspace the new label is pushed there too, so the
+   * two sides agree. A workspace that rejects it (a name another member
+   * already answers to) fails the whole call rather than leaving the label
+   * changed on one side only.
+   */
+  async setAgentDisplayName(name, displayName) {
+    const agent = this.config.getAgent(name);
+    if (!agent) throw new Error(`Agent '${name}' not found`);
+    const label = (displayName || '').trim();
+
+    const bound = this._workspaceClientFor(name);
+    if (bound) {
+      await bound.client.setMemberDisplayName(
+        bound.network.id,
+        bound.network.token || '',
+        name,
+        label,
+      );
+    }
+    // Local write comes second: if the workspace refused the label, nothing
+    // here has changed and the two sides are still in agreement.
+    this.config.updateAgent(name, { display_name: label || undefined });
+    return { success: true, displayName: label || null };
+  }
+
+  /**
+   * Drop an agent's member row from the workspace it joined.
+   *
+   * Deliberately SEPARATE from removeAgent rather than a flag on it. Removing
+   * an agent is a synchronous local edit that `agn remove` and the TUI call
+   * without awaiting, inside a try/catch — making it async would turn a thrown
+   * error into an unhandled rejection those callers can no longer see. So the
+   * network half lives here, and a caller that wants both awaits this first:
+   * failing to reach the workspace then leaves the agent intact locally, which
+   * is the recoverable order.
+   *
+   * A local-only agent is a no-op success — there is nothing over there.
+   */
+  async removeAgentFromWorkspace(name) {
+    const bound = this._workspaceClientFor(name);
+    if (!bound) return { success: true, skipped: true };
+    try {
+      await bound.client.removeMember(
+        bound.network.id,
+        bound.network.token || '',
+        name,
+      );
+    } catch (e) {
+      // 404 is the goal state, reached by someone else: the member row is
+      // already gone, or the whole workspace is. Treating it as a failure
+      // would strand the agent on this device — removal happens local-last, so
+      // an error here means it cannot be removed at all. Anything else (a
+      // network blip, an auth failure) is real and must stop the removal so
+      // the user can retry rather than lose track of a live membership.
+      if (!e || e.status !== 404) throw e;
+      return { success: true, alreadyGone: true };
+    }
+    return { success: true };
+  }
+
   removeAgent(name) {
     this.config.removeAgent(name);
     return { success: true };
@@ -193,11 +286,38 @@ class AgentConnector {
     return { success: true };
   }
 
+  /**
+   * Local half of leaving a workspace: forget the binding, keep the agent.
+   *
+   * Synchronous, and deliberately still local-only — `agn disconnect` and the
+   * TUI call it without awaiting, inside a try/catch, so an async version
+   * would turn a throw into an unhandled rejection they can no longer see.
+   * Callers that want the membership dropped too use leaveWorkspace below.
+   */
   disconnectWorkspace(agentName) {
     this.config.setAgentNetwork(agentName, null);
     return { success: true };
   }
 
+  /**
+   * Leave a workspace properly: drop the member row over there, and unbind
+   * here — the agent itself stays, with its config, credentials and working
+   * directory, ready to join another workspace.
+   *
+   * Leaving only the local half is the bug this replaces. The device stopped
+   * showing the agent as connected while the workspace went on listing it as a
+   * member, and nothing in the launcher could reach that row any more. The
+   * workspace-level "remove a workspace" action learned this same lesson
+   * already (see removeWorkspace) — this is the agent-level equivalent.
+   *
+   * Workspace first, local second: a failure there leaves the agent bound and
+   * retryable rather than orphaning a membership.
+   */
+  async leaveWorkspace(agentName) {
+    await this.removeAgentFromWorkspace(agentName);
+    return this.disconnectWorkspace(agentName);
+  }
+
   async removeWorkspace(slug) {
     const networks = this.config.getNetworks();
     const network = networks.find(n => n.slug === slug || n.id === slug);

package/src/installer.js

@@ -5,6 +5,7 @@ const os = require('os');
 const path = require('path');
 const { execSync, exec } = require('child_process');
 const { whichBinary, getEnhancedEnv, getRuntimePrefix, clearBinaryLookupCache, aiderBinDirs, resolveBinaryInKnownDirs } = require('./paths');
+const { isWslBinary, bridgedCommandString, wslHomeUnc } = require('./wsl');
 const { EnvManager } = require('./env');
 const { nodeDistUrls, installRegistry } = require('./mirrors');
 const { readinessReason, REASON } = require('./adapters/health-status');
@@ -173,6 +174,13 @@ class Installer {
       return { installed: false, managed: false, location: null };
     }
 
+    // Installed inside a WSL distro. Never 'managed': the launcher did not put
+    // it there and cannot uninstall it, and the isolated-runtime bookkeeping
+    // below is all about Windows paths that an in-distro binary can never match.
+    if (isWslBinary(binaryPath)) {
+      return { installed: true, managed: false, location: 'wsl' };
+    }
+
     // Verify it's not a stale shim pointing to a missing package
     const openagentsDir = path.join(os.homedir(), '.openagents');
     if (binaryPath.startsWith(openagentsDir)) {
@@ -580,6 +588,11 @@ class Installer {
    * shebang), so it's applied on every platform for consistency.
    */
   _versionProbeCommand(binary) {
+    // A binary inside WSL has to be asked through wsl.exe; running the Linux
+    // path as a Windows command yields "not recognized" and the marketplace
+    // then shows an installed agent with no version at all.
+    const bridged = bridgedCommandString(binary, ['--version']);
+    if (bridged) return bridged;
     if (/\.(mjs|cjs|js)$/i.test(binary)) {
       return `"${this._nodeBinary()}" "${binary}" --version`;
     }
@@ -744,14 +757,14 @@ class Installer {
     // authoritative; the legacy parser treats an empty {} as ready.
     const credsReady = checkReady.creds_json_has_entries
       ? false
-      : this._checkCredsReady(checkReady);
+      : this._checkCredsReady(checkReady, agentType);
     // Content-free credential probes (opt-in via check_ready). Detect agents
     // whose sign-in is a local OAuth/credential FILE (e.g. Gemini's
     // ~/.gemini/oauth_creds.json) or a service-account file path, WITHOUT
     // parsing or logging the token. Additive: agents that don't declare
     // creds_no_parse / creds_path_env get identical behavior to before.
-    const credsFile = this._evaluateCredsFile(checkReady);
-    const credsPathReady = this._checkCredsPathEnv(checkReady, savedEnv);
+    const credsFile = this._evaluateCredsFile(checkReady, agentType);
+    const credsPathReady = this._checkCredsPathEnv(checkReady, savedEnv, agentType);
 
     let cliReady = false;
     if (checkReady.status_command && binary) {
@@ -839,10 +852,10 @@ class Installer {
     return keys.some((key) => !!(source && source[key]));
   }
 
-  _checkCredsReady(checkReady) {
+  _checkCredsReady(checkReady, agentType) {
     if (checkReady.creds_file) {
       try {
-        const credsPath = checkReady.creds_file.replace('~', os.homedir());
+        const credsPath = this._expandHome(checkReady.creds_file, agentType);
         if (fs.existsSync(credsPath)) {
           const stat = fs.statSync(credsPath);
           if (stat.isDirectory()) return fs.readdirSync(credsPath).length > 0;
@@ -862,14 +875,38 @@ class Installer {
     return false;
   }
 
-  /** Expand a leading "~" to the running user's home directory. */
-  _expandHome(p) {
+  /**
+   * Expand a leading "~" to the home directory the AGENT writes its sign-in to.
+   *
+   * Normally the running user's. For an agent that resolved inside WSL it is
+   * the distro's $HOME, reached over the \\wsl.localhost mount — `claude login`
+   * run in the distro leaves ~/.claude there, and expanding against the Windows
+   * profile instead reports a signed-in agent as "Not logged in".
+   */
+  _expandHome(p, agentType) {
     if (typeof p !== 'string' || !p) return p;
-    if (p === '~') return os.homedir();
-    if (p.startsWith('~/') || p.startsWith('~\\')) return path.join(os.homedir(), p.slice(2));
+    const home = this._homeForAgent(agentType);
+    if (p === '~') return home;
+    if (p.startsWith('~/') || p.startsWith('~\\')) return path.join(home, p.slice(2));
     return p;
   }
 
+  /**
+   * Where this agent's dotfiles live, as a path this process can read. Falls
+   * back to the running user's home for every native install — and for a WSL
+   * one whose distro home could not be resolved, which is no worse than the
+   * behaviour before the WSL tier existed.
+   */
+  _homeForAgent(agentType) {
+    if (!agentType) return os.homedir();
+    try {
+      if (isWslBinary(this._whichBinary(agentType))) {
+        return wslHomeUnc() || os.homedir();
+      }
+    } catch { /* resolution is best-effort; the host home is the safe answer */ }
+    return os.homedir();
+  }
+
   /**
    * Existence/readability of a credential file. Returns 'present' |
    * 'unreadable' | 'absent'. A non-empty readable file (or a non-empty
@@ -881,9 +918,9 @@ class Installer {
    * against the running user's home (the daemon/launcher user), not the
    * renderer/browser user.
    */
-  _credsFileState(checkReady) {
+  _credsFileState(checkReady, agentType) {
     if (!checkReady || !checkReady.creds_file) return 'absent';
-    const p = this._expandHome(checkReady.creds_file);
+    const p = this._expandHome(checkReady.creds_file, agentType);
     let exists = false;
     try { exists = fs.existsSync(p); } catch { return 'unreadable'; }
     if (!exists) return 'absent';
@@ -922,11 +959,11 @@ class Installer {
    * parse + match `creds_key` via _checkCredsReady) keep their exact behavior.
    * Returns { ready, unreadable }.
    */
-  _evaluateCredsFile(checkReady) {
+  _evaluateCredsFile(checkReady, agentType) {
     if (!checkReady || !checkReady.creds_file || !checkReady.creds_no_parse) {
       return { ready: false, unreadable: false };
     }
-    const state = this._credsFileState(checkReady);
+    const state = this._credsFileState(checkReady, agentType);
     return { ready: state === 'present', unreadable: state === 'unreadable' };
   }
 
@@ -936,14 +973,14 @@ class Installer {
    * exists and is a readable file — a non-empty value alone is NOT enough.
    * Checks both the process env and the agent's saved env.
    */
-  _checkCredsPathEnv(checkReady, savedEnv) {
+  _checkCredsPathEnv(checkReady, savedEnv, agentType) {
     const names = checkReady && checkReady.creds_path_env;
     if (!Array.isArray(names) || !names.length) return false;
     for (const name of names) {
       const raw = ((process.env[name] || (savedEnv && savedEnv[name]) || '') + '').trim();
       if (!raw) continue;
       try {
-        const p = this._expandHome(raw);
+        const p = this._expandHome(raw, agentType);
         if (!fs.existsSync(p)) continue;
         fs.accessSync(p, fs.constants.R_OK);
         if (fs.statSync(p).isFile()) return true;
@@ -1568,8 +1605,12 @@ class Installer {
     const managed = this._resolveManagedBinary(agentType, entry, binary, aliases);
     if (managed) return managed;
 
+    // allowWsl:false — whichBinary would otherwise end its own search inside
+    // the distro, and this method still has two NATIVE tiers to run below. A
+    // Windows copy must win over a WSL one; resolveBinaryInKnownDirs() reaches
+    // the distro at the very end, once everything on this side has missed.
     for (const candidate of [binary, ...aliases]) {
-      const found = whichBinary(candidate);
+      const found = whichBinary(candidate, { allowWsl: false });
       if (found) return found;
     }
     // Fallback: resolve the installed package's OWN bin from its package.json