Upload 15 files

src/timeline_model.py

@@ -161,64 +161,211 @@ def _latest_event_by_step(bundle: dict[str, Any], step_name: str) -> dict[str, A
 
 
 
-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.
+def _hardware_attempt_rows(bundle: dict[str, Any]) -> list[dict[str, Any]]:
+    """Return normalized hardware-at-creation attempts.
 
-    v198.26.9 keeps this curated: it restores the building/runtime feedback
-    users need without dumping raw events into Active Run.
+    v198.26.11 uses these only to explain the Live Test story.  They must not
+    influence the run verdict.
     """
-    history: list[dict[str, Any]] = []
-    seen: set[str] = set()
+    sources = (bundle.get("hardware_attempts") or {}, bundle.get("hardware_strategy") or {}, bundle.get("state") or {})
+    for source in sources:
+        attempts = source.get("attempts") if isinstance(source, dict) else None
+        if isinstance(attempts, list):
+            return [a for a in attempts if isinstance(a, dict)]
+    return []
+
+
+def _attempt_hardware(attempt: dict[str, Any]) -> str:
+    return str(
+        attempt.get("hardware")
+        or attempt.get("requested_hardware")
+        or attempt.get("target_hardware")
+        or attempt.get("sku")
+        or attempt.get("flavor")
+        or ""
+    ).strip()
 
-    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)
+def _attempt_status(attempt: dict[str, Any]) -> str:
+    return _lower(attempt.get("status") or attempt.get("result") or attempt.get("outcome"))
+
+
+def _selected_hardware(bundle: dict[str, Any]) -> str:
+    for source in (bundle.get("hardware_attempts") or {}, bundle.get("hardware_strategy") or {}, bundle.get("summary") or {}, bundle.get("state") or {}):
+        if isinstance(source, dict):
+            value = str(source.get("selected_hardware") or source.get("hardware") or "").strip()
+            if value:
+                return value
+    return ""
+
+
+def _zero_gpu_fallback_story(bundle: dict[str, Any]) -> tuple[bool, str, str]:
+    attempts = _hardware_attempt_rows(bundle)
+    selected = _selected_hardware(bundle)
+    zero_failed = False
+    fallback_hardware = selected
+    fallback_success = False
+    for attempt in attempts:
+        hw = _attempt_hardware(attempt)
+        status = _attempt_status(attempt)
+        hw_lower = _lower(hw)
+        is_zero = "zero" in hw_lower or hw_lower.startswith("zero-")
+        if is_zero and (status in FAILED_STATUSES or status in {"refused", "unavailable", "denied", "quota_exceeded", "quota"} or "fail" in status):
+            zero_failed = True
+        if not is_zero and (status in SUCCESS_STATUSES or status in {"selected", "created", "ok"}):
+            fallback_success = True
+            fallback_hardware = hw or selected
+    if zero_failed and (fallback_success or (selected and "zero" not in _lower(selected))):
+        return True, fallback_hardware or selected or "fallback hardware", "ZeroGPU unavailable → using " + (fallback_hardware or selected or "fallback hardware")
+    return False, fallback_hardware or selected, ""
+
+
+def _latest_step_status(bundle: dict[str, Any], steps: set[str]) -> str:
+    for event in reversed(_events(bundle)):
+        if _lower(event.get("step")) in steps:
+            return _lower(event.get("status"))
+    return ""
+
+
+def _latest_step_message(bundle: dict[str, Any], steps: set[str]) -> str:
+    for event in reversed(_events(bundle)):
+        if _lower(event.get("step")) in steps:
+            return str(event.get("message") or "").strip()
+    return ""
+
+
+def build_live_test_story(bundle: dict[str, Any], *, live: dict[str, Any] | None = None, runtime: dict[str, Any] | None = None, smoke: dict[str, Any] | None = None, gate: dict[str, Any] | None = None) -> dict[str, Any]:
+    """Curated Live Test story for Active Run.
+
+    This is deliberately not a raw event dump.  It compresses retry/fallback
+    mechanics into user-facing process steps, so a normal ZeroGPU refusal followed
+    by an A10G fallback is shown as a controlled fallback rather than as a scary
+    duplicate "Creating Space failed" row.
+    """
+    live = live if isinstance(live, dict) else _live_status(bundle)
+    runtime = runtime if isinstance(runtime, dict) else _runtime(bundle)
+    smoke = smoke if isinstance(smoke, dict) else _smoke(bundle)
+    gate = gate if isinstance(gate, dict) else _gate(bundle)
+    signals = _signals(bundle)
+    summary = bundle.get("summary") or {}
+    state = bundle.get("state") or {}
+    steps: list[dict[str, Any]] = []
+
+    def add(step_id: str, label: str, status: str, detail: Any = "", ts: Any = "") -> None:
+        steps.append({
+            "id": step_id,
+            "stage": step_id,
+            "label": label,
+            "status": status or "pending",
+            "detail": str(detail or "")[:500],
+            "ts": ts or "",
+        })
+
+    fallback_used, fallback_hw, fallback_detail = _zero_gpu_fallback_story(bundle)
+    selected_hw = fallback_hw or _selected_hardware(bundle) or str(summary.get("selected_hardware") or state.get("selected_hardware") or "").strip()
+    create_status = _latest_step_status(bundle, {"create_space", "create_space_hardware"})
+    upload_status = _latest_step_status(bundle, {"upload_files"})
+    create_message = _latest_step_message(bundle, {"create_space", "create_space_hardware"})
+    runtime_upload_epoch = bundle.get("runtime_upload_epoch") or {}
+    runtime_uploaded = bool(
+        runtime_upload_epoch.get("last_upload_completed_at")
+        or runtime_upload_epoch.get("upload_sequence")
+        or upload_status in SUCCESS_STATUSES
+    )
+
+    zero_attempt_failed_without_fallback = (not fallback_used) and any(
+        ("zero" in _lower(_attempt_hardware(attempt))) and _attempt_status(attempt) in FAILED_STATUSES
+        for attempt in _hardware_attempt_rows(bundle)
+    )
+    if fallback_used:
+        add("hardware", "Hardware provisioning", "fallback", fallback_detail)
+    elif zero_attempt_failed_without_fallback or create_status in FAILED_STATUSES:
+        add("hardware", "Hardware provisioning", "failed", create_message or "Hardware provisioning failed")
+    elif selected_hw:
+        add("hardware", "Hardware provisioning", "selected", f"{selected_hw} selected")
+    else:
+        add("hardware", "Hardware provisioning", "running" if create_status in RUNNING_STATUSES else "pending", "Selecting hardware")
+
+    if create_status in FAILED_STATUSES and not fallback_used and not runtime_uploaded:
+        add("space", "Space setup", "failed", create_message or "Space creation failed")
+    elif create_status in SUCCESS_STATUSES or runtime_uploaded or summary.get("target_space") or state.get("target_space"):
+        suffix = f" on {selected_hw}" if selected_hw else ""
+        add("space", "Space setup", "success", f"Space created{suffix}")
+    elif create_status in RUNNING_STATUSES:
+        add("space", "Space setup", "running", "Creating Space")
+    else:
+        add("space", "Space setup", "pending", "Waiting for Space creation")
+
+    if runtime_uploaded:
+        add("runtime_upload", "Runtime deployment", "uploaded", "Runtime uploaded")
+    elif upload_status in RUNNING_STATUSES:
+        add("runtime_upload", "Runtime deployment", "running", "Uploading runtime")
+    elif upload_status in FAILED_STATUSES:
+        add("runtime_upload", "Runtime deployment", "failed", _latest_step_message(bundle, {"upload_files"}) or "Runtime upload failed")
+    else:
+        add("runtime_upload", "Runtime deployment", "pending", "Waiting for runtime upload")
 
     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 "")
+    if "ERROR" in upper_stage:
+        add("runtime_status", "Space runtime", "failed", runtime.get("error") or runtime_stage or "Runtime error")
+    elif "RUNNING" in upper_stage:
+        add("runtime_status", "Space runtime", "running", "Runtime running")
+    elif "BUILD" in upper_stage:
+        add("runtime_status", "Space runtime", "building", "Building on Hugging Face")
+    elif runtime_uploaded:
+        add("runtime_status", "Space runtime", "building", "Waiting for Hugging Face build")
+    else:
+        add("runtime_status", "Space runtime", "pending", "Waiting for upload")
+
     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:]
+    selected_endpoint = str(smoke.get("api_name") or gate.get("api_name") or gate.get("selected_endpoint") or gate.get("selected_api_name") or "").strip()
+    endpoint_known = bool(selected_endpoint or (isinstance(endpoints, list) and endpoints) or signals.get("generation_smoke_passed") is True or _lower(smoke.get("status")) == "success")
+    api_status = _latest_step_status(bundle, {"endpoint_discovery", "api_validation"})
+    if endpoint_known or api_status in SUCCESS_STATUSES:
+        add("api", "Gradio API", "ready", f"Ready{': ' + selected_endpoint if selected_endpoint else ''}")
+    elif api_status in FAILED_STATUSES:
+        add("api", "Gradio API", "failed", _latest_step_message(bundle, {"endpoint_discovery", "api_validation"}) or "API check failed")
+    elif api_status in RUNNING_STATUSES or (live.get("stage") in {"endpoint_discovery", "api_validation"}):
+        add("api", "Gradio API", "running", "Checking API schema")
+    else:
+        add("api", "Gradio API", "pending", "Waiting for runtime")
+
+    smoke_status = _lower(smoke.get("status") or _latest_step_status(bundle, {"generation_smoke"}))
+    if smoke_status == "success" or smoke.get("ok") is True or signals.get("generation_smoke_passed") is True:
+        add("smoke", "Generation smoke", "verified", "Generation verified")
+    elif smoke_status in FAILED_STATUSES or smoke_status in {"timeout", "exception"}:
+        add("smoke", "Generation smoke", "failed", smoke.get("error") or smoke.get("message") or "Generation not verified")
+    elif smoke_status in RUNNING_STATUSES or live.get("stage") == "generation_smoke":
+        add("smoke", "Generation smoke", "running", "Running smoke test")
+    else:
+        add("smoke", "Generation smoke", "pending", "Waiting for API")
+
+    story_status = "in_progress"
+    if steps and steps[-1]["status"] == "verified":
+        story_status = "success"
+    elif any(step["status"] == "failed" for step in steps):
+        story_status = "failed"
+    elif any(step["status"] in {"building", "running"} for step in steps):
+        story_status = "in_progress"
+    headline = "Generation verified" if story_status == "success" else "Waiting for Space runtime" if story_status == "in_progress" else "Live test needs attention"
+    return {
+        "schema_version": "live_test_story.v198_26_11",
+        "status": story_status,
+        "headline": headline,
+        "steps": steps,
+        "fallback_used": fallback_used,
+        "selected_hardware": selected_hw,
+    }
+
+
+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 the curated Live Test story steps for timeline details.
+
+    v198.26.11 replaces duplicate raw create/upload events with a process story:
+    hardware fallback, Space setup, runtime deployment, HF build/runtime, API, smoke.
+    """
+    return build_live_test_story(bundle, live=live, runtime=runtime, smoke=smoke, gate=gate).get("steps") or []
 
 def build_live_validation_model(bundle: dict[str, Any]) -> dict[str, Any]:
     """Compact live validation telemetry for the UI.
@@ -342,6 +489,7 @@ def build_live_validation_model(bundle: dict[str, Any]) -> dict[str, Any]:
         "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),
+        "live_test_story": build_live_test_story(bundle, live=live_status, runtime=runtime, smoke=smoke, gate=gate),
     }
 
 
@@ -572,7 +720,7 @@ def _build_phase_details(bundle: dict[str, Any], phase: str) -> list[dict[str, A
         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")})
+                details.append({"label": str(item.get("label")), "status": str(item.get("status") or "info"), "detail": str(item.get("detail") or "")})
         if runtime_stage and not runtime_history:
             details.append({"label": f"Space runtime: {runtime_stage}", "status": "info"})
         if live.get("health") == "passed":

src/version.py

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

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.10"
-app_version = "v198.26.10"
+APP_VERSION = "v198.26.11"
+app_version = "v198.26.11"
 
 # Internal agent/recovery files may be needed inside the transient Pi
 # workspace, but they should not be published to the generated Space or shown
@@ -3255,7 +3255,7 @@ def build_promise_validation_status(workspace: Path | None, validation: dict | N
         str(demo_contract.get("promise_fulfillment_risk") or ""),
         str(blockers.get("reason") or ""),
     ]).lower()
-    # v198.26.10: "official Space" by itself is not a blocker.  Pi often
+    # v198.26.11: "official Space" by itself is not a blocker.  Pi often
     # mentions the upstream official Space as provenance or comparison even when
     # the generated Space implements real inference.  Treat only explicit
     # redirect/only/not-implemented formulations as official-only blockers.
@@ -9788,7 +9788,7 @@ def infer_generation_gate(workspace: Path, implementation_mode: str, validation:
     minimal_smoke_ok = isinstance(generation_smoke, dict) and (generation_smoke.get("status") == "demo_usable_smoke_passed" or generation_smoke.get("demo_usable_smoke_passed") is True)
     full_inference_requested = implementation_mode in {"full-inference-gated", "full-inference-attempt"}
     promise_fulfilled = bool(promise_validation.get("promise_fulfilled"))
-    # v198.26.10 contradiction guard: when a canonical live generation smoke
+    # v198.26.11 contradiction guard: when a canonical live generation smoke
     # succeeds and the machine-readable contract does not declare no-full
     # inference, a broad/heuristic diagnostic promise must not manufacture a
     # blocker.  This keeps metrics as evidence while preserving real explicit
@@ -12563,7 +12563,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.10"
+    app_version = "v198.26.11"
     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"