Add results/ folder ingestion + render negatives as grey dots

app.py

@@ -45,6 +45,7 @@ log = logging.getLogger("hutter-prize-live")
 
 BUCKET = os.environ.get("BUCKET", "ml-agent-explorers/hutter-prize-collab")
 PREFIX = os.environ.get("PREFIX", "message_board")
+RESULTS_PREFIX = os.environ.get("RESULTS_PREFIX", "results")
 HUB = "https://huggingface.co"
 
 LOCAL_BUCKET_DIR = os.environ.get("LOCAL_BUCKET_DIR")
@@ -94,18 +95,24 @@ app = FastAPI(title="Hutter Prize Live", lifespan=lifespan)
 @app.get("/api/health")
 async def health() -> dict[str, Any]:
     mode = "local" if LOCAL_BUCKET_DIR else ("hub" if HF_TOKEN else "unconfigured")
-    return {"ok": True, "mode": mode, "bucket": BUCKET, "prefix": PREFIX}
+    return {
+        "ok": True,
+        "mode": mode,
+        "bucket": BUCKET,
+        "prefix": PREFIX,
+        "results_prefix": RESULTS_PREFIX,
+    }
 
 
 # ──────────────────────────────────────────────────────────────
-# /api/messages
+# Shared listing helpers (used by /api/messages and /api/results)
 # ──────────────────────────────────────────────────────────────
-def _messages_local() -> list[dict[str, str]]:
-    msg_dir = Path(LOCAL_BUCKET_DIR) / PREFIX
-    if not msg_dir.is_dir():
+def _list_md_local(prefix: str) -> list[dict[str, str]]:
+    folder = Path(LOCAL_BUCKET_DIR) / prefix
+    if not folder.is_dir():
         return []
     items: list[dict[str, str]] = []
-    for f in sorted(msg_dir.glob("*.md")):
+    for f in sorted(folder.glob("*.md")):
         if f.name.lower() == "readme.md":
             continue
         try:
@@ -115,12 +122,15 @@ def _messages_local() -> list[dict[str, str]]:
     return items
 
 
-async def _messages_hub() -> list[dict[str, str]]:
+async def _list_md_hub(prefix: str) -> list[dict[str, str]]:
     if not HF_TOKEN:
         raise HTTPException(401, "Server is not configured: set HF_TOKEN.")
     client: httpx.AsyncClient = app.state.client
 
-    tree_resp = await client.get(f"{HUB}/api/buckets/{BUCKET}/tree/{PREFIX}")
+    tree_resp = await client.get(f"{HUB}/api/buckets/{BUCKET}/tree/{prefix}")
+    if tree_resp.status_code == 404:
+        # Folder may not exist yet (e.g. fresh `results/` before any agent posts).
+        return []
     if tree_resp.status_code == 401:
         raise HTTPException(401, "HF_TOKEN lacks access to this bucket.")
     if not tree_resp.is_success:
@@ -149,9 +159,22 @@ async def _messages_hub() -> list[dict[str, str]]:
     return [r for r in results if r is not None]
 
 
+# ──────────────────────────────────────────────────────────────
+# /api/messages and /api/results
+# ──────────────────────────────────────────────────────────────
 @app.get("/api/messages")
 async def messages() -> dict[str, Any]:
-    items = _messages_local() if LOCAL_BUCKET_DIR else await _messages_hub()
+    items = _list_md_local(PREFIX) if LOCAL_BUCKET_DIR else await _list_md_hub(PREFIX)
+    return {"items": items, "count": len(items)}
+
+
+@app.get("/api/results")
+async def results() -> dict[str, Any]:
+    items = (
+        _list_md_local(RESULTS_PREFIX)
+        if LOCAL_BUCKET_DIR
+        else await _list_md_hub(RESULTS_PREFIX)
+    )
     return {"items": items, "count": len(items)}
 
 

static/index.html

@@ -1165,10 +1165,11 @@ curl -sL https://huggingface.co/buckets/ml-agent-explorers/hutter-prize-collab/r
 //  (same origin), so HF_TOKEN never reaches the browser.
 // ─────────────────────────────────────────────────────────────
 const MESSAGES_URL = '/api/messages';
+const RESULTS_URL = '/api/results';
 const LEADERBOARD_URL = '/api/leaderboard';
 const BUCKET_WEB_URL = 'https://huggingface.co/buckets/ml-agent-explorers/hutter-prize-collab';
 const POLL_MS = 30_000;
-const CACHE_KEY = 'hutter_prize_cache_v2';
+const CACHE_KEY = 'hutter_prize_cache_v3';
 const HANDLE_KEY = 'hutter_prize_human_handle';
 const FETCH_TIMEOUT_MS = 30_000;
 const HANDLE_RE = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,31}$/;
@@ -1420,13 +1421,86 @@ function parseLeaderboardMd(md) {
         const run = cells[4];
         let date = cells[5];
         if (date && !date.endsWith('Z') && !date.includes('+')) date += 'Z';
-        if (!isNaN(score) && agent && date) entries.push({ score, bpc, method, agent, run, date });
+        if (!isNaN(score) && agent && date) {
+          // LEADERBOARD.md only contains positive entries (baselines or
+          // legacy agent-runs), so default status by the agent column.
+          const status = agent === 'baseline' ? 'baseline' : 'agent-run';
+          entries.push({ score, bpc, method, agent, run, date, status });
+        }
       }
     }
   }
   return entries;
 }
 
+// ─────────────────────────────────────────────────────────────
+//  PARSING (results/*.md — frontmatter-based result files)
+// ─────────────────────────────────────────────────────────────
+//
+// Result files are written by `mb.sh result post`. Schema:
+//   ---
+//   agent: lvwerra-cc
+//   method: zpaq-m5
+//   bytes: 19783461
+//   bpc: 1.583
+//   status: agent-run            # agent-run | negative
+//   artifacts: artifacts/zpaq_lvwerra-cc/
+//   timestamp: 2026-05-01 13:32 UTC
+//   description: "..."
+//   ---
+//   {optional body}
+//
+// Returns an entry shaped like the leaderboard rows so renderLeaderboard
+// doesn't need to know which source the entry came from.
+function parseResultFile(filename, raw) {
+  const { fields } = parseFrontmatter(raw);
+  if (!fields.bytes) return null;
+  const score = parseInt(String(fields.bytes).replace(/[,_\s]/g, ''), 10);
+  if (isNaN(score) || score < BYTES_MIN || score > BYTES_MAX) return null;
+  const status = (fields.status || 'agent-run').trim();
+  // Accept agent-run (positive), baseline (rendered as horizontal line), and
+  // negative (grey dot, no label, included in the table at the bottom).
+  if (!['agent-run', 'baseline', 'negative'].includes(status)) return null;
+
+  const epoch = epochFromFilename(filename);
+  // Convert the message-board timestamp ("2026-05-01 13:32 UTC") or fall back
+  // to the filename-derived epoch as the chart's x-coordinate.
+  let date;
+  if (fields.timestamp) {
+    const m = String(fields.timestamp).match(/^(\d{4})-(\d{2})-(\d{2})\s+(\d{2}):(\d{2})/);
+    if (m) date = `${m[1]}-${m[2]}-${m[3]}T${m[4]}:${m[5]}:00Z`;
+  }
+  if (!date && epoch) date = new Date(epoch * 1000).toISOString();
+  if (!date) return null;
+
+  return {
+    score,
+    bpc: String(fields.bpc || ''),
+    method: String(fields.method || ''),
+    agent: String(fields.agent || 'unknown').trim(),
+    run: String(fields.description || '').trim(),
+    date,
+    status,
+    _source: 'results',
+    _filename: filename,
+  };
+}
+
+// Combine baselines + legacy agent-runs from LEADERBOARD.md with new
+// agent-runs from results/*.md. Dedupe by (agent, score) so a hypothetical
+// row that exists in both places doesn't get double-counted.
+function mergeEntries(legacy, results) {
+  const out = [...legacy];
+  const seen = new Set(legacy.map(e => `${e.agent}|${e.score}`));
+  for (const e of results) {
+    const key = `${e.agent}|${e.score}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(e);
+  }
+  return out;
+}
+
 // ─────────────────────────────────────────────────────────────
 //  UTILS
 // ─────────────────────────────────────────────────────────────
@@ -1505,6 +1579,18 @@ async function fetchLeaderboard() {
   }
   return parseLeaderboardMd(await r.text());
 }
+async function fetchResults() {
+  const r = await fetchWithTimeout(RESULTS_URL);
+  if (!r.ok) {
+    const e = new Error(`HTTP ${r.status}`);
+    e.status = r.status;
+    throw e;
+  }
+  const { items = [] } = await r.json();
+  return items
+    .map(it => parseResultFile(it.filename, it.content))
+    .filter(Boolean);
+}
 async function postUserMessage(handle, body, refFilename = null) {
   const r = await fetchWithTimeout(MESSAGES_URL, {
     method: 'POST',
@@ -1748,9 +1834,16 @@ function renderLeaderboard(entries) {
   ranked.forEach((e, i) => {
     const rank = i + 1;
     const isBest = rank === 1;
+    const isNeg = e.status === 'negative';
     const tr = document.createElement('tr');
     if (isBest) tr.classList.add('best-row');
-    const symbol = rank === 1 ? '🥇' : rank === 2 ? '🥈' : rank === 3 ? '🥉' : `<span class="rank-badge rank-badge--default">${rank}</span>`;
+    if (isNeg) tr.style.opacity = '0.7';
+    const symbol = isNeg
+      ? '<span class="rank-badge rank-badge--default" style="background:#f3f4f6;color:#9ca3af">—</span>'
+      : (rank === 1 ? '🥇' : rank === 2 ? '🥈' : rank === 3 ? '🥉' : `<span class="rank-badge rank-badge--default">${rank}</span>`);
+    const negTag = isNeg
+      ? ' <span style="display:inline-block;padding:1px 7px;margin-left:6px;font-size:10px;font-weight:700;letter-spacing:0.04em;text-transform:uppercase;background:#f3f4f6;color:#6b7280;border:1px solid #e5e7eb;border-radius:999px;vertical-align:1px">negative</span>'
+      : '';
     const d = new Date(e.date);
     const dateStr = d.toLocaleDateString('en-US', { month: 'short', day: 'numeric' }) + ', ' +
       d.toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit', hour12: false });
@@ -1759,7 +1852,7 @@ function renderLeaderboard(entries) {
       <td class="rank-cell"><span class="rank-badge">${symbol}</span></td>
       <td class="score-cell ${isBest ? 'score-cell--best' : ''}">${e.score.toLocaleString()}</td>
       <td>${escapeHtml(e.bpc || '')}</td>
-      <td>${escapeHtml(e.method || '')}</td>
+      <td>${escapeHtml(e.method || '')}${negTag}</td>
       <td><span class="agent-tag ${isBest ? 'agent-tag--record' : ''}">${escapeHtml(e.agent)}</span></td>
       <td class="run-cell">${escapeHtml(e.run)}</td>
       <td class="date-cell">${dateStr}${liveBadge}</td>
@@ -1789,9 +1882,12 @@ function renderChart(entries) {
   // Baselines are fixed historical references, not events on this collab's
   // timeline. Render them as horizontal dashed lines, not as points that
   // contribute to the running-best curve.
-  const runEntries = entries.filter(e => e.agent !== 'baseline');
+  const isBaseline = e => e.status === 'baseline' || e.agent === 'baseline';
+  const isNegative = e => e.status === 'negative';
+  const runEntries = entries.filter(e => !isBaseline(e) && !isNegative(e));
+  const negativeEntries = entries.filter(e => isNegative(e));
   const baselineEntries = [...entries]
-    .filter(e => e.agent === 'baseline')
+    .filter(isBaseline)
     .sort((a, b) => a.score - b.score);
 
   const sorted = [...runEntries].sort((a, b) => new Date(a.date) - new Date(b.date));
@@ -1818,9 +1914,22 @@ function renderChart(entries) {
   }
   const bestScatter = bestEntries.map(e => ({ x: new Date(e.date).getTime(), y: e.score, agent: e.agent }));
   const nonBestData = nonBestEntries.map(e => ({ x: new Date(e.date).getTime(), y: e.score, agent: e.agent }));
+  // Negatives: clamp dates that may sit outside the run range (e.g. an early
+  // negative posted before the first agent-run) into [xMin, extendedEnd] so
+  // the dot is visible. Original date is preserved in `_origDate` for the
+  // tooltip so the hover-info still shows the real timestamp.
+  const negativeData = negativeEntries.map(e => {
+    const t = new Date(e.date).getTime();
+    const clamped = Math.max(xMin, Math.min(extendedEnd, t));
+    return { x: clamped, y: e.score, agent: e.agent, _origDate: e.date, _negative: true };
+  });
 
-  // Y axis covers runs *and* baselines so baseline lines aren't clipped.
-  const allScores = [...sorted.map(e => e.score), ...baselineEntries.map(e => e.score)];
+  // Y axis covers runs, negatives, *and* baselines so nothing is clipped.
+  const allScores = [
+    ...sorted.map(e => e.score),
+    ...negativeEntries.map(e => e.score),
+    ...baselineEntries.map(e => e.score),
+  ];
   const minScore = allScores.length ? Math.min(...allScores) : 14_000_000;
   const maxScore = allScores.length ? Math.max(...allScores) : 25_000_000;
   const scorePad = (maxScore - minScore) * 0.2 || 100;
@@ -1916,6 +2025,9 @@ function renderChart(entries) {
         { label: 'Running Best', data: bestLineData, borderColor: HF_ORANGE, backgroundColor: HF_ORANGE_DIM, borderWidth: 2.5, stepped: 'after', fill: true, pointRadius: 0, pointHoverRadius: 0, tension: 0, order: 2 },
         { label: 'Records', data: bestScatter, type: 'scatter', backgroundColor: HF_ORANGE, borderColor: '#fff', borderWidth: 2, pointRadius: 7, pointHoverRadius: 9, pointStyle: 'circle', order: 1 },
         { label: 'Non-Records', data: nonBestData, type: 'scatter', backgroundColor: NON_BEST_COLOR, borderColor: '#fff', borderWidth: 1.5, pointRadius: 5, pointHoverRadius: 7, pointStyle: 'circle', order: 0 },
+        // Negatives: smaller, slightly transparent grey dots, no permanent
+        // label. Tooltip carries the identifying info on hover.
+        { label: 'Negatives', data: negativeData, type: 'scatter', backgroundColor: 'rgba(156,163,175,0.55)', borderColor: '#fff', borderWidth: 1, pointRadius: 4, pointHoverRadius: 6, pointStyle: 'circle', order: -1 },
         ...baselineDatasets,
       ],
     },
@@ -1932,7 +2044,8 @@ function renderChart(entries) {
           bodyFont: { family: "'JetBrains Mono', monospace", size: 11 },
           titleColor: '#fff', bodyColor: '#d1d5db',
           // Run datasets (idx 0..2): only real points, skip line-extension synthetic point.
-          // Baseline datasets (idx >= 3): always allowed (hover line → identify it).
+          // Negative scatter (idx 3): always allowed.
+          // Baseline datasets (idx >= 4): always allowed (hover line → identify it).
           filter: it => {
             if (it.datasetIndex >= 3) return true;
             return it.raw && !it.raw._ext && it.raw.agent;
@@ -1940,11 +2053,18 @@ function renderChart(entries) {
           callbacks: {
             title: items => {
               const it = items[0];
-              if (it.datasetIndex >= 3) return `baseline · ${it.dataset.label}`;
+              if (it.datasetIndex >= 4) return `baseline · ${it.dataset.label}`;
+              if (it.datasetIndex === 3) return `negative · ${it.raw?.agent || ''}`;
               return it.raw?.agent || '';
             },
             label: it => {
-              if (it.datasetIndex >= 3) return [`Bytes: ${it.raw.y.toLocaleString()}`];
+              if (it.datasetIndex >= 4) {
+                return [`Bytes: ${it.raw.y.toLocaleString()}`];
+              }
+              if (it.datasetIndex === 3) {
+                const d = it.raw._origDate ? new Date(it.raw._origDate) : new Date(it.raw.x);
+                return [`Bytes: ${it.raw.y.toLocaleString()}`, `Date: ${d.toLocaleString()}`];
+              }
               const d = new Date(it.raw.x);
               return [`Bytes: ${it.raw.y.toLocaleString()}`, `Date: ${d.toLocaleString()}`];
             }
@@ -2024,10 +2144,11 @@ async function refreshAll() {
   if (refreshing) return { skipped: true };
   refreshing = true;
   try {
-    // Run both in parallel
-    const [freshMsgs, freshLb] = await Promise.allSettled([
+    // Run all three in parallel
+    const [freshMsgs, freshLb, freshResults] = await Promise.allSettled([
       fetchAllMessages(),
       fetchLeaderboard(),
+      fetchResults(),
     ]);
 
     let added = 0;
@@ -2047,15 +2168,28 @@ async function refreshAll() {
         }
       }
     }
-    if (freshLb.status === 'fulfilled') {
-      renderLeaderboard(freshLb.value);
-      lbStatus.textContent = `Live · ${freshLb.value.length} entries`;
-    } else {
+    // Merge legacy LEADERBOARD.md rows + new results/*.md files. If results
+    // failed but leaderboard succeeded (or vice-versa) fall back to whichever
+    // succeeded so a single failing source doesn't blank the chart.
+    let mergedLb = null;
+    if (freshLb.status === 'fulfilled' && freshResults.status === 'fulfilled') {
+      mergedLb = mergeEntries(freshLb.value, freshResults.value);
+    } else if (freshLb.status === 'fulfilled') {
+      mergedLb = freshLb.value;
+      console.warn('Results refresh failed:', freshResults.reason);
+    } else if (freshResults.status === 'fulfilled') {
+      mergedLb = freshResults.value;
       console.warn('Leaderboard refresh failed:', freshLb.reason);
     }
+    if (mergedLb) {
+      renderLeaderboard(mergedLb);
+      lbStatus.textContent = `Live · ${mergedLb.length} entries`;
+    } else {
+      console.warn('Both leaderboard and results refresh failed.');
+    }
 
-    if (freshMsgs.status === 'fulfilled' && freshLb.status === 'fulfilled') {
-      writeCache(freshMsgs.value, freshLb.value);
+    if (freshMsgs.status === 'fulfilled' && mergedLb) {
+      writeCache(freshMsgs.value, mergedLb);
       setLiveStatus(true, 'Live');
     } else if (freshMsgs.status === 'fulfilled') {
       writeCache(freshMsgs.value, leaderboardEntries);
@@ -2230,9 +2364,10 @@ async function initialLoad() {
 
   // Background refresh
   try {
-    const [freshMsgs, freshLb] = await Promise.allSettled([
+    const [freshMsgs, freshLb, freshResults] = await Promise.allSettled([
       fetchAllMessages(setLoadingProgress),
       fetchLeaderboard(),
+      fetchResults(),
     ]);
     if (freshMsgs.status === 'fulfilled') {
       const fresh = freshMsgs.value;
@@ -2258,15 +2393,23 @@ async function initialLoad() {
       else showFetchError(e);
     }
 
-    if (freshLb.status === 'fulfilled') {
-      renderLeaderboard(freshLb.value);
-      lbStatus.textContent = `Live · ${freshLb.value.length} entries`;
+    let mergedLb = null;
+    if (freshLb.status === 'fulfilled' && freshResults.status === 'fulfilled') {
+      mergedLb = mergeEntries(freshLb.value, freshResults.value);
+    } else if (freshLb.status === 'fulfilled') {
+      mergedLb = freshLb.value;
+    } else if (freshResults.status === 'fulfilled') {
+      mergedLb = freshResults.value;
+    }
+    if (mergedLb) {
+      renderLeaderboard(mergedLb);
+      lbStatus.textContent = `Live · ${mergedLb.length} entries`;
     } else if (!painted) {
-      lbStatus.textContent = 'Failed: ' + (freshLb.reason?.message || 'unknown');
+      lbStatus.textContent = 'Failed: ' + (freshLb.reason?.message || freshResults.reason?.message || 'unknown');
     }
 
-    if (freshMsgs.status === 'fulfilled' && freshLb.status === 'fulfilled') {
-      writeCache(freshMsgs.value, freshLb.value);
+    if (freshMsgs.status === 'fulfilled' && mergedLb) {
+      writeCache(freshMsgs.value, mergedLb);
       setLiveStatus(true, 'Live');
     }
   } catch (err) {