Please address the comments from this code review:

## Individual Comments

### Comment 1
<location path="sensor/common/virtualmachine/index/handler_impl_test.go" line_range="341-345" />
<code_context>
 	s.Require().NotNil(ch)
 }
+
+func (s *virtualMachineHandlerSuite) TestSend_CapabilityNotSupported() {
+	// Remove capability to simulate old Central version
+	centralcaps.Set(nil)
+
+	cid := "1"
+	vm := &v1.IndexReport{VsockCid: cid}
+
+	// Send should return errCapabilityNotSupported when capability is absent
+	err := s.handler.Send(context.Background(), vm)
+	s.Require().Error(err)
+	s.Assert().ErrorContains(err, "Central does not have virtual machine capability")
+}
</code_context>
<issue_to_address>
**suggestion (testing):** Strengthen the assertion by checking the specific error value/sentinel instead of only using ErrorContains

Asserting the concrete error (e.g. `errCapabilityNotSupported`) instead of only using a substring match will make this test more resilient to future message wording changes and will more directly verify that the handler returns the expected guard error when the capability is absent. You could use `s.Require().ErrorIs(err, errCapabilityNotSupported)` (or equivalent) in place of, or alongside, `ErrorContains`.

```suggestion
	// Send should return errCapabilityNotSupported when capability is absent
	err := s.handler.Send(context.Background(), vm)
	s.Require().Error(err)
	s.Require().ErrorIs(err, errCapabilityNotSupported)
	s.Assert().ErrorContains(err, "Central does not have virtual machine capability")
}
```
</issue_to_address>

### Comment 2
<location path="sensor/kubernetes/listener/resources/virtualmachine/dispatcher/virtualmachines_test.go" line_range="279-286" />
<code_context>
 			},
 			expectedMsg: nil,
 		},
+		"feature flag disabled": {
+			action: central.ResourceAction_CREATE_RESOURCE,
+			obj:    toUnstructured(newVirtualMachineInstance(vmiUID, vmiName, vmiNamespace, ownerUID, nil, v1.Scheduled)),
+			expectFn: func() {
+				s.T().Setenv(features.VirtualMachines.EnvVar(), "false")
+			},
+			expectedMsg: nil,
+		},
 	}
</code_context>
<issue_to_address>
**suggestion (testing):** Tighten the "feature flag disabled" case by explicitly setting capabilities to avoid ambiguity in what guard is exercised

This case is meant to exercise the feature-flag-disabled path, but it doesn’t configure Central capabilities. To ensure the test fails only when the feature-flag guard regresses (and not due to missing capabilities or global state), set the VM capability to a supported state in `expectFn` before disabling the feature flag.

```suggestion
		"feature flag disabled": {
			action: central.ResourceAction_CREATE_RESOURCE,
			obj:    toUnstructured(newVirtualMachine(vmUID, vmName, vmNamespace, v1.VirtualMachineStatusStopped)),
			expectFn: func() {
				// Ensure capabilities are in a supported state so this case
				// specifically validates the feature-flag guard.
				centralcaps.Set(&centralcaps.Config{
					VirtualMachines: true,
				})
				s.T().Setenv(features.VirtualMachines.EnvVar(), "false")
			},
			expectedMsg: nil,
		},
```
</issue_to_address>