Fix live inference slider regression

Dockerfile

@@ -1,8 +1,10 @@
 FROM python:3.11-slim
 
+ARG DCV_BUILD_SHA=unknown
 ENV PYTHONUNBUFFERED=1
 ENV DCV_MODEL_RUN_DIR=data/model_runs/synthetic_v1_baseline
 ENV DCV_FEATURE_TABLE=data/synthetic_v1/features/window_features_all.csv
+ENV DCV_BUILD_SHA=${DCV_BUILD_SHA}
 
 WORKDIR /app
 
@@ -12,5 +14,6 @@ RUN pip install --no-cache-dir -r /tmp/requirements-api.txt
 COPY src ./src
 COPY data/model_runs/synthetic_v1_baseline ./data/model_runs/synthetic_v1_baseline
 COPY data/synthetic_v1/features/window_features_all.csv ./data/synthetic_v1/features/window_features_all.csv
+RUN printf '%s\n' "${DCV_BUILD_SHA}" > /app/.dcv-build-sha
 
 CMD ["sh", "-c", "uvicorn src.datacenter_verification_api.app:app --host 0.0.0.0 --port ${PORT:-7860}"]

src/datacenter_verification_api/__init__.py

@@ -1,5 +1,76 @@
 """Live inference API for the datacenter verification demo."""
 
-__all__ = ["__version__"]
+from __future__ import annotations
+
+import os
+import subprocess
+from functools import cache
+from pathlib import Path
+from typing import NamedTuple
+
+__all__ = ["__version__", "BuildInfo", "build_info"]
 
 __version__ = "0.1.0"
+
+
+class BuildInfo(NamedTuple):
+    sha: str | None
+    source: str | None
+
+
+def _clean_sha(value: str | None) -> str | None:
+    if not value:
+        return None
+    cleaned = value.strip()
+    if not cleaned or cleaned.lower() in {"unknown", "none", "null"}:
+        return None
+    return cleaned
+
+
+def _sha_from_env() -> BuildInfo | None:
+    for name in (
+        "DCV_BUILD_SHA",
+        "SPACE_COMMIT_SHA",
+        "HF_SPACE_COMMIT_SHA",
+        "GITHUB_SHA",
+        "RENDER_GIT_COMMIT",
+        "COMMIT_SHA",
+        "SOURCE_COMMIT",
+    ):
+        sha = _clean_sha(os.getenv(name))
+        if sha:
+            return BuildInfo(sha=sha, source=f"env:{name}")
+    return None
+
+
+def _sha_from_file() -> BuildInfo | None:
+    for path in (Path("/app/.dcv-build-sha"), Path.cwd() / ".dcv-build-sha"):
+        try:
+            sha = _clean_sha(path.read_text(encoding="utf-8"))
+        except OSError:
+            continue
+        if sha:
+            return BuildInfo(sha=sha, source=str(path))
+    return None
+
+
+def _sha_from_git() -> BuildInfo | None:
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--short=12", "HEAD"],
+            check=True,
+            capture_output=True,
+            text=True,
+            timeout=1,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+    sha = _clean_sha(result.stdout)
+    if sha:
+        return BuildInfo(sha=sha, source="git")
+    return None
+
+
+@cache
+def build_info() -> BuildInfo:
+    return _sha_from_env() or _sha_from_file() or _sha_from_git() or BuildInfo(sha=None, source=None)

src/datacenter_verification_api/app.py

@@ -9,7 +9,7 @@ from typing import AsyncIterator
 from fastapi import FastAPI, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 
-from src.datacenter_verification_api import __version__
+from src.datacenter_verification_api import __version__, build_info
 from src.datacenter_verification_api.model_service import ModelService
 from src.datacenter_verification_api.schemas import (
     BatchPredictRequest,
@@ -82,10 +82,13 @@ def require_service() -> ModelService:
 @app.get("/health", response_model=HealthResponse)
 def health() -> HealthResponse:
     loaded = service is not None
+    build = build_info()
     return HealthResponse(
         status="ok" if loaded else "error",
         model_loaded=loaded,
         api_version=__version__,
+        build_sha=build.sha,
+        build_source=build.source,
         model_run_id=service.model_run_id if service else None,
         dataset_id=service.dataset_id if service else None,
         feature_count=len(service.feature_columns) if service else 0,

src/datacenter_verification_api/feature_completion.py

@@ -20,7 +20,6 @@ FRACTION_COLUMNS = {
     "o3_training_sku_fraction",
     "o3_billing_continuity_score",
     "o4_gpu_util_duty_gt_70",
-    "o4_sm_tensor_active_p95",
     "o4_hbm_used_fraction_p50",
     "o4_hbm_bandwidth_active_p95",
     "o4_gpu_power_fraction_p95",
@@ -282,9 +281,6 @@ def complete_features(
             if clamped is not None:
                 set_if_changed(out, key, clamped, warnings, derived)
 
-    if derived:
-        warnings.append(f"derived fields updated from edited inputs: {', '.join(sorted(set(derived)))}")
-
     allocation = number_or_none(out.get("o2_max_concurrent_normalized_gpus"))
     capacity = number_or_none(out.get("o1_normalized_h100e_capacity"))
     fabric = number_or_none(out.get("o7_synchronized_fabric_footprint"))

src/datacenter_verification_api/model_service.py

@@ -10,7 +10,7 @@ import joblib
 import numpy as np
 import pandas as pd
 
-from src.datacenter_verification_api import __version__
+from src.datacenter_verification_api import __version__, build_info
 from src.datacenter_verification_api.feature_completion import (
     FeatureSchema,
     complete_features,
@@ -31,6 +31,11 @@ from src.datacenter_verification_modeling.common import (
 REPO_ROOT = Path(__file__).resolve().parents[2]
 DEFAULT_MODEL_RUN_DIR = Path("data/model_runs/synthetic_v1_baseline")
 DEFAULT_FEATURE_TABLE = Path("data/synthetic_v1/features/window_features_all.csv")
+KNOWN_NON_MODEL_METADATA_FIELDS = {
+    "capacity_evidence_only",
+    "integrity_evidence_only",
+    "physical_evidence_only",
+}
 
 
 def resolve_repo_path(value: str | Path | None, default: Path) -> Path:
@@ -147,8 +152,11 @@ class ModelService:
                 "governance": self.metrics.get("governance", {}),
                 "calibration": self.metrics.get("calibration", {}),
             }
+        build = build_info()
         return MetadataResponse(
             api_version=__version__,
+            build_sha=build.sha,
+            build_source=build.source,
             model_run_id=self.model_run_id,
             model_run_dir=repo_relative(self.model_run_dir) or self.model_run_dir.name,
             feature_table=repo_relative(self.feature_table_path),
@@ -162,8 +170,9 @@ class ModelService:
             base_row_lookup_enabled=bool(self.feature_lookup),
         )
 
-    def build_feature_row(self, request: PredictRequest) -> tuple[dict[str, Any], list[str]]:
+    def build_feature_row(self, request: PredictRequest) -> tuple[dict[str, Any], list[str], list[str]]:
         warnings: list[str] = []
+        debug_warnings: list[str] = []
         base_row = None
         if request.feature_row_id:
             base_row = self.feature_lookup.get(request.feature_row_id)
@@ -187,7 +196,10 @@ class ModelService:
             for key, value in values.items():
                 row[key] = value
                 changed_keys.add(key)
-                if key not in self.feature_columns and key not in {"feature_row_id"}:
+                if key in {"feature_row_id", *KNOWN_NON_MODEL_METADATA_FIELDS}:
+                    if key in KNOWN_NON_MODEL_METADATA_FIELDS:
+                        debug_warnings.append(f"{source_name} field is metadata-only and was not sent to the model: {key}")
+                elif key not in self.feature_columns:
                     warnings.append(f"{source_name} field is not a model feature and was kept only as metadata: {key}")
 
         for column in self.feature_columns:
@@ -208,10 +220,10 @@ class ModelService:
                     f"no base row supplied; {null_count} of {len(self.feature_columns)} model features are null"
                 )
 
-        return row, warnings
+        return row, warnings, debug_warnings
 
     def predict(self, request: PredictRequest) -> PredictResponse:
-        row, warnings = self.build_feature_row(request)
+        row, warnings, debug_warnings = self.build_feature_row(request)
         record = {
             column: (np.nan if row.get(column) is None else row.get(column))
             for column in sorted(set(row) | set(self.feature_columns))
@@ -245,5 +257,6 @@ class ModelService:
             top_evidence=split_semicolon(post["top_evidence"]),
             critical_missing_layers=split_semicolon(post["critical_missing_layers"]),
             input_warnings=warnings,
+            debug_warnings=debug_warnings,
             completed_features=completed_features,
         )

src/datacenter_verification_api/schemas.py

@@ -32,6 +32,8 @@ class HealthResponse(BaseModel):
     status: str
     model_loaded: bool
     api_version: str
+    build_sha: str | None = None
+    build_source: str | None = None
     model_run_id: str | None = None
     dataset_id: str | None = None
     feature_count: int = 0
@@ -41,6 +43,8 @@ class HealthResponse(BaseModel):
 
 class MetadataResponse(BaseModel):
     api_version: str
+    build_sha: str | None = None
+    build_source: str | None = None
     model_run_id: str
     model_run_dir: str
     feature_table: str | None = None
@@ -71,6 +75,7 @@ class PredictResponse(BaseModel):
     top_evidence: list[str]
     critical_missing_layers: list[str]
     input_warnings: list[str] = Field(default_factory=list)
+    debug_warnings: list[str] = Field(default_factory=list)
     completed_features: dict[str, Any] = Field(default_factory=dict)
 
 

src/datacenter_verification_api/smoke_test.py

@@ -12,7 +12,13 @@ from pathlib import Path
 
 import pandas as pd
 
-from src.datacenter_verification_api.model_service import DEFAULT_MODEL_RUN_DIR, REPO_ROOT, ModelService, resolve_repo_path
+from src.datacenter_verification_api.model_service import (
+    DEFAULT_MODEL_RUN_DIR,
+    KNOWN_NON_MODEL_METADATA_FIELDS,
+    REPO_ROOT,
+    ModelService,
+    resolve_repo_path,
+)
 from src.datacenter_verification_api.schemas import PredictRequest
 from src.datacenter_verification_modeling.common import LABELS
 
@@ -84,11 +90,42 @@ def main() -> int:
     if not edited.completed_features:
         raise AssertionError("edited prediction did not return completed_features")
 
+    target_row_id = "feat_455d59646b2f3bc099ffd959"
+    if target_row_id not in service.feature_lookup:
+        target_row_id = edit_row_id
+    base_row = service.feature_lookup[target_row_id]
+    full_ui_features = {column: base_row.get(column) for column in service.feature_columns}
+    for column in KNOWN_NON_MODEL_METADATA_FIELDS:
+        full_ui_features[column] = base_row.get(column, False)
+    full_ui_features["o4_sm_tensor_active_p95"] = 10
+    tensor_edit = service.predict(
+        PredictRequest(
+            feature_row_id=target_row_id,
+            features=full_ui_features,
+            context={
+                "scope_type": base_row.get("scope_type") or "topology_domain",
+                "window_length_seconds": base_row.get("window_length_seconds") or 3600,
+            },
+            derive=True,
+            return_completed_features=True,
+        )
+    )
+    if tensor_edit.input_warnings:
+        raise AssertionError(f"UI-style metadata payload produced user-facing warnings: {tensor_edit.input_warnings}")
+    completed_tensor = tensor_edit.completed_features.get("o4_sm_tensor_active_p95")
+    if completed_tensor != 10:
+        raise AssertionError(f"tensor activity edit was not preserved; completed value is {completed_tensor!r}")
+
     print(f"PASS live inference smoke test: matched {checked} exported rows from {predictions_path}")
     print(
         "PASS edited prediction schema: "
         f"row={edit_row_id} label={edited.predicted_label} p_large={edited.p_large_training:.6f}"
     )
+    print(
+        "PASS UI payload regression: "
+        f"row={target_row_id} tensor={tensor_edit.completed_features.get('o4_sm_tensor_active_p95')} "
+        f"debug_warnings={len(tensor_edit.debug_warnings)}"
+    )
     return 0