diff --git a/packages/twenty-front/src/modules/metadata-store/effect-components/IsMinimalMetadataReadyEffect.tsx b/packages/twenty-front/src/modules/metadata-store/effect-components/IsMinimalMetadataReadyEffect.tsx
index 165c3c1413..35275a8bb1 100644
--- a/packages/twenty-front/src/modules/metadata-store/effect-components/IsMinimalMetadataReadyEffect.tsx
+++ b/packages/twenty-front/src/modules/metadata-store/effect-components/IsMinimalMetadataReadyEffect.tsx
@@ -14,15 +14,22 @@ export const IsMinimalMetadataReadyEffect = () => {
   const hasAccessTokenPair = useHasAccessTokenPair();
   const currentUser = useAtomStateValue(currentUserState);
   const currentWorkspace = useAtomStateValue(currentWorkspaceState);
-  const metadataStore = useAtomFamilyStateValue(
+  const metadataStoreObjectMetadataItems = useAtomFamilyStateValue(
     metadataStoreState,
     'objectMetadataItems',
   );
-  // oxlint-disable-next-line twenty/matching-state-variable
+  const metadataStoreFieldMetadataItems = useAtomFamilyStateValue(
+    metadataStoreState,
+    'fieldMetadataItems',
+  );
   const metadataStoreViews = useAtomFamilyStateValue(
     metadataStoreState,
     'views',
   );
+  const metadataStoreViewFields = useAtomFamilyStateValue(
+    metadataStoreState,
+    'viewFields',
+  );
   const setIsMinimalMetadataReady = useSetAtomState(
     isMinimalMetadataReadyState,
   );
@@ -35,8 +42,12 @@ export const IsMinimalMetadataReadyEffect = () => {
 
     const hasActiveWorkspace = isWorkspaceActiveOrSuspended(currentWorkspace);
 
-    const areObjectsLoaded = metadataStore.status === 'up-to-date';
-    const areViewsLoaded = metadataStoreViews.status === 'up-to-date';
+    const areObjectsLoaded =
+      metadataStoreObjectMetadataItems.status === 'up-to-date' &&
+      metadataStoreFieldMetadataItems.status === 'up-to-date';
+    const areViewsLoaded =
+      metadataStoreViews.status === 'up-to-date' &&
+      metadataStoreViewFields.status === 'up-to-date';
 
     if (!areObjectsLoaded) {
       setIsMinimalMetadataReady(false);
@@ -53,8 +64,10 @@ export const IsMinimalMetadataReadyEffect = () => {
     hasAccessTokenPair,
     currentUser,
     currentWorkspace,
-    metadataStore.status,
+    metadataStoreObjectMetadataItems.status,
+    metadataStoreFieldMetadataItems.status,
     metadataStoreViews.status,
+    metadataStoreViewFields.status,
     setIsMinimalMetadataReady,
   ]);
 
diff --git a/packages/twenty-oxlint-rules/rules/matching-state-variable.spec.ts b/packages/twenty-oxlint-rules/rules/matching-state-variable.spec.ts
index 95623bb550..4d7d1a173e 100644
--- a/packages/twenty-oxlint-rules/rules/matching-state-variable.spec.ts
+++ b/packages/twenty-oxlint-rules/rules/matching-state-variable.spec.ts
@@ -26,6 +26,18 @@ ruleTester.run(RULE_NAME, rule, {
     {
       code: 'const [variable, setVariable] = useAtomComponentFamilyState(variableComponentFamilyState, key);',
     },
+    {
+      code: "const variableViews = useAtomFamilyStateValue(variableFamilyState, 'views');",
+    },
+    {
+      code: "const variableViewFields = useAtomFamilyStateValue(variableFamilyState, 'viewFields');",
+    },
+    {
+      code: "const [variableViews, setVariableViews] = useAtomComponentFamilyState(variableComponentFamilyState, 'views');",
+    },
+    {
+      code: "const setVariableViews = useSetAtomFamilyState(variableFamilyState, 'views');",
+    },
     {
       code: 'const setVariable = useSetAtomState(variableState);',
     },
@@ -114,5 +126,10 @@ ruleTester.run(RULE_NAME, rule, {
       output: 'const setVariable = useSetAtomComponentFamilyState(variableComponentFamilyState, key);',
       errors: [{ messageId: 'invalidSetterName' }],
     },
+    {
+      code: "const variableSorts = useAtomFamilyStateValue(variableFamilyState, 'views');",
+      output: "const variable = useAtomFamilyStateValue(variableFamilyState, 'views');",
+      errors: [{ messageId: 'invalidVariableName' }],
+    },
   ],
 });
diff --git a/packages/twenty-oxlint-rules/rules/matching-state-variable.ts b/packages/twenty-oxlint-rules/rules/matching-state-variable.ts
index 0c7bb9cf0e..e7d7a094b8 100644
--- a/packages/twenty-oxlint-rules/rules/matching-state-variable.ts
+++ b/packages/twenty-oxlint-rules/rules/matching-state-variable.ts
@@ -22,6 +22,14 @@ const SETTER_HOOKS = [
   'useSetAtomComponentFamilyState',
 ];
 
+const FAMILY_HOOKS = new Set([
+  'useAtomFamilyStateValue',
+  'useAtomComponentFamilyStateValue',
+  'useAtomComponentFamilyState',
+  'useSetAtomFamilyState',
+  'useSetAtomComponentFamilyState',
+]);
+
 const ALL_HOOKS = [...VALUE_HOOKS, ...STATE_HOOKS, ...SETTER_HOOKS];
 
 const SUFFIX_PATTERN =
@@ -33,6 +41,31 @@ const getExpectedBaseName = (stateArgName: string): string =>
 const getExpectedSetterName = (baseName: string): string =>
   `set${baseName.charAt(0).toUpperCase()}${baseName.slice(1)}`;
 
+// Family hooks may suffix the string-literal key to disambiguate multiple
+// reads of the same family in one scope (e.g. metadataStore / metadataStoreViews).
+const getFamilyKeyVariants = (
+  hookName: string,
+  args: ReadonlyArray<any> | undefined,
+): string[] => {
+  if (!FAMILY_HOOKS.has(hookName) || !args) {
+    return [];
+  }
+
+  const familyKeyArg = args[1];
+
+  if (
+    familyKeyArg?.type !== 'Literal' ||
+    typeof familyKeyArg.value !== 'string' ||
+    familyKeyArg.value.length === 0
+  ) {
+    return [];
+  }
+
+  const keyValue = familyKeyArg.value;
+
+  return [`${keyValue.charAt(0).toUpperCase()}${keyValue.slice(1)}`];
+};
+
 export const rule = defineRule({
   meta: {
     type: 'problem',
@@ -73,23 +106,37 @@ export const rule = defineRule({
 
         const expectedVariableNameBase = getExpectedBaseName(stateNameBase);
 
+        const familyKeySuffixes = getFamilyKeyVariants(
+          hookName,
+          node.init.arguments,
+        );
+
+        const acceptedVariableNames = [
+          expectedVariableNameBase,
+          ...familyKeySuffixes.map(
+            (suffix) => `${expectedVariableNameBase}${suffix}`,
+          ),
+        ];
+
+        const acceptedSetterNames = acceptedVariableNames.map(
+          getExpectedSetterName,
+        );
+
         if (SETTER_HOOKS.includes(hookName)) {
           if (node.id?.type === 'Identifier') {
             const actualName = node.id.name;
-            const expectedSetterName =
-              getExpectedSetterName(expectedVariableNameBase);
 
-            if (actualName !== expectedSetterName) {
+            if (!acceptedSetterNames.includes(actualName)) {
               context.report({
                 node,
                 messageId: 'invalidSetterName',
                 data: {
                   hookName: stateNameBase,
                   actualName,
-                  expectedName: expectedSetterName,
+                  expectedName: acceptedSetterNames[0],
                 },
                 fix: (fixer) =>
-                  fixer.replaceText(node.id, expectedSetterName),
+                  fixer.replaceText(node.id, acceptedSetterNames[0]),
               });
             }
           }
@@ -101,18 +148,18 @@ export const rule = defineRule({
           if (node.id?.type === 'Identifier') {
             const actualName = node.id.name;
 
-            if (actualName !== expectedVariableNameBase) {
+            if (!acceptedVariableNames.includes(actualName)) {
               context.report({
                 node,
                 messageId: 'invalidVariableName',
                 data: {
                   actualName,
-                  expectedName: expectedVariableNameBase,
+                  expectedName: acceptedVariableNames[0],
                   hookName: stateNameBase,
                   callee: hookName,
                 },
                 fix: (fixer) =>
-                  fixer.replaceText(node.id, expectedVariableNameBase),
+                  fixer.replaceText(node.id, acceptedVariableNames[0]),
               });
             }
           }
@@ -123,18 +170,18 @@ export const rule = defineRule({
         if (node.id?.type === 'Identifier') {
           const actualVariableName = node.id.name;
 
-          if (actualVariableName !== expectedVariableNameBase) {
+          if (!acceptedVariableNames.includes(actualVariableName)) {
             context.report({
               node,
               messageId: 'invalidVariableName',
               data: {
                 actualName: actualVariableName,
-                expectedName: expectedVariableNameBase,
+                expectedName: acceptedVariableNames[0],
                 hookName: stateNameBase,
                 callee: hookName,
               },
               fix: (fixer) =>
-                fixer.replaceText(node.id, expectedVariableNameBase),
+                fixer.replaceText(node.id, acceptedVariableNames[0]),
             });
           }
 
@@ -149,14 +196,14 @@ export const rule = defineRule({
 
           if (
             actualVariableName &&
-            actualVariableName !== expectedVariableNameBase
+            !acceptedVariableNames.includes(actualVariableName)
           ) {
             context.report({
               node,
               messageId: 'invalidVariableName',
               data: {
                 actualName: actualVariableName,
-                expectedName: expectedVariableNameBase,
+                expectedName: acceptedVariableNames[0],
                 hookName: stateNameBase,
                 callee: hookName,
               },
@@ -164,7 +211,7 @@ export const rule = defineRule({
                 if (node.id.type === 'ArrayPattern') {
                   return fixer.replaceText(
                     node.id.elements[0] as any,
-                    expectedVariableNameBase,
+                    acceptedVariableNames[0],
                   );
                 }
                 return null;
@@ -174,23 +221,21 @@ export const rule = defineRule({
 
           if (node.id.elements[1]?.type === 'Identifier') {
             const actualSetterName = node.id.elements[1].name;
-            const expectedSetterName =
-              getExpectedSetterName(expectedVariableNameBase);
 
-            if (actualSetterName !== expectedSetterName) {
+            if (!acceptedSetterNames.includes(actualSetterName)) {
               context.report({
                 node,
                 messageId: 'invalidSetterName',
                 data: {
                   hookName: stateNameBase,
                   actualName: actualSetterName,
-                  expectedName: expectedSetterName,
+                  expectedName: acceptedSetterNames[0],
                 },
                 fix: (fixer) => {
                   if (node.id.type === 'ArrayPattern') {
                     return fixer.replaceText(
                       node.id.elements[1]!,
-                      expectedSetterName,
+                      acceptedSetterNames[0],
                     );
                   }
                   return null;