diff --git a/server/PlanShare/Program.cs b/server/PlanShare/Program.cs
index d321c6c..f04964a 100644
--- a/server/PlanShare/Program.cs
+++ b/server/PlanShare/Program.cs
@@ -1,5 +1,6 @@
 using System.Collections.Concurrent;
 using System.Security.Cryptography;
+using System.Text;
 using System.Text.Json;
 using Microsoft.Data.Sqlite;
 
@@ -30,7 +31,15 @@ CREATE TABLE IF NOT EXISTS plans (
             created_at TEXT NOT NULL,
             expires_at TEXT NOT NULL,
             delete_token TEXT NOT NULL
-        )
+        );
+        CREATE TABLE IF NOT EXISTS page_views (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            path TEXT NOT NULL,
+            referrer TEXT,
+            visitor_hash TEXT NOT NULL,
+            created_at TEXT NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS idx_pv_created ON page_views(created_at);
         """;
     cmd.ExecuteNonQuery();
 }
@@ -45,8 +54,9 @@ delete_token TEXT NOT NULL
 var app = builder.Build();
 app.UseCors();
 
-// --- Rate limiter: 10 shares per minute per IP (in-memory) ---
+// --- Rate limiters (in-memory) ---
 var rateLimiter = new RateLimiter(maxRequests: 10, windowSeconds: 60);
+var analyticsRateLimiter = new RateLimiter(maxRequests: 30, windowSeconds: 60);
 
 const int MaxTtlDays = 365;
 
@@ -124,6 +134,186 @@ delete_token TEXT NOT NULL
     return Results.Content(result, "application/json");
 });
 
+// --- Analytics: page view tracking ---
+
+app.MapPost("/api/event", async (HttpContext ctx) =>
+{
+    // Rate limit: 30 events/min per IP (generous — covers page nav + shares)
+    var ip = ctx.Connection.RemoteIpAddress?.ToString() ?? "unknown";
+    if (!analyticsRateLimiter.IsAllowed(ip))
+        return Results.StatusCode(429);
+
+    using var reader = new StreamReader(ctx.Request.Body);
+    var body = await reader.ReadToEndAsync();
+
+    string path = "/";
+    string? referrer = null;
+    try
+    {
+        using var doc = JsonDocument.Parse(body);
+        if (doc.RootElement.TryGetProperty("path", out var p))
+            path = p.GetString() ?? "/";
+        if (doc.RootElement.TryGetProperty("referrer", out var r))
+            referrer = r.GetString();
+    }
+    catch (JsonException)
+    {
+        return Results.BadRequest("Invalid JSON");
+    }
+
+    // Strip referrer to domain only (no full URLs with query params)
+    if (!string.IsNullOrEmpty(referrer) && Uri.TryCreate(referrer, UriKind.Absolute, out var refUri))
+        referrer = refUri.Host;
+
+    // Visitor hash: SHA256(IP + User-Agent + date) — unique per day, no PII stored
+    var ua = ctx.Request.Headers.UserAgent.FirstOrDefault() ?? "";
+    var day = DateTime.UtcNow.ToString("yyyy-MM-dd");
+    var visitorHash = Convert.ToHexString(
+        SHA256.HashData(Encoding.UTF8.GetBytes($"{ip}|{ua}|{day}"))).ToLower()[..16];
+
+    using var conn = new SqliteConnection(connectionString);
+    conn.Open();
+    using var cmd = conn.CreateCommand();
+    cmd.CommandText = "INSERT INTO page_views (path, referrer, visitor_hash, created_at) VALUES (@path, @referrer, @hash, @now)";
+    cmd.Parameters.AddWithValue("@path", path);
+    cmd.Parameters.AddWithValue("@referrer", (object?)referrer ?? DBNull.Value);
+    cmd.Parameters.AddWithValue("@hash", visitorHash);
+    cmd.Parameters.AddWithValue("@now", DateTime.UtcNow.ToString("o"));
+    cmd.ExecuteNonQuery();
+
+    return Results.Ok();
+});
+
+app.MapGet("/api/stats", () =>
+{
+    using var conn = new SqliteConnection(connectionString);
+    conn.Open();
+    var now = DateTime.UtcNow.ToString("o");
+    var cutoff30 = DateTime.UtcNow.AddDays(-30).ToString("o");
+    var cutoff7 = DateTime.UtcNow.AddDays(-7).ToString("o");
+    var today = DateTime.UtcNow.ToString("yyyy-MM-dd");
+
+    // --- Plan sharing stats ---
+    long totalShared;
+    using (var cmd = conn.CreateCommand())
+    {
+        cmd.CommandText = "SELECT COUNT(*) FROM plans";
+        totalShared = (long)cmd.ExecuteScalar()!;
+    }
+
+    long activePlans;
+    using (var cmd = conn.CreateCommand())
+    {
+        cmd.CommandText = "SELECT COUNT(*) FROM plans WHERE expires_at > @now";
+        cmd.Parameters.AddWithValue("@now", now);
+        activePlans = (long)cmd.ExecuteScalar()!;
+    }
+
+    var dailyShares = new List<object>();
+    using (var cmd = conn.CreateCommand())
+    {
+        cmd.CommandText = """
+            SELECT DATE(created_at) as day, COUNT(*) as count
+            FROM plans WHERE created_at > @cutoff
+            GROUP BY DATE(created_at) ORDER BY day
+            """;
+        cmd.Parameters.AddWithValue("@cutoff", cutoff30);
+        using var reader = cmd.ExecuteReader();
+        while (reader.Read())
+            dailyShares.Add(new { day = reader.GetString(0), count = reader.GetInt64(1) });
+    }
+
+    // --- Page view stats ---
+    long viewsToday;
+    using (var cmd = conn.CreateCommand())
+    {
+        cmd.CommandText = "SELECT COUNT(*) FROM page_views WHERE DATE(created_at) = @today";
+        cmd.Parameters.AddWithValue("@today", today);
+        viewsToday = (long)cmd.ExecuteScalar()!;
+    }
+
+    long visitorsToday;
+    using (var cmd = conn.CreateCommand())
+    {
+        cmd.CommandText = "SELECT COUNT(DISTINCT visitor_hash) FROM page_views WHERE DATE(created_at) = @today";
+        cmd.Parameters.AddWithValue("@today", today);
+        visitorsToday = (long)cmd.ExecuteScalar()!;
+    }
+
+    long views7d;
+    using (var cmd = conn.CreateCommand())
+    {
+        cmd.CommandText = "SELECT COUNT(*) FROM page_views WHERE created_at > @cutoff";
+        cmd.Parameters.AddWithValue("@cutoff", cutoff7);
+        views7d = (long)cmd.ExecuteScalar()!;
+    }
+
+    long visitors7d;
+    using (var cmd = conn.CreateCommand())
+    {
+        cmd.CommandText = "SELECT COUNT(DISTINCT visitor_hash) FROM page_views WHERE created_at > @cutoff";
+        cmd.Parameters.AddWithValue("@cutoff", cutoff7);
+        visitors7d = (long)cmd.ExecuteScalar()!;
+    }
+
+    long views30d;
+    using (var cmd = conn.CreateCommand())
+    {
+        cmd.CommandText = "SELECT COUNT(*) FROM page_views WHERE created_at > @cutoff";
+        cmd.Parameters.AddWithValue("@cutoff", cutoff30);
+        views30d = (long)cmd.ExecuteScalar()!;
+    }
+
+    long visitors30d;
+    using (var cmd = conn.CreateCommand())
+    {
+        cmd.CommandText = "SELECT COUNT(DISTINCT visitor_hash) FROM page_views WHERE created_at > @cutoff";
+        cmd.Parameters.AddWithValue("@cutoff", cutoff30);
+        visitors30d = (long)cmd.ExecuteScalar()!;
+    }
+
+    var dailyViews = new List<object>();
+    using (var cmd = conn.CreateCommand())
+    {
+        cmd.CommandText = """
+            SELECT DATE(created_at) as day, COUNT(*) as views, COUNT(DISTINCT visitor_hash) as visitors
+            FROM page_views WHERE created_at > @cutoff
+            GROUP BY DATE(created_at) ORDER BY day
+            """;
+        cmd.Parameters.AddWithValue("@cutoff", cutoff30);
+        using var reader = cmd.ExecuteReader();
+        while (reader.Read())
+            dailyViews.Add(new { day = reader.GetString(0), views = reader.GetInt64(1), visitors = reader.GetInt64(2) });
+    }
+
+    var topReferrers = new List<object>();
+    using (var cmd = conn.CreateCommand())
+    {
+        cmd.CommandText = """
+            SELECT referrer, COUNT(*) as count
+            FROM page_views WHERE created_at > @cutoff AND referrer IS NOT NULL AND referrer != ''
+            GROUP BY referrer ORDER BY count DESC LIMIT 10
+            """;
+        cmd.Parameters.AddWithValue("@cutoff", cutoff30);
+        using var reader = cmd.ExecuteReader();
+        while (reader.Read())
+            topReferrers.Add(new { referrer = reader.GetString(0), count = reader.GetInt64(1) });
+    }
+
+    return Results.Json(new
+    {
+        sharing = new { total_shared = totalShared, active_plans = activePlans, daily = dailyShares },
+        traffic = new
+        {
+            today = new { views = viewsToday, visitors = visitorsToday },
+            last_7d = new { views = views7d, visitors = visitors7d },
+            last_30d = new { views = views30d, visitors = visitors30d },
+            daily = dailyViews,
+            top_referrers = topReferrers
+        }
+    });
+});
+
 app.MapDelete("/api/plans/{id}", (string id, HttpContext ctx) =>
 {
     var token = ctx.Request.Query["token"].FirstOrDefault();
@@ -188,21 +378,33 @@ private void Cleanup()
     {
         try
         {
-            var now = DateTime.UtcNow.ToString("o");
             using var conn = new SqliteConnection(_config.ConnectionString);
             conn.Open();
-            using var cmd = conn.CreateCommand();
-            cmd.CommandText = "DELETE FROM plans WHERE expires_at < @now";
-            cmd.Parameters.AddWithValue("@now", now);
-            var deleted = cmd.ExecuteNonQuery();
-            if (deleted > 0)
+
+            // Delete expired plans
+            var now = DateTime.UtcNow.ToString("o");
+            using (var cmd = conn.CreateCommand())
+            {
+                cmd.CommandText = "DELETE FROM plans WHERE expires_at < @now";
+                cmd.Parameters.AddWithValue("@now", now);
+                var deleted = cmd.ExecuteNonQuery();
+                if (deleted > 0)
+                    _logger.LogInformation("Cleaned up {Count} expired plans", deleted);
+            }
+
+            // Delete page views older than 90 days
+            using (var cmd = conn.CreateCommand())
             {
-                _logger.LogInformation("Cleaned up {Count} expired plans", deleted);
+                cmd.CommandText = "DELETE FROM page_views WHERE created_at < @cutoff";
+                cmd.Parameters.AddWithValue("@cutoff", DateTime.UtcNow.AddDays(-90).ToString("o"));
+                var deleted = cmd.ExecuteNonQuery();
+                if (deleted > 0)
+                    _logger.LogInformation("Cleaned up {Count} old page views", deleted);
             }
         }
         catch (Exception ex)
         {
-            _logger.LogError(ex, "Error during plan cleanup");
+            _logger.LogError(ex, "Error during cleanup");
         }
     }
 }
diff --git a/server/PlanShare/dashboard.html b/server/PlanShare/dashboard.html
new file mode 100644
index 0000000..b444890
--- /dev/null
+++ b/server/PlanShare/dashboard.html
@@ -0,0 +1,345 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Darling Data - GitHub Stats</title>
+    <script src="https://cdn.jsdelivr.net/npm/chart.js@4"></script>
+    <script src="https://cdn.jsdelivr.net/npm/chartjs-adapter-date-fns@3"></script>
+    <link rel="preconnect" href="https://fonts.googleapis.com" />
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+    <link href="https://fonts.googleapis.com/css2?family=Montserrat:wght@400;500;600;700&display=swap" rel="stylesheet" />
+    <link rel="icon" type="image/png" href="favicon.png" />
+    <style>
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+            background: #0d1117; color: #e6edf3;
+        }
+        .site-header {
+            padding: 0.6rem 2rem;
+            background: #161b22;
+            border-bottom: 3px solid #58a6ff;
+        }
+        .header-content {
+            display: flex; align-items: center; gap: 1rem;
+            max-width: 1400px; margin: 0 auto;
+        }
+        .header-logo { height: 40px; width: auto; }
+        .header-divider { width: 1px; height: 20px; background: #555; }
+        .header-title {
+            font-family: 'Montserrat', sans-serif; font-size: 1rem;
+            font-weight: 600; color: #ffffff; letter-spacing: 0.3px;
+        }
+        .header-nav { display: flex; gap: 1.5rem; margin-left: auto; }
+        .header-nav a {
+            color: #e0e0e0; text-decoration: none; font-size: 1rem;
+            font-weight: 500; padding: 0.3rem 0.6rem; border-radius: 4px; transition: all 0.15s;
+        }
+        .header-nav a:hover { color: #ffffff; background: rgba(255, 255, 255, 0.1); }
+        .main-content { padding: 20px; max-width: 1400px; margin: 0 auto; }
+        h1 { font-size: 1.8em; margin-bottom: 4px; }
+        .subtitle { color: #8b949e; margin-bottom: 24px; }
+        .repo-tabs { display: flex; gap: 8px; margin-bottom: 24px; flex-wrap: wrap; }
+        .repo-tab {
+            padding: 8px 16px; border: 1px solid #30363d; border-radius: 6px;
+            background: #161b22; color: #8b949e; cursor: pointer; font-size: 0.9em; transition: all 0.15s;
+        }
+        .repo-tab:hover { border-color: #58a6ff; color: #e6edf3; }
+        .repo-tab.active { background: #1f6feb; border-color: #1f6feb; color: #fff; }
+        .stats-row { display: grid; grid-template-columns: repeat(auto-fit, minmax(160px, 1fr)); gap: 12px; margin-bottom: 24px; }
+        .stat-card { background: #161b22; border: 1px solid #30363d; border-radius: 8px; padding: 16px; text-align: center; }
+        .stat-value { font-size: 1.8em; font-weight: 700; color: #58a6ff; }
+        .stat-label { font-size: 0.8em; color: #8b949e; margin-top: 4px; }
+        .stat-delta { font-size: 0.75em; margin-top: 2px; }
+        .delta-up { color: #3fb950; }
+        .delta-down { color: #f85149; }
+        .delta-flat { color: #8b949e; }
+        .charts-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(500px, 1fr)); gap: 16px; margin-bottom: 24px; }
+        .chart-card { background: #161b22; border: 1px solid #30363d; border-radius: 8px; padding: 16px; }
+        .chart-card h3 { font-size: 0.95em; color: #8b949e; margin-bottom: 12px; }
+        .chart-container { position: relative; height: 280px; }
+        .releases-table { width: 100%; border-collapse: collapse; font-size: 0.9em; }
+        .releases-table th, .releases-table td { padding: 8px 12px; text-align: left; border-bottom: 1px solid #21262d; }
+        .releases-table th { color: #8b949e; font-weight: 600; font-size: 0.85em; text-transform: uppercase; }
+        .releases-table tr:hover { background: #1c2028; }
+        .releases-table td.num { text-align: right; font-variant-numeric: tabular-nums; }
+        .tag { color: #58a6ff; }
+        .prerelease { font-size: 0.7em; background: #341a00; color: #d29922; padding: 2px 6px; border-radius: 10px; margin-left: 6px; }
+        footer { margin-top: 32px; padding-top: 16px; border-top: 1px solid #21262d; color: #484f58; font-size: 0.8em; text-align: center; padding-bottom: 20px; }
+        footer a { color: #58a6ff; text-decoration: none; }
+        @media (max-width: 768px) {
+            .site-header { padding: 0.6rem 1rem; }
+            .header-title { display: none; }
+            .header-divider { display: none; }
+            .header-nav { gap: 0.5rem; }
+            .header-nav a { font-size: 0.85rem; padding: 0.2rem 0.4rem; }
+            .charts-grid { grid-template-columns: 1fr; }
+            .stats-row { grid-template-columns: repeat(2, 1fr); }
+        }
+    </style>
+</head>
+<body>
+    <header class="site-header">
+        <div class="header-content">
+            <a href="https://www.erikdarling.com" target="_blank" rel="noopener"><img src="darling-data-logo.jpg" alt="Darling Data" class="header-logo" /></a>
+            <span class="header-divider"></span>
+            <span class="header-title">GitHub Stats</span>
+            <nav class="header-nav">
+                <a href="https://erikdarling.com/blog/" target="_blank" rel="noopener">Blog</a>
+                <a href="https://training.erikdarling.com/sqlconsulting" target="_blank" rel="noopener">Consulting</a>
+                <a href="https://training.erikdarling.com/catalog" target="_blank" rel="noopener">Training</a>
+                <a href="https://training.erikdarling.com/sql-monitoring" target="_blank" rel="noopener">Monitoring</a>
+                <a href="https://erikdarling.com/request-a-call/" target="_blank" rel="noopener">Request a Call</a>
+            </nav>
+        </div>
+    </header>
+    <div class="main-content">
+        <h1>Darling Data</h1>
+        <p class="subtitle">GitHub repository statistics</p>
+        <div class="repo-tabs" id="repoTabs"></div>
+        <div class="stats-row" id="statsRow"></div>
+        <div id="githubSection">
+            <div class="charts-grid" id="chartsGrid">
+                <div class="chart-card"><h3>Stars Over Time</h3><div class="chart-container"><canvas id="starsChart"></canvas></div></div>
+                <div class="chart-card"><h3>Daily Traffic (14-day window)</h3><div class="chart-container"><canvas id="trafficChart"></canvas></div></div>
+                <div class="chart-card"><h3>Cumulative Downloads</h3><div class="chart-container"><canvas id="downloadsChart"></canvas></div></div>
+                <div class="chart-card"><h3>Daily Clones (14-day window)</h3><div class="chart-container"><canvas id="clonesChart"></canvas></div></div>
+            </div>
+            <div class="chart-card" id="releasesCard" style="margin-bottom: 24px;">
+                <h3>Downloads by Release</h3>
+                <div style="overflow-x: auto;">
+                    <table class="releases-table" id="releasesTable">
+                        <thead><tr><th>Release</th><th>Date</th><th class="num">Downloads</th></tr></thead>
+                        <tbody></tbody>
+                    </table>
+                </div>
+            </div>
+        </div>
+        <div id="planSection" style="display: none;">
+            <div class="charts-grid">
+                <div class="chart-card"><h3>Daily Page Views &amp; Unique Visitors (30 days)</h3><div class="chart-container"><canvas id="pvChart"></canvas></div></div>
+                <div class="chart-card"><h3>Daily Plan Shares (30 days)</h3><div class="chart-container"><canvas id="sharesChart"></canvas></div></div>
+            </div>
+            <div class="chart-card" id="referrersCard" style="margin-bottom: 24px;">
+                <h3>Top Referrers (30 days)</h3>
+                <div style="overflow-x: auto;">
+                    <table class="releases-table" id="referrersTable">
+                        <thead><tr><th>Referrer</th><th class="num">Visits</th></tr></thead>
+                        <tbody></tbody>
+                    </table>
+                </div>
+            </div>
+        </div>
+        <footer>
+            Updated daily. Traffic data limited to 14 days by GitHub.
+            <br>Repos: <a href="https://github.com/erikdarlingdata/PerformanceMonitor">PerformanceMonitor</a>
+            &middot; <a href="https://github.com/erikdarlingdata/PerformanceStudio">PerformanceStudio</a>
+            &middot; <a href="https://github.com/erikdarlingdata/DarlingData">DarlingData</a>
+            &middot; <a href="https://plans.erikdarling.com">Plan Analyzer</a>
+        </footer>
+    </div>
+    <script>
+    const REPO_DISPLAY = {
+        PerformanceMonitor: { short: "PM", color: "#58a6ff" },
+        PerformanceStudio: { short: "PS", color: "#3fb950" },
+        DarlingData: { short: "DD", color: "#d2a8ff" },
+    };
+    const PLAN_TAB = { short: "PA", color: "#f0883e" };
+    const chartDefaults = {
+        responsive: true, maintainAspectRatio: false,
+        plugins: { legend: { labels: { color: "#8b949e", boxWidth: 12 } } },
+        scales: {
+            x: { ticks: { color: "#484f58" }, grid: { color: "#21262d" } },
+            y: { ticks: { color: "#484f58" }, grid: { color: "#21262d" }, beginAtZero: true },
+        },
+    };
+    let current = null, history = [], activeRepo = "PerformanceMonitor", charts = {};
+    let planStats = null;
+
+    async function load() {
+        const [cResp, hResp] = await Promise.all([fetch("data/current.json"), fetch("data/history.json")]);
+        current = await cResp.json();
+        history = await hResp.json();
+        buildTabs(); update();
+    }
+    function buildTabs() {
+        const c = document.getElementById("repoTabs"); c.innerHTML = "";
+        for (const [repo, meta] of Object.entries(REPO_DISPLAY)) {
+            const t = document.createElement("div");
+            t.className = "repo-tab" + (repo === activeRepo ? " active" : "");
+            t.textContent = meta.short + " - " + repo;
+            t.onclick = () => { activeRepo = repo; buildTabs(); update(); };
+            c.appendChild(t);
+        }
+        // Plan Analyzer tab
+        const pt = document.createElement("div");
+        pt.className = "repo-tab" + (activeRepo === "_plans" ? " active" : "");
+        pt.textContent = "PA - Plan Analyzer";
+        pt.onclick = () => { activeRepo = "_plans"; buildTabs(); update(); };
+        c.appendChild(pt);
+    }
+    function fmt(n) { return n == null ? "-" : n.toLocaleString(); }
+    function update() {
+        if (activeRepo === "_plans") {
+            document.getElementById("githubSection").style.display = "none";
+            document.getElementById("planSection").style.display = "";
+            loadPlanStats();
+        } else {
+            document.getElementById("githubSection").style.display = "";
+            document.getElementById("planSection").style.display = "none";
+            updateGitHub();
+        }
+    }
+    function updateGitHub() {
+        const repo = current.repos[activeRepo] || {};
+        const prev = history.length >= 2 ? (history[history.length - 2][activeRepo] || {}) : {};
+        function delta(cur, old) {
+            if (cur == null || old == null) return "";
+            const d = cur - old;
+            if (d > 0) return "<span class='delta-up'>+" + fmt(d) + "</span>";
+            if (d < 0) return "<span class='delta-down'>" + fmt(d) + "</span>";
+            return "<span class='delta-flat'>-</span>";
+        }
+        const cards = [
+            { label: "Stars", value: repo.stars, prev: prev.stars },
+            { label: "Forks", value: repo.forks, prev: prev.forks },
+            { label: "Visitors (14d)", value: repo.visitors_14d, prev: prev.visitors },
+            { label: "Views (14d)", value: repo.views_14d, prev: prev.views },
+            { label: "Cloners (14d)", value: repo.cloners_14d, prev: prev.cloners },
+            { label: "Clones (14d)", value: repo.clones_14d, prev: prev.clones },
+            { label: "Total Downloads", value: repo.total_downloads, prev: prev.downloads },
+            { label: "Open Issues", value: repo.open_issues, prev: prev.open_issues },
+        ];
+        const row = document.getElementById("statsRow");
+        row.innerHTML = cards.map(function(c) {
+            return "<div class='stat-card'><div class='stat-value'>" + fmt(c.value) +
+                "</div><div class='stat-label'>" + c.label +
+                "</div><div class='stat-delta'>" + delta(c.value, c.prev) + "</div></div>";
+        }).join("");
+        updateCharts(); updateReleases(repo);
+    }
+    async function loadPlanStats() {
+        try {
+            const resp = await fetch("/api/stats");
+            planStats = await resp.json();
+        } catch (e) {
+            planStats = null;
+        }
+        updatePlanView();
+    }
+    function updatePlanView() {
+        var row = document.getElementById("statsRow");
+        if (!planStats) {
+            row.innerHTML = "<div class='stat-card'><div class='stat-value'>-</div><div class='stat-label'>No data yet</div></div>";
+            return;
+        }
+        var t = planStats.traffic;
+        var s = planStats.sharing;
+        var cards = [
+            { label: "Views Today", value: t.today.views },
+            { label: "Visitors Today", value: t.today.visitors },
+            { label: "Views (7d)", value: t.last_7d.views },
+            { label: "Visitors (7d)", value: t.last_7d.visitors },
+            { label: "Views (30d)", value: t.last_30d.views },
+            { label: "Visitors (30d)", value: t.last_30d.visitors },
+            { label: "Plans Shared", value: s.total_shared },
+            { label: "Active Plans", value: s.active_plans },
+        ];
+        row.innerHTML = cards.map(function(c) {
+            return "<div class='stat-card'><div class='stat-value' style='color:" + PLAN_TAB.color + "'>" + fmt(c.value) +
+                "</div><div class='stat-label'>" + c.label + "</div></div>";
+        }).join("");
+        updatePlanCharts();
+        updateReferrers();
+    }
+    function updatePlanCharts() {
+        if (!planStats) return;
+        var daily = planStats.traffic.daily;
+        var days = daily.map(function(d) { return d.day; });
+        var views = daily.map(function(d) { return d.views; });
+        var visitors = daily.map(function(d) { return d.visitors; });
+        updateChart("pvChart", "bar", {
+            labels: days,
+            datasets: [
+                { label: "Page Views", data: views, backgroundColor: PLAN_TAB.color + "80", borderColor: PLAN_TAB.color, borderWidth: 1 },
+                { label: "Unique Visitors", data: visitors, backgroundColor: "#58a6ff80", borderColor: "#58a6ff", borderWidth: 1 },
+            ],
+        });
+        var sharesDaily = planStats.sharing.daily;
+        updateChart("sharesChart", "bar", {
+            labels: sharesDaily.map(function(d) { return d.day; }),
+            datasets: [{ label: "Plans Shared", data: sharesDaily.map(function(d) { return d.count; }),
+                backgroundColor: "#3fb95080", borderColor: "#3fb950", borderWidth: 1 }],
+        });
+    }
+    function updateReferrers() {
+        var tbody = document.querySelector("#referrersTable tbody");
+        if (!planStats || !planStats.traffic.top_referrers.length) {
+            tbody.innerHTML = "<tr><td colspan='2' style='color:#484f58'>No referrer data yet</td></tr>";
+            return;
+        }
+        tbody.innerHTML = planStats.traffic.top_referrers.map(function(r) {
+            return "<tr><td>" + r.referrer + "</td><td class='num'>" + fmt(r.count) + "</td></tr>";
+        }).join("");
+    }
+    function updateCharts() {
+        updateChart("starsChart", "line", {
+            datasets: Object.entries(REPO_DISPLAY).map(function([repo, meta]) {
+                return {
+                    label: meta.short,
+                    data: history.filter(function(h) { return h[repo]; }).map(function(h) { return { x: h.date, y: h[repo].stars }; }),
+                    borderColor: meta.color, backgroundColor: meta.color + "20", tension: 0.3, pointRadius: 2,
+                };
+            }),
+        });
+        var repo = current.repos[activeRepo] || {};
+        var views = (repo.daily_views || []).map(function(v) { return { x: v.timestamp.split("T")[0], y: v.uniques }; });
+        updateChart("trafficChart", "bar", {
+            datasets: [{ label: "Unique Visitors", data: views,
+                backgroundColor: REPO_DISPLAY[activeRepo].color + "80",
+                borderColor: REPO_DISPLAY[activeRepo].color, borderWidth: 1 }],
+        });
+        updateChart("downloadsChart", "line", {
+            datasets: Object.entries(REPO_DISPLAY).map(function([repo, meta]) {
+                return {
+                    label: meta.short,
+                    data: history.filter(function(h) { return h[repo]; }).map(function(h) { return { x: h.date, y: h[repo].downloads }; }),
+                    borderColor: meta.color, backgroundColor: meta.color + "20", tension: 0.3, pointRadius: 2,
+                };
+            }),
+        });
+        var clones = (repo.daily_clones || []).map(function(c) { return { x: c.timestamp.split("T")[0], y: c.uniques }; });
+        updateChart("clonesChart", "bar", {
+            datasets: [{ label: "Unique Cloners", data: clones,
+                backgroundColor: REPO_DISPLAY[activeRepo].color + "80",
+                borderColor: REPO_DISPLAY[activeRepo].color, borderWidth: 1 }],
+        });
+    }
+    function updateChart(id, type, data) {
+        if (charts[id]) charts[id].destroy();
+        charts[id] = new Chart(document.getElementById(id).getContext("2d"), {
+            type: type, data: data,
+            options: Object.assign({}, chartDefaults, {
+                scales: Object.assign({}, chartDefaults.scales, {
+                    x: Object.assign({}, chartDefaults.scales.x, { type: "category" })
+                })
+            }),
+        });
+    }
+    function updateReleases(repo) {
+        var tbody = document.querySelector("#releasesTable tbody");
+        var releases = repo.releases || [];
+        if (!releases.length) { tbody.innerHTML = "<tr><td colspan='3' style='color:#484f58'>No releases</td></tr>"; return; }
+        tbody.innerHTML = releases.map(function(r) {
+            return "<tr><td><span class='tag'>" + r.tag + "</span>" +
+                (r.prerelease ? "<span class='prerelease'>pre</span>" : "") +
+                (r.name && r.name !== r.tag ? "<br><small style='color:#8b949e'>" + r.name + "</small>" : "") +
+                "</td><td>" + (r.published ? r.published.split("T")[0] : "-") +
+                "</td><td class='num'>" + fmt(r.downloads) + "</td></tr>";
+        }).join("");
+    }
+    load();
+    </script>
+</body>
+</html>
diff --git a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml
index 758b21f..20c2f54 100644
--- a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml
+++ b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml
@@ -67,6 +67,15 @@
                         <ComboBoxItem Content="Executions" Tag="executions"/>
                     </ComboBox>
                 </StackPanel>
+                <StackPanel Spacing="4">
+                    <TextBlock Text="Group by" Foreground="{DynamicResource ForegroundBrush}" FontSize="11"/>
+                    <ComboBox x:Name="GroupByBox" Width="130" Height="36" FontSize="13"
+                              SelectedIndex="0" SelectionChanged="GroupBy_SelectionChanged">
+                        <ComboBoxItem Content="None" Tag="none"/>
+                        <ComboBoxItem Content="Query Hash" Tag="query-hash"/>
+                        <ComboBoxItem Content="Module" Tag="module"/>
+                    </ComboBox>
+                </StackPanel>
                 <StackPanel Spacing="4">
                     <TextBlock Text="Search by" Foreground="{DynamicResource ForegroundBrush}" FontSize="11"/>
                     <ComboBox x:Name="SearchTypeBox" Width="120" Height="36" FontSize="13"
@@ -141,6 +150,30 @@
                 </ContextMenu>
             </DataGrid.ContextMenu>
             <DataGrid.Columns>
+                <DataGridTemplateColumn Header="" Width="220" IsVisible="False">
+                    <DataGridTemplateColumn.CellTemplate>
+                        <DataTemplate x:DataType="local:QueryStoreRow">
+                            <StackPanel Orientation="Horizontal" Margin="{Binding IndentMargin}"
+                                        VerticalAlignment="Stretch">
+                                <Button Content="{Binding ExpandChevron}"
+                                        IsVisible="{Binding HasChildren}"
+                                        MinWidth="20" Padding="2,0"
+                                        FontSize="18" FontWeight="Bold"
+                                        Background="Transparent" BorderThickness="0"
+                                        Foreground="{DynamicResource ForegroundBrush}"
+                                        VerticalAlignment="Stretch"
+                                        VerticalContentAlignment="Center"
+                                        Click="ExpandRow_Click"/>
+                                <TextBlock Text="{Binding GroupDisplayText}"
+                                           VerticalAlignment="Center"
+                                           Margin="4,0,0,0"
+                                           FontWeight="{Binding GroupFontWeight}"
+                                           Foreground="{DynamicResource ForegroundBrush}"
+                                           TextTrimming="CharacterEllipsis"/>
+                            </StackPanel>
+                        </DataTemplate>
+                    </DataGridTemplateColumn.CellTemplate>
+                </DataGridTemplateColumn>
                 <DataGridTemplateColumn Header="" Width="40">
                     <DataGridTemplateColumn.CellTemplate>
                         <DataTemplate x:DataType="local:QueryStoreRow">
@@ -330,6 +363,16 @@
                            Foreground="{DynamicResource ForegroundBrush}"/>
             </StackPanel>
         </Border>
+        <!-- Empty-state overlay (Module groupby with no module data) -->
+        <Border x:Name="GridEmptyMessage" IsVisible="False"
+                HorizontalAlignment="Stretch" VerticalAlignment="Stretch"
+                IsHitTestVisible="False">
+            <TextBlock x:Name="GridEmptyMessageText"
+                       HorizontalAlignment="Center" VerticalAlignment="Center"
+                       FontSize="20" FontWeight="SemiBold"
+                       Foreground="{DynamicResource ForegroundMutedBrush}"
+                       TextAlignment="Center"/>
+        </Border>
         </Grid>
     </Grid>
 </UserControl>
diff --git a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
index 08f3ee1..71c779a 100644
--- a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
@@ -44,6 +44,8 @@ public partial class QueryStoreGridControl : UserControl
     private bool _waitStatsSupported;  // false until version + capture mode confirmed
     private bool _waitStatsEnabled = true;
     private bool _waitPercentMode;
+    private QueryStoreGroupBy _groupByMode = QueryStoreGroupBy.None;
+    private List<QueryStoreRow> _groupedRootRows = new(); // top-level rows for grouped mode
 
     public event EventHandler<List<QueryStorePlan>>? PlansSelected;
     public event EventHandler<string>? DatabaseChanged;
@@ -185,8 +187,10 @@ private async System.Threading.Tasks.Task FetchPlansForRangeAsync()
         StatusText.Text = "Fetching plans...";
         GridLoadingOverlay.IsVisible = true;
         GridLoadingText.Text = "Fetching plans...";
+        GridEmptyMessage.IsVisible = false;
         _rows.Clear();
         _filteredRows.Clear();
+        _groupedRootRows.Clear();
 
         // Start global + ribbon wait stats early (they don't depend on plan results)
         if (_waitStatsSupported && _waitStatsEnabled && _slicerStartUtc.HasValue && _slicerEndUtc.HasValue)
@@ -194,28 +198,14 @@ private async System.Threading.Tasks.Task FetchPlansForRangeAsync()
 
         try
         {
-            var plans = await QueryStoreService.FetchTopPlansAsync(
-                _connectionString, topN, orderBy, filter: filter, ct: ct,
-                startUtc: _slicerStartUtc, endUtc: _slicerEndUtc);
-
-            GridLoadingOverlay.IsVisible = false;
-
-            if (plans.Count == 0)
+            if (_groupByMode == QueryStoreGroupBy.None)
             {
-                StatusText.Text = "No Query Store data found for the selected range.";
-                return;
+                await FetchFlatPlansAsync(topN, orderBy, filter, ct);
+            }
+            else
+            {
+                await FetchGroupedPlansAsync(topN, orderBy, filter, ct);
             }
-
-            foreach (var plan in plans)
-                _rows.Add(new QueryStoreRow(plan));
-
-            ApplyFilters();
-            LoadButton.IsEnabled = true;
-            SelectToggleButton.Content = "Select All";
-
-            // Fetch per-plan wait stats after grid is populated (needs plan IDs)
-            if (_waitStatsSupported && _waitStatsEnabled && _slicerStartUtc.HasValue && _slicerEndUtc.HasValue)
-                _ = FetchPerPlanWaitStatsAsync(_slicerStartUtc.Value, _slicerEndUtc.Value, ct);
         }
         catch (OperationCanceledException)
         {
@@ -232,6 +222,409 @@ private async System.Threading.Tasks.Task FetchPlansForRangeAsync()
         }
     }
 
+    private async System.Threading.Tasks.Task FetchFlatPlansAsync(
+        int topN, string orderBy, QueryStoreFilter? filter, CancellationToken ct)
+    {
+        var plans = await QueryStoreService.FetchTopPlansAsync(
+            _connectionString, topN, orderBy, filter: filter, ct: ct,
+            startUtc: _slicerStartUtc, endUtc: _slicerEndUtc);
+
+        GridLoadingOverlay.IsVisible = false;
+
+        if (plans.Count == 0)
+        {
+            StatusText.Text = "No Query Store data found for the selected range.";
+            return;
+        }
+
+        foreach (var plan in plans)
+            _rows.Add(new QueryStoreRow(plan));
+
+        ApplyFilters();
+        LoadButton.IsEnabled = true;
+        SelectToggleButton.Content = "Select All";
+
+        // Fetch per-plan wait stats after grid is populated (needs plan IDs)
+        if (_waitStatsSupported && _waitStatsEnabled && _slicerStartUtc.HasValue && _slicerEndUtc.HasValue)
+            _ = FetchPerPlanWaitStatsAsync(_slicerStartUtc.Value, _slicerEndUtc.Value, ct);
+    }
+
+    private async System.Threading.Tasks.Task FetchGroupedPlansAsync(
+        int topN, string orderBy, QueryStoreFilter? filter, CancellationToken ct)
+    {
+        QueryStoreGroupedResult grouped;
+        if (_groupByMode == QueryStoreGroupBy.QueryHash)
+        {
+            grouped = await QueryStoreService.FetchGroupedByQueryHashAsync(
+                _connectionString, topN, orderBy, filter, ct,
+                _slicerStartUtc, _slicerEndUtc);
+        }
+        else // Module
+        {
+            grouped = await QueryStoreService.FetchGroupedByModuleAsync(
+                _connectionString, topN, orderBy, filter, ct,
+                _slicerStartUtc, _slicerEndUtc);
+        }
+
+        GridLoadingOverlay.IsVisible = false;
+        GridEmptyMessage.IsVisible = false;
+
+        if (grouped.IntermediateRows.Count == 0)
+        {
+            if (_groupByMode == QueryStoreGroupBy.Module)
+            {
+                GridEmptyMessageText.Text = "No module found in the selected period";
+                GridEmptyMessage.IsVisible = true;
+            }
+            else
+            {
+                StatusText.Text = "No Query Store data found for the selected range.";
+            }
+            return;
+        }
+
+        var rootRows = BuildGroupedRows(grouped);
+
+        // Sort root rows by consolidated metric descending
+        var metricAccessor = GetMetricAccessor(orderBy);
+        rootRows = rootRows.OrderByDescending(r => metricAccessor(r)).ToList();
+        _groupedRootRows = rootRows;
+
+        // Flatten to _rows (all levels) and show only top-level in _filteredRows
+        foreach (var root in rootRows)
+        {
+            _rows.Add(root);
+            foreach (var mid in root.Children)
+            {
+                _rows.Add(mid);
+                foreach (var leaf in mid.Children)
+                    _rows.Add(leaf);
+            }
+        }
+
+        // Show only root-level rows initially (collapsed)
+        _filteredRows.Clear();
+        foreach (var root in rootRows)
+            _filteredRows.Add(root);
+
+        LoadButton.IsEnabled = true;
+        SelectToggleButton.Content = "Select All";
+
+        // Auto-expand the first root row to the deepest level
+        if (rootRows.Count > 0)
+        {
+            var first = rootRows[0];
+            ExpandRowRecursive(first);
+        }
+
+        UpdateStatusText();
+        UpdateBarRatios();
+
+        // Fetch per-plan wait stats for leaf rows, then consolidate upward
+        if (_waitStatsSupported && _waitStatsEnabled && _slicerStartUtc.HasValue && _slicerEndUtc.HasValue)
+            _ = FetchGroupedWaitStatsAsync(_slicerStartUtc.Value, _slicerEndUtc.Value, ct);
+    }
+
+    /// <summary>
+    /// Recursively expands a row and all its children, inserting them into _filteredRows.
+    /// </summary>
+    private void ExpandRowRecursive(QueryStoreRow row)
+    {
+        if (!row.HasChildren) return;
+        row.IsExpanded = true;
+
+        var idx = _filteredRows.IndexOf(row);
+        if (idx < 0) return;
+
+        var insertAt = idx + 1;
+        foreach (var child in row.Children)
+        {
+            _filteredRows.Insert(insertAt, child);
+            insertAt++;
+        }
+
+        // Recurse into each child that has children
+        foreach (var child in row.Children)
+            ExpandRowRecursive(child);
+    }
+
+    /// <summary>
+    /// Fetches per-plan wait stats for all real plan IDs found in the grouped hierarchy,
+    /// assigns them to leaf rows, then consolidates upward to intermediate and root rows.
+    /// </summary>
+    private async System.Threading.Tasks.Task FetchGroupedWaitStatsAsync(
+        DateTime startUtc, DateTime endUtc, CancellationToken ct)
+    {
+        try
+        {
+            // Collect all real plan IDs from rows that have a real PlanId
+            var allPlanIds = _rows
+                .Where(r => r.PlanId > 0)
+                .Select(r => r.PlanId)
+                .Distinct()
+                .ToList();
+
+            if (allPlanIds.Count == 0) return;
+
+            var planWaits = await QueryStoreService.FetchPlanWaitStatsAsync(
+                _connectionString, startUtc, endUtc, allPlanIds, ct);
+            if (ct.IsCancellationRequested) return;
+
+            // Build lookup: plan_id → list of WaitCategoryTotal
+            var byPlan = planWaits
+                .GroupBy(x => x.PlanId)
+                .ToDictionary(g => g.Key, g => g.Select(x => x.Wait).ToList());
+
+            // 1. Assign raw waits + profiles to rows with a real PlanId
+            foreach (var row in _rows)
+            {
+                if (row.PlanId > 0 && byPlan.TryGetValue(row.PlanId, out var waits))
+                {
+                    row.RawWaitCategories = waits;
+                    row.WaitProfile = QueryStoreService.BuildWaitProfile(waits);
+                }
+            }
+
+            // 2. Consolidate upward through the hierarchy
+            foreach (var root in _groupedRootRows)
+                ConsolidateWaitProfileUpward(root);
+
+            UpdateWaitBarMode();
+        }
+        catch (OperationCanceledException) { }
+        catch (Exception) { }
+    }
+
+    /// <summary>
+    /// Recursively consolidates wait profiles from children into their parent.
+    /// For each parent: merges all children's RawWaitCategories by summing WaitRatio
+    /// per category, then builds a new WaitProfile from the merged totals.
+    /// </summary>
+    private static void ConsolidateWaitProfileUpward(QueryStoreRow parent)
+    {
+        if (parent.Children.Count == 0) return;
+
+        // Recurse first so children are consolidated before we merge them
+        foreach (var child in parent.Children)
+            ConsolidateWaitProfileUpward(child);
+
+        // Merge all children's raw wait categories by summing WaitRatio per category
+        var merged = parent.Children
+            .SelectMany(c => c.RawWaitCategories)
+            .GroupBy(w => new { w.WaitCategory, w.WaitCategoryDesc })
+            .Select(g => new WaitCategoryTotal
+            {
+                WaitCategory = g.Key.WaitCategory,
+                WaitCategoryDesc = g.Key.WaitCategoryDesc,
+                WaitRatio = g.Sum(w => w.WaitRatio),
+            })
+            .ToList();
+
+        if (merged.Count > 0)
+        {
+            parent.RawWaitCategories = merged;
+            parent.WaitProfile = QueryStoreService.BuildWaitProfile(merged);
+        }
+    }
+
+    /// <summary>Maps an orderBy metric string to a Func that extracts the sort value from a QueryStoreRow.</summary>
+    private static Func<QueryStoreRow, double> GetMetricAccessor(string orderBy) => orderBy.ToLowerInvariant() switch
+    {
+        "cpu"              => r => r.TotalCpuSort,
+        "avg-cpu"          => r => r.AvgCpuSort,
+        "duration"         => r => r.TotalDurSort,
+        "avg-duration"     => r => r.AvgDurSort,
+        "reads"            => r => r.TotalReadsSort,
+        "avg-reads"        => r => r.AvgReadsSort,
+        "writes"           => r => r.TotalWritesSort,
+        "avg-writes"       => r => r.AvgWritesSort,
+        "physical-reads"   => r => r.TotalPhysReadsSort,
+        "avg-physical-reads" => r => r.AvgPhysReadsSort,
+        "memory"           => r => r.TotalMemSort,
+        "avg-memory"       => r => r.AvgMemSort,
+        "executions"       => r => r.ExecsSort,
+        _                  => r => r.TotalCpuSort,
+    };
+
+    private List<QueryStoreRow> BuildGroupedRows(QueryStoreGroupedResult grouped)
+    {
+        var roots = new List<QueryStoreRow>();
+        var metricAccessor = GetMetricAccessor(_lastFetchedOrderBy);
+
+        if (_groupByMode == QueryStoreGroupBy.QueryHash)
+        {
+            // Level 0: QueryHash groups
+            var queryHashGroups = grouped.IntermediateRows
+                .GroupBy(r => r.QueryHash)
+                .ToList();
+
+            foreach (var qhGroup in queryHashGroups)
+            {
+                var qhKey = qhGroup.Key;
+                var intermediateRows = qhGroup.ToList();
+
+                // Build level-1 children (PlanHash)
+                var midChildren = new List<QueryStoreRow>();
+                foreach (var mid in intermediateRows)
+                {
+                    // Build level-2 children (QueryId/PlanId)
+                    var leafChildren = new List<QueryStoreRow>();
+                    var leaves = grouped.LeafRows
+                        .Where(l => l.QueryHash == mid.QueryHash && l.QueryPlanHash == mid.QueryPlanHash)
+                        .ToList();
+                    foreach (var leaf in leaves)
+                    {
+                        var leafPlan = GroupedRowToPlan(leaf);
+                        leafChildren.Add(new QueryStoreRow(leafPlan, 2,
+                            $"Q:{leaf.QueryId} P:{leaf.PlanId}{(leaf.IsTopRepresentative ? " ★" : "")}", new List<QueryStoreRow>()));
+                    }
+
+                    // Sort leaf children by metric descending
+                    leafChildren = leafChildren.OrderByDescending(r => metricAccessor(r)).ToList();
+
+                    var midPlan = GroupedRowToPlan(mid);
+                    // Populate QueryText from the top representative leaf for this plan hash
+                    var topLeafForMid = leaves.FirstOrDefault(l => l.IsTopRepresentative) ?? leaves.FirstOrDefault();
+                    if (topLeafForMid != null && !string.IsNullOrEmpty(topLeafForMid.QueryText))
+                        midPlan.QueryText = topLeafForMid.QueryText;
+                    midChildren.Add(new QueryStoreRow(midPlan, 1, mid.QueryPlanHash, leafChildren));
+                }
+
+                // Sort mid children by metric descending
+                midChildren = midChildren.OrderByDescending(r => metricAccessor(r)).ToList();
+
+                // Aggregate metrics at QueryHash level
+                var aggPlan = AggregateGroupedRows(intermediateRows, qhKey, intermediateRows.FirstOrDefault()?.ModuleName ?? "");
+                // Populate QueryText from the top representative leaf across all leaves in this query hash group
+                var topLeafForRoot = grouped.LeafRows
+                    .Where(l => l.QueryHash == qhKey && l.IsTopRepresentative && !string.IsNullOrEmpty(l.QueryText))
+                    .FirstOrDefault()
+                    ?? grouped.LeafRows.FirstOrDefault(l => l.QueryHash == qhKey && !string.IsNullOrEmpty(l.QueryText));
+                if (topLeafForRoot != null)
+                    aggPlan.QueryText = topLeafForRoot.QueryText;
+                roots.Add(new QueryStoreRow(aggPlan, 0, qhKey, midChildren));
+            }
+        }
+        else // Module
+        {
+            // Level 0: Module groups
+            var moduleGroups = grouped.IntermediateRows
+                .GroupBy(r => r.ModuleName)
+                .ToList();
+
+            foreach (var modGroup in moduleGroups)
+            {
+                var modKey = modGroup.Key;
+                var intermediateRows = modGroup.ToList();
+
+                // Build level-1 children (QueryHash)
+                var midChildren = new List<QueryStoreRow>();
+                foreach (var mid in intermediateRows)
+                {
+                    // Build level-2 children (QueryId/PlanId)
+                    var leafChildren = new List<QueryStoreRow>();
+                    var leaves = grouped.LeafRows
+                        .Where(l => l.ModuleName == mid.ModuleName && l.QueryHash == mid.QueryHash)
+                        .ToList();
+                    foreach (var leaf in leaves)
+                    {
+                        var leafPlan = GroupedRowToPlan(leaf);
+                        leafChildren.Add(new QueryStoreRow(leafPlan, 2,
+                            $"Q:{leaf.QueryId} P:{leaf.PlanId}{(leaf.IsTopRepresentative ? " ★" : "")}", new List<QueryStoreRow>()));
+                    }
+
+                    // Sort leaf children by metric descending
+                    leafChildren = leafChildren.OrderByDescending(r => metricAccessor(r)).ToList();
+
+                    var midPlan = GroupedRowToPlan(mid);
+                    // Populate QueryText from the top representative leaf for this query hash
+                    var topLeafForMid = leaves.FirstOrDefault(l => l.IsTopRepresentative) ?? leaves.FirstOrDefault();
+                    if (topLeafForMid != null && !string.IsNullOrEmpty(topLeafForMid.QueryText))
+                        midPlan.QueryText = topLeafForMid.QueryText;
+                    midChildren.Add(new QueryStoreRow(midPlan, 1, mid.QueryHash, leafChildren));
+                }
+
+                // Sort mid children by metric descending
+                midChildren = midChildren.OrderByDescending(r => metricAccessor(r)).ToList();
+
+                // Aggregate metrics at Module level
+                var aggPlan = AggregateGroupedRows(intermediateRows, "", modKey);
+                // Populate QueryText from the top representative leaf across all leaves in this module group
+                var topLeafForRoot = grouped.LeafRows
+                    .Where(l => l.ModuleName == modKey && l.IsTopRepresentative && !string.IsNullOrEmpty(l.QueryText))
+                    .FirstOrDefault()
+                    ?? grouped.LeafRows.FirstOrDefault(l => l.ModuleName == modKey && !string.IsNullOrEmpty(l.QueryText));
+                if (topLeafForRoot != null)
+                    aggPlan.QueryText = topLeafForRoot.QueryText;
+                roots.Add(new QueryStoreRow(aggPlan, 0, modKey, midChildren));
+            }
+        }
+
+        return roots;
+    }
+
+    private static QueryStorePlan GroupedRowToPlan(QueryStoreGroupedPlanRow row)
+    {
+        var totalExecs = row.CountExecutions > 0 ? row.CountExecutions : 1;
+        return new QueryStorePlan
+        {
+            QueryId = row.QueryId,
+            PlanId = row.PlanId,
+            QueryHash = row.QueryHash,
+            QueryPlanHash = row.QueryPlanHash,
+            ModuleName = row.ModuleName,
+            QueryText = row.QueryText,
+            PlanXml = row.PlanXml,
+            CountExecutions = row.CountExecutions,
+            TotalCpuTimeUs = row.TotalCpuTimeUs,
+            TotalDurationUs = row.TotalDurationUs,
+            TotalLogicalIoReads = row.TotalLogicalIoReads,
+            TotalLogicalIoWrites = row.TotalLogicalIoWrites,
+            TotalPhysicalIoReads = row.TotalPhysicalIoReads,
+            TotalMemoryGrantPages = row.TotalMemoryGrantPages,
+            AvgCpuTimeUs = (double)row.TotalCpuTimeUs / totalExecs,
+            AvgDurationUs = (double)row.TotalDurationUs / totalExecs,
+            AvgLogicalIoReads = (double)row.TotalLogicalIoReads / totalExecs,
+            AvgLogicalIoWrites = (double)row.TotalLogicalIoWrites / totalExecs,
+            AvgPhysicalIoReads = (double)row.TotalPhysicalIoReads / totalExecs,
+            AvgMemoryGrantPages = (double)row.TotalMemoryGrantPages / totalExecs,
+            LastExecutedUtc = row.LastExecutedUtc,
+        };
+    }
+
+    private static QueryStorePlan AggregateGroupedRows(List<QueryStoreGroupedPlanRow> rows, string queryHash, string moduleName)
+    {
+        var totalExecs = rows.Sum(r => r.CountExecutions);
+        var safeExecs = totalExecs > 0 ? totalExecs : 1;
+        var totalCpu = rows.Sum(r => r.TotalCpuTimeUs);
+        var totalDur = rows.Sum(r => r.TotalDurationUs);
+        var totalReads = rows.Sum(r => r.TotalLogicalIoReads);
+        var totalWrites = rows.Sum(r => r.TotalLogicalIoWrites);
+        var totalPhysReads = rows.Sum(r => r.TotalPhysicalIoReads);
+        var totalMem = rows.Sum(r => r.TotalMemoryGrantPages);
+        var lastExec = rows.Max(r => r.LastExecutedUtc);
+
+        return new QueryStorePlan
+        {
+            QueryHash = queryHash,
+            ModuleName = moduleName,
+            CountExecutions = totalExecs,
+            TotalCpuTimeUs = totalCpu,
+            TotalDurationUs = totalDur,
+            TotalLogicalIoReads = totalReads,
+            TotalLogicalIoWrites = totalWrites,
+            TotalPhysicalIoReads = totalPhysReads,
+            TotalMemoryGrantPages = totalMem,
+            AvgCpuTimeUs = (double)totalCpu / safeExecs,
+            AvgDurationUs = (double)totalDur / safeExecs,
+            AvgLogicalIoReads = (double)totalReads / safeExecs,
+            AvgLogicalIoWrites = (double)totalWrites / safeExecs,
+            AvgPhysicalIoReads = (double)totalPhysReads / safeExecs,
+            AvgMemoryGrantPages = (double)totalMem / safeExecs,
+            LastExecutedUtc = lastExec,
+        };
+    }
+
     private QueryStoreFilter? BuildSearchFilter()
     {
         var searchType = (SearchTypeBox.SelectedItem as ComboBoxItem)?.Tag?.ToString();
@@ -282,6 +675,152 @@ private void SearchValue_KeyDown(object? sender, Avalonia.Input.KeyEventArgs e)
         }
     }
 
+    private int[]? _savedColumnDisplayIndices;
+
+    private void GroupBy_SelectionChanged(object? sender, SelectionChangedEventArgs e)
+    {
+        if (!_initialOrderByLoaded) return;
+        var tag = (GroupByBox.SelectedItem as ComboBoxItem)?.Tag?.ToString() ?? "none";
+        var newMode = tag switch
+        {
+            "query-hash" => QueryStoreGroupBy.QueryHash,
+            "module" => QueryStoreGroupBy.Module,
+            _ => QueryStoreGroupBy.None,
+        };
+        if (newMode == _groupByMode) return;
+        _groupByMode = newMode;
+
+        // Show/hide the expand column (first column in the grid)
+        ResultsGrid.Columns[0].IsVisible = _groupByMode != QueryStoreGroupBy.None;
+
+        // Reorder columns: move the group key column right after expand+checkbox
+        ReorderColumnsForGroupBy();
+
+        // Re-fetch with new grouping
+        Fetch_Click(null, new RoutedEventArgs());
+    }
+
+    private void ReorderColumnsForGroupBy()
+    {
+        var cols = ResultsGrid.Columns;
+
+        if (_groupByMode == QueryStoreGroupBy.None)
+        {
+            // Restore original column order
+            if (_savedColumnDisplayIndices != null)
+            {
+                for (int i = 0; i < cols.Count && i < _savedColumnDisplayIndices.Length; i++)
+                    cols[i].DisplayIndex = _savedColumnDisplayIndices[i];
+                _savedColumnDisplayIndices = null;
+            }
+            // Reset header colors
+            ApplyGroupByHeaderColors();
+            return;
+        }
+
+        // Save original order if not yet saved
+        _savedColumnDisplayIndices ??= cols.Select(c => c.DisplayIndex).ToArray();
+
+        // Column definition indices (AXAML order):
+        //   0=Expand, 1=Checkbox, 2=QueryId, 3=PlanId, 4=QueryHash, 5=PlanHash, 6=Module
+        if (_groupByMode == QueryStoreGroupBy.QueryHash)
+        {
+            // Order: Expand, Checkbox, QueryHash, PlanHash, QueryId, PlanId, ...
+            cols[4].DisplayIndex = 2;  // QueryHash → 2
+            cols[5].DisplayIndex = 3;  // PlanHash → 3
+            cols[2].DisplayIndex = 4;  // QueryId → 4
+            cols[3].DisplayIndex = 5;  // PlanId → 5
+        }
+        else // Module
+        {
+            // Order: Expand, Checkbox, Module, QueryHash, QueryId, PlanId, ...
+            cols[6].DisplayIndex = 2;  // Module → 2
+            cols[4].DisplayIndex = 3;  // QueryHash → 3
+            cols[2].DisplayIndex = 4;  // QueryId → 4
+            cols[3].DisplayIndex = 5;  // PlanId → 5
+        }
+
+        // Apply golden header colors for expandable columns
+        ApplyGroupByHeaderColors();
+    }
+
+    /// <summary>
+    /// Applies golden foreground to column headers that represent expandable/collapsible
+    /// grouping levels in the current GroupBy mode, and resets others.
+    /// </summary>
+    private void ApplyGroupByHeaderColors()
+    {
+        // Column definition indices: 4=QueryHash, 5=PlanHash, 6=Module
+        var goldenCols = _groupByMode switch
+        {
+            QueryStoreGroupBy.QueryHash => new HashSet<int> { 4, 5 },   // QueryHash + PlanHash
+            QueryStoreGroupBy.Module    => new HashSet<int> { 6, 4 },   // Module + QueryHash
+            _                           => new HashSet<int>(),
+        };
+
+        var goldenBrush = new SolidColorBrush(Color.FromRgb(0xFF, 0xD7, 0x00)); // Gold
+
+        for (int i = 0; i < ResultsGrid.Columns.Count; i++)
+        {
+            var col = ResultsGrid.Columns[i];
+            if (col.Header is not StackPanel sp) continue;
+            var label = sp.Children.OfType<TextBlock>().LastOrDefault();
+            if (label == null) continue;
+
+            if (goldenCols.Contains(i))
+                label.Foreground = goldenBrush;
+            else
+                label.ClearValue(TextBlock.ForegroundProperty);
+        }
+    }
+
+    private void ExpandRow_Click(object? sender, RoutedEventArgs e)
+    {
+        if (sender is not Button btn) return;
+        if (btn.DataContext is not QueryStoreRow row) return;
+        if (!row.HasChildren) return;
+
+        row.IsExpanded = !row.IsExpanded;
+
+        if (row.IsExpanded)
+        {
+            // Insert children after this row in _filteredRows
+            var idx = _filteredRows.IndexOf(row);
+            if (idx < 0) return;
+            var insertAt = idx + 1;
+            foreach (var child in row.Children)
+            {
+                _filteredRows.Insert(insertAt, child);
+                insertAt++;
+            }
+
+            // Scroll the first child into view so the expansion is visible
+            if (row.Children.Count > 0)
+                ResultsGrid.ScrollIntoView(row.Children[0], null);
+        }
+        else
+        {
+            // Remove children (and their expanded children) recursively
+            CollapseRowChildren(row);
+        }
+
+        UpdateStatusText();
+        UpdateBarRatios();
+    }
+
+    private void CollapseRowChildren(QueryStoreRow parent)
+    {
+        foreach (var child in parent.Children)
+        {
+            if (child.IsExpanded)
+            {
+                child.IsExpanded = false;
+                CollapseRowChildren(child);
+            }
+            _filteredRows.Remove(child);
+        }
+    }
+
     private async void OrderBy_SelectionChanged(object? sender, SelectionChangedEventArgs e)
     {
         if (!_initialOrderByLoaded) return;
@@ -462,7 +1001,10 @@ private async System.Threading.Tasks.Task FetchWaitStatsAsync(
         DateTime startUtc, DateTime endUtc, CancellationToken ct)
     {
         await FetchGlobalWaitStatsOnlyAsync(startUtc, endUtc, ct);
-        await FetchPerPlanWaitStatsAsync(startUtc, endUtc, ct);
+        if (_groupByMode != QueryStoreGroupBy.None)
+            await FetchGroupedWaitStatsAsync(startUtc, endUtc, ct);
+        else
+            await FetchPerPlanWaitStatsAsync(startUtc, endUtc, ct);
     }
 
     private void OnWaitCategoryClicked(object? sender, string category)
@@ -573,15 +1115,57 @@ private void SelectToggle_Click(object? sender, RoutedEventArgs e)
 
     private void LoadSelected_Click(object? sender, RoutedEventArgs e)
     {
-        var selected = _filteredRows.Where(r => r.IsSelected).Select(r => r.Plan).ToList();
+        List<QueryStorePlan> selected;
+        if (_groupByMode != QueryStoreGroupBy.None)
+        {
+            // In grouped mode, expand selected grouped rows to their leaf plans
+            selected = _filteredRows
+                .Where(r => r.IsSelected)
+                .SelectMany(r => r.HasChildren ? CollectLeafPlans(r) : (r.PlanId > 0 && r.QueryId > 0 ? [r.Plan] : []))
+                .ToList();
+        }
+        else
+        {
+            selected = _filteredRows.Where(r => r.IsSelected).Select(r => r.Plan).ToList();
+        }
         if (selected.Count > 0)
             PlansSelected?.Invoke(this, selected);
     }
 
     private void LoadHighlightedPlan_Click(object? sender, RoutedEventArgs e)
     {
-        if (ResultsGrid.SelectedItem is QueryStoreRow row)
+        if (ResultsGrid.SelectedItem is not QueryStoreRow row) return;
+
+        // In grouped mode, load all descendant leaf plans with real IDs
+        if (_groupByMode != QueryStoreGroupBy.None && row.HasChildren)
+        {
+            var leafPlans = CollectLeafPlans(row);
+            if (leafPlans.Count > 0)
+                PlansSelected?.Invoke(this, leafPlans);
+        }
+        else if (row.PlanId > 0 && row.QueryId > 0)
+        {
             PlansSelected?.Invoke(this, new List<QueryStorePlan> { row.Plan });
+        }
+    }
+
+    /// <summary>
+    /// Recursively collects all leaf-level plans (PlanId > 0 and QueryId > 0) from a grouped row and its descendants.
+    /// </summary>
+    private static List<QueryStorePlan> CollectLeafPlans(QueryStoreRow row)
+    {
+        var plans = new List<QueryStorePlan>();
+        if (row.Children.Count == 0)
+        {
+            if (row.PlanId > 0 && row.QueryId > 0)
+                plans.Add(row.Plan);
+        }
+        else
+        {
+            foreach (var child in row.Children)
+                plans.AddRange(CollectLeafPlans(child));
+        }
+        return plans;
     }
 
     private async void ViewHistory_Click(object? sender, RoutedEventArgs e)
@@ -698,27 +1282,28 @@ private async System.Threading.Tasks.Task SetClipboardTextAsync(string text)
     private void SetupColumnHeaders()
     {
         var cols = ResultsGrid.Columns;
-        SetColumnFilterButton(cols[1],  "QueryId",        "Query ID");
-        SetColumnFilterButton(cols[2],  "PlanId",         "Plan ID");
-        SetColumnFilterButton(cols[3],  "QueryHash",      "Query Hash");
-        SetColumnFilterButton(cols[4],  "PlanHash",       "Plan Hash");
-        SetColumnFilterButton(cols[5],  "ModuleName",     "Module");
-        // cols[6] = WaitProfile (no filter button)
-        SetColumnFilterButton(cols[7],  "LastExecuted",   "Last Executed (Local)");
-        SetColumnFilterButton(cols[8],  "Executions",     "Executions");
-        SetColumnFilterButton(cols[9],  "TotalCpu",       "Total CPU (ms)");
-        SetColumnFilterButton(cols[10], "AvgCpu",         "Avg CPU (ms)");
-        SetColumnFilterButton(cols[11], "TotalDuration",  "Total Duration (ms)");
-        SetColumnFilterButton(cols[12], "AvgDuration",    "Avg Duration (ms)");
-        SetColumnFilterButton(cols[13], "TotalReads",     "Total Reads");
-        SetColumnFilterButton(cols[14], "AvgReads",       "Avg Reads");
-        SetColumnFilterButton(cols[15], "TotalWrites",    "Total Writes");
-        SetColumnFilterButton(cols[16], "AvgWrites",      "Avg Writes");
-        SetColumnFilterButton(cols[17], "TotalPhysReads", "Total Physical Reads");
-        SetColumnFilterButton(cols[18], "AvgPhysReads",   "Avg Physical Reads");
-        SetColumnFilterButton(cols[19], "TotalMemory",    "Total Memory (MB)");
-        SetColumnFilterButton(cols[20], "AvgMemory",      "Avg Memory (MB)");
-        SetColumnFilterButton(cols[21], "QueryText",      "Query Text");
+        // cols[0] = Expand column, cols[1] = Checkbox
+        SetColumnFilterButton(cols[2],  "QueryId",        "Query ID");
+        SetColumnFilterButton(cols[3],  "PlanId",         "Plan ID");
+        SetColumnFilterButton(cols[4],  "QueryHash",      "Query Hash");
+        SetColumnFilterButton(cols[5],  "PlanHash",       "Plan Hash");
+        SetColumnFilterButton(cols[6],  "ModuleName",     "Module");
+        // cols[7] = WaitProfile (no filter button)
+        SetColumnFilterButton(cols[8],  "LastExecuted",   "Last Executed (Local)");
+        SetColumnFilterButton(cols[9],  "Executions",     "Executions");
+        SetColumnFilterButton(cols[10], "TotalCpu",       "Total CPU (ms)");
+        SetColumnFilterButton(cols[11], "AvgCpu",         "Avg CPU (ms)");
+        SetColumnFilterButton(cols[12], "TotalDuration",  "Total Duration (ms)");
+        SetColumnFilterButton(cols[13], "AvgDuration",    "Avg Duration (ms)");
+        SetColumnFilterButton(cols[14], "TotalReads",     "Total Reads");
+        SetColumnFilterButton(cols[15], "AvgReads",       "Avg Reads");
+        SetColumnFilterButton(cols[16], "TotalWrites",    "Total Writes");
+        SetColumnFilterButton(cols[17], "AvgWrites",      "Avg Writes");
+        SetColumnFilterButton(cols[18], "TotalPhysReads", "Total Physical Reads");
+        SetColumnFilterButton(cols[19], "AvgPhysReads",   "Avg Physical Reads");
+        SetColumnFilterButton(cols[20], "TotalMemory",    "Total Memory (MB)");
+        SetColumnFilterButton(cols[21], "AvgMemory",      "Avg Memory (MB)");
+        SetColumnFilterButton(cols[22], "QueryText",      "Query Text");
     }
 
     private void SetColumnFilterButton(DataGridColumn col, string columnId, string label)
@@ -884,9 +1469,20 @@ private bool RowMatchesAllFilters(QueryStoreRow row)
     private void UpdateStatusText()
     {
         if (_rows.Count == 0) return;
-        StatusText.Text = _filteredRows.Count == _rows.Count
-            ? $"{_rows.Count} plans"
-            : $"{_filteredRows.Count} / {_rows.Count} plans (filtered)";
+        if (_groupByMode != QueryStoreGroupBy.None)
+        {
+            var rootCount = _groupedRootRows.Count;
+            var visibleRoots = _filteredRows.Count(r => r.IndentLevel == 0);
+            StatusText.Text = visibleRoots == rootCount
+                ? $"{rootCount} groups ({_rows.Count} total rows)"
+                : $"{visibleRoots} / {rootCount} groups (filtered)";
+        }
+        else
+        {
+            StatusText.Text = _filteredRows.Count == _rows.Count
+                ? $"{_rows.Count} plans"
+                : $"{_filteredRows.Count} / {_rows.Count} plans (filtered)";
+        }
     }
 
     private void ResultsGrid_Sorting(object? sender, DataGridColumnEventArgs e)
@@ -954,6 +1550,12 @@ private void ReapplyTopNSelection()
 
     private void ApplySortAndFilters()
     {
+        if (_groupByMode != QueryStoreGroupBy.None)
+        {
+            ApplySortAndFiltersGrouped();
+            return;
+        }
+
         IEnumerable<QueryStoreRow> source = _rows.Where(RowMatchesAllFilters);
 
         if (_sortedColumnTag != null)
@@ -972,6 +1574,40 @@ private void ApplySortAndFilters()
         UpdateBarRatios();
     }
 
+    private void ApplySortAndFiltersGrouped()
+    {
+        // In grouped mode, sort/filter only root rows and rebuild the visible list
+        IEnumerable<QueryStoreRow> source = _groupedRootRows.Where(RowMatchesAllFilters);
+
+        if (_sortedColumnTag != null)
+        {
+            source = _sortAscending
+                ? source.OrderBy(r => GetSortKey(_sortedColumnTag, r))
+                : source.OrderByDescending(r => GetSortKey(_sortedColumnTag, r));
+        }
+
+        _filteredRows.Clear();
+        foreach (var root in source)
+        {
+            _filteredRows.Add(root);
+            if (root.IsExpanded)
+                AddExpandedChildren(root);
+        }
+
+        UpdateStatusText();
+        UpdateBarRatios();
+    }
+
+    private void AddExpandedChildren(QueryStoreRow parent)
+    {
+        foreach (var child in parent.Children)
+        {
+            _filteredRows.Add(child);
+            if (child.IsExpanded)
+                AddExpandedChildren(child);
+        }
+    }
+
     // ── Bar chart ratio computation ────────────────────────────────────────
 
     // Maps a ColumnId (used in BarChartConfig) to the accessor that returns the raw sort value.
@@ -1098,13 +1734,64 @@ public class QueryStoreRow : INotifyPropertyChanged
     private WaitProfile? _waitProfile;
     private string? _waitHighlightCategory;
 
+    /// <summary>Raw wait category totals for this row. Used for upward consolidation in grouped mode.</summary>
+    public List<WaitCategoryTotal> RawWaitCategories { get; set; } = new();
+
+    // Hierarchy support
+    private bool _isExpanded;
+    private int _indentLevel;
+
+    /// <summary>Standard constructor for flat (ungrouped) rows.</summary>
     public QueryStoreRow(QueryStorePlan plan)
     {
         Plan = plan;
     }
 
+    /// <summary>Constructor for grouped parent/intermediate rows (aggregated, no single plan).</summary>
+    public QueryStoreRow(QueryStorePlan syntheticPlan, int indentLevel, string groupLabel, List<QueryStoreRow> children)
+    {
+        Plan = syntheticPlan;
+        _indentLevel = indentLevel;
+        GroupLabel = groupLabel;
+        Children = children;
+    }
+
     public QueryStorePlan Plan { get; }
 
+    // ── Hierarchy properties ───────────────────────────────────────────────
+
+    /// <summary>Indentation level: 0 = top group, 1 = intermediate, 2 = leaf.</summary>
+    public int IndentLevel
+    {
+        get => _indentLevel;
+        set { _indentLevel = value; OnPropertyChanged(); }
+    }
+
+    /// <summary>Label shown for grouped rows (e.g. "0x1A2B3C" or "dbo.MyProc").</summary>
+    public string GroupLabel { get; set; } = "";
+
+    /// <summary>Direct children of this group row.</summary>
+    public List<QueryStoreRow> Children { get; set; } = new();
+
+    public bool HasChildren => Children.Count > 0;
+
+    public bool IsExpanded
+    {
+        get => _isExpanded;
+        set { _isExpanded = value; OnPropertyChanged(); OnPropertyChanged(nameof(ExpandChevron)); }
+    }
+
+    public string ExpandChevron => HasChildren ? (IsExpanded ? "▾" : "▸") : "";
+
+    /// <summary>Left margin that increases with indent level to visually show hierarchy.</summary>
+    public Avalonia.Thickness IndentMargin => new(IndentLevel * 20, 0, 0, 0);
+
+    /// <summary>Text shown next to the chevron: the group label for parent rows, or QueryId/PlanId for leaves.</summary>
+    public string GroupDisplayText => !string.IsNullOrEmpty(GroupLabel) ? GroupLabel : "";
+
+    /// <summary>Bold for top-level groups, normal for children.</summary>
+    public Avalonia.Media.FontWeight GroupFontWeight => IndentLevel == 0 ? Avalonia.Media.FontWeight.Bold : Avalonia.Media.FontWeight.Normal;
+
     public bool IsSelected
     {
         get => _isSelected;
diff --git a/src/PlanViewer.Core/Models/QueryStoreGroupBy.cs b/src/PlanViewer.Core/Models/QueryStoreGroupBy.cs
new file mode 100644
index 0000000..6d62f70
--- /dev/null
+++ b/src/PlanViewer.Core/Models/QueryStoreGroupBy.cs
@@ -0,0 +1,65 @@
+namespace PlanViewer.Core.Models;
+
+/// <summary>
+/// Specifies how Query Store grid results are grouped.
+/// </summary>
+public enum QueryStoreGroupBy
+{
+    /// <summary>No grouping — one row per plan (existing behaviour).</summary>
+    None,
+    /// <summary>Group by query_hash → plan_hash → query_id/plan_id.</summary>
+    QueryHash,
+    /// <summary>Group by module → query_hash → query_id/plan_id.</summary>
+    Module,
+}
+
+/// <summary>
+/// A row returned by the grouped query. Contains raw totals for app-side aggregation.
+/// Used as the leaf or intermediate row in the hierarchy; parent-level aggregation
+/// (SUM totals, recomputed averages) is done on the application side.
+/// </summary>
+public class QueryStoreGroupedPlanRow
+{
+    // Grouping keys
+    public string ModuleName { get; set; } = "";
+    public string QueryHash { get; set; } = "";
+    public string QueryPlanHash { get; set; } = "";
+    public long QueryId { get; set; }
+    public long PlanId { get; set; }
+    public string QueryText { get; set; } = "";
+    public string PlanXml { get; set; } = "";
+
+    // Raw totals (aggregated across intervals for this plan_id / plan_hash level)
+    public long CountExecutions { get; set; }
+    public long TotalCpuTimeUs { get; set; }
+    public long TotalDurationUs { get; set; }
+    public long TotalLogicalIoReads { get; set; }
+    public long TotalLogicalIoWrites { get; set; }
+    public long TotalPhysicalIoReads { get; set; }
+    public long TotalMemoryGrantPages { get; set; }
+    public DateTime LastExecutedUtc { get; set; }
+
+    /// <summary>
+    /// Indicates whether this row is the "top" (true) or "bottom" (false) representative
+    /// for a query_hash/plan_hash pair. Only meaningful for leaf-level (QueryId/PlanId) rows.
+    /// </summary>
+    public bool IsTopRepresentative { get; set; }
+}
+
+/// <summary>
+/// Complete result of a grouped fetch. Contains intermediate-level rows (per plan_hash)
+/// and leaf-level rows (per query_id/plan_id).
+/// </summary>
+public class QueryStoreGroupedResult
+{
+    /// <summary>
+    /// Intermediate rows: one per (query_hash, plan_hash) or (module, query_hash).
+    /// These carry the aggregated metrics for that group.
+    /// </summary>
+    public List<QueryStoreGroupedPlanRow> IntermediateRows { get; set; } = new();
+
+    /// <summary>
+    /// Leaf rows: top and bottom query_id/plan_id representatives per group.
+    /// </summary>
+    public List<QueryStoreGroupedPlanRow> LeafRows { get; set; } = new();
+}
diff --git a/src/PlanViewer.Core/Services/QueryStoreService.cs b/src/PlanViewer.Core/Services/QueryStoreService.cs
index 8b96fbd..9427c1e 100644
--- a/src/PlanViewer.Core/Services/QueryStoreService.cs
+++ b/src/PlanViewer.Core/Services/QueryStoreService.cs
@@ -920,6 +920,573 @@ GROUP BY DATEADD(HOUR, DATEDIFF(HOUR, 0, rsi.start_time), 0),
         return rows;
     }
 
+    // ── Grouped fetches ──────────────────────────────────────────────────
+
+    /// <summary>
+    /// Helper: resolves the metric alias used inside aggregation temp tables.
+    /// Returns (planStatsColumn, aggAlias) where planStatsColumn references #plan_stats
+    /// and aggAlias is the column name used in GROUP BY aggregation selects.
+    /// </summary>
+    private static (string PlanStatsCol, string AggAlias) ResolveGroupMetric(string orderBy)
+    {
+        var key = orderBy.ToLowerInvariant();
+        return key switch
+        {
+            "cpu" or "avg-cpu"                       => ("total_cpu_us",        "total_cpu_us"),
+            "duration" or "avg-duration"             => ("total_duration_us",   "total_duration_us"),
+            "reads" or "avg-reads"                   => ("total_reads",         "total_reads"),
+            "writes" or "avg-writes"                 => ("total_writes",        "total_writes"),
+            "physical-reads" or "avg-physical-reads" => ("total_physical_reads","total_physical_reads"),
+            "memory" or "avg-memory"                 => ("total_memory_pages",  "total_memory_pages"),
+            "executions"                             => ("total_executions",    "total_executions"),
+            _ => ("total_cpu_us", "total_cpu_us"),
+        };
+    }
+
+    /// <summary>
+    /// Fetches grouped-by-QueryHash results.
+    /// Step 1: Top X query hashes by metric.
+    /// Step 2: Top 5 plan hashes per query hash with metrics.
+    /// Step 3: Top and bottom QueryId/PlanId per query_hash/plan_hash.
+    /// Final : Fetch Query Text and Plan XML for the identified QueryId/PlanId.
+    /// Returns intermediate (plan_hash level) and leaf (query_id/plan_id level) rows.
+    /// </summary>
+    public static async Task<QueryStoreGroupedResult> FetchGroupedByQueryHashAsync(
+        string connectionString, int topN = 25, string orderBy = "cpu",
+        QueryStoreFilter? filter = null, CancellationToken ct = default,
+        DateTime? startUtc = null, DateTime? endUtc = null)
+    {
+        var (metricCol, _) = ResolveGroupMetric(orderBy);
+        var parameters = new List<SqlParameter>();
+
+        // Time-range filter
+        string intervalWhereClause;
+        if (startUtc.HasValue && endUtc.HasValue)
+        {
+            intervalWhereClause = "WHERE rsi.start_time >= @rangeStart AND rsi.start_time < @rangeEnd";
+            parameters.Add(new SqlParameter("@rangeStart", startUtc.Value));
+            parameters.Add(new SqlParameter("@rangeEnd", endUtc.Value));
+        }
+        else
+        {
+            intervalWhereClause = "WHERE rsi.start_time >= DATEADD(HOUR, -24, GETUTCDATE())";
+        }
+
+        // Filter clauses
+        var filterClauses = new List<string>();
+        if (filter?.QueryId != null)
+        {
+            filterClauses.Add("AND q.query_id = @filterQueryId");
+            parameters.Add(new SqlParameter("@filterQueryId", filter.QueryId.Value));
+        }
+        if (!string.IsNullOrWhiteSpace(filter?.QueryHash))
+        {
+            filterClauses.Add("AND q.query_hash = CONVERT(binary(8), @filterQueryHash, 1)");
+            parameters.Add(new SqlParameter("@filterQueryHash", filter.QueryHash.Trim()));
+        }
+        if (!string.IsNullOrWhiteSpace(filter?.ModuleName))
+        {
+            var moduleVal = filter.ModuleName.Trim();
+            if (moduleVal.Contains('%'))
+                filterClauses.Add("AND OBJECT_SCHEMA_NAME(q.object_id) + N'.' + OBJECT_NAME(q.object_id) LIKE @filterModule");
+            else
+                filterClauses.Add("AND OBJECT_SCHEMA_NAME(q.object_id) + N'.' + OBJECT_NAME(q.object_id) = @filterModule");
+            parameters.Add(new SqlParameter("@filterModule", moduleVal));
+        }
+        var filterSql = filterClauses.Count > 0 ? "\n" + string.Join("\n", filterClauses) : "";
+
+        var sql = $@"
+SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
+
+/* Phase 1: Pre-filter matching interval IDs */
+DROP TABLE IF EXISTS #intervals;
+CREATE TABLE #intervals (runtime_stats_interval_id bigint NOT NULL PRIMARY KEY CLUSTERED);
+INSERT INTO #intervals (runtime_stats_interval_id)
+SELECT rsi.runtime_stats_interval_id
+FROM sys.query_store_runtime_stats_interval AS rsi
+{intervalWhereClause}
+OPTION (RECOMPILE);
+
+/* Phase 2: Aggregate runtime stats by plan_id */
+DROP TABLE IF EXISTS #plan_stats;
+CREATE TABLE #plan_stats (
+    plan_id bigint NOT NULL PRIMARY KEY CLUSTERED,
+    total_cpu_us float NOT NULL,
+    total_duration_us float NOT NULL,
+    total_reads float NOT NULL,
+    total_writes float NOT NULL,
+    total_physical_reads float NOT NULL,
+    total_memory_pages float NOT NULL,
+    total_executions bigint NOT NULL,
+    last_execution_time datetimeoffset NOT NULL
+);
+INSERT INTO #plan_stats
+SELECT
+    rs.plan_id,
+    SUM(rs.avg_cpu_time * rs.count_executions),
+    SUM(rs.avg_duration * rs.count_executions),
+    SUM(rs.avg_logical_io_reads * rs.count_executions),
+    SUM(rs.avg_logical_io_writes * rs.count_executions),
+    SUM(rs.avg_physical_io_reads * rs.count_executions),
+    SUM(rs.avg_query_max_used_memory * rs.count_executions),
+    SUM(rs.count_executions),
+    MAX(rs.last_execution_time)
+FROM sys.query_store_runtime_stats AS rs
+WHERE EXISTS (SELECT 1 FROM #intervals AS i WHERE i.runtime_stats_interval_id = rs.runtime_stats_interval_id)
+GROUP BY rs.plan_id
+OPTION (RECOMPILE);
+
+/* Step 1: Top X query hashes by metric */
+DROP TABLE IF EXISTS #top_hashes;
+;WITH qh AS (
+    SELECT
+        q.query_hash,
+        SUM(ps.{metricCol}) AS metric_total
+    FROM #plan_stats ps
+    JOIN sys.query_store_plan p ON ps.plan_id = p.plan_id
+    JOIN sys.query_store_query q ON p.query_id = q.query_id
+    WHERE 1=1{filterSql}
+    GROUP BY q.query_hash
+)
+SELECT TOP ({topN}) query_hash, metric_total
+INTO #top_hashes
+FROM qh
+ORDER BY metric_total DESC;
+
+/* Step 2: Top 5 plan hashes per query hash with metrics */
+DROP TABLE IF EXISTS #plan_hash_rows;
+;WITH ph AS (
+    SELECT
+        CONVERT(varchar(18), q.query_hash, 1) AS query_hash,
+        CONVERT(varchar(18), p.query_plan_hash, 1) AS plan_hash,
+        CASE WHEN q.object_id <> 0
+             THEN OBJECT_SCHEMA_NAME(q.object_id) + N'.' + OBJECT_NAME(q.object_id)
+             ELSE N'' END AS module_name,
+        SUM(ps.total_cpu_us) AS total_cpu_us,
+        SUM(ps.total_duration_us) AS total_duration_us,
+        SUM(ps.total_reads) AS total_reads,
+        SUM(ps.total_writes) AS total_writes,
+        SUM(ps.total_physical_reads) AS total_physical_reads,
+        SUM(ps.total_memory_pages) AS total_memory_pages,
+        SUM(ps.total_executions) AS total_executions,
+        MAX(ps.last_execution_time) AS last_execution_time,
+        ROW_NUMBER() OVER (PARTITION BY q.query_hash ORDER BY SUM(ps.{metricCol}) DESC) AS rnum
+    FROM #plan_stats ps
+    JOIN sys.query_store_plan p ON ps.plan_id = p.plan_id
+    JOIN sys.query_store_query q ON p.query_id = q.query_id
+    WHERE EXISTS (SELECT 1 FROM #top_hashes th WHERE th.query_hash = q.query_hash)
+    GROUP BY q.query_hash, p.query_plan_hash,
+             CASE WHEN q.object_id <> 0
+                  THEN OBJECT_SCHEMA_NAME(q.object_id) + N'.' + OBJECT_NAME(q.object_id)
+                  ELSE N'' END
+)
+SELECT query_hash, plan_hash, module_name,
+       CAST(total_cpu_us AS bigint) AS total_cpu_us,
+       CAST(total_duration_us AS bigint) AS total_duration_us,
+       CAST(total_reads AS bigint) AS total_reads,
+       CAST(total_writes AS bigint) AS total_writes,
+       CAST(total_physical_reads AS bigint) AS total_physical_reads,
+       CAST(total_memory_pages AS bigint) AS total_memory_pages,
+       total_executions,
+       last_execution_time
+INTO #plan_hash_rows
+FROM ph WHERE rnum <= 5;
+
+/* Step 3: Top and bottom QueryId/PlanId per query_hash/plan_hash */
+;WITH ranked AS (
+    SELECT
+        CONVERT(varchar(18), q.query_hash, 1) AS query_hash,
+        CONVERT(varchar(18), p.query_plan_hash, 1) AS plan_hash,
+        q.query_id,
+        ps.plan_id,
+        q.query_text_id,
+        CASE WHEN q.object_id <> 0
+             THEN OBJECT_SCHEMA_NAME(q.object_id) + N'.' + OBJECT_NAME(q.object_id)
+             ELSE N'' END AS module_name,
+        CAST(ps.total_cpu_us AS bigint) AS total_cpu_us,
+        CAST(ps.total_duration_us AS bigint) AS total_duration_us,
+        CAST(ps.total_reads AS bigint) AS total_reads,
+        CAST(ps.total_writes AS bigint) AS total_writes,
+        CAST(ps.total_physical_reads AS bigint) AS total_physical_reads,
+        CAST(ps.total_memory_pages AS bigint) AS total_memory_pages,
+        ps.total_executions,
+        ps.last_execution_time,
+        ROW_NUMBER() OVER (PARTITION BY q.query_hash, p.query_plan_hash ORDER BY ps.{metricCol} DESC) AS rn_top,
+        ROW_NUMBER() OVER (PARTITION BY q.query_hash, p.query_plan_hash ORDER BY ps.{metricCol} ASC) AS rn_bottom
+    FROM #plan_stats ps
+    JOIN sys.query_store_plan p ON ps.plan_id = p.plan_id
+    JOIN sys.query_store_query q ON p.query_id = q.query_id
+    WHERE EXISTS (SELECT 1 FROM #plan_hash_rows phr
+                  WHERE phr.query_hash = CONVERT(varchar(18), q.query_hash, 1)
+                    AND phr.plan_hash = CONVERT(varchar(18), p.query_plan_hash, 1))
+)
+SELECT *
+into #ranked_light
+FROM ranked
+WHERE rn_top = 1 OR rn_bottom = 1;
+
+/* Final select: join heavy elements (query_text, plan_xml) only for the top/bottom representatives */
+SELECT 
+r.query_hash, 
+r.plan_hash, 
+r.query_id, 
+r.plan_id, 
+qt.query_sql_text, 
+TRY_CONVERT(nvarchar(max), p.query_plan) AS plan_xml,
+r.module_name, 
+r.total_cpu_us, 
+r.total_duration_us, 
+r.total_reads, 
+r.total_writes,
+r.total_physical_reads, 
+r.total_memory_pages, 
+r.total_executions, 
+r.last_execution_time,
+CASE WHEN r.rn_top = 1 THEN 1 ELSE 0 END AS is_top
+FROM #ranked_light r
+JOIN sys.query_store_query_text qt ON r.query_text_id = qt.query_text_id
+JOIN sys.query_store_plan p ON r.plan_id = p.plan_id;
+
+/* Return intermediate rows (result set 1) */
+SELECT * FROM #plan_hash_rows ORDER BY query_hash, total_executions DESC;
+";
+
+        var result = new QueryStoreGroupedResult();
+        await using var conn = new SqlConnection(connectionString);
+        await conn.OpenAsync(ct);
+        await using var cmd = new SqlCommand(sql, conn) { CommandTimeout = 120 };
+        foreach (var p in parameters) cmd.Parameters.Add(p);
+        await using var reader = await cmd.ExecuteReaderAsync(ct);
+
+        // Result set 1: Leaf rows (top/bottom per query_hash/plan_hash)
+        while (await reader.ReadAsync(ct))
+        {
+            result.LeafRows.Add(new QueryStoreGroupedPlanRow
+            {
+                QueryHash = reader.IsDBNull(0) ? "" : reader.GetString(0),
+                QueryPlanHash = reader.IsDBNull(1) ? "" : reader.GetString(1),
+                QueryId = reader.GetInt64(2),
+                PlanId = reader.GetInt64(3),
+                QueryText = reader.IsDBNull(4) ? "" : reader.GetString(4),
+                PlanXml = reader.IsDBNull(5) ? "" : reader.GetString(5),
+                ModuleName = reader.IsDBNull(6) ? "" : reader.GetString(6),
+                TotalCpuTimeUs = reader.GetInt64(7),
+                TotalDurationUs = reader.GetInt64(8),
+                TotalLogicalIoReads = reader.GetInt64(9),
+                TotalLogicalIoWrites = reader.GetInt64(10),
+                TotalPhysicalIoReads = reader.GetInt64(11),
+                TotalMemoryGrantPages = reader.GetInt64(12),
+                CountExecutions = reader.GetInt64(13),
+                LastExecutedUtc = ((DateTimeOffset)reader.GetValue(14)).UtcDateTime,
+                IsTopRepresentative = reader.GetInt32(15) == 1,
+            });
+        }
+
+        // Result set 2: Intermediate rows (plan_hash level aggregated)
+        if (await reader.NextResultAsync(ct))
+        {
+            while (await reader.ReadAsync(ct))
+            {
+                result.IntermediateRows.Add(new QueryStoreGroupedPlanRow
+                {
+                    QueryHash = reader.IsDBNull(0) ? "" : reader.GetString(0),
+                    QueryPlanHash = reader.IsDBNull(1) ? "" : reader.GetString(1),
+                    ModuleName = reader.IsDBNull(2) ? "" : reader.GetString(2),
+                    TotalCpuTimeUs = reader.GetInt64(3),
+                    TotalDurationUs = reader.GetInt64(4),
+                    TotalLogicalIoReads = reader.GetInt64(5),
+                    TotalLogicalIoWrites = reader.GetInt64(6),
+                    TotalPhysicalIoReads = reader.GetInt64(7),
+                    TotalMemoryGrantPages = reader.GetInt64(8),
+                    CountExecutions = reader.GetInt64(9),
+                    LastExecutedUtc = ((DateTimeOffset)reader.GetValue(10)).UtcDateTime,
+                });
+            }
+        }
+
+        return result;
+    }
+
+    /// <summary>
+    /// Fetches grouped-by-Module results.
+    /// Step 1: Top X modules by metric.
+    /// Step 2: Top 5 query hashes per module with metrics.
+    /// Step 3: Top and bottom QueryId/PlanId per module/query_hash.
+    /// Final Step: Fetch Query Text and Plan XML for the identified QueryId/PlanId.
+    /// Returns intermediate (query_hash level) and leaf (query_id/plan_id level) rows.
+    /// </summary>
+    public static async Task<QueryStoreGroupedResult> FetchGroupedByModuleAsync(
+        string connectionString, int topN = 25, string orderBy = "cpu",
+        QueryStoreFilter? filter = null, CancellationToken ct = default,
+        DateTime? startUtc = null, DateTime? endUtc = null)
+    {
+        var (metricCol, _) = ResolveGroupMetric(orderBy);
+        var parameters = new List<SqlParameter>();
+
+        // Time-range filter
+        string intervalWhereClause;
+        if (startUtc.HasValue && endUtc.HasValue)
+        {
+            intervalWhereClause = "WHERE rsi.start_time >= @rangeStart AND rsi.start_time < @rangeEnd";
+            parameters.Add(new SqlParameter("@rangeStart", startUtc.Value));
+            parameters.Add(new SqlParameter("@rangeEnd", endUtc.Value));
+        }
+        else
+        {
+            intervalWhereClause = "WHERE rsi.start_time >= DATEADD(HOUR, -24, GETUTCDATE())";
+        }
+
+        // Filter clauses
+        var filterClauses = new List<string>();
+        if (!string.IsNullOrWhiteSpace(filter?.ModuleName))
+        {
+            var moduleVal = filter.ModuleName.Trim();
+            if (moduleVal.Contains('%'))
+                filterClauses.Add("AND OBJECT_SCHEMA_NAME(q.object_id) + N'.' + OBJECT_NAME(q.object_id) LIKE @filterModule");
+            else
+                filterClauses.Add("AND OBJECT_SCHEMA_NAME(q.object_id) + N'.' + OBJECT_NAME(q.object_id) = @filterModule");
+            parameters.Add(new SqlParameter("@filterModule", moduleVal));
+        }
+        if (!string.IsNullOrWhiteSpace(filter?.QueryHash))
+        {
+            filterClauses.Add("AND q.query_hash = CONVERT(binary(8), @filterQueryHash, 1)");
+            parameters.Add(new SqlParameter("@filterQueryHash", filter.QueryHash.Trim()));
+        }
+        var filterSql = filterClauses.Count > 0 ? "\n" + string.Join("\n", filterClauses) : "";
+
+        var sql = $@"
+SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
+
+/* Phase 1: Pre-filter matching interval IDs */
+DROP TABLE IF EXISTS #intervals;
+CREATE TABLE #intervals (runtime_stats_interval_id bigint NOT NULL PRIMARY KEY CLUSTERED);
+INSERT INTO #intervals (runtime_stats_interval_id)
+SELECT rsi.runtime_stats_interval_id
+FROM sys.query_store_runtime_stats_interval AS rsi
+{intervalWhereClause}
+OPTION (RECOMPILE);
+
+/* Phase 2: Aggregate runtime stats by plan_id */
+DROP TABLE IF EXISTS #plan_stats;
+CREATE TABLE #plan_stats (
+    plan_id bigint NOT NULL PRIMARY KEY CLUSTERED,
+    total_cpu_us float NOT NULL,
+    total_duration_us float NOT NULL,
+    total_reads float NOT NULL,
+    total_writes float NOT NULL,
+    total_physical_reads float NOT NULL,
+    total_memory_pages float NOT NULL,
+    total_executions bigint NOT NULL,
+    last_execution_time datetimeoffset NOT NULL
+);
+INSERT INTO #plan_stats
+SELECT
+    rs.plan_id,
+    SUM(rs.avg_cpu_time * rs.count_executions),
+    SUM(rs.avg_duration * rs.count_executions),
+    SUM(rs.avg_logical_io_reads * rs.count_executions),
+    SUM(rs.avg_logical_io_writes * rs.count_executions),
+    SUM(rs.avg_physical_io_reads * rs.count_executions),
+    SUM(rs.avg_query_max_used_memory * rs.count_executions),
+    SUM(rs.count_executions),
+    MAX(rs.last_execution_time)
+FROM sys.query_store_runtime_stats AS rs
+WHERE EXISTS (SELECT 1 FROM #intervals AS i WHERE i.runtime_stats_interval_id = rs.runtime_stats_interval_id)
+GROUP BY rs.plan_id
+OPTION (RECOMPILE);
+
+/* Step 1: Top X modules by metric */
+DROP TABLE IF EXISTS #top_modules;
+;WITH md AS (
+    SELECT
+        CASE WHEN q.object_id <> 0
+             THEN OBJECT_SCHEMA_NAME(q.object_id) + N'.' + OBJECT_NAME(q.object_id)
+             ELSE N'' END AS module_name,
+        SUM(ps.{metricCol}) AS metric_total
+    FROM #plan_stats ps
+    JOIN sys.query_store_plan p ON ps.plan_id = p.plan_id
+    JOIN sys.query_store_query q ON p.query_id = q.query_id
+    WHERE q.object_id <> 0{filterSql}
+    GROUP BY CASE WHEN q.object_id <> 0
+                  THEN OBJECT_SCHEMA_NAME(q.object_id) + N'.' + OBJECT_NAME(q.object_id)
+                  ELSE N'' END
+)
+SELECT TOP ({topN}) module_name, metric_total
+INTO #top_modules
+FROM md
+ORDER BY metric_total DESC;
+
+/* Step 2: Top 5 query hashes per module with metrics */
+DROP TABLE IF EXISTS #qhash_rows;
+;WITH qh AS (
+    SELECT
+        CASE WHEN q.object_id <> 0
+             THEN OBJECT_SCHEMA_NAME(q.object_id) + N'.' + OBJECT_NAME(q.object_id)
+             ELSE N'' END AS module_name,
+        CONVERT(varchar(18), q.query_hash, 1) AS query_hash,
+        SUM(ps.total_cpu_us) AS total_cpu_us,
+        SUM(ps.total_duration_us) AS total_duration_us,
+        SUM(ps.total_reads) AS total_reads,
+        SUM(ps.total_writes) AS total_writes,
+        SUM(ps.total_physical_reads) AS total_physical_reads,
+        SUM(ps.total_memory_pages) AS total_memory_pages,
+        SUM(ps.total_executions) AS total_executions,
+        MAX(ps.last_execution_time) AS last_execution_time,
+        ROW_NUMBER() OVER (PARTITION BY
+            CASE WHEN q.object_id <> 0
+                 THEN OBJECT_SCHEMA_NAME(q.object_id) + N'.' + OBJECT_NAME(q.object_id)
+                 ELSE N'' END
+            ORDER BY SUM(ps.{metricCol}) DESC) AS rnum
+    FROM #plan_stats ps
+    JOIN sys.query_store_plan p ON ps.plan_id = p.plan_id
+    JOIN sys.query_store_query q ON p.query_id = q.query_id
+    WHERE EXISTS (SELECT 1 FROM #top_modules tm
+                  WHERE tm.module_name = CASE WHEN q.object_id <> 0
+                       THEN OBJECT_SCHEMA_NAME(q.object_id) + N'.' + OBJECT_NAME(q.object_id)
+                       ELSE N'' END)
+    GROUP BY CASE WHEN q.object_id <> 0
+                  THEN OBJECT_SCHEMA_NAME(q.object_id) + N'.' + OBJECT_NAME(q.object_id)
+                  ELSE N'' END,
+             q.query_hash
+)
+SELECT module_name, query_hash,
+       CAST(total_cpu_us AS bigint) AS total_cpu_us,
+       CAST(total_duration_us AS bigint) AS total_duration_us,
+       CAST(total_reads AS bigint) AS total_reads,
+       CAST(total_writes AS bigint) AS total_writes,
+       CAST(total_physical_reads AS bigint) AS total_physical_reads,
+       CAST(total_memory_pages AS bigint) AS total_memory_pages,
+       total_executions,
+       last_execution_time
+INTO #qhash_rows
+FROM qh WHERE rnum <= 5;
+
+/* Step 3: Top and bottom QueryId/PlanId per module/query_hash */
+;WITH ranked AS (
+    SELECT
+        CASE WHEN q.object_id <> 0
+             THEN OBJECT_SCHEMA_NAME(q.object_id) + N'.' + OBJECT_NAME(q.object_id)
+             ELSE N'' END AS module_name,
+        CONVERT(varchar(18), q.query_hash, 1) AS query_hash,
+        CONVERT(varchar(18), p.query_plan_hash, 1) AS plan_hash,
+        q.query_id,
+        ps.plan_id,
+        q.query_text_id,
+        CAST(ps.total_cpu_us AS bigint) AS total_cpu_us,
+        CAST(ps.total_duration_us AS bigint) AS total_duration_us,
+        CAST(ps.total_reads AS bigint) AS total_reads,
+        CAST(ps.total_writes AS bigint) AS total_writes,
+        CAST(ps.total_physical_reads AS bigint) AS total_physical_reads,
+        CAST(ps.total_memory_pages AS bigint) AS total_memory_pages,
+        ps.total_executions,
+        ps.last_execution_time,
+        ROW_NUMBER() OVER (PARTITION BY
+            CASE WHEN q.object_id <> 0
+                 THEN OBJECT_SCHEMA_NAME(q.object_id) + N'.' + OBJECT_NAME(q.object_id)
+                 ELSE N'' END,
+            q.query_hash
+            ORDER BY ps.{metricCol} DESC) AS rn_top,
+        ROW_NUMBER() OVER (PARTITION BY
+            CASE WHEN q.object_id <> 0
+                 THEN OBJECT_SCHEMA_NAME(q.object_id) + N'.' + OBJECT_NAME(q.object_id)
+                 ELSE N'' END,
+            q.query_hash
+            ORDER BY ps.{metricCol} ASC) AS rn_bottom
+    FROM #plan_stats ps
+    JOIN sys.query_store_plan p ON ps.plan_id = p.plan_id
+    JOIN sys.query_store_query q ON p.query_id = q.query_id
+    WHERE EXISTS (SELECT 1 FROM #qhash_rows qhr
+                  WHERE qhr.module_name = CASE WHEN q.object_id <> 0
+                       THEN OBJECT_SCHEMA_NAME(q.object_id) + N'.' + OBJECT_NAME(q.object_id)
+                       ELSE N'' END
+                    AND qhr.query_hash = CONVERT(varchar(18), q.query_hash, 1))
+)
+SELECT *
+into #ranked_light
+FROM ranked
+WHERE rn_top = 1 OR rn_bottom = 1;
+
+/* Final select: join heavy elements (query_text, plan_xml) only for the top/bottom representatives */
+SELECT 
+    r.module_name, 
+    r.query_hash, 
+    r.plan_hash, 
+    r.query_id, 
+    r.plan_id, 
+    qt.query_sql_text, 
+    TRY_CONVERT(nvarchar(max), p.query_plan) AS plan_xml,
+    r.total_cpu_us, 
+    r.total_duration_us, 
+    r.total_reads, 
+    r.total_writes,
+    r.total_physical_reads, 
+    r.total_memory_pages, 
+    r.total_executions, 
+    r.last_execution_time,
+    CASE WHEN r.rn_top = 1 THEN 1 ELSE 0 END AS is_top
+FROM #ranked_light r
+JOIN sys.query_store_query_text qt ON r.query_text_id = qt.query_text_id
+JOIN sys.query_store_plan p ON r.plan_id = p.plan_id;
+
+/* Return intermediate rows (result set 2) */
+SELECT * FROM #qhash_rows ORDER BY module_name, total_executions DESC;
+";
+
+        var result = new QueryStoreGroupedResult();
+        await using var conn = new SqlConnection(connectionString);
+        await conn.OpenAsync(ct);
+        await using var cmd = new SqlCommand(sql, conn) { CommandTimeout = 120 };
+        foreach (var p in parameters) cmd.Parameters.Add(p);
+        await using var reader = await cmd.ExecuteReaderAsync(ct);
+
+        // Result set 1: Leaf rows (top/bottom per module/query_hash)
+        while (await reader.ReadAsync(ct))
+        {
+            result.LeafRows.Add(new QueryStoreGroupedPlanRow
+            {
+                ModuleName = reader.IsDBNull(0) ? "" : reader.GetString(0),
+                QueryHash = reader.IsDBNull(1) ? "" : reader.GetString(1),
+                QueryPlanHash = reader.IsDBNull(2) ? "" : reader.GetString(2),
+                QueryId = reader.GetInt64(3),
+                PlanId = reader.GetInt64(4),
+                QueryText = reader.IsDBNull(5) ? "" : reader.GetString(5),
+                PlanXml = reader.IsDBNull(6) ? "" : reader.GetString(6),
+                TotalCpuTimeUs = reader.GetInt64(7),
+                TotalDurationUs = reader.GetInt64(8),
+                TotalLogicalIoReads = reader.GetInt64(9),
+                TotalLogicalIoWrites = reader.GetInt64(10),
+                TotalPhysicalIoReads = reader.GetInt64(11),
+                TotalMemoryGrantPages = reader.GetInt64(12),
+                CountExecutions = reader.GetInt64(13),
+                LastExecutedUtc = ((DateTimeOffset)reader.GetValue(14)).UtcDateTime,
+                IsTopRepresentative = reader.GetInt32(15) == 1,
+            });
+        }
+
+        // Result set 2: Intermediate rows (query_hash level aggregated under module)
+        if (await reader.NextResultAsync(ct))
+        {
+            while (await reader.ReadAsync(ct))
+            {
+                result.IntermediateRows.Add(new QueryStoreGroupedPlanRow
+                {
+                    ModuleName = reader.IsDBNull(0) ? "" : reader.GetString(0),
+                    QueryHash = reader.IsDBNull(1) ? "" : reader.GetString(1),
+                    TotalCpuTimeUs = reader.GetInt64(2),
+                    TotalDurationUs = reader.GetInt64(3),
+                    TotalLogicalIoReads = reader.GetInt64(4),
+                    TotalLogicalIoWrites = reader.GetInt64(5),
+                    TotalPhysicalIoReads = reader.GetInt64(6),
+                    TotalMemoryGrantPages = reader.GetInt64(7),
+                    CountExecutions = reader.GetInt64(8),
+                    LastExecutedUtc = ((DateTimeOffset)reader.GetValue(9)).UtcDateTime,
+                });
+            }
+        }
+
+        return result;
+    }
+
     /// <summary>
     /// Builds a WaitProfile from raw category totals.
     /// Top 3 categories are kept; everything else is consolidated into "Others".
diff --git a/src/PlanViewer.Web/wwwroot/index.html b/src/PlanViewer.Web/wwwroot/index.html
index 40749b9..cc5472d 100644
--- a/src/PlanViewer.Web/wwwroot/index.html
+++ b/src/PlanViewer.Web/wwwroot/index.html
@@ -32,6 +32,20 @@
     </div>
 
     <script src="_framework/blazor.webassembly.js"></script>
+    <script>
+        // Lightweight analytics — pings PlanShare server, no cookies, no PII
+        (function() {
+            var r = document.referrer || '';
+            // Skip self-referrals
+            if (r && new URL(r).host === location.host) r = '';
+            fetch('https://stats.erikdarling.com/api/event', {
+                method: 'POST',
+                headers: {'Content-Type': 'application/json'},
+                body: JSON.stringify({path: location.pathname + location.search, referrer: r}),
+                keepalive: true
+            }).catch(function(){});
+        })();
+    </script>
     <script>
         function downloadFile(fileName, content) {
             const blob = new Blob([content], { type: 'text/html;charset=utf-8' });