Add bounded ZeroGPU native CUDA qualification; preserve Docker rollback

.gitattributes

@@ -37,3 +37,5 @@ tracks/R06[[:space:]]Mix.track filter=lfs diff=lfs merge=lfs -text
 tracks/R07[[:space:]]Mirage[[:space:]]Marina.track filter=lfs diff=lfs merge=lfs -text
 tracks/R09[[:space:]]Eau[[:space:]]Noir.track filter=lfs diff=lfs merge=lfs -text
 tracks/The[[:space:]]Champions[[:space:]]Trial.track filter=lfs diff=lfs merge=lfs -text
+bin/altd-sim filter=lfs diff=lfs merge=lfs -text
+bin/libaltd_gpu.so filter=lfs diff=lfs merge=lfs -text

BINARY_PROVENANCE.json

@@ -0,0 +1,22 @@
+{
+  "source_space": "TiGa-RCE/ald-tao-gpu",
+  "source_revision": "ba07e35a39211af7a0deda0ebd9adb2c554b4f38",
+  "upstream": "d8ab74c25df70b6a86ed101080e33d5fb785ea6f",
+  "image_config": "sha256:31f7854e5fac0b54679eed2899c8951cd96571650ea6c74c27e2400a8c4aa6d3",
+  "artifacts": [
+    {
+      "file": "bin/altd-sim",
+      "sha256": "2f2f2144ae14b0ef599ca8510f95712da00243c6875881491d384b394e7499f7",
+      "bytes": 13911800,
+      "layer": "sha256:d4f213ac74fe7556e8ef4d71aa6195a80dd619057697748f2f3863c0aa1cbca7",
+      "member": "app/github-simulator/source/target/release/altd-sim"
+    },
+    {
+      "file": "bin/libaltd_gpu.so",
+      "sha256": "279d6353b4c691686d6aeeae6abfd4a82b959e9b604f079a6c45f9823b48a87a",
+      "bytes": 3933424,
+      "layer": "sha256:c61e59a8a076ae00d64a4b8c55102f2ba9643dbe165cd66130ed662e131982ce",
+      "member": "app/libaltd_gpu.so"
+    }
+  ]
+}

README.md

@@ -1,15 +1,27 @@
 ---
-title: TAO GPU Training Lab
+title: TAO ZeroGPU Qualification
 emoji: 🏎️
 colorFrom: green
 colorTo: blue
-sdk: docker
-app_port: 7860
+sdk: gradio
+sdk_version: 6.29.1
+python_version: '3.10'
+app_file: app.py
 pinned: false
 ---
 
-Private CUDA deployment candidate pinned to Zorro909/driving_sim_rs d8ab74c25df70b6a86ed101080e33d5fb785ea6f, matching ald-tao-cpu. Builds unchanged upstream Rust CLI and CUDA library together. Explicit proton math profile; no fast-math override. CUDA 13.0 sm_75/sm_86 plus PTX for compatible newer devices. Driver/device acceptance remains unverified.
+Private native CUDA compatibility probe, not a qualified trainer.
+Uses included ZeroGPU allowance through a 45-second leased call. No paid Jobs
+or dedicated hardware requested. Check the authenticated caller's included quota
+before each call; the app itself does not know account billing balances.
 
-Hardware stays CPU Basic until separately authorized. This is NOT a verified GPU trainer yet. Without a usable GPU library/device, jobs fail preflight; CPU fallback is disabled. Only positive-mutation train-scratch jobs are supported by this wrapper; frozen replay stays on ald-tao-cpu. Existing Formula-only, bounded network/sensor and steering/acceleration restrictions remain. No upstream WebSocket service is exposed. CPU/GPU matched-output and benchmark acceptance remain pending.
+Original Docker source and dashboard remain in this repository but are inactive.
+Rollback: restore README.md from revision ba07e35a39211af7a0deda0ebd9adb2c554b4f38
+and request CPU Basic. BINARY_PROVENANCE.json pins the two exact HF-built binaries
+to that revision and upstream d8ab74c25df70b6a86ed101080e33d5fb785ea6f.
 
-Open upstream PRs 19 and 21 are not included. Keep use private and bounded. No original-game parity claim. Storage is ephemeral: download checkpoints and receipts before restart. PACKAGE_MANIFEST.json covers deployment files; UPSTREAM.json records provenance. No local saved-car library is uploaded.
+No CUDA initialization outside the lease. First check device discovery and a
+three-value sine kernel in process, then the normal Rust gpu-info subprocess.
+No fallback, training, trajectory parity, speedup or H200 claim. A second lease
+must independently pass before testing training. Retained PACKAGE_MANIFEST.json
+describes the prior Docker snapshot only; ZEROGPU_MANIFEST.json covers this overlay.

ZEROGPU_MANIFEST.json

@@ -0,0 +1,9 @@
+{
+  "README.md": "2ed9310903d06964947ba9008a34f522a5cba48318b183318af938a859911b37",
+  "app.py": "60bbb765a5783bb9786aca0b3b910a42eb570fffc6b3072d5220895be978450a",
+  "probe_core.py": "97a36ad8cf8efec09d84bb4b2c1ee6794658ceedfd643cd9849ff3c6d85aca9d",
+  "requirements.txt": "d4a97517b799a94b3370ea2e11aee3e41304aa12b77bab9abecd0b37e961acaf",
+  "BINARY_PROVENANCE.json": "f2223c1c6e2bbf8f6101b46e11563f4d866f99094c529cd5584f3228309e6551",
+  "bin/altd-sim": "2f2f2144ae14b0ef599ca8510f95712da00243c6875881491d384b394e7499f7",
+  "bin/libaltd_gpu.so": "279d6353b4c691686d6aeeae6abfd4a82b959e9b604f079a6c45f9823b48a87a"
+}

app.py

@@ -0,0 +1,22 @@
+import spaces  # Must precede libraries that interact with CUDA.
+import gradio as gr
+from probe_core import qualify, verify_artifacts
+
+# Integrity only: no device initialization or CUDA library loading at startup.
+verify_artifacts()
+
+@spaces.GPU(duration=45)
+def probe():
+    return qualify()
+
+with gr.Blocks() as demo:
+    gr.Markdown("# TAO · ZeroGPU compatibility check\n"
+                "Private, bounded native-library qualification. No training, CPU fallback, "
+                "or automatic runs. Uses up to 45 seconds of the caller's ZeroGPU allowance. "
+                "Check included quota before calling. Actual GPU identity is recorded; no H200 assumption.")
+    button = gr.Button("Run one compatibility check")
+    result = gr.JSON(label="Qualification receipt")
+    button.click(probe, inputs=[], outputs=result, api_name="probe", concurrency_limit=1)
+
+if __name__ == "__main__":
+    demo.queue(max_size=1).launch()

bin/altd-sim

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2f2f2144ae14b0ef599ca8510f95712da00243c6875881491d384b394e7499f7
+size 13911800

bin/libaltd_gpu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:279d6353b4c691686d6aeeae6abfd4a82b959e9b604f079a6c45f9823b48a87a
+size 3933424

probe_core.py

@@ -0,0 +1,81 @@
+"""Bounded native CUDA qualification; importing this module never initializes CUDA."""
+import ctypes
+import hashlib
+import json
+import math
+import os
+from pathlib import Path
+import subprocess
+import time
+
+ROOT = Path(__file__).resolve().parent
+
+def verify_artifacts(root=ROOT):
+    manifest = json.loads((root / "BINARY_PROVENANCE.json").read_text())
+    for item in manifest["artifacts"]:
+        path = root / item["file"]
+        if path.parent != root / "bin":
+            raise ValueError("Unexpected artifact path")
+        if hashlib.sha256(path.read_bytes()).hexdigest() != item["sha256"]:
+            raise ValueError("Artifact hash mismatch: " + item["file"])
+    return manifest
+
+def accepted_cli(info):
+    return (info.get("platform") == "CUDA" and bool(info.get("device"))
+            and info.get("layout") == "ok" and info.get("kernels") == "ok")
+
+def qualify(root=ROOT):
+    """Call only inside the outer GPU lease. No training or user input execution."""
+    started = time.perf_counter()
+    manifest = verify_artifacts(root)
+    report = {"schema": "ald-zerogpu-qualification/1", "provenance": manifest,
+              "inprocess_ok": False, "subprocess_ok": False,
+              "training_verified": False, "parity_verified": False}
+    try:
+        lib = ctypes.CDLL(str(root / "bin/libaltd_gpu.so"))
+        lib.altd_gpu_version.restype = ctypes.c_int
+        lib.altd_gpu_platform.restype = ctypes.c_char_p
+        report["abi"] = lib.altd_gpu_version()
+        report["platform"] = lib.altd_gpu_platform().decode()
+        if report["abi"] != 10 or report["platform"] != "CUDA":
+            raise RuntimeError("Unexpected native ABI/platform")
+        lib.altd_gpu_device_name.argtypes = [ctypes.c_void_p, ctypes.c_int]
+        lib.altd_gpu_device_name.restype = ctypes.c_int
+        name = ctypes.create_string_buffer(256)
+        status = lib.altd_gpu_device_name(name, len(name))
+        report["device_status"] = status
+        if status:
+            raise RuntimeError("Device discovery failed: " + str(status))
+        report["device"] = name.value.decode()
+        status = lib.altd_gpu_probe()
+        report["kernel_probe_status"] = status
+        if status:
+            raise RuntimeError("Kernel availability failed: " + str(status))
+        lib.altd_gpu_math.argtypes = [ctypes.c_int, ctypes.c_int, ctypes.c_void_p,
+                                     ctypes.c_void_p, ctypes.c_void_p]
+        lib.altd_gpu_math.restype = ctypes.c_int
+        # Independent analytical expectations, not copied simulator output.
+        values = (ctypes.c_float * 3)(0.0, 0.5, -0.5)
+        outputs = (ctypes.c_float * 3)()
+        errors = (ctypes.c_uint32 * 3)()
+        status = lib.altd_gpu_math(0, 3, values, outputs, errors)
+        report["math"] = {"status": status, "outputs": list(outputs), "errors": list(errors)}
+        report["inprocess_ok"] = (status == 0 and not any(errors)
+            and all(math.isfinite(y) and abs(y - math.sin(x)) <= 1e-6 for x, y in zip(values, outputs)))
+    except Exception as exc:
+        report["inprocess_error"] = str(exc)
+    try:
+        binary = root / "bin/altd-sim"
+        binary.chmod(0o755)
+        env = dict(os.environ, ALTD_GPU_LIB=str(root / "bin/libaltd_gpu.so"))
+        result = subprocess.run([str(binary), "gpu-info"], env=env,
+                                capture_output=True, text=True, timeout=20)
+        report["subprocess"] = {"returncode": result.returncode,
+                                "stdout": result.stdout[-8192:], "stderr": result.stderr[-8192:]}
+        if result.returncode == 0:
+            report["subprocess_ok"] = accepted_cli(json.loads(result.stdout))
+    except Exception as exc:
+        report["subprocess_error"] = str(exc)
+    report["wall_seconds"] = time.perf_counter() - started
+    report["qualified_for_next_test"] = report["inprocess_ok"] and report["subprocess_ok"]
+    return report

requirements.txt

@@ -0,0 +1 @@
+spaces==0.51.3