feat: emit OVOS-INTENT-2 §4.3 entity/slot blacklist on registration (#454)

Load the sibling `<entity>.blacklist` / `<slot>.blacklist` locale files and
carry their slot-value exclusions in the registration payloads so intent
engines can drop blacklisted slot values (e.g. a `person.blacklist` of pronouns
keeps "he" out of `{person}`).

- register_entity_file loads `<entity>.blacklist` and emits it as `blacklist`
  on the `padatious:register_entity` payload.
- register_intent_file scans each `{slot}` the template declares, loads the
  sibling `<slot>.blacklist`, and emits `slot_blacklist` keyed by slot name on
  the `padatious:register_intent` payload.

Both fields default empty (list / dict), keeping the payload shape-stable and
backward compatible. Mirrors the existing `<intent>.blacklist` suppression.

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: JarbasAl

ovos_workshop/intents.py

@@ -1,6 +1,6 @@
 from os.path import exists
 from threading import RLock
-from typing import List, Optional
+from typing import Dict, List, Optional
 import warnings
 from ovos_bus_client.message import Message, dig_for_message
 from ovos_bus_client.util import get_mycroft_bus
@@ -270,13 +270,19 @@ def remove_adapt_context(self, context: str):
         self.bus.emit(msg.forward('remove_context', {'context': context}))
 
     def register_padatious_intent(self, intent_name: str, filename: str,
-                                  lang: str, string_blacklist: Optional[List[str]] = None):
+                                  lang: str, string_blacklist: Optional[List[str]] = None,
+                                  slot_blacklist: Optional[Dict[str, List[str]]] = None):
         """
         Register a Padatious intent file with the intent service.
         @param intent_name: Unique intent identifier
             (usually `skill_id`:`filename`)
         @param filename: Absolute file path to entity file
         @param lang: BCP-47 language code of registered intent
+        @param string_blacklist: OVOS-INTENT-2 §4.3 phrases that suppress this
+            intent from matching (the sibling `<intent>.blacklist`).
+        @param slot_blacklist: OVOS-INTENT-2 §4.3 slot-value exclusions keyed by
+            slot name, ``{slot: [excluded phrases]}`` — values that MUST NOT
+            fill the named ``{slot}`` (each slot's sibling `<slot>.blacklist`).
         """
         if not isinstance(filename, str):
             raise ValueError('Filename path must be a string')
@@ -289,21 +295,26 @@ def register_padatious_intent(self, intent_name: str, filename: str,
                 "samples": samples,
                 'name': intent_name,
                 'lang': lang,
-                'blacklisted_words': string_blacklist}
+                'blacklisted_words': string_blacklist,
+                'slot_blacklist': slot_blacklist or {}}
         msg = dig_for_message() or Message("")
         if "skill_id" not in msg.context:
             msg.context["skill_id"] = self.skill_id
         self.bus.emit(msg.forward("padatious:register_intent", data))
         self.registered_intents.append((intent_name.split(':')[-1], data))
 
     def register_padatious_entity(self, entity_name: str, filename: str,
-                                  lang: str):
+                                  lang: str,
+                                  blacklist: Optional[List[str]] = None):
         """
         Register a Padatious entity file with the intent service.
         @param entity_name: Unique entity identifier
             (usually `skill_id`:`filename`)
         @param filename: Absolute file path to entity file
         @param lang: BCP-47 language code of registered intent
+        @param blacklist: OVOS-INTENT-2 §4.3 slot-value exclusions — phrases
+            that MUST NOT fill the ``{slot}`` this entity supplies (the sibling
+            `<entity>.blacklist`).
         """
         if not isinstance(filename, str):
             raise ValueError('Filename path must be a string')
@@ -319,7 +330,8 @@ def register_padatious_entity(self, entity_name: str, filename: str,
                                   {'file_name': filename,
                                    "samples": samples,
                                    'name': entity_name,
-                                   'lang': lang}))
+                                   'lang': lang,
+                                   'blacklist': blacklist or []}))
 
     def get_intent_names(self):
         log_deprecation("Reference `intent_names` directly", "0.1.0")

ovos_workshop/skills/ovos.py

@@ -1346,12 +1346,28 @@ def register_intent_file(self, intent_file: str, handler: callable,
             for enty in voc_blacklist or []:
                 disallowed_strings += self.voc_list(enty, lang=lang)
 
-            # OVOS-INTENT-2: a sibling "<intent>.blacklist" locale file lists
-            # slot-free phrases that should suppress this intent from matching
+            # OVOS-INTENT-2 §4.3: a sibling "<intent>.blacklist" locale file
+            # lists slot-free phrases that should suppress this intent from
+            # matching
             blacklist_name = intent_file.rsplit(".", 1)[0]
             disallowed_strings += resources.load_blacklist_file(blacklist_name)
 
-            self.intent_service.register_padatious_intent(name, filename, lang, string_blacklist=disallowed_strings)
+            # OVOS-INTENT-2 §4.3: for each "{slot}" the template declares, a
+            # sibling "<slot>.blacklist" locale file lists slot-value
+            # exclusions — values that MUST NOT bind to that slot (the
+            # canonical use is keeping anaphoric pronouns out of a referential
+            # slot). Keyed by slot name so consuming engines can drop them.
+            slot_blacklist = {}
+            with open(filename) as f:
+                slots = set(re.findall(r"{(.+?)}", f.read()))
+            for slot in slots:
+                phrases = resources.load_blacklist_file(slot)
+                if phrases:
+                    slot_blacklist[slot] = phrases
+
+            self.intent_service.register_padatious_intent(
+                name, filename, lang, string_blacklist=disallowed_strings,
+                slot_blacklist=slot_blacklist)
         if handler:
             self.add_event(name, handler, 'mycroft.skill.handler',
                            activation=True, is_intent=True)
@@ -1383,7 +1399,13 @@ def register_entity_file(self, entity_file: str):
             filename = str(entity.file_path)
             name = f"{self.skill_id}:{basename(entity_file)}_" \
                    f"{md5(entity_file.encode('utf-8')).hexdigest()}"
-            self.intent_service.register_padatious_entity(name, filename, lang)
+            # OVOS-INTENT-2 §4.3: a sibling "<entity>.blacklist" locale file
+            # lists slot-free phrases that MUST NOT fill the {slot} this entity
+            # supplies (e.g. a "person.blacklist" of pronouns keeps "he" out of
+            # the {person} slot)
+            blacklist = resources.load_blacklist_file(entity_file)
+            self.intent_service.register_padatious_entity(name, filename, lang,
+                                                          blacklist=blacklist)
 
     def register_vocabulary(self, entity: str, entity_type: str,
                             lang: Optional[str] = None):

test/unittests/ovos_tskill_blacklist/locale/en-US/person.blacklist

@@ -0,0 +1,3 @@
+# pronouns must not fill {person}
+he
+she

test/unittests/ovos_tskill_blacklist/locale/en-US/person.entity

@@ -0,0 +1,2 @@
+alice
+bob

test/unittests/ovos_tskill_blacklist/locale/en-US/thing.blacklist

@@ -0,0 +1,3 @@
+# values that must not fill {thing}
+the news
+the alarm

test/unittests/skills/test_base.py

@@ -443,7 +443,7 @@ def test_register_intent_file(self):
         skill.config_core["secondary_langs"] = []
         skill.register_intent_file("time.intent", Mock(__name__="test"))
         skill.intent_service.register_padatious_intent.assert_called_once_with(
-            f"{skill.skill_id}:time.intent", en_intent_file, "en-US", string_blacklist=[])
+            f"{skill.skill_id}:time.intent", en_intent_file, "en-US", string_blacklist=[], slot_blacklist={})
 
         # With secondary language
         skill.intent_service.register_padatious_intent.reset_mock()
@@ -452,9 +452,9 @@ def test_register_intent_file(self):
         self.assertEqual(
             skill.intent_service.register_padatious_intent.call_count, 2)
         skill.intent_service.register_padatious_intent.assert_any_call(
-            f"{skill.skill_id}:time.intent", en_intent_file, "en-US", string_blacklist=[])
+            f"{skill.skill_id}:time.intent", en_intent_file, "en-US", string_blacklist=[], slot_blacklist={})
         skill.intent_service.register_padatious_intent.assert_any_call(
-            f"{skill.skill_id}:time.intent", uk_intent_file, "uk-UA", string_blacklist=[])
+            f"{skill.skill_id}:time.intent", uk_intent_file, "uk-UA", string_blacklist=[], slot_blacklist={})
 
     def test_register_entity_file(self):
         skill = OVOSSkill(bus=self.bus, skill_id=self.skill_id)
@@ -470,7 +470,7 @@ def test_register_entity_file(self):
         skill.register_entity_file("dow")
         skill.intent_service.register_padatious_entity.assert_called_once_with(
             f"{skill.skill_id}:dow_d446b2a6e46e7d94cdf7787e21050ff9",
-            en_file, "en-US")
+            en_file, "en-US", blacklist=[])
 
         # With secondary language
         skill.intent_service.register_padatious_entity.reset_mock()
@@ -480,10 +480,10 @@ def test_register_entity_file(self):
             skill.intent_service.register_padatious_entity.call_count, 2)
         skill.intent_service.register_padatious_entity.assert_any_call(
             f"{skill.skill_id}:dow_d446b2a6e46e7d94cdf7787e21050ff9",
-            en_file, "en-US")
+            en_file, "en-US", blacklist=[])
         skill.intent_service.register_padatious_entity.assert_any_call(
             f"{skill.skill_id}:dow_d446b2a6e46e7d94cdf7787e21050ff9",
-            uk_file, "uk-UA")
+            uk_file, "uk-UA", blacklist=[])
 
     def test_handle_enable_intent(self):
         # TODO

test/unittests/test_intent_service_interface.py

@@ -140,6 +140,7 @@ def test_register_intent(self):
 
         intent_service.register_padatious_intent('test', filename, lang='en-US')
         expected_data = {'file_name': '/tmp/test.intent', 'lang': 'en-US', 'name': 'test',
-                         'samples': ['this is a test', 'test the intent'], 'blacklisted_words': None}
+                         'samples': ['this is a test', 'test the intent'], 'blacklisted_words': None,
+                         'slot_blacklist': {}}
         self.check_emitter([expected_data])
 

test/unittests/test_skill.py

@@ -191,3 +191,64 @@ def test_voc_blacklist_param_still_merges(self):
         data = self._register_payload("foo.intent")
         self.assertIsNotNone(data)
         self.assertIn("turn on the news", data["blacklisted_words"])
+
+
+class TestSlotBlacklistFile(unittest.TestCase):
+    """OVOS-INTENT-2 §4.3: a sibling '<slot>.blacklist' / '<entity>.blacklist'
+    locale file feeds slot-value exclusions into the entity/intent
+    registration payload so engines can drop blacklisted slot values."""
+
+    def setUp(self):
+        self.bus = FakeBus()
+        self.bus.emitted_msgs = []
+
+        def get_msg(msg):
+            self.bus.emitted_msgs.append(json.loads(msg))
+
+        self.bus.on("message", get_msg)
+
+        res_dir = f"{dirname(__file__)}/ovos_tskill_blacklist"
+        self.skill = OVOSSkill(skill_id="blacklist.test", bus=self.bus,
+                               resources_dir=res_dir)
+
+    def _payload(self, msg_type, name_part):
+        for msg in self.bus.emitted_msgs:
+            if msg["type"] == msg_type and \
+                    name_part in msg["data"]["name"]:
+                return msg["data"]
+        return None
+
+    def test_entity_with_blacklist_file(self):
+        self.bus.emitted_msgs = []
+        self.skill.register_entity_file("person.entity")
+        data = self._payload("padatious:register_entity", "person")
+        self.assertIsNotNone(data)
+        self.assertEqual(data["samples"], ["alice", "bob"])
+        self.assertIn("he", data["blacklist"])
+        self.assertIn("she", data["blacklist"])
+
+    def test_entity_without_blacklist_file(self):
+        self.bus.emitted_msgs = []
+        # bar has no sibling .blacklist -> empty, back-compat
+        self.skill.register_entity_file("bar.entity")
+        data = self._payload("padatious:register_entity", "bar")
+        # bar.entity does not exist; nothing registered
+        self.assertIsNone(data)
+
+    def test_intent_slot_blacklist_keyed_by_slot(self):
+        self.bus.emitted_msgs = []
+        # foo.intent declares {thing}; sibling thing.blacklist excludes values
+        self.skill.register_intent_file("foo.intent", None)
+        data = self._payload("padatious:register_intent", "foo.intent")
+        self.assertIsNotNone(data)
+        self.assertIn("thing", data["slot_blacklist"])
+        self.assertIn("the news", data["slot_blacklist"]["thing"])
+        self.assertIn("the alarm", data["slot_blacklist"]["thing"])
+
+    def test_intent_without_slot_blacklist(self):
+        self.bus.emitted_msgs = []
+        # bar.intent has no slots -> empty map, back-compat
+        self.skill.register_intent_file("bar.intent", None)
+        data = self._payload("padatious:register_intent", "bar.intent")
+        self.assertIsNotNone(data)
+        self.assertEqual(data["slot_blacklist"], {})