@wendellresearch-ai/benchwarmers 0.6.2 → 0.6.3

package/VERSION

@@ -1 +1 @@
-0.6.2
+0.6.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wendellresearch-ai/benchwarmers",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "description": "Self-hosted panel gateway for LLMs: ask a collection of models at once, keep every answer side by side, rotate explorer models in, and let your verdicts pick the next panel.",
   "mcpName": "io.github.WendellResearch-AI/benchwarmers",
   "license": "MIT",

package/scripts/provider_tags.py

@@ -68,13 +68,29 @@ def get(hub: str, path: str) -> dict:
         return json.load(response)
 
 
+def _host(url: str) -> str:
+    return (url or "").split("//", 1)[-1].split("/", 1)[0].split(":", 1)[0].lower()
+
+
 def connection_names(hub: str) -> list[str]:
-    """One short name per connection index. URLs only — never the keys."""
+    """One short name per connection index. URLs only — never the keys.
+
+    A provider reached both through the hub and on a direct endpoint of its
+    own (Cloudflare: chat through Open WebUI, decisions only direct) is ONE
+    connection: the hub's connection to that host takes the direct endpoint's
+    name, which is what its directly registered models are tagged (main). Any
+    provider, by host; other hubs (CLI Proxy API) are not direct endpoints."""
     urls = get(hub, "/openai/config").get("OPENAI_API_BASE_URLS", [])
+    direct: dict[str, str] = {}
+    for name, entry in endpoints.load().items():
+        if name != hub and not endpoints.hub(name):
+            direct.setdefault(_host(entry.get("base", "")), name)
     names = []
     for url in urls:
-        host = url.split("//", 1)[-1].split("/", 1)[0].split(":", 1)[0]
-        if host.replace(".", "").isdigit():
+        host = _host(url)
+        if host in direct and host not in (endpoints.connections().get("hosts") or {}):
+            names.append(direct[host])
+        elif host.replace(".", "").isdigit():
             # A BARE IP NAMES NOTHING, and guessing from it was worse than
             # useless: a proxy labelled `lan-proxy` is described by where it
             # sits rather than what it is, and Open WebUI does not expose

package/scripts/test_no_owui.py

@@ -236,6 +236,14 @@ def owner(fake: str) -> None:
     assert tags["fast-1"] == "groq" and tags["llm7.codestral"] == "llm7-api" and tags["vendor/x:free"] == "openrouter", tags
     assert "never-read" not in json.dumps(tags)
     assert route.connection_of("fast-1") == "groq" and route.connection_of("x-free") == "openrouter"
+    # A provider also on a direct endpoint of its own is one connection: the hub's takes the endpoint's name.
+    real_load, both = endpoints.load, dict(endpoints.load())
+    both["groq-direct"] = {"base": "https://api.groq.com/openai/v1", "key": "groq-direct"}
+    endpoints.load = lambda *a, **k: both
+    try:
+        assert provider_tags.connection_names("openwebui") == ["groq-direct", "llm7-api"]
+    finally:
+        endpoints.load = real_load
     # A decision model onboarded from the direct endpoint: in no registration, untagged, its `via` is its connection.
     write("decision-models.json", {"dec-1": {"served": "vendor/decide:free", "endpoint": "openrouter", "via": "openrouter"},
                                    "dec-hub": {"served": "hub-decide", "endpoint": "openwebui", "via": "openwebui"}})

package/serve.py

@@ -39,6 +39,7 @@ import datetime
 import functools
 import html
 import json
+import math
 import os
 import pathlib
 import re
@@ -2639,7 +2640,7 @@ def charts_data() -> dict:
                          "rate": int(hit[1]) / max(1, int(hit[2])) if hit else None, "invented": bool(v["invented"])})
     bars = [{"model": m, "kind": k, "rate": w / r["answers"], "n": f"{w}/{n}"}
             for m, r in sorted(wr.items()) if m in live and r["answers"] for k, (w, n) in r["by"].items() if w]
-    totals = {m: {"rate": r["wrong"] / r["answers"], "answers": r["answers"]}
+    totals = {m: {"rate": r["wrong"] / r["answers"], "answers": r["answers"], "wrong": r["wrong"]}
               for m, r in wr.items() if m in live and r["answers"]}
     hunt = [{"model": m, **r["hunt"]} for m, r in sorted(wr.items()) if m in live and any(r["hunt"].values())]
     return {"overview": overview, "heat": heat, "families": ["hand-built", "claims", "seeded, function",
@@ -2900,16 +2901,10 @@ def vision_card() -> str:
 
 
 def perf_charts() -> dict:
-    """Reliability over the last 14 days of probes, and speed on real tasks
-    against how much a model finds, for the Performance panel of Benchmarks."""
+    """Speed on real tasks against how much a model finds, for the Performance
+    panel of Benchmarks. (Whether probes answered is Uptime's.)"""
     import route
     live = on_bench()
-    since = (datetime.date.today() - datetime.timedelta(days=14)).isoformat()
-    outcomes: dict[tuple[str, str], int] = {}
-    for r in perf_rows():
-        if r["model"] in live and r.get("timestamp", "") >= since:
-            o = "answered" if int(r.get("answered") or 0) > 0 else (r.get("failure") or "error")
-            outcomes[(r["model"], o)] = outcomes.get((r["model"], o), 0) + 1
     seconds: dict[str, list[float]] = {}
     for (_task, m), v in suite_scores().items():
         if m in live and re.match(r"\d+/\d+", v["found"]):
@@ -2917,8 +2912,7 @@ def perf_charts() -> dict:
     recall = route.suite_recall()
     speed = [{"model": m, "seconds": sorted(s)[len(s) // 2], "recall": recall[m][0] / recall[m][1], "tasks": len(s)}
              for m, s in sorted(seconds.items()) if recall.get(m) and recall[m][1]]
-    return {"reliability": [{"model": m, "outcome": o, "count": n} for (m, o), n in sorted(outcomes.items())],
-            "speed": speed}
+    return {"speed": speed}
 
 
 # ---- Trend: does a model score lower, or higher, than it used to? ----------
@@ -3545,9 +3539,15 @@ DECIDE_KIND = {"errors": "choice of 6", "collection": "choice of the collections
 def decision_data() -> dict:
     """For bench.js: each model's calibration bins per set, [said, right, n]."""
     res = decide.results()
-    return {"sets": [[s, DECIDE_SETS[s]] for s in decide.SETS],
+    models = sorted((res.get("models") or {}).items())
+    return {"sets": [[s, DECIDE_SETS[s]] for s in decide.SETS], "low": decide.MIN_ITEMS,
+            # Right of asked per model and set: the bars, as the tables count it.
+            "scores": [{"model": a, "set": s, "correct": r.get("correct", 0), "asked": r["asked"],
+                        "answered": r.get("answered", 0), "brier": r.get("brier")}
+                       for a, by in models for s, r in by.items()
+                       if s in decide.SETS and isinstance(r, dict) and r.get("asked")],
             "points": [{"model": a, "set": s, "said": b["said"], "right": b["right"], "n": b["n"]}
-                       for a, by in sorted((res.get("models") or {}).items()) for s, r in by.items()
+                       for a, by in models for s, r in by.items()
                        if s in decide.SETS for b in r.get("calibration") or []]}
 
 
@@ -3614,8 +3614,7 @@ def decision_card() -> str:
     extra = (f"<h3 class='chart-head'>Who each use asks now</h3><ul class='links'>{''.join(uses)}</ul>"
              f"<p class='hint'>{'Measured up to ' + esc(when[:16].replace('T', ' ')) + '.' if when else 'Not measured yet.'}"
              " The scheduler's <code>decisions</code> job asks each model one question a set a day;"
-             " <code>python metrics/decide.py bench</code> runs a pass by hand.</p>"
-             "<h3 class='chart-head'>Calibration: said against right</h3>")
+             " <code>python metrics/decide.py bench</code> runs a pass by hand.</p>")
     key = f"""<dl>
       <dt>The sets</dt><dd>Questions with known answers, built from the bench's own data, no hand labelling.
         <b>Error classes</b>: failed calls' error text (redacted: no keys, ids or emails) and the class the
@@ -3627,8 +3626,12 @@ def decision_card() -> str:
         picked, so always saying the commonest option scores low.</dd>
       <dt>Brier</dt><dd>How far its probabilities sat from the truth: 0 is perfect; for a choice it is
         summed over the options, so up to 2. Lower is better, and a sure wrong answer costs most.</dd>
-      <dt>Calibration</dt><dd>The chart: answers grouped by the probability the model gave its answer
-        (x), against how often those answers were right (y). On the diagonal, its 80% answers come true
+      <dt>The bars</dt><dd>Right of asked for each model on each set, from 0%. A faint bar is a model
+        under {low} items on that set: shown, not ranked yet. Hover a bar for its Brier.</dd>
+      <dt>Calibration</dt><dd>The second chart, once a model answers at two or more levels of sureness
+        on a set: answers grouped by the probability the model gave its answer
+        (x), against how often those answers were right (y); both axes start just under the lowest
+        answer, not at 0%. On the diagonal, its 80% answers come true
         80% of the time; under it, it is surer than it should be. A bigger dot is more answers. The gap is
         the average distance from the diagonal, weighted by answers.</dd>
       <dt>At {decide.CONFIDENT}</dt><dd>The gateway acts on a choice only when the model is this sure: how
@@ -3669,26 +3672,45 @@ def bughunt_card() -> str:
         grey said there was no bug.</dd>
       <dt>Left of the line</dt><dd>The same files untouched: red is a false alarm, claiming a
         bug in clean code. The longer the red, the less to trust its "there's a bug here".</dd>
-      <dt>Order</dt><dd>Found share minus false-alarm share, best at the top.</dd>
+      <dt>Order</dt><dd>On what is proven, best at the top: the low end of the found share's likely
+        range (95%) less the high end of the false alarms'. A few tasks give wide ranges, so they
+        rank low; a model never shown clean code could be raising alarms on all of it.</dd>
+      <dt>Faint bars</dt><dd>Under 10 tasks: shown, but little to go on.</dd>
     </dl>"""
     return chart_card("Bug hunt", "Every task with an answer key: bugs found against false alarms on the"
                       " same files left clean. Right is good, left is bad.", "chart-hunt", "".join(body), key)
 
 
+def _wilson(k: int, n: int, z: float = 1.96) -> tuple[float, float]:
+    """The 95% Wilson interval of k successes in n, as bench.js wilson() draws it."""
+    if not n:
+        return 0.0, 1.0
+    p, z2 = k / n, z * z
+    mid, half = p + z2 / (2 * n), z * math.sqrt(p * (1 - p) / n + z2 / (4 * n * n))
+    return max(0.0, (mid - half) / (1 + z2 / n)), min(1.0, (mid + half) / (1 + z2 / n))
+
+
 def work_card() -> str:
     """How often real offloads helped."""
     rows = work_rows()
     body = ["<table><thead><tr>", th("Model"), th("Offloads", True), th("Judged", True), th("Helped", True),
-            th("Verified findings", True), th("False claims", True), "</tr></thead><tbody>"]
-    for r in sorted(rows, key=lambda r: -r["useful"] / r["judged"]):
+            th("Likely between", True), th("Verified findings", True), th("False claims", True), "</tr></thead><tbody>"]
+    for r in sorted(rows, key=lambda r: (-_wilson(r["useful"], r["judged"])[0], -r["judged"])):
+        lo, hi = _wilson(r["useful"], r["judged"])
         body.append(f"<tr><td>{named(r['model'])}</td><td class='num'>{r['offloads']}</td><td class='num'>{r['judged']}</td>"
                     f"<td class='num' data-sort='{r['useful'] / r['judged']:.3f}'>{r['useful']}/{r['judged']}</td>"
+                    f"<td class='num' data-sort='{lo:.3f}'>{lo * 100:.0f}–{hi * 100:.0f}%</td>"
                     f"<td class='num'>{r['real']}</td><td class='num'>{r['false']}</td></tr>")
     body.append("</tbody></table>")
     key = """<dl>
       <dt>Helped</dt><dd>Of the offloads judged, the share recorded useful: real work (reviews,
         enumerations) handed to the model and checked afterwards. Benchmarks never count here.</dd>
-      <dt>The number beside a name</dt><dd>How many were judged. 3 of 3 is weaker evidence than 40 of 50.</dd>
+      <dt>The dot and its line</dt><dd>The dot is the share that helped, bigger for more judged. The
+        line is where the true share likely sits (a 95% Wilson interval): long for 3 of 3, short for
+        40 of 50. Green when even its low end is over half, red when even its high end is under,
+        grey when there are too few to say.</dd>
+      <dt>Order</dt><dd>By the low end of that line, so volume counts: 40 of 50 ranks above 3 of 3.</dd>
+      <dt>The dashed line</dt><dd>Every model's judged offloads together, for comparison.</dd>
       <dt>Findings and false claims</dt><dd>Verified one by one in reviews, recorded since 2026-10-17.</dd>
     </dl>"""
     return chart_card("Real work", "When a model was given real work and the result was checked: how often"
@@ -3698,7 +3720,8 @@ def work_card() -> str:
 def overview_card() -> str:
     return (f"<div class='panel'>{SHARE}<h2>Who to trust with a review</h2><p class='sub'>Each dot is a model."
             " Right: finds more of the real bugs in our own code. Up: makes fewer things up (confidently"
-            " wrong on clean code, wrong lines, false claims, traps). Top right is where a reviewer should be.</p>"
+            " wrong on clean code, wrong lines, false claims, traps). Top right is where a reviewer should be."
+            " The models in or near the box, and the three that make most up, are named; hover for the rest.</p>"
             "<div class='chart' id='chart-overview'></div></div>")
 
 
@@ -3811,6 +3834,10 @@ def wrong_card() -> str:
       <dt>Reviews</dt><dd>False claims recorded in verdicts (<code>offload.py verdict|add
         --false "..."</code>), over judged offloads. Recorded in structured form only since
         2026-10-17, so older reviews show none.</dd>
+      <dt>The thin line</dt><dd>Where the true share likely sits (95% range). Long for a few
+        answers: 0 of 2 is not a clean record, and the line shows how bad it could be.</dd>
+      <dt>Order</dt><dd>Worst proven at the top: by the low end of that line. Under 10 answers a
+        model's bar is faint.</dd>
     </dl>"""
     return chart_card("Confidently wrong", "Who asserts things that are not true: false alarms on clean"
                       " code, wrong lines, false claims confirmed, traps taken. Shorter is better.",
@@ -3874,17 +3901,14 @@ def perf_card() -> str:
         when it is slow enough to change how you work.</dd>
     </dl>"""
     key = key.replace("</dl>", """
-      <dt>Did it answer?</dt><dd>Each probe of the last 14 days, by what came back: an answer, a
-        rate limit (capacity), a timeout, or a failure the bench classifies (structural, paywalled,
-        entitlement, other).</dd>
+      <dt>Did it answer?</dt><dd>Is on Uptime, by day, with our own quota and setup problems left out.</dd>
       <dt>Speed vs quality</dt><dd>Median seconds per answer on our own suite tasks (real prompts,
-        not the one-word probe) against the share of findings located. Top left is fast and good.</dd>
+        not the one-word probe) against the share of findings located. Top left is fast and good:
+        the green box is the faster half and the top quarter of findings.</dd>
     </dl>""")
     return chart_card("Performance", "What the serving path does — not what the models are worth. One"
                       " reading is weather; the history is climate.", "chart-speed", body, key,
-                      extra="<h3 class='chart-head'>Did it answer? Last 14 days of probes</h3>"
-                            "<div class='chart' id='chart-reliability'></div>"
-                            "<h3 class='chart-head'>Speed vs quality on our own tasks</h3>")
+                      extra="<h3 class='chart-head'>Speed vs quality on our own tasks</h3>")
 
 
 def favicon(theme: str) -> str:
@@ -4300,13 +4324,21 @@ def collections_tab() -> str:
         " the paid ones. Click a suggestion or type your own: comma-separated lower-case words, up to 8.</p>"
         # Not data-filter: that binds to the whole panel. The same match (any
         # text, case-insensitive), on the member list only; the seats show who is ticked.
-        "<label class='field' for='c-member-filter'>Members</label>"
+        "<div class='members-head'><label class='field' for='c-member-filter'>Members</label>"
+        # Model details as they are now (a fact set in a model's popup, a refresh of the
+        # catalog), the ticks and the search kept; also done when a model popup opened from here closes.
+        "<button class='btn small' type='button' id='c-refresh' title='Fetch the models and their details again;"
+        " what is ticked stays ticked'>Refresh model details</button>"
+        "<span class='done' id='c-refresh-out' role='status'></span></div>"
         # The panel as it will sit, drawn as the Collections list draws it
         # (bench.js recount): a seat per ticked member, explorer seats dashed.
         "<div id='c-seats' class='seats' aria-live='polite'></div>"
         "<div class='member-find'><input type='search' id='c-member-filter' class='member-filter' spellcheck='false'"
         " autocomplete='off' placeholder='Filter by model, provider or served name' aria-controls='c-members'"
-        " aria-describedby='c-count'><select id='c-member-provider' aria-label='Provider' aria-controls='c-members'>"
+        " aria-describedby='c-count'><select id='c-member-show' aria-label='Show' aria-controls='c-members'>"
+        "<option value=''>Every model</option><option value='ticked'>Ticked</option>"
+        "<option value='fits'>Fits the tags</option></select>"
+        "<select id='c-member-provider' aria-label='Provider' aria-controls='c-members'>"
         "<option value=''>Every provider</option></select></div>"
         "<div id='c-members' class='members' role='group' aria-label='Members'></div>"
         "<p class='rules' id='c-count'></p>"
@@ -5331,6 +5363,28 @@ def endpoints_page() -> str:
         "<div class='done' id='l-done'></div></div>")
 
 
+def _reply_cell(by_prompt: dict) -> str:
+    """Models' Reply: the daily probe's median seconds to a one-word answer (tiny),
+    with the 18 KB prompt's (large) and tokens a second on hover. Was on Benchmarks'
+    Performance, beside whether it answered, which is Uptime's now."""
+    def p50(r):
+        try:
+            return float(r["p50_s"]) if r and int(r.get("answered") or 0) > 0 else None
+        except (KeyError, TypeError, ValueError):
+            return None
+    tiny, large = p50(by_prompt.get("tiny")), p50(by_prompt.get("large"))
+    if tiny is None and large is None:
+        return "<td class='num muted' data-sort='999999'>—</td>"
+    shown = tiny if tiny is not None else large
+    why = "; ".join(b for b in (
+        f"one-word prompt {tiny:.1f}s" if tiny is not None else "",
+        f"18 KB prompt {large:.1f}s" if large is not None else "",
+        f"{(by_prompt.get('large') or {}).get('tokens_per_s')} tok/s"
+        if (by_prompt.get("large") or {}).get("tokens_per_s") else "") if b)
+    return (f"<td class='num' data-sort='{shown:.2f}' title='median, the daily probe: {esc(why)}'>"
+            f"{shown:.1f}s</td>")
+
+
 def models_page() -> str:
     """Every model on the bench by the connection it comes from."""
     cards = []
@@ -5344,6 +5398,10 @@ def models_page() -> str:
     # for what a collection may hold): they are on the bench like any other.
     by: dict[str, list[str]] = {}
     directory = model_directory()
+    # The daily probe's latest reading per model and prompt (perf/history.csv), for Reply.
+    speed: dict[str, dict] = {}
+    for r in perf_rows():
+        speed.setdefault(r["model"], {})[r.get("prompt", "")] = r
     for a in directory:
         by.setdefault(catalog.connection_of(a), []).append(a)
     for c in ({"name": n, "models": sorted(m)} for n, m in sorted(by.items())):
@@ -5356,7 +5414,7 @@ def models_page() -> str:
             kind = (" " + chip("decision", "", "a decision model: answers typed questions, not chat")
                     if a in decisions else "")
             if directory[a].get("ad_hoc"):
-                kind += " " + chip("ad hoc", "", "ad hoc only: never chosen by the bench on its own, only when you"
+                kind += " " + chip("ad hoc", "adhoc", "ad hoc only: never chosen by the bench on its own, only when you"
                                    " name it (a collection member, with, --model)")
             rows.append(f"<tr><td><a href='#' class='model' data-alias='{esc(a)}'>"
                         f"<span class='alias'>{esc(a)}</span></a>{kind}</td>"
@@ -5364,19 +5422,23 @@ def models_page() -> str:
                         f"<td class='num' data-sort='{f.get('context_window') or 0}'>{num(f.get('context_window'))}</td>"
                         f"<td class='num' data-sort='{f.get('max_output') or 0}'>{num(f.get('max_output'))}</td>"
                         f"<td>{esc(', '.join(f.get('input_modalities') or []) or '—')}</td>"
+                        + _reply_cell(speed.get(a, {}))
                         + "".join(f"<td class='num'>{num(lim.get(k))}</td>" for k in catalog.LIMIT_KEYS) + "</tr>")
         # One column plan for every card, so the cards line up under each other
         # (each table sized its own columns, so they drifted from card to card).
         cols = "<colgroup><col class='c-model'><col class='c-via'><col class='c-n'><col class='c-n'>" \
-               "<col class='c-input'>" + "<col class='c-lim'>" * len(catalog.LIMIT_KEYS) + "</colgroup>"
-        cards.append(f"<div class='panel'><h3 class='chart-head'>{esc(c['name'])} · {len(c['models'])} models</h3>"
+               "<col class='c-input'><col class='c-reply'>" + "<col class='c-lim'>" * len(catalog.LIMIT_KEYS) + "</colgroup>"
+        # Each connection folds; the page's one box filters them all (bench.js applyFilter, data-conn).
+        cards.append(f"<details class='panel model-card' open data-conn='{esc(c['name'])}'><summary>"
+                     f"<h3 class='chart-head'>{esc(c['name'])} · {len(c['models'])} models</h3></summary>"
                      f"<table class='model-cards'>{cols}<thead><tr>" + th("Model") + th("Through")
                      + th("Context", True) + th("Max output", True)
-                     + th("Input") + "".join(th(k, True) for k in catalog.LIMIT_KEYS)
-                     + f"</tr></thead><tbody>{''.join(rows)}</tbody></table></div>")
+                     + th("Input") + th("Reply", True) + "".join(th(k, True) for k in catalog.LIMIT_KEYS)
+                     + f"</tr></thead><tbody>{''.join(rows)}</tbody></table></details>")
     return ("<div class='panel'><h2>Models</h2><p class='sub'>Every model on the bench by the connection it"
             " comes from, with the endpoint it is reached through and what is known of its limits. A name"
-            " opens the model.</p></div>"
+            " opens the model.</p><div class='toolbar'><input type='search' data-filter='page'"
+            " placeholder='Find a model or connection' aria-label='Filter models'></div></div>"
             + "".join(cards))
 
 

package/ui/bench.css

@@ -293,10 +293,11 @@ td.num, th.num { text-align: right; }
 table.model-cards { table-layout: fixed; min-width: 52rem; }
 .panel:has(> table.model-cards) { overflow-x: auto; }        /* scrolls on a narrow window instead of wrapping numbers */
 table.model-cards td.num { white-space: nowrap; }
-table.model-cards col.c-model { width: 24%; }
-table.model-cards col.c-via { width: 13%; }
+table.model-cards col.c-model { width: 23%; }
+table.model-cards col.c-via { width: 11%; }
 table.model-cards col.c-n { width: 10%; }
-table.model-cards col.c-input { width: 19%; }
+table.model-cards col.c-input { width: 15%; }
+table.model-cards col.c-reply { width: 7%; }
 table.model-cards col.c-lim { width: 6%; }
 table.model-cards td { overflow-wrap: anywhere; }
 tbody tr:hover > td { background: var(--step-1); }
@@ -319,6 +320,7 @@ a.model:hover .alias { box-shadow: inset 0 -.3em 0 var(--signal); }
 .chip.err { background: var(--err-ground); color: var(--err); }
 .chip.new { background: var(--sky); color: var(--ink-deep); }
 /* an endpoint a model is reached through: outlined, so it reads as a place, not a state */
+.chip.adhoc { background: color-mix(in oklab, var(--sky) 55%, var(--paper-2)); color: var(--ink-deep); }
 .chip.via { background: transparent; border: 1px solid var(--line); color: var(--ink); font-family: var(--font-mono); }
 button.chip { font-family: inherit; border: 0; cursor: pointer; }
 button.chip:hover { outline: 1px solid currentColor; }
@@ -334,6 +336,8 @@ td.why { white-space: nowrap; }                     /* Uptime's down / left out,
 dialog { border: 1px solid var(--ink); border-radius: var(--radius); padding: 1.25rem 1.4rem;
          width: min(40rem, calc(100vw - 2rem)); max-height: calc(100vh - 2rem);
          background: var(--paper-2); color: var(--ink); box-shadow: 6px 6px 0 var(--ink); }
+/* The collection popup holds the member table: wider, so names and chips sit on one line. */
+dialog#c-form { width: min(54rem, calc(100vw - 2rem)); }
 dialog::backdrop { background: color-mix(in oklab, var(--ink-deep) 45%, transparent); }
 dialog h2 { margin: 0 0 .2rem; font-size: 1.375rem; font-weight: 700; }
 :is(dialog, .form-panel) .served { color: var(--muted); font-size: .9375rem; margin: 0 0 .9rem; overflow-wrap: anywhere; }
@@ -344,11 +348,24 @@ dialog h2 { margin: 0 0 .2rem; font-size: 1.375rem; font-weight: 700; }
 :is(dialog, .form-panel) .rules { font-size: .875rem; color: var(--muted); margin: .35rem 0 0; }
 :is(dialog, .form-panel) label.check { display: flex; align-items: center; gap: .5rem; margin-top: 1rem; cursor: pointer; }
 :is(dialog, .form-panel) fieldset { border: 0; padding: 0; margin: 1rem 0 0; }
-:is(dialog, .form-panel) .members { max-height: 18rem; overflow: auto; border-top: 1px solid var(--line); }
-/* One row per model: its name and what it holds, then a chip per provider it
-   is on, each ticking that alias (bench.js fillForm). */
-:is(dialog, .form-panel) .members .m-row { display: grid; grid-template-columns: minmax(0, 1fr) auto; gap: .2rem 1rem;
-                  align-items: center; padding: .4rem 0; border-bottom: 1px solid var(--line); }
+:is(dialog, .form-panel) .members { max-height: min(30rem, 55vh); overflow: auto; border: 1px solid var(--line);
+                  border-radius: var(--radius); }
+/* A table to scan: the model (its name opens it), context, what it can do, then a
+   chip per provider it is on, each ticking that alias (bench.js drawMembers). */
+:is(dialog, .form-panel) .members :is(.m-row, .m-head) { display: grid; gap: .2rem .8rem; align-items: center;
+                  grid-template-columns: minmax(9rem, 1.4fr) 3.6rem minmax(0, 1fr) minmax(0, 1.3fr); padding: .4rem .6rem; }
+:is(dialog, .form-panel) .members .m-head { position: sticky; top: 0; z-index: 1; background: var(--paper-2);
+                  border-bottom: 1px solid var(--ink); font-size: .75rem; font-weight: 600; color: var(--muted); }
+:is(dialog, .form-panel) .members .m-row { border-bottom: 1px solid var(--line); }
+:is(dialog, .form-panel) .members .m-row:nth-child(odd) { background: color-mix(in oklab, var(--band) 45%, transparent); }
+:is(dialog, .form-panel) .members .m-row:has(input:checked) { box-shadow: inset 3px 0 0 var(--bench-seat, var(--brand)); }
+:is(dialog, .form-panel) .members .m-name a.model { color: var(--ink); text-decoration: none; font-size: .875rem; }
+:is(dialog, .form-panel) .members .m-name a.model:hover { text-decoration: underline; }
+:is(dialog, .form-panel) .members .m-ctx { font-family: var(--font-mono); font-size: .8125rem; color: var(--muted); text-align: right; }
+:is(dialog, .form-panel) .members .m-can { display: flex; flex-wrap: wrap; gap: .2rem; }
+:is(dialog, .form-panel) .members .m-can .chip { font-size: .6875rem; padding: 0 .4rem; }
+#c-form .members-head { display: flex; align-items: baseline; gap: .6rem; flex-wrap: wrap; }
+#c-form .members-head .field { margin-right: auto; }
 :is(dialog, .form-panel) .members .m-name { display: flex; flex-wrap: wrap; align-items: baseline; gap: 0 .5rem;
                   font-size: .875rem; overflow-wrap: anywhere; }
 :is(dialog, .form-panel) .members .m-facts { color: var(--muted); font-size: .8125rem; }
@@ -380,6 +397,8 @@ dialog h2 { margin: 0 0 .2rem; font-size: 1.375rem; font-weight: 700; }
 :is(dialog, .form-panel) .profile .src { font-size: .75rem; color: var(--muted); }
 :is(dialog, .form-panel) .settings { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 0 1rem; }
 @media (max-width: 40rem) { :is(dialog, .form-panel) :is(.settings, .members .m-row) { grid-template-columns: minmax(0, 1fr); }
+                            :is(dialog, .form-panel) .members .m-head { display: none; }
+                            :is(dialog, .form-panel) .members .m-ctx { text-align: left; }
                             :is(dialog, .form-panel) .members .m-routes { justify-content: flex-start; } }
 :is(dialog, .form-panel) fieldset label.check { margin-top: .4rem; flex-wrap: wrap; }
 :is(dialog, .form-panel) fieldset label.check .muted { font-size: .875rem; }
@@ -519,6 +538,9 @@ pre.log.answer { max-height: 40vh; }
 .chart { margin: .5rem 0 .75rem; overflow-x: auto; }
 .chart.muted { font-size: .875rem; }
 h3.chart-head { font-size: 1rem; margin: 1rem 0 .2rem; }
+.chart-label { font-size: .875rem; font-weight: 600; margin: .9rem 0 .1rem; }
+/* Models: each connection a fold, its heading the summary */
+.model-card > summary h3.chart-head { display: inline; margin: 0; }
 /* the Collections tab: the dialog's form, kept to a readable width */
 .panel.form-panel > :not(#c-list, table) { max-width: 46rem; }
 /* a list of things you open (collections), with its New button above */

package/ui/bench.js

@@ -253,13 +253,21 @@
     var box = scope.querySelector('input[data-filter]'), q = box ? box.value.trim().toLowerCase() : '';
     var facets = Array.prototype.filter.call(scope.querySelectorAll('select[data-facet]'), function (s) { return s.value; });
     scope.querySelectorAll('tbody tr, .log-line').forEach(function (r) {
-      r.hidden = (q && r.textContent.toLowerCase().indexOf(q) === -1)
+      // A group's name (data-conn: Models' connection) counts as text of each of its rows.
+      var g = r.closest('[data-conn]'), text = r.textContent + (g ? ' ' + g.dataset.conn : '');
+      r.hidden = (q && text.toLowerCase().indexOf(q) === -1)
         || facets.some(function (s) { return r.dataset[s.dataset.facet] !== s.value; });
     });
     // A match inside a folded list (an endpoint's models) opens it.
     if (q) scope.querySelectorAll('details.models').forEach(function (d) {
       if (d.querySelector('tbody tr:not([hidden])')) d.open = true;
     });
+    // A group with no row left is hidden; one with a match opens.
+    scope.querySelectorAll('[data-conn]').forEach(function (g) {
+      var any = !!g.querySelector('tbody tr:not([hidden])');
+      g.hidden = !!q && !any;
+      if (q && any && g.tagName === 'DETAILS') g.open = true;
+    });
   }
   function scopeOf(c) {
     var box = c.closest('.toolbar') ? c.closest('.toolbar').querySelector('input[data-filter]') : c;
@@ -1880,7 +1888,7 @@
          pick: $('g-pick'), pickConf: $('g-pick-conf'),
          gErrors: $('g-errors'), gDone: $('g-done'), form: $('c-form'), status: $('c-status'),
          del: $('c-delete'), reply: $('c-reply'), merger: $('c-merger'), find: $('c-member-filter'),
-         seats: $('c-seats'), prov: $('c-member-provider'), adHoc: $('c-ad-hoc'),
+         seats: $('c-seats'), prov: $('c-member-provider'), show: $('c-member-show'), adHoc: $('c-ad-hoc'),
          ownCalls: $('c-max-calls'), ownExp: $('c-max-explorers')};
     return loadCollections();
   };
@@ -1994,7 +2002,7 @@
   // the seats above the list always show what is picked, each with its ×, and
   // every count still includes it. A row goes when all its chips do.
   function filterMembers() {
-    var q = c.find.value.trim().toLowerCase(), prov = c.prov.value;
+    var q = c.find.value.trim().toLowerCase(), prov = c.prov.value, show = c.show.value;
     c.members.querySelectorAll('.m-row').forEach(function (row) {
       var named = !q || row.dataset.name.toLowerCase().indexOf(q) !== -1, any = false;
       row.querySelectorAll('label.check').forEach(function (lab) {
@@ -2002,7 +2010,8 @@
         var text = (box.value + ' ' + (lab.dataset.served || '') + ' ' + (fact(box.value).connection || '') + ' ' +
                     lab.textContent).toLowerCase();
         lab.hidden = !box.checked && !!lab.dataset.paid || !named && text.indexOf(q) === -1
-                     || !!prov && (fact(box.value).provider || '') !== prov;
+                     || !!prov && (fact(box.value).provider || '') !== prov
+                     || show === 'ticked' && !box.checked || show === 'fits' && !!box.dataset.blocked;
         any = any || !lab.hidden;
       });
       row.hidden = !any;
@@ -2011,6 +2020,23 @@
   }
   on('input', 'c-member-filter', filterMembers);
   on('change', 'c-member-provider', filterMembers);
+  on('change', 'c-member-show', filterMembers);
+  // Refresh model details: the models and their facts fetched again, the list drawn
+  // anew with the same ticks, search and choices. The model popup's directory too.
+  function refreshMembers() {
+    var chosen = picked(), out = $('c-refresh-out'), btn = $('c-refresh');
+    btn.disabled = true; out.textContent = 'Refreshing…';
+    return Promise.all([get('/api/collections'), directory()]).then(function (res) {
+      C = res[0];
+      drawMembers(chosen);
+      applyTags();
+      out.textContent = 'Up to date.';
+    }).catch(function (err) { out.textContent = String(err); })
+      .then(function () { btn.disabled = false; });
+  }
+  on('click', 'c-refresh', refreshMembers);
+  // A model opened from the list may have been changed in its popup: what it now is, on close.
+  md.addEventListener('close', function () { if (c.form && c.form.open) refreshMembers(); });
   // Escape in a box with text clears it; only an empty box lets Escape close the popup.
   on('keydown', 'c-member-filter', function (e) {
     if (e.key === 'Escape' && c.find.value) { e.preventDefault(); e.stopPropagation(); c.find.value = ''; filterMembers(); }
@@ -2059,13 +2085,37 @@
     c.ownExp.value = row && row.max_explorers !== undefined ? row.max_explorers : '';
     c.ownCalls.placeholder = C.settings.max_calls; c.ownExp.placeholder = C.settings.max_explorers;
     drawTagPicks();
-    c.members.textContent = ''; c.find.value = '';
+    c.find.value = ''; c.show.value = ''; c.prov.value = '';
+    $('c-refresh-out').textContent = '';
+    drawMembers(row ? row.members : []);
+    c.shape.textContent = '';
+    c.shape.appendChild(el('option', {value: ''}, 'automatic'));
+    C.shapes.forEach(function (s) {
+      var o = el('option', {value: s}, s); if (row && row.shape === s) o.selected = true; c.shape.appendChild(o);
+    });
+    c.reply.value = row ? row.reply : 'all';
+    c.merger.textContent = '';
+    c.merger.appendChild(el('option', {value: ''}, 'automatic'));
+    C.models.forEach(function (alias) {
+      var o = el('option', {value: alias}, alias + (fact(alias).provider ? ' · ' + fact(alias).provider : ''));
+      if (row && row.merger === alias) o.selected = true; c.merger.appendChild(o);
+    });
+    showMerger(); applyTags();
+  }
+  // The member list: a table to scan down, one row per model (named by its shortest
+  // alias; the name opens its popup, as everywhere), its context and what it can do
+  // in columns of their own, then a chip per provider it is on, each ticking that
+  // alias. A chip whose window differs from the row's says its own. `chosen`: ticked.
+  function drawMembers(chosen) {
+    var keepProv = c.prov.value;
+    c.members.textContent = '';
     c.prov.length = 1;                                 // "Every provider", then each one a model is on
     Array.from(new Set(C.models.map(function (a) { return fact(a).provider; }).filter(Boolean))).sort()
       .forEach(function (p) { c.prov.appendChild(el('option', {value: p}, p)); });
-    // One row per model, named by its shortest alias, with what the first
-    // route says it holds and can do; each provider it is on is a chip that
-    // ticks that alias. A chip whose window differs from the row's says its own.
+    c.prov.value = keepProv;
+    var head = el('div', {class: 'm-head', 'aria-hidden': 'true'});
+    ['Model', 'Context', 'Can', 'On, tick one'].forEach(function (h) { head.appendChild(el('span', null, h)); });
+    c.members.appendChild(head);
     var groups = {};
     C.models.forEach(function (a) { var f = fact(a).family || a; (groups[f] = groups[f] || []).push(a); });
     Object.keys(groups).map(function (f) {
@@ -2073,18 +2123,22 @@
       return {family: f, name: routes[0], routes: routes};
     }).sort(function (x, y) { return x.name.toLowerCase() < y.name.toLowerCase() ? -1 : 1; }).forEach(function (g) {
       var first = fact(g.name), caps = first.caps || {};
-      var can = ['vision', 'tools'].filter(function (k) { return caps[k]; });
       var line = el('div', {class: 'm-row', role: 'group', 'aria-label': g.name, 'data-family': g.family, 'data-name': g.name});
       var name = el('div', {class: 'm-name'});
-      name.appendChild(el('span', {class: 'mono'}, g.name));
-      name.appendChild(el('span', {class: 'm-facts'}, [first.context ? tokens(first.context) : '', can.join(', '),
-        first.price === 'unknown' ? '' : first.price].filter(Boolean).join(' · ')));
+      name.appendChild(el('a', {href: '#', class: 'model mono', 'data-alias': g.name, title: 'Open ' + g.name}, g.name));
       line.appendChild(name);
+      line.appendChild(el('span', {class: 'm-ctx'}, first.context ? tokens(first.context) : '—'));
+      var can = el('span', {class: 'm-can'});
+      [['vision', 'vision'], ['tools', 'tools'], ['reasoning', 'reasons']].forEach(function (k) {
+        if (caps[k[0]]) can.appendChild(el('span', {class: 'chip'}, k[1]));
+      });
+      if (first.price === 'free') can.appendChild(el('span', {class: 'chip ok'}, 'free'));
+      line.appendChild(can);
       var chips = el('div', {class: 'm-routes'});
       g.routes.forEach(function (alias) {
         var f = fact(alias);
         var box = el('input', {type: 'checkbox', value: alias, 'aria-label': alias + ' on ' + (f.provider || 'its endpoint')});
-        box.checked = !!row && row.members.indexOf(alias) !== -1;
+        box.checked = chosen.indexOf(alias) !== -1;
         box.addEventListener('change', applyTags);      // ticked or not changes what a misfit shows as
         var lab = el('label', {class: 'check', 'data-served': (C.served || {})[alias] || ''});
         lab.appendChild(box);
@@ -2095,19 +2149,6 @@
       line.appendChild(chips);
       c.members.appendChild(line);
     });
-    c.shape.textContent = '';
-    c.shape.appendChild(el('option', {value: ''}, 'automatic'));
-    C.shapes.forEach(function (s) {
-      var o = el('option', {value: s}, s); if (row && row.shape === s) o.selected = true; c.shape.appendChild(o);
-    });
-    c.reply.value = row ? row.reply : 'all';
-    c.merger.textContent = '';
-    c.merger.appendChild(el('option', {value: ''}, 'automatic'));
-    C.models.forEach(function (alias) {
-      var o = el('option', {value: alias}, alias + (fact(alias).provider ? ' · ' + fact(alias).provider : ''));
-      if (row && row.merger === alias) o.selected = true; c.merger.appendChild(o);
-    });
-    showMerger(); applyTags();
   }
   // What a collection's members can all do, in the words the tag checks use.
   var CAN = {reasoning: 'reason'};
@@ -2660,7 +2701,8 @@
       try { box.appendChild(make(width())); } catch (e) { box.textContent = 'Chart failed: ' + e; }
     }
     // Pixel offsets that keep scatter labels apart: each label, in order, moves
-    // up or down until it clears the ones already placed.
+    // up or down until it clears the ones already placed; null when no place is
+    // free (that one is left to its hover, not drawn over another).
     function spread(points, xpx, ypx) {
       var boxes = [], tries = [-12, 14, -26, 28, -40, 42, -54, 56];
       return points.map(function (d) {
@@ -2672,7 +2714,7 @@
             return tries[k];
           }
         }
-        return tries[0];
+        return null;
       });
     }
     function rows(n) { return 20 * n + 80; }
@@ -2682,6 +2724,16 @@
       var keep = s.length - over - 1;
       return over <= 0 ? s : s.slice(0, Math.ceil(keep / 2)) + '…' + s.slice(s.length - Math.floor(keep / 2));
     }
+    function fit(s, max) { return middle(s, s.length - max); }
+    var FEW = 10;                        // under this many tasks or answers, a row is drawn faint
+    // The 95% Wilson interval of k successes in n: [low, high]. Honest at small n and at
+    // 0 or n of n, where k/n ± 1.96·se says nothing (3 of 3 is not "100% ± 0").
+    function wilson(k, n) {
+      if (!n) return [0, 1];
+      var z = 1.96, p = k / n, z2 = z * z, den = 1 + z2 / n;
+      var mid = p + z2 / (2 * n), half = z * Math.sqrt(p * (1 - p) / n + z2 / (4 * n * n));
+      return [Math.max(0, (mid - half) / den), Math.min(1, (mid + half) / den)];
+    }
 
     // Trend: who moved, which way, by how much and how sure (serve.trend_data),
     // in the window the card's select says. A row per model with a task to
@@ -2728,7 +2780,9 @@
       var nameW = Math.min(260, Math.max(150, 7 * Math.max.apply(null, M.map(function (r) { return r.key.length; })) + 24));
       var evW = 320;
       w = $('chart-trend').clientWidth || w;          // its own box: a phone's is narrower than width()'s 520
-      if (w < nameW + evW + 260) { evW = 0; nameW = Math.min(nameW, 130); }
+      // Without the evidence column the names take what the bars do not need (260 px), not a
+      // fixed 130 px: at the dashboard's width that cut "muse-glimmer-30b" to "muse-gl…mer-30b".
+      if (w < nameW + evW + 260) { evW = 0; nameW = Math.min(nameW, Math.max(130, w - 280)); }
       var fits = Math.floor((nameW - 24) / 7), right = evW || 20, wide = w < nameW + right + 140;
       w = Math.max(w, nameW + right + 140);
       // Symmetric, to the biggest bar and room for its number; 20 pts at least.
@@ -2830,16 +2884,74 @@
     // the time; under it, it is surer than it should be. Panels stack on a phone.
     var DC = C.decide;
     if (DC) put('chart-decide', function (w) {
-      if (!DC.points.length) return el('p', {class: 'hint'}, 'No decision model has answered a benchmark question yet.');
+      if (!(DC.scores || []).length) return el('p', {class: 'hint'}, 'No decision model has answered a benchmark question yet.');
       var names = {};
       DC.sets.forEach(function (s) { names[s[0]] = s[1]; });
       var panels = DC.sets.map(function (s) { return s[1]; });
+      // One colour per model across both charts, by name, never by rank.
+      var models = DC.scores.map(function (p) { return p.model; })
+        .filter(function (m, i, all) { return all.indexOf(m) === i; }).sort();
+      var colors = {domain: models, range: [sky, good, signal, warn, muted, ink, err]};
+      var box = el('div');
+      box.appendChild(el('h3', {class: 'chart-head'}, 'Right of asked, per set'));
+      box.appendChild(decideBars(w, names, panels, models, colors));
+      // Calibration only says something once a model's answers spread over two or more
+      // levels of sureness; while each sits in one top bin it is one dot in a corner.
+      var levels = DC.points.some(function (p, i, all) {
+        return all.some(function (q) { return q !== p && q.model === p.model && q.set === p.set; });
+      });
+      if (levels) {
+        box.appendChild(el('h3', {class: 'chart-head'}, 'Calibration: said against right'));
+        box.appendChild(decideCalibration(w, names, panels, models, colors));
+      } else {
+        box.appendChild(el('p', {class: 'hint'}, 'Calibration shows once a model gives answers at two or more levels'
+          + ' of sureness on a set; so far each answers at one, so the table\'s Brier and calibration gap say it.'));
+      }
+      return box;
+    });
+    // Right of asked as bars from 0: a small chart per set, a row per model asked on it,
+    // best first. A model under the ranking floor (DC.low items) is drawn faint: shown,
+    // not yet ranked.
+    function decideBars(w, names, panels, models, colors) {
+      var out = el('div');
+      DC.sets.forEach(function (s) {
+        var rows = DC.scores.filter(function (r) { return r.set === s[0]; }).map(function (r) {
+          return Object.assign({share: r.correct / r.asked, ranked: r.asked >= DC.low}, r);
+        }).sort(function (a, b) { return b.share - a.share || b.asked - a.asked || (a.model < b.model ? -1 : 1); });
+        out.appendChild(el('p', {class: 'chart-label'}, s[1]));
+        if (!rows.length) { out.appendChild(el('p', {class: 'hint'}, 'No model asked on this set yet.')); return; }
+        out.appendChild(Plot.plot({
+          width: w, height: rows.length * 26 + 40, style: style,
+          marginLeft: w < 560 ? 120 : 160, marginRight: 50, marginTop: 4, marginBottom: 30,
+          x: {domain: [0, 1], label: null, tickFormat: '.0%', ticks: 5, grid: true},
+          y: {domain: rows.map(function (r) { return r.model; }), label: null},
+          color: colors,
+          marks: [
+            Plot.barX(rows, {x: 'share', y: 'model', fill: 'model', insetTop: 4, insetBottom: 4, rx: 2,
+              fillOpacity: function (r) { return r.ranked ? 1 : 0.4; },
+              title: function (r) {
+                return r.model + ' · ' + s[1] + '\n' + r.correct + ' right of ' + r.asked + ' asked ('
+                  + Math.round(r.share * 100) + '%)' + (r.brier != null ? '\nBrier ' + r.brier.toFixed(3) : '')
+                  + (r.ranked ? '' : '\nnot ranked yet: under ' + DC.low + ' items');
+              }}),
+            Plot.text(rows, {x: 'share', y: 'model', dx: 6, textAnchor: 'start', fill: ink,
+              text: function (r) { return r.correct + '/' + r.asked; }}),
+            Plot.ruleX([0], {stroke: ink})
+          ]
+        }));
+      });
+      return out;
+    }
+    function decideCalibration(w, names, panels, models, colors) {
       var pts = DC.points.map(function (p) { return Object.assign({panel: names[p.set]}, p); })
         .sort(function (a, b) { return a.said - b.said; });
-      var models = pts.map(function (p) { return p.model; })
-        .filter(function (m, i, all) { return all.indexOf(m) === i; }).sort();
+      // Both axes start just under the lowest answer, not at 0%: a decision model is
+      // rarely under 50% sure of its own answer, so a 0-100% frame left every dot in
+      // one corner under a long empty diagonal. Same floor on both, so it stays 45°.
+      var low = Math.min.apply(null, pts.map(function (p) { return Math.min(p.said, p.right); }));
+      var lo = Math.max(0, Math.min(0.9, Math.floor((low - 0.05) * 20) / 20));
       var diag = [];
-      panels.forEach(function (s) { diag.push({panel: s, x: 0, y: 0}, {panel: s, x: 1, y: 1}); });
+      panels.forEach(function (s) { diag.push({panel: s, x: lo, y: lo}, {panel: s, x: 1, y: 1}); });
       function tip(p) {
         return p.model + ' · ' + names[p.set] + '\n' + plural(p.n, 'answer') + ' it was about '
           + Math.round(p.said * 100) + '% sure of\n' + Math.round(p.right * 100) + '% of them right';
@@ -2850,10 +2962,11 @@
       return Plot.plot(Object.assign(opts, {
         width: narrow ? Math.min(w, 520) : w, height: narrow ? 3 * 230 + 70 : 320, style: style,
         marginLeft: 52, marginRight: narrow ? 90 : 20, marginBottom: 44, marginTop: 28,
-        x: {domain: [0, 1], label: 'Probability it gave its answer →', tickFormat: '.0%', ticks: 5, grid: true},
-        y: {domain: [0, 1], label: '↑ Share right', tickFormat: '.0%', ticks: 5, grid: true},
+        inset: 14,                         // a dot at 100% clear of the frame
+        x: {domain: [lo, 1], label: 'Probability it gave its answer →', tickFormat: '.0%', ticks: 5, grid: true},
+        y: {domain: [lo, 1], label: '↑ Share right', tickFormat: '.0%', ticks: 5, grid: true},
         r: {range: [3, 13]},
-        color: {legend: true, domain: models, range: [sky, good, signal, warn, muted, ink, err]},
+        color: Object.assign({legend: true}, colors),
         marks: [
           Plot.frame({stroke: line}),
           Plot.line(diag, Object.assign({x: 'x', y: 'y', z: 'panel', stroke: muted, strokeDasharray: '4 3'}, by)),
@@ -2862,17 +2975,24 @@
                                        title: tip}, by))
         ]
       }));
-    });
+    }
     // Who to trust: finds real bugs (right) vs makes things up (up = less).
     put('chart-overview', function (w) {
       if (!C.overview.length) return el('p', {class: 'hint'}, 'No model has both suite scores and answers yet.');
       var worst = Math.max(0.1, Math.max.apply(null, C.overview.map(function (d) { return d.wrong; })));
       var x0 = Math.max(0, Math.floor((Math.min.apply(null, C.overview.map(function (d) { return d.recall; })) - 0.05) * 20) / 20);
       var pxW = w - 110, pxH = 370;
-      var pts = C.overview.slice().sort(function (a, b) { return a.wrong - b.wrong || b.recall - a.recall; });
+      // Named: the models in or next to the zone (the ones to pick from), then the clearest
+      // warnings (most made up). The rest are on hover: named all at once they ran together.
+      var zoneX = x0 + (1 - x0) / 2, zoneY = worst / 4;
+      var near = function (d) { return d.recall >= zoneX - (1 - x0) * 0.08 && d.wrong <= zoneY * 1.4; };
+      var worstFew = C.overview.slice().sort(function (a, b) { return b.wrong - a.wrong; }).slice(0, 3);
+      var pts = C.overview.filter(function (d) { return near(d) || worstFew.indexOf(d) !== -1; })
+        .sort(function (a, b) { return a.wrong - b.wrong || b.recall - a.recall; });
       var offs = spread(pts, function (d) { return (d.recall - x0) / (1 - x0) * pxW; },
                         function (d) { return d.wrong / worst * pxH; });
-      var labels = pts.map(function (d, i) { return {model: d.model, recall: d.recall, ty: d.wrong + offs[i] * worst / pxH}; });
+      var labels = pts.map(function (d, i) { return offs[i] == null ? null : {model: d.model, recall: d.recall, ty: d.wrong + offs[i] * worst / pxH}; })
+        .filter(Boolean);
       return Plot.plot({
         width: w, height: 440, style: style, grid: true, inset: 16, marginRight: 50, marginTop: 30,
         x: {label: 'Finds real bugs in our code →', domain: [x0, 1], tickFormat: '.0%'},
@@ -2900,71 +3020,72 @@
         tasks[h.model] = bugs + clean;
         var f = bugs ? h.found / bugs : 0, wl = bugs ? h['wrong line'] / bugs : 0, ms = bugs ? h.missed / bugs : 0;
         var fa = clean ? h['false alarm'] / clean : 0;
-        score[h.model] = f - fa;
+        // Ranked on what is proven: the low end of the found share's 95% range less the HIGH
+        // end of the false alarms' (never shown clean files: up to 100%), so a few tasks, or
+        // none on clean code, cannot top the chart.
+        score[h.model] = wilson(h.found, bugs)[0] - wilson(h['false alarm'], clean)[1];
         segs.push({model: h.model, part: 'false alarm', x1: -fa, x2: 0, n: h['false alarm'] + ' of ' + clean + ' clean files'});
         segs.push({model: h.model, part: 'found', x1: 0, x2: f, n: h.found + ' of ' + bugs + ' bugs'});
         segs.push({model: h.model, part: 'wrong line', x1: f, x2: f + wl, n: h['wrong line'] + ' of ' + bugs + ' bugs'});
         segs.push({model: h.model, part: 'missed', x1: f + wl, x2: f + wl + ms, n: h.missed + ' of ' + bugs + ' bugs'});
       });
-      var models = Object.keys(score).sort(function (a, b) { return score[b] - score[a]; });
+      var models = Object.keys(score).sort(function (a, b) { return score[b] - score[a] || tasks[b] - tasks[a]; });
       return Plot.plot({
-        width: w, height: rows(models.length), style: style, marginLeft: 250,
+        width: w, height: rows(models.length), style: style, marginLeft: w < 560 ? 150 : 250,
         x: {domain: [-1, 1], label: '← false alarms on clean files · bugs found →', grid: true,
             tickFormat: function (d) { return Math.abs(Math.round(d * 100)) + '%'; }},
-        y: {domain: models, label: null, tickFormat: function (m) { return m + '  (' + tasks[m] + ')'; }},
+        y: {domain: models, label: null, tickFormat: function (m) { return fit(m, w < 560 ? 16 : 28) + '  (' + tasks[m] + ')'; }},
         color: {legend: true, domain: ['found', 'wrong line', 'missed', 'false alarm'], range: [good, signal, line, err]},
         marks: [
+          // Under FEW tasks a model's bars are faint: shown, not much to go on.
           Plot.barX(segs.filter(function (s) { return s.x2 > s.x1; }), {x1: 'x1', x2: 'x2', y: 'model', fill: 'part',
-            title: function (d) { return d.model + ': ' + d.part + ', ' + d.n; }}),
+            fillOpacity: function (d) { return tasks[d.model] < FEW ? 0.4 : 1; },
+            title: function (d) { return d.model + ': ' + d.part + ', ' + d.n + (tasks[d.model] < FEW ? '\nfew tasks: little to go on' : ''); }}),
           Plot.ruleX([0], {stroke: ink, strokeWidth: 1.5})
         ]
       });
     });
 
-    // Real work: the share of judged offloads that helped, sample size beside the name.
+    // Real work: how often each model helped, with how sure that is. The dot is the share
+    // helped, its size how many were judged, the line the range the true share likely sits
+    // in (95% Wilson interval: wide for 3 of 3, narrow for 40 of 50). Ranked by the low end
+    // of that range, so volume counts: 3 of 3 no longer outranks 40 of 50. The dashed line
+    // is every model's offloads pooled.
     put('chart-work', function (w) {
-      var R = C.work.slice().sort(function (a, b) { return b.useful / b.judged - a.useful / a.judged || b.judged - a.judged; });
-      if (!R.length) return el('p', {class: 'hint'}, 'No judged offloads yet.');
-      var by = {};
-      R.forEach(function (r) { by[r.model] = r; });
-      function share(r) { return r.useful / r.judged; }
+      if (!C.work.length) return el('p', {class: 'hint'}, 'No judged offloads yet.');
+      var R = C.work.map(function (r) {
+        var b = wilson(r.useful, r.judged), p = r.useful / r.judged;
+        var verdict = b[0] >= 0.5 ? 'helps' : b[1] < 0.5 ? 'does not help' : 'too few to say';
+        return Object.assign({p: p, lo: b[0], hi: b[1], verdict: verdict}, r);
+      }).sort(function (a, b) { return b.lo - a.lo || b.judged - a.judged; });
+      var all = R.reduce(function (s, r) { return [s[0] + r.useful, s[1] + r.judged]; }, [0, 0]);
+      var pooled = all[0] / all[1];
+      var narrowW = w < 560, nameW = narrowW ? 130 : 210;
       return Plot.plot({
-        width: w, height: rows(R.length), style: style, marginLeft: 250, marginRight: 50,
-        x: {domain: [0, 1], label: 'Helped, share of judged offloads →', tickFormat: '.0%', grid: true},
+        width: w, height: 24 * R.length + 90, style: style, marginLeft: nameW, marginRight: 64, marginTop: 34,
+        x: {domain: [0, 1], label: 'Helped, share of judged offloads →', tickFormat: '.0%', ticks: 5, grid: true},
         y: {domain: R.map(function (r) { return r.model; }), label: null,
-            tickFormat: function (m) { return m + '  (' + by[m].judged + ')'; }},
+            tickFormat: function (m) { return fit(m, narrowW ? 16 : 26); }},
+        r: {domain: [0, Math.max.apply(null, R.map(function (r) { return r.judged; }))], range: [3, 11]},
+        color: {domain: ['helps', 'too few to say', 'does not help'], range: [good, muted, err], legend: true},
         marks: [
-          Plot.barX(R, {x: share, y: 'model', fill: function (r) { return share(r) >= 0.5 ? good : err; },
-            title: function (r) { return r.model + ': helped ' + r.useful + ' of ' + r.judged + ' judged (' + r.offloads + ' offloads)'
-              + (r.real || r.false ? '\nverified findings ' + r.real + ', false claims ' + r.false : ''); }}),
-          Plot.text(R, {x: share, y: 'model', text: function (r) { return r.useful + '/' + r.judged; }, dx: 18, fill: ink}),
-          Plot.ruleX([0], {stroke: ink})
+          Plot.ruleX([0.5], {stroke: line}),
+          Plot.ruleX([pooled], {stroke: ink, strokeDasharray: '4 3', strokeOpacity: 0.6}),
+          Plot.text([pooled], {x: function (d) { return d; }, frameAnchor: 'top', dy: -20, fill: muted, fontSize: 11,
+            text: function () { return 'all models ' + Math.round(pooled * 100) + '%'; }}),
+          Plot.ruleY(R, {y: 'model', x1: 'lo', x2: 'hi', stroke: 'verdict', strokeWidth: 2, strokeOpacity: 0.55}),
+          Plot.dot(R, {x: 'p', y: 'model', r: 'judged', fill: 'verdict', stroke: halo, strokeWidth: 1.5,
+            title: function (r) {
+              return r.model + '\nhelped ' + r.useful + ' of ' + r.judged + ' judged (' + Math.round(r.p * 100) + '%; '
+                + r.offloads + ' offloads)\nlikely between ' + Math.round(r.lo * 100) + '% and ' + Math.round(r.hi * 100) + '%'
+                + (r.real || r.false ? '\nverified findings ' + r.real + ', false claims ' + r.false : '');
+            }}),
+          Plot.text(R, {x: 'hi', y: 'model', dx: 8, textAnchor: 'start', fill: ink, fontSize: 11,
+            text: function (r) { return r.useful + '/' + r.judged; }})
         ]
       });
     });
 
-    // Did it answer: each probe of the last 14 days, by what came back.
-    put('chart-reliability', function (w) {
-      if (!C.reliability.length) return el('p', {class: 'hint'}, 'No probes in the last 14 days.');
-      var total = {}, ok = {};
-      C.reliability.forEach(function (d) {
-        total[d.model] = (total[d.model] || 0) + d.count;
-        if (d.outcome === 'answered') ok[d.model] = d.count;
-      });
-      var models = Object.keys(total).sort(function (a, b) { return (ok[b] || 0) / total[b] - (ok[a] || 0) / total[a]; });
-      var colour = {answered: good, capacity: signal, timeout: sky, structural: err, paywalled: warn,
-                    entitlement: '#c0563f', other: muted, error: ink};
-      var order = Object.keys(colour).filter(function (o) { return C.reliability.some(function (d) { return d.outcome === o; }); });
-      return Plot.plot({
-        width: w, height: rows(models.length), style: style, marginLeft: 250,
-        x: {label: 'Share of probes →', tickFormat: '.0%', grid: true},
-        y: {domain: models, label: null},
-        color: {legend: true, domain: order, range: order.map(function (o) { return colour[o]; })},
-        marks: [Plot.barX(C.reliability, Plot.stackX({x: 'count', y: 'model', fill: 'outcome', offset: 'normalize', order: order,
-          title: function (d) { return d.model + ': ' + d.outcome + ' ' + d.count + ' of ' + total[d.model] + ' probes'; }}))]
-      });
-    });
-
     // Speed vs quality: median seconds on our own tasks against findings located.
     put('chart-speed', function (w) {
       if (!C.speed.length) return el('p', {class: 'hint'}, 'No suite timings yet.');
@@ -2975,14 +3096,20 @@
       var pts = C.speed.slice().sort(function (a, b) { return b.recall - a.recall; });
       var offs = spread(pts, function (d) { return (Math.log(d.seconds) - Math.log(lo)) / (Math.log(hi) - Math.log(lo)) * pxW; },
                         function (d) { return (1 - d.recall) / (1 - y0) * pxH; });
-      var labels = pts.map(function (d, i) { return {model: d.model, seconds: d.seconds, ty: d.recall - offs[i] * (1 - y0) / pxH}; });
+      var labels = pts.map(function (d, i) { return offs[i] == null ? null : {model: d.model, seconds: d.seconds, ty: d.recall - offs[i] * (1 - y0) / pxH}; })
+        .filter(Boolean);
       return Plot.plot({
         width: w, height: 420, style: style, grid: true, inset: 16, marginRight: 50, marginTop: 30,
         x: {type: 'log', domain: [lo, hi], label: 'Median seconds per answer on our tasks →'},
         y: {domain: [y0, 1], label: '↑ Findings located', tickFormat: '.0%'},
         marks: [
+          // The zone to be in, as on Who to trust: the faster half (on the log scale) and the
+          // top quarter of findings. Outlined, so it reads on a dark ground too.
+          Plot.rect([{x1: lo, x2: Math.sqrt(lo * hi), y1: y0 + (1 - y0) * 3 / 4, y2: 1}], {x1: 'x1', x2: 'x2', y1: 'y1', y2: 'y2',
+            fill: good, fillOpacity: 0.12, stroke: good, strokeOpacity: 0.5, strokeDasharray: '4 3'}),
           Plot.dot(C.speed, {x: 'seconds', y: 'recall', r: 6, fill: sky, stroke: ink, strokeWidth: 0.5}),
-          Plot.text(labels, {x: 'seconds', y: 'ty', text: 'model', fontSize: 11, fill: ink}),
+          Plot.text(labels, {x: 'seconds', y: 'ty', text: 'model', fontSize: 11, fill: ink,
+                             stroke: halo, strokeWidth: 3.5, strokeOpacity: 0.9, paintOrder: 'stroke'}),
           Plot.tip(C.speed, Plot.pointer({x: 'seconds', y: 'recall',
             title: function (d) { return d.model + '\nmedian ' + d.seconds.toFixed(0) + 's over ' + d.tasks + ' tasks\nfinds ' + Math.round(d.recall * 100) + '%'; }}))
         ]
@@ -2997,25 +3124,41 @@
         return C.families.indexOf(fam[a]) - C.families.indexOf(fam[b]) || (a < b ? -1 : 1);
       });
       tasks.forEach(function (t) { if (!(fam[t] in first)) first[fam[t]] = t; });
-      var label = {};
-      Object.keys(first).forEach(function (f) { label[first[f]] = f; });
+      // Each group's name over its first task, on two staggered rows: side by side they
+      // ran into one another wherever a group is only a few tasks wide.
+      var heads = C.families.filter(function (f) { return f in first; })
+        .map(function (f, i) { return {task: first[f], name: f, row: i % 2}; });
       // By total found, so a model that played three tasks does not top one that played forty.
-      var sum = {};
-      C.heat.forEach(function (d) { sum[d.model] = (sum[d.model] || 0) + (d.rate || 0); });
-      var models = Object.keys(sum).sort(function (a, b) { return sum[b] - sum[a]; });
+      // A model with no scored task (only grey) gets no row: it is named under the chart.
+      var sum = {}, scored = {};
+      C.heat.forEach(function (d) {
+        sum[d.model] = (sum[d.model] || 0) + (d.rate || 0);
+        if (d.rate != null) scored[d.model] = true;
+      });
+      var models = Object.keys(sum).filter(function (m) { return scored[m]; }).sort(function (a, b) { return sum[b] - sum[a]; });
+      var idle = Object.keys(sum).filter(function (m) { return !scored[m]; }).sort();
+      var shown = C.heat.filter(function (d) { return scored[d.model]; });
+      var nameW = w < 560 ? 130 : 230;
       function tip(d) { return d.model + '\n' + d.task + ' (' + d.family + ')\n' + d.label + (d.invented ? '\ninvented something' : ''); }
-      return Plot.plot({
-        width: w, height: 22 * models.length + 70, style: style, marginLeft: 230, marginTop: 30, padding: 0.08,
-        x: {domain: tasks, axis: 'top', label: null, tickSize: 0, tickFormat: function (t) { return label[t] || ''; }},
-        y: {domain: models, label: null, tickSize: 0},
+      var box = el('div');
+      box.appendChild(Plot.plot({
+        width: w, height: 22 * models.length + 84, style: style, marginLeft: nameW, marginTop: 44, padding: 0.08,
+        x: {domain: tasks, axis: null},
+        y: {domain: models, label: null, tickSize: 0, tickFormat: function (m) { return fit(m, w < 560 ? 16 : 30); }},
         color: {type: 'linear', domain: [0, 0.5, 1], range: [err, signal, good]},
         marks: [
-          Plot.cell(C.heat.filter(function (d) { return d.rate == null; }), {x: 'task', y: 'model', fill: line, title: tip}),
-          Plot.cell(C.heat.filter(function (d) { return d.rate != null; }), {x: 'task', y: 'model', fill: 'rate', title: tip}),
-          Plot.dot(C.heat.filter(function (d) { return d.invented; }), {x: 'task', y: 'model', r: 2.4, fill: ink}),
-          Plot.ruleX(Object.keys(label), {x: function (t) { return t; }, stroke: ink, strokeOpacity: 0.25, dx: -2})
+          Plot.cell(shown.filter(function (d) { return d.rate == null; }), {x: 'task', y: 'model', fill: line, title: tip}),
+          Plot.cell(shown.filter(function (d) { return d.rate != null; }), {x: 'task', y: 'model', fill: 'rate', title: tip}),
+          Plot.dot(shown.filter(function (d) { return d.invented; }), {x: 'task', y: 'model', r: 2.4, fill: ink}),
+          Plot.ruleX(heads, {x: 'task', stroke: ink, strokeOpacity: 0.25, dx: -2}),
+          Plot.text(heads.filter(function (h) { return !h.row; }), {x: 'task', frameAnchor: 'top', dy: -30, dx: -2,
+            text: 'name', textAnchor: 'start', fontSize: 11, fill: ink}),
+          Plot.text(heads.filter(function (h) { return h.row; }), {x: 'task', frameAnchor: 'top', dy: -14, dx: -2,
+            text: 'name', textAnchor: 'start', fontSize: 11, fill: ink})
         ]
-      });
+      }));
+      if (idle.length) box.appendChild(el('p', {class: 'hint'}, 'No scored task yet, so no row: ' + idle.join(', ') + '.'));
+      return box;
     });
 
     // Vision tasks: one square per field and model, the task's name over its first field.
@@ -3062,39 +3205,66 @@
         kinds.forEach(function (k) { if (W[m][k]) data.push({model: m, kind: k, count: W[m][k]}); total[m] = (total[m] || 0) + W[m][k]; });
       });
       if (!data.length) return el('p', {class: 'hint'}, 'No vision panels through the gateway yet.');
-      // The models doing the most image work first: their bars are the evidence.
-      var models = Object.keys(total).sort(function (a, b) { return total[b] - total[a] || (a < b ? -1 : 1); });
+      // The models doing the most image work first: their bars are the evidence. Under FEW
+      // seats a row was mostly "no answer" and said little: those are listed under the chart.
+      var all = Object.keys(total).sort(function (a, b) { return total[b] - total[a] || (a < b ? -1 : 1); });
+      var models = all.filter(function (m) { return total[m] >= FEW; });
+      var few = all.filter(function (m) { return total[m] < FEW; });
+      if (!models.length) { models = all; few = []; }
+      data = data.filter(function (d) { return models.indexOf(d.model) !== -1; });
       var colour = {'checked, helped': good, 'checked, did not help': err, 'useful, no claims': sky,
                     'no use, no claims': warn, 'not judged': line, 'no answer': muted};
       // The claims checked by hand, beside the bar: the only right-or-wrong count real work has.
       var claims = models.filter(function (m) { return W[m].real + W[m].false; }).map(function (m) {
         return {model: m, text: W[m].real + ' of ' + (W[m].real + W[m].false) + ' claims right'};
       });
-      return Plot.plot({
-        width: w, height: rows(models.length), style: style, marginLeft: 300, marginRight: 150,
+      var narrowV = w < 560, box = el('div');
+      box.appendChild(Plot.plot({
+        width: w, height: rows(models.length), style: style, marginLeft: narrowV ? 150 : 260, marginRight: narrowV ? 20 : 150,
         x: {label: 'Share of its seats on image panels →', tickFormat: '.0%', grid: true, domain: [0, 1]},
-        y: {domain: models, label: null, tickFormat: function (m) { return m + '  (' + total[m] + ')'; }},
+        y: {domain: models, label: null, tickFormat: function (m) { return fit(m, narrowV ? 16 : 30) + '  (' + total[m] + ')'; }},
         color: {legend: true, domain: kinds, range: kinds.map(function (k) { return colour[k]; })},
         marks: [
           Plot.barX(data, Plot.stackX({x: 'count', y: 'model', fill: 'kind', offset: 'normalize', order: kinds,
             title: function (d) { return d.model + ': ' + d.kind + ', ' + d.count + ' of ' + total[d.model] + ' seats'; }})),
-          Plot.text(claims, {x: 1, y: 'model', text: 'text', dx: 8, textAnchor: 'start', fill: ink})
+          Plot.text(narrowV ? [] : claims.filter(function (c) { return models.indexOf(c.model) !== -1; }),
+            {x: 1, y: 'model', text: 'text', dx: 8, textAnchor: 'start', fill: ink})
         ]
-      });
+      }));
+      if (few.length) box.appendChild(el('p', {class: 'hint'}, 'Under ' + FEW + ' seats, so no bar: '
+        + few.map(function (m) { return m + ' (' + total[m] + ')'; }).join(', ') + '. The table has them all.'));
+      return box;
     });
 
-    // Confidently wrong: stacked by kind, worst at the top.
+    // Confidently wrong: stacked by kind. A thin line runs over each bar for the range the
+    // true share likely sits in (95% Wilson), so 0 of 2 shows how bad it could be, not a
+    // clean record. Worst proven at the top: by the low end of that range. Few answers: faint.
     put('chart-wrong', function (w) {
-      var T = C.wrongTotals;
-      var models = Object.keys(T).sort(function (a, b) { return T[b].rate - T[a].rate || T[b].answers - T[a].answers; });
+      var T = C.wrongTotals, R = {};
+      Object.keys(T).forEach(function (m) {
+        var b = wilson(T[m].wrong, T[m].answers);
+        R[m] = {model: m, lo: b[0], hi: b[1], few: T[m].answers < FEW};
+      });
+      var models = Object.keys(T).sort(function (a, b) {
+        return R[b].lo - R[a].lo || T[b].rate - T[a].rate || T[b].answers - T[a].answers;
+      });
+      var ranges = models.map(function (m) { return R[m]; });
+      var top = Math.min(1, Math.max.apply(null, ranges.map(function (r) { return r.hi; })) + 0.02);
       return Plot.plot({
-        width: w, height: 20 * models.length + 70, style: style, marginLeft: 250,
-        x: {label: 'Confidently wrong, share of answers that could have been →', tickFormat: '.0%', grid: true},
+        width: w, height: 20 * models.length + 70, style: style, marginLeft: w < 560 ? 150 : 250,
+        x: {domain: [0, top], label: 'Confidently wrong, share of answers that could have been →', tickFormat: '.0%', grid: true},
         // The count beside each name: 1 of 2 is not the same evidence as 17 of 26.
-        y: {domain: models, label: null, tickFormat: function (m) { return m + '  (' + T[m].answers + ')'; }},
+        y: {domain: models, label: null, tickFormat: function (m) { return fit(m, w < 560 ? 16 : 28) + '  (' + T[m].answers + ')'; }},
         color: {legend: true, domain: C.kinds, range: [err, signal, sky, muted]},
         marks: [
-          Plot.barX(C.wrong, {x: 'rate', y: 'model', fill: 'kind', title: function (d) { return d.model + ': ' + d.kind + ' ' + d.n; }}),
+          Plot.barX(C.wrong, {x: 'rate', y: 'model', fill: 'kind', insetTop: 3, insetBottom: 3,
+            fillOpacity: function (d) { return R[d.model].few ? 0.4 : 1; },
+            title: function (d) { return d.model + ': ' + d.kind + ' ' + d.n; }}),
+          Plot.ruleY(ranges, {y: 'model', x1: 'lo', x2: 'hi', stroke: ink, strokeOpacity: 0.45, strokeWidth: 1.5,
+            title: function (r) {
+              return r.model + ': ' + T[r.model].wrong + ' of ' + T[r.model].answers + ' confidently wrong\nlikely between '
+                + Math.round(r.lo * 100) + '% and ' + Math.round(r.hi * 100) + '%' + (r.few ? '\nfew answers: little to go on' : '');
+            }}),
           Plot.ruleX([0], {stroke: ink})
         ]
       });