Participation guide, prompt set, and per-model standings

app.py

@@ -14,6 +14,7 @@ import hashlib
 import hmac
 import json
 import os
+import re
 import secrets
 import time
 import urllib.parse
@@ -128,8 +129,7 @@ def _redirect_uri(request: Request):
 # ---------------------------------------------------------------- 화면
 @app.get("/")
 async def index():
-    # async 인 이유: sync 라우트는 요청 스레드풀에서 돈다. 그 풀이 Hub I/O 로 막히면
-    # 정적 페이지까지 뒤에 줄을 서서 사이트가 죽은 것처럼 보인다.
+    # 정적 페이지는 요청 스레드풀을 타지 않게 async 로 둔다.
     return FileResponse(os.path.join(HERE, "index.html"))
 
 
@@ -313,6 +313,58 @@ def leaderboard(request: Request):
                     headers={"Vary": "Accept-Encoding"})
 
 
+_FILLER = {"ai", "model", "llm", "the", "v", "ver", "version", "latest", "preview",
+           "chat", "instruct", "it", "api", "official", "new"}
+
+
+def canon_model(name):
+    """표기가 갈린 같은 모델을 하나로 묶는다.
+
+    'Anthropic Claude Opus 5' 와 'claude-opus-5' 는 같은 것이고, 따로 세면 둘 다
+    실제보다 적게 쓰인 것처럼 보인다. 다만 변종을 구분하는 낱말(Pro/Flash 등)은
+    지우지 않는다 - 그것까지 뭉치면 다른 모델이 한 칸에 들어간다.
+    """
+    s = re.sub(r"[^a-z0-9]+", " ", (name or "").lower()).strip()
+    toks = [t for t in s.split() if t and t not in _FILLER]
+    return " ".join(toks) or (name or "").strip().lower()
+
+
+@app.get("/api/models")
+def models(request: Request):
+    """모델별 성적: 어느 모델이 가장 좋은 후보를 냈는가, 그리고 얼마나 쓰이는가.
+
+    두 수를 **따로** 낸다. 많이 쓰인다고 잘하는 것이 아니다 - 다들 집는 모델은 점수와
+    무관하게 제출 수가 쌓이고, 세 번 쓰인 모델이 1위 후보를 갖고 있을 수 있다.
+    평균만 내면 둘 다 가려진다. 그래서 최고·평균·건수를 나란히 둔다.
+    기준물질은 제외한다 - 참가자의 모델이 만든 것이 아니다.
+    """
+    season = seasons.get(request.query_params.get("season"))
+    agg = {}
+    for r in (_board(season).get("entries") or {}).values():
+        if r.get("total") is None:
+            continue
+        name = (r.get("model_name") or "").strip() or "미기재 / unspecified"
+        key = canon_model(name)
+        a = agg.setdefault(key, {"n": 0, "best": None, "sum": 0.0,
+                                 "top_candidate": None, "spellings": {}})
+        a["spellings"][name] = a["spellings"].get(name, 0) + 1
+        a["n"] += 1
+        a["sum"] += r["total"]
+        if a["best"] is None or r["total"] > a["best"]:
+            a["best"] = r["total"]
+            a["top_candidate"] = r.get("candidate_id")
+    out = []
+    for k, a in agg.items():
+        # 참가자들이 실제로 가장 많이 쓴 표기를 이름으로 삼는다
+        label = max(a["spellings"].items(), key=lambda kv: kv[1])[0]
+        out.append({"model": label, "n": a["n"], "best": round(a["best"], 2),
+                    "mean": round(a["sum"] / a["n"], 2),
+                    "top_candidate": a["top_candidate"]})
+    out.sort(key=lambda x: (-x["best"], -x["n"]))
+    return {"models": out, "counts": {"models": len(out),
+                                      "entries": sum(m["n"] for m in out)}}
+
+
 @app.get("/api/queue")
 def queue(request: Request):
     season = seasons.get(request.query_params.get("season"))

index.html

@@ -86,6 +86,34 @@
   a{color:var(--accent)}
   .badges{display:flex;gap:8px;flex-wrap:wrap;margin-top:6px}
   .badges img{height:22px}
+  .lead{font-size:15px;margin:0 0 12px}
+  .facts{display:grid;grid-template-columns:repeat(auto-fit,minmax(240px,1fr));gap:10px;margin:12px 0}
+  .fact{background:var(--bg);border:1px solid var(--line);border-radius:10px;padding:11px 13px;font-size:13px}
+  .fact b{display:block;color:var(--accent);font-size:12px;margin-bottom:3px}
+  .pcard{border:1px solid var(--line);border-radius:11px;margin:10px 0;overflow:hidden}
+  .phead{display:flex;align-items:center;gap:9px;padding:9px 13px;background:var(--bg);
+    border-bottom:1px solid var(--line);flex-wrap:wrap}
+  .ptag{display:inline-flex;align-items:center;justify-content:center;width:22px;height:22px;
+    border-radius:6px;background:var(--accent);color:#fff;font-size:12px;font-weight:700}
+  .phead b{font-size:14px} .phead span{color:var(--muted);font-size:12.5px}
+  .pcopy{margin-left:auto;border:1px solid var(--line);background:var(--card);color:var(--muted);
+    border-radius:7px;padding:4px 11px;cursor:pointer;font:inherit;font-size:12px}
+  .pcopy:hover{border-color:var(--accent);color:var(--accent)}
+  .pbody{padding:12px 14px;font-family:ui-monospace,SFMono-Regular,Menlo,monospace;
+    font-size:12.5px;line-height:1.6;white-space:pre-wrap;color:var(--ink);max-height:280px;overflow:auto}
+  .pbody em{color:var(--warn);font-style:normal;font-weight:600}
+  .mrow{display:grid;grid-template-columns:minmax(120px,1.4fr) 1fr auto;gap:10px;
+    align-items:center;padding:7px 0;border-bottom:1px solid var(--line);font-size:13px}
+  .mrow:last-child{border-bottom:0}
+  .mname{white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+  .mbar{position:relative;height:16px;background:var(--bg);border-radius:5px;overflow:hidden}
+  .mbar i{position:absolute;inset:0 auto 0 0;background:var(--accent);border-radius:5px}
+  .mbar u{position:absolute;top:0;bottom:0;width:2px;background:var(--ink);opacity:.55}
+  .mnum{font-variant-numeric:tabular-nums;color:var(--muted);white-space:nowrap;font-size:12.5px}
+  .mlegend{display:flex;gap:14px;color:var(--muted);font-size:12px;margin-top:10px;flex-wrap:wrap}
+  .mlegend i{display:inline-block;width:10px;height:10px;background:var(--accent);border-radius:2px;margin-right:4px}
+  .mlegend u{display:inline-block;width:2px;height:11px;background:var(--ink);opacity:.55;margin-right:4px;
+    vertical-align:-1px;text-decoration:none}
 </style>
 </head>
 <body>
@@ -110,6 +138,21 @@
   <div class="callout" id="t_honest"></div>
 </div>
 
+<div class="card">
+  <h2 id="t_guide_h"></h2>
+  <p class="lead" id="t_guide_lead"></p>
+  <div class="facts" id="facts"></div>
+  <div id="t_guide_how"></div>
+  <div id="prompts"></div>
+</div>
+
+<div class="card">
+  <h2><span id="t_models_h"></span><span class="cnt" id="mcounts"></span></h2>
+  <div id="t_models_lead" class="note" style="margin-top:0"></div>
+  <div id="models"></div>
+  <div class="mlegend" id="t_mlegend"></div>
+</div>
+
 <div class="grid">
   <div class="card">
     <h2><span id="t_board_h"></span><span class="cnt" id="counts"></span></h2>
@@ -167,6 +210,24 @@ const T = {
     <b>이온전도도는 이번 시즌의 채점 항목이 아닙니다.</b> 따라서 전도도가 높은 계열이라도
     산화창이 좁거나 리튬 금속과 반응하면 낮게 나옵니다 — 그 두 가지가 이 시즌이 묻는 문제입니다.
     모든 값은 <b>계산 추정치</b>이며 실제 성능이나 안전성을 뜻하지 않습니다.`,
+  guide_h:"참가 가이드",
+  guide_lead:`전고체 전지는 리튬 이온이 <b>고체 안을</b> 지나가야 합니다. 그런데 그 물질은 동시에
+    <b>전자는 통과시키지 않아야</b> 하고, 충전 전압을 견뎌야 하고, 음극의 <b>리튬 금속</b>에 닿아도
+    분해되지 않아야 합니다. 이 네 가지를 한 물질에서 동시에 만족시키는 것이 아직 풀리지 않은 문제입니다.`,
+  facts:[
+    ["표적", "리튬이 지나갈 통로가 있는 고체. 리튬을 반드시 포함해야 합니다."],
+    ["넘어야 할 관문", "전자가 통하면 전지가 그대로 단락됩니다. 전자 절연성이 전제 조건입니다."],
+    ["가장 어려운 곳", "산화 안정성과 리튬금속 안정성은 서로 잘 안 맞습니다. 둘 다 잡는 것이 이 시즌의 과제입니다."],
+    ["제출", "조성 하나. 구조(CIF)는 선택이며, 내면 채점이 더 빠르고 정확합니다."]],
+  guide_how:`<p style="margin:14px 0 2px">아래 프롬프트를 쓰시는 AI 모델에 그대로 넣으시면 됩니다.
+    <b>복사</b> 버튼으로 가져가신 뒤, 기울임체로 표시된 부분은 본인 관심사로 바꿔 주십시오 —
+    그래야 다른 참가자와 같은 후보가 겹치지 않습니다. 나온 조성을 오른쪽 칸에 하나씩 제출하시면 됩니다.</p>`,
+  models_h:"AI 모델별 성과",
+  models_lead:`어느 모델이 <b>가장 좋�� 후보</b>를 냈는지(막대)와 <b>얼마나 쓰이는지</b>(오른쪽)를
+    함께 봅니다. 많이 쓰인다고 잘하는 것은 아니므로 따로 표시합니다.`,
+  mempty:"채점된 제출이 쌓이면 모델별 성과가 여기에 표시됩니다.",
+  mcounts:(m,n)=>`모델 ${m} · 제출 ${n}`,
+  mlegend:`<span><i></i>최고 점수</span><span><u></u>평균</span><span>제출 수</span>`,
   board_h:"순위표",
   boardnote:`<b>기준물질(노란 행)</b>은 점수를 받되 등수를 갖지 않습니다. 실제로 쓰이는 전해질이 몇 점인지
     눈으로 비교하시라고 넣었습니다.<br>
@@ -210,6 +271,24 @@ const T = {
     scores low if its oxidation window is narrow or it reacts with lithium metal — those two are the problem
     this season puts to you.
     Every value is a <b>computational estimate</b> and implies nothing about real performance or safety.`,
+  guide_h:"How to take part",
+  guide_lead:`In a solid-state cell the lithium ion has to travel <b>through a solid</b>. That same solid
+    must <b>block electrons</b>, hold up at the charging voltage, and survive contact with the
+    <b>lithium metal</b> anode without decomposing. Meeting all four in one material is the open problem.`,
+  facts:[
+    ["Target", "A solid with a path for lithium to move through. It must contain lithium."],
+    ["Get past this", "If electrons pass, the cell simply shorts. Electronic insulation is a precondition."],
+    ["Hardest part", "Oxidation stability and lithium-metal stability pull against each other. Holding both is the task."],
+    ["Submission", "One composition. A structure (CIF) is optional and makes scoring faster and more accurate."]],
+  guide_how:`<p style="margin:14px 0 2px">Paste a prompt below into the model you use. Hit <b>Copy</b>,
+    then change the italicised part to something of your own — otherwise your candidates will collide with
+    other entrants'. Submit the compositions it returns, one at a time, on the right.</p>`,
+  models_h:"By model",
+  models_lead:`Which model produced the <b>best candidate</b> (bar) and <b>how often it is used</b> (right).
+    Being used a lot is not the same as doing well, so the two are shown separately.`,
+  mempty:"Model standings appear here once scored entries accumulate.",
+  mcounts:(m,n)=>`${m} models · ${n} entries`,
+  mlegend:`<span><i></i>Best score</span><span><u></u>Mean</span><span>Entries</span>`,
   board_h:"Leaderboard",
   boardnote:`<b>Reference materials (amber rows)</b> are scored but hold no rank. They are there so you can see
     where materials in actual use land.<br>
@@ -242,6 +321,101 @@ const T = {
  }
 };
 
+// 프롬프트는 **목표**만 말한다. 무엇을 어떻게 재는지는 적지 않는다 - 적으면 물질이 아니라
+// 채점기를 겨냥한 제출이 들어온다.
+const PROMPTS_BY_SEASON = {
+ 1: [
+  {id:"A", ko:["기본형","처음 시작한다면 이것부터"], en:["Starter","Begin here"],
+   body:`You are proposing candidate solid electrolytes for an all-solid-state lithium battery,
+for an open materials challenge.
+
+Requirements for every candidate:
+- Contains lithium, with a plausible connected pathway for Li+ to migrate through the
+  lattice.
+- An electronic insulator. If electrons conduct, the cell short-circuits; this is a
+  precondition, not a trade-off.
+- Wide electrochemical window: stable against oxidation at high cell voltage.
+- Stable in contact with lithium metal at the anode, or decomposing only into a passivating
+  layer rather than an electronically conductive one.
+- Plausibly synthesisable: a composition close to a stable phase, not an exotic guess.
+
+Propose 8 candidate compositions as a JSON array:
+[{"formula":"...","name":"...","rationale":"why lithium should move through it, why it
+should not conduct electrons, and how it behaves against lithium metal"}]
+
+Use plain chemical formulae, e.g. Li3YCl6 or LiZr2(PO4)3.
+
+<em>VARY THIS: name a chemical family you want to explore (halides, oxides, phosphates,
+oxyhalides, anti-perovskites, …) or a constraint of your own, so your set does not collide
+with other entrants'. Identical submissions are rejected.</em>`},
+
+  {id:"B", ko:["산화 안정성","높은 전압을 견디는 설계 (35점)"], en:["Oxidation","Holding up at high voltage (35 pts)"],
+   body:`Propose solid lithium-ion electrolytes designed specifically for a WIDE oxidation
+window, so they survive against a high-voltage cathode.
+
+Reason from this:
+- The anion is usually what oxidises first. Sulfide frameworks conduct well but oxidise at
+  low potential; more electronegative anions push the oxidation limit higher.
+- The counter-cation matters: a cation already in a high oxidation state has less room to
+  be oxidised further.
+- A material that resists oxidation but has no lithium pathway is worthless. A connected
+  migration path is a precondition, not a trade-off.
+
+For each candidate state explicitly: which anion framework you chose and why you expect it
+to resist oxidation, and how lithium still moves through it.
+
+Propose 8 candidates as JSON: [{"formula","name","rationale"}]
+
+<em>VARY THIS: commit to ONE anion chemistry and build the whole set around it, rather than
+eight unrelated guesses.</em>`},
+
+  {id:"C", ko:["리튬금속 안정성","음극에서 버티는 설계 (30점)"], en:["Lithium-metal stability","Surviving the anode (30 pts)"],
+   body:`Propose solid lithium-ion electrolytes designed to survive direct contact with
+LITHIUM METAL.
+
+Reason from this:
+- Lithium metal is strongly reducing. Any cation in the electrolyte that can be reduced
+  will be. Transition metals in high oxidation states are the classic failure: they reduce,
+  the interface becomes electronically conductive, and the reaction never stops.
+- The useful case is a decomposition product that is itself an insulator, so the interface
+  passivates and the reaction halts.
+- Wide oxidation window alone does not help if the anode side fails. Both ends of the
+  window matter.
+
+For each candidate state explicitly: which element you expect lithium metal to attack, and
+why the interface should stop reacting rather than keep going.
+
+Propose 8 candidates as JSON: [{"formula","name","rationale"}]
+
+<em>VARY THIS: choose one strategy — reduction-proof cations, or a self-passivating
+decomposition product — and build the set around it.</em>`},
+
+  {id:"D", ko:["용도 신규성","가장 큰 점수 여지 (20점)"], en:["Use novelty","Where the headroom is (20 pts)"],
+   body:`Propose lithium-containing compositions that are NOT already reported as solid
+electrolytes.
+
+Important distinction: the composition does not have to be brand new. What matters is
+whether anyone has proposed it FOR THIS USE. A known compound that nobody has evaluated as
+a lithium electrolyte is exactly the target; a well-studied electrolyte family is not.
+
+So avoid the ones already worked over — the common sulfide, garnet, NASICON and
+argyrodite electrolyte families — and look at lithium compounds studied for other reasons
+entirely, or not studied much at all.
+
+Every candidate must still meet the basics: a lithium migration path, electronic
+insulation, and reasonable stability at both electrodes. Novelty with no function scores
+nothing.
+
+For each candidate state: what the composition is normally known for (if anything), and
+why it might work as an electrolyte.
+
+Propose 8 candidates as JSON: [{"formula","name","rationale"}]
+
+<em>VARY THIS: pick one source of overlooked compounds — a mineral class, a family studied
+for optics or ionics elsewhere, a ternary system that is sparsely mapped — and work it.</em>`}
+ ]
+};
+
 const $ = s => document.querySelector(s);
 const COLS = ["rank","cand","user","who","date","oxidation","li_stability","migration","novelty","total"];
 // 표가 커지면 한꺼번에 그리지 않고 한 페이지씩 그린다.
@@ -267,6 +441,13 @@ function setLang(l){
   $("#t_broker_h").textContent = d.broker_h;
   $("#t_broker").innerHTML = d.broker;
   $("#t_cifnote").innerHTML = d.cifnote;
+  $("#t_guide_h").textContent = d.guide_h;
+  $("#t_guide_lead").innerHTML = d.guide_lead;
+  $("#t_guide_how").innerHTML = d.guide_how;
+  $("#t_models_h").textContent = d.models_h;
+  $("#t_models_lead").innerHTML = d.models_lead;
+  renderFacts();
+  renderPrompts();
   $("#t_priv").textContent = d.priv;
   $("#t_pub").textContent = d.pub;
   $("#go").textContent = d.go;
@@ -284,7 +465,8 @@ function renderSeasonBar(){
       #${s.number} ${esc(nm)}</button>`;
   }).join("");
   document.querySelectorAll("#seasonbar button").forEach(b=>
-    b.onclick=()=>{ SEASON=parseInt(b.dataset.season,10); page=0; renderSeasonBar(); load(); });
+    b.onclick=()=>{ SEASON=parseInt(b.dataset.season,10); page=0;
+      renderSeasonBar(); renderPrompts(); load(); loadModels(); });
 }
 
 function sortVal(e,k){
@@ -297,6 +479,58 @@ function sortVal(e,k){
   return (e.axes||{})[k] ?? -1;
 }
 
+function promptsFor(){ return PROMPTS_BY_SEASON[SEASON] || PROMPTS_BY_SEASON[1]; }
+
+function renderPrompts(){
+  const d = t(), host = $("#prompts");
+  if(!host) return;
+  host.innerHTML = promptsFor().map((p,i)=>{
+    const [title,sub] = (LANG==="ko" ? p.ko : p.en);
+    return `<div class="pcard">
+      <div class="phead"><span class="ptag">${p.id}</span><b>${esc(title)}</b><span>${esc(sub)}</span>
+        <button class="pcopy" data-i="${i}">${LANG==="ko"?"복사":"Copy"}</button></div>
+      <div class="pbody">${p.body.trim()}</div></div>`;
+  }).join("");
+  host.querySelectorAll(".pcopy").forEach(b=>b.onclick=async()=>{
+    // 강조 표시는 화면용이다. 클립보드에는 깨끗한 본문만 넣는다.
+    const raw = promptsFor()[+b.dataset.i].body.replace(/<\/?em>/g,"").trim();
+    try{ await navigator.clipboard.writeText(raw); }
+    catch(_){ const ta=document.createElement("textarea"); ta.value=raw;
+      document.body.appendChild(ta); ta.select(); document.execCommand("copy"); ta.remove(); }
+    const was=b.textContent;
+    b.textContent = LANG==="ko" ? "복사됨 ✓" : "Copied ✓";
+    setTimeout(()=>{ b.textContent=was; },1500);
+  });
+}
+
+function renderFacts(){
+  const d = t();
+  $("#facts").innerHTML = (d.facts||[]).map(([k,v])=>
+    `<div class="fact"><b>${esc(k)}</b>${esc(v)}</div>`).join("");
+}
+
+function renderModels(m){
+  const d = t(), host = $("#models");
+  const rows = (m && m.models) || [];
+  $("#mcounts").textContent = d.mcounts((m&&m.counts&&m.counts.models)||0,
+                                        (m&&m.counts&&m.counts.entries)||0);
+  $("#t_mlegend").innerHTML = d.mlegend;
+  if(!rows.length){ host.innerHTML = `<div class="note">${d.mempty}</div>`; return; }
+  const max = Math.max(...rows.map(r=>r.best), 1);
+  host.innerHTML = rows.slice(0,14).map(r=>`
+    <div class="mrow">
+      <div class="mname" title="${esc(r.model)}">${esc(r.model)}</div>
+      <div class="mbar"><i style="width:${(r.best/max*100).toFixed(1)}%"></i>
+        <u style="left:${(r.mean/max*100).toFixed(1)}%"></u></div>
+      <div class="mnum">${r.best.toFixed(1)} · ${r.n}</div>
+    </div>`).join("");
+}
+
+async function loadModels(){
+  try{ renderModels(await (await fetch(`/api/models?season=${SEASON}`)).json()); }
+  catch(e){ renderModels(null); }
+}
+
 function renderPager(total,pages){
   const host = $("#pager"), d = t();
   if(pages<=1){ host.innerHTML=""; return; }
@@ -397,7 +631,7 @@ $("#go").onclick = async () => {
     const j = await r.json();
     if(!r.ok){ m.className="msg bad"; m.textContent = j.detail || ("HTTP "+r.status); }
     else{ m.className="msg ok"; m.innerHTML = d.ok(j.candidate_id, j.queue_position);
-          $("#f_formula").value=""; $("#f_cif").value=""; load(); }
+          $("#f_formula").value=""; $("#f_cif").value=""; load(); loadModels(); }
   }catch(e){ m.className="msg bad"; m.textContent=String(e); }
   $("#go").disabled = false;
 };
@@ -417,7 +651,9 @@ $("#go").onclick = async () => {
   }catch(e){}
   setLang("ko");
   await load();
+  loadModels();
   setInterval(load, 20000);
+  setInterval(loadModels, 600000);
 })();
 </script>
 </body>

seasons.py

@@ -3,7 +3,7 @@
 
 시즌마다 대상 물질군·게이트·배점이 다르다. 한 프로세스가 모든 시즌을 서빙하므로
 설정은 **환경변수가 아니라 인자**로 흐른다 - 환경변수로 두면 시즌 하나의 설정이
-다른 시즌 요청에 새어 들어간다 (ODC 에서 실제로 그럴 뻔했다).
+다른 시즌 요청에 새어 들어간다.
 """
 
 SEASONS = [

store.py

@@ -131,12 +131,8 @@ class Cached:
     Staleness is bounded and harmless here: the worst case is a leaderboard a few seconds
     behind, and the page polls anyway.
 
-    **Single flight.** The first version had no lock, so every concurrent request that
-    arrived after the TTL expired saw a miss and every one of them re-ran produce(). With
-    a few thousand entries that is a full paginated tree listing each, and on a 2-vCPU
-    container the request threadpool fills with blocked Hub I/O - at which point even the
-    static index page queues behind it and the site stops answering. One refresher at a
-    time; everyone else is served the value we already have.
+    **Single flight.** One refresher at a time; everyone else is served the value already
+    held, so an expiry does not send every concurrent request to the Hub at once.
 
     **Stale beats blocking, and stale beats an error.** A leaderboard a minute old is a
     working page. A timeout is not.