Resolve score scales from producer-stamped registry bounds

New snapshots stamp every comparison-index metric entry with
canonical_min_score / canonical_max_score — the effective metric's
registry bounds, i.e. the scale score_canonical sits on. Scale
resolution now consults them, with precedence:

1. mul100 seen => percent registry
2. div100 seen => fraction registry
3. registry bounds when usable (min 0 / max 100 => percent;
max <= 1.5 => fraction; anything else unusable)
4. the existing 'none'-cell unit vote, keeping both guards
(unit conflict => null, anchor required => null)

Bounds let two previously-guessed group shapes resolve exactly:
- all-'curated' groups (anchor-neutral tags, e.g. WildBench's 1-10
points folded onto [0,1] wb-score): a model whose only appearance
is the curated source now shows ~46% instead of the legacy "4.6%";
- unit-conflicted all-'none' groups (terminalbench-hard's lying
"percent" unit): now exact 11.0% instead of the legacy fallback.

The old-snapshot and no_bounds guards are unchanged. The display-axis
census now reads 'none' cells' source units and skips scale-neutral
'curated' cells (ties still break percent-ward). canonicalCellIsPercent
takes the same optional bounds for the sibling-whisker path; group call
sites (overlaps, histogram builder, signals strip) pass the metric
entry's bounds, merged across sibling metrics with conflicts treated
as unusable.

Verified against warehouse/2026-08-16T19-43-10Z through the real
buildOverlapRows path: openai/gpt-5.4 wildbench 45.97 -> "46.0%",
DeepSeek-R1 terminalbench-hard -> "11.0%".

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

components/benchmark-detail.tsx

@@ -2994,6 +2994,9 @@ export function BenchmarkDetail({
         const currentCell = currentRow ?? byModelRow
         const scaleGroup = resolveCanonicalScaleGroup(
           [...(currentCell ? [currentCell] : []), ...peerRows].map(scaleCellOf),
+          // Metric-level registry bounds (the scale score_canonical sits
+          // on): resolve anchor-neutral (all-curated) groups exactly.
+          { min: metric.canonical_min_score, max: metric.canonical_max_score },
         )
         const resolvedIsPercent = scaleGroup
           ? scaleGroup.percentSourceCount >= scaleGroup.fractionSourceCount
@@ -3949,7 +3952,12 @@ export function BenchmarkDetail({
         // Flagged or old-snapshot sibling cells keep the legacy heuristic
         // for that row.
         const siblingCellScale =
-          activeHist.resolvedIsPercent != null ? canonicalCellIsPercent(siblingCell) : null
+          activeHist.resolvedIsPercent != null
+            ? canonicalCellIsPercent(siblingCell, {
+                min: siblingMetric.canonical_min_score,
+                max: siblingMetric.canonical_max_score,
+              })
+            : null
         const reconciledScore =
           siblingCellScale != null && siblingCell.scoreCanonical != null
             ? scaleOnto(siblingCell.scoreCanonical, siblingCellScale, histIsPercent)

components/signals/benchmark-signals-strip.tsx

@@ -11,7 +11,11 @@ import type {
 } from "@/lib/backend-artifacts"
 import type { BenchmarkEvalSummary } from "@/lib/eval-processing"
 import type { ModelResultForBenchmark } from "@/lib/eval-processing"
-import { resolveCanonicalScaleGroup, type CanonicalScaleCell } from "@/lib/score-scale"
+import {
+  mergeRegistryBounds,
+  resolveCanonicalScaleGroup,
+  type CanonicalScaleCell,
+} from "@/lib/score-scale"
 
 type SignalId = "reproducibility" | "completeness" | "provenance" | "comparability"
 
@@ -779,7 +783,18 @@ function buildCrossSuiteAggregate(
       }
     }
   }
-  const scaleGroup = resolveCanonicalScaleGroup(scaleCells)
+  const scaleGroup = resolveCanonicalScaleGroup(
+    scaleCells,
+    // Registry bounds shared by the sibling metric entries — resolve
+    // anchor-neutral / unit-conflicted groups exactly (conflicting bounds
+    // merge to undefined and keep the fallback).
+    mergeRegistryBounds(
+      Array.from(metricByEval.values(), (m) => ({
+        min: m.canonical_min_score,
+        max: m.canonical_max_score,
+      })),
+    ),
+  )
   // Same display convention as the legacy guess (any percent-scale source
   // pulls the whole table onto the 0-100 axis), read off the producer
   // fields when available.

lib/backend-artifacts.ts

@@ -487,6 +487,11 @@ export interface ComparisonMetricEntry {
   group_order: number
   lower_is_better: boolean
   unit: string | null
+  /** Registry bounds of the EFFECTIVE metric — the scale `score_canonical`
+   *  sits on (e.g. [0,1] for a fold target like wb-score). Null when the
+   *  registry declares no bounds; absent on snapshots predating the stamp. */
+  canonical_min_score?: number | null
+  canonical_max_score?: number | null
   scores: ComparisonScoreEntry[]
 }
 

lib/overlaps.ts

@@ -22,6 +22,7 @@ import type {
 } from "./backend-artifacts"
 import {
   isPercentUnit,
+  mergeRegistryBounds,
   resolveCanonicalScaleGroup,
   type CanonicalScaleCell,
 } from "./score-scale"
@@ -47,6 +48,10 @@ export interface OverlapAppearance {
    *  (spec F5); undefined on old snapshots and summary-sourced appearances. */
   scoreCanonical?: number | null
   scaleConversion?: ScaleConversion | null
+  /** Registry bounds off the owning metric entry (the scale
+   *  `scoreCanonical` sits on); undefined pre-stamp / summary-sourced. */
+  canonicalMinScore?: number | null
+  canonicalMaxScore?: number | null
 }
 
 export interface OverlapRow {
@@ -257,6 +262,8 @@ export function buildOverlapRows(input: BuildOverlapRowsInput): OverlapRow[] {
               sourceKind: "comparison-index",
               scoreCanonical: cellInfo.scoreCanonical,
               scaleConversion: cellInfo.scaleConversion,
+              canonicalMinScore: targetMetric.canonical_min_score,
+              canonicalMaxScore: targetMetric.canonical_max_score,
             })
           }
         }
@@ -312,7 +319,16 @@ export function buildOverlapRows(input: BuildOverlapRowsInput): OverlapRow[] {
         scaleConversion: c.scaleConversion,
         unit: c.unit,
       })
-      const scaleGroup = resolveCanonicalScaleGroup(collected.map(scaleCellOf))
+      // Registry bounds shared by the appearances' metric entries (spec:
+      // producer-stamped `canonical_min_score` / `canonical_max_score`) —
+      // they let anchor-neutral groups (all-curated) and unit-conflicted
+      // groups resolve exactly; conflicting bounds merge to undefined.
+      const scaleGroup = resolveCanonicalScaleGroup(
+        collected.map(scaleCellOf),
+        mergeRegistryBounds(
+          collected.map((c) => ({ min: c.canonicalMinScore, max: c.canonicalMaxScore })),
+        ),
+      )
       let scaled: OverlapAppearance[]
       let useHigh: boolean
       if (scaleGroup) {

lib/score-scale.ts

@@ -9,14 +9,19 @@
 //   `scale_conversion` — how `score` maps onto `score_canonical`.
 // Old snapshots lack both keys entirely.
 //
+// Newer snapshots additionally stamp every comparison-index METRIC entry
+// with `canonical_min_score` / `canonical_max_score` — the effective
+// metric's registry bounds, i.e. the scale `score_canonical` sits on.
+//
 // `resolveCanonicalScaleGroup` decides whether a set of cells that a view
 // needs on ONE common scale can be settled exactly from those fields. When
 // it can, callers use the producer values and skip the legacy
 // `|score| > 1.5 ⇒ percent` guess; when it can't — any cell missing the
 // keys (old snapshot, or a mixed old/new group which must never be
 // half-converted), a bounds-less metric (canonical === raw guarantees
-// nothing about scale consistency), an all-flagged group, or contradictory
-// conversions — callers keep the legacy heuristic byte-for-byte.
+// nothing about scale consistency), an all-flagged group with no usable
+// registry bounds, or contradictory conversions — callers keep the legacy
+// heuristic byte-for-byte.
 //
 // NOTE: the comparison-index metric `unit` is source-reported, not the
 // registry's — a div100 metric can say "percent" while its canonical
@@ -42,6 +47,45 @@ export function isPercentUnit(unit: string | null | undefined): boolean {
   return /percent|%|pct/.test((unit ?? "").toLowerCase())
 }
 
+/** The effective metric's registry bounds off a comparison-index metric
+ *  entry (`canonical_min_score` / `canonical_max_score`); fields are
+ *  undefined on snapshots predating the stamp, null when the registry
+ *  declares no bounds. */
+export interface RegistryBounds {
+  min?: number | null
+  max?: number | null
+}
+
+/** Scale the registry bounds pin down: true ⇒ percent ([0,100]), false ⇒
+ *  fraction (max ≤ 1.5), null ⇒ absent or not usable (open-ended scales
+ *  like Elo, unusual ranges). */
+export function registryBoundsIsPercent(
+  bounds: RegistryBounds | null | undefined,
+): boolean | null {
+  if (!bounds) return null
+  if (bounds.min === 0 && bounds.max === 100) return true
+  if (bounds.max != null && bounds.max <= 1.5) return false
+  return null
+}
+
+/** Merge the per-metric registry bounds behind a cross-metric cell group:
+ *  the shared bounds when every stamped metric agrees, undefined when they
+ *  conflict (sibling metrics on different registry scales must not share
+ *  one anchor) or when no metric carries the stamp. */
+export function mergeRegistryBounds(
+  boundsList: Iterable<RegistryBounds | null | undefined>,
+): RegistryBounds | undefined {
+  let merged: { min: number | null; max: number | null } | undefined
+  for (const b of boundsList) {
+    if (!b || (b.min === undefined && b.max === undefined)) continue // pre-stamp metric
+    const min = b.min ?? null
+    const max = b.max ?? null
+    if (!merged) merged = { min, max }
+    else if (merged.min !== min || merged.max !== max) return undefined
+  }
+  return merged
+}
+
 /** Legacy per-row scale guess (`|raw| > 1.5 ⇒ percent`), mapped onto the
  *  requested display scale. Kept for old snapshots and flagged rows. */
 export function heuristicToScale(raw: number, toPercent: boolean): number {
@@ -62,7 +106,10 @@ export function scaleOnto(value: number, fromPercent: boolean, toPercent: boolea
  *  group prefer the group's `registryIsPercent` — a 'none' cell's
  *  source-reported unit can misstate the metric scale that its converted
  *  siblings pin down exactly. */
-export function canonicalCellIsPercent(cell: CanonicalScaleCell): boolean | null {
+export function canonicalCellIsPercent(
+  cell: CanonicalScaleCell,
+  registryBounds?: RegistryBounds | null,
+): boolean | null {
   if (cell.scoreCanonical == null) return null
   switch (cell.scaleConversion) {
     case "div100":
@@ -70,7 +117,15 @@ export function canonicalCellIsPercent(cell: CanonicalScaleCell): boolean | null
     case "mul100":
       return true // raw fraction × 100 ⇒ the registry scale is the percent
     case "none":
-      return isPercentUnit(cell.unit) // raw already sits on the registry scale
+    case "curated": {
+      // The producer-stamped registry bounds settle the canonical scale
+      // exactly when usable. Otherwise 'none' falls back to the
+      // source-reported unit (raw already sits on the registry scale) and
+      // 'curated' stays underivable — the tag alone can't anchor.
+      const fromBounds = registryBoundsIsPercent(registryBounds)
+      if (fromBounds != null) return fromBounds
+      return cell.scaleConversion === "none" ? isPercentUnit(cell.unit) : null
+    }
     default:
       return null // 'no_bounds', 'flagged', unexpected tokens
   }
@@ -91,6 +146,7 @@ export interface CanonicalScaleGroup {
 
 export function resolveCanonicalScaleGroup(
   cells: readonly CanonicalScaleCell[],
+  registryBounds?: RegistryBounds | null,
 ): CanonicalScaleGroup | null {
   if (cells.length === 0) return null
   let sawDiv100 = false
@@ -115,23 +171,38 @@ export function resolveCanonicalScaleGroup(
       else noneFractionUnit = true
     } else return null // unknown conversion token — don't guess
   }
-  // Need at least one convertible cell to anchor the scale, and the
-  // conversions must not contradict each other.
-  if (!sawDiv100 && !sawMul100 && noneCount === 0) return null
-  if (sawDiv100 && sawMul100) return null
-  // When no conversion anchors the scale and the 'none' cells' source
-  // units DISAGREE about percent-ness, the units are lying about at
-  // least one cell (they're source-reported, not registry data) — a lone
-  // mislabeled "percent" must not flip the whole group 100x. Stay legacy.
-  if (!sawDiv100 && !sawMul100 && nonePercentUnit && noneFractionUnit) return null
-  const registryIsPercent = sawMul100 || (!sawDiv100 && nonePercentUnit)
+  if (sawDiv100 && sawMul100) return null // contradictory conversions
+  // Scale precedence: a conversion pins the registry scale exactly; next
+  // the metric's stamped registry bounds; last the 'none' cells' unit
+  // vote. Bounds let anchor-neutral groups (all-curated, all-flagged) and
+  // unit-conflicted groups resolve exactly instead of falling back.
+  let registryIsPercent: boolean
+  if (sawMul100) registryIsPercent = true
+  else if (sawDiv100) registryIsPercent = false
+  else {
+    const boundsScale = registryBoundsIsPercent(registryBounds)
+    if (boundsScale != null) registryIsPercent = boundsScale
+    else {
+      // Need at least one 'none' cell to anchor the unit vote…
+      if (noneCount === 0) return null
+      // …and when the 'none' cells' source units DISAGREE about
+      // percent-ness, the units are lying about at least one cell
+      // (they're source-reported, not registry data) — a lone mislabeled
+      // "percent" must not flip the whole group 100x. Stay legacy.
+      if (nonePercentUnit && noneFractionUnit) return null
+      registryIsPercent = nonePercentUnit
+    }
+  }
   let percentSourceCount = 0
   let fractionSourceCount = 0
   for (const c of cells) {
     if (c.scoreCanonical == null) continue
+    // 'curated' sources sit on neither scale (e.g. 1-10 points) — they
+    // don't vote; ties break percent-ward at the call sites.
+    if (c.scaleConversion === "curated") continue
     if (c.scaleConversion === "div100") percentSourceCount += 1
     else if (c.scaleConversion === "mul100") fractionSourceCount += 1
-    else if (registryIsPercent) percentSourceCount += 1
+    else if (isPercentUnit(c.unit)) percentSourceCount += 1
     else fractionSourceCount += 1
   }
   return {

tests/overlaps.test.ts

@@ -322,6 +322,96 @@ describe("buildOverlapRows: producer canonical scale (spec F5)", () => {
     expect(rows[0].appearances.map((a) => a.displayScore)).toEqual(["11.0%", "0.0%"])
   })
 
+  it("resolves an all-curated group from producer registry bounds", () => {
+    // WildBench shape: raw 1-10 'points' scores curated onto a [0,1]
+    // registry metric. The 'curated' tag alone can't anchor
+    // fraction-vs-percent, but the metric-level registry bounds can — a
+    // model whose only appearance is the curated source now shows ~46%
+    // (matching the merged page) instead of the legacy magnitude guess
+    // reading raw 4.597 as "4.6%".
+    const rows = build({
+      benchmarkIndex: [MMLU_INDEX],
+      comparisonIndex: comparisonIndexOf({
+        "fam-a%2Fmmlu": evalEntry("fam-a%2Fmmlu", [
+          metricEntry({
+            unit: "points",
+            canonical_min_score: 0,
+            canonical_max_score: 1,
+            scores: [ownRow(4.597, { score_canonical: 0.4597, scale_conversion: "curated" })],
+          }),
+        ]),
+        "fam-b%2Fmmlu": evalEntry("fam-b%2Fmmlu", [metricEntry({ scores: [] })]),
+      }),
+    })
+    expect(rows).toHaveLength(1)
+    expect(rows[0].appearances[0].score).toBeCloseTo(45.97, 10)
+    expect(rows[0].appearances[0].displayScore).toBe("46.0%")
+    expect(rows[0].isPercentScale).toBe(true)
+  })
+
+  it("resolves a unit-conflicted group exactly when registry bounds are stamped", () => {
+    // Same terminalbench-hard shape as the legacy-fallback test above,
+    // but with the [0,1] registry bounds stamped on both metric entries:
+    // the group resolves as fraction-registry and both canonicals map
+    // exactly onto the percent display axis — no guessing.
+    const rows = build({
+      benchmarkIndex: [MMLU_INDEX],
+      comparisonIndex: comparisonIndexOf({
+        "fam-a%2Fmmlu": evalEntry("fam-a%2Fmmlu", [
+          metricEntry({
+            unit: "proportion",
+            canonical_min_score: 0,
+            canonical_max_score: 1,
+            scores: [ownRow(0.11, { score_canonical: 0.11, scale_conversion: "none" })],
+          }),
+        ]),
+        "fam-b%2Fmmlu": evalEntry("fam-b%2Fmmlu", [
+          metricEntry({
+            unit: "percent",
+            canonical_min_score: 0,
+            canonical_max_score: 1,
+            scores: [ownRow(0.0, { score_canonical: 0.0, scale_conversion: "none" })],
+          }),
+        ]),
+      }),
+    })
+    expect(rows[0].appearances[0].score).toBeCloseTo(11, 10)
+    expect(rows[0].appearances[1].score).toBeCloseTo(0, 10)
+    expect(rows[0].appearances.map((a) => a.displayScore)).toEqual(["11.0%", "0.0%"])
+    expect(rows[0].isPercentScale).toBe(true)
+  })
+
+  it("resolves a percent-registry metric from [0,100] bounds without double-scaling", () => {
+    // Bounds [0,100] pin the percent registry even though one cell's unit
+    // is missing (the unit conflict would otherwise force the legacy
+    // fallback). Canonical values already sit on the percent scale — they
+    // must pass through unscaled, not get multiplied or divided again.
+    const rows = build({
+      benchmarkIndex: [MMLU_INDEX],
+      comparisonIndex: comparisonIndexOf({
+        "fam-a%2Fmmlu": evalEntry("fam-a%2Fmmlu", [
+          metricEntry({
+            unit: "percent",
+            canonical_min_score: 0,
+            canonical_max_score: 100,
+            scores: [ownRow(65, { score_canonical: 65, scale_conversion: "none" })],
+          }),
+        ]),
+        "fam-b%2Fmmlu": evalEntry("fam-b%2Fmmlu", [
+          metricEntry({
+            unit: null,
+            canonical_min_score: 0,
+            canonical_max_score: 100,
+            scores: [ownRow(60, { score_canonical: 60, scale_conversion: "none" })],
+          }),
+        ]),
+      }),
+    })
+    expect(rows[0].appearances.map((a) => a.score)).toEqual([65, 60])
+    expect(rows[0].appearances.map((a) => a.displayScore)).toEqual(["65.0%", "60.0%"])
+    expect(rows[0].isPercentScale).toBe(true)
+  })
+
   it("reads the canonical fields off by_model cells too", () => {
     const rows = build({
       benchmarkIndex: [MMLU_INDEX],