feat: gate bus topics by legacy_namespace (PIPELINE-1 §8/§9.6, STOP-1 §4.2)

A skill emits either the legacy mycroft.* topics or the OVOS spec ovos.*
topics, chosen by the deployment 'legacy_namespace' config (default True) —
never both, so a subscriber never sees duplicate messages. Skills subscribe
on BOTH namespaces. Covers:
- handler-lifecycle trio: mycroft.skill.handler.* <-> ovos.intent.handler.* (§8)
- speak <-> ovos.utterance.speak (§9.6)
- stop ping/pong: {skill}.stop.ping/skill.stop.pong <-> ovos.stop.ping/ovos.stop.pong (§4.2)
- stop dispatch: also subscribe ovos.stop and {skill}:stop (§4.3/§5.3)

Adds dual-namespace unit tests (test/unittests/test_spec_bus_messages.py).

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

Author: JarbasAl

ovos_workshop/skills/ovos.py

@@ -1070,9 +1070,15 @@ def _register_system_event_handlers(self):
         """
         Register default messagebus event handlers
         """
+        # Stop topics: subscribe to BOTH the legacy and the OVOS-STOP-1 spec
+        # namespaces. Only one namespace is ever emitted (chosen by the
+        # 'legacy_namespace' config), so a subscriber never sees duplicates.
         self.add_event('mycroft.stop', self._handle_session_stop, speak_errors=False)
+        self.add_event('ovos.stop', self._handle_session_stop, speak_errors=False)  # STOP-1 §5.3
         self.add_event(f"{self.skill_id}.stop", self._handle_session_stop, speak_errors=False)
+        self.add_event(f"{self.skill_id}:stop", self._handle_session_stop, speak_errors=False)  # STOP-1 §4.3
         self.add_event(f"{self.skill_id}.stop.ping", self._handle_stop_ack, speak_errors=False)
+        self.add_event("ovos.stop.ping", self._handle_stop_ack, speak_errors=False)  # STOP-1 §4.2
         self.add_event(f"{self.skill_id}.converse.get_response", self.__handle_get_response, speak_errors=False)
 
         self.add_event('mycroft.skill.enable_intent', self.handle_enable_intent, speak_errors=False)
@@ -1142,15 +1148,28 @@ def handle_settings_change(self, message: Message):
                                        f"remote changes not handled!: {e}")
             self._start_filewatcher()
 
+    @staticmethod
+    def _legacy_namespace() -> bool:
+        """Whether to emit the legacy ``mycroft.*`` bus topics (default) or the
+        OVOS spec ``ovos.*`` topics, during the bus-namespace transition.
+
+        Deployment-wide, controlled by the ``legacy_namespace`` config key
+        (default ``True``). Emitters pick exactly one namespace so subscribers —
+        which listen on both — never receive duplicate messages.
+        """
+        return Configuration().get("legacy_namespace", True)
+
     def _handle_stop_ack(self, message: Message):
         """
-        Inform skills service if we want to handle stop. Individual skills
-        must implement the method self.can_stop to enable or
-        disable stop support.
-        @param message: `{self.skill_id}.stop.ping` Message
+        Answer a stoppability ping. Individual skills must implement the method
+        self.can_stop to enable or disable stop support. Replies on the legacy
+        ``skill.stop.pong`` or the spec ``ovos.stop.pong`` (OVOS-STOP-1 §4.2)
+        depending on the active namespace.
+        @param message: a ``{self.skill_id}.stop.ping`` or ``ovos.stop.ping`` Message
         """
+        topic = "skill.stop.pong" if self._legacy_namespace() else "ovos.stop.pong"
         self.bus.emit(message.reply(
-            "skill.stop.pong",
+            topic,
             data={"skill_id": self.skill_id,
                   "can_handle": self.can_stop(message)},
             context={"skill_id": self.skill_id}))
@@ -1423,6 +1442,16 @@ def handle_remove_cross_context(self, message: Message):
         context = message.data.get('context')
         self.remove_context(context)
 
+    def _intent_handler_data(self, message: Optional[Message],
+                             skill_data: dict) -> dict:
+        """Build the OVOS-PIPELINE-1 §8.2 handler-lifecycle payload
+        (``skill_id`` + ``intent_name``) on top of the legacy ``skill_data``."""
+        data = dict(skill_data)
+        data["skill_id"] = self.skill_id
+        if message is not None and ":" in message.msg_type:
+            data["intent_name"] = message.msg_type.split(":", 1)[-1]
+        return data
+
     def _on_event_start(self, message: Message, handler_info: str,
                         skill_data: dict, activation: Optional[bool] = None):
         """
@@ -1434,9 +1463,15 @@ def _on_event_start(self, message: Message, handler_info: str,
         """
         if handler_info:
             # Indicate that the skill handler is starting if requested
-            msg_type = handler_info + '.start'
             message.context["skill_id"] = self.skill_id
-            self.bus.emit(message.forward(msg_type, skill_data))
+            # OVOS-PIPELINE-1 §8 handler-lifecycle trio: legacy mycroft.skill.handler.*
+            # or spec ovos.intent.handler.* depending on the active namespace.
+            if handler_info == "mycroft.skill.handler" and not self._legacy_namespace():
+                self.bus.emit(message.forward(
+                    "ovos.intent.handler.start",
+                    self._intent_handler_data(message, skill_data)))
+            else:
+                self.bus.emit(message.forward(handler_info + '.start', skill_data))
 
     def _on_event_end(self, message: Message, handler_info: str,
                       skill_data: dict, is_intent: bool = False):
@@ -1445,9 +1480,14 @@ def _on_event_end(self, message: Message, handler_info: str,
         completed.
         """
         if handler_info:
-            msg_type = handler_info + '.complete'
             message.context["skill_id"] = self.skill_id
-            self.bus.emit(message.forward(msg_type, skill_data))
+            # OVOS-PIPELINE-1 §8: legacy or spec namespace.
+            if handler_info == "mycroft.skill.handler" and not self._legacy_namespace():
+                self.bus.emit(message.forward(
+                    "ovos.intent.handler.complete",
+                    self._intent_handler_data(message, skill_data)))
+            else:
+                self.bus.emit(message.forward(handler_info + '.complete', skill_data))
         if is_intent:
             self.bus.emit(message.forward("ovos.utterance.handled", skill_data))
 
@@ -1473,10 +1513,15 @@ def _on_event_error(self, error: str, message: Message, handler_info: str,
         skill_data['exception'] = repr(error)
         if handler_info:
             # Indicate that the skill handler errored
-            msg_type = handler_info + '.error'
             message = message or Message("")
             message.context["skill_id"] = self.skill_id
-            self.bus.emit(message.forward(msg_type, skill_data))
+            # OVOS-PIPELINE-1 §8: legacy or spec namespace.
+            if handler_info == "mycroft.skill.handler" and not self._legacy_namespace():
+                self.bus.emit(message.forward(
+                    "ovos.intent.handler.error",
+                    self._intent_handler_data(message, skill_data)))
+            else:
+                self.bus.emit(message.forward(handler_info + '.error', skill_data))
 
     def _register_adapt_intent(self,
                                intent_parser: Union[IntentBuilder, Intent, str],
@@ -1541,8 +1586,11 @@ def speak(self, utterance: str, expect_response: bool = False,
 
         # grab message that triggered speech so we can keep context
         message = dig_for_message()
-        m = message.forward("speak", data) if message \
-            else Message("speak", data)
+        # OVOS-PIPELINE-1 §9.6 natural-language response exit point: the legacy
+        # 'speak' topic or the spec 'ovos.utterance.speak', per active namespace.
+        topic = "speak" if self._legacy_namespace() else "ovos.utterance.speak"
+        m = message.forward(topic, data) if message \
+            else Message(topic, data)
         m.context["skill_id"] = self.skill_id
 
         # update any auto-translation metadata in message.context

test/unittests/test_spec_bus_messages.py

@@ -0,0 +1,74 @@
+"""Namespace bus-message tests for OVOSSkill.
+
+Each skill-emitted event goes out in exactly one namespace, chosen by the
+``legacy_namespace`` config (default True): the legacy ``mycroft.*`` topics or
+the OVOS spec ``ovos.*`` topics. Both modes are covered for the handler trio
+(PIPELINE-1 §8), speak (§9.6) and the stop pong (STOP-1 §4.2).
+"""
+import unittest
+
+from ovos_bus_client.message import Message
+from ovos_config.config import Configuration
+from ovos_utils.fakebus import FakeBus
+
+from ovos_workshop.skills.ovos import OVOSSkill
+
+
+class TestBusNamespace(unittest.TestCase):
+
+    def setUp(self):
+        self.bus = FakeBus()
+        self.skill = OVOSSkill(skill_id="test.skill", bus=self.bus)
+        self.seen = set()
+        for topic in ("speak", "ovos.utterance.speak",
+                      "skill.stop.pong", "ovos.stop.pong",
+                      "mycroft.skill.handler.start", "ovos.intent.handler.start"):
+            self.bus.on(topic, lambda m: self.seen.add(m.msg_type))
+
+    def tearDown(self):
+        Configuration()["legacy_namespace"] = True
+
+    # -- speak (PIPELINE-1 §9.6) ------------------------------------------
+    def test_speak_legacy_namespace(self):
+        Configuration()["legacy_namespace"] = True
+        self.skill.speak("hi")
+        self.assertIn("speak", self.seen)
+        self.assertNotIn("ovos.utterance.speak", self.seen)
+
+    def test_speak_spec_namespace(self):
+        Configuration()["legacy_namespace"] = False
+        self.skill.speak("hi")
+        self.assertIn("ovos.utterance.speak", self.seen)
+        self.assertNotIn("speak", self.seen)
+
+    # -- stop pong (STOP-1 §4.2) ------------------------------------------
+    def test_stop_pong_legacy_namespace(self):
+        Configuration()["legacy_namespace"] = True
+        self.skill._handle_stop_ack(Message("test.skill.stop.ping"))
+        self.assertIn("skill.stop.pong", self.seen)
+        self.assertNotIn("ovos.stop.pong", self.seen)
+
+    def test_stop_pong_spec_namespace(self):
+        Configuration()["legacy_namespace"] = False
+        self.skill._handle_stop_ack(Message("ovos.stop.ping"))
+        self.assertIn("ovos.stop.pong", self.seen)
+        self.assertNotIn("skill.stop.pong", self.seen)
+
+    # -- handler trio (PIPELINE-1 §8) -------------------------------------
+    def test_handler_start_legacy_namespace(self):
+        Configuration()["legacy_namespace"] = True
+        self.skill._on_event_start(Message("test.skill:greet"),
+                                   "mycroft.skill.handler", {"name": "h"})
+        self.assertIn("mycroft.skill.handler.start", self.seen)
+        self.assertNotIn("ovos.intent.handler.start", self.seen)
+
+    def test_handler_start_spec_namespace(self):
+        Configuration()["legacy_namespace"] = False
+        self.skill._on_event_start(Message("test.skill:greet"),
+                                   "mycroft.skill.handler", {"name": "h"})
+        self.assertIn("ovos.intent.handler.start", self.seen)
+        self.assertNotIn("mycroft.skill.handler.start", self.seen)
+
+
+if __name__ == "__main__":
+    unittest.main()