Please address the comments from this code review:

## Overall Comments
- There are now three separate mapping implementations between `storage.Cluster` and `v1.ClusterConfig` (central service, sensor generate, plus the implicit proto identity), which makes it easy for fields to drift; consider centralizing these conversions in a shared helper/package so new/changed fields only need to be wired in one place.
- The notion of "server‑managed" fields (status, health_status, helm_config, etc.) is currently enforced only implicitly in `convertAPIClusterToStorage`; it may be safer to capture this set in a single, clearly named helper or configuration so future contributors don’t accidentally start persisting client-supplied values for those fields.

## Individual Comments

### Comment 1
<location path="central/cluster/service/convert.go" line_range="11-20" />
<code_context>
+func convertStorageClusterToAPI(cluster *storage.Cluster) *v1.ClusterConfig {
</code_context>
<issue_to_address>
**suggestion:** Manual 1:1 field mapping in both conversion functions is fragile and may drift as proto definitions evolve.

Both `convertStorageClusterToAPI` and `convertAPIClusterToStorage` manually copy every field, which is easy to miss when new fields are added, contradicting the comment that all fields are copied. Please consider a more robust pattern (shared helper, codegen, or tests/compile-time checks such as round-trip `proto.Equal`) so new fields can’t be accidentally omitted.

Suggested implementation:

```golang
import (
	v1 "github.com/stackrox/rox/generated/api/v1"
	"github.com/stackrox/rox/generated/storage"
	"google.golang.org/protobuf/encoding/protojson"
)

```

```golang
 // convertStorageClusterToAPI converts a storage.Cluster to the API representation.
 // All fields are copied 1:1 via protojson. The API type is structurally identical to the storage
 // type today; they are separated to allow independent evolution in the future. Using protojson
 // reduces the risk of fields drifting as proto definitions evolve.
func convertStorageClusterToAPI(cluster *storage.Cluster) *v1.ClusterConfig {
	if cluster == nil {
		return nil
	}

	out := &v1.ClusterConfig{}

	// Use protojson to perform a structural copy so newly-added fields are automatically handled
	// as long as the underlying proto definitions remain structurally compatible.
	bytes, err := protojson.Marshal(cluster)
	if err != nil {
		// In the unlikely event of an error, return an empty config rather than partially populated data.
		// Callers should treat a nil cluster input as the primary "no config" signal.
		return out
	}

	if err := protojson.Unmarshal(bytes, out); err != nil {
		return out
	}

	return out

```

To fully implement the suggestion for both directions, the same pattern should be applied to `convertAPIClusterToStorage`, replacing its manual 1:1 field assignments with a protojson-based structural copy (marshal the `*v1.ClusterConfig` to JSON, then unmarshal into `*storage.Cluster`). This will ensure that both conversion functions automatically handle newly added fields as long as the proto messages remain structurally compatible.
</issue_to_address>