space: ZeroGPU diagnostic — measure CPU RAM/disk/VRAM + confirm a @spaces.GPU call works, before loading the model the documented .to('cuda') way

requirements.txt

@@ -1,12 +1,9 @@
-# HF Space (Gradio SDK) deps. Inference is llama.cpp via llama-cpp-python's
-# prebuilt CPU wheel (the [server] extra gives an OpenAI-compatible server) —
-# NOT transformers, so none of the torch / bnb / mamba-ssm stack the ZeroGPU
-# port choked on. llama.cpp runs the Nemotron-H (Mamba+MoE) hybrid natively.
-# The scrypt package is imported from the repo checkout via sys.path.
---extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cpu
-llama-cpp-python[server]==0.3.28
+# HF Space (Gradio SDK + ZeroGPU). Diagnostic build: measure the box (CPU RAM,
+# disk, real VRAM) and confirm a @spaces.GPU call works before loading the
+# model. torch only (no transformers/bnb yet) keeps this build light + safe.
 gradio==5.49.1
 spaces
+torch==2.10.0
 huggingface_hub>=0.30
 textual>=1.0
 rich>=13.0

space/app.py

@@ -1,22 +1,20 @@
-"""SCRYPT on the web — the local engine, hosted, on a free Gradio Space.
-
-The Warden runs exactly as it does on a player's machine: llama.cpp serving
-our Warden GGUF, on CPU. We fetch a prebuilt llama-server binary and the GGUF
-at boot, start one shared OpenAI-compatible server, and every visitor's game
-subprocess talks to it through the game's existing `api` backend over
-localhost. No transformers, no bitsandbytes, no GPU — the Nemotron-H
-(Mamba + MoE) hybrid runs natively in llama.cpp's C++, which is why the local
-build never hit the trouble the transformers/ZeroGPU port did.
-
-Gradio is the engine room, not the face: it launches the server (and satisfies
-the ZeroGPU platform's startup handshake), then we transplant our own routes
-onto its FastAPI so the custom CRT page and the raw PTY websocket win.
-
-  GET  /            a hand-built Osaka-Jade CRT landing page (static)
-  GET  /api/status  is llama-server up yet?
-  GET  /api/whisper a scripted Warden teaser (never wakes the model)
-  GET  /play        an xterm.js terminal, themed to match
-  WS   /pty         a per-visitor pseudo-terminal running `python -m scrypt.app`
+"""SCRYPT on the web — ZeroGPU diagnostic build.
+
+Before loading a 30B model (and risking another crash), this build MEASURES
+the box: CPU RAM, disk, and the real GPU VRAM seen inside a @spaces.GPU call.
+It also confirms that a GPU call works at all from our setup. The game stays
+playable on the scripted Warden meanwhile; styling and the PTY are intact.
+
+Once we know the numbers, the model gets loaded the way the ZeroGPU docs
+prescribe: placed on `cuda` at module level with `.to('cuda')` (NOT
+device_map, NOT bitsandbytes — both of which fight ZeroGPU's CUDA emulation).
+
+  GET  /            CRT landing page
+  GET  /api/status  warden state + CPU RAM + disk
+  GET  /api/gpuinfo run the @spaces.GPU probe: real VRAM + a CUDA alloc test
+  GET  /api/whisper scripted teaser
+  GET  /play        xterm.js terminal
+  WS   /pty         per-visitor game subprocess
 """
 
 from __future__ import annotations
@@ -25,94 +23,69 @@ import asyncio
 import json
 import os
 import random
-import subprocess
-import sys
+import shutil
 import tempfile
-import urllib.request
 from pathlib import Path
 
-# ZeroGPU contract: import spaces before torch-y things. We don't use the GPU,
-# but on ZeroGPU hardware the platform wants a @spaces.GPU function to exist at
-# startup — we register a trivial stub below purely to satisfy that.
+# ZeroGPU contract: import spaces before torch.
 try:
     import spaces
 except ImportError:
     spaces = None
 
-from fastapi import WebSocket, WebSocketDisconnect
+from fastapi import APIRouter, WebSocket, WebSocketDisconnect
 from fastapi.responses import FileResponse
 from fastapi.staticfiles import StaticFiles
+from starlette.concurrency import run_in_threadpool
 
 REPO_ROOT = Path(__file__).resolve().parent.parent
 STATIC = Path(__file__).parent / "static"
 
-# ------------------------------------------------------------ the Warden brain
 
-WARDEN_REPO = os.environ.get("WARDEN_REPO", "IMJONEZZ/warden-nemotron-3-nano-30b")
-# Q3_K_S (~18GB): the heaviest tier we've confirmed fits this box's RAM.
-WARDEN_GGUF = os.environ.get("WARDEN_GGUF", "warden-nemotron-3-nano-30b-Q3_K_S.gguf")
-LLAMA_PORT = int(os.environ.get("LLAMA_PORT", "8731"))
-LLAMA_CTX = int(os.environ.get("LLAMA_CTX", "8192"))
-LLAMA_THREADS = os.environ.get("LLAMA_THREADS")  # default: llama.cpp picks
-
-_llama_proc: subprocess.Popen | None = None
-WARDEN_ERR = "starting"
-
-
-def _start_llama() -> None:
-    """Download the GGUF and launch llama-cpp-python's OpenAI server on CPU.
-    Failures just leave WARDEN_ERR set; the game falls back to scripted."""
-    global _llama_proc, WARDEN_ERR
+def _meminfo() -> dict:
+    info = {}
     try:
-        from huggingface_hub import hf_hub_download
-
-        print(f"[warden] fetching {WARDEN_REPO}/{WARDEN_GGUF}", flush=True)
-        gguf = hf_hub_download(repo_id=WARDEN_REPO, filename=WARDEN_GGUF)
-
-        cmd = [
-            sys.executable, "-m", "llama_cpp.server",
-            "--model", gguf,
-            "--host", "127.0.0.1",
-            "--port", str(LLAMA_PORT),
-            "--n_ctx", str(LLAMA_CTX),
-        ]
-        if LLAMA_THREADS:
-            cmd += ["--n_threads", LLAMA_THREADS]
-        print(f"[warden] launching llama_cpp.server :{LLAMA_PORT}", flush=True)
-        _llama_proc = subprocess.Popen(cmd, stdout=sys.stdout, stderr=sys.stderr)
-        WARDEN_ERR = "loading"  # health probe flips this to "" when ready
-    except Exception as err:
-        WARDEN_ERR = f"{type(err).__name__}: {err}"
-        print(f"[warden] startup failed: {WARDEN_ERR}", flush=True)
-
-
-def _llama_healthy() -> bool:
-    # llama_cpp.server has no /health; /v1/models answers 200 once the model
-    # is loaded and the server is accepting requests.
+        for line in open("/proc/meminfo"):
+            k, v = line.split(":")
+            if k in ("MemTotal", "MemAvailable"):
+                info[k] = round(int(v.strip().split()[0]) / 1048576, 1)  # GB
+    except Exception:
+        pass
     try:
-        with urllib.request.urlopen(
-            f"http://127.0.0.1:{LLAMA_PORT}/v1/models", timeout=2
-        ) as r:
-            return r.status == 200
+        du = shutil.disk_usage("/")
+        info["DiskFreeGB"] = round(du.free / 1e9, 1)
+        info["DiskTotalGB"] = round(du.total / 1e9, 1)
     except Exception:
-        return False
+        pass
+    return info
+
+
+# ---------------------------------------------------------- the GPU probe
+
+def _gpu_probe() -> str:
+    """Trivial GPU work: report the real device + VRAM and prove a CUDA alloc
+    succeeds. This is the documented usage shape — if even this aborts, the
+    problem is the call mechanism, not the model."""
+    import torch
+
+    if not torch.cuda.is_available():
+        return "cuda not available inside @spaces.GPU"
+    p = torch.cuda.get_device_properties(0)
+    x = torch.ones(1024, 1024, device="cuda")
+    y = (x @ x).sum().item()
+    free, total = torch.cuda.mem_get_info()
+    return (
+        f"{p.name} | total {p.total_memory/1e9:.1f}GB | "
+        f"free {free/1e9:.1f}GB | matmul_ok={y>0}"
+    )
 
 
-def warden_ready() -> bool:
-    """True once llama-server answers /health. Cached once up."""
-    global WARDEN_ERR
-    if WARDEN_ERR == "":
-        return True
-    if _llama_proc is not None and _llama_healthy():
-        WARDEN_ERR = ""
-        return True
-    return False
+if spaces is not None:
+    _gpu_probe = spaces.GPU(duration=30)(_gpu_probe)
 
 
 # ----------------------------------------------------------------- the surface
 
-# Curated in-voice teasers for the landing page. Scripted on purpose: the
-# greeter must never cost an inference call or wait on the model.
 WHISPERS = [
     "Another process wakes in my machine. Show me what you are.",
     "You are a small thing in a large filesystem. I am the filesystem.",
@@ -124,60 +97,41 @@ WHISPERS = [
     "Trespasser. The door was open because nothing has ever made it out.",
 ]
 
-
-# We attach these to gradio's FastAPI in __main__; define them on a throwaway
-# router-less object via a small registry so the transplant stays explicit.
-from fastapi import APIRouter  # noqa: E402
-
 router = APIRouter()
 
 
 @router.get("/api/status")
 def status() -> dict:
-    ready = warden_ready()
     return {
-        "warden_ready": ready,
-        "warden_state": "ready" if ready else WARDEN_ERR,
-        "model": f"{WARDEN_REPO}/{WARDEN_GGUF}",
-        "engine": "llama.cpp (cpu)",
+        "mode": "diagnostic",
+        "zerogpu": spaces is not None,
+        "system": _meminfo(),
+        "note": "GET /api/gpuinfo to probe the real GPU",
     }
 
 
-@router.get("/api/whisper")
-def whisper() -> dict:
-    return {"line": random.choice(WHISPERS)}
-
-
-@router.get("/api/probe")
-def probe(q: str = "A new process woke up in your machine. Greet it in one short line, in voice.") -> dict:
-    """Verification/health: ask the live Warden one line through the internal
-    llama-server. Confirms generation actually works end-to-end."""
+@router.get("/api/gpuinfo")
+async def gpuinfo() -> dict:
+    """Run the @spaces.GPU probe directly from this route (the same call shape
+    real inference would use) and report what happens."""
     import time
 
-    if not warden_ready():
-        return {"ok": False, "state": WARDEN_ERR}
-    body = json.dumps({
-        "messages": [
-            {"role": "system", "content": "You are the Warden, the malevolent operating system of SCRYPTOS. Terse, menacing, Unix-flavored."},
-            {"role": "user", "content": q},
-        ],
-        "max_tokens": 60,
-        "temperature": 0.6,
-    }).encode()
-    req = urllib.request.Request(
-        f"http://127.0.0.1:{LLAMA_PORT}/v1/chat/completions",
-        data=body, headers={"Content-Type": "application/json"},
-    )
     t0 = time.time()
     try:
-        with urllib.request.urlopen(req, timeout=150) as r:
-            data = json.loads(r.read())
-        line = data["choices"][0]["message"]["content"].strip()
-        return {"ok": True, "line": line, "seconds": round(time.time() - t0, 1)}
+        result = await run_in_threadpool(_gpu_probe)
+        return {"ok": True, "gpu": result, "seconds": round(time.time() - t0, 1)}
     except Exception as err:
+        import traceback
+
+        traceback.print_exc()
         return {"ok": False, "error": f"{type(err).__name__}: {err}"}
 
 
+@router.get("/api/whisper")
+def whisper() -> dict:
+    return {"line": random.choice(WHISPERS)}
+
+
 @router.get("/")
 def landing() -> FileResponse:
     return FileResponse(STATIC / "index.html")
@@ -192,25 +146,14 @@ def play() -> FileResponse:
 
 
 def game_env() -> dict:
-    """Environment for one visitor's game process. The game's `api` backend
-    points at our shared llama-server; if it isn't up, the game falls back to
-    the scripted Warden. Sandboxes are always fabricated here."""
-    env = {
+    # Diagnostic build: no model yet, so the game runs its scripted Warden.
+    return {
         "TERM": "xterm-256color",
         "COLORTERM": "truecolor",
         "PYTHONUNBUFFERED": "1",
         "PYTHONPATH": str(REPO_ROOT),
+        "SCRYPT_BACKEND": "scripted",
     }
-    if warden_ready():
-        env |= {
-            "SCRYPT_BACKEND": "api",
-            "SCRYPT_API_BASE": f"http://127.0.0.1:{LLAMA_PORT}/v1",
-            "SCRYPT_API_KEY": "local",  # llama-server ignores it; backend wants one
-            "SCRYPT_MODEL": "warden",
-        }
-    else:
-        env["SCRYPT_BACKEND"] = "scripted"
-    return env
 
 
 async def _pump_pty_to_ws(master_fd: int, ws: WebSocket) -> None:
@@ -227,8 +170,6 @@ async def _pump_pty_to_ws(master_fd: int, ws: WebSocket) -> None:
 
 @router.websocket("/pty")
 async def pty_bridge(ws: WebSocket) -> None:
-    """One visitor, one game process, one private sandbox. Keystrokes flow
-    in as binary; a JSON {"resize":[cols,rows]} frame retunes the terminal."""
     import fcntl
     import pty
     import signal
@@ -241,7 +182,7 @@ async def pty_bridge(ws: WebSocket) -> None:
     if pid == 0:  # child: become the game
         env = {**os.environ, **game_env(), "SCRYPT_HOME": home}
         os.execvpe("python", ["python", "-m", "scrypt.app"], env)
-        os._exit(127)  # unreachable unless exec fails
+        os._exit(127)
 
     reader = asyncio.create_task(_pump_pty_to_ws(master_fd, ws))
     try:
@@ -278,39 +219,17 @@ async def pty_bridge(ws: WebSocket) -> None:
 
 import gradio as gr  # noqa: E402
 
-
-def _gpu_stub(x: str) -> str:
-    """No-op so ZeroGPU sees a @spaces.GPU function at startup. We never call
-    it — inference is CPU llama-server — but the platform requires one to
-    exist on ZeroGPU hardware."""
-    return "ok"
-
-
-if spaces is not None:
-    _gpu_stub = spaces.GPU(duration=10)(_gpu_stub)
-
-
 with gr.Blocks(title="SCRYPT engine room") as engine:
     gr.Markdown(
-        "# SCRYPT engine room\n\n"
-        "The game lives at [/](/). This page only exists so the platform has a "
-        "Gradio app to host; the Warden runs on llama.cpp behind the scenes."
+        "# SCRYPT engine room\n\nThe game lives at [/](/). "
+        "Diagnostic build — measuring the box before loading the Warden."
     )
-    gr.api(_gpu_stub, api_name="gpu_stub")
+    # Registering the GPU probe as a gradio API satisfies ZeroGPU's startup
+    # detection of a @spaces.GPU function.
+    gr.api(_gpu_probe, api_name="gpu_probe")
 
 
 if __name__ == "__main__":
-    import threading
-
-    # Start the model load in the background so the web layer (landing page,
-    # whisper, even a scripted-fallback game) is reachable while the binary +
-    # GGUF download and llama-server warms up.
-    threading.Thread(target=_start_llama, daemon=True).start()
-
-    # Gradio launches the server (and arms the ZeroGPU startup handshake); we
-    # transplant our routes in FRONT of gradio's so "/" is the CRT page and the
-    # PTY websocket resolves before any catch-all. ssr_mode=False keeps gradio
-    # from spawning a Node frontend that would seize the port.
     fastapi_app, _, _ = engine.launch(
         prevent_thread_lock=True,
         server_name="0.0.0.0",
@@ -320,10 +239,9 @@ if __name__ == "__main__":
     )
     fastapi_app.include_router(router)
     fastapi_app.mount("/static", StaticFiles(directory=STATIC), name="static")
-    # include_router appends; move our routes ahead of gradio's catch-alls.
+    # Move our routes (incl. the /static mount) ahead of gradio's catch-all.
     our = [r for r in fastapi_app.router.routes if getattr(r, "name", "") in {
-        "status", "whisper", "probe", "landing", "play", "pty_bridge",
-        "static",  # the stylesheet/font mount MUST beat gradio's catch-all
+        "status", "gpuinfo", "whisper", "landing", "play", "pty_bridge", "static",
     }]
     for r in our:
         fastapi_app.router.routes.remove(r)