diff --git a/site/tests/moderation/test_domains.py b/site/tests/moderation/test_domains.py
index c8895f956..7c74a418d 100644
--- a/site/tests/moderation/test_domains.py
+++ b/site/tests/moderation/test_domains.py
@@ -39,3 +39,17 @@ def test_lookup_domain(domains, domain, expected_status):
         assert LinkDomain.lookup_domain(domain) is None
     else:
         assert LinkDomain.lookup_domain(domain).status == expected_status
+
+
+@pytest.mark.parametrize(
+    "stored,expected",
+    [
+        (".io.blog", "blog.io"),
+        (".io.blog.spam", "spam.blog.io"),
+        (".ch.edu", "edu.ch"),
+        (".cam", "cam"),
+    ],
+)
+def test_domain_name(stored, expected):
+    """Domain names are exposed in display order."""
+    assert LinkDomain(domain=stored).domain_name == expected
diff --git a/site/tests/moderation/test_moderation_tasks.py b/site/tests/moderation/test_moderation_tasks.py
new file mode 100644
index 000000000..6d677a7e1
--- /dev/null
+++ b/site/tests/moderation/test_moderation_tasks.py
@@ -0,0 +1,59 @@
+# SPDX-FileCopyrightText: 2024-2026 CERN
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""Tests for moderation tasks."""
+
+from zenodo_rdm.moderation.tasks import _render_breakdown
+
+
+def test_render_breakdown_groups_drivers_by_rule():
+    """Only score-moving reasons are listed, grouped under their rule subtotal."""
+    results = {
+        "link_rule": {
+            "label": "Links",
+            "score": 13,
+            "reasons": [
+                {"score": 5, "label": "7 links in description"},
+                {"score": 8, "label": "link to spam domain bad.ru"},
+            ],
+        },
+        # rule that fired nothing is omitted entirely
+        "metadata_spam_indicators_rule": {
+            "label": "Metadata spam indicators",
+            "score": 0,
+            "reasons": [{"score": 0, "label": "2 emoji in metadata"}],
+        },
+    }
+    assert _render_breakdown(results) == (
+        "<ul>"
+        "<li>Links (13)<ul>"
+        "<li>+5 7 links in description</li>"
+        "<li>+8 link to spam domain bad.ru</li>"
+        "</ul></li>"
+        "</ul>"
+    )
+
+
+def test_render_breakdown_escapes_labels():
+    """Labels embed spammer-controlled text, so they must be HTML-escaped."""
+    results = {
+        "link_rule": {
+            "label": "Links",
+            "score": 8,
+            "reasons": [{"score": 8, "label": "link to <script>alert(1)</script>"}],
+        },
+    }
+    rendered = _render_breakdown(results)
+    assert "<script>" not in rendered
+    assert "&lt;script&gt;alert(1)&lt;/script&gt;" in rendered
+
+
+def test_render_breakdown_empty_when_nothing_fired():
+    """A record where no reason moved the score renders no breakdown."""
+    results = {
+        "link_rule": {
+            "label": "Links",
+            "score": 0,
+            "reasons": [{"score": 0, "label": "1 link"}],
+        },
+    }
+    assert _render_breakdown(results) == ""
diff --git a/site/tests/moderation/test_rules.py b/site/tests/moderation/test_rules.py
new file mode 100644
index 000000000..0e1b5f97b
--- /dev/null
+++ b/site/tests/moderation/test_rules.py
@@ -0,0 +1,295 @@
+# SPDX-FileCopyrightText: 2024-2026 CERN
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""Tests for moderation scoring rules."""
+
+from datetime import datetime, timezone
+from io import BytesIO
+
+import pytest
+from flask_principal import Need
+from invenio_access.permissions import system_identity
+from invenio_rdm_records.proxies import current_rdm_records_service as records_service
+from invenio_search import current_search_client
+
+from zenodo_rdm.moderation.models import LinkDomain, LinkDomainStatus
+from zenodo_rdm.moderation.percolator import (
+    create_percolator_index,
+    get_percolator_index,
+    index_percolate_query,
+)
+from zenodo_rdm.moderation.proxies import current_scores
+from zenodo_rdm.moderation.rules import (
+    FileRule,
+    LinkRule,
+    MatchQueryRule,
+    MetadataSpamIndicatorsRule,
+    OwnerVerifiedRule,
+    extract_emojis,
+    extract_links,
+)
+
+
+@pytest.mark.parametrize(
+    "text,expected",
+    [
+        # href targets and bare URLs are both extracted, in order
+        ('<a href="http://bad.ru/x">click</a>', ["http://bad.ru/x"]),
+        ("see http://a.com and www.b.org", ["http://a.com", "www.b.org"]),
+        (
+            'mix <a href="http://h.com">x</a> http://bare.com',
+            ["http://h.com", "http://bare.com"],
+        ),
+        ("no links here", []),
+        # repeated URLs are NOT deduplicated: each occurrence counts toward
+        # the >5 excess-links threshold
+        ("http://a.com http://a.com", ["http://a.com", "http://a.com"]),
+    ],
+)
+def test_extract_links(text, expected):
+    """Links are extracted from hrefs and bare URLs, without deduplication."""
+    assert extract_links(text) == expected
+
+
+@pytest.mark.parametrize(
+    "text,expected_count",
+    [
+        ("plain ascii text", 0),
+        ("hi 😀 there 🎉 ok 🚀", 3),
+        # a dense run of emoji (classic spam) counts every emoji, so it trips
+        # the >3 threshold rather than counting as a single match
+        ("😀😀😀😀", 4),
+    ],
+)
+def test_extract_emojis_counts_individual_emoji(text, expected_count):
+    """Each emoji is counted, so emoji-spam runs trip the >3 threshold."""
+    assert len(extract_emojis(text)) == expected_count
+
+
+@pytest.fixture()
+def spam_query(running_app, db):
+    """A percolator spam query matching a distinctive title, scored as spam.
+
+    The percolator index isn't invenio-managed, so the search fixture won't
+    clean it; we wipe and recreate it per test to keep queries from piling up.
+    """
+    record_cls = records_service.record_cls
+    index = get_percolator_index(record_cls)
+    current_search_client.indices.delete(index=index, ignore=[400, 404])
+    create_percolator_index(record_cls)
+    index_percolate_query(
+        record_cls,
+        query_id="q-spam-title",
+        query_string="metadata.title:Spammacious",
+        active=True,
+        score=8,
+        notes="spammy title",
+    )
+    current_search_client.indices.refresh(index=index)
+    yield {"score": 8, "notes": "spammy title"}
+    current_search_client.indices.delete(index=index, ignore=[400, 404])
+
+
+@pytest.fixture()
+def spam_record_data(minimal_record):
+    """Metadata-only record data whose title matches the spam query."""
+    return {
+        **minimal_record,
+        "files": {"enabled": False},
+        "metadata": {**minimal_record["metadata"], "title": "Spammacious"},
+    }
+
+
+def test_match_query_rule_matches_published_record(spam_query, spam_record_data):
+    """A published record whose title matches a spam query is scored."""
+    item = records_service.create(system_identity, spam_record_data)
+    record = records_service.publish(system_identity, item.id)._record
+
+    result = MatchQueryRule()(system_identity, record=record)
+
+    assert result.score == spam_query["score"]
+    assert [r.code for r in result.reasons] == ["matched_query"]
+    reason = result.reasons[0]
+    assert reason.query_id == "q-spam-title"
+    assert reason.notes == spam_query["notes"]
+
+
+def test_match_query_rule_matches_draft(spam_query, spam_record_data):
+    """A draft is percolated against the records index (no drafts index exists).
+
+    Regression for re-evaluating moderation on a draft: the rule must drop the
+    draft-only fields the strict records mapping rejects and still match.
+    """
+    draft = records_service.create(system_identity, spam_record_data)._record
+    assert draft.is_draft  # guard: we are exercising the draft path
+
+    result = MatchQueryRule()(system_identity, draft=draft)
+
+    assert result.score == spam_query["score"]
+    assert [r.code for r in result.reasons] == ["matched_query"]
+
+
+def test_match_query_rule_no_match(spam_query, minimal_record):
+    """A record that matches no spam query scores zero with no reasons."""
+    data = {**minimal_record, "files": {"enabled": False}}
+    item = records_service.create(system_identity, data)
+    record = records_service.publish(system_identity, item.id)._record
+
+    result = MatchQueryRule()(system_identity, record=record)
+
+    assert result.score == 0
+    assert result.reasons == []
+
+
+@pytest.fixture()
+def banned_domain(db):
+    """A banned link domain."""
+    domain = LinkDomain.create("spam.example", LinkDomainStatus.BANNED)
+    db.session.commit()
+    return domain
+
+
+def test_link_rule_flags_excess_links_and_banned_domains(
+    running_app, db, banned_domain, minimal_record
+):
+    """A description full of links to a banned domain is scored as spam."""
+    links = " ".join(f"http://spam.example/{i}" for i in range(6))
+    data = {
+        **minimal_record,
+        "files": {"enabled": False},
+        "metadata": {**minimal_record["metadata"], "description": f"Visit {links}"},
+    }
+    item = records_service.create(system_identity, data)
+    record = records_service.publish(system_identity, item.id)._record
+
+    result = LinkRule()(system_identity, record=record)
+
+    excess = [r for r in result.reasons if r.code == "excess_description_links"]
+    assert len(excess) == 1
+    assert excess[0].score == current_scores.excess_links  # 6 links > 5
+
+    domains = [r for r in result.reasons if r.code == "link_domain"]
+    assert domains
+    assert all(r.status == "spam" for r in domains)
+    assert all(r.score == current_scores.spam_link for r in domains)
+    assert all(r.domain == "spam.example" for r in domains)
+    assert all(r.label.endswith("domain spam.example") for r in domains)
+
+
+def test_metadata_spam_indicators_rule_flags_excess_emoji(
+    running_app, db, minimal_record
+):
+    """A description with more than three emoji is flagged."""
+    data = {
+        **minimal_record,
+        "files": {"enabled": False},
+        "metadata": {
+            **minimal_record["metadata"],
+            "description": "Amazing 🎉🎉🎉🎉 work",
+        },
+    }
+    item = records_service.create(system_identity, data)
+    record = records_service.publish(system_identity, item.id)._record
+
+    result = MetadataSpamIndicatorsRule()(system_identity, record=record)
+
+    by_code = {r.code: r for r in result.reasons}
+    assert by_code["excess_emoji"].count >= 4
+    assert by_code["excess_emoji"].score == current_scores.spam_emoji
+    assert by_code["excess_header_tags"].score == 0
+
+
+def _make_owner(UserFixture, app, db, email, verified_at):
+    """Create a user with a given verification timestamp."""
+    u = UserFixture(email=email, password="123456")
+    u.create(app, db)
+    u.user.verified_at = verified_at
+    db.session.commit()
+    # Resolving is_verified in tests needs an authenticated identity.
+    u.identity.provides.add(Need(method="system_role", value="authenticated_user"))
+    return u
+
+
+@pytest.fixture()
+def unverified_owner(UserFixture, app, db):
+    """A record owner whose account is not verified."""
+    return _make_owner(UserFixture, app, db, "unverified@test.org", None)
+
+
+@pytest.fixture()
+def verified_owner(UserFixture, app, db):
+    """A record owner whose account is verified."""
+    return _make_owner(
+        UserFixture, app, db, "verified@test.org", datetime.now(timezone.utc)
+    )
+
+
+def test_owner_verified_rule_unverified_owner(
+    running_app, db, unverified_owner, minimal_record
+):
+    """An unverified owner adds the unverified-user score."""
+    data = {**minimal_record, "files": {"enabled": False}}
+    item = records_service.create(unverified_owner.identity, data)
+    record = records_service.publish(unverified_owner.identity, item.id)._record
+
+    reason = OwnerVerifiedRule()(unverified_owner.identity, record=record).reasons[0]
+
+    assert reason.verified is False
+    assert reason.score == current_scores.unverified_user
+
+
+def test_owner_verified_rule_verified_owner(
+    running_app, db, verified_owner, minimal_record
+):
+    """A verified owner subtracts via the verified-user score."""
+    data = {**minimal_record, "files": {"enabled": False}}
+    item = records_service.create(verified_owner.identity, data)
+    record = records_service.publish(verified_owner.identity, item.id)._record
+
+    reason = OwnerVerifiedRule()(verified_owner.identity, record=record).reasons[0]
+
+    assert reason.verified is True
+    assert reason.score == current_scores.verified_user
+
+
+def _publish_with_files(identity, data, files):
+    """Create a draft, upload files, and publish it."""
+    data = {**data, "files": {"enabled": True}}
+    draft = records_service.create(identity, data)
+    recid = draft.id
+    records_service.draft_files.init_files(
+        identity, recid, [{"key": key} for key, _ in files]
+    )
+    for key, content in files:
+        records_service.draft_files.set_file_content(
+            identity, recid, key, BytesIO(content)
+        )
+        records_service.draft_files.commit_file(identity, recid, key)
+    return records_service.publish(identity, recid)._record
+
+
+def test_file_rule_flags_spam_files(running_app, db, minimal_record):
+    """A few small files with a spam extension add the spam-files score."""
+    record = _publish_with_files(
+        system_identity, minimal_record, [("malware.pdf", b"x" * 10)]
+    )
+
+    result = FileRule()(system_identity, record=record)
+
+    assert any(r.code == "file_stats" for r in result.reasons)
+    spam = [r for r in result.reasons if r.code == "spam_files"]
+    assert len(spam) == 1
+    assert spam[0].score == current_scores.spam_files
+    assert "pdf" in spam[0].extensions
+
+
+def test_file_rule_flags_ham_files(running_app, db, minimal_record):
+    """Many files indicate a genuine record and add the ham-files score."""
+    files = [(f"data{i}.txt", b"content") for i in range(5)]
+    record = _publish_with_files(system_identity, minimal_record, files)
+
+    result = FileRule()(system_identity, record=record)
+
+    ham = [r for r in result.reasons if r.code == "ham_files"]
+    assert len(ham) == 1
+    assert ham[0].score == current_scores.ham_files
+    assert not [r for r in result.reasons if r.code == "spam_files"]
diff --git a/site/zenodo_rdm/moderation/base.py b/site/zenodo_rdm/moderation/base.py
new file mode 100644
index 000000000..97e50a433
--- /dev/null
+++ b/site/zenodo_rdm/moderation/base.py
@@ -0,0 +1,45 @@
+# SPDX-FileCopyrightText: 2024-2026 CERN
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""Base contract for ZenodoRDM moderation rules.
+
+A rule is a callable returning a ``RuleResult`` that holds the typed ``Reason``
+objects explaining how its score was reached. Reasons are narrated even when
+they score zero, so a rule expected to fire but that didn't can still be
+inspected. All types serialize cleanly via ``dataclasses.asdict``.
+"""
+
+from dataclasses import dataclass, field
+
+
+@dataclass(frozen=True)
+class Reason:
+    """A single scored observation made by a rule."""
+
+    score: float
+    label: str
+
+
+@dataclass(frozen=True)
+class RuleResult:
+    """Outcome of a rule: its reasons and the derived total score."""
+
+    reasons: list[Reason]
+    score: float = field(init=False)
+
+    def __post_init__(self):
+        """Derive the total score from the reasons."""
+        object.__setattr__(self, "score", sum(r.score for r in self.reasons))
+
+
+class Rule:
+    """Base class for moderation scoring rules."""
+
+    label: str
+
+    def __call__(self, identity, draft=None, record=None) -> RuleResult:
+        """Resolve the draft/record and delegate to ``evaluate``."""
+        return self.evaluate(identity, record if record is not None else draft)
+
+    def evaluate(self, identity, record) -> RuleResult:
+        """Score the given record (or draft); implemented by each rule."""
+        raise NotImplementedError
diff --git a/site/zenodo_rdm/moderation/config.py b/site/zenodo_rdm/moderation/config.py
index ef6ad12ae..011107e8b 100644
--- a/site/zenodo_rdm/moderation/config.py
+++ b/site/zenodo_rdm/moderation/config.py
@@ -1,13 +1,13 @@
-# SPDX-FileCopyrightText: 2024 CERN
+# SPDX-FileCopyrightText: 2024-2026 CERN
 # SPDX-License-Identifier: GPL-3.0-or-later
 """Moderation config."""
 
 from .rules import (
-    files_rule,
-    links_rule,
-    match_query_rule,
-    text_sanitization_rule,
-    verified_user_rule,
+    FileRule,
+    LinkRule,
+    MatchQueryRule,
+    MetadataSpamIndicatorsRule,
+    OwnerVerifiedRule,
 )
 
 MODERATION_SCORES = {
@@ -41,19 +41,19 @@
 """List of users exempt from moderation."""
 
 MODERATION_RECORD_SCORE_RULES = {
-    "verified_user_rule": verified_user_rule,
-    "links_rule": links_rule,
-    "files_rule": files_rule,
-    "text_sanitization_rule": text_sanitization_rule,
-    "match_query_rule": match_query_rule,
+    "owner_verified_rule": OwnerVerifiedRule(),
+    "link_rule": LinkRule(),
+    "file_rule": FileRule(),
+    "metadata_spam_indicators_rule": MetadataSpamIndicatorsRule(),
+    "match_query_rule": MatchQueryRule(),
 }
 """Scoring rules for record moderation."""
 
 MODERATION_COMMUNITY_SCORE_RULES = {
-    "links_rule": links_rule,
-    "text_sanitization_rule": text_sanitization_rule,
-    "verified_user_rule": verified_user_rule,
-    "match_query_rule": match_query_rule,
+    "link_rule": LinkRule(),
+    "metadata_spam_indicators_rule": MetadataSpamIndicatorsRule(),
+    "owner_verified_rule": OwnerVerifiedRule(),
+    "match_query_rule": MatchQueryRule(),
 }
 """Scoring rules for communtiy moderation."""
 
diff --git a/site/zenodo_rdm/moderation/handlers.py b/site/zenodo_rdm/moderation/handlers.py
index fd25d5c29..dd01bdf7a 100644
--- a/site/zenodo_rdm/moderation/handlers.py
+++ b/site/zenodo_rdm/moderation/handlers.py
@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: 2024 CERN
+# SPDX-FileCopyrightText: 2024-2026 CERN
 # SPDX-License-Identifier: GPL-3.0-or-later
 """Handlers for ZenodoRDM Moderation.
 
@@ -23,6 +23,8 @@
   admins manually.
 """
 
+from dataclasses import asdict
+
 import invenio_rdm_records.services.communities.moderation as community_moderation
 from flask import current_app
 from invenio_access.permissions import system_identity
@@ -55,7 +57,7 @@ def rules(self):
 
     def evaluate_result(self, params):
         """Evaluate aggregate result based on params."""
-        return sum(params.values())
+        return sum(result.score for result in params.values())
 
     @property
     def should_apply_actions(self):
@@ -81,10 +83,14 @@ def run(self, identity, draft=None, record=None, user=None, uow=None):
                 results[name] = rule(identity, draft=draft, record=record)
 
             evaluation = self.evaluate_result(results)
+            obj = record if record is not None else draft
             action_ctx = {
                 "user_id": user.id,
-                "record_pid": record.pid.pid_value,
-                "results": results,
+                "record_pid": obj.pid.pid_value,
+                "results": {
+                    name: {"label": self.rules[name].label, **asdict(result)}
+                    for name, result in results.items()
+                },
                 "evaluation": evaluation,
             }
             current_app.logger.debug("Moderation score calculated", extra=action_ctx)
diff --git a/site/zenodo_rdm/moderation/models.py b/site/zenodo_rdm/moderation/models.py
index a5b502eb6..19327210a 100644
--- a/site/zenodo_rdm/moderation/models.py
+++ b/site/zenodo_rdm/moderation/models.py
@@ -41,6 +41,11 @@ def create(cls, domain, status, score=None, reason=None):
         db.session.add(ld)
         return ld
 
+    @property
+    def domain_name(self):
+        """Return the domain in display order."""
+        return ".".join(reversed(self.domain.strip(".").split(".")))
+
     @classmethod
     def lookup_domain(cls, url):
         """Lookup the status of a URL's domain."""
diff --git a/site/zenodo_rdm/moderation/rules.py b/site/zenodo_rdm/moderation/rules.py
index 81fd3d6a6..ef44ddcb3 100644
--- a/site/zenodo_rdm/moderation/rules.py
+++ b/site/zenodo_rdm/moderation/rules.py
@@ -1,12 +1,20 @@
-# SPDX-FileCopyrightText: 2024 CERN
+# SPDX-FileCopyrightText: 2024-2026 CERN
 # SPDX-License-Identifier: GPL-3.0-or-later
-"""Rules for moderation."""
+"""Rules for moderation.
+
+Each rule's reason types are nested in the rule that produces them, so a rule
+reads as one self-contained unit. See ``base.py`` for the ``Rule``/``Reason``/
+``RuleResult`` contract these build on.
+"""
 
 import re
+from dataclasses import dataclass, field
 
 from flask import current_app
+from invenio_rdm_records.proxies import current_rdm_records_service
 from invenio_search import current_search_client
 
+from .base import Reason, Rule, RuleResult
 from .models import LinkDomain, LinkDomainStatus
 from .percolator import get_percolator_index
 from .proxies import current_scores
@@ -22,7 +30,7 @@
     "\U0001f1e0-\U0001f1ff"  # Flags (iOS)
     "\U00002700-\U000027bf"  # Dingbats
     "\U000024c2-\U0001f251"  # Enclosed characters
-    "]+",
+    "]",
     flags=re.UNICODE,
 )
 
@@ -50,107 +58,257 @@ def extract_links(text):
 #
 # Rules
 #
-def links_rule(identity, draft=None, record=None):
-    """Calculate a moderation score based on links found in record metadata."""
-    score = 0
-    description_links = extract_links(str(record.metadata.get("description", "")))
-
-    if len(description_links) > 5:
-        score += current_scores.excess_links
-
-    extracted_links = extract_links(str(record.metadata))
-
-    for link in extracted_links:
-        domain = LinkDomain.lookup_domain(link)
-        if domain is None:
-            continue
-        default_score = (
-            current_scores.ham_link
-            if domain.status == LinkDomainStatus.SAFE
-            else current_scores.spam_link
-        )
-        if domain.score is not None:
-            score += domain.score
-        else:
-            score += default_score
+class LinkRule(Rule):
+    """Score based on links found in record metadata."""
 
-    return score
+    label = "Links"
 
+    @dataclass(frozen=True)
+    class Excess(Reason):
+        """Number of links found in the description."""
 
-def text_sanitization_rule(identity, draft=None, record=None):
-    """Calculate a score based on excessive emoji and HTML tag usage in metadata text."""
-    record_text = " ".join(map(str, record.metadata.values()))
-    htag_count = len(re.findall(r"<h[1-9]\b[^>]*>", record_text, re.IGNORECASE))
-    score = 0
+        code: str = field(default="excess_description_links", init=False)
+        count: int = 0
 
-    if len(extract_emojis(record_text)) > 3:
-        score += current_scores.spam_emoji
+    @dataclass(frozen=True)
+    class Domain(Reason):
+        """A known domain (safe or spam) linked from the metadata."""
 
-    if htag_count > 4:
-        score += current_scores.spam_header_tags
+        code: str = field(default="link_domain", init=False)
+        domain: str = ""
+        status: str = ""
 
-    return score
+    def evaluate(self, identity, record) -> RuleResult:
+        """Score the record's links."""
+        reasons = []
 
+        description_links = extract_links(str(record.metadata.get("description", "")))
+        reasons.append(
+            self.Excess(
+                score=current_scores.excess_links if len(description_links) > 5 else 0,
+                label=f"{len(description_links)} links in description",
+                count=len(description_links),
+            )
+        )
 
-def verified_user_rule(identity, draft=None, record=None):
-    """Adjust moderation score based on the verification status of the user."""
-    is_verified = (
-        getattr(record.parent, "is_verified", None)
-        if hasattr(record, "parent")
-        else getattr(record, "is_verified", False)
-    )
-    return (
-        current_scores.unverified_user
-        if not is_verified
-        else current_scores.verified_user
-    )
+        for link in extract_links(str(record.metadata)):
+            domain = LinkDomain.lookup_domain(link)
+            if domain is None:
+                continue
+            is_safe = domain.status == LinkDomainStatus.SAFE
+            default = current_scores.ham_link if is_safe else current_scores.spam_link
+            reasons.append(
+                self.Domain(
+                    score=domain.score if domain.score is not None else default,
+                    label=f"link to {'safe' if is_safe else 'spam'} domain {domain.domain_name}",
+                    domain=domain.domain_name,
+                    status="safe" if is_safe else "spam",
+                )
+            )
+
+        return RuleResult(reasons=reasons)
+
+
+class MetadataSpamIndicatorsRule(Rule):
+    """Score based on excessive emoji and HTML tag usage in metadata text."""
+
+    label = "Metadata spam indicators"
+
+    @dataclass(frozen=True)
+    class Emoji(Reason):
+        """Count of emoji found in the metadata text."""
+
+        code: str = field(default="excess_emoji", init=False)
+        count: int = 0
+
+    @dataclass(frozen=True)
+    class HeaderTags(Reason):
+        """Count of HTML header tags found in the metadata text."""
+
+        code: str = field(default="excess_header_tags", init=False)
+        count: int = 0
+
+    def evaluate(self, identity, record) -> RuleResult:
+        """Score the record's metadata text."""
+        record_text = " ".join(map(str, record.metadata.values()))
+        emoji_count = len(extract_emojis(record_text))
+        htag_count = len(re.findall(r"<h[1-9]\b[^>]*>", record_text, re.IGNORECASE))
+
+        return RuleResult(
+            reasons=[
+                self.Emoji(
+                    score=current_scores.spam_emoji if emoji_count > 3 else 0,
+                    label=f"{emoji_count} emoji in metadata",
+                    count=emoji_count,
+                ),
+                self.HeaderTags(
+                    score=current_scores.spam_header_tags if htag_count > 4 else 0,
+                    label=f"{htag_count} header tags in metadata",
+                    count=htag_count,
+                ),
+            ]
+        )
 
 
-def files_rule(identity, draft=None, record=None):
-    """Calculate score based on the number, size, and type of files associated with the record."""
-    score = 0
+class OwnerVerifiedRule(Rule):
+    """Adjust score based on the verification status of the owner."""
 
-    files_count = record.files.count
-    data_size = record.files.total_bytes
-    exts = {filename.split(".")[-1].lower() for filename in record.files.entries.keys()}
+    label = "Owner verified"
 
-    max_spam_file_size = current_app.config.get("MODERATION_MAX_SPAM_FILE_SIZE")
-    min_ham_file_size = current_app.config.get("MODERATION_MIN_HAM_FILE_SIZE")
-    spam_exts = len(
-        exts.intersection(current_app.config.get("MODERATION_SPAM_FILE_EXTS"))
-    )
+    @dataclass(frozen=True)
+    class Verification(Reason):
+        """Verification status of the record/community owner."""
 
-    if files_count <= 4 and data_size < max_spam_file_size and spam_exts > 0:
-        score += current_scores.spam_files
-
-    if files_count > 4 or data_size > min_ham_file_size:
-        score += current_scores.ham_files
-
-    return score
-
-
-def match_query_rule(identity, draft=None, record=None):
-    """Calculate a score based on matched percolate queries against the given document in the specified index."""
-    document = record.dumps()
-    percolator_index = get_percolator_index(record)
-    if percolator_index:
-        matched_queries = current_search_client.search(
-            index=percolator_index,
-            body={
-                "query": {
-                    "bool": {
-                        "must": [
-                            {"term": {"active": True}},
-                            {"percolate": {"field": "query", "document": document}},
-                        ]
-                    }
-                }
-            },
+        code: str = field(default="user_verification", init=False)
+        verified: bool = False
+
+    def evaluate(self, identity, record) -> RuleResult:
+        """Score the owner's verification status."""
+        is_verified = (
+            getattr(record.parent, "is_verified", None)
+            if hasattr(record, "parent")
+            else getattr(record, "is_verified", False)
         )
+        return RuleResult(
+            reasons=[
+                self.Verification(
+                    score=(
+                        current_scores.verified_user
+                        if is_verified
+                        else current_scores.unverified_user
+                    ),
+                    label=f"owner is {'verified' if is_verified else 'unverified'}",
+                    verified=bool(is_verified),
+                )
+            ]
+        )
+
 
-    score = 0
+class FileRule(Rule):
+    """Score based on the number, size, and type of files on the record."""
 
-    for hit in matched_queries["hits"]["hits"]:
-        query_score = hit["_source"].get("score", 0)
-        score += query_score
-    return score
+    label = "Files"
+
+    @dataclass(frozen=True)
+    class Stats(Reason):
+        """Informational snapshot of the record's files (always score 0)."""
+
+        code: str = field(default="file_stats", init=False)
+        files_count: int = 0
+        total_bytes: int = 0
+        extensions: tuple = ()
+
+    @dataclass(frozen=True)
+    class Spam(Reason):
+        """Few small files with a spam-associated extension."""
+
+        code: str = field(default="spam_files", init=False)
+        extensions: tuple = ()
+
+    @dataclass(frozen=True)
+    class Ham(Reason):
+        """Many files or a large payload, indicative of a genuine record."""
+
+        code: str = field(default="ham_files", init=False)
+
+    def evaluate(self, identity, record) -> RuleResult:
+        """Score the record's files."""
+        files_count = record.files.count
+        data_size = record.files.total_bytes
+        exts = {fn.split(".")[-1].lower() for fn in record.files.entries.keys()}
+
+        max_spam_file_size = current_app.config.get("MODERATION_MAX_SPAM_FILE_SIZE")
+        min_ham_file_size = current_app.config.get("MODERATION_MIN_HAM_FILE_SIZE")
+        spam_exts = exts.intersection(
+            current_app.config.get("MODERATION_SPAM_FILE_EXTS")
+        )
+
+        reasons = [
+            self.Stats(
+                score=0,
+                label=f"{files_count} files, {data_size} bytes",
+                files_count=files_count,
+                total_bytes=data_size,
+                extensions=tuple(sorted(exts)),
+            )
+        ]
+
+        if files_count <= 4 and data_size < max_spam_file_size and spam_exts:
+            reasons.append(
+                self.Spam(
+                    score=current_scores.spam_files,
+                    label=f"few small files with spam extensions {sorted(spam_exts)}",
+                    extensions=tuple(sorted(spam_exts)),
+                )
+            )
+
+        if files_count > 4 or data_size > min_ham_file_size:
+            reasons.append(
+                self.Ham(
+                    score=current_scores.ham_files,
+                    label="many files or large payload",
+                )
+            )
+
+        return RuleResult(reasons=reasons)
+
+
+class MatchQueryRule(Rule):
+    """Score based on matched percolate queries against the document."""
+
+    label = "Match query"
+
+    @dataclass(frozen=True)
+    class Match(Reason):
+        """A percolator spam query that matched the document."""
+
+        code: str = field(default="matched_query", init=False)
+        query_id: int = 0
+        notes: str = ""
+
+    def evaluate(self, identity, record) -> RuleResult:
+        """Score the record against the percolator spam queries."""
+        document = record.dumps()
+        # Drafts have no percolator index of their own; percolate against the
+        # published-records index and drop draft-only fields the strict mapping rejects.
+        index_cls = record
+        if getattr(record, "is_draft", False):
+            document.pop("expires_at", None)
+            document.pop("fork_version_id", None)
+            index_cls = current_rdm_records_service.record_cls
+        percolator_index = get_percolator_index(index_cls)
+
+        reasons = []
+        if percolator_index:
+            matched_queries = current_search_client.search(
+                index=percolator_index,
+                body={
+                    "query": {
+                        "bool": {
+                            "must": [
+                                {"term": {"active": True}},
+                                {
+                                    "percolate": {
+                                        "field": "query",
+                                        "document": document,
+                                    }
+                                },
+                            ]
+                        }
+                    }
+                },
+            )
+            for hit in matched_queries["hits"]["hits"]:
+                source = hit["_source"]
+                notes = source.get("notes") or ""
+                reasons.append(
+                    self.Match(
+                        score=source.get("score", 0),
+                        label=f"matched spam query #{source.get('id')}"
+                        + (f": {notes}" if notes else ""),
+                        query_id=source.get("id"),
+                        notes=notes,
+                    )
+                )
+
+        return RuleResult(reasons=reasons)
diff --git a/site/zenodo_rdm/moderation/tasks.py b/site/zenodo_rdm/moderation/tasks.py
index b76342fd2..b8b1ed55f 100644
--- a/site/zenodo_rdm/moderation/tasks.py
+++ b/site/zenodo_rdm/moderation/tasks.py
@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: 2024 CERN
+# SPDX-FileCopyrightText: 2024-2026 CERN
 # SPDX-License-Identifier: GPL-3.0-or-later
 """Tasks for moderation."""
 
@@ -22,6 +22,7 @@
 from invenio_requests.services.user_moderation.errors import OpenRequestAlreadyExists
 from invenio_search.engine import dsl
 from invenio_users_resources.proxies import current_users_service as users_service
+from markupsafe import escape
 
 
 @shared_task(ignore_result=True)
@@ -95,14 +96,33 @@ def update_moderation_request(user_id, action_ctx):
                 f' (<a href="/communities/{content_pid}">Community {content_pid}</a>)'
             )
 
+        breakdown = _render_breakdown(action_ctx.get("results", {}))
         comment = dict(
-            payload={"content": f"<p>Final evaluation: {evaluation}{content}</p>"}
+            payload={
+                "content": f"<p>Final evaluation: {evaluation}{content}</p>{breakdown}"
+            }
         )
         events_service.create(system_identity, req, comment, CommentEventType, uow=uow)
 
         uow.commit()
 
 
+def _render_breakdown(results):
+    """Render the score-moving reasons per rule as an HTML list for the comment."""
+    groups = []
+    for name, result in results.items():
+        drivers = [reason for reason in result["reasons"] if reason["score"]]
+        if not drivers:
+            continue
+        items = "".join(
+            f"<li>{reason['score']:+} {escape(reason['label'])}</li>"
+            for reason in drivers
+        )
+        label = escape(result.get("label", name))
+        groups.append(f"<li>{label} ({result['score']})<ul>{items}</ul></li>")
+    return f"<ul>{''.join(groups)}</ul>" if groups else ""
+
+
 @shared_task(ignore_result=True)
 def run_moderation_handlers(user_id, record_id=None, community_id=None):
     """Run the content moderation handlers for a record or community."""