fix: fail fast on insufficient disk space instead of retry loop

When a download fails with CURLE_WRITE_ERROR (code 23) due to disk
full, the retry logic would delete the partial file and restart from
zero — repeating indefinitely and wasting bandwidth.

This adds:
- Pre-flight disk space check before downloading, comparing available
  space against total download size
- Detection of CURLE_WRITE_ERROR + low disk as a fatal (non-retryable)
  condition with a clear error message
- disk_full flag on DownloadResult to short-circuit the retry loop

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: ianbmacdonald

src/cpp/include/lemon/utils/http_client.h

@@ -37,6 +37,7 @@ struct DownloadResult {
     size_t bytes_downloaded = 0;      // Bytes downloaded in this attempt
     size_t total_bytes = 0;           // Total file size (if known)
     bool can_resume = false;          // Whether partial download can be resumed
+    bool disk_full = false;            // True if download failed due to insufficient disk space
 };
 
 // Progress callback returns bool: true = continue, false = cancel download

src/cpp/server/model_manager.cpp

@@ -1805,6 +1805,21 @@ void ModelManager::download_from_manifest(const json& manifest, std::map<std::st
         total_download_size += file_desc["size"].get<size_t>();
     }
 
+    // Pre-flight disk space check: fail fast before downloading anything
+    {
+        std::error_code ec;
+        auto si = fs::space(fs::path(download_path), ec);
+        if (!ec && total_download_size > si.available) {
+            std::ostringstream oss;
+            oss << "Insufficient disk space: download requires "
+                << std::fixed << std::setprecision(1)
+                << (total_download_size / (1024.0 * 1024.0 * 1024.0)) << " GB but only "
+                << (si.available / (1024.0 * 1024.0 * 1024.0)) << " GB is available on "
+                << download_path;
+            throw std::runtime_error(oss.str());
+        }
+    }
+
     for (const auto& file_desc : manifest["files"]) {
         file_index++;
         std::string filename = file_desc["name"].get<std::string>();

src/cpp/server/utils/http_client.cpp

@@ -398,6 +398,7 @@ DownloadResult HttpClient::download_attempt(const std::string& url,
 
     if (res != CURLE_OK) {
         bool retryable = false;
+        bool disk_full = false;
         switch (res) {
             case CURLE_COULDNT_CONNECT:
             case CURLE_COULDNT_RESOLVE_HOST:
@@ -410,6 +411,17 @@ DownloadResult HttpClient::download_attempt(const std::string& url,
             case CURLE_SSL_CONNECT_ERROR:
                 retryable = true;
                 break;
+            case CURLE_WRITE_ERROR: {
+                // CURLE_WRITE_ERROR (23) typically means disk full.
+                // Check available disk space to confirm.
+                std::error_code ec;
+                auto si = fs::space(output_path_fs.parent_path(), ec);
+                if (!ec && si.available < 1024 * 1024) {  // Less than 1 MB free
+                    disk_full = true;
+                }
+                retryable = false;
+                break;
+            }
             default:
                 retryable = false;
         }
@@ -419,9 +431,20 @@ DownloadResult HttpClient::download_attempt(const std::string& url,
             current_file_size = fs::file_size(output_path_fs);
         }
         result.can_resume = retryable && (current_file_size > 0);
+        result.disk_full = disk_full;
 
         std::ostringstream oss;
-        oss << "Download failed: " << result.curl_error << " (CURL code: " << result.curl_code << ")";
+        if (disk_full) {
+            oss << "Disk full: not enough space to complete download";
+            std::error_code ec;
+            auto si = fs::space(output_path_fs.parent_path(), ec);
+            if (!ec) {
+                oss << " (" << std::fixed << std::setprecision(1)
+                    << (si.available / (1024.0 * 1024.0)) << " MB free)";
+            }
+        } else {
+            oss << "Download failed: " << result.curl_error << " (CURL code: " << result.curl_code << ")";
+        }
         if (result.bytes_downloaded > 0) {
             oss << "\n  Downloaded " << (result.bytes_downloaded / (1024.0 * 1024.0)) << " MB before failure";
         }
@@ -582,6 +605,12 @@ DownloadResult HttpClient::download_file(const std::string& url,
             return final_result;
         }
 
+        // If disk is full, fail immediately — retrying will just waste bandwidth
+        if (final_result.disk_full) {
+            LOG(ERROR, "HttpClient") << "[Download] " << final_result.error_message << std::endl;
+            return final_result;
+        }
+
         if (final_result.success) {
             // Download complete - rename .partial to final path
             std::error_code ec;