Remove .github/workflows/update-make-docs.yml

.github/workflows/update-make-docs.yml

@@ -1,21 +0,0 @@
-name: Update `make docs` procedure
-on:
-  schedule:
-    - cron: '0 7 * * 1-5'
-  workflow_dispatch:
-jobs:
-  main:
-    if: github.repository == 'grafana/grafana'
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v5
-        with:
-          persist-credentials: false
-      - uses: grafana/writers-toolkit/update-make-docs@update-make-docs/v1 # zizmor: ignore[unpinned-uses]
-        with:
-          pr_options: >
-            --label 'backport v10.1.x'
-            --label 'backport v10.2.x'
-            --label 'backport v10.3.x'
-            --label no-changelog
-            --label type/docs

packages/grafana-data/src/types/featureToggles.gen.ts

@@ -695,6 +695,10 @@ export interface FeatureToggles {
   */
   passwordlessMagicLinkAuthentication?: boolean;
   /**
+  * Display Related Logs in Grafana Metrics Drilldown
+  */
+  exploreMetricsRelatedLogs?: boolean;
+  /**
   * Adds support for quotes and special characters in label values for Prometheus queries
   */
   prometheusSpecialCharsInLabelValues?: boolean;

pkg/services/featuremgmt/registry.go

@@ -1148,6 +1148,14 @@ var (
 			Owner:        identityAccessTeam,
 			HideFromDocs: true,
 		},
+		{
+			Name:         "exploreMetricsRelatedLogs",
+			Description:  "Display Related Logs in Grafana Metrics Drilldown",
+			Stage:        FeatureStageExperimental,
+			Owner:        grafanaObservabilityMetricsSquad,
+			FrontendOnly: true,
+			HideFromDocs: false,
+		},
 		{
 			Name:         "prometheusSpecialCharsInLabelValues",
 			Description:  "Adds support for quotes and special characters in label values for Prometheus queries",

pkg/services/featuremgmt/toggles_gen.csv

@@ -159,6 +159,7 @@ newTimeRangeZoomShortcuts,experimental,@grafana/dataviz-squad,false,false,true
 azureMonitorDisableLogLimit,GA,@grafana/partner-datasources,false,false,false
 playlistsReconciler,experimental,@grafana/grafana-app-platform-squad,false,true,false
 passwordlessMagicLinkAuthentication,experimental,@grafana/identity-access-team,false,false,false
+exploreMetricsRelatedLogs,experimental,@grafana/observability-metrics,false,false,true
 prometheusSpecialCharsInLabelValues,experimental,@grafana/oss-big-tent,false,false,true
 enableExtensionsAdminPage,experimental,@grafana/plugins-platform-backend,false,true,false
 enableSCIM,preview,@grafana/identity-access-team,false,false,false

pkg/services/featuremgmt/toggles_gen.json

@@ -348,20 +348,6 @@
         "expression": "true"
       }
     },
-    {
-      "metadata": {
-        "name": "alertingNavigationV2",
-        "resourceVersion": "1767827323622",
-        "creationTimestamp": "2026-01-07T23:08:43Z",
-        "deletionTimestamp": "2026-01-12T18:34:54Z"
-      },
-      "spec": {
-        "description": "Enable new grouped navigation structure for Alerting",
-        "stage": "experimental",
-        "codeowner": "@grafana/alerting-squad",
-        "expression": "false"
-      }
-    },
     {
       "metadata": {
         "name": "alertingNotificationHistory",
@@ -1422,8 +1408,7 @@
       "metadata": {
         "name": "exploreMetricsRelatedLogs",
         "resourceVersion": "1764664939750",
-        "creationTimestamp": "2024-11-05T16:28:43Z",
-        "deletionTimestamp": "2026-01-09T22:14:53Z"
+        "creationTimestamp": "2024-11-05T16:28:43Z"
       },
       "spec": {
         "description": "Display Related Logs in Grafana Metrics Drilldown",

pkg/services/navtree/navtreeimpl/navtree.go

@@ -436,212 +436,97 @@ func (s *ServiceImpl) buildAlertNavLinks(c *contextmodel.ReqContext) *navtree.Na
 	hasAccess := ac.HasAccess(s.accessControl, c)
 	var alertChildNavs []*navtree.NavLink
 
-	var alertActivityChildren []*navtree.NavLink
 	//nolint:staticcheck // not yet migrated to OpenFeature
 	if s.features.IsEnabled(c.Req.Context(), featuremgmt.FlagAlertingTriage) {
 		if hasAccess(ac.EvalAny(ac.EvalPermission(ac.ActionAlertingRuleRead), ac.EvalPermission(ac.ActionAlertingRuleExternalRead))) {
-			alertActivityChildren = append(alertActivityChildren, &navtree.NavLink{
-				Text:     "Alerts",
-				SubTitle: "Visualize active and pending alerts",
-				Id:       "alert-activity-alerts",
-				Url:      s.cfg.AppSubURL + "/alerting/alerts",
-				Icon:     "bell",
-			})
-		}
-
-		if hasAccess(ac.EvalAny(ac.EvalPermission(ac.ActionAlertingInstanceRead), ac.EvalPermission(ac.ActionAlertingInstancesExternalRead))) {
-			alertActivityChildren = append(alertActivityChildren, &navtree.NavLink{
-				Text:     "Active notifications",
-				SubTitle: "See grouped alerts with active notifications",
-				Id:       "alert-activity-groups",
-				Url:      s.cfg.AppSubURL + "/alerting/groups",
-				Icon:     "layer-group",
-			})
-		}
-		if len(alertActivityChildren) > 0 {
 			alertChildNavs = append(alertChildNavs, &navtree.NavLink{
-				Text:     "Alert activity",
-				SubTitle: "Visualize active and pending alerts",
-				Id:       "alert-activity",
-				Url:      s.cfg.AppSubURL + "/alerting/alerts",
-				Icon:     "bell",
-				IsNew:    true,
-				Children: alertActivityChildren,
+				Text: "Alert activity", SubTitle: "Visualize active and pending alerts", Id: "alert-alerts", Url: s.cfg.AppSubURL + "/alerting/alerts", Icon: "bell", IsNew: true,
 			})
 		}
 	}
 
-	var alertRulesChildren []*navtree.NavLink
 	if hasAccess(ac.EvalAny(ac.EvalPermission(ac.ActionAlertingRuleRead), ac.EvalPermission(ac.ActionAlertingRuleExternalRead))) {
-		alertRulesChildren = append(alertRulesChildren, &navtree.NavLink{
-			Text:     "Alert rules",
-			SubTitle: "Rules that determine whether an alert will fire",
-			Id:       "alert-rules-list",
-			Url:      s.cfg.AppSubURL + "/alerting/list",
-			Icon:     "list-ul",
-		})
-	}
-	//nolint:staticcheck // not yet migrated to OpenFeature
-	if c.GetOrgRole() == org.RoleAdmin && s.features.IsEnabled(c.Req.Context(), featuremgmt.FlagAlertRuleRestore) && s.features.IsEnabled(c.Req.Context(), featuremgmt.FlagAlertingRuleRecoverDeleted) {
-		alertRulesChildren = append(alertRulesChildren, &navtree.NavLink{
-			Text:     "Recently deleted",
-			SubTitle: "Any items listed here for more than 30 days will be automatically deleted.",
-			Id:       "alert-rules-recently-deleted",
-			Url:      s.cfg.AppSubURL + "/alerting/recently-deleted",
-		})
-	}
-	if len(alertRulesChildren) > 0 {
 		alertChildNavs = append(alertChildNavs, &navtree.NavLink{
-			Text:     "Alert rules",
-			SubTitle: "Manage alert and recording rules",
-			Id:       "alert-rules",
-			Url:      s.cfg.AppSubURL + "/alerting/list",
-			Icon:     "list-ul",
-			Children: alertRulesChildren,
+			Text: "Alert rules", SubTitle: "Rules that determine whether an alert will fire", Id: "alert-list", Url: s.cfg.AppSubURL + "/alerting/list", Icon: "list-ul",
 		})
 	}
 
-	var notificationConfigChildren []*navtree.NavLink
-
 	contactPointsPerms := []ac.Evaluator{
 		ac.EvalPermission(ac.ActionAlertingNotificationsRead),
 		ac.EvalPermission(ac.ActionAlertingNotificationsExternalRead),
+
 		ac.EvalPermission(ac.ActionAlertingReceiversRead),
 		ac.EvalPermission(ac.ActionAlertingReceiversReadSecrets),
 		ac.EvalPermission(ac.ActionAlertingReceiversCreate),
+
 		ac.EvalPermission(ac.ActionAlertingNotificationsTemplatesRead),
 		ac.EvalPermission(ac.ActionAlertingNotificationsTemplatesWrite),
 		ac.EvalPermission(ac.ActionAlertingNotificationsTemplatesDelete),
 	}
 
 	if hasAccess(ac.EvalAny(contactPointsPerms...)) {
-		notificationConfigChildren = append(notificationConfigChildren, &navtree.NavLink{
-			Text:     "Contact points",
-			SubTitle: "Choose how to notify your contact points when an alert instance fires",
-			Id:       "notification-config-contact-points",
-			Url:      s.cfg.AppSubURL + "/alerting/notifications",
-			Icon:     "comment-alt-share",
-		})
-	}
-
-	if hasAccess(ac.EvalAny(
-		ac.EvalPermission(ac.ActionAlertingNotificationsRead),
-		ac.EvalPermission(ac.ActionAlertingNotificationsExternalRead),
-		ac.EvalPermission(ac.ActionAlertingRoutesRead),
-		ac.EvalPermission(ac.ActionAlertingRoutesWrite),
-		ac.EvalPermission(ac.ActionAlertingNotificationsTimeIntervalsRead),
-		ac.EvalPermission(ac.ActionAlertingNotificationsTimeIntervalsWrite),
-	)) {
-		notificationConfigChildren = append(notificationConfigChildren, &navtree.NavLink{
-			Text:     "Notification policies",
-			SubTitle: "Determine how alerts are routed to contact points",
-			Id:       "notification-config-policies",
-			Url:      s.cfg.AppSubURL + "/alerting/routes",
-			Icon:     "sitemap",
-		})
-	}
-
-	if hasAccess(ac.EvalAny(contactPointsPerms...)) {
-		notificationConfigChildren = append(notificationConfigChildren, &navtree.NavLink{
-			Text:     "Notification templates",
-			SubTitle: "Manage notification templates",
-			Id:       "notification-config-templates",
-			Url:      s.cfg.AppSubURL + "/alerting/notifications/templates",
-			Icon:     "file-alt",
-		})
-	}
-
-	if hasAccess(ac.EvalAny(
-		ac.EvalPermission(ac.ActionAlertingNotificationsRead),
-		ac.EvalPermission(ac.ActionAlertingNotificationsExternalRead),
-		ac.EvalPermission(ac.ActionAlertingRoutesRead),
-		ac.EvalPermission(ac.ActionAlertingRoutesWrite),
-		ac.EvalPermission(ac.ActionAlertingNotificationsTimeIntervalsRead),
-		ac.EvalPermission(ac.ActionAlertingNotificationsTimeIntervalsWrite),
-	)) {
-		notificationConfigChildren = append(notificationConfigChildren, &navtree.NavLink{
-			Text:     "Time intervals",
-			SubTitle: "Configure time intervals for notification policies",
-			Id:       "notification-config-time-intervals",
-			Url:      s.cfg.AppSubURL + "/alerting/routes?tab=time_intervals",
-			Icon:     "clock-nine",
-		})
-	}
-
-	if len(notificationConfigChildren) > 0 {
 		alertChildNavs = append(alertChildNavs, &navtree.NavLink{
-			Text:     "Notification configuration",
-			SubTitle: "Configure how alerts are notified",
-			Id:       "notification-config",
-			Url:      s.cfg.AppSubURL + "/alerting/notifications",
-			Icon:     "cog",
-			Children: notificationConfigChildren,
+			Text: "Contact points", SubTitle: "Choose how to notify your contact points when an alert instance fires", Id: "receivers", Url: s.cfg.AppSubURL + "/alerting/notifications",
+			Icon: "comment-alt-share",
 		})
 	}
 
-	var insightsChildren []*navtree.NavLink
-
-	if hasAccess(ac.EvalAny(ac.EvalPermission(ac.ActionAlertingRuleRead), ac.EvalPermission(ac.ActionAlertingRuleExternalRead))) {
-		insightsChildren = append(insightsChildren, &navtree.NavLink{
-			Text:     "System Insights",
-			SubTitle: "View system insights and analytics",
-			Id:       "insights-system", Url: s.cfg.AppSubURL + "/alerting/insights",
-			Icon: "chart-line",
-		})
+	if hasAccess(ac.EvalAny(
+		ac.EvalPermission(ac.ActionAlertingNotificationsRead),
+		ac.EvalPermission(ac.ActionAlertingNotificationsExternalRead),
+		ac.EvalPermission(ac.ActionAlertingRoutesRead),
+		ac.EvalPermission(ac.ActionAlertingRoutesWrite),
+		ac.EvalPermission(ac.ActionAlertingNotificationsTimeIntervalsRead),
+		ac.EvalPermission(ac.ActionAlertingNotificationsTimeIntervalsWrite),
+	)) {
+		alertChildNavs = append(alertChildNavs, &navtree.NavLink{Text: "Notification policies", SubTitle: "Determine how alerts are routed to contact points", Id: "am-routes", Url: s.cfg.AppSubURL + "/alerting/routes", Icon: "sitemap"})
 	}
-	// Alert state history
+
+	if hasAccess(ac.EvalAny(
+		ac.EvalPermission(ac.ActionAlertingInstanceRead),
+		ac.EvalPermission(ac.ActionAlertingInstancesExternalRead),
+		ac.EvalPermission(ac.ActionAlertingSilencesRead),
+	)) {
+		alertChildNavs = append(alertChildNavs, &navtree.NavLink{Text: "Silences", SubTitle: "Stop notifications from one or more alerting rules", Id: "silences", Url: s.cfg.AppSubURL + "/alerting/silences", Icon: "bell-slash"})
+	}
+
+	if hasAccess(ac.EvalAny(ac.EvalPermission(ac.ActionAlertingInstanceRead), ac.EvalPermission(ac.ActionAlertingInstancesExternalRead))) {
+		alertChildNavs = append(alertChildNavs, &navtree.NavLink{Text: "Alert groups", SubTitle: "See grouped alerts with active notifications", Id: "groups", Url: s.cfg.AppSubURL + "/alerting/groups", Icon: "layer-group"})
+	}
+
 	//nolint:staticcheck // not yet migrated to OpenFeature
 	if s.features.IsEnabled(c.Req.Context(), featuremgmt.FlagAlertingCentralAlertHistory) {
 		if hasAccess(ac.EvalAny(ac.EvalPermission(ac.ActionAlertingRuleRead))) {
-			insightsChildren = append(insightsChildren, &navtree.NavLink{
-				Text:     "Alert state history",
+			alertChildNavs = append(alertChildNavs, &navtree.NavLink{
+				Text:     "History",
 				SubTitle: "View a history of all alert events generated by your Grafana-managed alert rules. All alert events are displayed regardless of whether silences or mute timings are set.",
-				Id:       "insights-history",
+				Id:       "alerts-history",
 				Url:      s.cfg.AppSubURL + "/alerting/history",
 				Icon:     "history",
 			})
 		}
 	}
-
-	if len(insightsChildren) > 0 {
+	//nolint:staticcheck // not yet migrated to OpenFeature
+	if c.GetOrgRole() == org.RoleAdmin && s.features.IsEnabled(c.Req.Context(), featuremgmt.FlagAlertRuleRestore) && s.features.IsEnabled(c.Req.Context(), featuremgmt.FlagAlertingRuleRecoverDeleted) {
 		alertChildNavs = append(alertChildNavs, &navtree.NavLink{
-			Text:     "Insights",
-			SubTitle: "Analytics and history for alerting",
-			Id:       "insights",
-			Url:      s.cfg.AppSubURL + "/alerting/insights",
-			Icon:     "chart-line",
-			Children: insightsChildren,
+			Text:     "Recently deleted",
+			SubTitle: "Any items listed here for more than 30 days will be automatically deleted.",
+			Id:       "alerts/recently-deleted",
+			Url:      s.cfg.AppSubURL + "/alerting/recently-deleted",
 		})
 	}
 
 	if c.GetOrgRole() == org.RoleAdmin {
-		settingsChildren := []*navtree.NavLink{
-			{
-				Text: "Settings",
-				Id:   "alerting-admin",
-				Url:  s.cfg.AppSubURL + "/alerting/admin",
-				Icon: "cog",
-			},
-		}
 		alertChildNavs = append(alertChildNavs, &navtree.NavLink{
-			Text:     "Settings",
-			SubTitle: "Alerting configuration and administration",
-			Id:       "alerting-settings",
-			Url:      s.cfg.AppSubURL + "/alerting/admin",
-			Icon:     "cog",
-			Children: settingsChildren,
+			Text: "Settings", Id: "alerting-admin", Url: s.cfg.AppSubURL + "/alerting/admin",
+			Icon: "cog",
 		})
 	}
 
 	if hasAccess(ac.EvalAny(ac.EvalPermission(ac.ActionAlertingRuleCreate), ac.EvalPermission(ac.ActionAlertingRuleExternalWrite))) {
 		alertChildNavs = append(alertChildNavs, &navtree.NavLink{
-			Text:           "Create alert rule",
-			SubTitle:       "Create an alert rule",
-			Id:             "alert",
-			Icon:           "plus",
-			Url:            s.cfg.AppSubURL + "/alerting/new",
-			HideFromTabs:   true,
-			IsCreateAction: true,
+			Text: "Create alert rule", SubTitle: "Create an alert rule", Id: "alert",
+			Icon: "plus", Url: s.cfg.AppSubURL + "/alerting/new", HideFromTabs: true, IsCreateAction: true,
 		})
 	}
 

pkg/services/navtree/navtreeimpl/navtree_alerting_test.go

@@ -1,158 +0,0 @@
-package navtreeimpl
-
-import (
-	"net/http"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-
-	"github.com/grafana/grafana/pkg/infra/log"
-	ac "github.com/grafana/grafana/pkg/services/accesscontrol"
-	accesscontrolmock "github.com/grafana/grafana/pkg/services/accesscontrol/mock"
-	contextmodel "github.com/grafana/grafana/pkg/services/contexthandler/model"
-	"github.com/grafana/grafana/pkg/services/featuremgmt"
-	"github.com/grafana/grafana/pkg/services/navtree"
-	"github.com/grafana/grafana/pkg/services/org"
-	"github.com/grafana/grafana/pkg/services/user"
-	"github.com/grafana/grafana/pkg/setting"
-	"github.com/grafana/grafana/pkg/web"
-)
-
-// Test fixtures
-func setupTestContext() *contextmodel.ReqContext {
-	httpReq, _ := http.NewRequest(http.MethodGet, "", nil)
-	return &contextmodel.ReqContext{
-		SignedInUser: &user.SignedInUser{
-			UserID:  1,
-			OrgID:   1,
-			OrgRole: org.RoleAdmin,
-		},
-		Context: &web.Context{Req: httpReq},
-	}
-}
-
-func setupTestService(permissions []ac.Permission, featureFlags ...string) ServiceImpl {
-	// Convert string slice to []any for WithFeatures
-	flags := make([]any, len(featureFlags))
-	for i, flag := range featureFlags {
-		flags[i] = flag
-	}
-	return ServiceImpl{
-		log:           log.New("navtree"),
-		cfg:           setting.NewCfg(),
-		accessControl: accesscontrolmock.New().WithPermissions(permissions),
-		features:      featuremgmt.WithFeatures(flags...),
-	}
-}
-
-func fullPermissions() []ac.Permission {
-	return []ac.Permission{
-		{Action: ac.ActionAlertingRuleRead, Scope: "*"},
-		{Action: ac.ActionAlertingNotificationsRead, Scope: "*"},
-		{Action: ac.ActionAlertingRoutesRead, Scope: "*"},
-		{Action: ac.ActionAlertingInstanceRead, Scope: "*"},
-	}
-}
-
-// Helper to find a nav link by ID
-func findNavLink(navLink *navtree.NavLink, id string) *navtree.NavLink {
-	if navLink == nil {
-		return nil
-	}
-	if navLink.Id == id {
-		return navLink
-	}
-	for _, child := range navLink.Children {
-		if found := findNavLink(child, id); found != nil {
-			return found
-		}
-	}
-	return nil
-}
-
-// Helper to check if a nav link has a child with given ID
-func hasChildWithId(parent *navtree.NavLink, childId string) bool {
-	if parent == nil {
-		return false
-	}
-	for _, child := range parent.Children {
-		if child.Id == childId {
-			return true
-		}
-	}
-	return false
-}
-
-func TestBuildAlertNavLinks(t *testing.T) {
-	reqCtx := setupTestContext()
-	allFeatureFlags := []string{"alertingTriage", "alertingCentralAlertHistory", "alertRuleRestore", "alertingRuleRecoverDeleted"}
-	service := setupTestService(fullPermissions(), allFeatureFlags...)
-
-	t.Run("Should have correct parent structure", func(t *testing.T) {
-		navLink := service.buildAlertNavLinks(reqCtx)
-		require.NotNil(t, navLink)
-		require.NotEmpty(t, navLink.Children)
-
-		// Verify all parent items exist with children
-		parentIds := []string{"alert-rules", "notification-config", "insights", "alerting-settings"}
-		for _, parentId := range parentIds {
-			parent := findNavLink(navLink, parentId)
-			require.NotNil(t, parent, "Should have parent %s", parentId)
-			require.NotEmpty(t, parent.Children, "Parent %s should have children", parentId)
-		}
-	})
-
-	t.Run("Should have correct tabs under each parent", func(t *testing.T) {
-		navLink := service.buildAlertNavLinks(reqCtx)
-		require.NotNil(t, navLink)
-
-		// Table-driven test for tab verification
-		tests := []struct {
-			parentId     string
-			expectedTabs []string
-		}{
-			{"alert-rules", []string{"alert-rules-list", "alert-rules-recently-deleted"}},
-			{"notification-config", []string{"notification-config-contact-points", "notification-config-policies", "notification-config-templates", "notification-config-time-intervals"}},
-			{"insights", []string{"insights-system", "insights-history"}},
-		}
-
-		for _, tt := range tests {
-			parent := findNavLink(navLink, tt.parentId)
-			require.NotNil(t, parent, "Should have %s parent", tt.parentId)
-
-			for _, expectedTab := range tt.expectedTabs {
-				require.True(t, hasChildWithId(parent, expectedTab), "Parent %s should have tab %s", tt.parentId, expectedTab)
-			}
-		}
-	})
-
-	t.Run("Should respect permissions", func(t *testing.T) {
-		limitedPermissions := []ac.Permission{
-			{Action: ac.ActionAlertingRuleRead, Scope: "*"},
-		}
-		limitedService := setupTestService(limitedPermissions)
-
-		navLink := limitedService.buildAlertNavLinks(reqCtx)
-		require.NotNil(t, navLink)
-
-		// Should not have notification-config without notification permissions
-		require.Nil(t, findNavLink(navLink, "notification-config"), "Should not have notification-config without permissions")
-	})
-
-	t.Run("Should exclude future items", func(t *testing.T) {
-		navLink := service.buildAlertNavLinks(reqCtx)
-		require.NotNil(t, navLink)
-
-		// Verify future items are not present
-		futureIds := []string{
-			"alert-rules-recording-rules",
-			"alert-rules-evaluation-chains",
-			"insights-alert-optimizer",
-			"insights-notification-history",
-		}
-
-		for _, futureId := range futureIds {
-			require.Nil(t, findNavLink(navLink, futureId), "Should not have future item %s", futureId)
-		}
-	})
-}

pkg/storage/unified/resource/notifier.go

@@ -78,13 +78,13 @@ func (n *notifier) Watch(ctx context.Context, opts watchOptions) <-chan Event {
 	cache := gocache.New(cacheTTL, cacheCleanupInterval)
 	events := make(chan Event, opts.BufferSize)
 
-	lastRV, err := n.lastEventResourceVersion(ctx)
+	initialRV, err := n.lastEventResourceVersion(ctx)
 	if errors.Is(err, ErrNotFound) {
-		lastRV = 0 // No events yet, start from the beginning
+		initialRV = snowflakeFromTime(time.Now()) // No events yet, start from the beginning
 	} else if err != nil {
 		n.log.Error("Failed to get last event resource version", "error", err)
 	}
-	lastRV = lastRV + 1 // We want to start watching from the next event
+	lastRV := initialRV + 1 // We want to start watching from the next event
 
 	go func() {
 		defer close(events)
@@ -110,7 +110,7 @@ func (n *notifier) Watch(ctx context.Context, opts watchOptions) <-chan Event {
 					}
 
 					// Skip old events lower than the requested resource version
-					if evt.ResourceVersion < lastRV {
+					if evt.ResourceVersion <= initialRV {
 						continue
 					}
 

pkg/storage/unified/resource/notifier_test.go

@@ -25,6 +25,7 @@ func setupTestNotifier(t *testing.T) (*notifier, *eventStore) {
 	return notifier, eventStore
 }
 
+// nolint:unused
 func setupTestNotifierSqlKv(t *testing.T) (*notifier, *eventStore) {
 	dbstore := db.InitTestDB(t)
 	eDB, err := dbimpl.ProvideResourceDB(dbstore, setting.NewCfg(), nil)
@@ -59,7 +60,8 @@ func runNotifierTestWith(t *testing.T, storeName string, newStoreFn func(*testin
 
 func TestNotifier_lastEventResourceVersion(t *testing.T) {
 	runNotifierTestWith(t, "badger", setupTestNotifier, testNotifierLastEventResourceVersion)
-	runNotifierTestWith(t, "sqlkv", setupTestNotifierSqlKv, testNotifierLastEventResourceVersion)
+	// enable this when sqlkv is ready
+	// runNotifierTestWith(t, "sqlkv", setupTestNotifierSqlKv, testNotifierLastEventResourceVersion)
 }
 
 func testNotifierLastEventResourceVersion(t *testing.T, ctx context.Context, notifier *notifier, eventStore *eventStore) {
@@ -110,7 +112,8 @@ func testNotifierLastEventResourceVersion(t *testing.T, ctx context.Context, not
 
 func TestNotifier_cachekey(t *testing.T) {
 	runNotifierTestWith(t, "badger", setupTestNotifier, testNotifierCachekey)
-	runNotifierTestWith(t, "sqlkv", setupTestNotifierSqlKv, testNotifierCachekey)
+	// enable this when sqlkv is ready
+	// runNotifierTestWith(t, "sqlkv", setupTestNotifierSqlKv, testNotifierCachekey)
 }
 
 func testNotifierCachekey(t *testing.T, ctx context.Context, notifier *notifier, eventStore *eventStore) {
@@ -164,7 +167,8 @@ func testNotifierCachekey(t *testing.T, ctx context.Context, notifier *notifier,
 
 func TestNotifier_Watch_NoEvents(t *testing.T) {
 	runNotifierTestWith(t, "badger", setupTestNotifier, testNotifierWatchNoEvents)
-	runNotifierTestWith(t, "sqlkv", setupTestNotifierSqlKv, testNotifierWatchNoEvents)
+	// enable this when sqlkv is ready
+	// runNotifierTestWith(t, "sqlkv", setupTestNotifierSqlKv, testNotifierWatchNoEvents)
 }
 
 func testNotifierWatchNoEvents(t *testing.T, ctx context.Context, notifier *notifier, eventStore *eventStore) {
@@ -205,7 +209,8 @@ func testNotifierWatchNoEvents(t *testing.T, ctx context.Context, notifier *noti
 
 func TestNotifier_Watch_WithExistingEvents(t *testing.T) {
 	runNotifierTestWith(t, "badger", setupTestNotifier, testNotifierWatchWithExistingEvents)
-	runNotifierTestWith(t, "sqlkv", setupTestNotifierSqlKv, testNotifierWatchWithExistingEvents)
+	// enable this when sqlkv is ready
+	// runNotifierTestWith(t, "sqlkv", setupTestNotifierSqlKv, testNotifierWatchWithExistingEvents)
 }
 
 func testNotifierWatchWithExistingEvents(t *testing.T, ctx context.Context, notifier *notifier, eventStore *eventStore) {
@@ -279,7 +284,8 @@ func testNotifierWatchWithExistingEvents(t *testing.T, ctx context.Context, noti
 
 func TestNotifier_Watch_EventDeduplication(t *testing.T) {
 	runNotifierTestWith(t, "badger", setupTestNotifier, testNotifierWatchEventDeduplication)
-	runNotifierTestWith(t, "sqlkv", setupTestNotifierSqlKv, testNotifierWatchEventDeduplication)
+	// enable this when sqlkv is ready
+	// runNotifierTestWith(t, "sqlkv", setupTestNotifierSqlKv, testNotifierWatchEventDeduplication)
 }
 
 func testNotifierWatchEventDeduplication(t *testing.T, ctx context.Context, notifier *notifier, eventStore *eventStore) {
@@ -345,7 +351,8 @@ func testNotifierWatchEventDeduplication(t *testing.T, ctx context.Context, noti
 
 func TestNotifier_Watch_ContextCancellation(t *testing.T) {
 	runNotifierTestWith(t, "badger", setupTestNotifier, testNotifierWatchContextCancellation)
-	runNotifierTestWith(t, "sqlkv", setupTestNotifierSqlKv, testNotifierWatchContextCancellation)
+	// enable this when sqlkv is ready
+	// runNotifierTestWith(t, "sqlkv", setupTestNotifierSqlKv, testNotifierWatchContextCancellation)
 }
 
 func testNotifierWatchContextCancellation(t *testing.T, ctx context.Context, notifier *notifier, eventStore *eventStore) {
@@ -391,7 +398,8 @@ func testNotifierWatchContextCancellation(t *testing.T, ctx context.Context, not
 
 func TestNotifier_Watch_MultipleEvents(t *testing.T) {
 	runNotifierTestWith(t, "badger", setupTestNotifier, testNotifierWatchMultipleEvents)
-	runNotifierTestWith(t, "sqlkv", setupTestNotifierSqlKv, testNotifierWatchMultipleEvents)
+	// enable this when sqlkv is ready
+	// runNotifierTestWith(t, "sqlkv", setupTestNotifierSqlKv, testNotifierWatchMultipleEvents)
 }
 
 func testNotifierWatchMultipleEvents(t *testing.T, ctx context.Context, notifier *notifier, eventStore *eventStore) {

pkg/storage/unified/resource/storage_backend.go

@@ -346,8 +346,7 @@ func (k *kvStorageBackend) WriteEvent(ctx context.Context, event WriteEvent) (in
 			return 0, fmt.Errorf("failed to write data: %w", err)
 		}
 
-		rv = rvmanager.SnowflakeFromRv(rv)
-		dataKey.ResourceVersion = rv
+		dataKey.ResourceVersion = rvmanager.SnowflakeFromRv(rv)
 	} else {
 		err := k.dataStore.Save(ctx, dataKey, bytes.NewReader(event.Value))
 		if err != nil {

pkg/storage/unified/testing/storage_backend_sql_compatibility.go

@@ -9,6 +9,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/bwmarrin/snowflake"
 	"github.com/stretchr/testify/require"
 
 	claims "github.com/grafana/authlib/types"
@@ -186,30 +187,13 @@ func runKeyPathTest(t *testing.T, backend resource.StorageBackend, nsPrefix stri
 
 // verifyKeyPath is a helper function to verify key_path generation
 func verifyKeyPath(t *testing.T, db sqldb.DB, ctx context.Context, key *resourcepb.ResourceKey, action string, resourceVersion int64, expectedFolder string) {
-	// For SQL backend (namespace contains "-sql"), resourceVersion is in microsecond format
-	// but key_path stores snowflake RV, so convert to snowflake
-	// For KV backend (namespace contains "-kv"), resourceVersion is already in snowflake format
-	isSqlBackend := strings.Contains(key.Namespace, "-sql")
-
-	var keyPathRV int64
-	if isSqlBackend {
-		// Convert microsecond RV to snowflake for key_path construction
-		keyPathRV = rvmanager.SnowflakeFromRv(resourceVersion)
-	} else {
-		// KV backend already provides snowflake RV
-		keyPathRV = resourceVersion
-	}
-
-	// Build the expected key_path using DataKey format: unified/data/group/resource/namespace/name/resourceVersion~action~folder
-	expectedKeyPath := fmt.Sprintf("unified/data/%s/%s/%s/%s/%d~%s~%s", key.Group, key.Resource, key.Namespace, key.Name, keyPathRV, action, expectedFolder)
-
 	var query string
 	if db.DriverName() == "postgres" {
-		query = "SELECT key_path, resource_version, action, folder FROM resource_history WHERE key_path = $1"
+		query = "SELECT key_path, resource_version, action, folder FROM resource_history WHERE namespace = $1 AND name = $2 AND resource_version = $3"
 	} else {
-		query = "SELECT key_path, resource_version, action, folder FROM resource_history WHERE key_path = ?"
+		query = "SELECT key_path, resource_version, action, folder FROM resource_history WHERE namespace = ? AND name = ? AND resource_version = ?"
 	}
-	rows, err := db.QueryContext(ctx, query, expectedKeyPath)
+	rows, err := db.QueryContext(ctx, query, key.Namespace, key.Name, resourceVersion)
 	require.NoError(t, err)
 
 	require.True(t, rows.Next(), "Resource not found in resource_history table - both SQL and KV backends should write to this table")
@@ -236,6 +220,10 @@ func verifyKeyPath(t *testing.T, db sqldb.DB, ctx context.Context, key *resource
 	// Verify action suffix
 	require.Contains(t, keyPath, fmt.Sprintf("~%s~", action))
 
+	// Verify snowflake calculation
+	expectedSnowflake := (((resourceVersion / 1000) - snowflake.Epoch) << (snowflake.NodeBits + snowflake.StepBits)) + (resourceVersion % 1000)
+	require.Contains(t, keyPath, fmt.Sprintf("/%d~", expectedSnowflake), "actual RV: %d", actualRV)
+
 	// Verify folder if specified
 	if expectedFolder != "" {
 		require.Equal(t, expectedFolder, actualFolder)
@@ -504,10 +492,10 @@ func verifyResourceHistoryRecord(t *testing.T, record ResourceHistoryRecord, exp
 	}
 
 	// Validate previous_resource_version
-	// For KV backend operations, expectedPrevRV is now in snowflake format (returned by KV backend)
-	// but resource_history table stores microsecond RV, so we need to use IsRvEqual for comparison
+	// For KV backend operations, resource versions are stored as snowflake format
+	// but expectedPrevRV is in microsecond format, so we need to use IsRvEqual for comparison
 	if strings.Contains(record.Namespace, "-kv") {
-		require.True(t, rvmanager.IsRvEqual(expectedPrevRV, record.PreviousResourceVersion),
+		require.True(t, rvmanager.IsRvEqual(record.PreviousResourceVersion, expectedPrevRV),
 			"Previous resource version should match (KV backend snowflake format)")
 	} else {
 		require.Equal(t, expectedPrevRV, record.PreviousResourceVersion)
@@ -517,10 +505,9 @@ func verifyResourceHistoryRecord(t *testing.T, record ResourceHistoryRecord, exp
 	require.Equal(t, expectedGeneration, record.Generation)
 
 	// Validate resource_version
-	// For KV backend operations, expectedRV is now in snowflake format (returned by KV backend)
-	// but resource_history table stores microsecond RV, so we need to use IsRvEqual for comparison
+	// For KV backend operations, resource versions are stored as snowflake format
 	if strings.Contains(record.Namespace, "-kv") {
-		require.True(t, rvmanager.IsRvEqual(expectedRV, record.ResourceVersion),
+		require.True(t, rvmanager.IsRvEqual(record.ResourceVersion, expectedRV),
 			"Resource version should match (KV backend snowflake format)")
 	} else {
 		require.Equal(t, expectedRV, record.ResourceVersion)
@@ -587,7 +574,7 @@ func verifyResourceTable(t *testing.T, db sqldb.DB, namespace string, resources
 	// Resource version should match the expected version for test-resource-3 (updated version)
 	expectedRV := resourceVersions[2][1] // test-resource-3's update version
 	if strings.Contains(namespace, "-kv") {
-		require.True(t, rvmanager.IsRvEqual(expectedRV, record.ResourceVersion),
+		require.True(t, rvmanager.IsRvEqual(record.ResourceVersion, expectedRV),
 			"Resource version should match (KV backend snowflake format)")
 	} else {
 		require.Equal(t, expectedRV, record.ResourceVersion)
@@ -638,16 +625,9 @@ func verifyResourceVersionTable(t *testing.T, db sqldb.DB, namespace string, res
 
 	// The resource_version table should contain the latest RV for the group+resource
 	// It might be slightly higher due to RV manager operations, so check it's at least our max
-	// For KV backend, maxRV is in snowflake format but record.ResourceVersion is in microsecond format
-	// Use IsRvEqual for proper comparison between different RV formats
-	isKvBackend := strings.Contains(namespace, "-kv")
-	recordResourceVersion := record.ResourceVersion
-	if isKvBackend {
-		recordResourceVersion = rvmanager.SnowflakeFromRv(record.ResourceVersion)
-	}
-
-	require.Less(t, recordResourceVersion, int64(9223372036854775807), "resource_version should be reasonable")
-	require.Greater(t, recordResourceVersion, maxRV, "resource_version should be at least the latest RV we tracked")
+	require.GreaterOrEqual(t, record.ResourceVersion, maxRV, "resource_version should be at least the latest RV we tracked")
+	// But it shouldn't be too much higher (within a reasonable range)
+	require.LessOrEqual(t, record.ResourceVersion, maxRV+100, "resource_version shouldn't be much higher than expected")
 }
 
 // runTestCrossBackendConsistency tests basic consistency between SQL and KV backends (lightweight)

pkg/storage/unified/testing/storage_backend_test.go

@@ -38,6 +38,7 @@ func TestBadgerKVStorageBackend(t *testing.T) {
 
 func TestSQLKVStorageBackend(t *testing.T) {
 	skipTests := map[string]bool{
+		TestHappyPath:                 true,
 		TestWatchWriteEvents:          true,
 		TestList:                      true,
 		TestBlobSupport:               true,
@@ -50,24 +51,21 @@ func TestSQLKVStorageBackend(t *testing.T) {
 		TestGetResourceLastImportTime: true,
 		TestOptimisticLocking:         true,
 	}
-
-	t.Run("Without RvManager", func(t *testing.T) {
-		RunStorageBackendTest(t, func(ctx context.Context) resource.StorageBackend {
-			backend, _ := NewTestSqlKvBackend(t, ctx, false)
-			return backend
-		}, &TestOptions{
-			NSPrefix:  "sqlkvstorage-test",
-			SkipTests: skipTests,
-		})
+	// without RvManager
+	RunStorageBackendTest(t, func(ctx context.Context) resource.StorageBackend {
+		backend, _ := NewTestSqlKvBackend(t, ctx, false)
+		return backend
+	}, &TestOptions{
+		NSPrefix:  "sqlkvstorage-test",
+		SkipTests: skipTests,
 	})
 
-	t.Run("With RvManager", func(t *testing.T) {
-		RunStorageBackendTest(t, func(ctx context.Context) resource.StorageBackend {
-			backend, _ := NewTestSqlKvBackend(t, ctx, true)
-			return backend
-		}, &TestOptions{
-			NSPrefix:  "sqlkvstorage-withrvmanager-test",
-			SkipTests: skipTests,
-		})
+	// with RvManager
+	RunStorageBackendTest(t, func(ctx context.Context) resource.StorageBackend {
+		backend, _ := NewTestSqlKvBackend(t, ctx, true)
+		return backend
+	}, &TestOptions{
+		NSPrefix:  "sqlkvstorage-withrvmanager-test",
+		SkipTests: skipTests,
 	})
 }

public/app/core/components/AppChrome/MegaMenu/MegaMenu.tsx

@@ -37,24 +37,9 @@ export const MegaMenu = memo(
     const pinnedItems = usePinnedItems();
 
     // Remove profile + help from tree
-    // For Alerting navigation, flatten the sidebar to show only top-level items (hide nested children/tabs)
     const navItems = navTree
       .filter((item) => item.id !== 'profile' && item.id !== 'help')
-      .map((item) => {
-        const enriched = enrichWithInteractionTracking(item, state.megaMenuDocked);
-        // If this is Alerting section, flatten children for sidebar display
-        // Children are still available in navIndex for breadcrumbs and page navigation
-        if (item.id === 'alerting' && enriched.children) {
-          return {
-            ...enriched,
-            children: enriched.children.map((child) => ({
-              ...child,
-              children: undefined, // Remove nested children from sidebar, but keep them for page navigation
-            })),
-          };
-        }
-        return enriched;
-      });
+      .map((item) => enrichWithInteractionTracking(item, state.megaMenuDocked));
 
     const bookmarksItem = navItems.find((item) => item.id === 'bookmarks');
     if (bookmarksItem) {

public/app/core/components/Breadcrumbs/utils.ts

@@ -35,18 +35,11 @@ export function buildBreadcrumbs(sectionNav: NavModelItem, pageNav?: NavModelIte
 
     if (shouldAddCrumb) {
       const activeChildIndex = node.children?.findIndex((child) => child.active) ?? -1;
-      // Add active tab to breadcrumbs if it exists and its URL is different from the node's URL
-      // This ensures tabs show in breadcrumbs (including the first tab) while preventing duplication
-      if (activeChildIndex >= 0) {
+      // Add tab to breadcrumbs if it's not the first active child
+      if (activeChildIndex > 0) {
         const activeChild = node.children?.[activeChildIndex];
         if (activeChild) {
-          // Only add the active child if its URL doesn't match the node's URL
-          // This prevents duplication when the pageNav is the active tab
-          const nodeUrl = node.url?.split('?')[0] ?? '';
-          const childUrl = activeChild.url?.split('?')[0] ?? '';
-          if (nodeUrl !== childUrl) {
-            crumbs.unshift({ text: activeChild.text, href: activeChild.url ?? '' });
-          }
+          crumbs.unshift({ text: activeChild.text, href: activeChild.url ?? '' });
         }
       }
       crumbs.unshift({ text: node.text, href: node.url ?? '' });

public/app/features/alerting/routes.tsx

@@ -56,17 +56,6 @@ export function getAlertingRoutes(cfg = config): RouteDescriptor[] {
           )
       ),
     },
-    {
-      path: '/alerting/time-intervals',
-      roles: evaluateAccess([
-        AccessControlAction.AlertingNotificationsRead,
-        AccessControlAction.AlertingNotificationsExternalRead,
-        ...PERMISSIONS_TIME_INTERVALS_READ,
-      ]),
-      component: importAlertingComponent(
-        () => import(/* webpackChunkName: "TimeIntervalsPage" */ 'app/features/alerting/unified/TimeIntervalsPage')
-      ),
-    },
     {
       path: '/alerting/routes/mute-timing/new',
       roles: evaluateAccess([
@@ -223,13 +212,6 @@ export function getAlertingRoutes(cfg = config): RouteDescriptor[] {
           )
       ),
     },
-    {
-      path: '/alerting/insights',
-      roles: evaluateAccess([AccessControlAction.AlertingRuleRead, AccessControlAction.AlertingRuleExternalRead]),
-      component: importAlertingComponent(
-        () => import(/* webpackChunkName: "InsightsPage" */ 'app/features/alerting/unified/insights/InsightsPage')
-      ),
-    },
     {
       path: '/alerting/recently-deleted/',
       roles: () => ['Admin'],

public/app/features/alerting/unified/AlertGroups.tsx

@@ -14,7 +14,6 @@ import { AlertGroupFilter } from './components/alert-groups/AlertGroupFilter';
 import { useFilteredAmGroups } from './hooks/useFilteredAmGroups';
 import { useGroupedAlerts } from './hooks/useGroupedAlerts';
 import { useUnifiedAlertingSelector } from './hooks/useUnifiedAlertingSelector';
-import { useAlertActivityNav } from './navigation/useAlertActivityNav';
 import { useAlertmanager } from './state/AlertmanagerContext';
 import { fetchAlertGroupsAction } from './state/actions';
 import { NOTIFICATIONS_POLL_INTERVAL_MS } from './utils/constants';
@@ -114,9 +113,8 @@ const AlertGroups = () => {
 };
 
 function AlertGroupsPage() {
-  const { navId, pageNav } = useAlertActivityNav();
   return (
-    <AlertmanagerPageWrapper navId={navId || 'groups'} pageNav={pageNav} accessType="instance">
+    <AlertmanagerPageWrapper navId="groups" accessType="instance">
       <AlertGroups />
     </AlertmanagerPageWrapper>
   );

public/app/features/alerting/unified/NotificationPoliciesPage.test.tsx

@@ -140,35 +140,6 @@ const getRootRoute = async () => {
 };
 
 describe('NotificationPolicies', () => {
-  beforeEach(() => {
-    setupDataSources(dataSources.am);
-    grantUserPermissions([
-      AccessControlAction.AlertingNotificationsRead,
-      AccessControlAction.AlertingNotificationsWrite,
-      ...PERMISSIONS_NOTIFICATION_POLICIES,
-    ]);
-  });
-
-  it('shows only notification policies without internal tabs', async () => {
-    renderNotificationPolicies();
-
-    // Should show notification policies directly
-    expect(await ui.rootRouteContainer.find()).toBeInTheDocument();
-
-    // Should not have tabs
-    expect(screen.queryByRole('tab')).not.toBeInTheDocument();
-  });
-
-  it('does not show time intervals tab', async () => {
-    renderNotificationPolicies();
-
-    // Should show notification policies
-    expect(await ui.rootRouteContainer.find()).toBeInTheDocument();
-
-    // Should not show time intervals tab
-    expect(screen.queryByText(/time intervals/i)).not.toBeInTheDocument();
-  });
-
   // combobox hack :/
   beforeAll(() => {
     const mockGetBoundingClientRect = jest.fn(() => ({

public/app/features/alerting/unified/NotificationPoliciesPage.tsx

@@ -1,29 +1,115 @@
+import { css } from '@emotion/css';
+import { useState } from 'react';
+
+import { GrafanaTheme2, UrlQueryMap } from '@grafana/data';
+import { t } from '@grafana/i18n';
+import { Tab, TabContent, TabsBar, useStyles2 } from '@grafana/ui';
+import { useQueryParams } from 'app/core/hooks/useQueryParams';
+import { useMuteTimings } from 'app/features/alerting/unified/components/mute-timings/useMuteTimings';
 import { NotificationPoliciesList } from 'app/features/alerting/unified/components/notification-policies/NotificationPoliciesList';
+import { AlertmanagerAction, useAlertmanagerAbility } from 'app/features/alerting/unified/hooks/useAbilities';
 
 import { AlertmanagerPageWrapper } from './components/AlertingPageWrapper';
 import { GrafanaAlertmanagerWarning } from './components/GrafanaAlertmanagerWarning';
-import { useNotificationConfigNav } from './navigation/useNotificationConfigNav';
+import { TimeIntervalsTable } from './components/mute-timings/MuteTimingsTable';
 import { useAlertmanager } from './state/AlertmanagerContext';
 import { withPageErrorBoundary } from './withPageErrorBoundary';
 
-const NotificationPoliciesContent = () => {
+enum ActiveTab {
+  NotificationPolicies = 'notification_policies',
+  TimeIntervals = 'time_intervals',
+}
+
+const NotificationPoliciesTabs = () => {
+  const styles = useStyles2(getStyles);
+
+  // Alertmanager logic and data hooks
   const { selectedAlertmanager = '' } = useAlertmanager();
+  const [policiesSupported, canSeePoliciesTab] = useAlertmanagerAbility(AlertmanagerAction.ViewNotificationPolicyTree);
+  const [timingsSupported, canSeeTimingsTab] = useAlertmanagerAbility(AlertmanagerAction.ViewTimeInterval);
+  const availableTabs = [
+    canSeePoliciesTab && ActiveTab.NotificationPolicies,
+    canSeeTimingsTab && ActiveTab.TimeIntervals,
+  ].filter((tab) => !!tab);
+  const { data: muteTimings = [] } = useMuteTimings({
+    alertmanager: selectedAlertmanager,
+    skip: !canSeeTimingsTab,
+  });
+
+  // Tab state management
+  const [queryParams, setQueryParams] = useQueryParams();
+  const { tab } = getActiveTabFromUrl(queryParams, availableTabs[0]);
+  const [activeTab, setActiveTab] = useState<ActiveTab>(tab);
+
+  const muteTimingsTabActive = activeTab === ActiveTab.TimeIntervals;
+  const policyTreeTabActive = activeTab === ActiveTab.NotificationPolicies;
+
+  const numberOfMuteTimings = muteTimings.length;
+
   return (
     <>
       <GrafanaAlertmanagerWarning currentAlertmanager={selectedAlertmanager} />
-      <NotificationPoliciesList />
+      <TabsBar>
+        {policiesSupported && canSeePoliciesTab && (
+          <Tab
+            label={t('alerting.notification-policies-tabs.label-notification-policies', 'Notification Policies')}
+            active={policyTreeTabActive}
+            onChangeTab={() => {
+              setActiveTab(ActiveTab.NotificationPolicies);
+              setQueryParams({ tab: ActiveTab.NotificationPolicies });
+            }}
+          />
+        )}
+        {timingsSupported && canSeeTimingsTab && (
+          <Tab
+            label={t('alerting.notification-policies-tabs.label-time-intervals', 'Time intervals')}
+            active={muteTimingsTabActive}
+            counter={numberOfMuteTimings}
+            onChangeTab={() => {
+              setActiveTab(ActiveTab.TimeIntervals);
+              setQueryParams({ tab: ActiveTab.TimeIntervals });
+            }}
+          />
+        )}
+      </TabsBar>
+      <TabContent className={styles.tabContent}>
+        {policyTreeTabActive && <NotificationPoliciesList />}
+        {muteTimingsTabActive && <TimeIntervalsTable />}
+      </TabContent>
     </>
   );
 };
 
-function NotificationPoliciesPage() {
-  const { navId, pageNav } = useNotificationConfigNav();
+const getStyles = (theme: GrafanaTheme2) => ({
+  tabContent: css({
+    marginTop: theme.spacing(2),
+  }),
+});
 
-  // Show only notification policies (no internal tabs)
-  // Time intervals are accessible via the sidebar navigation
+interface QueryParamValues {
+  tab: ActiveTab;
+}
+
+function getActiveTabFromUrl(queryParams: UrlQueryMap, defaultTab: ActiveTab): QueryParamValues {
+  let tab = defaultTab;
+
+  if (queryParams.tab === ActiveTab.NotificationPolicies) {
+    tab = ActiveTab.NotificationPolicies;
+  }
+
+  if (queryParams.tab === ActiveTab.TimeIntervals) {
+    tab = ActiveTab.TimeIntervals;
+  }
+
+  return {
+    tab,
+  };
+}
+
+function NotificationPoliciesPage() {
   return (
-    <AlertmanagerPageWrapper navId={navId || 'am-routes'} pageNav={pageNav} accessType="notification">
-      <NotificationPoliciesContent />
+    <AlertmanagerPageWrapper navId="am-routes" accessType="notification">
+      <NotificationPoliciesTabs />
     </AlertmanagerPageWrapper>
   );
 }

public/app/features/alerting/unified/Templates.tsx

@@ -1,52 +1,13 @@
 import { Route, Routes } from 'react-router-dom-v5-compat';
 
-import { Trans } from '@grafana/i18n';
-import { LinkButton, Stack, Text } from '@grafana/ui';
-
-import { AlertmanagerPageWrapper } from './components/AlertingPageWrapper';
 import DuplicateMessageTemplate from './components/contact-points/DuplicateMessageTemplate';
 import EditMessageTemplate from './components/contact-points/EditMessageTemplate';
 import NewMessageTemplate from './components/contact-points/NewMessageTemplate';
-import { NotificationTemplates } from './components/contact-points/NotificationTemplates';
-import { AlertmanagerAction, useAlertmanagerAbility } from './hooks/useAbilities';
-import { useNotificationConfigNav } from './navigation/useNotificationConfigNav';
 import { withPageErrorBoundary } from './withPageErrorBoundary';
 
-const TemplatesList = () => {
-  const [createTemplateSupported, createTemplateAllowed] = useAlertmanagerAbility(
-    AlertmanagerAction.CreateNotificationTemplate
-  );
-
-  return (
-    <>
-      <Stack direction="row" alignItems="center" justifyContent="space-between">
-        <Text variant="body" color="secondary">
-          <Trans i18nKey="alerting.notification-templates-tab.create-notification-templates-customize-notifications">
-            Create notification templates to customize your notifications.
-          </Trans>
-        </Text>
-        {createTemplateSupported && (
-          <LinkButton
-            icon="plus"
-            variant="primary"
-            href="/alerting/notifications/templates/new"
-            disabled={!createTemplateAllowed}
-          >
-            <Trans i18nKey="alerting.notification-templates-tab.add-notification-template-group">
-              Add notification template group
-            </Trans>
-          </LinkButton>
-        )}
-      </Stack>
-      <NotificationTemplates />
-    </>
-  );
-};
-
-function NotificationTemplatesRoutes() {
+function NotificationTemplates() {
   return (
     <Routes>
-      <Route path="" element={<TemplatesList />} />
       <Route path="new" element={<NewMessageTemplate />} />
       <Route path=":name/edit" element={<EditMessageTemplate />} />
       <Route path=":name/duplicate" element={<DuplicateMessageTemplate />} />
@@ -54,14 +15,4 @@ function NotificationTemplatesRoutes() {
   );
 }
 
-function NotificationTemplatesPage() {
-  const { navId, pageNav } = useNotificationConfigNav();
-
-  return (
-    <AlertmanagerPageWrapper navId={navId || 'receivers'} pageNav={pageNav} accessType="notification">
-      <NotificationTemplatesRoutes />
-    </AlertmanagerPageWrapper>
-  );
-}
-
-export default withPageErrorBoundary(NotificationTemplatesPage);
+export default withPageErrorBoundary(NotificationTemplates);

public/app/features/alerting/unified/TimeIntervalsPage.test.tsx

@@ -1,65 +0,0 @@
-import { render, screen } from 'test/test-utils';
-
-import { configureStore } from 'app/store/configureStore';
-import { AccessControlAction } from 'app/types/accessControl';
-
-import TimeIntervalsPage from './TimeIntervalsPage';
-import { defaultConfig } from './components/mute-timings/mocks';
-import { setupMswServer } from './mockApi';
-import { grantUserPermissions, mockDataSource } from './mocks';
-import { setTimeIntervalsListEmpty } from './mocks/server/configure';
-import { setAlertmanagerConfig } from './mocks/server/entities/alertmanagers';
-import { setupDataSources } from './testSetup/datasources';
-import { DataSourceType, GRAFANA_RULES_SOURCE_NAME } from './utils/datasource';
-
-setupMswServer();
-
-const alertManager = mockDataSource({
-  name: 'Alertmanager',
-  type: DataSourceType.Alertmanager,
-});
-
-describe('TimeIntervalsPage', () => {
-  beforeEach(() => {
-    setupDataSources(alertManager);
-    setAlertmanagerConfig(GRAFANA_RULES_SOURCE_NAME, defaultConfig);
-    setTimeIntervalsListEmpty(); // Mock empty time intervals list so component renders
-    grantUserPermissions([
-      AccessControlAction.AlertingNotificationsRead,
-      AccessControlAction.AlertingTimeIntervalsRead,
-    ]);
-  });
-
-  it('renders time intervals table', async () => {
-    const mockNavIndex = {
-      'notification-config': {
-        id: 'notification-config',
-        text: 'Notification configuration',
-        url: '/alerting/notifications',
-      },
-      'notification-config-time-intervals': {
-        id: 'notification-config-time-intervals',
-        text: 'Time intervals',
-        url: '/alerting/time-intervals',
-      },
-    };
-    const store = configureStore({
-      navIndex: mockNavIndex,
-    });
-
-    render(<TimeIntervalsPage />, {
-      store,
-      historyOptions: {
-        initialEntries: ['/alerting/time-intervals'],
-      },
-    });
-
-    // Should show time intervals content
-    // When empty, it shows "You haven't created any time intervals yet"
-    // When loading, it shows "Loading time intervals..."
-    // When error, it shows "Error loading time intervals"
-    // All contain "time intervals" - use getAllByText since there are multiple matches (tab, description, empty state)
-    const timeIntervalsTexts = await screen.findAllByText(/time intervals/i, {}, { timeout: 5000 });
-    expect(timeIntervalsTexts.length).toBeGreaterThan(0);
-  });
-});

public/app/features/alerting/unified/TimeIntervalsPage.tsx

@@ -1,31 +0,0 @@
-import { AlertmanagerPageWrapper } from './components/AlertingPageWrapper';
-import { GrafanaAlertmanagerWarning } from './components/GrafanaAlertmanagerWarning';
-import { TimeIntervalsTable } from './components/mute-timings/MuteTimingsTable';
-import { useNotificationConfigNav } from './navigation/useNotificationConfigNav';
-import { useAlertmanager } from './state/AlertmanagerContext';
-import { withPageErrorBoundary } from './withPageErrorBoundary';
-
-// Content component that uses AlertmanagerContext
-// This must be rendered within AlertmanagerPageWrapper
-function TimeIntervalsPageContent() {
-  const { selectedAlertmanager } = useAlertmanager();
-
-  return (
-    <>
-      <GrafanaAlertmanagerWarning currentAlertmanager={selectedAlertmanager!} />
-      <TimeIntervalsTable />
-    </>
-  );
-}
-
-function TimeIntervalsPage() {
-  const { navId, pageNav } = useNotificationConfigNav();
-
-  return (
-    <AlertmanagerPageWrapper navId={navId || 'am-routes'} pageNav={pageNav} accessType="notification">
-      <TimeIntervalsPageContent />
-    </AlertmanagerPageWrapper>
-  );
-}
-
-export default withPageErrorBoundary(TimeIntervalsPage);

public/app/features/alerting/unified/components/contact-points/ContactPoints.test.tsx

@@ -170,26 +170,6 @@ describe('contact points', () => {
       });
     });
 
-    test('shows only contact points without internal tabs', async () => {
-      renderWithProvider(<ContactPointsPageContents />);
-
-      // Should show contact points directly
-      expect(await screen.findByText(/create contact point/i)).toBeInTheDocument();
-
-      // Should not have tabs
-      expect(screen.queryByRole('tab')).not.toBeInTheDocument();
-    });
-
-    test('does not show templates tab', async () => {
-      renderWithProvider(<ContactPointsPageContents />);
-
-      // Should show contact points
-      expect(await screen.findByText(/create contact point/i)).toBeInTheDocument();
-
-      // Should not show templates tab
-      expect(screen.queryByText(/notification templates/i)).not.toBeInTheDocument();
-    });
-
     describe('templates tab', () => {
       it('does not show a warning for a "misconfigured" template', async () => {
         renderWithProvider(
@@ -278,6 +258,14 @@ describe('contact points', () => {
       // there should be view buttons though - one for provisioned, and one for the un-editable contact point
       const viewButtons = screen.getAllByRole('link', { name: /^view$/i });
       expect(viewButtons).toHaveLength(2);
+
+      // check buttons in Notification Templates
+      const notificationTemplatesTab = screen.getByRole('tab', { name: 'Notification Templates' });
+      await user.click(notificationTemplatesTab);
+      expect(screen.getByRole('link', { name: 'Add notification template group' })).toHaveAttribute(
+        'aria-disabled',
+        'true'
+      );
     });
 
     it('allows deleting when not disabled', async () => {
@@ -482,6 +470,11 @@ describe('contact points', () => {
       const viewButton = screen.getByRole('link', { name: /^view$/i });
       expect(viewButton).toBeInTheDocument();
       expect(viewButton).toBeEnabled();
+
+      // check buttons in Notification Templates
+      const notificationTemplatesTab = screen.getByRole('tab', { name: 'Notification Templates' });
+      await user.click(notificationTemplatesTab);
+      expect(screen.queryByRole('link', { name: 'Add notification template group' })).not.toBeInTheDocument();
     });
   });
 

public/app/features/alerting/unified/components/contact-points/ContactPoints.tsx

@@ -1,5 +1,19 @@
+import { useMemo } from 'react';
+
 import { Trans, t } from '@grafana/i18n';
-import { Alert, Button, EmptyState, LinkButton, LoadingPlaceholder, Pagination, Stack } from '@grafana/ui';
+import {
+  Alert,
+  Button,
+  EmptyState,
+  LinkButton,
+  LoadingPlaceholder,
+  Pagination,
+  Stack,
+  Tab,
+  TabContent,
+  TabsBar,
+  Text,
+} from '@grafana/ui';
 import { contextSrv } from 'app/core/services/context_srv';
 import { shouldUseK8sApi } from 'app/features/alerting/unified/utils/k8s/utils';
 import { makeAMLink, stringifyErrorLike } from 'app/features/alerting/unified/utils/misc';
@@ -8,7 +22,6 @@ import { AccessControlAction } from 'app/types/accessControl';
 import { AlertmanagerAction, useAlertmanagerAbility } from '../../hooks/useAbilities';
 import { usePagination } from '../../hooks/usePagination';
 import { useURLSearchParams } from '../../hooks/useURLSearchParams';
-import { useNotificationConfigNav } from '../../navigation/useNotificationConfigNav';
 import { useAlertmanager } from '../../state/AlertmanagerContext';
 import { isExtraConfig } from '../../utils/alertmanager/extraConfigs';
 import { GRAFANA_RULES_SOURCE_NAME } from '../../utils/datasource';
@@ -17,6 +30,7 @@ import { AlertmanagerPageWrapper } from '../AlertingPageWrapper';
 import { GrafanaAlertmanagerWarning } from '../GrafanaAlertmanagerWarning';
 
 import { ContactPoint } from './ContactPoint';
+import { NotificationTemplates } from './NotificationTemplates';
 import { ContactPointsFilter } from './components/ContactPointsFilter';
 import { GlobalConfigAlert } from './components/GlobalConfigAlert';
 import { useContactPointsWithStatus } from './useContactPoints';
@@ -85,7 +99,7 @@ const ContactPointsTab = () => {
   }
 
   return (
-    <Stack direction="column" gap={1}>
+    <>
       {/* TODO we can add some additional info here with a ToggleTip */}
       <Stack direction="row" alignItems="end" justifyContent="space-between">
         <ContactPointsFilter />
@@ -134,19 +148,109 @@ const ContactPointsTab = () => {
         <GlobalConfigAlert alertManagerName={selectedAlertmanager!} />
       )}
       {ExportDrawer}
-    </Stack>
+    </>
   );
 };
 
+const NotificationTemplatesTab = () => {
+  const [createTemplateSupported, createTemplateAllowed] = useAlertmanagerAbility(
+    AlertmanagerAction.CreateNotificationTemplate
+  );
+
+  return (
+    <>
+      <Stack direction="row" alignItems="center" justifyContent="space-between">
+        <Text variant="body" color="secondary">
+          <Trans i18nKey="alerting.notification-templates-tab.create-notification-templates-customize-notifications">
+            Create notification templates to customize your notifications.
+          </Trans>
+        </Text>
+        {createTemplateSupported && (
+          <LinkButton
+            icon="plus"
+            variant="primary"
+            href="/alerting/notifications/templates/new"
+            disabled={!createTemplateAllowed}
+          >
+            <Trans i18nKey="alerting.notification-templates-tab.add-notification-template-group">
+              Add notification template group
+            </Trans>
+          </LinkButton>
+        )}
+      </Stack>
+      <NotificationTemplates />
+    </>
+  );
+};
+
+const useTabQueryParam = (defaultTab: ActiveTab) => {
+  const [queryParams, setQueryParams] = useURLSearchParams();
+  const param = useMemo(() => {
+    const queryParam = queryParams.get('tab');
+
+    if (!queryParam || !Object.values(ActiveTab).map(String).includes(queryParam)) {
+      return defaultTab;
+    }
+
+    return queryParam || defaultTab;
+  }, [defaultTab, queryParams]);
+
+  const setParam = (tab: ActiveTab) => setQueryParams({ tab });
+  return [param, setParam] as const;
+};
+
 export const ContactPointsPageContents = () => {
   const { selectedAlertmanager } = useAlertmanager();
+  const [, canViewContactPoints] = useAlertmanagerAbility(AlertmanagerAction.ViewContactPoint);
+  const [, canCreateContactPoints] = useAlertmanagerAbility(AlertmanagerAction.CreateContactPoint);
+  const [, showTemplatesTab] = useAlertmanagerAbility(AlertmanagerAction.ViewNotificationTemplate);
+
+  const showContactPointsTab = canViewContactPoints || canCreateContactPoints;
+
+  // Depending on permissions, user may not have access to all tabs,
+  // but we can default to picking the first one that they definitely _do_ have access to
+  const defaultTab = [
+    showContactPointsTab && ActiveTab.ContactPoints,
+    showTemplatesTab && ActiveTab.NotificationTemplates,
+  ].filter((tab) => !!tab)[0];
+
+  const [activeTab, setActiveTab] = useTabQueryParam(defaultTab);
+
+  const { contactPoints } = useContactPointsWithStatus({
+    alertmanager: selectedAlertmanager!,
+  });
+
+  const showingContactPoints = activeTab === ActiveTab.ContactPoints;
+  const showNotificationTemplates = activeTab === ActiveTab.NotificationTemplates;
 
-  // Show only contact points (no internal tabs)
-  // Templates are accessible via the sidebar navigation
   return (
     <>
       <GrafanaAlertmanagerWarning currentAlertmanager={selectedAlertmanager!} />
-      <ContactPointsTab />
+      <Stack direction="column">
+        <TabsBar>
+          {showContactPointsTab && (
+            <Tab
+              label={t('alerting.contact-points-page-contents.label-contact-points', 'Contact Points')}
+              active={showingContactPoints}
+              counter={contactPoints.length}
+              onChangeTab={() => setActiveTab(ActiveTab.ContactPoints)}
+            />
+          )}
+          {showTemplatesTab && (
+            <Tab
+              label={t('alerting.contact-points-page-contents.label-notification-templates', 'Notification Templates')}
+              active={showNotificationTemplates}
+              onChangeTab={() => setActiveTab(ActiveTab.NotificationTemplates)}
+            />
+          )}
+        </TabsBar>
+        <TabContent>
+          <Stack direction="column">
+            {showingContactPoints && <ContactPointsTab />}
+            {showNotificationTemplates && <NotificationTemplatesTab />}
+          </Stack>
+        </TabContent>
+      </Stack>
     </>
   );
 };
@@ -178,9 +282,8 @@ const ContactPointsList = ({ contactPoints, search, pageSize = DEFAULT_PAGE_SIZE
 };
 
 function ContactPointsPage() {
-  const { navId, pageNav } = useNotificationConfigNav();
   return (
-    <AlertmanagerPageWrapper navId={navId || 'receivers'} pageNav={pageNav} accessType="notification">
+    <AlertmanagerPageWrapper navId="receivers" accessType="notification">
       <ContactPointsPageContents />
     </AlertmanagerPageWrapper>
   );

public/app/features/alerting/unified/components/rules/central-state-history/CentralAlertHistoryPage.tsx

@@ -1,13 +1,11 @@
-import { useInsightsNav } from '../../../navigation/useInsightsNav';
 import { withPageErrorBoundary } from '../../../withPageErrorBoundary';
 import { AlertingPageWrapper } from '../../AlertingPageWrapper';
 
 import { CentralAlertHistoryScene } from './CentralAlertHistoryScene';
 
 function HistoryPage() {
-  const { navId, pageNav } = useInsightsNav();
   return (
-    <AlertingPageWrapper navId={navId || 'alerts-history'} pageNav={pageNav} isLoading={false}>
+    <AlertingPageWrapper navId="alerts-history" isLoading={false}>
       <CentralAlertHistoryScene />
     </AlertingPageWrapper>
   );

public/app/features/alerting/unified/components/rules/deleted-rules/DeletedRulesPage.tsx

@@ -3,7 +3,6 @@ import { Alert } from '@grafana/ui';
 
 import { alertRuleApi } from '../../../api/alertRuleApi';
 import { GRAFANA_RULER_CONFIG } from '../../../api/featureDiscoveryApi';
-import { useAlertRulesNav } from '../../../navigation/useAlertRulesNav';
 import { stringifyErrorLike } from '../../../utils/misc';
 import { withPageErrorBoundary } from '../../../withPageErrorBoundary';
 import { AlertingPageWrapper } from '../../AlertingPageWrapper';
@@ -19,10 +18,9 @@ function DeletedrulesPage() {
     rulerConfig: GRAFANA_RULER_CONFIG,
     filter: {}, // todo: add filters, and limit?????
   });
-  const { navId, pageNav } = useAlertRulesNav();
 
   return (
-    <AlertingPageWrapper navId={navId || 'alerts/recently-deleted'} pageNav={pageNav} isLoading={isLoading}>
+    <AlertingPageWrapper navId="alerts/recently-deleted" isLoading={isLoading}>
       <>
         {error && (
           <Alert title={t('alerting.deleted-rules.errorloading', 'Failed to load alert deleted rules')}>

public/app/features/alerting/unified/home/Home.tsx

@@ -1,24 +1,23 @@
-import { useMemo, useState } from 'react';
+import { useState } from 'react';
 
 import { t } from '@grafana/i18n';
 import { Box, Stack, Tab, TabContent, TabsBar } from '@grafana/ui';
 
 import { AlertingPageWrapper } from '../components/AlertingPageWrapper';
+import { isLocalDevEnv } from '../utils/misc';
 import { withPageErrorBoundary } from '../withPageErrorBoundary';
 
 import GettingStarted, { WelcomeHeader } from './GettingStarted';
 import IRMCard from './IRMCard';
-import { getInsightsScenes } from './Insights';
+import { getInsightsScenes, insightsIsAvailable } from './Insights';
 import { PluginIntegrations } from './PluginIntegrations';
 import SyntheticMonitoringCard from './SyntheticMonitoringCard';
 
 function Home() {
-  // Insights tab is not shown on Home page - Insights is available via the sidebar menu instead
-  const insightsEnabled = false;
+  const insightsEnabled = insightsIsAvailable() || isLocalDevEnv();
 
   const [activeTab, setActiveTab] = useState<'insights' | 'overview'>(insightsEnabled ? 'insights' : 'overview');
-  // Memoize the scene so it's only created once and properly initialized
-  const insightsScene = useMemo(() => getInsightsScenes(), []);
+  const insightsScene = getInsightsScenes();
 
   return (
     <AlertingPageWrapper subTitle="Learn about problems in your systems moments after they occur" navId="alerting">

public/app/features/alerting/unified/insights/InsightsPage.tsx

@@ -1,44 +0,0 @@
-import { useMemo } from 'react';
-
-import { Trans, t } from '@grafana/i18n';
-
-import { AlertingPageWrapper } from '../components/AlertingPageWrapper';
-import { getInsightsScenes, insightsIsAvailable } from '../home/Insights';
-import { useInsightsNav } from '../navigation/useInsightsNav';
-import { isLocalDevEnv } from '../utils/misc';
-import { withPageErrorBoundary } from '../withPageErrorBoundary';
-
-function InsightsPage() {
-  const insightsEnabled = insightsIsAvailable() || isLocalDevEnv();
-  const { navId, pageNav } = useInsightsNav();
-  // Memoize the scene so it's only created once and properly initialized
-  const insightsScene = useMemo(() => getInsightsScenes(), []);
-
-  if (!insightsEnabled) {
-    return (
-      <AlertingPageWrapper
-        navId={navId || 'insights'}
-        pageNav={pageNav}
-        subTitle={t('alerting.insights.subtitle', 'Analytics and history for alerting')}
-      >
-        <div>
-          <Trans i18nKey="alerting.insights.not-available">
-            Insights are not available. Please configure the required data sources.
-          </Trans>
-        </div>
-      </AlertingPageWrapper>
-    );
-  }
-
-  return (
-    <AlertingPageWrapper
-      navId={navId || 'insights'}
-      pageNav={pageNav}
-      subTitle={t('alerting.insights.subtitle', 'Analytics and history for alerting')}
-    >
-      <insightsScene.Component model={insightsScene} />
-    </AlertingPageWrapper>
-  );
-}
-
-export default withPageErrorBoundary(InsightsPage);

public/app/features/alerting/unified/navigation/useAlertActivityNav.test.tsx

@@ -1,134 +0,0 @@
-import { renderHook } from '@testing-library/react';
-import { getWrapper } from 'test/test-utils';
-
-import { configureStore } from 'app/store/configureStore';
-
-import { useAlertActivityNav } from './useAlertActivityNav';
-
-describe('useAlertActivityNav', () => {
-  const mockNavIndex = {
-    'alert-activity': {
-      id: 'alert-activity',
-      text: 'Alert activity',
-      url: '/alerting/alerts',
-    },
-    'alert-activity-alerts': {
-      id: 'alert-activity-alerts',
-      text: 'Alerts',
-      url: '/alerting/alerts',
-    },
-    'alert-activity-groups': {
-      id: 'alert-activity-groups',
-      text: 'Active notifications',
-      url: '/alerting/groups',
-    },
-  };
-
-  const defaultPreloadedState = {
-    navIndex: mockNavIndex,
-  };
-
-  it('should return navigation with pageNav for Alerts tab', () => {
-    const store = configureStore(defaultPreloadedState);
-    const wrapper = getWrapper({
-      store,
-      renderWithRouter: true,
-      historyOptions: {
-        initialEntries: ['/alerting/alerts'],
-      },
-    });
-
-    const { result } = renderHook(() => useAlertActivityNav(), { wrapper });
-
-    expect(result.current.navId).toBe('alert-activity');
-    expect(result.current.pageNav).toBeDefined();
-    // eslint-disable-next-line testing-library/no-node-access
-    expect(result.current.pageNav?.children).toBeDefined();
-    // The pageNav should represent Alert Activity (not the active tab) for consistent title
-    expect(result.current.pageNav?.text).toBe('Alert activity');
-  });
-
-  it('should return navigation with pageNav for Active notifications tab', () => {
-    const store = configureStore(defaultPreloadedState);
-    const wrapper = getWrapper({
-      store,
-      renderWithRouter: true,
-      historyOptions: {
-        initialEntries: ['/alerting/groups'],
-      },
-    });
-
-    const { result } = renderHook(() => useAlertActivityNav(), { wrapper });
-
-    expect(result.current.navId).toBe('alert-activity');
-    expect(result.current.pageNav).toBeDefined();
-    // eslint-disable-next-line testing-library/no-node-access
-    expect(result.current.pageNav?.children).toBeDefined();
-    // The pageNav should represent Alert Activity (not the active tab) for consistent title
-    expect(result.current.pageNav?.text).toBe('Alert activity');
-  });
-
-  it('should set active tab based on current path', () => {
-    const store = configureStore(defaultPreloadedState);
-    const wrapper = getWrapper({
-      store,
-      renderWithRouter: true,
-      historyOptions: {
-        initialEntries: ['/alerting/groups'],
-      },
-    });
-
-    const { result } = renderHook(() => useAlertActivityNav(), { wrapper });
-
-    // eslint-disable-next-line testing-library/no-node-access
-    const activeNotificationsTab = result.current.pageNav?.children?.find((tab) => tab.id === 'alert-activity-groups');
-    expect(activeNotificationsTab?.active).toBe(true);
-
-    // eslint-disable-next-line testing-library/no-node-access
-    const alertsTab = result.current.pageNav?.children?.find((tab) => tab.id === 'alert-activity-alerts');
-    expect(alertsTab?.active).toBe(false);
-  });
-
-  it('should filter tabs based on permissions', () => {
-    const limitedNavIndex = {
-      'alert-activity': mockNavIndex['alert-activity'],
-      'alert-activity-alerts': mockNavIndex['alert-activity-alerts'],
-      // Missing 'alert-activity-groups' - user doesn't have permission
-    };
-    const store = configureStore({
-      navIndex: limitedNavIndex,
-    });
-    const wrapper = getWrapper({
-      store,
-      renderWithRouter: true,
-      historyOptions: {
-        initialEntries: ['/alerting/alerts'],
-      },
-    });
-
-    const { result } = renderHook(() => useAlertActivityNav(), { wrapper });
-
-    // eslint-disable-next-line testing-library/no-node-access
-    expect(result.current.pageNav?.children?.length).toBe(1);
-    // eslint-disable-next-line testing-library/no-node-access
-    expect(result.current.pageNav?.children?.[0].id).toBe('alert-activity-alerts');
-  });
-
-  it('should return undefined when alert-activity nav is missing', () => {
-    const store = configureStore({
-      navIndex: {},
-    });
-    const wrapper = getWrapper({
-      store,
-      renderWithRouter: true,
-      historyOptions: {
-        initialEntries: ['/alerting/groups'],
-      },
-    });
-
-    const { result } = renderHook(() => useAlertActivityNav(), { wrapper });
-
-    expect(result.current.navId).toBeUndefined();
-    expect(result.current.pageNav).toBeUndefined();
-  });
-});

public/app/features/alerting/unified/navigation/useAlertActivityNav.ts

@@ -1,57 +0,0 @@
-import { useLocation } from 'react-router-dom-v5-compat';
-
-import { NavModelItem } from '@grafana/data';
-import { t } from '@grafana/i18n';
-import { useSelector } from 'app/types/store';
-
-export function useAlertActivityNav() {
-  const location = useLocation();
-  const navIndex = useSelector((state) => state.navIndex);
-
-  const alertActivityNav = navIndex['alert-activity'];
-  if (!alertActivityNav) {
-    return {
-      navId: undefined,
-      pageNav: undefined,
-    };
-  }
-
-  // All available tabs
-  const allTabs = [
-    {
-      id: 'alert-activity-alerts',
-      text: t('alerting.navigation.alerts', 'Alerts'),
-      url: '/alerting/alerts',
-      active: location.pathname === '/alerting/alerts',
-      icon: 'bell',
-      parentItem: alertActivityNav,
-    },
-    {
-      id: 'alert-activity-groups',
-      text: t('alerting.navigation.active-notifications', 'Active notifications'),
-      url: '/alerting/groups',
-      active: location.pathname === '/alerting/groups',
-      icon: 'layer-group',
-      parentItem: alertActivityNav,
-    },
-  ].filter((tab) => {
-    // Filter based on permissions - if nav item doesn't exist, user doesn't have permission
-    const navItem = navIndex[tab.id];
-    return navItem !== undefined;
-  });
-
-  // Create pageNav structure following the same pattern as useNotificationConfigNav
-  // Keep "Alert Activity" as the pageNav (not the active tab) so the title and subtitle stay consistent
-  // The tabs are children, and the breadcrumb utility will add the active tab to breadcrumbs
-  // (including the first tab, after our fix to the breadcrumb utility)
-  const pageNav: NavModelItem = {
-    ...alertActivityNav,
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    children: allTabs as NavModelItem[],
-  };
-
-  return {
-    navId: 'alert-activity',
-    pageNav,
-  };
-}

public/app/features/alerting/unified/navigation/useAlertRulesNav.test.tsx

@@ -1,95 +0,0 @@
-import { renderHook } from '@testing-library/react';
-import { getWrapper } from 'test/test-utils';
-
-import { configureStore } from 'app/store/configureStore';
-
-import { useAlertRulesNav } from './useAlertRulesNav';
-
-describe('useAlertRulesNav', () => {
-  const mockNavIndex = {
-    'alert-rules': {
-      id: 'alert-rules',
-      text: 'Alert rules',
-      url: '/alerting/list',
-      icon: 'list-ul' as const,
-    },
-    'alert-rules-list': {
-      id: 'alert-rules-list',
-      text: 'Alert rules',
-      url: '/alerting/list',
-    },
-    'alert-rules-recently-deleted': {
-      id: 'alert-rules-recently-deleted',
-      text: 'Recently deleted',
-      url: '/alerting/recently-deleted',
-    },
-  };
-
-  const defaultPreloadedState = {
-    navIndex: mockNavIndex,
-  };
-
-  it('should return navigation with pageNav', () => {
-    const store = configureStore(defaultPreloadedState);
-    const wrapper = getWrapper({
-      store,
-      renderWithRouter: true,
-      historyOptions: {
-        initialEntries: ['/alerting/list'],
-      },
-    });
-
-    const { result } = renderHook(() => useAlertRulesNav(), { wrapper });
-
-    expect(result.current.navId).toBe('alert-rules');
-    expect(result.current.pageNav).toBeDefined();
-    // eslint-disable-next-line testing-library/no-node-access
-    expect(result.current.pageNav?.children).toBeDefined();
-    // eslint-disable-next-line testing-library/no-node-access
-    expect(result.current.pageNav?.children?.length).toBeGreaterThan(0);
-  });
-
-  it('should filter tabs based on permissions', () => {
-    const limitedNavIndex = {
-      'alert-rules': mockNavIndex['alert-rules'],
-      'alert-rules-list': mockNavIndex['alert-rules-list'],
-      // Missing 'alert-rules-recently-deleted' - user doesn't have permission
-    };
-    const store = configureStore({
-      navIndex: limitedNavIndex,
-    });
-    const wrapper = getWrapper({
-      store,
-      renderWithRouter: true,
-      historyOptions: {
-        initialEntries: ['/alerting/list'],
-      },
-    });
-
-    const { result } = renderHook(() => useAlertRulesNav(), { wrapper });
-
-    // eslint-disable-next-line testing-library/no-node-access
-    expect(result.current.pageNav?.children?.length).toBe(1);
-    // eslint-disable-next-line testing-library/no-node-access
-    expect(result.current.pageNav?.children?.[0].id).toBe('alert-rules-list');
-  });
-
-  it('should set active tab based on current path', () => {
-    const store = configureStore(defaultPreloadedState);
-    const wrapper = getWrapper({
-      store,
-      renderWithRouter: true,
-      historyOptions: {
-        initialEntries: ['/alerting/recently-deleted'],
-      },
-    });
-
-    const { result } = renderHook(() => useAlertRulesNav(), { wrapper });
-
-    // eslint-disable-next-line testing-library/no-node-access
-    const recentlyDeletedTab = result.current.pageNav?.children?.find(
-      (tab) => tab.id === 'alert-rules-recently-deleted'
-    );
-    expect(recentlyDeletedTab?.active).toBe(true);
-  });
-});

public/app/features/alerting/unified/navigation/useAlertRulesNav.ts

@@ -1,54 +0,0 @@
-import { useLocation } from 'react-router-dom-v5-compat';
-
-import { NavModelItem } from '@grafana/data';
-import { t } from '@grafana/i18n';
-import { useSelector } from 'app/types/store';
-
-export function useAlertRulesNav() {
-  const location = useLocation();
-  const navIndex = useSelector((state) => state.navIndex);
-
-  const alertRulesNav = navIndex['alert-rules'];
-  if (!alertRulesNav) {
-    return {
-      navId: undefined,
-      pageNav: undefined,
-    };
-  }
-
-  // All available tabs
-  const allTabs = [
-    {
-      id: 'alert-rules-list',
-      text: t('alerting.navigation.alert-rules', 'Alert rules'),
-      url: '/alerting/list',
-      active: location.pathname === '/alerting/list',
-      icon: 'list-ul',
-      parentItem: alertRulesNav,
-    },
-    {
-      id: 'alert-rules-recently-deleted',
-      text: t('alerting.navigation.recently-deleted', 'Recently deleted'),
-      url: '/alerting/recently-deleted',
-      active: location.pathname === '/alerting/recently-deleted',
-      icon: 'trash-alt',
-      parentItem: alertRulesNav,
-    },
-  ].filter((tab) => {
-    // Filter based on permissions - if nav item doesn't exist, user doesn't have permission
-    const navItem = navIndex[tab.id];
-    return navItem !== undefined;
-  });
-
-  // Create pageNav that represents the Alert rules page with tabs as children
-  const pageNav: NavModelItem = {
-    ...alertRulesNav,
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    children: allTabs as NavModelItem[],
-  };
-
-  return {
-    navId: 'alert-rules',
-    pageNav,
-  };
-}

public/app/features/alerting/unified/navigation/useInsightsNav.test.tsx

@@ -1,90 +0,0 @@
-import { renderHook } from '@testing-library/react';
-import { getWrapper } from 'test/test-utils';
-
-import { configureStore } from 'app/store/configureStore';
-
-import { useInsightsNav } from './useInsightsNav';
-
-describe('useInsightsNav', () => {
-  const mockNavIndex = {
-    insights: {
-      id: 'insights',
-      text: 'Insights',
-      url: '/alerting/insights',
-    },
-    'insights-system': {
-      id: 'insights-system',
-      text: 'System Insights',
-      url: '/alerting/insights',
-    },
-    'insights-history': {
-      id: 'insights-history',
-      text: 'Alert state history',
-      url: '/alerting/history',
-    },
-  };
-
-  const defaultPreloadedState = {
-    navIndex: mockNavIndex,
-  };
-
-  it('should return navigation with pageNav', () => {
-    const store = configureStore(defaultPreloadedState);
-    const wrapper = getWrapper({
-      store,
-      renderWithRouter: true,
-      historyOptions: {
-        initialEntries: ['/alerting/insights'],
-      },
-    });
-
-    const { result } = renderHook(() => useInsightsNav(), { wrapper });
-
-    expect(result.current.navId).toBe('insights');
-    expect(result.current.pageNav).toBeDefined();
-    // eslint-disable-next-line testing-library/no-node-access
-    expect(result.current.pageNav?.children).toBeDefined();
-  });
-
-  it('should set active tab based on current path', () => {
-    const store = configureStore(defaultPreloadedState);
-    const wrapper = getWrapper({
-      store,
-      renderWithRouter: true,
-      historyOptions: {
-        initialEntries: ['/alerting/history'],
-      },
-    });
-
-    const { result } = renderHook(() => useInsightsNav(), { wrapper });
-
-    // eslint-disable-next-line testing-library/no-node-access
-    const historyTab = result.current.pageNav?.children?.find((tab) => tab.id === 'insights-history');
-    expect(historyTab?.active).toBe(true);
-  });
-
-  it('should filter tabs based on permissions', () => {
-    const limitedNavIndex = {
-      insights: mockNavIndex.insights,
-      'insights-system': mockNavIndex['insights-system'],
-      // Missing 'insights-history' - user doesn't have permission
-    };
-    const store = configureStore({
-      navIndex: limitedNavIndex,
-    });
-    const wrapper = getWrapper({
-      store,
-      renderWithRouter: true,
-      historyOptions: {
-        initialEntries: ['/alerting/insights'],
-      },
-    });
-
-    const { result } = renderHook(() => useInsightsNav(), { wrapper });
-
-    // eslint-disable-next-line testing-library/no-node-access
-    expect(result.current.pageNav?.children?.length).toBe(1);
-    // eslint-disable-next-line testing-library/no-node-access
-    expect(result.current.pageNav?.children?.[0].id).toBe('insights-system');
-  });
-});

public/app/features/alerting/unified/navigation/useInsightsNav.ts

@@ -1,54 +0,0 @@
-import { useLocation } from 'react-router-dom-v5-compat';
-
-import { NavModelItem } from '@grafana/data';
-import { t } from '@grafana/i18n';
-import { useSelector } from 'app/types/store';
-
-export function useInsightsNav() {
-  const location = useLocation();
-  const navIndex = useSelector((state) => state.navIndex);
-
-  const insightsNav = navIndex.insights;
-  if (!insightsNav) {
-    return {
-      navId: undefined,
-      pageNav: undefined,
-    };
-  }
-
-  // All available tabs
-  const allTabs = [
-    {
-      id: 'insights-system',
-      text: t('alerting.navigation.system-insights', 'System Insights'),
-      url: '/alerting/insights',
-      active: location.pathname === '/alerting/insights',
-      icon: 'chart-line',
-      parentItem: insightsNav,
-    },
-    {
-      id: 'insights-history',
-      text: t('alerting.navigation.alert-state-history', 'Alert state history'),
-      url: '/alerting/history',
-      active: location.pathname === '/alerting/history',
-      icon: 'history',
-      parentItem: insightsNav,
-    },
-  ].filter((tab) => {
-    // Filter based on permissions - if nav item doesn't exist, user doesn't have permission
-    const navItem = navIndex[tab.id];
-    return navItem !== undefined;
-  });
-
-  // Create pageNav that represents the Insights page with tabs as children
-  const pageNav: NavModelItem = {
-    ...insightsNav,
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    children: allTabs as NavModelItem[],
-  };
-
-  return {
-    navId: 'insights',
-    pageNav,
-  };
-}

public/app/features/alerting/unified/navigation/useNotificationConfigNav.test.tsx

@@ -1,102 +0,0 @@
-import { renderHook } from '@testing-library/react';
-import { getWrapper } from 'test/test-utils';
-
-import { configureStore } from 'app/store/configureStore';
-
-import { useNotificationConfigNav } from './useNotificationConfigNav';
-
-describe('useNotificationConfigNav', () => {
-  const mockNavIndex = {
-    'notification-config': {
-      id: 'notification-config',
-      text: 'Notification configuration',
-      url: '/alerting/notifications',
-    },
-    'notification-config-contact-points': {
-      id: 'notification-config-contact-points',
-      text: 'Contact points',
-      url: '/alerting/notifications',
-    },
-    'notification-config-policies': {
-      id: 'notification-config-policies',
-      text: 'Notification policies',
-      url: '/alerting/routes',
-    },
-    'notification-config-templates': {
-      id: 'notification-config-templates',
-      text: 'Notification templates',
-      url: '/alerting/notifications/templates',
-    },
-    'notification-config-time-intervals': {
-      id: 'notification-config-time-intervals',
-      text: 'Time intervals',
-      url: '/alerting/time-intervals',
-    },
-  };
-
-  const defaultPreloadedState = {
-    navIndex: mockNavIndex,
-  };
-
-  it('should return navigation with pageNav', () => {
-    const store = configureStore(defaultPreloadedState);
-    const wrapper = getWrapper({
-      store,
-      renderWithRouter: true,
-      historyOptions: {
-        initialEntries: ['/alerting/notifications'],
-      },
-    });
-
-    const { result } = renderHook(() => useNotificationConfigNav(), { wrapper });
-
-    expect(result.current.navId).toBe('notification-config');
-    expect(result.current.pageNav).toBeDefined();
-    // eslint-disable-next-line testing-library/no-node-access
-    expect(result.current.pageNav?.children).toBeDefined();
-  });
-
-  it('should detect time intervals tab from path', () => {
-    const store = configureStore(defaultPreloadedState);
-    const wrapper = getWrapper({
-      store,
-      renderWithRouter: true,
-      historyOptions: {
-        initialEntries: ['/alerting/time-intervals'],
-      },
-    });
-
-    const { result } = renderHook(() => useNotificationConfigNav(), { wrapper });
-
-    // eslint-disable-next-line testing-library/no-node-access
-    const timeIntervalsTab = result.current.pageNav?.children?.find(
-      (tab) => tab.id === 'notification-config-time-intervals'
-    );
-    expect(timeIntervalsTab?.active).toBe(true);
-  });
-
-  it('should filter tabs based on permissions', () => {
-    const limitedNavIndex = {
-      'notification-config': mockNavIndex['notification-config'],
-      'notification-config-contact-points': mockNavIndex['notification-config-contact-points'],
-      // Missing other tabs - user doesn't have permission
-    };
-    const store = configureStore({
-      navIndex: limitedNavIndex,
-    });
-    const wrapper = getWrapper({
-      store,
-      renderWithRouter: true,
-      historyOptions: {
-        initialEntries: ['/alerting/notifications'],
-      },
-    });
-
-    const { result } = renderHook(() => useNotificationConfigNav(), { wrapper });
-
-    // eslint-disable-next-line testing-library/no-node-access
-    expect(result.current.pageNav?.children?.length).toBe(1);
-    // eslint-disable-next-line testing-library/no-node-access
-    expect(result.current.pageNav?.children?.[0].id).toBe('notification-config-contact-points');
-  });
-});

public/app/features/alerting/unified/navigation/useNotificationConfigNav.ts

@@ -1,86 +0,0 @@
-import { useLocation } from 'react-router-dom-v5-compat';
-
-import { NavModelItem } from '@grafana/data';
-import { t } from '@grafana/i18n';
-import { useSelector } from 'app/types/store';
-
-export function useNotificationConfigNav() {
-  const location = useLocation();
-  const navIndex = useSelector((state) => state.navIndex);
-
-  const notificationConfigNav = navIndex['notification-config'];
-  if (!notificationConfigNav) {
-    // Fallback to legacy navIds
-    if (location.pathname.includes('/alerting/notifications/templates')) {
-      return {
-        navId: 'receivers',
-        pageNav: undefined,
-      };
-    }
-    if (location.pathname === '/alerting/routes') {
-      return {
-        navId: 'am-routes',
-        pageNav: undefined,
-      };
-    }
-    return {
-      navId: 'receivers',
-      pageNav: undefined,
-    };
-  }
-
-  // Check if we're on the time intervals page
-  const isTimeIntervalsTab = location.pathname === '/alerting/time-intervals';
-
-  // All available tabs
-  const allTabs = [
-    {
-      id: 'notification-config-contact-points',
-      text: t('alerting.navigation.contact-points', 'Contact points'),
-      url: '/alerting/notifications',
-      active: location.pathname === '/alerting/notifications' && !location.pathname.includes('/templates'),
-      icon: 'comment-alt-share',
-      parentItem: notificationConfigNav,
-    },
-    {
-      id: 'notification-config-policies',
-      text: t('alerting.navigation.notification-policies', 'Notification policies'),
-      url: '/alerting/routes',
-      active: location.pathname === '/alerting/routes' && !isTimeIntervalsTab,
-      icon: 'sitemap',
-      parentItem: notificationConfigNav,
-    },
-    {
-      id: 'notification-config-templates',
-      text: t('alerting.navigation.notification-templates', 'Notification templates'),
-      url: '/alerting/notifications/templates',
-      active: location.pathname.includes('/alerting/notifications/templates'),
-      icon: 'file-alt',
-      parentItem: notificationConfigNav,
-    },
-    {
-      id: 'notification-config-time-intervals',
-      text: t('alerting.navigation.time-intervals', 'Time intervals'),
-      url: '/alerting/time-intervals',
-      active: isTimeIntervalsTab,
-      icon: 'clock-nine',
-      parentItem: notificationConfigNav,
-    },
-  ].filter((tab) => {
-    // Filter based on permissions - if nav item doesn't exist, user doesn't have permission
-    const navItem = navIndex[tab.id];
-    return navItem !== undefined;
-  });
-
-  // Create pageNav that represents the Notification configuration page with tabs as children
-  const pageNav: NavModelItem = {
-    ...notificationConfigNav,
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    children: allTabs as NavModelItem[],
-  };
-
-  return {
-    navId: 'notification-config',
-    pageNav,
-  };
-}

public/app/features/alerting/unified/rule-list/RuleList.v1.tsx

@@ -20,7 +20,6 @@ import { shouldUsePrometheusRulesPrimary } from '../featureToggles';
 import { useCombinedRuleNamespaces } from '../hooks/useCombinedRuleNamespaces';
 import { useFilteredRules, useRulesFilter } from '../hooks/useFilteredRules';
 import { useUnifiedAlertingSelector } from '../hooks/useUnifiedAlertingSelector';
-import { useAlertRulesNav } from '../navigation/useAlertRulesNav';
 import { fetchAllPromAndRulerRulesAction, fetchAllPromRulesAction, fetchRulerRulesAction } from '../state/actions';
 import { RULE_LIST_POLL_INTERVAL_MS } from '../utils/constants';
 import { GRAFANA_RULES_SOURCE_NAME, getAllRulesSourceNames } from '../utils/datasource';
@@ -116,14 +115,11 @@ const RuleListV1 = () => {
 
   const combinedNamespaces: CombinedRuleNamespace[] = useCombinedRuleNamespaces();
   const filteredNamespaces = useFilteredRules(combinedNamespaces, filterState);
-  const { navId, pageNav } = useAlertRulesNav();
-
   return (
     // We don't want to show the Loading... indicator for the whole page.
     // We show separate indicators for Grafana-managed and Cloud rules
     <AlertingPageWrapper
-      navId={navId}
-      pageNav={pageNav}
+      navId="alert-list"
       isLoading={false}
       renderTitle={(title) => <RuleListPageTitle title={title} />}
       actions={<RuleListActionButtons hasAlertRulesCreated={hasAlertRulesCreated} />}

public/app/features/alerting/unified/rule-list/RuleList.v2.tsx

@@ -13,7 +13,6 @@ import { useListViewMode } from '../components/rules/Filter/RulesViewModeSelecto
 import { AIAlertRuleButtonComponent } from '../enterprise-components/AI/AIGenAlertRuleButton/addAIAlertRuleButton';
 import { AlertingAction, useAlertingAbility } from '../hooks/useAbilities';
 import { useRulesFilter } from '../hooks/useFilteredRules';
-import { useAlertRulesNav } from '../navigation/useAlertRulesNav';
 import { getRulesDataSources } from '../utils/datasource';
 
 import { FilterView } from './FilterView';
@@ -124,12 +123,10 @@ export function RuleListActions() {
 
 export default function RuleListPage() {
   const { isApplying } = useApplyDefaultSearch();
-  const { navId, pageNav } = useAlertRulesNav();
 
   return (
     <AlertingPageWrapper
-      navId={navId}
-      pageNav={pageNav}
+      navId="alert-list"
       renderTitle={(title) => <RuleListPageTitle title={title} />}
       isLoading={isApplying}
       actions={<RuleListActions />}

public/app/features/alerting/unified/triage/Triage.tsx

@@ -1,16 +1,23 @@
+import { t } from '@grafana/i18n';
 import { UrlSyncContextProvider } from '@grafana/scenes';
 import { withErrorBoundary } from '@grafana/ui';
 
 import { AlertingPageWrapper } from '../components/AlertingPageWrapper';
-import { useAlertActivityNav } from '../navigation/useAlertActivityNav';
 
 import { TriageScene, triageScene } from './scene/TriageScene';
 
 export const TriagePage = () => {
-  const { navId, pageNav } = useAlertActivityNav();
-
   return (
-    <AlertingPageWrapper navId={navId || 'alert-alerts'} pageNav={pageNav}>
+    <AlertingPageWrapper
+      navId="alert-alerts"
+      subTitle={t(
+        'alerting.pages.triage.subtitle',
+        'See what is currently alerting and explore historical data to investigate current or past issues.'
+      )}
+      pageNav={{
+        text: t('alerting.pages.triage.title', 'Alerts'),
+      }}
+    >
       <UrlSyncContextProvider scene={triageScene} updateUrlOnInit={true} createBrowserHistorySteps={true}>
         <TriageScene key={triageScene.state.key} />
       </UrlSyncContextProvider>

public/app/features/dashboard-scene/scene/VariableControls.test.tsx

@@ -1,84 +0,0 @@
-import { render, screen } from '@testing-library/react';
-
-import { VariableHide } from '@grafana/data';
-import { SceneGridLayout, SceneVariable, SceneVariableSet, ScopesVariable, TextBoxVariable } from '@grafana/scenes';
-
-import { DashboardScene } from './DashboardScene';
-import { VariableControls } from './VariableControls';
-import { DefaultGridLayoutManager } from './layout-default/DefaultGridLayoutManager';
-
-jest.mock('@grafana/runtime', () => {
-  const runtime = jest.requireActual('@grafana/runtime');
-  return {
-    ...runtime,
-    config: {
-      ...runtime.config,
-      featureToggles: {
-        dashboardNewLayouts: true,
-      },
-    },
-  };
-});
-
-describe('VariableControls', () => {
-  it('should not render scopes variable', () => {
-    const variables = [new ScopesVariable({})];
-    const dashboard = buildScene(variables);
-    dashboard.activate();
-
-    render(<VariableControls dashboard={dashboard} />);
-
-    expect(screen.queryByText('__scopes')).not.toBeInTheDocument();
-  });
-
-  it('should not render regular hidden variables', () => {
-    const hiddenVariable = new TextBoxVariable({
-      name: 'HiddenVar',
-      hide: VariableHide.hideVariable,
-    });
-    const variables = [hiddenVariable];
-    const dashboard = buildScene(variables);
-    dashboard.activate();
-
-    render(<VariableControls dashboard={dashboard} />);
-
-    expect(screen.queryByText('HiddenVar')).not.toBeInTheDocument();
-  });
-
-  it('should render regular hidden variables in edit mode', async () => {
-    const hiddenVariable = new TextBoxVariable({
-      name: 'HiddenVar',
-      hide: VariableHide.hideVariable,
-    });
-    const variables = [hiddenVariable];
-    const dashboard = buildScene(variables);
-    dashboard.activate();
-
-    dashboard.setState({ isEditing: true });
-    render(<VariableControls dashboard={dashboard} />);
-
-    expect(await screen.findByText('HiddenVar')).toBeInTheDocument();
-  });
-
-  it('should not render variables hidden in controls menu in edit mode', async () => {
-    const dashboard = buildScene([new TextBoxVariable({ name: 'TextVarControls', hide: VariableHide.inControlsMenu })]);
-    dashboard.activate();
-
-    dashboard.setState({ isEditing: true });
-    render(<VariableControls dashboard={dashboard} />);
-
-    expect(screen.queryByText('TextVarControls')).not.toBeInTheDocument();
-  });
-});
-
-function buildScene(variables: SceneVariable[] = []) {
-  const dashboard = new DashboardScene({
-    $variables: new SceneVariableSet({ variables }),
-    body: new DefaultGridLayoutManager({
-      grid: new SceneGridLayout({
-        children: [],
-      }),
-    }),
-  });
-  return dashboard;
-}

public/app/features/dashboard-scene/scene/VariableControls.tsx

@@ -39,9 +39,8 @@ export function VariableControls({ dashboard }: { dashboard: DashboardScene }) {
     ? restVariables.filter((v) => v.state.hide !== VariableHide.inControlsMenu)
     : variables.filter(
         (v) =>
-          // used for scopes variables, should always be hidden
           // if we're editing in dynamic dashboards, still shows hidden variable but greyed out
-          (!v.UNSAFE_renderAsHidden && isEditingNewLayouts && v.state.hide === VariableHide.hideVariable) ||
+          (isEditingNewLayouts && v.state.hide === VariableHide.hideVariable) ||
           v.state.hide !== VariableHide.inControlsMenu
       );
 

public/locales/en-US/grafana.json

@@ -938,6 +938,10 @@
       "label-search-by-name-or-type": "Search by name or type",
       "placeholder-search": "Search"
     },
+    "contact-points-page-contents": {
+      "label-contact-points": "Contact Points",
+      "label-notification-templates": "Notification Templates"
+    },
     "contact-points-tab": {
       "aria-label-add-contact-point": "add contact point",
       "aria-label-export-all": "export all",
@@ -1641,9 +1645,7 @@
     "insights": {
       "monitor-status-of-system": "Monitor the status of your system",
       "monitor-status-system-tooltip": "Alerting insights provides pre-built dashboards to monitor your alerting data.",
-      "monitor-status-system-tooltip-identify": "You can identify patterns in why things go wrong and discover trends in alerting performance within your organization.",
-      "not-available": "Insights are not available. Please configure the required data sources.",
-      "subtitle": "Analytics and history for alerting"
+      "monitor-status-system-tooltip-identify": "You can identify patterns in why things go wrong and discover trends in alerting performance within your organization."
     },
     "insights-menu-button-renderer": {
       "aria-label-rate-this-panel": "Rate this panel",
@@ -1926,18 +1928,6 @@
       "select-group": "Select group",
       "select-namespace": "Select namespace"
     },
-    "navigation": {
-      "active-notifications": "Active notifications",
-      "alert-rules": "Alert rules",
-      "alert-state-history": "Alert state history",
-      "alerts": "Alerts",
-      "contact-points": "Contact points",
-      "notification-policies": "Notification policies",
-      "notification-templates": "Notification templates",
-      "recently-deleted": "Recently deleted",
-      "system-insights": "System Insights",
-      "time-intervals": "Time intervals"
-    },
     "need-help-info": {
       "need-help": "Need help?"
     },
@@ -1986,6 +1976,10 @@
       "title-error-loading-alertmanager-config": "Error loading Alertmanager config",
       "title-notification-policies-have-changed": "Notification policies have changed"
     },
+    "notification-policies-tabs": {
+      "label-notification-policies": "Notification Policies",
+      "label-time-intervals": "Time intervals"
+    },
     "notification-policy-drawer": {
       "view-notification-policy-tree": "View notification policy tree"
     },
@@ -2051,6 +2045,12 @@
       "body-selected-alertmanager-not-found": "The selected Alertmanager no longer exists or you may not have permission to access it. You can select a different Alertmanager from the dropdown.",
       "title-selected-alertmanager-not-found": "Selected Alertmanager not found."
     },
+    "pages": {
+      "triage": {
+        "subtitle": "See what is currently alerting and explore historical data to investigate current or past issues.",
+        "title": "Alerts"
+      }
+    },
     "panel-alert-tab-content": {
       "alert": {
         "title-errors-loading-rules": "Errors loading rules"