{active &&

} {children}

); } // ─── Scan Line ──────────────────────────────────────────────── function ScanLine({ color, active }) { if (!active) return null; return (

); } // ─── Agent Card ─────────────────────────────────────────────── function AgentCard({ agent, status, result, index }) { const thinking = status === 'thinking'; const done = status === 'done'; const c = agent.color; return ( {thinking && }

{agent.icon} {thinking &&

} {done &&

✓

}

{agent.name} {agent.specialty}

{thinking && (

{[0,1,2].map(i=>

)} {t('analysing')}

)} {done && result && (

{result.bet_label} {result.risk} {result.weather_impact && result.weather_impact!=='NEUTRAL' && ( 🌦️{result.weather_impact} )}

)} {status==='pending' && {t('pendingWave')} {agent.wave} {t('waitingSuffix')}} {status==='error' && {t('error_conn')} Fallback aktiv}

{done && result && (

{result.confidence}

)}

{done && result?.reasoning && (

{result.reasoning}

{result.key_factor &&

→ {result.key_factor}

} {/* Weather specific */} {agent.id==='weather' && result.weather_impact && (

🌦️ {result.weather_impact}

)}

)} ); } // ─── Master Verdict ─────────────────────────────────────────── function MasterVerdict({ result, agent }) { const [visible, setVisible] = useState(false); useEffect(()=>{setTimeout(()=>setVisible(true),100);},[]); if (!result) return null; const c = agent.color; const consColor = getConsensusColor(result.consensus); return (

{agent.icon}

{t('masterDecision')}

{result.bet_label||result.final_pick}

{formatOdds(result.odds)}

{t('odds')}

{getRiskIcon(result.risk)} {result.risk} {result.consensus_count||'?'}/9 {t('of')} {result.confidence}% {t('confidence')}

{result.reasoning}

{result.key_factor &&

Entscheidend:{result.key_factor}

} {(() => { const alt = (result.alt_pick || '').toLowerCase(); const isEmpty = !alt || alt.includes('keine') || alt.includes('none') || alt.includes('n/a') || alt.includes('-'); if (isEmpty) return null; return

ALT: {result.alt_pick}

; })()} {(() => { const d = (result.dissent || '').toLowerCase(); // Hide "no dissent" messages: hide if it says "kein dissens", "einheitlich", "all agree", "no dissent", etc. const noDissent = !d || d.startsWith('kein') || d.includes('einheitlich') || d.includes('all agree') || d.includes('no dissent') || d.includes('einig') || d.includes('konsens') || (typeof result.consensus_count === 'number' && result.consensus_count >= 8); if (noDissent) { // Positive consensus indicator instead if (typeof result.consensus_count === 'number' && result.consensus_count >= 7) { return

✓ {t('strongConsensus').replace('{n}', result.consensus_count)}

; } return null; } return

⚠ {result.dissent}

; })()} {result.quant && } {result.ensemble && }

); } function EnsembleBreakdown({ e, accent }) { if (!e) return null; const consColor = e.agreeCount === e.total ? '#22ff88' : e.agreeCount >= 2 ? '#5ee7ff' : e.agreeCount === 1 ? '#ffb648' : '#ff5470'; const consLabel = e.agreeCount === e.total ? (currentLang==='tr'?'TAM KONSENSUS':currentLang==='en'?'FULL CONSENSUS':'VOLLER KONSENS') : e.agreeCount >= 2 ? (currentLang==='tr'?'ÇOĞUNLUK':currentLang==='en'?'MAJORITY':'MEHRHEIT') : (currentLang==='tr'?'BÖLÜNMÜŞ':currentLang==='en'?'SPLIT':'GETEILT'); const voices = [ e.master && { name:'DeepSeek V4', icon:'🧠', color:'#a855f7', ...e.master }, e.groq && { name:'Groq Llama-3.3', icon:'⚡', color:'#ffb648', ...e.groq }, e.gemini && { name:'OpenAI GPT-OSS 120B', icon:'✨', color:'#5ee7ff', ...e.gemini }, ].filter(Boolean); return (

🎼 ENSEMBLE · 3 STIMMEN · {consLabel} {e.agreeCount}/{e.total}

{voices.map((v,i) => (

0?'1px solid rgba(255,255,255,0.05)':'none'}}> {v.icon}

{v.name} {v.agrees?'✓':'≠'}{v.confidence!=null?` ${v.confidence}%`:''}

{v.pick}

{v.reasoning && !v.agrees &&

{v.reasoning}

}

))}

); } function QuantBreakdown({ q }) { if (!q) return null; const pct = (n) => `${(n*100).toFixed(0)}%`; const edgeColor = q.edge > 0.05 ? '#22ff88' : q.edge > 0 ? '#ffb648' : '#ff5470'; return (

⚙ {t('quantBlend')} · {q.method} EDGE {q.edge>0?'+':''}{(q.edge*100).toFixed(1)}%

{q.elo1X2 && }

	1	X	2
Poisson	{pct(q.poisson1X2.home)}	{pct(q.poisson1X2.draw)}	{pct(q.poisson1X2.away)}
Elo {q.elo1X2.ratings.home}/{q.elo1X2.ratings.away}	{pct(q.elo1X2.home)}	{pct(q.elo1X2.draw)}	{pct(q.elo1X2.away)}
LLM (9)	{pct(q.llm1X2.home)}	{pct(q.llm1X2.draw)}	{pct(q.llm1X2.away)}
BLEND	{pct(q.blended1X2.home)}	{pct(q.blended1X2.draw)}	{pct(q.blended1X2.away)}

); } // ─── Wave Label ─────────────────────────────────────────────── function WaveLabel({ wave, label, active, done }) { const c = active?'#22ff88':done?'rgba(255,255,255,0.4)':'rgba(255,255,255,0.15)'; return (

{wave}

{label} {active &&

}

); } // ─── Match Selector (Parallel Mode) ────────────────────────── function MatchSelector({ matches, selected, onToggle, onSelectAll, onClear }) { return (

SPIELE AUSWÄHLEN ({selected.length}/{matches.length})

{matches.map(m=>{ const sel = selected.includes(m.id); return (

onToggle(m.id)} style={{ display:'flex',alignItems:'center',gap:8,padding:'7px 10px', borderRadius:10,cursor:'pointer',transition:'all .2s', background:sel?'rgba(36,218,255,0.08)':'rgba(255,255,255,0.025)', border:`1px solid ${sel?'rgba(36,218,255,0.3)':'rgba(255,255,255,0.06)'}`, }}>

{sel?'✓':''}

{m.leagueFlag} {m.home} vs {m.away} {m.time}

); })}

); } // ─── Parallel Results Card ──────────────────────────────────── function ParallelResultCard({ match, result, onAddToTicket }) { const [exp, setExp] = useState(false); if (!result) return (

{match.home} vs {match.away}

); const c = getRiskColor(result.risk); return (

setExp(!exp)} style={{padding:'10px 12px',cursor:'pointer',display:'flex',alignItems:'center',gap:8}}>

{match.leagueFlag} {match.leagueShort} · {match.time}

{match.home} vs {match.away}

{result.bet_label||result.final_pick}

{formatOdds(result.odds)}

{result.confidence}%

▼

{exp && (

{result.reasoning}

)}

); } // ─── Agent Pipeline (Single + Parallel) ───────────────────── function AgentPipeline({ match, matches, onResultReady, onAddToTicket }) { const [mode, setMode] = useState('single'); // 'single' | 'parallel' const [selectedIds, setSelectedIds] = useState([]); const [parallelResults, setParallelResults] = useState({}); const [parallelRunning, setParallelRunning] = useState(false); const [parallelProgress, setParallelProgress] = useState(0); // Single mode state const wave1Agents = AGENTS.filter(a=>a.wave===1); const wave2Agents = AGENTS.filter(a=>a.wave===2); const riskAgent = AGENTS.find(a=>a.wave===3); const masterAgent = AGENTS.find(a=>a.wave===4); const [statuses, setStatuses] = useState(()=>Object.fromEntries(AGENTS.map(a=>[a.id,'pending']))); const [results, setResults] = useState({}); const [running, setRunning] = useState(false); const [waveActive, setWaveActive] = useState(0); const [enrichTick, setEnrichTick] = useState(0); const resultsRef = useRef({}); const scrollRef = useRef(null); // Enrich match with FATIGUE + LINEUP when selected useEffect(() => { if (!match || !window.enrichMatch) return; window.enrichMatch(match).then(() => setEnrichTick(t => t + 1)); }, [match?.id]); const setStatus = (id,s) => setStatuses(p=>({...p,[id]:s})); const setResult = (id,r) => { resultsRef.current[id]=r; setResults(p=>({...p,[id]:r})); }; const parseJSON = t => { try{const m=t.match(/\{[\s\S]*\}/);return m?JSON.parse(m[0]):null;}catch{return null;} }; const runAgent = async (agent,prompt) => { setStatus(agent.id,'thinking'); try { const text = await callAI(prompt); const parsed = parseJSON(text); const r = parsed||{recommendation:'HOME_WIN',bet_label:'Analyse fehlgeschlagen',confidence:60,reasoning:'KI-Verbindung unterbrochen.',key_factor:'-',risk:'GOOD'}; setResult(agent.id,r); setStatus(agent.id,'done'); return r; } catch(e) { const r={recommendation:'HOME_WIN',bet_label:'Fehler',confidence:55,reasoning:'Verbindungsfehler.',key_factor:'-',risk:'GOOD'}; setResult(agent.id,r); setStatus(agent.id,'error'); return r; } }; const startAnalysis = useCallback(async () => { if (running||!match) return; setRunning(true); setWaveActive(0); setResults({}); resultsRef.current={}; setStatuses(Object.fromEntries(AGENTS.map(a=>[a.id,'pending']))); const weather = match.weather; setWaveActive(1); const [s,st,inj,wthr] = await Promise.all([ runAgent(AGENTS[0],AGENTS[0].prompt(match)), runAgent(AGENTS[1],AGENTS[1].prompt(match)), runAgent(AGENTS[2],AGENTS[2].prompt(match)), runAgent(AGENTS[3],AGENTS[3].prompt(match,null,weather)), ]); const w1Summary=`Scout:${s?.bet_label}(${s?.confidence}%) Stats:${st?.bet_label}(${st?.confidence}%) Injury:${inj?.recommendation}(${inj?.rotation_risk||'MED'}) Weather:${wthr?.weather_impact||'NEUTRAL'}`; setWaveActive(2); const [tac,men,val,line] = await Promise.all([ runAgent(AGENTS[4],AGENTS[4].prompt(match,w1Summary)), runAgent(AGENTS[5],AGENTS[5].prompt(match,w1Summary)), runAgent(AGENTS[6],AGENTS[6].prompt(match,w1Summary)), runAgent(AGENTS[7],AGENTS[7].prompt(match,w1Summary)), ]); setWaveActive(3); const allRecs=[s,st,inj,wthr,tac,men,val,line].map((r,i)=>r?{agent:AGENTS[i]?.name,rec:r.bet_label,conf:r.confidence,risk:r.risk}:null); const risk = await runAgent(AGENTS[8],AGENTS[8].prompt(match,allRecs)); setWaveActive(4); // Wave 4: 3-Voice-Ensemble — DeepSeek MASTER + Groq Llama + Google Gemini parallel const allLLMResults = {scout:s,stats:st,injury:inj,weather:wthr,tactical:tac,mental:men,value:val,line,risk}; const ensemblePrompt = (engineName) => `Du bist ${engineName}, eine unabhängige KI als Teil eines 3-Stimmen-Ensembles. 9 Spezialisten haben analysiert: ${JSON.stringify(allLLMResults,null,1)} Spiel: ${match.home} vs ${match.away} (${match.league||match.leagueName}) Quoten: H${match.odds.home} X${match.odds.draw} A${match.odds.away} | BTTS:${match.btts?.yes} | O2.5:${match.overUnder?.o25} Gib eine UNABHÄNGIGE Einschätzung — nicht von den Spezialisten dominieren lassen. Antworte NUR als JSON: {"final_pick":"HOME_WIN|DRAW|AWAY_WIN|OVER_25|UNDER_25|BTTS_YES","bet_label":"...","odds":1.85,"confidence":78,"reasoning":"2 Sätze","key_factor":"...","risk":"SAFE|GOOD|RISK"}`; const [masterRes, groqText, gptOssText] = await Promise.all([ runAgent(AGENTS[9], AGENTS[9].prompt(match, allLLMResults)), callGroq(ensemblePrompt('GROQ Llama-3.3'), 800), callOpenAIOss(ensemblePrompt('OpenAI GPT-OSS 120B'), 800), ]); const groqRes = groqText ? parseJSON(groqText) : null; const geminiRes = gptOssText ? parseJSON(gptOssText) : null; // Quant-Override: blende Poisson + Elo + LLM-Konsens, ersetze final_pick const blended = computeQuantVerdict(match, masterRes, { ...allLLMResults, groq: groqRes, gemini: geminiRes }); let finalRes = blended ? { ...masterRes, ...blended } : masterRes; // 3-Voice-Vergleich: zähle Stimmen die mit Final-Pick übereinstimmen if (finalRes) { const norm = s => (s||'').toString().toUpperCase().replace(/[^A-Z]/g,''); const finalKey = norm(finalRes.final_pick || finalRes.bet_label).slice(0,4); const matches3 = (r) => { if (!r) return false; const k1 = norm(r.final_pick).slice(0,4); const k2 = norm(r.bet_label).slice(0,4); return k1 === finalKey || k2 === finalKey; }; const masterAgrees = matches3(masterRes); const groqAgrees = matches3(groqRes); const geminiAgrees = matches3(geminiRes); const agreeCount = (masterAgrees?1:0) + (groqAgrees?1:0) + (geminiAgrees?1:0); const validVoices = (masterRes?1:0) + (groqRes?1:0) + (geminiRes?1:0); finalRes.ensemble = { agreeCount, total: validVoices, master: masterRes ? { agrees: masterAgrees, pick: masterRes.bet_label || masterRes.final_pick, confidence: masterRes.confidence } : null, groq: groqRes ? { agrees: groqAgrees, pick: groqRes.bet_label || groqRes.final_pick, confidence: groqRes.confidence, reasoning: groqRes.reasoning } : null, gemini: geminiRes ? { agrees: geminiAgrees, pick: geminiRes.bet_label || geminiRes.final_pick, confidence: geminiRes.confidence, reasoning: geminiRes.reasoning } : null, }; // Confidence-Adjustment je nach Konsens if (validVoices >= 2 && finalRes.confidence) { if (agreeCount === validVoices) finalRes.confidence = Math.min(99, finalRes.confidence + 8); // Volle Einigkeit else if (agreeCount >= 2) finalRes.confidence = Math.min(99, finalRes.confidence + 3); // Mehrheit else if (agreeCount === 0) finalRes.confidence = Math.max(30, finalRes.confidence - 8); // Niemand stimmt zu (Quant alleine) } } setResult(AGENTS[9].id, finalRes); setRunning(false); setWaveActive(5); if (onResultReady&&finalRes) onResultReady(match.id,finalRes); if (scrollRef.current) scrollRef.current.scrollTo({top:scrollRef.current.scrollHeight,behavior:'smooth'}); },[match,running]); // ── Parallel Analysis ───────────────────────────────────── const runParallel = async () => { if (parallelRunning||selectedIds.length===0) return; setParallelRunning(true); setParallelProgress(0); setParallelResults({}); const toAnalyse = (matches||[]).filter(m=>selectedIds.includes(m.id)); const analyseOne = async (m) => { const weather = m.weather; try { const prompt = AGENTS[9].prompt(m, { scout:{bet_label:`${m.home} Sieg`,confidence:72,risk:'GOOD'}, stats:{bet_label:`O2.5 Tore`,confidence:68,risk:'GOOD'}, weather:{bet_label:`Wetter: ${weather?.label}`,confidence:65,risk:'GOOD',weather_impact:weather?.impact||'NEUTRAL'}, // Use fast single prompt for parallel mode }); // Faster: single master prompt with all context const fastPrompt = `Du bist MASTER Fußball-KI. Analysiere schnell: Spiel: ${m.home} vs ${m.away} (${m.league}, ${m.time}) Quoten: H${m.odds.home} X${m.odds.draw} A${m.odds.away} xG: H${m.xG.home} A${m.xG.away} | Form: H${m.form.home.join('')} A${m.form.away.join('')} Sharp Money: ${m.lineMovement?.sharpMoney||'NEUTRAL'} | Wetter: ${weather?.label} (${weather?.impact}) H2H: ${m.h2h} | AvgGoals: ${m.avgGoals} Antworte NUR als JSON: {"final_pick":"...","bet_label":"...","odds":1.85,"confidence":76,"reasoning":"2 Sätze","key_factor":"...","risk":"SAFE|GOOD|RISK","consensus":"MODERATE","consensus_count":6,"ticket_worthy":true,"alt_pick":"..."}`; const text = await callAI(fastPrompt); const parsed = text.match(/\{[\s\S]*\}/); return parsed ? JSON.parse(parsed[0]) : null; } catch(e) { return null; } }; // Run 3 at a time to avoid rate limits for (let i=0; i{ const m = batch[j]; setParallelResults(p=>({...p,[m.id]:r})); if (r&&onResultReady) onResultReady(m.id,r); }); setParallelProgress(Math.round((i+batch.length)/toAnalyse.length*100)); } setParallelRunning(false); }; const allDone = waveActive===5; const masterResult = results['master']; return (

{/* Mode Toggle */}

{[{id:'single',label:'🎯 Einzel'},{id:'parallel',label:'⚡ Multi'},{id:'liga',label:'🏆 Liga'}].map(m=>( ))}

{mode==='single' ? ( <> {/* Match Header */}

{match ? ( <>

{match.leagueFlag} {match.leagueShort} · {match.time}{match.importance?' · '+match.importance:''}

{/* Weather badge */} {match.weather && (

{match.weather.label} {match.weather.wind}km/h

)}

{match.home} vs {match.away}

{[{l:'H',v:match.odds.home},{l:'X',v:match.odds.draw},{l:'A',v:match.odds.away}].map(o=>(

{o.l}

{o.v.toFixed(2)}

))}

) : (

Kein Spiel ausgewählt — gehe zu "Heute"

)}

{/* Scrollable content: radar (top) + master decision */}

{/* Quant Model (Poisson) — always visible if match available */} {match && } {/* Only Master Decision */}

{masterResult ? ( ) : running ? (

{t('waveRunning').replace('{w}', waveActive).toUpperCase()}

{t('agentsAnalysing')}

) : (

{t('tapToStart')}

)}

{/* CTA */}

{!running&&!allDone&&match&&( )} {running&&(

{t('running')} {waveActive}/4 {t('of')}...

)} {allDone&&( )}

) : mode==='parallel' ? ( /* PARALLEL MODE */

setSelectedIds(p=>p.includes(id)?p.filter(x=>x!==id):[...p,id])} onSelectAll={()=>setSelectedIds((matches||[]).map(m=>m.id))} onClear={()=>setSelectedIds([])} />

{selectedIds.length===0&&(

⚡

Wähle Spiele für Parallel-Analyse

)} {(matches||[]).filter(m=>selectedIds.includes(m.id)).map(m=>( {})} /> ))} {Object.keys(parallelResults).length>0&&!parallelRunning&&(

✓ {Object.keys(parallelResults).length} Spiele analysiert · Tipps jetzt unter "Heute" sichtbar

)}

{parallelRunning ? (

⚡ Parallel-Analyse läuft... {parallelProgress}%

) : ( )}

) : mode==='liga' ? ( {})} /> ) : null}

); } // ─── Liga Analyse Result Row ────────────────────────────────── function LigaResultRow({ match, result, rank, onAddToTicket, isRunning }) { const [exp, setExp] = useState(false); // Pending — only show spinner if analysis is actively running if (!result) return isRunning ? (

{match.home} vs {match.away} {match.leagueFlag} {match.time}

) : null; const rc = getRiskColor(result.risk); const conf = result.confidence || 75; return (

setExp(!exp)} style={{ display:'flex', alignItems:'center', gap:8, padding:'8px 12px', cursor:'pointer' }}> {/* Rank */}

#{rank}

{/* Match info */}

{match.leagueFlag} {match.leagueShort} · {match.time}

{match.home} vs {match.away}

{result.bet_label || result.final_pick}

{/* Odds + Confidence */}

{(result.odds||2.0).toFixed(2)}

{conf}%

{exp?'▲':'▼'}

{/* Expanded */} {exp && (

{/* Confidence bar */}

KONFIDENZ {conf}%

{result.reasoning &&

{result.reasoning}

} {result.key_factor &&

→ {result.key_factor}

}

)}

); } // ─── Top 3 Summary Card ─────────────────────────────────────── function Top3Card({ results, matches, onAddToTicket, onAddAll }) { const top3 = results.slice(0, 3); if (top3.length === 0) return null; const totalOdds = top3.reduce((a, r) => a * (r.result?.odds || 1.85), 1); return (

🏆 TOP 3 HEUTE

Kombi-Quote: {totalOdds.toFixed(2)}

{top3.map((r, i) => { const rc = getRiskColor(r.result?.risk || 'GOOD'); return (

#{i+1}

{r.match.home} vs {r.match.away}

{r.result?.bet_label}

{(r.result?.odds||1.85).toFixed(2)}

{r.result?.confidence}%

); })}

); } // ─── Liga Analyse Screen ────────────────────────────────────── function LigaAnalyseScreen({ matches, onAddToTicket }) { const [selectedLeague, setSelectedLeague] = useState('ALL'); const [results, setResults] = useState({}); // matchId → result const [running, setRunning] = useState(false); const [progress, setProgress] = useState(0); const [sortBy, setSortBy] = useState('confidence'); // 'confidence' | 'odds' | 'risk' // Get unique leagues const leagues = ['ALL', ...new Set(matches.map(m => m.leagueShort))]; const leagueNames = { ALL:'🌍 Alle Ligen', ...Object.fromEntries(matches.map(m => [m.leagueShort, `${m.leagueFlag} ${m.leagueShort}`])) }; // Filter matches by league const filtered = selectedLeague === 'ALL' ? matches : matches.filter(m => m.leagueShort === selectedLeague); // Sorted results const sortedResults = Object.entries(results) .map(([id, result]) => ({ match: matches.find(m => m.id === id), result })) .filter(r => r.match && r.result) .sort((a, b) => { if (sortBy === 'confidence') return (b.result.confidence||0) - (a.result.confidence||0); if (sortBy === 'odds') return (b.result.odds||0) - (a.result.odds||0); if (sortBy === 'risk') { const riskOrder = { SAFE:0, GOOD:1, RISK:2 }; return (riskOrder[a.result.risk]||1) - (riskOrder[b.result.risk]||1); } return 0; }); const analyseLeague = async () => { if (running) return; // Only analyse matches in currently selected league that haven't been done yet const toRun = filtered.filter(m => !results[m.id]); if (toRun.length === 0) { setResults({}); return; } // reset if all done setRunning(true); setProgress(0); for (let i = 0; i < toRun.length; i += 3) { const batch = toRun.slice(i, i + 3); await Promise.all(batch.map(async m => { const weather = m.weather; const prompt = `Du bist Elite-Fußball-KI. Analysiere dieses Spiel präzise: Spiel: ${m.home} vs ${m.away} (${m.league}, ${m.time}) Quoten: H${m.odds.home} X${m.odds.draw} A${m.odds.away} | BTTS:${m.btts.yes} | O2.5:${m.overUnder.o25} xG: H${m.xG.home} A${m.xG.away} | Form: H${m.form.home.join('')} A${m.form.away.join('')} Sharp Money: ${m.lineMovement?.sharpMoney||'NEUTRAL'} | Wetter: ${weather?.label||'?'} (${weather?.impact||'NEUTRAL'}) H2H: ${m.h2h} | AvgGoals: ${m.avgGoals} | Heimpos: ${m.homePos}. | Auswärtspos: ${m.awayPos}. Antworte NUR als JSON: {"final_pick":"...","bet_label":"...","odds":1.85,"confidence":76,"reasoning":"2 präzise Sätze","key_factor":"...","risk":"SAFE|GOOD|RISK","ticket_worthy":true,"alt_pick":"..."}`; try { const text = await callAI(prompt); const parsed = text.match(/\{[\s\S]*\}/); if (parsed) { const result = JSON.parse(parsed[0]); setResults(p => ({ ...p, [m.id]: result })); } } catch(e) { console.warn('Liga analyse:', m.home, e.message); } })); setProgress(Math.round((i + Math.min(3, toRun.length - i)) / toRun.length * 100)); } setRunning(false); setProgress(100); }; const clearResults = () => { setResults({}); setProgress(0); }; const handleAddAll = () => { sortedResults.slice(0, 3).forEach(({ match, result }) => { if (result?.ticket_worthy !== false) onAddToTicket(match, result); }); }; const doneCount = Object.keys(results).length; const ticketWorthy = sortedResults.filter(r => r.result?.ticket_worthy !== false && (r.result?.confidence||0) >= 72); return (

{/* League Selector */}

LIGA WÄHLEN

{leagues.map(lk => { const a = selectedLeague === lk; const matchCount = lk === 'ALL' ? matches.length : matches.filter(m => m.leagueShort === lk).length; const doneInLeague = lk === 'ALL' ? doneCount : matches.filter(m => m.leagueShort === lk && results[m.id]).length; return ( ); })}

{/* Sort + Stats bar */} {doneCount > 0 && (

SORTIEREN: {[{k:'confidence',l:'KONFIDENZ'},{k:'odds',l:'QUOTE'},{k:'risk',l:'RISIKO'}].map(s => ( ))}

)} {/* Scrollable results */}

{/* Empty state — before first analysis */} {Object.keys(results).length === 0 && !running && (

🏆

{selectedLeague === 'ALL' ? 'Alle 18 Spiele' : `${filtered.length} Spiele in ${selectedLeague}`} bereit

Wähle eine Liga und klicke auf Analysieren.
Jede Analyse kostet API-Calls — gezielt einsetzen!

{filtered.map(m=>(

{m.leagueFlag} {m.home.split(' ')[0]} vs {m.away.split(' ')[0]}

))}

)} {/* Top 3 summary */} {sortedResults.length >= 3 && ( )} {/* Ticket-worthy picks highlight */} {ticketWorthy.length > 0 && (

✅ SCHEIN-WÜRDIG ({ticketWorthy.length} PICKS)

{ticketWorthy.length} Tipps mit ≥72% Konfidenz · Top-5 Kombi: {ticketWorthy.slice(0,5).reduce((a,r)=>a*(r.result?.odds||1.85),1).toFixed(2)}

)} {/* Pending (spinner only while running) */} {running && filtered.filter(m => !results[m.id]).map(m => ( ))} {/* Sorted results */} {sortedResults .filter(r => filtered.find(m => m.id === r.match.id)) .map((r, i) => ( )) }

{/* CTA */}

{/* API cost warning */} {!running && Object.keys(results).length === 0 && (

⚡ {filtered.length} API-Call{filtered.length>1?'s':''} · {selectedLeague === 'ALL' ? 'Alle Ligen' : `nur ${selectedLeague}`} · erst nach Klick

)} {running ? (

⚡ Analysiere {filtered.length} Spiele... {progress}%

{Object.keys(results).length}/{filtered.length} abgeschlossen

) : (

{ticketWorthy.length >= 2 && ( )}

)}

); } // ─── Erweiterte Radar-Knoten (Data + Quant + Ensemble) ──────── const RADAR_DATA_QUANT = [ // Wave 0 — Daten-Enricher (laufen vor dem KI-Komitee) { id:'fatigue', name:'FAT', color:'#ffb648', wave:0, type:'data', fullName:'Fatigue' }, { id:'lineup', name:'LIN', color:'#00ff88', wave:0, type:'data', fullName:'Lineup' }, { id:'motivation', name:'MOT', color:'#ffd700', wave:0, type:'data', fullName:'Motivation' }, { id:'referee', name:'REF', color:'#ff5470', wave:0, type:'data', fullName:'Referee' }, // Wave 4.5 — Ensemble Co-Master (parallel zu MASTER, andere Labs) { id:'groq', name:'GRQ', color:'#ffb648', wave:4, type:'ensemble', fullName:'Groq Llama-3.3 70B' }, { id:'gptoss', name:'GPT', color:'#5ee7ff', wave:4, type:'ensemble', fullName:'OpenAI GPT-OSS 120B' }, // Wave 5 — Quant-Anker (deterministisch, immer verfügbar) { id:'poisson', name:'POI', color:'#5ee7ff', wave:5, type:'quant', fullName:'Poisson 10k' }, { id:'elo', name:'ELO', color:'#a855f7', wave:5, type:'quant', fullName:'Elo Rating' }, ]; // Liefert die volle Knoten-Liste in Reihenfolge: data → wave1 → wave2 → wave3 → wave4 → ensemble → quant function getRadarAgents() { const dataNodes = RADAR_DATA_QUANT.filter(n => n.type === 'data'); const ensembleNodes = RADAR_DATA_QUANT.filter(n => n.type === 'ensemble'); const quantNodes = RADAR_DATA_QUANT.filter(n => n.type === 'quant'); return [ ...dataNodes, ...AGENTS.filter(a => a.wave === 1), ...AGENTS.filter(a => a.wave === 2), ...AGENTS.filter(a => a.wave === 3), ...AGENTS.filter(a => a.wave === 4), ...ensembleNodes, ...quantNodes, ]; } // Aggregat-Status für Multi/Liga-Modus: keine per-agent Daten verfügbar (nur ein // kumuliertes LLM-Result pro Match), daher zeigen alle 18 Knoten den Gesamtstatus — // running während Analyse, done mit avg-confidence wenn fertig, idle sonst. function getRadarAggregateResults(matchResults, running) { const agents = getRadarAgents(); const results = {}; const statuses = {}; const matchIds = Object.keys(matchResults || {}); if (matchIds.length === 0) { // Idle / pre-run — leeres Radar agents.forEach(a => { statuses[a.id] = 'idle'; }); return { results, statuses }; } const confidences = matchIds .map(id => matchResults[id]?.confidence) .filter(c => typeof c === 'number' && Number.isFinite(c)); const avg = confidences.length ? confidences.reduce((a, b) => a + b, 0) / confidences.length : 50; agents.forEach(a => { statuses[a.id] = running ? 'running' : 'done'; results[a.id] = { confidence: avg, dataQuality: 'aggregate' }; }); return { results, statuses }; } // Mappt Datenagent-Status + Quant-Probas auf Confidence-Werte für den Radar // Garantie: jeder Knoten kriegt IMMER einen sichtbaren Wert (Loading / no-data / partial / full) function getRadarResults(match, llmResults, llmStatuses) { const results = { ...llmResults }; const statuses = { ...llmStatuses }; const set = (id, status, conf, dataQuality) => { statuses[id] = status; if (conf != null) results[id] = { confidence: conf, dataQuality }; }; // FATIGUE if (!match?.fatigue) { set('fatigue', 'running'); } else if (match.fatigue.status === 'ok') { const both = match.fatigue.home && match.fatigue.away; set('fatigue', 'done', both ? 92 : 55, both ? 'full' : 'partial'); } else { set('fatigue', 'done', 18, 'unavailable'); } // LINEUP if (!match?.lineup) { set('lineup', 'running'); } else if (match.lineup.confirmed) { set('lineup', 'done', 95, 'full'); } else if (match.lineup.status === 'no_espn_id' || match.lineup.status === 'unavailable') { set('lineup', 'done', 18, 'unavailable'); } else { set('lineup', 'done', 35, 'pending'); // Roster bekannt aber nicht final } // MOTIVATION if (!match?.motivation) { set('motivation', 'running'); } else if (match.motivation.status === 'ok') { const avg = Math.round((match.motivation.home.score + match.motivation.away.score) / 2); set('motivation', 'done', avg, 'full'); } else { set('motivation', 'done', 18, 'unavailable'); } // REFEREE if (!match?.referee) { set('referee', 'running'); } else if (match.referee.status === 'ok') { set('referee', 'done', 95, 'full'); } else if (match.referee.status === 'not_found' || match.referee.status === 'no_data') { set('referee', 'done', 38, 'partial'); } else { set('referee', 'done', 18, 'unavailable'); } // GROQ + GPT-OSS Ensemble (aus llmResults.master.ensemble nach Wave 4) const ens = llmResults.master?.ensemble || (llmResults.groq || llmResults.gemini ? { groq: llmResults.groq?{confidence:llmResults.groq.confidence||60,agrees:true}:null, gemini: llmResults.gemini?{confidence:llmResults.gemini.confidence||60,agrees:true}:null } : null); if (ens?.groq) { set('groq', 'done', ens.groq.confidence || 60, ens.groq.agrees ? 'full' : 'partial'); } else if (llmStatuses.master === 'running') { set('groq', 'running'); } if (ens?.gemini) { set('gptoss', 'done', ens.gemini.confidence || 60, ens.gemini.agrees ? 'full' : 'partial'); } else if (llmStatuses.master === 'running') { set('gptoss', 'running'); } // POISSON — immer verfügbar bei Match mit Quoten if (match?.odds && window.poisson) { try { const sim = window.poisson.simulate(match, 2000); const top = Math.max(sim.home, sim.draw, sim.away); set('poisson', 'done', Math.round(top * 100), 'full'); } catch { set('poisson', 'done', 25, 'unavailable'); } } else { set('poisson', 'done', 25, 'unavailable'); } // ELO — geht nur mit Team-IDs if (match?.homeTeamId && match?.awayTeamId && window.elo) { try { const pred = window.elo.predict(match.homeTeamId, match.awayTeamId); const top = Math.max(pred.home, pred.draw, pred.away); const ratingsKnown = window.elo.get(match.homeTeamId) !== window.elo.DEFAULT && window.elo.get(match.awayTeamId) !== window.elo.DEFAULT; set('elo', 'done', Math.round(top * 100), ratingsKnown ? 'full' : 'bootstrapped'); } catch { set('elo', 'done', 25, 'unavailable'); } } else { set('elo', 'done', 25, 'unavailable'); } return { results, statuses }; } // ─── Quant-Verdict (Poisson + Elo + LLM-Konsens) ────────────── // Gewichte aus tracker.sourceWeights() — initial 60P/25E/15L, // werden nach 20+ aufgelösten Picks per inverse-Brier gelernt. function computeQuantVerdict(match, masterLLM, llmResults) { if (!match || !window.poisson) return null; const sim = window.poisson.simulate(match, 10000); const elo = window.elo && match.homeTeamId && match.awayTeamId ? window.elo.predict(match.homeTeamId, match.awayTeamId) : null; // Dynamische Gewichte aus History (Brier-basiert) const W = window.tracker?.sourceWeights?.() || { poisson: 0.60, elo: 0.25, llm: 0.15, learned: false }; // LLM-Konsens für 1X2: zähle Stimmen pro Outcome const recs = Object.values(llmResults || {}).filter(r => r && r.recommendation); const llmVotes = { '1':0, 'X':0, '2':0, 'O':0, 'U':0, 'B':0 }; recs.forEach(r => { const v = (r.recommendation || '').toUpperCase(); if (v.includes('HOME')) llmVotes['1']++; else if (v === 'DRAW') llmVotes['X']++; else if (v.includes('AWAY')) llmVotes['2']++; else if (v.includes('OVER')) llmVotes['O']++; else if (v.includes('UNDER')) llmVotes['U']++; else if (v.includes('BTTS')) llmVotes['B']++; }); const llmTotal = Object.values(llmVotes).reduce((a,b)=>a+b,0) || 1; const llm1X2 = { home: llmVotes['1'] / llmTotal, draw: llmVotes['X'] / llmTotal, away: llmVotes['2'] / llmTotal, }; // 1X2 blended mit dynamischen Gewichten const blended1X2 = { home: W.poisson * sim.home + W.elo * (elo?.home ?? sim.home) + W.llm * llm1X2.home, draw: W.poisson * sim.draw + W.elo * (elo?.draw ?? sim.draw) + W.llm * llm1X2.draw, away: W.poisson * sim.away + W.elo * (elo?.away ?? sim.away) + W.llm * llm1X2.away, }; // Normalisieren const z = blended1X2.home + blended1X2.draw + blended1X2.away; if (z > 0) { blended1X2.home /= z; blended1X2.draw /= z; blended1X2.away /= z; } // O2.5 / BTTS: Poisson dominiert, LLM-Beimischung skaliert mit gelerntem llm-Gewicht const llmOver = (llmVotes['O'] - llmVotes['U']) / llmTotal + 0.5; const wLlmGoals = Math.min(0.4, Math.max(0.1, W.llm * 2)); // 0.15→0.30, 0.05→0.10 const blendedO25 = (1 - wLlmGoals) * sim.over[2.5] + wLlmGoals * Math.max(0, Math.min(1, llmOver)); const llmBtts = llmVotes['B'] / llmTotal > 0 ? 0.65 : sim.btts; const blendedBtts = (1 - wLlmGoals) * sim.btts + wLlmGoals * llmBtts; // Kandidaten mit Edge gegen Markt const candidates = [ { market:'1X2', pick:'1', label:`${match.home} ${currentLang==='de'?'Sieg':currentLang==='tr'?'Galip':'Win'}`, prob: blended1X2.home, odd: match.odds?.home }, { market:'1X2', pick:'X', label: t('draw'), prob: blended1X2.draw, odd: match.odds?.draw }, { market:'1X2', pick:'2', label:`${match.away} ${currentLang==='de'?'Sieg':currentLang==='tr'?'Galip':'Win'}`, prob: blended1X2.away, odd: match.odds?.away }, { market:'O2.5', pick:'over', label: t('overGoals'), prob: blendedO25, odd: match.overUnder?.o25 }, { market:'O2.5', pick:'under', label: t('underGoals'), prob: 1 - blendedO25, odd: match.overUnder?.u25 }, { market:'BTTS', pick:'yes', label: t('bttsYes'), prob: blendedBtts, odd: match.btts?.yes }, { market:'BTTS', pick:'no', label: t('bttsNo'),prob: 1-blendedBtts, odd: match.btts?.no }, ].filter(c => c.odd && c.prob > 0).map(c => ({...c, edge: c.odd * c.prob - 1})); candidates.sort((a,b) => b.edge - a.edge); const best = candidates[0]; if (!best) return null; // Per-Source-Probability für genau diese Auswahl (best.market/pick) // → Brier pro Source kann nach Resolution berechnet werden const sourceProbForBest = (() => { const m = best.market, p = best.pick; const pickProb = (probs1X2, probOver, probBtts) => { if (m === '1X2') return p === '1' ? probs1X2.home : p === '2' ? probs1X2.away : probs1X2.draw; if (m === 'O2.5') return p === 'over' ? probOver : 1 - probOver; if (m === 'BTTS') return p === 'yes' ? probBtts : 1 - probBtts; return null; }; return { poisson: pickProb({ home: sim.home, draw: sim.draw, away: sim.away }, sim.over[2.5], sim.btts), elo: elo ? pickProb({ home: elo.home, draw: elo.draw, away: elo.away }, sim.over[2.5], sim.btts) : null, llm: pickProb(llm1X2, Math.max(0, Math.min(1, llmOver)), llmBtts), }; })(); // Isotonic-Kalibrierung auf die Final-Confidence (wenn genug Historie) const calib = window.tracker?.isotonicFit?.(); const calibratedProb = calib?.ready ? calib.calibrate(best.prob) : best.prob; const conf = Math.round(calibratedProb * 100); // Risk-Klassifizierung anhand Edge + Confidence const risk = best.edge > 0.10 || conf > 70 ? (best.odd < 1.8 ? 'SAFE' : 'GOOD') : best.edge > 0 ? 'GOOD' : 'RISK'; const ticketWorthy = best.edge >= 0.03 && conf >= 50; // Auto-Log in Tracker if (window.tracker) { window.tracker.logPick({ matchId: match.id, source: 'master_quant', market: best.market, pick: best.pick, confidence: conf, oddsAtPick: best.odd, kickoff: match.espnData?.date || null, label: best.label, meta: { home: match.home, away: match.away, edge: +best.edge.toFixed(3), rawProb: +best.prob.toFixed(4), calibratedProb: +calibratedProb.toFixed(4), weights: { poisson: +W.poisson.toFixed(3), elo: +W.elo.toFixed(3), llm: +W.llm.toFixed(3), learned: !!W.learned }, sources: sourceProbForBest, }, }); } return { final_pick: best.pick, bet_label: best.label, odds: best.odd, confidence: conf, risk, ticket_worthy: ticketWorthy, quant: { poisson1X2: { home: +sim.home.toFixed(3), draw: +sim.draw.toFixed(3), away: +sim.away.toFixed(3) }, elo1X2: elo ? { home: elo.home, draw: elo.draw, away: elo.away, ratings: elo.ratings } : null, llm1X2: { home: +llm1X2.home.toFixed(3), draw: +llm1X2.draw.toFixed(3), away: +llm1X2.away.toFixed(3) }, blended1X2: { home: +blended1X2.home.toFixed(3), draw: +blended1X2.draw.toFixed(3), away: +blended1X2.away.toFixed(3) }, edge: +best.edge.toFixed(3), method: `${Math.round(W.poisson*100)}P+${Math.round(W.elo*100)}E+${Math.round(W.llm*100)}L${W.learned?'•learned':''}`, weights: W, calibrated: calib?.ready ? { rawProb: +best.prob.toFixed(3), calibratedProb: +calibratedProb.toFixed(3) } : null, }, }; } // ─── FATIGUE + LINEUP Badges ────────────────────────────────── function DataAgentBadges({ match }) { const f = match?.fatigue, l = match?.lineup, mo = match?.motivation; if (!f && !l && !mo) return null; const fatigueLevel = (s) => { if (!s) return null; if (s.midweekEuro && s.daysRest <= 3) return { txt: t('tired'), c:'#ff5470' }; if (s.daysRest <= 2) return { txt: t('tired'), c:'#ff5470' }; if (s.daysRest >= 6) return { txt: t('fresh'), c:'#22ff88' }; return { txt: t('normalRest'), c:'#ffb648' }; }; const fH = fatigueLevel(f?.home), fA = fatigueLevel(f?.away); const luOk = l?.confirmed === true; return (

{fH && ⚡ {t('home_')} {f.home.daysRest}d · {fH.txt}{f.home.midweekEuro?' · UEL':''}} {fA && ⚡ {t('away_')} {f.away.daysRest}d · {fA.txt}{f.away.midweekEuro?' · UEL':''}} {l && (luOk ? ✓ {t('lineupConfirmed')} : l.status==='unavailable' || l.status==='no_espn_id' ? null : ⏳ {t('lineupPending')})} {mo?.status === 'ok' && (() => { const catColor = (cat) => cat?.includes('title_race') ? '#ffd700' : cat?.includes('relegation') ? '#ff5470' : cat?.includes('european') ? '#5ee7ff' : cat?.includes('dead_rubber') || cat?.includes('champion_secure') ? '#888' : cat?.includes('derby') ? '#ff0080' : '#ffb648'; const catIcon = (cat) => cat?.includes('title_race') ? '🏆' : cat?.includes('relegation_fight') ? '🆘' : cat?.includes('relegation') ? '⚠️' : cat?.includes('european') ? '🇪🇺' : cat?.includes('dead_rubber') ? '💤' : cat?.includes('champion_secure') ? '👑' : cat?.includes('derby') ? '🔥' : '⚽'; const cH = catColor(mo.home.category), cA = catColor(mo.away.category); return ( <> {catIcon(mo.home.category)} {t('home_')[0]} {mo.home.score} {catIcon(mo.away.category)} {t('away_')[0]} {mo.away.score} ); })()}

); } // ─── Poisson Quant-Modell Card ──────────────────────────────── function PoissonCard({ match }) { const sim = React.useMemo(() => { try { return poisson.simulate(match, 10000); } catch { return null; } }, [match?.id, match?.odds?.home, match?.odds?.away, match?.xG?.home, match?.xG?.away]); if (!sim) return null; const pct = (p) => `${(p*100).toFixed(0)}%`; const bestEdge = sim.bestBets?.[0]; const edgeColor = (e) => e == null ? 'rgba(255,255,255,0.3)' : e > 0.05 ? '#22ff88' : e > 0 ? '#ffb648' : '#ff5470'; return (

⚙ {t('poissonQuant')}

λH={sim.lambdas.home} · λA={sim.lambdas.away} · Ø{sim.avgGoals}

{/* 1X2 + Edge */}

{[ {l:'1', p:sim.home, e:sim.edge?.home, fair:sim.fair.home, market:match.odds?.home}, {l:'X', p:sim.draw, e:sim.edge?.draw, fair:sim.fair.draw, market:match.odds?.draw}, {l:'2', p:sim.away, e:sim.edge?.away, fair:sim.fair.away, market:match.odds?.away}, ].map(c=>(

{c.l}

{pct(c.p)}

fair {c.fair} · markt {c.market?.toFixed(2)}

{c.e == null ? '—' : (c.e > 0 ? '+' : '') + (c.e*100).toFixed(1) + '%'}

))}

{/* O2.5 + BTTS */}

OVER 2.5

{pct(sim.over[2.5])} {sim.edge?.o25 == null ? '' : (sim.edge.o25>0?'+':'') + (sim.edge.o25*100).toFixed(1)+'%'}

BTTS

{pct(sim.btts)} {sim.edge?.btts_y == null ? '' : (sim.edge.btts_y>0?'+':'') + (sim.edge.btts_y*100).toFixed(1)+'%'}

{/* Best Bet */} {bestEdge && bestEdge.edge > 0 && (

{t('valuePick')}

{bestEdge.label} {(bestEdge.edge*100).toFixed(1)}% Edge · @{bestEdge.odd?.toFixed(2)}

)}

); } // ─── Konfidenz Radar Chart ──────────────────────────────────── // Wrapper-Komponente: KONFIDENZ RADAR mit Header, Legende + optionalem Glow-Backdrop. // Funktioniert in 3 Modi: // single → results/statuses kommen von einem einzelnen Match (per-agent) // parallel → matchResults ist ein {matchId: {confidence,...}} Objekt aus Multi-Analyse // liga → matchResults ist ein {matchId: {confidence,...}} Objekt aus Liga-Analyse function RadarPanel({ mode, match, results, statuses, running, masterDone, matchResults, totalCount, size = 260 }) { const isAggregate = mode === 'parallel' || mode === 'liga'; const radarAgents = getRadarAgents(); const { results: radarResults, statuses: radarStatuses } = isAggregate ? getRadarAggregateResults(matchResults, running) : getRadarResults(match, results, statuses); const doneCount = isAggregate ? Object.keys(matchResults || {}).length : 0; const headerLabel = isAggregate ? `⬡ KONFIDENZ RADAR · 18 KNOTEN · ${doneCount}/${totalCount || 0} MATCHES` : '⬡ KONFIDENZ RADAR · 18 KNOTEN'; const glowColor = masterDone ? '#22ff88' : '#5ee7ff'; return (

{running && (

)}

{headerLabel}

{running &&

● LIVE

}

DATA·4 LLM·10 ENS·2 QUANT·2

); } function KonfidenzRadar({ agents, results, statuses = {}, running = false, size = 260 }) { // Wave-arrival ripple effect const [waveRipple, setWaveRipple] = React.useState(0); const prevDoneRef = React.useRef(0); React.useEffect(() => { const llmAgents = agents.filter(a => a.type !== 'data' && a.type !== 'quant'); const done = llmAgents.filter(a => statuses[a.id] === 'done').length; if (done > prevDoneRef.current) setWaveRipple(t => t + 1); prevDoneRef.current = done; }, [statuses]); const cx = size / 2, cy = size / 2; const maxR = size / 2 - 28; const n = agents.length; const rings = [25, 50, 75, 100]; const angleOf = i => (i / n) * Math.PI * 2 - Math.PI / 2; const pointOf = (i, r) => { const a = angleOf(i); return { x: cx + Math.cos(a) * r, y: cy + Math.sin(a) * r }; }; // Build polygon path for agent confidences const confPoints = agents.map((ag, i) => { const r = results[ag.id]; const conf = r ? (r.confidence || 60) : 0; const radius = (conf / 100) * maxR; return pointOf(i, radius); }); const polyPath = confPoints.map((p, i) => `${i === 0 ? 'M' : 'L'} ${p.x.toFixed(1)} ${p.y.toFixed(1)}`).join(' ') + ' Z'; // Gradient fill stops based on average confidence const avgConf = agents.reduce((a, ag) => a + ((results[ag.id]?.confidence || 0)), 0) / agents.length; const fillColor = avgConf >= 75 ? '#00ff88' : avgConf >= 60 ? '#ffa500' : '#ff5470'; return (

); } Object.assign(window, { AgentPipeline, GlowBorder, LigaAnalyseScreen, KonfidenzRadar });