Upload 15 files

src/bucket.py

@@ -1285,7 +1285,19 @@ def summarize_run_bundle(run_id: str, bundle: dict[str, Any], *, bucket_source:
     gate = bundle.get("inference_gate") or {}
     smoke = bundle.get("generation_smoke") or {}
     hardware = bundle.get("hardware_strategy") or {}
-    manual_validation = bundle.get("post_build_validation_status") or bundle.get("manual_validation_status") or {}
+    post_build_validation = bundle.get("post_build_validation_status") or {}
+    manual_validation = post_build_validation or bundle.get("manual_validation_status") or {}
+    linked_validations = bundle.get("linked_validations") or {}
+    linked_rows = linked_validations.get("validations") if isinstance(linked_validations, dict) else []
+    if isinstance(linked_rows, list):
+        linked_successes = [row for row in linked_rows if isinstance(row, dict) and str(row.get("status") or row.get("effective_status") or "").lower() in {"success", "passed", "succeeded", "full_inference_success", "validated_after_space_test", "validated_after_manual_space_test"}]
+        if linked_successes and str(manual_validation.get("status") or "").lower() != "success":
+            linked_successes.sort(key=lambda row: str(row.get("validated_at") or row.get("updated_at") or row.get("created_at") or ""), reverse=True)
+            manual_validation = linked_successes[0]
+    gate_smoke = gate.get("generation_smoke") if isinstance(gate.get("generation_smoke"), dict) else {}
+    zero_gpu_recommendation = gate.get("zero_gpu_duration_recommendation") if isinstance(gate, dict) else None
+    if isinstance(zero_gpu_recommendation, dict):
+        zero_gpu_recommendation = zero_gpu_recommendation.get("recommended_zero_gpu_duration_seconds") or zero_gpu_recommendation.get("recommended_zerogpu_duration_seconds") or zero_gpu_recommendation.get("seconds")
     eval_publish_status = bundle.get("eval_publish_status") or {}
     final_status_reconciliation = bundle.get("final_status_reconciliation") or {}
     eval_record = bundle.get("eval_record") or {}
@@ -1339,15 +1351,15 @@ def summarize_run_bundle(run_id: str, bundle: dict[str, Any], *, bucket_source:
         "updated_at": state.get("updated_at") or state.get("created_at") or launch.get("updated_at") or launch.get("created_at") or summary_file.get("updated_at") or summary_file.get("created_at") or "",
         "selected_hardware": hardware.get("selected_hardware") or state.get("selected_hardware") or launch.get("preferred_space_hardware") or summary_file.get("selected_hardware") or state.get("hardware") or "",
         "manual_hardware_required": bool(gate.get("manual_hardware_required") or hardware.get("manual_action_required") or launch.get("manual_hardware_required")),
-        "health_passed": bool((gate.get("implementation_signals") or {}).get("health_passed") or smoke.get("health_passed")),
-        "smoke_test_passed": bool(smoke.get("ok") or smoke.get("status") == "success"),
-        "latency_seconds": smoke.get("latency_seconds") or smoke.get("observed_latency_seconds") or manual_validation.get("latency_seconds"),
-        "observed_latency_seconds": smoke.get("observed_latency_seconds") or smoke.get("latency_seconds") or manual_validation.get("observed_latency_seconds"),
-        "recommended_zero_gpu_duration_seconds": smoke.get("recommended_zero_gpu_duration_seconds") or smoke.get("recommended_zerogpu_duration_seconds") or manual_validation.get("recommended_zero_gpu_duration_seconds"),
-        "recommended_zerogpu_duration_seconds": smoke.get("recommended_zerogpu_duration_seconds") or smoke.get("recommended_zero_gpu_duration_seconds") or manual_validation.get("recommended_zero_gpu_duration_seconds"),
-        "recommendation_source": smoke.get("recommendation_source") or manual_validation.get("recommendation_source") or "",
-        "recommendation_hardware": smoke.get("recommendation_hardware") or manual_validation.get("recommendation_hardware") or manual_validation.get("hardware_used_for_validation") or state.get("selected_hardware") or "",
-        "hardware_used_for_validation": manual_validation.get("hardware_used_for_validation") or manual_validation.get("recommendation_hardware") or "",
+        "health_passed": bool((gate.get("implementation_signals") or {}).get("health_passed") or smoke.get("health_passed") or gate_smoke.get("health_passed")),
+        "smoke_test_passed": bool(smoke.get("ok") or smoke.get("status") == "success" or gate_smoke.get("status") == "success"),
+        "latency_seconds": manual_validation.get("latency_seconds") or manual_validation.get("observed_latency_seconds") or smoke.get("latency_seconds") or smoke.get("observed_latency_seconds") or gate_smoke.get("latency_seconds") or gate_smoke.get("observed_latency_seconds"),
+        "observed_latency_seconds": manual_validation.get("observed_latency_seconds") or manual_validation.get("latency_seconds") or smoke.get("observed_latency_seconds") or smoke.get("latency_seconds") or gate_smoke.get("observed_latency_seconds") or gate_smoke.get("latency_seconds"),
+        "recommended_zero_gpu_duration_seconds": manual_validation.get("recommended_zero_gpu_duration_seconds") or manual_validation.get("recommended_zerogpu_duration_seconds") or smoke.get("recommended_zero_gpu_duration_seconds") or smoke.get("recommended_zerogpu_duration_seconds") or gate_smoke.get("recommended_zero_gpu_duration_seconds") or gate_smoke.get("recommended_zerogpu_duration_seconds") or zero_gpu_recommendation,
+        "recommended_zerogpu_duration_seconds": manual_validation.get("recommended_zerogpu_duration_seconds") or manual_validation.get("recommended_zero_gpu_duration_seconds") or smoke.get("recommended_zerogpu_duration_seconds") or smoke.get("recommended_zero_gpu_duration_seconds") or gate_smoke.get("recommended_zerogpu_duration_seconds") or gate_smoke.get("recommended_zero_gpu_duration_seconds") or zero_gpu_recommendation,
+        "recommendation_source": manual_validation.get("recommendation_source") or smoke.get("recommendation_source") or gate_smoke.get("recommendation_source") or ("linked_space_test" if str(manual_validation.get("status") or "").lower() == "success" else ""),
+        "recommendation_hardware": manual_validation.get("recommendation_hardware") or manual_validation.get("hardware_used_for_validation") or smoke.get("recommendation_hardware") or gate_smoke.get("recommendation_hardware") or state.get("selected_hardware") or "",
+        "hardware_used_for_validation": manual_validation.get("hardware_used_for_validation") or manual_validation.get("recommendation_hardware") or state.get("selected_hardware") or "",
         "manual_validation_status": manual_validation,
         "manual_validation_passed": bool(manual_validation.get("status") == "success"),
         "post_build_status": effective_run_status.get("post_build_status") or "none",

src/timeline_model.py

@@ -160,6 +160,66 @@ def _latest_event_by_step(bundle: dict[str, Any], step_name: str) -> dict[str, A
     return {}
 
 
+
+def _runtime_history(bundle: dict[str, Any], *, live: dict[str, Any], runtime: dict[str, Any], smoke: dict[str, Any], gate: dict[str, Any]) -> list[dict[str, Any]]:
+    """Return a compact build→runtime→API→smoke history for Live test.
+
+    v198.26.9 keeps this curated: it restores the building/runtime feedback
+    users need without dumping raw events into Active Run.
+    """
+    history: list[dict[str, Any]] = []
+    seen: set[str] = set()
+
+    def add(stage: str, label: str, status: str = "info", ts: Any = "", detail: Any = "") -> None:
+        key = f"{stage}:{label}:{status}"
+        if key in seen:
+            return
+        seen.add(key)
+        history.append({"stage": stage, "label": label, "status": status, "ts": ts or "", "detail": str(detail or "")[:500]})
+
+    for event in _events(bundle):
+        step = _lower(event.get("step"))
+        status = _lower(event.get("status")) or "info"
+        ts = event.get("ts") or event.get("created_at") or ""
+        msg = event.get("message") or event.get("step") or ""
+        if step in {"create_space", "create_space_hardware"}:
+            add("space_created", "Space created" if status in SUCCESS_STATUSES else "Creating Space", status, ts, msg)
+        elif step == "upload_files":
+            add("runtime_uploaded", "Runtime uploaded" if status in SUCCESS_STATUSES else "Uploading runtime", status, ts, msg)
+        elif step in {"space_runtime", "live_wait"}:
+            lower_msg = _lower(msg)
+            if "building" in lower_msg or "build" in lower_msg:
+                add("space_building", "Space is building", status, ts, msg)
+            elif "running" in lower_msg or "runtime" in lower_msg or step == "space_runtime":
+                add("space_running", "Space runtime observed", status, ts, msg)
+            else:
+                add("space_runtime", "Space runtime check", status, ts, msg)
+        elif step in {"endpoint_discovery", "api_validation"}:
+            add("api_schema", "Gradio API checked" if status in SUCCESS_STATUSES else "Checking Gradio API", status, ts, msg)
+        elif step == "generation_smoke":
+            add("generation_smoke", "Generation smoke passed" if status in SUCCESS_STATUSES else "Generation smoke running" if status in RUNNING_STATUSES else "Generation smoke checked", status, ts, msg)
+        elif step == "inference_gate":
+            add("inference_gate", "Inference gate resolved", status, ts, msg)
+
+    runtime_stage = str(runtime.get("stage") or runtime.get("status") or runtime.get("runtime_status") or "").strip()
+    upper_stage = runtime_stage.upper()
+    if upper_stage:
+        if "BUILD" in upper_stage and not any(h["stage"] == "space_building" for h in history):
+            add("space_building", "Space is building", "running", runtime.get("updated_at") or "", runtime_stage)
+        if "RUNNING" in upper_stage and not any(h["stage"] == "space_running" for h in history):
+            add("space_running", "Space runtime is running", "success", runtime.get("updated_at") or "", runtime_stage)
+        if "ERROR" in upper_stage:
+            add("space_runtime_error", "Space runtime error", "failed", runtime.get("updated_at") or "", runtime.get("error") or runtime_stage)
+    if live.get("stage") and not history:
+        add(str(live.get("stage")), str(live.get("message") or live.get("stage")), str(live.get("status") or "info"), live.get("updated_at") or "")
+    endpoints = gate.get("endpoints") or gate.get("api_endpoints") or gate.get("named_endpoints") or []
+    selected = str(smoke.get("api_name") or gate.get("api_name") or gate.get("selected_endpoint") or gate.get("selected_api_name") or "").strip()
+    if (selected or (isinstance(endpoints, list) and endpoints)) and not any(h["stage"] == "api_schema" for h in history):
+        add("api_schema", f"Gradio API detected{': ' + selected if selected else ''}", "success")
+    if (_lower(smoke.get("status")) == "success" or smoke.get("ok") is True or (gate.get("implementation_signals") or {}).get("generation_smoke_passed") is True) and not any(h["stage"] == "generation_smoke" for h in history):
+        add("generation_smoke", "Generation smoke passed", "success", smoke.get("updated_at") or "", smoke.get("api_name") or "")
+    return history[-10:]
+
 def build_live_validation_model(bundle: dict[str, Any]) -> dict[str, Any]:
     """Compact live validation telemetry for the UI.
 
@@ -281,6 +341,7 @@ def build_live_validation_model(bundle: dict[str, Any]) -> dict[str, Any]:
         "live_status_updated_at": live_status.get("updated_at") or "",
         "message": smoke.get("error") or smoke.get("message") or live_message or api_event.get("message") or runtime_error or "",
         "next_action": next_action,
+        "runtime_history": _runtime_history(bundle, live=live_status, runtime=runtime, smoke=smoke, gate=gate),
     }
 
 
@@ -508,7 +569,11 @@ def _build_phase_details(bundle: dict[str, Any], phase: str) -> list[dict[str, A
     elif phase == "live_validation":
         live = build_live_validation_model(bundle)
         runtime_stage = live.get("runtime_stage") or ""
-        if runtime_stage:
+        runtime_history = live.get("runtime_history") if isinstance(live.get("runtime_history"), list) else []
+        for item in runtime_history:
+            if isinstance(item, dict) and item.get("label"):
+                details.append({"label": str(item.get("label")), "status": str(item.get("status") or "info")})
+        if runtime_stage and not runtime_history:
             details.append({"label": f"Space runtime: {runtime_stage}", "status": "info"})
         if live.get("health") == "passed":
             details.append({"label": "Health passed", "status": "complete"})
@@ -677,14 +742,19 @@ def _phase_status(bundle: dict[str, Any], phase: str, verdict: str) -> str:
     if phase == "agent":
         latest_by_step = _latest_events_by_step(bundle, phase)
         pi_run = latest_by_step.get("pi_run") or {}
+        # v198.26.9: terminal success with downstream proof closes Agent.  An
+        # old pi_run=running signal must not keep the visible dot pulsing after
+        # deploy/live/archive/final success has already happened.
+        if terminal and _final_visual_status(verdict) == "success" and _has_downstream_proof(bundle, phase):
+            return "complete"
         if _lower(pi_run.get("status")) in RUNNING_STATUSES and not terminal:
             return "running"
         if terminal:
             material_events = [e for e in _events_for_phase(bundle, phase) if _lower(e.get("step")) != "pi_model_resolution"]
             material_statuses = {_lower(e.get("status")) for e in material_events}
-            if material_statuses.intersection(FAILED_STATUSES):
+            if material_statuses.intersection(FAILED_STATUSES) and _final_visual_status(verdict) != "success":
                 return "failed"
-            if material_statuses.intersection(RUNNING_STATUSES):
+            if material_statuses.intersection(RUNNING_STATUSES) and not _has_downstream_proof(bundle, phase):
                 return "running"
             if material_statuses.intersection(SUCCESS_STATUSES) or _has_downstream_proof(bundle, phase):
                 return "complete"

src/version.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
-ASF_APP_VERSION = "v198.26.8"
-ASF_RELEASE_NAME = "Agentic Space Factory v198.26.8"
+ASF_APP_VERSION = "v198.26.9"
+ASF_RELEASE_NAME = "Agentic Space Factory v198.26.9"
 
 
 def resolve_app_version(value: str | None = None) -> str:

src/view_models.py

@@ -544,7 +544,7 @@ def _space_target_url_from_bundle(bundle: dict[str, Any], target: str = "") -> s
 def build_space_link_state(bundle: dict[str, Any], *, target: str = "", target_url: str = "") -> dict[str, Any]:
     """Return durable Space link readiness for Active Run.
 
-    v198.26.8 invariant: Space links are a persisted run fact.  They must not
+    v198.26.9 invariant: Space links are a persisted run fact.  They must not
     depend on the frontend receiving the create/upload event inside a truncated
     recent-events window.  If a runtime upload epoch or Space runtime probe is
     present, a terminal failed run still gets Open Space / Settings links.
@@ -582,7 +582,7 @@ def build_space_link_state(bundle: dict[str, Any], *, target: str = "", target_u
     if space_runtime_known:
         sources.append("space_runtime")
     return {
-        "schema_version": "space_link_state.v198_26_8",
+        "schema_version": "space_link_state.v198_26_9",
         "target_space": target,
         "target_space_id": target,
         "target_space_known": bool(target),
@@ -602,6 +602,127 @@ def _space_links_ready_from_bundle(bundle: dict[str, Any]) -> bool:
     return bool(build_space_link_state(bundle).get("links_ready"))
 
 
+
+def _number_from_value(value: Any) -> float | None:
+    if value is None or value == "":
+        return None
+    if isinstance(value, (int, float)) and not isinstance(value, bool):
+        number = float(value)
+        return number if number > 0 else None
+    if isinstance(value, dict):
+        # Common shape: {"recommended_zero_gpu_duration_seconds": 40}
+        for key in (
+            "seconds",
+            "duration_seconds",
+            "recommended_zero_gpu_duration_seconds",
+            "recommended_zerogpu_duration_seconds",
+            "recommended_duration_seconds",
+            "latency_seconds",
+            "observed_latency_seconds",
+        ):
+            found = _number_from_value(value.get(key))
+            if found is not None:
+                return found
+        return None
+    text = str(value).strip().lower().replace("seconds", "").replace("second", "").replace("sec", "").replace("s", "")
+    try:
+        number = float(text)
+        return number if number > 0 else None
+    except Exception:
+        return None
+
+
+def _first_number(*values: Any) -> float | None:
+    for value in values:
+        number = _number_from_value(value)
+        if number is not None:
+            return number
+    return None
+
+
+def _latest_successful_linked_validation(bundle: dict[str, Any]) -> dict[str, Any]:
+    linked = bundle.get("linked_validations") or {}
+    rows = linked.get("validations") if isinstance(linked, dict) else []
+    if not isinstance(rows, list):
+        return {}
+    successful = [row for row in rows if isinstance(row, dict) and _lower(row.get("status") or row.get("effective_status")) in {"success", "passed", "succeeded", "full_inference_success", "validated_after_space_test", "validated_after_manual_space_test"}]
+    if not successful:
+        return {}
+    successful.sort(key=lambda row: str(row.get("validated_at") or row.get("updated_at") or row.get("created_at") or ""), reverse=True)
+    return successful[0]
+
+
+def build_validation_metrics(bundle: dict[str, Any]) -> dict[str, Any]:
+    """Durable validation/latency model for Active Run.
+
+    v198.26.9 invariant: latency and ZeroGPU duration are post-run facts, not
+    incidental event text.  They are resolved once from persisted automatic
+    smoke artifacts and linked Space Test artifacts, then exposed by /view and
+    /progress so the frontend does not have to guess.
+    """
+    bundle = bundle or {}
+    summary = bundle.get("summary") or {}
+    state = bundle.get("state") or {}
+    smoke = bundle.get("generation_smoke") or {}
+    gate = bundle.get("inference_gate") or {}
+    gate_smoke = gate.get("generation_smoke") if isinstance(gate.get("generation_smoke"), dict) else {}
+    post_build = bundle.get("post_build_validation_status") or {}
+    manual = bundle.get("manual_validation_status") or {}
+    linked_success = _latest_successful_linked_validation(bundle)
+    gate_recommendation = gate.get("zero_gpu_duration_recommendation") if isinstance(gate, dict) else None
+
+    # Linked Space Test success is a stronger post-build measurement than the
+    # original automatic build smoke.  It should update the parent Active Run.
+    source_order = [linked_success, post_build if _lower(post_build.get("status")) == "success" else {}, manual if _lower(manual.get("status")) == "success" else {}, smoke, gate_smoke, gate, summary, state]
+    latency = _first_number(*(src.get("latency_seconds") for src in source_order if isinstance(src, dict)), *(src.get("observed_latency_seconds") for src in source_order if isinstance(src, dict)))
+    duration = _first_number(
+        *(src.get("recommended_zero_gpu_duration_seconds") for src in source_order if isinstance(src, dict)),
+        *(src.get("recommended_zerogpu_duration_seconds") for src in source_order if isinstance(src, dict)),
+        *(src.get("recommended_duration_seconds") for src in source_order if isinstance(src, dict)),
+        gate_recommendation,
+    )
+    api_name = _first_nonempty(*(src.get("api_name") for src in source_order if isinstance(src, dict)), gate.get("selected_api_name"), gate.get("selected_endpoint"))
+    hardware = _first_nonempty(
+        *(src.get("hardware_used_for_validation") for src in source_order if isinstance(src, dict)),
+        *(src.get("recommendation_hardware") for src in source_order if isinstance(src, dict)),
+        smoke.get("hardware"),
+        gate.get("hardware"),
+        summary.get("selected_hardware"),
+        state.get("selected_hardware"),
+    )
+    output_artifact = _first_nonempty(*(src.get("output_artifact") or src.get("artifact_url") for src in source_order if isinstance(src, dict)))
+    source = ""
+    if linked_success or _lower(post_build.get("status")) == "success" or _lower(manual.get("status")) == "success":
+        source = "linked_space_test"
+    elif smoke.get("status") == "success" or smoke.get("ok") is True:
+        source = "automatic_generation_smoke"
+    elif gate_smoke or gate:
+        source = "inference_gate"
+    source = _first_nonempty(*(src.get("recommendation_source") for src in source_order if isinstance(src, dict)), source)
+    health_passed = bool((gate.get("implementation_signals") or {}).get("health_passed") or smoke.get("health_passed") or gate_smoke.get("health_passed"))
+    smoke_passed = bool(smoke.get("ok") or _lower(smoke.get("status")) == "success" or _lower(gate_smoke.get("status")) == "success" or (gate.get("implementation_signals") or {}).get("generation_smoke_passed") is True)
+    validation_run_id = _first_nonempty(linked_success.get("validation_run_id"), linked_success.get("run_id"), post_build.get("validation_run_id"), manual.get("validation_run_id"))
+    metrics = {
+        "schema_version": "validation_metrics.v198_26_9",
+        "available": bool(latency or duration or smoke_passed or health_passed or validation_run_id),
+        "source": source,
+        "latency_seconds": latency,
+        "observed_latency_seconds": latency,
+        "recommended_zero_gpu_duration_seconds": duration,
+        "recommended_zerogpu_duration_seconds": duration,
+        "hardware_used_for_validation": hardware,
+        "recommendation_hardware": hardware,
+        "api_name": api_name,
+        "output_artifact": output_artifact,
+        "health_passed": health_passed,
+        "generation_smoke_passed": smoke_passed,
+        "automatic_smoke_passed": bool(smoke.get("ok") or _lower(smoke.get("status")) == "success"),
+        "linked_space_test_passed": bool(linked_success or _lower(post_build.get("status")) == "success" or _lower(manual.get("status")) == "success"),
+        "validation_run_id": validation_run_id,
+        "updated_at": _first_nonempty(linked_success.get("validated_at"), linked_success.get("updated_at"), post_build.get("validated_at"), post_build.get("updated_at"), manual.get("validated_at"), manual.get("updated_at"), summary.get("updated_at"), state.get("updated_at")),
+    }
+    return metrics
+
 def _known_gradio_endpoint_info(bundle: dict[str, Any]) -> dict[str, Any]:
     smoke = bundle.get("generation_smoke") or {}
     gate = bundle.get("inference_gate") or {}
@@ -736,6 +857,7 @@ def build_space_test_policy(bundle: dict[str, Any], status_model: dict[str, Any]
 def build_space_test_model(bundle: dict[str, Any], status_model: dict[str, Any]) -> dict[str, Any]:
     smoke = bundle.get("generation_smoke") or {}
     summary = bundle.get("summary") or {}
+    metrics = build_validation_metrics(bundle)
     policy = build_space_test_policy(bundle, status_model)
     # v191.12 regression guard: a contract-declared boot-only blocker must not
     # resurrect the historical /generate fallback in the display model. Keep the
@@ -750,8 +872,12 @@ def build_space_test_model(bundle: dict[str, Any], status_model: dict[str, Any])
         "target_space": policy.get("target_space") or summary.get("target_space") or "",
         "target_space_url": policy.get("target_space_url") or summary.get("target_space_url") or "",
         "endpoint": endpoint,
-        "status": "passed" if smoke.get("ok") or smoke.get("status") == "success" else "pending",
-        "latency_seconds": smoke.get("latency_seconds") or summary.get("latency_seconds"),
+        "status": "passed" if metrics.get("generation_smoke_passed") or smoke.get("ok") or smoke.get("status") == "success" else "pending",
+        "latency_seconds": metrics.get("latency_seconds") or smoke.get("latency_seconds") or summary.get("latency_seconds"),
+        "observed_latency_seconds": metrics.get("observed_latency_seconds"),
+        "recommended_zero_gpu_duration_seconds": metrics.get("recommended_zero_gpu_duration_seconds"),
+        "recommended_zerogpu_duration_seconds": metrics.get("recommended_zerogpu_duration_seconds"),
+        "validation_metrics": metrics,
         "expected_output_type": summary.get("expected_output_type") or smoke.get("expected_output_type") or "",
         "verdict": status_model["verdict"],
         "output_artifact": smoke.get("output_artifact") or smoke.get("artifact_url") or "",
@@ -794,6 +920,7 @@ def build_run_view_model(
     target = _space_target_from_bundle(bundle)
     target_url = _space_target_url_from_bundle(bundle, target)
     space_link_state = build_space_link_state(bundle, target=target, target_url=target_url)
+    validation_metrics = build_validation_metrics({**bundle, "summary": summary})
     links = {
         "job_url": _job_url_from_view_sources(bucket_source=bucket_source, summary=summary, state=state, launch=bundle.get("launch") or {}),
         "target_space_url": target_url,
@@ -834,6 +961,8 @@ def build_run_view_model(
         "space_test": {**build_space_test_model(bundle, status_model), "linked_validation": manual_validation, "mode": "linked_build_run"},
         "space_test_policy": space_test_policy,
         "space_link_state": space_link_state,
+        "validation_metrics": validation_metrics,
+        "run_documents": bundle.get("run_documents") or [],
         "manual_validation": manual_validation,
         "post_build_validation": effective_run_status.get("post_build_validation") or {},
         "display_status": effective_run_status.get("display_status") or status_model.get("global_status"),

src/worker_payload.py

@@ -35,8 +35,8 @@ DEFAULT_PREFERRED_SPACE_HARDWARE = "zero-a10g"
 DEFAULT_FALLBACK_SPACE_HARDWARE = "a10g-large"
 DEFAULT_MODEL_ID = "sshleifer/tiny-gpt2"
 MAX_PI_REPAIR_ATTEMPTS = 3
-APP_VERSION = "v198.26.8"
-app_version = "v198.26.8"
+APP_VERSION = "v198.26.9"
+app_version = "v198.26.9"
 
 # Internal agent/recovery files may be needed inside the transient Pi
 # workspace, but they should not be published to the generated Space or shown
@@ -5254,7 +5254,7 @@ def reconcile_final_success_state(run_dir: Path, events_path: Path | None, final
 def write_terminal_status_reconciliation(run_dir: Path, events_path: Path | None, final_state: dict, *, status: str, message: str = "", details: dict | None = None, job_exit_code: int | None = None) -> dict:
     """Persist a terminal truth artifact for every final outcome.
 
-    v198.26.8: the UI must not have to infer failed/stopped states from a mix
+    v198.26.9: the UI must not have to infer failed/stopped states from a mix
     of state, repair_outcome and recent events.  Success already writes
     final_status_reconciliation.json; failed/auth/cancelled terminal paths now
     write the same artifact so Active Run can converge deterministically.
@@ -5268,7 +5268,7 @@ def write_terminal_status_reconciliation(run_dir: Path, events_path: Path | None
     runtime_uploaded = bool(runtime_upload_epoch.get("last_upload_completed_at") or runtime_upload_epoch.get("upload_sequence") or runtime_history)
     space_runtime_known = bool(isinstance(space_runtime, dict) and (space_runtime.get("stage") or space_runtime.get("status") or space_runtime.get("runtime_status") or space_runtime.get("updated_at") or space_runtime.get("url")))
     payload = {
-        "schema_version": "final_status_reconciliation.v198_26_8",
+        "schema_version": "final_status_reconciliation.v198_26_9",
         "status": status,
         "terminal": True,
         "message": message or state.get("message") or "",
@@ -12503,7 +12503,7 @@ def smoke_generate(target_space_id: str, token: str, run_dir: Path, events_path:
     # write_json(run_dir / "tests" / "payload_source.json", payload_source_record)
     # write_json(run_dir / "tests" / "replay_source.json", replay_source)
     # write_json(run_dir / "tests" / "validation_preflight.json", validation_preflight)
-    app_version = "v198.26.8"
+    app_version = "v198.26.9"
     engine_version = "unified_gradio_validation_harness_v198_25_3"
     parent_build_run_id = os.environ.get("PARENT_BUILD_RUN_ID", "").strip()
     validation_mode = os.environ.get("VALIDATION_MODE") or os.environ.get("SPACE_TEST_POLICY_MODE") or "linked"