librats 0.7.2 → 0.9.0

package/native-src/src/file_transfer.cpp

@@ -2,1807 +2,1414 @@
 #include "librats.h"
 #include "fs.h"
 #include "logger.h"
-#include "sha1.h"
+#include "crypto/sha256.h"
 
-// Define logging module for this file
-#define LOG_FILE_TRANSFER_INFO(message) LOG_INFO("filetransfer", message)
-#define LOG_FILE_TRANSFER_ERROR(message) LOG_ERROR("filetransfer", message)
-#define LOG_FILE_TRANSFER_WARN(message) LOG_WARN("filetransfer", message)
-#define LOG_FILE_TRANSFER_DEBUG(message) LOG_DEBUG("filetransfer", message)
 #include <algorithm>
-#include <random>
-#include <iomanip>
-#include <sstream>
 #include <cstring>
-#include <cstdlib>
-
-// Optional compression support
-#ifdef LIBRATS_ENABLE_ZLIB
-#include <zlib.h>
-#endif
+#include <random>
 
-#ifdef LIBRATS_ENABLE_LZ4
-#include <lz4.h>
-#endif
+// Logging shorthand for this module.
+#define LOG_FT_INFO(msg)  LOG_INFO("filetransfer", msg)
+#define LOG_FT_WARN(msg)  LOG_WARN("filetransfer", msg)
+#define LOG_FT_ERROR(msg) LOG_ERROR("filetransfer", msg)
+#define LOG_FT_DEBUG(msg) LOG_DEBUG("filetransfer", msg)
 
 namespace librats {
 
-//=============================================================================
-// DirectoryMetadata Implementation
-//=============================================================================
-
-uint64_t DirectoryMetadata::get_total_size() const {
-    uint64_t total = 0;
-    
-    // Add size of files in this directory
-    for (const auto& file : files) {
-        total += file.file_size;
-    }
-    
-    // Add size of subdirectories recursively
-    for (const auto& subdir : subdirectories) {
-        total += subdir.get_total_size();
+// =============================================================================
+// Wire constants
+// =============================================================================
+
+namespace {
+
+// Named control-message types exchanged on the JSON channel.
+constexpr const char* MSG_OFFER    = "ft_offer";
+constexpr const char* MSG_RESPONSE = "ft_response";
+constexpr const char* MSG_FILE_END = "ft_file_end";
+constexpr const char* MSG_PROGRESS = "ft_progress";
+constexpr const char* MSG_COMPLETE = "ft_complete";
+constexpr const char* MSG_CONTROL  = "ft_control";
+
+// Magic prefix of a binary chunk frame.
+constexpr char CHUNK_MAGIC[4] = {'R', 'F', 'T', '1'};
+
+// How long a finished transfer is kept queryable before being purged.
+constexpr auto FINISHED_RETENTION = std::chrono::minutes(5);
+
+// =============================================================================
+// Small helpers
+// =============================================================================
+
+// --- big-endian serialization ---
+void put_u16(std::vector<uint8_t>& b, uint16_t v) {
+    b.push_back(uint8_t(v >> 8));
+    b.push_back(uint8_t(v));
+}
+void put_u32(std::vector<uint8_t>& b, uint32_t v) {
+    b.push_back(uint8_t(v >> 24));
+    b.push_back(uint8_t(v >> 16));
+    b.push_back(uint8_t(v >> 8));
+    b.push_back(uint8_t(v));
+}
+void put_u64(std::vector<uint8_t>& b, uint64_t v) {
+    for (int s = 56; s >= 0; s -= 8) b.push_back(uint8_t(v >> s));
+}
+uint16_t get_u16(const uint8_t* p) { return uint16_t(p[0]) << 8 | p[1]; }
+uint32_t get_u32(const uint8_t* p) {
+    return uint32_t(p[0]) << 24 | uint32_t(p[1]) << 16 | uint32_t(p[2]) << 8 | p[3];
+}
+uint64_t get_u64(const uint8_t* p) {
+    uint64_t v = 0;
+    for (int i = 0; i < 8; ++i) v = (v << 8) | p[i];
+    return v;
+}
+
+// --- CRC32 (IEEE 802.3) for per-chunk integrity ---
+struct Crc32Table {
+    uint32_t t[256];
+    Crc32Table() {
+        for (uint32_t i = 0; i < 256; ++i) {
+            uint32_t c = i;
+            for (int k = 0; k < 8; ++k) c = (c & 1) ? (0xEDB88320u ^ (c >> 1)) : (c >> 1);
+            t[i] = c;
+        }
     }
-    
-    return total;
+};
+uint32_t crc32(const uint8_t* data, size_t len) {
+    static const Crc32Table tbl;
+    uint32_t c = 0xFFFFFFFFu;
+    for (size_t i = 0; i < len; ++i) c = tbl.t[(c ^ data[i]) & 0xFF] ^ (c >> 8);
+    return c ^ 0xFFFFFFFFu;
 }
 
-size_t DirectoryMetadata::get_total_file_count() const {
-    size_t count = files.size();
-    
-    // Add files from subdirectories recursively
-    for (const auto& subdir : subdirectories) {
-        count += subdir.get_total_file_count();
+// --- hex encoding ---
+std::string to_hex(const uint8_t* d, size_t n) {
+    static const char* h = "0123456789abcdef";
+    std::string s(n * 2, '0');
+    for (size_t i = 0; i < n; ++i) {
+        s[2 * i]     = h[d[i] >> 4];
+        s[2 * i + 1] = h[d[i] & 0xF];
     }
-    
-    return count;
+    return s;
 }
 
-//=============================================================================
-// FileTransferProgress Implementation
-//=============================================================================
+// SHA-256 of an empty input, used for zero-byte files.
+std::string sha256_of_empty() {
+    uint8_t digest[SHA256_HASH_SIZE];
+    sha256_hash(digest, nullptr, 0);
+    return to_hex(digest, SHA256_HASH_SIZE);
+}
 
-void FileTransferProgress::update_transfer_rates(uint64_t new_bytes_transferred) {
-    auto now = std::chrono::steady_clock::now();
-    auto time_diff = std::chrono::duration_cast<std::chrono::milliseconds>(now - last_update);
-    
-    if (time_diff.count() > 0) {
-        uint64_t bytes_diff = new_bytes_transferred - bytes_transferred;
-        transfer_rate_bps = (static_cast<double>(bytes_diff) * 1000.0) / time_diff.count();
-        
-        // Calculate average rate since start
-        auto total_time = std::chrono::duration_cast<std::chrono::milliseconds>(now - start_time);
-        if (total_time.count() > 0) {
-            average_rate_bps = (static_cast<double>(new_bytes_transferred) * 1000.0) / total_time.count();
-        }
-        
-        // Estimate time remaining
-        if (transfer_rate_bps > 0 && total_bytes > new_bytes_transferred) {
-            uint64_t remaining_bytes = total_bytes - new_bytes_transferred;
-            estimated_time_remaining = std::chrono::milliseconds(
-                static_cast<int64_t>((remaining_bytes * 1000.0) / transfer_rate_bps)
-            );
-        } else {
-            estimated_time_remaining = std::chrono::milliseconds(0);
+// --- random transfer id ---
+std::string random_transfer_id() {
+    static const char* h = "0123456789abcdef";
+    std::random_device rd;
+    std::mt19937 gen(rd() ^ uint32_t(std::chrono::steady_clock::now().time_since_epoch().count()));
+    std::uniform_int_distribution<int> dis(0, 15);
+    std::string id(32, '0');
+    for (char& c : id) c = h[dis(gen)];
+    return id;
+}
+
+// A relative path coming from a peer must not escape the destination directory.
+bool is_safe_relative_path(const std::string& p) {
+    if (p.empty()) return false;
+    if (p.front() == '/' || p.front() == '\\') return false;
+    if (p.size() >= 2 && p[1] == ':') return false; // Windows drive letter
+    size_t start = 0;
+    for (size_t i = 0; i <= p.size(); ++i) {
+        if (i == p.size() || p[i] == '/' || p[i] == '\\') {
+            std::string comp = p.substr(start, i - start);
+            if (comp.empty() || comp == "." || comp == "..") return false;
+            start = i + 1;
         }
     }
-    
-    bytes_transferred = new_bytes_transferred;
-    last_update = now;
+    return true;
 }
 
-//=============================================================================
-// FileTransferManager Implementation
-//=============================================================================
+} // namespace
+
+// =============================================================================
+// Internal per-transfer state
+// =============================================================================
+
+// One file within a transfer.
+struct TransferFile {
+    std::string relative_path;   // POSIX path relative to the transfer root
+    uint64_t    size = 0;
+
+    // sender side
+    std::string source_path;     // local path the data is read from
+
+    // receiver side
+    std::string temp_path;       // chunks are written here first
+    std::string final_path;      // destination once verified
+    uint64_t    received = 0;    // bytes written so far
+    bool        temp_created = false;
+    std::string expected_sha;    // from ft_file_end
+    std::string computed_sha;    // hashed while receiving
+    bool        sha_known = false;
+    bool        finalized = false;
+};
+
+// Full state of a single transfer. Always held through a shared_ptr; `mtx`
+// guards every field below `total_bytes`.
+struct Transfer {
+    // immutable after creation
+    std::string id;
+    std::string peer_id;
+    FileTransferDirection direction;
+    bool is_directory = false;
+    std::string name;
+    std::string local_root;          // sender: source path; receiver: destination
+    std::vector<TransferFile> files;
+    uint64_t total_bytes = 0;
+
+    // mutable state
+    std::mutex mtx;
+    std::condition_variable cv;
+    FileTransferStatus status = FileTransferStatus::PENDING;
+    bool finished = false;           // finish() has run (fired callbacks); distinct from status
+    std::string error;
+    uint64_t bytes_done = 0;         // sender: streamed bytes; receiver: written bytes
+    uint64_t acked_bytes = 0;        // sender: bytes confirmed by the peer
+    uint32_t files_done = 0;
+
+    // sender streaming cursor (survives pause)
+    size_t   send_file = 0;
+    uint64_t send_offset = 0;
+    sha256_context_t send_hash;
+    bool     worker_active = false;
+
+    // receiver cursor
+    size_t   recv_file = 0;
+    sha256_context_t recv_hash;
+    uint64_t last_ack_sent = 0;      // bytes_done at the last ft_progress emitted
+
+    // timing
+    std::chrono::steady_clock::time_point start_time;
+    std::chrono::steady_clock::time_point last_activity;
+    std::chrono::steady_clock::time_point last_progress_cb;
+
+    // throughput
+    double rate_bps = 0.0;
+    uint64_t rate_mark_bytes = 0;
+    std::chrono::steady_clock::time_point rate_mark_time;
+
+    bool is_terminal() const {
+        return status == FileTransferStatus::COMPLETED ||
+               status == FileTransferStatus::FAILED ||
+               status == FileTransferStatus::CANCELLED;
+    }
+};
+
+// =============================================================================
+// Status name
+// =============================================================================
+
+const char* file_transfer_status_name(FileTransferStatus s) {
+    switch (s) {
+        case FileTransferStatus::PENDING:     return "PENDING";
+        case FileTransferStatus::STARTING:    return "STARTING";
+        case FileTransferStatus::IN_PROGRESS: return "IN_PROGRESS";
+        case FileTransferStatus::PAUSED:      return "PAUSED";
+        case FileTransferStatus::COMPLETED:   return "COMPLETED";
+        case FileTransferStatus::FAILED:      return "FAILED";
+        case FileTransferStatus::CANCELLED:   return "CANCELLED";
+        case FileTransferStatus::RESUMING:    return "RESUMING";
+    }
+    return "UNKNOWN";
+}
+
+// =============================================================================
+// Construction / destruction
+// =============================================================================
 
 FileTransferManager::FileTransferManager(RatsClient& client, const FileTransferConfig& config)
-    : client_(client), config_(config), running_(true),
-      total_bytes_sent_(0), total_bytes_received_(0),
-      total_files_sent_(0), total_files_received_(0) {
-    
-    start_time_ = std::chrono::steady_clock::now();
-    initialize();
-}
+    : client_(client), config_(config) {
+    started_at_ = std::chrono::steady_clock::now();
+    create_directories(config_.temp_directory.c_str());
+    register_handlers();
 
-FileTransferManager::~FileTransferManager() {
-    shutdown();
-}
+    uint32_t threads = std::max<uint32_t>(1, config_.worker_threads);
+    for (uint32_t i = 0; i < threads; ++i) {
+        workers_.emplace_back(&FileTransferManager::worker_loop, this);
+    }
+    maintenance_thread_ = std::thread(&FileTransferManager::maintenance_loop, this);
 
-void FileTransferManager::initialize() {
-    // Ensure temp directory exists
-    create_directories(config_.temp_directory.c_str());
-    
-    // Register message handlers with RatsClient
-    client_.on("file_transfer_request", [this](const std::string& peer_id, const nlohmann::json& data) {
-        handle_transfer_request(peer_id, data);
-    });
-    
-    client_.on("file_transfer_response", [this](const std::string& peer_id, const nlohmann::json& data) {
-        handle_transfer_response(peer_id, data);
-    });
-    
-    client_.on("file_chunk_metadata", [this](const std::string& peer_id, const nlohmann::json& data) {
-        handle_chunk_metadata_message(peer_id, data);
-    });
-    
-    // Note: Binary chunk data will be handled through the global binary_data_callback_
-    // The FileTransferManager will check for file chunk magic headers in the callback
-    
-    client_.on("file_chunk_ack", [this](const std::string& peer_id, const nlohmann::json& data) {
-        handle_chunk_ack_message(peer_id, data);
-    });
-    
-    client_.on("file_transfer_control", [this](const std::string& peer_id, const nlohmann::json& data) {
-        handle_transfer_control(peer_id, data);
-    });
-    
-    client_.on("file_request", [this](const std::string& peer_id, const nlohmann::json& data) {
-        handle_file_request(peer_id, data);
-    });
-    
-    client_.on("directory_request", [this](const std::string& peer_id, const nlohmann::json& data) {
-        handle_directory_request(peer_id, data);
-    });
-    
-    // Start worker threads
-    for (uint32_t i = 0; i < config_.max_concurrent_chunks; ++i) {
-        worker_threads_.emplace_back(&FileTransferManager::worker_thread_loop, this);
-    }
-    
-    // Start cleanup thread for pending chunks timeout
-    worker_threads_.emplace_back(&FileTransferManager::cleanup_thread_loop, this);
-    
-    LOG_FILE_TRANSFER_INFO("FileTransferManager initialized with " << worker_threads_.size() << " worker threads");
+    LOG_FT_INFO("FileTransferManager started (" << threads << " workers)");
 }
 
-void FileTransferManager::shutdown() {
-    LOG_FILE_TRANSFER_INFO("FileTransferManager stopping...");
+FileTransferManager::~FileTransferManager() {
     running_.store(false);
-    
-    // Notify all condition variables to wake up waiting threads immediately
-    work_condition_.notify_all();
-    cleanup_condition_.notify_all();
-    throttle_condition_.notify_all();
-    
-    // Join all worker threads
-    for (auto& thread : worker_threads_) {
-        if (thread.joinable()) {
-            thread.join();
+    queue_cv_.notify_all();
+    maintenance_cv_.notify_all();
+
+    // Wake any worker blocked on a transfer's condition variable.
+    {
+        std::lock_guard<std::mutex> lk(transfers_mutex_);
+        for (auto& kv : transfers_) {
+            std::lock_guard<std::mutex> tk(kv.second->mtx);
+            kv.second->cv.notify_all();
         }
     }
-    
-    worker_threads_.clear();
-    LOG_FILE_TRANSFER_INFO("FileTransferManager stopped");
-}
 
-void FileTransferManager::worker_thread_loop() {
-    while (running_.load()) {
-        std::unique_lock<std::mutex> lock(work_mutex_);
-        work_condition_.wait(lock, [this] { return !work_queue_.empty() || !running_.load(); });
-        
-        if (!running_.load()) {
-            break;
-        }
-        
-        if (!work_queue_.empty()) {
-            std::string transfer_id = work_queue_.front();
-            work_queue_.pop();
-            lock.unlock();
-            
-            process_transfer(transfer_id);
-        }
+    for (auto& w : workers_) {
+        if (w.joinable()) w.join();
     }
+    if (maintenance_thread_.joinable()) maintenance_thread_.join();
+    LOG_FT_INFO("FileTransferManager stopped");
 }
 
-void FileTransferManager::cleanup_thread_loop() {
-    const auto cleanup_interval = std::chrono::seconds(5);
-    const auto pending_timeout = std::chrono::seconds(30);
-    
-    while (running_.load()) {
-        // Use condition variable with timeout instead of sleep
-        std::unique_lock<std::mutex> lock(cleanup_mutex_);
-        cleanup_condition_.wait_for(lock, cleanup_interval, [this] { return !running_.load(); });
-        
-        if (!running_.load()) {
-            break;
-        }
-        
-        // Clean up expired pending chunks
-        auto now = std::chrono::steady_clock::now();
-        std::vector<std::string> expired_peers;
-        
-        {
-            std::lock_guard<std::mutex> lock(chunks_mutex_);
-            for (auto it = pending_chunks_.begin(); it != pending_chunks_.end();) {
-                if (now - it->second.created_at > pending_timeout) {
-                    LOG_FILE_TRANSFER_WARN("Pending chunk from peer " << it->first << 
-                                          " timed out (transfer: " << it->second.transfer_id << 
-                                          ", chunk: " << it->second.chunk_index << ")");
-                    expired_peers.push_back(it->first);
-                    it = pending_chunks_.erase(it);
-                } else {
-                    ++it;
-                }
-            }
-        }
-        
-        // Send negative acknowledgments for expired chunks
-        for (const auto& peer_id : expired_peers) {
-            // We don't have direct access to the transfer info here, but the timeout logged above
-            // provides sufficient information for debugging
-            LOG_FILE_TRANSFER_DEBUG("Cleaned up " << expired_peers.size() << " expired pending chunks");
-        }
-    }
+void FileTransferManager::register_handlers() {
+    client_.on(MSG_OFFER,    [this](const std::string& p, const nlohmann::json& m) { on_offer(p, m); });
+    client_.on(MSG_RESPONSE, [this](const std::string& p, const nlohmann::json& m) { on_response(p, m); });
+    client_.on(MSG_FILE_END, [this](const std::string& p, const nlohmann::json& m) { on_file_end(p, m); });
+    client_.on(MSG_PROGRESS, [this](const std::string& p, const nlohmann::json& m) { on_progress(p, m); });
+    client_.on(MSG_COMPLETE, [this](const std::string& p, const nlohmann::json& m) { on_complete(p, m); });
+    client_.on(MSG_CONTROL,  [this](const std::string& p, const nlohmann::json& m) { on_control(p, m); });
 }
 
+// =============================================================================
+// Configuration
+// =============================================================================
+
 void FileTransferManager::set_config(const FileTransferConfig& config) {
-    std::lock_guard<std::mutex> lock(transfers_mutex_);
+    std::lock_guard<std::mutex> lk(config_mutex_);
     config_ = config;
-    
-    // Ensure temp directory exists
     create_directories(config_.temp_directory.c_str());
 }
 
-const FileTransferConfig& FileTransferManager::get_config() const {
+FileTransferConfig FileTransferManager::get_config() const {
+    std::lock_guard<std::mutex> lk(config_mutex_);
     return config_;
 }
 
-bool FileTransferManager::handle_binary_data(const std::string& peer_id, const std::vector<uint8_t>& binary_data) {
-    // Check if this is a file chunk binary message
-    const std::string magic = "FTCHUNK";
-    
-    if (binary_data.size() >= magic.length() && 
-        std::memcmp(binary_data.data(), magic.c_str(), magic.length()) == 0) {
-        
-        // This is a file transfer chunk - handle it
-        handle_chunk_binary_message(peer_id, binary_data);
-        return true;
-    }
-    
-    // Not a file transfer chunk
-    return false;
-}
+// =============================================================================
+// Callbacks
+// =============================================================================
 
-void FileTransferManager::set_progress_callback(FileTransferProgressCallback callback) {
-    progress_callback_ = callback;
+void FileTransferManager::set_offer_callback(TransferOfferCallback cb) {
+    std::lock_guard<std::mutex> lk(callbacks_mutex_);
+    offer_callback_ = std::move(cb);
 }
-
-void FileTransferManager::set_completion_callback(FileTransferCompletedCallback callback) {
-    completion_callback_ = callback;
+void FileTransferManager::set_progress_callback(TransferProgressCallback cb) {
+    std::lock_guard<std::mutex> lk(callbacks_mutex_);
+    progress_callback_ = std::move(cb);
 }
-
-void FileTransferManager::set_request_callback(FileTransferRequestCallback callback) {
-    request_callback_ = callback;
+void FileTransferManager::set_completed_callback(TransferCompletedCallback cb) {
+    std::lock_guard<std::mutex> lk(callbacks_mutex_);
+    completed_callback_ = std::move(cb);
 }
 
-void FileTransferManager::set_directory_progress_callback(DirectoryTransferProgressCallback callback) {
-    directory_progress_callback_ = callback;
-}
+// =============================================================================
+// Lookup / progress snapshot
+// =============================================================================
 
-void FileTransferManager::set_file_request_callback(FileRequestCallback callback) {
-    file_request_callback_ = callback;
+std::shared_ptr<Transfer> FileTransferManager::find(const std::string& id) const {
+    std::lock_guard<std::mutex> lk(transfers_mutex_);
+    auto it = transfers_.find(id);
+    return it == transfers_.end() ? nullptr : it->second;
 }
 
-void FileTransferManager::set_directory_request_callback(DirectoryRequestCallback callback) {
-    directory_request_callback_ = callback;
-}
+// Builds a progress snapshot. Caller must hold t->mtx.
+FileTransferProgress FileTransferManager::snapshot(const std::shared_ptr<Transfer>& t) const {
+    FileTransferProgress p;
+    p.transfer_id = t->id;
+    p.peer_id = t->peer_id;
+    p.direction = t->direction;
+    p.status = t->status;
+    p.filename = t->name;
+    p.local_path = t->local_root;
+    p.is_directory = t->is_directory;
+    p.bytes_transferred = t->bytes_done;
+    p.total_bytes = t->total_bytes;
+    p.files_completed = t->files_done;
+    p.total_files = static_cast<uint32_t>(t->files.size());
+    p.transfer_rate_bps = t->rate_bps;
+    p.error_message = t->error;
 
-std::string FileTransferManager::send_file(const std::string& peer_id, const std::string& file_path, 
-                                          const std::string& remote_filename) {
-    // Validate file
-    if (!validate_file_path(file_path, false)) {
-        LOG_FILE_TRANSFER_ERROR("Invalid file path: " << file_path);
-        return "";
-    }
-    
-    // Get file metadata
-    FileMetadata metadata = get_file_metadata(file_path);
-    if (metadata.file_size == 0) {
-        LOG_FILE_TRANSFER_ERROR("Failed to get metadata for file: " << file_path);
-        return "";
+    auto now = std::chrono::steady_clock::now();
+    auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(now - t->start_time);
+    p.elapsed_time = elapsed;
+    if (elapsed.count() > 0) {
+        p.average_rate_bps = static_cast<double>(t->bytes_done) * 1000.0 / elapsed.count();
     }
-    
-    // Use custom filename if provided
-    if (!remote_filename.empty()) {
-        metadata.filename = remote_filename;
+    if (t->rate_bps > 1.0 && t->total_bytes > t->bytes_done) {
+        double secs = static_cast<double>(t->total_bytes - t->bytes_done) / t->rate_bps;
+        p.estimated_time_remaining = std::chrono::milliseconds(static_cast<int64_t>(secs * 1000.0));
     }
-    
-    return send_file_with_metadata(peer_id, file_path, metadata);
+    return p;
 }
 
-std::string FileTransferManager::send_file_with_metadata(const std::string& peer_id, const std::string& file_path,
-                                                        const FileMetadata& metadata) {
-    std::string transfer_id = generate_transfer_id();
-    
-    // Create transfer progress tracking
-    auto progress = std::make_shared<FileTransferProgress>();
-    progress->transfer_id = transfer_id;
-    progress->peer_id = peer_id;
-    progress->direction = FileTransferDirection::SENDING;
-    progress->status = FileTransferStatus::STARTING;
-    progress->filename = metadata.filename;
-    progress->local_path = file_path;
-    progress->file_size = metadata.file_size;
-    progress->total_bytes = metadata.file_size;
-    progress->total_chunks = (metadata.file_size + config_.chunk_size - 1) / config_.chunk_size;
-    
-    {
-        std::lock_guard<std::mutex> lock(transfers_mutex_);
-        active_transfers_[transfer_id] = progress;
-    }
-    
-    // Send transfer request to peer
-    nlohmann::json request_msg = create_transfer_request_message(metadata, transfer_id);
-    client_.send(peer_id, "file_transfer_request", request_msg);
-    
-    LOG_FILE_TRANSFER_INFO("Initiated file transfer request: " << transfer_id << " (" << metadata.filename << " -> " << peer_id << ")");
-    return transfer_id;
+std::shared_ptr<FileTransferProgress>
+FileTransferManager::get_progress(const std::string& id) const {
+    auto t = find(id);
+    if (!t) return nullptr;
+    std::lock_guard<std::mutex> lk(t->mtx);
+    return std::make_shared<FileTransferProgress>(snapshot(t));
 }
 
-std::string FileTransferManager::send_directory(const std::string& peer_id, const std::string& directory_path,
-                                               const std::string& remote_directory_name, bool recursive) {
-    // Validate directory
-    if (!directory_exists(directory_path)) {
-        LOG_FILE_TRANSFER_ERROR("Invalid directory path: " << directory_path);
-        return "";
-    }
-    
-    // Get directory metadata
-    DirectoryMetadata dir_metadata = get_directory_metadata(directory_path, recursive);
-    if (dir_metadata.files.empty() && dir_metadata.subdirectories.empty()) {
-        LOG_FILE_TRANSFER_ERROR("Directory is empty: " << directory_path);
-        return "";
+std::vector<std::shared_ptr<FileTransferProgress>>
+FileTransferManager::get_active_transfers() const {
+    std::vector<std::shared_ptr<Transfer>> all;
+    {
+        std::lock_guard<std::mutex> lk(transfers_mutex_);
+        for (auto& kv : transfers_) all.push_back(kv.second);
+    }
+    std::vector<std::shared_ptr<FileTransferProgress>> out;
+    for (auto& t : all) {
+        std::lock_guard<std::mutex> lk(t->mtx);
+        if (!t->is_terminal()) {
+            out.push_back(std::make_shared<FileTransferProgress>(snapshot(t)));
+        }
     }
-    
-    // Use custom directory name if provided
-    if (!remote_directory_name.empty()) {
-        dir_metadata.directory_name = remote_directory_name;
-    }
-    
-    std::string transfer_id = generate_transfer_id();
-    
-    // Create transfer progress tracking for directory
-    auto progress = std::make_shared<FileTransferProgress>();
-    progress->transfer_id = transfer_id;
-    progress->peer_id = peer_id;
-    progress->direction = FileTransferDirection::SENDING;
-    progress->status = FileTransferStatus::STARTING;
-    progress->filename = dir_metadata.directory_name;
-    progress->local_path = directory_path;
-    progress->total_bytes = dir_metadata.get_total_size();
-    progress->file_size = progress->total_bytes;
-    
+    return out;
+}
+
+nlohmann::json FileTransferManager::get_statistics() const {
+    nlohmann::json j;
     {
-        std::lock_guard<std::mutex> lock(transfers_mutex_);
-        active_transfers_[transfer_id] = progress;
+        std::lock_guard<std::mutex> lk(stats_mutex_);
+        auto uptime = std::chrono::duration_cast<std::chrono::seconds>(
+            std::chrono::steady_clock::now() - started_at_);
+        j["uptime_seconds"] = uptime.count();
+        j["total_bytes_sent"] = stat_bytes_sent_;
+        j["total_bytes_received"] = stat_bytes_received_;
+        j["total_files_sent"] = stat_files_sent_;
+        j["total_files_received"] = stat_files_received_;
+        j["completed_transfers"] = stat_completed_;
+        j["failed_transfers"] = stat_failed_;
+        uint64_t total = stat_completed_ + stat_failed_;
+        j["success_rate"] = total ? static_cast<double>(stat_completed_) / total : 0.0;
     }
-    
-    // Store directory metadata for processing
     {
-        std::lock_guard<std::mutex> dir_lock(directory_transfers_mutex_);
-        active_directory_transfers_[transfer_id] = dir_metadata;
-    }
-    
-    // Create directory transfer request message
-    nlohmann::json request_msg;
-    request_msg["transfer_id"] = transfer_id;
-    request_msg["type"] = "directory";
-    
-    // Serialize directory metadata with full file information
-    nlohmann::json dir_metadata_json;
-    dir_metadata_json["directory_name"] = dir_metadata.directory_name;
-    dir_metadata_json["relative_path"] = dir_metadata.relative_path;
-    dir_metadata_json["total_size"] = dir_metadata.get_total_size();
-    dir_metadata_json["total_files"] = dir_metadata.get_total_file_count();
-    
-    // Serialize file metadata
-    nlohmann::json files_json = nlohmann::json::array();
-    for (const auto& file_meta : dir_metadata.files) {
-        nlohmann::json file_json;
-        file_json["filename"] = file_meta.filename;
-        file_json["relative_path"] = file_meta.relative_path;
-        file_json["file_size"] = file_meta.file_size;
-        file_json["last_modified"] = file_meta.last_modified;
-        file_json["mime_type"] = file_meta.mime_type;
-        file_json["checksum"] = file_meta.checksum;
-        files_json.push_back(file_json);
-    }
-    dir_metadata_json["files"] = files_json;
-    
-    // For now, we'll handle single-level directories (can be extended for nested later)
-    dir_metadata_json["subdirectories"] = nlohmann::json::array();
-    
-    request_msg["directory_metadata"] = dir_metadata_json;
-    
-    client_.send(peer_id, "file_transfer_request", request_msg);
-    
-    LOG_FILE_TRANSFER_INFO("Initiated directory transfer request: " << transfer_id << " (" << dir_metadata.directory_name << " -> " << peer_id << ")");
-    return transfer_id;
+        std::lock_guard<std::mutex> lk(transfers_mutex_);
+        size_t active = 0;
+        for (auto& kv : transfers_) {
+            std::lock_guard<std::mutex> tk(kv.second->mtx);
+            if (!kv.second->is_terminal()) ++active;
+        }
+        j["active_transfers"] = active;
+    }
+    return j;
 }
 
-std::string FileTransferManager::request_file(const std::string& peer_id, const std::string& remote_file_path,
-                                             const std::string& local_path) {
-    std::string transfer_id = generate_transfer_id();
-    
-    // Create file request message
-    nlohmann::json request_msg;
-    request_msg["transfer_id"] = transfer_id;
-    request_msg["type"] = "file_request";
-    request_msg["remote_path"] = remote_file_path;
-    request_msg["local_path"] = local_path;
-    
-    client_.send(peer_id, "file_request", request_msg);
-    
-    LOG_FILE_TRANSFER_INFO("Sent file request: " << transfer_id << " (" << remote_file_path << " from " << peer_id << ")");
-    return transfer_id;
-}
+// =============================================================================
+// Progress / completion notification
+// =============================================================================
 
-std::string FileTransferManager::request_directory(const std::string& peer_id, const std::string& remote_directory_path,
-                                                   const std::string& local_directory_path, bool recursive) {
-    std::string transfer_id = generate_transfer_id();
-    
-    // Create directory request message
-    nlohmann::json request_msg;
-    request_msg["transfer_id"] = transfer_id;
-    request_msg["type"] = "directory_request";
-    request_msg["remote_path"] = remote_directory_path;
-    request_msg["local_path"] = local_directory_path;
-    request_msg["recursive"] = recursive;
-    
-    client_.send(peer_id, "directory_request", request_msg);
-    
-    LOG_FILE_TRANSFER_INFO("Sent directory request: " << transfer_id << " (" << remote_directory_path << " from " << peer_id << ")");
-    return transfer_id;
-}
-
-bool FileTransferManager::accept_file_transfer(const std::string& transfer_id, const std::string& local_path) {
-    std::lock_guard<std::mutex> lock(pending_mutex_);
-    
-    auto it = pending_transfers_.find(transfer_id);
-    if (it == pending_transfers_.end()) {
-        LOG_FILE_TRANSFER_ERROR("Transfer not found in pending transfers: " << transfer_id);
-        return false;
-    }
-    
-    PendingFileTransfer pending_transfer = it->second;
-    pending_transfers_.erase(it);
-    
-    // Create transfer progress tracking
-    auto progress = std::make_shared<FileTransferProgress>();
-    progress->transfer_id = transfer_id;
-    progress->peer_id = pending_transfer.peer_id;
-    progress->direction = FileTransferDirection::RECEIVING;
-    progress->status = FileTransferStatus::STARTING;
-    progress->filename = pending_transfer.metadata.filename;
-    progress->local_path = local_path;
-    progress->file_size = pending_transfer.metadata.file_size;
-    progress->total_bytes = pending_transfer.metadata.file_size;
-    progress->total_chunks = (pending_transfer.metadata.file_size + config_.chunk_size - 1) / config_.chunk_size;
-    
+void FileTransferManager::emit_progress(const std::shared_ptr<Transfer>& t) {
+    FileTransferProgress snap;
     {
-        std::lock_guard<std::mutex> transfers_lock(transfers_mutex_);
-        active_transfers_[transfer_id] = progress;
-    }
-    
-    // Send acceptance response
-    nlohmann::json response_msg = create_transfer_response_message(transfer_id, true);
-    client_.send(pending_transfer.peer_id, "file_transfer_response", response_msg);
-    
-    // Add to work queue for processing
+        std::lock_guard<std::mutex> lk(t->mtx);
+        auto now = std::chrono::steady_clock::now();
+
+        // Refresh the throughput estimate roughly twice a second.
+        auto dt = std::chrono::duration_cast<std::chrono::milliseconds>(now - t->rate_mark_time);
+        if (dt.count() >= 500) {
+            t->rate_bps = static_cast<double>(t->bytes_done - t->rate_mark_bytes) * 1000.0 / dt.count();
+            t->rate_mark_bytes = t->bytes_done;
+            t->rate_mark_time = now;
+        }
+
+        // Throttle callbacks to ~10/s unless the transfer just finished.
+        auto since_cb = std::chrono::duration_cast<std::chrono::milliseconds>(now - t->last_progress_cb);
+        if (!t->is_terminal() && since_cb.count() < 100) return;
+        t->last_progress_cb = now;
+
+        snap = snapshot(t);
+    }
+    TransferProgressCallback cb;
     {
-        std::lock_guard<std::mutex> work_lock(work_mutex_);
-        work_queue_.push(transfer_id);
+        std::lock_guard<std::mutex> lk(callbacks_mutex_);
+        cb = progress_callback_;
     }
-    work_condition_.notify_one();
-    
-    LOG_FILE_TRANSFER_INFO("Accepted file transfer: " << transfer_id << " (" << pending_transfer.metadata.filename << " from " << pending_transfer.peer_id << " -> " << local_path << ")");
-    return true;
-}
-
-bool FileTransferManager::reject_file_transfer(const std::string& transfer_id, const std::string& reason) {
-    std::lock_guard<std::mutex> lock(pending_mutex_);
-    
-    auto it = pending_transfers_.find(transfer_id);
-    if (it == pending_transfers_.end()) {
-        LOG_FILE_TRANSFER_ERROR("Transfer not found in pending transfers: " << transfer_id);
-        return false;
-    }
-    
-    PendingFileTransfer pending_transfer = it->second;
-    pending_transfers_.erase(it);
-    
-    // Send rejection response
-    nlohmann::json response_msg = create_transfer_response_message(transfer_id, false, reason);
-    client_.send(pending_transfer.peer_id, "file_transfer_response", response_msg);
-    
-    LOG_FILE_TRANSFER_INFO("Rejected file transfer: " << transfer_id << " (" << pending_transfer.metadata.filename << " from " << pending_transfer.peer_id << ", reason: " << reason << ")");
-    return true;
+    if (cb) cb(snap);
 }
 
-bool FileTransferManager::accept_directory_transfer(const std::string& transfer_id, const std::string& local_path) {
-    std::lock_guard<std::mutex> lock(pending_mutex_);
-    
-    auto it = pending_directory_transfers_.find(transfer_id);
-    if (it == pending_directory_transfers_.end()) {
-        LOG_FILE_TRANSFER_ERROR("Directory transfer not found in pending transfers: " << transfer_id);
-        return false;
-    }
-    
-    PendingDirectoryTransfer pending_transfer = it->second;
-    pending_directory_transfers_.erase(it);
-    
-    // Create transfer progress tracking
-    auto progress = std::make_shared<FileTransferProgress>();
-    progress->transfer_id = transfer_id;
-    progress->peer_id = pending_transfer.peer_id;
-    progress->direction = FileTransferDirection::RECEIVING;
-    progress->status = FileTransferStatus::STARTING;
-    progress->filename = pending_transfer.metadata.directory_name;
-    progress->local_path = local_path;
-    progress->total_bytes = pending_transfer.metadata.get_total_size();
-    progress->file_size = progress->total_bytes;
-    progress->total_chunks = 0; // Will be calculated per file
-    
+void FileTransferManager::finish(const std::shared_ptr<Transfer>& t, bool success,
+                                 const std::string& error) {
+    FileTransferProgress snap;
+    bool is_receiver;
+    size_t file_count;
     {
-        std::lock_guard<std::mutex> transfers_lock(transfers_mutex_);
-        active_transfers_[transfer_id] = progress;
-    }
-    
-    // Send acceptance response
-    nlohmann::json response_msg = create_transfer_response_message(transfer_id, true);
-    client_.send(pending_transfer.peer_id, "file_transfer_response", response_msg);
-    
-    // Store directory metadata for processing
+        std::lock_guard<std::mutex> lk(t->mtx);
+        if (t->finished) return; // finish() already ran for this transfer
+        t->finished = true;
+        // Preserve an explicit CANCELLED status set by the cancel path.
+        if (!success && t->status == FileTransferStatus::CANCELLED) {
+            // keep CANCELLED
+        } else {
+            t->status = success ? FileTransferStatus::COMPLETED : FileTransferStatus::FAILED;
+        }
+        t->error = error;
+        t->last_activity = std::chrono::steady_clock::now();
+        t->last_progress_cb = {}; // force the final progress callback through
+        is_receiver = (t->direction == FileTransferDirection::RECEIVING);
+        file_count = t->files.size();
+        t->cv.notify_all();
+        snap = snapshot(t);
+    }
+
+    if (!success && is_receiver) {
+        cleanup_temp_files(t);
+    }
+
     {
-        std::lock_guard<std::mutex> dir_lock(directory_transfers_mutex_);
-        active_directory_transfers_[transfer_id] = pending_transfer.metadata;
+        std::lock_guard<std::mutex> lk(stats_mutex_);
+        if (success) {
+            ++stat_completed_;
+            if (is_receiver) stat_files_received_ += file_count;
+            else             stat_files_sent_ += file_count;
+        } else {
+            ++stat_failed_;
+        }
     }
-    
-    // Add to work queue for processing
+
+    TransferProgressCallback pcb;
+    TransferCompletedCallback ccb;
     {
-        std::lock_guard<std::mutex> work_lock(work_mutex_);
-        work_queue_.push(transfer_id);
+        std::lock_guard<std::mutex> lk(callbacks_mutex_);
+        pcb = progress_callback_;
+        ccb = completed_callback_;
     }
-    work_condition_.notify_one();
-    
-    LOG_FILE_TRANSFER_INFO("Accepted directory transfer: " << transfer_id << " (" << pending_transfer.metadata.directory_name << " from " << pending_transfer.peer_id << " -> " << local_path << ")");
-    return true;
-}
+    if (pcb) pcb(snap);
+    if (ccb) ccb(t->id, success, error);
 
-bool FileTransferManager::reject_directory_transfer(const std::string& transfer_id, const std::string& reason) {
-    std::lock_guard<std::mutex> lock(pending_mutex_);
-    
-    auto it = pending_directory_transfers_.find(transfer_id);
-    if (it == pending_directory_transfers_.end()) {
-        LOG_FILE_TRANSFER_ERROR("Directory transfer not found in pending transfers: " << transfer_id);
-        return false;
-    }
-    
-    PendingDirectoryTransfer pending_transfer = it->second;
-    pending_directory_transfers_.erase(it);
-    
-    // Send rejection response
-    nlohmann::json response_msg = create_transfer_response_message(transfer_id, false, reason);
-    client_.send(pending_transfer.peer_id, "file_transfer_response", response_msg);
-    
-    LOG_FILE_TRANSFER_INFO("Rejected directory transfer: " << transfer_id << " (" << pending_transfer.metadata.directory_name << " from " << pending_transfer.peer_id << ", reason: " << reason << ")");
-    return true;
+    LOG_FT_INFO("Transfer " << t->id << " " << (success ? "completed" : "ended")
+                            << (error.empty() ? "" : (": " + error)));
 }
 
-bool FileTransferManager::pause_transfer(const std::string& transfer_id) {
-    std::lock_guard<std::mutex> lock(transfers_mutex_);
-    
-    auto it = active_transfers_.find(transfer_id);
-    if (it == active_transfers_.end()) {
-        return false;
-    }
-    
-    auto& progress = it->second;
-    if (progress->status == FileTransferStatus::IN_PROGRESS) {
-        progress->status = FileTransferStatus::PAUSED;
-        
-        // Send pause control message
-        nlohmann::json control_msg = create_control_message(transfer_id, "pause");
-        client_.send(progress->peer_id, "file_transfer_control", control_msg);
-        
-        LOG_FILE_TRANSFER_INFO("Paused transfer: " << transfer_id);
-        return true;
+void FileTransferManager::cleanup_temp_files(const std::shared_ptr<Transfer>& t) {
+    std::vector<std::string> temps;
+    {
+        std::lock_guard<std::mutex> lk(t->mtx);
+        for (auto& f : t->files) {
+            if (f.temp_created && !f.finalized) temps.push_back(f.temp_path);
+        }
+    }
+    for (auto& p : temps) {
+        if (file_exists(p)) delete_file(p.c_str());
     }
-    
-    return false;
 }
 
-bool FileTransferManager::resume_transfer(const std::string& transfer_id) {
-    std::lock_guard<std::mutex> lock(transfers_mutex_);
-    
-    auto it = active_transfers_.find(transfer_id);
-    if (it == active_transfers_.end()) {
-        return false;
-    }
-    
-    auto& progress = it->second;
-    if (progress->status == FileTransferStatus::PAUSED) {
-        progress->status = FileTransferStatus::RESUMING;
-        
-        // Add to work queue for processing
-        {
-            std::lock_guard<std::mutex> work_lock(work_mutex_);
-            work_queue_.push(transfer_id);
+// =============================================================================
+// Sending: send_file / send_directory
+// =============================================================================
+
+namespace {
+// Recursively collects regular files under `abs_dir` into `out`.
+void scan_directory(const std::string& abs_dir, const std::string& rel_prefix,
+                    std::vector<TransferFile>& out) {
+    std::vector<DirectoryEntry> entries;
+    if (!list_directory(abs_dir.c_str(), entries)) return;
+    for (const auto& e : entries) {
+        std::string rel = rel_prefix.empty() ? e.name : rel_prefix + "/" + e.name;
+        if (e.is_directory) {
+            scan_directory(e.path, rel, out);
+        } else {
+            TransferFile f;
+            f.relative_path = rel;
+            int64_t sz = get_file_size(e.path.c_str());
+            f.size = sz > 0 ? static_cast<uint64_t>(sz) : 0;
+            f.source_path = e.path;
+            out.push_back(std::move(f));
         }
-        work_condition_.notify_one();
-        
-        // Send resume control message
-        nlohmann::json control_msg = create_control_message(transfer_id, "resume");
-        client_.send(progress->peer_id, "file_transfer_control", control_msg);
-        
-        LOG_FILE_TRANSFER_INFO("Resumed transfer: " << transfer_id);
-        return true;
     }
-    
-    return false;
 }
+} // namespace
 
-bool FileTransferManager::cancel_transfer(const std::string& transfer_id) {
-    std::lock_guard<std::mutex> lock(transfers_mutex_);
-    
-    auto it = active_transfers_.find(transfer_id);
-    if (it == active_transfers_.end()) {
-        return false;
-    }
-    
-    auto& progress = it->second;
-    progress->status = FileTransferStatus::CANCELLED;
-    
-    // Send cancel control message
-    nlohmann::json control_msg = create_control_message(transfer_id, "cancel");
-    client_.send(progress->peer_id, "file_transfer_control", control_msg);
-    
-    // Move to completed transfers
-    move_to_completed(transfer_id);
-    
-    LOG_FILE_TRANSFER_INFO("Cancelled transfer: " << transfer_id);
-    return true;
+std::string FileTransferManager::send_file(const std::string& peer_id, const std::string& file_path,
+                                           const std::string& remote_name) {
+    if (!file_exists(file_path) || is_directory(file_path.c_str())) {
+        LOG_FT_ERROR("send_file: not a readable file: " << file_path);
+        return "";
+    }
+    int64_t sz = get_file_size(file_path.c_str());
+    if (sz < 0) {
+        LOG_FT_ERROR("send_file: cannot stat: " << file_path);
+        return "";
+    }
+    std::string name = remote_name.empty() ? get_filename_from_path(file_path) : remote_name;
+
+    auto t = std::make_shared<Transfer>();
+    t->id = random_transfer_id();
+    t->peer_id = peer_id;
+    t->direction = FileTransferDirection::SENDING;
+    t->is_directory = false;
+    t->name = name;
+    t->local_root = file_path;
+    t->total_bytes = static_cast<uint64_t>(sz);
+
+    TransferFile f;
+    f.relative_path = name;
+    f.size = t->total_bytes;
+    f.source_path = file_path;
+    t->files.push_back(std::move(f));
+
+    return start_send(peer_id, t, name);
 }
 
-bool FileTransferManager::retry_transfer(const std::string& transfer_id) {
-    // Look in completed transfers for failed ones
-    std::lock_guard<std::mutex> lock(transfers_mutex_);
-    
-    auto it = completed_transfers_.find(transfer_id);
-    if (it == completed_transfers_.end()) {
-        return false;
-    }
-    
-    auto progress = it->second;
-    if (progress->status != FileTransferStatus::FAILED) {
-        return false;
-    }
-    
-    // Reset progress and move back to active
-    progress->status = FileTransferStatus::STARTING;
-    progress->bytes_transferred = 0;
-    progress->chunks_completed = 0;
-    progress->retry_count++;
-    progress->error_message.clear();
-    progress->start_time = std::chrono::steady_clock::now();
-    
-    active_transfers_[transfer_id] = progress;
-    completed_transfers_.erase(it);
-    
-    // Add to work queue
-    {
-        std::lock_guard<std::mutex> work_lock(work_mutex_);
-        work_queue_.push(transfer_id);
+std::string FileTransferManager::send_directory(const std::string& peer_id,
+                                                const std::string& directory_path,
+                                                const std::string& remote_name) {
+    if (!directory_exists(directory_path)) {
+        LOG_FT_ERROR("send_directory: not a directory: " << directory_path);
+        return "";
     }
-    work_condition_.notify_one();
-    
-    LOG_FILE_TRANSFER_INFO("Retrying transfer: " << transfer_id);
-    return true;
+    std::string name = remote_name.empty() ? get_filename_from_path(directory_path) : remote_name;
+
+    auto t = std::make_shared<Transfer>();
+    t->id = random_transfer_id();
+    t->peer_id = peer_id;
+    t->direction = FileTransferDirection::SENDING;
+    t->is_directory = true;
+    t->name = name;
+    t->local_root = directory_path;
+
+    scan_directory(directory_path, "", t->files);
+    for (auto& f : t->files) t->total_bytes += f.size;
+
+    return start_send(peer_id, t, name);
 }
 
-std::shared_ptr<FileTransferProgress> FileTransferManager::get_transfer_progress(const std::string& transfer_id) const {
-    std::lock_guard<std::mutex> lock(transfers_mutex_);
-    
-    auto it = active_transfers_.find(transfer_id);
-    if (it != active_transfers_.end()) {
-        return it->second;
+// Registers a freshly-built sending transfer and sends its offer.
+std::string FileTransferManager::start_send(const std::string& peer_id,
+                                            const std::shared_ptr<Transfer>& t,
+                                            const std::string& /*name*/) {
+    t->status = FileTransferStatus::STARTING;
+    t->start_time = std::chrono::steady_clock::now();
+    t->last_activity = t->start_time;
+    t->rate_mark_time = t->start_time;
+
+    {
+        std::lock_guard<std::mutex> lk(transfers_mutex_);
+        transfers_[t->id] = t;
     }
-    
-    auto completed_it = completed_transfers_.find(transfer_id);
-    if (completed_it != completed_transfers_.end()) {
-        return completed_it->second;
+
+    nlohmann::json offer;
+    offer["transfer_id"] = t->id;
+    offer["name"] = t->name;
+    offer["is_directory"] = t->is_directory;
+    offer["total_size"] = t->total_bytes;
+    nlohmann::json files = nlohmann::json::array();
+    for (const auto& f : t->files) {
+        files.push_back({{"path", f.relative_path}, {"size", f.size}});
     }
-    
-    return nullptr;
-}
+    offer["files"] = files;
 
-std::vector<std::shared_ptr<FileTransferProgress>> FileTransferManager::get_active_transfers() const {
-    std::lock_guard<std::mutex> lock(transfers_mutex_);
-    
-    std::vector<std::shared_ptr<FileTransferProgress>> transfers;
-    transfers.reserve(active_transfers_.size());
-    
-    for (const auto& pair : active_transfers_) {
-        transfers.push_back(pair.second);
-    }
-    
-    return transfers;
+    client_.send(peer_id, MSG_OFFER, offer);
+    LOG_FT_INFO("Offering " << (t->is_directory ? "directory '" : "file '") << t->name
+                            << "' (" << t->files.size() << " file(s), " << t->total_bytes
+                            << " bytes) to " << peer_id << " [" << t->id << "]");
+    return t->id;
 }
 
-std::vector<std::shared_ptr<FileTransferProgress>> FileTransferManager::get_transfer_history(size_t limit) const {
-    std::lock_guard<std::mutex> lock(transfers_mutex_);
-    
-    std::vector<std::shared_ptr<FileTransferProgress>> transfers;
-    
-    for (const auto& pair : completed_transfers_) {
-        transfers.push_back(pair.second);
-    }
-    
-    // Sort by completion time (most recent first)
-    std::sort(transfers.begin(), transfers.end(), 
-              [](const auto& a, const auto& b) {
-                  return a->last_update > b->last_update;
-              });
-    
-    if (limit > 0 && transfers.size() > limit) {
-        transfers.resize(limit);
-    }
-    
-    return transfers;
-}
 
-void FileTransferManager::clear_transfer_history() {
-    std::lock_guard<std::mutex> lock(transfers_mutex_);
-    completed_transfers_.clear();
-    LOG_FILE_TRANSFER_INFO("Cleared transfer history");
-}
+// =============================================================================
+// Sending: streaming worker
+// =============================================================================
 
-nlohmann::json FileTransferManager::get_transfer_statistics() const {
-    std::lock_guard<std::mutex> stats_lock(stats_mutex_);
-    std::lock_guard<std::mutex> transfers_lock(transfers_mutex_);
-    
-    auto now = std::chrono::steady_clock::now();
-    auto uptime = std::chrono::duration_cast<std::chrono::seconds>(now - start_time_);
-    
-    nlohmann::json stats;
-    stats["uptime_seconds"] = uptime.count();
-    stats["total_bytes_sent"] = total_bytes_sent_;
-    stats["total_bytes_received"] = total_bytes_received_;
-    stats["total_files_sent"] = total_files_sent_;
-    stats["total_files_received"] = total_files_received_;
-    stats["active_transfers"] = active_transfers_.size();
-    stats["completed_transfers"] = completed_transfers_.size();
-    
-    // Calculate success rate
-    size_t successful_transfers = 0;
-    for (const auto& pair : completed_transfers_) {
-        if (pair.second->status == FileTransferStatus::COMPLETED) {
-            successful_transfers++;
-        }
-    }
-    
-    if (!completed_transfers_.empty()) {
-        stats["success_rate"] = static_cast<double>(successful_transfers) / completed_transfers_.size();
-    } else {
-        stats["success_rate"] = 0.0;
-    }
-    
-    // Average transfer rate
-    if (uptime.count() > 0) {
-        stats["average_send_rate_bps"] = static_cast<double>(total_bytes_sent_) / uptime.count();
-        stats["average_receive_rate_bps"] = static_cast<double>(total_bytes_received_) / uptime.count();
-    } else {
-        stats["average_send_rate_bps"] = 0.0;
-        stats["average_receive_rate_bps"] = 0.0;
+void FileTransferManager::queue_send(const std::string& id) {
+    {
+        std::lock_guard<std::mutex> lk(queue_mutex_);
+        send_queue_.push(id);
     }
-    
-    return stats;
+    queue_cv_.notify_one();
 }
 
-// Static utility functions
-std::string FileTransferManager::calculate_file_checksum(const std::string& file_path, const std::string& algorithm) {
-    if (algorithm == "sha256") {
-        // Use a simple SHA1 implementation for now (we can extend this)
-        size_t file_size;
-        void* file_data = read_file_binary(file_path.c_str(), &file_size);
-        if (!file_data) {
-            return "";
+void FileTransferManager::worker_loop() {
+    while (running_.load()) {
+        std::string id;
+        {
+            std::unique_lock<std::mutex> lk(queue_mutex_);
+            queue_cv_.wait(lk, [this] { return !running_.load() || !send_queue_.empty(); });
+            if (!running_.load()) return;
+            id = send_queue_.front();
+            send_queue_.pop();
         }
-        
-        SHA1 sha1;
-        sha1.update(reinterpret_cast<const uint8_t*>(file_data), file_size);
-        std::string result = sha1.finalize();
-        
-        free_file_buffer(file_data);
-        return result;
-    }
-    
-    // For MD5 or other algorithms, we would need additional implementations
-    return "";
-}
+        auto t = find(id);
+        if (!t) continue;
 
-FileMetadata FileTransferManager::get_file_metadata(const std::string& file_path) {
-    FileMetadata metadata;
-    
-    try {
-        if (!file_or_directory_exists(file_path.c_str())) {
-            return metadata;
-        }
-        
-        metadata.filename = get_filename_from_path(file_path.c_str());
-        int64_t file_size = get_file_size(file_path.c_str());
-        if (file_size >= 0) {
-            metadata.file_size = static_cast<uint64_t>(file_size);
+        {
+            std::lock_guard<std::mutex> lk(t->mtx);
+            if (t->worker_active) continue; // another worker already owns it
+            t->worker_active = true;
         }
-        
-        // Get last modification time
-        metadata.last_modified = get_file_modified_time(file_path.c_str());
-        
-        // Calculate checksum (optional, can be expensive for large files)
-        if (metadata.file_size < 100 * 1024 * 1024) { // Only for files < 100MB
-            metadata.checksum = calculate_file_checksum(file_path, "sha256");
+        run_send(t);
+        {
+            std::lock_guard<std::mutex> lk(t->mtx);
+            t->worker_active = false;
         }
-        
-        // Determine MIME type based on extension
-        metadata.mime_type = get_mime_type(file_path);
-        
-    } catch (const std::exception& e) {
-        LOG_FILE_TRANSFER_ERROR("Failed to get file metadata for " << file_path << ": " << e.what());
     }
-    
-    return metadata;
 }
 
-DirectoryMetadata FileTransferManager::get_directory_metadata(const std::string& directory_path, bool recursive) {
-    DirectoryMetadata metadata;
-    
-    try {
-        metadata.directory_name = get_filename_from_path(directory_path.c_str());
-        
-        std::vector<DirectoryEntry> entries;
-        if (list_directory(directory_path.c_str(), entries)) {
-            for (const auto& entry : entries) {
-                if (!entry.is_directory) {
-                    FileMetadata file_meta = get_file_metadata(entry.path);
-                    file_meta.relative_path = entry.name;
-                    metadata.files.push_back(file_meta);
-                }
-                else if (recursive) {
-                    DirectoryMetadata subdir_meta = get_directory_metadata(entry.path, true);
-                    subdir_meta.relative_path = entry.name;
-                    metadata.subdirectories.push_back(subdir_meta);
-                }
+void FileTransferManager::run_send(const std::shared_ptr<Transfer>& t) {
+    FileTransferConfig cfg = get_config();
+    std::vector<uint8_t> buf(cfg.chunk_size);
+
+    while (running_.load()) {
+        size_t   file_index;
+        uint64_t offset;
+        uint64_t file_size;
+        std::string source_path;
+        {
+            std::unique_lock<std::mutex> lk(t->mtx);
+            if (t->status == FileTransferStatus::RESUMING) {
+                t->status = FileTransferStatus::IN_PROGRESS;
             }
+            if (t->status == FileTransferStatus::PAUSED) return;       // cursor preserved
+            if (t->status != FileTransferStatus::IN_PROGRESS) return;  // cancelled / failed
+            if (t->send_file >= t->files.size()) break;                // all data sent
+
+            file_index  = t->send_file;
+            offset      = t->send_offset;
+            file_size   = t->files[file_index].size;
+            source_path = t->files[file_index].source_path;
+            if (offset == 0) sha256_reset(&t->send_hash);
         }
-        
-    } catch (const std::exception& e) {
-        LOG_FILE_TRANSFER_ERROR("Failed to get directory metadata for " << directory_path << ": " << e.what());
-    }
-    
-    return metadata;
-}
 
-bool FileTransferManager::validate_file_path(const std::string& file_path, bool check_write) {
-    return validate_path(file_path.c_str(), check_write);
-}
+        // Empty file: no chunks, just the end marker.
+        if (file_size == 0) {
+            nlohmann::json end{{"transfer_id", t->id}, {"file_index", file_index},
+                               {"sha256", sha256_of_empty()}};
+            client_.send(t->peer_id, MSG_FILE_END, end);
+            std::lock_guard<std::mutex> lk(t->mtx);
+            t->send_file++;
+            t->send_offset = 0;
+            t->files_done++;
+            continue;
+        }
+
+        uint32_t want = static_cast<uint32_t>(std::min<uint64_t>(cfg.chunk_size, file_size - offset));
+        if (!read_file_chunk(source_path, offset, buf.data(), want)) {
+            nlohmann::json done{{"transfer_id", t->id}, {"success", false},
+                                {"error", "sender failed to read file"}};
+            client_.send(t->peer_id, MSG_COMPLETE, done);
+            finish(t, false, "failed to read " + source_path);
+            return;
+        }
 
-// Private implementation methods
+        uint32_t crc = crc32(buf.data(), want);
+
+        // Build the chunk frame: magic | id | file_index | offset | len | crc | data.
+        std::vector<uint8_t> frame;
+        frame.reserve(4 + 2 + t->id.size() + 4 + 8 + 4 + 4 + want);
+        frame.insert(frame.end(), CHUNK_MAGIC, CHUNK_MAGIC + 4);
+        put_u16(frame, static_cast<uint16_t>(t->id.size()));
+        frame.insert(frame.end(), t->id.begin(), t->id.end());
+        put_u32(frame, static_cast<uint32_t>(file_index));
+        put_u64(frame, offset);
+        put_u32(frame, want);
+        put_u32(frame, crc);
+        frame.insert(frame.end(), buf.data(), buf.data() + want);
+
+        bool sent = client_.send_binary_to_peer_id(t->peer_id, frame, MessageDataType::BINARY);
+        if (!sent) {
+            finish(t, false, "connection lost while sending");
+            return;
+        }
 
-std::string FileTransferManager::generate_transfer_id() const {
-    std::random_device rd;
-    std::mt19937 gen(rd());
-    std::uniform_int_distribution<> dis(0, 15);
-    
-    std::stringstream ss;
-    ss << std::hex;
-    for (int i = 0; i < 32; ++i) {
-        ss << dis(gen);
-    }
-    
-    return ss.str();
-}
+        bool file_done = false;
+        std::string sha_hex;
+        {
+            std::lock_guard<std::mutex> lk(t->mtx);
+            sha256_update(&t->send_hash, buf.data(), want);
+            t->send_offset += want;
+            t->bytes_done  += want;
+            t->last_activity = std::chrono::steady_clock::now();
+            if (t->send_offset >= file_size) {
+                uint8_t digest[SHA256_HASH_SIZE];
+                sha256_finish(&t->send_hash, digest);
+                sha_hex = to_hex(digest, SHA256_HASH_SIZE);
+                t->send_file++;
+                t->send_offset = 0;
+                t->files_done++;
+                file_done = true;
+            }
+        }
+        {
+            std::lock_guard<std::mutex> lk(stats_mutex_);
+            stat_bytes_sent_ += want;
+        }
+        if (file_done) {
+            nlohmann::json end{{"transfer_id", t->id}, {"file_index", file_index},
+                               {"sha256", sha_hex}};
+            client_.send(t->peer_id, MSG_FILE_END, end);
+        }
 
-void FileTransferManager::process_transfer(const std::string& transfer_id) {
-    // Exit immediately if shutting down
-    if (!running_.load()) {
-        return;
-    }
-    
-    auto progress = get_transfer_progress(transfer_id);
-    if (!progress) {
-        return;
-    }
-    
-    // Check again before processing (in case shutdown occurred during progress retrieval)
-    if (!running_.load()) {
-        return;
+        emit_progress(t);
+
+        // Backpressure: do not get more than `window_bytes` ahead of the peer.
+        {
+            std::unique_lock<std::mutex> lk(t->mtx);
+            while (running_.load() && t->status == FileTransferStatus::IN_PROGRESS &&
+                   t->bytes_done - t->acked_bytes >= cfg.window_bytes) {
+                t->cv.wait_for(lk, std::chrono::milliseconds(200));
+            }
+        }
     }
-    
-    // Check if this is a directory transfer
-    bool is_directory_transfer = false;
+
+    if (!running_.load()) return;
+
+    // All data streamed; wait for the receiver's ft_complete.
     {
-        std::lock_guard<std::mutex> dir_lock(directory_transfers_mutex_);
-        is_directory_transfer = active_directory_transfers_.find(transfer_id) != active_directory_transfers_.end();
-    }
-    
-    if (is_directory_transfer) {
-        if (progress->direction == FileTransferDirection::SENDING) {
-            start_directory_send(transfer_id);
-        } else {
-            start_directory_receive(transfer_id);
-        }
-    } else {
-        if (progress->direction == FileTransferDirection::SENDING) {
-            start_file_send(transfer_id);
-        } else {
-            start_file_receive(transfer_id);
+        std::unique_lock<std::mutex> lk(t->mtx);
+        while (running_.load() && t->status == FileTransferStatus::IN_PROGRESS) {
+            t->cv.wait_for(lk, std::chrono::milliseconds(200));
         }
     }
 }
 
-void FileTransferManager::start_file_send(const std::string& transfer_id) {
-    auto progress = get_transfer_progress(transfer_id);
-    if (!progress) {
-        return;
-    }
-    
-    progress->status = FileTransferStatus::IN_PROGRESS;
-    update_transfer_progress(transfer_id);
-    
-    // Read file and create chunks
-    uint64_t chunk_index = 0;
-    uint64_t file_offset = 0;
-    
-    while (file_offset < progress->file_size && running_.load()) {
-        // Check if transfer was cancelled or paused
-        auto current_progress = get_transfer_progress(transfer_id);
-        if (!current_progress || current_progress->status == FileTransferStatus::CANCELLED ||
-            current_progress->status == FileTransferStatus::PAUSED) {
-            return;
+// =============================================================================
+// Receiving: offer handling
+// =============================================================================
+
+void FileTransferManager::on_offer(const std::string& peer_id, const nlohmann::json& msg) {
+    try {
+        std::string id = msg.at("transfer_id").get<std::string>();
+        if (find(id)) return; // duplicate offer
+
+        auto t = std::make_shared<Transfer>();
+        t->id = id;
+        t->peer_id = peer_id;
+        t->direction = FileTransferDirection::RECEIVING;
+        t->is_directory = msg.value("is_directory", false);
+        t->name = msg.value("name", std::string("transfer"));
+        t->total_bytes = msg.value("total_size", uint64_t(0));
+        t->status = FileTransferStatus::PENDING;
+        t->start_time = std::chrono::steady_clock::now();
+        t->last_activity = t->start_time;
+        t->rate_mark_time = t->start_time;
+
+        bool unsafe = false;
+        for (const auto& fj : msg.at("files")) {
+            TransferFile f;
+            f.relative_path = fj.at("path").get<std::string>();
+            f.size = fj.value("size", uint64_t(0));
+            if (!is_safe_relative_path(f.relative_path)) unsafe = true;
+            t->files.push_back(std::move(f));
         }
-        
-        uint32_t chunk_size = (std::min)(static_cast<uint64_t>(config_.chunk_size), 
-                                      progress->file_size - file_offset);
-        
-        FileChunk chunk;
-        chunk.transfer_id = transfer_id;
-        chunk.chunk_index = chunk_index;
-        chunk.total_chunks = progress->total_chunks;
-        chunk.chunk_size = chunk_size;
-        chunk.file_offset = file_offset;
-        chunk.data.resize(chunk_size);
-        
-        // Read chunk data
-        if (!read_file_chunk(progress->local_path.c_str(), file_offset, chunk.data.data(), chunk_size)) {
-            complete_transfer(transfer_id, false, "Failed to read complete chunk from file");
+
+        if (unsafe) {
+            LOG_FT_WARN("Rejecting offer " << id << " from " << peer_id << ": unsafe path in manifest");
+            nlohmann::json resp{{"transfer_id", id}, {"accepted", false},
+                                {"reason", "unsafe path in manifest"}};
+            client_.send(peer_id, MSG_RESPONSE, resp);
             return;
         }
-        
-        // Calculate checksum
-        if (config_.verify_checksums) {
-            chunk.checksum = calculate_chunk_checksum(chunk.data);
+
+        {
+            std::lock_guard<std::mutex> lk(transfers_mutex_);
+            transfers_[id] = t;
         }
-        
-        // Note: Compression removed as requested - only binary chunks needed
-        
-        // Send chunk metadata first
-        nlohmann::json metadata_msg = create_chunk_metadata_message(chunk);
-        client_.send(progress->peer_id, "file_chunk_metadata", metadata_msg);
-        
-        // Send chunk binary data
-        std::vector<uint8_t> binary_msg = create_chunk_binary_message(chunk);
-        client_.send_binary_to_peer_id(progress->peer_id, binary_msg, MessageDataType::BINARY);
-        
-        chunk_index++;
-        file_offset += chunk_size;
-        
-        // Update progress
-        update_transfer_progress(transfer_id, chunk_size);
-        
-        // Throttle sending to avoid overwhelming the peer - use condition variable for fast shutdown
-        if (running_.load()) {
-            std::unique_lock<std::mutex> lock(throttle_mutex_);
-            throttle_condition_.wait_for(lock, std::chrono::milliseconds(10), [this] { return !running_.load(); });
+
+        IncomingTransferOffer offer;
+        offer.transfer_id = id;
+        offer.peer_id = peer_id;
+        offer.name = t->name;
+        offer.is_directory = t->is_directory;
+        offer.total_size = t->total_bytes;
+        for (const auto& f : t->files) offer.files.push_back({f.relative_path, f.size});
+
+        LOG_FT_INFO("Incoming offer [" << id << "] '" << t->name << "' from " << peer_id
+                                       << " (" << t->files.size() << " file(s), "
+                                       << t->total_bytes << " bytes)");
+
+        TransferOfferCallback cb;
+        {
+            std::lock_guard<std::mutex> lk(callbacks_mutex_);
+            cb = offer_callback_;
+        }
+        if (cb) {
+            cb(offer);
+        } else {
+            reject(id, "no offer handler configured");
         }
+    } catch (const std::exception& e) {
+        LOG_FT_ERROR("Malformed ft_offer from " << peer_id << ": " << e.what());
     }
-    
-    LOG_FILE_TRANSFER_INFO("Completed sending file chunks for transfer: " << transfer_id);
 }
 
-void FileTransferManager::start_file_receive(const std::string& transfer_id) {
-    // Exit immediately if shutting down
-    if (!running_.load()) {
-        return;
+bool FileTransferManager::accept(const std::string& transfer_id, const std::string& local_path) {
+    auto t = find(transfer_id);
+    if (!t || t->direction != FileTransferDirection::RECEIVING) return false;
+
+    FileTransferConfig cfg = get_config();
+    bool empty_transfer = false;
+    {
+        std::lock_guard<std::mutex> lk(t->mtx);
+        if (t->status != FileTransferStatus::PENDING) return false;
+        t->local_root = local_path;
+        for (size_t i = 0; i < t->files.size(); ++i) {
+            TransferFile& f = t->files[i];
+            f.final_path = t->is_directory ? combine_paths(local_path, f.relative_path)
+                                           : local_path;
+            f.temp_path  = combine_paths(cfg.temp_directory,
+                                         transfer_id + "." + std::to_string(i) + ".part");
+        }
+        t->status = FileTransferStatus::IN_PROGRESS;
+        t->start_time = std::chrono::steady_clock::now();
+        t->last_activity = t->start_time;
+        t->rate_mark_time = t->start_time;
+        empty_transfer = t->files.empty();
     }
-    
-    auto progress = get_transfer_progress(transfer_id);
-    if (!progress) {
-        return;
+
+    create_directories(cfg.temp_directory.c_str());
+    nlohmann::json resp{{"transfer_id", transfer_id}, {"accepted", true}};
+    client_.send(t->peer_id, MSG_RESPONSE, resp);
+    LOG_FT_INFO("Accepted transfer [" << transfer_id << "] -> " << local_path);
+
+    if (t->is_directory) create_directories(local_path.c_str());
+
+    emit_progress(t);
+
+    // A transfer with no files (e.g. an empty directory) is done immediately.
+    if (empty_transfer) {
+        nlohmann::json done{{"transfer_id", transfer_id}, {"success", true}};
+        client_.send(t->peer_id, MSG_COMPLETE, done);
+        finish(t, true, "");
     }
-    
-    progress->status = FileTransferStatus::IN_PROGRESS;
-    
-    // Create temporary file for receiving
-    if (!create_temp_file(transfer_id, progress->file_size)) {
-        complete_transfer(transfer_id, false, "Failed to create temporary file");
-        return;
+    return true;
+}
+
+bool FileTransferManager::reject(const std::string& transfer_id, const std::string& reason) {
+    auto t = find(transfer_id);
+    if (!t || t->direction != FileTransferDirection::RECEIVING) return false;
+    {
+        std::lock_guard<std::mutex> lk(t->mtx);
+        if (t->status != FileTransferStatus::PENDING) return false;
+        t->status = FileTransferStatus::CANCELLED;
     }
-    
-    update_transfer_progress(transfer_id);
-    LOG_FILE_TRANSFER_INFO("Started receiving file transfer: " << transfer_id);
+    nlohmann::json resp{{"transfer_id", transfer_id}, {"accepted", false}, {"reason", reason}};
+    client_.send(t->peer_id, MSG_RESPONSE, resp);
+    finish(t, false, reason.empty() ? "rejected" : ("rejected: " + reason));
+    return true;
 }
 
-void FileTransferManager::start_directory_send(const std::string& transfer_id) {
-    auto progress = get_transfer_progress(transfer_id);
-    if (!progress) {
-        return;
+// =============================================================================
+// Receiving: chunk handling
+// =============================================================================
+
+bool FileTransferManager::handle_binary_data(const std::string& peer_id,
+                                             const std::vector<uint8_t>& data) {
+    if (data.size() < 4 || std::memcmp(data.data(), CHUNK_MAGIC, 4) != 0) {
+        return false; // not a file-transfer frame
+    }
+    const uint8_t* p = data.data();
+    size_t n = data.size();
+    size_t pos = 4;
+
+    if (pos + 2 > n) return true;
+    uint16_t id_len = get_u16(p + pos);
+    pos += 2;
+    if (pos + id_len > n) return true;
+    std::string id(reinterpret_cast<const char*>(p + pos), id_len);
+    pos += id_len;
+    if (pos + 4 + 8 + 4 + 4 > n) return true;
+    uint32_t file_index = get_u32(p + pos); pos += 4;
+    uint64_t offset     = get_u64(p + pos); pos += 8;
+    uint32_t data_len   = get_u32(p + pos); pos += 4;
+    uint32_t crc        = get_u32(p + pos); pos += 4;
+    if (pos + data_len != n) {
+        LOG_FT_WARN("Chunk frame from " << peer_id << " has inconsistent length");
+        return true;
     }
-    
-    DirectoryMetadata dir_metadata;
+    on_chunk(id, peer_id, file_index, offset, p + pos, data_len, crc);
+    return true;
+}
+
+void FileTransferManager::on_chunk(const std::string& transfer_id, const std::string& peer_id,
+                                   uint32_t file_index, uint64_t offset,
+                                   const uint8_t* data, uint32_t len, uint32_t crc) {
+    auto t = find(transfer_id);
+    if (!t || t->direction != FileTransferDirection::RECEIVING) return;
+    FileTransferConfig cfg = get_config();
+
+    // Acknowledge at least twice per window so the sender never stalls waiting
+    // for a progress update it will not receive.
+    uint64_t ack_interval = std::min<uint64_t>(
+        cfg.progress_interval, std::max<uint32_t>(1, cfg.window_bytes / 2));
+
+    std::string temp_path;
+    uint64_t file_size = 0;
+    std::string fail_error;
     {
-        std::lock_guard<std::mutex> dir_lock(directory_transfers_mutex_);
-        auto it = active_directory_transfers_.find(transfer_id);
-        if (it == active_directory_transfers_.end()) {
-            complete_transfer(transfer_id, false, "Directory metadata not found");
+        std::lock_guard<std::mutex> lk(t->mtx);
+        // Only accept chunks while the transfer is live (PAUSED still drains
+        // chunks already in flight).
+        if (t->status != FileTransferStatus::IN_PROGRESS &&
+            t->status != FileTransferStatus::PAUSED) {
             return;
         }
-        dir_metadata = it->second;
-    }
-    
-    progress->status = FileTransferStatus::IN_PROGRESS;
-    update_transfer_progress(transfer_id);
-    
-    // Send each file in the directory
-    for (const auto& file_metadata : dir_metadata.files) {
-        if (!running_.load()) {
-            return;
-        }
-        
-        // Check if transfer was cancelled or paused
-        auto current_progress = get_transfer_progress(transfer_id);
-        if (!current_progress || current_progress->status == FileTransferStatus::CANCELLED ||
-            current_progress->status == FileTransferStatus::PAUSED) {
-            return;
+        if (file_index >= t->files.size() || file_index != t->recv_file) {
+            // Strict ordering is guaranteed by the reliable transport.
+            fail_error = "out-of-order file index";
+        } else {
+            TransferFile& f = t->files[file_index];
+            if (offset != f.received) {
+                fail_error = "out-of-order chunk offset";
+            } else if (offset + len > f.size) {
+                fail_error = "chunk exceeds declared file size";
+            } else {
+                temp_path = f.temp_path;
+                file_size = f.size;
+            }
         }
-        
-        std::string full_file_path = combine_paths(progress->local_path, file_metadata.relative_path);
-        
-        // Send individual file using existing file transfer logic
-        std::string file_transfer_id = send_file_with_metadata(progress->peer_id, full_file_path, file_metadata);
-        
-        if (file_transfer_id.empty()) {
-            complete_transfer(transfer_id, false, "Failed to send file: " + file_metadata.filename);
-            return;
+        if (!fail_error.empty()) {
+            t->status = FileTransferStatus::FAILED;
+            t->error = fail_error;
+            t->cv.notify_all();
         }
-        
-        // Wait for individual file transfer to complete
-        // Note: In a real implementation, we might want to track multiple concurrent file transfers
-        // For now, we'll send files sequentially
-    }
-    
-    LOG_FILE_TRANSFER_INFO("Completed sending directory transfer: " << transfer_id);
-    complete_transfer(transfer_id, true);
-}
+    }
+    if (!fail_error.empty()) {
+        nlohmann::json done{{"transfer_id", transfer_id}, {"success", false},
+                            {"error", fail_error}};
+        client_.send(peer_id, MSG_COMPLETE, done);
+        finish(t, false, fail_error);
+        return;
+    }
 
-void FileTransferManager::start_directory_receive(const std::string& transfer_id) {
-    auto progress = get_transfer_progress(transfer_id);
-    if (!progress) {
+    if (cfg.verify_integrity && crc32(data, len) != crc) {
+        nlohmann::json done{{"transfer_id", transfer_id}, {"success", false},
+                            {"error", "chunk CRC mismatch"}};
+        client_.send(peer_id, MSG_COMPLETE, done);
+        finish(t, false, "chunk CRC mismatch");
         return;
     }
-    
-    DirectoryMetadata dir_metadata;
+
+    // Create the temp file on first contact, pre-sized to the declared length.
     {
-        std::lock_guard<std::mutex> dir_lock(directory_transfers_mutex_);
-        auto it = active_directory_transfers_.find(transfer_id);
-        if (it == active_directory_transfers_.end()) {
-            complete_transfer(transfer_id, false, "Directory metadata not found");
-            return;
+        bool need_create;
+        {
+            std::lock_guard<std::mutex> lk(t->mtx);
+            need_create = !t->files[file_index].temp_created;
+        }
+        if (need_create) {
+            if (!create_file_with_size(temp_path.c_str(), file_size)) {
+                nlohmann::json done{{"transfer_id", transfer_id}, {"success", false},
+                                    {"error", "cannot create destination temp file"}};
+                client_.send(peer_id, MSG_COMPLETE, done);
+                finish(t, false, "cannot create temp file");
+                return;
+            }
+            std::lock_guard<std::mutex> lk(t->mtx);
+            t->files[file_index].temp_created = true;
         }
-        dir_metadata = it->second;
-    }
-    
-    progress->status = FileTransferStatus::IN_PROGRESS;
-    
-    // Create directory structure
-    std::string base_path = progress->local_path;
-    if (!ensure_directory_exists(base_path)) {
-        complete_transfer(transfer_id, false, "Failed to create local directory structure");
+    }
+
+    if (!write_file_chunk(temp_path, offset, data, len)) {
+        nlohmann::json done{{"transfer_id", transfer_id}, {"success", false},
+                            {"error", "receiver failed to write to disk"}};
+        client_.send(peer_id, MSG_COMPLETE, done);
+        finish(t, false, "failed to write chunk to disk");
         return;
     }
-    
-    // Create subdirectories if needed
-    for (const auto& file_metadata : dir_metadata.files) {
-        std::string file_dir = combine_paths(base_path, get_parent_directory(file_metadata.relative_path.c_str()));
-        if (!file_dir.empty() && !ensure_directory_exists(file_dir)) {
-            complete_transfer(transfer_id, false, "Failed to create subdirectory: " + file_dir);
-            return;
+
+    bool data_complete = false;
+    bool send_ack = false;
+    uint64_t ack_bytes = 0;
+    {
+        std::lock_guard<std::mutex> lk(t->mtx);
+        TransferFile& f = t->files[file_index];
+        if (f.received == 0) sha256_reset(&t->recv_hash);
+        sha256_update(&t->recv_hash, data, len);
+        f.received   += len;
+        t->bytes_done += len;
+        t->last_activity = std::chrono::steady_clock::now();
+
+        if (f.received >= f.size) {
+            uint8_t digest[SHA256_HASH_SIZE];
+            sha256_finish(&t->recv_hash, digest);
+            f.computed_sha = to_hex(digest, SHA256_HASH_SIZE);
+            data_complete = true;
+        }
+        if (data_complete || t->bytes_done - t->last_ack_sent >= ack_interval) {
+            t->last_ack_sent = t->bytes_done;
+            ack_bytes = t->bytes_done;
+            send_ack = true;
         }
     }
-    
-    update_transfer_progress(transfer_id);
-    LOG_FILE_TRANSFER_INFO("Started receiving directory transfer: " << transfer_id);
-    
-    // Note: Individual files will be received as separate file transfer requests
-    // The directory transfer completion will be handled when all files are received
+    {
+        std::lock_guard<std::mutex> lk(stats_mutex_);
+        stat_bytes_received_ += len;
+    }
+
+    if (send_ack) {
+        nlohmann::json prog{{"transfer_id", transfer_id}, {"bytes_received", ack_bytes}};
+        client_.send(peer_id, MSG_PROGRESS, prog);
+    }
+    emit_progress(t);
+
+    if (data_complete) try_finalize_file(t, file_index);
 }
 
-bool FileTransferManager::create_temp_file(const std::string& transfer_id, uint64_t file_size) {
-    std::string temp_path = get_temp_file_path(transfer_id, config_.temp_directory);
-    
+void FileTransferManager::on_file_end(const std::string& /*peer_id*/, const nlohmann::json& msg) {
     try {
-        create_directories(config_.temp_directory.c_str());
-        
-        // Create file with pre-allocated size
-        if (!create_file_with_size(temp_path.c_str(), file_size)) {
-            LOG_FILE_TRANSFER_ERROR("Failed to create temp file " << temp_path);
-            return false;
+        std::string id = msg.at("transfer_id").get<std::string>();
+        auto t = find(id);
+        if (!t || t->direction != FileTransferDirection::RECEIVING) return;
+        size_t file_index = msg.at("file_index").get<size_t>();
+        std::string sha = msg.value("sha256", std::string());
+        {
+            std::lock_guard<std::mutex> lk(t->mtx);
+            if (t->is_terminal() || file_index >= t->files.size()) return;
+            TransferFile& f = t->files[file_index];
+            if (f.finalized) return;
+            f.expected_sha = sha;
+            f.sha_known = true;
+            // A zero-byte file produces no chunks, so hash it here.
+            if (f.size == 0 && f.computed_sha.empty()) f.computed_sha = sha256_of_empty();
         }
-        
-        return true;
+        try_finalize_file(t, file_index);
     } catch (const std::exception& e) {
-        LOG_FILE_TRANSFER_ERROR("Failed to create temp file " << temp_path << ": " << e.what());
-        return false;
+        LOG_FT_ERROR("Malformed ft_file_end: " << e.what());
     }
 }
 
-std::string FileTransferManager::get_temp_file_path(const std::string& transfer_id, const std::string& temp_dir) {
-    return combine_paths(temp_dir, transfer_id + ".tmp");
-}
-
-bool FileTransferManager::ensure_directory_exists(const std::string& directory_path) {
-    return create_directories(directory_path.c_str());
-}
-
-std::string FileTransferManager::extract_filename(const std::string& file_path) {
-    return get_filename_from_path(file_path);
-}
+// Moves a fully-received, verified file to its destination. When the last file
+// of the transfer is finalized, completes the whole transfer.
+void FileTransferManager::try_finalize_file(const std::shared_ptr<Transfer>& t, size_t file_index) {
+    FileTransferConfig cfg = get_config();
+    std::string final_path, temp_path, rel_path;
+    bool do_finalize = false;
+    bool sha_mismatch = false;
+    bool zero_byte = false;
+    {
+        std::lock_guard<std::mutex> lk(t->mtx);
+        if (t->is_terminal() || file_index >= t->files.size()) return;
+        TransferFile& f = t->files[file_index];
+        if (f.finalized) return;
+        if (f.received < f.size) return; // data not complete yet
+        if (!f.sha_known) return;        // ft_file_end not received yet
+
+        if (cfg.verify_integrity && f.computed_sha != f.expected_sha) {
+            sha_mismatch = true;
+        } else {
+            do_finalize = true;
+            final_path = f.final_path;
+            temp_path  = f.temp_path;
+            rel_path   = f.relative_path;
+            zero_byte  = (f.size == 0);
+        }
+    }
 
-std::string FileTransferManager::get_mime_type(const std::string& file_path) {
-    std::string extension = get_file_extension(file_path);
-    std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower);
-    
-    // Basic MIME type mapping
-    static const std::unordered_map<std::string, std::string> mime_types = {
-        {".txt", "text/plain"},
-        {".json", "application/json"},
-        {".xml", "application/xml"},
-        {".html", "text/html"},
-        {".css", "text/css"},
-        {".js", "application/javascript"},
-        {".pdf", "application/pdf"},
-        {".png", "image/png"},
-        {".jpg", "image/jpeg"},
-        {".jpeg", "image/jpeg"},
-        {".gif", "image/gif"},
-        {".bmp", "image/bmp"},
-        {".svg", "image/svg+xml"},
-        {".mp3", "audio/mpeg"},
-        {".wav", "audio/wav"},
-        {".mp4", "video/mp4"},
-        {".avi", "video/x-msvideo"},
-        {".zip", "application/zip"},
-        {".tar", "application/x-tar"},
-        {".gz", "application/gzip"}
-    };
-    
-    auto it = mime_types.find(extension);
-    return (it != mime_types.end()) ? it->second : "application/octet-stream";
-}
+    if (sha_mismatch) {
+        nlohmann::json done{{"transfer_id", t->id}, {"success", false},
+                            {"error", "SHA-256 mismatch"}};
+        client_.send(t->peer_id, MSG_COMPLETE, done);
+        finish(t, false, "SHA-256 mismatch for " + rel_path);
+        return;
+    }
+    if (!do_finalize) return;
 
-// Message handling methods
+    // Place the file at its destination (parent directories created as needed).
+    std::string parent = get_parent_directory(final_path.c_str());
+    if (!parent.empty()) create_directories(parent.c_str());
+    if (file_exists(final_path)) delete_file(final_path.c_str());
 
-void FileTransferManager::handle_transfer_request(const std::string& peer_id, const nlohmann::json& message) {
-    try {
-        std::string transfer_id = message["transfer_id"];
-        
-        if (message.contains("directory_metadata")) {
-            // Directory transfer request
-            DirectoryMetadata dir_metadata;
-            auto dir_info = message["directory_metadata"];
-            dir_metadata.directory_name = dir_info["directory_name"];
-            dir_metadata.relative_path = dir_info["relative_path"];
-            
-            // Parse files and subdirectories from the metadata
-            if (dir_info.contains("files")) {
-                for (const auto& file_json : dir_info["files"]) {
-                    FileMetadata file_meta;
-                    file_meta.filename = file_json["filename"];
-                    file_meta.relative_path = file_json["relative_path"];
-                    file_meta.file_size = file_json["file_size"];
-                    file_meta.mime_type = file_json.value("mime_type", "application/octet-stream");
-                    file_meta.checksum = file_json.value("checksum", "");
-                    file_meta.last_modified = file_json.value("last_modified", 0);
-                    dir_metadata.files.push_back(file_meta);
-                }
-            }
-            
-            // For now, handle as single directory level (can be expanded for nested later)
-            
-            {
-                std::lock_guard<std::mutex> lock(pending_mutex_);
-                PendingDirectoryTransfer pending_transfer;
-                pending_transfer.metadata = dir_metadata;
-                pending_transfer.peer_id = peer_id;
-                pending_directory_transfers_[transfer_id] = pending_transfer;
-            }
-            
-            // Call user callback to approve/reject
-            if (request_callback_) {
-                // Create a dummy file metadata for compatibility with existing callback
-                FileMetadata dummy_metadata;
-                dummy_metadata.filename = dir_metadata.directory_name + " (directory)";
-                dummy_metadata.file_size = dir_info.value("total_size", 0);
-                
-                bool accepted = request_callback_(peer_id, dummy_metadata, transfer_id);
-                if (accepted) {
-                    std::string local_path = "./" + dir_metadata.directory_name;
-                    accept_directory_transfer(transfer_id, local_path);
-                } else {
-                    reject_directory_transfer(transfer_id, "Rejected by user");
-                }
-            } else {
-                // Auto-reject if no callback is set
-                reject_directory_transfer(transfer_id, "No request handler configured");
-            }
-            
-            LOG_FILE_TRANSFER_INFO("Received directory transfer request from " << peer_id << " for " << dir_metadata.directory_name);
-            return;
-        }
-        
-        // Single file transfer request
-        FileMetadata metadata;
-        auto file_info = message["file_metadata"];
-        metadata.filename = file_info["filename"];
-        metadata.file_size = file_info["file_size"];
-        metadata.mime_type = file_info.value("mime_type", "application/octet-stream");
-        metadata.checksum = file_info.value("checksum", "");
-        
-        {
-            std::lock_guard<std::mutex> lock(pending_mutex_);
-            PendingFileTransfer pending_transfer;
-            pending_transfer.metadata = metadata;
-            pending_transfer.peer_id = peer_id;
-            pending_transfers_[transfer_id] = pending_transfer;
+    bool ok;
+    if (zero_byte) {
+        ok = create_file_with_size(final_path.c_str(), 0);
+        if (file_exists(temp_path)) delete_file(temp_path.c_str());
+    } else {
+        ok = rename_file(temp_path, final_path);
+        if (!ok) {
+            // rename fails across volumes; fall back to copy + delete.
+            ok = copy_file(temp_path.c_str(), final_path.c_str());
+            if (ok) delete_file(temp_path.c_str());
         }
-        
-        // Call user callback to approve/reject
-        if (request_callback_) {
-            bool accepted = request_callback_(peer_id, metadata, transfer_id);
-            if (accepted) {
-                // We need a way to specify the local path - this should be part of the callback
-                // For now, we'll create a default path
-                std::string local_path = "./" + metadata.filename;
-                accept_file_transfer(transfer_id, local_path);
-            } else {
-                reject_file_transfer(transfer_id, "Rejected by user");
-            }
-        } else {
-            // Auto-reject if no callback is set
-            reject_file_transfer(transfer_id, "No request handler configured");
+    }
+    if (!ok) {
+        nlohmann::json done{{"transfer_id", t->id}, {"success", false},
+                            {"error", "cannot write destination file"}};
+        client_.send(t->peer_id, MSG_COMPLETE, done);
+        finish(t, false, "cannot move file to " + final_path);
+        return;
+    }
+
+    bool all_done = false;
+    {
+        std::lock_guard<std::mutex> lk(t->mtx);
+        TransferFile& f = t->files[file_index];
+        f.finalized = true;
+        t->files_done++;
+        if (file_index == t->recv_file) t->recv_file++;
+        all_done = true;
+        for (const auto& ff : t->files) {
+            if (!ff.finalized) { all_done = false; break; }
         }
-        
-    } catch (const std::exception& e) {
-        LOG_FILE_TRANSFER_ERROR("Error handling transfer request: " << e.what());
+    }
+    emit_progress(t);
+
+    if (all_done) {
+        nlohmann::json done{{"transfer_id", t->id}, {"success", true}};
+        client_.send(t->peer_id, MSG_COMPLETE, done);
+        finish(t, true, "");
     }
 }
 
-void FileTransferManager::handle_transfer_response(const std::string& peer_id, const nlohmann::json& message) {
+// =============================================================================
+// Control message handlers
+// =============================================================================
+
+void FileTransferManager::on_response(const std::string& /*peer_id*/, const nlohmann::json& msg) {
     try {
-        std::string transfer_id = message["transfer_id"];
-        bool accepted = message["accepted"];
-        
-        auto progress = get_transfer_progress(transfer_id);
-        if (!progress) {
-            LOG_FILE_TRANSFER_ERROR("Received response for unknown transfer: " << transfer_id);
-            return;
-        }
-        
+        std::string id = msg.at("transfer_id").get<std::string>();
+        auto t = find(id);
+        if (!t || t->direction != FileTransferDirection::SENDING) return;
+        bool accepted = msg.value("accepted", false);
+
         if (accepted) {
-            // Start sending file
             {
-                std::lock_guard<std::mutex> work_lock(work_mutex_);
-                work_queue_.push(transfer_id);
+                std::lock_guard<std::mutex> lk(t->mtx);
+                if (t->status != FileTransferStatus::STARTING) return;
+                t->status = FileTransferStatus::IN_PROGRESS;
+                t->start_time = std::chrono::steady_clock::now();
+                t->last_activity = t->start_time;
+                t->rate_mark_time = t->start_time;
             }
-            work_condition_.notify_one();
-            
-            LOG_FILE_TRANSFER_INFO("Transfer accepted by peer: " << transfer_id);
+            LOG_FT_INFO("Transfer " << id << " accepted by peer");
+            queue_send(id);
         } else {
-            std::string reason = message.value("reason", "No reason provided");
-            complete_transfer(transfer_id, false, "Transfer rejected by peer: " + reason);
+            std::string reason = msg.value("reason", std::string("rejected by peer"));
+            finish(t, false, reason);
         }
-        
     } catch (const std::exception& e) {
-        LOG_FILE_TRANSFER_ERROR("Error handling transfer response: " << e.what());
+        LOG_FT_ERROR("Malformed ft_response: " << e.what());
     }
 }
 
-void FileTransferManager::handle_chunk_metadata_message(const std::string& peer_id, const nlohmann::json& message) {
+void FileTransferManager::on_progress(const std::string& /*peer_id*/, const nlohmann::json& msg) {
     try {
-        PendingChunk pending;
-        pending.transfer_id = message["transfer_id"];
-        pending.chunk_index = message["chunk_index"];
-        pending.total_chunks = message["total_chunks"];
-        pending.chunk_size = message["chunk_size"];
-        pending.file_offset = message["file_offset"];
-        pending.checksum = message.value("checksum", "");
-        pending.created_at = std::chrono::steady_clock::now();
-        
-        // Store pending chunk metadata waiting for binary data
+        std::string id = msg.at("transfer_id").get<std::string>();
+        auto t = find(id);
+        if (!t || t->direction != FileTransferDirection::SENDING) return;
+        uint64_t acked = msg.value("bytes_received", uint64_t(0));
         {
-            std::lock_guard<std::mutex> lock(chunks_mutex_);
-            pending_chunks_[peer_id] = pending;
+            std::lock_guard<std::mutex> lk(t->mtx);
+            if (acked > t->acked_bytes) t->acked_bytes = acked;
+            t->last_activity = std::chrono::steady_clock::now();
+            t->cv.notify_all(); // wake the streaming worker if it was throttled
         }
-        
-        LOG_FILE_TRANSFER_DEBUG("Stored chunk metadata for transfer " << pending.transfer_id << 
-                               ", chunk " << pending.chunk_index << " from peer " << peer_id);
-        
     } catch (const std::exception& e) {
-        LOG_FILE_TRANSFER_ERROR("Error handling chunk metadata message: " << e.what());
+        LOG_FT_ERROR("Malformed ft_progress: " << e.what());
     }
 }
 
-void FileTransferManager::handle_chunk_binary_message(const std::string& peer_id, const std::vector<uint8_t>& binary_data) {
+void FileTransferManager::on_complete(const std::string& /*peer_id*/, const nlohmann::json& msg) {
     try {
-        // Parse binary chunk header and get the chunk data
-        FileChunk chunk;
-        if (!parse_chunk_binary_header(binary_data, chunk)) {
-            LOG_FILE_TRANSFER_ERROR("Failed to parse chunk binary header from peer " << peer_id);
-            return;
-        }
-        
-        // Get pending chunk metadata
-        PendingChunk pending;
-        bool found_pending = false;
-        {
-            std::lock_guard<std::mutex> lock(chunks_mutex_);
-            auto it = pending_chunks_.find(peer_id);
-            if (it != pending_chunks_.end()) {
-                pending = it->second;
-                pending_chunks_.erase(it);
-                found_pending = true;
-            }
-        }
-        
-        if (!found_pending) {
-            LOG_FILE_TRANSFER_ERROR("No pending chunk metadata found for peer " << peer_id);
-            return;
-        }
-        
-        // Combine metadata with binary data
-        chunk.transfer_id = pending.transfer_id;
-        chunk.chunk_index = pending.chunk_index;
-        chunk.total_chunks = pending.total_chunks;
-        chunk.chunk_size = pending.chunk_size;
-        chunk.file_offset = pending.file_offset;
-        chunk.checksum = pending.checksum;
-        
-        // Verify chunk size matches
-        if (chunk.data.size() != pending.chunk_size) {
-            LOG_FILE_TRANSFER_ERROR("Chunk size mismatch: expected " << pending.chunk_size << 
-                                   ", got " << chunk.data.size() << " for transfer " << pending.transfer_id);
-            
-            // Send negative acknowledgment
-            nlohmann::json ack_msg = create_chunk_ack_message(chunk.transfer_id, chunk.chunk_index, false, "Size mismatch");
-            client_.send(peer_id, "file_chunk_ack", ack_msg);
-            return;
-        }
-        
-        // Verify checksum if enabled
-        if (config_.verify_checksums && !chunk.checksum.empty()) {
-            if (!verify_chunk_checksum(chunk)) {
-                LOG_FILE_TRANSFER_ERROR("Chunk checksum verification failed for transfer " << chunk.transfer_id << 
-                                       ", chunk " << chunk.chunk_index);
-                
-                // Send negative acknowledgment
-                nlohmann::json ack_msg = create_chunk_ack_message(chunk.transfer_id, chunk.chunk_index, false, "Checksum mismatch");
-                client_.send(peer_id, "file_chunk_ack", ack_msg);
-                return;
-            }
-        }
-        
-        // Process the received chunk
-        handle_chunk_received(chunk);
-        
-        // Send positive acknowledgment
-        nlohmann::json ack_msg = create_chunk_ack_message(chunk.transfer_id, chunk.chunk_index, true);
-        client_.send(peer_id, "file_chunk_ack", ack_msg);
-        
-        LOG_FILE_TRANSFER_DEBUG("Successfully processed chunk " << chunk.chunk_index << 
-                               " for transfer " << chunk.transfer_id << " from peer " << peer_id);
-        
+        std::string id = msg.at("transfer_id").get<std::string>();
+        auto t = find(id);
+        if (!t) return;
+        bool success = msg.value("success", false);
+        std::string error = msg.value("error", std::string());
+        finish(t, success, success ? "" : (error.empty() ? "peer reported failure" : error));
     } catch (const std::exception& e) {
-        LOG_FILE_TRANSFER_ERROR("Error handling chunk binary message: " << e.what());
+        LOG_FT_ERROR("Malformed ft_complete: " << e.what());
     }
 }
 
-void FileTransferManager::handle_chunk_ack_message(const std::string& peer_id, const nlohmann::json& message) {
+void FileTransferManager::on_control(const std::string& /*peer_id*/, const nlohmann::json& msg) {
     try {
-        std::string transfer_id = message["transfer_id"];
-        uint64_t chunk_index = message["chunk_index"];
-        bool success = message["success"];
-        
-        handle_chunk_ack(transfer_id, chunk_index, success);
-        
-    } catch (const std::exception& e) {
-        LOG_FILE_TRANSFER_ERROR("Error handling chunk ack message: " << e.what());
-    }
-}
+        std::string id = msg.at("transfer_id").get<std::string>();
+        std::string action = msg.at("action").get<std::string>();
+        auto t = find(id);
+        if (!t) return;
 
-void FileTransferManager::handle_transfer_control(const std::string& peer_id, const nlohmann::json& message) {
-    try {
-        std::string transfer_id = message["transfer_id"];
-        std::string action = message["action"];
-        
         if (action == "pause") {
-            pause_transfer(transfer_id);
+            std::lock_guard<std::mutex> lk(t->mtx);
+            if (t->status == FileTransferStatus::IN_PROGRESS) {
+                t->status = FileTransferStatus::PAUSED;
+                t->cv.notify_all();
+            }
         } else if (action == "resume") {
-            resume_transfer(transfer_id);
+            bool requeue = false;
+            {
+                std::lock_guard<std::mutex> lk(t->mtx);
+                if (t->status == FileTransferStatus::PAUSED) {
+                    if (t->direction == FileTransferDirection::SENDING) {
+                        t->status = FileTransferStatus::RESUMING;
+                        requeue = true;
+                    } else {
+                        t->status = FileTransferStatus::IN_PROGRESS;
+                    }
+                    t->cv.notify_all();
+                }
+            }
+            if (requeue) queue_send(id);
         } else if (action == "cancel") {
-            cancel_transfer(transfer_id);
+            {
+                std::lock_guard<std::mutex> lk(t->mtx);
+                if (t->is_terminal()) return;
+                t->status = FileTransferStatus::CANCELLED;
+                t->cv.notify_all();
+            }
+            finish(t, false, "cancelled by peer");
         }
-        
     } catch (const std::exception& e) {
-        LOG_FILE_TRANSFER_ERROR("Error handling transfer control message: " << e.what());
+        LOG_FT_ERROR("Malformed ft_control: " << e.what());
     }
 }
 
-// Message creation methods
-
-nlohmann::json FileTransferManager::create_transfer_request_message(const FileMetadata& metadata, const std::string& transfer_id) {
-    nlohmann::json message;
-    message["transfer_id"] = transfer_id;
-    message["type"] = "file";
-    message["file_metadata"] = {
-        {"filename", metadata.filename},
-        {"file_size", metadata.file_size},
-        {"mime_type", metadata.mime_type},
-        {"checksum", metadata.checksum},
-        {"last_modified", metadata.last_modified}
-    };
-    return message;
-}
-
-nlohmann::json FileTransferManager::create_transfer_response_message(const std::string& transfer_id, bool accepted, const std::string& reason) {
-    nlohmann::json message;
-    message["transfer_id"] = transfer_id;
-    message["accepted"] = accepted;
-    if (!reason.empty()) {
-        message["reason"] = reason;
-    }
-    return message;
-}
-
-nlohmann::json FileTransferManager::create_chunk_metadata_message(const FileChunk& chunk) {
-    nlohmann::json message;
-    message["transfer_id"] = chunk.transfer_id;
-    message["chunk_index"] = chunk.chunk_index;
-    message["total_chunks"] = chunk.total_chunks;
-    message["chunk_size"] = chunk.chunk_size;
-    message["file_offset"] = chunk.file_offset;
-    message["checksum"] = chunk.checksum;
-    
-    return message;
-}
-
-std::vector<uint8_t> FileTransferManager::create_chunk_binary_message(const FileChunk& chunk) {
-    // Create binary message with header: "FTCHUNK" + chunk data
-    const std::string magic = "FTCHUNK";
-    std::vector<uint8_t> message;
-    
-    // Reserve space for the entire message
-    message.reserve(magic.length() + chunk.data.size());
-    
-    // Add magic header
-    message.insert(message.end(), magic.begin(), magic.end());
-    
-    // Add chunk data
-    message.insert(message.end(), chunk.data.begin(), chunk.data.end());
-    
-    return message;
-}
-
-nlohmann::json FileTransferManager::create_chunk_ack_message(const std::string& transfer_id, uint64_t chunk_index, bool success, const std::string& error) {
-    nlohmann::json message;
-    message["transfer_id"] = transfer_id;
-    message["chunk_index"] = chunk_index;
-    message["success"] = success;
-    if (!error.empty()) {
-        message["error"] = error;
-    }
-    return message;
-}
+// =============================================================================
+// Transfer control (local side)
+// =============================================================================
 
-nlohmann::json FileTransferManager::create_control_message(const std::string& transfer_id, const std::string& action, const nlohmann::json& data) {
-    nlohmann::json message;
-    message["transfer_id"] = transfer_id;
-    message["action"] = action;
-    if (!data.empty()) {
-        message["data"] = data;
-    }
-    return message;
+void FileTransferManager::send_control(const std::shared_ptr<Transfer>& t,
+                                       const std::string& action) {
+    nlohmann::json ctl{{"transfer_id", t->id}, {"action", action}};
+    client_.send(t->peer_id, MSG_CONTROL, ctl);
 }
 
-// Progress tracking methods
-
-void FileTransferManager::update_transfer_progress(const std::string& transfer_id, uint64_t bytes_delta) {
-    auto progress = get_transfer_progress(transfer_id);
-    if (!progress) {
-        return;
-    }
-    
-    if (bytes_delta > 0) {
-        progress->update_transfer_rates(progress->bytes_transferred + bytes_delta);
-        
-        // Update statistics
-        {
-            std::lock_guard<std::mutex> stats_lock(stats_mutex_);
-            if (progress->direction == FileTransferDirection::SENDING) {
-                total_bytes_sent_ += bytes_delta;
-            } else {
-                total_bytes_received_ += bytes_delta;
-            }
-        }
-    }
-    
-    // Call progress callback
-    if (progress_callback_) {
-        progress_callback_(*progress);
-    }
+bool FileTransferManager::pause(const std::string& transfer_id) {
+    auto t = find(transfer_id);
+    if (!t) return false;
+    {
+        std::lock_guard<std::mutex> lk(t->mtx);
+        if (t->status != FileTransferStatus::IN_PROGRESS) return false;
+        t->status = FileTransferStatus::PAUSED;
+        t->cv.notify_all();
+    }
+    send_control(t, "pause");
+    emit_progress(t);
+    LOG_FT_INFO("Transfer " << transfer_id << " paused");
+    return true;
 }
 
-void FileTransferManager::complete_transfer(const std::string& transfer_id, bool success, const std::string& error_message) {
-    auto progress = get_transfer_progress(transfer_id);
-    if (!progress) {
-        return;
-    }
-    
-    progress->status = success ? FileTransferStatus::COMPLETED : FileTransferStatus::FAILED;
-    progress->error_message = error_message;
-    
-    // Update statistics
+bool FileTransferManager::resume(const std::string& transfer_id) {
+    auto t = find(transfer_id);
+    if (!t) return false;
+    bool requeue = false;
     {
-        std::lock_guard<std::mutex> stats_lock(stats_mutex_);
-        if (progress->direction == FileTransferDirection::SENDING) {
-            total_files_sent_++;
+        std::lock_guard<std::mutex> lk(t->mtx);
+        if (t->status != FileTransferStatus::PAUSED) return false;
+        if (t->direction == FileTransferDirection::SENDING) {
+            t->status = FileTransferStatus::RESUMING;
+            requeue = true;
         } else {
-            total_files_received_++;
+            t->status = FileTransferStatus::IN_PROGRESS;
         }
+        t->last_activity = std::chrono::steady_clock::now();
+        t->cv.notify_all();
     }
-    
-    // Move to completed transfers
-    move_to_completed(transfer_id);
-    
-    // Call completion callback
-    if (completion_callback_) {
-        completion_callback_(transfer_id, success, error_message);
-    }
-    
-    LOG_FILE_TRANSFER_INFO("Transfer " << (success ? "completed" : "failed") << ": " << transfer_id);
+    send_control(t, "resume");
+    if (requeue) queue_send(transfer_id);
+    emit_progress(t);
+    LOG_FT_INFO("Transfer " << transfer_id << " resumed");
+    return true;
 }
 
-void FileTransferManager::move_to_completed(const std::string& transfer_id) {
-    std::lock_guard<std::mutex> lock(transfers_mutex_);
-    
-    auto it = active_transfers_.find(transfer_id);
-    if (it != active_transfers_.end()) {
-        completed_transfers_[transfer_id] = it->second;
-        active_transfers_.erase(it);
-    }
+bool FileTransferManager::cancel(const std::string& transfer_id) {
+    auto t = find(transfer_id);
+    if (!t) return false;
+    {
+        std::lock_guard<std::mutex> lk(t->mtx);
+        if (t->is_terminal()) return false;
+        t->status = FileTransferStatus::CANCELLED;
+        t->cv.notify_all();
+    }
+    send_control(t, "cancel");
+    finish(t, false, "cancelled");
+    LOG_FT_INFO("Transfer " << transfer_id << " cancelled");
+    return true;
 }
 
-// Binary chunk transmission implementation (replaces base64 encoding)
-//
-// PERFORMANCE OPTIMIZATIONS:
-// - Replaced JSON + base64 encoding with direct binary transmission
-// - Eliminates 33% encoding overhead from base64 
-// - Reduces CPU usage for encoding/decoding
-// - Minimizes memory allocations for string conversions
-// - Uses two-phase protocol: metadata (JSON) + binary data (raw)
-// - Added cleanup thread for timeout handling of split messages
-//
-// PROTOCOL CHANGES:
-// 1. Send file_chunk_metadata (JSON) with transfer info
-// 2. Send binary data with "FTCHUNK" magic header + raw file data
-// 3. Receive acknowledgments as before
-//
-// This approach provides maximum performance while maintaining protocol robustness.
-
-void FileTransferManager::handle_chunk_received(const FileChunk& chunk) {
-    // Write chunk to temporary file
-    std::string temp_path = get_temp_file_path(chunk.transfer_id, config_.temp_directory);
-    
-    if (!write_file_chunk(temp_path.c_str(), chunk.file_offset, chunk.data.data(), chunk.chunk_size)) {
-        LOG_FILE_TRANSFER_ERROR("Failed to write chunk to temp file: " << temp_path);
-        return;
-    }
-    
-    // Update progress
-    update_transfer_progress(chunk.transfer_id, chunk.chunk_size);
-    
-    // Check if transfer is complete
-    auto progress = get_transfer_progress(chunk.transfer_id);
-    if (progress) {
-        progress->chunks_completed++;
-        if (progress->chunks_completed == progress->total_chunks) {
-            // Transfer complete - move temp file to final location
-            if (finalize_received_file(chunk.transfer_id, progress->local_path)) {
-                complete_transfer(chunk.transfer_id, true);
-            } else {
-                complete_transfer(chunk.transfer_id, false, "Failed to finalize received file");
-            }
-        }
-    }
-}
+// =============================================================================
+// Peer disconnect
+// =============================================================================
 
-void FileTransferManager::handle_chunk_ack(const std::string& transfer_id, uint64_t chunk_index, bool success) {
-    auto progress = get_transfer_progress(transfer_id);
-    if (!progress) {
-        return;
-    }
-    
-    if (success) {
-        progress->chunks_completed++;
-        if (progress->chunks_completed == progress->total_chunks) {
-            complete_transfer(transfer_id, true);
+void FileTransferManager::on_peer_disconnected(const std::string& peer_id) {
+    std::vector<std::shared_ptr<Transfer>> affected;
+    {
+        std::lock_guard<std::mutex> lk(transfers_mutex_);
+        for (auto& kv : transfers_) {
+            if (kv.second->peer_id == peer_id) affected.push_back(kv.second);
         }
-    } else {
-        // Handle chunk failure - could retry or fail the transfer
-        LOG_FILE_TRANSFER_ERROR("Chunk " << chunk_index << " failed for transfer " << transfer_id);
     }
-}
-
-bool FileTransferManager::finalize_received_file(const std::string& transfer_id, const std::string& final_path) {
-    std::string temp_path = get_temp_file_path(transfer_id, config_.temp_directory);
-    
-    try {
-        // Ensure destination directory exists
-        std::string dest_dir = get_parent_directory(final_path.c_str());
-        if (!dest_dir.empty()) {
-            ensure_directory_exists(dest_dir);
-        }
-        
-        // Move temp file to final location
-        if (!rename_file(temp_path.c_str(), final_path.c_str())) {
-            LOG_FILE_TRANSFER_ERROR("Failed to rename temp file to final location: " << temp_path << " -> " << final_path);
-            return false;
+    for (auto& t : affected) {
+        bool active;
+        {
+            std::lock_guard<std::mutex> lk(t->mtx);
+            active = !t->is_terminal();
+            if (active) t->cv.notify_all();
         }
-        
-        return true;
-    } catch (const std::exception& e) {
-        LOG_FILE_TRANSFER_ERROR("Failed to finalize file " << final_path << ": " << e.what());
-        return false;
+        if (active) finish(t, false, "peer disconnected");
     }
 }
 
-std::string FileTransferManager::calculate_chunk_checksum(const std::vector<uint8_t>& data) {
-    SHA1 sha1;
-    sha1.update(data.data(), data.size());
-    return sha1.finalize();
-}
+// =============================================================================
+// Maintenance: timeouts and cleanup
+// =============================================================================
 
-bool FileTransferManager::parse_chunk_binary_header(const std::vector<uint8_t>& binary_data, FileChunk& chunk) {
-    const std::string magic = "FTCHUNK";
-    
-    // Check minimum size (magic header + at least some data)
-    if (binary_data.size() < magic.length()) {
-        return false;
-    }
-    
-    // Verify magic header
-    if (std::memcmp(binary_data.data(), magic.c_str(), magic.length()) != 0) {
-        return false;
-    }
-    
-    // Extract chunk data (everything after the magic header)
-    size_t data_start = magic.length();
-    size_t data_size = binary_data.size() - data_start;
-    
-    chunk.data.resize(data_size);
-    std::memcpy(chunk.data.data(), binary_data.data() + data_start, data_size);
-    
-    return true;
-}
+void FileTransferManager::maintenance_loop() {
+    while (running_.load()) {
+        {
+            std::unique_lock<std::mutex> lk(maintenance_mutex_);
+            maintenance_cv_.wait_for(lk, std::chrono::seconds(2),
+                                     [this] { return !running_.load(); });
+        }
+        if (!running_.load()) return;
 
-bool FileTransferManager::verify_chunk_checksum(const FileChunk& chunk) {
-    if (!config_.verify_checksums || chunk.checksum.empty()) {
-        return true;
-    }
-    
-    std::string calculated = calculate_chunk_checksum(chunk.data);
-    return calculated == chunk.checksum;
-}
+        auto now = std::chrono::steady_clock::now();
+        uint32_t timeout_secs = get_config().transfer_timeout_secs;
 
-void FileTransferManager::handle_file_request(const std::string& peer_id, const nlohmann::json& message) {
-    try {
-        std::string transfer_id = message["transfer_id"];
-        std::string remote_path = message["remote_path"];
-        
-        // Check if file exists and is accessible
-        if (!file_or_directory_exists(remote_path)) {
-            LOG_FILE_TRANSFER_WARN("File request denied - file not found: " << remote_path);
-            nlohmann::json response;
-            response["transfer_id"] = transfer_id;
-            response["accepted"] = false;
-            response["reason"] = "File not found or not accessible";
-            client_.send(peer_id, "file_transfer_response", response);
-            return;
+        std::vector<std::shared_ptr<Transfer>> all;
+        {
+            std::lock_guard<std::mutex> lk(transfers_mutex_);
+            for (auto& kv : transfers_) all.push_back(kv.second);
         }
-        
-        // Call user callback to approve/reject
-        if (file_request_callback_) {
-            bool accepted = file_request_callback_(peer_id, remote_path, transfer_id);
-            if (accepted) {
-                // Start file transfer
-                send_file(peer_id, remote_path);
-                LOG_FILE_TRANSFER_INFO("Accepted file request: " << remote_path << " for " << peer_id);
-            } else {
-                nlohmann::json response;
-                response["transfer_id"] = transfer_id;
-                response["accepted"] = false;
-                response["reason"] = "Request rejected by user";
-                client_.send(peer_id, "file_transfer_response", response);
-                LOG_FILE_TRANSFER_INFO("Rejected file request: " << remote_path << " for " << peer_id);
+
+        std::vector<std::shared_ptr<Transfer>> timed_out;
+        std::vector<std::string> to_purge;
+        for (auto& t : all) {
+            std::lock_guard<std::mutex> lk(t->mtx);
+            auto idle = std::chrono::duration_cast<std::chrono::seconds>(now - t->last_activity);
+            if (t->is_terminal()) {
+                if (idle > FINISHED_RETENTION) to_purge.push_back(t->id);
+            } else if (t->status != FileTransferStatus::PAUSED &&
+                       idle.count() > timeout_secs) {
+                timed_out.push_back(t);
             }
-        } else {
-            // Auto-reject if no callback is set
-            nlohmann::json response;
-            response["transfer_id"] = transfer_id;
-            response["accepted"] = false;
-            response["reason"] = "No file request handler configured";
-            client_.send(peer_id, "file_transfer_response", response);
-            LOG_FILE_TRANSFER_WARN("Auto-rejected file request - no handler: " << remote_path);
         }
-        
-    } catch (const std::exception& e) {
-        LOG_FILE_TRANSFER_ERROR("Error handling file request: " << e.what());
-    }
-}
 
-void FileTransferManager::handle_directory_request(const std::string& peer_id, const nlohmann::json& message) {
-    try {
-        std::string transfer_id = message["transfer_id"];
-        std::string remote_path = message["remote_path"];
-        bool recursive = message.value("recursive", true);
-        
-        // Check if directory exists and is accessible
-        if (!directory_exists(remote_path)) {
-            LOG_FILE_TRANSFER_WARN("Directory request denied - directory not found: " << remote_path);
-            nlohmann::json response;
-            response["transfer_id"] = transfer_id;
-            response["accepted"] = false;
-            response["reason"] = "Directory not found or not accessible";
-            client_.send(peer_id, "file_transfer_response", response);
-            return;
+        for (auto& t : timed_out) {
+            LOG_FT_WARN("Transfer " << t->id << " timed out");
+            nlohmann::json done{{"transfer_id", t->id}, {"success", false},
+                                {"error", "timed out"}};
+            client_.send(t->peer_id, MSG_COMPLETE, done);
+            finish(t, false, "timed out");
         }
-        
-        // Call user callback to approve/reject
-        if (directory_request_callback_) {
-            bool accepted = directory_request_callback_(peer_id, remote_path, recursive, transfer_id);
-            if (accepted) {
-                // Start directory transfer
-                send_directory(peer_id, remote_path, "", recursive);
-                LOG_FILE_TRANSFER_INFO("Accepted directory request: " << remote_path << " for " << peer_id);
-            } else {
-                nlohmann::json response;
-                response["transfer_id"] = transfer_id;
-                response["accepted"] = false;
-                response["reason"] = "Request rejected by user";
-                client_.send(peer_id, "file_transfer_response", response);
-                LOG_FILE_TRANSFER_INFO("Rejected directory request: " << remote_path << " for " << peer_id);
-            }
-        } else {
-            // Auto-reject if no callback is set
-            nlohmann::json response;
-            response["transfer_id"] = transfer_id;
-            response["accepted"] = false;
-            response["reason"] = "No directory request handler configured";
-            client_.send(peer_id, "file_transfer_response", response);
-            LOG_FILE_TRANSFER_WARN("Auto-rejected directory request - no handler: " << remote_path);
+        if (!to_purge.empty()) {
+            std::lock_guard<std::mutex> lk(transfers_mutex_);
+            for (auto& id : to_purge) transfers_.erase(id);
         }
-        
-    } catch (const std::exception& e) {
-        LOG_FILE_TRANSFER_ERROR("Error handling directory request: " << e.what());
     }
 }
 
+// =============================================================================
+// Utilities
+// =============================================================================
+
+std::string FileTransferManager::compute_file_sha256(const std::string& path) {
+    int64_t size = get_file_size(path.c_str());
+    if (size < 0) return "";
+    sha256_context_t ctx;
+    sha256_reset(&ctx);
+    std::vector<uint8_t> buf(64 * 1024);
+    uint64_t offset = 0;
+    uint64_t remaining = static_cast<uint64_t>(size);
+    while (remaining > 0) {
+        uint32_t want = static_cast<uint32_t>(std::min<uint64_t>(buf.size(), remaining));
+        if (!read_file_chunk(path, offset, buf.data(), want)) return "";
+        sha256_update(&ctx, buf.data(), want);
+        offset += want;
+        remaining -= want;
+    }
+    uint8_t digest[SHA256_HASH_SIZE];
+    sha256_finish(&ctx, digest);
+    return to_hex(digest, SHA256_HASH_SIZE);
+}
+
 } // namespace librats