Fix ArchUnit violations from the new server code (layering + no-sleep)

Two LlamaArchitectureTest rules failed on PR #293 because of this branch's server
additions:

- layeredArchitecture (12 violations): the branch adds two legitimate new edges
  out of the Server layer -- Server -> Args (OpenAiServerCli maps -ctk/-ctv to the
  args.CacheType enum) and Server -> Loader (NativeServer.start() calls
  LlamaLoader.initialize() before launching the embedded native server). The rule
  documents itself as the EXACT set of accessors today, to be updated when a new
  dependency is intended, so Server is added to the Loader and Args
  mayOnlyBeAccessedByLayers lists (+ a doc note). Server remains the only layer
  allowed to reach the Api root and stays mayNotBeAccessedByAnyLayer.

- noThreadSleep (1 violation): NativeServer.main() kept the JVM alive with a
  while(isRunning()) Thread.sleep(200) poll loop. The rule bans Thread.sleep and has
  no suppression seam (it prefers Condition.await/poll), so main() now blocks on a
  bounded CountDownLatch.await(200ms) signalled by the shutdown hook. This is also a
  behavioural improvement: Ctrl-C/SIGTERM wakes the wait immediately instead of after
  up to a 200 ms tick, while the timeout still re-checks isRunning() to catch a
  self-terminated native worker.

Verified: LlamaArchitectureTest 12/12 pass; server-package tests 44/44 pass
(ServerLauncher, OpenAiServerCli, NativeServerSmoke); javadoc + spotless clean.

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

Author: claude

llama/src/main/java/net/ladenthin/llama/server/NativeServer.java

@@ -5,6 +5,8 @@
 package net.ladenthin.llama.server;
 
 import java.util.Objects;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 import lombok.ToString;
 import net.ladenthin.llama.loader.LlamaLoader;
@@ -198,20 +200,27 @@ public void close() {
     public static void main(String[] args) throws InterruptedException {
         final NativeServer server = new NativeServer(args);
         final AtomicBoolean stoppedByHook = new AtomicBoolean(false);
+        // Signalled by the shutdown hook so the main thread wakes immediately on Ctrl-C / SIGTERM
+        // rather than waiting out a poll tick — and so the wait uses a bounded latch await instead of
+        // Thread.sleep (banned by LlamaArchitectureTest.noThreadSleep).
+        final CountDownLatch stopSignal = new CountDownLatch(1);
         // Graceful Ctrl-C / SIGTERM: the embedded server installs no signal handlers of its own
         // (see patches/0006), so the JVM-level shutdown hook is what stops it before exit.
         Runtime.getRuntime()
                 .addShutdownHook(new Thread(
                         () -> {
                             stoppedByHook.set(true);
                             server.close();
+                            stopSignal.countDown();
                         },
                         "jllama-native-server-shutdown"));
         server.start();
         // Keep the JVM alive until the native worker exits — on its own (e.g. a fatal startup/model
-        // error that llama_server has already logged) or because the shutdown hook stopped it.
-        while (server.isRunning()) {
-            Thread.sleep(200L);
+        // error that llama_server has already logged) or because the shutdown hook stopped it. The
+        // bounded await returns early when the hook fires; on timeout we re-check isRunning() to catch
+        // a self-terminated worker.
+        while (server.isRunning() && !stopSignal.await(200L, TimeUnit.MILLISECONDS)) {
+            // wait for the native worker to exit or the shutdown hook to fire
         }
         if (!stoppedByHook.get()) {
             server.close();

llama/src/test/java/net/ladenthin/llama/LlamaArchitectureTest.java

@@ -94,8 +94,10 @@ public class LlamaArchitectureTest {
      * intend it. Conceptual tiers (informational): {@code Server} > {@code Api} (root) >
      * {@code Loader} > {@code Json}/{@code Parameters} >
      * {@code Value}/{@code Callback}/{@code Exception}/{@code Args}. The {@code Server} layer is the
-     * optional OpenAI-compatible HTTP entry point; it is the only layer permitted to access the
-     * {@code Api} root.
+     * optional OpenAI-compatible HTTP / native-server entry point; it is the only layer permitted to
+     * access the {@code Api} root, and it also reaches the {@code Loader} ({@code NativeServer}
+     * triggers {@code LlamaLoader.initialize()} before starting the embedded native server) and the
+     * {@code Args} enums ({@code OpenAiServerCli} maps {@code -ctk}/{@code -ctv} to {@code CacheType}).
      */
     @ArchTest
     static final ArchRule layeredArchitecture = layeredArchitecture()
@@ -121,7 +123,7 @@ public class LlamaArchitectureTest {
             .whereLayer("Api")
             .mayOnlyBeAccessedByLayers("Server")
             .whereLayer("Loader")
-            .mayOnlyBeAccessedByLayers("Api")
+            .mayOnlyBeAccessedByLayers("Api", "Server")
             .whereLayer("Json")
             .mayOnlyBeAccessedByLayers("Api")
             .whereLayer("Parameters")
@@ -133,7 +135,7 @@ public class LlamaArchitectureTest {
             .whereLayer("Exception")
             .mayOnlyBeAccessedByLayers("Api", "Loader")
             .whereLayer("Args")
-            .mayOnlyBeAccessedByLayers("Api", "Loader", "Parameters")
+            .mayOnlyBeAccessedByLayers("Api", "Loader", "Parameters", "Server")
             .whereLayer("Server")
             .mayNotBeAccessedByAnyLayer();