fix(runtimes): make detection's chosen executable the one spawn sites use

The candidate walk taught detection to skip a binary it cannot execute, but
every other resolution — chat, the connection test, the memory summariser,
companion install — called `resolveAgentLaunch` with no skip list and got
back the first file that merely exists on PATH: the broken shim detection
had just rejected. Settings advertised the agent as installed while each
turn exec'd the wrapper, so the fix only ever reached the picker.

Detection is the only stage that spawns anything, so it is the only one that
learns which candidate works. It now publishes that winner, and resolution
prefers it over a fresh first-hit walk. An explicit `*_BIN` override and a
packaged built-in still outrank it, a winner whose file has since vanished
is ignored, and detection clears the entry before each pass so a rescan
after a repair never resolves against a stale one.

This restores the invariant the file already documented — detection probes
the exact path the runtime will spawn — which the walk had broken.

Reported by @mrcfps in review.

Author: lefarcen

apps/daemon/src/runtimes/detection.ts

@@ -11,7 +11,11 @@ import { spawnEnvForAgent } from './env.js';
 import { probeAgentAuthStatus } from './auth.js';
 import { agentCapabilities } from './capabilities.js';
 import { installMetaForAgent } from './metadata.js';
-import { resolveAmrOpenCodeExecutable } from './executables.js';
+import {
+  forgetDetectedExecutable,
+  rememberDetectedExecutable,
+  resolveAmrOpenCodeExecutable,
+} from './executables.js';
 import { resolveAmrProfile } from '../integrations/vela.js';
 import {
   buildAuthDiagnostic,
@@ -254,6 +258,9 @@ async function probe(
   configuredEnv: Record<string, string> = {},
 ): Promise<DetectedAgent> {
   detectedRuntimeVersions.delete(def.id);
+  // Drop the previous winner before re-probing: a rescan after the user fixes
+  // or removes a CLI must not resolve against a stale one.
+  forgetDetectedExecutable(def.id);
   // Detection must probe the exact path the runtime will spawn, not just the
   // PATH-visible shim. This is load-bearing for Codex under nvm/fnm/mise:
   // the discovered `codex` entry is often a `#!/usr/bin/env node` wrapper
@@ -337,6 +344,14 @@ async function probe(
     );
     outcome = await probeVersionAtPath(def, next.launchPath, probeEnv);
   }
+  // Publish the executable this pass proved invocable, so chat, the connection
+  // test, and every other spawn site resolve to the same binary instead of
+  // redoing the naive first-hit-on-PATH walk. This restores the invariant
+  // stated above — detection probes the exact path the runtime will spawn —
+  // which the candidate walk would otherwise have broken.
+  if (outcome.kind !== 'not-invocable') {
+    rememberDetectedExecutable(def.id, launch.selectedPath);
+  }
   if (outcome.kind === 'not-invocable') {
     // Report the path that was actually tried. The agent picker only renders
     // an unavailable agent when it carries a path (that is what makes the

apps/daemon/src/runtimes/executables.ts

@@ -353,6 +353,39 @@ export function resolveAgentExecutable(
   return inspectAgentExecutableResolution(def, configuredEnv).selectedPath;
 }
 
+// The executable a completed detection pass settled on, per agent id.
+//
+// Detection is the only stage that learns which candidate can actually be
+// executed — it is the only one that spawns anything. Without recording that
+// answer, every later resolution (chat, connection test, memory summariser,
+// companion install) would redo the naive "first hit on PATH" walk and land
+// back on the very shim detection just rejected: Settings would advertise the
+// agent as installed while each turn exec'd a broken wrapper. Publishing the
+// winner here keeps detection and launch pointed at the same binary.
+const detectedExecutables = new Map<string, string>();
+
+/** Record the executable a detection pass proved invocable. */
+export function rememberDetectedExecutable(agentId: string, resolvedPath: string): void {
+  detectedExecutables.set(agentId, resolvedPath);
+}
+
+/**
+ * Drop an agent's remembered executable. Detection clears it before each pass
+ * so a re-scan after the user repairs or removes a CLI never resolves against
+ * a stale winner.
+ */
+export function forgetDetectedExecutable(agentId: string): void {
+  detectedExecutables.delete(agentId);
+}
+
+function rememberedExecutable(agentId: string, skip: Set<string>): string | null {
+  const remembered = detectedExecutables.get(agentId);
+  if (!remembered || skip.has(remembered)) return null;
+  // A remembered winner that has since been uninstalled must not outrank a
+  // live PATH walk.
+  return existsSync(remembered) ? remembered : null;
+}
+
 export function inspectAgentExecutableResolution(
   def: RuntimeAgentDef,
   configuredEnv: Record<string, string> = {},
@@ -380,12 +413,19 @@ export function inspectAgentExecutableResolution(
     ...(Array.isArray(def.fallbackBins) ? def.fallbackBins : []),
   ];
   const skip = new Set(options.skipPathCandidates ?? []);
-  let pathResolvedPath: string | null = null;
-  outer: for (const bin of candidates) {
-    for (const resolved of resolveAllOnPath(bin)) {
-      if (skip.has(resolved)) continue;
-      pathResolvedPath = resolved;
-      break outer;
+  // Prefer the candidate detection proved invocable over a fresh PATH walk,
+  // which would otherwise return the first file that merely *exists* — the
+  // broken shim detection already walked past. An explicit `*_BIN` override
+  // and a packaged built-in still outrank both (see the selectedPath order
+  // below), so this only replaces the guesswork, never a deliberate choice.
+  let pathResolvedPath: string | null = rememberedExecutable(def.id, skip);
+  if (!pathResolvedPath) {
+    outer: for (const bin of candidates) {
+      for (const resolved of resolveAllOnPath(bin)) {
+        if (skip.has(resolved)) continue;
+        pathResolvedPath = resolved;
+        break outer;
+      }
     }
   }
   const builtInPath = packagedBuiltInExecutable(def, configuredEnv);

apps/daemon/tests/runtimes/executable-fallback.test.ts

@@ -3,6 +3,7 @@ import { tmpdir } from 'node:os';
 import path from 'node:path';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 import { detectAgent } from '../../src/runtimes/detection.js';
+import { resolveAgentLaunch } from '../../src/runtimes/launch.js';
 import type { RuntimeAgentDef } from '../../src/runtimes/types.js';
 
 // A minimal agent def: no compatibility probe, so these cases isolate the
@@ -90,6 +91,31 @@ describe('agent executable resolution falls back past unusable candidates', () =
     expect(detected.version).toBe('0.1.0-rc.6');
   });
 
+  // Detection deciding an agent is usable is worthless if the spawn sites go
+  // back to the binary detection just rejected: Settings would advertise the
+  // agent as installed while every chat turn execs the broken shim. Detection
+  // and launch have to agree on which executable this agent runs.
+  it('makes every later launch resolve to the binary detection settled on', async () => {
+    if (process.platform === 'win32') return;
+    const brokenDir = tempDir('broken-launch');
+    const goodDir = tempDir('good-launch');
+    const brokenBin = writeBrokenShim(brokenDir);
+    const goodBin = writeWorkingShim(goodDir);
+
+    process.env.OD_AGENT_HOME = goodDir;
+    process.env.PATH = [brokenDir, goodDir].join(path.delimiter);
+
+    const detected = await detectAgent(def);
+    expect(detected.available).toBe(true);
+    expect(detected.path).toBe(goodBin);
+
+    // What chat, the connection test, memory-llm, and companion setup all call.
+    const launch = resolveAgentLaunch(def);
+    expect(launch.selectedPath).toBe(goodBin);
+    expect(launch.selectedPath).not.toBe(brokenBin);
+    expect(launch.launchPath).toBe(goodBin);
+  });
+
   // Even when every candidate is unusable, detection must surface the path it
   // actually tried. The picker hides an agent that reports no path at all, so
   // dropping it leaves the user with an invisible agent and no way to act.