Windows CUDA: don't sccache-wrap nvcc; fail loudly on empty build

Run 28329638757 (788aaef): the CUDA build job went GREEN but produced an
empty artifact, so `package` failed with "Artifact not found:
Windows-x86_64-cuda". Two bugs:

1. sccache cannot wrap nvcc on Windows — it dies with
   "sccache: error: Could not parse shell line" on every .cu compile, so
   ggml-cuda never builds. My build.bat nvcc-launcher addition (mirrored
   from build.sh, which works on Linux) is the cause. Remove it: CUDA
   device code now builds with nvcc directly (uncached); the cl.exe C/C++
   TUs still cache via the C/CXX launcher.
2. The failed `cmake --build` exited 0 (sccache-as-launcher failure path),
   so build.bat reached the end and the job went green with no DLLs.
   build.bat now captures the build exit code, prints sccache stats
   regardless, then propagates a non-zero exit. As a backstop, the three
   GPU upload-artifact steps use if-no-files-found: error so an empty
   output fails the job loudly instead of surfacing later at package.

Docs (CLAUDE.md) corrected re: nvcc not being cached on Windows.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Deqf9xS6jz9t1idytVTaPV

Author: claude

.github/build.bat

@@ -38,27 +38,28 @@ if /I "%USE_CACHE%"=="true" (
     )
 )
 
-REM CUDA device-code caching: when sccache wrapping succeeded (LAUNCH set) and this
-REM is a CUDA build (GGML_CUDA in the cmake args), also front nvcc with sccache so the
-REM per-arch .cu device passes cache over Depot alongside the cl.exe TUs (mirrors
-REM build.sh). Inert on non-CUDA builds (the flag is simply unused).
-if defined LAUNCH (
-    echo %* | findstr /I "GGML_CUDA" >nul
-    if not errorlevel 1 (
-        set "LAUNCH=!LAUNCH! -DCMAKE_CUDA_COMPILER_LAUNCHER=sccache"
-        echo build.bat: CUDA build detected -- also wrapping nvcc with sccache.
-    )
-)
+REM NOTE: nvcc is NOT wrapped with sccache on Windows. Unlike build.sh (Linux) -- where
+REM sccache caches the per-arch .cu device passes -- sccache on Windows cannot parse the
+REM nvcc command line (it dies with `sccache: error: Could not parse shell line` and
+REM fails every .cu compile). So CUDA device code is built by nvcc directly (uncached)
+REM here; the cl.exe C/C++ TUs still cache via the C/CXX launcher set above.
 
 mkdir build
 cmake -Bbuild %LAUNCH% %*
-if errorlevel 1 exit /b %ERRORLEVEL%
+if errorlevel 1 exit /b 1
 cmake --build build --config Release
-if errorlevel 1 exit /b %ERRORLEVEL%
+set "BUILD_RC=!ERRORLEVEL!"
 
-REM Only query stats when sccache was actually wired in as the launcher; re-invoking
-REM a rejected/crashing sccache here would just repeat its failure output.
+REM Print cache stats (best-effort) regardless of build outcome -- only when sccache
+REM was wired in as the launcher.
 if defined LAUNCH (
     echo build.bat: sccache --show-stats
     sccache --show-stats
 )
+
+REM Propagate a build failure as a non-zero exit (a prior bug let a failed `cmake
+REM --build` reach here and exit 0, masquerading as a green build with no artifacts).
+if not "!BUILD_RC!"=="0" (
+    echo build.bat: cmake --build failed with exit code !BUILD_RC!.
+    exit /b !BUILD_RC!
+)

.github/workflows/publish.yml

@@ -734,6 +734,7 @@ jobs:
         with:
           name: Windows-x86_64-cuda
           path: ${{ github.workspace }}/src/main/resources_windows_cuda/net/ladenthin/llama/
+          if-no-files-found: error
 
   build-windows-x86_64-vulkan:
     name: Build Windows 2025 x86_64 Vulkan (Ninja + sccache)
@@ -782,6 +783,7 @@ jobs:
         with:
           name: Windows-x86_64-vulkan
           path: ${{ github.workspace }}/src/main/resources_windows_vulkan/net/ladenthin/llama/
+          if-no-files-found: error
 
   build-windows-x86_64-opencl:
     name: Build Windows 2025 x86_64 OpenCL (Ninja + sccache)
@@ -825,6 +827,7 @@ jobs:
         with:
           name: Windows-x86_64-opencl
           path: ${{ github.workspace }}/src/main/resources_windows_opencl/net/ladenthin/llama/
+          if-no-files-found: error
 
   # ---------------------------------------------------------------------------
   # CI-only jobs — no release artifact, purely for test coverage

CLAUDE.md

@@ -202,8 +202,12 @@ Wiring (mirrors the CUDA-Linux / OpenCL-Android classifier pattern):
    `resources_android_opencl`). The default CPU build (both generators) still emits to the canonical
    `src/main/resources/.../Windows/{x86_64,x86}/`, so the Ninja-vs-MSVC split is purely a
    CI-artifact-name + pom-profile concern (no CMake change for it).
-2. **`.github/build.bat`** — the sccache probe guard (mirrors `build.sh`); for CUDA builds it also
-   adds `-DCMAKE_CUDA_COMPILER_LAUNCHER=sccache` (detects `GGML_CUDA` in the args) so nvcc caches too.
+2. **`.github/build.bat`** — the sccache probe guard (mirrors `build.sh`) wraps the **cl.exe** C/C++ TUs
+   only. Unlike `build.sh` (Linux), it does **not** wrap `nvcc`: sccache on Windows can't parse the nvcc
+   command line (`sccache: error: Could not parse shell line`) and fails every `.cu` compile, so CUDA
+   device code builds with nvcc directly (uncached). `build.bat` also propagates a `cmake --build`
+   failure as a non-zero exit (a prior bug let a failed CUDA build exit 0 → empty artifact → late
+   `package` failure); the GPU upload steps additionally use `if-no-files-found: error` as a backstop.
 3. **`.github/build_opencl_windows.bat`** — stages Khronos OpenCL-Headers + builds OpenCL-ICD-Loader
    (`OpenCL.lib`), then delegates to `build.bat` with `-DOpenCL_INCLUDE_DIR`/`-DOpenCL_LIBRARY`
    (the Windows analogue of `build_opencl_android.sh`).