diff --git a/packtools/sps/validation/funding_group.py b/packtools/sps/validation/funding_group.py
index e2c0d6d36..e28bc79f0 100644
--- a/packtools/sps/validation/funding_group.py
+++ b/packtools/sps/validation/funding_group.py
@@ -107,50 +107,456 @@ def validate_required_award_ids(self):
 
     def validate_funding_statement(self):
         """
-        Validates the existence of funding sources and award IDs.
+        Validates that each <funding-group> has a <funding-statement> consistent
+        with the reference texts found in the document (fn elements, ack, etc.).
+
+        Each <funding-group> is evaluated individually so that a second group
+        without <funding-statement> is not silently skipped (bug C6). Reference
+        texts are whitespace-normalised before use in advice strings to avoid
+        raw concatenated whitespace from multiple <fn> elements (bug C7).
 
         Yields
         ------
         dict
-            Validation results for each funding source and award ID.
+            Validation result per <funding-group> node.
         """
-        if self.funding.award_groups:
-            for lang, statements in self.funding.statements_by_lang.items():
-                parent_id = statements.get("parent_id")
-                xml = f'<sub-article id="{parent_id}">' if parent_id else "<article>"
-                advice = None
-                funding_statement = statements["funding_statement"]
-                items = {k: v for k, v in statements["texts"].items() if v}
-                texts = []
-                valid = False
-                if items:
-                    texts = list(items.values())
-
-                if funding_statement and texts:
-                    best_score, best_matches = most_similar(similarity(texts, funding_statement, 0.8))
-
-                    if best_matches:
-                        valid = True
-                    else:
-                        valid = False
-                        advice = f'Replace <funding-statement>{funding_statement}</funding-statement> by <funding-statement>{texts[0]}</funding-statement> for {xml}'
-                elif texts:
-                    valid = False
-                    advice = f'Add <funding-statement>{texts[0]}</funding-statement> in <funding-group> for {xml}. Consult SPS documentation for more detail'
+        if not self.funding.award_groups:
+            return
+
+        funding_groups = self.xml_tree.xpath(".//article-meta/funding-group")
+        if not funding_groups:
+            return
+
+        funding_data = self.funding.data
+
+        # Collect document-level reference texts (fn elements, ack, etc.)
+        # and normalise whitespace to prevent C7 (raw concatenated whitespace
+        # from multiple <fn> nodes appearing in advice strings).
+        all_texts = []
+        for lang, statements in self.funding.statements_by_lang.items():
+            items = {k: v for k, v in statements["texts"].items() if v}
+            for v in items.values():
+                normalized = " ".join(v.split())
+                if normalized:
+                    all_texts.append(normalized)
+
+        # Iterate each <funding-group> individually (C6 fix: each node is
+        # evaluated; the second group is no longer silently skipped).
+        for fg_node in funding_groups:
+            # Infer parent context from the node itself so that sub-article
+            # scopes are correctly reported (mirrors validate_funding_group_uniqueness).
+            article_meta = fg_node.getparent()
+            parent_elem = article_meta.getparent() if article_meta is not None else None
+            if parent_elem is not None:
+                parent_tag = parent_elem.tag
+                if "}" in parent_tag:
+                    parent_tag = parent_tag.split("}", 1)[1]
+                parent_id = parent_elem.get("id")
+            else:
+                parent_tag = "article"
+                parent_id = None
+            parent = {
+                "parent": parent_tag,
+                "parent_id": parent_id,
+                "parent_article_type": funding_data.get("article_type"),
+                "parent_lang": funding_data.get("article_lang"),
+            }
+
+            fs_nodes = fg_node.xpath("funding-statement")
+            funding_statement = None
+            if fs_nodes:
+                # Concatenate text from ALL <funding-statement> nodes in this group
+                # (not just the first) to avoid false-negatives when multiple nodes
+                # are present — mirrors the approach in validate_funding_statement_presence().
+                raw = "".join("".join(node.itertext()) for node in fs_nodes)
+                funding_statement = " ".join(raw.split()) or None
+
+            texts = all_texts
+            valid = False
+            advice = None
+
+            if funding_statement and texts:
+                # Both a <funding-statement> and reference texts exist: compare them.
+                best_score, best_matches = most_similar(
+                    similarity(texts, funding_statement, 0.8)
+                )
+                if best_matches:
+                    valid = True
                 else:
-                    valid = False
-                    advice = f'Add funding statement with <funding-statement> inside <funding-group> for {xml}. Consult SPS documentation for more detail'
+                    advice = (
+                        f"Replace <funding-statement>{funding_statement}</funding-statement>"
+                        f" by <funding-statement>{texts[0]}</funding-statement>"
+                    )
+            elif funding_statement and not texts:
+                # <funding-statement> is present but no reference texts (fn/ack) were
+                # found to compare against.  We cannot invalidate the statement, so
+                # treat as valid and emit an informational advice only.
+                valid = True
+                advice = (
+                    "No reference texts (fn/ack elements) were found to compare with"
+                    " <funding-statement>. Verify manually that the statement is correct."
+                )
+            elif texts:
+                # Reference texts exist but <funding-statement> is absent.
+                advice = (
+                    f"Add <funding-statement>{texts[0]}</funding-statement>"
+                    " in <funding-group>. Consult SPS documentation for more detail"
+                )
+            else:
+                # Neither <funding-statement> nor reference texts are present.
+                advice = (
+                    "Add funding statement with <funding-statement> inside"
+                    " <funding-group>. Consult SPS documentation for more detail"
+                )
 
-                yield build_response(
-                    title="funding-statement",
-                    parent=statements,
-                    item="funding-statement",
-                    sub_item=None,
-                    validation_type="match",
-                    is_valid=valid,
-                    expected="funding-statement",
-                    obtained=statements,
-                    advice=advice,
-                    data=statements,
-                    error_level=self.params["funding_statement_error_level"],
+            yield build_response(
+                title="funding-statement",
+                parent=parent,
+                item="funding-statement",
+                sub_item=None,
+                validation_type="match",
+                is_valid=valid,
+                expected="funding-statement",
+                obtained=funding_statement or "None",
+                advice=advice,
+                data={"funding_statement": funding_statement, "texts": texts},
+                error_level=self.params["funding_statement_error_level"],
+            )
+
+    def validate_funding_group_uniqueness(self, error_level="ERROR"):
+        """
+        Rule 1: Validates that <funding-group> appears at most once in <article-meta>.
+        
+        According to SPS 1.10, only one <funding-group> is allowed per <article-meta>.
+        
+        Params
+        ------
+        error_level : str, optional
+            The severity level of the validation error, by default "ERROR".
+        
+        Yields
+        ------
+        dict
+            Validation result for funding-group uniqueness.
+        """
+        article_metas = self.xml_tree.xpath(".//article-meta")
+        funding_data = self.funding.data
+
+        for article_meta in article_metas:
+            funding_groups = article_meta.xpath("./funding-group")
+            count = len(funding_groups)
+
+            parent_elem = article_meta.getparent()
+            if parent_elem is not None:
+                parent_tag = parent_elem.tag
+                if "}" in parent_tag:
+                    parent_tag = parent_tag.split("}", 1)[1]
+                parent_id = parent_elem.get("id")
+            else:
+                parent_tag = "article"
+                parent_id = None
+
+            parent = {
+                "parent": parent_tag,
+                "parent_id": parent_id,
+                "parent_article_type": funding_data.get("article_type"),
+                "parent_lang": funding_data.get("article_lang"),
+            }
+
+            is_valid = count <= 1
+            advice = None
+            if not is_valid:
+                advice = (
+                    f"Found {count} <funding-group> elements in <article-meta>. "
+                    "Only one is allowed. Merge them into a single <funding-group>."
                 )
+
+            yield build_response(
+                title="funding-group uniqueness",
+                parent=parent,
+                item="funding-group",
+                sub_item=None,
+                validation_type="unique",
+                is_valid=is_valid,
+                expected="At most one <funding-group> in <article-meta>",
+                obtained=f"{count} <funding-group> element(s) found",
+                advice=advice,
+                data={"count": count},
+                error_level=error_level,
+            )
+
+    def validate_funding_statement_presence(self, error_level="CRITICAL"):
+        """
+        Rule 2: Validates that <funding-statement> is present in EACH <funding-group>.
+        
+        According to SPS 1.10, <funding-statement> is mandatory in all cases.
+        Each <funding-group> must have its own <funding-statement>.
+        
+        Params
+        ------
+        error_level : str, optional
+            The severity level of the validation error, by default "CRITICAL".
+        
+        Yields
+        ------
+        dict
+            Validation result for funding-statement presence in each funding-group.
+        """
+        funding_groups = self.xml_tree.xpath(".//article-meta/funding-group")
+        
+        if not funding_groups:
+            # No funding-group means no validation needed
+            return
+        
+        funding_data = self.funding.data
+        parent = {
+            "parent": "article",
+            "parent_id": None,
+            "parent_article_type": funding_data.get("article_type"),
+            "parent_lang": funding_data.get("article_lang"),
+        }
+        
+        # Validate each funding-group individually
+        for idx, funding_group_node in enumerate(funding_groups):
+            funding_statements = funding_group_node.xpath("funding-statement")
+            is_valid = len(funding_statements) > 0
+            
+            if is_valid:
+                # Get the text from funding-statement(s)
+                text_parts = []
+                for fs in funding_statements:
+                    raw_text = "".join(fs.itertext())
+                    cleaned = " ".join(raw_text.split())
+                    if cleaned:
+                        text_parts.append(cleaned)
+                funding_statement_text = " ".join(text_parts)
+                obtained = funding_statement_text if funding_statement_text else "Present but empty"
+                advice = None
+            else:
+                obtained = "None"
+                advice = f"Add <funding-statement> element inside <funding-group> (index {idx + 1}). It is mandatory according to SPS 1.10."
+            
+            yield build_response(
+                title="funding-statement presence",
+                parent=parent,
+                item="funding-statement",
+                sub_item=None,
+                validation_type="exist",
+                is_valid=is_valid,
+                expected="<funding-statement> present in <funding-group>",
+                obtained=obtained,
+                advice=advice,
+                data={"funding_group_index": idx + 1, "has_funding_statement": is_valid},
+                error_level=error_level,
+            )
+
+    def validate_funding_source_in_award_group(self, error_level="CRITICAL"):
+        """
+        Rule 3: Validates that <funding-source> is present when <award-group> exists.
+        
+        According to SPS 1.10, when there are institutions declared via <award-group>,
+        <funding-source> is mandatory.
+        
+        Params
+        ------
+        error_level : str, optional
+            The severity level of the validation error, by default "CRITICAL".
+        
+        Yields
+        ------
+        dict
+            Validation results for each award-group.
+        """
+        funding_data = self.funding.data
+        parent = {
+            "parent": "article",
+            "parent_id": None,
+            "parent_article_type": funding_data.get("article_type"),
+            "parent_lang": funding_data.get("article_lang"),
+        }
+        
+        for item in self.funding.award_groups:
+            funding_sources = item["funding-source"]
+            
+            is_valid = len(funding_sources) > 0
+            advice = None
+            if not is_valid:
+                advice = "Add at least one <funding-source> element inside this <award-group>. It is mandatory when <award-group> exists."
+            
+            yield build_response(
+                title="funding-source in award-group",
+                parent=parent,
+                item="award-group",
+                sub_item="funding-source",
+                validation_type="exist",
+                is_valid=is_valid,
+                expected="At least one <funding-source> in <award-group>",
+                obtained=f"{len(funding_sources)} <funding-source> element(s) found",
+                advice=advice,
+                data=item,
+                error_level=error_level,
+            )
+
+    def validate_label_absence(self, error_level="ERROR"):
+        """
+        Rule 5: Validates that <label> is not present in <funding-group> or its descendants.
+        
+        According to SPS 1.10, <label> is not allowed inside <funding-group>.
+        
+        Params
+        ------
+        error_level : str, optional
+            The severity level of the validation error, by default "ERROR".
+        
+        Yields
+        ------
+        dict
+            Validation result for label absence.
+        """
+        labels = self.xml_tree.xpath(".//funding-group//label")
+        count = len(labels)
+        
+        funding_data = self.funding.data
+        parent = {
+            "parent": "article",
+            "parent_id": None,
+            "parent_article_type": funding_data.get("article_type"),
+            "parent_lang": funding_data.get("article_lang"),
+        }
+        
+        is_valid = count == 0
+        advice = None
+        if not is_valid:
+            advice = f"Remove {count} <label> element(s) from <funding-group>. <label> is not allowed according to SPS 1.10."
+        
+        yield build_response(
+            title="label absence in funding-group",
+            parent=parent,
+            item="funding-group",
+            sub_item="label",
+            validation_type="forbidden",
+            is_valid=is_valid,
+            expected="No <label> elements in <funding-group>",
+            obtained=f"{count} <label> element(s) found",
+            advice=advice,
+            data={
+                "count": count,
+                "labels": [
+                    text
+                    for label in labels
+                    for text in [" ".join(label.itertext()).strip()]
+                    if text
+                ],
+            },
+            error_level=error_level,
+        )
+
+    def validate_title_absence(self, error_level="ERROR"):
+        """
+        Rule 6: Validates that <title> is not present in <funding-group> or its descendants.
+        
+        According to SPS 1.10, <title> is not allowed inside <funding-group>.
+        
+        Params
+        ------
+        error_level : str, optional
+            The severity level of the validation error, by default "ERROR".
+        
+        Yields
+        ------
+        dict
+            Validation result for title absence.
+        """
+        titles = self.xml_tree.xpath(".//funding-group//title")
+        count = len(titles)
+        
+        funding_data = self.funding.data
+        parent = {
+            "parent": "article",
+            "parent_id": None,
+            "parent_article_type": funding_data.get("article_type"),
+            "parent_lang": funding_data.get("article_lang"),
+        }
+        
+        is_valid = count == 0
+        advice = None
+        if not is_valid:
+            advice = f"Remove {count} <title> element(s) from <funding-group>. <title> is not allowed according to SPS 1.10."
+        
+        yield build_response(
+            title="title absence in funding-group",
+            parent=parent,
+            item="funding-group",
+            sub_item="title",
+            validation_type="forbidden",
+            is_valid=is_valid,
+            expected="No <title> elements in <funding-group>",
+            obtained=f"{count} <title> element(s) found",
+            advice=advice,
+            data={
+                "count": count,
+                "titles": [
+                    text
+                    for title in titles
+                    for text in [" ".join(title.itertext()).strip()]
+                    if text
+                ],
+            },
+            error_level=error_level,
+        )
+
+    def validate_award_id_funding_source_consistency(self, error_level="WARNING"):
+        """
+        Rule 7: Validates consistency of <funding-source> and <award-id> quantities.
+        
+        According to SPS 1.10, in each <award-group>, the quantity of <award-id> should be:
+        - 0: Support without contract
+        - 1: One contract for one or more funding sources
+        - N: Multiple contracts (should match number of funding sources in most cases)
+        
+        Params
+        ------
+        error_level : str, optional
+            The severity level of the validation error, by default "WARNING".
+        
+        Yields
+        ------
+        dict
+            Validation results for each award-group.
+        """
+        funding_data = self.funding.data
+        parent = {
+            "parent": "article",
+            "parent_id": None,
+            "parent_article_type": funding_data.get("article_type"),
+            "parent_lang": funding_data.get("article_lang"),
+        }
+        
+        for item in self.funding.award_groups:
+            funding_sources = item["funding-source"]
+            award_ids = item["award-id"]
+            
+            num_sources = len(funding_sources)
+            num_awards = len(award_ids)
+            
+            # Valid cases: 0 awards (support), 1 award (single contract), or N awards matching N sources
+            is_valid = num_awards == 0 or num_awards == 1 or num_awards == num_sources
+            
+            advice = None
+            if not is_valid:
+                if num_awards > 1 and num_awards != num_sources:
+                    advice = f"Inconsistent quantities: {num_sources} <funding-source>(s) but {num_awards} <award-id>(s). When multiple <award-id> elements exist, they should typically match the number of <funding-source> elements, or use separate <award-group> elements."
+            
+            yield build_response(
+                title="award-id and funding-source consistency",
+                parent=parent,
+                item="award-group",
+                sub_item="award-id",
+                validation_type="consistency",
+                is_valid=is_valid,
+                expected="Consistent quantities: 0 awards (support), 1 award (contract), or N awards matching N sources",
+                obtained=f"{num_sources} funding-source(s), {num_awards} award-id(s)",
+                advice=advice,
+                data=item,
+                error_level=error_level,
+            )
diff --git a/packtools/sps/validation/xml_validations.py b/packtools/sps/validation/xml_validations.py
index 290ca02d3..fbb586551 100644
--- a/packtools/sps/validation/xml_validations.py
+++ b/packtools/sps/validation/xml_validations.py
@@ -209,8 +209,30 @@ def validate_bibliographic_strip(xmltree, params):
 def validate_funding_data(xmltree, params):
     funding_data_rules = params["funding_data_rules"]
     validator = FundingGroupValidation(xmltree, funding_data_rules)
+    
+    # Existing validations
     yield from validator.validate_required_award_ids()
     yield from validator.validate_funding_statement()
+    
+    # New SPS 1.10 validations
+    yield from validator.validate_funding_group_uniqueness(
+        error_level=funding_data_rules.get("funding_group_uniqueness_error_level", "ERROR")
+    )
+    yield from validator.validate_funding_statement_presence(
+        error_level=funding_data_rules.get("funding_statement_error_level", "CRITICAL")
+    )
+    yield from validator.validate_funding_source_in_award_group(
+        error_level=funding_data_rules.get("funding_source_in_award_group_error_level", "CRITICAL")
+    )
+    yield from validator.validate_label_absence(
+        error_level=funding_data_rules.get("label_absence_error_level", "ERROR")
+    )
+    yield from validator.validate_title_absence(
+        error_level=funding_data_rules.get("title_absence_error_level", "ERROR")
+    )
+    yield from validator.validate_award_id_funding_source_consistency(
+        error_level=funding_data_rules.get("award_id_consistency_error_level", "WARNING")
+    )
 
 
 def validate_journal_meta(xmltree, params):
diff --git a/src/scielo-scholarly-data b/src/scielo-scholarly-data
new file mode 160000
index 000000000..a2899ce8a
--- /dev/null
+++ b/src/scielo-scholarly-data
@@ -0,0 +1 @@
+Subproject commit a2899ce8a1fa77396c516640d36686351210d606
diff --git a/tests/sps/validation/test_funding_group.py b/tests/sps/validation/test_funding_group.py
index dd63c784f..e4600e03d 100644
--- a/tests/sps/validation/test_funding_group.py
+++ b/tests/sps/validation/test_funding_group.py
@@ -55,7 +55,8 @@ def setUp(self):
 
     def test_proper_award_group(self):
         results = list(self.validator.validate_required_award_ids())
-        self.assertEqual(len(results), 0)
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["response"], "OK")
 
 
 class TestAwardInAck(TestFundingValidationBase):
@@ -107,7 +108,7 @@ def test_award_in_financial_disclosure(self):
         self.assertEqual(len(results), 1)
         result = results[0]
         self.assertEqual(
-            result["data"]["context"], "fn[@fn-type='financial-disclosure']"
+            result["data"]["context"], "financial-disclosure"
         )
         self.assertIn("123.456-7", str(result["data"]["look-like-award-id"]))
 
@@ -134,7 +135,7 @@ def test_award_in_supported_by(self):
         results = list(self.validator.validate_required_award_ids())
         self.assertEqual(len(results), 1)
         result = results[0]
-        self.assertEqual(result["data"]["context"], "fn[@fn-type='supported-by']")
+        self.assertEqual(result["data"]["context"], "supported-by")
         self.assertIn("123.456-7", str(result["data"]["look-like-award-id"]))
 
 
@@ -160,7 +161,7 @@ def test_award_in_funding_statement(self):
         results = list(self.validator.validate_required_award_ids())
         self.assertEqual(len(results), 1)
         result = results[0]
-        self.assertEqual(result["data"]["context"], "funding-group/funding-statement")
+        self.assertEqual(result["data"]["context"], "funding-statement")
         self.assertIn("123.456-7", str(result["data"]["look-like-award-id"]))
 
 
@@ -206,10 +207,10 @@ def test_awards_in_all_locations(self):
         self.assertEqual(len(contexts), 4)
 
         # Verifica cada contexto específico
-        self.assertIn("funding-group/funding-statement", contexts)
+        self.assertIn("funding-statement", contexts)
         self.assertIn("ack", contexts)
-        self.assertIn("fn[@fn-type='financial-disclosure']", contexts)
-        self.assertIn("fn[@fn-type='supported-by']", contexts)
+        self.assertIn("financial-disclosure", contexts)
+        self.assertIn("supported-by", contexts)
 
         # Verifica os award IDs encontrados
         award_ids = set()
@@ -235,18 +236,947 @@ def setUp(self):
 
     def test_warning_level(self):
         params = dict(self.params)
-        params["error_level"] = "WARNING"
+        params["award_id_error_level"] = "WARNING"
         validator = FundingGroupValidation(self.xml_tree, params)
         results = list(validator.validate_required_award_ids())
         self.assertEqual(results[0]["response"], "WARNING")
 
     def test_info_level(self):
         params = dict(self.params)
-        params["error_level"] = "INFO"
+        params["award_id_error_level"] = "INFO"
         validator = FundingGroupValidation(self.xml_tree, params)
         results = list(validator.validate_required_award_ids())
         self.assertEqual(results[0]["response"], "INFO")
 
 
+# ========================================
+# New Tests for SPS 1.10 Validations
+# ========================================
+
+
+class TestFundingGroupUniqueness(TestFundingValidationBase):
+    """Rule 1: Test <funding-group> uniqueness validation"""
+
+    def test_single_funding_group_valid(self):
+        """Single <funding-group> should be valid"""
+        xml = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                        <funding-group>
+                            <funding-statement>No funding</funding-statement>
+                        </funding-group>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_funding_group_uniqueness())
+        
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["response"], "OK")
+
+    def test_multiple_funding_groups_invalid(self):
+        """Multiple <funding-group> elements should be invalid"""
+        xml = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                        <funding-group>
+                            <funding-statement>Funding 1</funding-statement>
+                        </funding-group>
+                        <funding-group>
+                            <funding-statement>Funding 2</funding-statement>
+                        </funding-group>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_funding_group_uniqueness())
+        
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["response"], "ERROR")
+        self.assertIn("2 <funding-group>", results[0]["advice"])
+
+    def test_no_funding_group_valid(self):
+        """No <funding-group> should be valid (0 <= 1)"""
+        xml = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_funding_group_uniqueness())
+
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["response"], "OK")
+
+    def test_sub_article_each_with_one_funding_group_no_false_positive(self):
+        """
+        Sugestão 1: Two sub-articles, each with its own <article-meta> containing
+        exactly one <funding-group>, must NOT trigger a uniqueness error.
+        The old implementation (global count) would yield count=2 and raise a
+        false positive. The corrected implementation validates per article-meta.
+        """
+        xml = """
+            <article article-type="research-article" xml:lang="pt">
+                <front>
+                    <article-meta>
+                        <funding-group>
+                            <funding-statement>Funded by CNPq</funding-statement>
+                        </funding-group>
+                    </article-meta>
+                </front>
+                <sub-article article-type="translation" xml:lang="en" id="s1">
+                    <front-stub>
+                        <article-meta>
+                            <funding-group>
+                                <funding-statement>Funded by CNPq</funding-statement>
+                            </funding-group>
+                        </article-meta>
+                    </front-stub>
+                </sub-article>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_funding_group_uniqueness())
+
+        # Two article-meta nodes → two results, both OK
+        self.assertEqual(len(results), 2)
+        for result in results:
+            self.assertEqual(result["response"], "OK")
+
+    def test_sub_article_with_multiple_funding_groups_invalid(self):
+        """
+        A sub-article <article-meta> with two <funding-group> must be flagged,
+        while the main article-meta (with one) remains OK.
+        """
+        xml = """
+            <article article-type="research-article" xml:lang="pt">
+                <front>
+                    <article-meta>
+                        <funding-group>
+                            <funding-statement>Funded by CNPq</funding-statement>
+                        </funding-group>
+                    </article-meta>
+                </front>
+                <sub-article article-type="translation" xml:lang="en" id="s1">
+                    <front-stub>
+                        <article-meta>
+                            <funding-group>
+                                <funding-statement>Funding A</funding-statement>
+                            </funding-group>
+                            <funding-group>
+                                <funding-statement>Funding B</funding-statement>
+                            </funding-group>
+                        </article-meta>
+                    </front-stub>
+                </sub-article>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_funding_group_uniqueness())
+
+        self.assertEqual(len(results), 2)
+        # Main article-meta: OK
+        self.assertEqual(results[0]["response"], "OK")
+        # Sub-article article-meta: ERROR
+        self.assertEqual(results[1]["response"], "ERROR")
+        self.assertIn("2 <funding-group>", results[1]["advice"])
+
+
+class TestFundingStatementPresence(TestFundingValidationBase):
+    """Rule 2: Test <funding-statement> presence validation"""
+
+    def test_funding_statement_present_valid(self):
+        """<funding-statement> present should be valid"""
+        xml = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                        <funding-group>
+                            <funding-statement>This study was supported by FAPESP</funding-statement>
+                        </funding-group>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_funding_statement_presence())
+        
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["response"], "OK")
+
+    def test_funding_statement_missing_invalid(self):
+        """Missing <funding-statement> should be invalid"""
+        xml = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                        <funding-group>
+                            <award-group>
+                                <funding-source>FAPESP</funding-source>
+                                <award-id>04/08142-0</award-id>
+                            </award-group>
+                        </funding-group>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_funding_statement_presence())
+        
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["response"], "CRITICAL")
+        self.assertIn("Add <funding-statement>", results[0]["advice"])
+
+    def test_no_funding_group_no_validation(self):
+        """No <funding-group> means no validation needed"""
+        xml = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_funding_statement_presence())
+        
+        self.assertEqual(len(results), 0)
+
+    def test_multiple_funding_groups_second_missing_statement(self):
+        """
+        Case C1: Multiple funding-groups, second one missing funding-statement.
+        This test validates that each funding-group is checked individually.
+        """
+        xml = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                        <funding-group>
+                            <award-group>
+                                <funding-source>FAPESP</funding-source>
+                            </award-group>
+                            <funding-statement>First funding statement</funding-statement>
+                        </funding-group>
+                        <funding-group>
+                            <award-group>
+                                <funding-source>CNPq</funding-source>
+                            </award-group>
+                        </funding-group>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_funding_statement_presence())
+        
+        # Should get 2 results: one OK for first funding-group, one CRITICAL for second
+        self.assertEqual(len(results), 2)
+        
+        # First funding-group should be OK
+        self.assertEqual(results[0]["response"], "OK")
+        self.assertIn("First funding statement", results[0]["got_value"])
+        
+        # Second funding-group should be CRITICAL (missing funding-statement)
+        self.assertEqual(results[1]["response"], "CRITICAL")
+        self.assertIn("Add <funding-statement>", results[1]["advice"])
+        self.assertIn("index 2", results[1]["advice"])
+
+
+class TestFundingSourceInAwardGroup(TestFundingValidationBase):
+    """Rule 3: Test <funding-source> presence in <award-group> validation"""
+
+    def test_funding_source_present_valid(self):
+        """<funding-source> present in <award-group> should be valid"""
+        xml = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                        <funding-group>
+                            <award-group>
+                                <funding-source>FAPESP</funding-source>
+                                <award-id>04/08142-0</award-id>
+                            </award-group>
+                            <funding-statement>Funded by FAPESP</funding-statement>
+                        </funding-group>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_funding_source_in_award_group())
+        
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["response"], "OK")
+
+    def test_funding_source_missing_invalid(self):
+        """Missing <funding-source> in <award-group> should be invalid"""
+        xml = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                        <funding-group>
+                            <award-group>
+                                <award-id>04/08142-0</award-id>
+                            </award-group>
+                            <funding-statement>Funded</funding-statement>
+                        </funding-group>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_funding_source_in_award_group())
+        
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["response"], "CRITICAL")
+        self.assertIn("Add at least one <funding-source>", results[0]["advice"])
+
+    def test_multiple_funding_sources_valid(self):
+        """Multiple <funding-source> elements should be valid"""
+        xml = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                        <funding-group>
+                            <award-group>
+                                <funding-source>FAPESP</funding-source>
+                                <funding-source>CAPES</funding-source>
+                                <award-id>04/08142-0</award-id>
+                            </award-group>
+                            <funding-statement>Funded by FAPESP and CAPES</funding-statement>
+                        </funding-group>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_funding_source_in_award_group())
+        
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["response"], "OK")
+
+
+class TestLabelAbsence(TestFundingValidationBase):
+    """Rule 5: Test <label> absence validation"""
+
+    def test_no_label_valid(self):
+        """No <label> in <funding-group> should be valid"""
+        xml = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                        <funding-group>
+                            <award-group>
+                                <funding-source>FAPESP</funding-source>
+                            </award-group>
+                            <funding-statement>Funded by FAPESP</funding-statement>
+                        </funding-group>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_label_absence())
+        
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["response"], "OK")
+
+    def test_label_present_invalid(self):
+        """<label> in <funding-group> should be invalid"""
+        xml = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                        <funding-group>
+                            <label>Funding</label>
+                            <award-group>
+                                <funding-source>FAPESP</funding-source>
+                            </award-group>
+                            <funding-statement>Funded by FAPESP</funding-statement>
+                        </funding-group>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_label_absence())
+        
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["response"], "ERROR")
+        self.assertIn("Remove", results[0]["advice"])
+        self.assertIn("<label>", results[0]["advice"])
+
+
+class TestTitleAbsence(TestFundingValidationBase):
+    """Rule 6: Test <title> absence validation"""
+
+    def test_no_title_valid(self):
+        """No <title> in <funding-group> should be valid"""
+        xml = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                        <funding-group>
+                            <award-group>
+                                <funding-source>FAPESP</funding-source>
+                            </award-group>
+                            <funding-statement>Funded by FAPESP</funding-statement>
+                        </funding-group>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_title_absence())
+        
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["response"], "OK")
+
+    def test_title_present_invalid(self):
+        """<title> in <funding-group> should be invalid"""
+        xml = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                        <funding-group>
+                            <title>Funding Information</title>
+                            <award-group>
+                                <funding-source>FAPESP</funding-source>
+                            </award-group>
+                            <funding-statement>Funded by FAPESP</funding-statement>
+                        </funding-group>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_title_absence())
+        
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["response"], "ERROR")
+        self.assertIn("Remove", results[0]["advice"])
+        self.assertIn("<title>", results[0]["advice"])
+
+
+class TestAwardIdFundingSourceConsistency(TestFundingValidationBase):
+    """Rule 7: Test <award-id> and <funding-source> consistency validation"""
+
+    def test_support_without_contract_valid(self):
+        """Support without contract (0 award-ids) should be valid"""
+        xml = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                        <funding-group>
+                            <award-group>
+                                <funding-source>FAPESP</funding-source>
+                            </award-group>
+                            <funding-statement>Funded by FAPESP</funding-statement>
+                        </funding-group>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_award_id_funding_source_consistency())
+        
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["response"], "OK")
+
+    def test_single_contract_valid(self):
+        """Single contract (1 award-id) for multiple sources should be valid"""
+        xml = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                        <funding-group>
+                            <award-group>
+                                <funding-source>FAPESP</funding-source>
+                                <funding-source>CAPES</funding-source>
+                                <award-id>04/08142-0</award-id>
+                            </award-group>
+                            <funding-statement>Funded by FAPESP and CAPES</funding-statement>
+                        </funding-group>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_award_id_funding_source_consistency())
+        
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["response"], "OK")
+
+    def test_matching_quantities_valid(self):
+        """Matching quantities (N sources, N awards) should be valid"""
+        xml = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                        <funding-group>
+                            <award-group>
+                                <funding-source>FAPESP</funding-source>
+                                <funding-source>CAPES</funding-source>
+                                <award-id>04/08142-0</award-id>
+                                <award-id>05/09876-5</award-id>
+                            </award-group>
+                            <funding-statement>Funded by FAPESP and CAPES</funding-statement>
+                        </funding-group>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_award_id_funding_source_consistency())
+        
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["response"], "OK")
+
+    def test_inconsistent_quantities_warning(self):
+        """Inconsistent quantities should trigger warning"""
+        xml = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                        <funding-group>
+                            <award-group>
+                                <funding-source>FAPESP</funding-source>
+                                <award-id>04/08142-0</award-id>
+                                <award-id>05/09876-5</award-id>
+                                <award-id>06/12345-6</award-id>
+                            </award-group>
+                            <funding-statement>Funded by FAPESP</funding-statement>
+                        </funding-group>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_award_id_funding_source_consistency())
+        
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["response"], "WARNING")
+        self.assertIn("Inconsistent quantities", results[0]["advice"])
+
+
+class TestCompleteValidExamples(TestFundingValidationBase):
+    """Test complete valid XML examples from the issue"""
+
+    def test_example_1_funding_with_contract(self):
+        """Example 1: Funding with contract number"""
+        xml = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                        <funding-group>
+                            <award-group>
+                                <funding-source>Fundação de Amparo à Pesquisa do Estado de São Paulo (FAPESP)</funding-source>
+                                <award-id>04/08142-0</award-id>
+                            </award-group>
+                            <funding-statement>This study was supported by Fundação de Amparo à Pesquisa do Estado de São Paulo (FAPESP - Grant no. 04/08142-0; São Paulo, Brazil)</funding-statement>
+                        </funding-group>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        
+        # All validations should pass
+        uniqueness = list(validator.validate_funding_group_uniqueness())
+        statement = list(validator.validate_funding_statement_presence())
+        source = list(validator.validate_funding_source_in_award_group())
+        label = list(validator.validate_label_absence())
+        title = list(validator.validate_title_absence())
+        consistency = list(validator.validate_award_id_funding_source_consistency())
+        
+        self.assertEqual(uniqueness[0]["response"], "OK")
+        self.assertEqual(statement[0]["response"], "OK")
+        self.assertEqual(source[0]["response"], "OK")
+        self.assertEqual(label[0]["response"], "OK")
+        self.assertEqual(title[0]["response"], "OK")
+        self.assertEqual(consistency[0]["response"], "OK")
+
+    def test_example_6_negative_funding_declaration(self):
+        """Example 6: Negative funding declaration"""
+        xml = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                        <funding-group>
+                            <funding-statement>Não houve financiamento para esta publicação</funding-statement>
+                        </funding-group>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        
+        # Should pass all checks (no award-group means no source validation)
+        uniqueness = list(validator.validate_funding_group_uniqueness())
+        statement = list(validator.validate_funding_statement_presence())
+        source = list(validator.validate_funding_source_in_award_group())
+        label = list(validator.validate_label_absence())
+        title = list(validator.validate_title_absence())
+        
+        self.assertEqual(uniqueness[0]["response"], "OK")
+        self.assertEqual(statement[0]["response"], "OK")
+        self.assertEqual(len(source), 0)  # No award-group, so no validation
+        self.assertEqual(label[0]["response"], "OK")
+        self.assertEqual(title[0]["response"], "OK")
+
+
+class TestValidateFundingStatement(TestFundingValidationBase):
+    """
+    Tests for validate_funding_statement — covers the two bugs fixed on 06/03/2026:
+
+    C6 — second <funding-group> without <funding-statement> was silently skipped
+         because the old implementation iterated statements_by_lang (one entry
+         per language) instead of per <funding-group> node.
+    C7 — whitespace from multiple <fn> elements was concatenated raw into the
+         advice string; fixed by normalising with " ".join(v.split()).
+    """
+
+    # XML with two <funding-group>: first has a statement, second does not (C6)
+    XML_TWO_FG_SECOND_MISSING = """
+        <article article-type="research-article" xml:lang="pt">
+            <front>
+                <article-meta>
+                    <funding-group>
+                        <award-group>
+                            <funding-source>FAPESP</funding-source>
+                            <award-id>2022/12345-6</award-id>
+                        </award-group>
+                        <funding-statement>Financiado pela FAPESP processo 2022/12345-6</funding-statement>
+                    </funding-group>
+                    <funding-group>
+                        <award-group>
+                            <funding-source>CNPq</funding-source>
+                            <award-id>123456</award-id>
+                        </award-group>
+                    </funding-group>
+                </article-meta>
+            </front>
+            <back>
+                <fn-group>
+                    <fn fn-type="financial-disclosure" id="fn-fd1">
+                        <p>Financiado pela FAPESP processo 2022/12345-6</p>
+                    </fn>
+                    <fn fn-type="financial-disclosure" id="fn-fd2">
+                        <p>Apoio CNPq 123456</p>
+                    </fn>
+                </fn-group>
+            </back>
+        </article>
+    """
+
+    # XML with a single <funding-group> whose statement matches the fn text (valid)
+    XML_SINGLE_FG_VALID = """
+        <article article-type="research-article" xml:lang="pt">
+            <front>
+                <article-meta>
+                    <funding-group>
+                        <award-group>
+                            <funding-source>FAPESP</funding-source>
+                            <award-id>2022/12345-6</award-id>
+                        </award-group>
+                        <funding-statement>Financiado pela FAPESP processo 2022/12345-6</funding-statement>
+                    </funding-group>
+                </article-meta>
+            </front>
+            <back>
+                <fn-group>
+                    <fn fn-type="financial-disclosure" id="fn-fd1">
+                        <p>Financiado pela FAPESP processo 2022/12345-6</p>
+                    </fn>
+                </fn-group>
+            </back>
+        </article>
+    """
+
+    # XML where the fn text has multi-line / extra whitespace (C7 scenario)
+    XML_WHITESPACE_FN = """
+        <article article-type="research-article" xml:lang="pt">
+            <front>
+                <article-meta>
+                    <funding-group>
+                        <award-group>
+                            <funding-source>FAPESP</funding-source>
+                            <award-id>2022/12345-6</award-id>
+                        </award-group>
+                        <funding-statement>Outro texto completamente diferente</funding-statement>
+                    </funding-group>
+                </article-meta>
+            </front>
+            <back>
+                <fn-group>
+                    <fn fn-type="financial-disclosure" id="fn-fd1">
+                        <p>Financiado
+                           pela   FAPESP
+                           processo   2022/12345-6</p>
+                    </fn>
+                    <fn fn-type="financial-disclosure" id="fn-fd2">
+                        <p>Apoio   CNPq   123456</p>
+                    </fn>
+                </fn-group>
+            </back>
+        </article>
+    """
+
+    def test_c6_second_funding_group_without_statement_is_flagged(self):
+        """
+        C6: When two <funding-group> exist and the second has no
+        <funding-statement>, validate_funding_statement must yield TWO results
+        — one OK for the first group and one ERROR/CRITICAL for the second.
+        The old implementation only yielded one result (silently skipping C6).
+        """
+        xml_tree = etree.fromstring(self.XML_TWO_FG_SECOND_MISSING)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_funding_statement())
+
+        self.assertEqual(len(results), 2, "Must yield one result per <funding-group>")
+        # First group has a matching statement → OK
+        self.assertEqual(results[0]["response"], "OK")
+        # Second group has no statement → should be invalid
+        self.assertNotEqual(results[1]["response"], "OK")
+        self.assertIsNotNone(results[1]["advice"])
+        self.assertIn("<funding-statement>", results[1]["advice"])
+
+    def test_c7_advice_string_has_no_raw_whitespace(self):
+        """
+        C7: When the reference text in an <fn> element contains extra/multi-line
+        whitespace, the advice string must NOT contain sequences of multiple
+        spaces or newline characters. Normalization via ' '.join(v.split()) is
+        required before building the advice.
+        """
+        xml_tree = etree.fromstring(self.XML_WHITESPACE_FN)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_funding_statement())
+
+        self.assertEqual(len(results), 1)
+        result = results[0]
+        advice = result.get("advice", "") or ""
+        # Must not contain raw runs of whitespace / newlines in the advice
+        self.assertNotIn("\n", advice, "Advice must not contain newline characters")
+        self.assertNotRegex(advice, r"  +", "Advice must not contain consecutive spaces")
+
+    def test_valid_matching_statement_yields_ok(self):
+        """
+        When the <funding-statement> closely matches the reference fn text,
+        the result must be OK and advice must be None.
+        """
+        xml_tree = etree.fromstring(self.XML_SINGLE_FG_VALID)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_funding_statement())
+
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["response"], "OK")
+        self.assertIsNone(results[0]["advice"])
+
+    def test_early_exit_when_no_award_groups(self):
+        """
+        When there are no <award-group> elements, validate_funding_statement
+        must yield nothing (early return).
+        """
+        xml = """
+            <article article-type="research-article" xml:lang="pt">
+                <front>
+                    <article-meta>
+                        <funding-group>
+                            <funding-statement>Estudo realizado sem apoio financeiro externo.</funding-statement>
+                        </funding-group>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_funding_statement())
+
+        self.assertEqual(len(results), 0, "No award-groups → no results expected")
+
+
+# ========================================
+# Sugestão 3: Testes para o orquestrador validate_funding_data
+# Requer: from packtools.sps.validation.xml_validations import validate_funding_data
+# ========================================
+
+
+class TestValidateFundingDataOrchestrator(TestFundingValidationBase):
+    """
+    Sugestão 3: Testes de integração para validate_funding_data em xml_validations.py.
+
+    Verificam que:
+      (a) todas as novas validações SPS 1.10 são emitidas pelo orquestrador;
+      (b) os níveis configuráveis via funding_data_rules são propagados corretamente,
+          especialmente a chave funding_statement_error_level (não
+          funding_statement_presence_error_level, que era o nome incorreto no PR).
+    """
+
+    # Importação condicional: o teste é ignorado se xml_validations não estiver disponível
+    try:
+        from packtools.sps.validation.xml_validations import validate_funding_data as _vfd
+        _orchestrator_available = True
+    except ImportError:
+        _orchestrator_available = False
+
+    def setUp(self):
+        self.xml_full = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                        <funding-group>
+                            <award-group>
+                                <funding-source>FAPESP</funding-source>
+                                <award-id>04/08142-0</award-id>
+                            </award-group>
+                            <funding-statement>Funded by FAPESP grant 04/08142-0</funding-statement>
+                        </funding-group>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        self.xml_missing_statement = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                        <funding-group>
+                            <award-group>
+                                <funding-source>CNPq</funding-source>
+                                <award-id>123456</award-id>
+                            </award-group>
+                        </funding-group>
+                    </article-meta>
+                </front>
+            </article>
+        """
+
+    @unittest.skipUnless(_orchestrator_available, "xml_validations não disponível no path")
+    def test_orchestrator_emits_all_new_validations(self):
+        """
+        Sugestão 3a: validate_funding_data deve emitir resultados para todas as
+        validações SPS 1.10 (uniqueness, statement presence, source in award-group,
+        label absence, title absence, consistency).
+        """
+        from packtools.sps.validation.xml_validations import validate_funding_data
+
+        xml_tree = etree.fromstring(self.xml_full)
+        params = {
+            "funding_data_rules": {
+                "special_chars_award_id": ["/", ".", "-"],
+                "award_id_error_level": "CRITICAL",
+                "funding_statement_error_level": "CRITICAL",
+                "funding_group_uniqueness_error_level": "ERROR",
+                "funding_source_in_award_group_error_level": "CRITICAL",
+                "label_absence_error_level": "ERROR",
+                "title_absence_error_level": "ERROR",
+                "award_id_consistency_error_level": "WARNING",
+            }
+        }
+        results = list(validate_funding_data(xml_tree, params))
+        titles = {r["title"] for r in results}
+
+        self.assertIn("funding-group uniqueness", titles)
+        self.assertIn("funding-statement presence", titles)
+        self.assertIn("funding-source in award-group", titles)
+        self.assertIn("label absence in funding-group", titles)
+        self.assertIn("title absence in funding-group", titles)
+        self.assertIn("award-id and funding-source consistency", titles)
+
+    @unittest.skipUnless(_orchestrator_available, "xml_validations não disponível no path")
+    def test_orchestrator_propagates_funding_statement_error_level(self):
+        """
+        Sugestão 3b / Sugestão 2: o orquestrador deve ler a chave
+        'funding_statement_error_level' (não 'funding_statement_presence_error_level').
+        Configurar como WARNING e verificar que o resultado reflete WARNING,
+        não o fallback CRITICAL.
+        """
+        from packtools.sps.validation.xml_validations import validate_funding_data
+
+        xml_tree = etree.fromstring(self.xml_missing_statement)
+        params = {
+            "funding_data_rules": {
+                "special_chars_award_id": ["/", ".", "-"],
+                "award_id_error_level": "CRITICAL",
+                "funding_statement_error_level": "WARNING",   # chave correta
+            }
+        }
+        results = list(validate_funding_data(xml_tree, params))
+        statement_results = [r for r in results if r["title"] == "funding-statement presence"]
+
+        self.assertTrue(
+            len(statement_results) > 0,
+            "Nenhum resultado de 'funding-statement presence' emitido pelo orquestrador"
+        )
+        for r in statement_results:
+            self.assertEqual(
+                r["response"], "WARNING",
+                "O nível configurado via 'funding_statement_error_level' não foi propagado "
+                "como WARNING; provavelmente o orquestrador ainda usa a chave incorreta "
+                "'funding_statement_presence_error_level' ou está caindo no fallback CRITICAL."
+            )
+
+    @unittest.skipUnless(_orchestrator_available, "xml_validations não disponível no path")
+    def test_orchestrator_propagates_uniqueness_error_level(self):
+        """
+        Sugestão 3b: funding_group_uniqueness_error_level configurado como WARNING
+        deve ser refletido no resultado de uniqueness.
+        """
+        from packtools.sps.validation.xml_validations import validate_funding_data
+
+        xml_duplicate = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                        <funding-group><funding-statement>A</funding-statement></funding-group>
+                        <funding-group><funding-statement>B</funding-statement></funding-group>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml_duplicate)
+        params = {
+            "funding_data_rules": {
+                "special_chars_award_id": ["/", ".", "-"],
+                "funding_group_uniqueness_error_level": "WARNING",
+            }
+        }
+        results = list(validate_funding_data(xml_tree, params))
+        uniqueness_results = [r for r in results if r["title"] == "funding-group uniqueness"]
+
+        invalid = [r for r in uniqueness_results if r["response"] != "OK"]
+        self.assertTrue(len(invalid) > 0)
+        for r in invalid:
+            self.assertEqual(r["response"], "WARNING")
+
+
 if __name__ == "__main__":
     unittest.main()