Upload 15 files

src/version.py

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

src/view_models.py

@@ -454,8 +454,13 @@ def build_diagnostics(bundle: dict[str, Any], status_model: dict[str, Any], phas
         issue_detail = "Automatic hardware selection was not available. Choose hardware in Space settings, then run Space Test."
         issue_status = "action_required"
     elif status_model["global_status"] == "failed":
-        issue_title = "Run failed"
-        issue_detail = "Inspect logs and run artifacts for the failing step."
+        link_state = build_space_link_state(bundle)
+        if link_state.get("links_ready"):
+            issue_title = "Validation failed after Space upload"
+            issue_detail = "The generated Space exists and remains available, but automatic validation or recovery ended in failure."
+        else:
+            issue_title = "Run failed"
+            issue_detail = "Inspect logs and run artifacts for the failing step."
         issue_status = "open"
 
     health_passed = bool((gate.get("implementation_signals") or {}).get("health_passed") or smoke.get("health_passed"))
@@ -536,21 +541,65 @@ def _space_target_url_from_bundle(bundle: dict[str, Any], target: str = "") -> s
     return f"https://huggingface.co/spaces/{target}" if target else ""
 
 
-def _space_links_ready_from_bundle(bundle: dict[str, Any]) -> bool:
+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
+    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.
+    """
     identity = bundle.get("space_identity") or {}
-    if identity.get("links_ready") or identity.get("space_created") or identity.get("space_uploaded"):
-        return True
     runtime_upload_epoch = bundle.get("runtime_upload_epoch") or {}
-    if runtime_upload_epoch.get("last_upload_completed_at"):
-        return True
+    runtime_history = runtime_upload_epoch.get("history") if isinstance(runtime_upload_epoch.get("history"), list) else []
+    space_runtime = bundle.get("space_runtime") or {}
+    target = _space_target_from_bundle(bundle) if not target else _normalize_target_space_id(target)
+    target_url = target_url or _space_target_url_from_bundle(bundle, target)
+    create_event_ok = False
+    upload_event_ok = False
     for event in bundle.get("events") or []:
         if not isinstance(event, dict):
             continue
         step = str(event.get("step") or "")
         status = str(event.get("status") or "").lower()
-        if status == "success" and step in {"create_space", "create_space_hardware", "upload_files", "runtime_upload_epoch"}:
-            return True
-    return False
+        if status == "success" and step in {"create_space", "create_space_hardware"}:
+            create_event_ok = True
+        if status == "success" and step in {"upload_files", "runtime_upload_epoch"}:
+            upload_event_ok = True
+    runtime_uploaded = bool(identity.get("runtime_uploaded") or identity.get("space_uploaded") or runtime_upload_epoch.get("last_upload_completed_at") or runtime_upload_epoch.get("upload_sequence") or runtime_history or upload_event_ok)
+    space_runtime_known = bool(identity.get("space_runtime_known") or (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"))))
+    space_created = bool(identity.get("space_created") or (target and (create_event_ok or runtime_uploaded or space_runtime_known)))
+    links_ready = bool(target_url and (identity.get("links_ready") or space_created or runtime_uploaded or space_runtime_known))
+    sources: list[str] = []
+    if identity.get("source"):
+        sources.append(str(identity.get("source")))
+    if create_event_ok:
+        sources.append("create_space_event")
+    if upload_event_ok:
+        sources.append("upload_event")
+    if runtime_uploaded:
+        sources.append("runtime_upload_epoch")
+    if space_runtime_known:
+        sources.append("space_runtime")
+    return {
+        "schema_version": "space_link_state.v198_26_8",
+        "target_space": target,
+        "target_space_id": target,
+        "target_space_known": bool(target),
+        "target_space_url": target_url,
+        "target_space_settings_url": f"{target_url}/settings" if target_url else "",
+        "space_created": bool(space_created),
+        "runtime_uploaded": bool(runtime_uploaded),
+        "space_uploaded": bool(runtime_uploaded),
+        "space_runtime_known": bool(space_runtime_known),
+        "links_ready": bool(links_ready),
+        "can_open_space": bool(links_ready),
+        "source": "+".join(dict.fromkeys([s for s in sources if s])) or "resolved_from_persisted_artifacts",
+    }
+
+
+def _space_links_ready_from_bundle(bundle: dict[str, Any]) -> bool:
+    return bool(build_space_link_state(bundle).get("links_ready"))
 
 
 def _known_gradio_endpoint_info(bundle: dict[str, Any]) -> dict[str, Any]:
@@ -744,11 +793,18 @@ def build_run_view_model(
         elapsed_seconds = int((end - created).total_seconds())
     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)
     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,
         "target_space_settings_url": f"{target_url}/settings" if target_url else "",
         "artifacts_url": summary.get("artifacts_url") or f"https://huggingface.co/buckets/{bucket_source}/tree/{_runs_prefix()}/{run_id}",
+        "links_ready": bool(space_link_state.get("links_ready")),
+        "space_created": bool(space_link_state.get("space_created")),
+        "space_uploaded": bool(space_link_state.get("runtime_uploaded")),
+        "runtime_uploaded": bool(space_link_state.get("runtime_uploaded")),
+        "space_runtime_known": bool(space_link_state.get("space_runtime_known")),
+        "source": space_link_state.get("source") or "",
     }
     return {
         "schema_version": "run_view_model.v1",
@@ -777,6 +833,7 @@ def build_run_view_model(
         "diagnostics": build_diagnostics(bundle, status_model, phase),
         "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,
         "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"),
@@ -785,7 +842,7 @@ def build_run_view_model(
         "actions": {
             "can_resume": status_model["global_status"] in {"running", "stale", "unknown"},
             "can_stop": status_model["global_status"] in {"running", "queued", "unknown"},
-            "can_open_space": bool(target_url and _space_links_ready_from_bundle(bundle)),
+            "can_open_space": bool(space_link_state.get("can_open_space")),
             "can_validate": bool(space_test_policy.get("enabled")),
             "requires_manual_action": status_model["requires_manual_action"],
         },

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.7"
-app_version = "v198.26.7"
+APP_VERSION = "v198.26.8"
+app_version = "v198.26.8"
 
 # Internal agent/recovery files may be needed inside the transient Pi
 # workspace, but they should not be published to the generated Space or shown
@@ -2056,6 +2056,7 @@ def fail(run_dir: Path, events_path: Path, message: str, details: dict | None =
     write_json(run_dir / "state.json", failure_state)
     cleanup_status = run_final_cleanup_if_needed(run_dir, events_path, failure_state)
     failure_state["cleanup"] = cleanup_status
+    write_terminal_status_reconciliation(run_dir, events_path, failure_state, status=status, message=message, details=safe, job_exit_code=1)
     write_final_summary(run_dir, failure_state, {}, {}, status=status, message=message)
     live_failure_data = dict(safe)
     live_failure_data["cleanup"] = cleanup_status
@@ -5250,6 +5251,45 @@ def reconcile_final_success_state(run_dir: Path, events_path: Path | None, final
     return clean
 
 
+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
+    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.
+    """
+    state = final_state or {}
+    safe = safe_details(details or {})
+    runtime_upload_epoch = load_json_if_exists(run_dir / "runtime_upload_epoch.json") if (run_dir / "runtime_upload_epoch.json").exists() else {}
+    space_runtime = load_json_if_exists(run_dir / "space_runtime.json") if (run_dir / "space_runtime.json").exists() else {}
+    runtime_history = runtime_upload_epoch.get("history") if isinstance(runtime_upload_epoch.get("history"), list) else []
+    target_space = state.get("target_space") or state.get("target_space_id") or runtime_upload_epoch.get("target_space_id") or os.environ.get("TARGET_SPACE_ID", "")
+    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",
+        "status": status,
+        "terminal": True,
+        "message": message or state.get("message") or "",
+        "job_exit_code": int(job_exit_code if job_exit_code is not None else (0 if status == "full_inference_success" else 1)),
+        "target_space": target_space,
+        "target_space_url": f"https://huggingface.co/spaces/{target_space}" if target_space else "",
+        "space_created": bool(target_space and (runtime_uploaded or space_runtime_known)),
+        "runtime_uploaded": bool(runtime_uploaded),
+        "space_uploaded": bool(runtime_uploaded),
+        "space_runtime_known": bool(space_runtime_known),
+        "failure_type": safe.get("failure_type") or safe.get("repair_failure_type") or state.get("failure_type") or "",
+        "failure_phase": safe.get("phase") or safe.get("failure_phase") or safe.get("step") or "",
+        "details": safe,
+        "updated_at": now(),
+    }
+    write_json(run_dir / "final_status_reconciliation.json", payload)
+    if events_path is not None:
+        append_event(events_path, "final_status_reconciliation", "success" if status == "full_inference_success" else "failed", "Wrote terminal final status reconciliation", {k: payload.get(k) for k in ("status", "job_exit_code", "target_space", "runtime_uploaded", "space_runtime_known", "failure_type")})
+    return payload
+
+
 
 def _normalize_dependency_package_name(value: str = "") -> str:
     name = re.split(r"[<>=!~;\[,\s]", str(value or "").strip(), 1)[0].strip().lower().replace("_", "-")
@@ -12463,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.7"
+    app_version = "v198.26.8"
     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"