feat(dflash): add --lazy-draft to C++ server

Park the decode draft model (~3.3 GB) when idle to free VRAM for pflash
compression. Before generate, free the pflash drafter and unpark the decode
draft; after generate, park draft again.

Flow: startup → park draft | request → compress → free pflash drafter →
unpark draft → generate → park draft

Saves ~3.3 GB VRAM on idle, enabling longer context on 22 GB GPUs.
Port of Python server.py --lazy-draft behavior to the C++ in-process server.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: howard0su

dflash/src/server/http_server.cpp

@@ -712,13 +712,24 @@ void HttpServer::worker_loop() {
         };
 
         // Run generation (with or without restore).
+        // Lazy-draft: ensure decode draft is loaded before generate.
+        if (config_.lazy_draft) {
+            backend_.free_drafter();    // free pflash drafter (~1.4 GB) if loaded
+            backend_.unpark("draft");   // reload decode draft (~3.3 GB)
+        }
+
         GenerateResult result;
         if (using_restore) {
             result = backend_.restore_and_generate(cache_slot, gen_req, io);
         } else {
             result = backend_.generate(gen_req, io);
         }
 
+        // Lazy-draft: park decode draft after generate to free VRAM.
+        if (config_.lazy_draft) {
+            backend_.park("draft");
+        }
+
         // Confirm or abort the inline snapshot.
         if (snap_prepared) {
             if (completion_tokens > 0 && !client_disconnected) {

dflash/src/server/http_server.h

@@ -56,6 +56,7 @@ struct ServerConfig {
     float       pflash_keep_ratio = 0.05f;  // fraction of tokens to keep
     std::string pflash_drafter_path;        // path to drafter GGUF (Qwen3-0.6B)
     bool        pflash_skip_park = false;   // skip park/unpark for ≥32GB GPUs
+    bool        lazy_draft      = true;    // park decode draft when idle to save VRAM
 
     // Disk prefix cache
     std::string disk_cache_dir;             // empty = disabled

dflash/src/server/server_main.cpp

@@ -68,6 +68,7 @@ static void print_usage(const char * prog) {
         "  --prefill-keep-ratio <F>    Fraction of tokens to keep (default: 0.05)\n"
         "  --prefill-drafter <path>    Drafter GGUF for compression (Qwen3-0.6B)\n"
         "  --prefill-skip-park         Skip park/unpark (for >=32GB GPUs)\n"
+        "  --no-lazy-draft             Keep decode draft loaded at all times\n"
         "\n"
         "Disk KV cache:\n"
         "  --kv-cache-dir <path>       Directory for ondisk KV cache (enables feature)\n"
@@ -140,6 +141,8 @@ int main(int argc, char ** argv) {
             sconfig.pflash_drafter_path = argv[++i];
         } else if (std::strcmp(argv[i], "--prefill-skip-park") == 0) {
             sconfig.pflash_skip_park = true;
+        } else if (std::strcmp(argv[i], "--no-lazy-draft") == 0) {
+            sconfig.lazy_draft = false;
         } else if (std::strcmp(argv[i], "--kv-cache-dir") == 0 && i + 1 < argc) {
             sconfig.disk_cache_dir = argv[++i];
         } else if (std::strcmp(argv[i], "--kv-cache-budget") == 0 && i + 1 < argc) {
@@ -269,6 +272,9 @@ int main(int argc, char ** argv) {
     std::fprintf(stderr, "[server] │  fp_use_bsa      = %s\n", getenv("DFLASH_FP_USE_BSA") ? "ON" : "off");
     std::fprintf(stderr, "[server] │  fp_alpha        = %s\n", getenv("DFLASH_FP_ALPHA") ? getenv("DFLASH_FP_ALPHA") : "0.12 (default)");
     }
+    if (bargs.draft_path) {
+    std::fprintf(stderr, "[server] │  lazy_draft      = %s\n", sconfig.lazy_draft ? "ON" : "off");
+    }
     std::fprintf(stderr, "[server] ╰─────────────────────────────────────────────────────╯\n\n");
 
     HttpServer server(*backend, tokenizer, sconfig);
@@ -278,6 +284,12 @@ int main(int argc, char ** argv) {
     if (pflash_enabled) {
         server.set_drafter_tokenizer(&drafter_tokenizer);
     }
+
+    // Lazy-draft: park decode draft at startup to free VRAM (~3.3 GB).
+    if (sconfig.lazy_draft && bargs.draft_path) {
+        backend->park("draft");
+    }
+
     int ret = server.run();
 
     // Cleanup.