fixup: accept the float and zero-fraction forms cast accepts

`cast.ToBoolE` has a float branch, and `cast.ToInt64E` runs a string
through `trimZeroDecimal` before parsing it, so the Agent reads
`dogstatsd_non_local_traffic: 1.0` as true and `dogstatsd_port: "8125.0"`
as 8125. Both were rejected here.

Also collapse the Vale vocabulary entry to `deserializer(s?)` and cut the
skill section down to the rule an agent needs: fix the leaf's schema
type, never hand-write a per-key tolerant deserializer.

Author: webern

.claude/skills/config-system/SKILL.md

@@ -125,16 +125,10 @@ section rather than renaming it onto one.
 
 ## Scalar leaf coercion
 
-The Agent reads every setting by casting whatever is stored to the accessor's type (`GetBool`,
-`GetInt`, `GetString`, ...), so a leaf's permissiveness follows from its declared type, not from the
-key: `dogstatsd_port: "8125"`, or a `string`-typed leaf written as a YAML boolean, are configurations
-the Agent accepts. `datadog-agent/config/src/cast_de.rs` ports those casts, codegen attaches one to
-every scalar leaf by type (`permissivize`), and `env_decode` shares the same parsers, so every source
-accepts the same spellings. A value the cast cannot convert is a hard error rather than the Agent's
-silent zero value.
-
-Do not hand-write a per-key tolerant deserializer for a schema-typed scalar; give the coercion to the
-type instead. A generated field whose type has no classification fails the build.
+Every scalar leaf already accepts what the Agent's cast accepts (`dogstatsd_port: "8125"`, a `string`
+leaf written as a YAML boolean), because codegen attaches a `cast_de.rs` coercion per schema type.
+When a value fails to deserialize, fix the leaf's schema type; never hand-write a per-key tolerant
+deserializer.
 
 ## Saluki-only values
 

.vale/styles/config/vocabularies/technical/accept.txt

@@ -151,8 +151,7 @@ configurability
 cooldown
 crypto
 deserializable
-deserializer
-deserializers
+deserializer(s?)
 downcasted
 upcasted
 env

lib/datadog-agent/config/src/cast_de.rs

@@ -41,11 +41,20 @@ pub(crate) fn parse_bool(raw: &str) -> Result<bool, String> {
 ///
 /// Returns a message naming the value when it is not a decimal integer.
 pub(crate) fn parse_i64(raw: &str) -> Result<i64, String> {
-    raw.trim()
+    trim_zero_decimal(raw.trim())
         .parse::<i64>()
         .map_err(|_| format!("invalid integer `{raw}`"))
 }
 
+/// `cast`'s `trimZeroDecimal`, which drops an all-zero fraction before integer parsing, so `"8125.0"`
+/// is an integer setting while `"8125.5"` is not.
+fn trim_zero_decimal(raw: &str) -> &str {
+    match raw.split_once('.') {
+        Some((integer, fraction)) if !fraction.is_empty() && fraction.bytes().all(|byte| byte == b'0') => integer,
+        _ => raw,
+    }
+}
+
 /// `cast.ToFloat64E` for a string.
 ///
 /// # Errors
@@ -63,8 +72,8 @@ pub(crate) fn parse_f64(raw: &str) -> Result<f64, String> {
 ///
 /// # Errors
 ///
-/// Returns an error for a value the Agent cannot cast to a boolean: an unrecognized string, a
-/// floating-point number, or a compound value.
+/// Returns an error for a value the Agent cannot cast to a boolean: an unrecognized string or a
+/// compound value.
 pub(crate) fn deserialize_bool<'de, D>(deserializer: D) -> Result<bool, D::Error>
 where
     D: Deserializer<'de>,
@@ -128,7 +137,7 @@ impl Visitor<'_> for BoolVisitor {
     type Value = bool;
 
     fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str("a boolean, a boolean string, or an integer")
+        f.write_str("a boolean, a boolean string, or a number")
     }
 
     fn visit_bool<E: de::Error>(self, value: bool) -> Result<bool, E> {
@@ -143,6 +152,10 @@ impl Visitor<'_> for BoolVisitor {
         Ok(value != 0)
     }
 
+    fn visit_f64<E: de::Error>(self, value: f64) -> Result<bool, E> {
+        Ok(value != 0.0)
+    }
+
     fn visit_str<E: de::Error>(self, value: &str) -> Result<bool, E> {
         parse_bool(value).map_err(|_| E::invalid_value(Unexpected::Str(value), &self))
     }
@@ -359,23 +372,18 @@ mod tests {
             assert_eq!(as_bool(falsy.clone()), Ok(false), "{falsy}");
         }
 
-        // A non-zero integer is truthy, and a null reads as the zero value.
+        // Any non-zero number is truthy, and a null reads as the zero value.
         assert_eq!(as_bool(json!(2)), Ok(true));
         assert_eq!(as_bool(json!(-1)), Ok(true));
+        assert_eq!(as_bool(json!(1.0)), Ok(true));
+        assert_eq!(as_bool(json!(0.0)), Ok(false));
         assert_eq!(as_bool(json!(null)), Ok(false));
     }
 
     #[test]
     fn bool_rejects_what_go_rejects() {
-        // `strconv.ParseBool` accepts none of these, and `cast` has no float branch for a boolean.
-        for rejected in [
-            json!("yes"),
-            json!("on"),
-            json!(""),
-            json!(1.0),
-            json!([true]),
-            json!({"a": true}),
-        ] {
+        // `strconv.ParseBool` accepts none of these.
+        for rejected in [json!("yes"), json!("on"), json!(""), json!([true]), json!({"a": true})] {
             assert!(as_bool(rejected.clone()).is_err(), "{rejected}");
         }
     }
@@ -388,14 +396,27 @@ mod tests {
         assert_eq!(as_int(json!(true)), Ok(1));
         assert_eq!(as_int(json!(null)), Ok(0));
 
+        // `cast` drops an all-zero fraction from a numeric string.
+        assert_eq!(as_int(json!("8125.0")), Ok(8125));
+        assert_eq!(as_int(json!("8125.000")), Ok(8125));
+        assert_eq!(as_int(json!("-8125.0")), Ok(-8125));
+
         // Go truncates toward zero rather than rounding.
         assert_eq!(as_int(json!(10.9)), Ok(10));
         assert_eq!(as_int(json!(-10.9)), Ok(-10));
     }
 
     #[test]
     fn integer_rejects_unparseable_and_out_of_range_values() {
-        for rejected in [json!("8125ms"), json!(""), json!("0x1f"), json!(1e300), json!(["8125"])] {
+        for rejected in [
+            json!("8125ms"),
+            json!(""),
+            json!("0x1f"),
+            json!("8125.5"),
+            json!("8125."),
+            json!(1e300),
+            json!(["8125"]),
+        ] {
             assert!(as_int(rejected.clone()).is_err(), "{rejected}");
         }
     }

lib/datadog-agent/config/src/env_decode.rs

@@ -258,7 +258,8 @@ mod tests {
         assert_eq!(decode("T", EnvDecode::Bool).unwrap(), json!(true));
         assert!(decode("yes", EnvDecode::Bool).is_err());
         assert_eq!(decode("9125", EnvDecode::Integer).unwrap(), json!(9125));
-        assert!(decode("9125.0", EnvDecode::Integer).is_err());
+        assert_eq!(decode("9125.0", EnvDecode::Integer).unwrap(), json!(9125));
+        assert!(decode("9125.5", EnvDecode::Integer).is_err());
         assert_eq!(decode("1.5", EnvDecode::Float).unwrap(), json!(1.5));
     }