@@ -185,6 +185,36 @@ func isDataVolumeReady(dv *unstructured.Unstructured) bool {
 	return !dataVolumeInFlightPhases[phase]
 }
 
+// dataVolumeFailureMessage returns why the DataVolume's pod is not running, or
+// "" when nothing says so. A source that keeps failing (404, DNS) never moves
+// the phase off ImportInProgress, because CDI only fails the import on a fatal
+// error and restarts the pod otherwise (updateStatusPhase in
+// pkg/controller/datavolume/import-controller.go). The Running condition holds
+// the clean error text: CDI keeps it through the back-off between restarts and
+// clears it while the pod runs, and Bound repeats it behind PVC details.
+// Unknown is not a failure, so only False is read. For a host-assisted clone
+// CDI joins the target and source messages as "<target> and <source>"
+// (updateWithTargetNotRunning in pkg/controller/datavolume/conditions.go), so
+// empty halves are dropped instead of reporting " and ".
+func dataVolumeFailureMessage(dv *unstructured.Unstructured) string {
+	conditions, _, _ := unstructured.NestedSlice(dv.Object, "status", "conditions")
+	for _, c := range conditions {
+		cond, ok := c.(map[string]any)
+		if !ok || cond["type"] != "Running" || cond["status"] != "False" {
+			continue
+		}
+		message, _ := cond["message"].(string)
+		var parts []string
+		for _, part := range strings.Split(message, " and ") {
+			if part != "" {
+				parts = append(parts, part)
+			}
+		}
+		return strings.Join(parts, " and ")
+	}
+	return ""
+}
+
 // dataVolumeAPIServed treats a NoMatch as not served and returns any other
 // discovery error, so the caller retries instead of concluding CDI is absent.
 func dataVolumeAPIServed(mapper meta.RESTMapper) (bool, error) {
@@ -315,11 +345,14 @@ func (r *WorkloadMonitorReconciler) dataVolumesMessage(ctx context.Context, moni
 		}
 		notReady[dv.GetName()] = true
 		phase, _, _ := unstructured.NestedString(dv.Object, "status", "phase")
+		entry := fmt.Sprintf("DataVolume %s is %s", dv.GetName(), phase)
 		if phase == "" {
-			stuck = append(stuck, fmt.Sprintf("DataVolume %s has no phase", dv.GetName()))
-		} else {
-			stuck = append(stuck, fmt.Sprintf("DataVolume %s is %s", dv.GetName(), phase))
+			entry = fmt.Sprintf("DataVolume %s has no phase", dv.GetName())
+		}
+		if cause := dataVolumeFailureMessage(dv); cause != "" {
+			entry += ": " + cause
 		}
+		stuck = append(stuck, entry)
 	}
 	sort.Strings(stuck)
 	return strings.Join(stuck, "; "), notReady, true, nil
 
@@ -1648,6 +1648,81 @@ func TestReconcile_DataVolumeMessageNamesTheDiskAndPhase(t *testing.T) {
 	}
 }
 
+func withRunningCondition(dv *unstructured.Unstructured, status, reason, message string) *unstructured.Unstructured {
+	_ = unstructured.SetNestedSlice(dv.Object, []any{map[string]any{
+		"type":    "Running",
+		"status":  status,
+		"reason":  reason,
+		"message": message,
+	}}, "status", "conditions")
+	return dv
+}
+
+func TestReconcile_DataVolumeMessageCarriesTheImporterError(t *testing.T) {
+	selected := map[string]string{"app.kubernetes.io/instance": "vm-disk-test"}
+	phase := func(p string) *string { return &p }
+	// Running conditions CDI v1.64 wrote for importers that kept failing; only
+	// the host name is changed. v1.66 builds the condition the same way for a
+	// single-container importer.
+	const (
+		http404 = "Unable to connect to http data source: expected status code 200, got 404. Status: 404 Not Found"
+		noHost  = `Unable to connect to http data source: HTTP request errored: Get "http://image.example.invalid/disk.img": dial tcp: lookup image.example.invalid on 10.96.0.10:53: no such host`
+	)
+	cases := []struct {
+		name                    string
+		phase                   *string
+		status, reason, message string
+		want                    string
+	}{
+		{"404 from the source", phase("ImportInProgress"), "False", "Error", http404,
+			"DataVolume vm-disk-test is ImportInProgress: " + http404},
+		{"unresolvable host", phase("ImportInProgress"), "False", "Error", noHost,
+			"DataVolume vm-disk-test is ImportInProgress: " + noHost},
+		{"unschedulable importer", phase("ImportScheduled"), "False", "Unschedulable", "Importer pod cannot be scheduled",
+			"DataVolume vm-disk-test is ImportScheduled: Importer pod cannot be scheduled"},
+		{"fatal checksum error", phase("Failed"), "False", "ChecksumError", "checksum mismatch",
+			"DataVolume vm-disk-test is Failed: checksum mismatch"},
+		{"no phase", nil, "False", "Error", http404,
+			"DataVolume vm-disk-test has no phase: " + http404},
+		{"importer not started yet", phase("ImportScheduled"), "False", "", "",
+			"DataVolume vm-disk-test is ImportScheduled"},
+		{"importer running", phase("ImportInProgress"), "True", "Pod is running", "transferring",
+			"DataVolume vm-disk-test is ImportInProgress"},
+		{"source state unknown", phase("CloneInProgress"), "Unknown", "Pending and Unknown", "Pod Pending and source state unknown",
+			"DataVolume vm-disk-test is CloneInProgress"},
+		{"clone pods both waiting without a message", phase("CloneInProgress"), "False", "ContainerCreating and ContainerCreating", " and ",
+			"DataVolume vm-disk-test is CloneInProgress"},
+		{"only the source pod has a message", phase("CloneInProgress"), "False", "ContainerCreating and Error", " and source unreachable",
+			"DataVolume vm-disk-test is CloneInProgress: source unreachable"},
+		{"both clone pods have a message", phase("CloneInProgress"), "False", "Pending and Pending", "Pod Pending and Pod Pending",
+			"DataVolume vm-disk-test is CloneInProgress: Pod Pending and Pod Pending"},
+		{"populated", phase("Succeeded"), "False", "Completed", "Import Complete", ""},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			dv := withRunningCondition(newDataVolume("vm-disk-test", selected, tc.phase), tc.status, tc.reason, tc.message)
+			got := reconcileDataVolumeMonitor(t, true, nil, dv)
+			if got.Status.Message != tc.want {
+				t.Errorf("Message = %q, want %q", got.Status.Message, tc.want)
+			}
+		})
+	}
+
+	t.Run("only the Running condition is read", func(t *testing.T) {
+		dv := withRunningCondition(newDataVolume("vm-disk-test", selected, phase("ImportInProgress")), "True", "Pod is running", "")
+		conditions, _, _ := unstructured.NestedSlice(dv.Object, "status", "conditions")
+		conditions = append([]any{map[string]any{
+			"type": "Bound", "status": "False", "reason": "Pending",
+			"message": "target PVC vm-disk-test Pending and [prime-1] : " + http404,
+		}}, conditions...)
+		_ = unstructured.SetNestedSlice(dv.Object, conditions, "status", "conditions")
+		got := reconcileDataVolumeMonitor(t, true, nil, dv)
+		if want := "DataVolume vm-disk-test is ImportInProgress"; got.Status.Message != want {
+			t.Errorf("Message = %q, want %q", got.Status.Message, want)
+		}
+	})
+}
+
 func TestReconcile_PopulatedDataVolumeClearsTheLastVerdict(t *testing.T) {
 	s := newTestScheme()
 	selector := map[string]string{"app.kubernetes.io/instance": "vm-disk-test"}
 
@@ -4,7 +4,7 @@ A Virtual Machine Disk
 
 > `storageClass` and `source` are annotated as immutable in the chart schema — see [`docs/storage-immutability.md`](../../../docs/storage-immutability.md) for the contract and which consumers enforce it. `DataVolume.spec` is immutable in CDI, so the chart also fails the release on an attempted `storageClass`/`source` edit of an existing disk rather than silently reusing the old spec; delete and recreate the disk to change either field.
 
-> Whether CDI has finished populating the disk shows up in the `WorkloadsReady` condition, not in `Ready`, which follows the Helm release and does not wait on the DataVolume: `WorkloadsReady` stays `False` while an import, clone or upload is in flight and when the DataVolume fails. Its message names the DataVolume and the phase it is in, `kubectl get vmdisks` shows the condition in the `WORKLOADS` column, and the console badge reads `DataVolumeNotReady` until it is `True`. A disk created before this behaviour was introduced keeps its old release settings, under which `Ready` may wait on the DataVolume, until its application is next updated. A `source.upload` disk reads `False` from the moment it is created until `virtctl image-upload` completes, because CDI reports waiting for the upload and receiving it as one phase. A disk counts as ready while it waits for its consumer with `bindImmediately` off on a `WaitForFirstConsumer` class, because that is a state such a disk is supposed to rest in.
+> Whether CDI has finished populating the disk shows up in the `WorkloadsReady` condition, not in `Ready`, which follows the Helm release and does not wait on the DataVolume: `WorkloadsReady` stays `False` while an import, clone or upload is in flight and when the DataVolume fails. Its message names the DataVolume and the phase it is in, followed by the error CDI reports for the pod populating the disk when there is one, such as a 404 or an unresolvable host on an HTTP source: CDI keeps retrying such an import, so its phase stays `ImportInProgress`, and the error is shown between retries rather than while a retry is running. `kubectl get vmdisks` shows the condition in the `WORKLOADS` column, and the console badge reads `DataVolumeNotReady` until it is `True`. A disk created before this behaviour was introduced keeps its old release settings, under which `Ready` may wait on the DataVolume, until its application is next updated. A `source.upload` disk reads `False` from the moment it is created until `virtctl image-upload` completes, because CDI reports waiting for the upload and receiving it as one phase. A disk counts as ready while it waits for its consumer with `bindImmediately` off on a `WaitForFirstConsumer` class, because that is a state such a disk is supposed to rest in.
 
 > `bindImmediately` is on by default, so a disk's volume is provisioned when the disk is created rather than deferred to the first consumer. That default exists because a VMDisk is a standalone object with a lifecycle of its own: on a `WaitForFirstConsumer` StorageClass a disk that no VM has attached yet would otherwise never populate at all. It costs something on a node-pinned class such as `local`, where the CDI worker pod becomes the first consumer and the volume lands where that pod was scheduled rather than where the VM will run, so a VM whose placement is constrained (a `nodeSelector`, a resource request only one node satisfies, or the Windows affinity applied by `_cluster.scheduling.dedicatedNodesForWindowsVMs`) can stay unschedulable against a node-affinity conflict, and `storageClass` is immutable so the only exit is deleting and recreating the disk. Turn `bindImmediately` off for a disk a VMInstance will consume on such a class: KubeVirt then renders a temporary launcher pod carrying the VM's own affinity and node selector, and the volume binds where the VM can actually run. The chart default `replicated` binds `Immediate` regardless, so neither setting changes anything there.