Fix validated evaluator displays

app/evals/page.tsx

@@ -66,6 +66,12 @@ function EvalsPageInner() {
   )
   const [evaluatorSortCol, setEvaluatorSortCol] = useState<EvaluatorTableSortCol>("evals")
   const [evaluatorSortDir, setEvaluatorSortDir] = useState<"asc" | "desc">("desc")
+  // In verified-only mode the Verified column is hidden (it equals
+  // Evaluations reported), so a stale "verified" sort would otherwise sit
+  // active on a column the user can no longer see or toggle. Clamp it to
+  // "evals" — same ordering, but on a visible, interactive header.
+  const effectiveEvaluatorSortCol: EvaluatorTableSortCol =
+    verifiedOnly && evaluatorSortCol === "verified" ? "evals" : evaluatorSortCol
   const deferredSearchQuery = useDeferredValue(searchQuery)
 
   const handleEvaluatorSort = useCallback((col: EvaluatorTableSortCol) => {
@@ -178,13 +184,13 @@ function EvalsPageInner() {
     const dirMul = evaluatorSortDir === "asc" ? 1 : -1
     return list.slice().sort((a, b) => {
       let cmp = 0
-      if (evaluatorSortCol === "name") cmp = a.name.localeCompare(b.name)
-      else if (evaluatorSortCol === "verified") cmp = a.verifiedCount - b.verifiedCount
+      if (effectiveEvaluatorSortCol === "name") cmp = a.name.localeCompare(b.name)
+      else if (effectiveEvaluatorSortCol === "verified") cmp = a.verifiedCount - b.verifiedCount
       else cmp = a.evalCount - b.evalCount
       if (cmp === 0) cmp = a.name.localeCompare(b.name)
       return cmp * dirMul
     })
-  }, [evaluatorGroups, deferredSearchQuery, evaluatorSortCol, evaluatorSortDir])
+  }, [evaluatorGroups, deferredSearchQuery, effectiveEvaluatorSortCol, evaluatorSortDir])
 
   const families = hierarchy?.families ?? []
 
@@ -502,7 +508,7 @@ function EvalsPageInner() {
         ) : groupBy === "evaluator" ? (
           <EvaluatorTable
             rows={visibleEvaluators}
-            sortCol={evaluatorSortCol}
+            sortCol={effectiveEvaluatorSortCol}
             sortDir={evaluatorSortDir}
             onSort={handleEvaluatorSort}
             verifiedOnly={verifiedOnly}

components/evaluator-table.tsx

@@ -67,7 +67,11 @@ export function EvaluatorTable({ rows, sortCol, sortDir, onSort, verifiedOnly }:
           <tr>
             <SortTh col="name" style={{ width: "55%" }}>Evaluator</SortTh>
             <SortTh col="evals" className="num">Evaluations reported</SortTh>
-            <SortTh col="verified" className="num">Verified</SortTh>
+            {/* In verified-only mode every (eval, org) membership is already
+                verified, so verifiedCount === evalCount for every row — the
+                two columns are identical. Drop the redundant Verified column
+                there and keep it only when the counts can differ. */}
+            {!verifiedOnly && <SortTh col="verified" className="num">Verified</SortTh>}
             <th style={{ width: 90 }} />
           </tr>
         </thead>
@@ -85,18 +89,27 @@ export function EvaluatorTable({ rows, sortCol, sortDir, onSort, verifiedOnly }:
                 </Link>
               </td>
               <td className="num font-mono text-[13px]">
-                {row.evalCount.toLocaleString()}
-              </td>
-              <td className="num font-mono text-[13px]">
-                {row.verifiedCount > 0 ? (
+                {verifiedOnly ? (
                   <span className="inline-flex items-center gap-1 text-[color:var(--accent)]">
-                    {row.verifiedCount.toLocaleString()}
+                    {row.evalCount.toLocaleString()}
                     <VerifiedBadge verified size="sm" withTooltip={false} />
                   </span>
                 ) : (
-                  <span className="text-[color:var(--fg-subtle)]">—</span>
+                  row.evalCount.toLocaleString()
                 )}
               </td>
+              {!verifiedOnly && (
+                <td className="num font-mono text-[13px]">
+                  {row.verifiedCount > 0 ? (
+                    <span className="inline-flex items-center gap-1 text-[color:var(--accent)]">
+                      {row.verifiedCount.toLocaleString()}
+                      <VerifiedBadge verified size="sm" withTooltip={false} />
+                    </span>
+                  ) : (
+                    <span className="text-[color:var(--fg-subtle)]">—</span>
+                  )}
+                </td>
+              )}
               <td>
                 <Link
                   href={hrefFor(row.slug)}

lib/clean-hierarchy.ts

@@ -214,6 +214,7 @@ export function cleanHierarchy(
   collapseValsAiSetupVariants(h)
   dedupValsAiAliasedBenches(h)
   flattenSplitFamilies(h)
+  dropGroupingLeaderboardRollups(h)
   if (comparisonIndex) {
     dedupAggregatorBenchesByScore(h, comparisonIndex)
   }
@@ -1556,6 +1557,67 @@ function flattenSplitFamilies(h: CleanableHierarchy) {
   }
 }
 
+/**
+ * Drop a grouping's own aggregate "leaderboard" rollup benchmark.
+ *
+ * Some sources ship, inside a composite (or a multi-benchmark family), an
+ * extra benchmark that is just the aggregate score for the whole group —
+ * e.g. HELM's `helm-safety` composite ("HELM Safety") carries a
+ * `helm-safety-leaderboard` benchmark ("HELM-Safety-Leaderboard") that is
+ * the composite's own rollup. Listing it as a sibling benchmark makes the
+ * grouping show up as BOTH a family/group AND a benchmark — a semantic
+ * duplicate ("HELM Safety" is only a family, not a benchmark). We strip the
+ * rollup leaf so the group is only ever a group; the real member benchmarks
+ * (BBQ, HarmBench, …) stay.
+ *
+ * Detection is deliberately narrow: a leaf qualifies only when its key is
+ * the parent grouping's key plus a `-leaderboard` suffix
+ * (`${parentKey}-leaderboard`). That suffix is an unambiguous rollup signal
+ * — it catches all six HELM composites without touching real sibling
+ * benchmarks whose slug merely coincides with the family (e.g.
+ * `reward-bench`'s genuine `rewardbench` benchmark sitting beside
+ * RewardBench 2 / Safety / Reasoning). We only strip within groups that
+ * keep at least one other benchmark, so single-benchmark families — where
+ * the lone bench legitimately IS the family — are never touched.
+ *
+ * We drop only the benchmark leaf, NOT the rollup's eval ids from
+ * `family.constituent_evaluation_ids`. Those ids stay so the rollup eval row
+ * still resolves to its family/composite in the hierarchy lookup (it just
+ * no longer carries a benchmark-leaf label) — the row is an aggregate, not
+ * a distinct benchmark, which is exactly the outcome we want.
+ */
+function dropGroupingLeaderboardRollups(h: CleanableHierarchy) {
+  const slug = (s: string) => (s ?? "").toLowerCase().replace(/[^a-z0-9]+/g, "")
+  const isSelfRollup = (b: HierarchyBenchmark, parentKey: string): boolean =>
+    Boolean(b.key) &&
+    b.key.endsWith("-leaderboard") &&
+    slug(b.key.replace(/-leaderboard$/, "")) === slug(parentKey)
+
+  const strip = (
+    benches: HierarchyBenchmark[],
+    parentKey: string,
+  ): HierarchyBenchmark[] => {
+    if (benches.length < 2) return benches
+    const kept = benches.filter((b) => !isSelfRollup(b, parentKey))
+    // Never empty a group; only apply when something actually dropped.
+    return kept.length > 0 && kept.length < benches.length ? kept : benches
+  }
+
+  for (const fam of h.families ?? []) {
+    // Composites are always groupings — strip their self-rollup leaf.
+    for (const c of fam.composites ?? []) {
+      if (c.benchmarks) c.benchmarks = strip(c.benchmarks, c.key)
+    }
+    // Family-level rollup (a `${family.key}-leaderboard` bench sitting
+    // directly under a multi-benchmark family). None in the current
+    // snapshot, but keep the hierarchy consistent if one appears.
+    if (fam.benchmarks) fam.benchmarks = strip(fam.benchmarks, fam.key)
+    if (fam.standalone_benchmarks) {
+      fam.standalone_benchmarks = strip(fam.standalone_benchmarks, fam.key)
+    }
+  }
+}
+
 export function isHierarchyCleaned(h: EvalHierarchy | null | undefined): boolean {
   return Boolean((h as CleanableHierarchy | null | undefined)?.[CLEANED_MARKER])
 }

tests/clean-hierarchy.test.ts

@@ -457,6 +457,109 @@ describe("cleanHierarchy", () => {
     )
   })
 
+  it("drops a grouping's own *-leaderboard rollup but keeps real members", () => {
+    // HELM's `helm-safety` composite ("HELM Safety", a grouping) ships a
+    // `helm-safety-leaderboard` benchmark that is the composite's own
+    // aggregate — it makes the group show up as both a family and a
+    // benchmark. The rollup leaf is dropped; the real members survive.
+    const raw: EvalHierarchy = {
+      families: [
+        family("helm", "HELM", {
+          composites: [
+            {
+              key: "helm-safety",
+              display_name: "HELM Safety",
+              category: "Safety",
+              tags: { domains: [], languages: [], tasks: [] },
+              benchmarks: [
+                bench("bbq", "BBQ"),
+                bench("harmbench", "HarmBench"),
+                bench("helm-safety-leaderboard", "HELM-Safety-Leaderboard"),
+              ],
+            },
+          ],
+        }),
+      ],
+    }
+
+    const cleaned = cleanHierarchy(raw)
+    const helm = cleaned.families.find((f) => f.key === "helm")!
+    const safety = helm.composites!.find((c) => c.key === "helm-safety")!
+    const keys = (safety.benchmarks ?? []).map((b) => b.key)
+    expect(keys).not.toContain("helm-safety-leaderboard")
+    expect(keys).toEqual(expect.arrayContaining(["bbq", "harmbench"]))
+  })
+
+  it("keeps a real sibling whose slug matches the family but lacks the -leaderboard suffix", () => {
+    // reward-bench's genuine `rewardbench` benchmark slugifies the same as
+    // the `reward-bench` family but is a real member, not a rollup. The
+    // -leaderboard-only rule must leave it (and its siblings) alone.
+    const raw: EvalHierarchy = {
+      families: [
+        family("foo-bench", "Foo Bench", {
+          benchmarks: [bench("foobench", "Foo Bench"), bench("foobench-2", "Foo Bench 2")],
+        }),
+      ],
+    }
+
+    const cleaned = cleanHierarchy(raw)
+    const fam = cleaned.families.find((f) => f.key === "foo-bench")!
+    const keys = [...(fam.benchmarks ?? []), ...(fam.standalone_benchmarks ?? [])].map((b) => b.key)
+    expect(keys).toEqual(expect.arrayContaining(["foobench", "foobench-2"]))
+  })
+
+  it("drops a family-level rollup and preserves its eval ids on the family", () => {
+    const raw: EvalHierarchy = {
+      families: [
+        family("widget-bench", "Widget Bench", {
+          constituent_evaluation_ids: [
+            "widget-bench%2Fwidget-bench-leaderboard",
+            "widget-bench%2Fwidget-a",
+          ],
+          standalone_benchmarks: [
+            bench("widget-bench-leaderboard", "Widget Bench Leaderboard"),
+            bench("widget-a", "Widget A"),
+          ],
+        }),
+      ],
+    }
+
+    const cleaned = cleanHierarchy(raw)
+    const fam = cleaned.families.find((f) => f.key === "widget-bench")!
+    const keys = [...(fam.benchmarks ?? []), ...(fam.standalone_benchmarks ?? [])].map((b) => b.key)
+    // Rollup leaf gone, real member kept.
+    expect(keys).not.toContain("widget-bench-leaderboard")
+    expect(keys).toContain("widget-a")
+    // …but the rollup's eval id stays on the family so it still resolves.
+    expect(fam.constituent_evaluation_ids).toContain(
+      "widget-bench%2Fwidget-bench-leaderboard",
+    )
+  })
+
+  it("never empties a group: a lone *-leaderboard bench is kept", () => {
+    const raw: EvalHierarchy = {
+      families: [
+        family("solo", "Solo", {
+          composites: [
+            {
+              key: "solo-grp",
+              display_name: "Solo Grp",
+              category: "General",
+              tags: { domains: [], languages: [], tasks: [] },
+              benchmarks: [bench("solo-grp-leaderboard", "Solo Grp Leaderboard")],
+            },
+          ],
+        }),
+      ],
+    }
+
+    const cleaned = cleanHierarchy(raw)
+    const grp = cleaned.families
+      .find((f) => f.key === "solo")
+      ?.composites?.find((c) => c.key === "solo-grp")
+    expect(grp?.benchmarks?.map((b) => b.key)).toEqual(["solo-grp-leaderboard"])
+  })
+
   it("is idempotent: re-applying produces identical output", () => {
     const raw: EvalHierarchy = {
       families: [family("aime", "AIME")],