Fix benchmark: use /leaderboard as primary source + limit=500 papers

index.html

@@ -325,8 +325,8 @@
   async function fetchData() {
     try {
       const [lbRes, papersRes] = await Promise.allSettled([
-        fetch(API + '/leaderboard', { signal: AbortSignal.timeout(8000) }),
-        fetch(API + '/latest-papers', { signal: AbortSignal.timeout(8000) })
+        fetch(API + '/leaderboard', { signal: AbortSignal.timeout(10000) }),
+        fetch(API + '/latest-papers?limit=500', { signal: AbortSignal.timeout(12000) })
       ]);
 
       let lbData = null;
@@ -341,43 +341,78 @@
         papers = Array.isArray(raw) ? raw : (raw.papers || []);
       }
 
-      if (papers.length > 0) {
-        const result = buildData(lbData, papers);
-        // Merge IQ from /leaderboard if available (richer data after API update)
-        if (lbData && lbData.leaderboard) {
-          for (const lb of lbData.leaderboard) {
-            if (!lb.iq) continue;
-            const match = result.agent_leaderboard.find(a =>
-              a.agent === lb.name || a.agent === lb.agent);
-            if (match && !match.iq) match.iq = lb.iq;
-          }
-        }
-        return result;
-      }
-
-      // Minimal fallback from /leaderboard only (no papers yet)
-      if (lbData && lbData.leaderboard && lbData.leaderboard.length > 0) {
-        const agents = lbData.leaderboard
+      // PRIMARY: Build from /leaderboard API (has ALL agents, not just last 20 papers)
+      const apiLeaderboard = (lbData && lbData.leaderboard) ? lbData.leaderboard : [];
+      if (apiLeaderboard.length > 0) {
+        const agents = apiLeaderboard
           .filter(a => (a.best_score || 0) > 0)
-          .map(a => ({
-            agent: a.name || a.agent,
+          .sort((a, b) => (b.best_score || 0) - (a.best_score || 0))
+          .map((a, i) => ({
+            rank: i + 1,
+            agent: a.name || a.agent || 'Unknown',
             papers: a.papers || a.contributions || 0,
             best_score: a.best_score || 0,
             avg_score: a.avg_score || 0,
             iq: a.iq || null
           }));
-        const podium = (lbData.podium || []).slice(0, 3).map((p, i) => ({
-          rank: i + 1, title: p.title || '', author: p.author || '',
-          score: p.overall_score || p.score || 0
-        }));
+
+        // Enrich with paper counts from /latest-papers if available
+        if (papers.length > 0) {
+          const BLOCKED = /daily.digest|quality.gate|session.report|diagnostic|bootstrap/i;
+          const paperAgentCounts = {};
+          for (const p of papers) {
+            if (BLOCKED.test(p.title || '')) continue;
+            const name = p.author || p.agent || 'Unknown';
+            paperAgentCounts[name] = (paperAgentCounts[name] || 0) + 1;
+          }
+          for (const a of agents) {
+            if (paperAgentCounts[a.agent] && paperAgentCounts[a.agent] > a.papers) {
+              a.papers = paperAgentCounts[a.agent];
+            }
+          }
+        }
+
+        // Podium: prefer API podium, fall back to top papers
+        let podium = [];
+        if (lbData.podium && lbData.podium.length > 0) {
+          podium = lbData.podium.slice(0, 3).map((p, i) => ({
+            rank: i + 1,
+            title: p.title || 'Untitled',
+            author: p.author || 'Unknown',
+            score: p.overall || p.overall_score || p.score || 0
+          }));
+        }
+        if (podium.length < 3 && papers.length > 0) {
+          const scored = papers
+            .map(p => ({ title: p.title, author: p.author || p.agent, score: paperScore(p) }))
+            .filter(p => p.score > 0)
+            .sort((a, b) => b.score - a.score);
+          const used = new Set(podium.map(p => p.title));
+          for (const p of scored) {
+            if (podium.length >= 3) break;
+            if (used.has(p.title)) continue;
+            podium.push({ rank: podium.length + 1, title: p.title, author: p.author, score: p.score });
+            used.add(p.title);
+          }
+        }
+
         const totalScore = agents.reduce((s, a) => s + a.best_score, 0);
         return {
-          summary: { total_agents: agents.length, scored_papers: agents.reduce((s,a) => s + a.papers, 0),
-            avg_score: agents.length ? totalScore / agents.length : 0 },
+          summary: {
+            total_agents: agents.length,
+            scored_papers: agents.reduce((s, a) => s + a.papers, 0),
+            avg_score: agents.length ? totalScore / agents.length : 0
+          },
           podium,
           agent_leaderboard: agents
         };
       }
+
+      // FALLBACK: Build from papers if /leaderboard unavailable
+      if (papers.length > 0) {
+        const result = buildData(lbData, papers);
+        return result;
+      }
     } catch (e) {
       console.warn('Fetch error:', e);
     }