Verify admission failure diagnostics and updated Windows release archive

crates/searchi-service/src/coordination.rs

@@ -301,6 +301,70 @@ impl EmbeddingProvider for BudgetedProvider {
 mod tests {
     use super::*;
     #[test]
+    fn failed_admission_clears_prior_worker_diagnostics_without_calling_worker() {
+        use searchi_core::metrics::MetricsMode;
+        use std::sync::atomic::{AtomicUsize, Ordering};
+        struct ObservedInvocation(Arc<AtomicUsize>);
+        impl EmbeddingProvider for ObservedInvocation {
+            fn fingerprint(&self) -> &str {
+                "scheduler-test-only"
+            }
+            fn dimensions(&self) -> usize {
+                0
+            }
+            fn split_windows(&mut self, _: &str, _: &str) -> Result<Vec<TextWindow>> {
+                unreachable!()
+            }
+            fn embed_documents(&mut self, _: &[&str], _: &str) -> Result<Vec<Vec<f32>>> {
+                unreachable!()
+            }
+            fn embed_query(&mut self, _: &str) -> Result<Vec<f32>> {
+                self.0.fetch_add(1, Ordering::SeqCst);
+                Ok(Vec::new())
+            }
+            fn embed_code_query(&mut self, query: &str) -> Result<Vec<f32>> {
+                self.embed_query(query)
+            }
+            fn query_diagnostics(&self) -> BTreeMap<String, u64> {
+                BTreeMap::from([("prior_worker_call".into(), 1)])
+            }
+        }
+        let budget = InferenceBudget::new(1);
+        // Test worker weight two without requiring particular test host hardware.
+        budget.0.state.lock().unwrap().limit = 2;
+        let calls = Arc::new(AtomicUsize::new(0));
+        let mut provider = BudgetedProvider::new(
+            Box::new(ObservedInvocation(calls.clone())),
+            &budget,
+            InferenceRole::Foreground,
+            2,
+        );
+        provider
+            .embed_query_debug("first admitted invocation")
+            .unwrap();
+        assert_eq!(calls.load(Ordering::SeqCst), 1);
+        assert_eq!(provider.query_diagnostics()["prior_worker_call"], 1);
+        assert_eq!(budget.configure(1), 1);
+        let mut trace = TraceCollector::new(MetricsMode::Debug);
+        assert!(provider
+            .embed_query_traced("rejected invocation", true, &mut trace, None)
+            .is_err());
+        assert_eq!(calls.load(Ordering::SeqCst), 1);
+        assert!(provider.query_diagnostics().is_empty());
+        let metrics = trace.finish(0);
+        let stages = metrics.trace.unwrap();
+        assert_eq!(stages.len(), 1);
+        assert_eq!(stages[0].name, "semantic.inference.admission_wait");
+        assert_eq!(stages[0].counters["failed"], 1);
+        assert_eq!(stages[0].counters["worker_threads"], 2);
+        assert!(stages[0].duration_ms >= 0.0);
+        assert!(provider.embed_code_query_debug("also rejected").is_err());
+        assert!(provider.query_diagnostics().is_empty());
+        assert_eq!(calls.load(Ordering::SeqCst), 1);
+        assert_eq!(budget.0.state.lock().unwrap().foreground, 0);
+        assert_eq!(budget.0.state.lock().unwrap().used, 0);
+    }
+    #[test]
     fn reserved_query_capacity_admits_foreground_during_background() {
         let budget = InferenceBudget::new(1);
         // Deliberately exercise a two-thread scheduler independent of CI hardware.