Address review: read deprecated client field, OS-correct install prompt, tests

Follow-ups from the #5936 review (all non-blocking):

- environmentVersion now falls back to the deprecated Spec.Client field when
  Spec.EnvironmentVersion is empty. client is the predecessor of
  environment_version and some jobs still pin via it; reading both means the v4
  fallback and the differing-version guard observe whichever field carries the
  pin, instead of treating a client-pinned job as unversioned (which would
  silently resolve to v4 and let two differing client values slip past the
  guard). base_environment stays ignored — it is a path/ID, not a version. The
  divergence error message is now field-agnostic ("differing versions").

- confirmUvInstall's prompt now names the OS-specific installer URL via a shared
  uvInstallerURL helper (install.ps1 on Windows, install.sh elsewhere), which
  installUv also uses, so the prompt is transparent about what actually runs.

- Tests: environmentVersion field precedence (compute_test.go) and serverless
  --job version resolution + v4 fallback (target_test.go).

The end-to-end differing-versions rejection through GetJobSparkVersion is best
exercised as an acceptance scenario alongside the job fixtures in #5833; noted
on the PR.

Co-authored-by: Isaac

Author: rugpanov

cmd/localenv/compute.go

@@ -69,7 +69,7 @@ func (c sdkCompute) GetJobSparkVersion(ctx context.Context, jobID string) (spark
 		// first. A pinned-vs-unpinned mix is also ambiguous, so compare raw values.
 		for _, e := range job.Settings.Environments[1:] {
 			if environmentVersion(e) != version {
-				return "", false, "", fmt.Errorf("job %d has serverless environments with differing environment_version; pass --serverless explicitly to disambiguate", id)
+				return "", false, "", fmt.Errorf("job %d has serverless environments with differing versions; pass --serverless explicitly to disambiguate", id)
 			}
 		}
 		return "", true, version, nil
@@ -94,11 +94,21 @@ func (c sdkCompute) GetJobSparkVersion(ctx context.Context, jobID string) (spark
 	return "", false, "", fmt.Errorf("could not determine compute for job %d from its environments or job clusters (task-level compute is not supported); pass --cluster or --serverless explicitly", id)
 }
 
-// environmentVersion returns the serverless environment_version recorded on a
+// environmentVersion returns the serverless environment version recorded on a
 // job environment, or "" when the spec or version is absent.
+//
+// The version can arrive in either of two fields. environment_version is the
+// current one; client is its deprecated predecessor ("Use environment_version
+// instead") and is still what some jobs pin. Reading both means the v4 fallback
+// and the divergence guard observe whichever field actually carries the pin,
+// rather than treating a client-pinned job as unversioned. base_environment is
+// deliberately ignored: it is a path/ID, not a version.
 func environmentVersion(e jobs.JobEnvironment) string {
 	if e.Spec == nil {
 		return ""
 	}
-	return e.Spec.EnvironmentVersion
+	if e.Spec.EnvironmentVersion != "" {
+		return e.Spec.EnvironmentVersion
+	}
+	return e.Spec.Client
 }

cmd/localenv/compute_test.go

@@ -0,0 +1,32 @@
+package localenv
+
+import (
+	"testing"
+
+	"github.com/databricks/databricks-sdk-go/service/compute"
+	"github.com/databricks/databricks-sdk-go/service/jobs"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestEnvironmentVersion(t *testing.T) {
+	cases := []struct {
+		name string
+		env  jobs.JobEnvironment
+		want string
+	}{
+		{"nil spec", jobs.JobEnvironment{}, ""},
+		{"environment_version", jobs.JobEnvironment{Spec: &compute.Environment{EnvironmentVersion: "3"}}, "3"},
+		// client is the deprecated predecessor of environment_version; some jobs
+		// still pin via it, so it must be read when environment_version is empty.
+		{"client fallback", jobs.JobEnvironment{Spec: &compute.Environment{Client: "2"}}, "2"},
+		// environment_version wins when both are present.
+		{"environment_version wins", jobs.JobEnvironment{Spec: &compute.Environment{EnvironmentVersion: "4", Client: "2"}}, "4"},
+		// base_environment is a path/ID, not a version, and is ignored.
+		{"base_environment ignored", jobs.JobEnvironment{Spec: &compute.Environment{BaseEnvironment: "/Workspace/env.yaml"}}, ""},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			assert.Equal(t, tc.want, environmentVersion(tc.env))
+		})
+	}
+}

libs/localenv/target_test.go

@@ -90,6 +90,27 @@ func TestResolveJobClassicUsesSparkVersionReturn(t *testing.T) {
 	assert.Equal(t, "dbr/15.4.x-scala2.12", ti.EnvKey)
 }
 
+func TestResolveJobServerlessUsesRecordedVersion(t *testing.T) {
+	// A serverless job (isServerless=true) pins its serverless version via the
+	// third "recorded version" return; ResolveTarget must map it to the matching
+	// serverless-vN rather than the classic dbr path.
+	c := jobStubCompute{isServerless: true, version: "3"}
+	ti, err := ResolveTarget(t.Context(), TargetFlags{Job: "42"}, c, BundleTarget{})
+	require.NoError(t, err)
+	assert.Equal(t, "job", ti.Source)
+	assert.Empty(t, ti.SparkVersion)
+	assert.Equal(t, "serverless/serverless-v3", ti.EnvKey)
+}
+
+func TestResolveJobServerlessEmptyVersionFallsBackToV4(t *testing.T) {
+	// When the job records no serverless version, ResolveTarget defaults to v4
+	// (documented stand-in), matching the bundle serverless path.
+	c := jobStubCompute{isServerless: true, version: ""}
+	ti, err := ResolveTarget(t.Context(), TargetFlags{Job: "42"}, c, BundleTarget{})
+	require.NoError(t, err)
+	assert.Equal(t, "serverless/serverless-v4", ti.EnvKey)
+}
+
 func TestValidateTargetFlagsMutuallyExclusive(t *testing.T) {
 	assert.Error(t, ValidateTargetFlags(TargetFlags{Cluster: "a", Serverless: "v4"}))
 	assert.NoError(t, ValidateTargetFlags(TargetFlags{Cluster: "a"}))

libs/localenv/uv.go

@@ -323,22 +323,31 @@ func confirmUvInstall(ctx context.Context) bool {
 	if !cmdio.HasIO(ctx) || !cmdio.IsPromptSupported(ctx) {
 		return false
 	}
-	ok, err := cmdio.AskYesOrNo(ctx, "uv is not installed. Download and run the official uv installer (https://astral.sh/uv/install.sh)?")
+	// Name the OS-specific installer URL that installUv will actually fetch, so
+	// the prompt is transparent about what runs (install.ps1 on Windows).
+	ok, err := cmdio.AskYesOrNo(ctx, "uv is not installed. Download and run the official uv installer ("+uvInstallerURL()+")?")
 	return err == nil && ok
 }
 
+// uvInstallerURL returns the URL of the official uv installer script that
+// installUv fetches for the current OS.
+func uvInstallerURL() string {
+	if runtime.GOOS == "windows" {
+		return "https://astral.sh/uv/install.ps1"
+	}
+	return "https://astral.sh/uv/install.sh"
+}
+
 // installUv runs the official uv installer for the current OS. Unix uses the
 // shell installer; Windows uses the PowerShell installer, because the Unix
 // `sh`/`curl` pipeline is not available in a default Windows shell.
 // https://docs.astral.sh/uv/getting-started/installation/
 func installUv(ctx context.Context) error {
 	var cmd []string
 	if runtime.GOOS == "windows" {
-		// https://astral.sh/uv/install.ps1
-		cmd = []string{"powershell", "-ExecutionPolicy", "ByPass", "-Command", "irm https://astral.sh/uv/install.ps1 | iex"}
+		cmd = []string{"powershell", "-ExecutionPolicy", "ByPass", "-Command", "irm " + uvInstallerURL() + " | iex"}
 	} else {
-		// https://astral.sh/uv/install.sh
-		cmd = []string{"sh", "-c", "curl -LsSf https://astral.sh/uv/install.sh | sh"}
+		cmd = []string{"sh", "-c", "curl -LsSf " + uvInstallerURL() + " | sh"}
 	}
 	// This downloads and runs a remote installer that mutates the user's machine
 	// (~/.local/bin), so record exactly what ran before it fires — visible under