diff --git a/res/values/strings.xml b/res/values/strings.xml
index de34d8d..ba14ce1 100644
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -8728,7 +8728,7 @@
     <string name="notif_listener_more_settings">More settings</string>
     <string name="notif_listener_more_settings_desc">More settings are available inside this app</string>
 
-    <!-- Title for Polite Notifications setting  [CHAR LIMIT=30]-->
+    <!-- Title for Polite Notifications setting  [CHAR LIMIT=45]-->
     <string name="notification_polite_title">Cooldown</string>
     <string name="notification_polite_main_control_title">Use Cooldown</string>
     <string name="notification_polite_description">When you get many notifications within a short time span, your device will minimize sound interruptions and pop-ups on the screen. Calls, alarms, and priority conversations will still alert as notmal, and all delivered notifications are easy to find in the Shade.</string>
