diff --git a/cypress/e2e/tests/pages/fleet/advanced/bundles.spec.ts b/cypress/e2e/tests/pages/fleet/advanced/bundles.spec.ts
index ae495d0e397..89b76b955ea 100644
--- a/cypress/e2e/tests/pages/fleet/advanced/bundles.spec.ts
+++ b/cypress/e2e/tests/pages/fleet/advanced/bundles.spec.ts
@@ -52,7 +52,7 @@ describe('Bundles', { testIsolation: 'off', tags: ['@fleet', '@adminUser'] }, ()
       fleetBundleeDetailsPage.waitForPage();
 
       // check table headers
-      const expectedHeadersDetailsViewEvents = ['Name'];
+      const expectedHeadersDetailsViewEvents = ['State', 'API Version', 'Kind', 'Name', 'Namespace'];
 
       fleetBundleeDetailsPage.list().resourceTable().sortableTable()
         .tableHeaderRow()
diff --git a/shell/components/ResourceDetail/index.vue b/shell/components/ResourceDetail/index.vue
index 4889fec1d1e..572b39657fe 100644
--- a/shell/components/ResourceDetail/index.vue
+++ b/shell/components/ResourceDetail/index.vue
@@ -171,7 +171,8 @@ export default {
           },
           bundle: {
             inStoreType: 'management',
-            type:        FLEET.BUNDLE
+            type:        FLEET.BUNDLE,
+            opt:         { excludeFields: ['metadata.managedFields', 'spec.resources'] },
           },
 
           bundleDeployment: {
diff --git a/shell/components/fleet/FleetRepos.vue b/shell/components/fleet/FleetRepos.vue
index 2c0d4bae452..d4f5ecca62e 100644
--- a/shell/components/fleet/FleetRepos.vue
+++ b/shell/components/fleet/FleetRepos.vue
@@ -16,7 +16,6 @@ import {
   FLEET_REPO_PER_CLUSTER_STATE
 
 } from '@shell/config/table-headers';
-import { FLEET } from '@shell/config/labels-annotations';
 import { STATES_ENUM } from '@shell/plugins/dashboard-store/resource-class';
 
 // i18n-ignore repoDisplay
@@ -118,12 +117,6 @@ export default {
     parseTargetMode(row) {
       return row.targetInfo?.mode === 'clusterGroup' ? this.t('fleet.gitRepo.warningTooltip.clusterGroup') : this.t('fleet.gitRepo.warningTooltip.cluster');
     },
-
-    clusterViewResourceStatus(row) {
-      return row.clusterResourceStatus.find((c) => {
-        return c.metadata?.labels[FLEET.CLUSTER_NAME] === this.clusterId;
-      });
-    }
   },
 };
 </script>
diff --git a/shell/config/labels-annotations.js b/shell/config/labels-annotations.js
index 19209c14ad5..7e862ca9d99 100644
--- a/shell/config/labels-annotations.js
+++ b/shell/config/labels-annotations.js
@@ -111,6 +111,7 @@ export const FLEET = {
   CLUSTER_NAME:         'management.cattle.io/cluster-name',
   BUNDLE_ID:            'fleet.cattle.io/bundle-id',
   MANAGED:              'fleet.cattle.io/managed',
+  CLUSTER_NAMESPACE:    'fleet.cattle.io/cluster-namespace',
   CLUSTER:              'fleet.cattle.io/cluster'
 };
 
diff --git a/shell/detail/fleet.cattle.io.bundle.vue b/shell/detail/fleet.cattle.io.bundle.vue
index d4ed8a0c8ea..765b19fdf80 100644
--- a/shell/detail/fleet.cattle.io.bundle.vue
+++ b/shell/detail/fleet.cattle.io.bundle.vue
@@ -1,77 +1,25 @@
 <script>
-import { FLEET } from '@shell/config/types';
 import FleetBundleResources from '@shell/components/fleet/FleetBundleResources.vue';
-import SortableTable from '@shell/components/SortableTable';
+import FleetUtils from '@shell/utils/fleet';
 
 export default {
   name: 'FleetBundleDetail',
 
-  components: {
-    FleetBundleResources,
-    SortableTable,
-  },
-  props: {
+  components: { FleetBundleResources },
+  props:      {
     value: {
       type:     Object,
       required: true,
     }
   },
 
-  data() {
-    return { repo: null };
-  },
-
-  async fetch() {
-    const { namespace, labels } = this.value.metadata;
-    const repoName = `${ namespace }/${ labels['fleet.cattle.io/repo-name'] }`;
-
-    if (this.hasRepoLabel) {
-      this.repo = await this.$store.dispatch('management/find', { type: FLEET.GIT_REPO, id: repoName });
-    }
-  },
-
   computed: {
-    hasRepoLabel() {
-      return !!(this.value?.metadata?.labels && this.value?.metadata?.labels['fleet.cattle.io/repo-name']);
-    },
     bundleResources() {
-      if (this.hasRepoLabel) {
-        const bundleResourceIds = this.bundleResourceIds;
-
-        return this.repo?.status?.resources?.filter((resource) => {
-          return bundleResourceIds.includes(resource.name);
-        });
-      } else if (this.value?.spec?.resources?.length) {
-        return this.value?.spec?.resources.map((item) => {
-          return {
-            content: item.content,
-            name:    item.name.includes('.') ? item.name.split('.')[0] : item.name
-          };
-        });
-      }
-
-      return [];
-    },
-    resourceHeaders() {
-      return [
-        {
-          name:     'name',
-          value:    'name',
-          sort:     ['name'],
-          labelKey: 'tableHeaders.name',
-        },
-      ];
+      return FleetUtils.resourcesFromBundleStatus(this.value?.status);
     },
     resourceCount() {
-      return (this.bundleResources && this.bundleResources.length) || this.value?.spec?.resources?.length;
+      return this.bundleResources.length;
     },
-    bundleResourceIds() {
-      if (this.value.status?.resourceKey) {
-        return this.value?.status?.resourceKey.map((item) => item.name);
-      }
-
-      return [];
-    }
   }
 };
 
@@ -84,19 +32,8 @@ export default {
       <span>{{ resourceCount }}</span>
     </div>
     <FleetBundleResources
-      v-if="hasRepoLabel"
       :value="bundleResources"
     />
-    <SortableTable
-      v-else
-      :rows="bundleResources"
-      :headers="resourceHeaders"
-      :table-actions="false"
-      :row-actions="false"
-      key-field="tableKey"
-      default-sort-by="state"
-      :paged="true"
-    />
   </div>
 </template>
 
diff --git a/shell/detail/fleet.cattle.io.gitrepo.vue b/shell/detail/fleet.cattle.io.gitrepo.vue
index 3fcb33628b9..7d00a8f6607 100644
--- a/shell/detail/fleet.cattle.io.gitrepo.vue
+++ b/shell/detail/fleet.cattle.io.gitrepo.vue
@@ -80,7 +80,8 @@ export default {
     const allDispatches = await checkSchemasForFindAllHash({
       allBundles: {
         inStoreType: 'management',
-        type:        FLEET.BUNDLE
+        type:        FLEET.BUNDLE,
+        opt:         { excludeFields: ['metadata.managedFields', 'spec.resources'] },
       },
 
       allBundleDeployments: {
diff --git a/shell/models/fleet.cattle.io.bundle.js b/shell/models/fleet.cattle.io.bundle.js
index fd2fb142f32..9e3443e67f9 100644
--- a/shell/models/fleet.cattle.io.bundle.js
+++ b/shell/models/fleet.cattle.io.bundle.js
@@ -30,7 +30,9 @@ export default class FleetBundle extends SteveModel {
   }
 
   get repoName() {
-    return this.metadata.labels['fleet.cattle.io/repo-name'];
+    const labels = this.metadata?.labels || {};
+
+    return labels['fleet.cattle.io/repo-name'];
   }
 
   get targetClusters() {
diff --git a/shell/models/fleet.cattle.io.gitrepo.js b/shell/models/fleet.cattle.io.gitrepo.js
index 9c8ac614290..8c47ab8637a 100644
--- a/shell/models/fleet.cattle.io.gitrepo.js
+++ b/shell/models/fleet.cattle.io.gitrepo.js
@@ -1,16 +1,17 @@
 import Vue from 'vue';
 import { convert, matching, convertSelectorObj } from '@shell/utils/selector';
 import jsyaml from 'js-yaml';
-import { escapeHtml, randomStr } from '@shell/utils/string';
+import { escapeHtml } from '@shell/utils/string';
 import { FLEET } from '@shell/config/types';
 import { FLEET as FLEET_ANNOTATIONS } from '@shell/config/labels-annotations';
 import { addObject, addObjects, findBy, insertAt } from '@shell/utils/array';
 import { set } from '@shell/utils/object';
 import SteveModel from '@shell/plugins/steve/steve-class';
 import {
-  STATES_ENUM, colorForState, mapStateToEnum, primaryDisplayStatusFromCount, stateDisplay, stateSort
+  colorForState, mapStateToEnum, primaryDisplayStatusFromCount, stateDisplay, stateSort
 } from '@shell/plugins/dashboard-store/resource-class';
 import { NAME } from '@shell/config/product/explorer';
+import FleetUtils from '@shell/utils/fleet';
 
 function quacksLikeAHash(str) {
   if (str.match(/^[a-f0-9]{40,}$/i)) {
@@ -322,35 +323,29 @@ export default class GitRepo extends SteveModel {
   }
 
   get resourcesStatuses() {
-    const clusters = this.targetClusters || [];
-    const resources = this.status?.resources || [];
-    const conditions = this.status?.conditions || [];
+    const bundleDeployments = this.bundleDeployments || [];
+    const clusters = (this.targetClusters || []).reduce((res, c) => {
+      res[c.id] = c;
+
+      return res;
+    }, {});
 
     const out = [];
 
-    for (const c of clusters) {
-      const clusterBundleDeploymentResources = this.bundleDeployments
-        .find((bd) => bd.metadata?.labels?.[FLEET_ANNOTATIONS.CLUSTER] === c.metadata.name)
-        ?.status?.resources || [];
+    for (const bd of bundleDeployments) {
+      const clusterId = FleetUtils.clusterIdFromBundleDeploymentLabels(bd.metadata?.labels);
+      const c = clusters[clusterId];
 
-      resources.forEach((r, i) => {
-        let namespacedName = r.name;
+      if (!c) {
+        continue;
+      }
 
-        if (r.namespace) {
-          namespacedName = `${ r.namespace }:${ r.name }`;
-        }
+      const resources = FleetUtils.resourcesFromBundleDeploymentStatus(bd.status);
 
-        let state = r.state;
-        const perEntry = r.perClusterState?.find((x) => x.clusterId === c.id);
-        const tooMany = r.perClusterState?.length >= 10 || false;
-
-        if (perEntry) {
-          state = perEntry.state;
-        } else if (tooMany) {
-          state = STATES_ENUM.UNKNOWN;
-        } else {
-          state = STATES_ENUM.READY;
-        }
+      resources.forEach((r) => {
+        const id = FleetUtils.resourceId(r);
+        const type = FleetUtils.resourceType(r);
+        const state = r.state;
 
         const color = colorForState(state).replace('text-', 'bg-');
         const display = stateDisplay(state);
@@ -360,33 +355,38 @@ export default class GitRepo extends SteveModel {
           params: {
             product:   NAME,
             cluster:   c.metadata.labels[FLEET_ANNOTATIONS.CLUSTER_NAME],
-            resource:  r.type,
+            resource:  type,
             namespace: r.namespace,
             id:        r.name,
           }
         };
 
+        const key = `${ c.id }-${ type }-${ r.namespace }-${ r.name }`;
+
         out.push({
-          key:                    `${ r.id }-${ c.id }-${ r.type }-${ r.namespace }-${ r.name }`,
-          tableKey:               `${ r.id }-${ c.id }-${ r.type }-${ r.namespace }-${ r.name }-${ randomStr(8) }`,
-          kind:                   r.kind,
-          apiVersion:             r.apiVersion,
-          type:                   r.type,
-          id:                     r.id,
-          namespace:              r.namespace,
-          name:                   r.name,
-          clusterId:              c.id,
-          clusterLabel:           c.metadata.labels[FLEET_ANNOTATIONS.CLUSTER_NAME],
-          clusterName:            c.nameDisplay,
-          state:                  mapStateToEnum(state),
-          stateBackground:        color,
-          stateDisplay:           display,
-          stateSort:              stateSort(color, display),
-          namespacedName,
+          key,
+          tableKey: key,
+
+          // Needed?
+          id,
+          type,
+          clusterId: c.id,
+
+          // columns, see FleetResources.vue
+          state:             mapStateToEnum(state),
+          clusterName:       c.nameDisplay,
+          apiVersion:        r.apiVersion,
+          kind:              r.kind,
+          name:              r.name,
+          namespace:         r.namespace,
+          creationTimestamp: r.createdAt,
+
+          // other properties
+          clusterLabel:    c.metadata.labels[FLEET_ANNOTATIONS.CLUSTER_NAME],
+          stateBackground: color,
+          stateDisplay:    display,
+          stateSort:       stateSort(color, display),
           detailLocation,
-          conditions:             conditions[i],
-          bundleDeploymentStatus: clusterBundleDeploymentResources?.[i],
-          creationTimestamp:      clusterBundleDeploymentResources?.[i]?.createdAt
         });
       });
     }
@@ -407,9 +407,7 @@ export default class GitRepo extends SteveModel {
 
   get clusterResourceStatus() {
     const clusterStatuses = this.resourcesStatuses.reduce((prev, curr) => {
-      const { clusterId, clusterLabel } = curr;
-
-      const state = curr.state;
+      const { clusterId, clusterLabel, state } = curr;
 
       if (!prev[clusterId]) {
         prev[clusterId] = {
diff --git a/shell/pages/c/_cluster/fleet/index.vue b/shell/pages/c/_cluster/fleet/index.vue
index 5d73ac2a0c0..3c4261e6435 100644
--- a/shell/pages/c/_cluster/fleet/index.vue
+++ b/shell/pages/c/_cluster/fleet/index.vue
@@ -40,6 +40,7 @@ export default {
       allBundles: {
         inStoreType: 'management',
         type:        FLEET.BUNDLE,
+        opt:         { excludeFields: ['metadata.managedFields', 'spec.resources'] },
       },
       gitRepos: {
         inStoreType: 'management',
diff --git a/shell/types/resources/fleet.d.ts b/shell/types/resources/fleet.d.ts
new file mode 100644
index 00000000000..9b346f0a038
--- /dev/null
+++ b/shell/types/resources/fleet.d.ts
@@ -0,0 +1,40 @@
+export interface BundleResourceKey {
+  kind: string,
+  apiVersion: string,
+  namespace?: string,
+  name: string,
+}
+
+export interface BundleDeploymentResource extends BundleResourceKey {
+  createdAt?: string,
+}
+
+export interface BundleModifiedResource extends BundleResourceKey {
+  missing?: boolean,
+  delete?: boolean,
+  patch: string,
+}
+
+export interface BundleNonReadyResource extends BundleResourceKey {
+  summary: { [state: string]: string }
+}
+
+export interface BundleNonReadyBundle {
+  modifiedStatus: BundleModifiedResource[],
+  nonReadyStatus: BundleNonReadyResource[],
+}
+
+export interface BundleDeploymentStatus {
+  resources?: BundleDeploymentResource[],
+  modifiedStatus?: BundleModifiedResource[],
+  nonReadyStatus?: BundleNonReadyResource[],
+}
+
+export interface BundleStatusSummary {
+  nonReadyResources?: BundleNonReadyBundle[],
+}
+
+export interface BundleStatus {
+  resourceKey?: BundleResourceKey[],
+  summary?: BundleStatusSummary,
+}
diff --git a/shell/utils/auth.js b/shell/utils/auth.js
index 162ce4009d6..9b08def3517 100644
--- a/shell/utils/auth.js
+++ b/shell/utils/auth.js
@@ -99,7 +99,7 @@ export const checkSchemasForFindAllHash = (types, store) => {
     const validSchema = value.schemaValidator ? value.schemaValidator(schema) : !!schema;
 
     if (validSchema) {
-      hash[key] = store.dispatch(`${ value.inStoreType }/findAll`, { type: value.type } );
+      hash[key] = store.dispatch(`${ value.inStoreType }/findAll`, { type: value.type, opt: value.opt } );
     }
   }
 
diff --git a/shell/utils/fleet.ts b/shell/utils/fleet.ts
new file mode 100644
index 00000000000..5921c1b234c
--- /dev/null
+++ b/shell/utils/fleet.ts
@@ -0,0 +1,159 @@
+import {
+  BundleDeploymentResource,
+  BundleResourceKey,
+  BundleDeploymentStatus,
+  BundleStatus,
+} from '@shell/types/resources/fleet';
+import { STATES_ENUM } from '@shell/plugins/dashboard-store/resource-class';
+import { FLEET as FLEET_ANNOTATIONS } from '@shell/config/labels-annotations';
+
+interface Resource extends BundleDeploymentResource {
+  state: string,
+}
+
+type Labels = {
+  [key: string]: string,
+}
+
+interface StatesCounter { [state: string]: number }
+
+function incr(counter: StatesCounter, state: string) {
+  if (!counter[state]) {
+    counter[state] = 0;
+  }
+  counter[state]++;
+}
+
+function resourceKey(r: BundleResourceKey): string {
+  return `${ r.kind }/${ r.namespace }/${ r.name }`;
+}
+
+class Fleet {
+  resourceId(r: BundleResourceKey): string {
+    return r.namespace ? `${ r.namespace }/${ r.name }` : r.name;
+  }
+
+  /**
+   * resourceType normalizes APIVersion and Kind from a Resources into a single string
+   */
+  resourceType(r: Resource): string {
+    // ported from https://github.com/rancher/fleet/blob/v0.10.0/internal/cmd/controller/grutil/resourcekey.go#L116-L128
+    const type = r.kind.toLowerCase();
+
+    if (!r.apiVersion || r.apiVersion === 'v1') {
+      return type;
+    }
+
+    return `${ r.apiVersion.split('/', 2)[0] }.${ type }`;
+  }
+
+  /**
+   * resourcesFromBundleDeploymentStatus extracts the list of resources deployed by a BundleDeployment
+   */
+  resourcesFromBundleDeploymentStatus(status: BundleDeploymentStatus): Resource[] {
+    // status.resources includes of resources that were deployed by Fleet *and still exist in the cluster*
+    // Use a map to avoid `find` over and over again
+    const resources = (status?.resources || []).reduce((res, r) => {
+      res[resourceKey(r)] = Object.assign({ state: STATES_ENUM.READY }, r);
+
+      return res;
+    }, {} as { [resourceKey: string]: Resource });
+
+    const modified: Resource[] = [];
+
+    for (const r of status?.modifiedStatus || []) {
+      const state = r.missing ? STATES_ENUM.MISSING : r.delete ? STATES_ENUM.ORPHANED : STATES_ENUM.MODIFIED;
+      const found: Resource = resources[resourceKey(r)];
+
+      // Depending on the state, the same resource can appear in both fields
+      if (found) {
+        found.state = state;
+      } else {
+        modified.push(Object.assign({ state }, r));
+      }
+    }
+    for (const r of status?.nonReadyStatus || []) {
+      const state = r.summary?.state || STATES_ENUM.UNKNOWN;
+      const found: Resource = resources[resourceKey(r)];
+
+      if (found) {
+        found.state = state;
+      }
+    }
+
+    return modified.concat(Object.values(resources));
+  }
+
+  /**
+   * resourcesFromBundleStatus extracts the list of resources deployed by a Bundle
+   */
+  resourcesFromBundleStatus(status: BundleStatus): Resource[] {
+    // The state of every resource is spread all over the bundle status.
+    // resourceKey contains one entry per resource AND cluster (built by Fleet from all the child BundleDeployments).
+    // However, those entries do not contain the cluster that they belong to, leading to duplicate entries
+
+    // 1. Fold resourceKey by using a unique key, initializing counters for multiple occurrences of the same resource
+    const resources = (status.resourceKey || []).reduce((res, r) => {
+      const k = resourceKey(r);
+
+      if (!res[k]) {
+        res[k] = { r, count: {} };
+      }
+      incr(res[k].count, STATES_ENUM.READY);
+
+      return res;
+    }, {} as { [resourceKey: string]: { r: BundleResourceKey, count: StatesCounter } });
+
+    // 2. Non-ready resources are counted differently and may also appear in resourceKey, depending on their state
+    for (const bundle of status.summary?.nonReadyResources || []) {
+      for (const r of bundle.modifiedStatus || []) {
+        const k = resourceKey(r);
+
+        if (!resources[k]) {
+          resources[k] = { r, count: {} };
+        }
+
+        if (r.missing) {
+          incr(resources[k].count, STATES_ENUM.MISSING);
+        } else if (r.delete) {
+          resources[k].count[STATES_ENUM.READY]--;
+          incr(resources[k].count, STATES_ENUM.ORPHANED);
+        } else {
+          resources[k].count[STATES_ENUM.READY]--;
+          incr(resources[k].count, STATES_ENUM.MODIFIED);
+        }
+      }
+      for (const r of bundle.nonReadyStatus || []) {
+        const k = resourceKey(r);
+        const state = r.summary?.state || STATES_ENUM.UNKNOWN;
+
+        resources[k].count[STATES_ENUM.READY]--;
+        incr(resources[k].count, state);
+      }
+    }
+
+    // 3. Unfold back to an array of resources for display
+    return Object.values(resources).reduce((res, e) => {
+      const { r, count } = e;
+
+      for (const state in count) {
+        for (let x = 0; x < count[state]; x++) {
+          res.push(Object.assign({ state }, r));
+        }
+      }
+
+      return res;
+    }, [] as Resource[]);
+  }
+
+  clusterIdFromBundleDeploymentLabels(labels?: Labels): string {
+    const clusterNamespace = labels?.[FLEET_ANNOTATIONS.CLUSTER_NAMESPACE];
+    const clusterName = labels?.[FLEET_ANNOTATIONS.CLUSTER];
+
+    return `${ clusterNamespace }/${ clusterName }`;
+  }
+}
+
+const instance = new Fleet();
+
+export default instance;