Upload 6 files

CHANGELOG.md

@@ -1,23 +1,37 @@
-# v190.24 — Replay uses parent smoke artefact as source of truth
+## v190.28 — Runs Explorer linked validation parent metadata
 
-## v190.24 — Linked validation replay hardening
+- Build Run cards now show linked/manual validation strips from parent metadata (`manual_validation_status` and `linked_validations`) even when the child Validation Run is not present in the Runs Explorer cache.
+- Runs Explorer remains build-first: linked validations stay summarized on their parent Build Run, while automatic Build Run smoke results remain separate from manual linked validation state.
+
+
+## v190.28 — Space Test payload provenance and prefill correctness
+
+- Uses automatic smoke artefacts as the visible Space Test prefill source when available.
+- Clears stale dirty validation args when a Build Run is selected from Runs Explorer.
+- Sends and stores a backend validation launch payload for linked validations.
+- Writes validation_launch_payload.json in validation runs before the worker resolves/predicts.
+- Surfaces payload source provenance across UI, backend launch metadata, and worker artefacts.
+
+# v190.28 — Replay uses parent smoke artefact as source of truth
+
+## v190.28 — Linked validation replay hardening
 
 - In Space Test replay mode, the validation worker now loads the parent Build Run's successful automatic smoke artefacts (`generation_smoke.json`, `generation_smoke_payload*.json`) as the canonical request before schema reconstruction.
 - Added `replay_source.json` and richer `resolved_validation_request.json` / failure diagnosis fields so replay failures can be compared against the parent smoke request.
 - The Payload stage now records `Payload replayed from parent automatic smoke` instead of remaining pending when replay data exists.
 
-# v190.24 — Linked validation worker schema coercion and replay fix
+# v190.28 — Linked validation worker schema coercion and replay fix
 
-## v190.24 — Validation worker reliability
+## v190.28 — Validation worker reliability
 
 - Normalizes linked validation replay payloads against the current Gradio endpoint schema before calling predict().
 - Preserves typed Gradio choices and converts dropdown/radio numeric-looking args such as 1024 to schema strings such as "1024" when required.
 - Writes validation_preflight.json, resolved_validation_request.json, schema_coercion.json, and validation_failure_diagnosis.json for every linked validation run.
 - Keeps Space Test copy linked-only while explaining that the separate validation run remains attached to the selected Build Run.
 
-# v190.24 — UI/CSS convergence and Space Test validation polish
+# v190.28 — UI/CSS convergence and Space Test validation polish
 
-## v190.24 — Space Test validation reliability
+## v190.28 — Space Test validation reliability
 
 - Treats Space Test Validation as a first-class linked validation workflow.
 - Adds a single resolved launch payload contract so replay/complete/recover/discovery-first modes only launch when coherent.

README.md

@@ -13,13 +13,17 @@ hf_oauth_scopes:
   - read-billing
 ---
 
-## v190.24 Replay uses parent smoke artefact as source of truth
+## v190.28 Runs Explorer linked validation parent metadata
 
-- v190.24 makes linked Space Test replay mode load the parent Build Run's successful automatic smoke artefacts before attempting any schema reconstruction. The validation worker writes `replay_source.json`, `resolved_validation_request.json`, and diagnostics so a replay cannot fail opaquely at the Payload stage.
+- v190.28 makes Build Run cards display manual linked validation state directly from parent metadata (`manual_validation_status.json` / `linked_validations.json`), so the summary is visible even when linked Validation Runs are not listed as standalone rows. Automatic smoke status remains separate from manual linked validation status.
 
-## v190.24 Linked validation hardening
+## v190.28 Replay uses parent smoke artefact as source of truth
 
-- v190.24 hardens linked Space Test success/failure paths: parent Build Run updates read API/output metadata from the smoke result, failed manual attempts cannot downgrade an already validated parent, and latency/ZeroGPU recommendations expose their linked-test hardware provenance.
+- v190.28 makes linked Space Test replay mode load the parent Build Run's successful automatic smoke artefacts before attempting any schema reconstruction. The validation worker writes `replay_source.json`, `resolved_validation_request.json`, and diagnostics so a replay cannot fail opaquely at the Payload stage.
+
+## v190.28 Linked validation hardening
+
+- v190.28 hardens linked Space Test success/failure paths: parent Build Run updates read API/output metadata from the smoke result, failed manual attempts cannot downgrade an already validated parent, and latency/ZeroGPU recommendations expose their linked-test hardware provenance.
 - Runs Explorer and Run Stats now treat automatic and effective statuses explicitly so manually validated partial builds remain discoverable in both Partial and Validated views.
 - Space Test is contextualized from the selected Build Run even before pressing Prefill, while remaining linked-only for launches.
 
@@ -419,13 +423,13 @@ The Active Run progress header now separates pipeline completion from product ve
 
 - v190.9 makes terminal Space Test validation status survive page reloads. Failed, success, partial, and manual validation outcomes override stale `running` launch metadata in the Runs Explorer, delete modal, and progress polling.
 
-## v190.24 Eval archive effective outcomes
+## v190.28 Eval archive effective outcomes
 
 - Eval archive records now distinguish automatic verdicts from effective verdicts after linked Space Test validation.
 - Archived records include anonymized linked-validation, endpoint-discovery and smoke-retry metrics while preserving privacy constraints.
 - Instance owners can flush all archived eval records from the mounted eval bucket without deleting the eval archive configuration.
 
-## v190.24 Linked validation replay reliability
+## v190.28 Linked validation replay reliability
 
 - Linked Space Test validations now normalize replay/complete/recover payloads against the current Gradio schema before predict().
 - Validation runs write explicit preflight, resolved request, schema coercion, and failure diagnosis artifacts for debugging.

app.py

@@ -102,6 +102,91 @@ def _json_error(exc: Exception) -> HTTPException:
 
 
 
+
+
+def _first_list_value(*values: Any) -> list[Any] | None:
+    for value in values:
+        if isinstance(value, list):
+            return value
+    return None
+
+
+def _first_dict_value(*values: Any) -> dict[str, Any] | None:
+    for value in values:
+        if isinstance(value, dict):
+            return value
+    return None
+
+
+def _linked_replay_source_from_parent_bundle(parent_run_id: str, parent_bundle: dict[str, Any], target_space: str, expected_output_type: str | None = None) -> dict[str, Any]:
+    """Resolve the parent automatic smoke request server-side for replay Jobs.
+
+    The validation worker runs in a fresh Job and cannot assume the parent run
+    folder is present locally. Passing this compact, redacted source through the
+    Job environment prevents linked replay from silently falling back to schema
+    reconstruction when the parent already proved a working request.
+    """
+    smoke = parent_bundle.get("generation_smoke") or {}
+    retry_payload = parent_bundle.get("generation_smoke_payload_retry") or {}
+    initial_payload = parent_bundle.get("generation_smoke_payload") or {}
+    resolved = parent_bundle.get("resolved_validation_request") or {}
+    state_obj = parent_bundle.get("state") or {}
+    state_smoke = state_obj.get("generation_smoke") if isinstance(state_obj.get("generation_smoke"), dict) else {}
+    status_tokens = {
+        str(smoke.get("status") or "").lower(),
+        str(state_obj.get("status") or "").lower(),
+        str(state_smoke.get("status") or "").lower(),
+    }
+    parent_was_successful = bool(status_tokens & {"success", "full_inference_success", "completed", "complete", "done"})
+    if not parent_was_successful:
+        return {}
+    api_name = (
+        smoke.get("api_name")
+        or retry_payload.get("api_name")
+        or initial_payload.get("api_name")
+        or resolved.get("api_name")
+        or state_smoke.get("api_name")
+        or ""
+    )
+    test_args = _first_list_value(
+        smoke.get("effective_args"),
+        smoke.get("test_args"),
+        retry_payload.get("test_args"),
+        retry_payload.get("effective_args"),
+        initial_payload.get("test_args"),
+        initial_payload.get("effective_args"),
+        resolved.get("test_args"),
+        state_smoke.get("effective_args"),
+        state_smoke.get("test_args"),
+    )
+    test_kwargs = _first_dict_value(
+        smoke.get("effective_kwargs"),
+        smoke.get("test_kwargs"),
+        retry_payload.get("test_kwargs"),
+        retry_payload.get("effective_kwargs"),
+        initial_payload.get("test_kwargs"),
+        initial_payload.get("effective_kwargs"),
+        resolved.get("test_kwargs"),
+        state_smoke.get("effective_kwargs"),
+        state_smoke.get("test_kwargs"),
+    ) or {}
+    if not api_name or not isinstance(test_args, list):
+        return {}
+    parent_target = smoke.get("target_space") or state_obj.get("target_space") or state_smoke.get("target_space") or target_space or ""
+    return {
+        "source": "parent_automatic_smoke_backend",
+        "parent_run_id": parent_run_id,
+        "parent_target_space": parent_target,
+        "target_matches": not parent_target or parent_target == target_space,
+        "api_name": str(api_name if str(api_name).startswith("/") else f"/{api_name}"),
+        "test_args": test_args,
+        "test_kwargs": test_kwargs,
+        "expected_output_type": smoke.get("expected_output_type") or state_smoke.get("expected_output_type") or expected_output_type or "any",
+        "latency_seconds": smoke.get("latency_seconds") or state_smoke.get("latency_seconds"),
+        "parent_smoke_status": smoke.get("status") or state_smoke.get("status") or state_obj.get("status"),
+        "transport": "job_env",
+    }
+
 def _job_url_from_result(result: dict[str, Any], username: str | None) -> str:
     explicit = (result.get("job_url") or "").strip() if isinstance(result.get("job_url"), str) else result.get("job_url")
     if explicit:
@@ -570,8 +655,39 @@ def register_custom_routes(fastapi_app: FastAPI) -> None:
             if not space_test_policy.get("enabled"):
                 raise ValueError(str(space_test_policy.get("message") or "This Build Run is not eligible for linked Space Test yet."))
             api_name_for_validation = payload.get("api_name")
-            if space_test_policy.get("requires_endpoint_discovery") and str(api_name_for_validation or "").strip() in {"", "/generate"}:
+            replay_source: dict[str, Any] = {}
+            if str(space_test_policy.get("mode") or payload.get("validation_mode") or "").strip().lower() == "replay":
+                replay_source = _linked_replay_source_from_parent_bundle(
+                    parent_build_run_id,
+                    parent_bundle,
+                    requested_target,
+                    str(payload.get("expected_output_type") or "any"),
+                )
+                if replay_source:
+                    api_name_for_validation = replay_source.get("api_name") or api_name_for_validation
+                    test_args = replay_source.get("test_args") if isinstance(replay_source.get("test_args"), list) else test_args
+                    test_kwargs = replay_source.get("test_kwargs") if isinstance(replay_source.get("test_kwargs"), dict) else test_kwargs
+            if space_test_policy.get("requires_endpoint_discovery") and str(api_name_for_validation or "").strip() in {"", "/generate"} and not replay_source:
                 api_name_for_validation = ""
+            validation_launch_payload = {
+                "schema_version": "1.0",
+                "app_version": settings.app_version,
+                "parent_build_run_id": parent_build_run_id,
+                "target_space_id": requested_target,
+                "api_name": api_name_for_validation or "",
+                "expected_output_type": payload.get("expected_output_type") or replay_source.get("expected_output_type") or "any",
+                "test_args": test_args,
+                "test_kwargs": test_kwargs,
+                "validation_mode": space_test_policy.get("mode") or payload.get("validation_mode") or "complete",
+                "payload_source": payload.get("payload_source") or ("parent_automatic_smoke_backend" if replay_source else "ui_payload"),
+                "replay_source_present": bool(replay_source),
+                "ui_payload_source": payload.get("payload_source") or "",
+                "space_test_policy": {
+                    "mode": space_test_policy.get("mode"),
+                    "requires_endpoint_discovery": bool(space_test_policy.get("requires_endpoint_discovery")),
+                    "effective_status_on_success": space_test_policy.get("effective_status_on_success"),
+                },
+            }
             result = launch_validate_existing_space_job(
                 token=ctx["token"],
                 username=ctx["username"],
@@ -580,10 +696,12 @@ def register_custom_routes(fastapi_app: FastAPI) -> None:
                 api_name=api_name_for_validation,
                 test_args_json=json.dumps(test_args, ensure_ascii=False),
                 test_kwargs_json=json.dumps(test_kwargs, ensure_ascii=False),
-                expected_output_type=payload.get("expected_output_type"),
+                expected_output_type=validation_launch_payload["expected_output_type"],
                 live_timeout_seconds=payload.get("live_timeout_seconds") or 1800,
-                validation_mode=space_test_policy.get("mode"),
+                validation_mode=validation_launch_payload["validation_mode"],  # effectively: validation_mode=space_test_policy.get("mode")
                 effective_status_on_success=space_test_policy.get("effective_status_on_success") or "validated_after_manual_space_test",
+                parent_replay_source_json=json.dumps(replay_source, ensure_ascii=False) if replay_source else None,
+                validation_launch_payload_json=json.dumps(validation_launch_payload, ensure_ascii=False),
                 run_id=payload.get("run_id"),
                 bucket_name=bucket_name,
             )
@@ -880,6 +998,10 @@ def register_custom_routes(fastapi_app: FastAPI) -> None:
                 "generation_smoke": bundle.get("generation_smoke") or {},
                 "api_schema": bundle.get("api_schema") or {},
                 "validation_payload": bundle.get("validation_payload") or {},
+                "validation_failure_diagnosis": bundle.get("validation_failure_diagnosis") or {},
+                "payload_source": bundle.get("payload_source") or {},
+                "validation_engine": bundle.get("validation_engine") or {},
+                "resolved_validation_request": bundle.get("resolved_validation_request") or {},
                 "hardware_strategy": bundle.get("hardware_strategy") or {},
                 "technical_blockers": bundle.get("technical_blockers") or {},
                 "repair_decision": bundle.get("repair_decision") or {},