capability_grower_configuration/

tree_expansion_policy.rs

// ---------------- [ File: capability-grower-configuration/src/tree_expansion_policy.rs ]
crate::ix!();

/// This structure is the primary enum for controlling how we choose among `Dispatch`, `Aggregate`, and
/// `LeafHolder` nodes at each level of the tree generation procedure.
///
/// Each variant indicates a strategy for determining the mechanism of choosing the node-kind.
///
/// The choice should be made to optimally configure the grower for our target domain. Different
/// domains will require different variant selections here.
///
/// It is important for the language model to determine intelligent behavior for its selection.
///
/// TODO: *here we would like to indicate some useful guidelines about how to do this successfully*.
///
#[derive(
    SaveLoad,
    Debug, 
    Clone, 
    PartialEq, 
    Serialize, 
    Deserialize, 
    AiJsonTemplateWithJustification,
    AiJsonTemplate)]
#[serde(rename_all = "snake_case")]
pub enum TreeExpansionPolicy {

    /// This strategy will always pick `Dispatch` for intermediate nodes (levels < final) and `LeafHolder` for
    /// the final level. It will ignore aggregator nodes entirely. This is the classic “enum tree until depth,
    /// then leaves at the bottom.”
    Simple,

    /// At each level, this strategy will randomly pick among aggregator/dispatch/leaf with the given weights.
    /// (It has no built-in depth constraints.)
    Weighted(

        // Consider the relative frequencies of each particular kind of node.
        WeightedNodeVariantPolicy
    ),

    /// This strategy is the same as `Weighted`, but with inline constraints like aggregator max depth, etc.
    WeightedWithLimits(

        // Consider for our target domain the likelihoods of needing a node of a particular kind at
        // this level, as well as when node kinds turn on/off within the overall flow.
        WeightedNodeVariantPolicyWithLimits
    ),

    /// This strategy will define the level at which aggregator nodes “begin,” as well as the level at which leaf nodes “begin,”
    /// with dispatch nodes used before the aggregator nodes start.
    DepthBased(

        /// Here we need to take into account the characteristics of the target domain in order to
        /// choose specifically the levels at which nodes of a particular kind *begin* and when
        /// they *end.
        DepthBasedNodeVariantPolicy
    ),

    /// This strategy will always pick aggregator except for the final level (which presumably is a leaf).
    AlwaysAggregate,

    /// This strategy will always pick dispatch nodes except for during the final level.
    AlwaysDispatch,

    /// This strategy will force every node to be a leaf, ignoring depth. Typically used for flattening or testing.
    AlwaysLeafHolder,

    /// This strategy will specify a list of “phases,” each determining weights for aggregator/dispatch/leaf generation starting at
    /// a given depth, continuing until the next phase or the end.
    Phased(
        /// Here we need to take into account how many phases are useful for our target domain and
        /// what their parameters are.
        PhasedNodeVariantPolicy
    ),

    /// This strategy uses a direct “per-level” approach via a map from `u8` (level) → aggregator/dispatch/leaf
    /// probabilities. If a level is missing, the downstream generator code will fallback or clamp to last known.
    Scripted(

        /// Here we need to take into account the target domain in order to choose relevant levels
        /// and their respective parameters
        ScriptedNodeVariantPolicy
    ),
}

impl Default for TreeExpansionPolicy {

    fn default() -> Self {
        TreeExpansionPolicy::DepthBased(Default::default())
    }
}

impl FuzzyFromJsonValue for JustifiedTreeExpansionPolicy {
    fn fuzzy_from_json_value(value: &serde_json::Value) -> Result<Self, FuzzyFromJsonValueError> {
        trace!("(JustifiedTreeExpansionPolicy) Entering fuzzy_from_json_value => {}", value);

        // 1) If null => default => Simple
        if value.is_null() {
            debug!("(JustifiedTreeExpansionPolicy) Null => returning Simple");
            return Ok(Self::Simple {
                variant_confidence: 0.0,
                variant_justification: String::new(),
            });
        }

        // 2) If string => unify => { "variant_name": "someString" }
        if let Some(s) = value.as_str() {
            let mut map = serde_json::Map::new();
            map.insert("variant_name".to_string(), serde_json::Value::String(s.to_string()));
            let wrapped = serde_json::Value::Object(map);
            return Self::fuzzy_from_json_value(&wrapped);
        }

        // 3) Must be object => flatten all 'fields'
        let mut top = match value.as_object() {
            Some(m) => {
                let mut c = m.clone();
                flatten_all_fields(&mut c);
                c
            }
            None => {
                error!("(JustifiedTreeExpansionPolicy) Not an object => fail");
                return Err(FuzzyFromJsonValueError::NotAnObject {
                    target_type: "JustifiedTreeExpansionPolicy",
                    actual: value.clone(),
                });
            }
        };

        // recognized variants
        let recognized = [
            "Simple",
            "Weighted",
            "WeightedWithLimits",
            "DepthBased",
            "AlwaysAggregate",
            "AlwaysDispatch",
            "AlwaysLeafHolder",
            "Phased",
            "Scripted",
        ];

        // find single recognized key
        let mut found_keys = Vec::new();
        for k in top.keys() {
            // normalize (remove underscores, ignore case)
            let normk = k.replace("_","").to_lowercase();
            if recognized.iter().any(|r| r.replace("_","").to_lowercase() == normk) {
                found_keys.push(k.clone());
            }
        }

        if found_keys.len() == 1 {
            let recognized_key = found_keys[0].clone();
            trace!("(JustifiedTreeExpansionPolicy) single recognized key='{}' => unify", recognized_key);
            let variant_val = top.remove(&recognized_key).unwrap_or(serde_json::Value::Null);

            // new map => { "variant_name": recognized_key, ... leftover top-level ... }
            let mut new_map = serde_json::Map::new();
            new_map.insert("variant_name".to_string(), serde_json::Value::String(recognized_key));

            // handle the variant_val if object or array
            match variant_val {
                serde_json::Value::Object(o) => {
                    // flatten
                    let mut subo = o.clone();
                    flatten_all_fields(&mut subo);
                    // merge subo
                    for (k,v) in subo.into_iter() {
                        new_map.insert(k, v);
                    }
                }
                serde_json::Value::Array(arr) => {
                    // We interpret the array in the form [ subobject, variant_conf, variant_just ] if length >= 1
                    debug!("(JustifiedTreeExpansionPolicy) single-key is an array => we'll parse [ subobject, conf, justification ] if present.");
                    if !arr.is_empty() {
                        // The first element is the subobject
                        let first = &arr[0];
                        if let Some(ob) = first.as_object() {
                            let mut subo = ob.clone();
                            flatten_all_fields(&mut subo);
                            for (kk,vv) in subo.into_iter() {
                                new_map.insert(kk, vv);
                            }
                        }
                        // 2nd element => variant_conf
                        if arr.len() > 1 {
                            if let Some(num) = arr[1].as_f64() {
                                new_map.insert("variant_confidence".to_string(), serde_json::Value::Number(serde_json::Number::from_f64(num).unwrap()));
                            }
                        }
                        // 3rd element => variant_justification
                        if arr.len() > 2 {
                            if let Some(jst) = arr[2].as_str() {
                                new_map.insert("variant_justification".to_string(), serde_json::Value::String(jst.to_string()));
                            }
                        }
                    }
                }
                other => {
                    // if it's e.g. string/number => we treat that as subobject or ignore
                    debug!("(JustifiedTreeExpansionPolicy) single recognized key => got a non-object/array => ignoring or unify minimal");
                    // we'll store it as "variant_confidence" if it's f64
                    if let Some(num) = other.as_f64() {
                        new_map.insert("variant_confidence".to_string(), serde_json::Value::Number(serde_json::Number::from_f64(num).unwrap()));
                    }
                }
            }

            // also merge leftover top-level
            for (k,v) in top.into_iter() {
                new_map.insert(k, v);
            }

            let wrapped = serde_json::Value::Object(new_map);
            return Self::fuzzy_from_json_value(&wrapped);
        }

        // if not single recognized => expect "variant_name"
        let var_name_val = match top.remove("variant_name") {
            Some(v) => v,
            None => {
                error!("(JustifiedTreeExpansionPolicy) Missing 'variant_name' => fail");
                return Err(FuzzyFromJsonValueError::MissingField {
                    field_name: "variant_name",
                    target_type: "JustifiedTreeExpansionPolicy",
                });
            }
        };
        let var_name_str = match var_name_val.as_str() {
            Some(s) => s,
            None => {
                error!("(JustifiedTreeExpansionPolicy) 'variant_name' not a string => fail => got {:?}", var_name_val);
                return Err(FuzzyFromJsonValueError::Other {
                    target_type: "JustifiedTreeExpansionPolicy",
                    detail: format!("'variant_name' must be string => got {:?}", var_name_val),
                });
            }
        };

        let v_conf = top
            .remove("variant_confidence")
            .and_then(|x| x.as_f64())
            .unwrap_or(0.0);
        let v_just = top
            .remove("variant_justification")
            .and_then(|x| x.as_str().map(|s| s.to_string()))
            .unwrap_or_default();

        trace!("(JustifiedTreeExpansionPolicy) final => variant_name='{}', conf={}, just='{}'", var_name_str, v_conf, v_just);

        // unify if there's a "field_0" array or object
        if let Some(f0_val) = top.remove("field_0") {
            // if array => parse first as object, second as conf, third as just
            if let Some(arr) = f0_val.as_array() {
                if !arr.is_empty() {
                    // first => subobject
                    if let Some(objval) = arr.get(0) {
                        if let Some(ob) = objval.as_object() {
                            let mut subo = ob.clone();
                            flatten_all_fields(&mut subo);
                            for (kk, vv) in subo.into_iter() {
                                top.insert(kk, vv);
                            }
                        }
                    }
                    // second => conf
                    if arr.len() > 1 {
                        if let Some(num) = arr[1].as_f64() {
                            top.insert("variant_confidence".to_string(), serde_json::Value::Number(serde_json::Number::from_f64(num).unwrap()));
                        }
                    }
                    // third => justification
                    if arr.len() > 2 {
                        if let Some(sjust) = arr[2].as_str() {
                            top.insert("variant_justification".to_string(), serde_json::Value::String(sjust.to_string()));
                        }
                    }
                }
            } else if let Some(ob) = f0_val.as_object() {
                let mut subo = ob.clone();
                flatten_all_fields(&mut subo);
                for (kk,vv) in subo.into_iter() {
                    top.insert(kk, vv);
                }
            }
        }

        // after that, re-check if we replaced variant_confidence or justification
        let final_conf = top.remove("variant_confidence").and_then(|x| x.as_f64()).unwrap_or(v_conf);
        let final_just = top.remove("variant_justification").and_then(|x| x.as_str().map(|s| s.to_string())).unwrap_or(v_just);

        // now match
        let canonical = var_name_str.replace("_","").to_lowercase();
        match canonical.as_str() {
            "simple" => Ok(Self::Simple {
                variant_confidence: final_conf,
                variant_justification: final_just,
            }),
            "weighted" => {
                let sub = JustifiedWeightedNodeVariantPolicy::fuzzy_from_json_value(&serde_json::Value::Object(top))?;
                Ok(Self::Weighted {
                    field_0: sub,
                    field_0_confidence: 0.0,
                    field_0_justification: String::new(),
                    variant_confidence: final_conf,
                    variant_justification: final_just,
                })
            }
            "weightedwithlimits" => {
                let sub = JustifiedWeightedNodeVariantPolicyWithLimits::fuzzy_from_json_value(&serde_json::Value::Object(top))?;
                Ok(Self::WeightedWithLimits {
                    field_0: sub,
                    field_0_confidence: 0.0,
                    field_0_justification: String::new(),
                    variant_confidence: final_conf,
                    variant_justification: final_just,
                })
            }
            "depthbased" => {
                let sub = JustifiedDepthBasedNodeVariantPolicy::fuzzy_from_json_value(&serde_json::Value::Object(top))?;
                Ok(Self::DepthBased {
                    field_0: sub,
                    field_0_confidence: 0.0,
                    field_0_justification: String::new(),
                    variant_confidence: final_conf,
                    variant_justification: final_just,
                })
            }
            "alwaysaggregate" => Ok(Self::AlwaysAggregate {
                variant_confidence: final_conf,
                variant_justification: final_just,
            }),
            "alwaysdispatch" => Ok(Self::AlwaysDispatch {
                variant_confidence: final_conf,
                variant_justification: final_just,
            }),
            "alwaysleafholder" => Ok(Self::AlwaysLeafHolder {
                variant_confidence: final_conf,
                variant_justification: final_just,
            }),
            "phased" => {
                let sub = JustifiedPhasedNodeVariantPolicy::fuzzy_from_json_value(&serde_json::Value::Object(top))?;
                Ok(Self::Phased {
                    field_0: sub,
                    field_0_confidence: 0.0,
                    field_0_justification: String::new(),
                    variant_confidence: final_conf,
                    variant_justification: final_just,
                })
            }
            "scripted" => {
                let sub = JustifiedScriptedNodeVariantPolicy::fuzzy_from_json_value(&serde_json::Value::Object(top))?;
                Ok(Self::Scripted {
                    field_0: sub,
                    field_0_confidence: 0.0,
                    field_0_justification: String::new(),
                    variant_confidence: final_conf,
                    variant_justification: final_just,
                })
            }
            other => {
                error!("(JustifiedTreeExpansionPolicy) Unknown variant='{}'", other);
                Err(FuzzyFromJsonValueError::Other {
                    target_type: "JustifiedTreeExpansionPolicy",
                    detail: format!("Unknown variant_name='{}'", var_name_str),
                })
            }
        }
    }
}

#[cfg(test)]
mod test_tree_expansion_policy {
    use super::*;

    // ------------------------------------------------------------------
    // 1) Tests verifying normal instance-based usage of serde (round-trip).
    //    These tests confirm you can serialize each variant to JSON (as data)
    //    and recover the same variant.  This is separate from AiJsonTemplate,
    //    which is purely a *type-level* reflection.
    // ------------------------------------------------------------------

    /// Round-trip a policy via `serde_json` and compare equality. 
    /// (This ensures normal instance-based serialization works.)
    fn round_trip_serde(policy: &TreeExpansionPolicy) -> TreeExpansionPolicy {
        let ser = serde_json::to_string_pretty(policy)
            .expect("Serialization must succeed");
        let de: TreeExpansionPolicy = serde_json::from_str(&ser)
            .expect("Deserialization must succeed");
        de
    }

    #[traced_test]
    fn test_serde_default_policy() {
        // The default impl chooses DepthBased(aggregator=2, leaf=4)
        let def = TreeExpansionPolicy::default();
        if let TreeExpansionPolicy::DepthBased(cfg) = &def {
            assert_eq!(*cfg.aggregator_start_level(), 2);
            assert_eq!(*cfg.leaf_start_level(), 4);
        } else {
            panic!("Default should produce a DepthBased(...) variant");
        }

        // Round-trip
        let after = round_trip_serde(&def);
        assert_eq!(after, def);
    }

    #[traced_test]
    fn test_serde_simple_variant() {
        let policy = TreeExpansionPolicy::Simple;
        let after = round_trip_serde(&policy);
        assert_eq!(after, policy);
    }

    #[traced_test]
    fn test_serde_weighted_variant() {
        let w = WeightedNodeVariantPolicyBuilder::default()
            .aggregator_weight(0.3)
            .dispatch_weight(0.4)
            .leaf_holder_weight(0.3)
            .build()
            .unwrap();
        let policy = TreeExpansionPolicy::Weighted(w);

        let after = round_trip_serde(&policy);
        assert_eq!(after, policy);
    }

    #[traced_test]
    fn test_serde_weighted_with_limits_variant() {
        let wwl = WeightedNodeVariantPolicyWithLimitsBuilder::default()
            .aggregator_weight(0.4)
            .dispatch_weight(0.4)
            .leaf_holder_weight(0.2)
            .aggregator_max_depth(Some(3))
            .leaf_min_depth(Some(2))
            .build()
            .unwrap();
        let policy = TreeExpansionPolicy::WeightedWithLimits(wwl);

        let after = round_trip_serde(&policy);
        assert_eq!(after, policy);
    }

    #[traced_test]
    fn test_serde_depth_based_variant() {
        let db = DepthBasedNodeVariantPolicyBuilder::default()
            .aggregator_start_level(1)
            .leaf_start_level(5)
            .build()
            .unwrap();
        let policy = TreeExpansionPolicy::DepthBased(db);

        let after = round_trip_serde(&policy);
        assert_eq!(after, policy);
    }

    #[traced_test]
    fn test_serde_always_aggregate_variant() {
        let policy = TreeExpansionPolicy::AlwaysAggregate;
        let after = round_trip_serde(&policy);
        assert_eq!(after, policy);
    }

    #[traced_test]
    fn test_serde_always_dispatch_variant() {
        let policy = TreeExpansionPolicy::AlwaysDispatch;
        let after = round_trip_serde(&policy);
        assert_eq!(after, policy);
    }

    #[traced_test]
    fn test_serde_always_leaf_holder_variant() {
        let policy = TreeExpansionPolicy::AlwaysLeafHolder;
        let after = round_trip_serde(&policy);
        assert_eq!(after, policy);
    }

    #[traced_test]
    fn test_serde_phased_variant() {
        let p1 = NodeVariantPhaseRangeBuilder::default()
            .start_level(0)
            .aggregator_weight(0.1)
            .dispatch_weight(0.7)
            .leaf_weight(0.2)
            .build()
            .unwrap();
        let p2 = NodeVariantPhaseRangeBuilder::default()
            .start_level(5)
            .aggregator_weight(0.4)
            .dispatch_weight(0.3)
            .leaf_weight(0.3)
            .build()
            .unwrap();

        let phased_cfg = PhasedNodeVariantPolicyBuilder::default()
            .phases(vec![p1, p2])
            .build()
            .unwrap();

        let policy = TreeExpansionPolicy::Phased(phased_cfg);

        let after = round_trip_serde(&policy);
        assert_eq!(after, policy);
    }

    #[traced_test]
    fn test_serde_scripted_variant() {
        let lvw1 = NodeVariantLevelWeightsBuilder::default()
            .aggregator_chance(0.4)
            .dispatch_chance(0.4)
            .leaf_chance(0.2)
            .build()
            .unwrap();
        let lvw2 = NodeVariantLevelWeightsBuilder::default()
            .aggregator_chance(0.1)
            .dispatch_chance(0.1)
            .leaf_chance(0.8)
            .build()
            .unwrap();

        let mut levels_map = HashMap::new();
        levels_map.insert(0_u8, lvw1);
        levels_map.insert(3_u8, lvw2);

        let scripted_cfg = ScriptedNodeVariantPolicyBuilder::default()
            .levels(levels_map)
            .build()
            .unwrap();

        let policy = TreeExpansionPolicy::Scripted(scripted_cfg);

        let after = round_trip_serde(&policy);
        assert_eq!(after, policy);
    }

    // ------------------------------------------------------------------
    // 2) AiJsonTemplate: purely *type-level* reflection. We'll call 
    //    `::<Type as AiJsonTemplate>::to_template()`, since it's a 
    //    static/associated function (no instance data).
    // ------------------------------------------------------------------

    #[traced_test]
    fn test_tree_expansion_policy_type_template() {
        // Because AiJsonTemplate is a static reflection approach, we do:
        let tpl = <TreeExpansionPolicy as AiJsonTemplate>::to_template();
        // We can do minimal checks, e.g. confirm it's an object with "type":"complex_enum" or similar
        assert!(tpl.is_object(), "Expected a JSON object for enum template");

        let root_obj = tpl.as_object().unwrap();
        // Typically for an enum with non-unit variants, your macro sets "type" = "complex_enum" 
        // or something. Let's check. This depends on your actual macro expansion.
        let typ = root_obj.get("type").and_then(|v| v.as_str()).unwrap_or("");
        assert_eq!(typ, "complex_enum", "We expect a complex enum template for TreeExpansionPolicy");
    }

    #[traced_test]
    fn test_weighted_node_variant_policy_type_template() {
        let tpl = <WeightedNodeVariantPolicy as AiJsonTemplate>::to_template();
        assert!(tpl.is_object(), "Expected a JSON object for WeightedNodeVariantPolicy template");

        // If your macro sets "type":"struct", we can check that:
        let root_obj = tpl.as_object().unwrap();
        let typ = root_obj.get("type").and_then(|v| v.as_str()).unwrap_or("");
        assert_eq!(typ, "struct", "Usually WeightedNodeVariantPolicy is treated as a struct by AiJsonTemplate");
    }

    #[traced_test]
    fn test_weighted_with_limits_policy_type_template() {
        let tpl = <WeightedNodeVariantPolicyWithLimits as AiJsonTemplate>::to_template();
        assert!(tpl.is_object());
        let root_obj = tpl.as_object().unwrap();
        let typ = root_obj.get("type").and_then(|v| v.as_str()).unwrap_or("");
        assert_eq!(typ, "struct");
    }

    #[traced_test]
    fn test_depth_based_node_variant_policy_type_template() {
        let tpl = <DepthBasedNodeVariantPolicy as AiJsonTemplate>::to_template();
        assert!(tpl.is_object());
        let root_obj = tpl.as_object().unwrap();
        let typ = root_obj.get("type").and_then(|v| v.as_str()).unwrap_or("");
        assert_eq!(typ, "struct");
    }

    #[traced_test]
    fn test_phased_node_variant_policy_type_template() {
        let tpl = <PhasedNodeVariantPolicy as AiJsonTemplate>::to_template();
        assert!(tpl.is_object());
        let root_obj = tpl.as_object().unwrap();
        let typ = root_obj.get("type").and_then(|v| v.as_str()).unwrap_or("");
        assert_eq!(typ, "struct");
    }

    #[traced_test]
    fn test_node_variant_phase_range_type_template() {
        let tpl = <NodeVariantPhaseRange as AiJsonTemplate>::to_template();
        assert!(tpl.is_object());
        let root_obj = tpl.as_object().unwrap();
        let typ = root_obj.get("type").and_then(|v| v.as_str()).unwrap_or("");
        assert_eq!(typ, "struct");
    }

    #[traced_test]
    fn test_scripted_node_variant_policy_type_template() {
        let tpl = <ScriptedNodeVariantPolicy as AiJsonTemplate>::to_template();
        assert!(tpl.is_object());
        let root_obj = tpl.as_object().unwrap();
        let typ = root_obj.get("type").and_then(|v| v.as_str()).unwrap_or("");
        assert_eq!(typ, "struct");
    }

    #[traced_test]
    fn test_node_variant_level_weights_type_template() {
        let tpl = <NodeVariantLevelWeights as AiJsonTemplate>::to_template();
        assert!(tpl.is_object());
        let root_obj = tpl.as_object().unwrap();
        let typ = root_obj.get("type").and_then(|v| v.as_str()).unwrap_or("");
        assert_eq!(typ, "struct");
    }

    // Helper to wrap a "variant_name" into a JSON object with optional subfields
    fn wrap_variant(variant_name: &str, extra: Option<serde_json::Value>) -> serde_json::Value {
        let mut base = serde_json::Map::new();
        base.insert("variant_name".to_string(), json!(variant_name));
        if let Some(obj) = extra {
            if let Some(submap) = obj.as_object() {
                for (k,v) in submap.iter() {
                    base.insert(k.clone(), v.clone());
                }
            }
        }
        json!(base)
    }

    #[test]
    fn test_null_input() {
        let input = json!(null);
        let result = JustifiedTreeExpansionPolicy::fuzzy_from_json_value(&input);
        assert!(result.is_ok(), "Should default to Simple if null");
        let pol = result.unwrap();
        match pol {
            JustifiedTreeExpansionPolicy::Simple { .. } => { /* pass */ },
            other => panic!("Expected Simple, got {:?}", other),
        }
    }

    #[test]
    fn test_bare_string_simple() {
        // "Simple" => unify => parse => expect JustifiedTreeExpansionPolicy::Simple
        let input = json!("Simple");
        let result = JustifiedTreeExpansionPolicy::fuzzy_from_json_value(&input);
        assert!(result.is_ok(), "Bare string 'Simple' must parse OK");
        let pol = result.unwrap();
        matches!(pol, JustifiedTreeExpansionPolicy::Simple {..});
    }

    #[test]
    fn test_camel_case_weighted_with_limits() {
        // "WeightedWithLimits" => normalized => "weighted_with_limits"
        let input = wrap_variant("WeightedWithLimits", None);
        let result = JustifiedTreeExpansionPolicy::fuzzy_from_json_value(&input);
        assert!(result.is_ok(), "CamelCase WeightedWithLimits must parse OK");
        let pol = result.unwrap();
        if let JustifiedTreeExpansionPolicy::WeightedWithLimits { .. } = pol {
            // success
        } else {
            panic!("Expected WeightedWithLimits variant, got {:?}", pol);
        }
    }

    #[test]
    fn test_pascal_case_depth_based() {
        // "DepthBased" => normalized => "depth_based"
        let input = wrap_variant("DepthBased", None);
        let result = JustifiedTreeExpansionPolicy::fuzzy_from_json_value(&input);
        assert!(result.is_ok(), "CamelCase DepthBased must parse OK");
        let pol = result.unwrap();
        if let JustifiedTreeExpansionPolicy::DepthBased {..} = pol {
            // success
        } else {
            panic!("Expected DepthBased variant, got {:?}", pol);
        }
    }

    #[test]
    fn test_upper_snake_always_leaf_holder() {
        // "ALWAYS_LEAF_HOLDER" => normalized => "always_leaf_holder"
        let input = wrap_variant("ALWAYS_LEAF_HOLDER", None);
        let result = JustifiedTreeExpansionPolicy::fuzzy_from_json_value(&input);
        assert!(result.is_ok(), "UPPER_SNAKE => always_leaf_holder");
        let pol = result.unwrap();
        if let JustifiedTreeExpansionPolicy::AlwaysLeafHolder {..} = pol {
            // success
        } else {
            panic!("Expected AlwaysLeafHolder variant, got {:?}", pol);
        }
    }

    #[test]
    fn test_single_key_object_scripted() {
        // Single-key form:
        // {
        //   "Scripted": {
        //       "some_subfield": ...
        //   }
        // }
        let input = json!({
            "Scripted": {
                "some_random_field": 123
            }
        });
        let result = JustifiedTreeExpansionPolicy::fuzzy_from_json_value(&input);
        assert!(result.is_ok(), "Single-key object 'Scripted' must parse OK");
        let pol = result.unwrap();
        if let JustifiedTreeExpansionPolicy::Scripted { field_0, .. } = pol {
            // success, though we haven't tested subfields in detail.
            
            // Justified -> normal type
            // let normal = field_0.into(); 
            
            // or do something with it
        } else {
            panic!("Expected Scripted variant, got {:?}", pol);
        }
    }

    #[test]
    fn test_unknown_variant() {
        let input = wrap_variant("MadeUpStuff", None);
        let result = JustifiedTreeExpansionPolicy::fuzzy_from_json_value(&input);
        assert!(result.is_err(), "Should fail for unknown variant");
    }

    #[traced_test]
    fn test_real_snippet_can_parse() {
        // Here's the actual JSON snippet you provided, embedded in a raw string.
        // (You can omit or shorten it if needed, but below we show it in full.)
        let raw_json = r#"
        {
          "fields": {
              "aggregator_depth_limit": 3,
              "aggregator_depth_limit_confidence": 0.8,
              "aggregator_depth_limit_justification": "Aggregator nodes should group high-level categories in the early levels. Limiting them to level 3 ensures deeper layers focus on more direct dispatch or leaf nodes, which suits the broad yet progressively specialized domain of natural-movement.",
              "aggregator_preference": 0.4,
              "aggregator_preference_confidence": 0.85,
              "aggregator_preference_justification": "A moderate preference for aggregator nodes accommodates conceptual grouping without overshadowing dispatch nodes, aligning with the multi-environment nature of natural-movement.",
              "ai_confidence": {
                  "fields": {
                      "base_factor": 1.2,
                      "base_factor_confidence": 0.95,
                      "base_factor_justification": "We introduce a moderate positive offset when the AI is confident, allowing more sub-branches and deeper exploration where clarity is high.",
                      "factor_multiplier": 0.4,
                      "factor_multiplier_confidence": 0.8,
                      "factor_multiplier_justification": "We scale expansions proportionally to confidence at a moderate level, ensuring that higher certainty fosters richer branching."
                  },
                  "has_justification": true,
                  "struct_docs": " This struct should define how AI confidence modifies branching factor:\n\n If present, we interpret these fields to scale or reduce the final branch factor based on AI's\n certainty.\n",
                  "struct_name": "AiTreeBranchingConfidenceConfiguration",
                  "type": "struct"
              },
              "ai_confidence_confidence": 0.9,
              "ai_confidence_justification": "We enable AI-driven scaling of branching to harness domain knowledge, supporting deeper expansions when clarity around sub-environments (forest, cave, etc.) is high.",
              "allow_early_leaves": true,
              "allow_early_leaves_confidence": 0.9,
              "allow_early_leaves_justification": "Some sub-branches may be straightforward and conclude early, reflecting simpler movements that do not require many nested subdivisions.",
              "balance_symmetry": 0.6,
              "balance_symmetry_confidence": 0.7,
              "balance_symmetry_justification": "A moderately balanced tree highlights uniform coverage of skills while still allowing variation for the diverse sub-environments.",
              "breadth": 9,
              "breadth_confidence": 0.9,
              "breadth_justification": "The domain covers various natural terrain and movement modalities, so we choose a broad branching factor to capture diversity within each level.",
              "capstone": {
                  "fields": {
                      "mode": {
                          "variant_name": "Probabilistic",
                          "variant_confidence": 0.8,
                          "variant_justification": "Some leaves stand out as apex skills in natural movement, but not necessarily just one or none. Probability-based capstones fit well.",
                          "variant_docs": " This variant designates a fraction of leaves as highlight/capstones."
                      },
                      "mode_confidence": 0.8,
                      "mode_justification": "We occasionally designate certain high-level endpoints to highlight advanced or pinnacle movement skills.",
                      "probability": 0.15,
                      "probability_confidence": 0.7,
                      "probability_justification": "A moderate fraction of leaves can be elevated to capstone status to represent specialized or top-tier competencies."
                  },
                  "has_justification": true,
                  "struct_docs": " In the context of our tree-generation system, a capstone node is a special type of leaf node\n that represents a culminating skill, concept, or endpoint of a hierarchical branch. \n\n Capstone nodes stand out clearly as a final, specialized mastery points—often signifying an advanced,\n important, or unique skill within a skill-tree.\n\n This struct merges the chosen capstone mode with its relevant probability (if any).\n",
                  "struct_name": "CapstoneGenerationConfiguration",
                  "type": "struct"
              },
              "capstone_confidence": 0.9,
              "capstone_justification": "Natural-movement includes a few exceptionally advanced endpoints. This approach ensures those highlights are integrated.",
              "complexity": {
                  "variant_name": "Complex",
                  "variant_confidence": 0.85,
                  "variant_justification": "The numerous sub-environments and potential overlap with neighbors (e.g. forest-orienteering, river-crossing) warrant in-depth structures.",
                  "variant_docs": " This variant indicates a highly detailed, more complex approach."
              },
              "complexity_confidence": 0.85,
              "complexity_justification": "We want to capture the broad variety of movement and adaptability across different terrains and conditions.",
              "density": 10,
              "density_confidence": 0.8,
              "density_justification": "Each leaf node should describe multiple specific variations or techniques, reflecting the richness of natural movement at its endpoint.",
              "depth": 7,
              "depth_confidence": 0.9,
              "depth_justification": "A deeper hierarchy is vital to capture fundamental through advanced practices in varied terrains, providing ample layering of complexity.",
              "dispatch_depth_limit": 6,
              "dispatch_depth_limit_confidence": 0.8,
              "dispatch_depth_limit_justification": "This ensures that dispatch nodes primarily exist in mid-layers, reserving the deepest layer for leaf finalization of specialized skill sets.",
              "leaf_granularity": 0.7,
              "leaf_granularity_confidence": 0.8,
              "leaf_granularity_justification": "Leaves describe fairly detailed aspects of movement, though not to an extreme, preserving usability and avoiding excessive minutiae.",
              "leaf_min_depth": 5,
              "leaf_min_depth_confidence": 0.8,
              "leaf_min_depth_justification": "We enforce deeper expansions (levels < 5) before concluding with leaves, allowing intermediate branches for broad skill subdivisions.",
              "level_skipping": {
                  "fields": {
                      "leaf_probability_per_level": [
                          0,
                          0,
                          0.05,
                          0.1,
                          0.15,
                          0.25,
                          0.4
                      ],
                      "leaf_probability_per_level_confidence": 0.7,
                      "leaf_probability_per_level_justification": "At upper layers, it is uncommon to finalize too soon, but deeper levels see increased likelihood of culminating branches where specialized skills appear."
                  },
                  "has_justification": true,
                  "struct_docs": " This struct should define how you skip certain levels early, turning them into leaves based on probabilities.",
                  "struct_name": "LevelSkippingConfiguration",
                  "type": "struct"
              },
              "level_skipping_confidence": 0.75,
              "level_skipping_justification": "We allow a controlled chance of early termination to reflect straightforward or quickly mastered subdomains.",
              "level_specific": null,
              "level_specific_confidence": 0,
              "level_specific_justification": "A uniform configuration across levels is sufficient given the other constraints, so no per-level overrides are necessary.",
              "ordering": {
                  "variant_name": "DifficultyAscending",
                  "variant_confidence": 0.75,
                  "variant_justification": "Natural movement fundamentals appear first, with more advanced concepts introduced later.",
                  "variant_docs": " This variant starts with simpler branches first, advanced last."
              },
              "ordering_confidence": 0.75,
              "ordering_justification": "This approach clarifies progression for learners beginning with basic techniques.",
              "partial_subbranch_probability": 0.8,
              "partial_subbranch_probability_confidence": 0.9,
              "partial_subbranch_probability_justification": "We include most branches to capture variety but exclude some less critical or niche expansions, preventing unnecessary overlap.",
              "tree_expansion_policy": {
                  "variant_name": "WeightedWithLimits",
                  "variant_confidence": 0.95,
                  "variant_justification": "A weighted approach with depth constraints ensures aggregator usage early, dispatch in mid-layers, and leaf finalization at deeper levels. This matches the layered and structured growth needed for natural-movement.",
                  "variant_docs": " This strategy is the same as `Weighted`, but with inline constraints like aggregator max depth, etc.",
                  "fields": {
                      "field_0": {
                          "fields": {
                              "aggregator_max_depth": 3,
                              "aggregator_max_depth_confidence": 0.9,
                              "aggregator_max_depth_justification": "Aggregators group broad skill sets in early levels, after which dispatch takes over more specialized subdividing.",
                              "aggregator_weight": 0.3,
                              "aggregator_weight_confidence": 0.75,
                              "aggregator_weight_justification": "Aggregator nodes appear but are not dominant, allowing for some conceptual bundling.",
                              "dispatch_max_depth": 6,
                              "dispatch_max_depth_confidence": 0.9,
                              "dispatch_max_depth_justification": "Dispatch nodes persist through intermediate layers but do not appear at the deepest level, ensuring leaves finalize advanced skills.",
                              "dispatch_weight": 0.5,
                              "dispatch_weight_confidence": 0.8,
                              "dispatch_weight_justification": "Dispatch is the primary node type for mid-layer expansions, suiting the domain’s subdivided movement styles.",
                              "leaf_holder_weight": 0.2,
                              "leaf_holder_weight_confidence": 0.7,
                              "leaf_holder_weight_justification": "While finalization is critical, we still emphasize structuring sub-branches before reaching the leaf level.",
                              "leaf_min_depth": 5,
                              "leaf_min_depth_confidence": 0.9,
                              "leaf_min_depth_justification": "We restrict leaves to deeper levels so intermediate expansions can thoroughly elaborate skill subsets."
                          },
                          "has_justification": true,
                          "struct_docs": " This policy is the same as Weighted, but with built-in depth constraints to forbid aggregator or\n dispatch nodes beyond a certain depth. We can use it to forbid leaves before a certain depth.",
                          "struct_name": "WeightedNodeVariantPolicyWithLimits",
                          "type": "struct"
                      },
                      "field_0_confidence": 0.95,
                      "field_0_justification": "We tailor the probability distribution to reflect structured branching from general movement categories down to specific advanced leaves."
                  }
              },
              "tree_expansion_policy_confidence": 0.95,
              "tree_expansion_policy_justification": "Weighted distribution, restricted by level, fits the layered complexity and ensures a coherent shift from broad to specialized concepts.",
              "weighted_branching": {
                  "fields": {
                      "mean": 9,
                      "mean_confidence": 0.85,
                      "mean_justification": "We want an average branching factor near our base breadth, ensuring consistency with the overall tree design.",
                      "variance": 3,
                      "variance_confidence": 0.8,
                      "variance_justification": "We allow moderate variability around the mean, simulating natural complexity and preventing uniform branching at every node."
                  },
                  "has_justification": true,
                  "struct_docs": " This struct should define a **mean ± variance** approach for branching factor,\n letting you generate more **natural/organic** trees rather than uniform child counts.",
                  "struct_name": "WeightedBranchingConfiguration",
                  "type": "struct"
              },
              "weighted_branching_confidence": 0.8,
              "weighted_branching_justification": "Natural movement often involves organic, uneven expansions; a mean-variance approach to branching factor aligns with this domain."
          },
          "has_justification": true,
          "struct_docs": " We set the GrowerTreeConfiguration to refine the shape of our model trees:\n - **Depth**: # of hierarchical levels (≥1)\n - **Breadth**: baseline sibling count (≥1)\n - **Density**: variants at leaves (≥1)\n - **leaf_granularity**: fraction [0..1] controlling fine detail at leaves\n - **balance_symmetry**: fraction [0..1] controlling symmetrical vs. varied structure\n - **complexity**: overall complexity level (simple, balanced, or complex)\n\n Optional advanced sub-structs:\n - **level_specific**: arrays of breadth/density overrides for each level\n - **weighted_branching**: mean ± variance approach\n - **level_skipping**: per-level leaf probabilities\n - **capstone**: highlight nodes (off, single, or fraction)\n - **ordering**: sub-branch sorting approach\n - **ai_confidence**: modifies branch factor based on AI certainty\n\n New fields:\n - **aggregator_preference**: fraction [0..1] controlling how often aggregator is used vs. dispatch\n - **allow_early_leaves**: if true, allows leaf nodes to appear before the final depth\n - **partial_subbranch_probability**: fraction [0..1] controlling how often each child sub-branch is included\n - **tree_expansion_policy**: advanced logic for picking among aggregator/dispatch/leaf\n - **aggregator_depth_limit**, **dispatch_depth_limit**, **leaf_min_depth**: optional constraints on usage of aggregator, dispatch, or leaf nodes by depth\n\n Your justification must indicate why each justified parameter value was chosen deliberately by\n using knowledge and an understanding of the target domain as a guide. Since each target domain\n is different, the trees which map them will have different shapes and different\n GrowerTreeConfiguration parameters. Your job during justification is to explain clearly why\n a given parameter setting makes sense in the provided target domain.",
          "struct_name": "GrowerTreeConfiguration",
          "type": "struct"
        }
        "#;

        // 1) Parse it as serde_json::Value
        let parsed_value: JsonValue = serde_json::from_str(raw_json)
            .expect("JSON must be valid syntax");

        // 2) Attempt fuzzy parse
        let result = JustifiedGrowerTreeConfiguration::fuzzy_from_json_value(&parsed_value);

        // 3) Check success
        assert!(
            result.is_ok(),
            "Real snippet should parse successfully, got error: {:?}",
            result.err()
        );
        let jcfg = result.unwrap();

        // 4) Optional: Inspect `jcfg.tree_expansion_policy` to confirm we got WeightedWithLimits
        match jcfg.tree_expansion_policy() {
            JustifiedTreeExpansionPolicy::WeightedWithLimits { field_0, .. } => {
                info!("Got WeightedWithLimits as intended!");
                // You could do additional checks on aggregator_weight, etc.
                assert_eq!(*field_0.leaf_holder_weight(), 0.2, "should match snippet");
            }
            other => {
                panic!("Expected WeightedWithLimits from real snippet, got {:?}", other);
            }
        }

        // 5) If we want, we can do further checks on jcfg.ai_confidence, jcfg.depth, etc.
        assert_eq!(*jcfg.depth(), 7, "Should parse depth=7 from snippet");
        assert!((jcfg.ai_confidence().as_ref().unwrap().factor_multiplier() - 0.4).abs() < 1e-6);
    }

    #[traced_test]
    async fn test_parse_null() {
        trace!("Entering test_parse_null");
        let val = serde_json::Value::Null;
        let parsed = JustifiedTreeExpansionPolicy::fuzzy_from_json_value(&val);
        match parsed {
            Ok(variant) => {
                info!("Parsed variant: {:?}", variant);
                // By default, null => Simple variant
                assert!(matches!(variant, JustifiedTreeExpansionPolicy::Simple { .. }));
            }
            Err(e) => {
                error!("Should not fail on null => got error: {:?}", e);
                panic!("test_parse_null failed => expected Ok, got Err");
            }
        }
        trace!("Exiting test_parse_null");
    }

    #[traced_test]
    async fn test_parse_as_string_simple() {
        trace!("Entering test_parse_as_string_simple");
        let val = serde_json::Value::String("Simple".to_string());
        let parsed = JustifiedTreeExpansionPolicy::fuzzy_from_json_value(&val);
        match parsed {
            Ok(variant) => {
                debug!("Parsed variant as string => {:?}", variant);
                assert!(matches!(variant, JustifiedTreeExpansionPolicy::Simple { .. }));
            }
            Err(e) => {
                error!("Should have parsed 'Simple' => got error: {:?}", e);
                panic!("test_parse_as_string_simple failed => expected Ok, got Err");
            }
        }
        trace!("Exiting test_parse_as_string_simple");
    }

    #[traced_test]
    async fn test_parse_as_string_unrecognized() {
        trace!("Entering test_parse_as_string_unrecognized");
        let val = serde_json::Value::String("NotARealVariant".to_string());
        let parsed = JustifiedTreeExpansionPolicy::fuzzy_from_json_value(&val);
        match parsed {
            Ok(variant) => {
                error!("Unexpectedly parsed variant: {:?}", variant);
                panic!("test_parse_as_string_unrecognized failed => expected Err, got Ok");
            }
            Err(e) => {
                info!("Got expected error for unrecognized variant => {:?}", e);
                // We expect an error because the variant is unknown
            }
        }
        trace!("Exiting test_parse_as_string_unrecognized");
    }

    #[traced_test]
    async fn test_parse_missing_variant_name() {
        trace!("Entering test_parse_missing_variant_name");
        // No recognized variant key, no "variant_name"
        let val = json!({"some_key": true});
        let parsed = JustifiedTreeExpansionPolicy::fuzzy_from_json_value(&val);
        match parsed {
            Ok(variant) => {
                error!("Unexpectedly parsed => {:?}", variant);
                panic!("test_parse_missing_variant_name failed => expected Err, got Ok");
            }
            Err(e) => {
                info!("Got expected error => {:?}", e);
                // Missing 'variant_name' => FuzzyFromJsonValueError::MissingField
            }
        }
        trace!("Exiting test_parse_missing_variant_name");
    }

    #[traced_test]
    async fn test_parse_single_variant_key_always_dispatch() {
        trace!("Entering test_parse_single_variant_key_always_dispatch");
        // shape => { "AlwaysDispatch": { "variant_confidence":0.95, ... }, "other_info": 123 }
        let val = json!({
            "AlwaysDispatch": {
                "variant_confidence": 0.95,
                "variant_justification": "Direct dispatch usage"
            },
            "some_other_field": 123
        });
        let parsed = JustifiedTreeExpansionPolicy::fuzzy_from_json_value(&val);
        match parsed {
            Ok(variant) => {
                debug!("Parsed single-key variant => {:?}", variant);
                assert!(matches!(variant, JustifiedTreeExpansionPolicy::AlwaysDispatch { .. }));
            }
            Err(e) => {
                error!("Expected success => got error: {:?}", e);
                panic!("test_parse_single_variant_key_always_dispatch => expected Ok, got Err");
            }
        }
        trace!("Exiting test_parse_single_variant_key_always_dispatch");
    }

    #[traced_test]
    async fn test_parse_depth_based_object() {
        trace!("Entering test_parse_depth_based_object");
        // shape => { "variant_name": "DepthBased", "aggregator_start_level": 2, ... }
        let val = json!({
            "variant_name": "DepthBased",
            "aggregator_start_level": 2,
            "leaf_start_level": 5
        });
        let parsed = JustifiedTreeExpansionPolicy::fuzzy_from_json_value(&val);
        match parsed {
            Ok(variant) => {
                debug!("Parsed DepthBased => {:?}", variant);
                if let JustifiedTreeExpansionPolicy::DepthBased { field_0, .. } = variant {
                    assert_eq!(*field_0.aggregator_start_level(), 2);
                    assert_eq!(*field_0.leaf_start_level(), 5);
                } else {
                    panic!("Expected DepthBased => got {:?}", variant);
                }
            }
            Err(e) => {
                error!("Expected success => got error: {:?}", e);
                panic!("test_parse_depth_based_object => expected Ok, got Err");
            }
        }
        trace!("Exiting test_parse_depth_based_object");
    }

    #[traced_test]
    async fn test_parse_phased() {
        trace!("Entering test_parse_phased");
        // shape => { "Phased": { "phases": [ { "start_level": 0, "aggregator_weight":1.0 }, ... ] }, "variant_confidence":0.8 }
        let val = json!({
            "Phased": {
                "phases": [
                    { "start_level": 0, "aggregator_weight": 1.0, "dispatch_weight": 0.0, "leaf_weight": 0.0 }
                ]
            },
            "variant_confidence": 0.8
        });
        let parsed = JustifiedTreeExpansionPolicy::fuzzy_from_json_value(&val);
        match parsed {
            Ok(variant) => {
                info!("Parsed phased => {:?}", variant);
                if let JustifiedTreeExpansionPolicy::Phased { field_0, variant_confidence, .. } = variant {
                    assert_eq!(variant_confidence, 0.8);
                    assert_eq!(field_0.phases().len(), 1);
                    assert_eq!(*field_0.phases()[0].aggregator_weight(), 1.0);
                } else {
                    panic!("Expected Phased => got {:?}", variant);
                }
            }
            Err(e) => {
                error!("Expected success => got error: {:?}", e);
                panic!("test_parse_phased => expected Ok, got Err");
            }
        }
        trace!("Exiting test_parse_phased");
    }

    #[traced_test]
    async fn test_parse_real_json_snippet() {
        trace!("Entering test_parse_real_json_snippet");
        // The JSON snippet the user specifically gave us that was failing earlier
        let snippet = r#"
        {
          "DepthBased": {
              "field_0": {
                  "aggregator_start_level": 2,
                  "aggregator_start_level_confidence": 0.8,
                  "aggregator_start_level_justification": "Aggregator usage begins at level 2 to consolidate intermediate techniques of fire-environment-qigong.",
                  "leaf_start_level": 5,
                  "leaf_start_level_confidence": 0.9,
                  "leaf_start_level_justification": "Leaves begin at level 5, ensuring enough aggregator expansions before final specialized nodes."
              },
              "field_0_confidence": 0.8,
              "field_0_justification": "This structured approach fosters progressive complexity and a clear delineation between preliminary, aggregated, and final specialized nodes."
          },
          "variant_confidence": 0.9,
          "variant_justification": "A depth-based approach cleanly partitions the tree into early dispatch, mid aggregator, and final leaf expansions, fitting a layered qigong system."
        }
        "#;
        let json_val: serde_json::Value = serde_json::from_str(snippet)
            .expect("Real snippet must be valid JSON");
        let parsed = JustifiedTreeExpansionPolicy::fuzzy_from_json_value(&json_val);
        match parsed {
            Ok(variant) => {
                info!("Successfully parsed real snippet => {:?}", variant);
                if let JustifiedTreeExpansionPolicy::DepthBased { field_0, variant_confidence, variant_justification, .. } = variant {
                    debug!("DepthBased subfields => aggregator_start_level={}, leaf_start_level={}",
                           field_0.aggregator_start_level(), field_0.leaf_start_level());
                    assert_eq!(variant_confidence, 0.9);
                    assert!(variant_justification.contains("cleanly partitions the tree"));
                    assert_eq!(*field_0.aggregator_start_level(), 2);
                    assert_eq!(*field_0.leaf_start_level(), 5);
                } else {
                    panic!("Expected DepthBased variant => got {:?}", variant);
                }
            }
            Err(e) => {
                error!("Failed to parse the real JSON snippet => {:?}", e);
                panic!("test_parse_real_json_snippet => expected Ok, got Err");
            }
        }
        trace!("Exiting test_parse_real_json_snippet");
    }

    ////////////////////////////////////////////////////////////////////////
    // 1) Testing Single-Key Object Form for ConfigurationComplexity
    ////////////////////////////////////////////////////////////////////////

    #[test]
    fn test_single_key_complexity_balanced() {
        // JSON: { "Balanced": { "variant_confidence": 0.88, "variant_justification": "Reason" } }
        let input = json!({
            "Balanced": {
                "variant_confidence": 0.88,
                "variant_justification": "We want a balanced approach"
            }
        });
        let parsed = JustifiedConfigurationComplexity::fuzzy_from_json_value(&input);
        assert!(
            parsed.is_ok(),
            "Expected Balanced variant single-key parse => got error: {:?}",
            parsed.err()
        );
        let c = parsed.unwrap();
        match c {
            JustifiedConfigurationComplexity::Balanced {
                variant_confidence,
                variant_justification,
            } => {
                assert!((variant_confidence - 0.88).abs() < 1e-6);
                assert_eq!(
                    variant_justification,
                    "We want a balanced approach"
                );
            }
            other => panic!("Expected Balanced => got {:?}", other),
        }
    }

    #[test]
    fn test_single_key_complexity_simple_empty_obj() {
        // JSON: { "Simple": {} }
        let input = json!({ "Simple": {} });
        let parsed = JustifiedConfigurationComplexity::fuzzy_from_json_value(&input);
        assert!(
            parsed.is_ok(),
            "Expected single-key object => 'Simple': got error: {:?}",
            parsed.err()
        );
        let c = parsed.unwrap();
        match c {
            JustifiedConfigurationComplexity::Simple { variant_confidence, variant_justification } => {
                assert_eq!(variant_confidence, 0.0);
                assert!(variant_justification.is_empty());
            }
            other => panic!("Expected Simple => got {:?}", other),
        }
    }

    #[test]
    fn test_single_key_complexity_unknown() {
        // JSON: { "FooBar": {} }
        // Should fail because "FooBar" is not recognized (Simple,Balanced,Complex).
        let input = json!({ "FooBar": {} });
        let parsed = JustifiedConfigurationComplexity::fuzzy_from_json_value(&input);
        assert!(
            parsed.is_err(),
            "Expected error for unknown single-key complexity, got Ok: {:?}",
            parsed.ok()
        );
    }

    ////////////////////////////////////////////////////////////////////////
    // 2) Testing Single-Key Object Form for CapstoneMode
    ////////////////////////////////////////////////////////////////////////

    #[test]
    fn test_single_key_capstone_single() {
        // JSON: { "Single": {} }
        let input = json!({ 
            "Single": { 
                "variant_confidence": 0.92, 
                "variant_justification": "Only one capstone leaf needed"
            } 
        });
        let parsed = JustifiedCapstoneMode::fuzzy_from_json_value(&input);
        assert!(parsed.is_ok(), "Failed to parse single-key 'Single'");
        let mode = parsed.unwrap();
        match mode {
            JustifiedCapstoneMode::Single { variant_confidence, variant_justification } => {
                assert!((variant_confidence - 0.92).abs() < 1e-6);
                assert_eq!(variant_justification, "Only one capstone leaf needed");
            }
            _ => panic!("Expected Single capstone variant"),
        }
    }

    #[test]
    fn test_single_key_capstone_probabilistic_empty_obj() {
        // JSON: { "Probabilistic": {} }
        // no variant_confidence => default 0
        let input = json!({ "Probabilistic": {} });
        let parsed = JustifiedCapstoneMode::fuzzy_from_json_value(&input);
        assert!(parsed.is_ok(), "single-key 'Probabilistic': got error: {:?}", parsed.err());
        let mode = parsed.unwrap();
        match mode {
            JustifiedCapstoneMode::Probabilistic {
                variant_confidence, variant_justification
            } => {
                assert_eq!(variant_confidence, 0.0);
                assert_eq!(variant_justification, "");
            }
            other => panic!("Expected Probabilistic => got {:?}", other),
        }
    }

    #[test]
    fn test_single_key_capstone_off_with_fields() {
        // JSON: { "Off": { "variant_confidence": 0.5, "variant_justification": "No capstones" } }
        let input = json!({
            "Off": {
                "variant_confidence": 0.5,
                "variant_justification": "No capstones"
            }
        });
        let parsed = JustifiedCapstoneMode::fuzzy_from_json_value(&input);
        assert!(parsed.is_ok(), "Expected 'Off' => got error: {:?}", parsed.err());
        let mode = parsed.unwrap();
        match mode {
            JustifiedCapstoneMode::Off { variant_confidence, variant_justification } => {
                assert!((variant_confidence - 0.5).abs() < 1e-6);
                assert_eq!(variant_justification, "No capstones");
            }
            other => panic!("Expected Off => got {:?}", other),
        }
    }

    ////////////////////////////////////////////////////////////////////////
    // 3) Testing Array-Based Single Recognized Key for TreeExpansionPolicy
    ////////////////////////////////////////////////////////////////////////
    //    e.g.: "WeightedWithLimits": [
    //      { "aggregator_weight": 0.3, ... },
    //      0.9,
    //      "We use WeightedWithLimits for reason..."
    //    ]
    ////////////////////////////////////////////////////////////////////////

    #[test]
    fn test_array_form_weighted_with_limits_full() {
        // shape => {
        //   "WeightedWithLimits": [
        //       { "aggregator_weight":0.3, "dispatch_weight":0.5, "leaf_holder_weight":0.2 },
        //       0.9,
        //       "Balanced approach with depth constraints"
        //   ]
        // }
        let input = json!({
            "WeightedWithLimits": [
                {
                    "aggregator_weight": 0.3,
                    "dispatch_weight": 0.5,
                    "leaf_holder_weight": 0.2,
                    "aggregator_max_depth": 3
                },
                0.9,
                "Balanced approach with depth constraints"
            ]
        });
        let parsed = JustifiedTreeExpansionPolicy::fuzzy_from_json_value(&input);
        assert!(parsed.is_ok(), "Expected WeightedWithLimits array form => got error: {:?}", parsed.err());
        let pol = parsed.unwrap();
        match pol {
            JustifiedTreeExpansionPolicy::WeightedWithLimits {
                field_0,
                variant_confidence,
                variant_justification,
                ..
            } => {
                assert!((variant_confidence - 0.9).abs() < 1e-6);
                assert_eq!(
                    variant_justification,
                    "Balanced approach with depth constraints"
                );
                assert_eq!(*field_0.aggregator_weight(), 0.3);
                assert_eq!(*field_0.dispatch_weight(), 0.5);
                assert_eq!(*field_0.leaf_holder_weight(), 0.2);
                assert_eq!(*field_0.aggregator_max_depth(), Some(3));
            }
            other => panic!("Expected WeightedWithLimits => got {:?}", other),
        }
    }

    #[test]
    fn test_array_form_weighted_conf_only() {
        // shape => { "Weighted": [ { aggregator_weight:0.4, dispatch_weight:0.3, leaf_holder_weight:0.3 }, 0.75 ] }
        // no justification
        let input = json!({
            "Weighted": [
                {
                    "aggregator_weight": 0.4,
                    "dispatch_weight": 0.3,
                    "leaf_holder_weight": 0.3
                },
                0.75
            ]
        });
        let parsed = JustifiedTreeExpansionPolicy::fuzzy_from_json_value(&input);
        assert!(parsed.is_ok(), "Expected Weighted => got error: {:?}", parsed.err());
        let pol = parsed.unwrap();
        match pol {
            JustifiedTreeExpansionPolicy::Weighted {
                variant_confidence,
                variant_justification,
                field_0,
                ..
            } => {
                assert!((variant_confidence - 0.75).abs() < 1e-6);
                assert!(variant_justification.is_empty());
                assert_eq!(*field_0.aggregator_weight(), 0.4);
                assert_eq!(*field_0.dispatch_weight(), 0.3);
                assert_eq!(*field_0.leaf_holder_weight(), 0.3);
            }
            other => panic!("Expected Weighted => got {:?}", other),
        }
    }

    #[test]
    fn test_array_form_weighted_unknown_third_element() {
        // shape => { "Weighted": [ { aggregator_weight:0.4 }, 0.75, 999 ] }
        // We'll interpret 999 as 'variant_justification'? => but it's not a string => so we default it to empty.
        let input = json!({
            "Weighted": [
                { "aggregator_weight": 0.4, "dispatch_weight": 0.4, "leaf_holder_weight": 0.2 },
                0.75,
                999
            ]
        });
        let parsed = JustifiedTreeExpansionPolicy::fuzzy_from_json_value(&input);
        assert!(parsed.is_ok(), "Should parse ignoring the non-string justification");
        let pol = parsed.unwrap();
        match pol {
            JustifiedTreeExpansionPolicy::Weighted {
                variant_confidence,
                variant_justification,
                field_0,
                ..
            } => {
                assert!((variant_confidence - 0.75).abs() < 1e-6);
                assert!(variant_justification.is_empty(), "Non-string => default empty");
                assert_eq!(*field_0.aggregator_weight(), 0.4);
            }
            other => panic!("Expected Weighted => got {:?}", other),
        }
    }

    #[test]
    fn test_single_key_is_number_for_variant_conf() {
        // shape => { "Phased": 0.8 }
        // => interpret as => variant_name="Phased", variant_confidence=0.8, default subobject empty
        let input = json!({
            "Phased": 0.8
        });
        let parsed = JustifiedTreeExpansionPolicy::fuzzy_from_json_value(&input);
        assert!(parsed.is_ok(), "Should parse => variant_confidence=0.8, no phases");
        let pol = parsed.unwrap();
        match pol {
            JustifiedTreeExpansionPolicy::Phased {
                variant_confidence,
                field_0,
                ..
            } => {
                assert!((variant_confidence - 0.8).abs() < 1e-6);
                assert!(field_0.phases().is_empty(), "No phases => empty by default");
            }
            other => panic!("Expected Phased => got {:?}", other),
        }
    }

    ////////////////////////////////////////////////////////////////////////
    // 4) Integration: top-level JustifiedGrowerTreeConfiguration snippet
    ////////////////////////////////////////////////////////////////////////

    /// This test simulates a top-level snippet with these new shapes:
    /// - complexity => { "Balanced": {...} }
    /// - capstone => { "Single": {} }
    /// - tree_expansion_policy => { "WeightedWithLimits": [ { ... }, 0.9, "...just..." ] }
    #[test]
    fn test_integration_jcfg_with_single_key_and_array_forms() {
        let input = json!({
            "fields": {
                "depth": 4,
                "breadth": 7,
                "density": 9,
                "complexity": { 
                    "Balanced": {
                        "variant_confidence": 0.8,
                        "variant_justification": "Balanced complexity for mid-level judo"
                    }
                },
                "capstone": {
                    "mode": {
                        "Single": {
                            "variant_confidence": 0.95,
                            "variant_justification": "Just one final pinnacle skill"
                        }
                    }
                },
                "tree_expansion_policy": {
                    "WeightedWithLimits": [
                        {
                            "aggregator_weight": 0.3,
                            "dispatch_weight": 0.4,
                            "leaf_holder_weight": 0.3
                        },
                        0.88,
                        "We impose limits to keep aggregator usage moderate"
                    ]
                }
            }
        });

        let parsed = JustifiedGrowerTreeConfiguration::fuzzy_from_json_value(&input);
        assert!(parsed.is_ok(), "Should parse top-level snippet => got error: {:?}", parsed.err());
        let cfg = parsed.unwrap();

        // Check fields
        assert_eq!(*cfg.depth(), 4);
        assert_eq!(*cfg.breadth(), 7);
        assert_eq!(*cfg.density(), 9);

        // complexity => Balanced
        match cfg.complexity() {
            JustifiedConfigurationComplexity::Balanced {
                variant_confidence,
                variant_justification,
            } => {
                assert!((variant_confidence - 0.8).abs() < 1e-6);
                assert_eq!(variant_justification, "Balanced complexity for mid-level judo");
            }
            other => panic!("Expected Balanced => got {:?}", other),
        }

        // capstone => check mode Single
        match cfg.capstone() {
            Some(cap) => match cap.mode() {
                JustifiedCapstoneMode::Single {
                    variant_confidence,
                    variant_justification,
                } => {
                    assert!((variant_confidence - 0.95).abs() < 1e-6);
                    assert_eq!(variant_justification, "Just one final pinnacle skill");
                }
                other => panic!("Expected Single => got {:?}", other),
            },
            None => panic!("capstone missing => fail"),
        }

        // expansion policy => WeightedWithLimits
        match cfg.tree_expansion_policy() {
            JustifiedTreeExpansionPolicy::WeightedWithLimits {
                field_0,
                variant_confidence,
                variant_justification,
                ..
            } => {
                assert!((variant_confidence - 0.88).abs() < 1e-6);
                assert_eq!(
                    variant_justification,
                    "We impose limits to keep aggregator usage moderate"
                );
                assert_eq!(*field_0.aggregator_weight(), 0.3);
                assert_eq!(*field_0.dispatch_weight(), 0.4);
                assert_eq!(*field_0.leaf_holder_weight(), 0.3);
            }
            other => panic!("Expected WeightedWithLimits => got {:?}", other),
        }
    }
}