Spaces:

RLE-Bench
/

programmable-vla

Running

Add selectable model cards with saved per-panel preferences
ccaf22c verified 3 days ago
90.5 kB
const kinexDisplayVersion = ep => ep.kinex_version || (ep.links?.provenance?.endsWith('/research/kinex-vlact-rich-20261030/source-identities.json') ? '1.1.0' : null);
'use strict';
const plannedProtocol = (task, variant) => task.planned_protocol_by_variant?.[variant] || task.planned_protocol;
// RoboEnv LIBERO raw counters include five initialization frames; RoboBridge counters do not.
const actionSteps = (value, task, variant=task?.variant || current.variant || filters.variant) => Number.isFinite(value) ? Math.max(0, value - (task?.initialization_control_steps ?? task?.planned_protocol_by_variant?.[variant]?.initialization_control_steps ?? 0)) : null;
const currentBudget = task => data.budget_defaults?.tasks?.[task.native_id]?.action_step_limit ?? null;
const budgetNote = task => `<p class="subtle" data-budget-note>${currentBudget(task)==null?'':`Current benchmark default: ${number(currentBudget(task))} action steps. `}${task.family==='task02'?'RoboEnv and rosbridge displays exclude five initialization steps; RoboBridge directly counts agent actions. ':''}Recorded episodes and campaign plans retain their original budgets.</p>`;
const $ = s => document.querySelector(s);
const $$ = s => [...document.querySelectorAll(s)];
const esc = value => String(value ?? '').replace(/[&<>"']/g, c => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c]));
const number = v => v == null ? '—' : Number(v).toLocaleString('en-US');
const compact = v => v == null ? '—' : Math.abs(v) >= 1e9 ? (v/1e9).toFixed(2)+'B' : Math.abs(v) >= 1e6 ? (v/1e6).toFixed(2)+'M' : Math.abs(v) >= 1e3 ? (v/1e3).toFixed(1)+'K' : Math.round(v).toString();
const pct = v => v == null ? '—' : (v*100).toFixed(1)+'%';
const elapsed = v => v == null ? '—' : v >= 3600 ? (v/3600).toFixed(1)+' h' : v >= 60 ? (v/60).toFixed(1)+' min' : v.toFixed(1)+' s';
const arrow = '<span aria-hidden="true">↗</span>';
const colors = {'standalone-oft-all140k':'#547a36','standalone-vlact-clean':'#a75f7f','standalone-vlact-all':'#bd733b','standalone-official':'#39819c','standalone':'#39819c','kinex_policy':'#756ee4','kinex':'#27847a','codex-astra-spectator':'#a76a34','codex-astra':'#39819c','kinex-astra':'#756ee4','cc-opus':'#b48566','kinex-opus':'#958bc8','cc-opus-vertex-high':'#c9875a','cc-opus-vertex-xhigh':'#8c5a3a','kinex-opus-vertex-high':'#5b8bd8','kinex-opus-vertex-xhigh':'#3a5ba6','cc-opus-vertex-high-run2':'#e0a37a','cc-opus-vertex-xhigh-run2':'#a8704a','kinex-opus-vertex-high-run2':'#86aae6','kinex-opus-vertex-xhigh-run2':'#5876c0'};
let data, epoch = 0, current = {}, matrixMetric = 'success';
let filters = {query:'',family:'',status:'',variant:'standalone-vlact-clean',sort:'catalog'};
let sessionState = {filter:'all',query:'',count:40,view:'timeline'};
let imageItems = [], imageIndex = 0;
const sessionCache = new Map(), fileCache = new Map();
const episodes = (variant, family) => data.episodes.filter(e => (!variant || e.variant===variant) && (!family || e.family===family));
const reviewFor = (key, variant) => (data.runtime_reviews||[]).find(r => r.task_key===key && r.variant===variant);
const epFor = (key, variant) => data.episodes.find(e => e.task_key===key && e.variant===variant);
const plannedTasks = variant => data.tasks.filter(t => !variant || t.planned_variants.includes(variant));
const variantFor = id => data.variants.find(v => v.id===id);
const familyName = id => data.families.find(f => f.id===id)?.name || id;
const variantName = id => {const v=variantFor(id);return v ? `${v.label||v.agent} + ${v.model}` : id;};
const taskRoute = (key, variant='kinex', section='overview') => `#task/${key}/${variant}${section==='overview' ? '' : '/'+section}`;
const outcome = e => !e ? 'pending' : e.valid===false ? 'invalid' : typeof e.success!=='boolean' ? 'unreported' : e.success ? 'pass' : 'fail';
const badge = (e, link) => {if(!e&&link){const p=link.split('/'),t=data.tasks.find(t=>t.key===p.slice(1,3).join('/'));if(t&&!t.planned_variants.includes(p[3]))return '<span class="muted">Not scheduled</span>';}if(!e&&link){const p=link.split('/');if(reviewFor(p.slice(1,3).join('/'),p[3]))return `<a class="badge invalid" href="${esc(link)}">Under review</a>`;}const s=outcome(e),tag=link?'a':'span';return `<${tag} class="badge ${s}" ${link ? `href="${esc(link)}"` : ''}><span class="status-dot"></span>${s==='pending'?((data.active_campaign?.initialization_blocked||[]).includes((link||'').split('/').slice(1,4).join('/'))?'Blocked':'Pending'):s==='invalid'?'Invalid':s==='unreported'?'Unreported':s==='pass'?'Pass':'Fail'}</${tag}>`;};
const external = (url,label,cls='') => typeof url==='string' && /^(https?:|[a-zA-Z0-9_.-]+\/|[a-zA-Z0-9_.-]+\.json)/.test(url) ? `<a class="${cls}" href="${esc(evidenceURL(url))}" target="_blank" rel="noopener">${esc(label)} ${arrow}</a>` : '';
const modelLabel = v => `${v.model} <span class="separator">/</span> ${v.effort} <span class="separator">/</span> ${esc(v.provider)}`;
const icon = v => `<img class="agent-logo" src="assets/${v.agent==='Kinex'?'kinex':'vla'}-logo.svg" alt="" width="23" height="23">`;
function stats(es) {
  return UsageMetrics.stats(es);
}
window.benchmarkStats = stats;
const tokens = e => e && Number.isFinite(e.usage?.input_tokens) && Number.isFinite(e.usage?.output_tokens) ? e.usage.input_tokens+e.usage.output_tokens : null;
function metric(value,label,detail='',attrs='') {return `<div class="metric" ${attrs}><span class="metric-label">${label}</span><strong>${value}</strong>${detail?`<small>${detail}</small>`:''}</div>`;}
function variantTabs(selected,taskKey,section) {
  return `<div class="variant-tabs" aria-label="Choose agent and model">${data.variants.filter(v=>!taskKey||data.tasks.find(t=>t.key===taskKey)?.planned_variants.includes(v.id)).map(v=>`<a class="variant-tab ${v.id===selected?'active':''}" style="--variant:${colors[v.id]}" href="${taskKey?taskRoute(taskKey,v.id,epFor(taskKey,v.id)?section:'overview'):'#runs/'+v.id}" ${v.id===selected?'aria-current="page"':''}><span class="tab-agent">${icon(v)}<strong>${esc(v.label||v.agent)}</strong>${taskKey?badge(epFor(taskKey,v.id)):''}</span><span class="tab-model">${modelLabel(v)}</span></a>`).join('')}</div>`;
}

const rangeNumber = (lo,hi,formatter=compact) => UsageMetrics.bounds(lo,hi,formatter);
const costValue = s => UsageMetrics.bounds(s.costLow,s.costHigh,UsageMetrics.money);
const exactMoney = v => v == null ? '—' : '$'+v.toLocaleString('en-US',{minimumFractionDigits:6,maximumFractionDigits:6});
const costNote = s => !s.n ? 'Not evaluated' : s.costCount!==s.n ? `Pricing available for ${s.costCount} / ${s.n} episodes` : s.conditional ? 'Estimated · 5m cache-write basis' : 'Estimated · recorded session rates';
function taskResult(ep, link) {
  const s=stats(ep?[ep]:[]), cost=costValue(s);
  return `<span class="task-result">${badge(ep,link)}<span class="task-cost" title="${esc(costNote(s))} · USD" aria-label="Estimated cost: ${esc(cost)} USD">${cost}</span></span>`;
}
function usageTiles(s,includeCost=true) {
  return `<div class="usage-metrics">${metric(compact(s.fresh),'Fresh input','',`title="${number(s.fresh)}"`)}${metric(rangeNumber(s.cacheLow,s.cacheHigh),'Cache read','',`title="${rangeNumber(s.cacheLow,s.cacheHigh,number)}"`)}${metric(compact(s.cacheWrite),'Cache write','',`title="${number(s.cacheWrite)}"`)}${metric(compact(s.output),'Output')}${metric(rangeNumber(s.cacheRateLow,s.cacheRateHigh,pct),'Cache hit rate')}${includeCost?metric(costValue(s),'Estimated cost'):''}</div>`;
}
function modelGroups() {
  const groups=new Map();
  for (const v of data.variants) {
    const key=v.model+' / '+v.effort;
    if(!groups.has(key))groups.set(key,{key,model:v.model,effort:v.effort,variants:[]});
    groups.get(key).variants.push(v);
  }
  return [{key:'baselines',model:'RoboTwin 2.0',effort:'Seed 0',variants:data.variants}];
}
let expandedModels=null;
function perTaskStats(s) {
  const average = value => s.n > 0 && Number.isFinite(value) ? value / s.n : null;
  const result = {...s, perTask: true};
  for (const key of ['inclusive','fresh','cacheWrite','input','cached','output','inputLow','inputHigh','cacheLow','cacheHigh','reasoning','costLow','costHigh','knownCost']) result[key] = average(s[key]);
  result.buckets = s.buckets.map(b => ({...b, tokens: average(b.tokens), lower: average(b.lower), upper: average(b.upper)}));
  return result;
}
function comparisonCell(v,f) {
  if(!plannedTasks(v.id).some(t=>t.family===f.id))return '<td><span class="muted">Not scheduled</span></td>';
  const s=stats(episodes(v.id,f.id)),mean=perTaskStats(s),link=`#runs/${v.id}?family=${f.id}`;
  let value;
  if(matrixMetric==='success')value=`<div class="comparison-value"><strong>${pct(s.rate)}</strong><span>${s.n?s.passes+' / '+s.n+' passed':'Not evaluated'}</span></div><div class="mini-track"><span style="width:${(s.rate||0)*100}%;background:${colors[v.id]}"></span></div>`;
  else if(matrixMetric==='tokens')value=`<dl class="comparison-usage"><div><dt>Fresh input / task</dt><dd title="${number(mean.fresh)} tokens / task">${compact(mean.fresh)}</dd></div><div><dt>Cache write / task</dt><dd title="${number(mean.cacheWrite)} tokens / task">${compact(mean.cacheWrite)}</dd></div><div><dt>Cache read / task</dt><dd title="${rangeNumber(mean.cacheLow,mean.cacheHigh,number)} tokens / task">${rangeNumber(mean.cacheLow,mean.cacheHigh)}</dd></div><div><dt>Cache hit</dt><dd>${rangeNumber(s.cacheRateLow,s.cacheRateHigh,pct)}</dd></div><div><dt>Output / task</dt><dd title="${number(mean.output)} tokens / task">${compact(mean.output)}</dd></div></dl>`;
  else value=`<div class="comparison-value"><strong>${costValue(mean)}</strong><span>USD / task · ${costNote(s)}</span></div>`;
  return `<td data-harness="${esc(v.label||v.agent)}" style="--variant:${colors[v.id]}">${value}<a class="comparison-explore" href="${link}">${s.n} evaluated · ${plannedTasks(v.id).filter(t=>t.family===f.id).length-s.n} pending ${arrow}</a></td>`;
}

function comparisonTable() {
  return `<section class="comparison-panel" aria-labelledby="comparison-title"><div class="section-heading bare"><div><h2 id="comparison-title">Compare methods</h2></div><div class="segmented" aria-label="Comparison metric">${[['success','Success rate'],['tokens','Tokens / task'],['cost','Cost / task']].map(([k,l])=>`<button data-matrix="${k}" aria-pressed="${matrixMetric===k}">${l}</button>`).join('')}</div></div><div class="model-comparisons">${modelGroups().map((g,i)=>`<details class="model-comparison panel" data-model-group="${esc(g.key)}" ${expandedModels?expandedModels.has(g.key)?'open':'':i===0?'open':''}><summary><span><strong>${esc(g.model)}</strong><span class="model-group-meta">${g.key==='baselines'?'One episode per task':esc(g.effort)+' effort'}</span></span><span class="model-group-count">${g.variants.length} variants <span class="disclosure-arrow">⌄</span></span></summary><div class="table-scroll"><table class="comparison-table grouped-comparison ${matrixMetric}"><thead><tr><th>Environment</th>${g.variants.map(v=>`<th><a href="#runs/${v.id}" class="agent-inline">${icon(v)}${esc(v.label||v.agent)} ${arrow}</a><small>${modelLabel(v)}</small></th>`).join('')}</tr></thead><tbody>${data.families.map(f=>`<tr><th scope="row"><span class="family-code">${f.id.slice(-2)}</span>${esc(f.name)}<small>${f.tasks} tasks</small></th>${g.variants.map(v=>comparisonCell(v,f)).join('')}</tr>`).join('')}</tbody></table></div></details>`).join('')}</div></section>`;
}
function recordingComparisonNote(ep){
 if(!ep.recording_comparison)return '';
 const hd=ep.recording_mode==='spectator';
 return `<aside class="native-note" data-recording-comparison><span class="note-symbol">i</span><div><strong>Recording comparison · ${hd?'Online HD cameras':'Native camera frames'}</strong><p>${hd?'The agent receives native-resolution images. GPU controls show that extra HD cameras affect subsequent native RGB pixels through the shared renderer. Spectator images are for the human video only.':'The video uses cached native camera frames. No extra camera or rendering pass is added for recording.'}</p><p>Same task, seed 0, model, effort, prompt, budget and owner image; one fresh model attempt per condition. Model sampling also varies, so trajectory differences alone do not establish causality.</p>${ep.collector_review?`<p>Original Harbor collection failed because of a nested Docker log-path mismatch. The unchanged session, usage, sealed evidence and native failure were recovered; the original collection exception is retained. ${external(ep.links.collector_review,'Collection recovery receipt')}</p>`:''}${ep.encoding_review?`<p>The original 300-second encoding deadline expired after four of six videos. This presentation uses all sealed source frames re-encoded offline with a 600-second deadline; there was no model or simulator retry. ${external(ep.links.encoding_recovery,'Encoding recovery receipt')}</p>`:''}<a href="${taskRoute(ep.task_key,hd?'codex-astra':'codex-astra-spectator')}">View the other recording condition ↗</a>${external(data.recording_pilot.details_url||data.recording_pilot.report_url,'Measured image differences and behavior review')}</div></aside>`;
}

function methodology() {
  return `<details class="panel methodology" id="methodology"><summary><span><span class="eyebrow">Reading the benchmark</span><strong>Protocol, metrics & provenance</strong></span><span class="summary-plus">+</span></summary><div class="method-grid"><div><h3>One selected episode</h3><p>Each standalone checkpoint: 50 tasks, one episode each, official seed group 0 with native expert admission. VLAct Clean 50K, VLAct All 100K and the original Base 40K episodes are all retained. Kinex: the retained three-task seed-0 pilot. Kinex + VLA: the October 30 VLAct Clean 50k run on those same three tasks and seed 0; previous valid attempts remain archived.</p></div><div><h3>Native success</h3><p>Success rate is passes / evaluated tasks, pooled over the selected episodes. Pending tasks do not count as failures. Results follow the original native verifier.</p></div><div><h3>Native control budget</h3><p>RLE-Bench task03 · RoboTwin 2.0 · ALOHA AgileX. Standalone uses official take_action and task-specific limits. Kinex uses rosbridge control frames. Initializations and physical durations are not matched.</p></div><div><h3>Policy & agent</h3><p>Non-VLAct All 140k: StarVLA/Qwen3-VL-OFT-RoboTwin2-All, step 140,000, trained on 27,500 clean/randomized demonstrations. It uses three 224 × 224 images and full 50-action chunks. The existing Easy instruction protocol is retained; expert admission matched Base scene seeds on 45/50 tasks.</p><p>Standalone VLAct Clean: StarVLA/VLAct_Qwen3OFT_Robotwin_Finetune, step 50,000, RoboTwin Clean/Base training mixture. It uses the same released 32-action, image-bucket and wrap-joint contract as VLAct All. Official expert admission selected the same scene seed as All in 45/50 tasks. Each checkpoint has one admitted episode per task; training mixture and training duration differ, so these results do not isolate a causal mechanism. </p><p>Standalone VLAct All: StarVLA/VLAct_Qwen3OFT_Robotwin_all_Finetune, step 100,000, 32-action chunks and checkpoint-specific image buckets / wrap decoding. Official expert admission selected the same scene seed as Base 40k in 43 of 50 tasks; this is not a fully paired comparison. Standalone Base 40k retains StarVLA/Qwen3-VL-OFT-Robotwin2, step 40,000. Kinex + VLA now uses VLAct Clean 50k, with 32 predicted targets and its checkpoint-specific image buckets and wrap decoder. Kinex uses GPT-6 Astra / high. Kinex chooses whether to use VLA, writes its control loop, and chooses language, arbitrary JSON conditions and optional formatting. Additional conditions enter the frozen model through language. This interface supports richer inputs; effectiveness is a separate experimental question. The rerun returns untimed joint waypoints, executed by Kinex trajectories or agent-authored code. Encoder changes and progress monitors are not used.</p></div><div><h3>Token accounting</h3><p>API-equivalent cost uses the recorded Pi session estimates; account charges and GPU costs are not reported.</p></div></div><div class="method-links"><a href="${esc(evidenceURL('research/oft-all140k-20261103/REPORT.md'))}">All 140k results & validation ↗</a><a href="${esc(evidenceURL('research/oft-all140k-20261103/protocol.json'))}">All 140k protocol & checkpoint ↗</a><a href="${esc(resultURL('sources.json'))}" target="_blank">Data sources ↗</a><a href="history.html#overview">Previous rosbridge pilot ↗</a><a href="${esc(evidenceURL('research/vlact-clean-20261029/results.json'))}">VLAct Clean results ↗</a><a href="${esc(evidenceURL("research/vlact-all-20261029/results.json"))}">VLAct All results ↗</a><a href="${esc(evidenceURL("official/results.json"))}">Base 40k results ↗</a><button class="text-button" data-export="all">Download comparison CSV ↓</button></div></details>`;
}

const expandedTaskVariants = new Set();
const visibleTaskVariants = () => data.variants.filter(v => expandedTaskVariants.has(v.id));
function taskColumnPicker() {
  return `<div class="task-column-picker" role="group" aria-label="Methods to compare"><div class="column-picker-heading"><div><strong>Choose methods to compare</strong><p id="task-column-status" role="status">All method columns are collapsed. Select one or more to compare.</p></div><div class="column-picker-actions"><button class="text-button" data-task-columns="all">Expand all</button><button class="text-button" data-task-columns="none">Collapse all</button></div></div><div class="task-column-options">${data.variants.map(v=>`<button class="task-column-toggle" data-task-column="${esc(v.id)}" aria-expanded="${expandedTaskVariants.has(v.id)}" aria-controls="task-comparison" style="--variant:${colors[v.id]}"><span class="column-toggle-icon" aria-hidden="true">${expandedTaskVariants.has(v.id)?'−':'+'}</span><span>${esc(v.label||v.agent)}</span></button>`).join('')}</div></div>`;
}
function taskColumnHeaders() {
  return '<th scope="col">Task</th>' + visibleTaskVariants().map(v=>`<th scope="col" data-task-variant="${esc(v.id)}" class="${v.id===filters.variant?'focus-column':''}"><div class="task-column-label"><span>${esc(v.label||v.agent)}</span><button class="column-close" data-task-column="${esc(v.id)}" aria-label="Collapse ${esc(v.label||v.agent)} column" aria-expanded="true" aria-controls="task-comparison">×</button></div><small>${esc(v.model)} · ${esc(v.effort)}</small><small>Native result · Estimated USD</small></th>`).join('');
}
function syncTaskColumns() {
  if(current.type==='runs')return;
  const variants=visibleTaskVariants(), table=$('#task-comparison');
  table.querySelector('thead tr').innerHTML=taskColumnHeaders();
  table.classList.toggle('has-methods',variants.length>0);
  table.style.setProperty('--method-count',variants.length);
  $$('[data-task-column].task-column-toggle').forEach(button=>{
    const expanded=expandedTaskVariants.has(button.dataset.taskColumn);
    button.setAttribute('aria-expanded',expanded);
    button.querySelector('.column-toggle-icon').textContent=expanded?'−':'+';
  });
  $('#task-column-status').textContent=variants.length?`${variants.length} of ${data.variants.length} method columns expanded. Select another method to compare.`:'All method columns are collapsed. Select one or more to compare.';
  $('[data-task-columns="none"]').disabled=variants.length===0;
  $('[data-task-columns="all"]').disabled=variants.length===data.variants.length;
}

function taskBrowser(variant=null) {
  return `<section class="task-browser" id="tasks"><div class="section-heading bare"><div><div class="eyebrow">${variant?'Episode index':'Browse the benchmark'}</div><h2>Explore tasks <span class="heading-count">${plannedTasks(variant).length}</span></h2></div><button class="button secondary" data-export="${variant||'all'}">Export CSV ↓</button></div><div class="panel">${variant?'':taskColumnPicker()}<div class="filters"><label class="search-field"><span aria-hidden="true">⌕</span><input id="task-search" type="search" aria-label="Search tasks" placeholder="Search task name, instruction or ID" value="${esc(filters.query)}"></label><select id="task-family" aria-label="Environment"><option value="">All environments</option>${data.families.map(f=>`<option value="${f.id}" ${filters.family===f.id?'selected':''}>${f.name}</option>`).join('')}</select>${variant?'':`<select id="task-variant" aria-label="Agent for outcome filter">${data.variants.map(v=>`<option value="${v.id}" ${filters.variant===v.id?'selected':''}>${v.label||v.agent} · ${v.model}</option>`).join('')}</select>`}<select id="task-status" aria-label="Outcome"><option value="">All outcomes</option>${['pass','fail','pending'].map(s=>`<option value="${s}" ${filters.status===s?'selected':''}>${s[0].toUpperCase()+s.slice(1)}</option>`).join('')}</select><select id="task-sort" aria-label="Sort tasks"><option value="catalog" ${filters.sort==='catalog'?'selected':''}>Catalog order</option><option value="tokens" ${filters.sort==='tokens'?'selected':''}>Most fresh input tokens</option><option value="cost" ${filters.sort==='cost'?'selected':''}>Highest cost</option><option value="name" ${filters.sort==='name'?'selected':''}>Task name</option></select></div><div class="table-scroll"><table id="task-comparison" class="task-table ${variant?'single-variant':'selectable-task-table'}"><thead><tr>${variant?'<th scope="col">Task</th><th>Native result</th><th>Fresh input<small>Excludes read and write</small></th><th>Cache read</th><th>Cache write</th><th>Cache hit</th><th>Output</th><th>Total cost<small>Estimated USD</small></th><th>Action steps</th>':taskColumnHeaders()}</tr></thead><tbody id="task-rows"></tbody></table></div><div class="table-footer"><span id="task-count" aria-live="polite"></span><span id="filter-context"></span><button class="text-button" id="reset-filters">Reset filters</button></div></div></section>`;
}
function renderRows() {
  const variant=current.type==='runs'?current.variant:null, selected=variant||filters.variant, q=filters.query.trim().toLowerCase();
  let tasks=plannedTasks(variant).filter(t=>(!filters.family||t.family===filters.family)&&(!filters.status||outcome(epFor(t.key,selected))===filters.status)&&(!q||[t.key,t.title,t.catalog_instruction,t.native_id,familyName(t.family)].some(s=>s?.toLowerCase().includes(q))));
  if(filters.sort==='name') tasks.sort((a,b)=>a.title.localeCompare(b.title));
  if(filters.sort==='tokens') tasks.sort((a,b)=>(UsageMetrics.usage(epFor(b.key,selected)).fresh??-1)-(UsageMetrics.usage(epFor(a.key,selected)).fresh??-1));
  if(filters.sort==='cost') tasks.sort((a,b)=>(UsageMetrics.price(epFor(b.key,selected))?.upper??-1)-(UsageMetrics.price(epFor(a.key,selected))?.upper??-1));
  syncTaskColumns();
  $('#task-rows').innerHTML=tasks.length?tasks.map(t=>{const ep=epFor(t.key,selected),us=UsageMetrics.usage(ep),cs=stats(ep?[ep]:[]);return `<tr data-task="${t.key}"><th scope="row"><a class="task-title" href="${taskRoute(t.key,selected)}">${esc(t.title)} <span class="row-arrow">↗</span></a><span class="task-meta">${familyName(t.family)} <span>·</span> <code>${t.key}</code>${data.task_notes[t.key]?'<span class="native-marker" title="Simulator source issue">◆ Native note</span>':''}</span></th>${variant?`<td>${badge(ep,taskRoute(t.key,selected))}</td><td class="numeric" title="${number(us.fresh)}">${compact(us.fresh)}</td><td class="numeric" title="${rangeNumber(us.cacheLow,us.cacheHigh,number)}">${rangeNumber(us.cacheLow,us.cacheHigh)}</td><td class="numeric" title="${number(us.cacheWrite)}">${compact(us.cacheWrite)}</td><td class="numeric">${rangeNumber(us.cacheRateLow,us.cacheRateHigh,pct)}</td><td class="numeric">${compact(us.output)}</td><td class="numeric" title="${esc(costNote(cs))}">${costValue(cs)}</td><td class="numeric">${number(actionSteps(ep?.steps,t))}<small>${ep?'of '+number(actionSteps(ep.measured_protocol?.max_steps,ep)):number(actionSteps(plannedProtocol(t,selected).max_control_steps,t))+' campaign plan'}</small></td>`:visibleTaskVariants().map(v=>`<td class="${v.id===filters.variant?'focus-column':''}">${taskResult(epFor(t.key,v.id),taskRoute(t.key,v.id))}</td>`).join('')}</tr>`;}).join(''):`<tr><td colspan="${variant?9:visibleTaskVariants().length+1}" class="empty-state">No tasks match these filters. <button class="text-button" data-reset>Clear filters</button></td></tr>`;
  $('#task-count').textContent=`${tasks.length} of ${data.tasks.length} tasks`;
  $('#filter-context').textContent=variant?variantName(variant):'Outcome filter & usage/cost sort: '+variantName(filters.variant);

}

function overview() {
  current={type:'overview'};
  $('#main').innerHTML=`<section class="hero"><div><div class="eyebrow"><span class="tiny-logo">✦</span> RLE-Bench · Embodied agent evaluation</div><h1>Coding agents.<br><span>Physical tasks.</span></h1><p>Compare native success, token usage and recorded behavior.<br>Every result opens into the full agent session and its evidence.</p></div><div class="hero-facts"><div><strong>${data.families.length}</strong><span>environment</span></div><div><strong>${data.tasks.length}</strong><span>distinct tasks</span></div><div><strong>${data.variants.length}</strong><span>agent–model variants</span></div><span class="progress-label"><i></i>${data.benchmark_complete?'Evaluation complete':'Evaluation in progress'} · selected seeds</span></div></section>
  <div class="agent-cards">${data.variants.map(v=>{const s=stats(episodes(v.id));return `<a class="agent-card ${s.n?'':'planned'}" href="#runs/${v.id}" style="--variant:${colors[v.id]}"><div class="card-header"><span class="agent-name">${icon(v)}${esc(v.label||v.agent)}</span><span class="state-label">${s.n===plannedTasks(v.id).length?'Complete':s.n?'Partial':'Planned'}</span></div><p class="card-model">${modelLabel(v)}</p><div class="card-rate"><strong>${pct(s.rate)}</strong><span>native success</span></div><div class="card-stats"><span><b>${s.n?s.passes+' / '+s.n:'—'}</b> passed</span><span class="card-cost" title="${esc(costNote(s))}"><b>${costValue(s)}</b> total cost<small>Estimated USD</small></span></div><div class="completion-track"><span style="width:${s.n/plannedTasks(v.id).length*100}%"></span></div><div class="card-bottom"><span>${s.n} / ${plannedTasks(v.id).length} evaluated</span><span>${s.n?'Explore runs':'View planned'} ${arrow}</span></div></a>`;}).join('')}</div><div id="comparison-mount">${comparisonTable()}</div><a class="audit-launcher" href="#instructions"><div><strong>Instructions audit</strong><p>Compare current RLE goals with native descriptions, runtime language pools and recorded episode instructions.</p></div><span aria-hidden="true">↗</span></a>${taskBrowser()}${methodology()}`;
  ModelCards.mount($('.agent-cards'), 'easy');
  renderRows();
}
function runsPage(variant,params,restoredFilters=null) {
  if(!variantFor(variant)){overview();return;}
  if(current.type!=='runs'||current.variant!==variant)filters={query:'',family:'',status:'',variant,sort:'catalog'};
  current={type:'runs',variant};filters.variant=variant;
  if(params.has('family')){filters.family=params.get('family');filters.status='';filters.query='';}
  if(restoredFilters)filters={...restoredFilters};
  const v=variantFor(variant),s=stats(episodes(variant));
  $('#main').innerHTML=`<div class="breadcrumbs"><a href="#overview">Benchmark</a><span>/</span><span>Agent report</span></div>${variantTabs(variant)}<section class="report-hero" style="--variant:${colors[variant]}"><div><div class="eyebrow">${s.n?'Selected results':'Planned evaluation'}</div><h1>${esc(v.label||v.agent)} <span class="muted-times">×</span> ${v.model}</h1><p>${esc(v.effort)} effort · One seed per task · ${s.n} evaluated · ${plannedTasks(variant).length-s.n} pending</p></div><button class="button secondary" data-export="${variant}">Download results ↓</button></section><div class="report-metrics">${metric(pct(s.rate),'Native success',s.n?`${s.passes} passed / ${s.n} evaluated`:'No recorded episodes')}${metric(costValue(s),'Total cost',costNote(s))}${metric(number(s.responses??s.usageMessages),s.responses==null&&s.usageMessages!=null?'Session usage messages':'Model responses',s.n?(s.responses==null&&s.usageMessages!=null?'Provider response identity unavailable':'Recorded response count'):'Not yet measured')}${metric(elapsed(s.wall==null?null:s.wall/s.n),'Mean wall time',s.n?'Per evaluated episode':'Not yet measured')}</div>${usageTiles(s,false)}<div class="family-cards">${data.families.map(f=>{const fs=stats(episodes(variant,f.id));if(!plannedTasks(variant).some(t=>t.family===f.id))return '';return `<button class="family-card ${filters.family===f.id?'active':''}" data-report-family="${f.id}"><div><strong>${f.name}</strong><span>${pct(fs.rate)}</span></div><div class="mini-track"><span style="width:${(fs.rate||0)*100}%;background:${colors[variant]}"></span></div><small>${fs.n?`${fs.passes} / ${fs.n} passed`:'Pending'} · ${plannedTasks(variant).filter(t=>t.family===f.id).length-fs.n} untested</small></button>`;}).join('')}</div>${taskBrowser(variant)}${methodology()}`;
  renderRows();
}
function nativeNote(task,ep) {
  const note=data.task_notes[task.key];if(!note)return '';
  return `<aside class="native-note" data-native-note><span class="note-symbol">!</span><div><strong>Native source · ${esc(note.kind)}</strong><p>${esc(note.text)}</p><div class="inline-links">${external(note.source,'Pinned source')}${external(note.evidence,'Diagnostic evidence')}${external(ep?.links?.analysis,'Episode record')}${external(ep?.links?.terminal_frame,'Terminal frame')}</div></div></aside>`;
}
function videoPanel(ep,mini=false) {
  const m=ep.media||{},speed=m.speed||1,links=ep.links;
  return `<div class="video-panel ${mini?'mini-video':''}"><div class="video-caption"><span><i class="status-dot"></i> Native recording</span><span>${m.width||'—'} × ${m.height||'—'} · ${m.duration_s==null?'':m.duration_s.toFixed(2)+' s'}</span></div><video id="episode-video" controls playsinline preload="metadata" style="aspect-ratio:${m.width||2}/${m.height||1}" poster="${esc(links.poster||'')}" src="${esc(links.video)}"></video><div class="video-toolbar"><label>Speed <select id="playback-speed" aria-label="Video playback speed">${[.25,.5,1,2].map(x=>`<option value="${x}" ${x===1?'selected':''}>${x*speed}× ${m.playback_kind==='official_action_index'?'recording':'simulation'}</option>`).join('')}</select></label><div><button class="button small" id="final-frame">${m.playback_kind==='official_action_index'?'Last recorded frame':'Final frame'}</button>${external(links.video,'Video','button small')}${external(links.terminal_frame,'Still','button small')}</div></div><div id="video-error" class="inline-error" hidden>Video unavailable. Open the pinned video directly using the Video link.</div></div>`;
}
function episodeMetrics(ep) {
  const u=ep.usage||{},s=stats([ep]);
  return `<section class="episode-usage" aria-label="Token usage and cost">${usageTiles(s)}<div class="usage-activity"><span><strong>${u.response_count==null&&Number.isFinite(u.known_response_count)?number(u.known_response_count)+'+':number(u.response_count??u.usage_message_count)}</strong> ${u.response_count==null&&u.usage_message_count!=null?'session usage messages':'model responses'}</span><span><strong>${number(ep.call_activity?.model_tool_calls)}</strong> tool calls</span>${external(ep.links.usage,'Usage accounting record')}</div></section>`;
}
// Align words and punctuation while preserving the exact original whitespace.
function instructionDiff(original, revised) {
  const split = text => text.match(/\s+|[\p{L}\p{N}_]+|[^\s]/gu) || [];
  const a=split(original), b=split(revised);
  const lcs=Array.from({length:a.length+1},()=>new Uint16Array(b.length+1));
  for(let i=a.length-1;i>=0;i--)for(let j=b.length-1;j>=0;j--)
    lcs[i][j]=a[i]===b[j]?lcs[i+1][j+1]+1:Math.max(lcs[i+1][j],lcs[i][j+1]);
  const before=[],after=[];
  const append=(list,text,changed)=>{const last=list.at(-1);if(last&&last.changed===changed)last.text+=text;else list.push({text,changed});};
  let i=0,j=0;
  while(i<a.length||j<b.length){
    if(i<a.length&&j<b.length&&a[i]===b[j]){append(before,a[i++],false);append(after,b[j++],false);}
    else if(j<b.length&&(i===a.length||lcs[i][j+1]>=lcs[i+1][j]))append(after,b[j++],true);
    else append(before,a[i++],true);
  }
  const html=(parts,kind)=>parts.map(p=>p.changed&&p.text.trim()?`<${kind==='removed'?'del':'mark'} class="instruction-${kind}">${esc(p.text)}</${kind==='removed'?'del':'mark'}>`:esc(p.text)).join('');
  return {original:html(before,'removed'),revised:html(after,'added')};
}
function instructionPair(task, ep) {
  const candidate = ep ? measuredInstructions.episodes[ep.id] : null;
  const record = candidate && candidate.initial_goal === ep.instruction && candidate.task_key === task.key ? candidate : null;
  const recordedNative = record?.observed_native || (ep ? ep.native_instruction : task.native_instruction);
  const measured = record?.text || (ep ? (ep.instruction || (ep.instruction_policy === 'original_native' ? recordedNative : null)) : null);
  const reference = catalogInstructionAudit.tasks.find(item => item.key === task.key && item.native_id === task.native_id);
  const nativeReference = !recordedNative && reference?.native ? reference : null;
  const native = recordedNative || nativeReference?.native;
  return {record, native, measured, nativeReference};
}

function instructionPanel(task,ep) {
  const {record,native,measured:recorded,nativeReference}=instructionPair(task,ep);
  const measured=ep?recorded:task.catalog_instruction;
  const initial=record&&record.initial_goal!==measured?record.initial_goal:null;
  const changed=Boolean(native&&measured&&native!==measured);
  const diff=changed?instructionDiff(native,measured):null;
  const choices=[['measured',ep?'Measured':'Planned',measured],['native','Original native',native],['current','Current catalog',task.catalog_instruction]].filter(([key,,text])=>text&&(key!=='current'||(ep&&text!==measured&&text!==initial)));
  const currentChanged=native&&task.catalog_instruction&&native!==task.catalog_instruction;
  const description=!ep?'The current catalog instruction for the planned evaluation.':record?.kind==='scene_bound_goal'?"The measured goal with this episode's objects and targets filled in from the agent's session.":record?.kind==='native_received'?'The native instruction received by the agent during this episode.':'The task instruction supplied for this episode.';
  return `<section class="panel instruction-panel"><div class="section-heading"><div><h2>Task instruction</h2><p>${description}</p></div><div class="segmented" aria-label="Instruction version">${choices.map(([k,label],i)=>`<button data-instruction="${k}" aria-pressed="${i===0}">${label}</button>`).join('')}</div></div>${nativeReference?`<p class="instruction-diff-note" data-native-reference><span>Native comparison uses a pinned upstream reference${ep?'; native text was not recorded in this episode':''}. ${external(nativeReference.source_url,'Native source')}</span></p>`:''}${choices.map(([k,,text],i)=>{
    const comparison=k==='current'?(currentChanged?instructionDiff(native,text):null):diff;
    const html=comparison?(k==='native'?comparison.original:comparison.revised):esc(text);
    const note=comparison?(k==='native'?'Struck-through text was removed or replaced in the '+(ep?'measured':'planned')+' instruction.':'Highlighted text was added or replaced relative to the original native instruction.'):(native?'No changes from the original native instruction.':'Original native text is unavailable for comparison.');
    return `<div class="instruction-version" id="instruction-${k}" ${i?'hidden':''}><p class="instruction-diff-note">${comparison?`<span class="diff-swatch ${k==='native'?'removed':'added'}" aria-hidden="true"></span>`:''}${note}${k==='current'?' This catalog text is not the measured episode instruction.':''}</p><div class="instruction-text">${html}</div></div>`;
  }).join('')}<div class="instruction-footer"><span>${ep?`Policy: ${esc(ep.instruction_policy)}`:'Planned seed: '+(task.planned_seed_by_variant?.[current.variant]??plannedProtocol(task,current.variant).seed)}</span><span>${ep?'Recorded':'Campaign planned'} budget: ${number(actionSteps(ep?ep.measured_protocol?.max_steps:plannedProtocol(task,current.variant).max_control_steps,task))} action steps</span></div>${record&&initial?`<p class="instruction-diff-note">${record.kind==='scene_bound_goal'?'Object names are resolved for display; the measured completion requirements are preserved.':'The initial input contained a generic placeholder; this native instruction was received in the recorded session.'} <a href="${esc(record.source.instructions_url)}" target="_blank" rel="noopener">Original instruction record ↗</a> · <a href="${esc(record.source.transcript_url)}" target="_blank" rel="noopener">Session evidence ↗</a></p>`:''}</section>`;
}

function overviewDetail(task,ep) {
  const seedLimit=data.active_campaign?.native_seed_selection?.[task.key];
  const initializationNote=task.initialization_note_by_variant?.[ep?.variant]||task.initialization_note;
  const initializationBlocked=(data.active_campaign?.initialization_blocked||[]).includes(task.key+'/'+current.variant);
  const review=reviewFor(task.key,current.variant);
  if(!ep&&review)return `<section class="panel pending-panel" data-runtime-review><span class="badge invalid">Under review</span><h2>Native success recorded; runtime finalization failed</h2><p>${esc(review.reason)}</p><p>Original harness verdict: invalid. Recording manifest: incomplete. This attempt is excluded from formal success metrics; its usage is retained separately.</p><dl class="facts"><dt>Native terminal steps</dt><dd>${number(actionSteps(review.native_terminal_steps,task,current.variant))}</dd><dt>Fresh input</dt><dd>${number(review.usage.fresh_input_tokens)}</dd><dt>Cache read</dt><dd>${number(review.usage.cached_input_tokens)}</dd><dt>Output</dt><dd>${number(review.usage.output_tokens)}</dd><dt>Model responses</dt><dd>${number(review.usage.response_count)}</dd><dt>Estimated API-equivalent cost</dt><dd>${exactMoney(review.estimated_api_equivalent_usd)}</dd></dl><p>Both original camera streams decode successfully. Their completion manifest was not sealed, so they are retained as review evidence.</p><div class="inline-links">${Object.entries(review.links).map(([key,url])=>external(url,key.replaceAll('_',' '))).join('')}</div></section>${instructionPanel(task,null)}`;
  if(!ep)return `<div class="pending-layout"><section class="pending-panel"><span class="pending-orbit">○</span><span class="eyebrow">${initializationBlocked?'Initialization blocked':'Awaiting evaluation'}</span><h2>${seedLimit?.exhausted?'No native-valid seed at or below '+number(seedLimit.max_seed):initializationBlocked?'Native seed 0 could not initialize':'No recorded episode yet'}</h2><p>${variantName(current.variant)} / ${esc(variantFor(current.variant).effort)}</p><div class="pending-facts">${metric(number(actionSteps(plannedProtocol(task,current.variant).max_control_steps,task)),'Campaign planned action steps')}${metric(String(task.planned_seed_by_variant?.[current.variant]??plannedProtocol(task,current.variant).seed),'Seed')}${metric(task.planned_protocol.control_frequency_hz+' Hz','Control frequency')}</div><p class="subtle">${seedLimit?.exhausted?'Native checks exhausted seeds 1–'+number(seedLimit.max_seed)+'. No Codex model attempt was launched. The original Kinex result is retained; this unavailable Codex task is excluded from success rates.':initializationBlocked?'No model was called. Seed 0 is retained by user decision; this is excluded from task success rates.':'This task is included in the planned catalog. Results and usage will appear after evaluation.'}</p></section>${instructionPanel(task,null)}</div>${seedLimit?.evidence_url?external(seedLimit.evidence_url,'Native seed selection evidence'):''}${nativeNote(task,null)}`;
  const m=ep.media||{},u=ep.usage||{},a=ep.analysis||{};
  const reason=a.evidence_note||a.failure_reason||a.cause||a.observed||a.visible_completion;
  return `<div class="episode-layout"><div>${videoPanel(ep)}<p class="media-note">${m.playback_kind==='official_action_index'?'Head + left wrist + right wrist · 4× official recording, not simulation time. Wrist views update only at inference boundaries. Native 320 × 240 views are upscaled for display; action-limit recordings omit the post-final-action frame.':ep.recording_mode==='native'?'Native camera recording · cached agent-resolution frames · '+(m.speed||1)+'× simulation speed.':ep.provider==='robobridge'&&m.playback_kind==='live_spectator'?'Independent spectator cameras · 720 px high per view · overview + wrist views · '+(m.speed||1)+'× simulation speed. Agent images retain native resolution and orientation.':m.playback_kind==='native_observation_snapshots'?'Native observation snapshots · 10 FPS playback; this is not simulation time.':`${m.source_fps?m.source_fps+' FPS source capture · ':''}${m.speed||1}× simulation speed.`} Session timestamps use wall time and are not synchronized to video frames.</p></div><aside class="result-panel panel"><div class="result-head"><span class="eyebrow">Native verdict</span>${badge(ep)}</div><div class="result-number">${number(actionSteps(ep.steps,ep))}<span> / ${number(actionSteps(ep.measured_protocol?.max_steps,ep))} action steps</span></div><div class="completion-track"><span style="width:${Math.min(100,(actionSteps(ep.steps,ep)||0)/(actionSteps(ep.measured_protocol?.max_steps,ep)||1)*100)}%"></span></div><dl class="facts"><dt>Termination</dt><dd>${esc(ep.verdict?.termination||'—')}</dd><dt>Execution</dt><dd>${esc(ep.execution?.status||'—')}</dd><dt>Evidence</dt><dd>${ep.valid?'Valid':'Invalid'}</dd><dt>Simulation time</dt><dd title="${esc(ep.timing?.simulation_time_note||'')}">${ep.timing&&ep.simulation_time_s==null?'Not recorded':elapsed(ep.simulation_time_s)}</dd><dt>Wall time</dt><dd title="${esc(ep.timing?.wall_time_scope||'')}">${elapsed(ep.wall_time_s)}</dd><dt>Estimated cost</dt><dd>${costValue(stats([ep]))}</dd><dt>Seed</dt><dd>${ep.seed}</dd><dt>Agent version</dt><dd>${kinexDisplayVersion(ep)?'Kinex v'+esc(kinexDisplayVersion(ep)):ep.codex_version?'Codex '+esc(ep.codex_version):ep.claude_code_version?'Claude Code '+esc(ep.claude_code_version):esc(variantFor(ep.variant).agent)}</dd></dl><div class="result-links">${external(ep.links.verdict,'Native verdict')}${external(ep.links.provenance,'Source identity')}</div></aside></div>${nativeNote(task,ep)}${ep.post_terminal_review?`<aside class="native-note" data-post-terminal-note><span class="note-symbol">!</span><div><strong>Native episode completed; later provider error</strong><p>${esc(ep.post_terminal_review.reason)}</p>${external(ep.links.completion_review,"Terminal completion review")}</div></aside>`:""}${initializationNote?`<aside class="native-note" data-initialization-note><span class="note-symbol">!</span><div><strong>Measured initial-state variation</strong><p>${esc(initializationNote)}</p><a href="${esc(resultURL('initialization-comparison.json'))}" target="_blank">Paired initialization evidence ↗</a></div></aside>`:''}${ep.usage_review?`<aside class="native-note" data-usage-review-note><span class="note-symbol">i</span><div><strong>Context compaction included in usage</strong><p>${esc(ep.usage_review.reason)}</p>${external(ep.links.usage_review,"Usage reconciliation evidence")}</div></aside>`:""}${ep.native_clock_review?`<aside class="native-note" data-native-clock-note><span class="note-symbol">i</span><div><strong>Native physics clock differs from control-frame time</strong><p>${esc(ep.native_clock_review.reason)}</p>${external(ep.links.native_clock_review,"Native clock review")}</div></aside>`:""}${ep.collector_review&&ep.collector_review.schema!=="rlebench/collector-recovery/1"?`<aside class="native-note" data-collector-review-note><span class="note-symbol">i</span><div><strong>Host collector recovered; original model continued</strong><p>${esc(ep.collector_review.reason)}</p><p>Wall time uses the original session timestamps. Lost host setup timing is left unknown.</p><p>Host waiting protection was extended prospectively from 8 to 16 hours for this original execution; the native control budget is unchanged.</p>${external(ep.links.collector_review,"Collector recovery evidence")}</div></aside>`:""}${ep.provenance?.protocol_exception?.same_seed_comparison===false?`<aside class="native-note" data-seed-scope-note><span class="note-symbol">i</span><div><strong>Different evaluation seeds</strong><p>Codex uses seed ${number(ep.seed)} after native expert and initialization checks with no model calls during selection. ${ep.provenance.protocol_exception.max_seed!=null?'Seed selection was capped at '+number(ep.provenance.protocol_exception.max_seed)+'. ':''} Kinex retains its original seed ${number(ep.provenance.protocol_exception.preserved_kinex_seed)} result. Codex ran once; this is not a same-seed comparison.</p>${external(ep.links.seed_selection,'Native seed selection evidence')}</div></aside>`:''}${recordingComparisonNote(ep)}${episodeMetrics(ep)}<div class="detail-two-column">${instructionPanel(task,ep)}<section class="panel episode-analysis"><div class="section-heading"><div><h2>Episode notes</h2><p>Recorded observations and task-specific interpretation.</p></div></div><div class="analysis-body">${reason?`<p>${esc(reason)}</p>`:`<p>${esc(a.outcome||'The native result and original evidence are retained for this episode.')}</p>`}<details><summary>Read recorded analysis</summary>${Object.entries(a).filter(([k])=>k!=='preflight').map(([k,v])=>`<div class="analysis-entry"><span>${esc(k.replaceAll('_',' '))}</span><p>${esc(typeof v==='string'?v:JSON.stringify(v))}</p></div>`).join('')}</details><div class="inline-links">${external(ep.links.analysis,'Analysis JSON')}${external(ep.links.terminal_frame,'Terminal evidence')}</div></div></section></div><div class="detail-launchers"><a href="${taskRoute(task.key,ep.variant,'session')}"><span class="launcher-icon">≡</span><div><strong>Read the full session</strong><span>${number(ep.session_counts?.visible_events)} events · ${number(ep.session_counts?.observed_images)} observations</span></div>${arrow}</a><a href="${taskRoute(task.key,ep.variant,'artifacts')}"><span class="launcher-icon">⌘</span><div><strong>Inspect agent artifacts</strong><span>${ep.resources?.length||0} saved files · workspace & evidence</span></div>${arrow}</a></div>`;
}
function taskPage(key,variant,section='overview') {
  const task=data.tasks.find(t=>t.key===key);if(!task||!variantFor(variant)){notFound();return;}
  if(!task.planned_variants.includes(variant)){current={type:'not-scheduled'};$('#main').innerHTML=`<section class="panel pending-panel"><h1>Not scheduled</h1><p>${esc(variantFor(variant).agent)} is not included for ${esc(familyName(task.family))} in this campaign.</p><a class="button secondary" href="${taskRoute(key,task.planned_variants[0])}">View the scheduled evaluation ${arrow}</a></section>`;return;}
  const ep=epFor(key,variant), validSections=['overview','session','tools','policy','artifacts','evidence','attempts'];
  if(!validSections.includes(section)||(!ep&&!['overview','attempts'].includes(section)))section='overview';
  current={type:'task',key,variant,section,ep,task};
  sessionState={filter:'all',query:'',count:40,view:'timeline'};
  const taskList=plannedTasks(variant),index=taskList.indexOf(task),history=data.attempt_history.filter(h=>h.task_key===key&&h.variant===variant);
  document.title=`${task.title} · ${variantFor(variant).agent} — Programmable VLA`;
  $('#main').innerHTML=`<div class="breadcrumbs"><a data-task-return href="${esc(taskListReturn?.hash || '#tasks?task='+encodeURIComponent(key))}">← Back to tasks</a><span>/</span><a href="#runs/${variant}?family=${task.family}">${familyName(task.family)}</a><span>/</span><code>${key}</code></div><div class="task-heading"><div><div class="eyebrow">${familyName(task.family)} · ${key}</div><h1>${esc(task.title)}</h1><p><code>${esc(task.native_id)}</code></p></div><div class="task-arrows">${index?`<a class="button" href="${taskRoute(taskList[index-1].key,variant)}" aria-label="Previous task">←</a>`:''}${index<taskList.length-1?`<a class="button" href="${taskRoute(taskList[index+1].key,variant)}" aria-label="Next task">→</a>`:''}</div></div>${budgetNote(task)}${variantTabs(variant,key,section)}<nav class="detail-nav" aria-label="Episode sections">${[['overview','Overview',null],['session','Session',ep?.session_counts?.visible_events],['tools','Tool calls',ep?.call_activity?.model_tool_calls],['policy','VLA input/output',ep?.vla_calls],['artifacts','Artifacts',ep?.resources?.length],['evidence','Evidence',null],['attempts','Previous attempts',history.length]].filter(([k])=>k!=='attempts'||history.length).map(([k,l,n])=>!ep&&!['overview','attempts'].includes(k)?`<span class="disabled-tab" aria-disabled="true">${l}</span>`:`<a href="${taskRoute(key,variant,k)}" class="${k===section?'active':''}" ${k===section?'aria-current="page"':''}>${l}${n!=null?`<span>${number(n)}</span>`:''}</a>`).join('')}<span class="detail-model">${variantFor(variant).model} / ${variantFor(variant).effort}</span></nav><div id="detail-content">${section==='overview'?overviewDetail(task,ep):section==='session'?sessionShell(ep):section==='tools'?toolsShell(ep):section==='policy'?policyShell(ep):section==='artifacts'?artifactsPanel(ep):section==='evidence'?evidencePanel(task,ep):historyPanel(history,task)}</div>`;
  setupVideo();
  if(section==='session')loadSession(ep,epoch);
  if(section==='tools')loadTools(ep,epoch);
  if(section==='policy')loadPolicy(ep,epoch);
  if(section==='artifacts'&&ep.resources?.length)loadResource(0,epoch);
}
function setupVideo() {
  const v=$('#episode-video');if(!v)return;
  v.onerror=()=>{if($('#video-error'))$('#video-error').hidden=false;};
}
function sessionShell(ep) {
  return `<section class="panel session-panel"><div class="section-heading"><div><h2>Session & observations</h2><p id="session-summary">Loading the original transcript…</p></div><div class="inline-links">${external(ep.links.transcript,'Transcript JSON')}${external(ep.links.native_session,'Native session')}</div></div><div class="session-toolbar"><div class="segmented"><button data-session-view="timeline" aria-pressed="true">Timeline</button><button data-session-view="gallery" aria-pressed="false">Observations</button></div><select id="event-filter" aria-label="Filter session events"><option value="all">All events</option><option value="assistant">Assistant</option><option value="tools">Tool results</option><option value="errors">Tool errors</option><option value="images">With images</option><option value="context">User & context</option></select><input id="event-search" type="search" placeholder="Search text, tool name or event ID" aria-label="Search session"><span id="event-count" aria-live="polite"></span></div><div id="session-events"><div class="loading"><span class="spinner"></span>Loading session…</div></div><div class="session-more"><button id="more-events" class="button secondary" hidden>Load more events</button></div></section>`;
}
async function loadSession(ep,token) {
  try {
    if(!sessionCache.has(ep.id)) {
      const response=await fetch(ep.links.transcript);if(!response.ok)throw Error('HTTP '+response.status);
      const raw=await response.json();const entries=Array.isArray(raw)?raw:raw.messages||raw.entries||raw.events||[];
      if(!Array.isArray(entries))throw Error('Unsupported transcript format');
      sessionCache.set(ep.id,entries);
      if(sessionCache.size>6)sessionCache.delete(sessionCache.keys().next().value);
    }
    if(token!==epoch)return;
    const entries=sessionCache.get(ep.id),images=entries.flatMap((m,i)=>(m.parts||[]).filter(p=>p.type==='image'&&p.src).map(p=>({url:new URL(p.src,new URL(ep.links.transcript,location.href)).href,label:`Event ${i+1} · ${m.id||m.role||'Observation'}`})));
    $('#session-summary').textContent=`${number(entries.length)} events · ${number(images.length)} observation images · ${entries.filter(e=>e.error).length} tool errors. Event timestamps are in UTC.`;
    renderSession();
  } catch(error) {if(token!==epoch)return;$('#session-events').innerHTML=`<div class="empty-state">Transcript preview could not load (${esc(error.message)}).<br><button class="button secondary" data-retry-session>Retry</button> ${external(ep.links.transcript,'Open original transcript')}</div>`;}
}
function sessionText(entry) {return [entry.id,entry.role,entry.tool,...(entry.parts||[]).map(p=>p.text||JSON.stringify(p.input||p))].join('\n');}
function renderSession() {
  const entries=sessionCache.get(current.ep.id);if(!entries)return;
  const {filter,query,count,view}=sessionState, q=query.trim().toLowerCase();
  let matches=entries.map((entry,i)=>({entry,index:i})).filter(({entry:e})=>(filter==='all'||filter==='assistant'&&e.role==='assistant'||filter==='tools'&&e.role==='toolResult'||filter==='errors'&&e.error||filter==='images'&&(e.parts||[]).some(p=>p.type==='image')||filter==='context'&&['user','system','developer'].includes(e.role))&&(!q||sessionText(e).toLowerCase().includes(q)));
  imageItems=[];
  const imagePart=(p,index,entry,cls='observation')=>{
    const url=new URL(p.src,new URL(current.ep.links.transcript,location.href)).href;if(!/^https?:/.test(url))return '';
    const n=imageItems.length;imageItems.push({url,label:`Event ${index+1} · ${entry.id||entry.role||'Observation'}`});
    return `<button class="${cls}" data-image="${n}" aria-label="Open observation from event ${index+1}"><img src="${esc(url)}" alt="Agent observation at event ${index+1}" loading="lazy" decoding="async"><span>Event ${index+1} ${arrow}</span></button>`;
  };
  if(view==='gallery') {
    const images=matches.flatMap(({entry,index})=>(entry.parts||[]).filter(p=>p.type==='image'&&p.src).map(part=>({entry,index,part})));
    $('#session-events').innerHTML=images.length?`<div class="observation-gallery">${images.slice(0,count).map(({entry,index,part})=>imagePart(part,index,entry,'gallery-image')).join('')}</div>`:'<div class="empty-state">No observation images match these filters.</div>';
    $('#event-count').textContent=`${Math.min(count,images.length)} / ${images.length} images`;$('#more-events').hidden=count>=images.length;
  } else {
    $('#session-events').innerHTML=matches.length?`<div class="timeline">${matches.slice(0,count).map(({entry:e,index})=>{
      const role=e.role==='toolResult'?'Tool result':e.role==='assistant'?'Assistant':({user:'User',system:'System',developer:'Developer'}[e.role]||e.role||e.type||'Event');
      const tool=e.tool||(e.parts||[]).find(p=>p.type==='tool')?.name;
      return `<article class="session-entry ${e.error?'event-error':''}" id="event-${index}"><div class="event-index">${index+1}</div><div class="event-content"><div class="event-header"><strong>${esc(role)}</strong>${tool?`<code>${esc(tool)}</code>`:''}${e.error?'<span class="error-tag">Error</span>':''}<time>${esc(e.timestamp?e.timestamp.replace('T',' ').replace(/\.\d+Z$/,' UTC'):'')}</time></div><div class="event-parts">${(e.parts||[{type:'text',text:typeof e==='string'?e:JSON.stringify(e,null,2)}]).map(p=>{
        if(p.type==='image'&&p.src)return imagePart(p,index,e);
        if(p.type==='tool')return `<details class="tool-block"><summary><span>Tool call · <strong>${esc(p.name)}</strong></span><code>${esc((typeof p.input==='string'?p.input:JSON.stringify(p.input)).slice(0,130))}</code></summary><pre>${esc(typeof p.input==='string'?p.input:JSON.stringify(p.input,null,2))}</pre></details>`;
        const txt=p.text??p.thinking??JSON.stringify(p,null,2);
        if(txt==='')return '<span class="empty-event">No text recorded.</span>';
        if(p.type==='thinking'||p.type==='reasoning')return `<details class="tool-block"><summary>Recorded reasoning</summary><pre>${esc(txt)}</pre></details>`;
        if(e.role==='toolResult'||txt.length>1800)return `<details class="tool-block ${e.error?'error-block':''}"><summary><span>${e.role==='toolResult'?'Tool output':'Message'}</span><span class="output-excerpt">${esc(txt.slice(0,160))}</span></summary><pre>${esc(txt)}</pre></details>`;
        return `<div class="message-text">${esc(txt)}</div>`;
      }).join('')}</div><div class="event-id">${esc(e.id||'')}</div></div></article>`;
    }).join('')}</div>`:'<div class="empty-state">No events match these filters.</div>';
    $('#event-count').textContent=`${Math.min(count,matches.length)} / ${matches.length} events`;$('#more-events').hidden=count>=matches.length;
  }
  $('#more-events').textContent=view==='gallery'?'Load more observations':'Load next 40 events';
}
function artifactsPanel(ep) {
  const resources=ep.resources||[];
  return `<section class="panel artifacts-panel"><div class="section-heading"><div><h2>Agent artifacts</h2><p>Final files created during this episode. Their edit history remains in the session.</p></div><div class="inline-links">${external(ep.links.workspace,'Workspace archive')}${external(ep.links.workspace_changes,'Workspace manifest')}</div></div>${resources.length?`<div class="file-browser"><aside class="file-list" aria-label="Artifact files"><div class="file-list-title">${resources.length} saved files</div>${resources.map((r,i)=>`<button data-resource="${i}" class="file-item ${i===0?'active':''}" aria-pressed="${i===0}"><span class="file-extension">${esc(r.name.split('.').at(-1).toUpperCase().slice(0,4))}</span><span>${esc(r.name)}</span></button>`).join('')}</aside><div class="file-preview"><div class="file-toolbar"><code id="resource-name">${esc(resources[0].name)}</code><div><button class="button small" id="copy-resource">Copy</button><a class="button small" id="resource-open" target="_blank" rel="noopener" href="${esc(resources[0].file)}">Open file ↗</a></div></div><p id="resource-kind" class="file-caption"></p><pre id="resource-preview" tabindex="0">Loading file…</pre></div></div>`:'<div class="empty-state">No standalone tool or memo files were saved in this episode. The original session and workspace evidence remain available.</div>'}</section><div class="artifact-shortcuts">${evidenceCard('Execution evidence','Original verdict, protocol and runtime identity.',[['verdict','Native verdict'],['protocol','Protocol'],['provenance','Source identity']],ep)}${evidenceCard('Session & interactions','Original tool calls, observations and edited workspace.',[['native_session','Native session'],['trace','Trace'],['workspace_changes','Workspace changes']],ep)}</div>`;
}
async function fetchText(url) {
  if(fileCache.has(url))return fileCache.get(url);
  const r=await fetch(url);if(!r.ok)throw Error('HTTP '+r.status);
  if(Number(r.headers.get('content-length'))>3e6)throw Error('File exceeds the 3 MB preview limit; use Open file');
  const text=await r.text();if(text.length>3e6)throw Error('File exceeds the preview limit; use Open file');
  fileCache.set(url,text);if(fileCache.size>20)fileCache.delete(fileCache.keys().next().value);return text;
}
async function loadResource(index,token) {
  const r=current.ep?.resources?.[index];if(!r)return;
  current.resource=index;$('#resource-name').textContent=r.name;$('#resource-open').href=r.file;$('#resource-kind').textContent=r.kind||'Final workspace snapshot';$('#resource-preview').textContent='Loading file…';
  $$('[data-resource]').forEach(b=>{b.classList.toggle('active',+b.dataset.resource===index);b.setAttribute('aria-pressed',+b.dataset.resource===index);});
  try{const text=await fetchText(r.file);if(token===epoch&&current.resource===index){$('#resource-preview').textContent=text;current.resourceText=text;}}
  catch(e){if(token===epoch&&current.resource===index){$('#resource-preview').textContent='Preview unavailable: '+e.message;current.resourceText=null;}}
}
const evidenceGroups=[
  ['Native evaluation','Owner verdicts, measured task and control protocol.',[['verdict','Native verdict'],['timing','Episode timing'],['protocol','Measured protocol'],['native_goal','Task instructions'],['owner_journal','Owner action journal']]],
  ['Session & workspace','The original agent trajectory and final files.',[['native_session','Native session'],['transcript','Readable transcript'],['trace','Agent trace'],['workspace','Workspace archive'],['workspace_changes','Workspace manifest']]],
  ['Recording & review','Published media and checks against the recorded evidence.',[['native_video','Original head recording'],['video','Video'],['poster','Poster'],['terminal_frame','Terminal frame'],['recording_manifest','Recording manifest'],['media_check','Media validation'],['analysis','Episode analysis']]],
  ['Usage & provenance','Provider counters and the actual code used by the episode.',[['usage','Token usage'],['provider_usage','Provider usage ledger'],['provenance','Source identities'],['tool_errors','Tool errors']]]
];
function evidenceCard(title,description,items,ep) {
  return `<section class="panel evidence-card"><h3>${title}</h3><p>${description}</p><div>${items.filter(([k])=>ep.links[k]).flatMap(([k,l])=>(Array.isArray(ep.links[k])?ep.links[k]:[ep.links[k]]).map((url,i)=>external(url,l+(Array.isArray(ep.links[k])?' '+(i+1):'')))).join('')}</div></section>`;
}
function evidencePanel(task,ep) {
  const used=new Set(evidenceGroups.flatMap(g=>g[2].map(x=>x[0]))),extras=Object.keys(ep.links).filter(k=>!used.has(k));
  const source={...data.variant_sources[ep.variant],...(ep.source_dataset_revision?{dataset_revision:ep.source_dataset_revision}:{})};
  return `<div class="evidence-intro"><h2>Evidence & provenance</h2><p>Original files retained with their published checksums. Native verdicts and measured source identities remain unchanged.</p></div><div class="evidence-grid">${evidenceGroups.map(([title,desc,items])=>evidenceCard(title,desc,items,ep)).join('')}${extras.length?evidenceCard('Additional records','Episode-specific checks and retained references.',extras.map(k=>[k,k.replaceAll('_',' ')]),ep):''}</div><section class="panel provenance-panel"><div class="section-heading"><div><h2>Recorded identity</h2><p>Source and protocol belonging to this episode.</p></div></div><dl class="provenance-list"><dt>Episode</dt><dd><code>${esc(ep.source_episode_id)}</code></dd><dt>Model</dt><dd>${esc(ep.model)} / ${ep.effort}</dd><dt>Space</dt><dd>${external('https://huggingface.co/spaces/'+source.space,source.space)}</dd><dt>Original evidence revision</dt><dd><code>${source.evidence_revision}</code></dd>${ep.kinex_revision?`<dt>Kinex revision</dt><dd><code>${esc(ep.kinex_revision)}</code></dd>`:''}${Object.entries(ep.provenance?.sources||{}).map(([k,v])=>`<dt>${esc(k)}</dt><dd><code>${esc(v.revision||'Unrecorded revision')}</code>${v.dirty?' <span class="tag">Local changes recorded</span>':''}</dd>`).join('')}<dt>Recorded action-step budget</dt><dd>${number(actionSteps(ep.measured_protocol?.max_steps,ep))} steps</dd><dt>Campaign planned action-step budget</dt><dd>${number(actionSteps(plannedProtocol(task,current.variant).max_control_steps,task))} steps</dd><dt>Current benchmark default</dt><dd>${number(currentBudget(task))} action steps</dd></dl><details class="protocol-json"><summary>Inspect the measured protocol JSON</summary><pre>${esc(JSON.stringify(ep.measured_protocol,null,2))}</pre></details></section><section class="panel evidence-preview-panel"><div class="section-heading"><div><h2>Preview an evidence file</h2><p>Inspect the recorded JSON without leaving this page.</p></div><select id="evidence-select" aria-label="Choose evidence preview"><option value="">Choose a file…</option>${[['verdict','Native verdict'],['timing','Episode timing'],['protocol','Measured protocol'],['provenance','Source identities'],['usage','Token usage'],['analysis','Episode analysis'],['media_check','Media validation'],['recording_manifest','Recording manifest']].filter(([k])=>ep.links[k]).map(([k,l])=>`<option value="${k}">${l}</option>`).join('')}</select></div><pre id="evidence-preview" hidden tabindex="0"></pre></section>`;
}
function historyPanel(history,task) {
  return `<section class="panel history-panel"><div class="section-heading"><div><h2>Previous attempts</h2><p>Archived attempts are preserved separately and excluded from the current success rate, usage and costs.</p></div><a href="${esc(resultURL('attempt-history.json'))}" target="_blank" class="button secondary">Full archive ↗</a></div>${history.length?history.map(h=>`<article class="history-row"><div class="history-outcome">${badge(h)}<small>${h.valid===false?'Interrupted / invalid':typeof h.success==='boolean'?'Archived result':'Verdict not recorded'}</small></div><div><strong>${esc((h.status||'Archived attempt').replaceAll('_',' '))}</strong><p><code>${esc(h.id||h.job||h.dataset_revision||'Historical record')}</code></p><span class="history-stats">${h.steps!=null?number(actionSteps(h.steps,task))+' action steps · ':''}${h.usage?'Fresh input '+compact(UsageMetrics.usage(h).fresh)+' · cache read '+compact(h.usage.cached_input_tokens)+' · cache write '+compact(UsageMetrics.usage(h).cacheWrite)+' · output '+compact(UsageMetrics.usage(h).output)+' · ':''}${h.dataset_revision?'Revision '+h.dataset_revision.slice(0,8):''}</span>${h.analysis?.execution?`<p>${esc(h.analysis.execution)}</p>`:''}${h.instruction?`<details><summary>Measured instruction</summary><p>${esc(h.instruction)}</p></details>`:''}<div class="inline-links">${Object.entries(h.links||{}).filter(([k])=>['video','verdict','provenance','transcript','terminal_frame','native_session','result_page'].includes(k)).map(([k,u])=>external(u,k.replaceAll('_',' '))).join('')}</div></div></article>`).join(''):'<div class="empty-state">No earlier attempts are listed for this task and agent combination.</div>'}</section>`;
}
function notFound() {$('#main').innerHTML='<div class="empty-state"><h1>Page not found</h1><p><a href="#overview">Return to the benchmark</a></p></div>';}
// Keep each task list's view with its browser history entry.
history.scrollRestoration = 'manual';
let taskListReturn = null;
const navigationHash = () => location.hash || '#overview';
function saveTaskList(row = null) {
  if (!['overview', 'runs'].includes(current.type) || !$('#task-rows')) return;
  row ||= $$('#task-rows tr[data-task]').find(r => r.getBoundingClientRect().bottom > 100);
  const view = {
    hash: navigationHash(), filters: {...filters}, x: window.scrollX, y: window.scrollY,
    task: row?.dataset.task, offset: row?.getBoundingClientRect().top,
    tableX: $('#tasks .table-scroll').scrollLeft,
    matrixMetric, expandedModels: $$('[data-model-group][open]').map(el => el.dataset.modelGroup)
  };
  history.replaceState({...history.state, benchmarkNavigation: {list: view}}, '');
  return view;
}
function restoreTaskList(view) {
  const row = $$('#task-rows tr[data-task]').find(r => r.dataset.task === view.task);
  const y = row && view.offset != null
    ? window.scrollY + row.getBoundingClientRect().top - view.offset : view.y;
  $('#tasks .table-scroll').scrollLeft = view.tableX;
  window.scrollTo({left: view.x, top: y, behavior: 'instant'});
}
document.addEventListener('click', event => {
  const link = event.target.closest('a[href]');
  if (!link || event.button !== 0 || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey ||
      link.target === '_blank' || !link.getAttribute('href').startsWith('#')) return;
  const view = saveTaskList(link.closest('tr[data-task]'));
  if (view && link.getAttribute('href').startsWith('#task/')) taskListReturn = view;
}, true);
window.addEventListener('pagehide', () => saveTaskList());

function route() {
  epoch++;$$('video').forEach(v=>{v.pause();v.removeAttribute('src');v.load();});
  const [hash,query='']=location.hash.slice(1).split('?'),parts=hash.split('/'),params=new URLSearchParams(query);
  const saved = history.state?.benchmarkNavigation;
  const returning = current.type === 'task' && taskListReturn &&
    (taskListReturn.hash === navigationHash() ||
     ['#overview', '#tasks'].includes(taskListReturn.hash) && ['#overview', '#tasks'].includes(navigationHash()));
  const view = saved?.list?.hash === navigationHash() ? saved.list : returning ? taskListReturn : null;
  if (parts[0] === 'task') {
    taskListReturn = saved ? saved.origin || null : (['overview', 'runs', 'task'].includes(current.type) ? taskListReturn : null);
    history.replaceState({...history.state, benchmarkNavigation: {origin: taskListReturn}}, '');
  } else if (view) {
    filters = {...view.filters};
    matrixMetric = view.matrixMetric;
    expandedModels = new Set(view.expandedModels);
  }
  document.title='Programmable VLA — RLE-Bench';
  if(parts[0]==='task')taskPage(parts[1]+'/'+parts[2],parts[3],parts[4]||'overview');
  else if(parts[0]==='instructions'){current={type:'instructions'};const auditEpoch=epoch;InstructionAudit.render({panel:'easy',root:'',data,measuredInstructions,diff:instructionDiff,isCurrent:()=>epoch===auditEpoch});}
  else if(parts[0]==='runs')runsPage(parts[1],params,view?.filters);
  else overview();
  $$('[data-nav]').forEach(a=>a.setAttribute('aria-current',a.dataset.nav===(hash||'overview')?'page':'false'));
  if(view && $('#task-rows'))restoreTaskList(view);
  else if(hash==='tasks') {
    const row = $$('#task-rows tr[data-task]').find(r => r.dataset.task === params.get('task'));
    (row || $('#tasks')).scrollIntoView({block: row ? 'center' : 'start', behavior: 'instant'});
  }
  else if(hash==='methodology'){$('#methodology').open=true;$('#methodology').scrollIntoView();}
  else window.scrollTo({left:0,top:0,behavior:'instant'});
  if(parts[0]!=='task')taskListReturn=null;
}
function resetFilters() {filters={query:'',family:'',status:'',variant:filters.variant,sort:'catalog'};if(current.type==='runs')runsPage(current.variant,new URLSearchParams());else overview();$('#tasks').scrollIntoView();}
function showToast(text){$('#toast').textContent=text;$('#toast').classList.add('visible');setTimeout(()=>$('#toast').classList.remove('visible'),2200);}
function exportCSV(variant) {
  const ids=variant==='all'?data.variants.map(v=>v.id):[variant];
  const rows=[['task','environment','title','agent','model','effort','status','native_success','fresh_input_tokens','cache_read_tokens','cache_write_tokens','cache_write_counter_source','input_tokens_fresh_plus_cache_write','input_tokens_lower','input_tokens_upper','cached_tokens','cached_tokens_lower','cached_tokens_upper','cache_hit_rate','cache_hit_rate_lower','cache_hit_rate_upper','output_tokens','inclusive_input_tokens_original','cache_write_tokens_original','estimated_cost_usd','estimated_cost_lower_usd','estimated_cost_upper_usd','cost_basis','cache_write_basis','cache_write_assumed','steps','episode_id','reasoning_output_tokens','recorded_budget','planned_budget','source_episode_id','inclusive_total_tokens_original','seed','planned_seed','agent_execution','reported_harness_valid','post_terminal_provider_error','host_collector_recovered','harness_result_origin','agent_wall_time_limit_s','requested_wall_time_limit_s','wall_time_guard_adjusted','raw_steps','raw_recorded_budget','raw_planned_budget','current_action_step_budget']];
  for(const t of data.tasks)for(const id of ids){
    if(!t.planned_variants.includes(id))continue;
    const e=epFor(t.key,id),v=variantFor(id),u=UsageMetrics.usage(e),c=UsageMetrics.price(e);
    rows.push([t.key,familyName(t.family),t.title,v.agent,v.model,v.effort,outcome(e),e?e.success:'',u.fresh,u.cached,u.cacheWrite,e?u.writeBasis:null,u.input,u.inputLow,u.inputHigh,u.cached,u.cacheLow,u.cacheHigh,u.cacheRate,u.cacheRateLow,u.cacheRateHigh,u.output,u.inclusive,e?.usage?.cache_write_input_tokens,c&&c.lower===c.upper?c.lower:null,c?.lower,c?.upper,c?.basis,c?.cache_write_basis,c?.cache_write_assumed,actionSteps(e?.steps,t,id),e?.id,e?.usage?.reasoning_output_tokens,actionSteps(e?.measured_protocol?.max_steps,t,id),actionSteps(plannedProtocol(t,id).max_control_steps,t,id),e?.source_episode_id,tokens(e),e?.seed,t.planned_seed_by_variant[id],e?.execution?.status,e?(Object.prototype.hasOwnProperty.call(e,"harness_valid")?e.harness_valid:e.valid):null,e?Boolean(e.post_terminal_review):null,e?Boolean(e.collector_review):null,e?(e.harness_result_origin||"harbor"):null,e?.measured_protocol?.timeout_s,e?(e.measured_protocol?.requested_timeout_s??e.measured_protocol?.timeout_s):null,e?Boolean(e.collector_review?.operational_wall_time_adjustment):null,e?.steps,e?.measured_protocol?.max_steps,plannedProtocol(t,id).max_control_steps,currentBudget(t)]);
  }
  const csv=rows.map(row=>row.map(v=>'"'+String(v??'').replaceAll('"','""')+'"').join(',')).join('\r\n');
  const url=URL.createObjectURL(new Blob([csv],{type:'text/csv;charset=utf-8'})),a=document.createElement('a');a.href=url;a.download='kinex-benchmark-'+variant+'.csv';a.click();setTimeout(()=>URL.revokeObjectURL(url),1000);
}
function showImage(index) {
  if(!imageItems.length)return;imageIndex=(index+imageItems.length)%imageItems.length;const item=imageItems[imageIndex];$('#large-image').src=item.url;$('#image-original').href=item.url;$('#image-caption').textContent=`${imageIndex+1} / ${imageItems.length} · ${item.label}`;if(!$('#image-viewer').open)$('#image-viewer').showModal();
}
$('#main').addEventListener('click',async event=>{
  const b=event.target.closest('button,a');if(!b)return;
  if(b.dataset.taskColumn || b.dataset.taskColumns){
    const id=b.dataset.taskColumn, wasEmpty=expandedTaskVariants.size===0;
    if(id){
      if(expandedTaskVariants.has(id))expandedTaskVariants.delete(id);else expandedTaskVariants.add(id);
      if(wasEmpty){filters.variant=id;$('#task-variant').value=id;}
    }else{
      expandedTaskVariants.clear();
      if(b.dataset.taskColumns==='all')data.variants.forEach(v=>expandedTaskVariants.add(v.id));
    }
    renderRows();
    if(b.classList.contains('column-close'))$(`[data-task-column="${id}"].task-column-toggle`).focus({preventScroll:true});
  }
  if(b.dataset.matrix){expandedModels=new Set($$('[data-model-group][open]').map(x=>x.dataset.modelGroup));matrixMetric=b.dataset.matrix;$('#comparison-mount').innerHTML=comparisonTable();}
  if(b.dataset.familyLink){filters.family=b.dataset.familyLink;filters.query='';filters.status='';if(location.hash==='#tasks'){overview();$('#tasks').scrollIntoView();}}
  if(b.dataset.reportFamily){filters.family=filters.family===b.dataset.reportFamily?'':b.dataset.reportFamily;$('#task-family').value=filters.family;$$('[data-report-family]').forEach(x=>x.classList.toggle('active',x.dataset.reportFamily===filters.family));renderRows();$('#tasks').scrollIntoView({behavior:'smooth'});}
  if(b.id==='reset-filters'||b.hasAttribute('data-reset'))resetFilters();
  if(b.dataset.export)exportCSV(b.dataset.export);
  if(b.dataset.instruction){$$('[data-instruction]').forEach(x=>x.setAttribute('aria-pressed',x===b));$$('.instruction-version').forEach(x=>x.hidden=x.id!=='instruction-'+b.dataset.instruction);}
  if(b.id==='final-frame'){const v=$('#episode-video');if(v.readyState<1)await new Promise(r=>v.addEventListener('loadedmetadata',r,{once:true}));v.pause();v.currentTime=Math.max(0,v.duration-.001);}
  if(b.dataset.sessionView){sessionState.view=b.dataset.sessionView;sessionState.count=40;$$('[data-session-view]').forEach(x=>x.setAttribute('aria-pressed',x===b));renderSession();}
  if(b.id==='more-events'){sessionState.count+=40;renderSession();}
  if(b.hasAttribute('data-image'))showImage(+b.dataset.image);
  if(b.hasAttribute('data-resource'))loadResource(+b.dataset.resource,epoch);
  if(b.hasAttribute('data-retry-session'))loadSession(current.ep,epoch);
  if(b.id==='copy-resource'){if(current.resourceText!=null){try{await navigator.clipboard.writeText(current.resourceText);showToast('File copied to clipboard');}catch{showToast('Copy unavailable. Use Open file to select the text.');}}}
});
$('#main').addEventListener('input',event=>{
  if(event.target.id==='task-search'){filters.query=event.target.value;renderRows();}
  if(event.target.id==='event-search'){sessionState.query=event.target.value;sessionState.count=40;renderSession();}
});
$('#main').addEventListener('change',async event=>{
  const {id,value}=event.target;
  if(id==='task-family'){filters.family=value;renderRows();$$('[data-report-family]').forEach(x=>x.classList.toggle('active',x.dataset.reportFamily===value));}
  if(id==='task-variant'){filters.variant=value;renderRows();}
  if(id==='task-status'){filters.status=value;renderRows();}
  if(id==='task-sort'){filters.sort=value;renderRows();}
  if(id==='playback-speed')$('#episode-video').playbackRate=Number(value);
  if(id==='event-filter'){sessionState.filter=value;sessionState.count=40;renderSession();}
  if(id==='evidence-select'){
    const preview=$('#evidence-preview'),token=epoch;preview.hidden=!value;if(!value)return;preview.textContent='Loading evidence…';
    try{const text=await fetchText(current.ep.links[value]);if(token!==epoch||$('#evidence-select').value!==value)return;try{preview.textContent=JSON.stringify(JSON.parse(text),null,2);}catch{preview.textContent=text;}}
    catch(e){if(token===epoch)preview.textContent='Preview unavailable: '+e.message;}
  }
});
$('#close-viewer').onclick=()=>$('#image-viewer').close();$('#previous-image').onclick=()=>showImage(imageIndex-1);$('#next-image').onclick=()=>showImage(imageIndex+1);
$('#image-viewer').addEventListener('click',event=>{if(event.target===$('#image-viewer'))$('#image-viewer').close();});
$('#image-viewer').addEventListener('keydown',event=>{if(event.key==='ArrowLeft'){event.preventDefault();showImage(imageIndex-1);}if(event.key==='ArrowRight'){event.preventDefault();showImage(imageIndex+1);}});
let catalogInstructionAudit={tasks:[],families:[]};
let measuredInstructions={episodes:{}};
let evidenceRoot = '';
const evidenceURL = path => {
  if (typeof path !== 'string' || !evidenceRoot || path.endsWith('.html')) return path;
  if (/^(?:experiments|official|policy-contract|research|data|history|probes)\//.test(path) || /^[a-zA-Z0-9_-]+\.json$/.test(path)) return new URL(path, evidenceRoot).href;
  return path;
};
// Resolve published file references for display; downloaded evidence remains byte-identical.
function resolveEvidence(value) {
  if (typeof value === 'string') return evidenceURL(value);
  if (Array.isArray(value)) return value.map(resolveEvidence);
  if (value && typeof value === 'object') return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, resolveEvidence(item)]));
  return value;
}
let resultFiles = {};
const resultURL = name => evidenceURL(resultFiles[name]?.url || name);
let policyRecord=null;
function policyShell(ep) {
 return `<section class="panel session-panel"><div class="section-heading"><div><h2>VLA input/output</h2><p>${number(ep.vla_calls)} recorded inferences · model inputs, action outputs and agent tool results.</p></div><div class="inline-links">${external(ep.links.vla_io,'All calls JSON')}${external(ep.links.policy_trace,'Original trace')}</div></div><div class="policy-body" id="policy-body">Loading recorded calls…</div></section>`;
}
async function loadPolicy(ep,token) {
 try {const response=await fetch(ep.links.vla_io);if(!response.ok)throw Error(response.status);const record=resolveEvidence(await response.json());if(token!==epoch)return;policyRecord=record;renderPolicy(0);}catch(e){if(token===epoch)$('#policy-body').textContent='Preview unavailable: '+e.message;}
}
function jsonBlock(title,value,open=false) {return `<details class="tool-block" ${open?'open':''}><summary>${esc(title)}</summary><pre>${esc(JSON.stringify(value,null,2))}</pre></details>`;}
function renderPolicy(index) {
 const record=policyRecord,c=record.calls[index],ep=current.ep;
 if(ep.provider==='robotwin-official')return renderOfficialPolicy(index);
 if(!c){$('#policy-body').innerHTML='<div class="empty-state">No VLA inference was made in this episode.</div>';return;}
 const images=c.images.map(im=>`<figure><a href="${esc(im.model_image)}" target="_blank"><img src="${esc(im.model_image)}" alt="${esc(im.camera)} model input, call ${index+1}"></a><figcaption>${esc(im.camera)} · ${im.model_size.join(' × ')}<br><a href="${esc(im.recorded)}" target="_blank">Recorded RGB · ${im.recorded_size.join(' × ')} ↗</a></figcaption></figure>`).join('');
 const caller=c.caller;
 const textParts=p=>(p||[]).filter(x=>x.type!=='image');
 const toolImages=caller?caller.tool_result.parts.filter(p=>p.type==='image').map(p=>{const url=new URL(p.src,new URL(ep.links.transcript,location.href)).href;return `<a href="${esc(url)}" target="_blank"><img src="${esc(url)}" alt="Observation returned to the language agent" style="width:240px;max-width:100%"></a>`;}).join(''):'';
 const cols=record.contract.output_layout;
 $('#policy-body').innerHTML=`<label>Inference <select class="policy-select" id="policy-call" aria-label="VLA inference">${record.calls.map((x,i)=>`<option value="${i}" ${i===index?'selected':''}>${i+1} / ${record.calls.length} · ${x.call_id.slice(0,12)} · ${String(x.request.task||'').trim().toLowerCase().replace(/\s+/g,' ').replace(/[.!?]+$/,'')===String(ep.instruction||'').trim().toLowerCase().replace(/\s+/g,' ').replace(/[.!?]+$/,'')?'full task':'caller task'}</option>`).join('')}</select></label><div class="inline-links"><code>${esc(c.call_id)}</code><span>${c.service_response.inference_s.toFixed(3)} s · ${(c.service_response.waypoints||c.service_response.actions).length} × ${(c.service_response.waypoints||c.service_response.actions)[0].length} actions</span></div><h3>Task instruction</h3><div class="instruction-text">${esc(c.request.task)}</div><div class="policy-images">${images}</div><p class="subtle">${esc(record.contract.image_preprocessing||"Model images follow the recorded checkpoint preprocessing.")} Additional information reaches the model only when present in the request and rendered language below.</p>${jsonBlock('Complete model-service request',c.request)}${c.model_input_text!==undefined?jsonBlock('Language passed to predict_action · recorded',c.model_input_text,true):''}${jsonBlock('Backbone message · reconstructed from executed code',c.backbone_messages)}<h3>Model-service output</h3><p class="subtle">${c.service_response.waypoints?'Untimed joint waypoints consumed by the recorded caller. Kinex or agent-authored code determines their physical timing.':'The recorded action response consumed by the caller.'} Joint values are absolute radians; grippers use −1 open, +1 closed.</p><div class="policy-table"><table><thead><tr><th>Action</th>${cols.map(x=>`<th>${esc(x.replace('left_','L ').replace('right_','R '))}</th>`).join('')}</tr></thead><tbody>${(c.service_response.waypoints||c.service_response.actions).map((row,i)=>`<tr><th>${i+1}</th>${row.map(x=>`<td title="${x}">${x.toFixed(5)}</td>`).join('')}</tr>`).join('')}</tbody></table></div>${jsonBlock('Complete service response · full precision',c.service_response)}${c.execution?jsonBlock('Actual execution · target count and world time',{executor:c.planner,...c.execution},true):''}${jsonBlock('Internal diagnostic · denormalized training-order actions',c.internal_diagnostics.denormalized_actions)}${caller?`<h3>Kinex tool call & result</h3><p class="subtle">This inference is joined to the recorded tool call and result below. Agent-authored code may consume the model output directly; the language agent receives the displayed tool response.</p>${jsonBlock('Agent tool call',caller.tool_call,true)}${jsonBlock('Tool result received by the language agent',{...caller.tool_result,parts:textParts(caller.tool_result.parts)},true)}<div class="inline-links">${toolImages}<a href="${taskRoute(ep.task_key,ep.variant,'session')}">Read the full session ↗</a><a href="${taskRoute(ep.task_key,ep.variant,'artifacts')}">Inspect agent artifacts ↗</a></div>${c.executed_tool_source?jsonBlock('Agent-authored code at this call',c.executed_tool_source):''}`:'<p class="subtle">Standalone execution; no language-agent tool call.</p>'}<details class="tool-block"><summary>Recording coverage & model contract</summary><p>See the per-run contract below for recorded and reconstructed fields. Original requests and rendered language are retained in the current rich-input run; older runs have different recording coverage.</p><pre>${esc(JSON.stringify(record.contract,null,2))}</pre><div class="inline-links">${external(record.contract.model_metadata,'Model configuration')}${external(record.contract.executed_sources,'Executed source checksums')}${external(record.contract.model_service_source||'policy-contract/model_node.py','Model service')}${external(record.contract.adapter_source||'policy-contract/starvla.py','Policy adapter')}${external(record.contract.helper_source||'policy-contract/kinex_policy.py','Kinex run_policy')}</div></details>`;
 $('#policy-call').onchange=e=>renderPolicy(Number(e.target.value));
}
function toolsShell(ep) {return `<section class="panel session-panel"><div class="section-heading"><div><h2>Tool calls</h2><p>Original tool inputs and outputs from the agent trace.</p></div>${external(ep.links.tool_calls,'Tool calls JSON')}</div><div class="policy-body" id="tools-body">Loading tool calls…</div></section>`;}
async function loadTools(ep,token) {
 try{const r=await fetch(ep.links.tool_calls);if(!r.ok)throw Error(r.status);const calls=await r.json();if(token!==epoch)return;$('#tools-body').innerHTML=calls.length?calls.map((c,i)=>`<details class="tool-block"><summary>${i+1} · ${esc(c.name)}${c.is_error?' · Error':''}</summary><p><code>${esc(c.call_id)}</code></p><h3>Input</h3><pre>${esc(JSON.stringify(c.input,null,2))}</pre><h3>Output</h3><pre>${esc(typeof c.output==='string'?c.output:JSON.stringify(c.output,null,2))}</pre></details>`).join(''):'<div class="empty-state">No language-agent tool calls in this episode.</div>';}catch(e){if(token===epoch)$('#tools-body').textContent='Preview unavailable: '+e.message;}
}

async function boot(){try{
const source=await fetch('data-source.json');if(!source.ok)throw Error('Result source unavailable');
const sourceConfig=await source.json();evidenceRoot=sourceConfig.evidence_root;resultFiles=sourceConfig.files;
document.querySelectorAll('[data-result-file]').forEach(link=>{link.href=resultURL(link.dataset.resultFile);});
const r=await fetch(resultURL('data.json'));if(!r.ok)throw Error('HTTP '+r.status);data=resolveEvidence(await r.json());
const ir=await fetch(resultURL('measured-instructions.json'));if(!ir.ok)throw Error('Instruction evidence unavailable');measuredInstructions=resolveEvidence(await ir.json());
const nr=await fetch(resultURL('instruction-audit.json'));if(!nr.ok)throw Error('Instruction audit unavailable');catalogInstructionAudit=resolveEvidence(await nr.json());
try{const c=await fetch(resultURL('cost-data.json'));if(c.ok)UsageMetrics.init(resolveEvidence(await c.json()));}catch{UsageMetrics.init({episodes:{},sources:[]});}
for(const task of data.tasks){
  if(task.family==='task02'){
    const {suite_name,task_id}=task.native_identity;
    task.title=`LIBERO-${suite_name.replace(/^libero_/, '')}-${String(task_id+1).padStart(2,'0')}`;
  }
}
window.benchmarkData=data;$('#updated').textContent='Results updated '+data.updated_at.slice(0,10);window.addEventListener('hashchange',route);route();}catch(e){$('#main').innerHTML=`<div class="empty-state"><h2>Results could not load</h2><p>${esc(e.message)}</p><a href="${esc(resultURL('data.json'))}">Download the results index</a></div>`;}}
boot();

function renderOfficialPolicy(index) {
 const r=policyRecord,c=r.calls[index],ep=current.ep;
 const ims=c.images.map(im=>`<figure><a href="${esc(im.model_image)}" target="_blank"><img src="${esc(im.model_image)}" alt="${esc(im.camera)} model input"></a><figcaption>${esc(im.camera)} · ${im.model_size.join(' × ')}<br><a href="${esc(im.recorded)}" target="_blank">Recorded RGB · ${im.recorded_size.join(' × ')} ↗</a></figcaption></figure>`).join('');
 $('#policy-body').innerHTML=`<label>Inference <select class="policy-select" id="policy-call" aria-label="VLA inference">${r.calls.map((x,i)=>`<option value="${i}" ${i===index?'selected':''}>${i+1} / ${r.calls.length} · action ${x.native_step}</option>`).join('')}</select></label><div class="inline-links"><code>${esc(c.call_id)}</code><span>${c.service_response.inference_s.toFixed(3)} s · ${(c.service_response.waypoints||c.service_response.actions).length} × ${(c.service_response.waypoints||c.service_response.actions)[0].length} actions</span></div><h3>Task instruction</h3><div class="instruction-text">${esc(c.request.task)}</div><div class="policy-images">${ims}</div><p class="subtle">Exact transmitted RGB pixels. No joint state or agent conversation is passed to the VLA.</p>${jsonBlock('Complete model request · image arrays linked as PNGs',c.request.wire_payload)}<h3>Native action chunk</h3><p class="subtle">Reordered model output consumed by the official evaluator. Absolute joint radians; gripper opening: 0 closed, 1 open.</p><div class="policy-table"><table><thead><tr><th>Action</th>${r.contract.output_layout.map(x=>`<th>${esc(x.replace('left_','L ').replace('right_','R '))}</th>`).join('')}</tr></thead><tbody>${(c.service_response.waypoints||c.service_response.actions).map((row,i)=>`<tr><th>${i+1}</th>${row.map(x=>`<td title="${x}">${x.toFixed(5)}</td>`).join('')}</tr>`).join('')}</tbody></table></div>${jsonBlock('Complete recorded StarVLA response · full precision',c.raw_response)}${jsonBlock('Reordered native actions · full precision',c.service_response.actions)}<p class="subtle">Standalone execution; no language-agent session or tool call. Token and API costs cover the language agent only; local GPU cost is not reported.</p>${jsonBlock('Recording coverage & model contract',r.contract)}<div class="inline-links">${external(r.contract.model_metadata,'Model configuration')}${external(r.contract.executed_sources,'Source identities')}${external(r.contract.adapter_source||'official/adapters.py','Policy adapter')}${external(r.contract.integration_source||'official/integrations.py','Official evaluator integration')}</div>`;
 $('#policy-call').onchange=e=>renderPolicy(Number(e.target.value));
}