diff --git a/.github/ISSUE_TEMPLATE/feature-request.yml b/.github/ISSUE_TEMPLATE/feature-request.yml
index a7607565aa..070b3b3dae 100644
--- a/.github/ISSUE_TEMPLATE/feature-request.yml
+++ b/.github/ISSUE_TEMPLATE/feature-request.yml
@@ -1,5 +1,5 @@
 ---
-name: 🚀 Feature Request
+name: Feature Request
 description: Suggest an idea for this project
 title: "(topic): (short issue description)"
 labels: [feature-request, needs-triage]
diff --git a/.github/json_matrices/build-matrix.json b/.github/json_matrices/build-matrix.json
index 098a676f16..cf0d4038f4 100644
--- a/.github/json_matrices/build-matrix.json
+++ b/.github/json_matrices/build-matrix.json
@@ -81,5 +81,16 @@
         "IMAGE": "amazonlinux:latest",
         "PACKAGE_MANAGERS": [],
         "languages": ["python", "node", "java", "go"]
+    },
+    {
+        "OS": "windows",
+        "NAMED_OS": "windows",
+        "RUNNER": ["self-hosted", "windows", "x64"],
+        "ARCH": "x64",
+        "TARGET": "x86_64-pc-windows-msvc",
+        "PACKAGE_MANAGERS": ["maven"],
+        "languages": ["java"],
+        "run": "always",
+        "comment": "Self-hosted Windows runner for Java tests with remote Valkey cluster"
     }
 ]
diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml
index 0b1565f8b5..9b1f7f6c5f 100644
--- a/.github/workflows/codeql.yml
+++ b/.github/workflows/codeql.yml
@@ -85,12 +85,21 @@ jobs:
             - name: Install protoc compiler
               if: matrix.language == 'go'
               shell: bash
+              env:
+                  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
               run: |
                   # Check if protoc is already installed with correct version
                   if ! command -v protoc &> /dev/null || ! protoc --version | grep -q "29.1"; then
                       echo "Installing protoc 29.1..."
                       PB_REL="https://github.com/protocolbuffers/protobuf/releases"
-                      curl -LO $PB_REL/download/v29.1/protoc-29.1-linux-x86_64.zip
+                      
+                      # Add authentication header if token is available
+                      if [ -n "$GITHUB_TOKEN" ]; then
+                          curl -H "Authorization: Bearer $GITHUB_TOKEN" -LO $PB_REL/download/v29.1/protoc-29.1-linux-x86_64.zip
+                      else
+                          curl -LO $PB_REL/download/v29.1/protoc-29.1-linux-x86_64.zip
+                      fi
+                      
                       sudo unzip protoc-29.1-linux-x86_64.zip -d /usr/local
                       sudo chmod +x /usr/local/bin/protoc
                   else
@@ -125,12 +134,21 @@ jobs:
             - name: Build Java/Kotlin components
               if: matrix.language == 'java-kotlin'
               shell: bash
+              env:
+                  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
               run: |
                   # Check if protoc is already installed with correct version
                   if ! command -v protoc &> /dev/null || ! protoc --version | grep -q "29.1"; then
                       echo "Installing protoc 29.1..."
                       PB_REL="https://github.com/protocolbuffers/protobuf/releases"
-                      curl -LO $PB_REL/download/v29.1/protoc-29.1-linux-x86_64.zip
+                      
+                      # Add authentication header if token is available
+                      if [ -n "$GITHUB_TOKEN" ]; then
+                          curl -H "Authorization: Bearer $GITHUB_TOKEN" -LO $PB_REL/download/v29.1/protoc-29.1-linux-x86_64.zip
+                      else
+                          curl -LO $PB_REL/download/v29.1/protoc-29.1-linux-x86_64.zip
+                      fi
+                      
                       sudo unzip protoc-29.1-linux-x86_64.zip -d /usr/local
                       sudo chmod +x /usr/local/bin/protoc
                   else
diff --git a/.github/workflows/create-test-matrices/action.yml b/.github/workflows/create-test-matrices/action.yml
index b08dea10a4..f82e0f0394 100644
--- a/.github/workflows/create-test-matrices/action.yml
+++ b/.github/workflows/create-test-matrices/action.yml
@@ -20,6 +20,10 @@ inputs:
             - use-self-hosted
             - use-github
         default: false
+    run-with-windows-self-hosted:
+        description: "Include self-hosted Windows runners"
+        type: boolean
+        default: false
     containers:
         description: "Run in containers"
         required: true
@@ -46,12 +50,14 @@ runs:
               EVENT_NAME: ${{ github.event_name }}
               RUN_FULL_MATRIX: ${{ inputs.run-full-matrix }}
               RUN_WITH_MACOS: ${{ inputs.run-with-macos }}
+              RUN_WITH_WINDOWS_SELF_HOSTED: ${{ inputs.run-with-windows-self-hosted }}
               CONTAINERS: ${{ inputs.containers }}
               LANGUAGE_NAME: ${{ inputs.language-name }}
           run: |
               echo "EVENT_NAME=$EVENT_NAME" >> $GITHUB_ENV
               echo "RUN_FULL_MATRIX=$RUN_FULL_MATRIX" >> $GITHUB_ENV
               echo "RUN_WITH_MACOS=$RUN_WITH_MACOS" >> $GITHUB_ENV
+              echo "RUN_WITH_WINDOWS_SELF_HOSTED=$RUN_WITH_WINDOWS_SELF_HOSTED" >> $GITHUB_ENV
               echo "CONTAINERS=$CONTAINERS" >> $GITHUB_ENV
               echo "LANGUAGE_NAME=$LANGUAGE_NAME" >> $GITHUB_ENV
 
@@ -63,12 +69,16 @@ runs:
               echo 'Select server engines to run tests against'
               if [[ "$EVENT_NAME" == "pull_request" || "$EVENT_NAME" == "push" || "$RUN_FULL_MATRIX" == "false" ]]; then
                   echo 'Pick engines marked as `"run": "always"` only - on PR, push or manually triggered job which does not require full matrix'
-                  jq -c '[.[] | select(.run == "always")]' < .github/json_matrices/engine-matrix.json | awk '{ printf "engine-matrix=%s\n", $0 }' | tee -a $GITHUB_OUTPUT
+                  ENGINES=$(jq -c '[.[] | select(.run == "always")]' < .github/json_matrices/engine-matrix.json)
               else
                   echo 'Pick all engines - on cron (schedule) or if manually triggered job requires a full matrix'
-                  jq -c . < .github/json_matrices/engine-matrix.json | awk '{ printf "engine-matrix=%s\n", $0 }' | tee -a $GITHUB_OUTPUT
+                  ENGINES=$(jq -c . < .github/json_matrices/engine-matrix.json)
               fi
 
+              # Note: Redis 6.2 exclusion for Windows is handled in the host matrix filtering
+              # rather than globally excluding it from all platforms
+              echo "engine-matrix=$ENGINES" >> $GITHUB_OUTPUT
+
         - name: Load host matrix
           id: load-host-matrix
           shell: bash
@@ -78,8 +88,8 @@ runs:
               echo 'Select runners (VMs) to run tests on'
 
               if [[ "$EVENT_NAME" == "pull_request" || "$EVENT_NAME" == "push" || "$RUN_FULL_MATRIX" == "false" ]]; then
-                echo 'Getting "always run" runners'
-                BASE_MATRIX=$(jq -c '[.[] | select(.run == "always")]' < .github/json_matrices/build-matrix.json)
+                echo 'Getting "always run" runners for this language'
+                BASE_MATRIX=$(jq --arg lang "$LANGUAGE_NAME" -c '[.[] | select(.run == "always" and .languages? and any(.languages[] == $lang; .) and '"$CONDITION"')]' < .github/json_matrices/build-matrix.json)
               else
                 echo 'Getting full matrix for language excluding macOS'
                 BASE_MATRIX=$(jq --arg lang "$LANGUAGE_NAME" -c '[.[] | select(.languages? and any(.languages[] == $lang; .) and '"$CONDITION"' and .TARGET != "aarch64-apple-darwin")]' < .github/json_matrices/build-matrix.json)
@@ -97,6 +107,13 @@ runs:
               else
                 FINAL_MATRIX="$BASE_MATRIX"
               fi
+
+              # Add Windows self-hosted runners if specified
+              if [[ "$RUN_WITH_WINDOWS_SELF_HOSTED" == "true" ]]; then
+                echo "Including self-hosted Windows runners"
+                WIN_RUNNERS=$(jq --arg lang "$LANGUAGE_NAME" -c '[.[] | select(.languages? and any(.languages[] == $lang; .) and '"$CONDITION"' and .TARGET == "x86_64-pc-windows-msvc" and (.RUNNER == ["self-hosted","windows","x64"]))]' < .github/json_matrices/build-matrix.json)
+                FINAL_MATRIX=$(echo "$FINAL_MATRIX" "$WIN_RUNNERS" | jq -sc 'add')
+              fi
                         
               echo "host-matrix=$(echo $FINAL_MATRIX | tr -d '\n')" >> $GITHUB_OUTPUT
 
diff --git a/.github/workflows/dependabot-management.yml b/.github/workflows/dependabot-management.yml
index 8b259dff37..52e55551de 100644
--- a/.github/workflows/dependabot-management.yml
+++ b/.github/workflows/dependabot-management.yml
@@ -250,7 +250,7 @@ jobs:
                       }
 
                       // Add basic changelog information
-                      const changelog = `## Changelog\n\nUpdated ${depName} from ${fromVersion} to ${toVersion}\n\n📋 To view detailed changes, visit the package repository or release notes.`;
+                      const changelog = `## Changelog\n\nUpdated ${depName} from ${fromVersion} to ${toVersion}\n\n[INFO] To view detailed changes, visit the package repository or release notes.`;
                       
                       const newBody = `${body}\n\n${changelog}`;
                       
diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml
index 452e3b55f0..64e5565eee 100644
--- a/.github/workflows/go.yml
+++ b/.github/workflows/go.yml
@@ -152,8 +152,10 @@ jobs:
 
             - name: Install & build & test
               working-directory: go
+              shell: bash
               env:
                   RC_VERSION: ${{ github.event.inputs.rc-version }}
+                  CARGO_BUILD_JOBS: 1
               run: |
                   if [[ -n "$RC_VERSION" ]]; then
                     make install-tools
@@ -223,6 +225,8 @@ jobs:
 
             - name: Install and run linters
               working-directory: go
+              env:
+                  CARGO_BUILD_JOBS: 1
               run: |
                   make install-dev-tools install-build-tools gen-c-bindings generate-protobuf lint-ci
 
@@ -384,6 +388,7 @@ jobs:
 
             - name: Build and test
               working-directory: ./go
+              shell: bash
               env:
                   RC_VERSION: ${{ github.event.inputs.rc-version }}
               run: |
@@ -457,6 +462,7 @@ jobs:
 
             - name: Install & build & test
               working-directory: go
+              shell: bash
               env:
                   RC_VERSION: ${{ github.event.inputs.rc-version }}
               run: |
diff --git a/.github/workflows/install-rust-and-protoc/action.yml b/.github/workflows/install-rust-and-protoc/action.yml
index 9dee133a42..5af8b5a9a9 100644
--- a/.github/workflows/install-rust-and-protoc/action.yml
+++ b/.github/workflows/install-rust-and-protoc/action.yml
@@ -1,32 +1,241 @@
-name: Install Rust tool chain and protoc
-
-inputs:
-    target:
-        description: "Specified target for rust toolchain, ex. x86_64-apple-darwin"
-        type: string
-        required: false
-        default: "x86_64-unknown-linux-gnu"
-        options:
-            - x86_64-unknown-linux-gnu
-            - aarch64-unknown-linux-gnu
-            - x86_64-apple-darwin
-            - aarch64-apple-darwin
-    github-token:
-        description: "GitHub token"
-        type: string
-        required: true
+name: Install Rust and protoc
+description: Install Rust toolchain and protobuf compiler
 
 runs:
     using: "composite"
     steps:
-        - name: Install Rust toolchain
+        - name: Install Rust toolchain (Windows)
+          if: runner.os == 'Windows'
+          shell: powershell
+          run: |
+              Write-Host "Checking for existing Rust installation..."
+
+              # Check for Chocolatey Rust installation specifically
+              $rustcPath = "$env:ProgramFiles\Rust stable MSVC 1.82\bin\rustc.exe"
+              if (Test-Path $rustcPath) {
+                  Write-Host "Rust already installed - skipping installation"
+                  & $rustcPath --version
+              } else {
+                  Write-Host "Installing Rust with MSVC toolchain via Chocolatey..."
+
+              if (Get-Command choco -ErrorAction SilentlyContinue) {
+                  choco install rust-ms -y
+                  
+                  # Refresh PATH
+                  $env:PATH = [System.Environment]::GetEnvironmentVariable("PATH","Machine") + ";" + [System.Environment]::GetEnvironmentVariable("PATH","User")
+                  
+                  # Add cargo bin directory to PATH
+                  $cargoBin = "$env:USERPROFILE\.cargo\bin"
+                  if (Test-Path $cargoBin) {
+                      $env:PATH = "$cargoBin;$env:PATH"
+                      echo $cargoBin >> $env:GITHUB_PATH
+                      Write-Host "Added cargo bin to PATH: $cargoBin"
+                  }
+                  
+                  # Verify installation
+                  if (Get-Command rustc -ErrorAction SilentlyContinue) {
+                      $version = rustc --version
+                      Write-Host "Rust installed successfully: $version"
+                      
+                      # Install rustfmt and clippy components
+                      Write-Host "Installing rustfmt and clippy..."
+                      rustup component add rustfmt clippy
+                      
+                      # Add MSVC tools to PATH so Rust can find link.exe
+                      Write-Host "Adding VS 2022 MSVC tools to PATH..."
+                      
+                      $vs2022Paths = @(
+                          "${env:ProgramFiles}\Microsoft Visual Studio\2022\BuildTools\VC\Tools\MSVC",
+                          "${env:ProgramFiles(x86)}\Microsoft Visual Studio\2022\BuildTools\VC\Tools\MSVC"
+                      )
+                      
+                      $msvcFound = $false
+                      foreach ($msvcDir in $vs2022Paths) {
+                          if (Test-Path $msvcDir) {
+                              Write-Host "Found VS 2022 MSVC directory: $msvcDir"
+                              $msvcVersions = Get-ChildItem $msvcDir -Directory | Sort-Object Name -Descending
+                              if ($msvcVersions) {
+                                  $latestMsvc = $msvcVersions[0]
+                                  $msvcBin = "$($latestMsvc.FullName)\bin\Hostx64\x64"
+                                  
+                                  if (Test-Path "$msvcBin\link.exe") {
+                                      $env:PATH = "$msvcBin;$env:PATH"
+                                      echo $msvcBin >> $env:GITHUB_PATH
+                                      Write-Host "SUCCESS: Added MSVC bin to PATH: $msvcBin"
+                                      
+                                      # Run vcvars64.bat to set up MSVC environment
+                                      $vcvarsPath = "$($latestMsvc.Parent.Parent.Parent.FullName)\Auxiliary\Build\vcvars64.bat"
+                                      if (Test-Path $vcvarsPath) {
+                                          Write-Host "Running vcvars64.bat: $vcvarsPath"
+                                          
+                                          # Use PowerShell to call vcvars and capture environment
+                                          $psi = New-Object System.Diagnostics.ProcessStartInfo
+                                          $psi.FileName = "cmd.exe"
+                                          $psi.Arguments = "/c `"$vcvarsPath`" && set"
+                                          $psi.RedirectStandardOutput = $true
+                                          $psi.UseShellExecute = $false
+                                          $psi.CreateNoWindow = $true
+                                          
+                                          $process = [System.Diagnostics.Process]::Start($psi)
+                                          $output = $process.StandardOutput.ReadToEnd()
+                                          $process.WaitForExit()
+                                          
+                                          Write-Host "vcvars64.bat exit code: $($process.ExitCode)"
+                                          
+                                          # Parse and set environment variables
+                                          $libSet = $false
+                                          foreach ($line in $output -split "`n") {
+                                              if ($line -match "^([^=]+)=(.*)$") {
+                                                  $name = $matches[1].Trim()
+                                                  $value = $matches[2].Trim()
+                                                  if ($name -eq "LIB") {
+                                                      Write-Host "LIB from vcvars: $value"
+                                                      [System.Environment]::SetEnvironmentVariable($name, $value, "Process")
+                                                      echo "$name=$value" >> $env:GITHUB_ENV
+                                                      $libSet = $true
+                                                  } elseif ($name -in @("LIBPATH", "INCLUDE")) {
+                                                      Write-Host "$name from vcvars: $value"
+                                                      [System.Environment]::SetEnvironmentVariable($name, $value, "Process")
+                                                      echo "$name=$value" >> $env:GITHUB_ENV
+                                                  }
+                                              }
+                                          }
+                                          
+                                          if ($libSet) {
+                                              Write-Host "MSVC environment configured via vcvars64.bat"
+                                          } else {
+                                              Write-Host "ERROR: LIB variable not set by vcvars64.bat"
+                                              Write-Host "vcvars64.bat output:"
+                                              Write-Host $output
+                                          }
+                                      } else {
+                                          Write-Host "ERROR: vcvars64.bat not found at $vcvarsPath"
+                                      }
+                                      
+                                      $msvcFound = $true
+                                      break
+                                  }
+                              }
+                          }
+                      }
+                      
+                      if (-not $msvcFound) {
+                          Write-Host "ERROR: Could not find VS 2022 MSVC tools"
+                          exit 1
+                      }
+                      
+                      Write-Host "Rust MSVC toolchain installed successfully"
+                  } else {
+                      Write-Host "Rust installation failed"
+                      exit 1
+                  }
+              } else {
+                  Write-Host "Chocolatey not available - cannot install Rust"
+                  exit 1
+              }
+              }
+
+        - name: Install Rust toolchain (Unix)
+          if: runner.os != 'Windows'
           uses: dtolnay/rust-toolchain@stable
           with:
-              targets: ${{ inputs.target }}
               components: rustfmt, clippy
 
         - name: Install protoc (protobuf)
+          if: runner.os != 'Windows'
           uses: arduino/setup-protoc@v3
           with:
-              version: "25.1"
-              repo-token: ${{ inputs.github-token }}
+              version: "29.1"
+              repo-token: ${{ github.token }}
+
+        - name: Install protoc (Windows)
+          if: runner.os == 'Windows'
+          shell: powershell
+          run: |
+              Write-Host "Checking for existing protoc installation..."
+
+              # Check for protoc in the specific installation path we use
+              $protocPath = "C:\protoc\bin\protoc.exe"
+              if (Test-Path $protocPath) {
+                  Write-Host "protoc already installed - skipping installation"
+                  & $protocPath --version
+                  
+                  # Ensure protoc is in PATH for subsequent steps
+                  $protocBin = "C:\protoc\bin"
+                  echo $protocBin >> $env:GITHUB_PATH
+                  $env:PATH = "$protocBin;$env:PATH"
+              } else {
+                  Write-Host "Installing protoc version 29.1 via direct download..."
+
+              $protocUrl = "https://github.com/protocolbuffers/protobuf/releases/download/v29.1/protoc-29.1-win64.zip"
+              $protocZip = "$env:TEMP\protoc-29.1-win64.zip"
+              $protocDir = "C:\protoc"
+
+              Write-Host "Downloading protoc 29.1..."
+              Invoke-WebRequest -Uri $protocUrl -OutFile $protocZip
+
+              Write-Host "Extracting protoc..."
+              Expand-Archive -Path $protocZip -DestinationPath $protocDir -Force
+
+              $protocBin = "$protocDir\bin"
+              $env:PATH = "$protocBin;$env:PATH"
+              echo $protocBin >> $env:GITHUB_PATH
+
+              Remove-Item $protocZip -Force -ErrorAction SilentlyContinue
+
+              if (Get-Command protoc -ErrorAction SilentlyContinue) {
+                  $version = protoc --version
+                  Write-Host "protoc installed successfully: $version"
+              } else {
+                  Write-Host "protoc installation may have failed"
+                  exit 1
+              }
+              }
+
+        - name: Verify Rust installation (Windows)
+          if: runner.os == 'Windows'
+          shell: powershell
+          run: |
+              Write-Host "Rust version:"
+              rustc --version
+              Write-Host "Cargo version:"
+              cargo --version
+              Write-Host "Rustfmt version:"
+              rustfmt --version
+              Write-Host "Clippy version:"
+              cargo clippy --version
+
+        - name: Verify Rust installation (Unix)
+          if: runner.os != 'Windows'
+          shell: bash
+          run: |
+              echo "Rust version:"
+              rustc --version
+              echo "Cargo version:"
+              cargo --version
+              echo "Rustfmt version:"
+              rustfmt --version
+              echo "Clippy version:"
+              cargo clippy --version
+
+        - name: Verify protoc installation (Windows)
+          if: runner.os == 'Windows'
+          shell: powershell
+          run: |
+              Write-Host "Protoc version:"
+
+              # Check for protoc in the specific installation path we use
+              $protocPath = "C:\protoc\bin\protoc.exe"
+              if (Test-Path $protocPath) {
+                  & $protocPath --version
+              } else {
+                  Write-Host "protoc not found at expected location: $protocPath"
+                  exit 1
+              }
+
+        - name: Verify protoc installation (Unix)
+          if: runner.os != 'Windows'
+          shell: bash
+          run: |
+              echo "Protoc version:"
+              protoc --version
diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index 5ae71e53bb..0309d30f25 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -9,6 +9,7 @@ inputs:
             - amazon-linux
             - macos
             - ubuntu
+            - windows
     target:
         description: "Specified target for rust toolchain, ex. x86_64-apple-darwin"
         type: string
@@ -21,10 +22,15 @@ inputs:
             - aarch64-apple-darwin
             - aarch64-unknown-linux-musl
             - x86_64-unknown-linux-musl
+            - x86_64-pc-windows-msvc
     engine-version:
         description: "Engine version to install"
         required: false
         type: string
+    language:
+        description: "The language being built (optional, for language-specific setup)"
+        required: false
+        type: string
     github-token:
         description: "GITHUB_TOKEN, GitHub App installation access token"
         required: true
@@ -62,19 +68,335 @@ runs:
           run: |
               yum install -y gcc pkgconfig openssl openssl-devel which curl gettext libasan tar --allowerasing
 
-        - name: Install Rust toolchain and protoc
-          if: "${{ !contains(inputs.target, 'musl') }}"
-          uses: ./.github/workflows/install-rust-and-protoc
+        - name: Setup Windows dependencies
+          if: "${{ runner.os == 'Windows' && runner.environment != 'github-hosted' }}"
+          uses: ./.github/workflows/setup-windows-dependencies
           with:
-              target: ${{ inputs.target }}
               github-token: ${{ inputs.github-token }}
 
+        - name: Check Windows build dependencies
+          if: "${{ runner.os == 'Windows' }}"
+          id: check-deps
+          shell: powershell
+          run: |
+              Write-Host "Checking Windows build dependencies..."
+
+              # Debug: Show PATH and available Python commands
+              Write-Host "PATH contains:"
+              $env:PATH -split ';' | Where-Object { $_ -like '*python*' -or $_ -like '*Python*' } | ForEach-Object { Write-Host "  $_" }
+
+              Write-Host "Available Python commands:"
+              Get-Command python* -ErrorAction SilentlyContinue | ForEach-Object { Write-Host "  $($_.Name) -> $($_.Source)" }
+
+              # Check Windows registry for Python installations
+              Write-Host "Checking Windows registry for Python..."
+              $regPaths = @(
+                  "HKLM:\SOFTWARE\Python\PythonCore\*\InstallPath",
+                  "HKCU:\SOFTWARE\Python\PythonCore\*\InstallPath",
+                  "HKLM:\SOFTWARE\WOW6432Node\Python\PythonCore\*\InstallPath"
+              )
+
+              foreach ($regPath in $regPaths) {
+                  try {
+                      Get-ItemProperty $regPath -ErrorAction SilentlyContinue | ForEach-Object {
+                          $installPath = $_.'(default)'
+                          if ($installPath -and (Test-Path $installPath)) {
+                              Write-Host "  Registry: $installPath"
+                              $pythonExe = Join-Path $installPath "python.exe"
+                              if (Test-Path $pythonExe) {
+                                  Write-Host "    Found: $pythonExe"
+                              }
+                          }
+                      }
+                  } catch { }
+              }
+
+              # Check common installation directories
+              Write-Host "Checking common Python installation paths..."
+              $commonPaths = @(
+                  "$env:LOCALAPPDATA\Programs\Python\Python*",
+                  "$env:PROGRAMFILES\Python*",
+                  "$env:PROGRAMFILES(x86)\Python*",
+                  "C:\Python*",
+                  "$env:APPDATA\Local\Programs\Python\Python*"
+              )
+
+              foreach ($pathPattern in $commonPaths) {
+                  Get-ChildItem $pathPattern -Directory -ErrorAction SilentlyContinue | ForEach-Object {
+                      $pythonExe = Join-Path $_.FullName "python.exe"
+                      if (Test-Path $pythonExe) {
+                          Write-Host "  Found: $pythonExe"
+                          try {
+                              $version = & $pythonExe --version 2>&1
+                              Write-Host "    Version: $version"
+                          } catch {
+                              Write-Host "    Version check failed"
+                          }
+                      }
+                  }
+              }
+
+              # Check Python3
+              $python3Available = $false
+
+              # Method 1: Check for python3 command
+              if (Get-Command python3 -ErrorAction SilentlyContinue) {
+                  try {
+                      $version = python3 --version 2>&1
+                      if ($version -match "Python 3\." -and $version -notmatch "Microsoft Store" -and $version -notmatch "not found") {
+                          $python3Available = $true
+                          Write-Host "Python3 command found: $version"
+                      } else {
+                          Write-Host "Python3 command exists but not functional: $version"
+                      }
+                  } catch {
+                      Write-Host "Python3 command exists but version check failed: $_"
+                  }
+              }
+              # Method 2: Check for python command  
+              elseif (Get-Command python -ErrorAction SilentlyContinue) {
+                  try {
+                      $version = python --version 2>&1
+                      if ($version -match "Python 3\.") {
+                          $python3Available = $true
+                          Write-Host "Python 3.x found via python command: $version"
+                      } else {
+                          Write-Host "Python found but not version 3.x: $version"
+                      }
+                  } catch {
+                      Write-Host "Python command exists but version check failed"
+                  }
+              }
+              # Method 3: Check common installation paths
+              else {
+                  $commonPaths = @(
+                      "$env:LOCALAPPDATA\Programs\Python\Python*\python.exe",
+                      "$env:PROGRAMFILES\Python*\python.exe",
+                      "$env:PROGRAMFILES(x86)\Python*\python.exe",
+                      "C:\Python*\python.exe"
+                  )
+                  
+                  foreach ($path in $commonPaths) {
+                      $found = Get-ChildItem $path -ErrorAction SilentlyContinue | Select-Object -First 1
+                      if ($found) {
+                          try {
+                              $version = & $found.FullName --version 2>&1
+                              if ($version -match "Python 3\.") {
+                                  $python3Available = $true
+                                  Write-Host "Python 3.x found at: $($found.FullName) - $version"
+                                  break
+                              }
+                          } catch {
+                              Write-Host "Found Python at $($found.FullName) but version check failed"
+                          }
+                      }
+                  }
+              }
+
+              if (-not $python3Available) {
+                  Write-Host "No Python 3.x installation detected"
+                  
+                  # Try to install Python via Chocolatey on Windows
+                  if ($IsWindows -or $env:OS -eq "Windows_NT") {
+                      Write-Host "Attempting to install Python via Chocolatey..."
+                      
+                      # Check if Chocolatey is available
+                      if (Get-Command choco -ErrorAction SilentlyContinue) {
+                          Write-Host "Installing Python 3 via Chocolatey..."
+                          choco install python3 -y
+                          
+                          if ($LASTEXITCODE -eq 0) {
+                              Write-Host "Python installed successfully via Chocolatey"
+                              # Refresh PATH
+                              $env:PATH = [System.Environment]::GetEnvironmentVariable("PATH","Machine") + ";" + [System.Environment]::GetEnvironmentVariable("PATH","User")
+                              
+                              # Verify installation
+                              try {
+                                  $version = python --version 2>&1
+                                  if ($version -match "Python 3\.") {
+                                      $python3Available = $true
+                                      Write-Host "Python verification successful: $version"
+                                  }
+                              } catch {
+                                  Write-Host "Python installation verification failed"
+                              }
+                          } else {
+                              Write-Host "Chocolatey Python installation failed"
+                          }
+                      } else {
+                          Write-Host "Chocolatey not available for Python installation"
+                      }
+                  }
+              }
+
+              # Check Rust (should be installed by install-rust-and-protoc action)
+              $rustAvailable = $false
+              try {
+                  rustc --version
+                  cargo --version
+                  $rustAvailable = $true
+                  Write-Host "Rust toolchain already available"
+              } catch {
+                  Write-Host "Rust toolchain will be installed by install-rust-and-protoc action"
+              }
+
+              # Check SSH client
+              $sshAvailable = $false
+              try {
+                  ssh -V 2>$null
+                  $sshAvailable = $true
+                  Write-Host "SSH client available"
+              } catch {
+                  Write-Host "SSH client not found"
+              }
+
+              # Set outputs for conditional steps
+              echo "python3-available=$python3Available" >> $env:GITHUB_OUTPUT
+              echo "rust-available=$rustAvailable" >> $env:GITHUB_OUTPUT
+              echo "ssh-available=$sshAvailable" >> $env:GITHUB_OUTPUT
+
+              Write-Host "Dependency check complete"
+              Write-Host "Results: python3-available=$python3Available, rust-available=$rustAvailable, ssh-available=$sshAvailable"
+
+        - name: Show Python detection results
+          if: "${{ runner.os == 'Windows' }}"
+          shell: powershell
+          run: |
+              Write-Host "Python detection results:"
+              Write-Host "  python3-available: ${{ steps.check-deps.outputs.python3-available }}"
+              Write-Host "  Runner type: ${{ runner.name }}"
+              Write-Host "  Runner environment: ${{ runner.environment }}"
+              Write-Host "  Is GitHub-hosted: ${{ runner.environment == 'github-hosted' }}"
+              Write-Host "  Will install Python: ${{ runner.os == 'Windows' && steps.check-deps.outputs.python3-available != 'true' }}"
+
+        - name: Install Python for Windows (self-hosted)
+          if: "${{ runner.os == 'Windows' && steps.check-deps.outputs.python3-available != 'true' }}"
+          shell: powershell
+          run: |
+              Write-Host "Installing Python via Chocolatey for self-hosted runner..."
+
+              # Refresh PATH to pick up Chocolatey from previous step
+              $env:PATH = [System.Environment]::GetEnvironmentVariable("PATH","Machine") + ";" + [System.Environment]::GetEnvironmentVariable("PATH","User")
+
+              # Also add Chocolatey bin directory explicitly
+              $chocoPath = "C:\ProgramData\chocolatey\bin"
+              if (Test-Path $chocoPath) {
+                  $env:PATH = "$chocoPath;$env:PATH"
+                  Write-Host "Added Chocolatey to PATH: $chocoPath"
+              }
+
+              # Check if Chocolatey is available
+              if (Get-Command choco -ErrorAction SilentlyContinue) {
+                  Write-Host "Installing Python 3 via Chocolatey..."
+                  choco install python3 -y
+                  
+                  if ($LASTEXITCODE -eq 0) {
+                      Write-Host "Python installed successfully via Chocolatey"
+                      # Refresh PATH again for Python
+                      $env:PATH = [System.Environment]::GetEnvironmentVariable("PATH","Machine") + ";" + [System.Environment]::GetEnvironmentVariable("PATH","User")
+                      
+                      # Verify installation
+                      try {
+                          $version = python --version 2>&1
+                          Write-Host "Python verification successful: $version"
+                      } catch {
+                          Write-Host "Python installation verification failed"
+                      }
+                  } else {
+                      Write-Host "Chocolatey Python installation failed"
+                      exit 1
+                  }
+              } else {
+                  Write-Host "Error: Chocolatey not available for Python installation"
+                  Write-Host "Current PATH: $env:PATH"
+                  exit 1
+              }
+
+        - name: Cache Valkey build
+          if: "${{ inputs.engine-version != '' }}"
+          uses: actions/cache@v4
+          id: cache-valkey
+          with:
+              path: |
+                  valkey-cache/valkey-server
+                  valkey-cache/valkey-cli
+                  valkey-cache/valkey-benchmark
+              key: valkey-${{ inputs.engine-version }}-${{ inputs.os }}-${{ inputs.target }}-${{ github.sha }}
+              restore-keys: |
+                  valkey-${{ inputs.engine-version }}-${{ inputs.os }}-${{ inputs.target }}-
+
         - name: Install engine
-          if: "${{ inputs.engine-version }}"
-          uses: ./.github/workflows/install-engine
+          shell: bash
+          if: "${{ inputs.engine-version != '' && steps.cache-valkey.outputs.cache-hit == 'true' && inputs.os != 'windows' }}"
+          env:
+              ENGINE_VERSION: ${{ inputs.engine-version }}
+              OS_TYPE: ${{ inputs.os }}
+          run: |
+              echo "Using cached Valkey binaries"
+              echo "OS_TYPE: '$OS_TYPE'"
+              echo "ENGINE_VERSION: '$ENGINE_VERSION'"
+              # Clone repo fresh
+              git clone https://github.com/valkey-io/valkey.git
+              cd valkey && git checkout "$ENGINE_VERSION"
+              # Move cached binaries to correct location (force overwrite)
+              mkdir -p src
+              cp -f ../valkey-cache/* src/ 2>/dev/null || true
+              # Install the cached binaries
+              sudo make install
+
+        - name: Build engine from source
+          shell: bash
+          if: "${{ inputs.engine-version != '' && steps.cache-valkey.outputs.cache-hit != 'true' && inputs.os != 'windows' }}"
+          env:
+              ENGINE_VERSION: ${{ inputs.engine-version }}
+              OS_TYPE: ${{ inputs.os }}
+          run: |
+              echo "Building Valkey from source"
+              echo "OS_TYPE: '$OS_TYPE'"
+              echo "ENGINE_VERSION: '$ENGINE_VERSION'"
+              # Install dependencies (only needed on Linux, Windows handled by Vampire)
+              if [ "$OS_TYPE" != "windows" ]; then
+                  sudo apt install -y build-essential git pkg-config libssl-dev
+              fi
+              git clone https://github.com/valkey-io/valkey.git
+              cd valkey && git checkout "$ENGINE_VERSION" && make -j$(nproc) BUILD_TLS=yes
+              # Cache the built binaries - detect which naming convention is used
+              mkdir -p ../valkey-cache
+              if [ -f "src/valkey-server" ]; then
+                  echo "Found Valkey binaries"
+                  cp -f src/valkey-server src/valkey-cli src/valkey-benchmark ../valkey-cache/ 2>/dev/null || true
+              elif [ -f "src/redis-server" ]; then
+                  echo "Found Redis binaries"
+                  cp -f src/redis-server src/redis-cli src/redis-benchmark ../valkey-cache/ 2>/dev/null || true
+              else
+                  echo "Warning: No server binaries found to cache"
+              fi
+              # Install the binaries
+              sudo make install
+
+        - name: Start engine server
+          shell: bash
+          if: "${{ inputs.engine-version && inputs.os != 'windows' }}"
+          env:
+              OS_TYPE: ${{ inputs.os }}
+          run: |
+              echo "Starting Valkey server locally"
+              echo "OS_TYPE: '$OS_TYPE'"
+
+              # Start Valkey server in background
+              redis-server --daemonize yes --bind 0.0.0.0 --port 6379
+
+              # For Windows, write IP to a file that PowerShell can read
+              if [ "$OS_TYPE" = "windows" ]; then
+                  hostname -I | awk '{print $1}' > /tmp/wsl_ip.txt
+              fi
+
+        - name: Install Rust toolchain and protoc
+          if: "${{ !contains(inputs.target, 'musl') }}"
+          uses: ./.github/workflows/install-rust-and-protoc
           with:
-              engine-version: ${{ inputs.engine-version }}
               target: ${{ inputs.target }}
+              github-token: ${{ inputs.github-token }}
 
         - name: Install zig
           if: ${{ contains(inputs.target, 'linux-gnu') }}
diff --git a/.github/workflows/java.yml b/.github/workflows/java.yml
index 51571c21b7..0caae27294 100644
--- a/.github/workflows/java.yml
+++ b/.github/workflows/java.yml
@@ -50,6 +50,10 @@ on:
                     - use-self-hosted
                     - use-github
                 default: false
+            use-windows-self-hosted:
+                description: "Use self-hosted Windows runner"
+                type: boolean
+                default: false
             name:
                 required: false
                 type: string
@@ -90,17 +94,23 @@ jobs:
                   # Run full test matrix if job started by cron or it was explictly specified by a person who triggered the workflow
                   run-full-matrix: ${{ github.event.inputs.full-matrix == 'true' || github.event_name == 'schedule' }}
                   run-with-macos: ${{ (github.event.inputs.run-with-macos) }}
+                  # Use Windows self-hosted runner with VPC Linux instance by default for code changes
+                  run-with-windows-self-hosted: ${{ github.event.inputs.use-windows-self-hosted == 'true' || github.event_name == 'push' || github.event_name == 'pull_request' }}
 
     test-java:
         name: Java Tests - ${{ matrix.java }}, EngineVersion - ${{ matrix.engine.version }}, Target - ${{ matrix.host.TARGET }}
         needs: get-matrices
-        timeout-minutes: 35
+        timeout-minutes: ${{ matrix.host.OS == 'windows' && 60 || 35 }}
         strategy:
             fail-fast: false
             matrix:
                 java: ${{ fromJson(needs.get-matrices.outputs.version-matrix-output) }}
                 engine: ${{ fromJson(needs.get-matrices.outputs.engine-matrix-output) }}
                 host: ${{ fromJson(needs.get-matrices.outputs.host-matrix-output) }}
+                exclude:
+                    # Exclude Redis 6.2 on Windows (not supported)
+                    - engine: { type: "redis", version: "6.2" }
+                      host: { OS: "windows" }
         runs-on: ${{ matrix.host.RUNNER }}
 
         steps:
@@ -125,9 +135,11 @@ jobs:
                   os: ${{ matrix.host.OS }}
                   target: ${{ matrix.host.TARGET }}
                   github-token: ${{ secrets.GITHUB_TOKEN }}
-                  engine-version: ${{ matrix.engine.version }}
+                  engine-version: ${{ matrix.host.OS == 'windows' && '' || matrix.engine.version }}
+                  language: java
 
             - name: Install protoc (protobuf)
+              if: runner.os != 'Windows'
               uses: arduino/setup-protoc@v3
               with:
                   version: "29.1"
@@ -153,13 +165,59 @@ jobs:
                   restore-keys: |
                       ${{ runner.os }}-gradle-
 
-            - name: Build java client
+            - name: Setup Python3 for Windows
+              if: ${{ matrix.host.OS == 'windows' }}
+              shell: powershell
+              run: |
+                  # Create python3 symlink for Windows if python exists
+                  if (Get-Command python -ErrorAction SilentlyContinue) {
+                      $pythonPath = (Get-Command python).Source
+                      $python3Path = Join-Path (Split-Path $pythonPath) "python3.exe"
+                      if (-not (Test-Path $python3Path)) {
+                          New-Item -ItemType HardLink -Path $python3Path -Target $pythonPath -Force
+                          Write-Host "python3 symlink created"
+                      } else {
+                          Write-Host "python3 already exists"
+                      }
+                  } else {
+                      Write-Host "python command not found, skipping symlink creation"
+                  }
+
+            - name: Build java client (Windows)
+              if: ${{ matrix.host.OS == 'windows' }}
+              working-directory: java
+              env:
+                  CARGO_BUILD_JOBS: ${{ github.runner_cores || '2' }}
+                  SSH_PRIVATE_KEY_CONTENT: ${{ secrets.VALKEY_REMOTE_SSH_KEY }}
+                  VALKEY_REMOTE_HOST: ${{ vars.VALKEY_REMOTE_HOST }}
+                  NPM_SCOPE: ${{ vars.NPM_SCOPE }}
+              run: |
+                  # Stop any existing Gradle daemons to avoid compatibility issues
+                  .\gradlew.bat --stop                
+                  .\gradlew.bat --no-build-cache --no-daemon --continue build test -x javadoc "-Dengine-version=${{ matrix.engine.version }}" -DfocusTests=true
+
+            - name: Build java client (Linux/macOS)
+              if: ${{ matrix.host.OS != 'windows' }}
+              working-directory: java
+              env:
+                  CARGO_BUILD_JOBS: ${{ github.runner_cores || '2' }}
+              shell: bash
+              run: |
+                  ./gradlew --build-cache --continue build test -x javadoc "-Dengine-version=${{ matrix.engine.version }}"
+
+            - name: Ensure no skipped files by linter (Windows)
+              if: ${{ matrix.host.OS == 'windows' }}
               working-directory: java
-              run: ./gradlew --build-cache --continue build test -x javadoc
+              shell: powershell
+              run: |
+                  .\gradlew.bat --build-cache spotlessDiagnose | Select-String 'All formatters are well behaved for all files'
 
-            - name: Ensure no skipped files by linter
+            - name: Ensure no skipped files by linter (Linux/macOS)
+              if: ${{ matrix.host.OS != 'windows' }}
               working-directory: java
-              run: ./gradlew --build-cache spotlessDiagnose | grep 'All formatters are well behaved for all files'
+              shell: bash
+              run: |
+                  ./gradlew --build-cache spotlessDiagnose | grep 'All formatters are well behaved for all files'
 
             - uses: ./.github/workflows/test-benchmark
               if: ${{ matrix.engine.version == '8.0' && matrix.host.RUNNER == 'ubuntu-latest' && matrix.java == '17' }}
@@ -182,13 +240,17 @@ jobs:
     test-pubsub:
         name: Java PubSubTests - ${{ matrix.java }}, EngineVersion - ${{ matrix.engine.version }}, Target - ${{ matrix.host.TARGET }}
         needs: get-matrices
-        timeout-minutes: 35
+        timeout-minutes: ${{ matrix.host.OS == 'windows' && 60 || 35 }}
         strategy:
             fail-fast: false
             matrix:
                 java: ${{ fromJson(needs.get-matrices.outputs.version-matrix-output) }}
                 engine: ${{ fromJson(needs.get-matrices.outputs.engine-matrix-output) }}
                 host: ${{ fromJson(needs.get-matrices.outputs.host-matrix-output) }}
+                exclude:
+                    # Exclude Redis 6.2 on Windows (not supported)
+                    - engine: { type: "redis", version: "6.2" }
+                      host: { OS: "windows" }
         runs-on: ${{ matrix.host.RUNNER }}
 
         steps:
@@ -211,9 +273,11 @@ jobs:
                   os: ${{ matrix.host.OS }}
                   target: ${{ matrix.host.TARGET }}
                   github-token: ${{ secrets.GITHUB_TOKEN }}
-                  engine-version: ${{ matrix.engine.version }}
+                  engine-version: ${{ matrix.host.OS == 'windows' && '' || matrix.engine.version }}
+                  language: java
 
             - name: Install protoc (protobuf)
+              if: runner.os != 'Windows'
               uses: arduino/setup-protoc@v3
               with:
                   version: "29.1"
@@ -239,9 +303,29 @@ jobs:
                   restore-keys: |
                       ${{ runner.os }}-gradle-
 
-            - name: Test pubsub
+            - name: Test pubsub (Windows)
+              if: ${{ matrix.host.OS == 'windows' }}
+              working-directory: java
+              shell: powershell
+              env:
+                  CARGO_BUILD_JOBS: ${{ github.runner_cores || '2' }}
+                  SSH_PRIVATE_KEY_CONTENT: ${{ secrets.VALKEY_REMOTE_SSH_KEY }}
+                  VALKEY_REMOTE_HOST: ${{ vars.VALKEY_REMOTE_HOST }}
+              run: |
+                  # Stop any existing Gradle daemons to avoid compatibility issues
+                  .\gradlew.bat --stop
+
+                  # Run the pubsub tests with info logging
+                  .\gradlew.bat --build-cache --info :integTest:pubsubTest "-Dengine-version=${{ matrix.engine.version }}"
+
+            - name: Test pubsub (Linux/macOS)
+              if: ${{ matrix.host.OS != 'windows' }}
               working-directory: java
-              run: ./gradlew --build-cache :integTest:pubsubTest
+              shell: bash
+              env:
+                  CARGO_BUILD_JOBS: ${{ github.runner_cores || '2' }}
+              run: |
+                  ./gradlew --build-cache :integTest:pubsubTest "-Dengine-version=${{ matrix.engine.version }}"
 
             - name: Upload test & spotbugs reports
               if: always()
@@ -319,9 +403,11 @@ jobs:
                   os: ${{ matrix.host.OS }}
                   target: ${{ matrix.host.TARGET }}
                   github-token: ${{ secrets.GITHUB_TOKEN }}
-                  engine-version: ${{ matrix.engine.version }}
+                  language: java
+                  engine-version: ${{ matrix.host.OS == 'windows' && '' || matrix.engine.version }}
 
             - name: Install protoc (protobuf)
+              if: runner.os != 'Windows'
               uses: arduino/setup-protoc@v3
               with:
                   version: "29.1"
@@ -358,9 +444,12 @@ jobs:
                       ${{ runner.os }}-gradle-
 
             - name: Build java wrapper
+              if: ${{ matrix.host.OS != 'windows' }}
               working-directory: java
+              shell: bash
               env:
                   GLIDE_CONTAINER_BUILD: true
+                  CARGO_BUILD_JOBS: ${{ github.runner_cores || '2' }}
               run: |
                   if [[ "${{ matrix.host.OS }}" == "amazon-linux" ]]; then
                       export JAVA_HOME=/usr/lib/jvm/java-${{matrix.java}}-amazon-corretto.x86_64
@@ -372,7 +461,7 @@ jobs:
                       export JAVA_HOME=/usr/lib/jvm/java-11-openjdk
                       export PATH=$HOME/.cargo/bin:$PATH
                   fi
-                  ./gradlew --stacktrace --build-cache --continue build -x javadoc
+                  ./gradlew --stacktrace --build-cache --continue build -x javadoc "-Dengine-version=${{ matrix.engine.version }}"
 
             - name: Upload test & spotbugs reports
               if: always()
@@ -416,6 +505,7 @@ jobs:
                   java-version: 17
 
             - name: Install protoc (protobuf)
+              if: runner.os != 'Windows'
               uses: arduino/setup-protoc@v3
               with:
                   version: "29.1"
diff --git a/.github/workflows/setup-linux-runner.yml b/.github/workflows/setup-linux-runner.yml
new file mode 100644
index 0000000000..260cb13721
--- /dev/null
+++ b/.github/workflows/setup-linux-runner.yml
@@ -0,0 +1,153 @@
+name: Setup Linux Runner for Valkey
+
+on:
+    workflow_dispatch:
+        inputs:
+            action:
+                description: "Action to perform"
+                required: true
+                default: "start"
+                type: choice
+                options:
+                    - start
+                    - stop
+                    - status
+            instance_type:
+                description: "EC2 instance type"
+                required: false
+                default: "t3.medium"
+                type: string
+
+permissions: {}
+
+jobs:
+    manage-linux-runner:
+        runs-on: ubuntu-latest
+        outputs:
+            runner-ip: ${{ steps.setup.outputs.runner-ip }}
+
+        steps:
+            - name: Configure AWS credentials
+              uses: aws-actions/configure-aws-credentials@v4
+              with:
+                  aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
+                  aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+                  aws-region: us-east-1
+
+            - name: Setup Linux Runner
+              id: setup
+              env:
+                  ACTION: ${{ github.event.inputs.action }}
+                  INSTANCE_TYPE: ${{ github.event.inputs.instance_type }}
+                  KEY_NAME: ${{ secrets.AWS_KEY_PAIR_NAME }}
+              run: |
+                  case "$ACTION" in
+                    "start")
+                      echo "Starting Linux runner instance..."
+                      
+                      # Create security group if it doesn't exist
+                      aws ec2 describe-security-groups --group-names valkey-runner-sg || \
+                      aws ec2 create-security-group \
+                        --group-name valkey-runner-sg \
+                        --description "Security group for Valkey test runner" \
+                        --vpc-id $(aws ec2 describe-vpcs --filters "Name=is-default,Values=true" --query 'Vpcs[0].VpcId' --output text)
+                      
+                      # Add SSH and Valkey port rules
+                      aws ec2 authorize-security-group-ingress \
+                        --group-name valkey-runner-sg \
+                        --protocol tcp \
+                        --port 22 \
+                        --cidr 0.0.0.0/0 || true
+                      
+                      aws ec2 authorize-security-group-ingress \
+                        --group-name valkey-runner-sg \
+                        --protocol tcp \
+                        --port 6379-6400 \
+                        --cidr 0.0.0.0/0 || true
+                      
+                      # Launch instance
+                      INSTANCE_ID=$(aws ec2 run-instances \
+                        --image-id ami-0c02fb55956c7d316 \
+                        --instance-type "$INSTANCE_TYPE" \
+                        --key-name "$KEY_NAME" \
+                        --security-groups valkey-runner-sg \
+                        --user-data file://<(cat << 'EOF'
+                      #!/bin/bash
+                      apt-get update
+                      apt-get install -y python3 python3-pip git build-essential pkg-config libssl-dev
+                      
+                      # Install Valkey
+                      cd /tmp
+                      git clone https://github.com/valkey-io/valkey.git
+                      cd valkey
+                      make -j$(nproc) BUILD_TLS=yes
+                      make install
+                      
+                      # Setup GitHub Actions runner
+                      mkdir -p /home/ubuntu/actions-runner
+                      cd /home/ubuntu/actions-runner
+                      curl -o actions-runner-linux-x64-2.311.0.tar.gz -L https://github.com/actions/runner/releases/download/v2.311.0/actions-runner-linux-x64-2.311.0.tar.gz
+                      tar xzf ./actions-runner-linux-x64-2.311.0.tar.gz
+                      chown -R ubuntu:ubuntu /home/ubuntu/actions-runner
+                      
+                      # Configure runner (will be done manually or via API)
+                      echo "Runner setup complete"
+                      EOF
+                      ) \
+                        --tag-specifications 'ResourceType=instance,Tags=[{Key=Name,Value=valkey-runner},{Key=Purpose,Value=github-actions}]' \
+                        --query 'Instances[0].InstanceId' \
+                        --output text)
+                      
+                      echo "Instance ID: $INSTANCE_ID"
+                      echo "instance-id=$INSTANCE_ID" >> $GITHUB_OUTPUT
+                      
+                      # Wait for instance to be running
+                      aws ec2 wait instance-running --instance-ids $INSTANCE_ID
+                      
+                      # Get public IP
+                      PUBLIC_IP=$(aws ec2 describe-instances \
+                        --instance-ids $INSTANCE_ID \
+                        --query 'Reservations[0].Instances[0].PublicIpAddress' \
+                        --output text)
+                      
+                      echo "Runner IP: $PUBLIC_IP"
+                      echo "runner-ip=$PUBLIC_IP" >> $GITHUB_OUTPUT
+                      ;;
+                      
+                    "stop")
+                      echo "Stopping Linux runner instances..."
+                      INSTANCE_IDS=$(aws ec2 describe-instances \
+                        --filters "Name=tag:Purpose,Values=github-actions" "Name=instance-state-name,Values=running" \
+                        --query 'Reservations[].Instances[].InstanceId' \
+                        --output text)
+                      
+                      if [ -n "$INSTANCE_IDS" ]; then
+                        aws ec2 terminate-instances --instance-ids $INSTANCE_IDS
+                        echo "Terminated instances: $INSTANCE_IDS"
+                      else
+                        echo "No running instances found"
+                      fi
+                      ;;
+                      
+                    "status")
+                      echo "Checking Linux runner status..."
+                      aws ec2 describe-instances \
+                        --filters "Name=tag:Purpose,Values=github-actions" \
+                        --query 'Reservations[].Instances[].[InstanceId,State.Name,PublicIpAddress,InstanceType]' \
+                        --output table
+                      ;;
+                  esac
+
+            - name: Save runner info
+              if: github.event.inputs.action == 'start'
+              env:
+                  RUNNER_IP: ${{ steps.setup.outputs.runner-ip }}
+              run: |
+                  echo "Linux runner started successfully!"
+                  echo "IP Address: $RUNNER_IP"
+                  echo ""
+                  echo "To use this runner in Windows tests, set environment variable:"
+                  echo "VALKEY_REMOTE_HOST=$RUNNER_IP"
+                  echo ""
+                  echo "SSH access:"
+                  echo "ssh -i ~/.ssh/your-key.pem ubuntu@$RUNNER_IP"
diff --git a/.github/workflows/setup-windows-dependencies/action.yml b/.github/workflows/setup-windows-dependencies/action.yml
new file mode 100644
index 0000000000..73659fdd29
--- /dev/null
+++ b/.github/workflows/setup-windows-dependencies/action.yml
@@ -0,0 +1,328 @@
+name: "Setup Windows Dependencies"
+description: "Install Windows dependencies including Chocolatey, Python, and Visual Studio Build Tools"
+
+inputs:
+    github-token:
+        description: "GitHub token for authentication"
+        required: false
+        default: ${{ github.token }}
+
+outputs:
+    python-available:
+        description: "Whether Python is available"
+        value: ${{ steps.check.outputs.python-available }}
+    ssh-available:
+        description: "Whether SSH is available"
+        value: ${{ steps.check.outputs.ssh-available }}
+
+runs:
+    using: "composite"
+    steps:
+        - name: Install Chocolatey
+          shell: powershell
+          run: |
+              Write-Host "Installing Chocolatey..."
+
+              # Check if chocolatey is installed already and use it if so
+              $chocoPath = "C:\ProgramData\chocolatey\bin"
+              if (Test-Path $chocoPath) {
+                  $env:PATH = "$chocoPath;$env:PATH"
+                  Write-Host "Added Chocolatey to PATH: $chocoPath"
+              }
+
+              if (Get-Command choco -ErrorAction SilentlyContinue) {
+                  Write-Host "Chocolatey already available"
+                  choco --version
+                  echo $chocoPath >> $env:GITHUB_PATH
+              } else {
+                  # Remove any corrupted installations
+                  $paths = @("C:\ProgramData\chocolatey", "$env:ALLUSERSPROFILE\chocolatey")
+                  foreach ($path in $paths) {
+                      if (Test-Path $path) {
+                          Write-Host "Removing existing installation: $path"
+                          Remove-Item $path -Recurse -Force -ErrorAction SilentlyContinue
+                      }
+                  }
+                  
+                  # Install fresh
+                  Set-ExecutionPolicy Bypass -Scope Process -Force
+                  [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072
+                  Invoke-Expression ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))
+                  
+                  # Refresh PATH properly - Chocolatey adds C:\ProgramData\chocolatey\bin
+                  $env:PATH = [System.Environment]::GetEnvironmentVariable("PATH","Machine") + ";" + [System.Environment]::GetEnvironmentVariable("PATH","User")
+                  
+                  # Also add Chocolatey bin directory explicitly
+                  if (Test-Path $chocoPath) {
+                      $env:PATH = "$chocoPath;$env:PATH"
+                      echo $chocoPath >> $env:GITHUB_PATH
+                      Write-Host "Added Chocolatey to PATH: $chocoPath"
+                  }
+                  
+                  if (Get-Command choco -ErrorAction SilentlyContinue) {
+                      Write-Host "Chocolatey installed successfully"
+                      choco --version
+                  } else {
+                      Write-Host "Chocolatey installation failed - continuing anyway"
+                  }
+              }
+
+        - name: Check Windows dependencies
+          id: check
+          shell: powershell
+          run: |
+              Write-Host "Checking Windows dependencies..."
+
+              # Check for Python installations
+              $pythonAvailable = $false
+
+              # Method 1: Check PATH commands
+              Write-Host "Method 1: Checking PATH commands..."
+              if (Get-Command python3 -ErrorAction SilentlyContinue) {
+                  try {
+                      $version = python3 --version 2>&1
+                      Write-Host "python3 version check: $version"
+                      if ($version -match "Python 3\." -and $version -notmatch "Microsoft Store" -and $version -notmatch "not found") {
+                          $pythonAvailable = $true
+                          Write-Host "Valid Python 3.x found via python3 command: $version"
+                      } else {
+                          Write-Host "python3 command exists but not functional (likely Windows Store alias)"
+                      }
+                  } catch {
+                      Write-Host "python3 version check failed: $_"
+                  }
+              } elseif (Get-Command python -ErrorAction SilentlyContinue) {
+                  $version = python --version 2>&1
+                  Write-Host "Found python command, version: $version"
+                  if ($version -match "Python 3\.") {
+                      $pythonAvailable = $true
+                      Write-Host "Found Python 3.x via python command: $version"
+                  } else {
+                      Write-Host "Python found but not version 3.x: $version"
+                  }
+              } elseif (Get-Command py -ErrorAction SilentlyContinue) {
+                  Write-Host "Found py launcher, checking version..."
+                  try {
+                      $version = py --version 2>&1
+                      Write-Host "py launcher version: $version"
+                      if ($version -match "Python 3\.") {
+                          $pythonAvailable = $true
+                          Write-Host "Found Python 3.x via py launcher: $version"
+                      }
+                  } catch {
+                      Write-Host "py launcher version check failed: $_"
+                  }
+              } else {
+                  Write-Host "No python commands found in PATH"
+              }
+
+              # Check SSH
+              $sshAvailable = $false
+              try {
+                  ssh -V
+                  $sshAvailable = $true
+                  Write-Host "SSH client available"
+              } catch {
+                  Write-Host "SSH client not found"
+              }
+
+              # Set outputs
+              echo "python-available=$pythonAvailable" >> $env:GITHUB_OUTPUT
+              echo "ssh-available=$sshAvailable" >> $env:GITHUB_OUTPUT
+
+              Write-Host "Detection complete: Python=$pythonAvailable, SSH=$sshAvailable"
+
+        - name: Install Python if not available
+          if: steps.check.outputs.python-available != 'true'
+          shell: powershell
+          run: |
+              Write-Host "Checking for existing Python installation..."
+
+              # Check for Chocolatey Python installation - check multiple versions
+              $pythonPaths = @(
+                  "C:\Python314\python.exe",
+                  "C:\Python313\python.exe", 
+                  "C:\Python312\python.exe",
+                  "C:\Python311\python.exe"
+              )
+
+              $pythonFound = $false
+              foreach ($pythonPath in $pythonPaths) {
+                  if (Test-Path $pythonPath) {
+                      Write-Host "Python already installed - skipping installation"
+                      & $pythonPath --version
+                      $pythonFound = $true
+                      
+                      # Add existing Python to GITHUB_PATH
+                      $pythonDir = Split-Path $pythonPath
+                      echo $pythonDir >> $env:GITHUB_PATH
+                      $env:PATH = "$pythonDir;$env:PATH"
+                      
+                      # Create python3 alias if needed
+                      $python3Path = Join-Path $pythonDir "python3.exe"
+                      if (-not (Test-Path $python3Path)) {
+                          Copy-Item $pythonPath $python3Path
+                          Write-Host "Created python3.exe alias"
+                      }
+                      
+                      break
+                  }
+              }
+
+              if (-not $pythonFound) {
+                  Write-Host "Installing Python via Chocolatey..."
+
+              if (Get-Command choco -ErrorAction SilentlyContinue) {
+                  choco install python3 -y
+                  
+                  # Refresh PATH
+                  $env:PATH = [System.Environment]::GetEnvironmentVariable("PATH","Machine") + ";" + [System.Environment]::GetEnvironmentVariable("PATH","User")
+                  
+                  # Create python3 alias for Gradle compatibility
+                  $pythonExe = Get-Command python -ErrorAction SilentlyContinue
+                  if ($pythonExe) {
+                      $pythonDir = Split-Path $pythonExe.Source
+                      $python3Path = Join-Path $pythonDir "python3.exe"
+                      if (-not (Test-Path $python3Path)) {
+                          Copy-Item $pythonExe.Source $python3Path
+                          Write-Host "Created python3.exe alias"
+                      }
+                      
+                      # Add Python directory to GITHUB_PATH
+                      echo $pythonDir >> $env:GITHUB_PATH
+                      $env:PATH = "$pythonDir;$env:PATH"
+                  }
+                  
+                  # Verify
+                  if (Get-Command python -ErrorAction SilentlyContinue) {
+                      $version = python --version
+                      Write-Host "Python installed successfully: $version"
+                  } else {
+                      Write-Host "Python installation may have failed"
+                  }
+              } else {
+                  Write-Host "Chocolatey not available - cannot install Python"
+              }
+              }
+
+        - name: Install build tools (NASM and CMake)
+          shell: powershell
+          run: |
+              Write-Host "Checking for existing build tools..."
+
+              # Check for NASM
+              $nasmFound = $false
+              if (Test-Path "C:\Program Files\NASM\nasm.exe") {
+                  Write-Host "NASM already installed"
+                  $nasmFound = $true
+              }
+
+              # Check for CMake
+              $cmakeFound = $false
+              if (Test-Path "C:\Program Files\CMake\bin\cmake.exe") {
+                  Write-Host "CMake already installed"
+                  $cmakeFound = $true
+              }
+
+              if (Get-Command choco -ErrorAction SilentlyContinue) {
+                  if (-not $nasmFound) {
+                      Write-Host "Installing NASM..."
+                      choco install nasm -y
+                  }
+                  
+                  if (-not $cmakeFound) {
+                      Write-Host "Installing CMake..."
+                      choco install cmake -y
+                  }
+                  
+                  # Refresh PATH and add to GITHUB_PATH
+                  $env:PATH = [System.Environment]::GetEnvironmentVariable("PATH","Machine") + ";" + [System.Environment]::GetEnvironmentVariable("PATH","User")
+                  
+                  # Add NASM to PATH
+                  $nasmPath = "C:\Program Files\NASM"
+                  if (Test-Path $nasmPath) {
+                      echo $nasmPath >> $env:GITHUB_PATH
+                      $env:PATH = "$nasmPath;$env:PATH"
+                  }
+                  
+                  # Add CMake to PATH
+                  $cmakePath = "C:\Program Files\CMake\bin"
+                  if (Test-Path $cmakePath) {
+                      echo $cmakePath >> $env:GITHUB_PATH
+                      $env:PATH = "$cmakePath;$env:PATH"
+                  }
+              } else {
+                  Write-Host "Chocolatey not available - cannot install build tools"
+              }
+
+        - name: Install Visual Studio Build Tools
+          shell: powershell
+          run: |
+              Write-Host "Checking for existing Visual Studio Build Tools..."
+
+              # Check if VS Build Tools are already installed
+              $vsInstalled = $false
+              $vsPaths = @(
+                  "${env:ProgramFiles}\Microsoft Visual Studio\2022\BuildTools",
+                  "${env:ProgramFiles(x86)}\Microsoft Visual Studio\2022\BuildTools"
+              )
+
+              foreach ($vsPath in $vsPaths) {
+                  if (Test-Path "$vsPath\VC\Tools\MSVC") {
+                      Write-Host "Found existing VS Build Tools at: $vsPath"
+                      $vsInstalled = $true
+                      break
+                  }
+              }
+
+              if ($vsInstalled) {
+                  Write-Host "VS Build Tools already installed - skipping installation"
+              } else {
+                  Write-Host "Installing Visual Studio 2022 Build Tools..."
+                  
+                  # Download and install VS Build Tools directly with known working parameters
+                  $installerUrl = "https://aka.ms/vs/17/release/vs_buildtools.exe"
+                  $installerPath = "$env:TEMP\vs_buildtools.exe"
+                  
+                  Write-Host "Downloading VS Build Tools installer..."
+                  Invoke-WebRequest -Uri $installerUrl -OutFile $installerPath
+                  
+                  Write-Host "Installing VS Build Tools with C++ workload and Windows SDK..."
+                  $installArgs = @(
+                      "--quiet",
+                      "--wait",
+                      "--add", "Microsoft.VisualStudio.Workload.VCTools",
+                      "--add", "Microsoft.VisualStudio.Component.VC.Tools.x86.x64",
+                      "--add", "Microsoft.VisualStudio.Component.Windows11SDK.22000",
+                      "--add", "Microsoft.VisualStudio.Component.Windows10SDK.19041",
+                      "--add", "Microsoft.VisualStudio.Component.VC.CMake.Project"
+                  )
+                  
+                  $process = Start-Process -FilePath $installerPath -ArgumentList $installArgs -Wait -PassThru
+                  Write-Host "VS Build Tools installer exit code: $($process.ExitCode)"
+                  
+                  # Clean up
+                  Remove-Item $installerPath -Force -ErrorAction SilentlyContinue
+              }
+
+              # Verify installation
+              Write-Host "Verifying MSVC compiler installation..."
+              $msvcPaths = @(
+                  "${env:ProgramFiles}\Microsoft Visual Studio\2022\BuildTools\VC\Tools\MSVC\*\bin\Hostx64\x64\cl.exe",
+                  "${env:ProgramFiles(x86)}\Microsoft Visual Studio\2022\BuildTools\VC\Tools\MSVC\*\bin\Hostx64\x64\cl.exe"
+              )
+
+              $found = $false
+              foreach ($path in $msvcPaths) {
+                  $compiler = Get-ChildItem $path -ErrorAction SilentlyContinue | Select-Object -First 1
+                  if ($compiler) {
+                      Write-Host "MSVC compiler found: $($compiler.FullName)"
+                      $found = $true
+                      break
+                  }
+              }
+
+              if (-not $found) {
+                  Write-Host "Error: MSVC compiler not found after installation"
+                  exit 1
+              }
diff --git a/.github/workflows/setup-windows-dependencies/action.yml.backup b/.github/workflows/setup-windows-dependencies/action.yml.backup
new file mode 100644
index 0000000000..bda0e5dfe5
--- /dev/null
+++ b/.github/workflows/setup-windows-dependencies/action.yml.backup
@@ -0,0 +1,787 @@
+name: "Setup Windows Dependencies"
+description: "Setup Python, SSH, and other Windows-specific dependencies"
+
+inputs:
+    github-token:
+        description: "GitHub token for authentication"
+        required: false
+        default: ${{ github.token }}
+
+outputs:
+    python-available:
+        description: "Whether Python is available"
+        value: ${{ steps.check.outputs.python-available }}
+    ssh-available:
+        description: "Whether SSH is available"
+        value: ${{ steps.check.outputs.ssh-available }}
+
+runs:
+    using: "composite"
+    steps:
+        - name: Install Chocolatey
+          shell: powershell
+          run: |
+              Write-Host "=== Chocolatey Installation Diagnostics ==="
+              
+              # Show current environment
+              Write-Host "Current user: $env:USERNAME"
+              Write-Host "Current PATH: $env:PATH"
+              Write-Host "PowerShell execution policy: $(Get-ExecutionPolicy)"
+              Write-Host "PowerShell version: $($PSVersionTable.PSVersion)"
+              
+              # Check if Chocolatey command exists
+              $chocoCmd = Get-Command choco -ErrorAction SilentlyContinue
+              if ($chocoCmd) {
+                  Write-Host "Chocolatey command found at: $($chocoCmd.Source)"
+                  try {
+                      $version = choco --version
+                      Write-Host "Chocolatey version: $version"
+                  } catch {
+                      Write-Host "Error running choco --version: $_"
+                  }
+              # Search filesystem for Chocolatey
+              Write-Host "Searching for Chocolatey installations..."
+              $searchPaths = @(
+                  "$env:ALLUSERSPROFILE\chocolatey",
+                  "$env:PROGRAMDATA\chocolatey", 
+                  "C:\chocolatey",
+                  "C:\ProgramData\chocolatey"
+              )
+              
+              $chocoFound = $false
+              foreach ($path in $searchPaths) {
+                  if (Test-Path $path) {
+                      Write-Host "Found Chocolatey directory: $path"
+                      $chocoExe = Join-Path $path "bin\choco.exe"
+                      if (Test-Path $chocoExe) {
+                          Write-Host "  choco.exe exists: $chocoExe"
+                          try {
+                              $version = & $chocoExe --version
+                              Write-Host "  Version: $version"
+                              
+                              # Add to PATH
+                              $binPath = Split-Path $chocoExe
+                              Write-Host "  Adding to PATH: $binPath"
+                              $env:PATH = "$binPath;$env:PATH"
+                              echo $binPath >> $env:GITHUB_PATH
+                              
+                              # Test again
+                              if (Get-Command choco -ErrorAction SilentlyContinue) {
+                                  Write-Host "  SUCCESS: Chocolatey now available in PATH"
+                                  $chocoFound = $true
+                                  break
+                              } else {
+                                  Write-Host "  FAILED: Still not available after adding to PATH"
+                              }
+                          } catch {
+                              Write-Host "  ERROR running choco.exe: $_"
+                              Write-Host "  This installation appears corrupted"
+                          }
+                      } else {
+                          Write-Host "  choco.exe NOT found in bin directory - corrupted installation"
+                      }
+                  } else {
+                      Write-Host "Directory not found: $path"
+                  }
+              }
+              
+              if ($chocoFound) {
+                  Write-Host "Working Chocolatey installation found and configured"
+              } else {
+              
+              Write-Host "No working Chocolatey installation found - removing corrupted installation and installing fresh"
+              
+              # Remove corrupted Chocolatey installations
+              $chocolateyPaths = @(
+                  "$env:ALLUSERSPROFILE\chocolatey",
+                  "$env:PROGRAMDATA\chocolatey", 
+                  "C:\chocolatey",
+                  "C:\ProgramData\chocolatey"
+              )
+              
+              foreach ($path in $chocolateyPaths) {
+                  if (Test-Path $path) {
+                      Write-Host "Removing corrupted Chocolatey installation: $path"
+                      try {
+                          Remove-Item $path -Recurse -Force -ErrorAction SilentlyContinue
+                          Write-Host "  Removed: $path"
+                      } catch {
+                          Write-Host "  Failed to remove: $path - $_"
+                      }
+                  }
+              }
+              
+              # Also remove from registry if exists
+              try {
+                  Remove-Item "HKLM:\SOFTWARE\Chocolatey" -Recurse -Force -ErrorAction SilentlyContinue
+                  Write-Host "Removed Chocolatey registry entries"
+              } catch {
+                  Write-Host "No Chocolatey registry entries to remove"
+              }
+              
+              # Fresh installation with detailed error handling
+              try {
+                  Set-ExecutionPolicy Bypass -Scope Process -Force
+                  Write-Host "Execution policy set to Bypass"
+                  
+                  [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072
+                  Write-Host "Security protocol configured"
+                  
+                  Write-Host "Downloading Chocolatey install script..."
+                  $installScript = (New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1')
+                  Write-Host "Install script downloaded ($(($installScript.Length / 1KB).ToString('F1')) KB)"
+                  
+                  Write-Host "Executing Chocolatey install script..."
+                  Invoke-Expression $installScript
+                  
+                  Write-Host "Install script completed"
+                  
+              }
+              
+              # Final verification
+              Write-Host "=== Final Chocolatey Status ==="
+              if (Get-Command choco -ErrorAction SilentlyContinue) {
+                  Write-Host "SUCCESS: Chocolatey is now available"
+                  choco --version
+              } else {
+                  Write-Host "FAILED: Chocolatey still not available"
+                  Write-Host "Final PATH: $env:PATH"
+                  Write-Host "This may cause issues with subsequent installations"
+              }
+
+        - name: Check Windows dependencies
+          id: check
+          shell: powershell
+          run: |
+              Write-Host "Checking Windows dependencies..."
+
+              # Debug: Show current PATH
+              Write-Host "Current PATH:"
+              $env:PATH -split ';' | ForEach-Object { Write-Host "  $_" }
+
+              # Debug: Show all executables that might be Python
+              Write-Host "All python-like executables in PATH:"
+              Get-Command python*, py -ErrorAction SilentlyContinue | ForEach-Object { 
+                  Write-Host "  $($_.Name) -> $($_.Source)"
+                  try {
+                      $version = & $_.Source --version 2>&1
+                      Write-Host "    Version: $version"
+                  } catch {
+                      Write-Host "    Version check failed: $_"
+                  }
+              }
+
+              # Check for Python installations
+              $pythonAvailable = $false
+              $pythonPath = $null
+
+              # Method 1: Check PATH commands
+              Write-Host "Method 1: Checking PATH commands..."
+              if (Get-Command python3 -ErrorAction SilentlyContinue) {
+                  $pythonPath = (Get-Command python3).Source
+                  Write-Host "Found python3 in PATH: $pythonPath"
+                  
+                  # Validate it's not a Windows Store alias
+                  try {
+                      $version = python3 --version 2>&1
+                      Write-Host "python3 version check: $version"
+                      if ($version -match "Python 3\." -and $version -notmatch "Microsoft Store" -and $version -notmatch "not found") {
+                          $pythonAvailable = $true
+                          Write-Host "Valid Python 3.x found via python3 command: $version"
+                      } else {
+                          Write-Host "python3 command exists but not functional (likely Windows Store alias)"
+                      }
+                  } catch {
+                      Write-Host "python3 version check failed: $_"
+                  }
+              } elseif (Get-Command python -ErrorAction SilentlyContinue) {
+                  $version = python --version 2>&1
+                  Write-Host "Found python command, version: $version"
+                  if ($version -match "Python 3\.") {
+                      $pythonAvailable = $true
+                      $pythonPath = (Get-Command python).Source
+                      Write-Host "Found Python 3.x via python command: $version"
+                  } else {
+                      Write-Host "Python found but not version 3.x: $version"
+                  }
+              } elseif (Get-Command py -ErrorAction SilentlyContinue) {
+                  Write-Host "Found py launcher, checking version..."
+                  try {
+                      $version = py --version 2>&1
+                      Write-Host "py launcher version: $version"
+                      if ($version -match "Python 3\.") {
+                          $pythonAvailable = $true
+                          $pythonPath = (Get-Command py).Source
+                          Write-Host "Found Python 3.x via py launcher: $version"
+                      }
+                  } catch {
+                      Write-Host "py launcher version check failed: $_"
+                  }
+              } else {
+                  Write-Host "No python commands found in PATH"
+              }
+
+              # Method 2: Check registry if not found in PATH
+              if (-not $pythonAvailable) {
+                  Write-Host "Method 2: Checking Windows registry for Python..."
+                  $regPaths = @(
+                      "HKLM:\SOFTWARE\Python\PythonCore\*\InstallPath",
+                      "HKCU:\SOFTWARE\Python\PythonCore\*\InstallPath",
+                      "HKLM:\SOFTWARE\WOW6432Node\Python\PythonCore\*\InstallPath"
+                  )
+
+                  foreach ($regPath in $regPaths) {
+                      Write-Host "Checking registry path: $regPath"
+                      try {
+                          Get-ItemProperty $regPath -ErrorAction SilentlyContinue | ForEach-Object {
+                              $installPath = $_.'(default)'
+                              Write-Host "Registry entry found: $installPath"
+                              if ($installPath -and (Test-Path $installPath)) {
+                                  $pythonExe = Join-Path $installPath "python.exe"
+                                  Write-Host "Checking: $pythonExe"
+                                  if (Test-Path $pythonExe) {
+                                      try {
+                                          $version = & $pythonExe --version 2>&1
+                                          Write-Host "Found Python at $pythonExe - Version: $version"
+                                          if ($version -match "Python 3\.") {
+                                              $pythonAvailable = $true
+                                              $pythonPath = $pythonExe
+                                              Write-Host "Using Python 3.x from registry: $pythonExe"
+                                              break
+                                          }
+                                      } catch {
+                                          Write-Host "Version check failed for $pythonExe : $_"
+                                      }
+                                  } else {
+                                      Write-Host "python.exe not found at: $pythonExe"
+                                  }
+                              } else {
+                                  Write-Host "Install path does not exist: $installPath"
+                              }
+                          }
+                      } catch {
+                          Write-Host "Registry check failed for $regPath : $_"
+                      }
+                      if ($pythonAvailable) { break }
+                  }
+              }
+
+              # Method 3: Check common paths if still not found
+              if (-not $pythonAvailable) {
+                  Write-Host "Method 3: Checking common installation paths..."
+                  $commonPaths = @(
+                      "$env:LOCALAPPDATA\Programs\Python\Python*",
+                      "$env:PROGRAMFILES\Python*",
+                      "$env:PROGRAMFILES(x86)\Python*",
+                      "C:\Python*"
+                  )
+
+                  foreach ($pathPattern in $commonPaths) {
+                      Write-Host "Checking pattern: $pathPattern"
+                      Get-ChildItem $pathPattern -Directory -ErrorAction SilentlyContinue | ForEach-Object {
+                          $pythonExe = Join-Path $_.FullName "python.exe"
+                          Write-Host "Checking: $pythonExe"
+                          if (Test-Path $pythonExe) {
+                              try {
+                                  $version = & $pythonExe --version 2>&1
+                                  Write-Host "Found Python at $pythonExe - Version: $version"
+                                  if ($version -match "Python 3\.") {
+                                      $pythonAvailable = $true
+                                      $pythonPath = $pythonExe
+                                      Write-Host "Using Python 3.x from common path: $pythonExe"
+                                      break
+                                  }
+                              } catch {
+                                  Write-Host "Version check failed for $pythonExe : $_"
+                              }
+                          } else {
+                              Write-Host "python.exe not found at: $pythonExe"
+                          }
+                      }
+                      if ($pythonAvailable) { break }
+                  }
+              }
+
+              # Check SSH
+              $sshAvailable = $false
+              if (Get-Command ssh -ErrorAction SilentlyContinue) {
+                  $sshAvailable = $true
+                  Write-Host "SSH client available"
+              } else {
+                  Write-Host "SSH client not found"
+              }
+
+              # Set outputs
+              echo "python-available=$pythonAvailable" >> $env:GITHUB_OUTPUT
+              echo "ssh-available=$sshAvailable" >> $env:GITHUB_OUTPUT
+
+              Write-Host "Detection complete: Python=$pythonAvailable, SSH=$sshAvailable"
+              
+              # Install Python via Chocolatey if not found
+              if (-not $pythonAvailable) {
+                  Write-Host "Python not found, attempting installation via Chocolatey..."
+                  
+                  # Check if Chocolatey will be available (it gets installed in the next step)
+                  Write-Host "Python installation will be handled by Chocolatey in the next step"
+              }
+              
+              Write-Host "=== End of Windows dependency check ==="
+              Write-Host "Continuing to next step..."
+
+        - name: Install Visual Studio Build Tools
+          shell: powershell
+          env:
+              GITHUB_TOKEN: ${{ inputs.github-token }}
+          run: |
+              Write-Host "=== STEP 3: Visual Studio Build Tools Installation STARTED ==="
+              Write-Host "This step should run after Windows dependency check"
+              
+              try {
+                  # Use Chocolatey to install Visual Studio Build Tools
+                  if (Get-Command choco -ErrorAction SilentlyContinue) {
+                      Write-Host "Installing Visual Studio 2022 Build Tools via Chocolatey..."
+                      choco install visualstudio2022buildtools --package-parameters "--add Microsoft.VisualStudio.Workload.VCTools --add Microsoft.VisualStudio.Component.VC.Tools.x86.x64 --add Microsoft.VisualStudio.Component.Windows11SDK.22000" -y
+                      
+                      Write-Host "Chocolatey exit code: $LASTEXITCODE"
+                      
+                      if ($LASTEXITCODE -eq 0) {
+                          Write-Host "Visual Studio Build Tools installed successfully"
+                      } else {
+                          Write-Host "Visual Studio Build Tools installation failed with exit code: $LASTEXITCODE"
+                          Write-Host "Continuing anyway - this is not critical for Python installation"
+                      }
+                  } else {
+                      Write-Host "Warning: Chocolatey not available for Visual Studio installation"
+                      Write-Host "Continuing anyway - this is not critical for Python installation"
+                  }
+                  
+                  Write-Host "Visual Studio Build Tools step completed successfully"
+                  
+              } catch {
+                  Write-Host "ERROR in Visual Studio Build Tools installation: $_"
+                  Write-Host "Exception type: $($_.Exception.GetType().FullName)"
+                  Write-Host "Continuing anyway - this is not critical for Python installation"
+              }
+              
+              Write-Host "=== End of Visual Studio Build Tools Installation ==="
+              Write-Host "Installing Visual Studio Build Tools via Chocolatey..."
+              
+              # Connection pool and keep-alive diagnostics
+              Write-Host "=== Connection Pool and Keep-Alive Diagnostics ==="
+              
+              # Show current connection settings
+              Write-Host "Current DefaultConnectionLimit: $([System.Net.ServicePointManager]::DefaultConnectionLimit)"
+              Write-Host "Current MaxServicePointIdleTime: $([System.Net.ServicePointManager]::MaxServicePointIdleTime) ms"
+              Write-Host "Current UseNagleAlgorithm: $([System.Net.ServicePointManager]::UseNagleAlgorithm)"
+              Write-Host "Current Expect100Continue: $([System.Net.ServicePointManager]::Expect100Continue)"
+              Write-Host "Current DnsRefreshTimeout: $([System.Net.ServicePointManager]::DnsRefreshTimeout) ms"
+              
+              # Configure for stable long downloads
+              Write-Host "Configuring connection settings for long downloads..."
+              
+              # Increase connection limit but keep it reasonable
+              [System.Net.ServicePointManager]::DefaultConnectionLimit = 10
+              
+              # Increase idle timeout to prevent premature connection closure
+              [System.Net.ServicePointManager]::MaxServicePointIdleTime = 900000  # 15 minutes
+              
+              # Disable Nagle algorithm for better throughput
+              [System.Net.ServicePointManager]::UseNagleAlgorithm = $false
+              
+              # Disable Expect100Continue to reduce handshake overhead
+              [System.Net.ServicePointManager]::Expect100Continue = $false
+              
+              # Set DNS refresh timeout
+              [System.Net.ServicePointManager]::DnsRefreshTimeout = 120000  # 2 minutes
+              
+              # Configure TCP keep-alive at system level
+              try {
+                  # Enable TCP keep-alive with shorter intervals
+                  $tcpParams = "HKLM:\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters"
+                  Write-Host "Checking TCP keep-alive settings..."
+                  
+                  $keepAliveTime = Get-ItemProperty -Path $tcpParams -Name "KeepAliveTime" -ErrorAction SilentlyContinue
+                  $keepAliveInterval = Get-ItemProperty -Path $tcpParams -Name "KeepAliveInterval" -ErrorAction SilentlyContinue
+                  
+                  Write-Host "TCP KeepAliveTime: $($keepAliveTime.KeepAliveTime) ms (default: 7200000)"
+                  Write-Host "TCP KeepAliveInterval: $($keepAliveInterval.KeepAliveInterval) ms (default: 1000)"
+              } catch {
+                  Write-Host "Could not read TCP keep-alive settings: $_"
+              }
+              
+              # Show updated settings
+              Write-Host "Updated DefaultConnectionLimit: $([System.Net.ServicePointManager]::DefaultConnectionLimit)"
+              Write-Host "Updated MaxServicePointIdleTime: $([System.Net.ServicePointManager]::MaxServicePointIdleTime) ms"
+              Write-Host "Updated UseNagleAlgorithm: $([System.Net.ServicePointManager]::UseNagleAlgorithm)"
+              Write-Host "Updated Expect100Continue: $([System.Net.ServicePointManager]::Expect100Continue)"
+              
+              Write-Host "=== End Connection Diagnostics ==="
+              
+              # Check if running as administrator with multiple methods
+              Write-Host "Checking administrative privileges..."
+              
+              # Method 1: Standard check
+              $isAdmin1 = ([Security.Principal.WindowsPrincipal] [Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole] "Administrator")
+              Write-Host "Method 1 (Standard): $isAdmin1"
+              
+              # Method 2: Check current user
+              $currentUser = [System.Security.Principal.WindowsIdentity]::GetCurrent()
+              Write-Host "Current user: $($currentUser.Name)"
+              Write-Host "Authentication type: $($currentUser.AuthenticationType)"
+              
+              # Method 3: Try to access admin-only location
+              $canWriteToSystem = $false
+              try {
+                  $testFile = "$env:SystemRoot\temp\admin_test.txt"
+                  "test" | Out-File -FilePath $testFile -Force
+                  Remove-Item $testFile -Force -ErrorAction SilentlyContinue
+                  $canWriteToSystem = $true
+                  Write-Host "Method 3 (System write test): $canWriteToSystem"
+              } catch {
+                  Write-Host "Method 3 (System write test): $canWriteToSystem - $_"
+              }
+              
+              # Method 4: Check if we can run elevated commands
+              $canRunElevated = $false
+              try {
+                  $result = Start-Process -FilePath "whoami" -ArgumentList "/priv" -Wait -PassThru -WindowStyle Hidden
+                  $canRunElevated = ($result.ExitCode -eq 0)
+                  Write-Host "Method 4 (Elevated command test): $canRunElevated"
+              } catch {
+                  Write-Host "Method 4 (Elevated command test): $canRunElevated - $_"
+              }
+              
+              $hasAdminRights = $isAdmin1 -or $canWriteToSystem -or $canRunElevated
+              
+              if ($hasAdminRights) {
+                  Write-Host "Administrative privileges confirmed"
+              } else {
+                  Write-Host "Warning: Administrative privileges not detected - installations may fail"
+                  Write-Host "Continuing anyway..."
+              }
+              
+              # Check if Chocolatey is available in PATH
+              if (-not (Get-Command choco -ErrorAction SilentlyContinue)) {
+                  Write-Host "Chocolatey not found in PATH, searching system..."
+                  
+                  # Systematic search for Chocolatey
+                  $chocoPath = $null
+                  
+                  # Method 1: Check environment variable
+                  if ($env:ChocolateyInstall -and (Test-Path "$env:ChocolateyInstall\bin\choco.exe")) {
+                      $chocoPath = "$env:ChocolateyInstall\bin"
+                      Write-Host "Found Chocolatey via environment variable: $chocoPath"
+                  }
+                  # Method 2: Search filesystem
+                  elseif (-not $chocoPath) {
+                      Write-Host "Searching filesystem for choco.exe..."
+                      $found = Get-ChildItem -Path "C:\" -Name "choco.exe" -Recurse -ErrorAction SilentlyContinue | Select-Object -First 1
+                      if ($found) {
+                          $chocoPath = Split-Path $found.FullName
+                          Write-Host "Found Chocolatey via filesystem search: $chocoPath"
+                      }
+                  }
+                  # Method 3: Check registry
+                  elseif (-not $chocoPath) {
+                      Write-Host "Checking registry for Chocolatey..."
+                      try {
+                          $regPath = Get-ItemProperty -Path "HKLM:\SOFTWARE\Chocolatey" -Name "InstallLocation" -ErrorAction SilentlyContinue
+                          if ($regPath -and (Test-Path "$($regPath.InstallLocation)\bin\choco.exe")) {
+                              $chocoPath = "$($regPath.InstallLocation)\bin"
+                              Write-Host "Found Chocolatey via registry: $chocoPath"
+                          }
+                      } catch {
+                          Write-Host "Registry check failed: $_"
+                      }
+                  }
+                  
+                  if ($chocoPath) {
+                      # Add to PATH for current session
+                      $env:PATH = "$chocoPath;$env:PATH"
+                      # Persist for GitHub Actions
+                      echo $chocoPath >> $env:GITHUB_PATH
+                      Write-Host "Added Chocolatey to PATH"
+                  } else {
+                      Write-Host "No existing Chocolatey installation found"
+                      Write-Host "Installing prerequisites and Visual Studio Build Tools..."
+                      
+                      # Install prerequisites first to avoid exit code 5002
+                      Write-Host "Installing prerequisites..."
+                      
+                      # Install .NET Framework 4.8 (required for VS installer)
+                      try {
+                          Write-Host "Installing .NET Framework 4.8..."
+                          # Use the correct offline installer URL
+                          $netFrameworkUrl = "https://download.microsoft.com/download/9/4/1/941bcadcf2d5c19b8c5c7e6b8b5b8b8b/ndp48-x86-x64-allos-enu.exe"
+                          $netFrameworkPath = "$env:TEMP\ndp48-installer.exe"
+                          
+                          # Download with WebClient (more reliable)
+                          $webClient = New-Object System.Net.WebClient
+                          $webClient.Headers.Add("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64)")
+                          $webClient.DownloadFile($netFrameworkUrl, $netFrameworkPath)
+                          $webClient.Dispose()
+                          
+                          # Install with NETWORK SERVICE compatible flags
+                          Start-Process -FilePath $netFrameworkPath -ArgumentList "/quiet", "/norestart" -Wait
+                          Remove-Item $netFrameworkPath -Force -ErrorAction SilentlyContinue
+                          Write-Host ".NET Framework installation completed"
+                      } catch {
+                          Write-Host "Warning: .NET Framework installation failed: $_"
+                          Write-Host "Continuing without .NET Framework - VS installer may still work"
+                      }
+                      
+                      # Try winget first (more reliable on modern Windows)
+                      if (Get-Command winget -ErrorAction SilentlyContinue) {
+                          Write-Host "Using winget to install Microsoft C++ Build Tools..."
+                          winget install Microsoft.VisualStudio.2022.BuildTools.MSBuild --silent --accept-package-agreements --accept-source-agreements
+                          
+                          if ($LASTEXITCODE -eq 0) {
+                              Write-Host "winget installation successful"
+                              $skipChocolatey = $true
+                          } else {
+                              Write-Host "winget installation failed, trying full Build Tools..."
+                              winget install Microsoft.VisualStudio.2022.BuildTools --silent --accept-package-agreements --accept-source-agreements
+                              if ($LASTEXITCODE -eq 0) {
+                                  Write-Host "Full Build Tools installation successful"
+                                  $skipChocolatey = $true
+                              } else {
+                                  Write-Host "winget installation failed with exit code: $LASTEXITCODE"
+                                  Write-Host "Falling back to direct installer..."
+                              }
+                          }
+                      } else {
+                          Write-Host "winget not available, using direct installer..."
+                      }
+                      
+                      # Fallback to direct installer if winget failed or unavailable
+                      if ($LASTEXITCODE -ne 0 -or -not (Get-Command winget -ErrorAction SilentlyContinue)) {
+                          Write-Host "Creating offline VS 2022 Build Tools installer..."
+                          
+                          $installerUrl = "https://aka.ms/vs/17/release/vs_buildtools.exe"
+                          $installerPath = "$env:TEMP\vs_buildtools.exe"
+                          $offlineDir = "$env:TEMP\vs_offline"
+                          
+                          # Download bootstrapper with retry
+                          $downloadSuccess = $false
+                          for ($i = 1; $i -le 3; $i++) {
+                              try {
+                                  Write-Host "Downloading VS 2022 Build Tools bootstrapper (attempt $i/3)..."
+                                  
+                                  # Configure timeout via ServicePointManager (affects all WebClient instances)
+                                  [System.Net.ServicePointManager]::DefaultConnectionLimit = 10
+                                  [System.Net.ServicePointManager]::Expect100Continue = $false
+                                  
+                                  $webClient = New-Object System.Net.WebClient
+                                  # Set headers to avoid issues
+                                  $webClient.Headers.Add("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64)")
+                                  $webClient.DownloadFile($installerUrl, $installerPath)
+                                  $webClient.Dispose()
+                                  
+                                  if (Test-Path $installerPath) {
+                                      $fileSize = (Get-Item $installerPath).Length
+                                      Write-Host "Bootstrapper download successful ($(($fileSize / 1MB).ToString('F1')) MB)"
+                                      $downloadSuccess = $true
+                                      break
+                                  }
+                              } catch {
+                                  Write-Host "Download attempt $i failed: $_"
+                                  if ($i -lt 3) { Start-Sleep -Seconds 10 }
+                              }
+                          }
+                          
+                          if ($downloadSuccess) {
+                              # NETWORK SERVICE account has limitations - try direct installation instead of layout
+                              Write-Host "NETWORK SERVICE detected - trying direct installation instead of offline layout..."
+                              
+                              $installArgs = @(
+                                  "--quiet",
+                                  "--wait",
+                                  "--norestart",
+                                  "--nocache",
+                                  "--noUpdateInstaller",
+                                  "--add", "Microsoft.VisualStudio.Component.VC.Tools.x86.x64",
+                                  "--add", "Microsoft.VisualStudio.Component.Windows11SDK.22000"
+                              )
+                              
+                              Write-Host "Running direct installation..."
+                              Write-Host "Command: $installerPath $($installArgs -join ' ')"
+                              $installProcess = Start-Process -FilePath $installerPath -ArgumentList $installArgs -Wait -PassThru
+                              Write-Host "Direct installation completed with exit code: $($installProcess.ExitCode)"
+                              
+                              if ($installProcess.ExitCode -eq 0 -or $installProcess.ExitCode -eq 3010) {
+                                  Write-Host "VS 2022 Build Tools direct installation successful"
+                              } else {
+                                  Write-Host "VS 2022 Build Tools installation failed with exit code: $($installProcess.ExitCode)"
+                                  
+                                  # Try minimal components as fallback
+                                  Write-Host "Trying minimal component installation..."
+                                  $minimalArgs = @(
+                                      "--quiet",
+                                      "--wait", 
+                                      "--norestart",
+                                      "--add", "Microsoft.VisualStudio.Component.VC.Tools.x86.x64"
+                                  )
+                                  
+                                  $minimalProcess = Start-Process -FilePath $installerPath -ArgumentList $minimalArgs -Wait -PassThru
+                                  Write-Host "Minimal installation completed with exit code: $($minimalProcess.ExitCode)"
+                              }
+                              
+                              # Cleanup
+                              Remove-Item $installerPath -Force -ErrorAction SilentlyContinue
+                          } else {
+                              Write-Host "Failed to download VS Build Tools bootstrapper after 3 attempts"
+                          }
+                          
+                          # Skip the rest of Visual Studio logic
+                          $skipChocolatey = $true
+                      }
+                      
+                      # Skip the rest of Chocolatey logic
+                      $skipChocolatey = $true
+                  }
+              } else {
+                  Write-Host "Chocolatey already available in PATH"
+                  $skipChocolatey = $false
+              }
+              
+              # Only proceed with Chocolatey if we found it or it was already in PATH
+              if (-not $skipChocolatey) {
+                  # Verify choco is now available
+                  if (-not (Get-Command choco -ErrorAction SilentlyContinue)) {
+                      Write-Host "Warning: Chocolatey still not available after setup"
+                      Write-Host "Continuing without Chocolatey..."
+                  }
+                  
+                  # Install Visual Studio Build Tools 2022 with C++ workload
+                  Write-Host "Installing Visual Studio Build Tools 2022 via Chocolatey..."
+                  choco install visualstudio2022buildtools --package-parameters "--add Microsoft.VisualStudio.Workload.VCTools --add Microsoft.VisualStudio.Component.VC.Tools.x86.x64 --add Microsoft.VisualStudio.Component.Windows10SDK.19041" -y
+                  
+                  if ($LASTEXITCODE -ne 0) {
+                      Write-Host "Chocolatey installation failed with exit code: $LASTEXITCODE"
+                      Write-Host "Trying alternative approach..."
+                      
+                      # Fallback: Install just the C++ compiler
+                      choco install microsoft-build-tools -y
+                      choco install visualcpp-build-tools -y
+                  }
+              }
+              
+              # Verify installation
+              $vsWhere = "${env:ProgramFiles(x86)}\Microsoft Visual Studio\Installer\vswhere.exe"
+              if (Test-Path $vsWhere) {
+                  Write-Host "Success: vswhere.exe found at $vsWhere"
+                  
+                  $buildTools = & $vsWhere -products * -requires Microsoft.VisualStudio.Component.VC.Tools.x86.x64 -format json | ConvertFrom-Json
+                  if ($buildTools) {
+                      Write-Host "Success: Visual Studio Build Tools with C++ support installed"
+                      $buildTools | ForEach-Object { Write-Host "  Product: $($_.productId), Path: $($_.installationPath)" }
+                  } else {
+                      Write-Host "Warning: C++ tools verification failed, but continuing..."
+                  }
+              } else {
+                  Write-Host "Warning: vswhere.exe not found, trying manual MSVC detection..."
+                  
+                  # Check for MSVC directly
+                  $msvcPaths = @(
+                      "${env:ProgramFiles}\Microsoft Visual Studio\2022\BuildTools\VC\Tools\MSVC\*\bin\Hostx64\x64\link.exe",
+                      "${env:ProgramFiles(x86)}\Microsoft Visual Studio\2022\BuildTools\VC\Tools\MSVC\*\bin\Hostx64\x64\link.exe",
+                      "${env:ProgramFiles}\Microsoft Visual Studio\*\BuildTools\VC\Tools\MSVC\*\bin\Hostx64\x64\link.exe"
+                  )
+                  
+                  $linkFound = $false
+                  foreach ($pattern in $msvcPaths) {
+                      $found = Get-ChildItem $pattern -ErrorAction SilentlyContinue | Select-Object -First 1
+                      if ($found) {
+                          Write-Host "Found link.exe at: $($found.FullName)"
+                          $linkFound = $true
+                          break
+                      }
+                  }
+                  
+                  if (-not $linkFound) {
+                      Write-Host "Warning: No MSVC compiler found after installation"
+                      Write-Host "Continuing with other dependency installations..."
+                  }
+              }
+              
+              Write-Host "Visual Studio Build Tools installation complete"
+
+        - name: Install Python if not available
+          if: steps.check-deps.outputs.python-available != 'true'
+          shell: powershell
+          run: |
+              Write-Host "Installing Python via Chocolatey..."
+              
+              # Check if Chocolatey is available
+              if (Get-Command choco -ErrorAction SilentlyContinue) {
+                  Write-Host "Installing Python 3 via Chocolatey..."
+                  choco install python3 -y
+                  
+                  if ($LASTEXITCODE -eq 0) {
+                      Write-Host "Python installed successfully via Chocolatey"
+                      # Refresh PATH
+                      $env:PATH = [System.Environment]::GetEnvironmentVariable("PATH","Machine") + ";" + [System.Environment]::GetEnvironmentVariable("PATH","User")
+                      
+                      # Verify installation
+                      try {
+                          $version = python --version 2>&1
+                          Write-Host "Python verification successful: $version"
+                      } catch {
+                          Write-Host "Python installation verification failed"
+                      }
+                  } else {
+                      Write-Host "Chocolatey Python installation failed"
+                  }
+              } else {
+                  Write-Host "Chocolatey not available for Python installation"
+              }
+
+        - name: Setup Python3 symlink
+          if: steps.check.outputs.python-available == 'true'
+          shell: powershell
+          run: |
+              if (-not (Get-Command python3 -ErrorAction SilentlyContinue)) {
+                  if (Get-Command python -ErrorAction SilentlyContinue) {
+                      Write-Host "Creating python3 symlink..."
+                      $pythonPath = (Get-Command python).Source
+                      $python3Path = Join-Path (Split-Path $pythonPath) "python3.exe"
+                      New-Item -ItemType HardLink -Path $python3Path -Target $pythonPath -Force
+                      Write-Host "python3 symlink created"
+                  }
+              } else {
+                  Write-Host "python3 command already exists"
+              }
+
+        - name: Verify Python setup
+          shell: powershell
+          run: |
+              Write-Host "Verifying Python setup..."
+
+              $pythonWorking = $false
+
+              if (Get-Command python3 -ErrorAction SilentlyContinue) {
+                  try {
+                      $version = python3 --version 2>&1
+                      Write-Host "Python3 ready: $version"
+                      $pythonWorking = $true
+                  } catch {
+                      Write-Host "Python3 command failed: $_"
+                  }
+              } elseif (Get-Command python -ErrorAction SilentlyContinue) {
+                  try {
+                      $version = python --version 2>&1
+                      Write-Host "Python ready: $version"
+                      $pythonWorking = $true
+                  } catch {
+                      Write-Host "Python command failed: $_"
+                  }
+              } else {
+                  Write-Host "No Python commands available"
+              }
+
+              if (-not $pythonWorking) {
+                  Write-Host "Warning: Python verification failed, but continuing workflow"
+                  Write-Host "Python may still work for the actual build process"
+              } else {
+                  Write-Host "Python verification successful"
+              }
diff --git a/docs/REMOTE_CLUSTER_CREDENTIALS.md b/docs/REMOTE_CLUSTER_CREDENTIALS.md
new file mode 100644
index 0000000000..e92a1027a2
--- /dev/null
+++ b/docs/REMOTE_CLUSTER_CREDENTIALS.md
@@ -0,0 +1,247 @@
+# Remote Cluster Credentials Setup
+
+This guide explains how to securely configure SSH credentials for remote Valkey cluster access.
+
+## Overview
+
+Windows runners connect to Linux runners via SSH to manage Valkey clusters. This requires secure credential management using GitHub secrets and variables.
+
+## Required Credentials
+
+### 1. SSH Key Pair
+
+**Generate SSH key pair:**
+```bash
+# Generate new key pair for Valkey runner
+ssh-keygen -t ed25519 -f ~/.ssh/valkey_runner_key -C "valkey-runner@github-actions"
+
+# Public key (add to Linux runner)
+cat ~/.ssh/valkey_runner_key.pub
+
+# Private key (add to GitHub secret)
+cat ~/.ssh/valkey_runner_key
+```
+
+### 2. GitHub Repository Configuration
+
+#### Secrets (Repository Settings → Secrets and variables → Actions)
+
+**Required Secrets:**
+```
+VALKEY_RUNNER_SSH_KEY
+├── Description: Private SSH key for remote cluster access
+├── Value: Contents of ~/.ssh/valkey_runner_key (entire file)
+└── Usage: Automatically injected into Windows workflows
+
+AWS_ACCESS_KEY_ID (optional - for EC2 management)
+├── Description: AWS access key for EC2 instance management
+└── Value: Your AWS access key
+
+AWS_SECRET_ACCESS_KEY (optional - for EC2 management)  
+├── Description: AWS secret key for EC2 instance management
+└── Value: Your AWS secret access key
+
+AWS_KEY_PAIR_NAME (optional - for EC2 management)
+├── Description: EC2 key pair name for instance creation
+└── Value: Name of your EC2 key pair
+```
+
+#### Variables (Repository Settings → Secrets and variables → Actions)
+
+**Required Variables:**
+```
+VALKEY_REMOTE_HOST
+├── Description: IP address or hostname of Linux runner
+├── Value: 192.168.1.100 (example)
+└── Usage: Target host for SSH connections
+```
+
+## Setup Process
+
+### Step 1: Prepare Linux Runner
+
+**Option A: Manual EC2 Setup**
+```bash
+# Launch Ubuntu 22.04 instance
+# Security group: SSH (22), Valkey (6379-6400), Cluster bus (16379-16400)
+
+# SSH to instance
+ssh -i your-key.pem ubuntu@<instance-ip>
+
+# Run setup script
+curl -sSL https://raw.githubusercontent.com/valkey-io/valkey-glide/main/utils/setup_linux_runner.sh -o setup_linux_runner.sh
+bash setup_linux_runner.sh
+rm setup_linux_runner.sh
+
+# Add public key to authorized_keys
+echo "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5... valkey-runner@github-actions" >> ~/.ssh/authorized_keys
+```
+
+**Option B: GitHub Workflow**
+```bash
+# Use setup-linux-runner.yml workflow
+gh workflow run setup-linux-runner.yml -f action=start -f instance_type=t3.medium
+```
+
+### Step 2: Configure GitHub Repository
+
+**Add SSH private key to secrets:**
+```bash
+# Copy private key content
+cat ~/.ssh/valkey_runner_key | pbcopy
+
+# Go to GitHub repo → Settings → Secrets and variables → Actions
+# New repository secret: VALKEY_RUNNER_SSH_KEY
+# Paste the private key content (including -----BEGIN/END----- lines)
+```
+
+**Add remote host to variables:**
+```bash
+# Get Linux runner IP
+curl -s http://169.254.169.254/latest/meta-data/public-ipv4  # On EC2 instance
+
+# Go to GitHub repo → Settings → Secrets and variables → Actions → Variables
+# New repository variable: VALKEY_REMOTE_HOST
+# Value: <linux-runner-ip>
+```
+
+### Step 3: Test Configuration
+
+**Manual test:**
+```bash
+# Test SSH connection
+ssh -i ~/.ssh/valkey_runner_key ubuntu@<remote-host> "echo 'Connection successful'"
+
+# Test remote cluster manager
+python3 utils/remote_cluster_manager.py --host <remote-host> test
+```
+
+**Workflow test:**
+```bash
+# Trigger Java workflow on Windows
+# Check logs for "✅ Remote cluster access configured successfully"
+```
+
+## Security Best Practices
+
+### SSH Key Security
+- ✅ **Use dedicated key pair** - Don't reuse existing keys
+- ✅ **Ed25519 algorithm** - More secure than RSA
+- ✅ **No passphrase** - GitHub Actions can't handle interactive prompts
+- ✅ **Rotate regularly** - Generate new keys periodically
+
+### GitHub Secrets
+- ✅ **Repository secrets only** - Don't use organization secrets for SSH keys
+- ✅ **Minimal permissions** - Only workflows that need access
+- ✅ **Audit access** - Monitor secret usage in workflow logs
+
+### Network Security
+- ✅ **Security groups** - Restrict SSH access to GitHub IP ranges (if possible)
+- ✅ **VPC isolation** - Use private subnets with NAT gateway
+- ✅ **SSH hardening** - Disable password auth, use key-only
+
+### Instance Security
+- ✅ **Regular updates** - Keep Linux runner patched
+- ✅ **Minimal services** - Only run necessary services
+- ✅ **Monitoring** - Log SSH access and cluster operations
+
+## Credential Flow
+
+```mermaid
+sequenceDiagram
+    participant GH as GitHub Workflow
+    participant W as Windows Runner
+    participant L as Linux Runner
+    
+    GH->>W: Inject VALKEY_RUNNER_SSH_KEY secret
+    W->>W: Write SSH key to ~/.ssh/valkey_runner_key
+    W->>W: Set permissions (600)
+    W->>L: Test SSH connection
+    L-->>W: Connection successful
+    W->>L: Execute remote_cluster_manager.py
+    L->>L: Start Valkey cluster
+    L-->>W: Return cluster endpoints
+    W->>W: Run Java tests with remote endpoints
+```
+
+## Troubleshooting
+
+### SSH Connection Failures
+
+**Check SSH key format:**
+```bash
+# Key should start/end with these lines
+-----BEGIN OPENSSH PRIVATE KEY-----
+...
+-----END OPENSSH PRIVATE KEY-----
+```
+
+**Test SSH manually:**
+```bash
+# From Windows runner (in workflow)
+ssh -vvv -i ~/.ssh/valkey_runner_key ubuntu@<remote-host>
+```
+
+**Check security group:**
+```bash
+# Ensure port 22 is open
+aws ec2 describe-security-groups --group-names valkey-runner-sg
+```
+
+### Remote Cluster Failures
+
+**Check Valkey installation:**
+```bash
+ssh -i ~/.ssh/valkey_runner_key ubuntu@<remote-host> "valkey-server --version"
+```
+
+**Check cluster manager:**
+```bash
+ssh -i ~/.ssh/valkey_runner_key ubuntu@<remote-host> "cd valkey-glide/utils && python3 cluster_manager.py --help"
+```
+
+**Check firewall:**
+```bash
+ssh -i ~/.ssh/valkey_runner_key ubuntu@<remote-host> "sudo ufw status"
+```
+
+### GitHub Secrets Issues
+
+**Verify secret exists:**
+- Go to repo Settings → Secrets and variables → Actions
+- Confirm VALKEY_RUNNER_SSH_KEY is listed
+
+**Check secret content:**
+- Secrets are masked in logs, but you can verify length
+- Should be ~400-800 characters for Ed25519 key
+
+**Test in workflow:**
+```yaml
+- name: Debug SSH key
+  run: |
+    echo "SSH key length: ${#SSH_PRIVATE_KEY_CONTENT}"
+    echo "SSH key starts with: $(echo "$SSH_PRIVATE_KEY_CONTENT" | head -1)"
+  env:
+    SSH_PRIVATE_KEY_CONTENT: ${{ secrets.VALKEY_RUNNER_SSH_KEY }}
+```
+
+## Cost Management
+
+### Instance Lifecycle
+```bash
+# Start runner for testing
+gh workflow run setup-linux-runner.yml -f action=start
+
+# Stop runner to save costs  
+gh workflow run setup-linux-runner.yml -f action=stop
+
+# Check current status
+gh workflow run setup-linux-runner.yml -f action=status
+```
+
+### Shared Usage
+- One Linux runner can serve multiple repositories
+- Configure same VALKEY_REMOTE_HOST across repos
+- Share SSH key pair (but use separate GitHub secrets)
+
+This setup provides secure, cost-effective remote cluster access for Windows testing!
diff --git a/docs/REMOTE_CLUSTER_SETUP.md b/docs/REMOTE_CLUSTER_SETUP.md
new file mode 100644
index 0000000000..2ecc02aae3
--- /dev/null
+++ b/docs/REMOTE_CLUSTER_SETUP.md
@@ -0,0 +1,182 @@
+# Remote Cluster Setup for Windows Testing
+
+This document describes how to set up external Linux infrastructure for running Valkey clusters while testing on Windows.
+
+## Architecture
+
+```
+┌─────────────────┐    SSH/TCP    ┌─────────────────┐
+│  Windows Runner │ ──────────────▶│  Linux Runner   │
+│                 │               │                 │
+│ • Java Tests    │               │ • Valkey Server │
+│ • Gradle Build  │               │ • cluster_mgr   │
+│ • Remote Calls  │               │ • Self-hosted   │
+└─────────────────┘               └─────────────────┘
+```
+
+## Cost Analysis
+
+**Self-hosted runners are more cost-effective:**
+- **Containers**: Pay for compute during entire workflow (~35-40 mins)
+- **Self-hosted**: Pay only for instance uptime, shared across workflows
+- **Estimated savings**: 60-80% for frequent testing
+
+## Setup Instructions
+
+### 1. Launch Linux Runner
+
+#### Option A: Manual EC2 Setup
+```bash
+# Launch t3.medium instance with Ubuntu 22.04
+# Security group: SSH (22), Valkey (6379-6400), Cluster bus (16379-16400)
+
+# SSH to instance and run setup
+ssh -i your-key.pem ubuntu@<instance-ip>
+curl -sSL https://raw.githubusercontent.com/valkey-io/valkey-glide/main/utils/setup_linux_runner.sh -o setup_linux_runner.sh
+bash setup_linux_runner.sh
+rm setup_linux_runner.sh
+```
+
+#### Option B: GitHub Workflow
+```bash
+# Use the setup-linux-runner.yml workflow
+gh workflow run setup-linux-runner.yml -f action=start -f instance_type=t3.medium
+```
+
+### 2. Configure GitHub Secrets
+
+Add these secrets to your repository:
+
+```
+VALKEY_RUNNER_SSH_KEY: <private-key-content>
+AWS_ACCESS_KEY_ID: <aws-access-key>
+AWS_SECRET_ACCESS_KEY: <aws-secret-key>
+AWS_KEY_PAIR_NAME: <ec2-key-pair-name>
+```
+
+Add these variables:
+
+```
+VALKEY_REMOTE_HOST: <linux-runner-ip>
+```
+
+### 3. Test the Setup
+
+#### Local Test
+```bash
+# Test remote cluster manager
+python3 utils/remote_cluster_manager.py --host <linux-ip> start --cluster-mode -r 1
+
+# Test Java with remote cluster
+export VALKEY_REMOTE_HOST=<linux-ip>
+cd java && ./gradlew integTest
+```
+
+#### CI Test
+```bash
+# Windows workflow will automatically use remote cluster when VALKEY_REMOTE_HOST is set
+# No code changes needed in tests - they connect to remote endpoints transparently
+```
+
+## How It Works
+
+### Remote Cluster Manager
+
+The `remote_cluster_manager.py` script:
+
+1. **SSH Connection**: Connects to Linux runner via SSH
+2. **Repository Sync**: Ensures valkey-glide repo is up-to-date
+3. **Cluster Management**: Executes cluster_manager.py remotely
+4. **Endpoint Translation**: Converts localhost addresses to remote IPs
+5. **Result Parsing**: Returns connection strings for Java tests
+
+### Gradle Integration
+
+The Gradle build automatically detects remote mode:
+
+```gradle
+def remoteHost = System.getenv("VALKEY_REMOTE_HOST")
+if (remoteHost != null) {
+    // Use remote_cluster_manager.py
+    exec {
+        commandLine pythonCmd, 'remote_cluster_manager.py', '--host', remoteHost, 'start', '--cluster-mode'
+    }
+} else {
+    // Use local cluster_manager.py
+    exec {
+        commandLine pythonCmd, 'cluster_manager.py', 'start', '--cluster-mode'
+    }
+}
+```
+
+### Java Test Transparency
+
+Java tests require no changes:
+- Gradle provides remote endpoints via system properties
+- Tests connect to `<remote-ip>:6379` instead of `localhost:6379`
+- All existing test logic works unchanged
+
+## Troubleshooting
+
+### SSH Connection Issues
+```bash
+# Test SSH connectivity
+ssh -i ~/.ssh/valkey_runner_key ubuntu@<remote-ip> "echo 'SSH works'"
+
+# Check security group allows SSH (port 22)
+aws ec2 describe-security-groups --group-names valkey-runner-sg
+```
+
+### Cluster Start Failures
+```bash
+# Check remote Valkey installation
+ssh -i ~/.ssh/valkey_runner_key ubuntu@<remote-ip> "valkey-server --version"
+
+# Check cluster manager
+ssh -i ~/.ssh/valkey_runner_key ubuntu@<remote-ip> "cd valkey-glide/utils && python3 cluster_manager.py --help"
+
+# Manual cluster test
+ssh -i ~/.ssh/valkey_runner_key ubuntu@<remote-ip> "cd valkey-glide/utils && python3 cluster_manager.py start --cluster-mode"
+```
+
+### Network Connectivity
+```bash
+# Test Valkey port access from Windows
+telnet <remote-ip> 6379
+
+# Check firewall on Linux runner
+ssh -i ~/.ssh/valkey_runner_key ubuntu@<remote-ip> "sudo ufw status"
+```
+
+## Cost Optimization
+
+### Instance Management
+```bash
+# Start runner when needed
+gh workflow run setup-linux-runner.yml -f action=start
+
+# Stop runner to save costs
+gh workflow run setup-linux-runner.yml -f action=stop
+
+# Check status
+gh workflow run setup-linux-runner.yml -f action=status
+```
+
+### Shared Usage
+- One Linux runner can serve multiple Windows workflows
+- Runner stays alive between test runs
+- Automatic cluster cleanup between tests
+
+## Security Considerations
+
+1. **SSH Keys**: Use dedicated key pair for runner access
+2. **Security Groups**: Restrict access to necessary ports only
+3. **Instance Isolation**: Use dedicated VPC if handling sensitive data
+4. **Automatic Shutdown**: Configure auto-shutdown for cost control
+
+## Performance Benefits
+
+- **No WSL overhead**: Native Linux performance for Valkey
+- **Better networking**: No WSL networking quirks
+- **Faster cluster creation**: Optimized Linux environment
+- **Consistent behavior**: Same environment as production Linux tests
diff --git a/glide-core/redis-rs/redis/Cargo.toml b/glide-core/redis-rs/redis/Cargo.toml
index daebe688f4..4fa3d5c9b6 100644
--- a/glide-core/redis-rs/redis/Cargo.toml
+++ b/glide-core/redis-rs/redis/Cargo.toml
@@ -42,7 +42,7 @@ bytes = { version = "1", optional = true }
 futures-util = { version = "0.3", default-features = false, optional = true }
 pin-project-lite = { version = "0.2", optional = true }
 tokio-util = { version = "0.7", optional = true }
-tokio = { version = "1", features = ["rt", "net", "time", "sync"] }
+tokio = { version = "1.48", features = ["rt", "net", "time", "sync"] }
 socket2 = { version = "0.6", features = ["all"], optional = true }
 dispose = { version = "0.5", optional = true }
 
@@ -63,11 +63,11 @@ async-trait = { version = "0.1", optional = true }
 tokio-retry2 = { version = "0.5", features = ["jitter"], optional = true }
 
 # Only needed for rustls (default TLS implementation)
-rustls = { version = "0.23", features = ["aws-lc-rs"] }
-rustls-platform-verifier = { version = "0.6", default-features = false }
-tokio-rustls = { version = "0.26", default-features = false }
-rustls-pemfile = { version = "2" }
-rustls-pki-types = { version = "1" }
+rustls = { version = "0.23.35", features = ["aws-lc-rs"] }
+rustls-platform-verifier = { version = "0.6.2", default-features = false }
+tokio-rustls = { version = "0.26.4", default-features = false }
+rustls-pemfile = { version = "2.2.0" }
+rustls-pki-types = { version = "1.13.0" }
 
 # Only needed for bignum Support
 num-bigint = "0.4"
diff --git a/glide-core/redis-rs/redis/src/cluster_async/mod.rs b/glide-core/redis-rs/redis/src/cluster_async/mod.rs
index e43834a7e4..e8e6d6acca 100644
--- a/glide-core/redis-rs/redis/src/cluster_async/mod.rs
+++ b/glide-core/redis-rs/redis/src/cluster_async/mod.rs
@@ -598,8 +598,9 @@ impl<C> From<InternalSingleNodeRouting<C>> for InternalRoutingInfo<C> {
     }
 }
 
-#[derive(Clone)]
+#[derive(Clone, Default)]
 pub(crate) enum InternalSingleNodeRouting<C> {
+    #[default]
     Random,
     SpecificNode(Route),
     ByAddress(String),
@@ -613,12 +614,6 @@ pub(crate) enum InternalSingleNodeRouting<C> {
     },
 }
 
-impl<C> Default for InternalSingleNodeRouting<C> {
-    fn default() -> Self {
-        Self::Random
-    }
-}
-
 impl<C> From<SingleNodeRoutingInfo> for InternalSingleNodeRouting<C> {
     fn from(value: SingleNodeRoutingInfo) -> Self {
         match value {
@@ -1286,24 +1281,34 @@ where
             .fold(
                 (
                     ConnectionsMap(DashMap::with_capacity(initial_nodes.len())),
-                    None,
+                    Vec::new(), // Collect ALL errors instead of just the last one
                 ),
-                |connections: (ConnectionMap<C>, Option<String>), addr_conn_res| async move {
+                |mut connections: (ConnectionMap<C>, Vec<String>), addr_conn_res| async move {
                     match addr_conn_res {
                         Ok((addr, node)) => {
                             connections.0 .0.insert(addr, node);
-                            (connections.0, None)
+                            connections
+                        }
+                        Err(e) => {
+                            connections.1.push(e.to_string()); // Collect all errors
+                            connections
                         }
-                        Err(e) => (connections.0, Some(e.to_string())),
                     }
                 },
             )
             .await;
         if connections.0 .0.is_empty() {
+            let error_message = if connections.1.is_empty() {
+                "No errors reported".to_string()
+            } else {
+                format!("All {} connection attempts failed: [{}]", 
+                    connections.1.len(), 
+                    connections.1.join(", "))
+            };
             return Err(RedisError::from((
                 ErrorKind::IoError,
                 "Failed to create initial connections",
-                connections.1.unwrap_or("".to_string()),
+                error_message,
             )));
         }
         info!("Connected to initial nodes:\n{}", connections.0);
diff --git a/glide-core/redis-rs/redis/src/connection.rs b/glide-core/redis-rs/redis/src/connection.rs
index caaeaa453d..f4527df577 100644
--- a/glide-core/redis-rs/redis/src/connection.rs
+++ b/glide-core/redis-rs/redis/src/connection.rs
@@ -606,6 +606,19 @@ impl ActualConnection {
                 ref tls_params,
             } => {
                 let host: &str = host;
+                
+                // DEBUG: Log TLS connection attempt
+                println!("CLUSTER TLS DEBUG: Creating TLS connection to {}:{}", host, port);
+                if let Some(ref params) = tls_params {
+                    if let Some(ref store) = params.root_cert_store {
+                        println!("CLUSTER TLS DEBUG: Root cert store has {} certificates", store.len());
+                    } else {
+                        println!("CLUSTER TLS DEBUG: No root cert store");
+                    }
+                } else {
+                    println!("CLUSTER TLS DEBUG: No TLS params for {}:{}", host, port);
+                }
+                
                 let config = create_rustls_config(insecure, tls_params.as_ref().cloned())?;
                 let server_name = rustls_pki_types::ServerName::try_from(host)
                     .map_err(|e| {
diff --git a/glide-core/src/client/mod.rs b/glide-core/src/client/mod.rs
index 794d1b374a..d79351a6f1 100644
--- a/glide-core/src/client/mod.rs
+++ b/glide-core/src/client/mod.rs
@@ -1170,15 +1170,30 @@ async fn create_cluster_client(
             )));
         }
         let mut combined_certs = Vec::new();
-        for cert in &request.root_certs {
+        for (i, cert) in request.root_certs.iter().enumerate() {
             if cert.is_empty() {
                 return Err(RedisError::from((
                     ErrorKind::InvalidClientConfig,
                     "Root certificate cannot be empty byte string",
                 )));
             }
+            
+            // Add the certificate
             combined_certs.extend_from_slice(cert);
+            
+            // Ensure proper PEM separation between certificates
+            if i < request.root_certs.len() - 1 && !cert.ends_with(b"\n") {
+                combined_certs.push(b'\n');
+            }
         }
+        
+        // DEBUG: Print certificate content for cluster connections
+        println!("CLUSTER TLS DEBUG: Certificate stream length: {}", combined_certs.len());
+        println!("CLUSTER TLS DEBUG: First 50 bytes: {:?}", 
+            combined_certs.iter().take(50).collect::<Vec<_>>());
+        println!("CLUSTER TLS DEBUG: Last 50 bytes: {:?}", 
+            combined_certs.iter().rev().take(50).collect::<Vec<_>>());
+        
         let tls_certs = TlsCertificates {
             client_tls: None,
             root_cert: Some(combined_certs),
@@ -1191,15 +1206,47 @@ async fn create_cluster_client(
     let initial_nodes: Vec<_> = request
         .addresses
         .into_iter()
-        .map(|address| {
-            get_connection_info(
+        .enumerate()
+        .map(|(i, address)| {
+            // DEBUG: Log certificate data for each address
+            println!("CLUSTER TLS DEBUG: Address {}: {}:{}", 
+                i, address.host, get_port(&address));
+            
+            // Create fresh TLS params for each connection instead of cloning
+            let fresh_tls_params = if !request.root_certs.is_empty() && tls_mode != TlsMode::NoTls {
+                let mut combined_certs = Vec::new();
+                for (j, cert) in request.root_certs.iter().enumerate() {
+                    combined_certs.extend_from_slice(cert);
+                    if j < request.root_certs.len() - 1 && !cert.ends_with(b"\n") {
+                        combined_certs.push(b'\n');
+                    }
+                }
+                
+                let tls_certs = TlsCertificates {
+                    client_tls: None,
+                    root_cert: Some(combined_certs),
+                };
+                
+                println!("CLUSTER TLS DEBUG: Creating fresh TLS params for address {}", i);
+                match retrieve_tls_certificates(tls_certs) {
+                    Ok(params) => Some(params),
+                    Err(e) => {
+                        println!("CLUSTER TLS DEBUG: Failed to create TLS params for address {}: {}", i, e);
+                        return Err(e);
+                    }
+                }
+            } else {
+                None
+            };
+            
+            Ok(get_connection_info(
                 &address,
                 tls_mode,
                 valkey_connection_info.clone(),
-                tls_params.clone(),
-            )
+                fresh_tls_params,
+            ))
         })
-        .collect();
+        .collect::<Result<Vec<_>, _>>()?;
 
     let periodic_topology_checks = match request.periodic_checks {
         Some(PeriodicCheck::Disabled) => None,
diff --git a/glide-core/src/client/standalone_client.rs b/glide-core/src/client/standalone_client.rs
index f99279bedb..07c1b4c8be 100644
--- a/glide-core/src/client/standalone_client.rs
+++ b/glide-core/src/client/standalone_client.rs
@@ -166,6 +166,12 @@ impl StandaloneClient {
             for cert in &connection_request.root_certs {
                 combined_certs.extend_from_slice(cert);
             }
+            
+            // DEBUG: Print certificate content for standalone connections
+            println!("STANDALONE TLS DEBUG: Certificate stream length: {}", combined_certs.len());
+            println!("STANDALONE TLS DEBUG: First 50 bytes: {:?}", 
+                combined_certs.iter().take(50).collect::<Vec<_>>());
+            
             let tls_certificates = redis::TlsCertificates {
                 client_tls: None,
                 root_cert: Some(combined_certs),
diff --git a/java/.ort.yml b/java/.ort.yml
index ace1740f01..74f6cb5db4 100644
--- a/java/.ort.yml
+++ b/java/.ort.yml
@@ -1,23 +1,23 @@
 excludes:
-  paths:
-    - pattern: "java/benchmarks/**"
-      reason: "TEST_OF"
-      comment: >-
-        Licenses contained in this directory are used for benchmarks and do not apply to the OSS Review Toolkit.
-    - pattern: "java/integTest/**"
-      reason: "TEST_OF"
-      comment: >-
-        Licenses contained in this directory are used for testing and do not apply to the OSS Review Toolkit.
-  scopes:
-    - pattern: "test.*"
-      reason: "TEST_DEPENDENCY_OF"
-      comment: Packages for testing only. Not part of released artifacts.
-    - pattern: "(spotbugs.*|spotbugsSlf4j.*)"
-      reason: "TEST_DEPENDENCY_OF"
-      comment: Packages for static analysis only. Not part of released artifacts.
-    - pattern: "jacoco.*"
-      reason: "TEST_DEPENDENCY_OF"
-      comment: Packages for code coverage verification only. Not part of released artifacts.
-    - pattern: "compileClasspath.*"
-      reason: "TEST_DEPENDENCY_OF"
-      comment: Packages for Gradle only. Not part of released artifacts.
+    paths:
+        - pattern: "java/benchmarks/**"
+          reason: "TEST_OF"
+          comment: >-
+              Licenses contained in this directory are used for benchmarks and do not apply to the OSS Review Toolkit.
+        - pattern: "java/integTest/**"
+          reason: "TEST_OF"
+          comment: >-
+              Licenses contained in this directory are used for testing and do not apply to the OSS Review Toolkit.
+    scopes:
+        - pattern: "test.*"
+          reason: "TEST_DEPENDENCY_OF"
+          comment: Packages for testing only. Not part of released artifacts.
+        - pattern: "(spotbugs.*|spotbugsSlf4j.*)"
+          reason: "TEST_DEPENDENCY_OF"
+          comment: Packages for static analysis only. Not part of released artifacts.
+        - pattern: "jacoco.*"
+          reason: "TEST_DEPENDENCY_OF"
+          comment: Packages for code coverage verification only. Not part of released artifacts.
+        - pattern: "compileClasspath.*"
+          reason: "TEST_DEPENDENCY_OF"
+          comment: Packages for Gradle only. Not part of released artifacts.
diff --git a/java/build.gradle b/java/build.gradle
index a8ad68d9af..3bf381084e 100644
--- a/java/build.gradle
+++ b/java/build.gradle
@@ -109,6 +109,7 @@ spotless {
         removeUnusedImports()
         trimTrailingWhitespace()
         endWithNewline()
+        lineEndings 'UNIX'
         googleJavaFormat('1.22.0').reflowLongStrings().groupArtifact('com.google.googlejavaformat:google-java-format')
         leadingSpacesToTabs(2)
         leadingTabsToSpaces(4)
diff --git a/java/client/build.gradle b/java/client/build.gradle
index 5b08b319d3..b15c0eea0f 100644
--- a/java/client/build.gradle
+++ b/java/client/build.gradle
@@ -13,6 +13,16 @@ repositories {
     mavenCentral()
 }
 
+tasks.withType(JavaCompile) {
+    options.encoding = 'UTF-8'
+}
+
+tasks.withType(Javadoc) {
+    options.encoding = 'UTF-8'
+    options.charSet = 'UTF-8'
+    options.docEncoding = 'UTF-8'
+}
+
 dependencies {
     implementation('com.google.protobuf:protobuf-java') {
         version {
@@ -103,6 +113,8 @@ tasks.register('buildRust', Exec) {
             target = "${arch}-unknown-linux-gnu.2.17"
         } else if (osdetector.os == 'linux' && osdetector.release.id == 'alpine') {
             target = "${arch}-unknown-linux-musl"
+        } else if (osdetector.os == 'windows') {
+            target = "${arch}-pc-windows-msvc"
         } else {
             target = ""
         }
@@ -114,8 +126,13 @@ tasks.register('buildRust', Exec) {
     } else if (target.contains("musl")) {
         commandLine 'cargo', 'zigbuild', '--target', "$target", '--release'
         environment RUSTFLAGS: '-C target-feature=-crt-static'
+    } else if (target.contains("windows")) {
+        commandLine 'cargo', 'build', '--target', "$target", '--release', '-j', '4'
+        environment CARGO_BUILD_JOBS: '4'
+        environment RUSTFLAGS: '-C codegen-units=16 -C link-arg=-fuse-ld=lld'
     } else {
         commandLine 'cargo', 'build', '--release'
+        environment RUSTFLAGS: '-C codegen-units=16'
     }
     workingDir project.rootDir
     environment CARGO_TERM_COLOR: 'always'
@@ -148,6 +165,8 @@ tasks.register('copyNativeLib', Copy) {
         from "${projectDir}/../target/${arch}-unknown-linux-gnu/release/"
     } else if (osdetector.os == 'linux' && osdetector.release.id == 'alpine') {
         from "${projectDir}/../target/${arch}-unknown-linux-musl/release/"
+    } else if (osdetector.os == 'windows') {
+        from "${projectDir}/../target/${arch}-pc-windows-msvc/release/"
     } else {
         from "${projectDir}/../target/release/"
     }
@@ -254,6 +273,8 @@ tasks.withType(Test) {
         jvmArgs "-Djava.library.path=${projectDir}/../target/${arch}-unknown-linux-gnu/release"
     } else if (osdetector.os == 'linux' && osdetector.release.id == 'alpine') {
         jvmArgs "-Djava.library.path=${projectDir}/../target/${arch}-unknown-linux-musl/release"
+    } else if (osdetector.os == 'windows') {
+        jvmArgs "-Djava.library.path=${projectDir}/../target/${arch}-pc-windows-msvc/release"
     } else {
         jvmArgs "-Djava.library.path=${projectDir}/../target/release"
     }
diff --git a/java/client/src/main/java/glide/ffi/resolvers/NativeUtils.java b/java/client/src/main/java/glide/ffi/resolvers/NativeUtils.java
index 071bc8e615..a89681aa5f 100644
--- a/java/client/src/main/java/glide/ffi/resolvers/NativeUtils.java
+++ b/java/client/src/main/java/glide/ffi/resolvers/NativeUtils.java
@@ -31,10 +31,18 @@ public class NativeUtils {
     /** Temporary directory which will contain the dynamic library files. */
     private static File temporaryDir;
 
+    /** Track if the Glide library has already been loaded */
+    private static volatile boolean glideLibLoaded = false;
+
     /** Private constructor - this class will never be instanced */
     private NativeUtils() {}
 
-    public static void loadGlideLib() {
+    public static synchronized void loadGlideLib() {
+        // Check if already loaded to avoid multiple loads
+        if (glideLibLoaded) {
+            return;
+        }
+
         String glideLib = "/libglide_rs";
         try {
             String osName = System.getProperty("os.name").toLowerCase();
@@ -42,10 +50,13 @@ public static void loadGlideLib() {
                 NativeUtils.loadLibraryFromJar(glideLib + ".dylib");
             } else if (osName.contains("linux")) {
                 NativeUtils.loadLibraryFromJar(glideLib + ".so");
+            } else if (osName.contains("windows")) {
+                NativeUtils.loadLibraryFromJar("/glide_rs.dll");
             } else {
                 throw new UnsupportedOperationException(
-                        "OS not supported. Glide is only available on Mac OS and Linux systems.");
+                        "OS not supported. Glide is only available on Mac OS, Linux, and Windows systems.");
             }
+            glideLibLoaded = true; // Mark as loaded after successful load
         } catch (java.io.IOException e) {
             e.printStackTrace();
         }
diff --git a/java/integTest/build.gradle b/java/integTest/build.gradle
index 0bc2afb87f..b4d15956d2 100644
--- a/java/integTest/build.gradle
+++ b/java/integTest/build.gradle
@@ -13,7 +13,7 @@ tasks.withType(JavaCompile) {
 }
 
 dependencies {
-    def classifier 
+    def classifier
     if (osdetector.os == 'linux' && osdetector.release.id == 'alpine') {
         classifier = "linux_musl-${osdetector.arch}"
     }
@@ -22,7 +22,7 @@ dependencies {
     }
     // Use published GLIDE artifact
     implementation group: 'io.valkey', name: 'valkey-glide', version: project.ext.defaultReleaseVersion, classifier: classifier
-    
+
     // Use published jedis-compatibility artifact
     testImplementation group: 'io.valkey', name: 'valkey-glide-jedis-compatibility', version: project.ext.defaultReleaseVersion, classifier: osdetector.classifier
 
@@ -52,13 +52,20 @@ def clusterHosts = ''
 def clusterTlsHosts = ''
 def azClusterHosts = ''
 
+// Platform-specific Python executable
+def isWindows = System.getProperty('os.name').toLowerCase().contains('windows')
+def pythonCmd = isWindows ? ['python3'] : ['python3']
+
+// Use integration test IP from environment variable if available, otherwise default to localhost
+def clusterHost = System.getenv('VALKEY_INTEG_TEST_IP') ?: '127.0.0.1'
+
 ext {
     extractAddressesFromClusterManagerOutput = { String output ->
-        for (def line : output.split("\n")) {
+        for (def line : output.readLines()) {  // Use readLines() for cross-platform line splitting
             if (!line.startsWith("CLUSTER_NODES="))
                 continue
 
-            return line.split("=")[1]
+            return line.split("=")[1].trim()  // Add trim() to remove trailing whitespace
         }
         return ''
     }
@@ -66,15 +73,27 @@ ext {
 
 tasks.register('stopAllAfterTests') {
     doLast {
-        exec {
-            workingDir "${project.rootDir}/../utils"
-            commandLine 'python3', 'cluster_manager.py', 'stop', '--prefix', 'cluster', '--keep-folder'
-            ignoreExitValue true // ignore fail if servers are stopped before
-        }
-        exec {
-            workingDir "${project.rootDir}/../utils"
-            commandLine 'python3', 'cluster_manager.py', '--tls', 'stop', '--prefix', 'tls-cluster', '--keep-folder'
-            ignoreExitValue true
+        // Check if we should use remote cluster manager
+        def remoteHost = System.getenv("VALKEY_REMOTE_HOST")
+        if (remoteHost != null && !remoteHost.isEmpty()) {
+            // Stop remote clusters
+            exec {
+                workingDir "${project.rootDir}/../utils"
+                commandLine(*pythonCmd, 'remote_cluster_manager.py', '--host', remoteHost, 'stop')
+                ignoreExitValue true // ignore fail if servers are stopped before
+            }
+        } else {
+            // Stop local clusters
+            exec {
+                workingDir "${project.rootDir}/../utils"
+                commandLine(*pythonCmd, 'cluster_manager.py', '--host', clusterHost, 'stop', '--prefix', 'cluster', '--keep-folder')
+                ignoreExitValue true // ignore fail if servers are stopped before
+            }
+            exec {
+                workingDir "${project.rootDir}/../utils"
+                commandLine(*pythonCmd, 'cluster_manager.py', '--host', clusterHost, 'stop', '--prefix', 'cluster', '--keep-folder')
+                ignoreExitValue true
+            }
         }
     }
 }
@@ -84,15 +103,29 @@ tasks.register('stopAllAfterTests') {
 // We need to call for stop in case if previous test run was interrupted/crashed and didn't stop.
 tasks.register('stopAllBeforeTests') {
     doLast {
-        exec {
-            workingDir "${project.rootDir}/../utils"
-            commandLine 'python3', 'cluster_manager.py', 'stop', '--prefix', 'cluster'
-            ignoreExitValue true // ignore fail if servers are stopped before
-        }
-        exec {
-            workingDir "${project.rootDir}/../utils"
-            commandLine 'python3', 'cluster_manager.py', '--tls', 'stop', '--prefix', 'tls-cluster'
-            ignoreExitValue true
+        println "=== STOPPING ALL CLUSTERS BEFORE TESTS ==="
+        // Check if we should use remote cluster manager
+        def remoteHost = System.getenv("VALKEY_REMOTE_HOST")
+        if (remoteHost != null && !remoteHost.isEmpty()) {
+            println "Stopping remote clusters on: ${remoteHost}"
+            // Stop remote clusters
+            exec {
+                workingDir "${project.rootDir}/../utils"
+                commandLine(*pythonCmd, 'remote_cluster_manager.py', '--host', remoteHost, 'stop')
+                ignoreExitValue true // ignore fail if servers are stopped before
+            }
+        } else {
+            // Stop local clusters
+            exec {
+                workingDir "${project.rootDir}/../utils"
+                commandLine(*pythonCmd, 'cluster_manager.py', '--host', clusterHost, 'stop', '--prefix', 'cluster', '--keep-folder')
+                ignoreExitValue true // ignore fail if servers are stopped before
+            }
+            exec {
+                workingDir "${project.rootDir}/../utils"
+                commandLine(*pythonCmd, 'cluster_manager.py', '--host', clusterHost, 'stop', '--prefix', 'cluster', '--keep-folder')
+                ignoreExitValue true
+            }
         }
     }
 }
@@ -105,15 +138,37 @@ tasks.register('clearDirs', Delete) {
 tasks.register('startCluster') {
     doLast {
         if (System.getProperty("cluster-endpoints") == null) {
-            new ByteArrayOutputStream().withStream { os ->
-                exec {
-                    workingDir "${project.rootDir}/../utils"
-                    def args = ['python3', 'cluster_manager.py', 'start', '--cluster-mode']
-                    if (System.getProperty("tls") == 'true') args.add(2, '--tls')
-                    commandLine args
-                    standardOutput = os
+            def engineVersion = System.getProperty("engine-version") ?: "valkey-8.0"
+            // Check if we should use remote cluster manager
+            def remoteHost = System.getenv("VALKEY_REMOTE_HOST")
+            if (remoteHost != null && !remoteHost.isEmpty()) {
+                // Use remote cluster manager
+                println "Using remote cluster manager for standalone with host: ${remoteHost}"
+                new ByteArrayOutputStream().withStream { os ->
+                    exec {
+                        workingDir "${project.rootDir}/../utils"
+                        def args = [*pythonCmd, 'remote_cluster_manager.py', '--host', remoteHost]
+                        if (System.getProperty("engine-version")) args.addAll(['--engine-version', System.getProperty("engine-version")])
+                        args.addAll(['start', '--cluster-mode', '-r', '1'])
+                        if (System.getProperty("tls") == 'true') args.add('--tls')
+                        commandLine args
+                        standardOutput = os
+                    }
+                    // Parse remote cluster endpoints
+                    clusterHosts = extractAddressesFromClusterManagerOutput(os.toString())
+                }
+            } else {
+                // Use local cluster manager (original behavior for non-Windows)
+                new ByteArrayOutputStream().withStream { os ->
+                    exec {
+                        workingDir "${project.rootDir}/../utils"
+                        def args = [*pythonCmd, 'cluster_manager.py', '--host', clusterHost, 'start', '--cluster-mode', '-r', '1']
+                        if (System.getProperty("tls") == 'true') args.add('--tls')
+                        commandLine args
+                        standardOutput = os
+                    }
+                    clusterHosts = extractAddressesFromClusterManagerOutput(os.toString())
                 }
-                clusterHosts = extractAddressesFromClusterManagerOutput(os.toString())
             }
         } else {
             clusterHosts = System.getProperty("cluster-endpoints")
@@ -124,15 +179,37 @@ tasks.register('startCluster') {
 tasks.register('startClusterForAz') {
     doLast {
         if (System.getProperty("cluster-endpoints") == null) {
-            new ByteArrayOutputStream().withStream { os ->
-                exec {
-                    workingDir "${project.rootDir}/../utils"
-                    def args = ['python3', 'cluster_manager.py', 'start', '--cluster-mode', '-r', '4']
-                    if (System.getProperty("tls") == 'true') args.add(2, '--tls')
-                    commandLine args
-                    standardOutput = os
+            def engineVersion = System.getProperty("engine-version") ?: "valkey-8.0"
+
+            // Check if we should use remote cluster manager
+            def remoteHost = System.getenv("VALKEY_REMOTE_HOST")
+            if (remoteHost != null && !remoteHost.isEmpty()) {
+                // Use remote cluster manager
+                new ByteArrayOutputStream().withStream { os ->
+                    exec {
+                        workingDir "${project.rootDir}/../utils"
+                        def args = [*pythonCmd, 'remote_cluster_manager.py', '--host', remoteHost]
+                        if (System.getProperty("engine-version")) args.addAll(['--engine-version', System.getProperty("engine-version")])
+                        args.addAll(['start', '--cluster-mode', '-r', '4'])
+                        if (System.getProperty("tls") == 'true') args.add('--tls')
+                        commandLine args
+                        standardOutput = os
+                    }
+                    // Parse remote cluster endpoints
+                    azClusterHosts = extractAddressesFromClusterManagerOutput(os.toString())
+                }
+            } else {
+                // Use local cluster manager (original behavior for non-Windows)
+                new ByteArrayOutputStream().withStream { os ->
+                    exec {
+                        workingDir "${project.rootDir}/../utils"
+                        def args = [*pythonCmd, 'cluster_manager.py', '--host', clusterHost, 'start', '--cluster-mode', '-r', '4']
+                        if (System.getProperty("tls") == 'true') args.add('--tls')
+                        commandLine args
+                        standardOutput = os
+                    }
+                    azClusterHosts = extractAddressesFromClusterManagerOutput(os.toString())
                 }
-                azClusterHosts = extractAddressesFromClusterManagerOutput(os.toString())
             }
         } else {
             azClusterHosts = System.getProperty("cluster-endpoints")
@@ -148,9 +225,20 @@ tasks.register('startStandalone') {
             new ByteArrayOutputStream().withStream { os ->
                 exec {
                     workingDir "${project.rootDir}/../utils"
-                    def args = ['python3', 'cluster_manager.py', 'start', '-r', '0']
-                    if (System.getProperty("tls") == 'true') args.add(2, '--tls')
-                    commandLine args
+
+                    // Check if we should use remote cluster manager
+                    def remoteHost = System.getenv("VALKEY_REMOTE_HOST")
+                    if (remoteHost != null && !remoteHost.isEmpty()) {
+                        def args = [*pythonCmd, 'remote_cluster_manager.py', '--host', remoteHost]
+                        if (System.getProperty("engine-version")) args.addAll(['--engine-version', System.getProperty("engine-version")])
+                        args.addAll(['start', '-r', '0'])
+                        if (System.getProperty("tls") == 'true') args.add('--tls')
+                        commandLine args
+                    } else {
+                        def args = [*pythonCmd, 'cluster_manager.py', '--host', clusterHost, 'start', '-r', '0']
+                        if (System.getProperty("tls") == 'true') args.add('--tls')
+                        commandLine args
+                    }
                     standardOutput = os
                 }
                 standaloneHosts = extractAddressesFromClusterManagerOutput(os.toString())
@@ -163,37 +251,86 @@ tasks.register('startStandalone') {
 
 tasks.register('startStandaloneTls') {
     doLast {
-        new ByteArrayOutputStream().withStream { os ->
-            exec {
-                workingDir "${project.rootDir}/../utils"
-                commandLine 'python3', 'cluster_manager.py', '--tls', 'start', '-r', '0'
-                standardOutput = os
+        if (System.getProperty("standalone-tls-endpoints") == null) {
+            new ByteArrayOutputStream().withStream { os ->
+                exec {
+                    workingDir "${project.rootDir}/../utils"
+                    
+                    // Check if we should use remote cluster manager
+                    def remoteHost = System.getenv("VALKEY_REMOTE_HOST")
+                    if (remoteHost != null && !remoteHost.isEmpty()) {
+                        def args = [*pythonCmd, 'remote_cluster_manager.py', '--host', remoteHost]
+                        if (System.getProperty("engine-version")) args.addAll(['--engine-version', System.getProperty("engine-version")])
+                        args.addAll(['start', '--tls', '-r', '0'])
+                        commandLine args
+                    } else {
+                        commandLine 'python3', 'cluster_manager.py', 'start', '--tls', '-r', '0'
+                    }
+                    standardOutput = os
+                }
+                standaloneTlsHosts = extractAddressesFromClusterManagerOutput(os.toString())
             }
-            standaloneTlsHosts = extractAddressesFromClusterManagerOutput(os.toString())
+        } else {
+            standaloneTlsHosts = System.getProperty("standalone-tls-endpoints")
         }
     }
 }
 
 tasks.register('startClusterTls') {
     doLast {
-        new ByteArrayOutputStream().withStream { os ->
-            exec {
-                workingDir "${project.rootDir}/../utils"
-                commandLine 'python3', 'cluster_manager.py', '--tls', 'start', '--cluster-mode'
-                standardOutput = os
+        if (System.getProperty("cluster-endpoints") == null) {
+            // Check if we should use remote cluster manager
+            def remoteHost = System.getenv("VALKEY_REMOTE_HOST")
+            if (remoteHost != null && !remoteHost.isEmpty()) {
+                // Use remote cluster manager
+                println "Using remote cluster manager for TLS cluster with host: ${remoteHost}"
+                new ByteArrayOutputStream().withStream { os ->
+                    exec {
+                        workingDir "${project.rootDir}/../utils"
+                        def args = [*pythonCmd, 'remote_cluster_manager.py', '--host', remoteHost]
+                        if (System.getProperty("engine-version")) args.addAll(['--engine-version', System.getProperty("engine-version")])
+                        args.addAll(['start', '--cluster-mode', '--tls', '-n', '6', '-r', '0'])
+                        commandLine args
+                        standardOutput = os
+                    }
+                    // Parse remote cluster endpoints
+                    clusterTlsHosts = extractAddressesFromClusterManagerOutput(os.toString())
+                    println "=== GRADLE CLUSTER TLS SETUP ==="
+                    println "Extracted cluster TLS hosts: ${clusterTlsHosts}"
+                    println "================================="
+                }
+            } else {
+                // Use local cluster manager
+                new ByteArrayOutputStream().withStream { os ->
+                    exec {
+                        workingDir "${project.rootDir}/../utils"
+                        commandLine(*pythonCmd, 'cluster_manager.py', 'start', '--cluster-mode', '--tls', '-n', '6', '-r', '0')
+                        standardOutput = os
+                    }
+                    clusterTlsHosts = extractAddressesFromClusterManagerOutput(os.toString())
+                    println "=== GRADLE LOCAL CLUSTER TLS SETUP ==="
+                    println "Extracted cluster TLS hosts: ${clusterTlsHosts}"
+                    println "======================================="
+                }
             }
-            clusterTlsHosts = extractAddressesFromClusterManagerOutput(os.toString())
+        } else {
+            clusterTlsHosts = System.getProperty("cluster-endpoints")
         }
     }
 }
 
 beforeTests.dependsOn 'stopAllBeforeTests'
 stopAllBeforeTests.finalizedBy 'clearDirs'
-clearDirs.finalizedBy 'startStandalone'
-clearDirs.finalizedBy 'startStandaloneTls'
-clearDirs.finalizedBy 'startCluster'
-clearDirs.finalizedBy 'startClusterTls'
-clearDirs.finalizedBy 'startClusterForAz'
+startStandalone.dependsOn 'clearDirs'
+startStandaloneTls.dependsOn 'clearDirs'
+startCluster.dependsOn 'clearDirs'
+startClusterTls.dependsOn 'clearDirs'
+startClusterForAz.dependsOn 'clearDirs'
+beforeTests.dependsOn 'startStandalone'
+beforeTests.dependsOn 'startStandaloneTls'
+beforeTests.dependsOn 'startCluster'
+beforeTests.dependsOn 'startClusterTls'
+beforeTests.dependsOn 'startClusterForAz'
 afterTests.finalizedBy 'stopAllAfterTests'
 compileTestJava.dependsOn ':client:publishToMavenLocal', ':jedis-compatibility:publishToMavenLocal'
 
@@ -212,6 +349,15 @@ tasks.withType(Test) {
         systemProperty 'test.server.cluster.tls', clusterTlsHosts
         systemProperty 'test.server.azcluster', azClusterHosts
         systemProperty 'test.server.tls', System.getProperty("tls")
+        
+        // Filter tests to focus on specific failing cluster TLS tests only
+        if (System.getProperty("focusTests") == "true") {
+            filter {
+                includeTestsMatching "*ClusterTlsCertificateTest.testClusterTlsWithSelfSignedCertificateSucceeds*"
+                includeTestsMatching "*ClusterTlsCertificateTest.testClusterTlsWithMultipleCertificatesSucceeds*"
+                includeTestsMatching "*ClusterTlsCertificateTest.testClusterTlsWithKeyStoreSucceeds*"
+            }
+        }
     }
 
     testLogging {
@@ -222,10 +368,10 @@ tasks.withType(Test) {
 
     minHeapSize = "2048m" // Initial heap size. Needed for max size tests.
     maxHeapSize = "2048m" // Maximum heap size. Needed for max size tests.
-    
+
     // Native library path for GLIDE FFI - needed for Jedis compatibility tests
     jvmArgs "-Djava.library.path=${project.rootDir}/../target/release"
-    
+
     // Disable modularity for jedis compatibility tests
     if (name.contains('jedis') || filter.includePatterns.any { it.contains('jedis') }) {
         jvmArgs += "--add-opens=java.base/java.lang=ALL-UNNAMED"
@@ -266,6 +412,19 @@ test {
     filter {
         excludeTestsMatching 'glide.PubSubTests'
         excludeTestsMatching 'glide.modules.*'
+        
+        // When focusing on cluster TLS tests, exclude everything else
+        if (System.getProperty("focusTests") == "true") {
+            excludeTestsMatching 'glide.*CommandTests*'
+            excludeTestsMatching 'glide.*BatchTests*'
+            excludeTestsMatching 'compatibility.jedis.*'
+            excludeTestsMatching 'glide.*AsyncTests*'
+            excludeTestsMatching 'glide.*TransactionTests*'
+            excludeTestsMatching 'glide.*ConnectionTests*'
+            excludeTestsMatching 'glide.standalone.*'
+            excludeTestsMatching 'glide.cluster.ClusterConnectionTests*'
+            excludeTestsMatching 'glide.cluster.ClusterCommandTests*'
+        }
     }
 }
 
diff --git a/java/integTest/src/test/java/glide/OpenTelemetryConfigTests.java b/java/integTest/src/test/java/glide/OpenTelemetryConfigTests.java
index d72e5e3f2c..fcef358a8f 100644
--- a/java/integTest/src/test/java/glide/OpenTelemetryConfigTests.java
+++ b/java/integTest/src/test/java/glide/OpenTelemetryConfigTests.java
@@ -5,14 +5,26 @@
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import glide.api.OpenTelemetry;
+import java.nio.file.Files;
+import java.nio.file.Path;
 import lombok.SneakyThrows;
+import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.Timeout;
 
 @Timeout(30) // seconds
 public class OpenTelemetryConfigTests {
-    private static final String VALID_ENDPOINT_TRACES = "/tmp/spans.json";
-    private static final String VALID_FILE_ENDPOINT_TRACES = "file://" + VALID_ENDPOINT_TRACES;
+    private static String VALID_ENDPOINT_TRACES;
+    private static String VALID_FILE_ENDPOINT_TRACES;
+
+    @BeforeAll
+    @SneakyThrows
+    static void setup() {
+        // Use Java's system temporary directory API (cross-platform)
+        Path tempDir = Files.createTempDirectory("otel-test");
+        VALID_ENDPOINT_TRACES = tempDir.resolve("spans.json").toString();
+        VALID_FILE_ENDPOINT_TRACES = "file://" + VALID_ENDPOINT_TRACES;
+    }
 
     // Test wrong open telemetry configs
     @Test
diff --git a/java/integTest/src/test/java/glide/OpenTelemetryTests.java b/java/integTest/src/test/java/glide/OpenTelemetryTests.java
index eab3748aea..ae4ff95d2a 100644
--- a/java/integTest/src/test/java/glide/OpenTelemetryTests.java
+++ b/java/integTest/src/test/java/glide/OpenTelemetryTests.java
@@ -25,7 +25,8 @@
 @Timeout(30) // seconds
 public class OpenTelemetryTests {
 
-    private static final String VALID_ENDPOINT_TRACES = "/tmp/spans.json";
+    private static final String VALID_ENDPOINT_TRACES =
+            System.getProperty("java.io.tmpdir") + System.getProperty("file.separator") + "spans.json";
     private static final String VALID_FILE_ENDPOINT_TRACES = "file://" + VALID_ENDPOINT_TRACES;
     private static final String VALID_ENDPOINT_METRICS = "https://valid-endpoint/v1/metrics";
     private static GlideClusterClient client;
diff --git a/java/integTest/src/test/java/glide/cluster/ClusterBatchTests.java b/java/integTest/src/test/java/glide/cluster/ClusterBatchTests.java
index cc56be62fb..768a958850 100644
--- a/java/integTest/src/test/java/glide/cluster/ClusterBatchTests.java
+++ b/java/integTest/src/test/java/glide/cluster/ClusterBatchTests.java
@@ -174,6 +174,7 @@ public void keyless_batches_with_group_of_commands(
     @SneakyThrows
     @ParameterizedTest
     @MethodSource("getClientsWithAtomic")
+    @Timeout(15)
     public void test_batch_large_values(GlideClusterClient clusterClient, boolean isAtomic) {
         // Skip on macOS - the macOS tests run on self hosted VMs which have resource limits
         // making this test flaky with "no buffer space available" errors. See -
diff --git a/java/integTest/src/test/java/glide/cluster/ClusterTlsCertificateTest.java b/java/integTest/src/test/java/glide/cluster/ClusterTlsCertificateTest.java
index e90b70b15a..85ed78d595 100644
--- a/java/integTest/src/test/java/glide/cluster/ClusterTlsCertificateTest.java
+++ b/java/integTest/src/test/java/glide/cluster/ClusterTlsCertificateTest.java
@@ -21,6 +21,7 @@
 import java.util.ArrayList;
 import java.util.List;
 import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 
 public class ClusterTlsCertificateTest {
@@ -31,7 +32,10 @@ public class ClusterTlsCertificateTest {
     @BeforeAll
     static void setup() throws Exception {
         String clusterHosts = System.getProperty("test.server.cluster.tls", "");
+        System.out.println("=== CLUSTER TLS TEST SETUP ===");
+        System.out.println("Raw cluster hosts property: " + clusterHosts);
         String[] hosts = clusterHosts.split(",");
+        System.out.println("Split into " + hosts.length + " hosts:");
 
         clusterNodes = new ArrayList<>();
         for (String host : hosts) {
@@ -39,7 +43,10 @@ static void setup() throws Exception {
             NodeAddress node =
                     NodeAddress.builder().host(parts[0]).port(Integer.parseInt(parts[1])).build();
             clusterNodes.add(node);
+            System.out.println("  - " + parts[0] + ":" + parts[1]);
         }
+        System.out.println("Total cluster nodes configured: " + clusterNodes.size());
+        System.out.println("===============================");
 
         caCert = getCaCertificate();
     }
@@ -65,6 +72,7 @@ void testClusterTlsWithSelfSignedCertificateSucceeds() throws Exception {
     }
 
     @Test
+    @Disabled("Temporarily disabled to isolate single test")
     void testClusterTlsWithMultipleCertificatesSucceeds() throws Exception {
         String caCertStr = new String(caCert, StandardCharsets.UTF_8);
         String multipleCerts = caCertStr + "\n" + caCertStr;
@@ -103,6 +111,7 @@ void testClusterTlsWithInvalidCertificateFails() throws Exception {
     }
 
     @Test
+    @Disabled("Temporarily disabled to isolate single test")
     void testClusterTlsWithKeyStoreSucceeds() throws Exception {
         Path keyStorePath = Files.createTempFile("test-keystore", ".jks");
         char[] password = "password".toCharArray();
diff --git a/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java b/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java
index e0e3d7534c..2457534a78 100644
--- a/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java
+++ b/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java
@@ -8,6 +8,7 @@
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import java.util.concurrent.TimeUnit;
 
@@ -20,9 +21,66 @@ public class ValkeyCluster implements AutoCloseable {
                     .resolve("utils")
                     .resolve("cluster_manager.py");
 
+    private static final Path REMOTE_MANAGER_SCRIPT =
+            Paths.get(System.getProperty("user.dir"))
+                    .getParent()
+                    .getParent()
+                    .resolve("utils")
+                    .resolve("remote_cluster_manager.py");
+
+    /** Get platform-specific Python command with WSL support */
+    private static List<String> getPythonCommand() {
+        String osName = System.getProperty("os.name").toLowerCase();
+        if (osName.contains("windows")) {
+            // Check if we should use remote cluster manager
+            String remoteHost = System.getenv("VALKEY_REMOTE_HOST");
+
+            if (remoteHost != null) {
+                // Use native Windows Python for remote manager
+                return Arrays.asList("python3");
+            } else {
+                // Use WSL for local cluster manager
+                return Arrays.asList("wsl", "--", "python3");
+            }
+        } else {
+            return Arrays.asList("python3");
+        }
+    }
+
+    /** Get the appropriate cluster manager script and arguments */
+    private static ClusterManagerInfo getClusterManagerInfo() {
+        String remoteHost = System.getenv("VALKEY_REMOTE_HOST");
+
+        if (remoteHost != null && !remoteHost.isEmpty()) {
+            // Use remote cluster manager
+            return new ClusterManagerInfo(REMOTE_MANAGER_SCRIPT, ClusterManagerType.REMOTE, remoteHost);
+        } else {
+            // Use local cluster manager
+            return new ClusterManagerInfo(SCRIPT_FILE, ClusterManagerType.LOCAL, null);
+        }
+    }
+
+    private enum ClusterManagerType {
+        LOCAL,
+        REMOTE
+    }
+
+    private static class ClusterManagerInfo {
+        final Path scriptPath;
+        final ClusterManagerType type;
+        final String host;
+
+        ClusterManagerInfo(Path scriptPath, ClusterManagerType type, String host) {
+            this.scriptPath = scriptPath;
+            this.type = type;
+            this.host = host;
+        }
+    }
+
     private boolean tls = false;
     private String clusterFolder;
     private List<NodeAddress> nodesAddr;
+    private ClusterManagerInfo managerInfo;
 
     /**
      * Creates a new ValkeyCluster instance
@@ -43,28 +101,77 @@ public ValkeyCluster(
             List<List<String>> addresses)
             throws IOException, InterruptedException {
 
+        this.managerInfo = getClusterManagerInfo();
+
         if (addresses != null && !addresses.isEmpty()) {
             initFromExistingCluster(addresses);
         } else {
             this.tls = tls;
             List<String> command = new ArrayList<>();
-            command.add("python3");
-            command.add(SCRIPT_FILE.toString());
+            command.addAll(getPythonCommand());
+            command.add(managerInfo.scriptPath.toString());
+
+            // Add manager-specific arguments
+            if (managerInfo.type == ClusterManagerType.REMOTE) {
+                command.add("--host");
+                command.add(managerInfo.host);
+
+                // Add engine version if specified
+                String engineVersion = System.getProperty("engine-version");
+                if (engineVersion != null && !engineVersion.isEmpty()) {
+                    command.add("--engine-version");
+                    command.add(engineVersion);
+                }
 
-            if (tls) {
-                command.add("--tls");
-            }
+                command.add("start");
+
+                if (clusterMode) {
+                    command.add("--cluster-mode");
+                }
+            } else {
+                // Local cluster manager
+                command.add("start"); // Action must come first
 
-            command.add("start");
+                if (clusterMode) {
+                    command.add("--cluster-mode");
+                }
 
-            if (clusterMode) {
-                command.add("--cluster-mode");
+                // Add host parameter - use environment variable or default to localhost
+                String host = System.getenv("VALKEY_INTEG_TEST_IP");
+                if (host == null || host.isEmpty()) {
+                    host = "127.0.0.1";
+                }
+                command.add("--host");
+                command.add(host);
             }
 
-            if (loadModule != null && !loadModule.isEmpty()) {
-                for (String module : loadModule) {
-                    command.add("--load-module");
-                    command.add(module);
+            if (tls) {
+                // Add TLS certificate files if specified, otherwise use --tls flag
+                String tlsCertFile = System.getProperty("tls-cert-file");
+                String tlsKeyFile = System.getProperty("tls-key-file");
+                String tlsCaFile = System.getProperty("tls-ca-cert-file");
+
+                boolean hasCustomCerts =
+                        (tlsCertFile != null && !tlsCertFile.isEmpty())
+                                || (tlsKeyFile != null && !tlsKeyFile.isEmpty())
+                                || (tlsCaFile != null && !tlsCaFile.isEmpty());
+
+                if (hasCustomCerts) {
+                    if (tlsCertFile != null && !tlsCertFile.isEmpty()) {
+                        command.add("--tls-cert-file");
+                        command.add(tlsCertFile);
+                    }
+                    if (tlsKeyFile != null && !tlsKeyFile.isEmpty()) {
+                        command.add("--tls-key-file");
+                        command.add(tlsKeyFile);
+                    }
+                    if (tlsCaFile != null && !tlsCaFile.isEmpty()) {
+                        command.add("--tls-ca-cert-file");
+                        command.add(tlsCaFile);
+                    }
+                } else {
+                    // No custom certificates - use --tls flag for defaults
+                    command.add("--tls");
                 }
             }
 
@@ -73,6 +180,13 @@ public ValkeyCluster(
             command.add("-r");
             command.add(String.valueOf(replicaCount));
 
+            if (loadModule != null && !loadModule.isEmpty()) {
+                for (String module : loadModule) {
+                    command.add("--load-module");
+                    command.add(module);
+                }
+            }
+
             ProcessBuilder pb = new ProcessBuilder(command);
             pb.redirectErrorStream(true);
             Process process = pb.start();
@@ -86,7 +200,7 @@ public ValkeyCluster(
                 }
             }
 
-            if (!process.waitFor(80, TimeUnit.SECONDS)) {
+            if (!process.waitFor(120, TimeUnit.SECONDS)) { // Increased timeout for remote operations
                 process.destroy();
                 throw new RuntimeException("Timeout waiting for cluster creation");
             }
@@ -95,7 +209,11 @@ public ValkeyCluster(
                 throw new RuntimeException("Failed to create cluster: " + output);
             }
 
-            parseClusterScriptStartOutput(output.toString());
+            if (managerInfo.type == ClusterManagerType.REMOTE) {
+                parseRemoteClusterOutput(output.toString());
+            } else {
+                parseClusterScriptStartOutput(output.toString());
+            }
         }
     }
 
@@ -104,6 +222,44 @@ public ValkeyCluster(boolean tls) throws IOException, InterruptedException {
         this(tls, false, 3, 1, null, null);
     }
 
+    private void parseRemoteClusterOutput(String output) {
+        // Parse CLUSTER_ENDPOINTS=host1:port1,host2:port2,... format
+        for (String line : output.split("\n")) {
+            if (line.contains("CLUSTER_ENDPOINTS=")) {
+                this.nodesAddr = new ArrayList<>();
+                String[] parts = line.split("CLUSTER_ENDPOINTS=");
+                if (parts.length != 2) {
+                    throw new IllegalArgumentException("Invalid CLUSTER_ENDPOINTS format");
+                }
+
+                String[] endpoints = parts[1].split(",");
+                if (endpoints.length == 0) {
+                    throw new IllegalArgumentException("No cluster endpoints found");
+                }
+
+                for (String endpoint : endpoints) {
+                    String[] hostPort = endpoint.trim().split(":");
+                    if (hostPort.length != 2) {
+                        throw new IllegalArgumentException("Invalid endpoint format: " + endpoint);
+                    }
+
+                    try {
+                        int port = Integer.parseInt(hostPort[1]);
+                        this.nodesAddr.add(NodeAddress.builder().host(hostPort[0]).port(port).build());
+                    } catch (NumberFormatException e) {
+                        throw new IllegalArgumentException("Invalid port number in endpoint: " + endpoint);
+                    }
+                }
+
+                // Set a dummy cluster folder for remote clusters
+                this.clusterFolder = "remote-cluster";
+                return;
+            }
+        }
+
+        throw new IllegalArgumentException("No CLUSTER_ENDPOINTS found in output: " + output);
+    }
+
     private void parseClusterScriptStartOutput(String output) {
         if (!output.contains("CLUSTER_FOLDER") || !output.contains("CLUSTER_NODES")) {
             throw new IllegalArgumentException("Invalid cluster script output");
@@ -130,59 +286,85 @@ private void parseClusterScriptStartOutput(String output) {
                     throw new IllegalArgumentException("No cluster nodes found");
                 }
 
-                for (String addr : addresses) {
-                    String[] hostPort = addr.split(":");
+                for (String address : addresses) {
+                    String[] hostPort = address.split(":");
                     if (hostPort.length != 2) {
-                        throw new IllegalArgumentException("Invalid node address format: " + addr);
+                        throw new IllegalArgumentException("Invalid address format");
+                    }
+
+                    try {
+                        int port = Integer.parseInt(hostPort[1]);
+                        this.nodesAddr.add(NodeAddress.builder().host(hostPort[0]).port(port).build());
+                    } catch (NumberFormatException e) {
+                        throw new IllegalArgumentException("Invalid port number");
                     }
-                    this.nodesAddr.add(
-                            NodeAddress.builder().host(hostPort[0]).port(Integer.parseInt(hostPort[1])).build());
                 }
             }
         }
     }
 
+    public List<NodeAddress> getNodesAddr() {
+        return nodesAddr;
+    }
+
     private void initFromExistingCluster(List<List<String>> addresses) {
-        this.tls = false;
-        this.clusterFolder = "";
         this.nodesAddr = new ArrayList<>();
-
         for (List<String> address : addresses) {
-            if (address.size() != 2) {
-                throw new IllegalArgumentException("Each address must contain host and port");
+            if (address.size() >= 2) {
+                try {
+                    String host = address.get(0);
+                    int port = Integer.parseInt(address.get(1));
+                    this.nodesAddr.add(NodeAddress.builder().host(host).port(port).build());
+                } catch (NumberFormatException e) {
+                    throw new IllegalArgumentException("Invalid port number in address: " + address);
+                }
             }
-            this.nodesAddr.add(
-                    NodeAddress.builder()
-                            .host(address.get(0))
-                            .port(Integer.parseInt(address.get(1)))
-                            .build());
         }
     }
 
-    /** Gets the list of node addresses in the cluster */
-    public List<NodeAddress> getNodesAddr() {
-        return nodesAddr;
-    }
-
-    /** Gets the cluster folder path */
-    public String getClusterFolder() {
-        return clusterFolder;
-    }
-
     @Override
-    public void close() throws IOException {
+    public void close() throws IOException, InterruptedException {
         if (clusterFolder != null && !clusterFolder.isEmpty()) {
             List<String> command = new ArrayList<>();
-            command.add("python3");
-            command.add(SCRIPT_FILE.toString());
+            command.addAll(getPythonCommand());
+
+            // Use appropriate script based on manager type
+            if (managerInfo.type == ClusterManagerType.REMOTE) {
+                command.add(managerInfo.scriptPath.toString());
+                command.add("--host");
+                command.add(managerInfo.host);
+                command.add("stop");
+
+                // Add engine version if specified
+                String engineVersion = System.getProperty("engine-version", "valkey-8.0");
+                command.add("--engine");
+                command.add(engineVersion);
+            } else if (managerInfo.type == ClusterManagerType.REMOTE) {
+                command.add(managerInfo.scriptPath.toString());
+                command.add("--host");
+                command.add(managerInfo.host);
+                command.add("stop");
+            } else {
+                // Local cluster manager
+                command.add(managerInfo.scriptPath.toString());
+
+                if (tls) {
+                    command.add("--tls");
+                }
 
-            if (tls) {
-                command.add("--tls");
-            }
+                command.add("stop");
 
-            command.add("stop");
-            command.add("--cluster-folder");
-            command.add(clusterFolder);
+                // Add host parameter - use environment variable or default to localhost
+                String host = System.getenv("VALKEY_INTEG_TEST_IP");
+                if (host == null || host.isEmpty()) {
+                    host = "127.0.0.1";
+                }
+                command.add("--host");
+                command.add(host);
+
+                command.add("--cluster-folder");
+                command.add(clusterFolder);
+            }
 
             ProcessBuilder pb = new ProcessBuilder(command);
             pb.redirectErrorStream(true);
@@ -198,7 +380,8 @@ public void close() throws IOException {
             }
 
             try {
-                if (!process.waitFor(20, TimeUnit.SECONDS)) {
+                int timeoutSeconds = managerInfo.type == ClusterManagerType.REMOTE ? 30 : 20;
+                if (!process.waitFor(timeoutSeconds, TimeUnit.SECONDS)) {
                     process.destroy();
                     throw new IOException("Timeout waiting for cluster shutdown");
                 }
diff --git a/java/jedis-compatibility/build.gradle b/java/jedis-compatibility/build.gradle
index ca521670a1..a04f6ec540 100644
--- a/java/jedis-compatibility/build.gradle
+++ b/java/jedis-compatibility/build.gradle
@@ -10,6 +10,16 @@ repositories {
     mavenCentral()
 }
 
+tasks.withType(JavaCompile) {
+    options.encoding = 'UTF-8'
+}
+
+tasks.withType(Javadoc) {
+    options.encoding = 'UTF-8'
+    options.charSet = 'UTF-8'
+    options.docEncoding = 'UTF-8'
+}
+
 ext {
     // osdetector returns 'aarch_64', but rust triplet has 'aarch64'
     arch = osdetector.arch == 'aarch_64' ? 'aarch64' : osdetector.arch;
diff --git a/python/glide-sync/glide_sync/logger.py b/python/glide-sync/glide_sync/logger.py
index 624d207f68..999b0e015f 100644
--- a/python/glide-sync/glide_sync/logger.py
+++ b/python/glide-sync/glide_sync/logger.py
@@ -35,7 +35,7 @@ class Logger:
     If none of these functions are called, the first log attempt will initialize a new logger with default configuration.
     """
 
-    _instance: Logger | None = None
+    _instance: Optional[Logger] = None
     _glide_ffi = _GlideFFI()
     _ffi = _glide_ffi.ffi
     _lib = _glide_ffi.lib
diff --git a/python/tests/async_tests/test_async_client.py b/python/tests/async_tests/test_async_client.py
index 716c85a4ff..6ea9e63fff 100644
--- a/python/tests/async_tests/test_async_client.py
+++ b/python/tests/async_tests/test_async_client.py
@@ -2602,7 +2602,7 @@ async def test_persist(self, glide_client: TGlideClient):
     @pytest.mark.parametrize("protocol", [ProtocolVersion.RESP2, ProtocolVersion.RESP3])
     async def test_geoadd(self, glide_client: TGlideClient):
         key, key2 = get_random_string(10), get_random_string(10)
-        members_coordinates: Dict[str | bytes, GeospatialData] = {
+        members_coordinates: Dict[Union[str, bytes], GeospatialData] = {
             "Palermo": GeospatialData(13.361389, 38.115556),
             "Catania": GeospatialData(15.087269, 37.502669),
         }
diff --git a/python/tests/sync_tests/test_sync_client.py b/python/tests/sync_tests/test_sync_client.py
index ebbf2d7e1e..dcd38fe9d9 100644
--- a/python/tests/sync_tests/test_sync_client.py
+++ b/python/tests/sync_tests/test_sync_client.py
@@ -2570,7 +2570,7 @@ def test_sync_persist(self, glide_sync_client: TGlideClient):
     @pytest.mark.parametrize("protocol", [ProtocolVersion.RESP2, ProtocolVersion.RESP3])
     def test_sync_geoadd(self, glide_sync_client: TGlideClient):
         key, key2 = get_random_string(10), get_random_string(10)
-        members_coordinates: Dict[str | bytes, GeospatialData] = {
+        members_coordinates: Dict[Union[str, bytes], GeospatialData] = {
             "Palermo": GeospatialData(13.361389, 38.115556),
             "Catania": GeospatialData(15.087269, 37.502669),
         }
diff --git a/utils/cluster_manager.py b/utils/cluster_manager.py
index b09e90f8d2..90026780a3 100755
--- a/utils/cluster_manager.py
+++ b/utils/cluster_manager.py
@@ -61,7 +61,24 @@ def get_server_command() -> str:
     """Get server command, checking valkey-server first, then redis-server"""
     global _SERVER_COMMAND
     if _SERVER_COMMAND is None:
-        _SERVER_COMMAND = get_command(["valkey-server", "redis-server"])
+        # Check if ENGINE_PATH is set (for multi-engine setup)
+        engine_path = os.environ.get("ENGINE_PATH")
+        if engine_path:
+            # Try engine-specific binaries first
+            engine_valkey = f"{engine_path}/src/valkey-server"
+            engine_redis = f"{engine_path}/src/redis-server"
+
+            if os.path.exists(engine_valkey) and os.access(engine_valkey, os.X_OK):
+                _SERVER_COMMAND = engine_valkey
+            elif os.path.exists(engine_redis) and os.access(engine_redis, os.X_OK):
+                _SERVER_COMMAND = engine_redis
+            else:
+                raise Exception(
+                    f"No executable server binary found in {engine_path}/src/"
+                )
+        else:
+            # Fall back to PATH-based lookup
+            _SERVER_COMMAND = get_command(["valkey-server", "redis-server"])
     return _SERVER_COMMAND
 
 
@@ -69,7 +86,26 @@ def get_cli_command() -> str:
     """Get CLI command, checking valkey-cli first, then redis-cli"""
     global _CLI_COMMAND
     if _CLI_COMMAND is None:
-        _CLI_COMMAND = get_command(["valkey-cli", "redis-cli"])
+        # Check if ENGINE_PATH is set (for multi-engine setup)
+        engine_path = os.environ.get("ENGINE_PATH")
+        if engine_path:
+            # Try engine-specific binaries first
+            engine_valkey_cli = f"{engine_path}/src/valkey-cli"
+            engine_redis_cli = f"{engine_path}/src/redis-cli"
+
+            if os.path.exists(engine_valkey_cli) and os.access(
+                engine_valkey_cli, os.X_OK
+            ):
+                _CLI_COMMAND = engine_valkey_cli
+            elif os.path.exists(engine_redis_cli) and os.access(
+                engine_redis_cli, os.X_OK
+            ):
+                _CLI_COMMAND = engine_redis_cli
+            else:
+                raise Exception(f"No executable CLI binary found in {engine_path}/src/")
+        else:
+            # Fall back to PATH-based lookup
+            _CLI_COMMAND = get_command(["valkey-cli", "redis-cli"])
     return _CLI_COMMAND
 
 
@@ -87,7 +123,7 @@ def check_if_tls_cert_exist(tls_file: str, timeout: int = 15):
             return True
         else:
             time.sleep(0.005)
-    logging.warn(f"Timed out waiting for certificate file {tls_file}")
+    logging.warning(f"Timed out waiting for certificate file {tls_file}")
     return False
 
 
@@ -99,29 +135,42 @@ def check_if_tls_cert_is_valid(tls_file: str):
     return time_since_created.days < 3650
 
 
-def should_generate_new_tls_certs() -> bool:
-    # Returns False if we already have existing and valid TLS files, otherwise True
+def should_generate_new_tls_certs(host="127.0.0.1") -> bool:
+    # Returns False if we already have existing and valid TLS files for the correct host, otherwise True
     try:
         Path(TLS_FOLDER).mkdir(exist_ok=False)
     except FileExistsError:
         files_list = [CA_CRT, SERVER_KEY, SERVER_CRT]
         for file in files_list:
-            if check_if_tls_cert_exist(file) and check_if_tls_cert_is_valid(file):
-                return False
+            if not (check_if_tls_cert_exist(file) and check_if_tls_cert_is_valid(file)):
+                return True
+        
+        # Check if existing certificate is valid for the current host
+        if host != "127.0.0.1" and host != "localhost":
+            # If we're using a remote host, always regenerate to include the correct IP
+            logging.info(f"Regenerating TLS certificates for remote host: {host}")
+            return True
+        
+        return False
     return True
 
 
-def generate_tls_certs():
+def generate_tls_certs(host="127.0.0.1"):
     # Based on shell script in valkey's server tests
     # https://github.com/valkey-io/valkey/blob/0d2ba9b94d28d4022ea475a2b83157830982c941/utils/gen-test-certs.sh
-    logging.debug("## Generating TLS certificates")
+    logging.info(f"## Generating TLS certificates for host: {host}")
     tic = time.perf_counter()
     ca_key = f"{TLS_FOLDER}/ca.key"
     ca_serial = f"{TLS_FOLDER}/ca.txt"
     ext_file = f"{TLS_FOLDER}/openssl.cnf"
 
     f = open(ext_file, "w")
-    f.write("keyUsage = digitalSignature, keyEncipherment\nsubjectAltName = IP:127.0.0.1,DNS:localhost")
+    # Include both localhost and the actual host IP in certificate
+    subject_alt_name = f"IP:127.0.0.1,DNS:localhost,IP:{host}"
+    logging.info(f"Certificate subjectAltName: {subject_alt_name}")
+    f.write(
+        f"keyUsage = digitalSignature, keyEncipherment\nsubjectAltName = {subject_alt_name}"
+    )
     f.close()
 
     def make_key(name: str, size: int):
@@ -235,7 +284,9 @@ def make_key(name: str, size: int):
 
 
 def get_cli_option_args(
-    cluster_folder: str, use_tls: bool, auth: Optional[str] = None,
+    cluster_folder: str,
+    use_tls: bool,
+    auth: Optional[str] = None,
     tls_cert_file: Optional[str] = None,
     tls_key_file: Optional[str] = None,
     tls_ca_cert_file: Optional[str] = None,
@@ -304,8 +355,13 @@ def print_servers_json(servers: List[Server]):
 
 
 def next_free_port(
-    min_port: int = 6379, max_port: int = 55535, timeout: int = 60
+    min_port: Optional[int] = None, max_port: int = 55535, timeout: int = 60
 ) -> int:
+    # Use BASE_PORT from environment if set (for multi-engine setup)
+    if min_port is None:
+        base_port = os.environ.get("BASE_PORT")
+        min_port = int(base_port) if base_port else 6379
+
     tic = time.perf_counter()
     sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     timeout_start = time.time()
@@ -383,6 +439,9 @@ def get_server_version(server_name):
         get_server_command(),
         f"{'--tls-port' if tls else '--port'}",
         str(port),
+    ]
+    
+    cmd_args.extend([
         "--cluster-enabled",
         f"{'yes' if cluster_mode else 'no'}",
         "--dir",
@@ -397,7 +456,11 @@ def get_server_version(server_name):
         "no",
         "--save",
         "",
-    ]
+    ])
+
+    # Add bind directive if host is not localhost (for remote access)
+    if host not in ["127.0.0.1", "localhost"]:
+        cmd_args.extend(["--bind", host])
     if server_version >= (7, 0, 0):
         cmd_args.extend(["--enable-debug-command", "yes"])
     # Enable multi-database support in cluster mode for Valkey 9.0+
@@ -460,21 +523,22 @@ def create_servers(
         cert_file = tls_cert_file or SERVER_CRT
         key_file = tls_key_file or SERVER_KEY
         ca_file = tls_ca_cert_file or CA_CRT
-        
+
         # Only generate default certs if using default paths and they don't exist
-        if not tls_cert_file and should_generate_new_tls_certs():
-            generate_tls_certs()
-            
+        if not tls_cert_file and should_generate_new_tls_certs(host):
+            logging.info(f"Generating TLS certificates for host: {host}")
+            generate_tls_certs(host)
+
         tls_args = [
             "--tls-cluster",
-            "yes",
+            "yes",  # Required for proper port allocation
             "--tls-cert-file",
             cert_file,
             "--tls-key-file",
             key_file,
             "--tls-ca-cert-file",
             ca_file,
-            "--tls-auth-clients",  # Make it so client doesn't have to send cert
+            "--tls-auth-clients",
             "no",
             "--bind",
             host,
@@ -517,7 +581,15 @@ def create_servers(
                 )
             )
             continue
-        if not wait_for_server(server, cluster_folder, tls, 10, tls_cert_file, tls_key_file, tls_ca_cert_file):
+        if not wait_for_server(
+            server,
+            cluster_folder,
+            tls,
+            10,
+            tls_cert_file,
+            tls_key_file,
+            tls_ca_cert_file,
+        ):
             raise Exception(
                 f"Waiting for server {server.host}:{server.port} to start exceeded timeout.\n"
                 f"See {node_folder}/server.log for more information"
@@ -545,7 +617,14 @@ def create_cluster(
     p = subprocess.Popen(
         [
             get_cli_command(),
-            *get_cli_option_args(cluster_folder, use_tls, None, tls_cert_file, tls_key_file, tls_ca_cert_file),
+            *get_cli_option_args(
+                cluster_folder,
+                use_tls,
+                None,
+                tls_cert_file,
+                tls_key_file,
+                tls_ca_cert_file,
+            ),
             "--cluster",
             "create",
             *servers_tuple,
@@ -562,7 +641,9 @@ def create_cluster(
         raise Exception(f"Failed to create cluster: {err if err else output}")
 
     wait_for_a_message_in_logs(cluster_folder, "Cluster state changed: ok")
-    wait_for_all_topology_views(servers, cluster_folder, use_tls, tls_cert_file, tls_key_file, tls_ca_cert_file)
+    wait_for_all_topology_views(
+        servers, cluster_folder, use_tls, tls_cert_file, tls_key_file, tls_ca_cert_file
+    )
     print_servers_json(servers)
 
     logging.debug("The cluster was successfully created!")
@@ -710,7 +791,14 @@ def wait_for_all_topology_views(
             server.host,
             "-p",
             str(server.port),
-            *get_cli_option_args(cluster_folder, use_tls, None, tls_cert_file, tls_key_file, tls_ca_cert_file),
+            *get_cli_option_args(
+                cluster_folder,
+                use_tls,
+                None,
+                tls_cert_file,
+                tls_key_file,
+                tls_ca_cert_file,
+            ),
             "cluster",
             "slots",
         ]
@@ -718,24 +806,39 @@ def wait_for_all_topology_views(
         retries = 80
         while retries >= 0:
             output = redis_cli_run_command(cmd_args)
-            if output is not None and output.count(f"{server.host}") == len(servers):
-                # Server is ready, get the node's role
-                cmd_args = [
-                    get_cli_command(),
-                    "-h",
-                    server.host,
-                    "-p",
-                    str(server.port),
-                    *get_cli_option_args(cluster_folder, use_tls, None, tls_cert_file, tls_key_file, tls_ca_cert_file),
-                    "cluster",
-                    "nodes",
-                ]
-                cluster_slots_output = redis_cli_run_command(cmd_args)
-                node_info = parse_cluster_nodes(cluster_slots_output)
-                if node_info:
-                    server.set_primary(node_info["is_primary"])
-                logging.debug(f"Server {server} is ready!")
-                break
+            logging.debug(
+                f"Checking server {server.host}:{server.port}, output: {output}"
+            )
+            if output is not None:
+                host_count = output.count(f"{server.host}")
+                logging.debug(
+                    f"Found {host_count} occurrences of '{server.host}' in output, need {len(servers)}"
+                )
+                if host_count == len(servers):
+                    # Server is ready, get the node's role
+                    cmd_args = [
+                        get_cli_command(),
+                        "-h",
+                        server.host,
+                        "-p",
+                        str(server.port),
+                        *get_cli_option_args(
+                            cluster_folder,
+                            use_tls,
+                            None,
+                            tls_cert_file,
+                            tls_key_file,
+                            tls_ca_cert_file,
+                        ),
+                        "cluster",
+                        "nodes",
+                    ]
+                    cluster_slots_output = redis_cli_run_command(cmd_args)
+                    node_info = parse_cluster_nodes(cluster_slots_output)
+                    if node_info:
+                        server.set_primary(node_info["is_primary"])
+                    logging.debug(f"Server {server} is ready!")
+                    break
             else:
                 retries -= 1
                 time.sleep(1)
@@ -767,7 +870,14 @@ def wait_for_server(
                 server.host,
                 "-p",
                 str(server.port),
-                *get_cli_option_args(cluster_folder, use_tls, None, tls_cert_file, tls_key_file, tls_ca_cert_file),
+                *get_cli_option_args(
+                    cluster_folder,
+                    use_tls,
+                    None,
+                    tls_cert_file,
+                    tls_key_file,
+                    tls_ca_cert_file,
+                ),
                 "PING",
             ],
             stdout=subprocess.PIPE,
@@ -805,7 +915,9 @@ def wait_for_message(
             else:
                 time.sleep(0.1)
                 continue
-    logging.warn(f"Timeout exceeded trying to check if {log_file} contains {message}")
+    logging.warning(
+        f"Timeout exceeded trying to check if {log_file} contains {message}"
+    )
     return False
 
 
@@ -852,7 +964,7 @@ def is_address_already_in_use(
         if not os.path.exists(log_file):
             time.sleep(0.1)
             continue
-        
+
         with open(log_file, "r") as f:
             server_log = f.read()
             # Check for known error message variants because different C libraries
@@ -865,7 +977,7 @@ def is_address_already_in_use(
             else:
                 time.sleep(0.1)
                 continue
-    logging.warn(
+    logging.warning(
         f"Timeout exceeded trying to check if address already in use for server {server}!"
     )
     return False
@@ -1097,6 +1209,15 @@ def main():
 
     # Start parser
     parser_start = subparsers.add_parser("start", help="Start a new cluster")
+    parser_start.add_argument(
+        "-H",
+        "--host",
+        type=str,
+        help="Host address (default: %(default)s)",
+        required=False,
+        default="127.0.0.1",
+    )
+
     parser_start.add_argument(
         "--cluster-mode",
         action="store_true",
@@ -1156,21 +1277,28 @@ def main():
         help="The paths of the server modules to load.",
         required=False,
     )
-    
+
+    parser_start.add_argument(
+        "--tls",
+        action="store_true",
+        help="Enable TLS (default: %(default)s)",
+        required=False,
+    )
+
     parser_start.add_argument(
         "--tls-cert-file",
         type=str,
         help="Path to TLS certificate file (default: uses generated certificates)",
         required=False,
     )
-    
+
     parser_start.add_argument(
         "--tls-key-file",
         type=str,
         help="Path to TLS key file (default: uses generated certificates)",
         required=False,
     )
-    
+
     parser_start.add_argument(
         "--tls-ca-cert-file",
         type=str,
@@ -1180,6 +1308,15 @@ def main():
 
     # Stop parser
     parser_stop = subparsers.add_parser("stop", help="Shutdown a running cluster")
+    parser_stop.add_argument(
+        "-H",
+        "--host",
+        type=str,
+        help="Host address (default: %(default)s)",
+        required=False,
+        default="127.0.0.1",
+    )
+
     parser_stop.add_argument(
         "--folder-path",
         type=dir_path,
@@ -1218,6 +1355,16 @@ def main():
     )
 
     args = parser.parse_args()
+
+    # TLS mode is enabled by --tls flag OR presence of TLS certificate arguments
+    if not hasattr(args, "tls"):
+        args.tls = False
+    args.tls = args.tls or bool(
+        getattr(args, "tls_cert_file", None)
+        or getattr(args, "tls_key_file", None)
+        or getattr(args, "tls_ca_cert_file", None)
+    )
+
     # Check logging level
 
     level = LOG_LEVELS.get(args.log.lower())
@@ -1262,9 +1409,9 @@ def main():
             args.cluster_mode,
             args.load_module,
             False,
-            getattr(args, 'tls_cert_file', None),
-            getattr(args, 'tls_key_file', None),
-            getattr(args, 'tls_ca_cert_file', None),
+            getattr(args, "tls_cert_file", None),
+            getattr(args, "tls_key_file", None),
+            getattr(args, "tls_ca_cert_file", None),
         )
         if args.cluster_mode:
             # Create a cluster
@@ -1274,9 +1421,9 @@ def main():
                 args.replica_count,
                 cluster_folder,
                 args.tls,
-                getattr(args, 'tls_cert_file', None),
-                getattr(args, 'tls_key_file', None),
-                getattr(args, 'tls_ca_cert_file', None),
+                getattr(args, "tls_cert_file", None),
+                getattr(args, "tls_key_file", None),
+                getattr(args, "tls_ca_cert_file", None),
             )
         elif args.replica_count > 0:
             # Create a standalone replication group
diff --git a/utils/remote_cluster_manager.py b/utils/remote_cluster_manager.py
new file mode 100755
index 0000000000..30cb4e4316
--- /dev/null
+++ b/utils/remote_cluster_manager.py
@@ -0,0 +1,1183 @@
+#!/usr/bin/env python3
+"""
+Remote Cluster Manager - Executes cluster_manager.py on remote Linux instance via SSH
+"""
+
+import argparse
+import json
+import logging
+import os
+import subprocess
+import sys
+import tempfile
+from typing import List, Optional
+
+LOG_LEVELS = {
+    "critical": logging.CRITICAL,
+    "error": logging.ERROR,
+    "warn": logging.WARNING,
+    "warning": logging.WARNING,
+    "info": logging.INFO,
+    "debug": logging.DEBUG,
+}
+
+
+def init_logger(logfile: str):
+    print(f"LOG_FILE={logfile}")
+    root_logger = logging.getLogger()
+    handler = logging.FileHandler(logfile, "w", "utf-8")
+    root_logger.addHandler(handler)
+    root_logger.addHandler(logging.StreamHandler(sys.stdout))
+    root_logger.addHandler(logging.StreamHandler(sys.stderr))
+
+
+class RemoteClusterManager:
+    def __init__(
+        self,
+        host: str,
+        user: str = "ubuntu",
+        key_path: Optional[str] = None,
+        key_content: Optional[str] = None,
+        engine_version: str = "8.0",
+    ):
+        # Validate engine version
+        supported_versions = ["7.2", "8.0", "8.1", "9.0"]
+        if engine_version not in supported_versions:
+            raise ValueError(
+                f"Unsupported engine version: {engine_version}. Supported: {supported_versions}"
+            )
+
+        self.host = host
+        self.user = user
+        self.key_path: Optional[str] = key_path
+        self.key_content = key_content
+        self.temp_key_file = None
+        self.remote_repo_path = "/home/ubuntu/valkey-glide"
+        self.engine_version = engine_version
+        self.engines_base_path = "/opt/engines"
+        self.engine_path = f"{self.engines_base_path}/valkey-{engine_version}"
+
+        # Handle SSH key from environment or content
+        self._setup_ssh_key()
+        # After _setup_ssh_key, key_path is guaranteed to be set
+        assert self.key_path is not None
+
+    def _setup_ssh_key(self):
+        """Setup SSH key from various sources"""
+        if self.key_content:
+            # Create temporary key file from content (for GitHub secrets)
+            self.temp_key_file = tempfile.NamedTemporaryFile(
+                mode="w", delete=False, suffix=".pem"
+            )
+
+            logging.info(f"Writing Key file from content: {self.temp_key_file}")
+            self.temp_key_file.write(self.key_content)
+            self.temp_key_file.close()
+            os.chmod(self.temp_key_file.name, 0o600)
+            self.key_path = self.temp_key_file.name
+
+        elif not self.key_path:
+            # Try common key locations
+            possible_keys = [
+                os.environ.get("SSH_PRIVATE_KEY_PATH"),
+                os.path.expanduser("~/.ssh/valkey_runner_key"),
+                os.path.expanduser("~/.ssh/id_rsa"),
+                os.path.expanduser("~/.ssh/id_ed25519"),
+            ]
+
+            for key_file in possible_keys:
+                if key_file and os.path.exists(key_file):
+                    self.key_path = key_file
+                    break
+
+        if not self.key_path:
+            raise Exception(
+                "No SSH key found. Set SSH_PRIVATE_KEY_PATH or provide key content"
+            )
+
+    def __del__(self):
+        """Cleanup temporary key file"""
+        if self.temp_key_file and os.path.exists(self.temp_key_file.name):
+            os.unlink(self.temp_key_file.name)
+
+    def _build_ssh_command(self, remote_command: str) -> List[str]:
+        """Build SSH command with proper authentication"""
+        ssh_cmd = [
+            "ssh",
+            "-o",
+            "StrictHostKeyChecking=no",
+            "-o",
+            "UserKnownHostsFile=/dev/null",
+            "-o",
+            "LogLevel=ERROR",  # Reduce noise
+        ]
+
+        if self.key_path:
+            logging.info(f"Connecting using key: {self.key_path}")
+            ssh_cmd.extend(["-i", self.key_path])
+
+        ssh_cmd.extend([f"{self.user}@{self.host}", remote_command])
+        return ssh_cmd
+
+    def test_connection(self) -> bool:
+        """Test SSH connection to remote host"""
+        try:
+            returncode, stdout, stderr = self._execute_remote_command(
+                "echo 'SSH connection test'", timeout=10
+            )
+            return returncode == 0 and "SSH connection test" in stdout
+        except Exception as e:
+            logging.error(f"SSH connection test failed: {e}")
+            return False
+
+    def _execute_remote_command(
+        self, command: str, timeout: int = 300
+    ) -> tuple[int, str, str]:
+        """Execute command on remote host via SSH"""
+        ssh_cmd = self._build_ssh_command(command)
+
+        try:
+            result = subprocess.run(
+                ssh_cmd, capture_output=True, text=True, timeout=timeout
+            )
+            return result.returncode, result.stdout, result.stderr
+        except subprocess.TimeoutExpired:
+            return 1, "", f"Command timed out after {timeout} seconds"
+
+    def setup_remote_environment(self) -> bool:
+        """Ensure remote environment is ready"""
+        logging.info(f"Setting up remote environment on {self.host}...")
+
+        # Test connection first
+        if not self.test_connection():
+            logging.error("[FAIL] SSH connection failed")
+            return False
+
+        # Setup engines directory and install engine if needed
+        if not self._setup_engine():
+            return False
+
+        # Check if repo exists, clone if not
+        check_repo = f"test -d {self.remote_repo_path}"
+        returncode, _, _ = self._execute_remote_command(check_repo)
+
+        if returncode != 0:
+            logging.info("Cloning valkey-glide repository...")
+            clone_cmd = f"git clone https://github.com/valkey-io/valkey-glide.git {self.remote_repo_path}"
+            returncode, stdout, stderr = self._execute_remote_command(
+                clone_cmd, timeout=120
+            )
+            if returncode != 0:
+                logging.error(f"Failed to clone repository: {stderr}")
+                return False
+
+        # Update repository
+        logging.info("Updating repository...")
+        update_cmd = f"cd {self.remote_repo_path} && git pull origin main && git log -1 --oneline"
+        returncode, stdout, stderr = self._execute_remote_command(update_cmd)
+        if returncode != 0:
+            logging.warning(f"Warning: Failed to update repository: {stderr}")
+        else:
+            logging.info(f"Repository updated. Latest commit: {stdout.strip()}")
+
+        # Install dependencies
+        logging.info("Installing Python dependencies...")
+        install_cmd = f"cd {self.remote_repo_path}/utils && pip3 install -r requirements.txt || true"
+        self._execute_remote_command(install_cmd)
+
+        # Copy our local cluster_manager.py to ensure we have the latest version
+        logging.info("Copying local cluster_manager.py to remote...")
+        local_cluster_manager = os.path.join(
+            os.path.dirname(__file__), "cluster_manager.py"
+        )
+        remote_cluster_manager = (
+            f"{self.remote_repo_path}/utils/cluster_manager_local.py"
+        )
+        self._copy_file_to_remote(local_cluster_manager, remote_cluster_manager)
+
+        return True
+
+    def _setup_engine(self) -> bool:
+        """Setup engine directory and install Valkey if needed"""
+        logging.info(f"Setting up Valkey {self.engine_version}...")
+
+        # Create engines base directory
+        setup_cmd = f"""
+        sudo mkdir -p {self.engines_base_path}
+        sudo chown ubuntu:ubuntu {self.engines_base_path}
+        sudo apt-get update -qq
+        sudo apt-get install -y build-essential git pkg-config libssl-dev
+        """
+
+        returncode, stdout, stderr = self._execute_remote_command(
+            setup_cmd, timeout=300
+        )
+        if returncode != 0:
+            logging.error(f"Failed to setup base environment: {stderr}")
+            return False
+
+        # Check if engine is already installed
+        check_engine = f"test -f {self.engine_path}/src/valkey-server"
+        returncode, _, _ = self._execute_remote_command(check_engine)
+
+        if returncode == 0:
+            logging.info(f"Valkey {self.engine_version} already installed")
+            return True
+
+        # Install engine
+        logging.info(f"Installing Valkey {self.engine_version}...")
+        install_cmd = f"""
+        cd {self.engines_base_path}
+        if [ -d "valkey-{self.engine_version}" ]; then
+            rm -rf valkey-{self.engine_version}
+        fi
+        git clone https://github.com/valkey-io/valkey.git valkey-{self.engine_version}
+        cd valkey-{self.engine_version}
+        git checkout {self.engine_version}
+        make BUILD_TLS=yes -j$(nproc)
+        """
+
+        returncode, stdout, stderr = self._execute_remote_command(
+            install_cmd, timeout=600
+        )
+        if returncode != 0:
+            logging.error(f"Failed to install Valkey {self.engine_version}: {stderr}")
+            return False
+
+        logging.info(f"Successfully installed Valkey {self.engine_version}")
+        return True
+
+    def start_cluster(
+        self,
+        cluster_mode: bool = True,
+        shard_count: int = 3,
+        replica_count: int = 1,
+        tls: bool = False,
+        tls_cert_file: Optional[str] = None,
+        tls_key_file: Optional[str] = None,
+        tls_ca_cert_file: Optional[str] = None,
+        load_module: Optional[List[str]] = None,
+    ) -> Optional[List[str]]:
+        """Start cluster on remote host and return connection endpoints"""
+
+        if not self.setup_remote_environment():
+            return None
+
+        logging.info(
+            f"Starting cluster on {self.host} (shards={shard_count}, replicas={replica_count})..."
+        )
+
+        # Handle TLS certificate files
+        remote_tls_cert = None
+        remote_tls_key = None
+        remote_tls_ca = None
+
+        if tls:
+            if tls_cert_file or tls_key_file or tls_ca_cert_file:
+                # Custom TLS files provided - copy them to remote
+                if tls_cert_file:
+                    remote_tls_cert = f"{self.remote_repo_path}/tls_cert.pem"
+                    self._copy_file_to_remote(tls_cert_file, remote_tls_cert)
+                if tls_key_file:
+                    remote_tls_key = f"{self.remote_repo_path}/tls_key.pem"
+                    self._copy_file_to_remote(tls_key_file, remote_tls_key)
+                if tls_ca_cert_file:
+                    remote_tls_ca = f"{self.remote_repo_path}/tls_ca.pem"
+                    self._copy_file_to_remote(tls_ca_cert_file, remote_tls_ca)
+            # If no custom files, let remote cluster_manager.py generate defaults
+
+        # Get the internal IP of the remote host for binding
+        internal_ip = self._get_remote_internal_ip()
+        if not internal_ip:
+            logging.warning(
+                "Could not determine remote internal IP, using default bind"
+            )
+            bind_ip = None
+        else:
+            logging.info(f"Using internal IP for binding: {internal_ip}")
+            bind_ip = internal_ip
+
+        # Build cluster_manager.py command with engine-specific PATH
+        cmd_parts = [
+            f"cd {self.remote_repo_path}/utils",
+            "&&",
+            f"export PATH={self.engine_path}/src:$PATH",
+            "&&",
+            "python3 cluster_manager_local.py start",
+        ]
+
+        if bind_ip:
+            cmd_parts.extend(["--host", bind_ip])
+
+        if cluster_mode:
+            cmd_parts.append("--cluster-mode")
+        if tls:
+            if remote_tls_cert or remote_tls_key or remote_tls_ca:
+                # Custom TLS files provided - pass them explicitly
+                if remote_tls_cert:
+                    cmd_parts.extend(["--tls-cert-file", remote_tls_cert])
+                if remote_tls_key:
+                    cmd_parts.extend(["--tls-key-file", remote_tls_key])
+                if remote_tls_ca:
+                    cmd_parts.extend(["--tls-ca-cert-file", remote_tls_ca])
+            # If no custom files, don't pass TLS args - cluster_manager.py will use defaults
+            else:
+                # No custom files - use --tls flag to trigger TLS mode with defaults
+                cmd_parts.append("--tls")
+
+            # Set paths for copying generated certs back after cluster starts
+            if not (remote_tls_cert and remote_tls_key and remote_tls_ca):
+                remote_tls_cert = f"{self.remote_repo_path}/utils/tls_crts/server.crt"
+                remote_tls_key = f"{self.remote_repo_path}/utils/tls_crts/server.key"
+                remote_tls_ca = f"{self.remote_repo_path}/utils/tls_crts/ca.crt"
+
+        cmd_parts.extend(["-n", str(shard_count), "-r", str(replica_count)])
+        if load_module:
+            for module in load_module:
+                cmd_parts.extend(["--load-module", module])
+
+        remote_command = " ".join(cmd_parts)
+        logging.info(f"Executing remote cluster command: {remote_command}")
+
+        # Execute cluster start
+        returncode, stdout, stderr = self._execute_remote_command(
+            remote_command, timeout=180
+        )
+
+        if returncode != 0:
+            logging.error(f"Remote cluster start failed with return code: {returncode}")
+            logging.error(f"Command: {remote_command}")
+            logging.error(f"stdout: {stdout}")
+            logging.error(f"stderr: {stderr}")
+            return None
+
+        # Parse cluster endpoints from output
+        try:
+            # Look for CLUSTER_NODES= output from cluster_manager.py
+            endpoints = []
+            for line in stdout.strip().splitlines():
+                if line.startswith("CLUSTER_NODES="):
+                    nodes_str = line.split("=", 1)[1].strip()  # Strip the entire value
+                    # Parse the comma-separated host:port pairs
+                    for node in nodes_str.split(","):
+                        node = node.strip()
+                        if ":" in node:
+                            # Replace localhost/127.0.0.1 with remote host IP
+                            host, port = node.rsplit(":", 1)
+                            port = port.strip()  # Remove any trailing whitespace
+                            if host in ["127.0.0.1", "localhost"]:
+                                endpoints.append(f"{self.host}:{port}")
+                            else:
+                                endpoints.append(
+                                    f"{host}:{port}"
+                                )  # Ensure clean format
+                    break
+
+            if endpoints:
+                logging.info(f"Cluster started successfully. Endpoints: {endpoints}")
+                logging.info(f"Raw cluster output: {stdout}")
+                
+                # Verify cluster nodes are actually running
+                logging.info("Verifying cluster nodes are running...")
+                for endpoint in endpoints:
+                    host, port = endpoint.split(':')
+                    # Check if process is listening on the port
+                    check_cmd = f"ss -tlnp | grep ':{port}' || netstat -tlnp | grep ':{port}' || echo 'Port {port} not found'"
+                    check_returncode, check_stdout, check_stderr = self._execute_remote_command(check_cmd, timeout=10)
+                    if check_returncode == 0 and port in check_stdout:
+                        logging.info(f"OK - Node {endpoint} is listening")
+                    else:
+                        logging.warning(f"FAIL - Node {endpoint} may not be running: {check_stdout}")
+                
+                # Check cluster status and topology
+                if endpoints:
+                    first_endpoint = endpoints[0]
+                    host, port = first_endpoint.split(':')
+                    
+                    # Get cluster nodes info to see topology
+                    cluster_nodes_cmd = f"cd {self.remote_repo_path}/utils && export PATH={self.engine_path}/src:$PATH && echo 'CLUSTER NODES' | valkey-cli -h {host} -p {port} --tls --cert tls_crts/server.crt --key tls_crts/server.key --cacert tls_crts/ca.crt"
+                    nodes_returncode, nodes_stdout, nodes_stderr = self._execute_remote_command(cluster_nodes_cmd, timeout=15)
+                    if nodes_returncode == 0:
+                        logging.info(f"Cluster topology:")
+                        for line in nodes_stdout.strip().split('\n'):
+                            if line.strip():
+                                logging.info(f"  {line}")
+                    else:
+                        logging.warning(f"Could not get cluster nodes: {nodes_stderr}")
+                    
+                    # Get cluster info to see overall status
+                    cluster_info_cmd = f"cd {self.remote_repo_path}/utils && export PATH={self.engine_path}/src:$PATH && echo 'CLUSTER INFO' | valkey-cli -h {host} -p {port} --tls --cert tls_crts/server.crt --key tls_crts/server.key --cacert tls_crts/ca.crt"
+                    info_returncode, info_stdout, info_stderr = self._execute_remote_command(cluster_info_cmd, timeout=15)
+                    if info_returncode == 0:
+                        logging.info(f"Cluster status:")
+                        for line in info_stdout.strip().split('\n'):
+                            if 'cluster_state' in line or 'cluster_slots' in line or 'cluster_known_nodes' in line:
+                                logging.info(f"  {line}")
+                    else:
+                        logging.warning(f"Could not get cluster info: {info_stderr}")
+                        
+                    # Test connectivity to each endpoint
+                    logging.info("Testing connectivity to each cluster endpoint...")
+                    for endpoint in endpoints:  # Test ALL endpoints, not just first 3
+                        ep_host, ep_port = endpoint.split(':')
+                        ping_cmd = f"cd {self.remote_repo_path}/utils && export PATH={self.engine_path}/src:$PATH && echo 'PING' | valkey-cli -h {ep_host} -p {ep_port} --tls --cert tls_crts/server.crt --key tls_crts/server.key --cacert tls_crts/ca.crt"
+                        ping_returncode, ping_stdout, ping_stderr = self._execute_remote_command(ping_cmd, timeout=10)
+                        if ping_returncode == 0 and 'PONG' in ping_stdout:
+                            logging.info(f"OK - {endpoint} responds to PING")
+                        else:
+                            logging.warning(f"FAIL - {endpoint} failed PING: {ping_stderr}")
+
+                # Verify connectivity to endpoints
+                logging.info("Verifying connectivity to cluster endpoints...")
+                reachable_endpoints = []
+                for endpoint in endpoints:
+                    if self._test_endpoint_connectivity(endpoint):
+                        reachable_endpoints.append(endpoint)
+                        logging.info(f"[OK] {endpoint} is reachable")
+                    else:
+                        logging.warning(f"[FAIL] {endpoint} is not reachable")
+
+                if not reachable_endpoints:
+                    logging.error("No endpoints are reachable from local machine")
+                    return None
+                elif len(reachable_endpoints) < len(endpoints):
+                    logging.warning(
+                        f"Only {len(reachable_endpoints)}/{len(endpoints)} endpoints are reachable"
+                    )
+
+                # Copy TLS certificates back to local machine if using defaults
+                if tls and not (tls_cert_file or tls_key_file or tls_ca_cert_file):
+                    logging.info("Copying generated TLS certificates from remote...")
+                    
+                    # Copy and verify certificates
+                    local_cert_files = {
+                        "ca.crt": "ca_cert_local.pem",
+                        "server.crt": "server_cert_local.pem", 
+                        "server.key": "server_key_local.pem"
+                    }
+                    
+                    for remote_name, local_name in local_cert_files.items():
+                        remote_path = f"{self.remote_repo_path}/utils/tls_crts/{remote_name}"
+                        if self._copy_file_from_remote(remote_path, local_name):
+                            logging.info(f"Copied {remote_name} to {local_name}")
+                            
+                            # Print certificate content for debugging
+                            try:
+                                with open(local_name, 'rb') as f:
+                                    cert_content = f.read()
+                                    logging.info(f"Certificate {remote_name} length: {len(cert_content)} bytes")
+                                    logging.info(f"Certificate {remote_name} first 100 bytes: {cert_content[:100]}")
+                                    logging.info(f"Certificate {remote_name} last 100 bytes: {cert_content[-100:]}")
+                                    
+                                    # Check for line ending types
+                                    lf_count = cert_content.count(b'\n')
+                                    crlf_count = cert_content.count(b'\r\n')
+                                    cr_count = cert_content.count(b'\r') - crlf_count
+                                    
+                                    logging.info(f"Certificate {remote_name} line endings: LF={lf_count}, CRLF={crlf_count}, CR={cr_count}")
+                                    
+                                    # Print as hex for exact comparison with Rust output
+                                    hex_first = ' '.join(f'{b:02x}' for b in cert_content[:50])
+                                    logging.info(f"Certificate {remote_name} first 50 bytes hex: {hex_first}")
+                                    
+                                    # Check for PEM structure
+                                    if b'-----BEGIN' in cert_content and b'-----END' in cert_content:
+                                        logging.info(f"Certificate {remote_name} appears to be valid PEM format")
+                                        
+                                        # Check if base64 content has proper line breaks
+                                        lines = cert_content.decode('utf-8', errors='ignore').split('\n')
+                                        base64_lines = [line for line in lines if line and not line.startswith('-----')]
+                                        if base64_lines:
+                                            avg_line_length = sum(len(line) for line in base64_lines) / len(base64_lines)
+                                            logging.info(f"Certificate {remote_name} average base64 line length: {avg_line_length:.1f}")
+                                    else:
+                                        logging.warning(f"Certificate {remote_name} does NOT appear to be valid PEM format")
+                                        
+                            except Exception as e:
+                                logging.error(f"Failed to read copied certificate {local_name}: {e}")
+                        else:
+                            logging.error(f"Failed to copy {remote_name}")
+                            
+                    # Test certificate on Linux server side
+                    self.test_certificates_on_server(endpoints)
+
+                    # Create local tls_crts directory
+                    import os
+
+                    local_tls_dir = os.path.join(os.path.dirname(__file__), "tls_crts")
+                    os.makedirs(local_tls_dir, exist_ok=True)
+
+                    # Copy certificates
+                    if remote_tls_cert:
+                        local_cert_path = os.path.join(local_tls_dir, "server.crt")
+                        self._copy_file_from_remote(remote_tls_cert, local_cert_path)
+                        if os.path.exists(local_cert_path):
+                            logging.info(f"Successfully copied {remote_tls_cert} to {local_cert_path}")
+                        else:
+                            logging.error(f"Failed to copy {remote_tls_cert} to {local_cert_path}")
+                    
+                    if remote_tls_key:
+                        local_key_path = os.path.join(local_tls_dir, "server.key")
+                        self._copy_file_from_remote(remote_tls_key, local_key_path)
+                        if os.path.exists(local_key_path):
+                            logging.info(f"Successfully copied {remote_tls_key} to {local_key_path}")
+                        else:
+                            logging.error(f"Failed to copy {remote_tls_key} to {local_key_path}")
+                    
+                    if remote_tls_ca:
+                        local_ca_path = os.path.join(local_tls_dir, "ca.crt")
+                        self._copy_file_from_remote(remote_tls_ca, local_ca_path)
+                        if os.path.exists(local_ca_path):
+                            logging.info(f"Successfully copied {remote_tls_ca} to {local_ca_path}")
+                        else:
+                            logging.error(f"Failed to copy {remote_tls_ca} to {local_ca_path}")
+                            
+                    # Verify all required certificates exist
+                    required_certs = [
+                        os.path.join(local_tls_dir, "server.crt"),
+                        os.path.join(local_tls_dir, "server.key"), 
+                        os.path.join(local_tls_dir, "ca.crt")
+                    ]
+                    missing_certs = [cert for cert in required_certs if not os.path.exists(cert)]
+                    if missing_certs:
+                        logging.error(f"Missing TLS certificates: {missing_certs}")
+                    else:
+                        logging.info("All TLS certificates successfully copied and verified")
+
+                # Run TLS diagnostics if TLS is enabled
+                if tls:
+                    self.diagnose_tls_issue(endpoints)
+                    self.test_cluster_discovery_tls(endpoints)
+                    
+                    # Test glide-core cluster TLS to isolate Java vs Rust issue
+                    self.test_glide_core_cluster_tls(endpoints)
+                
+                return endpoints
+            else:
+                logging.error("Could not parse cluster endpoints from output")
+                logging.error(f"stdout: {stdout}")
+                return None
+
+        except json.JSONDecodeError as e:
+            logging.error(f"Failed to parse cluster output: {e}")
+            logging.error(f"stdout: {stdout}")
+            return None
+
+    def stop_cluster(self) -> bool:
+        """Stop cluster on remote host"""
+        logging.info(f"Stopping cluster on {self.host}...")
+
+        stop_cmd = f"cd {self.remote_repo_path}/utils && export PATH={self.engine_path}/src:$PATH && python3 cluster_manager.py stop --prefix cluster"
+        returncode, stdout, stderr = self._execute_remote_command(stop_cmd)
+
+        if returncode != 0:
+            logging.error(f"Failed to stop cluster: {stderr}")
+            return False
+
+        logging.info("Cluster stopped successfully")
+        return True
+
+    def get_cluster_status(self) -> Optional[dict]:
+        """Get cluster status from remote host"""
+        status_cmd = f"cd {self.remote_repo_path}/utils && export PATH={self.engine_path}/src:$PATH && python3 cluster_manager.py status || echo 'No cluster running'"
+        returncode, stdout, stderr = self._execute_remote_command(status_cmd)
+
+        # Return basic status info
+        return {
+            "host": self.host,
+            "engine_version": self.engine_version,
+            "status": "running" if returncode == 0 else "stopped",
+            "output": stdout.strip(),
+        }
+
+    def _copy_file_from_remote(self, remote_path: str, local_path: str) -> bool:
+        """Copy a file from remote host to local using scp"""
+        try:
+            import subprocess
+
+            assert self.key_path is not None  # Guaranteed by _setup_ssh_key
+            scp_cmd = [
+                "scp",
+                "-i",
+                self.key_path,
+                "-o",
+                "StrictHostKeyChecking=no",
+                "-o",
+                "UserKnownHostsFile=/dev/null",
+                f"{self.user}@{self.host}:{remote_path}",
+                local_path,
+            ]
+
+            result = subprocess.run(scp_cmd, capture_output=True, text=True, timeout=30)
+            if result.returncode != 0:
+                logging.error(
+                    f"Failed to copy {remote_path} from remote: {result.stderr}"
+                )
+                return False
+
+            logging.info(f"Successfully copied {remote_path} to {local_path}")
+            return True
+
+        except Exception as e:
+            logging.error(f"Error copying file from remote: {e}")
+            return False
+
+    def _get_remote_internal_ip(self) -> Optional[str]:
+        """Get the internal IP address of the remote host"""
+        try:
+            # Try to get the IP that would be used to reach the internet (usually the VPC internal IP)
+            cmd = "ip route get 8.8.8.8 | awk '{print $7; exit}'"
+            returncode, stdout, stderr = self._execute_remote_command(cmd)
+            if returncode == 0 and stdout.strip():
+                internal_ip = stdout.strip()
+                logging.debug(f"Detected internal IP via route: {internal_ip}")
+                return internal_ip
+
+            # Fallback: get IP of the default interface
+            cmd = "hostname -I | awk '{print $1}'"
+            returncode, stdout, stderr = self._execute_remote_command(cmd)
+            if returncode == 0 and stdout.strip():
+                internal_ip = stdout.strip()
+                logging.debug(f"Detected internal IP via hostname: {internal_ip}")
+                return internal_ip
+
+        except Exception as e:
+            logging.warning(f"Failed to detect remote internal IP: {e}")
+
+        return None
+
+    def _test_endpoint_connectivity(self, endpoint: str, timeout: int = 5) -> bool:
+        """Test if an endpoint is reachable via TCP connection"""
+        try:
+            host, port = endpoint.rsplit(":", 1)
+            port = int(port)
+
+            import socket
+
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            sock.settimeout(timeout)
+            result = sock.connect_ex((host, port))
+            sock.close()
+            return result == 0
+        except Exception as e:
+            logging.debug(f"Connectivity test failed for {endpoint}: {e}")
+            return False
+
+    def _copy_file_to_remote(self, local_path: str, remote_path: str) -> bool:
+        """Copy a local file to remote host using scp"""
+        try:
+            import subprocess
+
+            assert self.key_path is not None  # Guaranteed by _setup_ssh_key
+            scp_cmd = [
+                "scp",
+                "-i",
+                self.key_path,
+                "-o",
+                "StrictHostKeyChecking=no",
+                "-o",
+                "UserKnownHostsFile=/dev/null",
+                local_path,
+                f"{self.user}@{self.host}:{remote_path}",
+            ]
+
+            result = subprocess.run(scp_cmd, capture_output=True, text=True, timeout=30)
+            if result.returncode != 0:
+                logging.error(f"Failed to copy {local_path} to remote: {result.stderr}")
+                return False
+
+            logging.info(f"Copied {local_path} to {remote_path}")
+            return True
+
+        except Exception as e:
+            logging.error(f"Error copying file to remote: {e}")
+            return False
+
+
+    def diagnose_tls_issue(self, endpoints: List[str]) -> None:
+        """Diagnose TLS connectivity issues for cluster endpoints"""
+        logging.info("=== TLS DIAGNOSTICS ===")
+        
+        # 1. Check cluster topology and what nodes advertise
+        if endpoints:
+            first_endpoint = endpoints[0]
+            host, port = first_endpoint.split(':')
+            
+            logging.info("1. Checking cluster topology...")
+            cluster_nodes_cmd = f"cd {self.remote_repo_path}/utils && export PATH={self.engine_path}/src:$PATH && echo 'CLUSTER NODES' | valkey-cli -h {host} -p {port} --tls --cert tls_crts/server.crt --key tls_crts/server.key --cacert tls_crts/ca.crt"
+            returncode, stdout, stderr = self._execute_remote_command(cluster_nodes_cmd, timeout=15)
+            
+            if returncode == 0:
+                logging.info("Cluster nodes output:")
+                for line in stdout.strip().split('\n'):
+                    if line.strip():
+                        # Parse node info: node_id ip:port@cluster_port flags master/slave ...
+                        parts = line.split()
+                        if len(parts) >= 2:
+                            node_addr = parts[1].split('@')[0]  # Remove cluster port
+                            logging.info(f"  Node advertises: {node_addr}")
+            else:
+                logging.error(f"Failed to get cluster nodes: {stderr}")
+        
+        # 2. Test TLS handshake to each endpoint
+        logging.info("2. Testing TLS handshake to each endpoint...")
+        for i, endpoint in enumerate(endpoints):
+            host, port = endpoint.split(':')
+            logging.info(f"Testing endpoint {i+1}/{len(endpoints)}: {endpoint}")
+            
+            # Test with openssl s_client
+            openssl_cmd = f"echo 'QUIT' | openssl s_client -connect {host}:{port} -servername {host} -verify_return_error -CAfile {self.remote_repo_path}/utils/tls_crts/ca.crt 2>&1"
+            returncode, stdout, stderr = self._execute_remote_command(openssl_cmd, timeout=10)
+            
+            if "Verify return code: 0 (ok)" in stdout:
+                logging.info(f"  OK - TLS handshake OK for {endpoint}")
+            else:
+                logging.warning(f"  FAIL - TLS handshake FAILED for {endpoint}")
+                # Extract relevant error info
+                for line in stdout.split('\n'):
+                    if 'verify error' in line.lower() or 'certificate verify failed' in line.lower():
+                        logging.warning(f"    Error: {line.strip()}")
+        
+        # 3. Check certificate details
+        logging.info("3. Checking certificate SAN entries...")
+        cert_cmd = f"cd {self.remote_repo_path}/utils && openssl x509 -in tls_crts/server.crt -text -noout | grep -A1 'Subject Alternative Name'"
+        returncode, stdout, stderr = self._execute_remote_command(cert_cmd, timeout=5)
+        
+        if returncode == 0 and stdout.strip():
+            logging.info(f"Certificate SAN: {stdout.strip()}")
+        else:
+            logging.warning("Could not extract certificate SAN entries")
+        
+        # 4. Test connection order dependency
+        logging.info("4. Testing connection order dependency...")
+        for i, endpoint in enumerate(endpoints):
+            host, port = endpoint.split(':')
+            ping_cmd = f"cd {self.remote_repo_path}/utils && export PATH={self.engine_path}/src:$PATH && timeout 5 echo 'PING' | valkey-cli -h {host} -p {port} --tls --cert tls_crts/server.crt --key tls_crts/server.key --cacert tls_crts/ca.crt"
+            returncode, stdout, stderr = self._execute_remote_command(ping_cmd, timeout=10)
+            
+            if returncode == 0 and 'PONG' in stdout:
+                logging.info(f"  Connection {i+1}: {endpoint} - OK")
+            else:
+                logging.warning(f"  Connection {i+1}: {endpoint} - FAILED: {stderr}")
+        
+        logging.info("=== END TLS DIAGNOSTICS ===")
+
+    def test_cluster_discovery_tls(self, endpoints: List[str]) -> None:
+        """Test if cluster discovery reveals different IPs than initial connections"""
+        if not endpoints:
+            return
+            
+        logging.info("=== CLUSTER DISCOVERY TLS TEST ===")
+        
+        # Connect to first node and get full cluster topology
+        first_endpoint = endpoints[0]
+        host, port = first_endpoint.split(':')
+        
+        cluster_nodes_cmd = f"cd {self.remote_repo_path}/utils && export PATH={self.engine_path}/src:$PATH && echo 'CLUSTER NODES' | valkey-cli -h {host} -p {port} --tls --cert tls_crts/server.crt --key tls_crts/server.key --cacert tls_crts/ca.crt"
+        returncode, stdout, stderr = self._execute_remote_command(cluster_nodes_cmd, timeout=15)
+        
+        if returncode == 0:
+            discovered_nodes = []
+            for line in stdout.strip().split('\n'):
+                if line.strip():
+                    parts = line.split()
+                    if len(parts) >= 2:
+                        node_addr = parts[1].split('@')[0]  # Remove cluster port
+                        discovered_nodes.append(node_addr)
+            
+            logging.info(f"Initial endpoints: {endpoints}")
+            logging.info(f"Discovered nodes:  {discovered_nodes}")
+            
+            # Check if discovered nodes match initial endpoints
+            initial_set = set(endpoints)
+            discovered_set = set(discovered_nodes)
+            
+            if initial_set == discovered_set:
+                logging.info("OK - Discovered nodes match initial endpoints")
+            else:
+                logging.warning("FAIL - Discovered nodes differ from initial endpoints")
+                only_initial = initial_set - discovered_set
+                only_discovered = discovered_set - initial_set
+                if only_initial:
+                    logging.warning(f"  Only in initial: {only_initial}")
+                if only_discovered:
+                    logging.warning(f"  Only in discovered: {only_discovered}")
+        else:
+            logging.error(f"Failed to get cluster topology: {stderr}")
+        
+        logging.info("=== END CLUSTER DISCOVERY TLS TEST ===")
+
+
+    def test_glide_core_cluster_tls(self, endpoints: List[str]) -> bool:
+        """Test glide-core Rust cluster TLS against the remote cluster"""
+        if not endpoints:
+            return False
+            
+        logging.info("=== GLIDE-CORE CLUSTER TLS TEST ===")
+        
+        # Copy TLS certificates to local machine for glide-core test
+        local_tls_dir = "tls_test_certs"
+        os.makedirs(local_tls_dir, exist_ok=True)
+        
+        try:
+            # Copy certificates from remote
+            cert_files = ["ca.crt", "server.crt", "server.key"]
+            for cert_file in cert_files:
+                remote_path = f"{self.remote_repo_path}/utils/tls_crts/{cert_file}"
+                local_path = f"{local_tls_dir}/{cert_file}"
+                self._copy_file_from_remote(remote_path, local_path)
+                logging.info(f"Copied {cert_file} to {local_path}")
+            
+            # Create a simple Rust test program
+            test_program = f'''
+use redis::{{Client, cluster::{{ClusterClient, ClusterClientBuilder}}}};
+use std::fs;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {{
+    let endpoints = vec![{", ".join(f'"{ep}"' for ep in endpoints)}];
+    
+    // Read certificates
+    let ca_cert = fs::read("{local_tls_dir}/ca.crt")?;
+    
+    println!("Testing cluster connection to: {{:?}}", endpoints);
+    
+    // Create cluster client with TLS
+    let client = ClusterClientBuilder::new(endpoints)
+        .tls(redis::cluster::TlsMode::Secure)
+        .certs(redis::TlsCertificates {{
+            client_tls: None,
+            root_cert: Some(ca_cert),
+        }})
+        .build()?;
+    
+    println!("Created cluster client, attempting connection...");
+    
+    // Test connection
+    let mut conn = client.get_async_connection().await?;
+    
+    println!("Connected successfully! Testing PING...");
+    
+    // Test basic operation
+    let pong: String = redis::cmd("PING").query_async(&mut conn).await?;
+    println!("PING response: {{}}", pong);
+    
+    println!("SUCCESS: Rust glide-core cluster TLS test passed");
+    Ok(())
+}}
+'''
+            
+            # Write test program
+            test_dir = "rust_cluster_test"
+            os.makedirs(test_dir, exist_ok=True)
+            
+            with open(f"{test_dir}/main.rs", "w") as f:
+                f.write(test_program)
+            
+            # Create Cargo.toml
+            cargo_toml = '''[package]
+name = "cluster_tls_test"
+version = "0.1.0"
+edition = "2021"
+
+[[bin]]
+name = "main"
+path = "main.rs"
+
+[dependencies]
+redis = { path = "../gh/jduo/valkey-glide/glide-core/redis-rs/redis", features = ["cluster-async", "tokio-comp"] }
+tokio = { version = "1", features = ["full"] }
+'''
+            
+            with open(f"{test_dir}/Cargo.toml", "w") as f:
+                f.write(cargo_toml)
+            
+            # Run the test
+            logging.info("Running Rust cluster TLS test...")
+            result = subprocess.run(
+                ["cargo", "run", "--manifest-path", f"{test_dir}/Cargo.toml"],
+                capture_output=True,
+                text=True,
+                timeout=60,
+                env={**os.environ, "RUST_LOG": "debug"}
+            )
+            
+            if result.returncode == 0:
+                logging.info("SUCCESS - Rust cluster TLS test passed")
+                logging.info("This indicates the issue is Java-specific, not in Rust core")
+                if "SUCCESS: Rust glide-core cluster TLS test passed" in result.stdout:
+                    logging.info("Rust test output: Connection and PING successful")
+                return True
+            else:
+                logging.warning("FAILED - Rust cluster TLS test failed")
+                logging.warning("This indicates the issue is in the Rust core")
+                logging.warning(f"Test stdout: {result.stdout}")
+                logging.warning(f"Test stderr: {result.stderr}")
+                
+                # Check for specific BadSignature error
+                if "BadSignature" in result.stderr:
+                    logging.warning("CONFIRMED: Rust core also shows BadSignature error")
+                    logging.warning("This is a RustTLS issue in the core, not Java-specific")
+                
+                return False
+                
+        except Exception as e:
+            logging.error(f"Error running Rust cluster test: {e}")
+            return False
+        finally:
+            # Cleanup
+            import shutil
+            for cleanup_dir in [local_tls_dir, "rust_cluster_test"]:
+                if os.path.exists(cleanup_dir):
+                    shutil.rmtree(cleanup_dir)
+        
+        logging.info("=== END GLIDE-CORE CLUSTER TLS TEST ===")
+
+    def _copy_file_from_remote(self, remote_path: str, local_path: str) -> bool:
+        """Copy file from remote host to local machine"""
+        try:
+            cmd = [
+                "scp",
+                "-i", self.key_path,
+                "-o", "StrictHostKeyChecking=no",
+                "-o", "UserKnownHostsFile=/dev/null",
+                f"{self.user}@{self.host}:{remote_path}",
+                local_path
+            ]
+            
+            result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
+            return result.returncode == 0
+            
+        except Exception as e:
+            logging.error(f"Failed to copy {remote_path} from remote: {e}")
+            return False
+
+
+    def test_certificates_on_server(self, endpoints: List[str]) -> None:
+        """Test certificates entirely on the Linux server side"""
+        if not endpoints:
+            return
+            
+        logging.info("=== SERVER-SIDE CERTIFICATE TEST ===")
+        
+        # Test with valkey-cli on server
+        first_endpoint = endpoints[0]
+        host, port = first_endpoint.split(':')
+        
+        # Test basic TLS connection
+        test_cmd = f"cd {self.remote_repo_path}/utils && export PATH={self.engine_path}/src:$PATH && echo 'PING' | valkey-cli -h {host} -p {port} --tls --cert tls_crts/server.crt --key tls_crts/server.key --cacert tls_crts/ca.crt"
+        returncode, stdout, stderr = self._execute_remote_command(test_cmd, timeout=10)
+        
+        if returncode == 0 and 'PONG' in stdout:
+            logging.info("SUCCESS - Server-side valkey-cli TLS connection works")
+        else:
+            logging.warning(f"FAILED - Server-side valkey-cli TLS connection failed: {stderr}")
+        
+        # Test cluster mode connection with valkey-cli
+        cluster_test_cmd = f"cd {self.remote_repo_path}/utils && export PATH={self.engine_path}/src:$PATH && echo 'CLUSTER INFO' | valkey-cli -c -h {host} -p {port} --tls --cert tls_crts/server.crt --key tls_crts/server.key --cacert tls_crts/ca.crt"
+        returncode, stdout, stderr = self._execute_remote_command(cluster_test_cmd, timeout=10)
+        
+        if returncode == 0 and 'cluster_state:ok' in stdout:
+            logging.info("SUCCESS - Server-side valkey-cli CLUSTER mode TLS connection works")
+        else:
+            logging.warning(f"FAILED - Server-side valkey-cli CLUSTER mode TLS connection failed: {stderr}")
+            
+        # Test cluster discovery with valkey-cli
+        cluster_nodes_cmd = f"cd {self.remote_repo_path}/utils && export PATH={self.engine_path}/src:$PATH && echo 'CLUSTER NODES' | valkey-cli -c -h {host} -p {port} --tls --cert tls_crts/server.crt --key tls_crts/server.key --cacert tls_crts/ca.crt"
+        returncode, stdout, stderr = self._execute_remote_command(cluster_nodes_cmd, timeout=10)
+        
+        if returncode == 0:
+            logging.info("SUCCESS - Server-side valkey-cli cluster discovery works")
+            logging.info("Cluster nodes discovered:")
+            for line in stdout.split('\n')[:6]:  # First 6 nodes
+                if line.strip() and '172.31.34.123' in line:
+                    parts = line.split()
+                    if len(parts) >= 2:
+                        node_addr = parts[1].split('@')[0]
+                        logging.info(f"  Node: {node_addr}")
+        else:
+            logging.warning(f"FAILED - Server-side valkey-cli cluster discovery failed: {stderr}")
+        
+        # Print certificate details on server
+        cert_info_cmd = f"cd {self.remote_repo_path}/utils && openssl x509 -in tls_crts/ca.crt -text -noout | head -20"
+        returncode, stdout, stderr = self._execute_remote_command(cert_info_cmd, timeout=5)
+        
+        if returncode == 0:
+            logging.info("Server certificate info:")
+            for line in stdout.split('\n')[:10]:  # First 10 lines
+                if line.strip():
+                    logging.info(f"  {line}")
+        
+        # Print raw certificate content for comparison
+        cert_content_cmd = f"cd {self.remote_repo_path}/utils && wc -c tls_crts/ca.crt && echo '=== FIRST 200 CHARS ===' && head -c 200 tls_crts/ca.crt && echo && echo '=== LAST 200 CHARS ===' && tail -c 200 tls_crts/ca.crt && echo && echo '=== LINE ENDINGS CHECK ===' && od -c tls_crts/ca.crt | head -5"
+        returncode, stdout, stderr = self._execute_remote_command(cert_content_cmd, timeout=5)
+        
+        if returncode == 0:
+            logging.info("Server certificate raw content and line endings:")
+            for line in stdout.split('\n'):
+                if line.strip():
+                    logging.info(f"  {line}")
+        
+        # Print certificate as hex for exact comparison
+        cert_hex_cmd = f"cd {self.remote_repo_path}/utils && xxd -l 100 tls_crts/ca.crt"
+        returncode, stdout, stderr = self._execute_remote_command(cert_hex_cmd, timeout=5)
+        
+        if returncode == 0:
+            logging.info("Server certificate hex (first 100 bytes):")
+            for line in stdout.split('\n'):
+                if line.strip():
+                    logging.info(f"  {line}")
+        
+        # Test with a simple Rust program on server
+        rust_test_program = '''
+use std::fs;
+use std::process::Command;
+
+fn main() {
+    println!("Testing certificate files on server...");
+    
+    let cert_files = ["tls_crts/ca.crt", "tls_crts/server.crt", "tls_crts/server.key"];
+    
+    for file in &cert_files {
+        match fs::read(file) {
+            Ok(content) => {
+                println!("File {}: {} bytes", file, content.len());
+                println!("First 50 bytes: {:?}", content.iter().take(50).collect::<Vec<_>>());
+            }
+            Err(e) => println!("Failed to read {}: {}", file, e),
+        }
+    }
+}
+'''
+        
+        # Write and run the test program on server
+        write_test_cmd = f"cd {self.remote_repo_path}/utils && cat > cert_test.rs << 'EOF'\n{rust_test_program}\nEOF"
+        self._execute_remote_command(write_test_cmd, timeout=5)
+        
+        compile_cmd = f"cd {self.remote_repo_path}/utils && rustc cert_test.rs -o cert_test"
+        returncode, stdout, stderr = self._execute_remote_command(compile_cmd, timeout=10)
+        
+        if returncode == 0:
+            run_cmd = f"cd {self.remote_repo_path}/utils && ./cert_test"
+            returncode, stdout, stderr = self._execute_remote_command(run_cmd, timeout=5)
+            
+            if returncode == 0:
+                logging.info("Server-side certificate test output:")
+                for line in stdout.split('\n'):
+                    if line.strip():
+                        logging.info(f"  {line}")
+        
+        logging.info("=== END SERVER-SIDE CERTIFICATE TEST ===")
+
+
+def main():
+    logfile = "./cluster_manager.log"
+    init_logger(logfile)
+
+    parser = argparse.ArgumentParser(description="Remote Cluster Manager")
+    parser.add_argument("--host", help="Remote Linux host IP/hostname")
+    parser.add_argument("--user", default="ubuntu", help="SSH user (default: ubuntu)")
+    parser.add_argument("--key-path", help="SSH private key path")
+    parser.add_argument(
+        "--engine-version", default="8.0", help="Valkey engine version (default: 8.0)"
+    )
+
+    subparsers = parser.add_subparsers(dest="command", help="Commands")
+
+    # Start command
+    start_parser = subparsers.add_parser("start", help="Start remote cluster")
+    start_parser.add_argument(
+        "--cluster-mode", action="store_true", help="Enable cluster mode"
+    )
+    start_parser.add_argument(
+        "-n", "--shard-count", type=int, default=3, help="Number of shards"
+    )
+    start_parser.add_argument(
+        "-r", "--replica-count", type=int, default=1, help="Number of replicas"
+    )
+    start_parser.add_argument("--tls", action="store_true", help="Enable TLS")
+    start_parser.add_argument(
+        "--tls-cert-file", type=str, help="Path to TLS certificate file"
+    )
+    start_parser.add_argument("--tls-key-file", type=str, help="Path to TLS key file")
+    start_parser.add_argument(
+        "--tls-ca-cert-file", type=str, help="Path to TLS CA certificate file"
+    )
+    start_parser.add_argument("--load-module", action="append", help="Load module")
+
+    # Other subcommands (parsers created but not used yet)
+    subparsers.add_parser("stop", help="Stop remote cluster")
+    subparsers.add_parser("status", help="Get cluster status")
+    subparsers.add_parser("test", help="Test SSH connection")
+
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        return 1
+
+    level = logging.INFO
+    logging.root.setLevel(level=level)
+
+    # Get credentials from environment or arguments
+    host = args.host or os.environ.get("VALKEY_REMOTE_HOST")
+    if not host:
+        logging.error(
+            "Error: Remote host must be specified via --host or VALKEY_REMOTE_HOST environment variable"
+        )
+        return 1
+
+    # Get SSH key from multiple sources
+    key_path = args.key_path
+    key_content = os.environ.get("SSH_PRIVATE_KEY_CONTENT")  # For GitHub secrets
+
+    try:
+        manager = RemoteClusterManager(
+            host, args.user, key_path, key_content, args.engine_version
+        )
+
+        if args.command == "test":
+            if manager.test_connection():
+                logging.info("[OK] SSH connection successful")
+                return 0
+            else:
+                logging.error("[FAIL] SSH connection failed")
+                return 1
+
+        elif args.command == "start":
+            endpoints = manager.start_cluster(
+                cluster_mode=args.cluster_mode,
+                shard_count=args.shard_count,
+                replica_count=args.replica_count,
+                tls=args.tls,
+                tls_cert_file=args.tls_cert_file,
+                tls_key_file=args.tls_key_file,
+                tls_ca_cert_file=args.tls_ca_cert_file,
+                load_module=args.load_module,
+            )
+            if endpoints:
+                # Output endpoints in format expected by Gradle (to stdout)
+                print("CLUSTER_NODES=" + ",".join(endpoints))
+                return 0
+            else:
+                return 1
+
+        elif args.command == "stop":
+            success = manager.stop_cluster()
+            return 0 if success else 1
+
+        elif args.command == "status":
+            status = manager.get_cluster_status()
+            if status:
+                print(json.dumps(status, indent=2))
+                return 0
+            else:
+                return 1
+
+    except Exception as e:
+        logging.error(f"Error: {e}")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/utils/setup_linux_runner.sh b/utils/setup_linux_runner.sh
new file mode 100755
index 0000000000..bb7b881456
--- /dev/null
+++ b/utils/setup_linux_runner.sh
@@ -0,0 +1,86 @@
+#!/bin/bash
+# Setup script for Linux runner with Valkey support
+
+set -e
+
+echo "Setting up Linux runner for Valkey GLIDE tests..."
+
+# Update system
+sudo apt-get update
+sudo apt-get install -y python3 python3-pip git build-essential pkg-config libssl-dev curl
+
+# Install Valkey
+echo "Installing Valkey..."
+cd /tmp
+if [ ! -d "valkey" ]; then
+    git clone https://github.com/valkey-io/valkey.git
+fi
+cd valkey
+git checkout 8.0.1  # Use stable version
+make -j$(nproc) BUILD_TLS=yes
+sudo make install
+
+# Verify Valkey installation
+echo "Verifying Valkey installation..."
+valkey-server --version
+valkey-cli --version
+
+# Install Python dependencies
+echo "Installing Python dependencies..."
+pip3 install psutil
+
+# Clone valkey-glide repository
+echo "Setting up valkey-glide repository..."
+cd /home/ubuntu
+if [ ! -d "valkey-glide" ]; then
+    git clone https://github.com/valkey-io/valkey-glide.git
+fi
+cd valkey-glide
+git pull origin main
+
+# Install Python requirements for cluster manager
+cd utils
+pip3 install -r requirements.txt || echo "No requirements.txt found, continuing..."
+
+# Test cluster manager
+echo "Testing cluster manager..."
+python3 cluster_manager.py --help
+
+# Configure firewall for Valkey ports
+echo "Configuring firewall..."
+sudo ufw allow 22/tcp      # SSH
+sudo ufw allow 6379:6400/tcp  # Valkey ports
+sudo ufw allow 16379:16400/tcp # Valkey cluster bus ports
+sudo ufw --force enable
+
+# Create systemd service for keeping runner alive
+echo "Creating runner service..."
+sudo tee /etc/systemd/system/valkey-runner.service > /dev/null << EOF
+[Unit]
+Description=Valkey Test Runner
+After=network.target
+
+[Service]
+Type=simple
+User=ubuntu
+WorkingDirectory=/home/ubuntu/valkey-glide
+ExecStart=/bin/bash -c 'while true; do sleep 60; done'
+Restart=always
+RestartSec=10
+
+[Install]
+WantedBy=multi-user.target
+EOF
+
+sudo systemctl daemon-reload
+sudo systemctl enable valkey-runner
+sudo systemctl start valkey-runner
+
+echo "Linux runner setup complete!"
+echo ""
+echo "Runner is ready to accept remote cluster management requests."
+echo "Use the following environment variables in Windows tests:"
+echo "  VALKEY_REMOTE_HOST=$(curl -s http://169.254.169.254/latest/meta-data/public-ipv4)"
+echo ""
+echo "Test the setup with:"
+echo "  python3 /home/ubuntu/valkey-glide/utils/remote_cluster_manager.py --host localhost start --cluster-mode"