Upload 15 files

src/version.py

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

src/view_models.py

@@ -189,17 +189,27 @@ def _first_authoritative_terminal_status(bundle: dict[str, Any]) -> tuple[str, s
         ("generation_smoke", bundle.get("generation_smoke") or {}),
         ("live_status", bundle.get("live_status") or {}),
     ])
+    blocking_seen = False
     for source_name, source in ordered_sources:
         if not isinstance(source, dict):
             continue
         for key in AUTHORITATIVE_TERMINAL_SOURCE_KEYS:
             normalized = _normalize_terminal_status(source.get(key))
             if normalized:
+                if normalized in BLOCKED_RAW_STATUSES | FAILED_RAW_STATUSES | MANUAL_RAW_STATUSES | AUTH_RAW_STATUSES | CANCELLED_RAW_STATUSES | {"stopped", "stale"}:
+                    return normalized, f"{source_name}.{key}"
+                if normalized == "full_inference_success" and blocking_seen:
+                    continue
                 return normalized, f"{source_name}.{key}"
-        if source.get("ok") is True or source.get("generation_smoke_passed") is True:
+        raw_text = " ".join(_lower(source.get(k)) for k in AUTHORITATIVE_TERMINAL_SOURCE_KEYS if isinstance(source.get(k), (str, int, float, bool)))
+        if any(token in raw_text for token in ("technical_blocker", "technical blocker", "blocked", "failed", "manual_hardware_required", "auth_refresh_required", "stopped")):
+            blocking_seen = True
+        # Metrics/smoke are evidence, not a verdict. They may confirm success
+        # only when no authoritative blocking source has appeared earlier.
+        if not blocking_seen and (source.get("ok") is True or source.get("generation_smoke_passed") is True):
             return "full_inference_success", f"{source_name}.generation_smoke_passed"
         signals = source.get("implementation_signals") if isinstance(source.get("implementation_signals"), dict) else {}
-        if signals.get("generation_smoke_passed") is True:
+        if not blocking_seen and signals.get("generation_smoke_passed") is True:
             return "full_inference_success", f"{source_name}.implementation_signals.generation_smoke_passed"
     return "", ""
 
@@ -868,11 +878,15 @@ def build_space_test_model(bundle: dict[str, Any], status_model: dict[str, Any])
         endpoint = ""
     else:
         endpoint = policy.get("endpoint") or smoke.get("api_name") or smoke.get("endpoint") or "/generate"
+    parent_blocked = _lower(status_model.get("global_status")) in {"blocked", "failed", "auth_refresh_required", "cancelled"} or _lower(status_model.get("verdict")) in BLOCKED_RAW_STATUSES | FAILED_RAW_STATUSES | AUTH_RAW_STATUSES | {"cancelled", "stopped"}
+    smoke_evidence_passed = bool(metrics.get("generation_smoke_passed") or smoke.get("ok") or smoke.get("status") == "success")
+    preview_status = "blocked" if parent_blocked else "passed" if smoke_evidence_passed else "pending"
     return {
         "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 metrics.get("generation_smoke_passed") or smoke.get("ok") or smoke.get("status") == "success" else "pending",
+        "status": preview_status,
+        "smoke_evidence_passed": smoke_evidence_passed,
         "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"),

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.9"
-app_version = "v198.26.9"
+APP_VERSION = "v198.26.10"
+app_version = "v198.26.10"
 
 # 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,14 +3255,44 @@ 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
+    # 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.
     official_only = any(marker in official_only_text for marker in (
-        "official demo", "official space", "does not generate real", "does not load model", "not generate real", "real inference is not", "full inference deferred",
+        "only available in the official",
+        "available only in the official",
+        "use the official demo instead",
+        "use the official space instead",
+        "redirects to the official",
+        "redirect to the official",
+        "this space does not run inference",
+        "this demo does not run inference",
+        "does not generate real",
+        "does not load model",
+        "not generate real",
+        "real inference is not implemented",
+        "full inference is not implemented",
+        "full inference deferred",
     ))
 
     health_passed = validation_health_passed(validation) or bool(generation_smoke.get("health_passed"))
     smoke_status_lower = str(generation_smoke.get("status") or "").lower()
     smoke_passed = smoke_status_lower == "success" or _as_bool_true(generation_smoke.get("ok"))
     demo_usable_smoke = smoke_status_lower == "demo_usable_smoke_passed" or _as_bool_true(generation_smoke.get("demo_usable_smoke_passed"))
+    # A live canonical smoke with positive contracts is runtime proof.  It must
+    # override advisory/heuristic text such as a benign "official Space" mention.
+    runtime_full_inference_proof = bool(
+        smoke_passed
+        and not contract_no_full.get("declared")
+        and not fallback_only
+        and not real_inference_false
+        and not full_inference_false
+        and not diagnostic_level
+        and not manual_required
+    )
+    if runtime_full_inference_proof:
+        official_only = False
     no_full_reason = contract_no_full.get("declared") or fallback_only or real_inference_false or full_inference_false or diagnostic_level or official_only or manual_required
 
     if manual_required:
@@ -9732,8 +9762,14 @@ def infer_generation_gate(workspace: Path, implementation_mode: str, validation:
         "returns a detailed diagnostic",
         "diagnostic report instead",
         "diagnostic demo",
-        "official demo",
-        "official space",
+        "only available in the official",
+        "available only in the official",
+        "use the official demo instead",
+        "use the official space instead",
+        "redirects to the official",
+        "redirect to the official",
+        "this space does not run inference",
+        "this demo does not run inference",
         "does not generate real",
         "does not load model weights",
         "does not generate real audio",
@@ -9752,6 +9788,30 @@ 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
+    # 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
+    # blockers (contract_no_full/manual/scaffold).
+    runtime_smoke_contract_positive = bool(
+        full_inference_requested
+        and smoke_ok
+        and not contract_no_full
+        and not promise_validation.get("manual_hardware_required")
+    )
+    if runtime_smoke_contract_positive and diagnostic_contract and not blockers:
+        promise_validation = {
+            **promise_validation,
+            "promise_validation_status": "fulfilled",
+            "promise_fulfilled": True,
+            "ui_status": "full_inference_success",
+            "ui_badge": "Full inference",
+            "diagnostic_only": False,
+            "reason": "A canonical live generation smoke test passed; heuristic diagnostic wording was downgraded.",
+            "v198_26_10_runtime_smoke_overrode_diagnostic": True,
+        }
+        diagnostic_contract = False
+        promise_fulfilled = True
     heuristic_marker_detected = any(m in combined for m in blocked_markers)
     scaffold_detected = bool(scaffold_detection.get("detected"))
     blocker_source = str(blockers.get("source") or "") if isinstance(blockers, dict) else ""
@@ -12503,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.9"
+    app_version = "v198.26.10"
     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"