Upload 16 files

src/bucket.py

@@ -12,6 +12,7 @@ from huggingface_hub import HfFileSystem, bucket_info, create_bucket, sync_bucke
 
 from .config import bucket_uri_from_source, normalize_bucket_name, settings, user_bucket_source
 from .effective_status import compute_effective_run_status
+from .target_space_identity import target_space_identity_overlay
 from .security import redact
 
 
@@ -1613,6 +1614,8 @@ def summarize_run_bundle(run_id: str, bundle: dict[str, Any], *, bucket_source:
         "full_inference_success",
         "validated_after_space_test",
         "validated_after_manual_space_test",
+        "success_with_expert_intervention",
+        "expert_intervention_validation_passed",
         "recovered_by_space_test",
         "recovered_by_manual_validation",
         "manual_validation_passed",
@@ -1640,6 +1643,8 @@ def summarize_run_bundle(run_id: str, bundle: dict[str, Any], *, bucket_source:
         "full_inference_success",
         "validated_after_space_test",
         "validated_after_manual_space_test",
+        "success_with_expert_intervention",
+        "expert_intervention_validation_passed",
         "recovered_by_space_test",
         "recovered_by_manual_validation",
         "manual_validation_passed",
@@ -1658,7 +1663,8 @@ def summarize_run_bundle(run_id: str, bundle: dict[str, Any], *, bucket_source:
     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 {}
-    target_space = state.get("target_space") or launch.get("target_space") or summary_file.get("target_space") or ""
+    target_overlay = target_space_identity_overlay(bundle)
+    target_space = target_overlay.get("target_space") or state.get("target_space") or launch.get("target_space") or summary_file.get("target_space") or ""
     kind = state.get("kind") or launch.get("kind") or summary_file.get("kind") or "unknown"
     is_validation = "validate" in str(kind).lower() or str(run_id).startswith("validate-")
     if is_validation:
@@ -1704,7 +1710,12 @@ def summarize_run_bundle(run_id: str, bundle: dict[str, Any], *, bucket_source:
         "model_id": state.get("model_id") or launch.get("model_id") or summary_file.get("model_id") or state.get("model") or "",
         "pi_model": state.get("pi_model") or launch.get("pi_model") or summary_file.get("pi_model") or (bundle.get("pi_model_resolution") or {}).get("requested_model") or "",
         "target_space": target_space,
-        "target_space_url": state.get("target_space_url") or launch.get("target_space_url") or summary_file.get("target_space_url") or (f"https://huggingface.co/spaces/{target_space}" if target_space else ""),
+        "target_space_id": target_space,
+        "target_space_url": target_overlay.get("target_space_url") or state.get("target_space_url") or launch.get("target_space_url") or summary_file.get("target_space_url") or (f"https://huggingface.co/spaces/{target_space}" if target_space else ""),
+        "target_space_settings_url": target_overlay.get("target_space_settings_url") or (f"https://huggingface.co/spaces/{target_space}/settings" if target_space else ""),
+        "target_space_original": target_overlay.get("target_space_original") or "",
+        "target_space_override_active": bool(target_overlay.get("target_space_override_active")),
+        "target_space_source": target_overlay.get("target_space_source") or "generated_run",
         "job_id": state.get("job_id") or launch.get("job_id") or summary_file.get("job_id") or "",
         "job_url": _job_url_from_sources(bucket_source=bucket_source, summary_file=summary_file, launch=launch, state=state),
         "created_at": state.get("created_at") or launch.get("created_at") or summary_file.get("created_at") or "",
@@ -1784,6 +1795,7 @@ def read_run_bundle(run_id: str, *, bucket_source: str, token: str | None = None
         "pi_model_resolution": _safe_read_json(f"{paths.root}/pi_model_resolution.json", token=token) or (read_json(paths.state, token=token) or {}).get("pi_model_resolution") or {},
         "space_runtime": _safe_read_json(f"{paths.root}/space_runtime.json", token=token),
         "runtime_upload_epoch": _safe_read_json(f"{paths.root}/runtime_upload_epoch.json", token=token),
+        "target_space_override": _safe_read_json(f"{paths.root}/TARGET_SPACE_OVERRIDE.json", token=token),
         "placeholder_scaffold_detection": _safe_read_json(f"{paths.root}/placeholder_scaffold_detection.json", token=token),
         "api_schema": _safe_read_json(f"{paths.root}/tests/api_schema.json", token=token) or _safe_read_json(f"{paths.root}/tests/generation_api_schema.json", token=token),
         "validation_payload": _safe_read_json(f"{paths.root}/tests/validation_payload.json", token=token),
@@ -1954,7 +1966,7 @@ def _build_run_list_item_from_files(run_id: str, *, root: str, bucket_source: st
         item["effective_status"] = post_build_validation_status.get("effective_status") or item.get("effective_status")
     if linked_validations:
         rows = linked_validations.get("validations") if isinstance(linked_validations, dict) else []
-        terminal_tokens = {"success", "passed", "succeeded", "full_inference_success", "validated_after_space_test", "validated_after_manual_space_test", "recovered_by_space_test", "recovered_by_manual_validation", "manual_validation_passed", "manual_validated", "partial_validation", "manual_hardware_required", "generated_needs_manual_hardware", "technical_blocker", "technical_blocker_boot_only", "blocked", "completed_with_warnings", "failed", "failure", "error", "auth_refresh_required", "stale", "stopped", "cancelled", "canceled"}
+        terminal_tokens = {"success", "passed", "succeeded", "full_inference_success", "validated_after_space_test", "validated_after_manual_space_test", "success_with_expert_intervention", "expert_intervention_validation_passed", "recovered_by_space_test", "recovered_by_manual_validation", "manual_validation_passed", "manual_validated", "partial_validation", "manual_hardware_required", "generated_needs_manual_hardware", "technical_blocker", "technical_blocker_boot_only", "blocked", "completed_with_warnings", "failed", "failure", "error", "auth_refresh_required", "stale", "stopped", "cancelled", "canceled"}
         accounted_rows = [row for row in rows if isinstance(row, dict) and str(row.get("status") or row.get("validation_status") or row.get("result_status") or row.get("effective_status") or "").lower() in terminal_tokens] if isinstance(rows, list) else []
         item["linked_validations"] = linked_validations
         item["linked_validation_count"] = len(accounted_rows)

src/effective_status.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 from typing import Any
 
+from .target_space_identity import target_space_identity_overlay
+
 
 SUCCESS_VALIDATION_TOKENS = {
     "success",
@@ -15,6 +17,8 @@ SUCCESS_VALIDATION_TOKENS = {
     "manual_validated",
     "recovered_by_manual_validation",
     "recovered_by_space_test",
+    "success_with_expert_intervention",
+    "expert_intervention_validation_passed",
 }
 
 PARTIAL_BUILD_TOKENS = {
@@ -54,6 +58,9 @@ def _first_nonempty(*values: Any) -> str:
 
 
 def _target_space_from_bundle(bundle: dict[str, Any]) -> str:
+    overlay = target_space_identity_overlay(bundle)
+    if overlay.get("target_space"):
+        return str(overlay.get("target_space") or "")
     summary = bundle.get("summary") or bundle.get("summary_file") or {}
     state = bundle.get("state") or {}
     launch = bundle.get("launch") or {}
@@ -180,6 +187,8 @@ def _successful_post_build_validation(bundle: dict[str, Any]) -> dict[str, Any]:
 
 def _normalize_build_status(value: Any) -> str:
     status = _lower(value)
+    if status in {"success_with_expert_intervention", "expert_intervention_validation_passed"}:
+        return "success_with_expert_intervention"
     if status in {"succeeded", "success", "passed", "done", "completed", "repair_success"}:
         return "full_inference_success"
     if status in {"repair_validation_failed", "upload_failed", "smoke_still_failed", "repair_failed_same_error", "repair_exhausted", "no_patch_produced_by_pi", "no_relevant_patch_produced_by_pi", "pi_patch_rejected_by_guard"}:
@@ -235,8 +244,23 @@ def compute_effective_run_status(
     can_promote = bool(post)
     promotion_reason = ""
 
+    expert_intervention_required = bool(
+        post.get("expert_intervention_required")
+        or post.get("accepted_outcome") == "success_with_expert_intervention"
+        or post.get("expert_acceptance")
+    ) if isinstance(post, dict) else False
+
     if can_promote:
-        if (
+        if expert_intervention_required:
+            display_status = "success_with_expert_intervention"
+            legacy_effective_status = "recovered_by_manual_validation" if (
+                normalized_build in FAILED_BUILD_TOKENS
+                or "failed" in normalized_build
+                or normalized_build in BLOCKED_BUILD_TOKENS
+                or "technical_blocker" in normalized_build
+            ) else "validated_after_manual_space_test"
+            promotion_reason = "expert_intervention_acceptance_validation_success"
+        elif (
             normalized_build in FAILED_BUILD_TOKENS
             or "failed" in normalized_build
             or normalized_build in BLOCKED_BUILD_TOKENS
@@ -244,14 +268,16 @@ def compute_effective_run_status(
         ):
             display_status = "recovered_by_space_test"
             legacy_effective_status = "recovered_by_manual_validation"
+            promotion_reason = "linked_space_test_success"
         else:
             display_status = "validated_after_space_test"
             legacy_effective_status = "validated_after_manual_space_test"
-        if can_promote:
-            post_build_status = display_status
             promotion_reason = "linked_space_test_success"
+        post_build_status = display_status
 
-    if display_status == "validated_after_space_test":
+    if display_status == "success_with_expert_intervention":
+        display_label = "Success with expert intervention"
+    elif display_status == "validated_after_space_test":
         display_label = "Validated after Space Test"
     elif display_status == "recovered_by_space_test":
         display_label = "Recovered by Space Test"
@@ -279,18 +305,20 @@ def compute_effective_run_status(
         display_label = display_status.replace("_", " ").title() if display_status else "Unknown"
 
     return {
-        "schema_version": "effective_run_status.v198_26_6",
+        "schema_version": "effective_run_status.v198_26_120",
         "build_status": normalized_build,
         "build_verdict": normalized_verdict,
         "build_verdict_preserved": True,
         "post_build_status": post_build_status,
         "post_build_validation": {
             "status": "success" if can_promote else ("blocked" if post and not can_promote else "none"),
-            "source": "linked_space_test" if post else "none",
+            "source": "expert_intervention_acceptance" if (post and expert_intervention_required) else ("linked_space_test" if post else "none"),
             "validation_run_id": post.get("validation_run_id") or post.get("run_id") or "",
             "target_space": post.get("target_space") or post.get("target_space_id") or "",
             "api_name": post.get("api_name") or "",
             "updated_at": post.get("updated_at") or post.get("validated_at") or "",
+            "expert_intervention_required": expert_intervention_required,
+            "accepted_outcome": post.get("accepted_outcome") or ("success_with_expert_intervention" if expert_intervention_required else ""),
         },
         "display_status": display_status,
         "display_label": display_label,

src/eval_archive.py

@@ -9,7 +9,7 @@ from .bucket import RunPaths, read_json, read_text, write_json
 from .eval_config import effective_eval_config
 from .security import redact
 
-_TERMINAL = {"success", "done", "completed", "failed", "failure", "error", "cancelled", "canceled", "manual", "stale", "partial", "partial_validation", "completed_with_warnings", "success_with_warnings", "validated", "validated_after_manual_space_test", "recovered_by_manual_validation", "validated_after_stale_run", "manual_validation_passed", "full_inference_success", "full_inference_candidate_health_passed", "health_only", "technical_blocker", "technical_blocker_boot_only", "manual_hardware_required"}
+_TERMINAL = {"success", "done", "completed", "failed", "failure", "error", "cancelled", "canceled", "manual", "stale", "partial", "partial_validation", "completed_with_warnings", "success_with_warnings", "validated", "validated_after_manual_space_test", "success_with_expert_intervention", "expert_intervention_validation_passed", "recovered_by_manual_validation", "validated_after_stale_run", "manual_validation_passed", "full_inference_success", "full_inference_candidate_health_passed", "health_only", "technical_blocker", "technical_blocker_boot_only", "manual_hardware_required"}
 
 
 def _now() -> str:
@@ -59,7 +59,7 @@ def _first_successful_linked_validation(payload: dict[str, Any] | None) -> dict[
     if not isinstance(payload, dict):
         return {}
     rows = payload.get("validations") if isinstance(payload.get("validations"), list) else []
-    success_tokens = {"success", "passed", "full_inference_success", "validated_after_manual_space_test", "recovered_by_manual_validation"}
+    success_tokens = {"success", "passed", "full_inference_success", "validated_after_manual_space_test", "success_with_expert_intervention", "expert_intervention_validation_passed", "recovered_by_manual_validation"}
     for row in reversed(rows):
         if isinstance(row, dict) and str(row.get("status") or row.get("effective_status") or "").lower() in success_tokens:
             return row

src/jobs.py

@@ -351,6 +351,8 @@ def launch_validate_existing_space_job(
     effective_status_on_success: str | None = None,
     parent_replay_source_json: str | None = None,
     validation_launch_payload_json: str | None = None,
+    expert_intervention_required: bool = False,
+    expert_intervention_note: str | None = None,
     run_id: str | None = None,
     bucket_name: str | None = None,
 ) -> dict[str, Any]:
@@ -382,6 +384,9 @@ def launch_validate_existing_space_job(
     env["VALIDATION_LINK_MODE"] = "build_run"
     env["SPACE_TEST_POLICY_MODE"] = (validation_mode or "complete").strip()
     env["EFFECTIVE_STATUS_ON_SUCCESS"] = (effective_status_on_success or "validated_after_manual_space_test").strip()
+    env["EXPERT_INTERVENTION_REQUIRED"] = "true" if expert_intervention_required else "false"
+    if expert_intervention_note:
+        env["EXPERT_INTERVENTION_NOTE"] = ensure_validation_payload_json_fits_env(expert_intervention_note, field_name="expert_intervention_note")
     env["API_NAME"] = (api_name if api_name is not None else "/generate").strip()
     env["ENDPOINT_DISCOVERY_REQUIRED"] = "true" if not env["API_NAME"] else "false"
     env["TEST_ARGS_JSON"] = ensure_validation_payload_json_fits_env(test_args_json or '["a cinematic robot cat astronaut, detailed, studio lighting"]', field_name="test_args_json")
@@ -414,6 +419,8 @@ def launch_validate_existing_space_job(
             "linked_target_space": target,
             "space_test_policy_mode": env.get("SPACE_TEST_POLICY_MODE"),
             "effective_status_on_success": env.get("EFFECTIVE_STATUS_ON_SUCCESS"),
+            "expert_intervention_required": env.get("EXPERT_INTERVENTION_REQUIRED") == "true",
+            "expert_intervention_note_present": bool(env.get("EXPERT_INTERVENTION_NOTE")),
             "api_name": env["API_NAME"] or "<discover>",
             "endpoint_discovery_required": env.get("ENDPOINT_DISCOVERY_REQUIRED") == "true",
             "expected_output_type": env["EXPECTED_OUTPUT_TYPE"],

src/target_space_identity.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+import re
+from typing import Any
+
+TARGET_SPACE_OVERRIDE_FILENAME = "TARGET_SPACE_OVERRIDE.json"
+TARGET_SPACE_OVERRIDE_CLEARED_STATUS = "cleared"
+
+
+def normalize_target_space_id(value: Any) -> str:
+    text = str(value or "").strip()
+    if not text or text == "—":
+        return ""
+    text = text.replace("https://huggingface.co/spaces/", "").strip("/")
+    text = text.split("/settings", 1)[0].strip("/")
+    text = text.split("?", 1)[0].split("#", 1)[0].strip("/")
+    if ".hf.space" in text and "/" not in text:
+        return ""
+    return text if re.match(r"^[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+$", text) else ""
+
+
+def _first_nonempty(*values: Any) -> str:
+    for value in values:
+        text = str(value or "").strip()
+        if text:
+            return text
+    return ""
+
+
+def _target_space_from_events(events: list[dict[str, Any]] | None, *, require_success: bool = False) -> str:
+    for event in reversed(events or []):
+        if not isinstance(event, dict):
+            continue
+        step = str(event.get("step") or "")
+        status = str(event.get("status") or "").lower()
+        if step not in {"create_space", "create_space_hardware", "upload_files", "runtime_upload_epoch"}:
+            continue
+        if require_success and status != "success":
+            continue
+        data = event.get("data") if isinstance(event.get("data"), dict) else {}
+        target = normalize_target_space_id(data.get("target_space") or data.get("target_space_id"))
+        if target:
+            return target
+    return ""
+
+
+def target_space_url(target_space_id: Any) -> str:
+    target = normalize_target_space_id(target_space_id)
+    return f"https://huggingface.co/spaces/{target}" if target else ""
+
+
+def active_target_space_override(bundle: dict[str, Any] | None) -> dict[str, Any]:
+    override = (bundle or {}).get("target_space_override") or {}
+    if not isinstance(override, dict):
+        return {}
+    if str(override.get("status") or "active").strip().lower() == TARGET_SPACE_OVERRIDE_CLEARED_STATUS:
+        return {}
+    target = normalize_target_space_id(override.get("target_space_id") or override.get("target_space"))
+    if not target:
+        return {}
+    return {**override, "target_space_id": target, "target_space": target, "target_space_url": target_space_url(target)}
+
+
+def original_target_space_from_bundle(bundle: dict[str, Any] | None) -> str:
+    bundle = bundle or {}
+    summary = bundle.get("summary") or bundle.get("summary_file") or {}
+    state = bundle.get("state") or {}
+    launch = bundle.get("launch") or {}
+    runtime_upload_epoch = bundle.get("runtime_upload_epoch") or {}
+    return normalize_target_space_id(_first_nonempty(
+        summary.get("target_space"), summary.get("target_space_id"),
+        state.get("target_space"), state.get("target_space_id"),
+        launch.get("target_space"), launch.get("target_space_id"),
+        runtime_upload_epoch.get("target_space_id"), runtime_upload_epoch.get("target_space"),
+        _target_space_from_events(bundle.get("events") or []),
+    ))
+
+
+def effective_target_space_from_bundle(bundle: dict[str, Any] | None) -> str:
+    override = active_target_space_override(bundle)
+    if override:
+        return normalize_target_space_id(override.get("target_space_id"))
+    return original_target_space_from_bundle(bundle)
+
+
+def target_space_identity_overlay(bundle: dict[str, Any] | None) -> dict[str, Any]:
+    original = original_target_space_from_bundle(bundle)
+    override = active_target_space_override(bundle)
+    effective = normalize_target_space_id(override.get("target_space_id") if override else original)
+    return {
+        "target_space": effective,
+        "target_space_id": effective,
+        "target_space_url": target_space_url(effective),
+        "target_space_settings_url": f"{target_space_url(effective)}/settings" if effective else "",
+        "target_space_original": original,
+        "target_space_original_url": target_space_url(original),
+        "target_space_override_active": bool(override),
+        "target_space_override": override,
+        "target_space_source": "manual_override" if override else "generated_run",
+    }

src/version.py

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

src/view_models.py

@@ -8,6 +8,7 @@ from .progress import STEP_ALIASES, STEP_LABELS, STEP_ORDER
 from .timeline_model import build_run_timeline_model
 from .config import settings
 from .effective_status import compute_effective_run_status
+from .target_space_identity import target_space_identity_overlay
 
 PRODUCT_STEPS = [{"id": step, "label": STEP_LABELS[step]} for step in STEP_ORDER]
 
@@ -47,7 +48,7 @@ RUNNING_RAW_STATUSES = {"started", "running", "waiting", "queued", "pending", "s
 AUTH_RAW_STATUSES = {"auth_refresh_required", "oauth_expired", "auth_expired", "repair_validation_inconclusive_auth", "inconclusive_auth_expired"}
 
 AUTHORITATIVE_TERMINAL_SOURCE_KEYS = ("status", "final_status", "effective_status", "effective_verdict", "display_status", "verdict", "result_status", "validation_status", "post_repair_validation", "failure_type")
-TERMINAL_DISPLAY_STATUSES = SUCCESS_RAW_STATUSES | PARTIAL_RAW_STATUSES | MANUAL_RAW_STATUSES | FAILED_RAW_STATUSES | CANCELLED_RAW_STATUSES | BLOCKED_RAW_STATUSES | AUTH_RAW_STATUSES | {"stale", "stopped", "succeeded", "validated_after_space_test", "validated_after_manual_space_test", "recovered_by_space_test", "recovered_by_manual_validation"}
+TERMINAL_DISPLAY_STATUSES = SUCCESS_RAW_STATUSES | PARTIAL_RAW_STATUSES | MANUAL_RAW_STATUSES | FAILED_RAW_STATUSES | CANCELLED_RAW_STATUSES | BLOCKED_RAW_STATUSES | AUTH_RAW_STATUSES | {"stale", "stopped", "succeeded", "validated_after_space_test", "validated_after_manual_space_test", "success_with_expert_intervention", "expert_intervention_validation_passed", "recovered_by_space_test", "recovered_by_manual_validation"}
 
 STEP_TO_PHASE = {step: step for step in STEP_ORDER} | {alias: canonical for alias, canonical in STEP_ALIASES.items()}
 
@@ -545,6 +546,9 @@ def _space_target_from_events(events: list[dict[str, Any]] | None, *, require_su
 
 
 def _space_target_from_bundle(bundle: dict[str, Any]) -> str:
+    overlay = target_space_identity_overlay(bundle)
+    if overlay.get("target_space"):
+        return _normalize_target_space_id(overlay.get("target_space"))
     summary = bundle.get("summary") or {}
     state = bundle.get("state") or {}
     launch = bundle.get("launch") or {}
@@ -564,6 +568,9 @@ def _space_target_from_bundle(bundle: dict[str, Any]) -> str:
 
 
 def _space_target_url_from_bundle(bundle: dict[str, Any], target: str = "") -> str:
+    overlay = target_space_identity_overlay(bundle)
+    if overlay.get("target_space_url"):
+        return str(overlay.get("target_space_url"))
     summary = bundle.get("summary") or {}
     state = bundle.get("state") or {}
     launch = bundle.get("launch") or {}
@@ -622,6 +629,9 @@ def build_space_link_state(bundle: dict[str, Any], *, target: str = "", target_u
         "target_space_known": bool(target),
         "target_space_url": target_url,
         "target_space_settings_url": f"{target_url}/settings" if target_url else "",
+        "target_space_original": target_space_identity_overlay(bundle).get("target_space_original") or "",
+        "target_space_override_active": bool(target_space_identity_overlay(bundle).get("target_space_override_active")),
+        "target_space_source": target_space_identity_overlay(bundle).get("target_space_source") or "generated_run",
         "space_created": bool(space_created),
         "runtime_uploaded": bool(runtime_uploaded),
         "space_uploaded": bool(runtime_uploaded),
@@ -679,7 +689,7 @@ def _latest_successful_linked_validation(bundle: dict[str, Any]) -> dict[str, An
     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"}]
+    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", "success_with_expert_intervention", "expert_intervention_validation_passed"}]
     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)

src/worker_payload.py

@@ -40,8 +40,8 @@ DEFAULT_FALLBACK_SPACE_HARDWARE = "a10g-large"
 DEFAULT_MODEL_ID = "sshleifer/tiny-gpt2"
 MAX_PI_REPAIR_ATTEMPTS = 3
 DEFAULT_FACTORY_UPLOAD_RETRY_BUDGET = 1
-APP_VERSION = "v198.26.119"
-app_version = "v198.26.119"
+APP_VERSION = "v198.26.121"
+app_version = "v198.26.121"
 
 # Internal agent/recovery files may be needed inside the transient Pi
 # workspace, but they should not be published to the generated Space or shown
@@ -144,6 +144,10 @@ RUNTIME_PAYLOAD_RELEASE_ARTIFACT_FILENAMES = {
     "SMOKE_PRIMARY_ERROR.json",
     "MEMORY_DIAGNOSIS_PACKET.json",
     "RUNTIME_RISK_HINTS.json",
+    "EXPERT_INTERVENTION_ACCEPTANCE.json",
+    "EXPERT_ACCEPTANCE_RESULT.json",
+    "TARGET_SPACE_OVERRIDE.json",
+    "TARGET_SPACE_ID_OVERRIDE.json",
 }
 
 
@@ -510,7 +514,7 @@ def build_runtime_risk_hints(workspace: Path, run_dir: Path, events_path: Path,
         )
 
     payload = {
-        "schema_version": "runtime_risk_hints.v198_26_119",
+        "schema_version": "runtime_risk_hints.v198_26_121",
         "mode": "advisory_only",
         "reason": reason,
         "auto_applied": False,
@@ -19607,7 +19611,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.119"
+    app_version = "v198.26.121"
     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"
@@ -20042,12 +20046,14 @@ def main():
     output_root = Path(os.environ.get("OUTPUT_ROOT", "/output"))
     target_space_id = os.environ["TARGET_SPACE_ID"].strip()
     parent_build_run_id = os.environ.get("PARENT_BUILD_RUN_ID", "").strip()
+    expert_intervention_required = str(os.environ.get("EXPERT_INTERVENTION_REQUIRED") or "").strip().lower() in {"1", "true", "yes", "on"}
+    expert_intervention_note = (os.environ.get("EXPERT_INTERVENTION_NOTE") or "").strip()
     token = os.environ.get("HF_TOKEN")
     run_dir = output_root / "runs" / run_id
     events_path = run_dir / "events.jsonl"
     state_path = run_dir / "state.json"
-    append_event(events_path, "bootstrap", "started", "Existing Space validation worker started", {"target_space_id": target_space_id})
-    write_json(state_path, {"run_id": run_id, "kind": "linked_space_validation", "status": "running", "target_space": target_space_id, "parent_build_run_id": parent_build_run_id, "source_kind": "build_run_prefill", "created_by": username, "updated_at": now()})
+    append_event(events_path, "bootstrap", "started", "Existing Space validation worker started", {"target_space_id": target_space_id, "expert_intervention_required": expert_intervention_required})
+    write_json(state_path, {"run_id": run_id, "kind": "linked_space_validation", "status": "running", "target_space": target_space_id, "parent_build_run_id": parent_build_run_id, "source_kind": "build_run_prefill", "expert_intervention_required": expert_intervention_required, "created_by": username, "updated_at": now()})
     if not token:
         raise RuntimeError("HF_TOKEN is missing")
     ensure_hf_token_context(run_dir, events_path)
@@ -20073,6 +20079,8 @@ def main():
             "target_space_url": f"https://huggingface.co/spaces/{target_space_id}",
             "live_validation": live,
             "generation_smoke": smoke,
+            "expert_intervention_required": expert_intervention_required,
+            "expert_intervention_note_present": bool(expert_intervention_note),
             "updated_at": now(),
         }
         final_state["parent_build_run_id"] = parent_build_run_id
@@ -20088,10 +20096,33 @@ def main():
             expected_output_type_used = smoke.get("expected_output_type") or os.environ.get("EXPECTED_OUTPUT_TYPE") or "any"
             effective_status_on_success = os.environ.get("EFFECTIVE_STATUS_ON_SUCCESS") or "validated_after_space_test"
             space_test_policy_mode = os.environ.get("SPACE_TEST_POLICY_MODE") or "complete"
+            expert_acceptance = None
+            if expert_intervention_required:
+                effective_status_on_success = "success_with_expert_intervention"
+                expert_acceptance = {
+                    "schema_version": "expert_intervention_acceptance.v198_26_121",
+                    "status": "validated",
+                    "accepted_outcome": "success_with_expert_intervention",
+                    "expert_intervention_required": True,
+                    "expert_intervention_note": expert_intervention_note,
+                    "parent_build_run_id": parent_build_run_id,
+                    "validation_run_id": run_id,
+                    "target_space": target_space_id,
+                    "api_name": api_name_used,
+                    "expected_output_type": expected_output_type_used,
+                    "validation_status": "full_inference_success",
+                    "validated_at": now(),
+                    "raw_build_status_preserved": True,
+                }
+                write_json(run_dir / "EXPERT_INTERVENTION_ACCEPTANCE.json", expert_acceptance)
+                write_json(parent_dir / "EXPERT_INTERVENTION_ACCEPTANCE.json", expert_acceptance)
             manual_status = {
-                "schema_version": "post_build_validation.v198_26_7",
+                "schema_version": "post_build_validation.v198_26_121",
                 "status": "success",
                 "effective_status": effective_status_on_success,
+                "expert_intervention_required": expert_intervention_required,
+                "expert_intervention_note_present": bool(expert_intervention_note),
+                "accepted_outcome": "success_with_expert_intervention" if expert_intervention_required else effective_status_on_success,
                 "legacy_effective_status": "validated_after_manual_space_test",
                 "space_test_policy_mode": space_test_policy_mode,
                 "validation_run_id": run_id,
@@ -20108,6 +20139,8 @@ def main():
                 "validated_at": now(),
                 "applies_to_target_space": True,
             }
+            if expert_acceptance:
+                manual_status["expert_acceptance"] = {k: v for k, v in expert_acceptance.items() if k != "expert_intervention_note"}
             write_json(parent_dir / "post_build_validation_status.json", manual_status)
             write_json(parent_dir / "manual_validation_status.json", manual_status)
             linked_path = parent_dir / "linked_validations.json"
@@ -20119,9 +20152,9 @@ def main():
             if not isinstance(validations, list):
                 validations = []
             validations.append(manual_status)
-            linked = {"parent_build_run_id": parent_build_run_id, "effective_status": effective_status_on_success, "validations": validations, "updated_at": now()}
+            linked = {"parent_build_run_id": parent_build_run_id, "effective_status": effective_status_on_success, "expert_intervention_required": expert_intervention_required, "validations": validations, "updated_at": now()}
             write_json(linked_path, linked)
-            update_runs_index(parent_dir, {"run_id": parent_build_run_id, "manual_validation_passed": True, "post_build_status": effective_status_on_success, "effective_status": effective_status_on_success, "linked_validation_count": len(validations), "linked_validations_count": len(validations), "latency_seconds": manual_status.get("latency_seconds"), "observed_latency_seconds": manual_status.get("observed_latency_seconds"), "recommended_zero_gpu_duration_seconds": manual_status.get("recommended_zero_gpu_duration_seconds"), "recommendation_source": "linked_space_test", "recommendation_hardware": manual_status.get("recommendation_hardware"), "hardware_used_for_validation": manual_status.get("hardware_used_for_validation"), "updated_at": now()})
+            update_runs_index(parent_dir, {"run_id": parent_build_run_id, "manual_validation_passed": True, "expert_intervention_required": expert_intervention_required, "expert_acceptance_status": "validated" if expert_intervention_required else "none", "post_build_status": effective_status_on_success, "effective_status": effective_status_on_success, "linked_validation_count": len(validations), "linked_validations_count": len(validations), "latency_seconds": manual_status.get("latency_seconds"), "observed_latency_seconds": manual_status.get("observed_latency_seconds"), "recommended_zero_gpu_duration_seconds": manual_status.get("recommended_zero_gpu_duration_seconds"), "recommendation_source": "expert_intervention_acceptance" if expert_intervention_required else "linked_space_test", "recommendation_hardware": manual_status.get("recommendation_hardware"), "hardware_used_for_validation": manual_status.get("hardware_used_for_validation"), "updated_at": now()})
         report = f"""# Agentic Space Factory — Existing Space Validation Report
 
 Status: **full_inference_success**
@@ -20161,14 +20194,14 @@ Target Space: [`{target_space_id}`](https://huggingface.co/spaces/{target_space_
             details["status_reason"] = "auth_refresh_required"
             details["failure_type"] = "auth_refresh_required"
         terminal_status = "auth_refresh_required" if auth_blocked else "failed"
-        failure_state = {"run_id": run_id, "kind": "linked_space_validation", "status": terminal_status, "message": "HF OAuth token expired or will expire too soon; refresh sign-in before continuing" if auth_blocked else str(exc), "target_space": target_space_id, "parent_build_run_id": parent_build_run_id, "source_kind": "build_run_prefill", "details": details, "updated_at": now()}
+        failure_state = {"run_id": run_id, "kind": "linked_space_validation", "status": terminal_status, "message": "HF OAuth token expired or will expire too soon; refresh sign-in before continuing" if auth_blocked else str(exc), "target_space": target_space_id, "parent_build_run_id": parent_build_run_id, "source_kind": "build_run_prefill", "expert_intervention_required": expert_intervention_required, "details": details, "updated_at": now()}
         write_json(state_path, failure_state)
         write_final_summary(run_dir, failure_state, {}, {"status": terminal_status, "failure_type": details.get("failure_type", "linked_validation_failed") if isinstance(details, dict) else "linked_validation_failed"}, status=terminal_status, message=str(failure_state.get("message") or details.get("error", "Existing Space validation failed")) if isinstance(details, dict) else "Existing Space validation failed")
         append_event(events_path, "failure", "failed", "Existing Space validation failed; terminal state was written before log collection", details)
         if parent_build_run_id:
             parent_dir = output_root / "runs" / parent_build_run_id
             parent_dir.mkdir(parents=True, exist_ok=True)
-            failed_status = {"schema_version": "post_build_validation.v198_26_7", "status": terminal_status, "validation_run_id": run_id, "parent_build_run_id": parent_build_run_id, "target_space": target_space_id, "details": details, "updated_at": now(), "effective_status": "unchanged"}
+            failed_status = {"schema_version": "post_build_validation.v198_26_121", "status": terminal_status, "validation_run_id": run_id, "parent_build_run_id": parent_build_run_id, "target_space": target_space_id, "expert_intervention_required": expert_intervention_required, "expert_acceptance_status": "validation_failed" if expert_intervention_required else "none", "details": details, "updated_at": now(), "effective_status": "unchanged"}
             linked_path = parent_dir / "linked_validations.json"
             linked = read_json(linked_path, {"parent_build_run_id": parent_build_run_id, "validations": []}) or {"parent_build_run_id": parent_build_run_id, "validations": []}
             validations = linked.get("validations") if isinstance(linked, dict) else []