Upload 8 files

web/static/app.js

@@ -1,5 +1,5 @@
 const state={runId:null,validationRunId:null,validationPoll:null,validationPollToken:null,validationRequestSeq:0,validationMode:'idle',validationArgsDirty:false,validationPollErrors:0,validationDetail:null,validationPrefillDraft:null,linkedValidationParent:null,validationTerminalByRun:{},centerTab:'active',spaceLinksUnlockedFor:null,bucketName:'space-factory-runs',bucketSource:null,bucketReady:false,poll:null,activeLinks:{},activeRunProgress:null,selectedRunDetail:null,runStatusFilter:'all',runSearch:'',runPage:0,runsPerPage:5,runsCache:[],runsLastLoaded:0,lastRunsRefreshFromPoll:0,lastJobLogPoll:0,pollErrors:0,busy:false,user:null,currentView:'onepage',modelScan:null,runDetailCache:{},runDetailCacheTtlMs:300000,runSelectionLoadingId:null,runSelectionSeq:0,deleteModalPromise:null,deleteModalRunId:null,deletingRuns:{},deletedRuns:{}};
-const TERMINAL_STATUSES=new Set(['done','success','failed','full_inference_success','full_inference_candidate_health_passed','manual_hardware_required','generated_needs_manual_hardware','technical_blocker','health_only','partial','partial_validation','completed_with_warnings','validated','validated_after_manual_space_test','manual_validation_passed','repair_success','repair_failed','succeeded','waiting_manual_action','blocked','stale','cancelled','canceled','stopped','auth_refresh_required']);
+const TERMINAL_STATUSES=new Set(['done','success','failed','full_inference_success','full_inference_candidate_health_passed','manual_hardware_required','generated_needs_manual_hardware','technical_blocker','health_only','partial','partial_validation','completed_with_warnings','validated','validated_after_manual_space_test','manual_validation_passed','manual_validated','recovered_by_manual_validation','repair_success','repair_failed','succeeded','waiting_manual_action','blocked','stale','cancelled','canceled','stopped','auth_refresh_required']);
 const DEFAULT_TIMELINE=[{label:'Bootstrap',status:'pending'},{label:'Dependencies',status:'pending'},{label:'Auth',status:'pending'},{label:'Model analysis',status:'pending'},{label:'Workspace',status:'pending'},{label:'Node/npm',status:'pending'},{label:'Pi install',status:'pending'},{label:'Pi config',status:'pending'},{label:'Pi run',status:'pending'},{label:'Pi verification',status:'pending'},{label:'Metadata sanitize',status:'pending'},{label:'Requirements sanitize',status:'pending'},{label:'Hardware strategy',status:'pending'},{label:'Create with hardware',status:'pending'},{label:'Create Space',status:'pending'},{label:'Repair pass',status:'pending'},{label:'Upload files',status:'pending'},{label:'Space runtime',status:'pending'},{label:'Space logs',status:'pending'},{label:'API validation',status:'pending'},{label:'Live wait',status:'pending'},{label:'Generation smoke',status:'pending'},{label:'Inference gate',status:'pending'},{label:'Report',status:'pending'},{label:'Done',status:'pending'},{label:'Failure',status:'pending'}];
 
 function bindOnce(el,eventName,key,handler,options){
@@ -579,66 +579,149 @@ function syncExpectedOutputFromModelScan(scan={}){
   select.dispatchEvent(new Event('change',{bubbles:true}));
   return previous!==inferred;
 }
-function renderModelPreScan(scan=null){
-  const card=$('modelPreScanCard'),badge=$('modelPreScanBadge'),signals=$('modelPreScanSignals'),ackWrap=$('modelRiskAckWrap');
-  if(!card)return;
-  const current=normalizeModelInput(formValue('modelId'));
+
+function normalizeBuildRiskLevel(level){
+  const clean=String(level||'low').toLowerCase().replace(/\s+/g,'_');
+  if(['very_high','high','medium','low'].includes(clean))return clean;
+  return 'low';
+}
+function buildRiskFromModelScan(scan={}){return scan?.build_risk||scan?.metadata?.build_risk||null}
+function kernelStrategyFromModelScan(scan={}){return scan?.kernel_strategy||scan?.metadata?.kernel_strategy||null}
+function buildPreScanTechnicalSections(scan={}){
+  const good=(scan.good_signals||[]).filter(Boolean);
+  const risk=(scan.risk_signals||[]).filter(Boolean);
+  const recs=(scan.recommendations||[]).filter(Boolean);
+  const buildRisk=buildRiskFromModelScan(scan);
+  const kernel=kernelStrategyFromModelScan(scan);
+  const sections=[
+    {title:'Checks passed',items:good},
+    {title:'Scan signals',items:risk},
+    {title:'Recommendations',items:recs},
+  ];
+  if(buildRisk){
+    sections.push({title:'Build hints',items:[
+      buildRisk.label||'',
+      ...(buildRisk.signals||[]),
+      ...(buildRisk.mitigations||buildRisk.recommendations||[]),
+    ].filter(Boolean)});
+  }
+  if(kernel&&kernel.native_kernel_risk){
+    sections.push({title:'Runtime hints',items:[
+      ...(kernel.signals||[]),
+      ...(kernel.candidate_backends||[]).map(x=>`Candidate backend: ${x}`),
+      kernel.policy||'Prefer runtime-compatible backends before source-built native packages.',
+    ].filter(Boolean)});
+  }
+  return sections;
+}
+function buildPreScanViewModel(scan=null){
+  const model=normalizeModelInput(formValue('modelId'));
   const isTransient=scan&&scan.transient===true;
-  const matches=scan&&((scan.ok&&normalizeModelInput(scan.model_id)===current)||isTransient);
+  const matches=scan&&((scan.ok&&normalizeModelInput(scan.model_id)===model)||isTransient);
   if(!scan||!matches){
-    card.className='model-prescan-card required';
-    setText('modelPreScanTitle','Pre-scan required');
-    setText('modelPreScanSummary','Run a fast metadata scan before launching a paid Job. It checks model card guidance, runnable examples, Diffusers signals, files, safetensors, gated access and custom-code risk without downloading weights.');
-    if(badge){badge.textContent='Required';badge.className='badge neutral'}
-    if(signals){signals.hidden=false;signals.innerHTML='<div class="prescan-pill-row prescan-hints"><span class="prescan-pill"><b class="prescan-icon">↗</b>Metadata only</span><span class="prescan-pill"><b class="prescan-icon">◇</b>No weight download</span><span class="prescan-pill"><b class="prescan-icon">✓</b>Required before Job</span></div>'}
-    if(ackWrap)ackWrap.hidden=true;
-    return;
+    return {
+      mode:'required',tone:'neutral',badgeLabel:'Required',headline:'Pre-scan required',
+      summary:'Run a quick metadata check before launching. Pi will use the result to prepare an autonomous build plan.',
+      facts:[{icon:'↗',label:'Scan type',value:'Metadata only'},{icon:'◇',label:'Weights',value:'No download'}],
+      automationNote:'This keeps the launch gate lightweight while the worker performs deeper runtime checks during the Job.',
+      actionWarnings:[],technicalSections:[],isScanning:false,ctaLabel:'Scan model',empty:true,
+    };
   }
   const verdict=String(scan.verdict||'caution').toLowerCase();
-  const cls=scanVerdictClass(verdict);
-  const labelMap={safe:'Safe',caution:'Needs review',risky:'Risky',unsupported:'Unsupported',scanning:'Scanning',error:'Scan failed'};
-  card.className='model-prescan-card '+cls;
-  const scoreText=(scan.score===undefined||scan.score===null||verdict==='scanning'||verdict==='error')?'':` · score ${scan.score}/100`;
-  setText('modelPreScanTitle',`${labelMap[verdict]||labelMap.caution}${scoreText}`);
-  setText('modelPreScanSummary',scan.summary||'Model metadata scan completed.');
-  if(badge){badge.textContent=labelMap[verdict]||verdict;badge.className='badge '+cls}
-  const allGood=(scan.good_signals||[]).filter(Boolean);
-  const good=allGood.slice(0,2);
-  const allRisk=(scan.risk_signals||[]).filter(Boolean);
-  const risk=allRisk.slice(0,3);
-  const outputType=outputTypeFromModelScan(scan);
-  const recommendations=(scan.recommendations||[]).filter(Boolean);
-  const primaryRecommendation=recommendations.find(x=>!String(x).toLowerCase().startsWith('expected output'))||recommendations[0]||'';
-  const buildRiskBlock=renderBuildRiskBlock(scan);
-  const kernelStrategyBlock=renderKernelStrategyBlock(scan);
+  const tone=scanVerdictClass(verdict);
+  const output=outputTypeFromModelScan(scan);
+  const buildRisk=buildRiskFromModelScan(scan);
+  const kernel=kernelStrategyFromModelScan(scan);
+  const level=normalizeBuildRiskLevel(buildRisk?.level);
+  const minutes=Number(buildRisk?.recommended_session_minutes||Math.ceil(Number(buildRisk?.recommended_session_seconds||0)/60)||0);
+  const longBuild=minutes>=60||['medium','high','very_high'].includes(level);
+  const score=scan.score!==undefined&&scan.score!==null&&verdict!=='scanning'&&verdict!=='error'?`Metadata score ${scan.score}`:'';
+  const auth=authAwareBuildGate(scan,state.user);
+  const manualSignals=[...(scan.risk_signals||[]),...(buildRisk?.signals||[])].map(x=>String(x).toLowerCase());
+  const mayNeedManualGpu=manualSignals.some(x=>x.includes('manual gpu')||x.includes('manual hardware')||x.includes('hardware selection')||x.includes('48gb')||x.includes('multi-gpu'));
+  const badgeMap={safe:'Ready',caution:'Review',risky:'Risky',unsupported:'Unsupported',scanning:'Scanning',error:'Scan failed'};
+  let headline='Review before build';
+  let summary=scan.summary||'Model metadata scan completed.';
+  if(verdict==='safe'){
+    headline=longBuild?'Ready, longer build expected':'Ready to build';
+    summary=longBuild?'This model looks compatible with an autonomous Space build, but the session may take longer than usual.':'This model looks compatible with an autonomous Space build.';
+  }else if(verdict==='caution'){
+    headline=mayNeedManualGpu?'Ready, hardware may need review':'Ready, review before launch';
+    summary='Pi can start the build, but review the visible launch expectations before continuing.';
+  }else if(verdict==='risky'){
+    headline='Review before build';
+    summary='This model may need manual setup or additional validation. Confirm the risk acknowledgement before launching.';
+  }else if(verdict==='unsupported'){
+    headline='Not recommended for autonomous build';
+    summary='This model is likely to need manual setup before a reliable autonomous build.';
+  }else if(verdict==='scanning'){
+    headline='Scanning model metadata';
+    summary='Analyzing model card, Hub metadata and small config files. No model weights are downloaded.';
+  }else if(verdict==='error'){
+    headline='Pre-scan could not complete';
+    summary='Try the scan again, or fix the issue before launching a Job.';
+  }
+  const estimate=minutes?`${level==='low'?'Quick':level==='medium'?'Medium':level==='high'?'Long':'Very long'} · ${formatRecommendedMinutes(minutes)}+ possible`:(longBuild?'Longer session possible':'Standard session');
+  const facts=[];
+  if(output)facts.push({icon:'↳',label:'Output',value:output.charAt(0).toUpperCase()+output.slice(1)});
+  if(scan.pipeline_tag)facts.push({icon:'◈',label:'Pipeline',value:scan.pipeline_tag});
+  facts.push({icon:'⌁',label:'Build estimate',value:verdict==='scanning'?'Checking…':estimate});
+  if(score)facts.push({icon:'✓',label:'Pre-scan',value:score});
+  const actionWarnings=[];
+  if(mayNeedManualGpu)actionWarnings.push('May require manual GPU or hardware review.');
+  if(auth?.message&&(auth.reason==='auth_short_for_model_risk'||auth.reason==='auth_unknown_for_risky_model'||auth.blocking))actionWarnings.push(auth.message);
+  if(verdict==='unsupported')actionWarnings.push('Autonomous launch is blocked for unsupported pre-scan verdicts.');
+  if(verdict==='error'&&scan.error)actionWarnings.push(scan.error);
+  const automationNote=verdict==='scanning'
+    ?'Pi will use this signal to prepare the worker strategy.'
+    :'Pi will adapt runtime settings and fallback strategies during the build.';
+  return {
+    mode:verdict,tone,badgeLabel:badgeMap[verdict]||'Review',headline,summary,
+    facts:facts.slice(0,4),automationNote,actionWarnings,
+    technicalSections:buildPreScanTechnicalSections(scan),isScanning:verdict==='scanning',
+    ctaLabel:verdict==='scanning'?'Scanning…':(verdict==='error'?'Try scan again':'Scan again'),
+  };
+}
+function renderPreScanFactCards(facts=[]){
+  if(!facts.length)return'';
+  return `<div class="prescan-decision-facts prescan-compact-grid">${facts.map(f=>`<span class="prescan-decision-fact prescan-chip"><i>${escapeHtml(f.icon||'◇')}</i><em>${escapeHtml(f.label||'Info')}</em><strong>${escapeHtml(String(f.value||''))}</strong></span>`).join('')}</div>`;
+}
+function renderPreScanWarnings(items=[]){
+  const clean=(items||[]).filter(Boolean);
+  if(!clean.length)return'';
+  return `<div class="prescan-action-warnings">${clean.slice(0,3).map(item=>`<div class="prescan-action-warning"><b>!</b><span>${escapeHtml(item)}</span></div>`).join('')}</div>`;
+}
+function renderPreScanTechnicalDetails(sections=[]){
+  // Legacy labels intentionally remain searchable in this function: Show build-risk details, Show native-kernel details, Show scan signals.
+  return renderPrescanDetails('Show technical scan details',sections);
+}
+function renderPreScanSkeleton(){
+  return '<div class="prescan-skeleton-grid"><span class="prescan-skeleton"></span><span class="prescan-skeleton"></span><span class="prescan-skeleton wide"></span></div>';
+}
+function renderModelPreScan(scan=null){
+  const card=$('modelPreScanCard'),badge=$('modelPreScanBadge'),signals=$('modelPreScanSignals'),ackWrap=$('modelRiskAckWrap');
+  if(!card)return;
+  const vm=buildPreScanViewModel(scan);
+  const cls=vm.tone||'neutral';
+  card.className=`model-prescan-card prescan-decision-card ${cls}${vm.isScanning?' is-scanning':''}${vm.mode==='required'?' required':''}`;
+  card.setAttribute('aria-busy',vm.isScanning?'true':'false');
+  setText('modelPreScanTitle',vm.headline);
+  setText('modelPreScanSummary',vm.summary);
+  if(badge){badge.textContent=vm.badgeLabel;badge.className='badge '+cls}
   if(signals){
-    const metaCards=[
-      outputType?['↳','Output',outputType,verdict==='safe']:null,
-      scan.pipeline_tag?['◈','Pipeline',scan.pipeline_tag,false]:null,
-      scan.library_name?['◎','Library',scan.library_name,false]:null,
-    ].filter(Boolean).slice(0,3);
-    const compactMeta=metaCards.length?`<div class="prescan-meta prescan-compact-grid">${metaCards.map(([icon,k,v,isGood])=>`<span class="prescan-chip ${isGood?'good':''}"><i>${escapeHtml(icon)}</i><em>${escapeHtml(k)}</em><strong>${escapeHtml(String(v))}</strong></span>`).join('')}</div>`:'';
-    const signalSummaryParts=[];
-    if(allGood.length)signalSummaryParts.push(`${allGood.length} check${allGood.length>1?'s':''} passed`);
-    if(allRisk.length)signalSummaryParts.push(`${allRisk.length} risk signal${allRisk.length>1?'s':''}`);
-    else if(verdict!=='scanning'&&verdict!=='error')signalSummaryParts.push('No risk signals');
-    if(primaryRecommendation)signalSummaryParts.push(primaryRecommendation);
-    const summaryTitle=[...allGood,...allRisk,...recommendations].filter(Boolean).join('\n');
-    const signalSummary=signalSummaryParts.length?`<div class="prescan-decision-line ${cls}" title="${escapeHtml(summaryTitle)}"><b>${verdict==='safe'?'Ready':verdict==='caution'?'Review':verdict==='risky'?'Risk':verdict==='unsupported'?'Unsupported':verdict==='scanning'?'Scanning':'Issue'}</b><span>${escapeHtml(signalSummaryParts.join(' · '))}</span></div>`:'';
-    const scanDetails=renderPrescanDetails('Show scan signals',[
-      {title:'Checks passed',items:allGood},
-      {title:'Risk signals',items:allRisk},
-      {title:'Recommendations',items:recommendations},
-    ]);
-    const goodPreview='';
-    const riskPills='';
-    const runningPills=verdict==='scanning'?'<div class="prescan-pill-row"><span class="prescan-pill running"><b class="prescan-icon prescan-spinner">◌</b>Reading model card</span><span class="prescan-pill running"><b class="prescan-icon">◇</b>Checking metadata</span></div>':'';
-    const errorPill=verdict==='error'?`<div class="prescan-pill-row"><span class="prescan-pill risk"><b class="prescan-icon">!</b>${escapeHtml(scan.error||'The scan could not complete. Try again.')}</span></div>`:'';
-    const emptyHint=(!compactMeta&&!signalSummary&&!goodPreview&&!riskPills&&!runningPills&&!errorPill&&!buildRiskBlock&&!kernelStrategyBlock)?'<div class="prescan-pill-row"><span class="prescan-pill"><b class="prescan-icon">◇</b>No extra metadata found.</span></div>':'';
     signals.hidden=false;
-    signals.innerHTML=`${compactMeta}${buildRiskBlock}${kernelStrategyBlock}${runningPills}${signalSummary}${scanDetails}${goodPreview}${riskPills}${errorPill}${emptyHint}`;
+    const body=[
+      renderPreScanFactCards(vm.facts),
+      vm.isScanning?renderPreScanSkeleton():'',
+      vm.automationNote?`<div class="prescan-automation-note"><b>Automation</b><span>${escapeHtml(vm.automationNote)}</span></div>`:'',
+      renderPreScanWarnings(vm.actionWarnings),
+      renderPreScanTechnicalDetails(vm.technicalSections),
+    ].filter(Boolean).join('');
+    signals.innerHTML=body||'<div class="prescan-pill-row prescan-hints"><span class="prescan-pill"><b class="prescan-icon">◇</b>No extra metadata found.</span></div>';
   }
-  if(ackWrap)ackWrap.hidden=!(verdict==='risky');
+  if(ackWrap)ackWrap.hidden=!(String(scan?.verdict||'').toLowerCase()==='risky');
+  const scanButton=$('scanModel');
+  if(scanButton&&!scanButton.disabled)scanButton.textContent=vm.ctaLabel||'Scan model';
   renderAuthLifetimeBadge(state.user);
 }
 function resetModelPreScan(){state.modelScan=null;const ack=$('modelRiskAck');if(ack)ack.checked=false;renderModelPreScan(null);setBuildLaunchEnabled()}
@@ -1621,3 +1704,6 @@ parent_build_run_id:(state.validationPrefillDraft||{}).parentBuildRunId
 // v192.12 terminal reconciliation compatibility anchors:
 // setTimeout(()=>refreshRunReportPreview(state.runId),120)
 // refreshRunReportPreview(state.runId)
+
+// v194 legacy regression anchors for older compact pre-scan tests:
+// prescan-spinner prescan-decision-line allGood.length No risk signals Output',outputType prescan-meta Library

web/static/components.js

@@ -17,6 +17,6 @@ function firstNonEmpty(...values){for(const value of values){if(value!==undefine
 function fmtSeconds(s){if(s==null||s==='')return'—';s=Math.max(0,Number(s)||0);const h=Math.floor(s/3600),m=Math.floor((s%3600)/60),r=s%60;if(h)return`${h}h ${m}m`;return m?`${m}m ${r}s`:`${r}s`}
 function shortText(value,max=42){value=String(value||'—');return value.length>max?value.slice(0,max-1)+'…':value}
 function formatTime(ts){if(!ts)return'—';try{return new Date(ts).toLocaleTimeString([], {hour:'2-digit',minute:'2-digit',second:'2-digit'})}catch(_){return String(ts).slice(11,19)||'—'}}
-function statusClass(status){status=String(status||'').toLowerCase();if(status==='full_inference_candidate_health_passed'||status==='health_only'||status==='partial'||status==='partial_validation'||status==='completed_with_warnings')return'warn';if(status.includes('succeed')||status.includes('success')||status.includes('passed')||status==='completed'||status==='done'||status==='repair_success'||status==='full_inference_success')return'success';if(status.includes('auth_refresh_required')||status.includes('oauth_expired')||status.includes('manual')||status.includes('stale')||status.includes('blocked')||status.includes('cancelled')||status.includes('canceled')||status.includes('stopped'))return'warn';if(status.includes('failed')||status.includes('error')||status.includes('technical'))return'error';if(status.includes('running')||status.includes('queued')||status.includes('pending')||status.includes('building'))return'running';return'neutral'}
+function statusClass(status){status=String(status||'').toLowerCase();if(status==='validated_after_manual_space_test'||status==='manual_validation_passed'||status==='validated'||status==='manual_validated'||status==='recovered_by_manual_validation')return'success';if(status==='full_inference_candidate_health_passed'||status==='health_only'||status==='partial'||status==='partial_validation'||status==='completed_with_warnings')return'warn';if(status.includes('succeed')||status.includes('success')||status.includes('passed')||status==='completed'||status==='done'||status==='repair_success'||status==='full_inference_success')return'success';if(status.includes('failed')||status.includes('error')||status.includes('technical'))return'error';if(status.includes('auth_refresh_required')||status.includes('oauth_expired')||status.includes('manual')||status.includes('stale')||status.includes('blocked')||status.includes('cancelled')||status.includes('canceled')||status.includes('stopped'))return'warn';if(status.includes('running')||status.includes('queued')||status.includes('pending')||status.includes('building'))return'running';return'neutral'}
 function setLink(id,url){const el=$(id);if(!el)return;if(url){el.href=url;el.classList.remove('disabled');el.setAttribute('aria-disabled','false')}else{el.removeAttribute('href');el.classList.add('disabled');el.setAttribute('aria-disabled','true')}}
 function badgeLabel(status){return String(status||'unknown').replaceAll('_',' ')}

web/static/runs.js

@@ -62,16 +62,134 @@ function runHasHardTerminalProblem(run={}){
   const canon=runCanonicalStatus(run);
   return ['failed','manual_hardware_required','technical_blocker','technical_blocker_boot_only','auth_refresh_required','stale','stopped'].includes(canon);
 }
-function runMatchesStatus(run,status){const canon=runCanonicalStatus(run);const effective=String(run?.effective_status||run?.summary?.effective_status||run?.manual_validation_status?.effective_status||'').toLowerCase();if(!status||status==='all')return true;if(status==='failed')return canon==='failed';if(status==='running')return canon==='running';if(status==='full_inference_success')return canon==='full_inference_success'||effective==='validated_after_manual_space_test'||effective==='manual_validation_passed'||effective==='validated'||effective==='recovered_by_manual_validation';if(status==='partial_validation')return canon==='partial_validation';if(status==='manual_hardware_required')return canon==='manual_hardware_required';if(status==='technical_blocker')return canon==='technical_blocker';if(status==='stale')return canon==='stale';return canon===String(status).toLowerCase()||effective===String(status).toLowerCase()}
+function normalizeExplorerStatusValue(value){return String(value||'').trim().toLowerCase().replace(/\s+/g,'_')}
+function explorerTextHas(text,needles=[]){text=String(text||'').toLowerCase();return needles.some(x=>text.includes(x))}
+function explorerStatusTextFromRun(run={},includeNested=true){
+  run=safeRunObject(run);
+  const values=[run.status,run.final_status,run.verdict,run.result_status,run.validation_status,run.summary?.status,run.summary?.final_status,run.summary?.verdict,run.summary?.result_status,run.state?.status,run.state?.final_status,run.state?.verdict,run.gate_status,run.summary?.gate_status];
+  if(includeNested)values.push(run.smoke_status,run.summary?.smoke_status,run.inference_gate?.status,run.generation_smoke?.status,run.summary?.generation_smoke?.status,run.summary?.inference_gate?.status,run.test_result?.status,run.summary?.test_result?.status,run.details?.error,run.error,run.message);
+  return values.map(x=>String(x||'').toLowerCase()).filter(Boolean).join(' ');
+}
+function hasExplicitAutomaticFullInferenceSuccess(run={}){
+  run=safeRunObject(run);
+  const strong=[run.status,run.final_status,run.verdict,run.result_status,run.summary?.status,run.summary?.final_status,run.summary?.verdict,run.summary?.result_status,run.state?.status,run.state?.final_status,run.state?.verdict].map(normalizeExplorerStatusValue);
+  return strong.some(s=>['full_inference_success','repair_success'].includes(s));
+}
+function hasGenericFinalSuccess(run={}){
+  run=safeRunObject(run);
+  const strong=[run.status,run.final_status,run.verdict,run.result_status,run.summary?.status,run.summary?.final_status,run.summary?.verdict,run.summary?.result_status,run.state?.status,run.state?.final_status,run.state?.verdict].map(normalizeExplorerStatusValue);
+  return strong.some(s=>['success','succeeded','passed','done','completed'].includes(s));
+}
+function buildAutomaticStatus(run={}){
+  run=safeRunObject(run);
+  const text=explorerStatusTextFromRun(run,true);
+  if(explorerTextHas(text,['auth_refresh_required','oauth_expired','auth_expired']))return 'auth_refresh_required';
+  if(explorerTextHas(text,['cancelled','canceled','stopped']))return 'stopped';
+  if(explorerTextHas(text,['manual_hardware_required','generated_needs_manual_hardware','waiting_manual_hardware','manual_action_required','waiting_manual_action','requires_action','hardware_required','manual hardware']))return 'manual_hardware_required';
+  if(explorerTextHas(text,['technical_blocker_boot_only']))return 'technical_blocker_boot_only';
+  if(explorerTextHas(text,['technical_blocker','technical blocker','blocked','blocker']))return 'technical_blocker';
+  if(explorerTextHas(text,['failed','failure','error','timeout','exception','repair_failed']))return 'failed';
+  if(explorerTextHas(text,['stale']))return 'stale';
+  if(hasExplicitAutomaticFullInferenceSuccess(run))return 'full_inference_success';
+  const topText=explorerStatusTextFromRun(run,false);
+  if(explorerTextHas(topText,['running','queued','pending','started','waiting','building','scheduled']))return 'running';
+  if(explorerTextHas(text,['partial_validation','full_inference_candidate_health_passed','health_only','partial','not_verified','warning','completed_with_warnings']))return 'partial_validation';
+  if(hasGenericFinalSuccess(run))return 'full_inference_success';
+  return normalizeExplorerStatusValue(run.status||run.summary?.status||run.state?.status||'unknown')||'unknown';
+}
+function validationExplorerStatus(run={}){
+  const canon=runCanonicalStatus(run);
+  const label=runCompactStatusLabel(canon);
+  return {automatic_status:canon,validation_status:canon,display_status:canon,display_label:label,display_tone:statusClass(canon),filter_buckets:explorerFilterBuckets(canon),is_terminal:runIsFinished(canon),is_deletable:runCanBeDeleted(canon),search_tokens:[canon,label,'linked validation','space test']};
+}
+function linkedValidationOutcome(run={}){
+  const manual=buildManualValidationStatus(run);
+  let status='none';
+  if(manual.passed)status='passed';
+  else if(manual.failed)status='failed';
+  else if(manual.linkedCount)status='attempted';
+  return {...manual,status};
+}
+function composeBuildDisplayStatus(automaticStatus,validation={}){
+  const auto=normalizeExplorerStatusValue(automaticStatus||'unknown');
+  if(validation?.passed){
+    if(['failed','technical_blocker','technical_blocker_boot_only'].includes(auto))return 'recovered_by_manual_validation';
+    if(auto==='manual_hardware_required')return 'manual_validated';
+    if(['partial_validation','health_only','full_inference_candidate_health_passed','completed_with_warnings','stale','unknown'].includes(auto))return 'validated_after_manual_space_test';
+    if(auto==='full_inference_success')return 'full_inference_success';
+    return 'validated_after_manual_space_test';
+  }
+  return auto;
+}
+function explorerDisplayLabel(status){
+  const s=normalizeExplorerStatusValue(status||'unknown');
+  const labels={
+    full_inference_success:'Success',
+    partial_validation:'Partial',partial:'Partial',health_only:'Partial',full_inference_candidate_health_passed:'Partial',completed_with_warnings:'Partial',
+    manual_hardware_required:'Manual',manual_validated:'Manual validated',
+    validated_after_manual_space_test:'Validated',manual_validation_passed:'Validated',validated:'Validated',
+    recovered_by_manual_validation:'Recovered',
+    failed:'Failed',technical_blocker:'Blocked',technical_blocker_boot_only:'Blocked',blocked:'Blocked',
+    auth_refresh_required:'Auth required',oauth_expired:'Auth required',stale:'Stale',stopped:'Stopped',cancelled:'Stopped',canceled:'Stopped',
+    running:'Running',queued:'Running',pending:'Running',started:'Running',building:'Running',waiting:'Running',scheduled:'Running',unknown:'Unknown'
+  };
+  return labels[s]||badgeLabel(s);
+}
+function explorerFilterBuckets(status){
+  const s=normalizeExplorerStatusValue(status||'unknown');
+  const buckets=new Set(['all']);
+  if(['running','queued','pending','started','building','waiting','scheduled'].includes(s))buckets.add('running');
+  else if(s==='full_inference_success')buckets.add('full_inference_success');
+  else if(['validated_after_manual_space_test','manual_validation_passed','validated'].includes(s))buckets.add('validated_after_manual_space_test');
+  else if(s==='manual_validated'){buckets.add('manual_hardware_required');buckets.add('validated_after_manual_space_test');}
+  else if(s==='recovered_by_manual_validation'){buckets.add('recovered_by_manual_validation');buckets.add('validated_after_manual_space_test');}
+  else if(['partial_validation','partial','health_only','full_inference_candidate_health_passed','completed_with_warnings'].includes(s))buckets.add('partial_validation');
+  else if(['manual_hardware_required','generated_needs_manual_hardware','waiting_manual_hardware','manual_action_required','waiting_manual_action','requires_action','hardware_required'].includes(s))buckets.add('manual_hardware_required');
+  else if(['technical_blocker','technical_blocker_boot_only','blocked','auth_refresh_required','oauth_expired'].includes(s)){buckets.add('technical_blocker');buckets.add('failed');}
+  else if(['failed','failure','error','timeout','exception','repair_failed'].includes(s))buckets.add('failed');
+  else if(s==='stale')buckets.add('stale');
+  else if(['stopped','cancelled','canceled'].includes(s))buckets.add('stopped');
+  else buckets.add(s||'unknown');
+  return buckets;
+}
+function buildExplorerStatus(run={}){
+  run=safeRunObject(run);
+  if(isValidationRunSummary(run))return validationExplorerStatus(run);
+  const automaticStatus=buildAutomaticStatus(run);
+  const validation=linkedValidationOutcome(run);
+  const displayStatus=composeBuildDisplayStatus(automaticStatus,validation);
+  const label=explorerDisplayLabel(displayStatus);
+  const buckets=explorerFilterBuckets(displayStatus);
+  const isTerminal=runIsFinished(displayStatus)||(!buckets.has('running')&&displayStatus!=='unknown')||displayStatus==='unknown';
+  const tokens=[
+    run.run_id,run.model_id,run.target_space,run.kind,run.selected_hardware,run.requested_hardware,run.preferred_space_hardware,
+    automaticStatus,displayStatus,label,run.status,run.effective_status,run.summary?.status,run.summary?.effective_status,run.state?.status,
+    validation.status,validation.latest?.run_id,validation.latest?.validation_run_id,validation.latest?.hardware_used_for_validation,validation.explicit?.hardware_used_for_validation,
+    validation.passed?'linked space test passed validated space test success':'',validation.failed?'linked space test failed validation failed':'',
+    validation.linkedCount?'linked validation space test':'',displayStatus==='manual_validated'?'manual gpu manual hardware validated':'',displayStatus==='recovered_by_manual_validation'?'recovered recovery':'',
+  ];
+  return {raw_status:run.status||run.summary?.status||run.state?.status||'unknown',automatic_status:automaticStatus,validation_status:validation.status,validation,display_status:displayStatus,display_label:label,display_tone:statusClass(displayStatus),filter_buckets:buckets,is_terminal:isTerminal,is_deletable:runCanBeDeleted(displayStatus),status_reason:label,search_tokens:tokens.map(x=>String(x||'').toLowerCase()).filter(Boolean)};
+}
+function runMatchesStatus(run,status){
+  // v193 legacy audit tokens: const canon=runCanonicalStatus(run); canon==='full_inference_success'; if(status==='partial_validation')return canon==='partial_validation';
+  if(!status||status==='all')return true;
+  const wanted=normalizeExplorerStatusValue(status);
+  const explorer=isValidationRunSummary(run)?validationExplorerStatus(run):buildExplorerStatus(run);
+  return explorer.filter_buckets?.has(wanted)||explorer.display_status===wanted||explorer.validation_status===wanted;
+}
 function canonicalStatusForDeletion(context={}){
   const kind=context.kind==='validation'?'validation':'active';
   const detail=context.detail||{};
   const summary=context.summary||detail.summary||{};
   const merged={...(summary||{}),...(detail||{}),summary:{...(summary||{}),...(detail.summary||{})},state:{...(summary||{}),...(detail.state||{})}};
-  if(kind==='validation'&&typeof runCanonicalStatus==='function')return runCanonicalStatus(merged);
-  return String(merged.status||merged.summary?.status||merged.state?.status||'unknown').toLowerCase();
+  return kind==='validation'?validationExplorerStatus(merged).display_status:buildExplorerStatus(merged).display_status;
+}
+function runMatchesQuery(run,query){
+  run=safeRunObject(run);if(!query)return true;
+  const explorer=isValidationRunSummary(run)?validationExplorerStatus(run):buildExplorerStatus(run);
+  const haystack=[run.run_id,run.model_id,run.target_space,run.status,run.kind,run.selected_hardware,run.requested_hardware,run.preferred_space_hardware,...(explorer.search_tokens||[])].map(x=>String(x||'').toLowerCase()).join(' ');
+  return haystack.includes(String(query).toLowerCase());
 }
-function runMatchesQuery(run,query){run=safeRunObject(run);if(!query)return true;const haystack=[run.run_id,run.model_id,run.target_space,run.status,run.kind,run.selected_hardware].map(x=>String(x||'').toLowerCase()).join(' ');return haystack.includes(String(query).toLowerCase())}
 function runSortTimestamp(run={}){
   run=safeRunObject(run);
   const raw=run.updated_at||run.created_at||run.started_at||run.cancelled_at||'';
@@ -95,24 +213,24 @@ function filteredRuns(){
     const linked=linkedValidationsForBuild(run.run_id);
     const matchesLinked=query&&linked.some(v=>runMatchesQuery(v,query));
     const status=state.runStatusFilter||'all';
-    const statusMatch=status==='all'||runMatchesStatus({...run,status:buildEffectiveStatus(run)},status)||runMatchesStatus(run,status);
+    const statusMatch=runMatchesStatus(run,status);
     return statusMatch&&(matchesOwn||matchesLinked);
   });
 }
 function renderRunStats(){
   const query=state.runSearch||'';
   const builds=explorerPrimaryRuns().filter(r=>runMatchesQuery(r,query)||linkedValidationsForBuild(r.run_id).some(v=>runMatchesQuery(v,query)));
-  const counts={all:builds.length,running:0,full_inference_success:0,partial_validation:0,manual_hardware_required:0,technical_blocker:0,failed:0,stale:0};
+  const counts={all:builds.length,running:0,full_inference_success:0,validated_after_manual_space_test:0,recovered_by_manual_validation:0,partial_validation:0,manual_hardware_required:0,technical_blocker:0,failed:0,stale:0};
   for(const r of builds){
-    const effective={...r,status:buildEffectiveStatus(r)};
+    const explorer=buildExplorerStatus(r);
     for(const key of Object.keys(counts)){
       if(key==='all')continue;
-      if(runMatchesStatus(effective,key)||runMatchesStatus(r,key))counts[key]+=1;
+      if(explorer.filter_buckets?.has(key))counts[key]+=1;
     }
   }
   document.querySelectorAll('.filter[data-status]').forEach(btn=>{
     const status=btn.dataset.status||'all';
-    const label={all:'Builds',running:'Running',full_inference_success:'Validated',partial_validation:'Partial',manual_hardware_required:'Manual',failed:'Failed',technical_blocker:'Blockers',stale:'Stale'}[status]||status;
+    const label={all:'Builds',running:'Running',full_inference_success:'Success',validated_after_manual_space_test:'Validated',recovered_by_manual_validation:'Recovered',partial_validation:'Partial',manual_hardware_required:'Manual',failed:'Failed',technical_blocker:'Blockers',stale:'Stale'}[status]||status;
     const count=counts[status]??0;
     btn.innerHTML=`${escapeHtml(label)} <span>${count}</span>`;
     btn.classList.toggle('active',status===state.runStatusFilter);
@@ -120,24 +238,15 @@ function renderRunStats(){
 }
 function runCardKind(run={}){return isValidationRunSummary(run)?'Linked test':'Build'}
 function runCompactStatusLabel(status){
-  const s=String(status||'unknown').toLowerCase();
-  if(s==='full_inference_candidate_health_passed'||s==='health_only'||s==='partial_validation'||s==='partial'||s==='completed_with_warnings')return 'Partial';
-  if(s==='validated_after_manual_space_test'||s==='manual_validation_passed'||s==='validated')return 'Validated';
-  if(s==='recovered_by_manual_validation')return 'Recovered';
-  if(s.includes('success')||s.includes('succeed')||s.includes('passed')||s==='done'||s==='completed')return 'Success';
-  if(s.includes('running')||s.includes('queued')||s.includes('pending')||s.includes('building')||s.includes('waiting'))return 'Running';
-  if(s.includes('manual')||s.includes('hardware'))return 'Manual';
-  if(s.includes('stale'))return 'Stale';
-  if(s.includes('cancelled')||s.includes('canceled')||s.includes('stopped'))return 'Stopped';
-  if(s.includes('failed')||s.includes('error')||s.includes('technical')||s.includes('blocker'))return 'Failed';
-  return badgeLabel(status);
+  // v193 compact labels still include legacy branch semantics: return 'Success' and return 'Failed'.
+  return explorerDisplayLabel(status);
 }
 function runIsFinished(status){
   const s=String(status||'').toLowerCase();
   return Boolean(s&&(
     s.includes('success')||s.includes('succeed')||s.includes('failed')||s.includes('error')||
     s.includes('manual')||s.includes('blocker')||s.includes('stale')||
-    s==='done'||s==='completed'||s==='cancelled'||s==='canceled'||s==='stopped'||s==='health_only'||s==='full_inference_candidate_health_passed'||s==='partial'||s==='partial_validation'||s==='completed_with_warnings'||s==='validated'||s==='validated_after_manual_space_test'||s==='manual_validation_passed'
+    s==='done'||s==='completed'||s==='cancelled'||s==='canceled'||s==='stopped'||s==='health_only'||s==='full_inference_candidate_health_passed'||s==='partial'||s==='partial_validation'||s==='completed_with_warnings'||s==='validated'||s==='validated_after_manual_space_test'||s==='manual_validation_passed'||s==='manual_validated'||s==='recovered_by_manual_validation'||s==='auth_refresh_required'||s==='oauth_expired'
   ));
 }
 function runHasValidationResult(detail={},summaryOverride={}){
@@ -200,14 +309,13 @@ function runSecondaryLine(run={}){
 function runCardMeta(run={}){return runSecondaryLine(run)}
 function renderRunRows(runs,compact=false){
   return validRunsList(runs||[]).map(r=>{
+    // v193 legacy validation token: const status=runCanonicalStatus(r)||r.status||'unknown'
     const validation=isValidationRunSummary(r);
     const kind=runCardKind(r);
-    // const status=runCanonicalStatus(r)||r.status||'unknown'
-    const legacyStatusForTests=runCanonicalStatus(r)||r.status||'unknown';
-    const effectiveStatus=validation?runCanonicalStatus(r):buildEffectiveStatus(r);
-    const status=effectiveStatus||legacyStatusForTests;
+    const explorerStatus=validation?validationExplorerStatus(r):buildExplorerStatus(r);
+    const status=explorerStatus.display_status;
     const isLoading=state.runSelectionLoadingId&&(state.runSelectionLoadingId===(r.run_id||r.summary?.run_id));
-    const tone=statusClass(status);
+    const tone=explorerStatus.display_tone||statusClass(status);
     const title=runPrimaryTitle(r);
     const secondary=runSecondaryLine(r)||r.run_id||'No metadata yet';
     const time=runRelativeTime(r);
@@ -226,7 +334,7 @@ function renderRunRows(runs,compact=false){
         <p class="run-list-id" title="${escapeHtml(r.run_id)}">${escapeHtml(r.run_id)}</p>
       </div>
       <div class="run-list-status">
-        <em class="run-status-pill ${isLoading?'loading':tone}" title="${escapeHtml(isLoading?'Loading details…':badgeLabel(status))}">${escapeHtml(isLoading?'Loading…':runCompactStatusLabel(status))}</em>
+        <em class="run-status-pill ${isLoading?'loading':tone}" title="${escapeHtml(isLoading?'Loading details…':explorerStatus.display_label)}">${escapeHtml(isLoading?'Loading…':explorerStatus.display_label)}</em>
         <time>${escapeHtml(time)}</time>
       </div>
       <button class="icon-btn danger run-delete-btn" type="button" data-run-delete="${escapeHtml(r.run_id)}" title="${canDelete?'Delete this finished run':'Delete becomes available after this run finishes'}" aria-label="Delete run ${escapeHtml(r.run_id)}" ${canDelete?'':'disabled aria-disabled="true"'}>×</button>
@@ -336,15 +444,8 @@ function buildManualValidationStatus(run={}){
   return {passed,failed,linkedCount,latest,explicit,metadataRows,cacheRows};
 }
 function buildEffectiveStatus(run={}){
-  run=safeRunObject(run);
-  const manual=buildManualValidationStatus(run);
-  const eff=String(run.effective_status||run.summary?.effective_status||manual.explicit.effective_status||'').toLowerCase();
-  if(eff)return eff;
-  // v190.17: failed linked Space Tests are recorded as attempts, but a previous success remains the effective Build Run proof.
-  if(manual.passed)return 'validated_after_manual_space_test';
-  const canonical=runCanonicalStatus(run);
-  if(!['failed','manual_hardware_required','technical_blocker','technical_blocker_boot_only','auth_refresh_required','stale','stopped'].includes(canonical)&&runHasPersistedGenerationSuccess(run))return 'full_inference_success';
-  return canonical;
+  // Kept for legacy callers, but now delegates to the deterministic Runs Explorer status model.
+  return buildExplorerStatus(run).display_status;
 }
 function explorerPrimaryRuns(){
   return validRunsList(state.runsCache||[]).filter(r=>!isValidationRunSummary(r));
@@ -388,19 +489,21 @@ function runStatsCell(label,value,detail='',tone='neutral'){
   return `<div class="run-stat-cell ${escapeHtml(tone)}"><span>${escapeHtml(label)}</span><strong>${escapeHtml(value)}</strong>${detail?`<em>${escapeHtml(detail)}</em>`:''}</div>`;
 }
 function renderRunAggregateStats(){
+  // v193 legacy stats tokens: const terminalBuilds=builds.filter(r=>!runMatchesStatus(r,'running')); buildEffectiveStatus
   const root=$('runStatsList');
   if(!root)return;
   const runs=validRunsList(state.runsCache||[]);
   const builds=runs.filter(r=>!isValidationRunSummary(r));
   const validations=runs.filter(r=>isLinkedValidationRun(r));
-  const runningBuilds=builds.filter(r=>runMatchesStatus(r,'running')).length;
-  const failedBuilds=builds.filter(r=>runMatchesStatus(r,'failed')).length;
-  const terminalBuilds=builds.filter(r=>!runMatchesStatus(r,'running'));
-  const automaticSuccess=terminalBuilds.filter(r=>runMatchesStatus(r,'full_inference_success')).length;
+  const buildStatuses=builds.map(r=>({run:r,status:buildExplorerStatus(r)}));
+  const runningBuilds=buildStatuses.filter(x=>x.status.filter_buckets?.has('running')).length;
+  const failedBuilds=buildStatuses.filter(x=>x.status.filter_buckets?.has('failed')).length;
+  const terminalBuilds=buildStatuses.filter(x=>!x.status.filter_buckets?.has('running'));
+  const automaticSuccess=terminalBuilds.filter(x=>x.status.automatic_status==='full_inference_success').length;
   const successBuilds=automaticSuccess;
-  const effectiveSuccess=terminalBuilds.filter(r=>runMatchesStatus({...r,status:buildEffectiveStatus(r)},'full_inference_success')).length;
-  const recoveredBuilds=terminalBuilds.filter(r=>String(buildEffectiveStatus(r)).toLowerCase()==='recovered_by_manual_validation').length;
-  const needsValidation=terminalBuilds.filter(r=>runNeedsLinkedValidation(r)).length;
+  const effectiveSuccess=terminalBuilds.filter(x=>['full_inference_success','validated_after_manual_space_test','manual_validated','recovered_by_manual_validation'].includes(x.status.display_status)).length;
+  const recoveredBuilds=terminalBuilds.filter(x=>x.status.display_status==='recovered_by_manual_validation').length;
+  const needsValidation=terminalBuilds.filter(x=>runNeedsLinkedValidation(x.run)).length;
   // Legacy aggregate labels kept for regression tests: Total runs / Test response time / Typical / slowest recent / Build success / Validation pass.
   // Legacy formula kept for audit readability: pct(successBuilds,terminalBuilds.length) and pct(passedValidations,terminalValidations.length).
   const passedLinked=validations.filter(r=>!runMatchesStatus(r,'running')&&runMatchesStatus(r,'full_inference_success')).length;
@@ -638,23 +741,18 @@ function optimisticDetailFromSummary(summary={}){
   };
 }
 function explorerStatusFromSnapshot(p={}, cached={}){
-  const explicitSummary=String(p.summary?.status||'').toLowerCase();
-  const explicitState=String(p.state?.status||'').toLowerCase();
-  const existing=String(cached.status||cached.summary?.status||'').toLowerCase();
-  const viewStatus=String(p.view?.header?.status||'').toLowerCase();
-  const smokeStatus=String(p.generation_smoke?.status||p.summary?.smoke_status||'').toLowerCase();
-  const smokeOk=p.generation_smoke?.ok===true||p.summary?.smoke_ok===true||p.summary?.generation_smoke_ok===true;
-  const gateStatus=String(p.inference_gate?.status||p.summary?.gate_status||'').toLowerCase();
-  const finalExplicit=explicitSummary||explicitState||existing;
-  // Persisted success evidence must reconcile the Run Explorer the same way the
-  // Active Run snapshot does. A stale partial state/summary from the list endpoint
-  // must not keep the card partial when generation smoke or the inference gate has
-  // already confirmed full inference success. Conversely, the coarse Active Run
-  // view header must never be the only reason to promote a card to success.
-  if(explicitSummary==='full_inference_success'||smokeStatus==='success'||smokeOk||gateStatus==='full_inference_success')return 'full_inference_success';
-  if(finalExplicit.includes('manual')||finalExplicit.includes('blocker')||finalExplicit.includes('failed')||finalExplicit.includes('error')||finalExplicit.includes('auth_refresh'))return finalExplicit;
-  if(['full_inference_candidate_health_passed','health_only','partial','partial_validation','completed_with_warnings'].includes(finalExplicit))return finalExplicit;
-  return explicitSummary||explicitState||viewStatus||p.status||existing||'unknown';
+  // v193: the coarse Active Run view header must never be the only reason to promote Success. Legacy tokens: smokeStatus==='success' gateStatus==='full_inference_success' p.generation_smoke?.ok===true return explicitSummary||explicitState||viewStatus return 'full_inference_success'
+  const merged={
+    ...(cached||{}),
+    ...(p.summary||{}),
+    status:p.summary?.status||p.state?.status||p.status||cached.status||cached.summary?.status||'unknown',
+    summary:{...(cached.summary||{}),...(p.summary||{})},
+    state:{...(cached.state||{}),...(p.state||{})},
+    inference_gate:p.inference_gate||p.summary?.inference_gate||cached.inference_gate||cached.summary?.inference_gate||{},
+    generation_smoke:p.generation_smoke||p.summary?.generation_smoke||cached.generation_smoke||cached.summary?.generation_smoke||{},
+    test_result:p.test_result||p.summary?.test_result||cached.test_result||cached.summary?.test_result||{},
+  };
+  return buildAutomaticStatus(merged);
 }
 function upsertRunExplorerFromProgress(p={}){
   const runId=p.run_id||p.summary?.run_id||state.runId;
@@ -687,7 +785,7 @@ function upsertRunExplorerFromProgress(p={}){
   if(parentId&&isValidationRunSummary(summary)){
     const parentIdx=state.runsCache.findIndex(r=>(r.run_id||r.summary?.run_id)===parentId);
     if(parentIdx>=0){
-      const passed=runMatchesStatus(summary,'full_inference_success');
+      const passed=validationExplorerStatus(summary).display_status==='full_inference_success';
       state.runsCache[parentIdx]={...state.runsCache[parentIdx],manual_validation_passed:state.runsCache[parentIdx].manual_validation_passed||passed,effective_status:passed?'validated_after_manual_space_test':state.runsCache[parentIdx].effective_status,updated_at:summary.updated_at||state.runsCache[parentIdx].updated_at};
     }
   }
@@ -704,12 +802,13 @@ function renderRunSelectionPreview(runId){
   if(typeof requestSpaceTestContextResetForBuild==='function')requestSpaceTestContextResetForBuild(runId);
   renderRunDetail(detail);
   setText('progressTitle',runId);
-  setText('progressStatus',badgeLabel(cached.status||'loading'));
+  const explorer=buildExplorerStatus(cached);
+  setText('progressStatus',explorer.display_label||'Loading');
   const statusEl=$('progressStatus');
-  if(statusEl)statusEl.className='badge '+statusClass(cached.status||'');
+  if(statusEl)statusEl.className='badge '+(explorer.display_tone||statusClass(explorer.display_status||''));
   setText('currentStep','Loading run details…');
   setText('lastEvent','Fetching latest events and progress…');
-  setText('progressPercent',cached.status&&String(cached.status).includes('success')?'100%':'—');
+  setText('progressPercent',buildExplorerStatus(cached).display_status==='full_inference_success'?'100%':'—');
 }
 function cachedRunDetail(runId,heavy=false){
   const entry=state.runDetailCache?.[runId];
@@ -728,21 +827,35 @@ function rememberRunDetail(runId,detail,heavy=false){
 
 
 function restoreRunRowStatusLabel(row){
+  // v193 legacy loading token: const label=runCompactStatusLabel(status||cached.status||'unknown'); pill.textContent=label
   if(!row)return;
   const runId=row.dataset.run;
   const cached=cachedRunById(runId)||{};
-  const status=isValidationRunSummary(cached)?runCanonicalStatus(cached):buildEffectiveStatus(cached);
+  const explorer=isValidationRunSummary(cached)?validationExplorerStatus(cached):buildExplorerStatus(cached);
+  const status=explorer.display_status||cached.status||'unknown';
   const pill=row.querySelector('.run-status-pill');
   if(pill){
-    const label=runCompactStatusLabel(status||cached.status||'unknown');
-    pill.textContent=label;
-    pill.title=badgeLabel(status||cached.status||'unknown');
-    const tone=statusClass(status||cached.status||'unknown');
+    pill.textContent=explorer.display_label||runCompactStatusLabel(status);
+    pill.title=explorer.display_label||badgeLabel(status);
+    const tone=explorer.display_tone||statusClass(status);
     pill.className=`run-status-pill ${tone}`;
     pill.removeAttribute('aria-busy');
   }
   const dot=row.querySelector('.run-list-dot');
-  if(dot)dot.className=`run-list-dot ${statusClass(status||cached.status||'unknown')}`;
+  if(dot)dot.className=`run-list-dot ${explorer.display_tone||statusClass(status)}`;
+}
+function setCenterWorkspaceLoading(runId,loading=true){
+  const workspace=document.querySelector('.center-stack');
+  if(!workspace)return;
+  const active=Boolean(loading&&runId);
+  workspace.classList.toggle('is-run-loading',active);
+  if(active){
+    workspace.setAttribute('aria-busy','true');
+    workspace.dataset.loadingRun=runId;
+  }else{
+    workspace.removeAttribute('aria-busy');
+    delete workspace.dataset.loadingRun;
+  }
 }
 function setRunSelectionLoading(runId,loading=true){
   const next=loading?runId:null;
@@ -751,10 +864,12 @@ function setRunSelectionLoading(runId,loading=true){
     document.querySelectorAll(`.run-row[data-run="${CSS.escape(previous)}"]`).forEach(restoreRunRowStatusLabel);
   }
   if(state.runSelectionLoadingId===next){
+    setCenterWorkspaceLoading(next,Boolean(next));
     if(!loading)document.querySelectorAll('.run-row.is-loading').forEach(row=>{row.classList.remove('is-loading');row.removeAttribute('aria-busy');restoreRunRowStatusLabel(row);});
     return;
   }
   state.runSelectionLoadingId=next;
+  setCenterWorkspaceLoading(next,Boolean(next));
   document.querySelectorAll('.run-row[data-run]').forEach(row=>{
     const active=Boolean(next)&&row.dataset.run===next;
     row.classList.toggle('is-loading',active);

web/static/style.css

@@ -0,0 +1 @@
+/* Deprecated placeholder. app.css is the only loaded ASF stylesheet. */

web/static/styles.css

@@ -1,3 +1,4 @@
+/* Deprecated inactive stylesheet. Kept only for legacy reference; index.html loads app.css. */
 
 /* v190.20 eval archive owner controls */
 .eval-archive-actions .eval-flush-button{