diff --git a/api/autoscaling/v1alpha1/llmscaler_types.go b/api/autoscaling/v1alpha1/llmscaler_types.go
index 4bf93a1..1ed22e4 100644
--- a/api/autoscaling/v1alpha1/llmscaler_types.go
+++ b/api/autoscaling/v1alpha1/llmscaler_types.go
@@ -49,37 +49,183 @@ const (
 const DefaultDeferTimeoutSeconds int32 = 600
 
 // Condition types and reasons on LLMScalerStatus.Conditions.
+// The conditions are AbleToScale, ScalingActive, and ScalingLimited.
+// DecisionAvailable is deprecated and mirrors ScalingActive.
 const (
-	// ConditionDecisionAvailable is set under the Custom provider: true when the
-	// last sync got a decision, false (with the error as message) when it held
-	// replicas instead.
+	// ConditionAbleToScale reports whether this sync could scale the target.
+	// It is the HPA AbleToScale equivalent. True is the normal state. It stays
+	// True while a rollout or settle guard holds the write, when the deferral
+	// timeout forces that write, and when scale-down stabilization is applying
+	// a higher recent recommendation. False means this sync could not scale:
+	// targetRef.apiVersion does not parse (InvalidSpec), the target could not
+	// be read (TargetNotFound, TargetUnreadable), or the replica write failed
+	// (TargetWriteFailed).
+	//
+	// Precedence among True reasons, first match per sync:
+	//  1. A guard hold (RolloutInProgress or ScaleDownSettling), in every hold
+	//     case: deferring a write, a no-op while a deferral is already running,
+	//     and pacing a forced write. DeferralTimedOut is in this tier too,
+	//     when the timeout forces the write the guard was holding.
+	//  2. ScaleDownStabilized, when the stabilization window returned a value
+	//     higher than this sync's clamped recommendation. It is not a guard:
+	//     it does not start, keep, or clear deferredSince, and it does not
+	//     emit ScalingDeferred. A stabilized no-op with no guard ends a
+	//     deferral exactly as a Synced no-op does.
+	//  3. Synced.
+	ConditionAbleToScale = "AbleToScale"
+
+	// ConditionScalingActive means this sync has a usable scaling signal.
+	// It is the HPA ScalingActive equivalent. Both providers set it on every
+	// sync that reaches a recommendation, so switching metricProvider
+	// overwrites it. It does not reflect target read or write failures; those
+	// stay on AbleToScale.
+	//
+	// Custom, decision read: True / DecisionReceived, "decision server
+	// recommends N replicas". Custom, no decision: False /
+	// DecisionUnavailable, "custom provider returned no decision: <err>".
+	// Custom with spec.customProvider nil: False / InvalidSpec,
+	// "spec.customProvider is not set".
+	//
+	// Prometheus, at least one metric evaluated: True / MetricsAvailable,
+	// "evaluated K of M metrics; recommends N replicas". N is the raw maximum
+	// before clamping and stabilization. Prometheus, nothing evaluated: False
+	// / DecisionUnavailable. The message names prometheus and the last error,
+	// or says that no metric could be evaluated when there is no error. A
+	// non-200 Prometheus body quoted in that error is capped at 1 KiB.
+	//
+	// A sync that stops before the recommendation (targetRef.apiVersion does
+	// not parse, or the target cannot be read) does not touch this condition,
+	// and does not touch ScalingLimited either. A target write failure keeps
+	// the value computed earlier in that sync, and keeps the ScalingLimited
+	// computed with it.
+	ConditionScalingActive = "ScalingActive"
+
+	// ConditionScalingLimited reports whether a limit bound the replica count
+	// this sync. It is the HPA ScalingLimited equivalent. True means the raw
+	// provider count was outside min/max, or spec.scaleDown.maxStepReplicas
+	// capped the write. False / DesiredWithinRange means the count was inside
+	// the acceptable range. It is informational.
+	//
+	// It is set only when ScalingActive is True this sync, at the moment the
+	// recommendation is computed and before the target write, so a write
+	// failure persists it the way ScalingActive is persisted. When
+	// ScalingActive is False this sync it is left as it is, including on
+	// the first sync where it may be absent. An unparseable targetRef.apiVersion
+	// and a failed target read stop before a recommendation and leave it as
+	// it is too. There is no ScaleUpLimit: scale-up is never capped.
+	//
+	// Precedence, the constraint that bound the final write:
+	//  1. ScaleDownLimit when the step cap changed the write
+	//     (targetReplicas != recommendedReplicas).
+	//  2. TooFewReplicas when the raw provider count, before clamping and
+	//     before stabilization, is below minReplicas. TooManyReplicas when
+	//     that raw count is above maxReplicas. TooFewReplicas is checked
+	//     first.
+	//  3. DesiredWithinRange otherwise.
+	//
+	// Stabilization lifting the count afterwards does not clear a clamp
+	// reason. Only the step cap outranks the clamp.
+	ConditionScalingLimited = "ScalingLimited"
+
+	// ConditionDecisionAvailable is written with the same status, reason,
+	// message, observedGeneration, and set points as ConditionScalingActive.
+	//
+	// Deprecated: mirrors ScalingActive; will be removed in a future release.
 	ConditionDecisionAvailable = "DecisionAvailable"
 
-	// ConditionScalingDeferred is true while a rollout or settle guard is holding
-	// a scale action back, including a no-op sync whose deferral clock is still
-	// running. It is false when this sync wrote (a normal write or one forced
-	// after the timeout) or when nothing is deferred.
-	ConditionScalingDeferred = "ScalingDeferred"
-
-	ReasonDecisionReceived    = "DecisionReceived"
+	// ReasonDecisionReceived means the Custom provider read a decision this
+	// sync. ScalingActive is True with this reason.
+	ReasonDecisionReceived = "DecisionReceived"
+	// ReasonDecisionUnavailable means this sync has no usable scaling signal,
+	// so the replica count was held at spec.replicas, apart from the min/max
+	// bounds. Both providers use it: Custom when the decision server returned
+	// nothing, Prometheus when no metric could be evaluated. ScalingActive is
+	// False with this reason. AbleToScale still describes the scale decision.
+	// ScalingLimited is left as it is.
 	ReasonDecisionUnavailable = "DecisionUnavailable"
 
 	// ReasonRolloutInProgress means a Deployment rollout is in progress, so the
-	// scale action is held in both directions.
+	// scale action is held in both directions. AbleToScale is True with this
+	// reason: the target can be scaled, and the guard is holding the write.
 	ReasonRolloutInProgress = "RolloutInProgress"
 	// ReasonScaleDownSettling means a scale-down is waiting for the target to
-	// finish absorbing the previous replica count.
+	// finish absorbing the previous replica count. AbleToScale is True with
+	// this reason.
 	ReasonScaleDownSettling = "ScaleDownSettling"
 	// ReasonDeferralTimedOut means the scale action was held longer than
 	// spec.deferTimeoutSeconds and was applied anyway. The value matches the
-	// DeferralTimedOut event. The deferral clock keeps running when the guard
-	// still matches.
+	// DeferralTimedOut event. AbleToScale is True with this reason. The
+	// deferral clock keeps running when the guard still matches. It outranks
+	// ScaleDownStabilized.
 	ReasonDeferralTimedOut = "DeferralTimedOut"
-	// ReasonNotDeferred means this sync found no guard matching: it wrote, or
-	// it was a no-op that did not have a deferral in progress. A no-op does not
-	// start a deferral, and a no-op while a guard still matches is not this
-	// reason when deferredSince is already set.
-	ReasonNotDeferred = "NotDeferred"
+
+	// ReasonScaleDownStabilized means the scale-down stabilization window
+	// returned a value higher than this sync's clamped recommendation, and no
+	// guard hold or DeferralTimedOut described the write. AbleToScale is True
+	// with this reason. The message is HPA's: "recent recommendations were
+	// higher than current one, applying the highest recent recommendation".
+	// It is not a guard. It does not start, keep, or clear deferredSince, and
+	// it does not emit ScalingDeferred. A stabilized no-op with no guard ends
+	// a deferral exactly as a Synced no-op does.
+	// A following guard treats a previous ScaleDownStabilized as a changed
+	// reason, the same way it treats Synced, and emits ScalingDeferred once.
+	ReasonScaleDownStabilized = "ScaleDownStabilized"
+
+	// ReasonSynced means the last sync completed cleanly. It is the AbleToScale
+	// reason when no guard holds and stabilization did not raise the
+	// recommendation: a normal write, or a no-op with no deferral running.
+	// deferredSince is cleared in that case.
+	ReasonSynced = "Synced"
+	// ReasonMetricsAvailable means the Prometheus provider evaluated at least
+	// one metric this sync. ScalingActive is True with this reason. The
+	// replica count in the message is the raw maximum across those metrics,
+	// before clamping to min/max and before scale-down stabilization.
+	ReasonMetricsAvailable = "MetricsAvailable"
+	// ReasonInvalidSpec means the scaler cannot be reconciled as written.
+	// On AbleToScale it means targetRef.apiVersion does not parse, and the
+	// sync stops. On ScalingActive it is set when metricProvider is Custom
+	// and customProvider is not set; AbleToScale still describes the scale
+	// decision in that case. A missing target is reported first, so
+	// AbleToScale is TargetNotFound and ScalingActive is not evaluated when
+	// both apply.
+	ReasonInvalidSpec = "InvalidSpec"
+	// ReasonTargetNotFound means getting the scale target returned NotFound.
+	// AbleToScale is False. ScalingActive, ScalingLimited, deferredSince, and
+	// the replica counts are left as they are.
+	ReasonTargetNotFound = "TargetNotFound"
+	// ReasonTargetUnreadable means getting the scale target failed for a
+	// reason other than NotFound. AbleToScale is False. ScalingActive,
+	// ScalingLimited, deferredSince, and the replica counts are left as they
+	// are.
+	ReasonTargetUnreadable = "TargetUnreadable"
+	// ReasonTargetWriteFailed means setting or updating spec.replicas on the
+	// scale target failed. AbleToScale is False. The ScalingActive and
+	// ScalingLimited computed earlier in that sync are kept. deferredSince
+	// and the replica counts are left as they are.
+	ReasonTargetWriteFailed = "TargetWriteFailed"
+
+	// ReasonTooFewReplicas means the raw provider count, before clamping and
+	// before stabilization, was below minReplicas, and the step cap did not
+	// change the write. ScalingLimited is True. Message: "the desired replica
+	// count is less than the minimum replica count".
+	ReasonTooFewReplicas = "TooFewReplicas"
+	// ReasonTooManyReplicas means the raw provider count, before clamping and
+	// before stabilization, was above maxReplicas, and neither the step cap
+	// nor TooFewReplicas applied. ScalingLimited is True. Message: "the
+	// desired replica count is more than the maximum replica count".
+	ReasonTooManyReplicas = "TooManyReplicas"
+	// ReasonDesiredWithinRange means this sync had a usable signal and neither
+	// the min/max clamp nor the scale-down step cap bound the write.
+	// ScalingLimited is False. Message: "the desired count is within the
+	// acceptable range".
+	ReasonDesiredWithinRange = "DesiredWithinRange"
+	// ReasonScaleDownLimit means spec.scaleDown.maxStepReplicas capped this
+	// sync's write (the step target differed from the recommendation). It is
+	// the HPA behavior rate limit. ScalingLimited is True, and it wins over a
+	// min/max clamp on the same sync. Message: "the desired replica count is
+	// decreasing faster than the maximum scale rate (maxStepReplicas N)".
+	// There is no ScaleUpLimit because scale-up is never capped.
+	ReasonScaleDownLimit = "ScaleDownLimit"
 )
 
 // CustomProviderSpec configures the "Custom" metric provider: an external
@@ -102,7 +248,8 @@ const (
 //
 // A request that fails, a reply in an unknown schema, and a reply with no
 // matching decision are all treated the way an unevaluable metric is: that sync
-// is skipped and the replica count is held where it is, never read as zero.
+// is skipped and the replica count is held at spec.replicas, apart from the
+// min/max bounds, never read as zero.
 type CustomProviderSpec struct {
 	// serviceId names the service whose decision to read. It is sent as the
 	// serviceId query parameter and is also matched against
@@ -140,7 +287,7 @@ type MetricSpec struct {
 	// aggregate away every label the source varies on (backend, model, route,
 	// pod). A query that errors, returns no data, or returns NaN/Inf is skipped
 	// for that sync rather than read as zero; if every metric is skipped the
-	// replica count is held where it is.
+	// replica count is held at spec.replicas, apart from the min/max bounds.
 	Query string `json:"query"`
 
 	// target is the desired per-replica value of the query result. When the
@@ -322,7 +469,22 @@ type LLMScalerStatus struct {
 	// +optional
 	DeferredSince *metav1.Time `json:"deferredSince,omitempty"`
 
-	// conditions represent the current state of the LLMScaler resource.
+	// observedGeneration is the most recent generation observed by the
+	// controller. It is set to metadata.generation on every status write.
+	// +optional
+	ObservedGeneration int64 `json:"observedGeneration,omitempty"`
+
+	// lastScaleTime is when the controller last successfully wrote
+	// spec.replicas on the target, taken from the reconciler clock. It is set
+	// on a normal write and on a write forced after the deferral timeout, and
+	// left unchanged on every other sync: a no-op, a deferral, pacing, or an
+	// error.
+	// +optional
+	LastScaleTime *metav1.Time `json:"lastScaleTime,omitempty"`
+
+	// conditions represent the current state of the LLMScaler resource:
+	// AbleToScale, ScalingActive, and ScalingLimited. DecisionAvailable is
+	// deprecated and mirrors ScalingActive.
 	// +listType=map
 	// +listMapKey=type
 	// +optional
@@ -335,7 +497,9 @@ type LLMScalerStatus struct {
 // +kubebuilder:printcolumn:name="MaxReplicas",type="integer",JSONPath=".spec.maxReplicas",description="The upper limit for the number of replicas"
 // +kubebuilder:printcolumn:name="CurrentReplicas",type="integer",JSONPath=".status.currentReplicas",description="The current number of replicas"
 // +kubebuilder:printcolumn:name="DesiredReplicas",type="integer",JSONPath=".status.desiredReplicas",description="The desired number of replicas"
-// +kubebuilder:printcolumn:name="Deferred",type="string",JSONPath=".status.conditions[?(@.type==\"ScalingDeferred\")].status",description="Whether a scale action is currently deferred"
+// +kubebuilder:printcolumn:name="Active",type="string",JSONPath=".status.conditions[?(@.type==\"ScalingActive\")].status",description="Whether a usable scaling signal was received"
+// +kubebuilder:printcolumn:name="AbleToScale",type="string",JSONPath=".status.conditions[?(@.type==\"AbleToScale\")].status",description="Whether this sync could scale the target"
+// +kubebuilder:printcolumn:name="Scaling",type="string",JSONPath=".status.conditions[?(@.type==\"AbleToScale\")].reason",description="The AbleToScale reason: Synced, a guard hold (RolloutInProgress, ScaleDownSettling), DeferralTimedOut, ScaleDownStabilized while the stabilization window keeps the count, or a failure"
 
 // LLMScaler is the Schema for the llmscalers API
 type LLMScaler struct {
diff --git a/api/autoscaling/v1alpha1/zz_generated.deepcopy.go b/api/autoscaling/v1alpha1/zz_generated.deepcopy.go
index 3b6be94..044eccb 100644
--- a/api/autoscaling/v1alpha1/zz_generated.deepcopy.go
+++ b/api/autoscaling/v1alpha1/zz_generated.deepcopy.go
@@ -146,6 +146,10 @@ func (in *LLMScalerStatus) DeepCopyInto(out *LLMScalerStatus) {
 		in, out := &in.DeferredSince, &out.DeferredSince
 		*out = (*in).DeepCopy()
 	}
+	if in.LastScaleTime != nil {
+		in, out := &in.LastScaleTime, &out.LastScaleTime
+		*out = (*in).DeepCopy()
+	}
 	if in.Conditions != nil {
 		in, out := &in.Conditions, &out.Conditions
 		*out = make([]v1.Condition, len(*in))
diff --git a/config/crd/bases/autoscaling.modelsphere.dev_llmscalers.yaml b/config/crd/bases/autoscaling.modelsphere.dev_llmscalers.yaml
index 7727afa..6c66b07 100644
--- a/config/crd/bases/autoscaling.modelsphere.dev_llmscalers.yaml
+++ b/config/crd/bases/autoscaling.modelsphere.dev_llmscalers.yaml
@@ -31,9 +31,19 @@ spec:
       jsonPath: .status.desiredReplicas
       name: DesiredReplicas
       type: integer
-    - description: Whether a scale action is currently deferred
-      jsonPath: .status.conditions[?(@.type=="ScalingDeferred")].status
-      name: Deferred
+    - description: Whether a usable scaling signal was received
+      jsonPath: .status.conditions[?(@.type=="ScalingActive")].status
+      name: Active
+      type: string
+    - description: Whether this sync could scale the target
+      jsonPath: .status.conditions[?(@.type=="AbleToScale")].status
+      name: AbleToScale
+      type: string
+    - description: 'The AbleToScale reason: Synced, a guard hold (RolloutInProgress,
+        ScaleDownSettling), DeferralTimedOut, ScaleDownStabilized while the stabilization
+        window keeps the count, or a failure'
+      jsonPath: .status.conditions[?(@.type=="AbleToScale")].reason
+      name: Scaling
       type: string
     name: v1alpha1
     schema:
@@ -150,7 +160,7 @@ spec:
                         aggregate away every label the source varies on (backend, model, route,
                         pod). A query that errors, returns no data, or returns NaN/Inf is skipped
                         for that sync rather than read as zero; if every metric is skipped the
-                        replica count is held where it is.
+                        replica count is held at spec.replicas, apart from the min/max bounds.
                       type: string
                     target:
                       description: |-
@@ -311,8 +321,10 @@ spec:
                 format: int32
                 type: integer
               conditions:
-                description: conditions represent the current state of the LLMScaler
-                  resource.
+                description: |-
+                  conditions represent the current state of the LLMScaler resource:
+                  AbleToScale, ScalingActive, and ScalingLimited. DecisionAvailable is
+                  deprecated and mirrors ScalingActive.
                 items:
                   description: Condition contains details for one aspect of the current
                     state of this API Resource.
@@ -391,6 +403,21 @@ spec:
                   pods managed by this autoscaler
                 format: int32
                 type: integer
+              lastScaleTime:
+                description: |-
+                  lastScaleTime is when the controller last successfully wrote
+                  spec.replicas on the target, taken from the reconciler clock. It is set
+                  on a normal write and on a write forced after the deferral timeout, and
+                  left unchanged on every other sync: a no-op, a deferral, pacing, or an
+                  error.
+                format: date-time
+                type: string
+              observedGeneration:
+                description: |-
+                  observedGeneration is the most recent generation observed by the
+                  controller. It is set to metadata.generation on every status write.
+                format: int64
+                type: integer
             type: object
         required:
         - spec
diff --git a/dist/chart/templates/crd/llmscalers.autoscaling.modelsphere.dev.yaml b/dist/chart/templates/crd/llmscalers.autoscaling.modelsphere.dev.yaml
index 8ca7645..541d63f 100644
--- a/dist/chart/templates/crd/llmscalers.autoscaling.modelsphere.dev.yaml
+++ b/dist/chart/templates/crd/llmscalers.autoscaling.modelsphere.dev.yaml
@@ -34,9 +34,19 @@ spec:
       jsonPath: .status.desiredReplicas
       name: DesiredReplicas
       type: integer
-    - description: Whether a scale action is currently deferred
-      jsonPath: .status.conditions[?(@.type=="ScalingDeferred")].status
-      name: Deferred
+    - description: Whether a usable scaling signal was received
+      jsonPath: .status.conditions[?(@.type=="ScalingActive")].status
+      name: Active
+      type: string
+    - description: Whether this sync could scale the target
+      jsonPath: .status.conditions[?(@.type=="AbleToScale")].status
+      name: AbleToScale
+      type: string
+    - description: 'The AbleToScale reason: Synced, a guard hold (RolloutInProgress,
+        ScaleDownSettling), DeferralTimedOut, ScaleDownStabilized while the stabilization
+        window keeps the count, or a failure'
+      jsonPath: .status.conditions[?(@.type=="AbleToScale")].reason
+      name: Scaling
       type: string
     name: v1alpha1
     schema:
@@ -153,7 +163,7 @@ spec:
                         aggregate away every label the source varies on (backend, model, route,
                         pod). A query that errors, returns no data, or returns NaN/Inf is skipped
                         for that sync rather than read as zero; if every metric is skipped the
-                        replica count is held where it is.
+                        replica count is held at spec.replicas, apart from the min/max bounds.
                       type: string
                     target:
                       description: |-
@@ -314,8 +324,10 @@ spec:
                 format: int32
                 type: integer
               conditions:
-                description: conditions represent the current state of the LLMScaler
-                  resource.
+                description: |-
+                  conditions represent the current state of the LLMScaler resource:
+                  AbleToScale, ScalingActive, and ScalingLimited. DecisionAvailable is
+                  deprecated and mirrors ScalingActive.
                 items:
                   description: Condition contains details for one aspect of the current
                     state of this API Resource.
@@ -394,6 +406,21 @@ spec:
                   pods managed by this autoscaler
                 format: int32
                 type: integer
+              lastScaleTime:
+                description: |-
+                  lastScaleTime is when the controller last successfully wrote
+                  spec.replicas on the target, taken from the reconciler clock. It is set
+                  on a normal write and on a write forced after the deferral timeout, and
+                  left unchanged on every other sync: a no-op, a deferral, pacing, or an
+                  error.
+                format: date-time
+                type: string
+              observedGeneration:
+                description: |-
+                  observedGeneration is the most recent generation observed by the
+                  controller. It is set to metadata.generation on every status write.
+                format: int64
+                type: integer
             type: object
         required:
         - spec
diff --git a/dist/install.yaml b/dist/install.yaml
index a3dd946..95668d8 100644
--- a/dist/install.yaml
+++ b/dist/install.yaml
@@ -39,9 +39,19 @@ spec:
       jsonPath: .status.desiredReplicas
       name: DesiredReplicas
       type: integer
-    - description: Whether a scale action is currently deferred
-      jsonPath: .status.conditions[?(@.type=="ScalingDeferred")].status
-      name: Deferred
+    - description: Whether a usable scaling signal was received
+      jsonPath: .status.conditions[?(@.type=="ScalingActive")].status
+      name: Active
+      type: string
+    - description: Whether this sync could scale the target
+      jsonPath: .status.conditions[?(@.type=="AbleToScale")].status
+      name: AbleToScale
+      type: string
+    - description: 'The AbleToScale reason: Synced, a guard hold (RolloutInProgress,
+        ScaleDownSettling), DeferralTimedOut, ScaleDownStabilized while the stabilization
+        window keeps the count, or a failure'
+      jsonPath: .status.conditions[?(@.type=="AbleToScale")].reason
+      name: Scaling
       type: string
     name: v1alpha1
     schema:
@@ -158,7 +168,7 @@ spec:
                         aggregate away every label the source varies on (backend, model, route,
                         pod). A query that errors, returns no data, or returns NaN/Inf is skipped
                         for that sync rather than read as zero; if every metric is skipped the
-                        replica count is held where it is.
+                        replica count is held at spec.replicas, apart from the min/max bounds.
                       type: string
                     target:
                       description: |-
@@ -319,8 +329,10 @@ spec:
                 format: int32
                 type: integer
               conditions:
-                description: conditions represent the current state of the LLMScaler
-                  resource.
+                description: |-
+                  conditions represent the current state of the LLMScaler resource:
+                  AbleToScale, ScalingActive, and ScalingLimited. DecisionAvailable is
+                  deprecated and mirrors ScalingActive.
                 items:
                   description: Condition contains details for one aspect of the current
                     state of this API Resource.
@@ -399,6 +411,21 @@ spec:
                   pods managed by this autoscaler
                 format: int32
                 type: integer
+              lastScaleTime:
+                description: |-
+                  lastScaleTime is when the controller last successfully wrote
+                  spec.replicas on the target, taken from the reconciler clock. It is set
+                  on a normal write and on a write forced after the deferral timeout, and
+                  left unchanged on every other sync: a no-op, a deferral, pacing, or an
+                  error.
+                format: date-time
+                type: string
+              observedGeneration:
+                description: |-
+                  observedGeneration is the most recent generation observed by the
+                  controller. It is set to metadata.generation on every status write.
+                format: int64
+                type: integer
             type: object
         required:
         - spec
diff --git a/docs/llmscaler.md b/docs/llmscaler.md
index 043ab53..236ccc1 100644
--- a/docs/llmscaler.md
+++ b/docs/llmscaler.md
@@ -80,28 +80,59 @@ Only read when `metricProvider: Custom`.
 | `desiredReplicas` | int32 | Last recommendation after clamping to min/max and scale-down stabilization, but **before** the `maxStepReplicas` cap. While a step cap is walking the fleet down it therefore reports the destination, not the replica count just written. |
 | `appliedReplicas` | int32 | The target's `spec.replicas` after this sync: the value just written, or the unchanged value when the sync deferred or had nothing to do. This is the replica count left on the target, separate from the `desiredReplicas` recommendation. |
 | `deferredSince` | metav1.Time | When the current deferral started. Set on the first sync that holds a scale action back. Kept across guard reason changes, no-op syncs while a guard still matches, and forced writes. Cleared only when a sync finds no guard matching (a normal write, or a no-op with no guard). A no-op does not start it. Stored in status so it survives an operator restart. |
-| `conditions` | []metav1.Condition | `DecisionAvailable` under the Custom provider (see [Custom metric provider](#custom-metric-provider)) and `ScalingDeferred` (see below). |
+| `observedGeneration` | int64 | `metadata.generation` at the last status write. |
+| `lastScaleTime` | metav1.Time | When the controller last successfully wrote `spec.replicas` on the target. Set on a normal write and on a write forced after the deferral timeout. Left unchanged on a no-op, a deferral, pacing, or an error. |
+| `conditions` | []metav1.Condition | `AbleToScale`, `ScalingActive`, and `ScalingLimited`. `DecisionAvailable` is deprecated and mirrors `ScalingActive`. See [Conditions](#conditions). |
 
-`kubectl get llmscalers` prints `MinReplicas`, `MaxReplicas`, `CurrentReplicas`, `DesiredReplicas`, `Deferred` (the `ScalingDeferred` condition status).
+`kubectl get llmscalers` prints `MinReplicas`, `MaxReplicas`, `CurrentReplicas`, `DesiredReplicas`, `Active` (the `ScalingActive` condition status), `AbleToScale` (the `AbleToScale` condition status), and `Scaling` (the `AbleToScale` condition reason: `Synced`, a guard hold (`RolloutInProgress`, `ScaleDownSettling`), `DeferralTimedOut`, `ScaleDownStabilized` while the stabilization window keeps the count, or a failure). `ScalingLimited` is not a printed column.
 
-#### `ScalingDeferred` condition
+### Conditions
 
-Set on every sync that gets as far as a scale decision. It describes that sync.
+`AbleToScale`, `ScalingActive`, and `ScalingLimited` are the HPA conditions of the same name. `DecisionAvailable` is deprecated: it mirrors `ScalingActive` (same status, reason, message, `observedGeneration`, and set points) and will be removed in a future release. Every condition carries the `metadata.generation` of the sync that last wrote it as its `observedGeneration`. `AbleToScale` replaces the earlier `ScalingDeferred` condition (polarity inverted; `NotDeferred` became `Synced`). Objects created before this change may keep a stale `ScalingDeferred` condition; clients should prefer `AbleToScale` and ignore `ScalingDeferred`, and it can be removed with `kubectl patch --subresource=status`.
 
-A no-op while a guard still matches leaves `deferredSince` unchanged. If it is set, the condition stays `True` with that guard's reason and a message that nothing needs writing this sync, the guard is still active, and the deferral clock keeps running. If it is nil, the condition is `False`/`NotDeferred`: a no-op does not start a deferral.
+A scaler is failing when `AbleToScale` or `ScalingActive` is `False`. `ScalingLimited` is informational. `AbleToScale` `True` with `RolloutInProgress`, `ScaleDownSettling`, or `ScaleDownStabilized` means waiting. Otherwise the scaler is healthy.
 
-| Status | Reason | Meaning |
-| --- | --- | --- |
-| `True` | `RolloutInProgress` | A Deployment rollout is in progress; the scale action is held in either direction. |
-| `True` | `ScaleDownSettling` | A scale-down is waiting for `readyReplicas` to equal `spec.replicas`. |
-| `False` | `DeferralTimedOut` | The deferral reached `deferTimeoutSeconds` and the held write was applied anyway. `deferredSince` stays set when the guard still matches. |
-| `False` | `NotDeferred` | No guard matches: this sync wrote, or the target was already at the step target. |
+| Type | Status | Reason | Set when |
+| --- | --- | --- | --- |
+| `ScalingActive` | `True` | `DecisionReceived` | Custom provider: a decision was read this sync. Message: `decision server recommends N replicas`. |
+| `ScalingActive` | `True` | `MetricsAvailable` | Prometheus provider: at least one metric evaluated this sync. Message: `evaluated K of M metrics; recommends N replicas`. N is the raw maximum before clamping and stabilization. |
+| `ScalingActive` | `False` | `DecisionUnavailable` | No usable signal this sync, so the replica count is held at `spec.replicas`, apart from the min/max bounds. Custom: `custom provider returned no decision: <err>` (request failed, unknown schema, or no usable decision). Prometheus: `no prometheus metric could be evaluated`, followed by `: <last err>` when a query failed, returned no data, was NaN/Inf, or the target did not parse. A non-200 Prometheus body quoted in that error is capped at 1 KiB. `ScalingLimited` is left as it is. `AbleToScale` still describes the scale decision. |
+| `ScalingActive` | `False` | `InvalidSpec` | Custom provider and `spec.customProvider` is not set. Message: `spec.customProvider is not set`. The replica count is held at `spec.replicas`, apart from the min/max bounds. `ScalingLimited` is left as it is. `AbleToScale` still describes the scale decision. If that scaler's target is also missing, the read runs first, so `AbleToScale` is `TargetNotFound` and `ScalingActive` is not evaluated. |
+| `DecisionAvailable` | same as `ScalingActive` | same as `ScalingActive` | Deprecated. Written with `ScalingActive`, with the same status, reason, message, and `observedGeneration`, on the same syncs. |
+| `AbleToScale` | `True` | `Synced` | No guard holds, and the stabilization window did not raise this sync's clamped recommendation. A normal write (`scaled X -> Y`), or a no-op with no deferral running (`replica count is already at the step target`). `deferredSince` is cleared. |
+| `AbleToScale` | `True` | `RolloutInProgress` | A guard holds the write and this one matched first. A `Deployment` is mid-rollout: `observedGeneration < generation`, `updatedReplicas < spec.replicas`, or `replicas > updatedReplicas`. Covers the deferring case, a no-op while a deferral is already running, and forced-write pacing. Wins over `ScaleDownStabilized`. |
+| `AbleToScale` | `True` | `ScaleDownSettling` | A guard holds the write and the rollout guard did not. A scale-down while `readyReplicas != spec.replicas`, or, when the terminating check is on (off by default), `terminatingReplicas > 0`. Same three hold cases as `RolloutInProgress`. Wins over `ScaleDownStabilized`. |
+| `AbleToScale` | `True` | `DeferralTimedOut` | A guard still matched and `deferTimeoutSeconds` has elapsed since `deferredSince`, so the held write was applied. Same message as the Warning event. `deferredSince` is kept. Wins over `ScaleDownStabilized`. |
+| `AbleToScale` | `True` | `ScaleDownStabilized` | The stabilization window returned a value higher than this sync's clamped recommendation, and no guard hold or `DeferralTimedOut` described the write. Message: `recent recommendations were higher than current one, applying the highest recent recommendation`. Not a guard: it does not start, keep, or clear `deferredSince`, and it does not emit `ScalingDeferred`. A stabilized no-op with no guard ends a deferral the same way a `Synced` no-op does. |
+| `AbleToScale` | `False` | `InvalidSpec` | `targetRef.apiVersion` does not parse. The sync stops before a recommendation, so `ScalingActive`, `DecisionAvailable`, and `ScalingLimited` are not updated. Message: `targetRef.apiVersion "<value>" does not parse: ...`. |
+| `AbleToScale` | `False` | `TargetNotFound` | Getting the target returned NotFound. The sync stops before a recommendation. `ScalingActive`, `DecisionAvailable`, `ScalingLimited`, `deferredSince`, and the replica counts stay untouched. Retried after `retryPeriodSeconds`. |
+| `AbleToScale` | `False` | `TargetUnreadable` | Getting the target failed for another reason. The sync stops before a recommendation. `ScalingActive`, `DecisionAvailable`, `ScalingLimited`, `deferredSince`, and the replica counts stay untouched. |
+| `AbleToScale` | `False` | `TargetWriteFailed` | Updating `spec.replicas` on the target failed (`could not write spec.replicas: ...`). The `ScalingActive`, `DecisionAvailable`, and `ScalingLimited` computed earlier in that sync are kept. `deferredSince` and the replica counts stay untouched. The error is returned, so the sync is retried with backoff. |
+| `ScalingLimited` | `True` | `TooFewReplicas` | `ScalingActive` is `True`, the raw provider count before clamping and before stabilization was below `minReplicas`, and the step cap did not change the write. Message: `the desired replica count is less than the minimum replica count`. |
+| `ScalingLimited` | `True` | `TooManyReplicas` | `ScalingActive` is `True` and that raw count was above `maxReplicas`, and neither the step cap nor `TooFewReplicas` applied. Message: `the desired replica count is more than the maximum replica count`. |
+| `ScalingLimited` | `True` | `ScaleDownLimit` | `ScalingActive` is `True` and `spec.scaleDown.maxStepReplicas` changed this sync's write (`targetReplicas != recommendedReplicas`). This is HPA's behavior rate limit. It wins over a min/max clamp on the same sync. Message: `the desired replica count is decreasing faster than the maximum scale rate (maxStepReplicas N)`. There is no `ScaleUpLimit`: scale-up is never capped. |
+| `ScalingLimited` | `False` | `DesiredWithinRange` | `ScalingActive` is `True` and neither the min/max clamp nor the step cap bound the write. Message: `the desired count is within the acceptable range`. |
+
+- `ScalingActive` is written on every sync that reaches a recommendation, for both providers, before clamping. Switching `metricProvider` overwrites it on the next such sync. `DecisionAvailable` is written with it. It is not written when `targetRef.apiVersion` does not parse or the target cannot be read. A target write failure keeps the value computed earlier in that sync. It does not reflect target read or write failures; those stay on `AbleToScale`.
+- `AbleToScale` `True` reasons, per sync: (1) a guard hold (`RolloutInProgress` or `ScaleDownSettling`), in all three hold cases — deferring a write, a no-op while a deferral is already running, and pacing a forced write — and `DeferralTimedOut` when the timeout forces the write; these describe the write and win. (2) `ScaleDownStabilized`, when the stabilization window returned a value higher than the clamped recommendation. (3) `Synced`. `ScaleDownStabilized` is not a guard: it does not start, keep, or clear `deferredSince`, and it does not emit `ScalingDeferred`. A stabilized no-op with no guard ends a deferral exactly as a `Synced` no-op does.
+- `ScalingLimited` is set only when `ScalingActive` is `True` this sync, once the recommendation and the step cap are known and before the target write, so a write failure persists it the way `ScalingActive` is persisted. When `ScalingActive` is `False` this sync it is left as it is, including on the first sync where it may be absent. The no-signal fallback is held at `spec.replicas`, apart from the min/max bounds, and that clamp does not update `ScalingLimited`. An unparseable `targetRef.apiVersion` or a failed target read stops before a recommendation and leaves it as it is. It is informational, and it is not a printed column. Precedence, the constraint that bound the final write: (1) `ScaleDownLimit` when the step cap changed the write (`targetReplicas != recommendedReplicas`); (2) `TooFewReplicas` when the raw provider count, before clamping and before stabilization, is below `minReplicas`, else `TooManyReplicas` when that raw count is above `maxReplicas`; (3) `DesiredWithinRange`. Stabilization lifting the count afterwards does not clear a clamp reason. Only the step cap outranks the clamp. There is no `ScaleUpLimit` because scale-up is never capped.
+- A Custom scaler without `customProvider` whose target is also missing is read first, so `AbleToScale` is `TargetNotFound` and `ScalingActive` is not evaluated.
+- An unparseable `targetRef.apiVersion` or a failed target read writes `AbleToScale` and `status.observedGeneration` only. `ScalingActive`, `DecisionAvailable`, `ScalingLimited`, the replica counts, `deferredSince`, and `lastScaleTime` are left untouched.
+- A failed target write writes `AbleToScale`, `status.observedGeneration`, and the `ScalingActive`, `DecisionAvailable`, and `ScalingLimited` computed earlier in that sync. The replica counts, `deferredSince`, and `lastScaleTime` are left untouched.
+
+#### `AbleToScale` details
+
+A no-op while a guard still matches leaves `deferredSince` unchanged. If it is set, the condition stays `True` with that guard's reason and a message that nothing needs writing this sync, the guard is still active, and the deferral clock keeps running. If it is nil, the condition is `True`/`Synced` (`replica count is already at the step target`): a no-op does not start a deferral. The same branch runs when the stabilization window raised the recommendation and no guard holds: `deferredSince` is cleared, and the reason is `ScaleDownStabilized` instead of `Synced`.
+
+While a guard is holding a write that has not yet reached `deferTimeoutSeconds`, the condition is `True` with that guard's reason. The message is `holding N replicas (wanted M): <guard>; deferred since <time>, will apply after Ns`, or `never forced (deferTimeoutSeconds is 0)` when the timeout is 0.
 
 When the deadline has passed but a forced write already happened within the last sync period, the condition is `True` with the current guard reason and the message notes that the forced write is paced to one per sync period.
 
+When the timeout forces the write, the condition is `True`/`DeferralTimedOut` with the same message as the Warning event.
+
 Events, both on the `LLMScaler`:
 
-- **Normal `ScalingDeferred`** when a deferral starts, and again if the guard reason changes (rollout to settling is still one deferral, so `deferredSince` does not move). Not emitted on every sync, and not restarted by a forced write or by a no-op.
+- **Normal `ScalingDeferred`** when a deferral starts, and again if the guard reason differs from the previous `AbleToScale` reason (a previous `False`, `Synced`, `ScaleDownStabilized`, or `DeferralTimedOut` counts as changed). `ScaleDownStabilized` does not emit it. Rollout to settling is still one deferral, so `deferredSince` does not move. Not emitted on every sync, and not emitted by the forced write itself or by a no-op. After a `TargetNotFound` sync, a returning guard emits once.
 - **Warning `DeferralTimedOut`** when the timeout forces the write. The message names the guard reason, how long the action was deferred, and the `from -> to` replica change. The write is the one the guard held back, still capped by `maxStepReplicas`. `deferredSince` is kept when the guard still matches, so the next stuck step does not wait out the timeout again. While the guard still matches, forced writes are paced to one per sync period.
 
 ### Example
@@ -167,8 +198,8 @@ Only `decisions[].replicas.active` is read; every other field either identifies
 - **The CRD bounds still hold.** The count is clamped to `[minReplicas, maxReplicas]` and then goes through the same `scaleDown.stabilizationWindowSeconds` damping and `maxStepReplicas` pacing as any other recommendation. The server recommends; this operator keeps the rail. A decision of `0` is a real recommendation: with `minReplicas: 0` it scales the target to zero, otherwise it clamps up to `minReplicas`.
 - **`apiVersion` selects the schema.** The reply says how to read itself, and only `llmscaling.inference.x-k8s.io/v1alpha1` is understood; anything else is refused rather than parsed hopefully, since a later schema is free to reuse `replicas` for something that is not an absolute count.
 - **The reply is matched, not trusted.** `serviceId` is sent as a query parameter *and* checked against `decisions[].serviceId`, because what comes back is the server's choice — a decision for a service this scaler did not ask about must not be able to drive it. Exactly one decision must match; **more than one is an error**, the same rule (and the same reasoning) as a multi-series PromQL result. Set `customProvider.namespace` if the server reports the same `serviceId` in several namespaces.
-- **A failure holds the fleet, it never reads as zero.** A server that is down, a non-200, an unknown `apiVersion`, no matching decision, or a decision with no `replicas.active` all skip that sync and leave `spec.replicas` where it is — mirroring how an unevaluable PromQL query is handled.
-- **The outcome is on the status, not in the error log.** Each sync sets the `DecisionAvailable` condition: `True` (`DecisionReceived`) when a decision arrived, `False` (`DecisionUnavailable`) with the error as its message when replicas were held. Check it with `kubectl get llmscaler <name> -o jsonpath='{.status.conditions}'`.
+- **A failure holds the fleet at `spec.replicas`, apart from the min/max bounds, and never reads as zero.** A server that is down, a non-200, an unknown `apiVersion`, no matching decision, or a decision with no `replicas.active` all skip that sync. The fallback is still clamped to min/max and still runs through scale-down stabilization — mirroring how an unevaluable PromQL query is handled. `ScalingLimited` is left as it is.
+- **The outcome is on the status, not in the error log.** Every sync that reaches a recommendation sets `ScalingActive`, for both providers, and switching `metricProvider` overwrites it. `DecisionAvailable` mirrors it. Under Custom it is `True` (`DecisionReceived`, `decision server recommends N replicas`) when a decision arrived, `False` (`DecisionUnavailable`, `custom provider returned no decision: <err>`) when the replica count was held at `spec.replicas`, apart from the min/max bounds, and `False` (`InvalidSpec`, `spec.customProvider is not set`) when `customProvider` is missing. `AbleToScale` still describes the scale decision. Check it with `kubectl get llmscaler <name> -o jsonpath='{.status.conditions}'`.
 - **`scaleDown.deletionCostQuery` is ignored** under this provider: it is PromQL and `serverAddress` is now a decision server, so victim selection falls back to the newest-pod-first heuristic. The controller logs when it skips it.
 
 ```yaml
@@ -208,16 +239,16 @@ desired = clamp(desired, minReplicas, maxReplicas)
 Under `metricProvider: Custom` only the first line is replaced — `desired` is the decision server's `replicas.active`, and everything from the clamp onward is identical.
 
 - Computed off the target's **ready** replicas (actual serving capacity), so it does not compound on pods that were just requested but haven't started. A ready count of 0 falls back to `spec.replicas` for this ratio only; `status.currentReplicas` and the settle guard keep the raw count, so a fully-unready fleet is not treated as settled.
-- **A metric that cannot be measured is skipped, not read as zero.** A query that errors, returns an empty vector, returns more than one series, or returns `NaN`/`Inf` contributes nothing to that sync; when *every* metric is skipped the replica count is held where it is. This matters when mixing a metric that drives scale-up with a guardrail: `histogram_quantile` over a histogram with no observations in the window returns `NaN`, and were that read as 0 a guardrail could recommend `minReplicas` on its own whenever the primary metric happened to fail. For the same reason, do not append `or vector(0)` to a guardrail — reserve it for the metric that drives scale-up, where a genuine zero should scale in.
+- **A metric that cannot be measured is skipped, not read as zero.** A query that errors, returns an empty vector, returns more than one series, or returns `NaN`/`Inf` contributes nothing to that sync; when *every* metric is skipped the replica count is held at `spec.replicas`, apart from the min/max bounds (the clamp and scale-down stabilization still run, so `spec.replicas: 1` with `minReplicas: 3` writes `scaled 1 -> 3`). `ScalingLimited` is not updated on that sync. This matters when mixing a metric that drives scale-up with a guardrail: `histogram_quantile` over a histogram with no observations in the window returns `NaN`, and were that read as 0 a guardrail could recommend `minReplicas` on its own whenever the primary metric happened to fail. For the same reason, do not append `or vector(0)` to a guardrail — reserve it for the metric that drives scale-up, where a genuine zero should scale in.
 - The controller watches the `LLMScaler` with `GenerationChangedPredicate`, so its own status writes don't re-trigger reconciliation. Periodic evaluation is driven by `RequeueAfter`: `syncPeriod` on a normal sync, or sooner while a write is held and the deferral deadline (or the forced-write pace) is closer than that. The wait is never under one second.
 - **Rollout guard** (both directions): while a Deployment target is mid-rollout — the controller has not observed the latest spec, not every replica is on the new pod template, or old-template pods still exist — scaling is deferred. Changing `spec.replicas` in the middle of a rollout spreads that delta across both ReplicaSets, the one on the old template and the one on the new, so the guard holds scale-up and scale-down alike. New pods also start with cold KV caches that distort the metric average and would be mis-picked as scale-down victims.
 - **Scale Down**
-    - **Scale-down stabilization** (`spec.scaleDown.stabilizationWindowSeconds`, 0 = off): replicas are held at the highest recommendation seen within the window, so a brief metric dip doesn't shrink the fleet.
-    - **Scale-down step cap** (`spec.scaleDown.maxStepReplicas`, 0 = unlimited): at most this many replicas are removed per scale-down action, so a collapsed metric walks the fleet down (`10 → 8 → 6 → …` at `maxStepReplicas: 2`) instead of bursting from N straight to `minReplicas`. This is the knob for "don't throw away all the warm caches at once". Note it bounds the *size* of a step, not the interval between steps — that is the settle guard's job (see below).
+    - **Scale-down stabilization** (`spec.scaleDown.stabilizationWindowSeconds`, 0 = off): replicas are held at the highest recommendation seen within the window, so a brief metric dip doesn't shrink the fleet. When the window returns a value higher than this sync's clamped recommendation, `AbleToScale` is `True`/`ScaleDownStabilized` unless a guard hold or `DeferralTimedOut` wins. That reason is not a guard.
+    - **Scale-down step cap** (`spec.scaleDown.maxStepReplicas`, 0 = unlimited): at most this many replicas are removed per scale-down action, so a collapsed metric walks the fleet down (`10 → 8 → 6 → …` at `maxStepReplicas: 2`) instead of bursting from N straight to `minReplicas`. This is the knob for "don't throw away all the warm caches at once". Note it bounds the *size* of a step, not the interval between steps — that is the settle guard's job (see below). When the cap changes this sync's write, `ScalingLimited` is `True`/`ScaleDownLimit`. There is no `ScaleUpLimit`.
 - **Settle guard**: a scale-down waits until the target has absorbed the previous replica count (`status.readyReplicas == spec.replicas`), using the raw ready count. A missing count is 0, so a fully-unready fleet does not count as settled. Scale-up is not gated on this. A further check that `status.terminatingReplicas == 0` covers the drain window but is off by default; with it off, a pod leaves `readyReplicas` as soon as it has a deletion timestamp, and the guard only bridges the gap between the write and the workload controller reflecting it in status.
 - **Deferral timeout** (`spec.deferTimeoutSeconds`, default 600; `0` never forces): the guards above are otherwise unbounded, so a stuck rollout — progress deadline exceeded, a paused Deployment, a quota rejection, or pods stuck Pending — freezes the scaler in both directions, including the scale-down that would free capacity. Once a scale action has been held for this long, measured from `status.deferredSince`, the controller applies the same write the guard held back (still capped by `maxStepReplicas`) and emits a `DeferralTimedOut` warning. The clock keeps running across that write, across a change of guard reason, and across a no-op while a guard still matches, so a target that stays stuck steps at the normal sync pace instead of waiting out the timeout again. `deferredSince` is cleared only when a sync finds no guard matching (a normal write, or a no-op with no guard). A no-op does not start the clock, and a no-op while a guard still matches does not clear it. With `0` the guards may defer indefinitely. While a write is held and the timeout is non-zero, the next sync waits the earlier of `syncPeriod` and the time remaining until the deadline; a forced write that is only waiting out the one-per-sync-period pace waits the earlier of `syncPeriod` and the time left on that pace. Either wait is at least one second.
-- **Scale-up is immediate** — no scale-up stabilization window, so capacity is added as soon as the metric warrants it (the fast-up / slow-down shape). It stays bounded because `desired` is computed off *ready* replicas (no compounding) and clamped to `maxReplicas`. A scale-up rate cap for slow-starting pods is intentionally not implemented — vLLM pods are heavy, so a `1 → maxReplicas` jump can start several at once and briefly overshoot before they serve; add a step cap only if that overshoot actually hurts you.
-- **Scale-to-zero** (`minReplicas: 0`): an idle metric recommends `0` and the target is scaled all the way down. Waking back up works on both providers: under `Custom` the decision server hands back an absolute count, and under `Prometheus` the ratio is evaluated against a single-replica baseline (a fleet of zero has no per-replica measurement to scale off, so `ceil(value / target)` is used). A metric that cannot be evaluated while at zero (e.g. a per-pod query returning no series) still holds the fleet at zero rather than waking it.
+- **Scale-up is immediate** — no scale-up stabilization window and no scale-up step cap, so capacity is added as soon as the metric warrants it (the fast-up / slow-down shape) and `ScalingLimited` has no `ScaleUpLimit`. It stays bounded because `desired` is computed off *ready* replicas (no compounding) and clamped to `maxReplicas`. A scale-up rate cap for slow-starting pods is intentionally not implemented — vLLM pods are heavy, so a `1 → maxReplicas` jump can start several at once and briefly overshoot before they serve; add a step cap only if that overshoot actually hurts you.
+- **Scale-to-zero** (`minReplicas: 0`): an idle metric recommends `0` and the target is scaled all the way down. Waking back up works on both providers: under `Custom` the decision server hands back an absolute count, and under `Prometheus` the ratio is evaluated against a single-replica baseline (a fleet of zero has no per-replica measurement to scale off, so `ceil(value / target)` is used). A metric that cannot be evaluated while at zero (e.g. a per-pod query returning no series) holds the fleet at `spec.replicas`, apart from the min/max bounds — at zero, that stays zero — rather than waking it.
 
 ## Cache-aware scale-down
 
diff --git a/internal/controller/autoscaling/customprovider_test.go b/internal/controller/autoscaling/customprovider_test.go
index fc16894..53a25ba 100644
--- a/internal/controller/autoscaling/customprovider_test.go
+++ b/internal/controller/autoscaling/customprovider_test.go
@@ -24,6 +24,7 @@ import (
 	"strings"
 	"testing"
 
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/types"
 
 	autoscalingv1alpha1 "github.com/modelsphere/llm-operator/api/autoscaling/v1alpha1"
@@ -238,7 +239,9 @@ type recommendCustomFile struct {
 		AbsentCustomProvider bool   `json:"absentCustomProvider"`
 	} `json:"inputs"`
 	Expected struct {
-		Replicas int32 `json:"replicas"`
+		Replicas            int32  `json:"replicas"`
+		HoldReason          string `json:"holdReason"`
+		HoldMessageContains string `json:"holdMessageContains"`
 	} `json:"expected"`
 }
 
@@ -277,10 +280,24 @@ func TestRecommendReplicasCustomProvider(t *testing.T) {
 		key := types.NamespacedName{Namespace: "ns", Name: "s"}
 		// specReplicas is what "hold where it is" means. The files set it to the
 		// same figure as readyReplicas so a hold is not confused with a clamp.
-		got := r.recommendReplicas(context.Background(), scaler, key, in.ReadyReplicas, in.SpecReplicas)
+		got := r.recommendReplicas(context.Background(), scaler, key, in.ReadyReplicas, in.SpecReplicas).replicas
 		if got != tc.Expected.Replicas {
 			t.Fatalf("recommendReplicas = %d, want %d", got, tc.Expected.Replicas)
 		}
+		active := scalingActive(t, scaler)
+		if tc.Expected.HoldReason != "" {
+			if active.Status != metav1.ConditionFalse || active.Reason != tc.Expected.HoldReason {
+				t.Errorf("ScalingActive = %s/%s, want False/%s", active.Status, active.Reason, tc.Expected.HoldReason)
+			}
+		} else if active.Status != metav1.ConditionTrue || active.Reason != autoscalingv1alpha1.ReasonDecisionReceived {
+			t.Errorf("ScalingActive = %s/%s, want True/%s", active.Status, active.Reason, autoscalingv1alpha1.ReasonDecisionReceived)
+		} else if active.Message != fmt.Sprintf("decision server recommends %s replicas", in.Active) {
+			// The message names the server's count, before clamping.
+			t.Errorf("ScalingActive message = %q, want the raw decision", active.Message)
+		}
+		if sub := tc.Expected.HoldMessageContains; sub != "" && !strings.Contains(active.Message, sub) {
+			t.Errorf("ScalingActive message = %q, want it to contain %q", active.Message, sub)
+		}
 	})
 }
 
@@ -335,10 +352,16 @@ func TestRecommendReplicasDefaultProviderIsPrometheus(t *testing.T) {
 
 		r := &LLMScalerReconciler{}
 		key := types.NamespacedName{Namespace: "ns", Name: "s"}
-		got := r.recommendReplicas(context.Background(), scaler, key, tc.Inputs.ReadyReplicas, tc.Inputs.SpecReplicas)
+		got := r.recommendReplicas(context.Background(), scaler, key, tc.Inputs.ReadyReplicas, tc.Inputs.SpecReplicas).replicas
 		if got != tc.Expected.Replicas {
 			t.Errorf("recommendReplicas = %d, want %d", got, tc.Expected.Replicas)
 		}
+		active := scalingActive(t, scaler)
+		if active.Status != metav1.ConditionTrue || active.Reason != autoscalingv1alpha1.ReasonMetricsAvailable {
+			t.Errorf("ScalingActive = %+v, want True/%s", active, autoscalingv1alpha1.ReasonMetricsAvailable)
+		} else if !strings.Contains(active.Message, fmt.Sprintf("recommends %d replicas", tc.Expected.Replicas)) {
+			t.Errorf("ScalingActive message = %q, want the raw recommendation", active.Message)
+		}
 		if gotPath != tc.Expected.Path {
 			t.Errorf("path = %q, want %q", gotPath, tc.Expected.Path)
 		}
diff --git a/internal/controller/autoscaling/guards.go b/internal/controller/autoscaling/guards.go
index 3ff22a0..30fe13d 100644
--- a/internal/controller/autoscaling/guards.go
+++ b/internal/controller/autoscaling/guards.go
@@ -110,9 +110,9 @@ type ScaleIntent struct {
 
 // Guard decides whether a scale write must wait.
 // The first entry in guards whose Hold reports held supplies the
-// ScalingDeferred reason and message.
+// AbleToScale reason and message.
 type Guard interface {
-	// Reason is the ScalingDeferred condition reason used when Hold reports
+	// Reason is the AbleToScale condition reason used when Hold reports
 	// the guard is active.
 	Reason() string
 	// Hold reports whether this guard is holding the write back.
@@ -132,7 +132,7 @@ var guards = []Guard{rolloutGuard{}, settleGuard{}}
 // and on a no-op. Other kinds never hold.
 type rolloutGuard struct{}
 
-// Reason is the ScalingDeferred condition reason for an in-progress rollout.
+// Reason is the AbleToScale condition reason for an in-progress rollout.
 func (rolloutGuard) Reason() string { return autoscalingv1alpha1.ReasonRolloutInProgress }
 
 // Hold reports whether a Deployment rollout is in progress.
@@ -183,7 +183,7 @@ var checkTerminatingReplicas = false
 // check degrades to the readyReplicas condition alone even when gated on.
 type settleGuard struct{}
 
-// Reason is the ScalingDeferred condition reason for a scale-down that has
+// Reason is the AbleToScale condition reason for a scale-down that has
 // not settled.
 func (settleGuard) Reason() string { return autoscalingv1alpha1.ReasonScaleDownSettling }
 
@@ -209,7 +209,7 @@ func (settleGuard) Hold(s WorkloadState, in ScaleIntent) (bool, string) {
 // directions, and the settle guard holds scale-down until the raw ready count
 // is back at spec.
 type scaleDeferral struct {
-	// reason is the ScalingDeferred condition reason (RolloutInProgress or
+	// reason is the AbleToScale condition reason (RolloutInProgress or
 	// ScaleDownSettling), or "" when nothing defers.
 	reason string
 	// message is the human description of the guard, for the log and the condition.
diff --git a/internal/controller/autoscaling/llmscaler_casefile_test.go b/internal/controller/autoscaling/llmscaler_casefile_test.go
index 65c7d22..c793f58 100644
--- a/internal/controller/autoscaling/llmscaler_casefile_test.go
+++ b/internal/controller/autoscaling/llmscaler_casefile_test.go
@@ -110,6 +110,10 @@ type stepInput struct {
 	RestoreStatus  bool           `json:"restoreStatus"`
 	SkipReconcile  bool           `json:"skipReconcile"`
 	SnapshotStatus bool           `json:"snapshotStatus"`
+	DeleteDeploy   bool           `json:"deleteDeploy"`
+	APIVersion     string         `json:"apiVersion"`
+	MaxReplicas    *int32         `json:"maxReplicas"`
+	CloseServer    bool           `json:"closeServer"`
 }
 
 type condInput struct {
@@ -117,6 +121,9 @@ type condInput struct {
 	Reason                    string   `json:"reason"`
 	MessageContains           []string `json:"messageContains"`
 	ObservedGenerationCurrent bool     `json:"observedGenerationCurrent"`
+	ObservedGenerationStale   bool     `json:"observedGenerationStale"`
+	// Absent requires the condition to be missing. Other fields must be unset.
+	Absent bool `json:"absent"`
 }
 
 func (c condInput) expect() condExpect {
@@ -125,6 +132,8 @@ func (c condInput) expect() condExpect {
 		reason:                    c.Reason,
 		messageContains:           c.MessageContains,
 		observedGenerationCurrent: c.ObservedGenerationCurrent,
+		observedGenerationStale:   c.ObservedGenerationStale,
+		absent:                    c.Absent,
 	}
 }
 
@@ -138,35 +147,58 @@ func (e eventInput) expect() eventExpect {
 }
 
 type stepExpected struct {
-	Replicas      *int32          `json:"replicas"`
-	Desired       *int32          `json:"desired"`
-	Applied       *int32          `json:"applied"`
-	Current       *int32          `json:"current"`
-	DeferredSince sinceCheck      `json:"deferredSince"`
-	Condition     *condInput      `json:"condition"`
-	RequeueAfter  *cases.Duration `json:"requeueAfter"`
-	Events        []eventInput    `json:"events"`
-	NoMoreEvents  bool            `json:"noMoreEvents"`
-	ForcedWrite   *bool           `json:"forcedWrite"`
-	ForcedWriteAt *cases.Duration `json:"forcedWriteAt"`
+	Replicas                            *int32          `json:"replicas"`
+	Desired                             *int32          `json:"desired"`
+	Applied                             *int32          `json:"applied"`
+	Current                             *int32          `json:"current"`
+	DeferredSince                       sinceCheck      `json:"deferredSince"`
+	Condition                           *condInput      `json:"condition"`
+	RequeueAfter                        *cases.Duration `json:"requeueAfter"`
+	Events                              []eventInput    `json:"events"`
+	NoMoreEvents                        bool            `json:"noMoreEvents"`
+	ForcedWrite                         *bool           `json:"forcedWrite"`
+	ForcedWriteAt                       *cases.Duration `json:"forcedWriteAt"`
+	Active                              *condInput      `json:"active"`
+	Decision                            *condInput      `json:"decision"`
+	Limited                             *condInput      `json:"limited"`
+	ObservedGenerationCurrent           bool            `json:"observedGenerationCurrent"`
+	ConditionsObservedGenerationCurrent bool            `json:"conditionsObservedGenerationCurrent"`
+	GenerationGreaterThan               int64           `json:"generationGreaterThan"`
+	LastScaleTime                       string          `json:"lastScaleTime"`
 }
 
 func (e stepExpected) expect() stepExpect {
 	out := stepExpect{
-		replicas:      e.Replicas,
-		desired:       e.Desired,
-		applied:       e.Applied,
-		current:       e.Current,
-		deferredSince: e.DeferredSince.expect(),
-		requeueAfter:  durPtr(e.RequeueAfter),
-		noMoreEvents:  e.NoMoreEvents,
-		forcedWrite:   e.ForcedWrite,
-		forcedWriteAt: durPtr(e.ForcedWriteAt),
+		replicas:                            e.Replicas,
+		desired:                             e.Desired,
+		applied:                             e.Applied,
+		current:                             e.Current,
+		deferredSince:                       e.DeferredSince.expect(),
+		requeueAfter:                        durPtr(e.RequeueAfter),
+		noMoreEvents:                        e.NoMoreEvents,
+		forcedWrite:                         e.ForcedWrite,
+		forcedWriteAt:                       durPtr(e.ForcedWriteAt),
+		observedGenerationCurrent:           e.ObservedGenerationCurrent,
+		conditionsObservedGenerationCurrent: e.ConditionsObservedGenerationCurrent,
+		generationGreaterThan:               e.GenerationGreaterThan,
+		lastScaleTime:                       parseLastScale(e.LastScaleTime),
 	}
 	if e.Condition != nil {
 		cond := e.Condition.expect()
 		out.condition = &cond
 	}
+	if e.Active != nil {
+		active := e.Active.expect()
+		out.active = &active
+	}
+	if e.Decision != nil {
+		decision := e.Decision.expect()
+		out.decision = &decision
+	}
+	if e.Limited != nil {
+		limited := e.Limited.expect()
+		out.limited = &limited
+	}
 	if len(e.Events) > 0 {
 		out.events = make([]eventExpect, len(e.Events))
 		for i, ev := range e.Events {
@@ -186,6 +218,10 @@ func (s stepInput) step(exp stepExpected) scenarioStep {
 		restoreStatus:  s.RestoreStatus,
 		skipReconcile:  s.SkipReconcile,
 		snapshotStatus: s.SnapshotStatus,
+		deleteDeploy:   s.DeleteDeploy,
+		apiVersion:     s.APIVersion,
+		maxReplicas:    s.MaxReplicas,
+		closeServer:    s.CloseServer,
 		expect:         exp.expect(),
 	}
 	if s.Deploy != nil {
@@ -213,6 +249,7 @@ type scalerInputs struct {
 	CheckTerminating         *bool           `json:"checkTerminating"`
 	PlainReconciler          bool            `json:"plainReconciler"`
 	ExpectNilRecommendations bool            `json:"expectNilRecommendations"`
+	CloseServer              bool            `json:"closeServer"`
 	Steps                    []stepInput     `json:"steps"`
 }
 
@@ -247,6 +284,7 @@ func (c scalerCase) scenario() scalerScenario {
 		checkTerminating:         in.CheckTerminating,
 		plainReconciler:          in.PlainReconciler,
 		expectNilRecommendations: in.ExpectNilRecommendations,
+		closeServer:              in.CloseServer,
 		steps:                    steps,
 	}
 	if in.Deploy != nil {
@@ -274,29 +312,40 @@ type customReconcileFile struct {
 		StatusBy    string       `json:"statusBy"`
 	} `json:"inputs"`
 	Expected struct {
-		Replicas                int32  `json:"replicas"`
-		Desired                 *int32 `json:"desired"`
-		DecisionStatus          string `json:"decisionStatus"`
-		DecisionReason          string `json:"decisionReason"`
-		DecisionMessageNonEmpty bool   `json:"decisionMessageNonEmpty"`
+		Replicas                  int32      `json:"replicas"`
+		Desired                   *int32     `json:"desired"`
+		DecisionStatus            string     `json:"decisionStatus"`
+		DecisionReason            string     `json:"decisionReason"`
+		DecisionMessageNonEmpty   bool       `json:"decisionMessageNonEmpty"`
+		DecisionMessageContains   []string   `json:"decisionMessageContains"`
+		Active                    *condInput `json:"active"`
+		ObservedGenerationCurrent bool       `json:"observedGenerationCurrent"`
+		LastScaleTime             string     `json:"lastScaleTime"`
 	} `json:"expected"`
 }
 
 func runCustomReconcileFile(c customReconcileFile) {
 	exp := c.Expected
 	tc := customReconcileCase{
-		createBy:                c.Inputs.CreateBy,
-		deployBy:                c.Inputs.DeployBy,
-		closeServer:             c.Inputs.CloseServer,
-		closeBy:                 c.Inputs.CloseBy,
-		reconcileBy:             c.Inputs.ReconcileBy,
-		replicasBy:              c.Inputs.ReplicasBy,
-		wantReplicas:            exp.Replicas,
-		statusBy:                c.Inputs.StatusBy,
-		wantDesired:             exp.Desired,
-		decisionStatus:          metav1.ConditionStatus(exp.DecisionStatus),
-		decisionReason:          exp.DecisionReason,
-		decisionMessageNonEmpty: exp.DecisionMessageNonEmpty,
+		createBy:                  c.Inputs.CreateBy,
+		deployBy:                  c.Inputs.DeployBy,
+		closeServer:               c.Inputs.CloseServer,
+		closeBy:                   c.Inputs.CloseBy,
+		reconcileBy:               c.Inputs.ReconcileBy,
+		replicasBy:                c.Inputs.ReplicasBy,
+		wantReplicas:              exp.Replicas,
+		statusBy:                  c.Inputs.StatusBy,
+		wantDesired:               exp.Desired,
+		decisionStatus:            metav1.ConditionStatus(exp.DecisionStatus),
+		decisionReason:            exp.DecisionReason,
+		decisionMessageNonEmpty:   exp.DecisionMessageNonEmpty,
+		decisionMessageContains:   exp.DecisionMessageContains,
+		observedGenerationCurrent: exp.ObservedGenerationCurrent,
+		lastScaleTime:             parseLastScale(exp.LastScaleTime),
+	}
+	if exp.Active != nil {
+		active := exp.Active.expect()
+		tc.active = &active
 	}
 	if c.Inputs.Deploy != nil {
 		st := c.Inputs.Deploy.state()
diff --git a/internal/controller/autoscaling/llmscaler_controller.go b/internal/controller/autoscaling/llmscaler_controller.go
index 568dfc4..d149824 100644
--- a/internal/controller/autoscaling/llmscaler_controller.go
+++ b/internal/controller/autoscaling/llmscaler_controller.go
@@ -65,12 +65,19 @@ const (
 	deploymentKind = "Deployment"
 
 	// eventReasonScalingDeferred is the Normal event emitted when a scale action
-	// starts being held back, or the guard reason changes. It is not repeated on
-	// every sync.
+	// starts being held back, or the guard reason differs from the previous
+	// AbleToScale reason. A previous False, Synced, ScaleDownStabilized, or
+	// DeferralTimedOut counts as changed. It is not repeated on every sync,
+	// and ScaleDownStabilized does not emit it.
 	eventReasonScalingDeferred = "ScalingDeferred"
 	// eventReasonDeferralTimedOut is the Warning event emitted when the deferral
 	// timeout forces the write the guard was holding back.
 	eventReasonDeferralTimedOut = "DeferralTimedOut"
+
+	// scaleDownStabilizedMessage is HPA's AbleToScale text when the stabilization
+	// window keeps a higher recent recommendation. It is the message for
+	// ReasonScaleDownStabilized on every such sync, write or no-op.
+	scaleDownStabilizedMessage = "recent recommendations were higher than current one, applying the highest recent recommendation"
 )
 
 // scaleRecommendation is a timestamped desired-replica recommendation, retained
@@ -138,7 +145,11 @@ func (r *LLMScalerReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 	gv, err := schema.ParseGroupVersion(targetRef.APIVersion)
 	if err != nil {
 		logger.Error(err, "invalid apiVersion in targetRef")
-		return ctrl.Result{}, nil // Stop reconciling if spec is invalid
+		// Stop before a recommendation. ScalingActive, DecisionAvailable, and
+		// ScalingLimited are left as they are.
+		r.recordScaleFailure(ctx, &scaler, metav1.ConditionFalse, autoscalingv1alpha1.ReasonInvalidSpec,
+			fmt.Sprintf("targetRef.apiVersion %q does not parse: %s", targetRef.APIVersion, err.Error()))
+		return ctrl.Result{}, nil
 	}
 
 	// 1. Use unstructured to dynamically support Deployment, StatefulSet, or LeaderWorkerSet
@@ -159,9 +170,12 @@ func (r *LLMScalerReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 
 	if err != nil {
 		logger.Error(err, "unable to fetch target resource", "kind", targetRef.Kind, "name", targetRef.Name)
-		// Requeue since the target might be created later. deferredSince and
-		// ScalingDeferred are left as they are, so the deadline carries over
-		// once the target is readable again.
+		// Requeue since the target might be created later. ScalingActive,
+		// DecisionAvailable, ScalingLimited, deferredSince, and the replica
+		// counts are left as they are, so the deadline carries over once the
+		// target is readable again. AbleToScale is False with the read failure.
+		reason, msg := targetReadFailure(err, targetRef.Kind, targetRef.Name)
+		r.recordScaleFailure(ctx, &scaler, metav1.ConditionFalse, reason, msg)
 		return ctrl.Result{RequeueAfter: retryPeriod}, nil
 	}
 
@@ -187,25 +201,40 @@ func (r *LLMScalerReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 
 	// 3. Compute the recommendation: metrics, clamped to min/max, damped on the
 	// way down by the stabilization window. This is what we want, independent of
-	// how fast we are allowed to get there.
-	recommendedReplicas := r.recommendReplicas(ctx, &scaler, req.NamespacedName, specReplicas, metricReady)
+	// how fast we are allowed to get there. Both providers set ScalingActive
+	// here, before clamping; DecisionAvailable mirrors it. A missing signal is
+	// held at spec.replicas, apart from the min/max bounds, and ScalingLimited
+	// is left as it is.
+	rec := r.recommendReplicas(ctx, &scaler, req.NamespacedName, specReplicas, metricReady)
+	recommendedReplicas := rec.replicas
 
 	// 4. Execute Scale Action, rate-limited by maxStepReplicas. The cap belongs
 	// here rather than in the recommendation: it governs how far a single write
 	// may travel toward desiredReplicas, not what the right replica count is. Each
 	// sync moves one step closer, so the fleet converges on the recommendation
-	// over several periods instead of in one burst. Scale-up is never capped.
+	// over several periods instead of in one burst. Scale-up is never capped,
+	// so there is no ScaleUpLimit on ScalingLimited.
 	targetReplicas := scaleGuard(int32(specReplicas), recommendedReplicas, scaler.Spec.ScaleDown.MaxStepReplicas)
 	if targetReplicas != recommendedReplicas {
 		logger.Info("Scale-down step capped", "recommended", recommendedReplicas, "thisStep", targetReplicas, "maxStepReplicas", scaler.Spec.ScaleDown.MaxStepReplicas)
 	}
+	// ScalingLimited is fixed once the recommendation and the step cap are both
+	// known, and before the write, and only when ScalingActive is True. A later
+	// write failure persists it, the same way it persists ScalingActive. When
+	// ScalingActive is False, leave it alone, including when it has never been set.
+	if rec.signal {
+		limitedStatus, limitedReason, limitedMsg := scalingLimitedCondition(
+			rec.raw, scaler.Spec.MinReplicas, scaler.Spec.MaxReplicas,
+			recommendedReplicas, targetReplicas, scaler.Spec.ScaleDown.MaxStepReplicas)
+		setScalingLimitedCondition(&scaler, limitedStatus, limitedReason, limitedMsg)
+	}
 
 	// One deferral timeout covers every guard. deferredSince is set on the first
 	// sync that holds a write and kept across guard changes, no-ops while a
 	// guard still matches, and forced writes. It is cleared only when no guard
 	// matches. It lives in status, so the deadline survives an operator restart.
-	// applied is the target's spec.replicas after this sync; a failed target
-	// update returns before the status write.
+	// applied is the target's spec.replicas after this sync. A failed target
+	// update records AbleToScale and returns before replica counts are written.
 	now := r.now()
 	timeout := deferTimeout(&scaler)
 	deferral := evaluateGuards(state, ScaleIntent{From: state.Spec, To: targetReplicas})
@@ -217,20 +246,26 @@ func (r *LLMScalerReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 	paceRemaining := r.forcedWriteRemaining(req.NamespacedName, syncPeriod, now)
 	requeueAfter := syncPeriod
 
+	// AbleToScale=True precedence: a guard hold (the three cases below) and
+	// DeferralTimedOut (inside writeScaleTarget) describe the write and win;
+	// otherwise ScaleDownStabilized when the window raised the recommendation;
+	// otherwise Synced. ScaleDownStabilized is not a guard, so it does not
+	// change which branch runs or whether deferredSince moves.
 	switch {
 	case noop && (!guarded || scaler.Status.DeferredSince == nil):
 		// Nothing is being held back. A guard that matches on a no-op does not
-		// start a deferral, and a no-op with no guard ends one.
+		// start a deferral, and a no-op with no guard ends one. A stabilized
+		// no-op takes this same path: it ends a deferral and does not emit
+		// ScalingDeferred.
 		r.endDeferral(req.NamespacedName, &scaler)
-		setScalingDeferredCondition(&scaler, metav1.ConditionFalse, autoscalingv1alpha1.ReasonNotDeferred,
-			"replica count is already at the step target")
+		setSyncedOrStabilized(&scaler, rec.stabilized, "replica count is already at the step target")
 	case noop:
 		// A guard still matches and the clock is already running. There is
 		// nothing to write, so deferredSince stays and this sync is not holding
 		// a write: the next sync stays on syncPeriod.
 		logger.Info("No scale write this sync; deferral clock still running", "reason", deferral.message, "deferredSince", scaler.Status.DeferredSince.Time)
-		setScalingDeferredCondition(&scaler, metav1.ConditionTrue, deferral.reason,
-			scalingDeferredNoopMessage(deferral.message, scaler.Status.DeferredSince.Time, timeout))
+		setAbleToScaleCondition(&scaler, metav1.ConditionTrue, deferral.reason,
+			holdNoopMessage(deferral.message, scaler.Status.DeferredSince.Time, timeout))
 	case guarded && !pastDeferTimeout(scaler.Status.DeferredSince, timeout, now):
 		r.holdScaleDeferred(&scaler, deferral, int32(specReplicas), targetReplicas, timeout, now)
 		logger.Info("Deferring scaling", "reason", deferral.message, "current", specReplicas, "ready", readyReplicas, "target", targetReplicas)
@@ -239,18 +274,19 @@ func (r *LLMScalerReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 	case guarded && paceRemaining > 0:
 		// Deadline passed, but this process already forced a write within the
 		// last sync period. See lastForcedWrite.
-		msg := scalingDeferredPacedMessage(int32(specReplicas), targetReplicas, deferral.message, scaler.Status.DeferredSince.Time)
+		msg := holdPacedMessage(int32(specReplicas), targetReplicas, deferral.message, scaler.Status.DeferredSince.Time)
 		logger.Info("Pacing forced scale", "reason", deferral.message, "current", specReplicas, "target", targetReplicas, "retryAfter", paceRemaining)
-		if scalingDeferredReasonChanged(&scaler, deferral.reason) {
+		if holdReasonChanged(&scaler, deferral.reason) {
 			r.event(&scaler, corev1.EventTypeNormal, eventReasonScalingDeferred, msg)
 		}
-		setScalingDeferredCondition(&scaler, metav1.ConditionTrue, deferral.reason, msg)
+		setAbleToScaleCondition(&scaler, metav1.ConditionTrue, deferral.reason, msg)
 		requeueAfter = deferralRequeueAfter(syncPeriod, true, timeout, 0, paceRemaining)
 	default:
 		// A normal write (no guard) or a forced write the pace allows. A failed
 		// target update returns before any deferral state is recorded.
-		wrote, err := r.writeScaleTarget(ctx, &scaler, targetObj, req.NamespacedName, int32(specReplicas), targetReplicas, guarded, deferral, timeout, now)
+		wrote, err := r.writeScaleTarget(ctx, &scaler, targetObj, req.NamespacedName, int32(specReplicas), targetReplicas, guarded, rec.stabilized, deferral, timeout, now)
 		if err != nil {
+			r.recordTargetWriteFailure(ctx, &scaler, err)
 			return ctrl.Result{}, err
 		}
 		applied = wrote
@@ -261,6 +297,7 @@ func (r *LLMScalerReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 	scaler.Status.CurrentReplicas = int32(readyReplicas)
 	scaler.Status.DesiredReplicas = recommendedReplicas
 	scaler.Status.AppliedReplicas = applied
+	scaler.Status.ObservedGeneration = scaler.Generation
 	if err := r.Status().Update(ctx, &scaler); err != nil {
 		logger.Error(err, "failed to update scaler status")
 		return ctrl.Result{}, err
@@ -272,10 +309,13 @@ func (r *LLMScalerReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 // writeScaleTarget writes targetReplicas onto the workload. forced is set when
 // a guard matched and the deadline has passed: the deferral clock is kept and
 // the write is paced from now. Otherwise no guard matched, and the deferral
-// ends. The pace is recorded only after the target update succeeds, so a
-// failed write can be retried immediately; the status update that follows may
-// still fail, which is what the pace is there to absorb.
-func (r *LLMScalerReconciler) writeScaleTarget(ctx context.Context, scaler *autoscalingv1alpha1.LLMScaler, targetObj *unstructured.Unstructured, key types.NamespacedName, specReplicas, targetReplicas int32, forced bool, deferral scaleDeferral, timeout time.Duration, now time.Time) (int32, error) {
+// ends. stabilized selects ScaleDownStabilized over Synced on that unforced
+// write; DeferralTimedOut still wins when forced is set. The pace is recorded
+// only after the target update succeeds, so a failed write can be retried
+// immediately; the status update that follows may still fail, which is what
+// the pace is there to absorb. ScalingLimited was already set by the caller
+// when this sync had a signal, and a failed write leaves it in place.
+func (r *LLMScalerReconciler) writeScaleTarget(ctx context.Context, scaler *autoscalingv1alpha1.LLMScaler, targetObj *unstructured.Unstructured, key types.NamespacedName, specReplicas, targetReplicas int32, forced, stabilized bool, deferral scaleDeferral, timeout time.Duration, now time.Time) (int32, error) {
 	logger := logf.FromContext(ctx)
 	targetRef := scaler.Spec.TargetRef
 
@@ -319,6 +359,9 @@ func (r *LLMScalerReconciler) writeScaleTarget(ctx context.Context, scaler *auto
 		logger.Error(err, "failed to update target resource")
 		return 0, err
 	}
+	// lastScaleTime moves only when the target accepted the new replica count.
+	stamped := metav1.NewTime(now)
+	scaler.Status.LastScaleTime = &stamped
 
 	// Pace the descent: pin the fleet at what we just wrote for one
 	// stabilization window, and drop the recommendations that were measured
@@ -335,11 +378,10 @@ func (r *LLMScalerReconciler) writeScaleTarget(ctx context.Context, scaler *auto
 		// wait out the timeout again.
 		r.recordForcedWrite(key, now)
 		r.event(scaler, corev1.EventTypeWarning, eventReasonDeferralTimedOut, timedOutEvent)
-		setScalingDeferredCondition(scaler, metav1.ConditionFalse, autoscalingv1alpha1.ReasonDeferralTimedOut, timedOutEvent)
+		setAbleToScaleCondition(scaler, metav1.ConditionTrue, autoscalingv1alpha1.ReasonDeferralTimedOut, timedOutEvent)
 	} else {
 		r.endDeferral(key, scaler)
-		setScalingDeferredCondition(scaler, metav1.ConditionFalse, autoscalingv1alpha1.ReasonNotDeferred,
-			fmt.Sprintf("scaled %d -> %d", specReplicas, targetReplicas))
+		setSyncedOrStabilized(scaler, stabilized, scaledMessage(specReplicas, targetReplicas))
 	}
 	return targetReplicas, nil
 }
@@ -475,29 +517,36 @@ func (r *LLMScalerReconciler) holdScaleDeferred(scaler *autoscalingv1alpha1.LLMS
 		scaler.Status.DeferredSince = &stamped
 	}
 	// Read the previous reason before overwriting the condition.
-	reasonChanged := scalingDeferredReasonChanged(scaler, deferral.reason)
-	msg := scalingDeferredMessage(specReplicas, targetReplicas, deferral.message, scaler.Status.DeferredSince.Time, timeout)
-	setScalingDeferredCondition(scaler, metav1.ConditionTrue, deferral.reason, msg)
+	reasonChanged := holdReasonChanged(scaler, deferral.reason)
+	msg := holdMessage(specReplicas, targetReplicas, deferral.message, scaler.Status.DeferredSince.Time, timeout)
+	setAbleToScaleCondition(scaler, metav1.ConditionTrue, deferral.reason, msg)
 	if entering || reasonChanged {
 		r.event(scaler, corev1.EventTypeNormal, eventReasonScalingDeferred, msg)
 	}
 }
 
-// scalingDeferredReasonChanged reports whether the ScalingDeferred condition is
-// not already True with this guard reason. The caller uses it to avoid emitting
-// the same deferral event on every sync.
-func scalingDeferredReasonChanged(scaler *autoscalingv1alpha1.LLMScaler, reason string) bool {
-	prev := meta.FindStatusCondition(scaler.Status.Conditions, autoscalingv1alpha1.ConditionScalingDeferred)
+// holdReasonChanged reports whether the Normal deferral event should fire for
+// this guard reason. It is true unless AbleToScale is already True with that
+// reason. A previous False, Synced, ScaleDownStabilized, or DeferralTimedOut
+// counts as changed. ScaleDownStabilized is not a guard reason, so a guard
+// that starts after it emits once, the same way it would after Synced.
+// A TargetNotFound sync sets AbleToScale False, so a returning guard emits once.
+func holdReasonChanged(scaler *autoscalingv1alpha1.LLMScaler, reason string) bool {
+	prev := meta.FindStatusCondition(scaler.Status.Conditions, autoscalingv1alpha1.ConditionAbleToScale)
 	if prev == nil || prev.Status != metav1.ConditionTrue {
 		return true
 	}
+	switch prev.Reason {
+	case autoscalingv1alpha1.ReasonSynced, autoscalingv1alpha1.ReasonScaleDownStabilized, autoscalingv1alpha1.ReasonDeferralTimedOut:
+		return true
+	}
 	return prev.Reason != reason
 }
 
-// scalingDeferredMessage describes the scale action being held back. "wanted"
+// holdMessage describes the scale action being held back. "wanted"
 // is the step-capped write, which is what the guard is holding, not the uncapped
 // recommendation (that stays on status.desiredReplicas).
-func scalingDeferredMessage(specReplicas, targetReplicas int32, guardMessage string, since time.Time, timeout time.Duration) string {
+func holdMessage(specReplicas, targetReplicas int32, guardMessage string, since time.Time, timeout time.Duration) string {
 	limit := "never forced (deferTimeoutSeconds is 0)"
 	if timeout > 0 {
 		limit = fmt.Sprintf("will apply after %ds", int64(timeout/time.Second))
@@ -506,10 +555,10 @@ func scalingDeferredMessage(specReplicas, targetReplicas int32, guardMessage str
 		specReplicas, targetReplicas, guardMessage, since.UTC().Format(time.RFC3339), limit)
 }
 
-// scalingDeferredNoopMessage is the condition message when a guard still
+// holdNoopMessage is the condition message when a guard still
 // matches but the step target is already spec.replicas. The clock keeps
 // running; the sync does not start or clear deferredSince.
-func scalingDeferredNoopMessage(guardMessage string, since time.Time, timeout time.Duration) string {
+func holdNoopMessage(guardMessage string, since time.Time, timeout time.Duration) string {
 	limit := "never forced (deferTimeoutSeconds is 0)"
 	if timeout > 0 {
 		limit = fmt.Sprintf("will apply after %ds", int64(timeout/time.Second))
@@ -518,16 +567,39 @@ func scalingDeferredNoopMessage(guardMessage string, since time.Time, timeout ti
 		guardMessage, since.UTC().Format(time.RFC3339), limit)
 }
 
-// scalingDeferredPacedMessage is the condition message when the deadline has
+// holdPacedMessage is the condition message when the deadline has
 // passed but another forced write must wait out the sync period.
-func scalingDeferredPacedMessage(specReplicas, targetReplicas int32, guardMessage string, since time.Time) string {
+func holdPacedMessage(specReplicas, targetReplicas int32, guardMessage string, since time.Time) string {
 	return fmt.Sprintf("holding %d replicas (wanted %d): %s; deferred since %s, forced write paced to one per sync period",
 		specReplicas, targetReplicas, guardMessage, since.UTC().Format(time.RFC3339))
 }
 
-func setScalingDeferredCondition(scaler *autoscalingv1alpha1.LLMScaler, status metav1.ConditionStatus, reason, msg string) {
+// setSyncedOrStabilized sets AbleToScale when no guard hold and no
+// DeferralTimedOut describe this sync.
+//
+// Precedence among AbleToScale=True reasons, per sync:
+//  1. A guard hold (RolloutInProgress or ScaleDownSettling), in every hold
+//     case: deferring a write, a no-op while a deferral is already running,
+//     and pacing a forced write. DeferralTimedOut, when the timeout forces
+//     the write, is in this tier too. Those callers set the condition
+//     themselves and do not call this.
+//  2. ScaleDownStabilized, when the stabilization window returned a value
+//     higher than the clamped recommendation. It is not a guard. The caller
+//     has already applied the same deferral handling it would for Synced.
+//     This does not start, keep, or clear deferredSince, and it does not
+//     emit ScalingDeferred.
+//  3. Synced.
+func setSyncedOrStabilized(scaler *autoscalingv1alpha1.LLMScaler, stabilized bool, syncedMsg string) {
+	if stabilized {
+		setAbleToScaleCondition(scaler, metav1.ConditionTrue, autoscalingv1alpha1.ReasonScaleDownStabilized, scaleDownStabilizedMessage)
+		return
+	}
+	setAbleToScaleCondition(scaler, metav1.ConditionTrue, autoscalingv1alpha1.ReasonSynced, syncedMsg)
+}
+
+func setAbleToScaleCondition(scaler *autoscalingv1alpha1.LLMScaler, status metav1.ConditionStatus, reason, msg string) {
 	meta.SetStatusCondition(&scaler.Status.Conditions, metav1.Condition{
-		Type:               autoscalingv1alpha1.ConditionScalingDeferred,
+		Type:               autoscalingv1alpha1.ConditionAbleToScale,
 		Status:             status,
 		Reason:             reason,
 		Message:            msg,
@@ -535,6 +607,89 @@ func setScalingDeferredCondition(scaler *autoscalingv1alpha1.LLMScaler, status m
 	})
 }
 
+func setScalingLimitedCondition(scaler *autoscalingv1alpha1.LLMScaler, status metav1.ConditionStatus, reason, msg string) {
+	meta.SetStatusCondition(&scaler.Status.Conditions, metav1.Condition{
+		Type:               autoscalingv1alpha1.ConditionScalingLimited,
+		Status:             status,
+		Reason:             reason,
+		Message:            msg,
+		ObservedGeneration: scaler.Generation,
+	})
+}
+
+// scalingLimitedCondition is the HPA ScalingLimited condition for one sync
+// whose ScalingActive is True. The caller invokes it only then, after the step
+// cap and before the target write.
+//
+// Precedence, the constraint that bound the final write:
+//  1. ScaleDownLimit when scaleGuard changed the write (target != recommended).
+//     There is no ScaleUpLimit: scale-up is never capped.
+//  2. TooFewReplicas when raw, the provider count before clamping and before
+//     stabilization, is below minReplicas.
+//  3. TooManyReplicas when raw is above maxReplicas.
+//  4. DesiredWithinRange otherwise.
+//
+// A raw count that is both below min and above max (minReplicas > maxReplicas)
+// reports TooFewReplicas. Stabilization lifting the count afterwards does not
+// clear a clamp reason; only the step cap outranks it.
+func scalingLimitedCondition(raw, minReplicas, maxReplicas, recommended, target, maxStep int32) (metav1.ConditionStatus, string, string) {
+	if target != recommended {
+		return metav1.ConditionTrue, autoscalingv1alpha1.ReasonScaleDownLimit,
+			fmt.Sprintf("the desired replica count is decreasing faster than the maximum scale rate (maxStepReplicas %d)", maxStep)
+	}
+	if raw < minReplicas {
+		return metav1.ConditionTrue, autoscalingv1alpha1.ReasonTooFewReplicas,
+			"the desired replica count is less than the minimum replica count"
+	}
+	if raw > maxReplicas {
+		return metav1.ConditionTrue, autoscalingv1alpha1.ReasonTooManyReplicas,
+			"the desired replica count is more than the maximum replica count"
+	}
+	return metav1.ConditionFalse, autoscalingv1alpha1.ReasonDesiredWithinRange,
+		"the desired count is within the acceptable range"
+}
+
+// scaledMessage is the AbleToScale text for a normal write.
+func scaledMessage(from, to int32) string {
+	return fmt.Sprintf("scaled %d -> %d", from, to)
+}
+
+// targetReadFailure is the AbleToScale reason for a target Get that failed.
+func targetReadFailure(err error, kind, name string) (string, string) {
+	if apierrors.IsNotFound(err) {
+		return autoscalingv1alpha1.ReasonTargetNotFound, fmt.Sprintf("target %s %q not found", kind, name)
+	}
+	return autoscalingv1alpha1.ReasonTargetUnreadable, fmt.Sprintf("could not get target %s %q: %s", kind, name, err.Error())
+}
+
+// recordScaleFailure sets AbleToScale and writes status.observedGeneration.
+// Callers use it when the sync stops before a recommendation (an unparseable
+// apiVersion, or a target Get that failed) and when the target write failed.
+// ScalingActive, DecisionAvailable, ScalingLimited, the replica counts,
+// deferredSince, and lastScaleTime are left as they stand. A target write
+// failure therefore keeps the ScalingActive and ScalingLimited computed
+// earlier in that sync. A status-write error is logged; the caller keeps its
+// original result.
+func (r *LLMScalerReconciler) recordScaleFailure(ctx context.Context, scaler *autoscalingv1alpha1.LLMScaler, status metav1.ConditionStatus, reason, msg string) {
+	logger := logf.FromContext(ctx)
+	setAbleToScaleCondition(scaler, status, reason, msg)
+	scaler.Status.ObservedGeneration = scaler.Generation
+	if err := r.Status().Update(ctx, scaler); err != nil {
+		logger.Error(err, "failed to update scaler status")
+	}
+}
+
+// recordTargetWriteFailure records AbleToScale False with TargetWriteFailed
+// after spec.replicas could not be written. The ScalingActive computed earlier
+// in this sync is kept, and so is the ScalingLimited computed with the
+// recommendation before the write. DecisionAvailable mirrors that ScalingActive.
+// deferredSince, the replica counts, and lastScaleTime are left as they stand.
+// The status write is best-effort.
+func (r *LLMScalerReconciler) recordTargetWriteFailure(ctx context.Context, scaler *autoscalingv1alpha1.LLMScaler, writeErr error) {
+	r.recordScaleFailure(ctx, scaler, metav1.ConditionFalse, autoscalingv1alpha1.ReasonTargetWriteFailed,
+		fmt.Sprintf("could not write spec.replicas: %s", writeErr.Error()))
+}
+
 func (r *LLMScalerReconciler) event(obj client.Object, eventType, reason, msg string) {
 	if r.Recorder == nil {
 		return
@@ -575,21 +730,32 @@ func (r *LLMScalerReconciler) stabilizeDesired(key types.NamespacedName, desired
 // recommendReplicas turns the metric source into the replica count this scaler
 // wants, clamped to [minReplicas, maxReplicas] and damped on the way down by the
 // stabilization window. This is the target, not the next write — the caller
-// rate-limits how fast to approach it . Stabilization can
-// never lower a scale-up, since it only ever returns the window maximum, but it
-// is still entered on one: it has to record every recommendation, because the
-// peak it later holds at is itself a scale-up.
+// rate-limits how fast to approach it. Stabilization can never lower a
+// scale-up, since it only ever returns the window maximum, but it is still
+// entered on one: it has to record every recommendation, because the peak it
+// later holds at is itself a scale-up. stabilized reports whether that window
+// returned a value higher than the clamped recommendation. The replica count
+// itself is unchanged by surfacing the flag.
 //
 // Only the first step differs between providers: Prometheus derives the count
 // from per-replica measurements, Custom is handed the count outright. Both feed
 // the same clamping and damping below, so a scaler behaves identically once the
-// number exists.
-func (r *LLMScalerReconciler) recommendReplicas(ctx context.Context, scaler *autoscalingv1alpha1.LLMScaler, key types.NamespacedName, specReplicas, readyReplicas int64) int32 {
+// number exists. Both set ScalingActive before that clamping; DecisionAvailable
+// mirrors it. The count in a Prometheus MetricsAvailable message is the raw
+// maximum, not the clamped or stabilized value returned here.
+//
+// When the provider has no usable signal, the count is held at spec.replicas,
+// apart from the min/max bounds (the clamp below still runs, and so does
+// stabilization). signal is false, ScalingActive is False, and the caller
+// leaves ScalingLimited alone. raw is the provider count before that clamp
+// and is meaningful only when signal is true.
+func (r *LLMScalerReconciler) recommendReplicas(ctx context.Context, scaler *autoscalingv1alpha1.LLMScaler, key types.NamespacedName, specReplicas, readyReplicas int64) replicaRecommendation {
 	logger := logf.FromContext(ctx)
 
 	// Use the metric recommendation when at least one metric was evaluated — it
 	// may legitimately be 0 for an idle target (clamped up to minReplicas below).
-	// Only when every metric failed to fetch do we hold current replicas.
+	// Only when every metric failed do we hold at spec.replicas, apart from
+	// the min/max bounds.
 	var (
 		maxDesiredReplicas int32
 		haveMetric         bool
@@ -601,11 +767,15 @@ func (r *LLMScalerReconciler) recommendReplicas(ctx context.Context, scaler *aut
 	}
 
 	desiredReplicas := int32(specReplicas)
+	var raw int32
 	if haveMetric {
+		raw = maxDesiredReplicas
 		desiredReplicas = maxDesiredReplicas
 	}
 
-	// Ensure desired is within min/max boundaries
+	// Ensure desired is within min/max boundaries. Clamp detection for
+	// ScalingLimited compares raw, the provider count before this clamp and
+	// before stabilization, not the value after it.
 	if desiredReplicas < scaler.Spec.MinReplicas {
 		desiredReplicas = scaler.Spec.MinReplicas
 	}
@@ -616,15 +786,40 @@ func (r *LLMScalerReconciler) recommendReplicas(ctx context.Context, scaler *aut
 	// Scale-down stabilization: hold at the highest recommendation seen within
 	// the window so a brief metric dip doesn't shrink the fleet. Scale-up stays
 	// immediate, since the current recommendation is then the window's max.
+	// raised is the ScaleDownStabilized signal: the window returned a value
+	// higher than the clamped recommendation. Replica selection is unchanged.
+	raised := false
 	if window := time.Duration(scaler.Spec.ScaleDown.StabilizationWindowSeconds) * time.Second; window > 0 {
 		stabilized := r.stabilizeDesired(key, desiredReplicas, window, r.now())
-		if stabilized != desiredReplicas {
+		if stabilized > desiredReplicas {
+			raised = true
 			logger.Info("Scale-down stabilized", "raw", desiredReplicas, "stabilized", stabilized, "windowSeconds", scaler.Spec.ScaleDown.StabilizationWindowSeconds)
 		}
 		desiredReplicas = stabilized
 	}
 
-	return desiredReplicas
+	return replicaRecommendation{
+		replicas:   desiredReplicas,
+		raw:        raw,
+		signal:     haveMetric,
+		stabilized: raised,
+	}
+}
+
+// replicaRecommendation is one sync's replica target.
+// replicas is after the min/max clamp and scale-down stabilization. That is
+// status.desiredReplicas, still before the maxStepReplicas cap.
+// raw is the provider count before either of those. It is meaningful only
+// when signal is true, and ScalingLimited compares it with min/max.
+// signal is false when this sync has no usable scaling signal. The caller
+// then leaves ScalingLimited as it is.
+// stabilized is true when the stabilization window returned a value higher
+// than the clamped recommendation.
+type replicaRecommendation struct {
+	replicas   int32
+	raw        int32
+	signal     bool
+	stabilized bool
 }
 
 // scaleGuard limits a single scale-down write to maxStep replicas below
@@ -687,34 +882,41 @@ func (r *LLMScalerReconciler) forgetRecommendations(key types.NamespacedName) {
 // computeDesiredFromMetrics evaluates each metric's PromQL query and returns the
 // maximum desired replica count (HPA-style: ceil(readyReplicas * value/target))
 // and whether any metric was successfully evaluated.
+//
+// It always sets ScalingActive, and DecisionAvailable mirrors it. True /
+// MetricsAvailable names how many metrics evaluated and recommends the raw
+// maximum: the value returned here, before the caller clamps it or runs
+// scale-down stabilization. False / DecisionUnavailable names prometheus and
+// the last error.
 func (r *LLMScalerReconciler) computeDesiredFromMetrics(ctx context.Context, scaler *autoscalingv1alpha1.LLMScaler, readyReplicas int64) (int32, bool) {
 	logger := logf.FromContext(ctx)
 	var maxDesired int32
-	haveMetric := false
+	evaluated := 0
+	var lastErr error
 
 	for _, metric := range scaler.Spec.Metrics {
 		currentValue, err := queryPrometheusScalar(scaler.Spec.ServerAddress, metric.Query, scaler.Spec.ServerHeaders)
 		if err != nil {
+			lastErr = err
 			logger.Error(err, "failed to fetch metric", "name", metric.Name, "query", metric.Query)
 			continue
 		}
 
-		// A non-finite sample is a missing measurement, not a zero, and must not
-		// count as a successful evaluation. histogram_quantile over a histogram
-		// with no observations in the window returns NaN — routine for a latency
-		// guardrail whenever that traffic class is idle — and a division by a
-		// zero-valued series returns +Inf. Both convert to a large negative
-		// int32, so they lose the max() below silently while still setting
-		// haveMetric: a NaN guardrail alongside a failing primary metric leaves
-		// maxDesired at 0, which clamps the whole fleet to minReplicas.
+		// A non-finite sample is a missing measurement, not a zero. histogram_quantile
+		// over a histogram with no observations in the window returns NaN — routine
+		// for an idle latency guardrail — and a division by a zero-valued series
+		// returns +Inf. Skip it here, before evaluated is incremented: only finite
+		// samples count. A non-finite result is not counted.
 		if math.IsNaN(currentValue) || math.IsInf(currentValue, 0) {
-			logger.Error(fmt.Errorf("query returned %v", currentValue), "ignoring non-finite metric value",
+			lastErr = fmt.Errorf("query returned %v", currentValue)
+			logger.Error(lastErr, "ignoring non-finite metric value",
 				"name", metric.Name, "query", metric.Query)
 			continue
 		}
 
 		targetValue, err := parseTargetValue(metric.Target)
 		if err != nil {
+			lastErr = err
 			logger.Error(err, "invalid target value", "target", metric.Target)
 			continue
 		}
@@ -732,12 +934,30 @@ func (r *LLMScalerReconciler) computeDesiredFromMetrics(ctx context.Context, sca
 		metricDesired := int32(math.Ceil(float64(max(readyReplicas, 1)) * ratio))
 		logger.Info("Metric calculation", "name", metric.Name, "query", metric.Query, "current", currentValue, "target", targetValue, "calculatedDesired", metricDesired)
 
-		haveMetric = true
+		evaluated++
 		if metricDesired > maxDesired {
 			maxDesired = metricDesired
 		}
 	}
-	return maxDesired, haveMetric
+	if evaluated == 0 {
+		setDecisionCondition(scaler, metav1.ConditionFalse, autoscalingv1alpha1.ReasonDecisionUnavailable,
+			noPrometheusMetricMessage(lastErr))
+		return maxDesired, false
+	}
+	// N is maxDesired, the raw maximum before clamping and stabilization.
+	setDecisionCondition(scaler, metav1.ConditionTrue, autoscalingv1alpha1.ReasonMetricsAvailable,
+		fmt.Sprintf("evaluated %d of %d metrics; recommends %d replicas", evaluated, len(scaler.Spec.Metrics), maxDesired))
+	return maxDesired, true
+}
+
+// noPrometheusMetricMessage is the ScalingActive text when the Prometheus
+// provider evaluated nothing. The prefix names the source. lastErr is the last
+// query failure, non-finite sample, or target-parse error, when there was one.
+func noPrometheusMetricMessage(lastErr error) string {
+	if lastErr == nil {
+		return "no prometheus metric could be evaluated"
+	}
+	return fmt.Sprintf("no prometheus metric could be evaluated: %s", lastErr.Error())
 }
 
 // desiredFromCustomProvider fetches the decision server's replica
@@ -750,9 +970,11 @@ func (r *LLMScalerReconciler) computeDesiredFromMetrics(ctx context.Context, sca
 // apply upstream: the CRD bounds are this operator's rail, not the server's.
 //
 // A failure returns false rather than 0, so a decision server that is down or
-// answering in a schema we don't know holds the fleet where it is instead of
-// collapsing it to minReplicas — the same rule the Prometheus path applies to a
-// query that cannot be evaluated.
+// answering in a schema we don't know is not read as a recommendation of zero.
+// The count is held at spec.replicas, apart from the min/max bounds — the same
+// rule the Prometheus path applies to a query that cannot be evaluated.
+// ScalingActive says why, on every return. DecisionAvailable mirrors it.
+// ScalingLimited is left as it is.
 func (r *LLMScalerReconciler) desiredFromCustomProvider(ctx context.Context, scaler *autoscalingv1alpha1.LLMScaler) (int32, bool) {
 	logger := logf.FromContext(ctx)
 
@@ -762,6 +984,8 @@ func (r *LLMScalerReconciler) desiredFromCustomProvider(ctx context.Context, sca
 		// the cluster predates the validation rule.
 		logger.Error(fmt.Errorf("spec.customProvider is not set"),
 			"Could not query the custom metric provider", "metricProvider", scaler.Spec.MetricProvider)
+		setDecisionCondition(scaler, metav1.ConditionFalse, autoscalingv1alpha1.ReasonInvalidSpec,
+			"spec.customProvider is not set")
 		return 0, false
 	}
 
@@ -772,7 +996,8 @@ func (r *LLMScalerReconciler) desiredFromCustomProvider(ctx context.Context, sca
 		// service, so no error-level stack trace; the condition carries it.
 		logger.Info("No decision from the custom metric provider; holding replicas",
 			"serverAddress", scaler.Spec.ServerAddress, "serviceId", provider.ServiceID, "error", err.Error())
-		setDecisionCondition(scaler, metav1.ConditionFalse, autoscalingv1alpha1.ReasonDecisionUnavailable, err.Error())
+		setDecisionCondition(scaler, metav1.ConditionFalse, autoscalingv1alpha1.ReasonDecisionUnavailable,
+			fmt.Sprintf("custom provider returned no decision: %s", err.Error()))
 		return 0, false
 	}
 
@@ -782,14 +1007,22 @@ func (r *LLMScalerReconciler) desiredFromCustomProvider(ctx context.Context, sca
 	return replicas, true
 }
 
+// setDecisionCondition writes ScalingActive and the deprecated
+// DecisionAvailable together, with the same status, reason, message, and
+// observedGeneration.
 func setDecisionCondition(scaler *autoscalingv1alpha1.LLMScaler, status metav1.ConditionStatus, reason, msg string) {
-	meta.SetStatusCondition(&scaler.Status.Conditions, metav1.Condition{
-		Type:               autoscalingv1alpha1.ConditionDecisionAvailable,
-		Status:             status,
-		Reason:             reason,
-		Message:            msg,
-		ObservedGeneration: scaler.Generation,
-	})
+	for _, condType := range []string{
+		autoscalingv1alpha1.ConditionScalingActive,
+		autoscalingv1alpha1.ConditionDecisionAvailable, //nolint:staticcheck // deprecated mirror of ScalingActive, still written
+	} {
+		meta.SetStatusCondition(&scaler.Status.Conditions, metav1.Condition{
+			Type:               condType,
+			Status:             status,
+			Reason:             reason,
+			Message:            msg,
+			ObservedGeneration: scaler.Generation,
+		})
+	}
 }
 
 // markColdestPodsForDeletion biases the ReplicaSet toward removing the
@@ -923,7 +1156,9 @@ func promInstantQuery(serverAddress, promQL string, headers map[string]string) (
 	defer func() { _ = resp.Body.Close() }()
 
 	if resp.StatusCode != http.StatusOK {
-		body, _ := io.ReadAll(resp.Body)
+		// Cap the body the way the decision client does. The error is quoted
+		// on ScalingActive, and an error page can be large.
+		body, _ := io.ReadAll(io.LimitReader(resp.Body, 1024))
 		return nil, fmt.Errorf("prometheus returned status %d: %s", resp.StatusCode, string(body))
 	}
 
diff --git a/internal/controller/autoscaling/llmscaler_controller_test.go b/internal/controller/autoscaling/llmscaler_controller_test.go
index fc0d495..cd104ac 100644
--- a/internal/controller/autoscaling/llmscaler_controller_test.go
+++ b/internal/controller/autoscaling/llmscaler_controller_test.go
@@ -45,12 +45,16 @@ var _ = Describe("LLMScaler Controller", func() {
 			ginkgocases.Entries("testdata/controller/settle-guard", scalerDesc))
 		DescribeTable("stabilization and max step", runScalerCase,
 			ginkgocases.Entries("testdata/controller/stabilization-and-step", scalerDesc))
+		DescribeTable("scaling limited", runScalerCase,
+			ginkgocases.Entries("testdata/controller/scaling-limited", scalerDesc))
 		DescribeTable("deferral timeout", runScalerCase,
 			ginkgocases.Entries("testdata/controller/deferral-timeout", scalerDesc))
 		DescribeTable("deferral status", runScalerCase,
 			ginkgocases.Entries("testdata/controller/deferral-status", scalerDesc))
 		DescribeTable("forced-write pacing", runScalerCase,
 			ginkgocases.Entries("testdata/controller/forced-write-pacing", scalerDesc))
+		DescribeTable("condition status", runScalerCase,
+			ginkgocases.Entries("testdata/controller/condition-status", scalerDesc))
 
 		for _, f := range cases.MustLoad[deferDefaultFile]("testdata/controller/crd-default") {
 			tc := f.Case
diff --git a/internal/controller/autoscaling/llmscaler_helpers_test.go b/internal/controller/autoscaling/llmscaler_helpers_test.go
index 8f8916c..2da62b2 100644
--- a/internal/controller/autoscaling/llmscaler_helpers_test.go
+++ b/internal/controller/autoscaling/llmscaler_helpers_test.go
@@ -17,6 +17,7 @@ limitations under the License.
 package controller
 
 import (
+	"bytes"
 	"context"
 	"fmt"
 	"net/http"
@@ -303,21 +304,68 @@ type promScalarFile struct {
 	Description string `json:"description,omitempty"`
 	Inputs      struct {
 		Result string `json:"result"`
+		// Status, when set, is a non-200 reply. ErrorBodyBytes is the body
+		// length; a marker is written at offset 1024 so a 1 KiB cap drops it.
+		Status         int `json:"status"`
+		ErrorBodyBytes int `json:"errorBodyBytes"`
 	} `json:"inputs"`
 	Expected struct {
 		Value         float64  `json:"value"`
 		ErrorContains []string `json:"errorContains"`
+		// TruncatedBodyBytes is the exact length of the body quoted in the
+		// error. The quoted bytes are 'A', and the marker past that offset
+		// must be absent. That error is what ScalingActive quotes.
+		TruncatedBodyBytes int `json:"truncatedBodyBytes"`
 	} `json:"expected"`
 }
 
 func TestQueryPrometheusScalar(t *testing.T) {
 	cases.Run(t, "testdata/helpers/query-prometheus-scalar", func(t *testing.T, tc promScalarFile) {
+		const pastLimit = "PAST-THE-LIMIT"
+		var errorBody []byte
+		if tc.Inputs.Status != 0 {
+			if tc.Inputs.Status < 100 || tc.Inputs.Status > 999 {
+				t.Fatalf("status %d", tc.Inputs.Status)
+			}
+			if tc.Inputs.ErrorBodyBytes <= len(pastLimit)+1024 {
+				t.Fatalf("errorBodyBytes %d must extend past 1 KiB", tc.Inputs.ErrorBodyBytes)
+			}
+			errorBody = bytes.Repeat([]byte{'A'}, tc.Inputs.ErrorBodyBytes)
+			copy(errorBody[1024:], pastLimit)
+		} else if tc.Inputs.ErrorBodyBytes != 0 {
+			t.Fatal("errorBodyBytes requires status")
+		}
 		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+			if tc.Inputs.Status != 0 {
+				w.WriteHeader(tc.Inputs.Status)
+				_, _ = w.Write(errorBody)
+				return
+			}
 			_, _ = fmt.Fprintf(w, `{"status":"success","data":{"result":%s}}`, tc.Inputs.Result)
 		}))
 		defer srv.Close()
 
 		got, err := queryPrometheusScalar(srv.URL, "some_query", nil)
+		if tc.Expected.TruncatedBodyBytes > 0 {
+			if err == nil {
+				t.Fatal("expected a truncated non-200 error")
+			}
+			prefix := fmt.Sprintf("prometheus returned status %d: ", tc.Inputs.Status)
+			rest, ok := strings.CutPrefix(err.Error(), prefix)
+			if !ok {
+				t.Fatalf("error = %q, want prefix %q", err, prefix)
+			}
+			want := strings.Repeat("A", tc.Expected.TruncatedBodyBytes)
+			if rest != want {
+				t.Fatalf("quoted body length %d, want %d of 'A' and not %s", len(rest), tc.Expected.TruncatedBodyBytes, pastLimit)
+			}
+			if strings.Contains(err.Error(), pastLimit) {
+				t.Fatalf("error quotes the body past 1 KiB: %q", err)
+			}
+			if len(tc.Expected.ErrorContains) == 0 {
+				return
+			}
+		}
 		if len(tc.Expected.ErrorContains) == 0 {
 			if err != nil {
 				t.Fatalf("unexpected error: %v", err)
@@ -389,6 +437,24 @@ func TestComputeDesiredFromMetrics(t *testing.T) {
 		if desired != tc.Expected.Desired {
 			t.Errorf("desired = %d, want %d", desired, tc.Expected.Desired)
 		}
+		active := scalingActive(t, scaler)
+		if !tc.Expected.Have {
+			if active.Status != metav1.ConditionFalse || active.Reason != autoscalingv1alpha1.ReasonDecisionUnavailable {
+				t.Errorf("ScalingActive = %s/%s, want False/%s", active.Status, active.Reason, autoscalingv1alpha1.ReasonDecisionUnavailable)
+			}
+			if !strings.Contains(active.Message, "no prometheus metric could be evaluated") {
+				t.Errorf("ScalingActive message = %q, want it to name prometheus", active.Message)
+			}
+		} else {
+			if active.Status != metav1.ConditionTrue || active.Reason != autoscalingv1alpha1.ReasonMetricsAvailable {
+				t.Errorf("ScalingActive = %s/%s, want True/%s", active.Status, active.Reason, autoscalingv1alpha1.ReasonMetricsAvailable)
+			}
+			// The message names the raw maximum, which this helper returns before clamping.
+			want := fmt.Sprintf("recommends %d replicas", desired)
+			if !strings.Contains(active.Message, want) || !strings.Contains(active.Message, "evaluated 1 of 1 metrics") {
+				t.Errorf("ScalingActive message = %q, want it to contain %q and the evaluation count", active.Message, want)
+			}
+		}
 	})
 }
 
diff --git a/internal/controller/autoscaling/llmscaler_scenario_test.go b/internal/controller/autoscaling/llmscaler_scenario_test.go
index df4fc37..30823d4 100644
--- a/internal/controller/autoscaling/llmscaler_scenario_test.go
+++ b/internal/controller/autoscaling/llmscaler_scenario_test.go
@@ -146,33 +146,79 @@ type scenarioStep struct {
 	restoreStatus  bool
 	skipReconcile  bool
 	snapshotStatus bool
+	deleteDeploy   bool
+	apiVersion     string
+	maxReplicas    *int32
+	closeServer    bool
 	expect         stepExpect
 }
 
+// lastScaleExpect says how a step checks status.lastScaleTime. The zero value
+// leaves the field unchecked. set means this sync wrote it (and, when the
+// step reconciled on the fake clock, that it equals that instant). unset
+// means nil. unchanged means equal to the value from before the reconcile.
+type lastScaleExpect int
+
+const (
+	lastScaleSkip lastScaleExpect = iota
+	lastScaleSet
+	lastScaleUnset
+	lastScaleUnchanged
+)
+
+func parseLastScale(s string) lastScaleExpect {
+	switch s {
+	case "":
+		return lastScaleSkip
+	case "set":
+		return lastScaleSet
+	case "unset":
+		return lastScaleUnset
+	case "unchanged":
+		return lastScaleUnchanged
+	default:
+		Fail(fmt.Sprintf("lastScaleTime %q", s))
+		return lastScaleSkip
+	}
+}
+
 // stepExpect is the assertions for one step. Nil pointers and the zero
 // sinceExpect are skipped, so a step only states what that beat checked.
 type stepExpect struct {
-	replicas      *int32
-	desired       *int32
-	applied       *int32
-	current       *int32
-	deferredSince sinceExpect
-	condition     *condExpect
-	requeueAfter  *time.Duration
-	events        []eventExpect
-	noMoreEvents  bool
-	forcedWrite   *bool
-	forcedWriteAt *time.Duration
-}
-
-// condExpect is the ScalingDeferred condition. messageContains are substrings
-// that must all appear in the message. observedGenerationCurrent requires
-// the condition's ObservedGeneration to equal the scaler's generation.
+	replicas                            *int32
+	desired                             *int32
+	applied                             *int32
+	current                             *int32
+	deferredSince                       sinceExpect
+	condition                           *condExpect
+	requeueAfter                        *time.Duration
+	events                              []eventExpect
+	noMoreEvents                        bool
+	forcedWrite                         *bool
+	forcedWriteAt                       *time.Duration
+	active                              *condExpect
+	decision                            *condExpect
+	limited                             *condExpect
+	observedGenerationCurrent           bool
+	conditionsObservedGenerationCurrent bool
+	generationGreaterThan               int64
+	lastScaleTime                       lastScaleExpect
+}
+
+// condExpect is one status condition. messageContains are substrings that
+// must all appear in the message. observedGenerationCurrent requires the
+// condition's ObservedGeneration to equal the scaler's generation.
 type condExpect struct {
 	status                    metav1.ConditionStatus
 	reason                    string
 	messageContains           []string
 	observedGenerationCurrent bool
+	// observedGenerationStale requires ObservedGeneration to differ from the
+	// scaler's generation: a later sync left a condition written earlier alone.
+	observedGenerationStale bool
+	// absent requires the condition to be missing. The other fields must be
+	// unset; a present condition fails the step.
+	absent bool
 }
 
 // eventExpect is one event in the order the recorder received it.
@@ -196,6 +242,7 @@ type scalerScenario struct {
 	checkTerminating         *bool
 	plainReconciler          bool
 	expectNilRecommendations bool
+	closeServer              bool
 	steps                    []scenarioStep
 }
 
@@ -510,6 +557,9 @@ func runScalerScenario(sc scalerScenario) {
 	if sc.expectNilRecommendations {
 		Expect(run.r.recommendations).To(BeNil())
 	}
+	if sc.closeServer {
+		f.server.Close()
+	}
 	for _, step := range sc.steps {
 		runScenarioStep(run, step)
 	}
@@ -536,8 +586,24 @@ func runScenarioStep(run *scenarioRun, step scenarioStep) {
 	if step.restoreStatus {
 		restoreScalerStatus(f.ctx, f.scaler, run.held)
 	}
+	if step.deleteDeploy {
+		deleteDeployment(f.ctx, f.deploy)
+	}
+	if step.apiVersion != "" {
+		setTargetAPIVersion(f.ctx, f.scaler, step.apiVersion)
+	}
+	if step.maxReplicas != nil {
+		patchMaxReplicas(f.ctx, f.scaler, *step.maxReplicas)
+	}
+	if step.closeServer {
+		f.server.Close()
+	}
+	var prevLastScale *metav1.Time
+	if step.expect.lastScaleTime == lastScaleUnchanged {
+		prevLastScale = scalerLastScaleTime(f.ctx, f.scaler)
+	}
 	if step.skipReconcile {
-		assertStep(run, step)
+		assertStep(run, step, prevLastScale)
 		return
 	}
 	if run.clk != nil {
@@ -546,7 +612,7 @@ func runScenarioStep(run *scenarioRun, step scenarioStep) {
 	var err error
 	run.result, err = run.r.Reconcile(f.ctx, reconcile.Request{NamespacedName: f.scaler})
 	Expect(err).NotTo(HaveOccurred())
-	assertStep(run, step)
+	assertStep(run, step, prevLastScale)
 	if step.snapshotStatus {
 		run.held = snapshotScalerStatus(f.ctx, f.scaler)
 	}
@@ -566,12 +632,12 @@ func restoreScalerStatus(ctx context.Context, nn types.NamespacedName, held *aut
 	Expect(k8sClient.Status().Update(ctx, scaler)).To(Succeed())
 }
 
-func assertStep(run *scenarioRun, step scenarioStep) {
+func assertStep(run *scenarioRun, step scenarioStep, prevLastScale *metav1.Time) {
 	exp := step.expect
 	if exp.replicas != nil {
 		Expect(deploymentReplicas(run.fix.ctx, run.fix.deploy)).To(Equal(*exp.replicas))
 	}
-	assertScalerStatus(run, exp)
+	assertScalerStatus(run, step, prevLastScale)
 	if exp.requeueAfter != nil {
 		Expect(run.result.RequeueAfter).To(Equal(*exp.requeueAfter))
 	}
@@ -579,9 +645,13 @@ func assertStep(run *scenarioRun, step scenarioStep) {
 	assertForcedWrite(run, exp)
 }
 
-func assertScalerStatus(run *scenarioRun, exp stepExpect) {
+func assertScalerStatus(run *scenarioRun, step scenarioStep, prevLastScale *metav1.Time) {
+	exp := step.expect
 	if exp.desired == nil && exp.applied == nil && exp.current == nil &&
-		exp.deferredSince.kind == sinceUnchecked && exp.condition == nil {
+		exp.deferredSince.kind == sinceUnchecked && exp.condition == nil &&
+		exp.active == nil && exp.decision == nil && exp.limited == nil &&
+		!exp.observedGenerationCurrent && !exp.conditionsObservedGenerationCurrent &&
+		exp.generationGreaterThan == 0 && exp.lastScaleTime == lastScaleSkip {
 		return
 	}
 	scaler := &autoscalingv1alpha1.LLMScaler{}
@@ -597,8 +667,32 @@ func assertScalerStatus(run *scenarioRun, exp stepExpect) {
 	}
 	assertDeferredSince(scaler, exp.deferredSince, run.seed)
 	if exp.condition != nil {
-		assertCondition(scaler, *exp.condition)
+		assertCondition(scaler, autoscalingv1alpha1.ConditionAbleToScale, *exp.condition)
+	}
+	if exp.active != nil {
+		assertCondition(scaler, autoscalingv1alpha1.ConditionScalingActive, *exp.active)
 	}
+	if exp.decision != nil {
+		assertCondition(scaler, autoscalingv1alpha1.ConditionScalingActive, *exp.decision)
+	}
+	expectDecisionMirrorsActive(scaler)
+	if exp.limited != nil {
+		assertCondition(scaler, autoscalingv1alpha1.ConditionScalingLimited, *exp.limited)
+	}
+	if exp.observedGenerationCurrent {
+		Expect(scaler.Status.ObservedGeneration).To(Equal(scaler.Generation))
+	}
+	if exp.generationGreaterThan > 0 {
+		Expect(scaler.Generation).To(BeNumerically(">", exp.generationGreaterThan))
+	}
+	if exp.conditionsObservedGenerationCurrent {
+		Expect(scaler.Status.Conditions).NotTo(BeEmpty())
+		for i := range scaler.Status.Conditions {
+			Expect(scaler.Status.Conditions[i].ObservedGeneration).To(Equal(scaler.Generation),
+				"condition %s observedGeneration", scaler.Status.Conditions[i].Type)
+		}
+	}
+	assertLastScaleTime(scaler.Status.LastScaleTime, exp.lastScaleTime, prevLastScale, deferralStart.Add(step.at), run.clk != nil && !step.skipReconcile)
 }
 
 func assertDeferredSince(scaler *autoscalingv1alpha1.LLMScaler, exp sinceExpect, seed *time.Duration) {
@@ -619,8 +713,17 @@ func assertDeferredSince(scaler *autoscalingv1alpha1.LLMScaler, exp sinceExpect,
 	}
 }
 
-func assertCondition(scaler *autoscalingv1alpha1.LLMScaler, exp condExpect) {
-	cond := scalingDeferredCondition(scaler)
+func assertCondition(scaler *autoscalingv1alpha1.LLMScaler, condType string, exp condExpect) {
+	cond := meta.FindStatusCondition(scaler.Status.Conditions, condType)
+	if exp.absent {
+		if exp.status != "" || exp.reason != "" || len(exp.messageContains) > 0 ||
+			exp.observedGenerationCurrent || exp.observedGenerationStale {
+			Fail("absent condition also sets fields")
+		}
+		Expect(cond).To(BeNil())
+		return
+	}
+	Expect(cond).NotTo(BeNil())
 	if exp.status != "" {
 		Expect(cond.Status).To(Equal(exp.status))
 	}
@@ -634,9 +737,38 @@ func assertCondition(scaler *autoscalingv1alpha1.LLMScaler, exp condExpect) {
 		}
 		Expect(cond.Message).To(ContainSubstring(sub))
 	}
+	if exp.observedGenerationCurrent && exp.observedGenerationStale {
+		Fail("observedGenerationCurrent and observedGenerationStale are both set")
+	}
 	if exp.observedGenerationCurrent {
 		Expect(cond.ObservedGeneration).To(Equal(scaler.Generation))
 	}
+	if exp.observedGenerationStale {
+		Expect(cond.ObservedGeneration).NotTo(Equal(scaler.Generation))
+	}
+}
+
+func assertLastScaleTime(got *metav1.Time, exp lastScaleExpect, prev *metav1.Time, when time.Time, checkWhen bool) {
+	switch exp {
+	case lastScaleSkip:
+		return
+	case lastScaleUnset:
+		Expect(got).To(BeNil())
+	case lastScaleSet:
+		Expect(got).NotTo(BeNil())
+		if checkWhen {
+			Expect(got.Time).To(BeTemporally("==", when))
+		}
+	case lastScaleUnchanged:
+		if prev == nil {
+			Expect(got).To(BeNil())
+			return
+		}
+		Expect(got).NotTo(BeNil())
+		Expect(got.Time).To(BeTemporally("==", prev.Time))
+	default:
+		Fail(fmt.Sprintf("unknown lastScaleTime check %d", exp))
+	}
 }
 
 func assertEvents(run *scenarioRun, exp stepExpect) {
@@ -688,28 +820,55 @@ func newScalerReconciler(clk *testingclock.FakeClock, rec events.EventRecorder)
 	}
 }
 
-func scalingDeferredCondition(scaler *autoscalingv1alpha1.LLMScaler) *metav1.Condition {
-	cond := meta.FindStatusCondition(scaler.Status.Conditions, autoscalingv1alpha1.ConditionScalingDeferred)
-	Expect(cond).NotTo(BeNil())
-	return cond
+func deleteDeployment(ctx context.Context, nn types.NamespacedName) {
+	deploy := &appsv1.Deployment{}
+	Expect(k8sClient.Get(ctx, nn, deploy)).To(Succeed())
+	Expect(k8sClient.Delete(ctx, deploy)).To(Succeed())
+}
+
+func patchMaxReplicas(ctx context.Context, nn types.NamespacedName, maxReplicas int32) {
+	scaler := &autoscalingv1alpha1.LLMScaler{}
+	Expect(k8sClient.Get(ctx, nn, scaler)).To(Succeed())
+	scaler.Spec.MaxReplicas = maxReplicas
+	Expect(k8sClient.Update(ctx, scaler)).To(Succeed())
+}
+
+func setTargetAPIVersion(ctx context.Context, nn types.NamespacedName, apiVersion string) {
+	scaler := &autoscalingv1alpha1.LLMScaler{}
+	Expect(k8sClient.Get(ctx, nn, scaler)).To(Succeed())
+	scaler.Spec.TargetRef.APIVersion = apiVersion
+	Expect(k8sClient.Update(ctx, scaler)).To(Succeed())
+}
+
+func scalerLastScaleTime(ctx context.Context, nn types.NamespacedName) *metav1.Time {
+	scaler := &autoscalingv1alpha1.LLMScaler{}
+	Expect(k8sClient.Get(ctx, nn, scaler)).To(Succeed())
+	if scaler.Status.LastScaleTime == nil {
+		return nil
+	}
+	return scaler.Status.LastScaleTime.DeepCopy()
 }
 
 // customReconcileCase drives one decision-server reconcile. The *By fields are
 // By texts for each phase; empty strings skip the label.
 type customReconcileCase struct {
-	createBy                string
-	deploy                  *deployState
-	deployBy                string
-	closeServer             bool
-	closeBy                 string
-	reconcileBy             string
-	replicasBy              string
-	wantReplicas            int32
-	statusBy                string
-	wantDesired             *int32
-	decisionStatus          metav1.ConditionStatus
-	decisionReason          string
-	decisionMessageNonEmpty bool
+	createBy                  string
+	deploy                    *deployState
+	deployBy                  string
+	closeServer               bool
+	closeBy                   string
+	reconcileBy               string
+	replicasBy                string
+	wantReplicas              int32
+	statusBy                  string
+	wantDesired               *int32
+	decisionStatus            metav1.ConditionStatus
+	decisionReason            string
+	decisionMessageNonEmpty   bool
+	decisionMessageContains   []string
+	active                    *condExpect
+	observedGenerationCurrent bool
+	lastScaleTime             lastScaleExpect
 }
 
 func runCustomProviderReconcile(tc customReconcileCase) {
@@ -745,7 +904,10 @@ func runCustomProviderReconcile(tc customReconcileCase) {
 	}
 	Expect(deploymentReplicas(f.ctx, f.deploy)).To(Equal(tc.wantReplicas))
 
-	if tc.wantDesired == nil && tc.decisionStatus == "" {
+	needStatus := tc.wantDesired != nil || tc.decisionStatus != "" || tc.active != nil ||
+		tc.observedGenerationCurrent || tc.lastScaleTime != lastScaleSkip ||
+		len(tc.decisionMessageContains) > 0
+	if !needStatus {
 		return
 	}
 	if tc.statusBy != "" {
@@ -756,18 +918,50 @@ func runCustomProviderReconcile(tc customReconcileCase) {
 	if tc.wantDesired != nil {
 		Expect(scaler.Status.DesiredReplicas).To(Equal(*tc.wantDesired))
 	}
-	if tc.decisionStatus == "" {
-		return
+	if tc.observedGenerationCurrent {
+		Expect(scaler.Status.ObservedGeneration).To(Equal(scaler.Generation))
 	}
-	cond := meta.FindStatusCondition(scaler.Status.Conditions, autoscalingv1alpha1.ConditionDecisionAvailable)
-	Expect(cond).NotTo(BeNil())
-	Expect(cond.Status).To(Equal(tc.decisionStatus))
-	if tc.decisionReason != "" {
-		Expect(cond.Reason).To(Equal(tc.decisionReason))
+	assertLastScaleTime(scaler.Status.LastScaleTime, tc.lastScaleTime, nil, time.Time{}, false)
+	var active *metav1.Condition
+	if tc.decisionStatus != "" || len(tc.decisionMessageContains) > 0 {
+		active = meta.FindStatusCondition(scaler.Status.Conditions, autoscalingv1alpha1.ConditionScalingActive)
+		Expect(active).NotTo(BeNil())
 	}
-	if tc.decisionMessageNonEmpty {
-		Expect(cond.Message).NotTo(BeEmpty())
+	if tc.decisionStatus != "" {
+		Expect(active.Status).To(Equal(tc.decisionStatus))
+		if tc.decisionReason != "" {
+			Expect(active.Reason).To(Equal(tc.decisionReason))
+		}
+		if tc.decisionMessageNonEmpty {
+			Expect(active.Message).NotTo(BeEmpty())
+		}
+	}
+	for _, sub := range tc.decisionMessageContains {
+		if sub == "" {
+			Fail("decisionMessageContains entry is empty")
+		}
+		Expect(active.Message).To(ContainSubstring(sub))
+	}
+	if tc.active != nil {
+		assertCondition(scaler, autoscalingv1alpha1.ConditionScalingActive, *tc.active)
+	}
+	expectDecisionMirrorsActive(scaler)
+}
+
+// expectDecisionMirrorsActive checks that the deprecated DecisionAvailable
+// condition matches ScalingActive whenever either one is present.
+func expectDecisionMirrorsActive(scaler *autoscalingv1alpha1.LLMScaler) {
+	active := meta.FindStatusCondition(scaler.Status.Conditions, autoscalingv1alpha1.ConditionScalingActive)
+	decision := meta.FindStatusCondition(scaler.Status.Conditions, autoscalingv1alpha1.ConditionDecisionAvailable) //nolint:staticcheck // deprecated mirror of ScalingActive, still written
+	if active == nil && decision == nil {
+		return
 	}
+	Expect(active).NotTo(BeNil())
+	Expect(decision).NotTo(BeNil())
+	Expect(decision.Status).To(Equal(active.Status))
+	Expect(decision.Reason).To(Equal(active.Reason))
+	Expect(decision.Message).To(Equal(active.Message))
+	Expect(decision.ObservedGeneration).To(Equal(active.ObservedGeneration))
 }
 
 // customAdmissionCase submits one scaler the CRD should reject.
diff --git a/internal/controller/autoscaling/llmscaler_status_test.go b/internal/controller/autoscaling/llmscaler_status_test.go
new file mode 100644
index 0000000..f249314
--- /dev/null
+++ b/internal/controller/autoscaling/llmscaler_status_test.go
@@ -0,0 +1,500 @@
+/*
+Copyright 2026.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package controller
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+	"time"
+
+	appsv1 "k8s.io/api/apps/v1"
+	corev1 "k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/meta"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/types"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+	"sigs.k8s.io/controller-runtime/pkg/client/fake"
+	"sigs.k8s.io/controller-runtime/pkg/client/interceptor"
+	"sigs.k8s.io/controller-runtime/pkg/reconcile"
+
+	autoscalingv1alpha1 "github.com/modelsphere/llm-operator/api/autoscaling/v1alpha1"
+)
+
+// TestTargetWriteFailedRecordsAbleToScale covers the path envtest cannot force:
+// the target update returns an error. AbleToScale records TargetWriteFailed,
+// and observedGeneration is recorded. The deferral and the replica counts
+// already in status are left alone, and the original error is returned.
+// ScalingActive from this sync is kept.
+func TestTargetWriteFailedRecordsAbleToScale(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		_, _ = fmt.Fprintf(w, `{"status":"success","data":{"result":[{"value":[0,"%s"]}]}}`, "0.85")
+	}))
+	defer srv.Close()
+
+	deferred := metav1.NewTime(time.Date(2026, 3, 1, 12, 0, 0, 0, time.UTC))
+	scaler := prometheusScaler(srv.URL)
+	scaler.Status = autoscalingv1alpha1.LLMScalerStatus{
+		CurrentReplicas: 4,
+		DesiredReplicas: 4,
+		AppliedReplicas: 4,
+		DeferredSince:   &deferred,
+	}
+	meta.SetStatusCondition(&scaler.Status.Conditions, metav1.Condition{
+		Type:               autoscalingv1alpha1.ConditionAbleToScale,
+		Status:             metav1.ConditionTrue,
+		Reason:             autoscalingv1alpha1.ReasonRolloutInProgress,
+		Message:            "seeded",
+		ObservedGeneration: 2,
+	})
+
+	scheme := statusScheme(t)
+	c := fake.NewClientBuilder().
+		WithScheme(scheme).
+		WithObjects(rolledDeployment(), scaler).
+		WithStatusSubresource(&autoscalingv1alpha1.LLMScaler{}).
+		WithInterceptorFuncs(interceptor.Funcs{
+			Update: func(ctx context.Context, c client.WithWatch, obj client.Object, opts ...client.UpdateOption) error {
+				if _, ok := obj.(*unstructured.Unstructured); ok {
+					return fmt.Errorf("injected write failure")
+				}
+				return c.Update(ctx, obj, opts...)
+			},
+		}).
+		Build()
+
+	result, err := (&LLMScalerReconciler{Client: c, Scheme: scheme}).Reconcile(context.Background(), reconcile.Request{
+		NamespacedName: types.NamespacedName{Namespace: scaler.Namespace, Name: scaler.Name},
+	})
+	if err == nil || !strings.Contains(err.Error(), "injected write failure") {
+		t.Fatalf("Reconcile error = %v, want the injected write failure", err)
+	}
+	if result.RequeueAfter != 0 {
+		t.Errorf("RequeueAfter = %s, want 0", result.RequeueAfter)
+	}
+
+	got := &autoscalingv1alpha1.LLMScaler{}
+	if err := c.Get(context.Background(), client.ObjectKeyFromObject(scaler), got); err != nil {
+		t.Fatal(err)
+	}
+	if got.Generation == 0 {
+		t.Fatal("generation = 0, the fixture did not stick")
+	}
+	if got.Status.ObservedGeneration != got.Generation {
+		t.Errorf("observedGeneration = %d, want generation %d", got.Status.ObservedGeneration, got.Generation)
+	}
+	if got.Status.LastScaleTime != nil {
+		t.Errorf("lastScaleTime = %s, want unset", got.Status.LastScaleTime.Time)
+	}
+	if got.Status.CurrentReplicas != 4 || got.Status.DesiredReplicas != 4 || got.Status.AppliedReplicas != 4 {
+		t.Errorf("replicas current/desired/applied = %d/%d/%d, want 4/4/4",
+			got.Status.CurrentReplicas, got.Status.DesiredReplicas, got.Status.AppliedReplicas)
+	}
+	if got.Status.DeferredSince == nil || !got.Status.DeferredSince.Time.Equal(deferred.Time) {
+		t.Errorf("deferredSince = %v, want %s", got.Status.DeferredSince, deferred.Time)
+	}
+	able := meta.FindStatusCondition(got.Status.Conditions, autoscalingv1alpha1.ConditionAbleToScale)
+	if able == nil {
+		t.Fatal("AbleToScale condition missing")
+	}
+	if able.Status != metav1.ConditionFalse || able.Reason != autoscalingv1alpha1.ReasonTargetWriteFailed {
+		t.Errorf("AbleToScale = %s/%s, want False/%s", able.Status, able.Reason, autoscalingv1alpha1.ReasonTargetWriteFailed)
+	}
+	if !strings.Contains(able.Message, "injected write failure") {
+		t.Errorf("AbleToScale message = %q, want the injected error", able.Message)
+	}
+	if able.ObservedGeneration != got.Generation {
+		t.Errorf("AbleToScale.observedGeneration = %d, want %d", able.ObservedGeneration, got.Generation)
+	}
+	// The recommendation was computed before the write failed, so
+	// ScalingActive from this sync is kept, and so is ScalingLimited.
+	// DecisionAvailable mirrors ScalingActive.
+	assertScalingActive(t, got, metav1.ConditionTrue, autoscalingv1alpha1.ReasonMetricsAvailable,
+		"evaluated 1 of 1 metrics; recommends 2 replicas")
+	assertScalingLimited(t, got, metav1.ConditionFalse, autoscalingv1alpha1.ReasonDesiredWithinRange,
+		"the desired count is within the acceptable range")
+
+	deploy := &appsv1.Deployment{}
+	if err := c.Get(context.Background(), client.ObjectKey{Namespace: "ns", Name: "d"}, deploy); err != nil {
+		t.Fatal(err)
+	}
+	if deploy.Spec.Replicas == nil || *deploy.Spec.Replicas != 1 {
+		t.Errorf("deployment replicas = %v, want 1", deploy.Spec.Replicas)
+	}
+}
+
+// TestTargetUnreadableRecordsAbleToScale covers a target Get that fails for a
+// reason other than NotFound. AbleToScale is False with TargetUnreadable.
+// deferredSince and the replica counts stay as seeded. ScalingActive is not
+// written on this path.
+func TestTargetUnreadableRecordsAbleToScale(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		_, _ = fmt.Fprintf(w, `{"status":"success","data":{"result":[{"value":[0,"%s"]}]}}`, "0.85")
+	}))
+	defer srv.Close()
+
+	deferred := metav1.NewTime(time.Date(2026, 3, 1, 12, 0, 0, 0, time.UTC))
+	scaler := prometheusScaler(srv.URL)
+	scaler.Status = autoscalingv1alpha1.LLMScalerStatus{
+		CurrentReplicas: 4,
+		DesiredReplicas: 4,
+		AppliedReplicas: 4,
+		DeferredSince:   &deferred,
+	}
+	// A read failure stops before a recommendation, so a signal from an earlier
+	// sync is left alone. ScalingActive and DecisionAvailable stay paired.
+	for _, condType := range []string{
+		autoscalingv1alpha1.ConditionScalingActive,
+		autoscalingv1alpha1.ConditionDecisionAvailable, //nolint:staticcheck // deprecated mirror of ScalingActive, still written
+	} {
+		meta.SetStatusCondition(&scaler.Status.Conditions, metav1.Condition{
+			Type:               condType,
+			Status:             metav1.ConditionFalse,
+			Reason:             autoscalingv1alpha1.ReasonDecisionUnavailable,
+			Message:            "stale custom decision",
+			ObservedGeneration: 1,
+		})
+	}
+	// A read failure stops before a recommendation, so a ScalingLimited from
+	// an earlier sync is left alone.
+	meta.SetStatusCondition(&scaler.Status.Conditions, metav1.Condition{
+		Type:               autoscalingv1alpha1.ConditionScalingLimited,
+		Status:             metav1.ConditionTrue,
+		Reason:             autoscalingv1alpha1.ReasonTooManyReplicas,
+		Message:            "seeded limit",
+		ObservedGeneration: 1,
+	})
+
+	scheme := statusScheme(t)
+	c := fake.NewClientBuilder().
+		WithScheme(scheme).
+		WithObjects(rolledDeployment(), scaler).
+		WithStatusSubresource(&autoscalingv1alpha1.LLMScaler{}).
+		WithInterceptorFuncs(interceptor.Funcs{
+			Get: func(ctx context.Context, c client.WithWatch, key client.ObjectKey, obj client.Object, opts ...client.GetOption) error {
+				if _, ok := obj.(*unstructured.Unstructured); ok {
+					return fmt.Errorf("injected read failure")
+				}
+				return c.Get(ctx, key, obj, opts...)
+			},
+		}).
+		Build()
+
+	result, err := (&LLMScalerReconciler{Client: c, Scheme: scheme}).Reconcile(context.Background(), reconcile.Request{
+		NamespacedName: types.NamespacedName{Namespace: scaler.Namespace, Name: scaler.Name},
+	})
+	if err != nil {
+		t.Fatalf("Reconcile error = %v", err)
+	}
+	if result.RequeueAfter != 10*time.Second {
+		t.Errorf("RequeueAfter = %s, want 10s", result.RequeueAfter)
+	}
+
+	got := &autoscalingv1alpha1.LLMScaler{}
+	if err := c.Get(context.Background(), client.ObjectKeyFromObject(scaler), got); err != nil {
+		t.Fatal(err)
+	}
+	if got.Status.ObservedGeneration != got.Generation {
+		t.Errorf("observedGeneration = %d, want generation %d", got.Status.ObservedGeneration, got.Generation)
+	}
+	assertConditionLeft(t, got, autoscalingv1alpha1.ConditionScalingActive,
+		metav1.ConditionFalse, autoscalingv1alpha1.ReasonDecisionUnavailable, "stale custom decision", 1)
+	assertConditionLeft(t, got, autoscalingv1alpha1.ConditionDecisionAvailable, //nolint:staticcheck // deprecated mirror of ScalingActive, still written
+		metav1.ConditionFalse, autoscalingv1alpha1.ReasonDecisionUnavailable, "stale custom decision", 1)
+	assertConditionLeft(t, got, autoscalingv1alpha1.ConditionScalingLimited,
+		metav1.ConditionTrue, autoscalingv1alpha1.ReasonTooManyReplicas, "seeded limit", 1)
+	able := meta.FindStatusCondition(got.Status.Conditions, autoscalingv1alpha1.ConditionAbleToScale)
+	if able == nil {
+		t.Fatal("AbleToScale condition missing")
+	}
+	if able.Status != metav1.ConditionFalse || able.Reason != autoscalingv1alpha1.ReasonTargetUnreadable {
+		t.Errorf("AbleToScale = %s/%s, want False/%s", able.Status, able.Reason, autoscalingv1alpha1.ReasonTargetUnreadable)
+	}
+	if !strings.Contains(able.Message, "injected read failure") {
+		t.Errorf("AbleToScale message = %q, want the injected error", able.Message)
+	}
+	if able.ObservedGeneration != got.Generation {
+		t.Errorf("AbleToScale.observedGeneration = %d, want %d", able.ObservedGeneration, got.Generation)
+	}
+	if got.Status.CurrentReplicas != 4 || got.Status.DesiredReplicas != 4 || got.Status.AppliedReplicas != 4 {
+		t.Errorf("replicas current/desired/applied = %d/%d/%d, want 4/4/4",
+			got.Status.CurrentReplicas, got.Status.DesiredReplicas, got.Status.AppliedReplicas)
+	}
+	if got.Status.DeferredSince == nil || !got.Status.DeferredSince.Time.Equal(deferred.Time) {
+		t.Errorf("deferredSince = %v, want %s", got.Status.DeferredSince, deferred.Time)
+	}
+	if got.Status.LastScaleTime != nil {
+		t.Errorf("lastScaleTime = %s, want unset", got.Status.LastScaleTime.Time)
+	}
+}
+
+// TestMissingCustomProviderRecordsInvalidSpec runs the admission-rejected
+// pairing through the controller. The fleet stays where it is. ScalingActive
+// is False/InvalidSpec; AbleToScale still describes the scale decision.
+func TestMissingCustomProviderRecordsInvalidSpec(t *testing.T) {
+	scaler := prometheusScaler("http://127.0.0.1:9")
+	scaler.Spec.MetricProvider = autoscalingv1alpha1.MetricProviderCustom
+	scaler.Spec.CustomProvider = nil
+	scaler.Spec.Metrics = nil
+
+	scheme := statusScheme(t)
+	c := fake.NewClientBuilder().
+		WithScheme(scheme).
+		WithObjects(rolledDeployment(), scaler).
+		WithStatusSubresource(&autoscalingv1alpha1.LLMScaler{}).
+		Build()
+
+	result, err := (&LLMScalerReconciler{Client: c, Scheme: scheme}).Reconcile(context.Background(), reconcile.Request{
+		NamespacedName: types.NamespacedName{Namespace: scaler.Namespace, Name: scaler.Name},
+	})
+	if err != nil {
+		t.Fatalf("Reconcile error = %v", err)
+	}
+	if result.RequeueAfter != 15*time.Second {
+		t.Errorf("RequeueAfter = %s, want 15s", result.RequeueAfter)
+	}
+
+	got := &autoscalingv1alpha1.LLMScaler{}
+	if err := c.Get(context.Background(), client.ObjectKeyFromObject(scaler), got); err != nil {
+		t.Fatal(err)
+	}
+	assertScalingActive(t, got, metav1.ConditionFalse, autoscalingv1alpha1.ReasonInvalidSpec, "spec.customProvider is not set")
+	able := meta.FindStatusCondition(got.Status.Conditions, autoscalingv1alpha1.ConditionAbleToScale)
+	if able == nil {
+		t.Fatal("AbleToScale condition missing")
+	}
+	if able.Status != metav1.ConditionTrue || able.Reason != autoscalingv1alpha1.ReasonSynced {
+		t.Errorf("AbleToScale = %s/%s, want True/Synced", able.Status, able.Reason)
+	}
+	if able.Message != "replica count is already at the step target" {
+		t.Errorf("AbleToScale message = %q", able.Message)
+	}
+	if able.ObservedGeneration != got.Generation {
+		t.Errorf("AbleToScale.observedGeneration = %d, want %d", able.ObservedGeneration, got.Generation)
+	}
+	if meta.FindStatusCondition(got.Status.Conditions, autoscalingv1alpha1.ConditionScalingLimited) != nil {
+		t.Error("ScalingLimited set without a usable signal")
+	}
+	if got.Status.DesiredReplicas != 1 || got.Status.AppliedReplicas != 1 || got.Status.CurrentReplicas != 1 {
+		t.Errorf("replicas desired/applied/current = %d/%d/%d, want 1/1/1",
+			got.Status.DesiredReplicas, got.Status.AppliedReplicas, got.Status.CurrentReplicas)
+	}
+	if got.Status.LastScaleTime != nil {
+		t.Errorf("lastScaleTime = %s, want unset", got.Status.LastScaleTime.Time)
+	}
+	if got.Generation == 0 || got.Status.ObservedGeneration != got.Generation {
+		t.Errorf("observedGeneration = %d, generation = %d", got.Status.ObservedGeneration, got.Generation)
+	}
+
+	deploy := &appsv1.Deployment{}
+	if err := c.Get(context.Background(), client.ObjectKey{Namespace: "ns", Name: "d"}, deploy); err != nil {
+		t.Fatal(err)
+	}
+	if deploy.Spec.Replicas == nil || *deploy.Spec.Replicas != 1 {
+		t.Errorf("deployment replicas = %v, want 1", deploy.Spec.Replicas)
+	}
+}
+
+// TestMetricProviderSwitchOverwritesScalingActive reconciles a Custom
+// scaler, switches it to Prometheus, then switches it back. Each sync that
+// reaches a recommendation overwrites ScalingActive, so neither provider's
+// condition lingers. DecisionAvailable mirrors it.
+func TestMetricProviderSwitchOverwritesScalingActive(t *testing.T) {
+	prom := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		_, _ = fmt.Fprintf(w, `{"status":"success","data":{"result":[{"value":[0,"%s"]}]}}`, "0.5")
+	}))
+	defer prom.Close()
+	decisionSrv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		_, _ = fmt.Fprintf(w,
+			`{"apiVersion":%q,"decisions":[{"serviceId":"svc","replicas":{"active":1}}]}`,
+			decisionsAPIVersion)
+	}))
+	defer decisionSrv.Close()
+
+	scaler := prometheusScaler(decisionSrv.URL)
+	scaler.Spec.MetricProvider = autoscalingv1alpha1.MetricProviderCustom
+	scaler.Spec.CustomProvider = &autoscalingv1alpha1.CustomProviderSpec{ServiceID: "svc"}
+
+	scheme := statusScheme(t)
+	c := fake.NewClientBuilder().
+		WithScheme(scheme).
+		WithObjects(rolledDeployment(), scaler).
+		WithStatusSubresource(&autoscalingv1alpha1.LLMScaler{}).
+		Build()
+	rec := &LLMScalerReconciler{Client: c, Scheme: scheme}
+	key := types.NamespacedName{Namespace: scaler.Namespace, Name: scaler.Name}
+	req := reconcile.Request{NamespacedName: key}
+
+	reconcileAndGet := func() *autoscalingv1alpha1.LLMScaler {
+		t.Helper()
+		if _, err := rec.Reconcile(context.Background(), req); err != nil {
+			t.Fatalf("Reconcile error = %v", err)
+		}
+		got := &autoscalingv1alpha1.LLMScaler{}
+		if err := c.Get(context.Background(), key, got); err != nil {
+			t.Fatal(err)
+		}
+		return got
+	}
+	setProvider := func(provider, server string) {
+		t.Helper()
+		got := &autoscalingv1alpha1.LLMScaler{}
+		if err := c.Get(context.Background(), key, got); err != nil {
+			t.Fatal(err)
+		}
+		got.Spec.MetricProvider = provider
+		got.Spec.ServerAddress = server
+		if err := c.Update(context.Background(), got); err != nil {
+			t.Fatal(err)
+		}
+	}
+	assertSynced := func(got *autoscalingv1alpha1.LLMScaler, reason, message string) {
+		t.Helper()
+		assertScalingActive(t, got, metav1.ConditionTrue, reason, message)
+	}
+
+	got := reconcileAndGet()
+	assertSynced(got, autoscalingv1alpha1.ReasonDecisionReceived, "decision server recommends 1 replicas")
+
+	setProvider(autoscalingv1alpha1.MetricProviderPrometheus, prom.URL)
+	got = reconcileAndGet()
+	assertSynced(got, autoscalingv1alpha1.ReasonMetricsAvailable, "evaluated 1 of 1 metrics; recommends 1 replicas")
+
+	setProvider(autoscalingv1alpha1.MetricProviderCustom, decisionSrv.URL)
+	got = reconcileAndGet()
+	assertSynced(got, autoscalingv1alpha1.ReasonDecisionReceived, "decision server recommends 1 replicas")
+}
+
+// assertConditionLeft checks that a condition written by an earlier sync was
+// not replaced. observedGeneration is the seeded value, not the current one.
+func assertConditionLeft(t *testing.T, got *autoscalingv1alpha1.LLMScaler, condType string, status metav1.ConditionStatus, reason, message string, observedGeneration int64) {
+	t.Helper()
+	cond := meta.FindStatusCondition(got.Status.Conditions, condType)
+	if cond == nil || cond.Status != status || cond.Reason != reason || cond.Message != message || cond.ObservedGeneration != observedGeneration {
+		t.Errorf("%s = %+v, want the seeded condition left untouched", condType, cond)
+	}
+}
+
+// assertScalingLimited checks the limit condition written on this sync,
+// including the generation it was computed from.
+func assertScalingLimited(t *testing.T, got *autoscalingv1alpha1.LLMScaler, status metav1.ConditionStatus, reason, message string) {
+	t.Helper()
+	limited := meta.FindStatusCondition(got.Status.Conditions, autoscalingv1alpha1.ConditionScalingLimited)
+	if limited == nil {
+		t.Fatal("ScalingLimited condition missing")
+	}
+	if limited.Status != status || limited.Reason != reason {
+		t.Errorf("ScalingLimited = %s/%s, want %s/%s", limited.Status, limited.Reason, status, reason)
+	}
+	if limited.Message != message {
+		t.Errorf("ScalingLimited message = %q, want %q", limited.Message, message)
+	}
+	if limited.ObservedGeneration != got.Generation {
+		t.Errorf("ScalingLimited.observedGeneration = %d, want %d", limited.ObservedGeneration, got.Generation)
+	}
+}
+
+// scalingActive returns ScalingActive and checks that DecisionAvailable mirrors it.
+func scalingActive(t *testing.T, scaler *autoscalingv1alpha1.LLMScaler) *metav1.Condition {
+	t.Helper()
+	active := meta.FindStatusCondition(scaler.Status.Conditions, autoscalingv1alpha1.ConditionScalingActive)
+	if active == nil {
+		t.Fatal("ScalingActive condition missing")
+	}
+	decision := meta.FindStatusCondition(scaler.Status.Conditions, autoscalingv1alpha1.ConditionDecisionAvailable) //nolint:staticcheck // deprecated mirror of ScalingActive, still written
+	if decision == nil || decision.Status != active.Status || decision.Reason != active.Reason ||
+		decision.Message != active.Message || decision.ObservedGeneration != active.ObservedGeneration {
+		t.Errorf("DecisionAvailable = %+v, want it to mirror ScalingActive %+v", decision, active)
+	}
+	return active
+}
+
+// assertScalingActive checks the signal condition written on this sync,
+// including the generation it was computed from. DecisionAvailable must
+// mirror it.
+func assertScalingActive(t *testing.T, got *autoscalingv1alpha1.LLMScaler, status metav1.ConditionStatus, reason, message string) {
+	t.Helper()
+	active := scalingActive(t, got)
+	if active.Status != status || active.Reason != reason {
+		t.Errorf("ScalingActive = %s/%s, want %s/%s", active.Status, active.Reason, status, reason)
+	}
+	if active.Message != message {
+		t.Errorf("ScalingActive message = %q, want %q", active.Message, message)
+	}
+	if active.ObservedGeneration != got.Generation {
+		t.Errorf("ScalingActive.observedGeneration = %d, want %d", active.ObservedGeneration, got.Generation)
+	}
+}
+
+func statusScheme(t *testing.T) *runtime.Scheme {
+	t.Helper()
+	scheme := runtime.NewScheme()
+	if err := autoscalingv1alpha1.AddToScheme(scheme); err != nil {
+		t.Fatal(err)
+	}
+	if err := appsv1.AddToScheme(scheme); err != nil {
+		t.Fatal(err)
+	}
+	return scheme
+}
+
+func prometheusScaler(serverURL string) *autoscalingv1alpha1.LLMScaler {
+	return &autoscalingv1alpha1.LLMScaler{
+		ObjectMeta: metav1.ObjectMeta{Name: "s", Namespace: "ns", Generation: 7},
+		Spec: autoscalingv1alpha1.LLMScalerSpec{
+			TargetRef: autoscalingv1alpha1.TargetRef{
+				APIVersion: "apps/v1",
+				Kind:       deploymentKind,
+				Name:       "d",
+			},
+			ServerAddress: serverURL,
+			MinReplicas:   1,
+			MaxReplicas:   5,
+			Metrics: []autoscalingv1alpha1.MetricSpec{{
+				Query:  "avg(vllm:kv_cache_usage_perc)",
+				Target: "0.5",
+			}},
+		},
+	}
+}
+
+func rolledDeployment() *appsv1.Deployment {
+	replicas := int32(1)
+	return &appsv1.Deployment{
+		ObjectMeta: metav1.ObjectMeta{Name: "d", Namespace: "ns", Generation: 1},
+		Spec: appsv1.DeploymentSpec{
+			Replicas: &replicas,
+			Selector: &metav1.LabelSelector{MatchLabels: map[string]string{appLabelKey: "d"}},
+			Template: corev1.PodTemplateSpec{
+				ObjectMeta: metav1.ObjectMeta{Labels: map[string]string{appLabelKey: "d"}},
+				Spec:       corev1.PodSpec{Containers: []corev1.Container{{Name: "nginx", Image: "nginx"}}},
+			},
+		},
+		Status: appsv1.DeploymentStatus{
+			ObservedGeneration: 1,
+			Replicas:           1,
+			UpdatedReplicas:    1,
+			ReadyReplicas:      1,
+			AvailableReplicas:  1,
+		},
+	}
+}
diff --git a/internal/controller/autoscaling/testdata/controller/condition-status/should-keep-scaling-active-while-a-rollout-defers-the-next-scale.yaml b/internal/controller/autoscaling/testdata/controller/condition-status/should-keep-scaling-active-while-a-rollout-defers-the-next-scale.yaml
new file mode 100644
index 0000000..93b4bcb
--- /dev/null
+++ b/internal/controller/autoscaling/testdata/controller/condition-status/should-keep-scaling-active-while-a-rollout-defers-the-next-scale.yaml
@@ -0,0 +1,53 @@
+# First sync: ceil(1 * 0.85/0.5) = 2, a normal write. Second sync raises the
+# metric to 2.5 while the new spec is still unobserved, so ceil(1 * 2.5/0.5) = 5
+# is held by the rollout guard. lastScaleTime stays at the first write.
+"name": "should-keep-scaling-active-while-a-rollout-defers-the-next-scale"
+"description": "should keep ScalingActive while a rollout defers the next scale"
+"inputs":
+  "steps":
+  - "by": "scaling 1 -> 2"
+    "at": "0s"
+  - "by": "raising the metric while the rollout is still in progress"
+    "at": "10s"
+    "metric": "2.5"
+    "rollout": true
+"expected":
+  "steps":
+  - "replicas": 2
+    "desired": 2
+    "applied": 2
+    "condition":
+      "status": "True"
+      "reason": "Synced"
+      "messageContains":
+      - "scaled 1 -> 2"
+    "active":
+      "status": "True"
+      "reason": "MetricsAvailable"
+      "messageContains":
+      - "evaluated 1 of 1 metrics"
+      - "recommends 2 replicas"
+      "observedGenerationCurrent": true
+    "lastScaleTime": "set"
+    "observedGenerationCurrent": true
+  - "replicas": 2
+    "desired": 5
+    "applied": 2
+    "current": 1
+    "deferredSince": "10s"
+    "requeueAfter": "15s"
+    "condition":
+      "status": "True"
+      "reason": "RolloutInProgress"
+      "messageContains":
+      - "holding 2 replicas (wanted 5)"
+      - "Deployment rollout in progress"
+      "observedGenerationCurrent": true
+    "active":
+      "status": "True"
+      "reason": "MetricsAvailable"
+      "messageContains":
+      - "recommends 5 replicas"
+      "observedGenerationCurrent": true
+    "lastScaleTime": "unchanged"
+    "observedGenerationCurrent": true
diff --git a/internal/controller/autoscaling/testdata/controller/condition-status/should-record-the-new-generation-after-a-spec-change.yaml b/internal/controller/autoscaling/testdata/controller/condition-status/should-record-the-new-generation-after-a-spec-change.yaml
new file mode 100644
index 0000000..62dac48
--- /dev/null
+++ b/internal/controller/autoscaling/testdata/controller/condition-status/should-record-the-new-generation-after-a-spec-change.yaml
@@ -0,0 +1,48 @@
+# metric 0.5 over target 0.5 is already spec, so both syncs are no-ops.
+# Raising maxReplicas bumps metadata.generation. The second sync records that
+# generation on status.observedGeneration and on every condition.
+"name": "should-record-the-new-generation-after-a-spec-change"
+"description": "should record the new generation after a spec change"
+"inputs":
+  "metric": "0.5"
+  "steps":
+  - "by": "reconciling once at the current generation"
+    "at": "0s"
+  - "by": "raising maxReplicas and reconciling again"
+    "at": "0s"
+    "maxReplicas": 9
+"expected":
+  "steps":
+  - "replicas": 1
+    "desired": 1
+    "applied": 1
+    "current": 1
+    "condition":
+      "status": "True"
+      "reason": "Synced"
+      "observedGenerationCurrent": true
+    "decision":
+      "status": "True"
+      "reason": "MetricsAvailable"
+      "messageContains":
+      - "evaluated 1 of 1 metrics"
+      - "recommends 1 replicas"
+      "observedGenerationCurrent": true
+    "observedGenerationCurrent": true
+    "conditionsObservedGenerationCurrent": true
+  - "replicas": 1
+    "desired": 1
+    "condition":
+      "status": "True"
+      "reason": "Synced"
+      "observedGenerationCurrent": true
+    "decision":
+      "status": "True"
+      "reason": "MetricsAvailable"
+      "messageContains":
+      - "evaluated 1 of 1 metrics"
+      - "recommends 1 replicas"
+      "observedGenerationCurrent": true
+    "observedGenerationCurrent": true
+    "conditionsObservedGenerationCurrent": true
+    "generationGreaterThan": 1
diff --git a/internal/controller/autoscaling/testdata/controller/condition-status/should-report-decision-unavailable-when-prometheus-is-unreachable.yaml b/internal/controller/autoscaling/testdata/controller/condition-status/should-report-decision-unavailable-when-prometheus-is-unreachable.yaml
new file mode 100644
index 0000000..ed4adc8
--- /dev/null
+++ b/internal/controller/autoscaling/testdata/controller/condition-status/should-report-decision-unavailable-when-prometheus-is-unreachable.yaml
@@ -0,0 +1,39 @@
+# The query cannot be evaluated, so the replica count stays at spec.
+"name": "should-report-decision-unavailable-when-prometheus-is-unreachable"
+"description": "should report DecisionUnavailable when Prometheus is unreachable"
+"inputs":
+  "closeServer": true
+  "steps":
+  - "by": "reconciling with Prometheus down"
+    "at": "0s"
+"expected":
+  "steps":
+  - "replicas": 1
+    "desired": 1
+    "applied": 1
+    "current": 1
+    "deferredSince": null
+    "requeueAfter": "15s"
+    "condition":
+      "status": "True"
+      "reason": "Synced"
+      "messageContains":
+      - "already at the step target"
+    "active":
+      "status": "False"
+      "reason": "DecisionUnavailable"
+      "messageContains":
+      - "no prometheus metric could be evaluated"
+      - "failed to query prometheus"
+      "observedGenerationCurrent": true
+    "decision":
+      "status": "False"
+      "reason": "DecisionUnavailable"
+      "messageContains":
+      - "no prometheus metric could be evaluated"
+      - "prometheus"
+      "observedGenerationCurrent": true
+    "limited":
+      "absent": true
+    "lastScaleTime": "unset"
+    "observedGenerationCurrent": true
diff --git a/internal/controller/autoscaling/testdata/controller/condition-status/should-report-invalid-spec-when-targetref-apiversion-does-not-parse.yaml b/internal/controller/autoscaling/testdata/controller/condition-status/should-report-invalid-spec-when-targetref-apiversion-does-not-parse.yaml
new file mode 100644
index 0000000..40a8c70
--- /dev/null
+++ b/internal/controller/autoscaling/testdata/controller/condition-status/should-report-invalid-spec-when-targetref-apiversion-does-not-parse.yaml
@@ -0,0 +1,64 @@
+# A normal write lands first. An apiVersion with more than one slash does not
+# parse, so the next sync records InvalidSpec on AbleToScale and leaves the
+# replica counts, lastScaleTime, and ScalingActive alone.
+"name": "should-report-invalid-spec-when-targetref-apiversion-does-not-parse"
+"description": "should report InvalidSpec when targetRef.apiVersion does not parse"
+"inputs":
+  "steps":
+  - "by": "scaling once so status is populated"
+    "at": "0s"
+  - "by": "setting an apiVersion that does not parse"
+    "at": "5s"
+    "apiVersion": "apps/v1/extra"
+"expected":
+  "steps":
+  - "replicas": 2
+    "desired": 2
+    "applied": 2
+    "current": 1
+    "condition":
+      "status": "True"
+      "reason": "Synced"
+      "messageContains":
+      - "scaled 1 -> 2"
+    "decision":
+      "status": "True"
+      "reason": "MetricsAvailable"
+      "messageContains":
+      - "evaluated 1 of 1 metrics"
+      - "recommends 2 replicas"
+      "observedGenerationCurrent": true
+    "limited":
+      "status": "False"
+      "reason": "DesiredWithinRange"
+      "messageContains":
+      - "the desired count is within the acceptable range"
+      "observedGenerationCurrent": true
+    "lastScaleTime": "set"
+    "observedGenerationCurrent": true
+  - "replicas": 2
+    "desired": 2
+    "applied": 2
+    "current": 1
+    "requeueAfter": "0s"
+    "condition":
+      "status": "False"
+      "reason": "InvalidSpec"
+      "messageContains":
+      - "apps/v1/extra"
+      "observedGenerationCurrent": true
+    "decision":
+      "status": "True"
+      "reason": "MetricsAvailable"
+      "messageContains":
+      - "evaluated 1 of 1 metrics"
+      - "recommends 2 replicas"
+      "observedGenerationStale": true
+    "limited":
+      "status": "False"
+      "reason": "DesiredWithinRange"
+      "messageContains":
+      - "the desired count is within the acceptable range"
+      "observedGenerationStale": true
+    "lastScaleTime": "unchanged"
+    "observedGenerationCurrent": true
diff --git a/internal/controller/autoscaling/testdata/controller/condition-status/should-report-scaling-active-and-lastscaletime-when-a-scale-write-succeeds.yaml b/internal/controller/autoscaling/testdata/controller/condition-status/should-report-scaling-active-and-lastscaletime-when-a-scale-write-succeeds.yaml
new file mode 100644
index 0000000..bed1bdb
--- /dev/null
+++ b/internal/controller/autoscaling/testdata/controller/condition-status/should-report-scaling-active-and-lastscaletime-when-a-scale-write-succeeds.yaml
@@ -0,0 +1,29 @@
+# ceil(1 * 0.85/0.5) = ceil(1.7) = 2. The mock sample is 0.85 and the target is 0.5.
+"name": "should-report-scaling-active-and-lastscaletime-when-a-scale-write-succeeds"
+"description": "should report ScalingActive and lastScaleTime when a scale write succeeds"
+"inputs":
+  "steps":
+  - "by": "scaling the deployment"
+    "at": "0s"
+"expected":
+  "steps":
+  - "replicas": 2
+    "desired": 2
+    "applied": 2
+    "current": 1
+    "requeueAfter": "15s"
+    "condition":
+      "status": "True"
+      "reason": "Synced"
+      "messageContains":
+      - "scaled 1 -> 2"
+      "observedGenerationCurrent": true
+    "decision":
+      "status": "True"
+      "reason": "MetricsAvailable"
+      "messageContains":
+      - "evaluated 1 of 1 metrics"
+      - "recommends 2 replicas"
+      "observedGenerationCurrent": true
+    "lastScaleTime": "set"
+    "observedGenerationCurrent": true
diff --git a/internal/controller/autoscaling/testdata/controller/condition-status/should-report-scaling-active-on-a-no-op-without-a-lastscaletime.yaml b/internal/controller/autoscaling/testdata/controller/condition-status/should-report-scaling-active-on-a-no-op-without-a-lastscaletime.yaml
new file mode 100644
index 0000000..0485d53
--- /dev/null
+++ b/internal/controller/autoscaling/testdata/controller/condition-status/should-report-scaling-active-on-a-no-op-without-a-lastscaletime.yaml
@@ -0,0 +1,31 @@
+# ceil(1 * 0.5/0.5) = 1, which is already spec, and the deployment is fully rolled out.
+"name": "should-report-scaling-active-on-a-no-op-without-a-lastscaletime"
+"description": "should report ScalingActive on a no-op without a lastScaleTime"
+"inputs":
+  "metric": "0.5"
+  "steps":
+  - "by": "reconciling a fleet that is already at the step target"
+    "at": "0s"
+"expected":
+  "steps":
+  - "replicas": 1
+    "desired": 1
+    "applied": 1
+    "current": 1
+    "deferredSince": null
+    "requeueAfter": "15s"
+    "condition":
+      "status": "True"
+      "reason": "Synced"
+      "messageContains":
+      - "already at the step target"
+      "observedGenerationCurrent": true
+    "decision":
+      "status": "True"
+      "reason": "MetricsAvailable"
+      "messageContains":
+      - "evaluated 1 of 1 metrics"
+      - "recommends 1 replicas"
+      "observedGenerationCurrent": true
+    "lastScaleTime": "unset"
+    "observedGenerationCurrent": true
diff --git a/internal/controller/autoscaling/testdata/controller/condition-status/should-report-target-not-found-and-leave-the-deferral-untouched.yaml b/internal/controller/autoscaling/testdata/controller/condition-status/should-report-target-not-found-and-leave-the-deferral-untouched.yaml
new file mode 100644
index 0000000..417fc03
--- /dev/null
+++ b/internal/controller/autoscaling/testdata/controller/condition-status/should-report-target-not-found-and-leave-the-deferral-untouched.yaml
@@ -0,0 +1,60 @@
+# The first sync defers a scale-up (wanted 2) while the deployment rolls out.
+# Deleting the target records TargetNotFound on AbleToScale without clearing
+# deferredSince, ScalingActive, or the replica counts already written.
+# The delete does not change metadata.generation, so ScalingActive's
+# observedGeneration from the first sync is still current. The reason staying
+# MetricsAvailable is what shows the read path did not rewrite it.
+"name": "should-report-target-not-found-and-leave-the-deferral-untouched"
+"description": "should report TargetNotFound and leave the deferral untouched"
+"inputs":
+  "rollout": true
+  "steps":
+  - "by": "deferring the scale-up and stamping deferredSince"
+    "at": "0s"
+  - "by": "deleting the target and reconciling again"
+    "at": "10s"
+    "deleteDeploy": true
+"expected":
+  "steps":
+  - "replicas": 1
+    "desired": 2
+    "applied": 1
+    "current": 1
+    "deferredSince": "0s"
+    "requeueAfter": "15s"
+    "condition":
+      "status": "True"
+      "reason": "RolloutInProgress"
+      "messageContains":
+      - "holding 1 replicas (wanted 2)"
+      - "Deployment rollout in progress"
+      - "will apply after 600s"
+      "observedGenerationCurrent": true
+    "active":
+      "status": "True"
+      "reason": "MetricsAvailable"
+      "messageContains":
+      - "evaluated 1 of 1 metrics"
+      - "recommends 2 replicas"
+      "observedGenerationCurrent": true
+    "lastScaleTime": "unset"
+    "observedGenerationCurrent": true
+  - "desired": 2
+    "applied": 1
+    "current": 1
+    "deferredSince": "0s"
+    "requeueAfter": "10s"
+    "condition":
+      "status": "False"
+      "reason": "TargetNotFound"
+      "messageContains":
+      - "not found"
+      "observedGenerationCurrent": true
+    "active":
+      "status": "True"
+      "reason": "MetricsAvailable"
+      "messageContains":
+      - "recommends 2 replicas"
+      "observedGenerationCurrent": true
+    "lastScaleTime": "unset"
+    "observedGenerationCurrent": true
diff --git a/internal/controller/autoscaling/testdata/controller/custom-reconcile/should-hold-replicas-when-the-decision-server-is-unreachable.yaml b/internal/controller/autoscaling/testdata/controller/custom-reconcile/should-hold-replicas-when-the-decision-server-is-unreachable.yaml
index 6537faa..b4d14f1 100644
--- a/internal/controller/autoscaling/testdata/controller/custom-reconcile/should-hold-replicas-when-the-decision-server-is-unreachable.yaml
+++ b/internal/controller/autoscaling/testdata/controller/custom-reconcile/should-hold-replicas-when-the-decision-server-is-unreachable.yaml
@@ -15,6 +15,17 @@
   "statusBy": "checking the failure is reported on the status"
 "expected":
   "replicas": 3
+  "desired": 3
   "decisionStatus": "False"
   "decisionReason": "DecisionUnavailable"
-  "decisionMessageNonEmpty": true
+  "decisionMessageContains":
+  - "custom provider returned no decision"
+  - "decision server"
+  "active":
+    "status": "False"
+    "reason": "DecisionUnavailable"
+    "messageContains":
+    - "custom provider returned no decision"
+    "observedGenerationCurrent": true
+  "lastScaleTime": "unset"
+  "observedGenerationCurrent": true
diff --git a/internal/controller/autoscaling/testdata/controller/custom-reconcile/should-scale-the-deployment-to-the-count-the-decision-server-reports.yaml b/internal/controller/autoscaling/testdata/controller/custom-reconcile/should-scale-the-deployment-to-the-count-the-decision-server-reports.yaml
index 734a302..9e4c462 100644
--- a/internal/controller/autoscaling/testdata/controller/custom-reconcile/should-scale-the-deployment-to-the-count-the-decision-server-reports.yaml
+++ b/internal/controller/autoscaling/testdata/controller/custom-reconcile/should-scale-the-deployment-to-the-count-the-decision-server-reports.yaml
@@ -10,3 +10,14 @@
   "replicas": 4
   "desired": 4
   "decisionStatus": "True"
+  "decisionReason": "DecisionReceived"
+  "decisionMessageContains":
+  - "decision server recommends 4 replicas"
+  "active":
+    "status": "True"
+    "reason": "DecisionReceived"
+    "messageContains":
+    - "decision server recommends 4 replicas"
+    "observedGenerationCurrent": true
+  "lastScaleTime": "set"
+  "observedGenerationCurrent": true
diff --git a/internal/controller/autoscaling/testdata/controller/deferral-status/should-clear-a-deferral-on-a-no-op-once-no-guard-matches.yaml b/internal/controller/autoscaling/testdata/controller/deferral-status/should-clear-a-deferral-on-a-no-op-once-no-guard-matches.yaml
index 2a3182d..76894b7 100644
--- a/internal/controller/autoscaling/testdata/controller/deferral-status/should-clear-a-deferral-on-a-no-op-once-no-guard-matches.yaml
+++ b/internal/controller/autoscaling/testdata/controller/deferral-status/should-clear-a-deferral-on-a-no-op-once-no-guard-matches.yaml
@@ -19,7 +19,7 @@
     "applied": 1
     "forcedWrite": false
     "condition":
-      "status": "False"
-      "reason": "NotDeferred"
+      "status": "True"
+      "reason": "Synced"
       "messageContains":
       - "already at the step target"
diff --git a/internal/controller/autoscaling/testdata/controller/deferral-status/should-keep-deferredsince-across-no-op-syncs-while-a-rollout-guard-still-matches.yaml b/internal/controller/autoscaling/testdata/controller/deferral-status/should-keep-deferredsince-across-no-op-syncs-while-a-rollout-guard-still-matches.yaml
index b23401e..5be5e88 100644
--- a/internal/controller/autoscaling/testdata/controller/deferral-status/should-keep-deferredsince-across-no-op-syncs-while-a-rollout-guard-still-matches.yaml
+++ b/internal/controller/autoscaling/testdata/controller/deferral-status/should-keep-deferredsince-across-no-op-syncs-while-a-rollout-guard-still-matches.yaml
@@ -26,8 +26,8 @@
   - "deferredSince": null
     "replicas": 1
     "condition":
-      "status": "False"
-      "reason": "NotDeferred"
+      "status": "True"
+      "reason": "Synced"
   - "deferredSince": "10s"
     "replicas": 1
     "condition":
@@ -58,7 +58,7 @@
   - "replicas": 2
     "deferredSince": "10s"
     "condition":
-      "status": "False"
+      "status": "True"
       "reason": "DeferralTimedOut"
       "messageContains":
       - "scaling 1 -> 2 anyway"
diff --git a/internal/controller/autoscaling/testdata/controller/deferral-timeout/should-force-a-deferral-that-already-exceeded-the-timeout-on-a-fresh-reconciler.yaml b/internal/controller/autoscaling/testdata/controller/deferral-timeout/should-force-a-deferral-that-already-exceeded-the-timeout-on-a-fresh-reconciler.yaml
index 273eea2..e1c396c 100644
--- a/internal/controller/autoscaling/testdata/controller/deferral-timeout/should-force-a-deferral-that-already-exceeded-the-timeout-on-a-fresh-reconciler.yaml
+++ b/internal/controller/autoscaling/testdata/controller/deferral-timeout/should-force-a-deferral-that-already-exceeded-the-timeout-on-a-fresh-reconciler.yaml
@@ -15,7 +15,7 @@
     "deferredSince": "seed"
     "applied": 2
     "condition":
-      "status": "False"
+      "status": "True"
       "reason": "DeferralTimedOut"
     "events":
     - "prefix": "Warning DeferralTimedOut"
diff --git a/internal/controller/autoscaling/testdata/controller/deferral-timeout/should-force-a-scale-down-of-an-unready-fleet-once-the-deferral-times-out.yaml b/internal/controller/autoscaling/testdata/controller/deferral-timeout/should-force-a-scale-down-of-an-unready-fleet-once-the-deferral-times-out.yaml
index d108f09..d0962c9 100644
--- a/internal/controller/autoscaling/testdata/controller/deferral-timeout/should-force-a-scale-down-of-an-unready-fleet-once-the-deferral-times-out.yaml
+++ b/internal/controller/autoscaling/testdata/controller/deferral-timeout/should-force-a-scale-down-of-an-unready-fleet-once-the-deferral-times-out.yaml
@@ -40,7 +40,7 @@
     "applied": 3
     "current": 0
     "condition":
-      "status": "False"
+      "status": "True"
       "reason": "DeferralTimedOut"
       "messageContains":
       - "scaling 5 -> 3 anyway"
diff --git a/internal/controller/autoscaling/testdata/controller/deferral-timeout/should-force-a-scale-up-once-a-stuck-rollout-exceeds-the-deferral-timeout.yaml b/internal/controller/autoscaling/testdata/controller/deferral-timeout/should-force-a-scale-up-once-a-stuck-rollout-exceeds-the-deferral-timeout.yaml
index a97d880..7fdfd40 100644
--- a/internal/controller/autoscaling/testdata/controller/deferral-timeout/should-force-a-scale-up-once-a-stuck-rollout-exceeds-the-deferral-timeout.yaml
+++ b/internal/controller/autoscaling/testdata/controller/deferral-timeout/should-force-a-scale-up-once-a-stuck-rollout-exceeds-the-deferral-timeout.yaml
@@ -27,6 +27,8 @@
       - "2026-03-01T12:00:00Z"
       - "will apply after 60s"
       "observedGenerationCurrent": true
+    "lastScaleTime": "unset"
+    "observedGenerationCurrent": true
     "events":
     - "prefix": "Normal ScalingDeferred"
       "contains":
@@ -42,11 +44,13 @@
     "applied": 2
     "requeueAfter": "15s"
     "condition":
-      "status": "False"
+      "status": "True"
       "reason": "DeferralTimedOut"
       "messageContains":
       - "scaling 1 -> 2 anyway"
       "observedGenerationCurrent": true
+    "lastScaleTime": "set"
+    "observedGenerationCurrent": true
     "events":
     - "prefix": "Warning DeferralTimedOut"
       "contains":
diff --git a/internal/controller/autoscaling/testdata/controller/forced-write-pacing/should-clear-deferredsince-and-the-forced-write-pace-when-no-guard-matches.yaml b/internal/controller/autoscaling/testdata/controller/forced-write-pacing/should-clear-deferredsince-and-the-forced-write-pace-when-no-guard-matches.yaml
index e69bfe5..42ee1da 100644
--- a/internal/controller/autoscaling/testdata/controller/forced-write-pacing/should-clear-deferredsince-and-the-forced-write-pace-when-no-guard-matches.yaml
+++ b/internal/controller/autoscaling/testdata/controller/forced-write-pacing/should-clear-deferredsince-and-the-forced-write-pace-when-no-guard-matches.yaml
@@ -27,7 +27,7 @@
     "deferredSince": null
     "forcedWrite": false
     "condition":
-      "status": "False"
-      "reason": "NotDeferred"
+      "status": "True"
+      "reason": "Synced"
       "messageContains":
       - "scaled 3 -> 1"
diff --git a/internal/controller/autoscaling/testdata/controller/forced-write-pacing/should-force-the-next-stuck-scale-down-step-after-one-sync-period.yaml b/internal/controller/autoscaling/testdata/controller/forced-write-pacing/should-force-the-next-stuck-scale-down-step-after-one-sync-period.yaml
index 5a52f47..78518ca 100644
--- a/internal/controller/autoscaling/testdata/controller/forced-write-pacing/should-force-the-next-stuck-scale-down-step-after-one-sync-period.yaml
+++ b/internal/controller/autoscaling/testdata/controller/forced-write-pacing/should-force-the-next-stuck-scale-down-step-after-one-sync-period.yaml
@@ -34,7 +34,7 @@
     "deferredSince": "0s"
     "applied": 1
     "condition":
-      "status": "False"
+      "status": "True"
       "reason": "DeferralTimedOut"
       "messageContains":
       - "scaling 3 -> 1 anyway"
diff --git a/internal/controller/autoscaling/testdata/controller/forced-write-pacing/should-not-take-a-second-forced-step-until-a-sync-period-has-elapsed.yaml b/internal/controller/autoscaling/testdata/controller/forced-write-pacing/should-not-take-a-second-forced-step-until-a-sync-period-has-elapsed.yaml
index 6e348a5..ac2353a 100644
--- a/internal/controller/autoscaling/testdata/controller/forced-write-pacing/should-not-take-a-second-forced-step-until-a-sync-period-has-elapsed.yaml
+++ b/internal/controller/autoscaling/testdata/controller/forced-write-pacing/should-not-take-a-second-forced-step-until-a-sync-period-has-elapsed.yaml
@@ -30,6 +30,8 @@
   "steps":
   - {}
   - "replicas": 3
+    "lastScaleTime": "set"
+    "observedGenerationCurrent": true
   - {}
   - "replicas": 3
     "requeueAfter": "15s"
@@ -39,6 +41,7 @@
       "status": "True"
       "messageContains":
       - "forced write paced to one per sync period"
+    "lastScaleTime": "unchanged"
   - "replicas": 3
     "requeueAfter": "1s"
     "deferredSince": "0s"
diff --git a/internal/controller/autoscaling/testdata/controller/metric-scaling/should-keep-the-ready-replica-fallback-for-the-scaling-ratio-only.yaml b/internal/controller/autoscaling/testdata/controller/metric-scaling/should-keep-the-ready-replica-fallback-for-the-scaling-ratio-only.yaml
index c182d5a..35394e9 100644
--- a/internal/controller/autoscaling/testdata/controller/metric-scaling/should-keep-the-ready-replica-fallback-for-the-scaling-ratio-only.yaml
+++ b/internal/controller/autoscaling/testdata/controller/metric-scaling/should-keep-the-ready-replica-fallback-for-the-scaling-ratio-only.yaml
@@ -18,5 +18,5 @@
     "applied": 5
     "deferredSince": null
     "condition":
-      "status": "False"
-      "reason": "NotDeferred"
+      "status": "True"
+      "reason": "Synced"
diff --git a/internal/controller/autoscaling/testdata/controller/scaling-limited/should-leave-scalinglimited-unchanged-when-prometheus-is-unreachable.yaml b/internal/controller/autoscaling/testdata/controller/scaling-limited/should-leave-scalinglimited-unchanged-when-prometheus-is-unreachable.yaml
new file mode 100644
index 0000000..8d9e936
--- /dev/null
+++ b/internal/controller/autoscaling/testdata/controller/scaling-limited/should-leave-scalinglimited-unchanged-when-prometheus-is-unreachable.yaml
@@ -0,0 +1,47 @@
+# The first sync records DesiredWithinRange. Closing Prometheus makes
+# ScalingActive False, and raising maxReplicas bumps generation, so a
+# rewritten ScalingLimited would carry the new generation. It keeps the old one.
+"name": "should-leave-scalinglimited-unchanged-when-prometheus-is-unreachable"
+"description": "should leave ScalingLimited unchanged when Prometheus is unreachable"
+"inputs":
+  "metric": "0.5"
+  "steps":
+  - "by": "recording DesiredWithinRange from a usable signal"
+    "at": "0s"
+  - "by": "losing Prometheus and bumping generation"
+    "at": "0s"
+    "closeServer": true
+    "maxReplicas": 9
+"expected":
+  "steps":
+  - "replicas": 1
+    "desired": 1
+    "limited":
+      "status": "False"
+      "reason": "DesiredWithinRange"
+      "messageContains":
+      - "the desired count is within the acceptable range"
+      "observedGenerationCurrent": true
+    "decision":
+      "status": "True"
+      "reason": "MetricsAvailable"
+  - "replicas": 1
+    "desired": 1
+    "generationGreaterThan": 1
+    "decision":
+      "status": "False"
+      "reason": "DecisionUnavailable"
+      "messageContains":
+      - "no prometheus metric could be evaluated"
+      "observedGenerationCurrent": true
+    "condition":
+      "status": "True"
+      "reason": "Synced"
+      "messageContains":
+      - "already at the step target"
+    "limited":
+      "status": "False"
+      "reason": "DesiredWithinRange"
+      "messageContains":
+      - "the desired count is within the acceptable range"
+      "observedGenerationStale": true
diff --git a/internal/controller/autoscaling/testdata/controller/scaling-limited/should-report-desired-within-range.yaml b/internal/controller/autoscaling/testdata/controller/scaling-limited/should-report-desired-within-range.yaml
new file mode 100644
index 0000000..e3b97f0
--- /dev/null
+++ b/internal/controller/autoscaling/testdata/controller/scaling-limited/should-report-desired-within-range.yaml
@@ -0,0 +1,21 @@
+# ceil(1 * 0.85/0.5) = 2, inside minReplicas 1 and maxReplicas 5, and no step cap.
+"name": "should-report-desired-within-range"
+"description": "should report ScalingLimited DesiredWithinRange when nothing bounds the recommendation"
+"inputs":
+  "steps":
+  - "by": "scaling within min and max with no step cap"
+"expected":
+  "steps":
+  - "replicas": 2
+    "desired": 2
+    "condition":
+      "status": "True"
+      "reason": "Synced"
+      "messageContains":
+      - "scaled 1 -> 2"
+    "limited":
+      "status": "False"
+      "reason": "DesiredWithinRange"
+      "messageContains":
+      - "the desired count is within the acceptable range"
+      "observedGenerationCurrent": true
diff --git a/internal/controller/autoscaling/testdata/controller/scaling-limited/should-report-scaledownlimit.yaml b/internal/controller/autoscaling/testdata/controller/scaling-limited/should-report-scaledownlimit.yaml
new file mode 100644
index 0000000..3ceddb2
--- /dev/null
+++ b/internal/controller/autoscaling/testdata/controller/scaling-limited/should-report-scaledownlimit.yaml
@@ -0,0 +1,33 @@
+# ceil(5 * 0/0.5) = 0, which is also below minReplicas. maxStepReplicas changes
+# the write from 1 to 3, so ScaleDownLimit wins over TooFewReplicas.
+"name": "should-report-scaledownlimit"
+"description": "should report ScalingLimited ScaleDownLimit when maxStepReplicas caps the write"
+"inputs":
+  "spec":
+    "maxStepReplicas": 2
+  "metric": "0"
+  "steps":
+  - "by": "taking one capped step down from 5"
+    "deploy":
+      "spec": 5
+      "replicas": 5
+      "updated": 5
+      "ready": 5
+      "available": 5
+"expected":
+  "steps":
+  - "replicas": 3
+    "desired": 1
+    "applied": 3
+    "condition":
+      "status": "True"
+      "reason": "Synced"
+      "messageContains":
+      - "scaled 5 -> 3"
+    "limited":
+      "status": "True"
+      "reason": "ScaleDownLimit"
+      "messageContains":
+      - "the desired replica count is decreasing faster than the maximum scale rate"
+      - "maxStepReplicas 2"
+      "observedGenerationCurrent": true
diff --git a/internal/controller/autoscaling/testdata/controller/scaling-limited/should-report-too-few-replicas.yaml b/internal/controller/autoscaling/testdata/controller/scaling-limited/should-report-too-few-replicas.yaml
new file mode 100644
index 0000000..c4c0900
--- /dev/null
+++ b/internal/controller/autoscaling/testdata/controller/scaling-limited/should-report-too-few-replicas.yaml
@@ -0,0 +1,36 @@
+# ceil(5 * 0/0.5) = 0, raised to minReplicas 3. No step cap, so TooFewReplicas.
+"name": "should-report-too-few-replicas"
+"description": "should report ScalingLimited TooFewReplicas when the recommendation is raised to minReplicas"
+"inputs":
+  "spec":
+    "minReplicas": 3
+  "metric": "0"
+  "steps":
+  - "by": "scaling an idle fleet up to minReplicas"
+    "deploy":
+      "spec": 5
+      "replicas": 5
+      "updated": 5
+      "ready": 5
+      "available": 5
+"expected":
+  "steps":
+  - "replicas": 3
+    "desired": 3
+    "applied": 3
+    "condition":
+      "status": "True"
+      "reason": "Synced"
+      "messageContains":
+      - "scaled 5 -> 3"
+    "decision":
+      "status": "True"
+      "reason": "MetricsAvailable"
+      "messageContains":
+      - "recommends 0 replicas"
+    "limited":
+      "status": "True"
+      "reason": "TooFewReplicas"
+      "messageContains":
+      - "the desired replica count is less than the minimum replica count"
+      "observedGenerationCurrent": true
diff --git a/internal/controller/autoscaling/testdata/controller/scaling-limited/should-report-too-many-replicas.yaml b/internal/controller/autoscaling/testdata/controller/scaling-limited/should-report-too-many-replicas.yaml
new file mode 100644
index 0000000..058a153
--- /dev/null
+++ b/internal/controller/autoscaling/testdata/controller/scaling-limited/should-report-too-many-replicas.yaml
@@ -0,0 +1,28 @@
+# ceil(1 * 3/0.5) = 6, capped at maxReplicas 5.
+"name": "should-report-too-many-replicas"
+"description": "should report ScalingLimited TooManyReplicas when the recommendation is capped at maxReplicas"
+"inputs":
+  "metric": "3"
+  "steps":
+  - "by": "scaling a hot metric up to maxReplicas"
+"expected":
+  "steps":
+  - "replicas": 5
+    "desired": 5
+    "applied": 5
+    "condition":
+      "status": "True"
+      "reason": "Synced"
+      "messageContains":
+      - "scaled 1 -> 5"
+    "decision":
+      "status": "True"
+      "reason": "MetricsAvailable"
+      "messageContains":
+      - "recommends 6 replicas"
+    "limited":
+      "status": "True"
+      "reason": "TooManyReplicas"
+      "messageContains":
+      - "the desired replica count is more than the maximum replica count"
+      "observedGenerationCurrent": true
diff --git a/internal/controller/autoscaling/testdata/controller/stabilization-and-step/should-hold-for-the-stabilization-window-between-scale-down-steps.yaml b/internal/controller/autoscaling/testdata/controller/stabilization-and-step/should-hold-for-the-stabilization-window-between-scale-down-steps.yaml
index 0c78180..d846fb3 100644
--- a/internal/controller/autoscaling/testdata/controller/stabilization-and-step/should-hold-for-the-stabilization-window-between-scale-down-steps.yaml
+++ b/internal/controller/autoscaling/testdata/controller/stabilization-and-step/should-hold-for-the-stabilization-window-between-scale-down-steps.yaml
@@ -25,5 +25,17 @@
   "steps":
   - {}
   - "replicas": 3
-  - {}
+    "condition":
+      "status": "True"
+      "reason": "Synced"
+      "messageContains":
+      - "scaled 5 -> 3"
+  - "replicas": 3
+    "desired": 3
+    "deferredSince": null
+    "condition":
+      "status": "True"
+      "reason": "ScaleDownStabilized"
+      "messageContains":
+      - "recent recommendations were higher than current one, applying the highest recent recommendation"
   - "replicas": 3
diff --git a/internal/controller/autoscaling/testdata/controller/stabilization-and-step/should-let-a-settle-guard-win-over-stabilization.yaml b/internal/controller/autoscaling/testdata/controller/stabilization-and-step/should-let-a-settle-guard-win-over-stabilization.yaml
new file mode 100644
index 0000000..2e5fe9f
--- /dev/null
+++ b/internal/controller/autoscaling/testdata/controller/stabilization-and-step/should-let-a-settle-guard-win-over-stabilization.yaml
@@ -0,0 +1,68 @@
+# The window is holding 5 when the fleet is moved to 8 with only 6 ready.
+# Stabilization would still name ScaleDownStabilized, but the settle guard is
+# deferring the write, so ScaleDownSettling wins. The previous
+# ScaleDownStabilized counts as a changed reason, and ScalingDeferred fires once.
+"name": "should-let-a-settle-guard-win-over-stabilization"
+"description": "should let a settle guard win over stabilization"
+"inputs":
+  "spec":
+    "stabilizationWindowSeconds": 300
+  "steps":
+  - "by": "recording a recommendation of 5"
+    "at": "0s"
+    "metric": "0.5"
+    "deploy":
+      "spec": 5
+      "replicas": 5
+      "updated": 5
+      "ready": 5
+      "available": 5
+  - "by": "dipping the metric so the window, not Synced, describes the no-op"
+    "at": "10s"
+    "metric": "0"
+  - "by": "deferring the stabilized scale-down while the fleet is short of ready"
+    "at": "20s"
+    "metric": "0"
+    "deploy":
+      "spec": 8
+      "replicas": 8
+      "updated": 8
+      "ready": 6
+      "available": 6
+"expected":
+  "steps":
+  - "replicas": 5
+    "desired": 5
+    "deferredSince": null
+    "condition":
+      "status": "True"
+      "reason": "Synced"
+    "noMoreEvents": true
+  - "replicas": 5
+    "desired": 5
+    "deferredSince": null
+    "condition":
+      "status": "True"
+      "reason": "ScaleDownStabilized"
+      "messageContains":
+      - "recent recommendations were higher than current one, applying the highest recent recommendation"
+    "noMoreEvents": true
+  - "replicas": 8
+    "desired": 5
+    "applied": 8
+    "current": 6
+    "deferredSince": "20s"
+    "requeueAfter": "15s"
+    "condition":
+      "status": "True"
+      "reason": "ScaleDownSettling"
+      "messageContains":
+      - "holding 8 replicas (wanted 5)"
+      - "previous scale-down has not settled"
+    "events":
+    - "contains":
+      - "ScalingDeferred"
+      - "holding 8 replicas (wanted 5)"
+      - "previous scale-down has not settled"
+    "noMoreEvents": true
+    "lastScaleTime": "unset"
diff --git a/internal/controller/autoscaling/testdata/controller/stabilization-and-step/should-report-scaledownstabilized-on-a-stabilized-no-op.yaml b/internal/controller/autoscaling/testdata/controller/stabilization-and-step/should-report-scaledownstabilized-on-a-stabilized-no-op.yaml
new file mode 100644
index 0000000..4d5be4c
--- /dev/null
+++ b/internal/controller/autoscaling/testdata/controller/stabilization-and-step/should-report-scaledownstabilized-on-a-stabilized-no-op.yaml
@@ -0,0 +1,60 @@
+# First sync records 5. The dip to 0 would clamp to minReplicas, but the window
+# keeps 5, so the sync is a no-op. AbleToScale is ScaleDownStabilized and the
+# deferral is cleared, the same as a Synced no-op. No ScalingDeferred event.
+"name": "should-report-scaledownstabilized-on-a-stabilized-no-op"
+"description": "should report ScaleDownStabilized on a stabilized no-op"
+"inputs":
+  "spec":
+    "stabilizationWindowSeconds": 300
+  "metric": "0.5"
+  "deploy":
+    "spec": 5
+    "replicas": 5
+    "updated": 5
+    "ready": 5
+    "available": 5
+  "steps":
+  - "by": "recording the recommendation the window will hold"
+    "at": "0s"
+  - "by": "dipping the metric inside the window"
+    "at": "10s"
+    "metric": "0"
+"expected":
+  "steps":
+  - "replicas": 5
+    "desired": 5
+    "applied": 5
+    "deferredSince": null
+    "condition":
+      "status": "True"
+      "reason": "Synced"
+      "messageContains":
+      - "already at the step target"
+    "limited":
+      "status": "False"
+      "reason": "DesiredWithinRange"
+      "messageContains":
+      - "the desired count is within the acceptable range"
+    "noMoreEvents": true
+  - "replicas": 5
+    "desired": 5
+    "applied": 5
+    "current": 5
+    "deferredSince": null
+    "condition":
+      "status": "True"
+      "reason": "ScaleDownStabilized"
+      "messageContains":
+      - "recent recommendations were higher than current one, applying the highest recent recommendation"
+    "decision":
+      "status": "True"
+      "reason": "MetricsAvailable"
+      "messageContains":
+      - "recommends 0 replicas"
+    "limited":
+      "status": "True"
+      "reason": "TooFewReplicas"
+      "messageContains":
+      - "the desired replica count is less than the minimum replica count"
+    "lastScaleTime": "unset"
+    "noMoreEvents": true
diff --git a/internal/controller/autoscaling/testdata/controller/stabilization-and-step/should-report-scaledownstabilized-when-the-window-still-allows-a-scale-down.yaml b/internal/controller/autoscaling/testdata/controller/stabilization-and-step/should-report-scaledownstabilized-when-the-window-still-allows-a-scale-down.yaml
new file mode 100644
index 0000000..aaf3a47
--- /dev/null
+++ b/internal/controller/autoscaling/testdata/controller/stabilization-and-step/should-report-scaledownstabilized-when-the-window-still-allows-a-scale-down.yaml
@@ -0,0 +1,54 @@
+# The window holds a recent recommendation of 3 while the raw count clamps to
+# minReplicas. Spec is 5, so the sync still writes, and AbleToScale names the
+# window rather than Synced. The write is the step target.
+"name": "should-report-scaledownstabilized-when-the-window-still-allows-a-scale-down"
+"description": "should report ScaleDownStabilized when the window still allows a scale-down"
+"inputs":
+  "spec":
+    "stabilizationWindowSeconds": 300
+  "steps":
+  - "by": "recording a recommendation of 3"
+    "at": "0s"
+    "metric": "0.5"
+    "deploy":
+      "spec": 3
+      "replicas": 3
+      "updated": 3
+      "ready": 3
+      "available": 3
+  - "by": "scaling down only as far as the window allows"
+    "at": "10s"
+    "metric": "0"
+    "deploy":
+      "spec": 5
+      "replicas": 5
+      "updated": 5
+      "ready": 5
+      "available": 5
+"expected":
+  "steps":
+  - "replicas": 3
+    "desired": 3
+    "deferredSince": null
+    "condition":
+      "status": "True"
+      "reason": "Synced"
+      "messageContains":
+      - "already at the step target"
+    "noMoreEvents": true
+  - "replicas": 3
+    "desired": 3
+    "applied": 3
+    "deferredSince": null
+    "condition":
+      "status": "True"
+      "reason": "ScaleDownStabilized"
+      "messageContains":
+      - "recent recommendations were higher than current one, applying the highest recent recommendation"
+    "limited":
+      "status": "True"
+      "reason": "TooFewReplicas"
+      "messageContains":
+      - "the desired replica count is less than the minimum replica count"
+    "lastScaleTime": "set"
+    "noMoreEvents": true
diff --git a/internal/controller/autoscaling/testdata/helpers/query-prometheus-scalar/a-non-200-body-longer-than-1kib-is-truncated.yaml b/internal/controller/autoscaling/testdata/helpers/query-prometheus-scalar/a-non-200-body-longer-than-1kib-is-truncated.yaml
new file mode 100644
index 0000000..88e0e6a
--- /dev/null
+++ b/internal/controller/autoscaling/testdata/helpers/query-prometheus-scalar/a-non-200-body-longer-than-1kib-is-truncated.yaml
@@ -0,0 +1,9 @@
+"name": "a-non-200-body-longer-than-1kib-is-truncated"
+"description": "a non-200 body longer than 1 KiB is truncated"
+"inputs":
+  "status": 500
+  "errorBodyBytes": 4096
+"expected":
+  "truncatedBodyBytes": 1024
+  "errorContains":
+  - "prometheus returned status 500"
diff --git a/internal/controller/autoscaling/testdata/helpers/recommend-custom/a-missing-customprovider-holds-the-fleet-where-it-is.yaml b/internal/controller/autoscaling/testdata/helpers/recommend-custom/a-missing-customprovider-holds-the-fleet-where-it-is.yaml
index 33ecae8..7429797 100644
--- a/internal/controller/autoscaling/testdata/helpers/recommend-custom/a-missing-customprovider-holds-the-fleet-where-it-is.yaml
+++ b/internal/controller/autoscaling/testdata/helpers/recommend-custom/a-missing-customprovider-holds-the-fleet-where-it-is.yaml
@@ -13,3 +13,5 @@
   "pinAPIVersion": true
 "expected":
   "replicas": 8
+  "holdReason": "InvalidSpec"
+  "holdMessageContains": "spec.customProvider is not set"
diff --git a/internal/controller/autoscaling/testdata/helpers/recommend-custom/an-unreadable-decision-holds-the-fleet-where-it-is.yaml b/internal/controller/autoscaling/testdata/helpers/recommend-custom/an-unreadable-decision-holds-the-fleet-where-it-is.yaml
index 26c0199..4dd07f1 100644
--- a/internal/controller/autoscaling/testdata/helpers/recommend-custom/an-unreadable-decision-holds-the-fleet-where-it-is.yaml
+++ b/internal/controller/autoscaling/testdata/helpers/recommend-custom/an-unreadable-decision-holds-the-fleet-where-it-is.yaml
@@ -11,3 +11,5 @@
   "apiVersion": "some.other.api/v1"
 "expected":
   "replicas": 8
+  "holdReason": "DecisionUnavailable"
+  "holdMessageContains": "custom provider returned no decision"