Upload 8 files

web/static/app.js

@@ -1291,6 +1291,33 @@ function showValidationRunDetail(detail={}){
   switchCenterTab('validate');
   if(state.validationRunId&&validationCanonicalStatus(detail)==='running')startValidationPolling(state.validationRunId);
 }
+
+function linkedValidationParentFromDetail(detail={}){
+  return firstNonEmpty(
+    detail.parent_build_run_id,
+    detail.summary?.parent_build_run_id,
+    detail.state?.parent_build_run_id,
+    detail.launch?.parent_build_run_id,
+    state.linkedValidationParent,
+    state.validationPrefillDraft?.parentBuildRunId,
+    state.validationPrefillDraft?.sourceRunId
+  );
+}
+async function refreshLinkedValidationParentAfterTerminal(detail={}){
+  const parentId=linkedValidationParentFromDetail(detail);
+  if(!parentId)return;
+  try{
+    const snapshot=await fetchRunViewSnapshotOnce(parentId,{includeJobLogs:false});
+    if(snapshot){
+      if(typeof rememberRunDetail==='function')rememberRunDetail(parentId,snapshot,true);
+      if(typeof upsertRunExplorerFromProgress==='function')upsertRunExplorerFromProgress(snapshot);
+      if(state.runId===parentId&&typeof renderRunViewSnapshot==='function')renderRunViewSnapshot(snapshot);
+      if(typeof renderRunStats==='function')renderRunStats(state.runsCache||[]);
+    }
+  }catch(err){console.warn('linked validation parent refresh failed',err)}
+  try{await loadRuns(true)}catch(err){console.warn('linked validation runs refresh failed',err)}
+}
+
 function stopValidationPolling(){
   if(state.validationPoll){clearInterval(state.validationPoll);state.validationPoll=null}
   state.validationPollToken=null;
@@ -1301,11 +1328,12 @@ async function refreshValidationProgress(pollToken=state.validationPollToken){
   try{
     const p=await apiGet(`/api/runs/${encodeURIComponent(requestedRunId)}/progress?bucket_name=${encodeURIComponent(state.bucketName)}&include_job_logs=1`);
     if(pollToken!==state.validationPollToken||requestedRunId!==state.validationRunId)return;
-    if(shouldIgnoreValidationUpdate(p,requestedRunId)){const terminal=terminalValidationForRun(requestedRunId);if(terminal){renderValidationStatus({...terminal.detail,_refreshing:true});stopValidationPolling();loadRuns(false);}return;}
+    if(shouldIgnoreValidationUpdate(p,requestedRunId)){const terminal=terminalValidationForRun(requestedRunId);if(terminal){renderValidationStatus({...terminal.detail,_refreshing:true});stopValidationPolling();await refreshLinkedValidationParentAfterTerminal(terminal.detail);}return;}
     state.validationPollErrors=0;
     renderValidationStatus(p);
+    if(typeof upsertRunExplorerFromProgress==='function')upsertRunExplorerFromProgress(p);
     const canonical=validationCanonicalStatus(p);
-    if(validationIsTerminalStatus(canonical)){state.validationMode='view';rememberTerminalValidation(p);stopValidationPolling();showMessage(`Validation finished: ${badgeLabel(canonical)}`,statusClass(canonical)==='success'?'success':statusClass(canonical)==='error'?'error':'warning');loadRuns(false)}
+    if(validationIsTerminalStatus(canonical)){state.validationMode='view';rememberTerminalValidation(p);stopValidationPolling();showMessage(`Validation finished: ${badgeLabel(canonical)}`,statusClass(canonical)==='success'?'success':statusClass(canonical)==='error'?'error':'warning');await refreshLinkedValidationParentAfterTerminal(p)}
   }catch(e){
     if(pollToken!==state.validationPollToken||requestedRunId!==state.validationRunId)return;
     state.validationPollErrors+=1;
@@ -1315,7 +1343,7 @@ async function refreshValidationProgress(pollToken=state.validationPollToken){
 }
 function startValidationPolling(runId){
   const terminal=terminalValidationForRun(runId);
-  if(terminal){stopValidationPolling();state.validationMode='view';state.validationRunId=runId;renderValidationStatus({...terminal.detail,_refreshing:true});return;}
+  if(terminal){stopValidationPolling();state.validationMode='view';state.validationRunId=runId;renderValidationStatus({...terminal.detail,_refreshing:true});refreshLinkedValidationParentAfterTerminal(terminal.detail);return;}
   stopValidationPolling();
   state.validationMode='running';
   state.validationRunId=runId;

web/static/progress.js

@@ -575,6 +575,8 @@ function timelineDetailStatusLabel(status=''){
   if(s==='verified')return'Verified';
   if(s==='fallback')return'Fallback';
   if(s==='building')return'Building';
+  if(s==='queued')return'Queued';
+  if(s==='blocked')return'Blocked';
   if(s==='warning'||s==='warn')return'Needs attention';
   if(s==='running'||s==='waiting')return'In progress';
   if(s==='not_needed'||s==='skipped')return'Not needed';

web/static/runs.js

@@ -60,7 +60,7 @@ function runHasPersistedGenerationSuccess(run={}){
 }
 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);
+  return ['failed','manual_hardware_required','generated_needs_manual_hardware','technical_blocker','technical_blocker_boot_only','blocked','completed_with_warnings','auth_refresh_required','stale','stopped'].includes(canon);
 }
 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))}
@@ -91,7 +91,7 @@ function explicitExplorerStatus(run={}){
     run.status,run.final_status,run.verdict,run.result_status
   ].map(normalizeExplorerStatusValue).filter(Boolean);
   for(const s of values){
-    if(['full_inference_success','partial_validation','manual_hardware_required','technical_blocker','technical_blocker_boot_only','failed','stale','stopped','cancelled','canceled','auth_refresh_required','validated_after_space_test','recovered_by_space_test','validated_after_manual_space_test','recovered_by_manual_validation','demo_usable_full_promise_not_verified','interactive_app_available_smoke_failed','manual_test_required_smoke_failed','placeholder_scaffold_deployed'].includes(s))return s==='cancelled'||s==='canceled'?'stopped':s;
+    if(['full_inference_success','partial_validation','manual_hardware_required','generated_needs_manual_hardware','technical_blocker','technical_blocker_boot_only','blocked','completed_with_warnings','failed','stale','stopped','cancelled','canceled','auth_refresh_required','validated_after_space_test','recovered_by_space_test','validated_after_manual_space_test','recovered_by_manual_validation','demo_usable_full_promise_not_verified','interactive_app_available_smoke_failed','manual_test_required_smoke_failed','placeholder_scaffold_deployed'].includes(s))return s==='cancelled'||s==='canceled'?'stopped':s;
     if(s==='full_inference_candidate_health_passed'||s==='health_only'||s==='partial'||s==='completed_with_warnings')return 'partial_validation';
   }
   return '';
@@ -435,7 +435,45 @@ function linkedValidationRowsFromMetadata(run={}){
   }
   return rows.filter(x=>x&&typeof x==='object');
 }
+const LINKED_VALIDATION_RUNNING_STATUSES=new Set(['','none','unknown','unchanged','idle','pending','queued','running','started','building','waiting','scheduled']);
+const LINKED_VALIDATION_TERMINAL_STATUSES=new Set(['success','passed','succeeded','full_inference_success','validated_after_space_test','validated_after_manual_space_test','recovered_by_space_test','recovered_by_manual_validation','manual_validation_passed','manual_validated','partial_validation','failed','failure','error','auth_refresh_required','stale','stopped','cancelled','canceled','manual_hardware_required','generated_needs_manual_hardware','technical_blocker','technical_blocker_boot_only','blocked','completed_with_warnings']);
+const LINKED_VALIDATION_PASS_STATUSES=new Set(['success','passed','succeeded','full_inference_success','validated_after_space_test','validated_after_manual_space_test','recovered_by_space_test','recovered_by_manual_validation','manual_validation_passed','manual_validated']);
+const LINKED_VALIDATION_FAIL_STATUSES=new Set(['failed','failure','error','auth_refresh_required','stale','stopped','cancelled','canceled','technical_blocker','technical_blocker_boot_only']);
+function linkedValidationRowStatus(row={}){
+  row=safeRunObject(row);
+  return normalizeExplorerStatusValue(row.status||row.validation_status||row.result_status||row.verdict||row.effective_status||row.summary?.status||row.state?.status||'');
+}
+function linkedValidationIsTerminalForAccounting(row={}){
+  const st=linkedValidationRowStatus(row);
+  if(LINKED_VALIDATION_RUNNING_STATUSES.has(st))return false;
+  if(LINKED_VALIDATION_TERMINAL_STATUSES.has(st))return true;
+  return runIsFinished(st)&&!LINKED_VALIDATION_RUNNING_STATUSES.has(st);
+}
+function linkedValidationPassedForAccounting(row={}){
+  const st=linkedValidationRowStatus(row);
+  return LINKED_VALIDATION_PASS_STATUSES.has(st);
+}
+function linkedValidationFailedForAccounting(row={}){
+  const st=linkedValidationRowStatus(row);
+  return LINKED_VALIDATION_FAIL_STATUSES.has(st);
+}
+function linkedValidationAccountingKey(row={},idx=0){
+  return String(row.validation_run_id||row.run_id||row.summary?.run_id||row.state?.run_id||row.id||`${row.parent_build_run_id||''}:${row.updated_at||row.validated_at||row.created_at||idx}`);
+}
+function dedupeLinkedValidationRows(rows=[]){
+  const seen=new Set();
+  const out=[];
+  (Array.isArray(rows)?rows:[]).forEach((row,idx)=>{
+    if(!row||typeof row!=='object')return;
+    const key=linkedValidationAccountingKey(row,idx);
+    if(key&&seen.has(key))return;
+    if(key)seen.add(key);
+    out.push(row);
+  });
+  return out;
+}
 function linkedValidationCountFromMetadata(run={},rows=[]){
+  const explicitRows=Array.isArray(rows)?rows.filter(linkedValidationIsTerminalForAccounting):[];
   const counts=[
     run.linked_validation_count,
     run.summary?.linked_validation_count,
@@ -446,32 +484,39 @@ function linkedValidationCountFromMetadata(run={},rows=[]){
     run.linked_validations?.count,
     run.summary?.linked_validations?.count
   ].map(Number).filter(n=>Number.isFinite(n)&&n>0);
-  return Math.max(rows.length,...counts,0);
+  return Math.max(explicitRows.length,...counts,0);
 }
-function linkedValidationRowStatus(row={}){
-  row=safeRunObject(row);
-  return String(row.status||row.validation_status||row.result_status||row.verdict||row.effective_status||row.summary?.status||'').toLowerCase();
+function linkedValidationExplicitTerminalRow(explicit={}){
+  if(!explicit||typeof explicit!=='object')return null;
+  return linkedValidationIsTerminalForAccounting(explicit)?explicit:null;
+}
+function linkedValidationTerminalRowsForBuild(run={}){
+  run=safeRunObject(run);
+  const metadataRows=linkedValidationRowsFromMetadata(run);
+  const cacheRows=linkedValidationsForBuild(run.run_id).filter(linkedValidationIsTerminalForAccounting);
+  return dedupeLinkedValidationRows([...metadataRows,...cacheRows]).filter(linkedValidationIsTerminalForAccounting);
+}
+function linkedValidationAccountingRowsForBuilds(builds=[]){
+  const rows=[];
+  validRunsList(builds).forEach(build=>rows.push(...linkedValidationTerminalRowsForBuild(build)));
+  return dedupeLinkedValidationRows(rows).filter(linkedValidationIsTerminalForAccounting);
 }
 function buildManualValidationStatus(run={}){
   run=safeRunObject(run);
   const explicit=run.post_build_validation||run.effective_run_status?.post_build_validation||run.summary?.post_build_validation||run.summary?.effective_run_status?.post_build_validation||run.manual_validation_status||run.summary?.manual_validation_status||{};
   const metadataRows=linkedValidationRowsFromMetadata(run);
-  const cacheRows=linkedValidationsForBuild(run.run_id).filter(v=>!runMatchesStatus(v,'running'));
-  const rows=[...metadataRows,...cacheRows];
-  const explicitStatus=String(explicit.status||explicit.validation_status||explicit.result_status||explicit.verdict||'').toLowerCase();
-  const metadataCount=linkedValidationCountFromMetadata(run,metadataRows);
-  const linkedCount=Math.max(metadataCount,cacheRows.length,explicitStatus?1:0);
+  const cacheRows=linkedValidationsForBuild(run.run_id).filter(linkedValidationIsTerminalForAccounting);
+  const explicitRow=linkedValidationExplicitTerminalRow(explicit);
+  const rows=dedupeLinkedValidationRows([...metadataRows,...cacheRows,...(explicitRow?[explicitRow]:[])]).filter(linkedValidationIsTerminalForAccounting);
+  const metadataCount=linkedValidationCountFromMetadata(run,rows);
+  const linkedCount=Math.max(metadataCount,rows.length);
   const passed=Boolean(
     run.manual_validation_passed||run.summary?.manual_validation_passed||
-    explicitStatus==='success'||explicitStatus==='passed'||explicitStatus==='full_inference_success'||explicitStatus==='validated_after_space_test'||explicitStatus==='validated_after_manual_space_test'||
-    rows.some(v=>{const st=linkedValidationRowStatus(v);return st==='success'||st==='passed'||st==='full_inference_success'||st==='validated_after_space_test'||st==='validated_after_manual_space_test'||runMatchesStatus(v,'full_inference_success');})
-  );
-  const failed=Boolean(
-    explicitStatus==='failed'||explicitStatus==='failure'||explicitStatus==='error'||
-    rows.some(v=>{const st=linkedValidationRowStatus(v);return st==='failed'||st==='failure'||st==='error'||runMatchesStatus(v,'failed');})
+    rows.some(linkedValidationPassedForAccounting)
   );
+  const failed=Boolean(rows.some(linkedValidationFailedForAccounting));
   const latest=rows[0]||{};
-  return {passed,failed,linkedCount,latest,explicit,metadataRows,cacheRows};
+  return {passed,failed,linkedCount,latest,explicit,metadataRows,cacheRows,accountedRows:rows};
 }
 function buildEffectiveStatus(run={}){
   // Kept for legacy callers, but now delegates to the deterministic Runs Explorer status model.
@@ -501,17 +546,18 @@ function percentile(values=[],p=0.5){
   return nums[lo]+(nums[hi]-nums[lo])*(idx-lo);
 }
 function pct(part,total){return total?`${Math.round((part/total)*100)}%`:'—'}
-function runStatsIssueCounts(runs=[]){
+function runStatsIssueCounts(runs=[],linkedRows=[]){
   runs=validRunsList(runs);
   const counts={failed_builds:0,failed_linked_tests:0,manual_hardware:0,pi_model_mismatch:0,stale:0};
+  counts.failed_linked_tests=dedupeLinkedValidationRows(linkedRows).filter(linkedValidationFailedForAccounting).length;
   for(const r of runs){
     const validation=isValidationRunSummary(r);
     const status=String(r.status||'').toLowerCase();
     const pi=r.pi_model_resolution||{};
-    if(runMatchesStatus(r,'failed')){if(validation&&isLinkedValidationRun(r))counts.failed_linked_tests++;else if(!validation)counts.failed_builds++;}
+    if(!validation&&runMatchesStatus(r,'failed'))counts.failed_builds++;
     if(!validation&&runMatchesStatus(r,'manual_hardware_required')) counts.manual_hardware++;
     if(!validation&&(pi.mismatch||status.includes('model_mismatch'))) counts.pi_model_mismatch++;
-    if(status.includes('stale')) counts.stale++;
+    if(!validation&&status.includes('stale')) counts.stale++;
   }
   return counts;
 }
@@ -524,7 +570,9 @@ function renderRunAggregateStats(){
   if(!root)return;
   const runs=validRunsList(state.runsCache||[]);
   const builds=runs.filter(r=>!isValidationRunSummary(r));
-  const validations=runs.filter(r=>isLinkedValidationRun(r));
+  const linkedRows=linkedValidationAccountingRowsForBuilds(builds);
+  const validations=linkedRows;
+  const runningLinked=runs.filter(r=>isLinkedValidationRun(r)&&!linkedValidationIsTerminalForAccounting(r)).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;
@@ -536,17 +584,17 @@ function renderRunAggregateStats(){
   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;
-  const terminalValidations=validations.filter(r=>!runMatchesStatus(r,'running'));
+  const passedLinked=validations.filter(linkedValidationPassedForAccounting).length;
+  const terminalValidations=validations;
   const passedValidations=passedLinked;
   const latencies=validations.map(runStatLatencyValue).filter(v=>v!==null);
   const median=percentile(latencies,.5);
   const p95=percentile(latencies,.95);
-  const issues=runStatsIssueCounts(runs);
+  const issues=runStatsIssueCounts(runs,validations);
   const issueTotal=Object.values(issues).reduce((a,b)=>a+b,0);
   const badge=$('runStatsBadge');
   if(badge){
-    badge.textContent=builds.length?`${builds.length} builds · ${validations.length} linked tests`:'No builds';
+    badge.textContent=builds.length?`${builds.length} builds · ${validations.length} linked tests${runningLinked?` · ${runningLinked} running`:''}`:'No builds';
     badge.className='badge '+(failedBuilds||issueTotal?'warn':runningBuilds?'running':builds.length?'success':'neutral');
   }
   if(!builds.length){
@@ -562,7 +610,7 @@ function renderRunAggregateStats(){
   ].filter(([,count])=>count>0);
   root.innerHTML=`
     <div class="run-stats-grid build-first-stats">
-      ${runStatsCell('Build Runs',String(builds.length),`${validations.length} linked Space Test${validations.length===1?'':'s'}`,'neutral')}
+      ${runStatsCell('Build Runs',String(builds.length),`${validations.length} completed linked Space Test${validations.length===1?'':'s'}${runningLinked?` · ${runningLinked} running`:''}`,'neutral')}
       ${runStatsCell('Build status',`${runningBuilds} running`,`${failedBuilds} failed` ,failedBuilds?'warn':runningBuilds?'running':'success')}
       ${runStatsCell('Automatic success',pct(automaticSuccess,terminalBuilds.length),`${automaticSuccess}/${terminalBuilds.length} finished builds`,'success')}
       ${runStatsCell('Effective success',pct(effectiveSuccess,terminalBuilds.length),`${effectiveSuccess}/${terminalBuilds.length} after linked tests`,'success')}
@@ -618,7 +666,7 @@ function runExplorerNeedsBackgroundHydration(run={}){
   const runId=run.run_id||run.summary?.run_id;
   if(!runId||isRunLocallyDeleted(runId))return false;
   const canonical=buildEffectiveStatus(run);
-  if(['full_inference_success','failed','manual_hardware_required','technical_blocker','technical_blocker_boot_only','auth_refresh_required','stale','stopped','running'].includes(canonical))return false;
+  if(['full_inference_success','failed','manual_hardware_required','generated_needs_manual_hardware','technical_blocker','technical_blocker_boot_only','blocked','completed_with_warnings','auth_refresh_required','stale','stopped','running'].includes(canonical))return false;
   return ['partial_validation','health_only','partial','completed_with_warnings','unknown',''].includes(String(canonical||'').toLowerCase());
 }
 function scheduleRunExplorerBackgroundHydration(runs=[]){
@@ -803,8 +851,16 @@ function upsertRunExplorerFromProgress(p={}){
     recommended_zerogpu_duration_seconds:p.summary?.recommended_zerogpu_duration_seconds||p.generation_smoke?.recommended_zerogpu_duration_seconds||p.generation_smoke?.recommended_zero_gpu_duration_seconds,
     kind:p.summary?.kind||p.state?.kind||'universal_model_card_builder',
     parent_build_run_id:p.summary?.parent_build_run_id||p.state?.parent_build_run_id,
-    manual_validation_passed:p.summary?.manual_validation_passed||p.manual_validation_status?.status==='success',
-    effective_status:p.summary?.effective_status||p.manual_validation_status?.effective_status,
+    post_build_validation:p.post_build_validation||p.view?.post_build_validation||p.summary?.post_build_validation||p.effective_run_status?.post_build_validation||p.summary?.effective_run_status?.post_build_validation||{},
+    post_build_validation_status:p.post_build_validation_status||p.summary?.post_build_validation_status||{},
+    manual_validation_status:p.manual_validation_status||p.summary?.manual_validation_status||p.view?.manual_validation||{},
+    linked_validations:p.linked_validations||p.summary?.linked_validations||{},
+    linked_validation_count:p.summary?.linked_validation_count||p.linked_validation_count,
+    linked_validations_count:p.summary?.linked_validations_count||p.linked_validations_count,
+    effective_run_status:p.effective_run_status||p.summary?.effective_run_status||p.view?.effective_run_status||{},
+    display_status:p.summary?.display_status||p.display_status||p.view?.display_status,
+    manual_validation_passed:p.summary?.manual_validation_passed||p.manual_validation_status?.status==='success'||p.view?.manual_validation?.status==='success',
+    effective_status:p.summary?.effective_status||p.effective_status||p.manual_validation_status?.effective_status||p.view?.effective_status,
     bucket_source:p.bucket_source||p.summary?.bucket_source||state.bucketSource,
   };
   state.runsCache=validRunsList(state.runsCache||[]);
@@ -815,8 +871,15 @@ 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=validationExplorerStatus(summary).display_status==='full_inference_success';
-      state.runsCache[parentIdx]={...state.runsCache[parentIdx],manual_validation_passed:state.runsCache[parentIdx].manual_validation_passed||passed,post_build_status:passed?'validated_after_space_test':state.runsCache[parentIdx].post_build_status,effective_status:passed?'validated_after_space_test':state.runsCache[parentIdx].effective_status,updated_at:summary.updated_at||state.runsCache[parentIdx].updated_at};
+      const terminal=linkedValidationIsTerminalForAccounting(summary);
+      const passed=linkedValidationPassedForAccounting(summary);
+      const existingParent=state.runsCache[parentIdx]||{};
+      const existingLinked=existingParent.linked_validations&&typeof existingParent.linked_validations==='object'?existingParent.linked_validations:{parent_build_run_id:parentId,validations:[]};
+      const existingRows=Array.isArray(existingLinked.validations)?existingLinked.validations:[];
+      const nextRows=terminal?dedupeLinkedValidationRows([...existingRows,summary]):existingRows;
+      const nextLinked={...existingLinked,parent_build_run_id:parentId,validations:nextRows,updated_at:summary.updated_at||existingLinked.updated_at||''};
+      if(passed)nextLinked.effective_status='validated_after_space_test';
+      state.runsCache[parentIdx]={...existingParent,linked_validations:nextLinked,linked_validation_count:nextRows.filter(linkedValidationIsTerminalForAccounting).length,linked_validations_count:nextRows.filter(linkedValidationIsTerminalForAccounting).length,manual_validation_passed:existingParent.manual_validation_passed||passed,post_build_status:passed?'validated_after_space_test':existingParent.post_build_status,effective_status:passed?'validated_after_space_test':existingParent.effective_status,updated_at:summary.updated_at||existingParent.updated_at};
     }
   }
   state.runsLastLoaded=Date.now();