Summary of Changes

Hello @jdx, I'm Gemini Code Assist¹! I'm currently reviewing this pull request and will post my feedback shortly. In the meantime, here's a summary to help you and other reviewers quickly get up to speed!

This pull request resolves a regression where mise x commands would bypass the PATH environment variable's order, specifically impacting virtual environment resolution. By removing a pre-resolution step, the system now correctly prioritizes binaries found earlier in the PATH, ensuring that tools like Python virtualenvs function as expected without reintroducing shim recursion issues.

Highlights

• Removed pre-resolution logic: The ts.which_bin() pre-resolution from Exec::run() that was introduced in fix(exec): strip shims from PATH on Unix to prevent infinite recursion #8276 has been removed.
• Restored PATH order for virtualenvs: This change ensures that the PATH order is respected, allowing virtualenv binaries (e.g., from _.python.venv configurations) to take precedence over mise-managed installations.
• Addressed regression: The previous pre-resolution bypassed PATH entirely for mise-managed tools, causing issues with virtualenv resolution, which this PR rectifies.
• Maintained shim recursion prevention: The shim stripping in exec_program (also from fix(exec): strip shims from PATH on Unix to prevent infinite recursion #8276) remains in place, continuing to prevent shim recursion without the need for the problematic pre-resolution.

Greptile Summary

This PR removes the ts.which_bin() pre-resolution that was introduced in #8276, which was bypassing PATH lookup and preventing virtualenv binaries from taking precedence over mise-managed tools.

Key changes:

• Removed the which_bin pre-resolution logic from Exec::run() that resolved bare program names to absolute mise-managed tool paths before PATH computation
• This allows exec_program to properly resolve binaries via the full PATH (which includes .venv/bin when _.python.venv is configured)
• Recursion protection remains intact via shim-stripping in exec_program, which was the other fix from fix(exec): strip shims from PATH on Unix to prevent infinite recursion #8276
• Added regression test test_exec_venv_path_order to verify venv binaries are found first

Rationale:
When which_bin pre-resolved python to ~/.local/share/mise/installs/python/3.9.1/bin/python, the absolute path skipped PATH lookup entirely, so .venv/bin/python added by _.python.venv was never considered. The fix correctly delegates all PATH resolution to exec_program where shims are stripped.

Confidence Score: 4/5

• This PR is safe to merge with low risk, though it changes execution resolution behavior
• The change correctly reverts problematic pre-resolution logic while keeping the essential shim-stripping recursion protection. The test suite covers both the new venv PATH order case and the original shim recursion case. The only risk is potential edge cases with wrapper scripts that aren't covered by shim-stripping alone, but the PR description indicates this was already tested.
• No files require special attention - the logic is straightforward and well-tested

Important Files Changed

Flowchart

%%{init: {'theme': 'neutral'}}%%
flowchart TD
    Start["`mise x -- python`"] --> ParseCmd["Parse command"]
    ParseCmd --> BuildEnv["Build env with PATH<br/>(includes .venv/bin if configured)"]
    BuildEnv --> ExecProg["exec_program(program, args, env)"]
    
    ExecProg --> CheckPath{Is program<br/>already a path?}
    CheckPath -->|Yes, contains /| UseAsIs["Use as-is"]
    CheckPath -->|No, bare name| StripShims["Strip shims from PATH"]
    
    StripShims --> WhichIn["which_in(program, filtered_path)"]
    WhichIn --> Found{Found?}
    Found -->|Yes| ResolvedPath["Use resolved path<br/>(e.g., .venv/bin/python)"]
    Found -->|No| Fallback["Fall back to original"]
    
    UseAsIs --> Exec["execvp()"]
    ResolvedPath --> Exec
    Fallback --> Exec
    
    style StripShims fill:#90EE90
    style WhichIn fill:#87CEEB
    style ResolvedPath fill:#FFD700

_{Last reviewed commit: d85ede1}

Hyperfine Performance

mise x -- echo

mise env

mise hook-env

mise ls

xtasks/test/perf

Greptile Summary

Reverts the ts.which_bin() pre-resolution introduced in PR #8276, which was breaking virtualenv PATH precedence by resolving bare tool names to absolute mise-managed paths before PATH computation.

• Removed Unix-only pre-resolution logic that bypassed PATH lookup for mise-managed tools
• The shim stripping mechanism in exec_program (kept from fix(exec): strip shims from PATH on Unix to prevent infinite recursion #8276) is sufficient to prevent both shim and wrapper script recursion
• When mise x runs, env_with_path prepends mise tool paths to PATH, ensuring mise-managed tools are found before wrapper scripts
• Added comprehensive regression tests for both the venv PATH ordering (fixed by this PR) and wrapper recursion (still prevented)

Confidence Score: 5/5

• This PR is safe to merge with minimal risk
• The change cleanly reverts problematic pre-resolution logic while preserving the shim stripping that prevents recursion. Both regression tests pass (venv PATH order and wrapper recursion), and the fix directly addresses the root cause of issue Bug: `mise x -- python` bypasses virtualenv after v2026.2.18 #8340 without introducing new complexity
• No files require special attention

Important Files Changed

Flowchart

%%{init: {'theme': 'neutral'}}%%
flowchart TD
    A[User runs: mise x -- python] --> B[Exec::run parses command]
    B --> C[Build toolset with mise config]
    C --> D[Install missing tools if needed]
    D --> E[Compute env_with_path]
    E --> F{PATH construction}
    F --> G[Prepend mise tool paths]
    G --> H[Add _.path entries like .venv/bin]
    H --> I[Add original PATH]
    I --> J[exec_program called with bare 'python']
    J --> K{Is program already absolute path?}
    K -->|Yes| L[Use as-is]
    K -->|No| M[Filter shims from PATH]
    M --> N[Use which_in to resolve]
    N --> O{Which binary found first?}
    O -->|.venv/bin/python| P[Execute venv python]
    O -->|mise python| Q[Execute mise python]
    O -->|wrapper script| R[Wrapper calls mise x again]
    R --> S[Recursive call prepends mise paths again]
    S --> T[Mise python found before wrapper]
    T --> Q

_{Last reviewed commit: b241665}