style(acoustic): Complete size_t -> std::size_t cleanup across all files

- Fix remaining bare 'size_t' in pipeline.cpp, gunshot_classifier.cpp,
  threat_tracker.cpp, mobile_phone_source.cpp
- All tests pass: test_core_lib 6/6, demo_offline 20/20

src/drone-software/src/acoustic/src/core/gunshot_classifier.cpp

@@ -39,20 +39,20 @@ struct GunshotClassifier::Impl {
 
         // Try simple JSON object format: {"0": "ambient", "1": "threat"}
         if (content.find('{') != std::string::npos) {
-            size_t pos = 0;
+            std::size_t pos = 0;
             while ((pos = content.find('"', pos)) != std::string::npos) {
-                size_t key_start = pos + 1;
-                size_t key_end = content.find('"', key_start);
+                std::size_t key_start = pos + 1;
+                std::size_t key_end = content.find('"', key_start);
                 if (key_end == std::string::npos) break;
                 std::string key = content.substr(key_start, key_end - key_start);
                 int idx = -1;
                 try { idx = std::stoi(key); } catch (...) {}
 
-                size_t colon = content.find(':', key_end);
+                std::size_t colon = content.find(':', key_end);
                 if (colon == std::string::npos) break;
-                size_t val_quote = content.find('"', colon);
+                std::size_t val_quote = content.find('"', colon);
                 if (val_quote == std::string::npos) break;
-                size_t val_end = content.find('"', val_quote + 1);
+                std::size_t val_end = content.find('"', val_quote + 1);
                 if (val_end == std::string::npos) break;
                 std::string label = content.substr(val_quote + 1, val_end - val_quote - 1);
 
@@ -64,9 +64,9 @@ struct GunshotClassifier::Impl {
             }
         } else {
             // Fallback: "index: label" line format
-            size_t line_start = 0;
+            std::size_t line_start = 0;
             while (line_start < content.size()) {
-                size_t line_end = content.find('\n', line_start);
+                std::size_t line_end = content.find('\n', line_start);
                 if (line_end == std::string::npos) line_end = content.size();
                 std::string line = content.substr(line_start, line_end - line_start);
                 line_start = line_end + 1;
@@ -108,7 +108,7 @@ struct GunshotClassifier::Impl {
         int wlen = MultiByteToWideChar(CP_UTF8, 0, path.c_str(), -1, nullptr, 0);
         std::wstring wpath;
         if (wlen > 0) {
-            wpath.resize(static_cast<size_t>(wlen));
+            wpath.resize(static_cast<std::size_t>(wlen));
             MultiByteToWideChar(CP_UTF8, 0, path.c_str(), -1, &wpath[0], wlen);
         }
         try {
@@ -150,7 +150,7 @@ struct GunshotClassifier::Impl {
         int n_frames = static_cast<int>(mel_spectrogram.cols());
 
         // Flatten to std::vector<float> with layout [batch, time_frames, n_mels]
-        std::vector<float> input_data(static_cast<size_t>(n_mels) * n_frames);
+        std::vector<float> input_data(static_cast<std::size_t>(n_mels) * n_frames);
         for (int t = 0; t < n_frames; ++t) {
             for (int m = 0; m < n_mels; ++m) {
                 input_data[t * n_mels + m] = mel_spectrogram(m, t);
@@ -176,27 +176,27 @@ struct GunshotClassifier::Impl {
         // Get output
         float* output_data = output_tensors.front().GetTensorMutableData<float>();
         auto output_shape = output_tensors.front().GetTensorTypeAndShapeInfo().GetShape();
-        size_t num_classes = labels.empty() ? static_cast<size_t>(output_shape.back()) : labels.size();
+        std::size_t num_classes = labels.empty() ? static_cast<std::size_t>(output_shape.back()) : labels.size();
         if (num_classes == 0) num_classes = 2;
 
         // Softmax
         std::vector<float> probs(num_classes);
         float max_val = output_data[0];
-        for (size_t i = 1; i < num_classes; ++i) {
+        for (std::size_t i = 1; i < num_classes; ++i) {
             if (output_data[i] > max_val) max_val = output_data[i];
         }
         float sum = 0.0f;
-        for (size_t i = 0; i < num_classes; ++i) {
+        for (std::size_t i = 0; i < num_classes; ++i) {
             probs[i] = std::exp(output_data[i] - max_val);
             sum += probs[i];
         }
-        for (size_t i = 0; i < num_classes; ++i) {
+        for (std::size_t i = 0; i < num_classes; ++i) {
             probs[i] /= sum;
         }
 
         // Find best
-        size_t best_idx = 0;
-        for (size_t i = 1; i < num_classes; ++i) {
+        std::size_t best_idx = 0;
+        for (std::size_t i = 1; i < num_classes; ++i) {
             if (probs[i] > probs[best_idx]) best_idx = i;
         }
 

src/drone-software/src/acoustic/src/core/pipeline.cpp

@@ -35,7 +35,7 @@ struct Pipeline::Impl {
     }
 
     void ResetModules() {
-        size_t chunk_samples = static_cast<size_t>(config.sample_rate * config.chunk_duration);
+        std::size_t chunk_samples = static_cast<std::size_t>(config.sample_rate * config.chunk_duration);
         audio_buffer = std::make_unique<AudioBuffer>(chunk_samples,
                                                      static_cast<int>(config.mic_array.num_mics));
 
@@ -71,8 +71,8 @@ struct Pipeline::Impl {
         float energy_db = 10.0f * std::log10(energy + 1e-10f);
 
         // Zero-crossing rate
-        size_t zcr = 0;
-        for (size_t i = 1; i < audio.size(); ++i) {
+        std::size_t zcr = 0;
+        for (std::size_t i = 1; i < audio.size(); ++i) {
             if ((audio[i] >= 0.0f) != (audio[i - 1] >= 0.0f)) ++zcr;
         }
         float zcr_rate = static_cast<float>(zcr) / (audio.size() - 1);
@@ -113,7 +113,7 @@ struct Pipeline::Impl {
         // Push interleaved multi-channel audio into ring buffer
         audio_buffer->Push(audio_samples);
 
-        size_t chunk_samples = static_cast<size_t>(config.sample_rate * config.chunk_duration);
+        std::size_t chunk_samples = static_cast<std::size_t>(config.sample_rate * config.chunk_duration);
 
         // VAD on first channel
         std::size_t avail = audio_buffer->Size();
@@ -136,7 +136,7 @@ struct Pipeline::Impl {
         Eigen::MatrixXf avg_mel;
         if (!mel_specs.empty()) {
             avg_mel = mel_specs[0];
-            for (size_t i = 1; i < mel_specs.size(); ++i) {
+            for (std::size_t i = 1; i < mel_specs.size(); ++i) {
                 avg_mel += mel_specs[i];
             }
             if (mel_specs.size() > 1) {
@@ -182,13 +182,13 @@ struct Pipeline::Impl {
             if (localizer && config.mic_array.num_mics >= 2) {
                 Eigen::MatrixXf audio_mat(static_cast<int>(chunk_samples),
                                           static_cast<int>(config.mic_array.num_mics));
-                for (size_t ch = 0; ch < config.mic_array.num_mics; ++ch) {
+                for (std::size_t ch = 0; ch < config.mic_array.num_mics; ++ch) {
                     std::vector<float> ch_data;
                     ch_data.reserve(latest_flat.size() / config.mic_array.num_mics);
                     for (std::size_t i = ch; i < latest_flat.size(); i += config.mic_array.num_mics) {
                         ch_data.push_back(latest_flat[i]);
                     }
-                    for (size_t i = 0; i < ch_data.size(); ++i) {
+                    for (std::size_t i = 0; i < ch_data.size(); ++i) {
                         audio_mat(static_cast<int>(i), static_cast<int>(ch)) = ch_data[i];
                     }
                 }

src/drone-software/src/acoustic/src/core/threat_tracker.cpp

@@ -45,9 +45,9 @@ std::vector<AcousticThreat> ThreatTracker::Update(
         if (track.missing_frames > max_missing_frames_) continue;
 
         float best_diff = azimuth_gate_deg_;
-        size_t best_idx = detected_threats.size();
+        std::size_t best_idx = detected_threats.size();
 
-        for (size_t d = 0; d < detected_threats.size(); ++d) {
+        for (std::size_t d = 0; d < detected_threats.size(); ++d) {
             if (det_matched[d]) continue;
             float diff = std::abs(detected_threats[d].azimuth - track.last_azimuth);
             if (diff > 180.0f) diff = 360.0f - diff;
@@ -71,7 +71,7 @@ std::vector<AcousticThreat> ThreatTracker::Update(
     }
 
     // Initialize new tracks for unmatched detections
-    for (size_t d = 0; d < detected_threats.size(); ++d) {
+    for (std::size_t d = 0; d < detected_threats.size(); ++d) {
         if (det_matched[d]) continue;
         TrackedThreat track;
         track.threat_id = GenerateId();

src/drone-software/src/acoustic/src/io/mobile_phone_source.cpp

@@ -77,9 +77,9 @@ struct MobilePhoneSource::Impl {
                                  packet_buf.size() * sizeof(float),
                                  0, reinterpret_cast<sockaddr*>(&client_addr), &addr_len);
             if (n > 0) {
-                size_t samples = static_cast<size_t>(n) / sizeof(float);
+                std::size_t samples = static_cast<std::size_t>(n) / sizeof(float);
                 std::lock_guard<std::mutex> lock(mutex_);
-                for (size_t i = 0; i < samples; ++i) {
+                for (std::size_t i = 0; i < samples; ++i) {
                     buffer_.push(packet_buf[i]);
                 }
                 cv_.notify_one();