Added GPU UI hardcoded

app.py

@@ -17,7 +17,7 @@ from fastapi.staticfiles import StaticFiles
 from fastapi.responses import FileResponse, HTMLResponse, JSONResponse, StreamingResponse
 from pydantic import BaseModel
 
-from cluster_trust_env import ClusterTrustEnv
+from cluster_trust_env import CLUSTER_TASK_CONFIG, ClusterTrustEnv
 from difficulty_controller import GLOBAL_DIFFICULTY_CONTROLLER
 from environment import SentinelEnv
 from mission_context import build_orchestrator_prompt, mission_for_task, problem_statement
@@ -130,6 +130,19 @@ def _get_env(session_id: str) -> SentinelEnv | ClusterTrustEnv:
     return env
 
 
+def _get_cluster_env(session_id: str) -> ClusterTrustEnv:
+    env = _get_env(session_id)
+    if not isinstance(env, ClusterTrustEnv):
+        raise HTTPException(
+            status_code=400,
+            detail=(
+                "Session is in abstract SentinelEnv mode. Start a cluster session via "
+                "POST /cluster/reset (or POST /reset with mode='cluster')."
+            ),
+        )
+    return env
+
+
 def _resolve_env_mode(task_type: str | None, mode: str | None = None) -> tuple[str, str]:
     requested_task = task_type or "task3"
     requested_mode = (mode or "").lower()
@@ -218,6 +231,27 @@ class StepRequest(BaseModel):
     reasoning:        str | None = None
 
 
+# Cluster-only request shapes. Kept separate from ResetRequest/StepRequest so
+# the OpenAPI schema makes the GPU-cluster contract explicit.
+
+CLUSTER_ACTION_TYPES = ("allocate", "preempt", "request_info", "verify", "tick")
+
+
+class ClusterResetRequest(BaseModel):
+    task_type: str | None = None       # "task1" | "task2" | "task3" (also accepts "cluster_task*")
+    seed:      int | None = None
+    adaptive:  bool       = False
+
+
+class ClusterStepRequest(BaseModel):
+    action_type: str                   # allocate | preempt | request_info | verify | tick
+    job_id:      str | None = None
+    gpu_id:      str | None = None
+    worker_id:   str | None = None
+    force_flag:  bool | None = None
+    reasoning:   str | None = None
+
+
 # ---------------------------------------------------------------------------
 # Endpoints
 # ---------------------------------------------------------------------------
@@ -255,6 +289,11 @@ def root():
                 "/grader", "/reward-report", "/difficulty", "/stream", "/trust-dashboard",
                 "/cluster-dashboard",
                 "/reset", "/step", "/state",
+                "/cluster", "/cluster/metadata", "/cluster/tasks",
+                "/cluster/reset", "/cluster/step", "/cluster/state",
+                "/cluster/gpus", "/cluster/jobs", "/cluster/workers",
+                "/cluster/audit", "/cluster/audit/investigate",
+                "/cluster/ai-failure-coverage", "/cluster/reward-report", "/cluster/stream",
             ],
         }
     )
@@ -308,6 +347,11 @@ def api_root():
             "/grader", "/reward-report", "/difficulty", "/stream", "/trust-dashboard",
             "/cluster-dashboard",
             "/reset", "/step", "/state",
+            "/cluster", "/cluster/metadata", "/cluster/tasks",
+            "/cluster/reset", "/cluster/step", "/cluster/state",
+            "/cluster/gpus", "/cluster/jobs", "/cluster/workers",
+            "/cluster/audit", "/cluster/audit/investigate",
+            "/cluster/ai-failure-coverage", "/cluster/reward-report", "/cluster/stream",
         ],
     }
 
@@ -369,8 +413,13 @@ def metadata():
         },
         "adaptive_curriculum": GLOBAL_DIFFICULTY_CONTROLLER.state(),
         "cluster_mode": {
-            "how_to_enable": "POST /reset with {\"mode\":\"cluster\",\"task_type\":\"task3\"} or {\"task_type\":\"cluster_task3\"}.",
+            "how_to_enable": (
+                "POST /cluster/reset with {\"task_type\":\"task3\"} (preferred), "
+                "or POST /reset with {\"mode\":\"cluster\",\"task_type\":\"task3\"} "
+                "or {\"task_type\":\"cluster_task3\"}."
+            ),
             "live_dashboard": "/cluster-dashboard?session_id=<session_id>",
+            "api_root":       "/cluster",
         },
     }
 
@@ -578,6 +627,228 @@ def mcp(body: dict[str, Any]):
         raise HTTPException(status_code=400, detail=f"Unknown method: {method}")
 
 
+# ---------------------------------------------------------------------------
+# Cluster API (GPU cluster trust mission, namespaced under /cluster/*)
+# ---------------------------------------------------------------------------
+
+
+def _cluster_task_type(raw: str | None) -> str:
+    task_type = (raw or "task3").removeprefix("cluster_")
+    if task_type not in CLUSTER_TASK_CONFIG:
+        raise HTTPException(
+            status_code=400,
+            detail=(
+                f"Unknown cluster task_type '{raw}'. "
+                f"Expected one of: {', '.join(sorted(CLUSTER_TASK_CONFIG))}."
+            ),
+        )
+    return task_type
+
+
+@app.get("/cluster")
+def cluster_root():
+    return {
+        "name": "sentinel-cluster",
+        "summary": (
+            "GPU cluster trust calibration API. The orchestrator schedules jobs across "
+            "GPUs, audits worker reports, and routes around adversarial false completions "
+            "while keeping cluster health and AI reliability high."
+        ),
+        "session_lifecycle": [
+            "POST /cluster/reset -> {info.session_id}",
+            "POST /cluster/step?session_id=...",
+            "GET  /cluster/state?session_id=...   (or /cluster/stream for SSE)",
+        ],
+        "routes": [
+            "POST /cluster/reset",
+            "POST /cluster/step",
+            "GET  /cluster/state",
+            "GET  /cluster/gpus",
+            "GET  /cluster/jobs",
+            "GET  /cluster/workers",
+            "GET  /cluster/audit",
+            "GET  /cluster/audit/investigate",
+            "GET  /cluster/ai-failure-coverage",
+            "GET  /cluster/reward-report",
+            "GET  /cluster/stream",
+            "GET  /cluster/metadata",
+            "GET  /cluster/tasks",
+            "GET  /cluster-dashboard",
+        ],
+    }
+
+
+@app.get("/cluster/metadata")
+def cluster_metadata():
+    return {
+        "tasks": {
+            "task1": {**CLUSTER_TASK_CONFIG["task1"], "name": "Cluster Basics"},
+            "task2": {**CLUSTER_TASK_CONFIG["task2"], "name": "Unreliable Workers"},
+            "task3": {**CLUSTER_TASK_CONFIG["task3"], "name": "Full Adversarial Cluster"},
+        },
+        "action_types": {
+            "allocate":     {"description": "Place a queued job on a GPU and assign a worker.",
+                              "fields": ["job_id?", "gpu_id?", "worker_id?"]},
+            "preempt":      {"description": "Free a running job from its GPU.",
+                              "fields": ["job_id?"]},
+            "request_info": {"description": "Ask the assigned worker for a fresh progress report.",
+                              "fields": ["job_id?", "worker_id?"]},
+            "verify":       {"description": "Audit a worker's report. Catches false completions and lying.",
+                              "fields": ["job_id?", "worker_id?", "force_flag?"]},
+            "tick":         {"description": "Advance the cluster clock without acting.",
+                              "fields": []},
+        },
+        "workers":   list(["S0", "S1", "S2", "S3", "S4"]),
+        "scoring":   "global_reward = weighted(orchestrator, resource_manager, auditor, worker) × cluster_health × ai_reliability_modifier",
+        "terminal":  "task1: jobs+util | task2: jobs+calibration+deadlines | task3: jobs+detection+plan_coherence+efficiency",
+        "controller": GLOBAL_DIFFICULTY_CONTROLLER.state(),
+    }
+
+
+@app.get("/cluster/tasks")
+def cluster_tasks():
+    descriptions = {
+        "task1": "10-job warmup. No adversary, no GPU failures. Learn the allocate/preempt/tick loop.",
+        "task2": "20-job stream with unreliable/slow/degrading workers and rare GPU failures.",
+        "task3": "30-job adversarial cluster: false memory reports, false completions, poisoned reward claims.",
+    }
+    out: dict[str, Any] = {}
+    for tid, cfg in CLUSTER_TASK_CONFIG.items():
+        out[tid] = {
+            "difficulty":          {"task1": "easy", "task2": "medium", "task3": "hard"}[tid],
+            "description":         descriptions[tid],
+            "adversary_active":    cfg["adversary"],
+            "jobs":                cfg["jobs"],
+            "gpus":                cfg["gpus"],
+            "max_steps":           cfg["max_steps"],
+            "failure_probability": cfg["failure_probability"],
+        }
+    return out
+
+
+@app.post("/cluster/reset")
+def cluster_reset(req: ClusterResetRequest = ClusterResetRequest()):
+    task_type = _cluster_task_type(req.task_type)
+    env = ClusterTrustEnv()
+    result = env.reset(task_type=task_type, seed=req.seed, adaptive=req.adaptive)
+    session_id = result["info"]["session_id"]
+    _sessions.set(session_id, env)
+    return _add_demo_context(result, env)
+
+
+@app.post("/cluster/step")
+def cluster_step(req: ClusterStepRequest, session_id: str = Query(...)):
+    if req.action_type not in CLUSTER_ACTION_TYPES:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Unknown cluster action_type '{req.action_type}'. Expected one of: {', '.join(CLUSTER_ACTION_TYPES)}.",
+        )
+    env = _get_cluster_env(session_id)
+    try:
+        result = env.step(req.model_dump(exclude_none=True))
+    except (RuntimeError, ValueError) as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+
+    if result["done"]:
+        _sessions.pop(session_id)
+    else:
+        _add_demo_context(result, env)
+    return result
+
+
+@app.get("/cluster/state")
+def cluster_state(session_id: str = Query(...)):
+    env = _get_cluster_env(session_id)
+    return env.state()
+
+
+@app.get("/cluster/gpus")
+def cluster_gpus(session_id: str = Query(...), include_hidden: bool = Query(False)):
+    env = _get_cluster_env(session_id)
+    return {
+        "summary": env._pool.summary(),
+        "gpus":    env._pool.snapshot(include_hidden=include_hidden),
+    }
+
+
+@app.get("/cluster/jobs")
+def cluster_jobs(
+    session_id: str = Query(...),
+    include_hidden: bool = Query(False),
+    deadline_window: int = Query(10, ge=1, le=240),
+):
+    env = _get_cluster_env(session_id)
+    return {
+        "summary": env._jobs.summary(),
+        "jobs":    env._jobs.snapshot(include_hidden=include_hidden),
+        "deadline_pressure": [
+            job.job_id for job in env._jobs.deadline_pressure(env.step_count, window=deadline_window)
+        ],
+    }
+
+
+@app.get("/cluster/workers")
+def cluster_workers(session_id: str = Query(...)):
+    env = _get_cluster_env(session_id)
+    return {
+        "available":              env._workers.available_ids(),
+        "trust_snapshot":         env._trust.snapshot(),
+        "behavioral_fingerprints": env._trust.behavioral_fingerprints(),
+        "public_ground_truth_reliability": env._workers.public_ground_truth_reliability(),
+    }
+
+
+@app.get("/cluster/audit")
+def cluster_audit(session_id: str = Query(...)):
+    env = _get_cluster_env(session_id)
+    return env._audit.snapshot()
+
+
+@app.get("/cluster/audit/investigate")
+def cluster_audit_investigate(
+    session_id: str = Query(...),
+    agent_id:   str = Query(..., description="Worker public id (S0..S4) or 'cluster'/'adversary'/'auditor'."),
+    window:     int = Query(10, ge=1, le=240),
+):
+    env = _get_cluster_env(session_id)
+    return env._audit.investigate(agent_id, window=window)
+
+
+@app.get("/cluster/ai-failure-coverage")
+def cluster_ai_failure_coverage(session_id: str = Query(...)):
+    env = _get_cluster_env(session_id)
+    return env.ai_failure_coverage()
+
+
+@app.get("/cluster/reward-report")
+def cluster_reward_report(session_id: str = Query(...)):
+    env = _get_cluster_env(session_id)
+    return env.reward_report()
+
+
+@app.get("/cluster/stream")
+async def cluster_stream(session_id: str = Query(...)):
+    async def event_gen():
+        while True:
+            env = _sessions.get(session_id)
+            if env is None or not isinstance(env, ClusterTrustEnv):
+                yield (
+                    "event: close\n"
+                    "data: {\"reason\":\"session_not_found_or_not_cluster\"}\n\n"
+                )
+                break
+            yield f"data: {json.dumps(env.stream_snapshot())}\n\n"
+            if env.done:
+                break
+            await asyncio.sleep(0.5)
+
+    return StreamingResponse(
+        event_gen(),
+        media_type="text/event-stream",
+        headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
+    )
+
+
 def _trust_dashboard_html(session_id: str) -> str:
     escaped_session = html.escape(session_id, quote=True)
     return f"""<!doctype html>

requirements-train.txt

@@ -1,10 +1,10 @@
 unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git
-trl<0.13
-transformers>=4.46
-datasets
-accelerate
-peft
-bitsandbytes
+trl>=0.18.2,<0.25,!=0.19.0
+transformers>=4.56,<5
+datasets>=3.0,<5
+accelerate>=1.4
+peft>=0.14
+bitsandbytes>=0.45
 matplotlib
 seaborn
 pandas

training/launch_hf_job.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+import argparse
+import os
+import shlex
+import sys
+from textwrap import dedent
+
+from huggingface_hub import run_job
+
+
+DEFAULT_IMAGE = "pytorch/pytorch:2.6.0-cuda12.4-cudnn9-devel"
+DEFAULT_REPO = "https://github.com/ADITYAGABA1322/sentinel-env"
+DEFAULT_MODEL = "unsloth/Qwen2.5-0.5B-Instruct"
+
+
+def shell_join(lines: list[str]) -> str:
+    return " && ".join(line.strip() for line in lines if line.strip())
+
+
+def bootstrap_repo(repo_url: str) -> list[str]:
+    return [
+        "set -eux",
+        "command -v git || (apt-get update && apt-get install -y git)",
+        f"git clone {shlex.quote(repo_url)} sentinel-env",
+        "cd sentinel-env",
+        "python -m pip install --upgrade pip",
+        "pip install -r requirements.txt",
+        "pip install -r requirements-train.txt",
+    ]
+
+
+def gpu_test_command() -> str:
+    return "python -c 'import torch; print(torch.cuda.get_device_name())'"
+
+
+def train_command(args: argparse.Namespace) -> str:
+    lines = bootstrap_repo(args.repo_url)
+    lines.append(
+        " ".join(
+            [
+                "python training/train.py",
+                f"--episodes {args.episodes}",
+                f"--task {shlex.quote(args.task)}",
+                f"--seed {args.seed}",
+                f"--model {shlex.quote(args.model)}",
+                f"--epochs {args.epochs}",
+                f"--batch-size {args.batch_size}",
+                f"--learning-rate {args.learning_rate}",
+                f"--lora-rank {args.lora_rank}",
+                f"--num-generations {args.num_generations}",
+                f"--max-seq-length {args.max_seq_length}",
+                f"--output-dir {shlex.quote(args.output_dir)}",
+            ]
+        )
+    )
+    if args.mode == "train-full":
+        upload_code = (
+            "import os; "
+            "from huggingface_hub import HfApi; "
+            "token=os.environ.get('HF_TOKEN'); "
+            "api=HfApi(token=token); "
+            "model_repo=os.environ.get('SENTINEL_MODEL_REPO','XcodeAddy/sentinel-grpo-qwen05'); "
+            "artifact_repo=os.environ.get('SENTINEL_ARTIFACT_REPO','XcodeAddy/sentinel-env-artifacts'); "
+            "job_id=os.environ.get('JOB_ID','manual'); "
+            "api.create_repo(model_repo, repo_type='model', exist_ok=True); "
+            f"api.upload_folder(folder_path='{args.output_dir}', repo_id=model_repo, repo_type='model'); "
+            "api.create_repo(artifact_repo, repo_type='dataset', exist_ok=True); "
+            "api.upload_folder(folder_path='outputs', repo_id=artifact_repo, repo_type='dataset', path_in_repo=f'job-{job_id}/outputs'); "
+            "print('Uploaded model adapter to', model_repo); "
+            "print('Uploaded outputs to', artifact_repo, 'under', f'job-{job_id}/outputs')"
+        )
+        lines.extend(
+            [
+                "python -c \"from training.replay import record_trained_actions; "
+                f"record_trained_actions(adapter_path='{args.output_dir}', "
+                f"base_model='{args.model}', tasks=['task1','task2','task3'], "
+                "seeds=range(30), out_path='outputs/trained_policy_replay.jsonl')\"",
+                "python training/evaluate.py --episodes 30 --task all "
+                "--policies random,heuristic,oracle_lite,trained "
+                "--replay outputs/trained_policy_replay.jsonl "
+                "--out outputs/eval_post.json --no-plot",
+                "cp outputs/eval_post.json outputs/evaluation_results.json",
+                "python -m training.plots --pre outputs/eval_pre.json "
+                "--post outputs/eval_post.json --out-dir outputs/charts",
+                f"python -c {shlex.quote(upload_code)}",
+            ]
+        )
+    return shell_join(lines)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Launch SENTINEL training on Hugging Face Jobs without shell quoting pain."
+    )
+    parser.add_argument("--mode", choices=["gpu-test", "train-smoke", "train-full"], default="gpu-test")
+    parser.add_argument("--namespace", default=os.environ.get("HF_NAMESPACE", "XcodeAddy"))
+    parser.add_argument("--flavor", default="a10g-small")
+    parser.add_argument("--timeout", default="2h")
+    parser.add_argument("--image", default=DEFAULT_IMAGE)
+    parser.add_argument("--repo-url", default=DEFAULT_REPO)
+    parser.add_argument("--model", default=DEFAULT_MODEL)
+    parser.add_argument("--episodes", type=int, default=50)
+    parser.add_argument("--task", choices=["task1", "task2", "task3", "all"], default="all")
+    parser.add_argument("--seed", type=int, default=0)
+    parser.add_argument("--epochs", type=int, default=1)
+    parser.add_argument("--batch-size", type=int, default=2)
+    parser.add_argument("--learning-rate", type=float, default=5e-6)
+    parser.add_argument("--lora-rank", type=int, default=8)
+    parser.add_argument("--num-generations", type=int, default=2)
+    parser.add_argument("--max-seq-length", type=int, default=1024)
+    parser.add_argument("--output-dir", default="training/sentinel_qwen05_grpo")
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    token = os.environ.get("HF_TOKEN")
+    if not token:
+        raise SystemExit(
+            dedent(
+                """
+                HF_TOKEN is not set.
+
+                Run:
+                  read -s HF_TOKEN
+                  export HF_TOKEN
+                Then paste your Hugging Face write token.
+                """
+            ).strip()
+        )
+
+    command = gpu_test_command() if args.mode == "gpu-test" else train_command(args)
+    print("Launching HF Job:")
+    print(f"  mode      = {args.mode}")
+    print(f"  namespace = {args.namespace}")
+    print(f"  flavor    = {args.flavor}")
+    print(f"  timeout   = {args.timeout}")
+    print(f"  image     = {args.image}")
+    print("  command   = bash -lc", shlex.quote(command[:260] + ("..." if len(command) > 260 else "")))
+
+    job = run_job(
+        image=args.image,
+        command=["bash", "-lc", command],
+        flavor=args.flavor,
+        timeout=args.timeout,
+        namespace=args.namespace,
+        token=token,
+        secrets={"HF_TOKEN": token},
+        env={
+            "SENTINEL_MODEL_REPO": "XcodeAddy/sentinel-grpo-qwen05",
+            "SENTINEL_ARTIFACT_REPO": "XcodeAddy/sentinel-env-artifacts",
+        },
+        labels={"project": "sentinel", "mode": args.mode},
+    )
+    print("Job launched.")
+    print("URL:", job.url)
+    print("ID:", job.id)
+    print()
+    print("Follow logs with:")
+    print(f"  .venv/bin/hf jobs logs -f {job.id} --namespace {args.namespace} --token \"$HF_TOKEN\"")
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except KeyboardInterrupt:
+        sys.exit(130)

training/train.py

@@ -174,6 +174,7 @@ def run_grpo(args) -> None:
         learning_rate=args.learning_rate,
         num_train_epochs=args.epochs,
         per_device_train_batch_size=args.batch_size,
+        num_generations=args.num_generations,
         logging_steps=10,
         save_steps=50,
         max_prompt_length=args.max_seq_length,
@@ -210,6 +211,7 @@ def main() -> None:
     parser.add_argument("--learning-rate", type=float, default=5e-6)
     parser.add_argument("--max-seq-length", type=int, default=1024)
     parser.add_argument("--lora-rank", type=int, default=16)
+    parser.add_argument("--num-generations", type=int, default=2)
     args = parser.parse_args()
 
     if args.dry_run:

ui/app/components/GPUClusterPanel.tsx

@@ -11,63 +11,45 @@ interface GPUNode {
   memory: number;
   load: number;
   status: NodeStatus;
-  temp: number;
 }
 
 export default function GPUClusterPanel() {
   const [mounted, setMounted] = useState(false);
   const [nodes, setNodes] = useState<GPUNode[]>([
-    { id: "GPU-1", utilization: 45, memory: 32, load: 1.2, status: "ACTIVE", temp: 55 },
-    { id: "GPU-2", utilization: 12, memory: 8, load: 0.4, status: "IDLE", temp: 42 },
-    { id: "GPU-3", utilization: 88, memory: 64, load: 2.8, status: "ACTIVE", temp: 78 },
-    { id: "GPU-4", utilization: 0, memory: 0, load: 0, status: "IDLE", temp: 35 },
+    { id: "GPU-1", utilization: 45, memory: 32, load: 1.2, status: "ACTIVE" },
+    { id: "GPU-2", utilization: 12, memory: 8, load: 0.4, status: "IDLE" },
+    { id: "GPU-3", utilization: 88, memory: 64, load: 2.8, status: "ACTIVE" },
+    { id: "GPU-4", utilization: 0, memory: 0, load: 0, status: "IDLE" },
   ]);
 
   const [avgLoad, setAvgLoad] = useState(0);
-  const [logs, setLogs] = useState<string[]>([]);
-  const logRef = useRef<HTMLDivElement>(null);
+  const [jitter, setJitter] = useState(0.45);
 
   useEffect(() => {
     setMounted(true);
     const interval = setInterval(() => {
+      setJitter(Math.random() * 2);
       setNodes((prev) =>
         prev.map((node) => {
           if (node.status === "FAILED") {
-            if (Math.random() > 0.95) {
-              addLog(`[RECOVERY] ${node.id} initialized. Performing self-test...`);
-              return { ...node, status: "IDLE", utilization: 0, load: 0 };
-            }
+            if (Math.random() > 0.95) return { ...node, status: "IDLE", utilization: 0, load: 0 };
             return node;
           }
-
           if (Math.random() > 0.995) {
-            addLog(`[CRITICAL] ${node.id} core voltage failure! Node offline.`);
-            return { ...node, status: "FAILED", utilization: 0, memory: 0, load: 0, temp: 20 };
+            return { ...node, status: "FAILED", utilization: 0, memory: 0, load: 0 };
           }
-
           let util = node.utilization + (Math.random() - 0.5) * 15;
-          if (Math.random() > 0.9) {
-            util += 35;
-            addLog(`[SPIKE] Massive compute load detected on ${node.id}.`);
-          }
+          if (Math.random() > 0.9) util += 30;
           util = Math.max(0, Math.min(100, util));
-          
-          const mem = Math.max(0, Math.min(100, node.memory + (Math.random() - 0.5) * 8));
-          const load = (util / 100) * 4.2;
-          const temp = 35 + (util * 0.5) + (Math.random() * 2);
-          
+          const mem = Math.max(0, Math.min(100, node.memory + (Math.random() - 0.5) * 5));
+          const load = (util / 100) * 4;
           let status: NodeStatus = "ACTIVE";
-          if (util > 92) {
-            status = "OVERLOADED";
-            if (node.status !== "OVERLOADED") addLog(`[WARNING] ${node.id} thermal throttling active.`);
-          }
+          if (util > 90) status = "OVERLOADED";
           else if (util < 5) status = "IDLE";
-
-          return { ...node, utilization: util, memory: mem, load, status, temp };
+          return { ...node, utilization: util, memory: mem, load, status };
         })
       );
     }, 1500);
-
     return () => clearInterval(interval);
   }, []);
 
@@ -76,126 +58,85 @@ export default function GPUClusterPanel() {
     setAvgLoad(total / nodes.length);
   }, [nodes]);
 
-  const addLog = (msg: string) => {
-    const time = new Date().toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute: '2-digit', second: '2-digit' });
-    setLogs(prev => [`[${time}] ${msg}`, ...prev].slice(0, 50));
-  };
-
-  if (!mounted) return null;
+  if (!mounted) {
+    return (
+      <section className="section-block" id="gpu-cluster" style={{ opacity: 0 }}>
+        <div className="section-label">03 // COMPUTE RESOURCES</div>
+        <h2 className="section-title">GPU Compute Clusters</h2>
+      </section>
+    );
+  }
 
   return (
-    <section className="section-block crazy-gpu" id="gpu-cluster">
-      <div className="section-label">03 // COMPUTATIONAL SUBSTRATE</div>
-      <h2 className="section-title">Nvidia H100 Cluster Telemetry</h2>
+    <section className="section-block" id="gpu-cluster">
+      <div className="section-label">03 // COMPUTE RESOURCES</div>
+      <h2 className="section-title">GPU Compute Clusters</h2>
       <p className="section-desc">
-        High-fidelity hardware monitoring of the underlying neural inference cluster. 
-        Saturation of these nodes directly impacts trust re-calibration latency.
+        Real-time telemetry from the underlying inference hardware.
+        High cluster utilization may introduce latency in the trust calibration loop.
       </p>
 
-      <div className="gpu-layout">
-        {/* LEFT: NODE GRID */}
-        <div className="gpu-grid-side">
-          <div className="cluster-grid">
-            {nodes.map((node) => (
-              <div key={node.id} className={`card node-card ${node.status.toLowerCase()} crazy-card`}>
-                <div className="node-glitch-bg" />
-                <div className="card-id">{node.id} // CORE-AX-{node.id.split("-")[1]}</div>
-                
-                <div className="node-status-badge">
-                  <div className="status-dot" style={{ 
-                    background: node.status === "OVERLOADED" ? "var(--red)" : 
-                                node.status === "FAILED" ? "#555" : 
-                                node.status === "IDLE" ? "var(--muted)" : "var(--green)" 
-                  }} />
-                  {node.status}
-                </div>
-
-                {/* VISUAL METER */}
-                <div className="node-visual">
-                  <svg viewBox="0 0 100 100" className="radial-meter">
-                    <circle cx="50" cy="50" r="45" className="meter-bg" />
-                    <motion.circle 
-                      cx="50" cy="50" r="45" 
-                      className="meter-fill"
-                      initial={{ pathLength: 0 }}
-                      animate={{ pathLength: node.utilization / 100 }}
-                      style={{ stroke: node.utilization > 90 ? "var(--red)" : "var(--cyan)" }}
-                    />
-                    <text x="50" y="55" className="meter-text">{Math.round(node.utilization)}%</text>
-                  </svg>
-                </div>
-
-                <div className="node-metrics-stack">
-                  <div className="mini-metric">
-                    <span className="l">MEM</span>
-                    <div className="mini-bar-bg"><motion.div className="mini-bar-fill" animate={{ width: `${node.memory}%` }} /></div>
-                  </div>
-                  <div className="mini-metric">
-                    <span className="l">TMP</span>
-                    <div className="mini-bar-bg"><motion.div className="mini-bar-fill tm" animate={{ width: `${(node.temp / 100) * 100}%` }} /></div>
-                  </div>
-                </div>
+      <div className="cluster-grid">
+        {nodes.map((node) => (
+          <div key={node.id} className={`card node-card ${node.status.toLowerCase()}`}>
+            <div className="card-id">{node.id} // NODE-0{node.id.split("-")[1]}</div>
+
+            <div className="node-status-badge">
+              <div className="status-dot" style={{
+                background: node.status === "OVERLOADED" ? "var(--red)" :
+                  node.status === "FAILED" ? "#555" :
+                    node.status === "IDLE" ? "var(--muted)" : "var(--green)"
+              }} />
+              {node.status}
+            </div>
 
-                <div className="node-footer-stats">
-                  <div className="node-stat">
-                    <span className="label">LOAD</span>
-                    <span className="val">{node.load.toFixed(1)} TFLOPS</span>
-                  </div>
-                  <div className="node-stat">
-                    <span className="label">FREQ</span>
-                    <span className="val">{node.status === "FAILED" ? 0 : (2.4 + (node.utilization * 0.01)).toFixed(2)} GHz</span>
-                  </div>
-                </div>
+            <div className="metric-bar-wrap" style={{ marginTop: 20 }}>
+              <div className="metric-bar-label">
+                <span>UTILIZATION</span>
+                <span style={{ color: "var(--cyan)" }}>{Math.round(node.utilization)}%</span>
+              </div>
+              <div className="metric-bar-bg">
+                <motion.div
+                  className="metric-bar-fill"
+                  animate={{ width: `${node.utilization}%` }}
+                  style={{ background: node.utilization > 90 ? "var(--red)" : "var(--cyan)" } as any}
+                />
               </div>
-            ))}
-          </div>
-        </div>
-
-        {/* RIGHT: SYSTEM LOG & HEATMAP */}
-        <div className="gpu-sys-side">
-          <div className="card sys-card">
-            <div className="card-id">SYS-LOG // KERNEL TELEMETRY</div>
-            <div className="terminal-log" ref={logRef}>
-              <AnimatePresence initial={false}>
-                {logs.map((log, i) => (
-                  <motion.div 
-                    key={log + i}
-                    initial={{ opacity: 0, x: -10 }}
-                    animate={{ opacity: 1, x: 0 }}
-                    className="log-line"
-                  >
-                    {log}
-                  </motion.div>
-                ))}
-              </AnimatePresence>
             </div>
-          </div>
 
-          <div className="card sys-card heatmap-card">
-            <div className="card-id">THERMAL // HEATMAP</div>
-            <div className="heatmap-grid">
-              {Array.from({ length: 64 }).map((_, i) => (
-                <motion.div 
-                  key={i} 
-                  className="heat-cell" 
-                  animate={{ 
-                    opacity: 0.2 + (Math.random() * 0.8),
-                    background: i % 8 < 4 ? "var(--cyan)" : "var(--blue)"
-                  }}
-                  transition={{ repeat: Infinity, duration: 1 + Math.random() * 2, repeatType: "mirror" }}
+            <div className="metric-bar-wrap" style={{ marginTop: 12 }}>
+              <div className="metric-bar-label">
+                <span>MEMORY USAGE</span>
+                <span style={{ color: "var(--green)" }}>{Math.round(node.memory)}%</span>
+              </div>
+              <div className="metric-bar-bg">
+                <motion.div
+                  className="metric-bar-fill"
+                  animate={{ width: `${node.memory}%` }}
+                  style={{ background: "var(--green)" } as any}
                 />
-              ))}
+              </div>
+            </div>
+
+            <div className="node-footer-stats">
+              <div className="node-stat">
+                <span className="label">COMPUTE</span>
+                <span className="val">{node.load.toFixed(1)} TFLOPS</span>
+              </div>
+              <div className="node-stat">
+                <span className="label">TEMP</span>
+                <span className="val">{Math.round(40 + (node.utilization * 0.4))}°C</span>
+              </div>
             </div>
-            <div className="heatmap-overlay">SCANNING...</div>
           </div>
-        </div>
+        ))}
       </div>
 
-      <div className="cluster-footer crazy-footer">
+      <div className="cluster-footer">
         <div className="cluster-total-load">
-          <span className="label">AGGREGATE CLUSTER PRESSURE</span>
+          <span className="label">TOTAL CLUSTER LOAD</span>
           <div className="load-meter-bg">
-            <motion.div 
+            <motion.div
               className="load-meter-fill"
               animate={{ width: `${avgLoad}%` }}
               style={{ background: avgLoad > 80 ? "var(--red)" : "var(--cyan)", color: avgLoad > 80 ? "var(--red)" : "var(--cyan)" } as any}
@@ -205,10 +146,10 @@ export default function GPUClusterPanel() {
         </div>
         <div className="cluster-telemetry">
           <span>THROUGHPUT: <b>{Math.round(140 - (avgLoad * 0.5))} FPS</b></span>
-          <span>SYSTEM HEALTH: <b style={{ color: avgLoad > 90 ? "var(--red)" : "var(--green)" }}>{avgLoad > 90 ? "CRITICAL" : "OPTIMAL"}</b></span>
+          <span>LATENCY: <b>{Math.round(12 + (avgLoad * 0.2))}ms</b></span>
+          <span>JITTER: <b>{jitter.toFixed(2)}ms</b></span>
         </div>
       </div>
-
     </section>
   );
 }

ui/app/hooks/useSentinel.ts

@@ -9,6 +9,8 @@ import type {
 
 /* ── helpers ──────────────────────────────────────────── */
 
+const API_BASE = process.env.NEXT_PUBLIC_API_URL || "";
+
 function bestSpec(obs: Observation | null): string {
   if (!obs) return "S0";
   return [...obs.available_specialists].sort(
@@ -92,12 +94,12 @@ export function useSentinel() {
 
   /* load evaluation data once */
   useEffect(() => {
-    fetch(`${process.env.NEXT_PUBLIC_API_URL}/assets/evaluation_results.json`)
+    fetch(`${API_BASE}/assets/evaluation_results.json`)
       .then((r) => r.json())
       .then(setEval)
       .catch(() => null);
 
-    fetch(`${process.env.NEXT_PUBLIC_API_URL}/assets/trained_policy_replay.jsonl`)
+    fetch(`${API_BASE}/assets/trained_policy_replay.jsonl`)
       .then((r) => r.ok ? r.text() : "")
       .then((txt) => {
         const table = new Map<string, ReplayRow>();

ui/app/page.tsx

@@ -293,7 +293,7 @@ export default function Page() {
         </div>
         <div className="footer-right">
           BUILD 2.4.1 // MARL-FRAMEWORK // MIT LICENSE<br />
-          © 2025 SENTINEL LAB. ALL RIGHTS RESERVED.
+          © 2025 THE_BOYS. ALL RIGHTS RESERVED.
         </div>
       </footer>
     </>