feat: emit INTENT-4 template registrations in the intent runner

The runner's _register_templates() only emitted the legacy
padatious:register_intent topic. kw-template-matcher (from 0.1.6a1)
also binds the OVOS-INTENT-4 §6 spec topic
ovos.intent.register.template and keys templates learned from it as
"skill_id:intent_name" — the same skill-prefixed form m2v-style
fighters return in IntentHandlerMatch.match_type. The runner never
emitted that topic, so its own transformer slot lookup (always keyed
by the bare, normalised intent id) could only ever hit the legacy-topic
registration.

Emit ovos.intent.register.template alongside the legacy topic (mirrored
onto the transformer bus, matching ovos-workshop's own dual-emit in
Skill.register_template()), and make _transform_slots try both the bare
and the "arena:<intent_id>" skill-prefixed lookup keys so a transformer
that only recognises the spec-form key still fills slots. Both
registration messages carry context={"skill_id": "arena"}: OVOS-INTENT-4
§3.1 engines key registration on message.context, not message.data.

Adds the floor pin keyword-template-matcher>=0.1.6a1 to the test extra.

Fail-before: with only the source change reverted,
test_register_templates_emits_spec_topic and
test_transform_slots_falls_back_to_skill_prefixed_key fail (2 failed,
23 passed in tests/test_intent_pipeline.py); with only the context
argument reverted, test_register_templates_emits_spec_topic fails with
KeyError: 'skill_id' on seen[0].context. All 25 pass with the fix. The
22 failures elsewhere in the suite fail identically on origin/dev in
the same venv (missing `datasets` and similar), unchanged by this
branch.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

Author: JarbasAl

pyproject.toml

@@ -90,6 +90,12 @@ test = [
     # test_intent_pipeline.py exercises the typed-slot stripping choke
     # point directly, so the test extra needs it self-sufficiently too.
     "ovos-spec-tools>=1.11.0a1",
+    # The intent-transformer tests (tests/test_intent_pipeline.py::
+    # TestIntentTransformers) exercise the real kw-template-matcher plugin
+    # against both the legacy padatious:register_intent topic and the
+    # OVOS-INTENT-4 ovos.intent.register.template spec topic; 0.1.6a1 is
+    # the floor that binds the spec topic.
+    "keyword-template-matcher>=0.1.6a1",
 ]
 lint = [
     "ruff>=0.6",

runner/intent_pipeline.py

@@ -306,15 +306,38 @@ def _register_templates(self, bus, rows: list[dict], extra_bus=None) -> None:
                 "samples": samples,
                 "lang": self.lang,
                 "skill_id": "arena",
-            })
+            }, {"skill_id": "arena"})
             bus.emit(msg)
+            # OVOS-INTENT-4 §6 spec topic — ovos-workshop's Skill.register_
+            # template() dual-emits this alongside the legacy padatious
+            # topic (see ovos_workshop.intents.PadatiousIntentContainer.
+            # register_template), and kw-template-matcher >=0.1.6a1 keys
+            # templates registered from it as "skill_id:intent_name"
+            # (kw_template_matcher.opm.KeywordTemplateMatcher.
+            # handle_register_template) rather than the bare name the
+            # legacy topic uses. Emitting both lets the transformer serve
+            # both a legacy-form and a spec-form (m2v-style, skill-
+            # prefixed) match_type; kw-template-matcher de-duplicates a
+            # template set registered twice under different topics for
+            # the same (lang, key), so this is not a double-count.
+            spec_msg = Message("ovos.intent.register.template", {
+                "skill_id": "arena",
+                "intent_name": intent_id,
+                "samples": samples,
+                "lang": self.lang,
+                "blacklist": [],
+                "slot_blacklist": {},
+            }, {"skill_id": "arena"})
+            bus.emit(spec_msg)
             # Mirror onto the intent-transformer bus (if configured) so
             # transformers that learn from registration traffic — e.g.
-            # kw-template-matcher's ``padatious:register_intent`` listener —
-            # see the same templates every pipeline plugin trains on,
-            # regardless of which stage ends up firing at predict() time.
+            # kw-template-matcher's ``padatious:register_intent`` and
+            # ``ovos.intent.register.template`` listeners — see the same
+            # templates every pipeline plugin trains on, regardless of
+            # which stage ends up firing at predict() time.
             if extra_bus is not None:
                 extra_bus.emit(msg)
+                extra_bus.emit(spec_msg)
 
         # Entities registered once per name — merged example values across
         # intents (some engines raise on re-registration)
@@ -405,26 +428,35 @@ def _transform_slots(
         """Run the winning match through the configured intent-transformer
         chain and return any slot keys it added.
 
-        Constructed with the normalised ``intent_id`` (not the engine's raw,
-        possibly skill-prefixed ``match_type``) so it lines up with the name
-        transformers like kw-template-matcher learned from
-        ``padatious:register_intent`` (see ``_register_templates``).
+        Transformers like kw-template-matcher key what they learned by the
+        topic the templates arrived on: the legacy ``padatious:
+        register_intent`` topic keys by the bare intent name, while the
+        spec ``ovos.intent.register.template`` topic keys by the skill-
+        prefixed ``"arena:<intent_id>"`` form used by ``IntentHandlerMatch.
+        match_type`` for m2v-style fighters (see ``_register_templates``).
+        Try both forms and keep whichever one the transformer actually
+        recognised.
         """
         from ovos_plugin_manager.templates.pipeline import IntentHandlerMatch
 
         before = set(match_data.keys())
-        handler_match = IntentHandlerMatch(
-            match_type=intent_id,
-            match_data=dict(match_data),
-            skill_id="arena",
-            utterance=utterance,
-        )
-        transformed = self._xformers.transform(handler_match)
-        tdata = transformed.match_data if isinstance(transformed.match_data, dict) else {}
-        return {
-            k: v for k, v in tdata.items()
-            if k not in before and k not in _META_KEYS and isinstance(v, str)
-        }
+        for match_type in (intent_id, f"arena:{intent_id}"):
+            handler_match = IntentHandlerMatch(
+                match_type=match_type,
+                match_data=dict(match_data),
+                skill_id="arena",
+                utterance=utterance,
+            )
+            transformed = self._xformers.transform(handler_match)
+            tdata = (transformed.match_data
+                     if isinstance(transformed.match_data, dict) else {})
+            new_slots = {
+                k: v for k, v in tdata.items()
+                if k not in before and k not in _META_KEYS and isinstance(v, str)
+            }
+            if new_slots:
+                return new_slots
+        return {}
 
     @staticmethod
     def _normalise(match_type: str) -> str:

tests/test_intent_pipeline.py

@@ -260,6 +260,52 @@ def test_slots_filled_with_transformer_configured(self):
         assert stage == "toy-label-pipeline-high"
         assert slots == {"song": "africa"}
 
+    def test_register_templates_emits_spec_topic(self):
+        # OVOS-INTENT-4 §6: ovos-workshop's Skill.register_template()
+        # dual-emits padatious:register_intent (legacy) and
+        # ovos.intent.register.template (spec) — the runner's own
+        # registration must do the same so transformers that only bind
+        # the spec topic (or key templates by its skill-prefixed form,
+        # like kw-template-matcher) still see the training data.
+        pipeline = _toy_pipeline(with_transformer=True)
+        seen = []
+        pipeline.xformer_bus.on(
+            "ovos.intent.register.template", lambda m: seen.append(m)
+        )
+
+        pipeline.train(TRAIN_ROWS)
+
+        assert len(seen) == 1
+        assert seen[0].context["skill_id"] == "arena"
+        assert seen[0].data["skill_id"] == "arena"
+        assert seen[0].data["intent_name"] == "play_song"
+        assert seen[0].data["lang"] == "en-us"
+        assert "play africa" in seen[0].data["samples"]
+
+    def test_transform_slots_falls_back_to_skill_prefixed_key(self):
+        # kw-template-matcher keys templates it learned from the spec
+        # topic as "skill_id:intent_name" (m2v's IntentHandlerMatch.
+        # match_type convention) rather than the bare name the legacy
+        # padatious topic uses. Register a template ONLY via the spec
+        # topic (bypassing train()'s legacy emission) and confirm the
+        # runner's lookup still finds it by trying the skill-prefixed
+        # form after the bare form misses.
+        from ovos_bus_client.message import Message
+
+        pipeline = _toy_pipeline(with_transformer=True)
+        pipeline.xformer_bus.emit(Message("ovos.intent.register.template", {
+            "skill_id": "arena",
+            "intent_name": "spec_only_intent",
+            "samples": ["play {song}"],
+            "lang": "en-us",
+        }))
+
+        slots = pipeline._transform_slots(
+            "spec_only_intent", {"conf": 1.0}, "play africa"
+        )
+
+        assert slots == {"song": "africa"}
+
     def test_no_slots_without_transformer_configured(self):
         pipeline = _toy_pipeline(with_transformer=False)
         pipeline.train(TRAIN_ROWS)