fix: wait for instances to be ready before reporting rollout complete

The `compute deploy` rollout watcher reported PHASE=Done and exited
within seconds of creating the workload, before any instances were
scheduled. A WorkloadDeployment's Status.DesiredReplicas stays at zero
until the controller first reconciles it, and computePhase treated zero
desired as Done — so the very first poll of a fresh deployment looked
complete.

Resolve the wait target from the spec minimum while the controller has
not yet reported a desired count, and require that no stale replicas
remain before reporting Done so scale-downs and rolling updates aren't
declared complete while old instances are still draining.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: scotwells

internal/cmd/compute/watch/watch.go

@@ -112,11 +112,11 @@ func processDeployments(
 		key := d.Spec.CityCode
 		prev, exists := states[key]
 
-		desired := d.Status.DesiredReplicas
+		desired := resolveDesired(d)
 		ready := d.Status.ReadyReplicas
 		current := d.Status.CurrentReplicas
 
-		newPhase := computePhase(desired, ready, current, prev)
+		newPhase := computePhase(desired, ready, current, d.Status.Replicas)
 
 		if !exists || prev.desired != desired || prev.ready != ready || prev.current != current || prev.phase != newPhase {
 			newPhase = updateDeploymentState(states, key, d, exists, prev, desired, ready, current, newPhase)
@@ -186,10 +186,7 @@ func printDeploymentRow(
 	current, ready int32,
 	newPhase deploymentPhase,
 ) {
-	old := d.Status.Replicas - d.Status.CurrentReplicas
-	if old < 0 {
-		old = 0
-	}
+	old := max(d.Status.Replicas-d.Status.CurrentReplicas, 0)
 
 	_, _ = fmt.Fprintf(tw, "  %s\t%s\t%d\t%d\t%d\t%s\n",
 		d.Spec.PlacementName,
@@ -217,16 +214,28 @@ func printElapsed(out io.Writer, elapsed time.Duration) {
 	}
 }
 
-func computePhase(desired, ready, current int32, _ *deploymentState) deploymentPhase {
+// resolveDesired returns the replica count the rollout should wait for.
+// Status.DesiredReplicas stays at zero until the controller first reconciles
+// the deployment; until then, fall back to the spec minimum so a freshly
+// created deployment isn't reported Done before any instances are scheduled.
+// Once the controller has reported a desired count, trust it.
+func resolveDesired(d computev1alpha.WorkloadDeployment) int32 {
+	if d.Status.DesiredReplicas == 0 {
+		return d.Spec.ScaleSettings.MinReplicas
+	}
+	return d.Status.DesiredReplicas
+}
+
+func computePhase(desired, ready, current, replicas int32) deploymentPhase {
 	if desired == 0 {
 		return phaseDone
 	}
+	if ready >= desired && current >= desired && replicas <= current {
+		return phaseDone
+	}
 	if current == 0 {
 		return phasePending
 	}
-	if ready >= desired && current >= desired {
-		return phaseDone
-	}
 	return phaseUpdating
 }
 

internal/cmd/compute/watch/watch_test.go

@@ -0,0 +1,181 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+
+package watch
+
+import (
+	"testing"
+	"time"
+
+	computev1alpha "go.datum.net/compute/api/v1alpha"
+)
+
+func TestResolveDesired(t *testing.T) {
+	tests := []struct {
+		name            string
+		statusDesired   int32
+		specMinReplicas int32
+		want            int32
+	}{
+		{
+			name:            "unreconciled status falls back to spec min",
+			statusDesired:   0,
+			specMinReplicas: 1,
+			want:            1,
+		},
+		{
+			name:            "genuine scale-to-zero",
+			statusDesired:   0,
+			specMinReplicas: 0,
+			want:            0,
+		},
+		{
+			name:            "controller desired above min (e.g. autoscaled)",
+			statusDesired:   3,
+			specMinReplicas: 1,
+			want:            3,
+		},
+		{
+			// Once the controller has spoken, trust its value even if below spec min.
+			name:            "controller desired below min — trust controller",
+			statusDesired:   1,
+			specMinReplicas: 2,
+			want:            1,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			d := computev1alpha.WorkloadDeployment{}
+			d.Status.DesiredReplicas = tc.statusDesired
+			d.Spec.ScaleSettings.MinReplicas = tc.specMinReplicas
+
+			got := resolveDesired(d)
+			if got != tc.want {
+				t.Errorf("resolveDesired() = %d, want %d", got, tc.want)
+			}
+		})
+	}
+}
+
+func TestComputePhase(t *testing.T) {
+	tests := []struct {
+		name     string
+		desired  int32
+		ready    int32
+		current  int32
+		replicas int32
+		want     deploymentPhase
+	}{
+		{
+			name:     "zero desired is Done",
+			desired:  0,
+			ready:    0,
+			current:  0,
+			replicas: 0,
+			want:     phaseDone,
+		},
+		{
+			name:     "fresh create with no instances yet is Pending",
+			desired:  1,
+			ready:    0,
+			current:  0,
+			replicas: 0,
+			want:     phasePending,
+		},
+		{
+			name:     "instance scheduled but not ready is Updating",
+			desired:  1,
+			ready:    0,
+			current:  1,
+			replicas: 1,
+			want:     phaseUpdating,
+		},
+		{
+			name:     "single instance ready is Done",
+			desired:  1,
+			ready:    1,
+			current:  1,
+			replicas: 1,
+			want:     phaseDone,
+		},
+		{
+			// OLD replicas still draining after scale-down must not report Done.
+			name:     "scale-down with old replicas still draining is Updating",
+			desired:  1,
+			ready:    1,
+			current:  1,
+			replicas: 5,
+			want:     phaseUpdating,
+		},
+		{
+			name:     "partial readiness is Updating",
+			desired:  3,
+			ready:    1,
+			current:  2,
+			replicas: 3,
+			want:     phaseUpdating,
+		},
+		{
+			name:     "all replicas ready is Done",
+			desired:  2,
+			ready:    2,
+			current:  2,
+			replicas: 2,
+			want:     phaseDone,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			got := computePhase(tc.desired, tc.ready, tc.current, tc.replicas)
+			if got != tc.want {
+				t.Errorf("computePhase(%d, %d, %d, %d) = %q, want %q",
+					tc.desired, tc.ready, tc.current, tc.replicas, got, tc.want)
+			}
+		})
+	}
+}
+
+func TestUpdateDeploymentState(t *testing.T) {
+	const key = "DFW"
+
+	makeDeployment := func() computev1alpha.WorkloadDeployment {
+		var d computev1alpha.WorkloadDeployment
+		d.Spec.PlacementName = "default"
+		d.Spec.CityCode = key
+		return d
+	}
+
+	t.Run("stalled updating for 40s is promoted to Blocked", func(t *testing.T) {
+		states := map[string]*deploymentState{}
+		stalledAt := time.Now().Add(-40 * time.Second)
+		states[key] = &deploymentState{
+			phase:        phaseUpdating,
+			ready:        1,
+			current:      2,
+			stalledSince: stalledAt,
+		}
+
+		got := updateDeploymentState(states, key, makeDeployment(), true, states[key], 3, 1, 2, phaseUpdating)
+
+		if got != phaseBlocked {
+			t.Errorf("updateDeploymentState() phase = %q, want %q", got, phaseBlocked)
+		}
+		if states[key].phase != phaseBlocked {
+			t.Errorf("states[key].phase = %q, want %q", states[key].phase, phaseBlocked)
+		}
+	})
+
+	t.Run("first observation of Updating is not yet Blocked", func(t *testing.T) {
+		states := map[string]*deploymentState{}
+
+		got := updateDeploymentState(states, key, makeDeployment(), false, nil, 3, 1, 2, phaseUpdating)
+
+		if got != phaseUpdating {
+			t.Errorf("updateDeploymentState() phase = %q, want %q", got, phaseUpdating)
+		}
+		if states[key].phase != phaseUpdating {
+			t.Errorf("states[key].phase = %q, want %q", states[key].phase, phaseUpdating)
+		}
+	})
+}