feat: introduce neural debugger dashboard and update memory UI components to use CSS variables

Author: apstenku123

.github/workflows/cuda-lane.yml

@@ -0,0 +1,30 @@
+name: CUDA Lane
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  workflow_dispatch:
+
+jobs:
+  cuda-tests:
+    name: Run CUDA-only tests
+    runs-on: [self-hosted, cuda]
+    timeout-minutes: 30
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.13"
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -e ".[dev]"
+
+      - name: Run CUDA tests
+        run: |
+          python -m pytest -m "cuda_hardware or cuda_required" -v --tb=short

backend.log

@@ -48,6 +48,7 @@
     PathCPhysicalAbiBankOwner,
     logical_bank_view,
     make_physical_abi_bank_owner,
+    path_c_top_level_kernel_buffer_specs,
     write_into_bank_slot,
 )
 from cppmega_mlx.runtime.path_c_taps import emit_and_tap_path_c_tensor
@@ -1130,10 +1131,17 @@ def path_c_fused_train_block_prim_func(
 
         This drives the same schedule planner the production runtime uses and
         returns the generated PrimFunc (carrying the physical-ABI attrs), or
-        ``None`` when no Path C route region exists. The model never caches the
-        artifact — callers that need to reuse it across calls should hold the
-        returned reference themselves.
+        ``None`` when no Path C route region exists. Results are cached per
+        ``sequence_length`` so repeated calls return the same object.
         """
+        cache: dict[int | None, Any] = getattr(
+            self, "_prim_func_cache", None,
+        ) or {}
+        if not hasattr(self, "_prim_func_cache"):
+            self._prim_func_cache = cache
+        if sequence_length in cache:
+            return cache[sequence_length]
+
         from cppmega_mlx.runtime.path_c_fusion_schedules import (
             plan_path_c_fusion_schedule_for_region,
         )
@@ -1163,21 +1171,22 @@ def path_c_fused_train_block_prim_func(
         schedule_target = getattr(planned, "schedule_target", None)
         if schedule_target is None:
             return None
-        return schedule_target.schedule_template(planned.region)
+        result = schedule_target.schedule_template(planned.region)
+        cache[sequence_length] = result
+        return result
 
     def make_path_c_physical_abi_bank_owner(
         self,
         *,
         sequence_length: int | None = None,
     ) -> PathCPhysicalAbiBankOwner | None:
-        """Allocate the physical ABI banks the generated fused PrimFunc needs.
+        """Allocate the caller-owned buffers the generated fused PrimFunc needs.
 
         Returns a validated :class:`PathCPhysicalAbiBankOwner` whose ``buffers``
         are freshly zero-initialised MLX arrays sized exactly to the generated
-        ``_cppmega_path_c_physical_buffer_abi_shapes`` map (dtype is taken from
-        the corresponding logical-buffer placement so every bank reflects the
-        generated kernel ABI). The owner never repacks or copies model tensors;
-        it only owns the bank arrays so the runtime can bind kernel arguments
+        dtype banks plus any top-level spilled scratch parameters declared by
+        the generated PrimFunc. The owner never repacks or copies model
+        tensors; it only owns kernel buffers so the runtime can bind arguments
         in declared order.
 
         Returns ``None`` when no Path C route region exists for the model.
@@ -1219,6 +1228,17 @@ def make_path_c_physical_abi_bank_owner(
                 tuple(int(dim) for dim in tuple(shape)),
                 dtype=mx_dtype,
             )
+        for name, spec in path_c_top_level_kernel_buffer_specs(
+            prim_func,
+            physical_abi_map=abi_map,
+            physical_abi_shapes=abi_shapes,
+        ).items():
+            if name in bank_buffers:
+                continue
+            bank_buffers[name] = mx.zeros(
+                tuple(int(dim) for dim in tuple(spec["shape"])),
+                dtype=_path_c_bank_dtype(str(spec["dtype"])),
+            )
         profile_name = str(
             getattr(self, "path_c_profile_name", "HybridTinyLM")
         )

cppmega_mlx/models/hybrid_lm.py

@@ -2055,6 +2055,7 @@ def _build_legacy_mamba3_fp8_train_diagnostic_region() -> PathCFusionRegion:
 def build_mamba3_fp8_train_acceptance_fixture_region(
     *,
     include_backward: bool = False,
+    model_config: Any | None = None,
 ) -> PathCFusionRegion:
     """Return the explicit named acceptance fixture for MRA train-block tests.
 
@@ -2064,14 +2065,15 @@ def build_mamba3_fp8_train_acceptance_fixture_region(
     model's actual brick graph.
     """
 
-    from cppmega_mlx.recipes.model_factory import local_gb10_quarter_profile
+    if model_config is None:
+        from cppmega_mlx.recipes.model_factory import local_gb10_quarter_profile
 
-    acceptance_profile = local_gb10_quarter_profile()
+        model_config = local_gb10_quarter_profile().hybrid_config()
     return _build_path_c_acceptance_fixture_region_from_route_symbols(
         region_name="mamba3_m2rnn_attention_fp8_train_block",
         route_symbols=("M", "R", "A"),
         include_backward=include_backward,
-        model_config=acceptance_profile.hybrid_config(),
+        model_config=model_config,
         acceptance_tags=("mamba3_fp8_train_acceptance",),
     )