Upload 8 files

web/static/app.css

@@ -2793,7 +2793,7 @@ strong,p,h1,h2,h3,h4,span,a,button,div,li{overflow-wrap:break-word;word-break:no
 
 /* v190.10 — Active Run timeline hotfix */
 
-/* v190.14 — Build-first Runs Explorer polish */
+/* v190.15 — Build-first Runs Explorer polish */
 .runs-table{
   gap:12px!important;
 }
@@ -2857,3 +2857,59 @@ strong,p,h1,h2,h3,h4,span,a,button,div,li{overflow-wrap:break-word;word-break:no
   .run-row.run-list-item{padding:13px 10px!important;border-radius:18px!important}
   .linked-validation-strip{width:100%;justify-content:space-between;border-radius:14px}
 }
+
+/* v190.15 — Build-first compatibility cleanup */
+.run-row.run-list-item{border-left:0!important;border-right:0!important}
+.run-row.build-run{background:linear-gradient(180deg,#fff,#fbfaf7)}
+.run-row .linked-validation-strip{margin-top:10px}
+
+/* v190.16 — Delete cascade clarity */
+.delete-run-meta span strong{letter-spacing:.01em}
+.delete-run-meta span code{word-break:break-word}
+.delete-run-card{
+  border-left:0!important;
+  border-right:0!important;
+  box-shadow:0 24px 80px rgba(15,23,42,.18)!important;
+}
+.delete-run-warning{
+  border-left:0!important;
+  border-right:0!important;
+}
+
+/* v190.16 — Build-first Runs Explorer polish */
+/* v190.16 — Build-first compatibility cleanup */
+
+/* v190.17 — Effective eval and linked validation provenance */
+.eval-effective-note{
+  margin:.45rem 0 .7rem;
+  padding:.55rem .7rem;
+  border:0;
+  border-radius:14px;
+  background:rgba(34,197,94,.08);
+  color:#31513a;
+}
+.eval-effective-note code{font-size:.78rem;}
+.metrics-list li em{
+  display:block;
+  margin-top:.18rem;
+  color:var(--muted,#6b7280);
+  font-size:.75rem;
+  font-style:normal;
+}
+
+/* v190.17 — Delete cascade clarity */
+
+/* v190.17 — Build-first Runs Explorer polish */
+
+/* v190.17 — Build-first compatibility cleanup */
+
+/* v190.19 — Build completion matrix + endpoint discovery-first linked Space Test */
+.space-test-policy-chip{display:inline-flex;align-items:center;gap:.4rem;border-radius:999px;padding:.35rem .65rem;background:rgba(99,102,241,.09);color:#3730a3;font-weight:650;border:0;box-shadow:none}
+.space-test-policy-chip.recover{background:rgba(245,158,11,.12);color:#92400e}
+.space-test-policy-chip.unavailable,.space-test-policy-chip.blocked{background:rgba(100,116,139,.12);color:#475569}
+.endpoint-discovery-note{margin-top:.55rem;padding:.7rem .85rem;border-radius:14px;background:rgba(14,165,233,.08);color:#075985;border:0;line-height:1.45}
+.recovered-build-chip{display:inline-flex;gap:.35rem;align-items:center;border-radius:999px;padding:.25rem .55rem;background:rgba(16,185,129,.12);color:#047857;border:0}
+/* v190.19 — Build-first Runs Explorer polish */
+/* v190.19 — Build-first compatibility cleanup */
+/* v190.19 — Delete cascade clarity */
+/* v190.19 — Effective eval and linked validation provenance */

web/static/app.js

@@ -344,11 +344,13 @@ function renderAnonymousEvalStatus(me){
   const enable=$('enableEvalArchive');
   const disable=$('disableEvalArchive');
   const verify=$('verifyEvalArchive');
+  const flush=$('flushEvalArchive');
   const stateBadge=$('evalArchiveStateBadge');
   const cfg=me?.anonymous_eval||{};
   const enabled=Boolean(cfg.enabled);
   const canManage=Boolean(cfg.can_manage)&&cfg.env_override!==true;
   const readonly=Boolean(cfg.readonly)||Boolean(enabled&&!canManage);
+  const canFlush=Boolean(cfg.can_flush)&&enabled;
   const bucket=cfg.bucket_source||cfg.proposed_bucket_source||'configured bucket';
   const path=cfg.bucket_path?'/'+cfg.bucket_path:(cfg.default_bucket_path?'/'+cfg.default_bucket_path:'');
   const mount=cfg.job_mount_path||cfg.default_mount_path||'/evals';
@@ -396,6 +398,11 @@ function renderAnonymousEvalStatus(me){
     verify.disabled=state.busy;
     verify.title='Refresh and verify the eval archive configuration.';
   }
+  if(flush){
+    flush.hidden=!canFlush;
+    flush.disabled=state.busy;
+    flush.title='Delete all anonymized eval records from the mounted operator archive. Config is preserved.';
+  }
 }
 function setBucketReady(ok,message){state.bucketReady=Boolean(ok);setBuildLaunchEnabled();const feedback=state.bucketReady?'Ready for builds, validations and artifacts.':(message||'Create your private run bucket before launching builds.');setText('buildGateText',state.bucketReady?'Bucket ready. You can launch builds.':bucketFeedbackSummary(feedback));setText('bucketInlineStatus',state.bucketReady?'Ready':'Setup needed');setBucketFeedback(state.bucketReady?'ready':'error',feedback);for(const id of ['bucketInlineDot','sidebarBucketDot']){const dot=$(id);if(dot)dot.className='status-dot '+(state.bucketReady?'green':'amber-dot')}const inline=$('bucketInlineStatus');if(inline)inline.className='badge '+(state.bucketReady?'success':'warn');document.querySelectorAll('[data-requires-bucket="true"]').forEach(btn=>btn.disabled=state.busy||!state.bucketReady);setBuildLaunchEnabled()}
 function effectivePreferredHardware(){const preferred=formValue('preferredHardware')||'zero-a10g';const fallback=formValue('fallbackHardware')||'a10g-large';const tryZero=$('tryZeroGpu')?.checked??true;if(tryZero)return preferred;if(preferred==='zero-a10g'||preferred.startsWith('zero'))return fallback;return preferred}
@@ -643,6 +650,20 @@ async function disableEvalArchive(){
 }
 
 
+async function flushEvalArchive(){
+  const ok=window.confirm('Delete all anonymized eval archive records from the mounted operator bucket? This preserves the eval archive configuration but cannot be undone.');
+  if(!ok)return;
+  setButtonBusy('flushEvalArchive',true,'Flushing…');
+  try{
+    const result=await apiPost('/api/eval-archive/flush',{});
+    state.user={...(state.user||{}),anonymous_eval:result};
+    renderAnonymousEvalStatus(state.user);
+    showMessage(result.message||'Eval archive records flushed.',result.partial_flush?'warning':'success');
+  }catch(e){showMessage(e.message,true)}
+  finally{setButtonBusy('flushEvalArchive',false)}
+}
+
+
 async function checkBucket(noisy=true){setButtonBusy('checkBucket',true,'Checking…');setBucketFeedback('checking','Checking private bucket access…');try{const data=await apiGet(`/api/bucket/status?bucket_name=${encodeURIComponent(state.bucketName)}`);const source=data.bucket_source||state.bucketName;state.bucketSource=source;setText('bucketInlineLabel',source);setBucketReady(Boolean(data.ok),data.error||'Create your private run bucket before launching builds.');if(noisy)showMessage(data.ok?`Bucket ready: ${source}`:`Bucket not ready: ${data.error||'not found'}`,!data.ok);return data}catch(e){setBucketReady(false,e.message);if(noisy)showMessage(e.message,true);throw e}finally{setButtonBusy('checkBucket',false)}}
 async function createBucket(){setButtonBusy('createBucket',true,'Creating…');setBucketFeedback('creating','Creating private bucket…');try{const data=await apiPost('/api/bucket/create',{bucket_name:state.bucketName});const source=data.bucket_source||state.bucketName;state.bucketSource=source;setText('bucketInlineLabel',source);setBucketReady(Boolean(data.ok),data.error||'Could not create bucket.');showMessage(data.ok?`Created/ready: ${source}`:`Could not create bucket: ${data.error}`,!data.ok);if(data.ok)loadRuns(true)}catch(e){setBucketReady(false,e.message);showMessage(e.message,true)}finally{setButtonBusy('createBucket',false)}}
 
@@ -746,11 +767,12 @@ function validationPrefillFromDetail(detail={}){
   let kwargs=firstObjectPath(smoke.test_kwargs,smoke.kwargs,gate.test_kwargs,gateSmoke.test_kwargs,launch.test_kwargs_json,summary.test_kwargs_json);
   if(!Array.isArray(args))args=defaultValidationArgs(expected);
   if(!kwargs||Array.isArray(kwargs)||typeof kwargs!=='object')kwargs={};
-  const target=summary.target_space||stateObj.target_space||launch.target_space||progress.target_space||$('detailSpace')?.textContent||'';
-  const api=normalizeApiName(smoke.api_name||gate.api_name||launch.api_name||gateSmoke.api_name||progress.api_name||'/generate');
-  const parentBuildRunId=detail.run_id||detail.summary?.run_id||state.runId||progress.run_id||'';
-  const automaticSmokePassed=Boolean(smoke.ok||smoke.status==='success');
-  return {target,api,expected,args,kwargs,parentBuildRunId,sourceRunId:parentBuildRunId,linkedTargetSpace:target,automaticSmokePassed,smokeLatency:smoke.latency_seconds||smoke.observed_latency_seconds};
+  const policy=detail.space_test_policy||detail.view?.space_test_policy||detail.space_test?.policy||progress.view?.space_test_policy||progress.view?.space_test?.policy||{};
+  const target=policy.target_space||summary.target_space||stateObj.target_space||launch.target_space||progress.target_space||$('detailSpace')?.textContent||'';
+  const api=policy.requires_endpoint_discovery?'':normalizeApiName(policy.endpoint||smoke.api_name||gate.api_name||launch.api_name||gateSmoke.api_name||progress.api_name||'/generate');
+  const parentBuildRunId=policy.parent_build_run_id||detail.run_id||detail.summary?.run_id||state.runId||progress.run_id||'';
+  const automaticSmokePassed=Boolean(smoke.ok||smoke.status==='success'||policy.mode==='replay');
+  return {target,api,expected,args,kwargs,parentBuildRunId,sourceRunId:parentBuildRunId,linkedTargetSpace:target,automaticSmokePassed,smokeLatency:smoke.latency_seconds||smoke.observed_latency_seconds,spaceTestPolicy:policy,requiresEndpointDiscovery:Boolean(policy.requires_endpoint_discovery)};
 }
 function renderValidationStatus(data={}){
   const candidateRunId=validationDetailRunId(data)||state.validationRunId;
@@ -879,10 +901,10 @@ function renderValidationPrefillDraft(prefill={},sourceLabel='selected Space'){
   if(tabDot)tabDot.className='tab-status-dot neutral';
   const card=$('spaceTestPreview');
   if(card)card.classList.remove('is-validating');
-  setText('spaceTestOutput',prefill.automaticSmokePassed?'Replay linked smoke test':'New linked validation');
+  setText('spaceTestOutput',prefill.requiresEndpointDiscovery?'Discover endpoints and validate':(prefill.automaticSmokePassed?'Replay linked smoke test':'New linked validation'));
   setText('validationStartedAt','Not launched');
   setText('spaceTestLatency','—');
-  setText('spaceTestVerdict',prefill.automaticSmokePassed?`Automatic smoke passed · ready to replay from ${sourceLabel}`:`Linked to ${sourceLabel}`);
+  setText('spaceTestVerdict',prefill.spaceTestPolicy?.message|| (prefill.automaticSmokePassed?`Automatic smoke passed · ready to replay from ${sourceLabel}`:`Linked to ${sourceLabel}`));
   setText('spaceTestProgressPercent','0%');
   const fill=$('spaceTestProgressFill');
   if(fill){fill.style.width='0%';fill.className='validation-progress-fill neutral'}
@@ -893,7 +915,7 @@ function renderValidationPrefillDraft(prefill={},sourceLabel='selected Space'){
   const endpoints=$('spaceTestEndpoints');
   if(endpoints)endpoints.innerHTML=`<div class="empty compact-empty">Linked to Build Run <code>${escapeHtml(state.validationPrefillDraft.parentBuildRunId||'—')}</code>. Endpoint schema will be refreshed when this validation runs.</div>`;
   const launchBtn=$('launchValidate');
-  if(launchBtn&&!launchBtn.classList.contains('is-busy'))launchBtn.textContent='Launch validation';
+  if(launchBtn&&!launchBtn.classList.contains('is-busy'))launchBtn.textContent=prefill.requiresEndpointDiscovery?'Discover endpoints and validate':'Launch validation';
   setValidationLaunchEnabled();
   const deleteBtn=$('deleteValidationRun');
   if(deleteBtn){deleteBtn.disabled=true;deleteBtn.onclick=null;}
@@ -917,11 +939,30 @@ function prepareValidationFromActiveRun(){
   const activeDetail={...selected,...(state.activeRunProgress||{}),summary:{...(selected.summary||{}),...(state.activeRunProgress?.summary||{})}};
   applyValidationPrefill(activeDetail,'active run',{preserveSelection:false});
 }
+function contextualizeSpaceTestFromBuildRun(detail={}){
+  if(!detail||typeof detail!=='object')return;
+  if(typeof isValidationRunDetail==='function'&&isValidationRunDetail(detail))return;
+  if(state.validationMode==='running')return;
+  const prefill=validationPrefillFromDetail(detail);
+  if(!prefill.parentBuildRunId||!prefill.target||prefill.target==='—')return;
+  state.validationPrefillDraft={...prefill,sourceLabel:'selected Build Run',parentBuildRunId:prefill.parentBuildRunId,sourceRunId:prefill.parentBuildRunId,linkedTargetSpace:prefill.target};
+  state.linkedValidationParent=prefill.parentBuildRunId;
+  if(!state.validationArgsDirty){
+    setInputValue('validateSpace',prefill.target);
+    setInputValue('expectedOutput',prefill.expected);
+    setInputValue('validateApi',prefill.api);
+    setInputValue('testArgs',prettyJson(prefill.args));
+    setInputValue('testKwargs',prettyJson(prefill.kwargs));
+  }
+  const endpoints=$('spaceTestEndpoints');
+  if(endpoints&&state.centerTab!=='validate')endpoints.innerHTML=`<div class="empty compact-empty">Linked to selected Build Run <code>${escapeHtml(prefill.parentBuildRunId)}</code>. ${prefill.requiresEndpointDiscovery?'Endpoints will be discovered before validation.':'Open Space Test to replay or run a linked validation.'}</div>`;
+  setValidationLaunchEnabled();
+}
 function prepareValidationFromSelectedRun(){
   applyValidationPrefill(state.selectedRunDetail||{},'selected run',{preserveSelection:false});
 }
 async function launchBuild(){const formError=validateBuildForm();if(formError){showMessage(formError,true);return}setBusy(true,'Launching build Job…');setButtonBusy('launchBuild',true,'Launching…');try{setText('hardwarePlan',hardwarePlanLabel());const payload={bucket_name:state.bucketName,model_id:formValue('modelId'),target_space_name:formValue('targetSpace')||undefined,pi_model:formValue('piModel'),implementation_mode:formValue('implementationMode'),preferred_space_hardware:effectivePreferredHardware(),fallback_space_hardware:formValue('fallbackHardware'),allow_fixed_gpu_fallback:$('allowFallback')?.checked??true,try_zero_gpu_first:$('tryZeroGpu')?.checked??true,expected_output_type:formValue('buildExpectedOutput')};const result=await apiPost('/api/build',payload);setActiveRun(result);showMessage(`Build launched: ${result.run_id}`,'success');loadRuns(true)}catch(e){showMessage(e.message,true)}finally{setBusy(false);setButtonBusy('launchBuild',false)}}
-async function launchValidate(){const formError=validateValidationForm();if(formError){showMessage(formError,true);return}setBusy(true,'Launching validation Job…');setButtonBusy('launchValidate',true,'Launching…');try{const args=parseJsonField('testArgs',[]);const kwargs=parseJsonField('testKwargs',{});const payload={bucket_name:state.bucketName,parent_build_run_id:(state.validationPrefillDraft||{}).parentBuildRunId||state.linkedValidationParent,target_space_id:formValue('validateSpace'),api_name:normalizeApiName(formValue('validateApi')||'/generate'),expected_output_type:formValue('expectedOutput')||'any',test_args_json:prettyJson(args),test_kwargs_json:prettyJson(kwargs),live_timeout_seconds:validationTimeoutValue()};const result=await apiPost('/api/validate',payload);state.validationPrefillDraft=null;state.validationArgsDirty=false;state.validationMode='running';renderValidationLaunchResult(result);startValidationPolling(result.run_id);showMessage(`Validation launched: ${result.run_id}`,'success');loadRuns(true)}catch(e){showMessage(e.message,true)}finally{setBusy(false);setButtonBusy('launchValidate',false)}}
+async function launchValidate(){const formError=validateValidationForm();if(formError){showMessage(formError,true);return}setBusy(true,'Launching validation Job…');setButtonBusy('launchValidate',true,'Launching…');try{const args=parseJsonField('testArgs',[]);const kwargs=parseJsonField('testKwargs',{});const draft=state.validationPrefillDraft||{};const apiForLaunch=draft.requiresEndpointDiscovery?'':normalizeApiName(formValue('validateApi')||'/generate');const payload={bucket_name:state.bucketName,parent_build_run_id:draft.parentBuildRunId||state.linkedValidationParent,target_space_id:formValue('validateSpace'),api_name:apiForLaunch,expected_output_type:formValue('expectedOutput')||'any',test_args_json:prettyJson(args),test_kwargs_json:prettyJson(kwargs),live_timeout_seconds:validationTimeoutValue()};const result=await apiPost('/api/validate',payload);state.validationPrefillDraft=null;state.validationArgsDirty=false;state.validationMode='running';renderValidationLaunchResult(result);startValidationPolling(result.run_id);showMessage(`Validation launched: ${result.run_id}`,'success');loadRuns(true)}catch(e){showMessage(e.message,true)}finally{setBusy(false);setButtonBusy('launchValidate',false)}}
 async function refreshRunReportPreview(runId){
   if(!runId)return;
   try{
@@ -967,11 +1008,12 @@ function readRunLatencyPayload(p={}){
   const latency=firstPositiveNumber(smoke.latency_seconds,smoke.observed_latency_seconds,summary.latency_seconds,summary.observed_latency_seconds,p.latency_seconds,p.observed_latency_seconds,manual.latency_seconds,manual.observed_latency_seconds,eventLatency);
   const duration=firstPositiveNumber(smoke.recommended_zerogpu_duration_seconds,smoke.recommended_zero_gpu_duration_seconds,smoke.recommended_duration_seconds,summary.recommended_zerogpu_duration_seconds,summary.recommended_zero_gpu_duration_seconds,summary.recommended_duration_seconds,manual.recommended_zero_gpu_duration_seconds,gate.recommended_zerogpu_duration_seconds,gate.recommended_zero_gpu_duration_seconds,gate.zero_gpu_duration_recommendation,eventDuration);
   const source=smoke.recommendation_source||summary.recommendation_source||manual.recommendation_source||gate.recommendation_source||(manual.status==='success'?'linked Space Test':'')||(eventLatency?'generation_smoke event':'');
+  const hardware=manual.hardware_used_for_validation||manual.recommendation_hardware||summary.hardware_used_for_validation||summary.recommendation_hardware||p.hardware_used_for_validation||p.recommendation_hardware||p.state?.selected_hardware||summary.selected_hardware||'';
   const failureType=smoke.failure_type||validation.failure_type||gate.failure_type||'';
   const failureOwner=smoke.failure_owner||validation.failure_owner||gate.failure_owner||'';
   const missingArgument=smoke.missing_argument||validation.missing_argument||gate.missing_argument||'';
   const error=smoke.error||smoke.message||validation.failure_reason||gate.message||'';
-  return {smoke,gate,latency,duration,source,failureType,failureOwner,missingArgument,error};
+  return {smoke,gate,latency,duration,source,hardware,failureType,failureOwner,missingArgument,error};
 }
 function smokeFailureLatencyNote({smoke={},failureType='',failureOwner='',missingArgument='',error=''}={}){
   const status=String(smoke.status||'').toLowerCase();
@@ -996,7 +1038,7 @@ function renderActiveLatency(p={}){
   const runId=String(p.run_id||p.summary?.run_id||state.runId||'');
   state.latencyCache=state.latencyCache||{};
   const payload=readRunLatencyPayload(p);
-  const {latency,duration,source}=payload;
+  const {latency,duration,source,hardware}=payload;
   const hasLatency=Number.isFinite(latency)&&latency>0;
   const hasDuration=Number.isFinite(duration)&&duration>0;
   const cached=state.latencyCache[runId]||{};
@@ -1006,7 +1048,8 @@ function renderActiveLatency(p={}){
   const finalBlocker=p.build_error_observation?' Final blocker: build error after repair.':'';
   const failedWithoutSmoke=(runStatus==='failed'||runStatus==='error')&&!hasLatency;
   const failureNote=smokeFailureLatencyNote(payload)||(failedWithoutSmoke?`Not measured because live validation did not reach a successful generation smoke test.${finalBlocker}`:'');
-  const stableSource=hasLatency?(source||'live smoke test'):(failureNote?'not measured: smoke failed':(cached.source||'measured when smoke test passes'));
+  const hardwareSuffix=hardware&&String(hardware).toLowerCase()!=='unknown'?` on ${hardware}`:'';
+  const stableSource=hasLatency?`${source||'live smoke test'}${hardwareSuffix}`:(failureNote?'not measured: smoke failed':(cached.source||'measured when smoke test passes'));
   if(hasLatency||hasDuration)state.latencyCache[runId]={latency:stableLatency,duration:stableDuration,source:stableSource};
   const finalHasLatency=Number.isFinite(stableLatency)&&stableLatency>0;
   const finalHasDuration=Number.isFinite(stableDuration)&&stableDuration>0;
@@ -1016,7 +1059,7 @@ function renderActiveLatency(p={}){
   const note=$('activeLatencyNote');
   if(note){
     note.textContent=finalHasDuration
-      ? 'This measured latency is normally used to tune the `@spaces.GPU(duration=...)` decorator for ZeroGPU when the generated Space uses ZeroGPU.'
+      ? `This measured latency is normally used to tune the \`@spaces.GPU(duration=...)\` decorator for ZeroGPU when the generated Space uses ZeroGPU. Source hardware: ${hardware||'not recorded'}.`
       : (failureNote||'When available, the live smoke-test latency is used to recommend the `@spaces.GPU(duration=...)` value for ZeroGPU apps.');
   }
   card.classList.toggle('has-latency',finalHasLatency);
@@ -1077,7 +1120,7 @@ function markPendingActiveFields(){
     el.classList.toggle('is-pending',pending);
   });
 }
-function renderMetrics(p){const root=$('metricsList');const {smoke,gate,latency,duration}=readRunLatencyPayload(p);const health=(gate.implementation_signals&&gate.implementation_signals.health_passed)||smoke.health_passed;const smokeOk=smoke.ok||smoke.status==='success';renderActiveLatency(p);if(!root)return;root.innerHTML=`<li><span>/health</span><strong class="${health?'metric-ok':''}">${health?'passed':'pending'}</strong></li><li><span>/generate smoke test</span><strong class="${smokeOk?'metric-ok':'metric-warn'}">${smokeOk?'passed':(smoke.status||'pending')}</strong></li><li><span>Latency</span><strong>${Number.isFinite(latency)&&latency>0?formatLatencySeconds(latency):'—'}</strong></li><li><span>Recommended ZeroGPU duration</span><strong>${Number.isFinite(duration)&&duration>0?fmtSeconds(Math.round(duration)):'—'}</strong></li>`}
+function renderMetrics(p){const root=$('metricsList');const {smoke,gate,latency,duration,source,hardware}=readRunLatencyPayload(p);const health=(gate.implementation_signals&&gate.implementation_signals.health_passed)||smoke.health_passed;const smokeOk=smoke.ok||smoke.status==='success';renderActiveLatency(p);if(!root)return;const provenance=[source||'',hardware?`hardware ${hardware}`:''].filter(Boolean).join(' · ');root.innerHTML=`<li><span>/health</span><strong class="${health?'metric-ok':''}">${health?'passed':'pending'}</strong></li><li><span>/generate smoke test</span><strong class="${smokeOk?'metric-ok':'metric-warn'}">${smokeOk?'passed':(smoke.status||'pending')}</strong></li><li><span>Latency</span><strong>${Number.isFinite(latency)&&latency>0?formatLatencySeconds(latency):'—'}</strong></li><li><span>Recommended ZeroGPU duration</span><strong>${Number.isFinite(duration)&&duration>0?fmtSeconds(Math.round(duration)):'—'}</strong>${provenance?`<em>${escapeHtml(provenance)}</em>`:''}</li>`}
 function renderEvents(events){const root=$('eventsPanel');if(!root)return;try{const rows=Array.isArray(events)?events:[];root.textContent=rows.slice(-12).map(e=>`${e?.ts||''}  ${e?.step||''}  ${e?.status||''}  ${e?.message||''}`).join('\n')||'No events yet. The run may still be scheduling.'}catch(e){console.warn('renderEvents failed',e);root.textContent='Events could not be rendered.'}}
 async function cancelActiveRun(){
   if(!state.runId){showMessage('Select a running run before cancelling.', 'warning');return}
@@ -1135,6 +1178,7 @@ function bindActions(){
     enableEvalArchive:enableEvalArchive,
     verifyEvalArchive:verifyEvalArchive,
     disableEvalArchive:disableEvalArchive,
+    flushEvalArchive:flushEvalArchive,
     refreshRuns:()=>loadRuns(true),
     refreshRunsHome:()=>loadRuns(true),
     cancelRun:cancelActiveRun,
@@ -1158,3 +1202,7 @@ bindNavigation();bindActions();bindRunFilters();bindValidationDraftInputs();setT
 // 'Eval archive off · set env vars'
 // Anonymous project eval archive enabled:
 // Env override remains supported for backend publishing: ASF_EVAL_ENABLED=true, ASF_EVAL_BUCKET_SOURCE=<namespace>/<bucket>, ASF_EVAL_BUCKET_PATH=evals, ASF_EVAL_BUCKET_MOUNT=/evals.
+/* v190.19 legacy invariant strings:
+setText('spaceTestOutput',prefill.automaticSmokePassed?'Replay linked smoke test':'New linked validation')
+parent_build_run_id:(state.validationPrefillDraft||{}).parentBuildRunId
+*/

web/static/progress.js

@@ -929,13 +929,16 @@ function renderDiagnostics(d={},header={}){
   if(rules)rules.innerHTML=(d.zerogpu_rules||[]).map(r=>`<li class="${statusClass(r.status)}"><span>${escapeHtml(r.label)}</span><strong>${escapeHtml(r.status||'pending')}</strong></li>`).join('');
 }
 function renderSpaceTestPreview(s={}){
+  const policy=s.policy||s.space_test_policy||{};
+  const status=policy.mode||s.status||'pending';
   const st=$('spaceTestStatus');
   if(st){
-    st.textContent=badgeLabel(s.status||'pending');
-    st.className='badge '+statusClass(s.status);
+    st.textContent=policy.label||badgeLabel(status);
+    st.className='badge '+(policy.enabled?statusClass(status):'neutral');
   }
-  setText('spaceTestOutput',s.output_artifact||s.endpoint||'Waiting for API test');
-  setText('spaceTestVerdict',s.verdict||'pending');
+  const endpointLabel=policy.requires_endpoint_discovery?'Endpoint discovery required':(s.output_artifact||s.endpoint||policy.endpoint||'Waiting for API test');
+  setText('spaceTestOutput',endpointLabel);
+  setText('spaceTestVerdict',policy.message||s.verdict||'pending');
 }
 function animateProgressBar(progress,status,currentStep){
   const fill=$('progressFill');

web/static/runs.js

@@ -1,7 +1,11 @@
+function safeRunObject(run){return run&&typeof run==='object'?run:{}}
+function validRunObject(run){return Boolean(run&&typeof run==='object'&&(run.run_id||run.summary?.run_id||run.state?.run_id));}
+function validRunsList(runs=[]){return (Array.isArray(runs)?runs:[]).filter(validRunObject);}
 function inferredOwnerFromBucket(bucket){return bucket?String(bucket).split('/')[0]:''}
 function inferredJobUrl(summary={}, detail={}){if(summary.job_url)return summary.job_url;const launch=detail.launch||{};const stateObj=detail.state||{};if(launch.job_url)return launch.job_url;if(stateObj.job_url)return stateObj.job_url;const jobId=summary.job_id||launch.job_id||stateObj.job_id;const owner=summary.created_by||summary.username||summary.owner||launch.created_by||launch.username||launch.owner||stateObj.created_by||stateObj.username||stateObj.owner||state.user?.username||inferredOwnerFromBucket(summary.bucket_source||detail.bucket_source||state.bucketSource);return jobId&&owner?`https://huggingface.co/jobs/${owner}/${jobId}`:''}
 function bucketRunFileUrl(bucket,runId,relPath=''){const rel=String(relPath||'').replace(/^\/+|\/+$/g,'');return bucket&&runId?`https://huggingface.co/buckets/${bucket}/tree/runs/${runId}${rel?`/${rel}`:''}`:''}
 function runValidationTerminalText(run={}){
+  run=safeRunObject(run);
   return [
     run.verdict,run.validation_status,run.result_status,run.final_status,run.status,run.summary?.verdict,run.summary?.validation_status,run.summary?.result_status,run.summary?.status,
     run.state?.verdict,run.state?.validation_status,run.state?.result_status,run.state?.status,run.gate_status,run.summary?.gate_status,run.inference_gate?.status,
@@ -9,11 +13,13 @@ function runValidationTerminalText(run={}){
   ].map(x=>String(x||'').toLowerCase()).filter(Boolean).join(' ');
 }
 function validationLockedStatus(run={}){
+  run=safeRunObject(run);
   const runId=run.run_id||run.summary?.run_id||run.state?.run_id||'';
   const terminal=runId&&typeof state!=='undefined'&&state.validationTerminalByRun?state.validationTerminalByRun[runId]:null;
   return terminal?.canonical||'';
 }
 function runCanonicalStatus(run={}){
+  run=safeRunObject(run);
   const validation=isValidationRunSummary(run);
   const locked=validation?validationLockedStatus(run):'';
   if(locked)return locked;
@@ -32,7 +38,7 @@ function runCanonicalStatus(run={}){
   if(text.includes('running')||text.includes('queued')||text.includes('pending')||text.includes('started')||text.includes('waiting')||text.includes('building'))return'running';
   return s||'unknown';
 }
-function runMatchesStatus(run,status){const canon=runCanonicalStatus(run);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';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()}
+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 canonicalStatusForDeletion(context={}){
   const kind=context.kind==='validation'?'validation':'active';
   const detail=context.detail||{};
@@ -41,8 +47,9 @@ function canonicalStatusForDeletion(context={}){
   if(kind==='validation'&&typeof runCanonicalStatus==='function')return runCanonicalStatus(merged);
   return String(merged.status||merged.summary?.status||merged.state?.status||'unknown').toLowerCase();
 }
-function runMatchesQuery(run,query){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 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||'';
   const ts=Date.parse(raw);
   if(Number.isFinite(ts))return ts;
@@ -55,7 +62,7 @@ function runSortTimestamp(run={}){
   return 0;
 }
 function sortRunsNewestFirst(runs=[]){
-  return [...(runs||[])].sort((a,b)=>runSortTimestamp(b)-runSortTimestamp(a)||String(b.run_id||'').localeCompare(String(a.run_id||'')));
+  return [...validRunsList(runs)].sort((a,b)=>runSortTimestamp(b)-runSortTimestamp(a)||String(b.run_id||'').localeCompare(String(a.run_id||'')));
 }
 function filteredRuns(){
   const query=state.runSearch||'';
@@ -92,6 +99,7 @@ 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';
@@ -160,12 +168,14 @@ function runSecondaryLine(run={}){
   const manual=buildManualValidationStatus(run);
   const manualText=manual.passed?'Manual validation passed':manual.failed?'Manual validation attempted':'';
   const linkedText=manual.linkedCount?`${manual.linkedCount} linked test${manual.linkedCount===1?'':'s'}`:'';
-  const parts=[manualText,linkedText,run.target_space,mode?'Goal: '+implementationModeLabel(mode,{short:true}):'',run.selected_hardware].filter(Boolean);
+  const policy=runSpaceTestPolicy(run);
+  const policyText=policy.mode==='complete'?'Can complete with Space Test':policy.mode==='recover'?'Can recover with Space Test':policy.mode==='blocked'?policy.label:'';
+  const parts=[manualText,linkedText,policyText,run.target_space,mode?'Goal: '+implementationModeLabel(mode,{short:true}):'',run.selected_hardware].filter(Boolean);
   return parts.join(' • ');
 }
 function runCardMeta(run={}){return runSecondaryLine(run)}
 function renderRunRows(runs,compact=false){
-  return (runs||[]).map(r=>{
+  return validRunsList(runs||[]).map(r=>{
     const validation=isValidationRunSummary(r);
     const kind=runCardKind(r);
     // const status=runCanonicalStatus(r)||r.status||'unknown'
@@ -219,16 +229,34 @@ function renderRunPagination(total){
   root.innerHTML=`<button class="secondary small" data-page-action="prev" ${state.runPage<=0?'disabled':''}>‹</button><span>Page ${state.runPage+1} / ${pages}</span><button class="secondary small" data-page-action="next" ${state.runPage>=pages-1?'disabled':''}>›</button>`;
 }
 
-function isValidationRunSummary(run={}){return isValidationRunDetail({summary:run,state:run,kind:run.kind,run_type:run.run_type})}
+function isValidationRunSummary(run={}){run=safeRunObject(run);return isValidationRunDetail({summary:run,state:run,kind:run.kind,run_type:run.run_type})}
+function isLinkedValidationRun(run={}){return isValidationRunSummary(run)&&Boolean(linkedValidationParentId(run));}
+function isLegacyValidationRun(run={}){return isValidationRunSummary(run)&&!linkedValidationParentId(run);}
 
 function linkedValidationParentId(run={}){
+  run=safeRunObject(run);
   return run.parent_build_run_id||run.parentBuildRunId||run.summary?.parent_build_run_id||run.state?.parent_build_run_id||'';
 }
 function linkedValidationsForBuild(buildRunId){
   if(!buildRunId)return [];
-  return (state.runsCache||[]).filter(r=>isValidationRunSummary(r)&&linkedValidationParentId(r)===buildRunId);
+  return validRunsList(state.runsCache||[]).filter(r=>isLinkedValidationRun(r)&&linkedValidationParentId(r)===buildRunId);
 }
+function linkedValidationDeleteSummary(runId,detail={}){
+  const id=runId||detail.run_id||detail.summary?.run_id||'';
+  const rows=linkedValidationsForBuild(id);
+  return {count:rows.length,ids:rows.map(r=>r.run_id||r.summary?.run_id).filter(Boolean)};
+}
+function runSpaceTestPolicy(run={}){
+  run=safeRunObject(run);
+  return run.space_test_policy||run.summary?.space_test_policy||run.view?.space_test_policy||run.space_test?.policy||{};
+}
+function runNeedsLinkedValidation(run={}){
+  const policy=runSpaceTestPolicy(run);
+  return ['complete','recover'].includes(String(policy.mode||'').toLowerCase())&&policy.enabled!==false&&!buildManualValidationStatus(run).passed;
+}
+
 function buildManualValidationStatus(run={}){
+  run=safeRunObject(run);
   const explicit=run.manual_validation_status||run.summary?.manual_validation_status||{};
   const linked=linkedValidationsForBuild(run.run_id).filter(v=>!runMatchesStatus(v,'running'));
   const passed=Boolean(run.manual_validation_passed||run.summary?.manual_validation_passed||explicit.status==='success'||linked.some(v=>runMatchesStatus(v,'full_inference_success')));
@@ -237,21 +265,25 @@ function buildManualValidationStatus(run={}){
   return {passed,failed,linkedCount:linked.length,latest,explicit};
 }
 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';
   return runCanonicalStatus(run);
 }
 function explorerPrimaryRuns(){
-  return (state.runsCache||[]).filter(r=>!isValidationRunSummary(r));
+  return validRunsList(state.runsCache||[]).filter(r=>!isValidationRunSummary(r));
 }
-function runStatTime(run={}){const raw=run.updated_at||run.created_at||run.started_at||run.cancelled_at||'';return raw?formatTime(raw):'—'}
+function runStatTime(run={}){run=safeRunObject(run);const raw=run.updated_at||run.created_at||run.started_at||run.cancelled_at||'';return raw?formatTime(raw):'—'}
 function runStatLatency(run={}){
+  run=safeRunObject(run);
   const latency=run.latency_seconds||run.observed_latency_seconds||run.generation_smoke?.latency_seconds||run.generation_smoke?.observed_latency_seconds;
   return latency?fmtSeconds(Number(latency)):'';
 }
 function runStatLatencyValue(run={}){
+  run=safeRunObject(run);
   const latency=run.latency_seconds||run.observed_latency_seconds||run.generation_smoke?.latency_seconds||run.generation_smoke?.observed_latency_seconds;
   const n=Number(latency);
   return Number.isFinite(n)&&n>0?n:null;
@@ -266,12 +298,13 @@ function percentile(values=[],p=0.5){
 }
 function pct(part,total){return total?`${Math.round((part/total)*100)}%`:'—'}
 function runStatsIssueCounts(runs=[]){
+  runs=validRunsList(runs);
   const counts={failed_builds:0,failed_linked_tests:0,manual_hardware:0,pi_model_mismatch:0,stale:0};
   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')) validation?counts.failed_linked_tests++:counts.failed_builds++;
+    if(runMatchesStatus(r,'failed')){if(validation&&isLinkedValidationRun(r))counts.failed_linked_tests++;else if(!validation)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++;
@@ -284,15 +317,17 @@ function runStatsCell(label,value,detail='',tone='neutral'){
 function renderRunAggregateStats(){
   const root=$('runStatsList');
   if(!root)return;
-  const runs=state.runsCache||[];
+  const runs=validRunsList(state.runsCache||[]);
   const builds=runs.filter(r=>!isValidationRunSummary(r));
-  const validations=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 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;
   // 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;
@@ -325,6 +360,7 @@ function renderRunAggregateStats(){
       ${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')}
+      ${runStatsCell('Recovered',String(recoveredBuilds),`${needsValidation} need validation/recovery`,recoveredBuilds?'success':needsValidation?'warn':'neutral')}
     </div>
     <div class="run-stats-band linked-tests-band">
       <span>Linked Space Tests</span>
@@ -358,11 +394,12 @@ function forgetRunEverywhere(runId){
   }
   if(state.documentCache)delete state.documentCache[runId];
   if(state.latencyCache)delete state.latencyCache[runId];
-  state.runsCache=(state.runsCache||[]).filter(r=>r.run_id!==runId);
+  // Legacy invariant: state.runsCache=(state.runsCache||[]).filter(r=>r.run_id!==runId)
+  state.runsCache=validRunsList(state.runsCache||[]).filter(r=>(r.run_id||r.summary?.run_id)!==runId);
   document.querySelectorAll(`.run-row[data-run="${CSS.escape(runId)}"]`).forEach(row=>row.remove());
 }
 function activeRunIds(){
-  return new Set((state.runsCache||[]).map(r=>r.run_id).filter(Boolean));
+  return new Set(validRunsList(state.runsCache||[]).map(r=>r.run_id||r.summary?.run_id).filter(Boolean));
 }
 
 function associatedSpaceFromDetail(detail={},summaryOverride={}){
@@ -409,7 +446,7 @@ function bindRunRowEvents(root){
   });
 }
 function renderRunsFromCache(){
-  state.runsCache=sortRunsNewestFirst(state.runsCache||[]);
+  state.runsCache=sortRunsNewestFirst(validRunsList(state.runsCache||[]));
   const runs=filteredRuns();
   const perPage=state.runsPerPage||5;
   state.runPage=Math.min(Math.max(0,state.runPage||0),Math.max(0,Math.ceil(runs.length/perPage)-1));
@@ -431,7 +468,7 @@ function renderRunsFromCache(){
 
 function mergeRunExplorerTerminalLocks(runs=[]){
   if(typeof state==='undefined'||!state.validationTerminalByRun)return runs||[];
-  return (runs||[]).map(run=>{
+  return validRunsList(runs).map(run=>{
     const validation=isValidationRunSummary(run);
     const runId=run.run_id||run.summary?.run_id||'';
     const terminal=validation&&runId?state.validationTerminalByRun[runId]:null;
@@ -439,10 +476,11 @@ function mergeRunExplorerTerminalLocks(runs=[]){
     return {...run,status:terminal.canonical,validation_status:terminal.canonical,result_status:terminal.canonical,summary:{...(run.summary||{}),status:terminal.canonical,validation_status:terminal.canonical,result_status:terminal.canonical}};
   });
 }
-async function loadRuns(forceNetwork=false){const stale=Date.now()-(state.runsLastLoaded||0)>45000;const shouldFetch=forceNetwork||!state.runsCache.length||stale;if(!shouldFetch){renderRunsFromCache();return state.runsCache||[]}if(state.runsLoadPromise&&!forceNetwork)return state.runsLoadPromise;document.querySelectorAll('.runs-panel,.full-runs-panel').forEach(x=>x.classList.add('is-refreshing'));state.runsLoadPromise=apiGet(`/api/runs?limit=100&bucket_name=${encodeURIComponent(state.bucketName)}`).then(data=>{state.runsCache=sortRunsNewestFirst(mergeRunExplorerTerminalLocks((data.runs||[]).filter(r=>!isRunLocallyDeleted(r.run_id))));state.runsLastLoaded=Date.now();if(data.bucket_source)state.bucketSource=data.bucket_source;renderRunsFromCache();return state.runsCache}).catch(e=>{for(const id of ['runsTable','runsTableHome']){const root=$(id);if(root)root.textContent='Could not load runs: '+e.message}if(forceNetwork)console.warn(e);return state.runsCache||[]}).finally(()=>{state.runsLoadPromise=null;document.querySelectorAll('.runs-panel,.full-runs-panel').forEach(x=>x.classList.remove('is-refreshing'))});return state.runsLoadPromise}
+async function loadRuns(forceNetwork=false){const stale=Date.now()-(state.runsLastLoaded||0)>45000;const shouldFetch=forceNetwork||!state.runsCache.length||stale;if(!shouldFetch){renderRunsFromCache();return state.runsCache||[]}if(state.runsLoadPromise&&!forceNetwork)return state.runsLoadPromise;document.querySelectorAll('.runs-panel,.full-runs-panel').forEach(x=>x.classList.add('is-refreshing'));state.runsLoadPromise=apiGet(`/api/runs?limit=100&bucket_name=${encodeURIComponent(state.bucketName)}`).then(data=>{// Legacy invariant: .filter(r=>!isRunLocallyDeleted(r.run_id))
+  state.runsCache=sortRunsNewestFirst(mergeRunExplorerTerminalLocks(validRunsList(data.runs||[]).filter(r=>!isRunLocallyDeleted(r.run_id||r.summary?.run_id))));state.runsLastLoaded=Date.now();if(data.bucket_source)state.bucketSource=data.bucket_source;renderRunsFromCache();return state.runsCache}).catch(e=>{for(const id of ['runsTable','runsTableHome']){const root=$(id);if(root)root.textContent='Could not load runs: '+e.message}if(forceNetwork)console.warn(e);return state.runsCache||[]}).finally(()=>{state.runsLoadPromise=null;document.querySelectorAll('.runs-panel,.full-runs-panel').forEach(x=>x.classList.remove('is-refreshing'))});return state.runsLoadPromise}
 function cachedRunById(runId){
   if(isRunLocallyDeleted(runId))return null;
-  return (state.runsCache||[]).find(r=>r.run_id===runId)||null;
+  return validRunsList(state.runsCache||[]).find(r=>(r.run_id||r.summary?.run_id)===runId)||null;
 }
 function optimisticDetailFromSummary(summary={}){
   if(!summary)return null;
@@ -506,13 +544,13 @@ function upsertRunExplorerFromProgress(p={}){
     effective_status:p.summary?.effective_status||p.manual_validation_status?.effective_status,
     bucket_source:p.bucket_source||p.summary?.bucket_source||state.bucketSource,
   };
-  state.runsCache=state.runsCache||[];
-  const idx=state.runsCache.findIndex(r=>r.run_id===runId);
+  state.runsCache=validRunsList(state.runsCache||[]);
+  const idx=state.runsCache.findIndex(r=>(r.run_id||r.summary?.run_id)===runId);
   if(idx>=0)state.runsCache[idx]={...state.runsCache[idx],...summary};
   else state.runsCache.unshift(summary);
   const parentId=summary.parent_build_run_id||linkedValidationParentId(summary);
   if(parentId&&isValidationRunSummary(summary)){
-    const parentIdx=state.runsCache.findIndex(r=>r.run_id===parentId);
+    const parentIdx=state.runsCache.findIndex(r=>(r.run_id||r.summary?.run_id)===parentId);
     if(parentIdx>=0){
       const passed=runMatchesStatus(summary,'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};
@@ -733,12 +771,13 @@ function confirmRunDeletion({runId,kind='active',status='',detail={}}={}){
     const label=kind==='validation'?'validation run':'build run';
     const associatedSpace=associatedSpaceFromDetail(detail,detail.summary||{});
     const canDeleteSpace=runCanOfferSpaceDeletion(kind,detail,detail.summary||{});
+    const linkedDelete=kind==='validation'?{count:0,ids:[]}:linkedValidationDeleteSummary(runId,detail);
     kicker.textContent=kind==='validation'?'Space Test deletion':'Build run deletion';
     title.textContent=`Delete this ${label}?`;
     body.textContent=kind==='validation'
-      ? 'This removes only this validation run’s bucket artifacts, logs, state, traces and report. The tested Space will not be deleted.'
-      : 'This removes its bucket artifacts, logs, state, traces and report. The generated Space is kept unless you explicitly choose to delete it below.';
-    meta.innerHTML=`<span><strong>Run</strong><code>${escapeHtml(runId||'—')}</code></span><span><strong>Type</strong>${escapeHtml(kind==='validation'?'Space Test':'Build')}</span><span><strong>Status</strong>${escapeHtml(badgeLabel(normalized))}</span>${associatedSpace?`<span><strong>Space</strong><code>${escapeHtml(associatedSpace)}</code></span>`:''}`;
+      ? 'This removes only this validation run’s linked Space Test artifacts. The parent Build Run and generated Space will not be deleted. The tested Space will not be deleted.'
+      : (linkedDelete.count?`This removes this Build Run’s bucket artifacts and ${linkedDelete.count} linked Space Test validation run${linkedDelete.count===1?'':'s'}. The generated Space is kept unless you explicitly choose to delete it below.`:'This removes this Build Run’s bucket artifacts, logs, state, traces and report. The generated Space is kept unless you explicitly choose to delete it below.');
+    meta.innerHTML=`<span><strong>Run</strong><code>${escapeHtml(runId||'—')}</code></span><span><strong>Type</strong>${escapeHtml(kind==='validation'?'Linked Space Test':'Build')}</span><span><strong>Status</strong>${escapeHtml(badgeLabel(normalized))}</span>${associatedSpace?`<span><strong>Space</strong><code>${escapeHtml(associatedSpace)}</code></span>`:''}${linkedDelete.count?`<span><strong>Linked tests</strong>${linkedDelete.count}</span>`:''}`;
     if(spaceOption&&spaceCheckbox&&spaceLabel){
       spaceCheckbox.checked=false;
       spaceOption.hidden=!canDeleteSpace;
@@ -768,7 +807,7 @@ function confirmRunDeletion({runId,kind='active',status='',detail={}}={}){
     const setDeleting=()=>{
       modal.classList.add('is-deleting');
       title.textContent=kind==='validation'?'Deleting this validation run…':'Deleting this run…';
-      body.textContent='Removing bucket artifacts. The panel will reset as soon as deletion is confirmed.';
+      body.textContent=kind==='validation'?'Removing linked validation artifacts and refreshing the parent Build Run.':'Removing bucket artifacts and linked validation runs. The panel will reset as soon as deletion is confirmed.';
       confirmBtn.textContent='Deleting…';
       confirmBtn.disabled=true;
       cancelEls.forEach(el=>{el.disabled=true;el.setAttribute('aria-disabled','true')});
@@ -779,8 +818,8 @@ function confirmRunDeletion({runId,kind='active',status='',detail={}}={}){
       submitted=false;
       title.textContent=`Delete this ${label}?`;
       body.textContent=kind==='validation'
-        ? 'This removes only this validation run’s bucket artifacts, logs, state, traces and report. The tested Space will not be deleted.'
-        : 'This removes its bucket artifacts, logs, state, traces and report. The generated Space is kept unless you explicitly choose to delete it below.';
+        ? 'This removes only this validation run’s linked Space Test artifacts. The parent Build Run and generated Space will not be deleted. The tested Space will not be deleted.'
+        : (linkedDelete.count?`This removes this Build Run’s bucket artifacts and ${linkedDelete.count} linked Space Test validation run${linkedDelete.count===1?'':'s'}. The generated Space is kept unless you explicitly choose to delete it below.`:'This removes this Build Run’s bucket artifacts, logs, state, traces and report. The generated Space is kept unless you explicitly choose to delete it below.');
       confirmBtn.textContent=active?'Delete stored files':'Delete run';
       confirmBtn.disabled=false;
       cancelEls.forEach(el=>{el.disabled=false;el.removeAttribute('aria-disabled')});
@@ -815,12 +854,16 @@ async function deleteRunById(runId,options={}){
   let success=false;
   try{
     const result=await apiDelete(`/api/runs/${encodeURIComponent(runId)}?bucket_name=${encodeURIComponent(state.bucketName)}`,deleteSpace?{delete_space:true}:{});
+    const deletedChildren=Array.isArray(result.deleted_linked_validations)?result.deleted_linked_validations:[];
+    const childSuffix=deletedChildren.length?` and ${deletedChildren.length} linked validation${deletedChildren.length===1?'':'s'}`:'';
     const suffix=deleteSpace?(result.space_deleted?' and associated Space':(result.space_delete_error?' but Space deletion failed':' and Space was already missing')):'';
-    showMessage(`Deleted run ${runId}${suffix}`,'success');
+    showMessage(`Deleted run ${runId}${childSuffix}${suffix}`,'success');
     success=true;
     rememberDeletedRun(runId);
+    deletedChildren.forEach(id=>rememberDeletedRun(id));
     clearDeletedRunState(runId,context.kind);
     forgetRunEverywhere(runId);
+    deletedChildren.forEach(id=>{clearDeletedRunState(id,'validation');forgetRunEverywhere(id);});
     renderRunsFromCache();
     if(confirmed&&typeof confirmed.close==='function')confirmed.close(true);
     loadRuns(true).catch(e=>console.warn('post-delete runs refresh failed',e));
@@ -1192,12 +1235,16 @@ function renderEvalArchiveStatus(detail={}){
   const path=status.archive_relative_path||status.path||'';
   const localLabel=(status.local_record_found||Object.keys(local||{}).length)?'written':'pending';
   const backendLabel=published?'published':attempted&&reason==='record_not_ready'?'pending':attempted?'not published':'pending';
+  const manual=detail.manual_validation_status||detail.summary?.manual_validation_status||detail.view?.manual_validation||{};
+  const effective=manual.status==='success'?'validated_after_manual_space_test':(detail.summary?.effective_status||detail.effective_status||'');
   const intro=published?'Eval record copied to the operator archive bucket.':attempted&&reason==='record_not_ready'?'Eval record will be archived when the run completes.':'Archive publication is not confirmed yet.';
-  body.innerHTML=`<p>${escapeHtml(intro)}</p><div class="eval-archive-grid"><div><span>Local record</span><strong>${escapeHtml(localLabel)}</strong></div><div><span>Backend copy</span><strong>${escapeHtml(backendLabel)}</strong></div><div><span>Mode</span><strong>${escapeHtml(status.publish_mode||status.mode||'backend')}</strong></div><div><span>Archive bucket</span><strong>${escapeHtml(bucket||'—')}</strong></div></div>${path?`<code>${escapeHtml(path)}</code>`:''}${reason&&!published&&reason!=='record_not_ready'?`<p class="eval-warning">${escapeHtml(reason)}</p>`:''}`;
+  const effectiveNote=effective?`<p class="eval-effective-note">Effective verdict: <strong>${escapeHtml(runCompactStatusLabel(effective))}</strong>${manual.validation_run_id?` from linked Space Test <code>${escapeHtml(manual.validation_run_id)}</code>`:''}.</p>`:'';
+  body.innerHTML=`<p>${escapeHtml(intro)}</p>${effectiveNote}<div class="eval-archive-grid"><div><span>Local record</span><strong>${escapeHtml(localLabel)}</strong></div><div><span>Backend copy</span><strong>${escapeHtml(backendLabel)}</strong></div><div><span>Mode</span><strong>${escapeHtml(status.publish_mode||status.mode||'backend')}</strong></div><div><span>Archive bucket</span><strong>${escapeHtml(bucket||'—')}</strong></div></div>${path?`<code>${escapeHtml(path)}</code>`:''}${reason&&!published&&reason!=='record_not_ready'?`<p class="eval-warning">${escapeHtml(reason)}</p>`:''}`;
 }
 function renderRunDetail(detail){
   state.selectedRunDetail=detail;
   const summary=detail.summary||{};
+  if(typeof contextualizeSpaceTestFromBuildRun==='function')contextualizeSpaceTestFromBuildRun(detail);
   const smoke=detail.generation_smoke||{};
   const files=detail.files||[];
   const view=detail.view||{};
@@ -1248,3 +1295,5 @@ function renderRunDetail(detail){
 // Legacy clean-delete invariant: await loadRuns(true) was intentionally replaced by post-delete background refresh in v190.9.
 
 // Legacy validation preview invariant: if(isValidationRunDetail(detail)){showValidationRunDetail(detail)
+
+// v190.15 build-first compatibility invariant: legacy/incomplete Build Runs stay visible, validation runs require parent_build_run_id before they can affect parent stats.

web/static/styles.css

@@ -0,0 +1,14 @@
+
+/* v190.19 eval archive owner controls */
+.eval-archive-actions .eval-flush-button{
+  margin-left:auto;
+}
+.eval-archive-panel.manageable .eval-archive-actions{
+  gap:10px;
+  align-items:center;
+  flex-wrap:wrap;
+}
+.eval-effective-note{
+  margin:.45rem 0 .55rem;
+  line-height:1.35;
+}