diff --git a/CHANGELOG.md b/CHANGELOG.md
index 16e2b751811..202fdbbbddd 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,14 @@
 # Changelog
 
+## [2.2.4a3](https://github.com/OpenVoiceOS/ovos-core/tree/2.2.4a3) (2026-06-28)
+
+[Full Changelog](https://github.com/OpenVoiceOS/ovos-core/compare/2.2.4a1...2.2.4a3)
+
+**Merged pull requests:**
+
+- test\(e2e\): fix transient test\_fallback\_match meta mismatch on dev [\#792](https://github.com/OpenVoiceOS/ovos-core/pull/792) ([JarbasAl](https://github.com/JarbasAl))
+- ci: wire shared opm-check workflow \(opm.pipeline entry-points\) [\#787](https://github.com/OpenVoiceOS/ovos-core/pull/787) ([JarbasAl](https://github.com/JarbasAl))
+
 ## [2.2.4a1](https://github.com/OpenVoiceOS/ovos-core/tree/2.2.4a1) (2026-06-28)
 
 [Full Changelog](https://github.com/OpenVoiceOS/ovos-core/compare/2.2.3a1...2.2.4a1)
diff --git a/ovos_core/intent_services/converse_service.py b/ovos_core/intent_services/converse_service.py
index aea52c66402..c28e88f48df 100644
--- a/ovos_core/intent_services/converse_service.py
+++ b/ovos_core/intent_services/converse_service.py
@@ -1,8 +1,9 @@
 import time
-from threading import Event
+from threading import Event, Lock, Timer
 from typing import Optional, Dict, List, Union
 
 from ovos_bus_client.client import MessageBusClient
+from ovos_bus_client.handler import HandlerLifecycle
 from ovos_bus_client.message import Message
 from ovos_bus_client.session import SessionManager, UtteranceState, Session
 from ovos_config.config import Configuration
@@ -14,12 +15,20 @@
 from ovos_plugin_manager.templates.pipeline import PipelinePlugin, IntentHandlerMatch
 from ovos_workshop.permissions import ConverseMode, ConverseActivationMode
 
+#: upper bound, seconds, on how long core waits for a skill's
+#: ``skill.converse.response`` before the dispatch lifecycle is declared a
+#: timeout (``mycroft.skill.handler.error``). Generous: converse handlers may
+#: legitimately run a while, but this must eventually backstop a silent skill so
+#: an orchestrator observing the done-signal never hangs on the in-flight
+#: dispatch.
+CONVERSE_HANDLER_TIMEOUT = 5 * 60
+
 
 class ConverseService(PipelinePlugin):
     """Intent Service handling conversational skills."""
 
     def __init__(self, bus: Optional[Union[MessageBusClient, FakeBus]] = None,
-                 config: Optional[Dict] = None):
+                 config: Optional[Dict] = None) -> None:
         config = config or Configuration().get("skills", {}).get("converse", {})
         super().__init__(bus, config)
         self._consecutive_activations = {}
@@ -31,7 +40,54 @@ def __init__(self, bus: Optional[Union[MessageBusClient, FakeBus]] = None,
         self.bus.on("converse:skill", self.handle_converse)
 
     def handle_converse(self, message: Message):
+        """Priority-based skill activation and deactivation. Tracks active skills per session, handles converse requests, and manages lifecycle events."""
         skill_id = message.data["skill_id"]
+        # the dispatch belongs to this session; only an ack carrying the same
+        # session may resolve it (a concurrent converse dispatch to the same
+        # skill in another session must not cross-resolve).
+        session_id = SessionManager.get(message).session_id
+
+        lifecycle = HandlerLifecycle(self.bus, message, skill_id=skill_id,
+                                     handler_name=f"{skill_id}.converse")
+
+        resolved = Event()
+        resolve_lock = Lock()
+
+        def _claim() -> bool:
+            with resolve_lock:
+                if resolved.is_set():
+                    return False
+                resolved.set()
+                return True
+
+        def _resolve_complete(msg: Message) -> None:
+            if msg.data.get("skill_id") and msg.data.get("skill_id") != skill_id:
+                return  # ack from a different skill, ignore
+            if "session" in msg.context and \
+                    SessionManager.get(msg).session_id != session_id:
+                return  # ack from a different session, ignore
+            if not _claim():
+                return
+            timer.cancel()
+            self.bus.remove("skill.converse.response", _resolve_complete)
+            lifecycle.complete()
+
+        def _resolve_timeout() -> None:
+            if not _claim():
+                return
+            self.bus.remove("skill.converse.response", _resolve_complete)
+            LOG.warning(f"converse dispatch to {skill_id} timed out after "
+                        f"{CONVERSE_HANDLER_TIMEOUT}s; emitting handler error")
+            lifecycle.error(TimeoutError(
+                f"converse handler timed out after {CONVERSE_HANDLER_TIMEOUT} seconds"))
+
+        timer = Timer(CONVERSE_HANDLER_TIMEOUT, _resolve_timeout)
+        timer.daemon = True
+
+        self.bus.on("skill.converse.response", _resolve_complete)
+        timer.start()
+        # mycroft.skill.handler.start, then the dispatch itself
+        lifecycle.start()
         self.bus.emit(message.reply(f"{skill_id}.converse.request", message.data))
 
     @property
@@ -58,7 +114,7 @@ def get_active_skills(message: Optional[Message] = None) -> List[str]:
         return [skill[0] for skill in session.active_skills]
 
     def deactivate_skill(self, skill_id: str, source_skill: Optional[str] = None,
-                         message: Optional[Message] = None):
+                         message: Optional[Message] = None) -> None:
         """Remove a skill from being targetable by converse.
 
         Args:
@@ -68,13 +124,13 @@ def deactivate_skill(self, skill_id: str, source_skill: Optional[str] = None,
         """
         source_skill = source_skill or skill_id
         if self._deactivate_allowed(skill_id, source_skill):
+            message = message or Message("")
             session = SessionManager.get(message)
             if session.is_active(skill_id):
                 # update converse session
                 session.deactivate_skill(skill_id)
 
                 # keep message.context
-                message = message or Message("")
                 message.context["session"] = session.serialize()  # update session active skills
                 # send bus event
                 self.bus.emit(
@@ -97,12 +153,12 @@ def activate_skill(self, skill_id: str, source_skill: Optional[str] = None,
         """
         source_skill = source_skill or skill_id
         if self._activate_allowed(skill_id, source_skill):
+            message = message or Message("")
             # update converse session
             session = SessionManager.get(message)
             session.activate_skill(skill_id)
 
             # keep message.context
-            message = message or Message("")
             message.context["session"] = session.serialize()  # update session active skills
             message = message.forward("intent.service.skills.activated",
                                       {"skill_id": skill_id})
@@ -159,7 +215,7 @@ def _activate_allowed(self, skill_id: str, source_skill: Optional[str] = None) -
         default_max = self.config.get("max_activations", -1)
         # per skill override limit of consecutive activations
         skill_max = self.config.get("skill_activations", {}).get(skill_id)
-        max_activations = skill_max or default_max
+        max_activations = skill_max if skill_max is not None else default_max
         if skill_id not in self._consecutive_activations:
             self._consecutive_activations[skill_id] = 0
         if max_activations < 0:
@@ -386,7 +442,7 @@ def handle_get_active_skills(self, message: Message):
         self.bus.emit(message.reply("intent.service.active_skills.reply",
                                     {"skills": self.get_active_skills(message)}))
 
-    def shutdown(self):
+    def shutdown(self) -> None:
         self.bus.remove("converse:skill", self.handle_converse)
         self.bus.remove('intent.service.skills.deactivate', self.handle_deactivate_skill_request)
         self.bus.remove('intent.service.skills.activate', self.handle_activate_skill_request)
diff --git a/ovos_core/intent_services/dispatcher.py b/ovos_core/intent_services/dispatcher.py
new file mode 100644
index 00000000000..a2e7fceee16
--- /dev/null
+++ b/ovos_core/intent_services/dispatcher.py
@@ -0,0 +1,220 @@
+# Copyright 2017 Mycroft AI Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+"""§7/§8 handler-lifecycle trio — dispatcher.
+
+Emits ``ovos.intent.handler.start`` before each ``<skill_id>:<intent_name>``
+dispatch and exactly one terminal (``complete``/``error``/timeout) after. The
+framework done-signal (``mycroft.skill.handler.complete``/``.error``) is consumed
+as the completion hint. A §8.3 timeout backstops every dispatch. The §9.5
+``ovos.utterance.handled`` end-marker is NOT this class's concern — the
+orchestrator's ``on_terminal`` callback is invoked after each §8 terminal.
+"""
+import threading
+from typing import Callable, Dict, List, Optional
+
+from ovos_bus_client.message import Message
+from ovos_spec_tools import SpecMessage
+from ovos_utils.log import LOG
+
+#: default upper bound on handler execution before §8.3 timeout fires, seconds.
+#: handlers are long-running by design (§6.5) so this is generous; set to 0 or a
+#: negative value (config ``intents.handler_timeout``) to disable the timer.
+DEFAULT_HANDLER_TIMEOUT = 5 * 60
+
+
+class _InFlightDispatch:
+    """A dispatch awaiting its §8 terminal."""
+
+    __slots__ = ("skill_id", "intent_name", "dispatch_msg", "timer", "resolved")
+
+    def __init__(self, skill_id: str, intent_name: str, dispatch_msg: Message):
+        self.skill_id = skill_id
+        self.intent_name = intent_name
+        self.dispatch_msg = dispatch_msg
+        self.timer: Optional[threading.Timer] = None
+        self.resolved = False
+
+
+class IntentDispatcher:
+    """Owns the PIPELINE-1 §7 dispatch + §8 handler-lifecycle trio.
+
+    Emits ``ovos.intent.handler.start`` before the ``<skill_id>:<intent_name>``
+    dispatch and exactly one terminal (``complete``/``error``/timeout) after. The
+    surrounding §6.1 orchestration — the §9.2 ``ovos.intent.matched`` notification,
+    skill activation, session update — lives in
+    ``IntentService._dispatch_match``, which hands a built dispatch Message to
+    :meth:`dispatch`. This class wires its own bus observers for the framework
+    done-signals (``mycroft.skill.handler.complete``/``.error``).
+    """
+
+    def __init__(self, bus, timeout: Optional[float] = DEFAULT_HANDLER_TIMEOUT,
+                 on_terminal: Optional[Callable[[Message], None]] = None):
+        self.bus = bus
+        self.timeout = timeout
+        # Called synchronously with the dispatch Message immediately AFTER each §8
+        # terminal (complete/error/timeout) is emitted, so the orchestrator can emit
+        # its §9.5 ovos.utterance.handled end-marker. Doing this in the same step
+        # (rather than via a separate bus subscription) guarantees the terminal is
+        # observed before the end-marker — otherwise a consumer subscribed to the
+        # terminal could emit the end-marker before the terminal is recorded.
+        self.on_terminal = on_terminal
+        # session_id -> stack of _InFlightDispatch (LIFO for nested lifecycles)
+        self._in_flight: Dict[str, List[_InFlightDispatch]] = {}
+        self._lock = threading.Lock()
+        # framework done-signals (legacy namespace; do NOT bridge to the spec trio)
+        self.bus.on("mycroft.skill.handler.complete", self._on_skill_complete)
+        self.bus.on("mycroft.skill.handler.error", self._on_skill_error)
+
+    def shutdown(self):
+        try:
+            self.bus.remove("mycroft.skill.handler.complete", self._on_skill_complete)
+            self.bus.remove("mycroft.skill.handler.error", self._on_skill_error)
+        except Exception:
+            LOG.exception("failed to remove done-signal handlers during shutdown")
+        with self._lock:
+            for stack in self._in_flight.values():
+                for entry in stack:
+                    entry.resolved = True
+                    if entry.timer is not None:
+                        entry.timer.cancel()
+            self._in_flight.clear()
+
+    # -- public API ------------------------------------------------------
+    def dispatch(self, dispatch_msg: Message,
+                 skill_id: Optional[str] = None,
+                 intent_name: Optional[str] = None):
+        """Dispatch a matched intent and own its §8 handler-lifecycle trio.
+
+        Emits ``ovos.intent.handler.start`` (§8.1), the dispatch on
+        ``<skill_id>:<intent_name>`` (§7), then exactly one terminal
+        (``complete``/``error``/timeout) once the handler reports. The dispatch goes
+        out asynchronously — this call does NOT block. The orchestrator reacts to the
+        §8 terminal to emit its §9.5 ``ovos.utterance.handled`` end-marker.
+
+        ``skill_id``/``intent_name`` default to the two halves of the dispatch
+        topic; the orchestrator passes them explicitly from its own ``Match`` so
+        they never come from the skill.
+        """
+        topic = dispatch_msg.msg_type
+        if skill_id is None:
+            skill_id = topic.split(":", 1)[0]
+        if intent_name is None:
+            intent_name = topic.split(":", 1)[-1]
+
+        entry = _InFlightDispatch(skill_id, intent_name, dispatch_msg)
+        sid = self._session_id(dispatch_msg)
+        with self._lock:
+            self._in_flight.setdefault(sid, []).append(entry)
+            if self.timeout and self.timeout > 0:
+                entry.timer = threading.Timer(self.timeout, self._on_timeout,
+                                              args=(sid, entry))
+                entry.timer.daemon = True
+                entry.timer.start()
+
+        # §8.1: start immediately before invoking (dispatching) the handler
+        self._emit(SpecMessage.INTENT_HANDLER_START, dispatch_msg,
+                   {"skill_id": skill_id, "intent_name": intent_name})
+        # §7: the dispatch itself
+        self.bus.emit(dispatch_msg)
+
+    # -- emission helpers ------------------------------------------------
+    @staticmethod
+    def _session_id(message: Message) -> str:
+        return (message.context.get("session") or {}).get("session_id", "default")
+
+    def _emit(self, topic, dispatch_msg: Message, data: dict):
+        """Emit a Message forwarded from the dispatch (§6.1 / §8 — context, incl.
+        session, preserved unchanged via MSG-1 §5.1 ``forward``)."""
+        self.bus.emit(dispatch_msg.forward(topic, data))
+
+    def _notify_terminal(self, dispatch_msg: Message):
+        """Tell the orchestrator a §8 terminal just fired so it can emit its §9.5
+        end-marker. Called after the terminal is on the bus, so the terminal is
+        always observed before the end-marker."""
+        if self.on_terminal is not None:
+            self.on_terminal(dispatch_msg)
+
+    # -- terminal resolution ---------------------------------------------
+    def _pop(self, sid: str, skill_id: Optional[str]) -> Optional[_InFlightDispatch]:
+        """Pop the most-recent unresolved in-flight dispatch for this session
+        whose ``skill_id`` matches (when known). LIFO so nested lifecycles
+        resolve innermost-first (§6.5)."""
+        with self._lock:
+            stack = self._in_flight.get(sid)
+            if not stack:
+                return None
+            for i in range(len(stack) - 1, -1, -1):
+                entry = stack[i]
+                if entry.resolved:
+                    continue
+                if skill_id and entry.skill_id != skill_id:
+                    continue
+                entry.resolved = True
+                stack.pop(i)
+                if not stack:
+                    self._in_flight.pop(sid, None)
+                if entry.timer is not None:
+                    entry.timer.cancel()
+                return entry
+            return None
+
+    def _on_skill_complete(self, message: Message):
+        """Framework done-signal -> ``complete`` (§8.1)."""
+        entry = self._pop(self._session_id(message), message.context.get("skill_id"))
+        if entry is None:
+            return
+        try:
+            self._emit(SpecMessage.INTENT_HANDLER_COMPLETE, entry.dispatch_msg,
+                       {"skill_id": entry.skill_id, "intent_name": entry.intent_name})
+        finally:
+            self._notify_terminal(entry.dispatch_msg)
+
+    def _on_skill_error(self, message: Message):
+        """Framework done-signal -> ``error`` with the exception (§8.2)."""
+        entry = self._pop(self._session_id(message), message.context.get("skill_id"))
+        if entry is None:
+            return
+        exception = (message.data.get("exception")
+                     or message.data.get("error")
+                     or "handler raised an exception")
+        try:
+            self._emit(SpecMessage.INTENT_HANDLER_ERROR, entry.dispatch_msg,
+                       {"skill_id": entry.skill_id,
+                        "intent_name": entry.intent_name,
+                        "exception": str(exception)})
+        finally:
+            self._notify_terminal(entry.dispatch_msg)
+
+    def _on_timeout(self, sid: str, entry: _InFlightDispatch):
+        """§8.3 — bound handler execution; on timeout emit ``error``."""
+        with self._lock:
+            if entry.resolved:
+                return
+            entry.resolved = True
+            entry.timer = None
+            stack = self._in_flight.get(sid)
+            if stack and entry in stack:
+                stack.remove(entry)
+                if not stack:
+                    self._in_flight.pop(sid, None)
+        LOG.warning(f"handler timeout for {entry.skill_id}:{entry.intent_name} "
+                    f"after {self.timeout}s; emitting ovos.intent.handler.error")
+        try:
+            self._emit(SpecMessage.INTENT_HANDLER_ERROR, entry.dispatch_msg,
+                       {"skill_id": entry.skill_id,
+                        "intent_name": entry.intent_name,
+                        "exception": f"handler timed out after {self.timeout} seconds"})
+        finally:
+            self._notify_terminal(entry.dispatch_msg)
diff --git a/ovos_core/intent_services/fallback_service.py b/ovos_core/intent_services/fallback_service.py
index bcf049d60a7..dad6a4607ae 100644
--- a/ovos_core/intent_services/fallback_service.py
+++ b/ovos_core/intent_services/fallback_service.py
@@ -16,9 +16,10 @@
 import threading
 import time
 from collections import namedtuple
-from typing import Optional, Dict, List, Union
+from typing import Callable, Dict, List, Optional, Tuple, Union
 
 from ovos_bus_client.client import MessageBusClient
+from ovos_bus_client.handler import HandlerLifecycle
 from ovos_bus_client.message import Message
 from ovos_bus_client.session import SessionManager
 from ovos_config import Configuration
@@ -36,17 +37,50 @@ class FallbackService(ConfidenceMatcherPipeline):
     """Intent Service handling fallback skills."""
 
     def __init__(self, bus: Optional[Union[MessageBusClient, FakeBus]] = None,
-                 config: Optional[Dict] = None):
-        config = config or Configuration().get("skills", {}).get("fallbacks", {})
+                 config: Optional[Dict] = None) -> None:
+        config = config if config is not None else Configuration().get("skills", {}).get("fallbacks", {})
         super().__init__(bus, config)
-        self.registered_fallbacks = {}  # skill_id: priority
+        self.registered_fallbacks: Dict[str, int] = {}  # skill_id: priority
+        # skill_id -> (start_handler, response_handler) wired for the
+        # done-signal translation, so they can be removed on deregister
+        self._lifecycle_handlers: Dict[str, Tuple[Callable, Callable]] = {}
         self._fallback_response_event = threading.Event()
         self.bus.on("ovos.skills.fallback.register", self.handle_register_fallback)
         self.bus.on("ovos.skills.fallback.deregister", self.handle_deregister_fallback)
 
-    def handle_register_fallback(self, message: Message):
+    def _wire_lifecycle(self, skill_id: str) -> None:
+        """Translate lifecycle done-signal for a fallback skill."""
+        if skill_id in self._lifecycle_handlers:
+            return
+
+        def _on_start(message: Message) -> None:
+            HandlerLifecycle(self.bus, message, skill_id=skill_id,
+                             handler_name=f"{skill_id}.fallback").start()
+
+        def _on_response(message: Message) -> None:
+            # .response is emitted whether or not a handler matched; the dispatch
+            # itself completed either way (the result bool is orthogonal to the
+            # handler lifecycle), so this is always ``complete``.
+            HandlerLifecycle(self.bus, message, skill_id=skill_id,
+                             handler_name=f"{skill_id}.fallback").complete()
+
+        self.bus.on(f"ovos.skills.fallback.{skill_id}.start", _on_start)
+        self.bus.on(f"ovos.skills.fallback.{skill_id}.response", _on_response)
+        self._lifecycle_handlers[skill_id] = (_on_start, _on_response)
+
+    def _unwire_lifecycle(self, skill_id: str) -> None:
+        handlers = self._lifecycle_handlers.pop(skill_id, None)
+        if not handlers:
+            return
+        start_handler, response_handler = handlers
+        self.bus.remove(f"ovos.skills.fallback.{skill_id}.start", start_handler)
+        self.bus.remove(f"ovos.skills.fallback.{skill_id}.response", response_handler)
+
+    def handle_register_fallback(self, message: Message) -> None:
         skill_id = message.data.get("skill_id")
-        priority = message.data.get("priority") or 101
+        priority = message.data.get("priority")
+        if priority is None:
+            priority = 101
 
         # check if .conf is overriding the priority for this skill
         priority_overrides = self.config.get("fallback_priorities", {})
@@ -57,10 +91,16 @@ def handle_register_fallback(self, message: Message):
         else:
             self.registered_fallbacks[skill_id] = priority
 
-    def handle_deregister_fallback(self, message: Message):
+        # report this skill's fallback dispatch lifecycle as the framework
+        # done-signal so an orchestrator can resolve it (no skill_id -> skip)
+        if skill_id:
+            self._wire_lifecycle(skill_id)
+
+    def handle_deregister_fallback(self, message: Message) -> None:
         skill_id = message.data.get("skill_id")
         if skill_id in self.registered_fallbacks:
             self.registered_fallbacks.pop(skill_id)
+        self._unwire_lifecycle(skill_id)
 
     def _fallback_allowed(self, skill_id: str) -> bool:
         """Checks if a skill_id is allowed to fallback
@@ -95,6 +135,8 @@ def _collect_fallback_skills(self, message: Message,
         fallback_skills = []  # skill_ids that want to handle fallback
 
         sess = SessionManager.get(message)
+        if sess is None:
+            return fallback_skills
         # filter skills outside the fallback_range
         in_range = [s for s, p in self.registered_fallbacks.items()
                     if fb_range.start < p <= fb_range.stop
@@ -152,6 +194,8 @@ def _fallback_range(self, utterances: List[str], lang: str,
         message.data["lang"] = lang
 
         sess = SessionManager.get(message)
+        if sess is None:
+            return None
         # new style bus api
         available_skills = self._collect_fallback_skills(message, fb_range)
         fallbacks = [(k, v) for k, v in self.registered_fallbacks.items()
@@ -190,6 +234,8 @@ def match_low(self, utterances: List[str], lang: str, message: Message) -> Optio
         return self._fallback_range(utterances, lang, message,
                                     FallbackRange(90, 101))
 
-    def shutdown(self):
+    def shutdown(self) -> None:
+        for skill_id in list(self._lifecycle_handlers):
+            self._unwire_lifecycle(skill_id)
         self.bus.remove("ovos.skills.fallback.register", self.handle_register_fallback)
         self.bus.remove("ovos.skills.fallback.deregister", self.handle_deregister_fallback)
diff --git a/ovos_core/intent_services/locale/ca-es/global_stop.voc b/ovos_core/intent_services/locale/ca-es/global_stop.voc
index 94a29474ac9..8f4a4e77339 100644
--- a/ovos_core/intent_services/locale/ca-es/global_stop.voc
+++ b/ovos_core/intent_services/locale/ca-es/global_stop.voc
@@ -1,8 +1,8 @@
 (atura|para)(|-ho) tot
 finalitza(|-ho) tot
 acaba(|-ho) tot
-cancel·la(-ho) tot
-(acaba|finalitza)(-ho) tot
+cancel·la-ho tot
+(acaba|finalitza)-ho tot
 para-ho tot
 avorta(-ho|) tot
 cessa tot
diff --git a/ovos_core/intent_services/locale/ca-es/stop.voc b/ovos_core/intent_services/locale/ca-es/stop.voc
index 68952b1e612..db73e93f622 100644
--- a/ovos_core/intent_services/locale/ca-es/stop.voc
+++ b/ovos_core/intent_services/locale/ca-es/stop.voc
@@ -1,6 +1,6 @@
 (atura|para)('t|)
 (prou|para|estop|stop) (de fer això|)
-(prou|para|estop|stop) (això)
+(prou|para|estop|stop) això
 (atura|para) el que estàs fent
 (atura|para) (això|ço)
 pots parar
diff --git a/ovos_core/intent_services/locale/de-de/global_stop.voc b/ovos_core/intent_services/locale/de-de/global_stop.voc
index 8e23ed2be8e..e1bb5185383 100644
--- a/ovos_core/intent_services/locale/de-de/global_stop.voc
+++ b/ovos_core/intent_services/locale/de-de/global_stop.voc
@@ -2,7 +2,7 @@ alles (stoppen|schließen|schliessen|beenden|abbrechen)
 (schließe|schließ|schliess|stop|stoppe|beende) alles
 beende alles
 (breche|brech) alles ab
-(breche|brech) (alles) ab
+(breche|brech) alles ab
 alles anhalten
 alles abbrechen
 alles aufgeben
diff --git a/ovos_core/intent_services/service.py b/ovos_core/intent_services/service.py
index 30aab6f1c08..55bdd9c6826 100644
--- a/ovos_core/intent_services/service.py
+++ b/ovos_core/intent_services/service.py
@@ -17,7 +17,7 @@
 import re
 import time
 from collections import defaultdict
-from typing import Tuple, Callable, List
+from typing import Optional, Tuple, Callable, List
 
 import requests
 from ovos_bus_client.message import Message
@@ -32,6 +32,7 @@
 from ovos_utils.thread_utils import create_daemon
 
 from ovos_core.transformers import MetadataTransformersService, UtteranceTransformersService, IntentTransformersService
+from ovos_core.intent_services.dispatcher import IntentDispatcher, DEFAULT_HANDLER_TIMEOUT
 from ovos_plugin_manager.pipeline import OVOSPipelineFactory
 from ovos_plugin_manager.templates.pipeline import IntentHandlerMatch, ConfidenceMatcherPipeline
 
@@ -94,7 +95,7 @@ class IntentService:
     def __init__(self, bus, config=None, preload_pipelines=True,
                  alive_hook=on_alive, started_hook=on_started,
                  ready_hook=on_ready,
-                 error_hook=on_error, stopping_hook=on_stopping):
+                 error_hook=on_error, stopping_hook=on_stopping) -> None:
         """
         Initializes the IntentService with all intent parsing pipelines, transformer services, and messagebus event handlers.
 
@@ -110,16 +111,20 @@ def __init__(self, bus, config=None, preload_pipelines=True,
                                       on_error=error_hook,
                                       on_stopping=stopping_hook)
         self.bus = bus
-        self.status = ProcessStatus('intents', bus=self.bus, callback_map=callbacks)
+        self.status: ProcessStatus = ProcessStatus('intents', bus=self.bus, callback_map=callbacks)
         self.status.set_started()
-        self.config = config or Configuration().get("intents", {})
+        self.config: dict = config or Configuration().get("intents", {})
 
         # load and cache the plugins right away so they receive all bus messages
-        self.pipeline_plugins = {}
+        self.pipeline_plugins: dict = {}
 
-        self.utterance_plugins = UtteranceTransformersService(bus)
-        self.metadata_plugins = MetadataTransformersService(bus)
-        self.intent_plugins = IntentTransformersService(bus)
+        self.utterance_plugins: UtteranceTransformersService = UtteranceTransformersService(bus)
+        self.metadata_plugins: MetadataTransformersService = MetadataTransformersService(bus)
+        self.intent_plugins: IntentTransformersService = IntentTransformersService(bus)
+
+        handler_timeout = self.config.get("handler_timeout", DEFAULT_HANDLER_TIMEOUT)
+        self.intent_dispatcher: IntentDispatcher = IntentDispatcher(
+            bus, timeout=handler_timeout, on_terminal=self._emit_utterance_handled)
 
         # connection SessionManager to the bus,
         # this will sync default session across all components
@@ -136,7 +141,7 @@ def __init__(self, bus, config=None, preload_pipelines=True,
         self.bus.on('intent.service.intent.get', self.handle_get_intent)
 
         # internal, track skills that call self.deactivate to avoid reactivating them again
-        self._deactivations = defaultdict(list)
+        self._deactivations: defaultdict = defaultdict(list)
         self.bus.on('intent.service.skills.deactivate', self._handle_deactivate)
         self.bus.on('intent.service.pipelines.reload', self.handle_reload_pipelines)
 
@@ -272,38 +277,43 @@ def _handle_deactivate(self, message):
         skill_id = message.data.get("skill_id")
         self._deactivations[sess.session_id].append(skill_id)
 
-    def _emit_match_message(self, match: IntentHandlerMatch, message: Message, lang: str):
-        """
-        Emit a reply message for a matched intent, updating session and skill activation.
-
-        This method processes matched intents from either a pipeline matcher or an intent handler,
-        creating a reply message with matched intent details and managing skill activation.
+    def _emit_utterance_handled(self, dispatch_msg: Message):
+        """OVOS-PIPELINE-1 §9.5 — emit the universal ``ovos.utterance.handled``
+        end-marker once a matched handler reaches its §8 terminal.
+
+        Invoked by the dispatcher (``on_terminal``) right after a complete/error/
+        timeout terminal is on the bus — non-blocking, and ordered after the terminal
+        so consumers never see the end-marker first. The no-match and cancel paths
+        emit their own end-marker inline; together they give exactly one per
+        utterance."""
+        self.bus.emit(dispatch_msg.forward(SpecMessage.UTTERANCE_HANDLED, {}))
+
+    def _dispatch_match(self, match: IntentHandlerMatch, message: Message, lang: str,
+                        pipeline_id: str = None) -> None:
+        """Orchestrate the OVOS-PIPELINE-1 §6.1 post-match steps, then dispatch.
+
+        Runs the service-state-dependent post-match orchestration — the
+        intent-transformer chain (TRANSFORM-1 §3.4), skill activation +
+        ``{skill_id}.activate``, session update, and ``context['pipeline_id']``
+        stamping (§7.1) — builds the dispatch Message, emits the §9.2
+        ``ovos.intent.matched`` notification, and hands the dispatch Message to
+        the IntentDispatcher, which owns the §7 dispatch + §8 handler-lifecycle
+        trio.
 
         Args:
-            match (IntentHandlerMatch): The matched intent object containing
-                utterance and matching information.
-            message (Message): The original messagebus message that triggered the intent match.
-            lang (str): The language of the pipeline plugin match
-
-        Details:
-            - Handles two types of matches: PipelineMatch and IntentHandlerMatch
-            - Creates a reply message with matched intent data
-            - Activates the corresponding skill if not previously deactivated
-            - Updates session information
-            - Emits the reply message on the messagebus
-
-        Side Effects:
-            - Modifies session state
-            - Emits a messagebus event
-            - Can trigger skill activation events
+            match (IntentHandlerMatch): The matched intent (utterance, match_type,
+                skill_id, match_data, optional updated_session).
+            message (Message): The originating utterance Message to derive from.
+            lang (str): The content language of the match.
+            pipeline_id (str): The pipeline plugin that produced the match (§3.1).
 
         Returns:
             None
         """
         try:
             match = self.intent_plugins.transform(match)
-        except Exception as e:
-            LOG.error(f"Error in IntentTransformers: {e}")
+        except Exception:
+            LOG.exception("_dispatch_match failed")
 
         reply = None
         sess = match.updated_session or SessionManager.get(message)
@@ -332,9 +342,6 @@ def _emit_match_message(self, match: IntentHandlerMatch, message: Message, lang:
                 # ensure skill_id is present in message.context
                 reply.context["skill_id"] = match.skill_id
 
-                # NOTE: do not re-activate if the skill called self.deactivate
-                # we could also skip activation if skill is already active,
-                # but we still want to update the timestamp
                 was_deactivated = match.skill_id in self._deactivations[sess.session_id]
                 if not was_deactivated:
                     sess.activate_skill(match.skill_id)
@@ -344,8 +351,24 @@ def _emit_match_message(self, match: IntentHandlerMatch, message: Message, lang:
             # update Session if modified by pipeline
             reply.context["session"] = sess.serialize()
 
-            # finally emit reply message
-            self.bus.emit(reply)
+            # stamp the matching plugin's identity on the dispatch (§3.1, §7.1)
+            if pipeline_id:
+                reply.context["pipeline_id"] = pipeline_id
+
+            skill_id = (match.skill_id
+                        or (match.match_data or {}).get("skill_id")
+                        or reply.msg_type.split(":", 1)[0])
+            self.bus.emit(reply.forward(SpecMessage.INTENT_MATCHED, {
+                "skill_id": skill_id,
+                "intent_name": match.match_type,
+                "lang": lang,
+                "utterance": match.utterance,
+                "slots": dict(match.match_data or {}),
+                "pipeline_id": reply.context.get("pipeline_id"),
+            }))
+
+            intent_name = reply.msg_type.split(":", 1)[-1]
+            self.intent_dispatcher.dispatch(reply, skill_id, intent_name)
 
         else:  # upload intent metrics if enabled
             if self.config.get("open_data", {}).get("intent_urls"):
@@ -409,8 +432,9 @@ def send_cancel_event(self, message):
         sound = Configuration().get('sounds', {}).get('cancel', "snd/cancel.mp3")
         # NOTE: message.reply to ensure correct message destination
         self.bus.emit(message.reply('mycroft.audio.play_sound', {"uri": sound}))
-        self.bus.emit(message.reply("ovos.utterance.cancelled"))
-        self.bus.emit(message.reply("ovos.utterance.handled"))
+        # OVOS-PIPELINE-1 §6.4 cancellation terminal path: cancelled -> handled
+        self.bus.emit(message.reply(SpecMessage.UTTERANCE_CANCELLED))
+        self.bus.emit(message.reply(SpecMessage.UTTERANCE_HANDLED))
 
     def handle_utterance(self, message: Message):
         """Main entrypoint for handling user utterances
@@ -469,9 +493,20 @@ def handle_utterance(self, message: Message):
                     # if multilingual matching is enabled, attempt to match all user languages if main fails
                     langs += [l for l in get_valid_languages() if l != lang]
                 for intent_lang in langs:
-                    match = match_func(utterances, intent_lang, message)
+                    try:
+                        match = match_func(utterances, intent_lang, message)
+                    except Exception:
+                        # a misbehaving pipeline matcher (e.g. a malformed .voc
+                        # resource) must not abort the whole utterance — log and
+                        # treat it as a no-match so iteration continues.
+                        LOG.exception(f"{match_func} raised while matching "
+                                      f"'{intent_lang}'; treating as no-match")
+                        match = None
                     if match:
                         LOG.info(f"{pipeline} match ({intent_lang}): {match}")
+                        if match and not match.match_type:
+                            LOG.warning(f"Matcher {type(match_func).__name__} returned a match with empty match_type; skipping")
+                            continue
                         if match.skill_id and match.skill_id in (sess.blacklisted_skills or []):
                             LOG.debug(
                                 f"ignoring match, skill_id '{match.skill_id}' blacklisted by Session '{sess.session_id}'")
@@ -481,7 +516,8 @@ def handle_utterance(self, message: Message):
                                 f"ignoring match, intent '{match.match_type}' blacklisted by Session '{sess.session_id}'")
                             continue
                         try:
-                            self._emit_match_message(match, message, intent_lang)
+                            self._dispatch_match(match, message, intent_lang,
+                                                     pipeline_id=pipeline)
                             break
                         except Exception:
                             LOG.exception(f"{match_func} returned an invalid match")
@@ -505,7 +541,17 @@ def handle_utterance(self, message: Message):
         return match, message.context, stopwatch
 
     def send_complete_intent_failure(self, message):
-        """Send a message that no skill could handle the utterance.
+        """Emit the OVOS-PIPELINE-1 §9.3 no-match terminal.
+
+        The orchestrator owns the no-match branch of the §6.1 lifecycle: it plays
+        the error sound, emits ``ovos.intent.unmatched`` (§9.3 — the intent-layer
+        failure signal) and then the universal end-marker ``ovos.utterance.handled``
+        (§9.5). Exactly one ``ovos.utterance.handled`` terminates the utterance.
+
+        ``ovos.intent.unmatched`` is the spec replacement for the legacy
+        ``complete_intent_failure``; the two are bridged by ovos-spec-tools'
+        MIGRATION_MAP, so emitting the spec topic re-delivers the legacy one to
+        any consumer still subscribed to it.
 
         Args:
             message (Message): original message to forward from
@@ -513,8 +559,10 @@ def send_complete_intent_failure(self, message):
         sound = Configuration().get('sounds', {}).get('error', "snd/error.mp3")
         # NOTE: message.reply to ensure correct message destination
         self.bus.emit(message.reply('mycroft.audio.play_sound', {"uri": sound}))
-        self.bus.emit(message.reply('complete_intent_failure', message.data))
-        self.bus.emit(message.reply("ovos.utterance.handled"))
+        # §9.3: intent-layer failure signal (carries lang from message.data)
+        self.bus.emit(message.reply(SpecMessage.INTENT_UNMATCHED, message.data))
+        # §9.5: universal end-marker
+        self.bus.emit(message.reply(SpecMessage.UTTERANCE_HANDLED))
 
     @staticmethod
     def handle_add_context(message: Message):
@@ -605,7 +653,8 @@ def handle_get_intent(self, message):
         self.bus.emit(message.reply("intent.service.intent.reply",
                                     {"intent": None, "utterance": utterance}))
 
-    def shutdown(self):
+    def shutdown(self) -> None:
+        self.intent_dispatcher.shutdown()
         self.utterance_plugins.shutdown()
         self.metadata_plugins.shutdown()
         for pipeline in self.pipeline_plugins.values():
diff --git a/ovos_core/intent_services/stop_service.py b/ovos_core/intent_services/stop_service.py
index c7a5d7d9a22..f08723f43c2 100644
--- a/ovos_core/intent_services/stop_service.py
+++ b/ovos_core/intent_services/stop_service.py
@@ -1,46 +1,48 @@
-import re
-from os.path import dirname
+from os.path import dirname, join
 from threading import Event
 from typing import Optional, Dict, List, Union
 
 from ovos_bus_client.client import MessageBusClient
+from ovos_bus_client.handler import HandlerLifecycle
 from ovos_bus_client.message import Message
 from ovos_bus_client.session import SessionManager, UtteranceState
 
 from ovos_config.config import Configuration
 from ovos_plugin_manager.templates.pipeline import ConfidenceMatcherPipeline, IntentHandlerMatch
+from ovos_spec_tools import LocaleResources
 from ovos_utils import flatten_list
 from ovos_utils.fakebus import FakeBus
 from ovos_utils.log import LOG
 from ovos_utils.parse import match_one
-from ovos_workshop.app import OVOSAbstractApplication
 
 
-class StopService(ConfidenceMatcherPipeline, OVOSAbstractApplication):
+class StopService(ConfidenceMatcherPipeline):
     """Intent Service that handles stopping skills."""
 
     def __init__(self, bus: Optional[Union[MessageBusClient, FakeBus]] = None,
-                 config: Optional[Dict] = None):
-        # OVOSAbstractApplication provides voc_match, voc_list, and locale
-        # resource loading — same pattern as CommonQAService and OCPPipelineMatcher
-        OVOSAbstractApplication.__init__(self, bus=bus or FakeBus(),
-                                         skill_id="stop.openvoiceos",
-                                         resources_dir=f"{dirname(__file__)}")
-        config = config or Configuration().get("skills", {}).get("stop") or {}
+                 config: Optional[Dict] = None) -> None:
+        config = config if config is not None else Configuration().get("skills", {}).get("stop") or {}
+        bus = bus or FakeBus()
         ConfidenceMatcherPipeline.__init__(self, config=config, bus=bus)
+        self._locale = LocaleResources(skill_locale=join(dirname(__file__), "locale"))
         self.bus.on("stop:global", self.handle_global_stop)
         self.bus.on("stop:skill", self.handle_skill_stop)
 
     def handle_global_stop(self, message: Message) -> None:
-        """Emit a global mycroft.stop and mark the utterance handled."""
-        self.bus.emit(message.forward("mycroft.stop"))
-        # TODO - this needs a confirmation dialog if nothing was stopped
-        self.bus.emit(message.forward("ovos.utterance.handled"))
+        """Emit a global mycroft.stop; the §9.5 end-marker is the orchestrator's
+        responsibility (``IntentDispatcher._notify_terminal``)."""
+        with HandlerLifecycle(self.bus, message,
+                              skill_id="stop.openvoiceos",
+                              data={"name": "StopService.handle_global_stop"}):
+            self.bus.emit(message.forward("mycroft.stop"))
 
     def handle_skill_stop(self, message: Message) -> None:
         """Forward a stop request to the specific skill."""
         skill_id = message.data["skill_id"]
-        self.bus.emit(message.reply(f"{skill_id}.stop"))
+        with HandlerLifecycle(self.bus, message,
+                              skill_id="stop.openvoiceos",
+                              data={"name": "StopService.handle_skill_stop"}):
+            self.bus.emit(message.reply(f"{skill_id}.stop"))
 
     @staticmethod
     def get_active_skills(message: Optional[Message] = None) -> List[str]:
@@ -183,8 +185,8 @@ def match_high(self, utterances: List[str], lang: str, message: Message) -> Opti
         # we call flatten in case someone is sending the old style list of tuples
         utterance = flatten_list(utterances)[0]
 
-        is_stop = self.voc_match(utterance, 'stop', lang=lang, exact=True)
-        is_global_stop = self.voc_match(utterance, 'global_stop', lang=lang, exact=True) or \
+        is_stop = self._locale.voc_match(utterance, 'stop', lang, exact=True)
+        is_global_stop = self._locale.voc_match(utterance, 'global_stop', lang, exact=True) or \
                          (is_stop and not len(self.get_active_skills(message)))
 
         conf = 1.0
@@ -241,9 +243,9 @@ def match_medium(self, utterances: List[str], lang: str, message: Message) -> Op
         # we call flatten in case someone is sending the old style list of tuples
         utterance = flatten_list(utterances)[0]
 
-        is_stop = self.voc_match(utterance, 'stop', lang=lang, exact=False)
+        is_stop = self._locale.voc_match(utterance, 'stop', lang, exact=False)
         if not is_stop:
-            is_global_stop = self.voc_match(utterance, 'global_stop', lang=lang, exact=False) or \
+            is_global_stop = self._locale.voc_match(utterance, 'global_stop', lang, exact=False) or \
                              (is_stop and not len(self.get_active_skills(message)))
             if not is_global_stop:
                 return None
@@ -274,7 +276,7 @@ def match_low(self, utterances: List[str], lang: str, message: Message) -> Optio
         # we call flatten in case someone is sending the old style list of tuples
         utterance = flatten_list(utterances)[0]
 
-        stop_vocs = self.voc_list('stop', lang)
+        stop_vocs = self._locale.voc_list('stop', lang)
         if not stop_vocs:
             return None
 
diff --git a/pyproject.toml b/pyproject.toml
index a72f502ddbd..9cfa2639fec 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -15,13 +15,13 @@ dependencies = [
     "python-dateutil>=2.6, <3.0",
     "watchdog>=2.1, <3.0",
     "combo-lock>=0.2.2, <0.4",
-    "ovos-utils>=0.11.1a1,<1.0.0",
-    "ovos_bus_client>=2.2.0a1,<3.0.0",
+    "ovos-utils>=0.13.2a1,<1.0.0",
+    "ovos_bus_client>=2.6.0a1,<3.0.0",
     "ovos-plugin-manager>=2.5.0a1,<3.0.0",
     "ovos-config>=0.0.13,<3.0.0",
-    "ovos-workshop>=8.3.0a1,<10.0.0",
+    "ovos-workshop>=9.0.2a1,<10.0.0",
     "rapidfuzz>=3.6,<4.0",
-    "ovos-spec-tools[langcodes]>=0.9.0a1",
+    "ovos-spec-tools[langcodes]>=1.1.0a1,<2.0.0",
 ]
 
 [project.urls]
@@ -37,9 +37,9 @@ test = [
     "pytest-testmon>=2.1.3",
     "pytest-randomly>=3.16.0",
     "cov-core>=1.15.0",
-    "ovoscope>=1.0.0a1,<2.0.0",
-    "ovos-m2v-pipeline>=0.0.10a1,<1.0.0",
-    "ovos-adapt-parser>=1.3.1a1, <2.0.0",
+    "ovoscope>=1.4.0a1,<2.0.0",
+    "ovos-m2v-pipeline>=0.3.1a1,<1.0.0",
+    "ovos-adapt-parser>=1.4.2a1, <2.0.0",
     "ovos_padatious>=1.4.5a2,<2.0.0",
     "ovos-utterance-plugin-cancel>=0.3.0a1, <1.0.0",
     "ovos-skill-count>=0.0.3a4",
@@ -49,10 +49,10 @@ test = [
 ]
 mycroft = [
     "ovos_PHAL[extras]>=0.2.16a1,<1.0.0",
-    "ovos-audio[extras]>=2.0.1a1,<3.0.0",
-    "ovos-gui>=1.3.7a3,<2.0.0",
+    "ovos-audio[extras]>=2.1.1a1,<3.0.0",
+    "ovos-gui>=1.4.1a1,<2.0.0",
     "ovos-messagebus>=0.0.13a2,<1.0.0",
-    "ovos-dinkum-listener[extras]>=0.7.2a1,<1.0.0",
+    "ovos-dinkum-listener[extras]>=0.8.2a1,<1.0.0",
 ]
 lgpl = [
     "ovos_padatious>=1.4.5a2,<2.0.0",
@@ -66,20 +66,20 @@ plugins = [
     "ovos-utterance-normalizer>=0.2.5a1, <1.0.0",
     "ovos-number-parser>=0.5.2a2,<1.0.0",
     "ovos-date-parser>=0.7.0a5,<1.0.0",
-    "ovos-m2v-pipeline>=0.0.10a1,<1.0.0",
-    "ovos-common-query-pipeline-plugin>=1.1.12a5, <2.0.0",
-    "ovos-adapt-parser>=1.3.1a1, <2.0.0",
-    "ovos_ocp_pipeline_plugin>=1.1.21a5, <2.0.0",
-    "ovos-persona>=0.9.0a7,<1.0.0",
+    "ovos-m2v-pipeline>=0.3.1a1,<1.0.0",
+    "ovos-common-query-pipeline-plugin>=1.1.15a1, <2.0.0",
+    "ovos-adapt-parser>=1.4.2a1, <2.0.0",
+    "ovos_ocp_pipeline_plugin>=1.1.23a1, <2.0.0",
+    "ovos-persona>=0.9.0a11,<1.0.0",
     "padacioso>=1.0.0,<3.0.0",
     "keyword-template-matcher>=0.1.1,<1.0.0",
     "ahocorasick-ner>=0.1.1,<1.0.0",
 ]
 skills-essential = [
     "ovos-skill-fallback-unknown>=0.1.10a2",
-    "ovos-skill-alerts>=0.1.32a1",
-    "ovos-skill-personal>=0.1.23a3",
-    "ovos-skill-date-time>=1.1.10a4,<2.0.0",
+    "ovos-skill-alerts>=0.1.33a1",
+    "ovos-skill-personal>=0.1.24a1",
+    "ovos-skill-date-time>=1.1.11a1,<2.0.0",
     "ovos-skill-hello-world>=0.2.5a2",
     "ovos-skill-spelling>=0.2.7a1",
     "ovos-skill-diagnostics>=0.0.11a3",
diff --git a/test/end2end/conftest.py b/test/end2end/conftest.py
new file mode 100644
index 00000000000..8210d1dd381
--- /dev/null
+++ b/test/end2end/conftest.py
@@ -0,0 +1,17 @@
+"""End-to-end suite config: keep the §8.3 handler-timeout backstop short.
+
+The orchestrator (``IntentService``) blocks on each matched handler's §8 terminal
+before emitting the §9.5 ``ovos.utterance.handled`` end-marker. In production the
+backstop is 5 minutes (``DEFAULT_HANDLER_TIMEOUT``); in this suite every handler
+reports within a second — or is explicitly stopped — so a long backstop only buys a
+slow hang if a done-signal is ever dropped. Pin it low so such a regression fails
+fast (a few seconds) instead of stalling the whole run.
+"""
+import pytest
+
+
+@pytest.fixture(autouse=True)
+def patch_handler_timeout(monkeypatch):
+    monkeypatch.setattr(
+        "ovos_core.intent_services.service.DEFAULT_HANDLER_TIMEOUT", 10
+    )
diff --git a/test/end2end/test_activate.py b/test/end2end/test_activate.py
index cb4dc8409e6..08af652996d 100644
--- a/test/end2end/test_activate.py
+++ b/test/end2end/test_activate.py
@@ -12,7 +12,11 @@
 # legacy counterpart is derived via migration_counterpart, never hardcoded.
 SPEC_UTTERANCE = SpecMessage.UTTERANCE.value              # ovos.utterance.handle
 LEGACY_UTTERANCE = migration_counterpart(SPEC_UTTERANCE)  # recognizer_loop:utterance
-UTTERANCE_HANDLED = SpecMessage.UTTERANCE_HANDLED.value   # ovos.utterance.handled
+# PIPELINE-1 orchestrator-emitted matched-path messages: §9.2 ovos.intent.matched
+# (before dispatch) and §8.1 ovos.intent.handler.start. The converse:skill
+# dispatch is a reserved-name dispatch with no mycroft.skill.handler.* done-signal,
+# so its §8 terminal resolves via the §8.3 timeout (after the end-marker, not
+# captured here).
 
 # The two namespace paths the utterance-injecting scenario is run on.
 #   key       -> (modernize, emit_legacy, utterance_topic)
@@ -199,10 +203,25 @@ def _run_deactivate_inside_converse(self, namespace):
                 Message(f"{self.skill_id}.activate",
                         data={},
                         context={"skill_id": self.skill_id}),
+                # PIPELINE-1 §9.2: matched notification precedes the dispatch
+                Message(SpecMessage.INTENT_MATCHED,
+                        data={"skill_id": self.skill_id,
+                              "intent_name": "converse:skill"},
+                        context={"skill_id": self.skill_id}),
+                # PIPELINE-1 §8.1: orchestrator start immediately before the dispatch
+                Message(SpecMessage.INTENT_HANDLER_START,
+                        data={"skill_id": self.skill_id,
+                              "intent_name": "skill"},
+                        context={"skill_id": self.skill_id}),
                 Message("converse:skill",
                         data={"utterances": ["deactivate skill from within converse"], "lang": session.lang,
                               "skill_id": self.skill_id},
                         context={"skill_id": self.skill_id}),
+                # ConverseService reports the converse dispatch lifecycle to the
+                # orchestrator via the mycroft.skill.handler.* done-signal
+                Message("mycroft.skill.handler.start",
+                        data={"handler": f"{self.skill_id}.converse"},
+                        context={"skill_id": self.skill_id}),
                 Message(f"{self.skill_id}.converse.request",
                         data={"utterances": ["deactivate skill from within converse"], "lang": session.lang},
                         context={"skill_id": self.skill_id}),
@@ -220,7 +239,14 @@ def _run_deactivate_inside_converse(self, namespace):
                 Message("skill.converse.response",
                         data={"skill_id": self.skill_id},
                         context={"skill_id": self.skill_id}),
-                Message(UTTERANCE_HANDLED,
+                Message("mycroft.skill.handler.complete",
+                        data={"handler": f"{self.skill_id}.converse"},
+                        context={"skill_id": self.skill_id}),
+                # PIPELINE-1 §8 terminal: orchestrator correlates the done-signal
+                Message(SpecMessage.INTENT_HANDLER_COMPLETE,
+                        data={"skill_id": self.skill_id, "intent_name": "skill"},
+                        context={"skill_id": self.skill_id}),
+                Message(SpecMessage.UTTERANCE_HANDLED,
                         data={},
                         context={"skill_id": self.skill_id})
 
diff --git a/test/end2end/test_adapt.py b/test/end2end/test_adapt.py
index 748f77f1958..d844507aedc 100644
--- a/test/end2end/test_adapt.py
+++ b/test/end2end/test_adapt.py
@@ -27,6 +27,16 @@
 LEGACY_UTTERANCE = migration_counterpart(SPEC_UTTERANCE)
 SPEC_SPEAK = SpecMessage.SPEAK.value
 UTTERANCE_HANDLED = SpecMessage.UTTERANCE_HANDLED.value
+# PIPELINE-1 orchestrator-emitted matched-path messages: §9.2 ovos.intent.matched
+# (before dispatch) and the §8 handler-lifecycle trio (start before dispatch,
+# complete on the framework done-signal). The skill's own ovos.utterance.handled
+# (§9.5) is left to ovos-workshop on this matched path.
+INTENT_MATCHED = SpecMessage.INTENT_MATCHED.value
+HANDLER_START = SpecMessage.INTENT_HANDLER_START.value
+HANDLER_COMPLETE = SpecMessage.INTENT_HANDLER_COMPLETE.value
+# PIPELINE-1 §9.3: the no-match / all-filtered terminal is ovos.intent.unmatched
+# (the spec replacement for the legacy complete_intent_failure).
+INTENT_UNMATCHED = SpecMessage.INTENT_UNMATCHED.value
 
 NAMESPACE_PATHS = {
     "spec": (False, False, SPEC_UTTERANCE),
@@ -47,56 +57,79 @@ def _run_adapt_match(self, namespace):
         modernize, emit_legacy, utt_topic = NAMESPACE_PATHS[namespace]
         minicroft = get_minicroft([self.skill_id], modernize=modernize,
                                   emit_legacy=emit_legacy)
-
-        session = Session("123")
-        session.lang = "en-US"
-        session.pipeline = ['ovos-adapt-pipeline-plugin-high']
-        message = Message(utt_topic,
-                          {"utterances": ["hello world"], "lang": session.lang},
-                          {"session": session.serialize(), "source": "A", "destination": "B"})
-
-        final_session = deepcopy(session)
-        final_session.active_skills = [(self.skill_id, 0.0)]
-
-        test = End2EndTest(
-            minicroft=minicroft,
-            skill_ids=[self.skill_id],
-            flip_points=[utt_topic],
-            entry_points=[utt_topic],
-            source_message=message,
-            final_session=final_session,
-            activation_points=[f"{self.skill_id}:HelloWorldIntent"],
-            expected_messages=[
-                message,
-                Message(f"{self.skill_id}.activate",
-                        data={},
-                        context={"skill_id": self.skill_id}),
-                Message(f"{self.skill_id}:HelloWorldIntent",
-                        data={"utterance": "hello world", "lang": session.lang},
-                        context={"skill_id": self.skill_id}),
-                Message("mycroft.skill.handler.start",
-                        data={"name": "HelloWorldSkill.handle_hello_world_intent"},
-                        context={"skill_id": self.skill_id}),
-                Message(SPEC_SPEAK,
-                        data={"utterance": "Hello world",
-                              "expect_response": False,
-                              "meta": {
-                                  "dialog": "hello.world",
-                                  "data": {},
-                                  "skill": self.skill_id
-                              }},
-                        context={"skill_id": self.skill_id}),
-                Message("mycroft.skill.handler.complete",
-                        data={"name": "HelloWorldSkill.handle_hello_world_intent"},
-                        context={"skill_id": self.skill_id}),
-                Message(UTTERANCE_HANDLED,
-                        data={},
-                        context={"skill_id": self.skill_id}),
-            ]
-        )
-
-        test.execute(timeout=10)
-        minicroft.stop()
+        try:
+
+            session = Session("123")
+            session.lang = "en-US"
+            session.pipeline = ['ovos-adapt-pipeline-plugin-high']
+            message = Message(utt_topic,
+                              {"utterances": ["hello world"], "lang": session.lang},
+                              {"session": session.serialize(), "source": "A", "destination": "B"})
+
+            final_session = deepcopy(session)
+            final_session.active_skills = [(self.skill_id, 0.0)]
+
+            test = End2EndTest(
+                minicroft=minicroft,
+                skill_ids=[self.skill_id],
+                flip_points=[utt_topic],
+                entry_points=[utt_topic],
+                ignore_messages=["recognizer_loop:audio_output_start",
+                                  "recognizer_loop:audio_output_end"],
+                source_message=message,
+                final_session=final_session,
+                activation_points=[f"{self.skill_id}:HelloWorldIntent"],
+                expected_messages=[
+                    message,
+                    Message(f"{self.skill_id}.activate",
+                            data={},
+                            context={"skill_id": self.skill_id}),
+                # PIPELINE-1 §9.2: matched notification, before the dispatch.
+                # intent_name carries the full <skill_id>:<intent_name> match_type.
+                    Message(INTENT_MATCHED,
+                            data={"skill_id": self.skill_id,
+                                  "intent_name": f"{self.skill_id}:HelloWorldIntent",
+                                  "utterance": "hello world",
+                                  "lang": session.lang},
+                            context={"skill_id": self.skill_id}),
+                # PIPELINE-1 §8.1: orchestrator emits start immediately before dispatch
+                    Message(HANDLER_START,
+                            data={"skill_id": self.skill_id,
+                                  "intent_name": "HelloWorldIntent"},
+                            context={"skill_id": self.skill_id}),
+                    Message(f"{self.skill_id}:HelloWorldIntent",
+                            data={"utterance": "hello world", "lang": session.lang},
+                            context={"skill_id": self.skill_id}),
+                    Message("mycroft.skill.handler.start",
+                            data={"name": "HelloWorldSkill.handle_hello_world_intent"},
+                            context={"skill_id": self.skill_id}),
+                    Message(SPEC_SPEAK,
+                            data={"utterance": "Hello world",
+                                  "expect_response": False,
+                                  "meta": {
+                                      "dialog": "hello.world",
+                                      "data": {},
+                                      "skill": self.skill_id
+                                  }},
+                            context={"skill_id": self.skill_id}),
+                    Message("mycroft.skill.handler.complete",
+                            data={"name": "HelloWorldSkill.handle_hello_world_intent"},
+                            context={"skill_id": self.skill_id}),
+                # PIPELINE-1 §8.1: orchestrator emits complete on the handler's
+                # completion, before the end-marker (spec ordering §6.1).
+                    Message(HANDLER_COMPLETE,
+                            data={"skill_id": self.skill_id,
+                                  "intent_name": "HelloWorldIntent"},
+                            context={"skill_id": self.skill_id}),
+                    Message(UTTERANCE_HANDLED,
+                            data={},
+                            context={"skill_id": self.skill_id}),
+                ]
+            )
+
+            test.execute(timeout=10)
+        finally:
+            minicroft.stop()
 
     def test_adapt_match(self):
         for namespace in NAMESPACE_PATHS:
@@ -107,32 +140,34 @@ def _run_skill_blacklist(self, namespace):
         modernize, emit_legacy, utt_topic = NAMESPACE_PATHS[namespace]
         minicroft = get_minicroft([self.skill_id], modernize=modernize,
                                   emit_legacy=emit_legacy)
-
-        session = Session("123")
-        session.lang = "en-US"
-        session.pipeline = ['ovos-adapt-pipeline-plugin-high']
-        session.blacklisted_skills = [self.skill_id]
-        message = Message(utt_topic,
-                          {"utterances": ["hello world"], "lang": session.lang},
-                          {"session": session.serialize(), "source": "A", "destination": "B"})
-
-        test = End2EndTest(
-            minicroft=minicroft,
-            skill_ids=[self.skill_id],
-            flip_points=[utt_topic],
-            entry_points=[utt_topic],
-            source_message=message,
-            final_session=session,
-            expected_messages=[
-                message,
-                Message("mycroft.audio.play_sound", {"uri": "snd/error.mp3"}),
-                Message("complete_intent_failure", {}),
-                Message(UTTERANCE_HANDLED, {})
-            ]
-        )
-
-        test.execute(timeout=10)
-        minicroft.stop()
+        try:
+
+            session = Session("123")
+            session.lang = "en-US"
+            session.pipeline = ['ovos-adapt-pipeline-plugin-high']
+            session.blacklisted_skills = [self.skill_id]
+            message = Message(utt_topic,
+                              {"utterances": ["hello world"], "lang": session.lang},
+                              {"session": session.serialize(), "source": "A", "destination": "B"})
+
+            test = End2EndTest(
+                minicroft=minicroft,
+                skill_ids=[self.skill_id],
+                flip_points=[utt_topic],
+                entry_points=[utt_topic],
+                source_message=message,
+                final_session=session,
+                expected_messages=[
+                    message,
+                    Message("mycroft.audio.play_sound", {"uri": "snd/error.mp3"}),
+                    Message(INTENT_UNMATCHED, {}),
+                    Message(UTTERANCE_HANDLED, {})
+                ]
+            )
+
+            test.execute(timeout=10)
+        finally:
+            minicroft.stop()
 
     def test_skill_blacklist(self):
         for namespace in NAMESPACE_PATHS:
@@ -143,32 +178,34 @@ def _run_intent_blacklist(self, namespace):
         modernize, emit_legacy, utt_topic = NAMESPACE_PATHS[namespace]
         minicroft = get_minicroft([self.skill_id], modernize=modernize,
                                   emit_legacy=emit_legacy)
-
-        session = Session("123")
-        session.lang = "en-US"
-        session.pipeline = ['ovos-adapt-pipeline-plugin-high']
-        session.blacklisted_intents = [f"{self.skill_id}:HelloWorldIntent"]
-        message = Message(utt_topic,
-                          {"utterances": ["hello world"], "lang": session.lang},
-                          {"session": session.serialize(), "source": "A", "destination": "B"})
-
-        test = End2EndTest(
-            minicroft=minicroft,
-            skill_ids=[self.skill_id],
-            flip_points=[utt_topic],
-            entry_points=[utt_topic],
-            source_message=message,
-            final_session=session,
-            expected_messages=[
-                message,
-                Message("mycroft.audio.play_sound", {"uri": "snd/error.mp3"}),
-                Message("complete_intent_failure", {}),
-                Message(UTTERANCE_HANDLED, {})
-            ]
-        )
-
-        test.execute(timeout=10)
-        minicroft.stop()
+        try:
+
+            session = Session("123")
+            session.lang = "en-US"
+            session.pipeline = ['ovos-adapt-pipeline-plugin-high']
+            session.blacklisted_intents = [f"{self.skill_id}:HelloWorldIntent"]
+            message = Message(utt_topic,
+                              {"utterances": ["hello world"], "lang": session.lang},
+                              {"session": session.serialize(), "source": "A", "destination": "B"})
+
+            test = End2EndTest(
+                minicroft=minicroft,
+                skill_ids=[self.skill_id],
+                flip_points=[utt_topic],
+                entry_points=[utt_topic],
+                source_message=message,
+                final_session=session,
+                expected_messages=[
+                    message,
+                    Message("mycroft.audio.play_sound", {"uri": "snd/error.mp3"}),
+                    Message(INTENT_UNMATCHED, {}),
+                    Message(UTTERANCE_HANDLED, {})
+                ]
+            )
+
+            test.execute(timeout=10)
+        finally:
+            minicroft.stop()
 
     def test_intent_blacklist(self):
         for namespace in NAMESPACE_PATHS:
@@ -179,31 +216,33 @@ def _run_padatious_no_match(self, namespace):
         modernize, emit_legacy, utt_topic = NAMESPACE_PATHS[namespace]
         minicroft = get_minicroft([self.skill_id], modernize=modernize,
                                   emit_legacy=emit_legacy)
-
-        session = Session("123")
-        session.lang = "en-US"
-        session.pipeline = ["ovos-padatious-pipeline-plugin-high"]
-        message = Message(utt_topic,
-                          {"utterances": ["hello world"], "lang": session.lang},
-                          {"session": session.serialize(), "source": "A", "destination": "B"})
-
-        test = End2EndTest(
-            minicroft=minicroft,
-            skill_ids=[self.skill_id],
-            flip_points=[utt_topic],
-            entry_points=[utt_topic],
-            final_session=session,
-            source_message=message,
-            expected_messages=[
-                message,
-                Message("mycroft.audio.play_sound", {"uri": "snd/error.mp3"}),
-                Message("complete_intent_failure", {}),
-                Message(UTTERANCE_HANDLED, {})
-            ]
-        )
-
-        test.execute(timeout=10)
-        minicroft.stop()
+        try:
+
+            session = Session("123")
+            session.lang = "en-US"
+            session.pipeline = ["ovos-padatious-pipeline-plugin-high"]
+            message = Message(utt_topic,
+                              {"utterances": ["hello world"], "lang": session.lang},
+                              {"session": session.serialize(), "source": "A", "destination": "B"})
+
+            test = End2EndTest(
+                minicroft=minicroft,
+                skill_ids=[self.skill_id],
+                flip_points=[utt_topic],
+                entry_points=[utt_topic],
+                final_session=session,
+                source_message=message,
+                expected_messages=[
+                    message,
+                    Message("mycroft.audio.play_sound", {"uri": "snd/error.mp3"}),
+                    Message(INTENT_UNMATCHED, {}),
+                    Message(UTTERANCE_HANDLED, {})
+                ]
+            )
+
+            test.execute(timeout=10)
+        finally:
+            minicroft.stop()
 
     def test_padatious_no_match(self):
         for namespace in NAMESPACE_PATHS:
diff --git a/test/end2end/test_converse.py b/test/end2end/test_converse.py
index 2d10ae07ab0..e4f3acde7f1 100644
--- a/test/end2end/test_converse.py
+++ b/test/end2end/test_converse.py
@@ -25,6 +25,17 @@
 LEGACY_UTTERANCE = migration_counterpart(SPEC_UTTERANCE)
 SPEC_SPEAK = SpecMessage.SPEAK.value
 UTTERANCE_HANDLED = SpecMessage.UTTERANCE_HANDLED.value
+INTENT_MATCHED = SpecMessage.INTENT_MATCHED.value      # ovos.intent.matched (§9.2)
+# §8 handler-lifecycle trio wraps every dispatch; this suite asserts converse
+# routing, not the trio (covered by the adapt/padatious suites), so it is
+# filtered via ignore_messages below.
+HANDLER_TRIO = [SpecMessage.INTENT_HANDLER_START.value,
+                SpecMessage.INTENT_HANDLER_COMPLETE.value,
+                SpecMessage.INTENT_HANDLER_ERROR.value,
+                "ovos.skills.settings_changed",  # keep ovoscope's default ignore
+                "recognizer_loop:audio_output_start",  # TTS mock duck
+                "recognizer_loop:audio_output_end"]  # TTS mock unduck
+INTENT_UNMATCHED = SpecMessage.INTENT_UNMATCHED.value  # ovos.intent.unmatched (§9.3)
 
 # key -> (modernize, emit_legacy, utterance_topic)
 NAMESPACE_PATHS = {
@@ -47,153 +58,181 @@ def _run_parrot_mode(self, namespace: str) -> None:
         modernize, emit_legacy, utt_topic = NAMESPACE_PATHS[namespace]
         minicroft = get_minicroft([self.skill_id], modernize=modernize,
                                   emit_legacy=emit_legacy)
+        try:
 
-        session = Session("123")
-        session.lang = "en-US"
-        session.pipeline = ["ovos-converse-pipeline-plugin", "ovos-padatious-pipeline-plugin-high"]
+            session = Session("123")
+            session.lang = "en-US"
+            session.pipeline = ["ovos-converse-pipeline-plugin", "ovos-padatious-pipeline-plugin-high"]
 
-        message1 = Message(utt_topic,
-                           {"utterances": ["start parrot mode"], "lang": session.lang},
-                           {"session": session.serialize(), "source": "A", "destination": "B"})
+            message1 = Message(utt_topic,
+                               {"utterances": ["start parrot mode"], "lang": session.lang},
+                               {"session": session.serialize(), "source": "A", "destination": "B"})
         # NOTE: we dont pass session after first message
         # End2EndTest will inject/update the session from message1
-        message2 = Message(utt_topic,
-                           {"utterances": ["echo test"], "lang": session.lang},
-                           {"source": "A", "destination": "B"})
-        message3 = Message(utt_topic,
-                           {"utterances": ["stop parrot"], "lang": session.lang},
-                           {"source": "A", "destination": "B"})
-        message4 = Message(utt_topic,
-                           {"utterances": ["echo test"], "lang": session.lang},
-                           {"source": "A", "destination": "B"})
-
-        expected1 = [
-            message1,
-            Message(f"{self.skill_id}.activate",
-                    data={},
-                    context={"skill_id": self.skill_id}),
-            Message(f"{self.skill_id}:start_parrot.intent",
-                    data={"utterance": "start parrot mode", "lang": session.lang},
-                    context={"skill_id": self.skill_id}),
-            Message("mycroft.skill.handler.start",
-                    data={"name": "ParrotSkill.handle_start_parrot_intent"},
-                    context={"skill_id": self.skill_id}),
-            Message(SPEC_SPEAK,
-                    data={"expect_response": False,
-                          "meta": {
-                              "dialog": "parrot_start",
-                              "data": {},
-                              "skill": self.skill_id
-                          }},
-                    context={"skill_id": self.skill_id}),
-            Message("mycroft.skill.handler.complete",
-                    data={"name": "ParrotSkill.handle_start_parrot_intent"},
-                    context={"skill_id": self.skill_id}),
-            Message(UTTERANCE_HANDLED,
-                    data={},
-                    context={"skill_id": self.skill_id}),
-        ]
-        expected2 = [
-            message2,
-            Message(f"{self.skill_id}.converse.ping",
-                    data={"utterances": ["echo test"], "skill_id": self.skill_id},
-                    context={}),
-            Message("skill.converse.pong",
-                    data={"can_handle": True, "skill_id": self.skill_id},
-                    context={"skill_id": self.skill_id}),
-            Message(f"{self.skill_id}.activate",
-                    data={},
-                    context={"skill_id": self.skill_id}),
-            Message("converse:skill",
-                    data={"utterances": ["echo test"], "lang": session.lang, "skill_id": self.skill_id},
-                    context={"skill_id": self.skill_id}),
-            Message(f"{self.skill_id}.converse.request",
-                    data={"utterances": ["echo test"], "lang": session.lang},
-                    context={"skill_id": self.skill_id}),
-            Message(SPEC_SPEAK,
-                    data={"utterance": "echo test",
-                          "expect_response": False,
-                          "lang": session.lang,
-                          "meta": {
-                              "skill": self.skill_id
-                          }},
-                    context={"skill_id": self.skill_id}),
-            Message("skill.converse.response",
-                    data={"skill_id": self.skill_id},
-                    context={"skill_id": self.skill_id}),
-            Message(UTTERANCE_HANDLED,
-                    data={},
-                    context={"skill_id": self.skill_id})
-        ]
-        expected3 = [
-            message3,
-            Message(f"{self.skill_id}.converse.ping",
-                    data={"utterances": ["stop parrot"], "skill_id": self.skill_id},
-                    context={}),
-            Message("skill.converse.pong",
-                    data={"can_handle": True, "skill_id": self.skill_id},
-                    context={"skill_id": self.skill_id}),
-            Message(f"{self.skill_id}.activate",
-                    data={},
-                    context={"skill_id": self.skill_id}),
-
-            Message("converse:skill",
-                    data={"utterances": ["stop parrot"], "lang": session.lang, "skill_id": self.skill_id},
-                    context={"skill_id": self.skill_id}),
-            Message(f"{self.skill_id}.converse.request",
-                    data={"utterances": ["stop parrot"], "lang": session.lang},
-                    context={"skill_id": self.skill_id}),
-
-            Message(SPEC_SPEAK,
-                    data={"expect_response": False,
-                          "lang": session.lang,
-                          "meta": {
-                              "dialog": "parrot_stop",
-                              "data": {},
-                              "skill": self.skill_id
-                          }},
-                    context={"skill_id": self.skill_id}),
-            Message("skill.converse.response",
-                    data={"skill_id": self.skill_id},
-                    context={"skill_id": self.skill_id}),
-            Message(UTTERANCE_HANDLED,
-                    data={},
-                    context={"skill_id": self.skill_id})
-        ]
-        expected4 = [
-            message4,
-            Message(f"{self.skill_id}.converse.ping",
-                    data={"utterances": ["echo test"], "skill_id": self.skill_id},
-                    context={}),
-            Message("skill.converse.pong",
-                    data={"can_handle": False, "skill_id": self.skill_id},
-                    context={"skill_id": self.skill_id}),
-            Message("mycroft.audio.play_sound", data={"uri": "snd/error.mp3"}),
-            Message("complete_intent_failure"),
-            Message(UTTERANCE_HANDLED)
-        ]
-
-        final_session = deepcopy(session)
-        final_session.active_skills = [(self.skill_id, 0.0)]
-
-        test = End2EndTest(
-            minicroft=minicroft,
-            skill_ids=[self.skill_id],
-            eof_msgs=[UTTERANCE_HANDLED],
-            flip_points=[utt_topic],
-            entry_points=[utt_topic],
-            final_session=final_session,
-            source_message=[message1, message2, message3, message4],
-            expected_messages=expected1 + expected2 + expected3 + expected4,
-            activation_points=[f"{self.skill_id}:start_parrot.intent"],
+            message2 = Message(utt_topic,
+                               {"utterances": ["echo test"], "lang": session.lang},
+                               {"source": "A", "destination": "B"})
+            message3 = Message(utt_topic,
+                               {"utterances": ["stop parrot"], "lang": session.lang},
+                               {"source": "A", "destination": "B"})
+            message4 = Message(utt_topic,
+                               {"utterances": ["echo test"], "lang": session.lang},
+                               {"source": "A", "destination": "B"})
+
+            expected1 = [
+                message1,
+                Message(f"{self.skill_id}.activate",
+                        data={},
+                        context={"skill_id": self.skill_id}),
+                Message(INTENT_MATCHED,
+                        data={"skill_id": self.skill_id,
+                              "intent_name": f"{self.skill_id}:start_parrot.intent"},
+                        context={"skill_id": self.skill_id}),
+                Message(f"{self.skill_id}:start_parrot.intent",
+                        data={"utterance": "start parrot mode", "lang": session.lang},
+                        context={"skill_id": self.skill_id}),
+                Message("mycroft.skill.handler.start",
+                        data={"name": "ParrotSkill.handle_start_parrot_intent"},
+                        context={"skill_id": self.skill_id}),
+                Message(SPEC_SPEAK,
+                        data={"expect_response": False,
+                              "meta": {
+                                  "dialog": "parrot_start",
+                                  "data": {},
+                                  "skill": self.skill_id
+                              }},
+                        context={"skill_id": self.skill_id}),
+                Message("mycroft.skill.handler.complete",
+                        data={"name": "ParrotSkill.handle_start_parrot_intent"},
+                        context={"skill_id": self.skill_id}),
+                Message(UTTERANCE_HANDLED,
+                        data={},
+                        context={"skill_id": self.skill_id}),
+            ]
+            expected2 = [
+                message2,
+                Message(f"{self.skill_id}.converse.ping",
+                        data={"utterances": ["echo test"], "skill_id": self.skill_id},
+                        context={}),
+                Message("skill.converse.pong",
+                        data={"can_handle": True, "skill_id": self.skill_id},
+                        context={"skill_id": self.skill_id}),
+                Message(f"{self.skill_id}.activate",
+                        data={},
+                        context={"skill_id": self.skill_id}),
+                Message(INTENT_MATCHED,
+                        data={"skill_id": self.skill_id, "intent_name": "converse:skill"},
+                        context={"skill_id": self.skill_id}),
+                Message("converse:skill",
+                        data={"utterances": ["echo test"], "lang": session.lang, "skill_id": self.skill_id},
+                        context={"skill_id": self.skill_id}),
+            # core reports the converse dispatch lifecycle as the framework
+            # done-signal (handler.start at dispatch, handler.complete on the
+            # skill's converse.response) so an orchestrator can resolve it
+                Message("mycroft.skill.handler.start",
+                        data={"handler": f"{self.skill_id}.converse"},
+                        context={"skill_id": self.skill_id}),
+                Message(f"{self.skill_id}.converse.request",
+                        data={"utterances": ["echo test"], "lang": session.lang},
+                        context={"skill_id": self.skill_id}),
+                Message(SPEC_SPEAK,
+                        data={"utterance": "echo test",
+                              "expect_response": False,
+                              "lang": session.lang,
+                              "meta": {
+                                  "skill": self.skill_id
+                              }},
+                        context={"skill_id": self.skill_id}),
+                Message("skill.converse.response",
+                        data={"skill_id": self.skill_id},
+                        context={"skill_id": self.skill_id}),
+                Message("mycroft.skill.handler.complete",
+                        data={"handler": f"{self.skill_id}.converse"},
+                        context={"skill_id": self.skill_id}),
+                Message(UTTERANCE_HANDLED,
+                        data={},
+                        context={"skill_id": self.skill_id})
+            ]
+            expected3 = [
+                message3,
+                Message(f"{self.skill_id}.converse.ping",
+                        data={"utterances": ["stop parrot"], "skill_id": self.skill_id},
+                        context={}),
+                Message("skill.converse.pong",
+                        data={"can_handle": True, "skill_id": self.skill_id},
+                        context={"skill_id": self.skill_id}),
+                Message(f"{self.skill_id}.activate",
+                        data={},
+                        context={"skill_id": self.skill_id}),
+
+                Message(INTENT_MATCHED,
+                        data={"skill_id": self.skill_id, "intent_name": "converse:skill"},
+                        context={"skill_id": self.skill_id}),
+                Message("converse:skill",
+                        data={"utterances": ["stop parrot"], "lang": session.lang, "skill_id": self.skill_id},
+                        context={"skill_id": self.skill_id}),
+                Message("mycroft.skill.handler.start",
+                        data={"handler": f"{self.skill_id}.converse"},
+                        context={"skill_id": self.skill_id}),
+                Message(f"{self.skill_id}.converse.request",
+                        data={"utterances": ["stop parrot"], "lang": session.lang},
+                        context={"skill_id": self.skill_id}),
+
+                Message(SPEC_SPEAK,
+                        data={"expect_response": False,
+                              "lang": session.lang,
+                              "meta": {
+                                  "dialog": "parrot_stop",
+                                  "data": {},
+                                  "skill": self.skill_id
+                              }},
+                        context={"skill_id": self.skill_id}),
+                Message("skill.converse.response",
+                        data={"skill_id": self.skill_id},
+                        context={"skill_id": self.skill_id}),
+                Message("mycroft.skill.handler.complete",
+                        data={"handler": f"{self.skill_id}.converse"},
+                        context={"skill_id": self.skill_id}),
+                Message(UTTERANCE_HANDLED,
+                        data={},
+                        context={"skill_id": self.skill_id})
+            ]
+            expected4 = [
+                message4,
+                Message(f"{self.skill_id}.converse.ping",
+                        data={"utterances": ["echo test"], "skill_id": self.skill_id},
+                        context={}),
+                Message("skill.converse.pong",
+                        data={"can_handle": False, "skill_id": self.skill_id},
+                        context={"skill_id": self.skill_id}),
+                Message("mycroft.audio.play_sound", data={"uri": "snd/error.mp3"}),
+                Message(INTENT_UNMATCHED),
+                Message(UTTERANCE_HANDLED)
+            ]
+
+            final_session = deepcopy(session)
+            final_session.active_skills = [(self.skill_id, 0.0)]
+
+            test = End2EndTest(
+                minicroft=minicroft,
+                skill_ids=[self.skill_id],
+                eof_msgs=[UTTERANCE_HANDLED],
+                flip_points=[utt_topic],
+                entry_points=[utt_topic],
+                final_session=final_session,
+                source_message=[message1, message2, message3, message4],
+                expected_messages=expected1 + expected2 + expected3 + expected4,
+                ignore_messages=HANDLER_TRIO,
+                activation_points=[f"{self.skill_id}:start_parrot.intent"],
             # messages internal to ovos-core, i.e. would not be sent to clients such as hivemind
-            keep_original_src=[f"{self.skill_id}.converse.ping",
-                               f"{self.skill_id}.converse.request"
+                keep_original_src=[f"{self.skill_id}.converse.ping",
+                                   f"{self.skill_id}.converse.request"
                                # f"{self.skill_id}.activate",  # TODO
-                               ]
-        )
-        test.execute(timeout=10)
-        minicroft.stop()
+                                   ]
+            )
+            test.execute(timeout=10)
+        finally:
+            minicroft.stop()
 
     def test_parrot_mode(self):
         for namespace in NAMESPACE_PATHS:
diff --git a/test/end2end/test_fallback.py b/test/end2end/test_fallback.py
index 5549abfcae3..51fb4d4f489 100644
--- a/test/end2end/test_fallback.py
+++ b/test/end2end/test_fallback.py
@@ -23,6 +23,15 @@
 LEGACY_UTTERANCE = migration_counterpart(SPEC_UTTERANCE)
 SPEC_SPEAK = SpecMessage.SPEAK.value
 UTTERANCE_HANDLED = SpecMessage.UTTERANCE_HANDLED.value
+# PIPELINE-1 orchestrator-emitted matched-path messages: §9.2 ovos.intent.matched
+# (before dispatch), §8.1 ovos.intent.handler.start (before the dispatch) and the
+# §8 ovos.intent.handler.complete terminal. The fallback service re-emits the
+# skill's own .start/.response markers as the mycroft.skill.handler.* done-signal,
+# which the dispatcher correlates (by the match_data skill_id) to emit the §8
+# terminal promptly — without waiting out the §8.3 handler timeout.
+INTENT_MATCHED = SpecMessage.INTENT_MATCHED.value
+HANDLER_START = SpecMessage.INTENT_HANDLER_START.value
+HANDLER_COMPLETE = SpecMessage.INTENT_HANDLER_COMPLETE.value
 
 # key -> (modernize, emit_legacy, utterance_topic)
 NAMESPACE_PATHS = {
@@ -45,55 +54,81 @@ def _run_fallback_match(self, namespace: str) -> None:
         modernize, emit_legacy, utt_topic = NAMESPACE_PATHS[namespace]
         minicroft = get_minicroft([self.skill_id], modernize=modernize,
                                   emit_legacy=emit_legacy)
-
-        session = Session("123")
-        session.lang = "en-US"
-        session.pipeline = ['ovos-fallback-pipeline-plugin-low']
-        message = Message(utt_topic,
-                          {"utterances": ["hello world"], "lang": session.lang},
-                          {"session": session.serialize(), "source": "A", "destination": "B"})
-
-        final_session = deepcopy(session)
-
-        test = End2EndTest(
-            minicroft=minicroft,
-            skill_ids=[self.skill_id],
-            eof_msgs=[UTTERANCE_HANDLED],
-            flip_points=[utt_topic],
-            entry_points=[utt_topic],
-            final_session=final_session,
-            keep_original_src=[
-                "ovos.skills.fallback.ping",
+        try:
+
+            session = Session("123")
+            session.lang = "en-US"
+            session.pipeline = ['ovos-fallback-pipeline-plugin-low']
+            message = Message(utt_topic,
+                              {"utterances": ["hello world"], "lang": session.lang},
+                              {"session": session.serialize(), "source": "A", "destination": "B"})
+
+            final_session = deepcopy(session)
+
+            test = End2EndTest(
+                minicroft=minicroft,
+                skill_ids=[self.skill_id],
+                eof_msgs=[UTTERANCE_HANDLED],
+                flip_points=[utt_topic],
+                entry_points=[utt_topic],
+                final_session=final_session,
+                keep_original_src=[
+                    "ovos.skills.fallback.ping",
                 # "ovos.skills.fallback.pong", # TODO
-            ],
-            activation_points=[f"ovos.skills.fallback.{self.skill_id}.request"],
-            source_message=message,
-            expected_messages=[
-                message,
-                Message("ovos.skills.fallback.ping",
-                        {"utterances": ["hello world"], "lang": session.lang, "range": [90, 101]}),
-                Message("ovos.skills.fallback.pong", {"skill_id": self.skill_id, "can_handle": True}),
-                Message(f"ovos.skills.fallback.{self.skill_id}.request",
-                        {"utterances": ["hello world"], "lang": session.lang, "range": [90, 101], "skill_id": self.skill_id}),
-                Message(f"ovos.skills.fallback.{self.skill_id}.start", {}),
-                Message(SPEC_SPEAK,
-                        data={"lang": session.lang,
-                              "expect_response": False,
-                              "meta": {
-                                  "dialog": "unknown",
-                                  "data": {},
-                                  "skill": self.skill_id
-                              }},
-                        context={"skill_id": self.skill_id}),
-                Message(f"ovos.skills.fallback.{self.skill_id}.response",
-                        data={"fallback_handler": "UnknownSkill.handle_fallback"}),
-
-                Message(UTTERANCE_HANDLED, {})
-            ]
-        )
-
-        test.execute(timeout=10)
-        minicroft.stop()
+                ],
+                ignore_messages=["recognizer_loop:audio_output_start",
+                                  "recognizer_loop:audio_output_end"],
+                activation_points=[f"ovos.skills.fallback.{self.skill_id}.request"],
+                source_message=message,
+                expected_messages=[
+                    message,
+                    Message("ovos.skills.fallback.ping",
+                            {"utterances": ["hello world"], "lang": session.lang, "range": [90, 101]}),
+                    Message("ovos.skills.fallback.pong", {"skill_id": self.skill_id, "can_handle": True}),
+                # PIPELINE-1 §9.2: matched notification precedes the dispatch. The
+                # fallback match_type is the .request topic; it bears no ':' so
+                # skill_id/intent_name resolve to that topic.
+                    Message(INTENT_MATCHED,
+                            data={"intent_name": f"ovos.skills.fallback.{self.skill_id}.request",
+                                  "utterance": "hello world", "lang": session.lang}),
+                # PIPELINE-1 §8.1: orchestrator start immediately before the dispatch
+                    Message(HANDLER_START,
+                            data={"intent_name": f"ovos.skills.fallback.{self.skill_id}.request"}),
+                    Message(f"ovos.skills.fallback.{self.skill_id}.request",
+                            {"utterances": ["hello world"], "lang": session.lang, "range": [90, 101], "skill_id": self.skill_id}),
+                    Message(f"ovos.skills.fallback.{self.skill_id}.start", {}),
+                # core reports the fallback dispatch lifecycle as the framework
+                # done-signal by translating the skill's own .start/.response
+                # markers, so an orchestrator can resolve it
+                    Message("mycroft.skill.handler.start",
+                            data={"handler": f"{self.skill_id}.fallback"},
+                            context={"skill_id": self.skill_id}),
+                    Message(SPEC_SPEAK,
+                            data={"lang": session.lang,
+                                  "expect_response": False,
+                                  "meta": {
+                                      "dialog": "unknown",
+                                      "data": {},
+                                      "skill": self.skill_id
+                                  }},
+                            context={"skill_id": self.skill_id}),
+                    Message(f"ovos.skills.fallback.{self.skill_id}.response",
+                            data={"fallback_handler": "UnknownSkill.handle_fallback"}),
+                    Message("mycroft.skill.handler.complete",
+                            data={"handler": f"{self.skill_id}.fallback"},
+                            context={"skill_id": self.skill_id}),
+                # PIPELINE-1 §8 terminal: the orchestrator correlates the done-signal
+                # to the in-flight fallback dispatch and emits its own complete.
+                    Message(HANDLER_COMPLETE,
+                            data={"intent_name": f"ovos.skills.fallback.{self.skill_id}.request"}),
+
+                    Message(UTTERANCE_HANDLED, {})
+                ]
+            )
+
+            test.execute(timeout=10)
+        finally:
+            minicroft.stop()
 
     def test_fallback_match(self):
         for namespace in NAMESPACE_PATHS:
diff --git a/test/end2end/test_intent_pipeline.py b/test/end2end/test_intent_pipeline.py
index d5b66c1f2e3..6ed85de4473 100644
--- a/test/end2end/test_intent_pipeline.py
+++ b/test/end2end/test_intent_pipeline.py
@@ -47,8 +47,9 @@
 # legacy counterpart is derived via migration_counterpart, never hardcoded.
 SPEC_UTTERANCE = SpecMessage.UTTERANCE.value          # ovos.utterance.handle
 LEGACY_UTTERANCE = migration_counterpart(SPEC_UTTERANCE)  # recognizer_loop:utterance
-SPEC_SPEAK = SpecMessage.SPEAK.value                  # ovos.utterance.speak
-UTTERANCE_HANDLED = SpecMessage.UTTERANCE_HANDLED.value
+# PIPELINE-1 orchestrator-emitted terminal events: §9.2 matched, §8 trio, §9.3
+# unmatched (the spec replacement for legacy complete_intent_failure).
+INTENT_UNMATCHED = SpecMessage.INTENT_UNMATCHED.value
 
 # The two namespace paths every scenario is run on.
 #   key       -> (modernize, emit_legacy, utterance_topic)
@@ -78,27 +79,34 @@ class TestIntentPipelineRouting(TestCase):
     # count skill speaks on the spec topic ``ovos.utterance.speak`` (no legacy
     # mirror because emit_legacy=False on both paths).
     ignore_messages = [
-        SPEC_SPEAK,
+        SpecMessage.SPEAK,
+        "recognizer_loop:audio_output_start",  # TTS mock duck
+        "recognizer_loop:audio_output_end",  # TTS mock unduck
         "ovos.common_play.stop.response",
         "common_query.openvoiceos.stop.response",
         "persona.openvoiceos.stop.response",
         "ovos-hivemind-pipeline-plugin.stop.response",
-        "stop.openvoiceos.stop.response",
     ]
 
     def setUp(self) -> None:
         LOG.set_level("DEBUG")
+        self._minicrofts = []
 
     def tearDown(self) -> None:
         LOG.set_level("CRITICAL")
+        for mc in self._minicrofts:
+            mc.stop()
+        self._minicrofts.clear()
 
     # ------------------------------------------------------------------
     # helpers
     # ------------------------------------------------------------------
     def _make_minicroft(self, namespace: str) -> "MiniCroft":
         modernize, emit_legacy, _ = NAMESPACE_PATHS[namespace]
-        return get_minicroft([self.skill_id], modernize=modernize,
-                             emit_legacy=emit_legacy)
+        mc = get_minicroft([self.skill_id], modernize=modernize,
+                           emit_legacy=emit_legacy)
+        self._minicrofts.append(mc)
+        return mc
 
     def _source_message(self, namespace: str, utterance: str, pipeline,
                         session_id: str, blacklisted=None) -> Message:
@@ -129,7 +137,7 @@ def _run_padatious_intent_matched(self, namespace: str) -> None:
         test = End2EndTest(
             minicroft=self._make_minicroft(namespace),
             skill_ids=[self.skill_id],
-            eof_msgs=[UTTERANCE_HANDLED],
+            eof_msgs=[SpecMessage.UTTERANCE_HANDLED],
             flip_points=[utt_topic],
             entry_points=[utt_topic],
             ignore_messages=self.ignore_messages,
@@ -143,6 +151,21 @@ def _run_padatious_intent_matched(self, namespace: str) -> None:
                     data={},
                     context={"skill_id": self.skill_id},
                 ),
+                # PIPELINE-1 §9.2: matched notification, before the dispatch
+                Message(
+                    SpecMessage.INTENT_MATCHED,
+                    data={"skill_id": self.skill_id,
+                          "intent_name": f"{self.skill_id}:count_to_N.intent",
+                          "utterance": "count to 3", "lang": session.lang},
+                    context={"skill_id": self.skill_id},
+                ),
+                # PIPELINE-1 §8.1: orchestrator start before dispatch
+                Message(
+                    SpecMessage.INTENT_HANDLER_START,
+                    data={"skill_id": self.skill_id,
+                          "intent_name": "count_to_N.intent"},
+                    context={"skill_id": self.skill_id},
+                ),
                 Message(
                     f"{self.skill_id}:count_to_N.intent",
                     data={"utterance": "count to 3", "lang": session.lang},
@@ -158,8 +181,15 @@ def _run_padatious_intent_matched(self, namespace: str) -> None:
                     data={"name": "CountSkill.handle_how_are_you_intent"},
                     context={"skill_id": self.skill_id},
                 ),
+                # PIPELINE-1 §8.1: orchestrator complete before the end-marker
+                Message(
+                    SpecMessage.INTENT_HANDLER_COMPLETE,
+                    data={"skill_id": self.skill_id,
+                          "intent_name": "count_to_N.intent"},
+                    context={"skill_id": self.skill_id},
+                ),
                 Message(
-                    UTTERANCE_HANDLED,
+                    SpecMessage.UTTERANCE_HANDLED,
                     data={},
                     context={"skill_id": self.skill_id},
                 ),
@@ -190,7 +220,7 @@ def _run_high_priority_stage_handles_before_low(self, namespace: str) -> None:
         test = End2EndTest(
             minicroft=self._make_minicroft(namespace),
             skill_ids=[self.skill_id],
-            eof_msgs=[UTTERANCE_HANDLED],
+            eof_msgs=[SpecMessage.UTTERANCE_HANDLED],
             flip_points=[utt_topic],
             entry_points=[utt_topic],
             ignore_messages=self.ignore_messages,
@@ -204,6 +234,21 @@ def _run_high_priority_stage_handles_before_low(self, namespace: str) -> None:
                     data={},
                     context={"skill_id": self.skill_id},
                 ),
+                # PIPELINE-1 §9.2: matched notification, before the dispatch
+                Message(
+                    SpecMessage.INTENT_MATCHED,
+                    data={"skill_id": self.skill_id,
+                          "intent_name": f"{self.skill_id}:count_to_N.intent",
+                          "utterance": "count to 3", "lang": session.lang},
+                    context={"skill_id": self.skill_id},
+                ),
+                # PIPELINE-1 §8.1: orchestrator start before dispatch
+                Message(
+                    SpecMessage.INTENT_HANDLER_START,
+                    data={"skill_id": self.skill_id,
+                          "intent_name": "count_to_N.intent"},
+                    context={"skill_id": self.skill_id},
+                ),
                 Message(
                     f"{self.skill_id}:count_to_N.intent",
                     data={"utterance": "count to 3", "lang": session.lang},
@@ -219,8 +264,15 @@ def _run_high_priority_stage_handles_before_low(self, namespace: str) -> None:
                     data={"name": "CountSkill.handle_how_are_you_intent"},
                     context={"skill_id": self.skill_id},
                 ),
+                # PIPELINE-1 §8.1: orchestrator complete before the end-marker
+                Message(
+                    SpecMessage.INTENT_HANDLER_COMPLETE,
+                    data={"skill_id": self.skill_id,
+                          "intent_name": "count_to_N.intent"},
+                    context={"skill_id": self.skill_id},
+                ),
                 Message(
-                    UTTERANCE_HANDLED,
+                    SpecMessage.UTTERANCE_HANDLED,
                     data={},
                     context={"skill_id": self.skill_id},
                 ),
@@ -247,7 +299,7 @@ def _run_no_match_produces_intent_failure(self, namespace: str) -> None:
         test = End2EndTest(
             minicroft=self._make_minicroft(namespace),
             skill_ids=[self.skill_id],
-            eof_msgs=[UTTERANCE_HANDLED],
+            eof_msgs=[SpecMessage.UTTERANCE_HANDLED],
             flip_points=[utt_topic],
             entry_points=[utt_topic],
             ignore_messages=self.ignore_messages,
@@ -256,8 +308,8 @@ def _run_no_match_produces_intent_failure(self, namespace: str) -> None:
             expected_messages=[
                 message,
                 Message("mycroft.audio.play_sound", {"uri": "snd/error.mp3"}),
-                Message("complete_intent_failure", {}),
-                Message(UTTERANCE_HANDLED, {}),
+                Message(INTENT_UNMATCHED, {}),
+                Message(SpecMessage.UTTERANCE_HANDLED, {}),
             ],
         )
         test.execute(timeout=15)
@@ -282,7 +334,7 @@ def _run_blacklisted_skill_falls_through_to_failure(self, namespace: str) -> Non
         test = End2EndTest(
             minicroft=self._make_minicroft(namespace),
             skill_ids=[self.skill_id],
-            eof_msgs=[UTTERANCE_HANDLED],
+            eof_msgs=[SpecMessage.UTTERANCE_HANDLED],
             flip_points=[utt_topic],
             entry_points=[utt_topic],
             ignore_messages=self.ignore_messages,
@@ -291,8 +343,8 @@ def _run_blacklisted_skill_falls_through_to_failure(self, namespace: str) -> Non
             expected_messages=[
                 message,
                 Message("mycroft.audio.play_sound", {"uri": "snd/error.mp3"}),
-                Message("complete_intent_failure", {}),
-                Message(UTTERANCE_HANDLED, {}),
+                Message(INTENT_UNMATCHED, {}),
+                Message(SpecMessage.UTTERANCE_HANDLED, {}),
             ],
         )
         test.execute(timeout=15)
diff --git a/test/end2end/test_lang_detect.py b/test/end2end/test_lang_detect.py
index 2c04ff0c4ed..dfb81d6f542 100644
--- a/test/end2end/test_lang_detect.py
+++ b/test/end2end/test_lang_detect.py
@@ -24,6 +24,10 @@
 LEGACY_UTTERANCE = migration_counterpart(SPEC_UTTERANCE)
 SPEC_SPEAK = SpecMessage.SPEAK.value
 UTTERANCE_HANDLED = SpecMessage.UTTERANCE_HANDLED.value
+# OVOS-PIPELINE-1 §9.3: the no-match terminal is ovos.intent.unmatched. The
+# orchestrator emits the spec topic; complete_intent_failure is the legacy
+# counterpart re-delivered only by the emit_legacy bridge.
+INTENT_UNMATCHED = SpecMessage.INTENT_UNMATCHED.value
 
 NAMESPACE_PATHS = {
     "spec": (False, False, SPEC_UTTERANCE),
@@ -65,7 +69,7 @@ def _run_stt_lang(self, namespace: str) -> None:
             expected_messages=[
                 message,
                 Message("mycroft.audio.play_sound", {"uri": "snd/error.mp3"}),
-                Message("complete_intent_failure", {"lang": lang_keys["stt_lang"]}),
+                Message(INTENT_UNMATCHED, {"lang": lang_keys["stt_lang"]}),
                 Message(UTTERANCE_HANDLED, {}),
             ]
         )
@@ -102,7 +106,7 @@ def _run_lang_text_detection(self, namespace: str) -> None:
             expected_messages=[
                 message,
                 Message("mycroft.audio.play_sound", {"uri": "snd/error.mp3"}),
-                Message("complete_intent_failure", {"lang": lang_keys["detected_lang"]}),
+                Message(INTENT_UNMATCHED, {"lang": lang_keys["detected_lang"]}),
                 Message(UTTERANCE_HANDLED, {}),
             ]
         )
@@ -140,7 +144,7 @@ def _run_metadata_preferred_over_text_detection(self, namespace: str) -> None:
             expected_messages=[
                 message,
                 Message("mycroft.audio.play_sound", {"uri": "snd/error.mp3"}),
-                Message("complete_intent_failure", {"lang": lang_keys["request_lang"]}),
+                Message(INTENT_UNMATCHED, {"lang": lang_keys["request_lang"]}),
                 Message(UTTERANCE_HANDLED, {}),
             ]
         )
@@ -177,7 +181,7 @@ def _run_invalid_lang_detection(self, namespace: str) -> None:
             expected_messages=[
                 message,
                 Message("mycroft.audio.play_sound", {"uri": "snd/error.mp3"}),
-                Message("complete_intent_failure", {"lang": session.lang}),
+                Message(INTENT_UNMATCHED, {"lang": session.lang}),
                 Message(UTTERANCE_HANDLED, {}),
             ]
         )
diff --git a/test/end2end/test_no_skills.py b/test/end2end/test_no_skills.py
index 2eed8af1453..1f09d648ba3 100644
--- a/test/end2end/test_no_skills.py
+++ b/test/end2end/test_no_skills.py
@@ -24,6 +24,9 @@
 LEGACY_UTTERANCE = migration_counterpart(SPEC_UTTERANCE)
 SPEC_SPEAK = SpecMessage.SPEAK.value
 UTTERANCE_HANDLED = SpecMessage.UTTERANCE_HANDLED.value
+# OVOS-PIPELINE-1 §9.3: no-match terminal is ovos.intent.unmatched; the legacy
+# complete_intent_failure is only re-delivered by the emit_legacy bridge.
+INTENT_UNMATCHED = SpecMessage.INTENT_UNMATCHED.value
 
 NAMESPACE_PATHS = {
     "spec": (False, False, SPEC_UTTERANCE),
@@ -42,27 +45,29 @@ def tearDown(self):
     def _run_complete_failure(self, namespace: str) -> None:
         modernize, emit_legacy, utt_topic = NAMESPACE_PATHS[namespace]
         minicroft = get_minicroft([], modernize=modernize, emit_legacy=emit_legacy)
-
-        message = Message(utt_topic,
-                          {"utterances": ["hello world"]})
-
-        test = End2EndTest(
-            minicroft=minicroft,
-            skill_ids=[],
-            eof_msgs=[UTTERANCE_HANDLED],
-            flip_points=[utt_topic],
-            entry_points=[utt_topic],
-            source_message=message,
-            expected_messages=[
-                message,
-                Message("mycroft.audio.play_sound", {"uri": "snd/error.mp3"}),
-                Message("complete_intent_failure", {}),
-                Message(UTTERANCE_HANDLED, {}),
-            ]
-        )
-
-        test.execute()
-        minicroft.stop()
+        try:
+
+            message = Message(utt_topic,
+                              {"utterances": ["hello world"]})
+
+            test = End2EndTest(
+                minicroft=minicroft,
+                skill_ids=[],
+                eof_msgs=[UTTERANCE_HANDLED],
+                flip_points=[utt_topic],
+                entry_points=[utt_topic],
+                source_message=message,
+                expected_messages=[
+                    message,
+                    Message("mycroft.audio.play_sound", {"uri": "snd/error.mp3"}),
+                    Message(INTENT_UNMATCHED, {}),
+                    Message(UTTERANCE_HANDLED, {}),
+                ]
+            )
+
+            test.execute()
+        finally:
+            minicroft.stop()
 
     def test_complete_failure(self):
         for namespace in NAMESPACE_PATHS:
@@ -74,28 +79,30 @@ def _run_routing(self, namespace: str) -> None:
         # done automatically if "source" and "destination" are in message.context
         modernize, emit_legacy, utt_topic = NAMESPACE_PATHS[namespace]
         minicroft = get_minicroft([], modernize=modernize, emit_legacy=emit_legacy)
-
-        message = Message(utt_topic,
-                          {"utterances": ["hello world"]},
-                          {"source": "A", "destination": "B"})
-
-        test = End2EndTest(
-            minicroft=minicroft,
-            skill_ids=[],
-            eof_msgs=[UTTERANCE_HANDLED],
-            flip_points=[utt_topic],
-            entry_points=[utt_topic],
-            source_message=message,
-            expected_messages=[
-                message,
-                Message("mycroft.audio.play_sound", {"uri": "snd/error.mp3"}),
-                Message("complete_intent_failure", {}),
-                Message(UTTERANCE_HANDLED, {}),
-            ]
-        )
-
-        test.execute()
-        minicroft.stop()
+        try:
+
+            message = Message(utt_topic,
+                              {"utterances": ["hello world"]},
+                              {"source": "A", "destination": "B"})
+
+            test = End2EndTest(
+                minicroft=minicroft,
+                skill_ids=[],
+                eof_msgs=[UTTERANCE_HANDLED],
+                flip_points=[utt_topic],
+                entry_points=[utt_topic],
+                source_message=message,
+                expected_messages=[
+                    message,
+                    Message("mycroft.audio.play_sound", {"uri": "snd/error.mp3"}),
+                    Message(INTENT_UNMATCHED, {}),
+                    Message(UTTERANCE_HANDLED, {}),
+                ]
+            )
+
+            test.execute()
+        finally:
+            minicroft.stop()
 
     def test_routing(self):
         for namespace in NAMESPACE_PATHS:
diff --git a/test/end2end/test_padatious.py b/test/end2end/test_padatious.py
index 8d7f1dc2f8d..de077d05c1c 100644
--- a/test/end2end/test_padatious.py
+++ b/test/end2end/test_padatious.py
@@ -27,6 +27,12 @@
 LEGACY_UTTERANCE = migration_counterpart(SPEC_UTTERANCE)
 SPEC_SPEAK = SpecMessage.SPEAK.value
 UTTERANCE_HANDLED = SpecMessage.UTTERANCE_HANDLED.value
+# PIPELINE-1 orchestrator-emitted terminal events: §9.2 matched, §8 trio, §9.3
+# unmatched (the spec replacement for legacy complete_intent_failure).
+INTENT_MATCHED = SpecMessage.INTENT_MATCHED.value
+INTENT_UNMATCHED = SpecMessage.INTENT_UNMATCHED.value
+HANDLER_START = SpecMessage.INTENT_HANDLER_START.value
+HANDLER_COMPLETE = SpecMessage.INTENT_HANDLER_COMPLETE.value
 
 NAMESPACE_PATHS = {
     "spec": (False, False, SPEC_UTTERANCE),
@@ -47,55 +53,75 @@ def _run_padatious_match(self, namespace):
         modernize, emit_legacy, utt_topic = NAMESPACE_PATHS[namespace]
         minicroft = get_minicroft([self.skill_id], modernize=modernize,
                                   emit_legacy=emit_legacy)
-
-        session = Session("123")
-        session.lang = "en-US"
-        session.pipeline = ["ovos-padatious-pipeline-plugin-high"]
-        message = Message(utt_topic,
-                          {"utterances": ["good morning"], "lang": session.lang},
-                          {"session": session.serialize(), "source": "A", "destination": "B"})
-
-        final_session = deepcopy(session)
-        final_session.active_skills = [(self.skill_id, 0.0)]
-
-        test = End2EndTest(
-            minicroft=minicroft,
-            skill_ids=[self.skill_id],
-            flip_points=[utt_topic],
-            entry_points=[utt_topic],
-            source_message=message,
-            final_session=final_session,
-            activation_points=[f"{self.skill_id}:Greetings.intent"],
-            expected_messages=[
-                message,
-                Message(f"{self.skill_id}.activate",
-                        data={},
-                        context={"skill_id": self.skill_id}),
-                Message(f"{self.skill_id}:Greetings.intent",
-                        data={"utterance": "good morning", "lang": session.lang},
-                        context={"skill_id": self.skill_id}),
-                Message("mycroft.skill.handler.start",
-                        data={"name": "HelloWorldSkill.handle_greetings"},
-                        context={"skill_id": self.skill_id}),
-                Message(SPEC_SPEAK,
-                        data={"expect_response": False,
-                              "meta": {
-                                  "dialog": "hello",
-                                  "data": {},
-                                  "skill": self.skill_id
-                              }},
-                        context={"skill_id": self.skill_id}),
-                Message("mycroft.skill.handler.complete",
-                        data={"name": "HelloWorldSkill.handle_greetings"},
-                        context={"skill_id": self.skill_id}),
-                Message(UTTERANCE_HANDLED,
-                        data={},
-                        context={"skill_id": self.skill_id}),
-            ]
-        )
-
-        test.execute(timeout=10)
-        minicroft.stop()
+        try:
+
+            session = Session("123")
+            session.lang = "en-US"
+            session.pipeline = ["ovos-padatious-pipeline-plugin-high"]
+            message = Message(utt_topic,
+                              {"utterances": ["good morning"], "lang": session.lang},
+                              {"session": session.serialize(), "source": "A", "destination": "B"})
+
+            final_session = deepcopy(session)
+            final_session.active_skills = [(self.skill_id, 0.0)]
+
+            test = End2EndTest(
+                minicroft=minicroft,
+                skill_ids=[self.skill_id],
+                flip_points=[utt_topic],
+                entry_points=[utt_topic],
+                ignore_messages=["recognizer_loop:audio_output_start",
+                                  "recognizer_loop:audio_output_end"],
+                source_message=message,
+                final_session=final_session,
+                activation_points=[f"{self.skill_id}:Greetings.intent"],
+                expected_messages=[
+                    message,
+                    Message(f"{self.skill_id}.activate",
+                            data={},
+                            context={"skill_id": self.skill_id}),
+                # PIPELINE-1 §9.2: matched notification, before the dispatch
+                    Message(INTENT_MATCHED,
+                            data={"skill_id": self.skill_id,
+                                  "intent_name": f"{self.skill_id}:Greetings.intent",
+                                  "utterance": "good morning", "lang": session.lang},
+                            context={"skill_id": self.skill_id}),
+                # PIPELINE-1 §8.1: orchestrator start before dispatch
+                    Message(HANDLER_START,
+                            data={"skill_id": self.skill_id,
+                                  "intent_name": "Greetings.intent"},
+                            context={"skill_id": self.skill_id}),
+                    Message(f"{self.skill_id}:Greetings.intent",
+                            data={"utterance": "good morning", "lang": session.lang},
+                            context={"skill_id": self.skill_id}),
+                    Message("mycroft.skill.handler.start",
+                            data={"name": "HelloWorldSkill.handle_greetings"},
+                            context={"skill_id": self.skill_id}),
+                    Message(SPEC_SPEAK,
+                            data={"expect_response": False,
+                                  "meta": {
+                                      "dialog": "hello",
+                                      "data": {},
+                                      "skill": self.skill_id
+                                  }},
+                            context={"skill_id": self.skill_id}),
+                    Message("mycroft.skill.handler.complete",
+                            data={"name": "HelloWorldSkill.handle_greetings"},
+                            context={"skill_id": self.skill_id}),
+                # PIPELINE-1 §8.1: orchestrator complete before the end-marker
+                    Message(HANDLER_COMPLETE,
+                            data={"skill_id": self.skill_id,
+                                  "intent_name": "Greetings.intent"},
+                            context={"skill_id": self.skill_id}),
+                    Message(UTTERANCE_HANDLED,
+                            data={},
+                            context={"skill_id": self.skill_id}),
+                ]
+            )
+
+            test.execute(timeout=10)
+        finally:
+            minicroft.stop()
 
     def test_padatious_match(self):
         for namespace in NAMESPACE_PATHS:
@@ -106,32 +132,34 @@ def _run_skill_blacklist(self, namespace):
         modernize, emit_legacy, utt_topic = NAMESPACE_PATHS[namespace]
         minicroft = get_minicroft([self.skill_id], modernize=modernize,
                                   emit_legacy=emit_legacy)
-
-        session = Session("123")
-        session.lang = "en-US"
-        session.pipeline = ["ovos-padatious-pipeline-plugin-high"]
-        session.blacklisted_skills = [self.skill_id]
-        message = Message(utt_topic,
-                          {"utterances": ["good morning"], "lang": session.lang},
-                          {"session": session.serialize(), "source": "A", "destination": "B"})
-
-        test = End2EndTest(
-            minicroft=minicroft,
-            skill_ids=[self.skill_id],
-            flip_points=[utt_topic],
-            entry_points=[utt_topic],
-            source_message=message,
-            final_session=session,
-            expected_messages=[
-                message,
-                Message("mycroft.audio.play_sound", {"uri": "snd/error.mp3"}),
-                Message("complete_intent_failure", {}),
-                Message(UTTERANCE_HANDLED, {})
-            ]
-        )
-
-        test.execute(timeout=10)
-        minicroft.stop()
+        try:
+
+            session = Session("123")
+            session.lang = "en-US"
+            session.pipeline = ["ovos-padatious-pipeline-plugin-high"]
+            session.blacklisted_skills = [self.skill_id]
+            message = Message(utt_topic,
+                              {"utterances": ["good morning"], "lang": session.lang},
+                              {"session": session.serialize(), "source": "A", "destination": "B"})
+
+            test = End2EndTest(
+                minicroft=minicroft,
+                skill_ids=[self.skill_id],
+                flip_points=[utt_topic],
+                entry_points=[utt_topic],
+                source_message=message,
+                final_session=session,
+                expected_messages=[
+                    message,
+                    Message("mycroft.audio.play_sound", {"uri": "snd/error.mp3"}),
+                    Message(INTENT_UNMATCHED, {}),
+                    Message(UTTERANCE_HANDLED, {})
+                ]
+            )
+
+            test.execute(timeout=10)
+        finally:
+            minicroft.stop()
 
     def test_skill_blacklist(self):
         for namespace in NAMESPACE_PATHS:
@@ -142,32 +170,34 @@ def _run_intent_blacklist(self, namespace):
         modernize, emit_legacy, utt_topic = NAMESPACE_PATHS[namespace]
         minicroft = get_minicroft([self.skill_id], modernize=modernize,
                                   emit_legacy=emit_legacy)
-
-        session = Session("123")
-        session.lang = "en-US"
-        session.pipeline = ["ovos-padatious-pipeline-plugin-high"]
-        session.blacklisted_intents = [f"{self.skill_id}:Greetings.intent"]
-        message = Message(utt_topic,
-                          {"utterances": ["good morning"], "lang": session.lang},
-                          {"session": session.serialize(), "source": "A", "destination": "B"})
-
-        test = End2EndTest(
-            minicroft=minicroft,
-            skill_ids=[self.skill_id],
-            flip_points=[utt_topic],
-            entry_points=[utt_topic],
-            source_message=message,
-            final_session=session,
-            expected_messages=[
-                message,
-                Message("mycroft.audio.play_sound", {"uri": "snd/error.mp3"}),
-                Message("complete_intent_failure", {}),
-                Message(UTTERANCE_HANDLED, {})
-            ]
-        )
-
-        test.execute(timeout=10)
-        minicroft.stop()
+        try:
+
+            session = Session("123")
+            session.lang = "en-US"
+            session.pipeline = ["ovos-padatious-pipeline-plugin-high"]
+            session.blacklisted_intents = [f"{self.skill_id}:Greetings.intent"]
+            message = Message(utt_topic,
+                              {"utterances": ["good morning"], "lang": session.lang},
+                              {"session": session.serialize(), "source": "A", "destination": "B"})
+
+            test = End2EndTest(
+                minicroft=minicroft,
+                skill_ids=[self.skill_id],
+                flip_points=[utt_topic],
+                entry_points=[utt_topic],
+                source_message=message,
+                final_session=session,
+                expected_messages=[
+                    message,
+                    Message("mycroft.audio.play_sound", {"uri": "snd/error.mp3"}),
+                    Message(INTENT_UNMATCHED, {}),
+                    Message(UTTERANCE_HANDLED, {})
+                ]
+            )
+
+            test.execute(timeout=10)
+        finally:
+            minicroft.stop()
 
     def test_intent_blacklist(self):
         for namespace in NAMESPACE_PATHS:
@@ -178,31 +208,33 @@ def _run_adapt_no_match(self, namespace):
         modernize, emit_legacy, utt_topic = NAMESPACE_PATHS[namespace]
         minicroft = get_minicroft([self.skill_id], modernize=modernize,
                                   emit_legacy=emit_legacy)
-
-        session = Session("123")
-        session.lang = "en-US"
-        session.pipeline = ['ovos-adapt-pipeline-plugin-high']
-        message = Message(utt_topic,
-                          {"utterances": ["good morning"], "lang": session.lang},
-                          {"session": session.serialize(), "source": "A", "destination": "B"})
-
-        test = End2EndTest(
-            minicroft=minicroft,
-            skill_ids=[self.skill_id],
-            flip_points=[utt_topic],
-            entry_points=[utt_topic],
-            source_message=message,
-            final_session=session,
-            expected_messages=[
-                message,
-                Message("mycroft.audio.play_sound", {"uri": "snd/error.mp3"}),
-                Message("complete_intent_failure", {}),
-                Message(UTTERANCE_HANDLED, {})
-            ]
-        )
-
-        test.execute(timeout=10)
-        minicroft.stop()
+        try:
+
+            session = Session("123")
+            session.lang = "en-US"
+            session.pipeline = ['ovos-adapt-pipeline-plugin-high']
+            message = Message(utt_topic,
+                              {"utterances": ["good morning"], "lang": session.lang},
+                              {"session": session.serialize(), "source": "A", "destination": "B"})
+
+            test = End2EndTest(
+                minicroft=minicroft,
+                skill_ids=[self.skill_id],
+                flip_points=[utt_topic],
+                entry_points=[utt_topic],
+                source_message=message,
+                final_session=session,
+                expected_messages=[
+                    message,
+                    Message("mycroft.audio.play_sound", {"uri": "snd/error.mp3"}),
+                    Message(INTENT_UNMATCHED, {}),
+                    Message(UTTERANCE_HANDLED, {})
+                ]
+            )
+
+            test.execute(timeout=10)
+        finally:
+            minicroft.stop()
 
     def test_adapt_no_match(self):
         for namespace in NAMESPACE_PATHS:
diff --git a/test/end2end/test_stop.py b/test/end2end/test_stop.py
index 72a48cc8d25..5578154eb14 100644
--- a/test/end2end/test_stop.py
+++ b/test/end2end/test_stop.py
@@ -16,7 +16,7 @@
 from unittest import TestCase
 
 from ovos_bus_client.message import Message
-from ovos_bus_client.session import Session
+from ovos_bus_client.session import Session, SessionManager
 from ovos_spec_tools import SpecMessage, migration_counterpart
 from ovos_utils import create_daemon
 from ovos_utils.log import LOG
@@ -27,8 +27,24 @@
 # legacy counterpart is derived via migration_counterpart, never hardcoded.
 SPEC_UTTERANCE = SpecMessage.UTTERANCE.value              # ovos.utterance.handle
 LEGACY_UTTERANCE = migration_counterpart(SPEC_UTTERANCE)  # recognizer_loop:utterance
-UTTERANCE_HANDLED = SpecMessage.UTTERANCE_HANDLED.value   # ovos.utterance.handled
 SPEC_SPEAK = SpecMessage.SPEAK.value                      # ovos.utterance.speak
+INTENT_UNMATCHED = SpecMessage.INTENT_UNMATCHED.value     # ovos.intent.unmatched (§9.3)
+HANDLER_ERROR = SpecMessage.INTENT_HANDLER_ERROR.value
+
+
+def _wait_for_active_skill(session_id, skill_id, timeout=10, interval=0.1):
+    """Poll until *skill_id* appears in the session's active skills."""
+    deadline = time.time() + timeout
+    while time.time() < deadline:
+        sess = SessionManager.sessions.get(session_id)
+        if sess and sess.is_active(skill_id):
+            return
+        time.sleep(interval)
+    raise TimeoutError(
+        f"Skill {skill_id} did not activate in session {session_id} "
+        f"within {timeout}s"
+    )
+
 
 # The two namespace paths every scenario is run on.
 #   key       -> (modernize, emit_legacy, utterance_topic)
@@ -44,16 +60,82 @@
 # on the spec topic ovos.utterance.speak (no legacy mirror, emit_legacy=False).
 IGNORE_MESSAGES = [
     SPEC_SPEAK,
+    "recognizer_loop:audio_output_start",  # TTS mock duck
+    "recognizer_loop:audio_output_end",  # TTS mock unduck
+    # ovos.intent.matched (§9.2) precedes every dispatch; these scenarios assert
+    # stop routing/activation, not the matched broadcast, so it is filtered here.
+    SpecMessage.INTENT_MATCHED,
+    # the §8 handler-lifecycle trio also wraps every dispatch; these scenarios
+    # assert stop routing, not the trio (it is covered by the adapt/padatious
+    # suites), so it is filtered here too.
+    SpecMessage.INTENT_HANDLER_START,
+    SpecMessage.INTENT_HANDLER_COMPLETE,
+    HANDLER_ERROR,
     "ovos.common_play.stop.response",
     "common_query.openvoiceos.stop.response",
     "persona.openvoiceos.stop.response",
     "ovos-hivemind-pipeline-plugin.stop.response",
-    # StopService now subclasses OVOSAbstractApplication,
-    # so it also emits a stop.response when mycroft.stop is broadcast
-    "stop.openvoiceos.stop.response",
+    # The async stop-pipeline callback cleans up an interrupted skill depending
+    # on exactly where the stop lands (mid get_response / active / mid-TTS). These
+    # artifacts are timing-dependent — ignore them so the assertion stays stable.
+    "mycroft.skills.abort_question",
+    "ovos.skills.converse.force_timeout",
+    "mycroft.audio.speech.stop",
 ]
 
 
+def skill_stop_lifecycle(skill_id):
+    """The deterministic stop-dispatch §8 lifecycle, as seen filtered to
+    ``skill_id="stop.openvoiceos"`` (the StopService that owns the stop dispatch).
+
+    Stopping a *running* skill produces two concurrent dispatch lifecycles whose
+    messages interleave non-deterministically: the stop dispatch (asserted here)
+    and the interrupted skill's own §8 trio + §9.5 terminal, which completes
+    asynchronously once the daemon thread unwinds. The End2EndTest ``skill_id``
+    filter isolates the stop dispatch; ``eof_count=2`` lets capture span both
+    utterances' ``ovos.utterance.handled`` before filtering. The interrupted
+    skill's §8 trio is asserted deterministically (uninterrupted) by ``test_count``.
+    """
+    return [
+        Message("stop.openvoiceos.activate", {},
+                {"skill_id": "stop.openvoiceos"}),
+        Message("stop:skill",
+                {"skill_id": skill_id},
+                {"skill_id": "stop.openvoiceos"}),
+        # StopService wraps handle_skill_stop in HandlerLifecycle (the framework
+        # done-signal trio the orchestrator translates into the §8 terminal)
+        Message("mycroft.skill.handler.start",
+                {"name": "StopService.handle_skill_stop"},
+                {"skill_id": "stop.openvoiceos"}),
+        Message(f"{skill_id}.stop", {},
+                {"skill_id": "stop.openvoiceos"}),
+        Message("mycroft.skill.handler.complete",
+                {"name": "StopService.handle_skill_stop"},
+                {"skill_id": "stop.openvoiceos"}),
+        # §9.5 end-marker
+        Message(SpecMessage.UTTERANCE_HANDLED, {},
+                {"skill_id": "stop.openvoiceos"}),
+    ]
+
+
+# Shared End2EndTest config for the skill-stop (ping-pong) scenarios: isolate the
+# stop dispatch lifecycle and wait for BOTH utterances to terminate before filtering.
+# The §8 SPEC trio (ovos.intent.matched/handler.start/handler.complete) is filtered:
+# in these concurrent-lifecycle scenarios under heavy parallel load it is not
+# reliably observed alongside the legacy done-signal, so it is asserted in the
+# single-lifecycle adapt/padatious suites instead. The legacy mycroft.skill.handler
+# done-signal trio (which the orchestrator translates into the §8 terminal) IS
+# asserted above.
+SKILL_STOP_LIFECYCLE_KWARGS = dict(
+    skill_id="stop.openvoiceos",
+    eof_msgs=[SpecMessage.UTTERANCE_HANDLED],
+    eof_count=2,
+    test_active_skills=False,
+    ignore_messages=[SpecMessage.INTENT_MATCHED, SpecMessage.INTENT_HANDLER_START, SpecMessage.INTENT_HANDLER_COMPLETE, HANDLER_ERROR,
+                     "ovos.skills.settings_changed"],
+)
+
+
 class TestStopNoSkills(TestCase):
 
     def setUp(self):
@@ -76,7 +158,7 @@ def _run_exact(self, namespace):
             test = End2EndTest(
                 minicroft=minicroft,
                 skill_ids=[],
-                eof_msgs=[UTTERANCE_HANDLED],
+                eof_msgs=[SpecMessage.UTTERANCE_HANDLED],
                 flip_points=[utt_topic],
                 entry_points=[utt_topic],
                 ignore_messages=IGNORE_MESSAGES,
@@ -87,9 +169,14 @@ def _run_exact(self, namespace):
                     Message("stop.openvoiceos.activate", {}),  # stop pipeline counts as active_skill
 
                     Message("stop:global", {}),  # global stop, no active skill
+                    # StopService wraps the global-stop handler in HandlerLifecycle
+                    Message("mycroft.skill.handler.start",
+                            {"name": "StopService.handle_global_stop"}),
                     Message("mycroft.stop", {}),
+                    Message("mycroft.skill.handler.complete",
+                            {"name": "StopService.handle_global_stop"}),
 
-                    Message(UTTERANCE_HANDLED, {})
+                    Message(SpecMessage.UTTERANCE_HANDLED, {})
                 ]
             )
 
@@ -116,7 +203,7 @@ def _run_not_exact_high(self, namespace):
             test = End2EndTest(
                 minicroft=minicroft,
                 skill_ids=[],
-                eof_msgs=[UTTERANCE_HANDLED],
+                eof_msgs=[SpecMessage.UTTERANCE_HANDLED],
                 flip_points=[utt_topic],
                 entry_points=[utt_topic],
                 ignore_messages=IGNORE_MESSAGES,
@@ -124,8 +211,8 @@ def _run_not_exact_high(self, namespace):
                 expected_messages=[
                     message,
                     Message("mycroft.audio.play_sound", {"uri": "snd/error.mp3"}),
-                    Message("complete_intent_failure", {}),
-                    Message(UTTERANCE_HANDLED, {}),
+                    Message(INTENT_UNMATCHED, {}),
+                    Message(SpecMessage.UTTERANCE_HANDLED, {}),
                 ]
             )
 
@@ -152,7 +239,7 @@ def _run_not_exact_med(self, namespace):
             test = End2EndTest(
                 minicroft=minicroft,
                 skill_ids=[],
-                eof_msgs=[UTTERANCE_HANDLED],
+                eof_msgs=[SpecMessage.UTTERANCE_HANDLED],
                 flip_points=[utt_topic],
                 entry_points=[utt_topic],
                 source_message=message,
@@ -163,9 +250,14 @@ def _run_not_exact_med(self, namespace):
                     Message("stop.openvoiceos.activate", {}),  # stop pipeline counts as active_skill
 
                     Message("stop:global", {}),  # global stop, no active skill
+                    # StopService wraps the global-stop handler in HandlerLifecycle
+                    Message("mycroft.skill.handler.start",
+                            {"name": "StopService.handle_global_stop"}),
                     Message("mycroft.stop", {}),
+                    Message("mycroft.skill.handler.complete",
+                            {"name": "StopService.handle_global_stop"}),
 
-                    Message(UTTERANCE_HANDLED, {})
+                    Message(SpecMessage.UTTERANCE_HANDLED, {})
                 ]
             )
 
@@ -215,12 +307,12 @@ def _run_count(self, namespace):
                     "name": "CountSkill.handle_how_are_you_intent"
                 }),
 
-                Message(UTTERANCE_HANDLED, {})
+                Message(SpecMessage.UTTERANCE_HANDLED, {})
             ]
             test = End2EndTest(
                 minicroft=minicroft,
                 skill_ids=[],
-                eof_msgs=[UTTERANCE_HANDLED],
+                eof_msgs=[SpecMessage.UTTERANCE_HANDLED],
                 flip_points=[utt_topic],
                 entry_points=[utt_topic],
                 ignore_messages=IGNORE_MESSAGES,
@@ -252,82 +344,31 @@ def make_it_count():
                 msg = Message(utt_topic,
                               {"utterances": ["count to infinity"], "lang": session.lang},
                               {"session": session.serialize(), "source": "A", "destination": "B"})
-                session.activate_skill(self.skill_id)  # ensure in active skill list
                 minicroft.bus.emit(msg)
 
             # count to infinity, the skill will keep running in the background
             create_daemon(make_it_count)
 
-            time.sleep(2)
+            # Wait for the skill to activate before sending stop; under parallel
+            # CI load the fixed sleep is too short, so poll deterministically.
+            _wait_for_active_skill(session.session_id, self.skill_id)
 
+            # The count intent self-activates the skill server-side; the Session
+            # singleton holds the authoritative state (SESSION-1 last-write-wins).
+            # A real client tracks the session via responses and resends it, so
+            # the stop turn carries the running skill in active_skills — no manual
+            # activation required.
+            session = SessionManager.sessions[session.session_id]
             message = Message(utt_topic,
                               {"utterances": ["stop"], "lang": session.lang},
                               {"session": session.serialize(), "source": "A", "destination": "B"})
 
-            stop_skill_active = [
-                message,
-                Message(f"{self.skill_id}.stop.ping",
-                        {"skill_id": self.skill_id}),
-                Message("skill.stop.pong",
-                        {"skill_id": self.skill_id, "can_handle": True},
-                        {"skill_id": self.skill_id}),
-
-                Message("stop.openvoiceos.activate",
-                        context={"skill_id": "stop.openvoiceos"}),
-                Message("stop:skill",
-                        context={"skill_id": "stop.openvoiceos"}),
-                Message(f"{self.skill_id}.stop",
-                        context={"skill_id": "stop.openvoiceos"}),
-                Message(f"{self.skill_id}.stop.response",
-                        {"skill_id": self.skill_id, "result": True},
-                        {"skill_id": self.skill_id}),
-
-                # async stop pipeline callback emits these messages
-                # but we cant guarantee where in the test they will be emitted
-
-                # if skill is in middle of get_response
-                #Message("mycroft.skills.abort_question",
-                #        {"skill_id": self.skill_id},
-                #        {"skill_id": self.skill_id}),
-
-                # if skill is in active_list
-                #Message("ovos.skills.converse.force_timeout",
-                #        {"skill_id": self.skill_id},
-                #        {"skill_id": self.skill_id}),
-
-                # if skill is executing TTS
-                #Message("mycroft.audio.speech.stop",
-                #        {"skill_id": self.skill_id},
-                #        {"skill_id": self.skill_id}),
-
-                # the intent running in the daemon thread exits cleanly
-                Message("mycroft.skill.handler.complete",
-                        {"name": "CountSkill.handle_how_are_you_intent"},
-                        {"skill_id": self.skill_id}),
-                Message(UTTERANCE_HANDLED,
-                        {"name": "CountSkill.handle_how_are_you_intent"},
-                        {"skill_id": self.skill_id})
-            ]
             test = End2EndTest(
                 minicroft=minicroft,
                 skill_ids=[],
-                eof_msgs=[],
-                flip_points=[utt_topic],
-                entry_points=[utt_topic],
-                # messages in 'keep_original_src' would not be sent to hivemind clients
-                # i.e. they are directed towards ovos-core
-                keep_original_src=[f"{self.skill_id}.stop.ping",
-                                   f"{self.skill_id}.stop",
-                                   "mycroft.skills.abort_question",
-                                   "ovos.skills.converse.force_timeout",
-                                   # "stop.openvoiceos.activate" # TODO
-                                   ],
-                async_messages=[
-                    "ovos.skills.converse.force_timeout"
-                ],  # order that it wil be received unknown
-                ignore_messages=IGNORE_MESSAGES,
                 source_message=message,
-                expected_messages=stop_skill_active
+                expected_messages=skill_stop_lifecycle(self.skill_id),
+                **SKILL_STOP_LIFECYCLE_KWARGS,
             )
             test.execute()
         finally:
@@ -364,27 +405,31 @@ def make_it_count():
             message = Message(utt_topic,
                               {"utterances": ["stop"], "lang": session.lang},
                               {"session": session.serialize()})
+            # Assert ONLY the global-stop dispatch lifecycle (skill_id=stop.openvoiceos);
+            # the interrupted count intent's terminal races in asynchronously and is
+            # isolated out by the skill_id filter (eof_count=2 spans both utterances).
             stop_skill_from_global = [
-                message,
-                Message("stop.openvoiceos.activate", {}),  # stop pipeline counts as active_skill
-
-                Message("stop:global", {}),  # global stop, no active skill
-                Message("mycroft.stop", {}),
-
-                Message(f"{self.skill_id}.stop.response",
-                        {"skill_id": self.skill_id, "result": True}),
-                Message(UTTERANCE_HANDLED, {})
+                Message("stop.openvoiceos.activate", {},
+                        {"skill_id": "stop.openvoiceos"}),
+                Message("stop:global", {},
+                        {"skill_id": "stop.openvoiceos"}),
+                Message("mycroft.skill.handler.start",
+                        {"name": "StopService.handle_global_stop"},
+                        {"skill_id": "stop.openvoiceos"}),
+                Message("mycroft.stop", {},
+                        {"skill_id": "stop.openvoiceos"}),
+                Message("mycroft.skill.handler.complete",
+                        {"name": "StopService.handle_global_stop"},
+                        {"skill_id": "stop.openvoiceos"}),
+                Message(SpecMessage.UTTERANCE_HANDLED, {},
+                        {"skill_id": "stop.openvoiceos"}),
             ]
             test = End2EndTest(
                 minicroft=minicroft,
                 skill_ids=[],
-                eof_msgs=[UTTERANCE_HANDLED],
-                flip_points=[utt_topic],
-                entry_points=[utt_topic],
-                ignore_messages=IGNORE_MESSAGES,
                 source_message=message,
                 expected_messages=stop_skill_from_global,
-                #keep_original_src=["stop.openvoiceos.activate"],  # TODO
+                **SKILL_STOP_LIFECYCLE_KWARGS,
             )
             test.execute()
         finally:
@@ -406,85 +451,31 @@ def _run_count_infinity_stop_low(self, namespace):
                                 'ovos-stop-pipeline-plugin-low']
 
             def make_it_count():
-                nonlocal session
                 msg = Message(utt_topic,
                               {"utterances": ["count to infinity"], "lang": session.lang},
                               {"session": session.serialize(), "source": "A", "destination": "B"})
-                session.activate_skill(self.skill_id)  # ensure in active skill list
                 minicroft.bus.emit(msg)
 
             # count to infinity, the skill will keep running in the background
             create_daemon(make_it_count)
 
-            time.sleep(2)
+            # Wait for the skill to activate before sending stop; under parallel
+            # CI load the fixed sleep is too short, so poll deterministically.
+            _wait_for_active_skill(session.session_id, self.skill_id)
 
+            # resend the live (singleton) session, as a client tracking responses
+            # would — the count intent self-activated the skill server-side
+            session = SessionManager.sessions[session.session_id]
             message = Message(utt_topic,
                               {"utterances": ["full stop"], "lang": session.lang},
                               {"session": session.serialize(), "source": "A", "destination": "B"})
 
-            stop_skill_active = [
-                message,
-                Message(f"{self.skill_id}.stop.ping",
-                        {"skill_id": self.skill_id}),
-                Message("skill.stop.pong",
-                        {"skill_id": self.skill_id, "can_handle": True},
-                        {"skill_id": self.skill_id}),
-
-                Message("stop.openvoiceos.activate",
-                        context={"skill_id": "stop.openvoiceos"}),
-                Message("stop:skill",
-                        context={"skill_id": "stop.openvoiceos"}),
-                Message(f"{self.skill_id}.stop",
-                        context={"skill_id": "stop.openvoiceos"}),
-                Message(f"{self.skill_id}.stop.response",
-                        {"skill_id": self.skill_id, "result": True},
-                        {"skill_id": self.skill_id}),
-
-                # async stop pipeline callback emits these messages
-                # but we cant guarantee where in the test they will be emitted
-
-                # if skill is in middle of get_response
-                #Message("mycroft.skills.abort_question",
-                #        {"skill_id": self.skill_id},
-                #        {"skill_id": self.skill_id}),
-
-                # if skill is in active_list
-                #Message("ovos.skills.converse.force_timeout",
-                #        {"skill_id": self.skill_id},
-                #        {"skill_id": self.skill_id}),
-
-                # if skill is executing TTS
-                #Message("mycroft.audio.speech.stop",
-                #        {"skill_id": self.skill_id},
-                #        {"skill_id": self.skill_id}),
-
-                # the intent running in the daemon thread exits cleanly
-                Message("mycroft.skill.handler.complete",
-                        {"name": "CountSkill.handle_how_are_you_intent"},
-                        {"skill_id": self.skill_id}),
-                Message(UTTERANCE_HANDLED,
-                        {"name": "CountSkill.handle_how_are_you_intent"},
-                        {"skill_id": self.skill_id})
-            ]
             test = End2EndTest(
                 minicroft=minicroft,
                 skill_ids=[],
-                eof_msgs=[],
-                flip_points=[utt_topic],
-                entry_points=[utt_topic],
-                # messages in 'keep_original_src' would not be sent to hivemind clients
-                # i.e. they are directed towards ovos-core
-                keep_original_src=[f"{self.skill_id}.stop.ping",
-                                   f"{self.skill_id}.stop",
-                                   "mycroft.skills.abort_question",
-                                   # "stop.openvoiceos.activate", # TODO
-                                   "ovos.skills.converse.force_timeout"],
-                ignore_messages=IGNORE_MESSAGES,
-                async_messages=[
-                    "ovos.skills.converse.force_timeout"
-                ],  # order that it wil be received unknown
                 source_message=message,
-                expected_messages=stop_skill_active
+                expected_messages=skill_stop_lifecycle(self.skill_id),
+                **SKILL_STOP_LIFECYCLE_KWARGS,
             )
             test.execute()
         finally:
diff --git a/test/end2end/test_stop_refactor.py b/test/end2end/test_stop_refactor.py
index f4cdbdc6fec..78cd0f0ba0e 100644
--- a/test/end2end/test_stop_refactor.py
+++ b/test/end2end/test_stop_refactor.py
@@ -1,14 +1,15 @@
-"""End-to-end tests for the StopService OVOSAbstractApplication refactor.
+"""End-to-end tests for the StopService stop-vocabulary refactor.
 
-These tests verify behaviour introduced or changed when StopService was
-refactored to subclass OVOSAbstractApplication:
+StopService is a pipeline plugin (NOT an ovos-workshop skill); it matches the
+stop vocabulary via ovos-spec-tools (LocaleResources) instead of the
+OVOSAbstractApplication base class. These tests verify:
 
 1. Vocabulary loaded from .voc files (renamed from .intent) still matches.
 2. global_stop.voc phrases trigger a global stop even when skills are active.
 3. can_handle=False default: a skill that declines the stop ping is still
    tried via the active-skills fallback.
-4. StopService (as OVOSSkill) emits stop.openvoiceos.stop.response when
-   mycroft.stop is broadcast — verified via ignore_messages pattern.
+4. StopService does NOT register skill machinery — it never answers the
+   mycroft.stop broadcast with stop.openvoiceos.stop.response.
 
 Every scenario that injects an utterance is run on BOTH bus namespace paths via
 ``self.subTest(namespace=...)``:
@@ -28,7 +29,7 @@
 from unittest import TestCase
 
 from ovos_bus_client.message import Message
-from ovos_bus_client.session import Session
+from ovos_bus_client.session import Session, SessionManager
 from ovos_spec_tools import SpecMessage, migration_counterpart
 from ovos_utils import create_daemon
 from ovos_utils.log import LOG
@@ -39,8 +40,8 @@
 # legacy counterpart is derived via migration_counterpart, never hardcoded.
 SPEC_UTTERANCE = SpecMessage.UTTERANCE.value              # ovos.utterance.handle
 LEGACY_UTTERANCE = migration_counterpart(SPEC_UTTERANCE)  # recognizer_loop:utterance
-UTTERANCE_HANDLED = SpecMessage.UTTERANCE_HANDLED.value   # ovos.utterance.handled
 SPEC_SPEAK = SpecMessage.SPEAK.value                      # ovos.utterance.speak
+HANDLER_ERROR = SpecMessage.INTENT_HANDLER_ERROR.value
 
 # The two namespace paths every scenario is run on.
 #   key       -> (modernize, emit_legacy, utterance_topic)
@@ -57,12 +58,25 @@
 # emit_legacy=False on both paths).
 _STOP_RESPONSES = [
     SPEC_SPEAK,
+    "recognizer_loop:audio_output_start",  # TTS mock duck
+    "recognizer_loop:audio_output_end",  # TTS mock unduck
+    # ovos.intent.matched (§9.2) precedes every dispatch; these scenarios assert
+    # stop routing/activation, not the matched broadcast, so it is filtered here.
+    SpecMessage.INTENT_MATCHED,
+    # the §8 handler-lifecycle trio also wraps every dispatch; filtered here
+    # (covered by the adapt/padatious suites).
+    SpecMessage.INTENT_HANDLER_START,
+    SpecMessage.INTENT_HANDLER_COMPLETE,
+    HANDLER_ERROR,
     "ovos.common_play.stop.response",
     "common_query.openvoiceos.stop.response",
     "persona.openvoiceos.stop.response",
     "ovos-hivemind-pipeline-plugin.stop.response",
-    # StopService now subclasses OVOSAbstractApplication — it also responds to mycroft.stop
-    "stop.openvoiceos.stop.response",
+    # timing-dependent cleanup of an interrupted skill (mid get_response /
+    # active / mid-TTS) — ignore so the assertion stays stable across runs.
+    "mycroft.skills.abort_question",
+    "ovos.skills.converse.force_timeout",
+    "mycroft.audio.speech.stop",
 ]
 
 
@@ -70,11 +84,11 @@ class TestGlobalStopVocabulary(TestCase):
     """global_stop.voc phrases trigger stop:global when no skills are active.
 
     These tests verify that the .voc file rename (from .intent) preserved the
-    vocabulary content and that voc_match (now delegated to OVOSAbstractApplication)
-    correctly distinguishes 'stop' from 'stop everything'.
+    vocabulary content and that voc_match (delegated to ovos-spec-tools
+    LocaleResources) correctly distinguishes 'stop' from 'stop everything'.
 
-    No skills are loaded here so mycroft.stop does not produce any extra
-    {skill_id}.stop.response messages beyond stop.openvoiceos.stop.response.
+    No skills are loaded here, so mycroft.stop produces no {skill_id}.stop.response
+    messages — and StopService itself no longer answers it.
     """
 
     def setUp(self):
@@ -98,7 +112,7 @@ def _run_global_stop_voc_no_active_skills(self, namespace):
         test = End2EndTest(
             minicroft=minicroft,
             skill_ids=[],
-            eof_msgs=[UTTERANCE_HANDLED],
+            eof_msgs=[SpecMessage.UTTERANCE_HANDLED],
             flip_points=[utt_topic],
             entry_points=[utt_topic],
             ignore_messages=_STOP_RESPONSES,
@@ -107,8 +121,13 @@ def _run_global_stop_voc_no_active_skills(self, namespace):
                 message,
                 Message("stop.openvoiceos.activate", {}),
                 Message("stop:global", {}),
+                # StopService wraps the global-stop handler in HandlerLifecycle
+                Message("mycroft.skill.handler.start",
+                        {"name": "StopService.handle_global_stop"}),
                 Message("mycroft.stop", {}),
-                Message(UTTERANCE_HANDLED, {}),
+                Message("mycroft.skill.handler.complete",
+                        {"name": "StopService.handle_global_stop"}),
+                Message(SpecMessage.UTTERANCE_HANDLED, {}),
             ]
         )
         test.execute()
@@ -137,7 +156,7 @@ def _run_stop_voc_exact_still_works(self, namespace):
         test = End2EndTest(
             minicroft=minicroft,
             skill_ids=[],
-            eof_msgs=[UTTERANCE_HANDLED],
+            eof_msgs=[SpecMessage.UTTERANCE_HANDLED],
             flip_points=[utt_topic],
             entry_points=[utt_topic],
             ignore_messages=_STOP_RESPONSES,
@@ -146,8 +165,13 @@ def _run_stop_voc_exact_still_works(self, namespace):
                 message,
                 Message("stop.openvoiceos.activate", {}),
                 Message("stop:global", {}),
+                # StopService wraps the global-stop handler in HandlerLifecycle
+                Message("mycroft.skill.handler.start",
+                        {"name": "StopService.handle_global_stop"}),
                 Message("mycroft.stop", {}),
-                Message(UTTERANCE_HANDLED, {}),
+                Message("mycroft.skill.handler.complete",
+                        {"name": "StopService.handle_global_stop"}),
+                Message(SpecMessage.UTTERANCE_HANDLED, {}),
             ]
         )
         test.execute()
@@ -196,7 +220,7 @@ def _run_global_stop_voc_with_active_skill(self, namespace):
         test = End2EndTest(
             minicroft=minicroft,
             skill_ids=[],
-            eof_msgs=[UTTERANCE_HANDLED],
+            eof_msgs=[SpecMessage.UTTERANCE_HANDLED],
             flip_points=[utt_topic],
             entry_points=[utt_topic],
             ignore_messages=ignore,
@@ -205,8 +229,13 @@ def _run_global_stop_voc_with_active_skill(self, namespace):
                 message,
                 Message("stop.openvoiceos.activate", {}),
                 Message("stop:global", {}),
+                # StopService wraps the global-stop handler in HandlerLifecycle
+                Message("mycroft.skill.handler.start",
+                        {"name": "StopService.handle_global_stop"}),
                 Message("mycroft.stop", {}),
-                Message(UTTERANCE_HANDLED, {}),
+                Message("mycroft.skill.handler.complete",
+                        {"name": "StopService.handle_global_stop"}),
+                Message(SpecMessage.UTTERANCE_HANDLED, {}),
             ]
         )
         test.execute()
@@ -255,50 +284,59 @@ def make_it_count():
             msg = Message(utt_topic,
                           {"utterances": ["count to infinity"], "lang": session.lang},
                           {"session": session.serialize(), "source": "A", "destination": "B"})
-            session.activate_skill(self.skill_id)
             minicroft.bus.emit(msg)
 
         create_daemon(make_it_count)
         time.sleep(2)
 
+        # The count intent self-activates the skill server-side; the Session
+        # singleton holds the authoritative state (SESSION-1 last-write-wins).
+        # Resend the live session for the stop turn as a real client would, so
+        # the running skill is in active_skills — no manual activation required.
+        session = SessionManager.sessions[session.session_id]
         message = Message(utt_topic,
                           {"utterances": ["stop"], "lang": session.lang},
                           {"session": session.serialize(), "source": "A", "destination": "B"})
 
+        # Assert ONLY the stop dispatch lifecycle (skill_id=stop.openvoiceos).
+        # Stopping a running skill produces two concurrent lifecycles whose
+        # messages interleave non-deterministically: the stop dispatch (asserted
+        # here) and the interrupted count intent's own §8 trio + §9.5 terminal,
+        # which completes asynchronously when the daemon unwinds. The skill_id
+        # filter isolates the stop dispatch; eof_count=2 lets capture span both
+        # utterances' ovos.utterance.handled before filtering.
+        # The §8 SPEC trio (ovos.intent.matched/handler.start/handler.complete) is
+        # filtered via ignore_messages: in this concurrent-lifecycle scenario under
+        # heavy parallel load it is not reliably observed alongside the legacy
+        # done-signal, so it is asserted in the single-lifecycle adapt/padatious
+        # suites instead. The legacy mycroft.skill.handler done-signal trio (which
+        # the orchestrator translates into the §8 terminal) IS asserted here.
         expected = [
-            message,
-            Message(f"{self.skill_id}.stop.ping", {"skill_id": self.skill_id}),
-            Message("skill.stop.pong",
-                    {"skill_id": self.skill_id, "can_handle": True},
-                    {"skill_id": self.skill_id}),
-            Message("stop.openvoiceos.activate", context={"skill_id": "stop.openvoiceos"}),
-            Message("stop:skill", context={"skill_id": "stop.openvoiceos"}),
-            Message(f"{self.skill_id}.stop", context={"skill_id": "stop.openvoiceos"}),
-            Message(f"{self.skill_id}.stop.response",
-                    {"skill_id": self.skill_id, "result": True},
-                    {"skill_id": self.skill_id}),
+            Message("stop.openvoiceos.activate", {},
+                    {"skill_id": "stop.openvoiceos"}),
+            Message("stop:skill", {"skill_id": self.skill_id},
+                    {"skill_id": "stop.openvoiceos"}),
+            Message("mycroft.skill.handler.start",
+                    {"name": "StopService.handle_skill_stop"},
+                    {"skill_id": "stop.openvoiceos"}),
+            Message(f"{self.skill_id}.stop", {},
+                    {"skill_id": "stop.openvoiceos"}),
             Message("mycroft.skill.handler.complete",
-                    {"name": "CountSkill.handle_how_are_you_intent"},
-                    {"skill_id": self.skill_id}),
-            Message(UTTERANCE_HANDLED,
-                    {"name": "CountSkill.handle_how_are_you_intent"},
-                    {"skill_id": self.skill_id}),
+                    {"name": "StopService.handle_skill_stop"},
+                    {"skill_id": "stop.openvoiceos"}),
+            Message(SpecMessage.UTTERANCE_HANDLED, {},
+                    {"skill_id": "stop.openvoiceos"}),
         ]
 
         test = End2EndTest(
             minicroft=minicroft,
             skill_ids=[],
-            eof_msgs=[],
-            flip_points=[utt_topic],
-            entry_points=[utt_topic],
-            keep_original_src=[
-                f"{self.skill_id}.stop.ping",
-                f"{self.skill_id}.stop",
-                "mycroft.skills.abort_question",
-                "ovos.skills.converse.force_timeout",
-            ],
-            async_messages=["ovos.skills.converse.force_timeout"],
-            ignore_messages=_STOP_RESPONSES,
+            skill_id="stop.openvoiceos",
+            eof_msgs=[SpecMessage.UTTERANCE_HANDLED],
+            eof_count=2,
+            test_active_skills=False,
+            ignore_messages=[SpecMessage.INTENT_MATCHED, SpecMessage.INTENT_HANDLER_START, SpecMessage.INTENT_HANDLER_COMPLETE,
+                             HANDLER_ERROR, "ovos.skills.settings_changed"],
             source_message=message,
             expected_messages=expected,
         )
@@ -311,16 +349,14 @@ def test_stop_with_active_skill_ping_pong(self):
                 self._run_stop_with_active_skill_ping_pong(namespace)
 
 
-class TestStopServiceAsSkill(TestCase):
-    """Verify that StopService behaves correctly as an OVOSAbstractApplication.
-
-    Since StopService now subclasses OVOSAbstractApplication it is registered
-    as a skill under skill_id='stop.openvoiceos'.  It therefore:
-      - responds to mycroft.stop with stop.openvoiceos.stop.response
-      - emits stop.openvoiceos.activate when the stop pipeline matches
+class TestStopServiceNotASkill(TestCase):
+    """StopService is a pipeline plugin, NOT an ovos-workshop skill.
 
-    These messages are already filtered via ignore_messages in other tests;
-    here we explicitly verify their presence.
+    It matches the stop vocabulary via ovos-spec-tools (LocaleResources) and owns
+    the stop dispatch, but it MUST NOT register skill machinery — in particular it
+    must NOT answer the mycroft.stop broadcast with stop.openvoiceos.stop.response
+    (that would make it stop "itself" and pollute the lifecycle). This is the
+    regression guard for dropping the OVOSAbstractApplication base class.
     """
 
     def setUp(self):
@@ -329,9 +365,9 @@ def setUp(self):
     def tearDown(self):
         LOG.set_level("CRITICAL")
 
-    def _run_stop_service_emits_activate_and_stop_response(self, namespace):
-        """After a global stop, stop.openvoiceos.activate and stop.openvoiceos.stop.response
-        are both emitted — confirming the service participates in skill lifecycle."""
+    def _run_stop_service_is_not_a_skill(self, namespace):
+        """A global stop with no skills loaded emits the stop dispatch lifecycle
+        and NO stop.openvoiceos.stop.response (StopService does not self-respond)."""
         modernize, emit_legacy, utt_topic = NAMESPACE_PATHS[namespace]
         minicroft = get_minicroft([], modernize=modernize, emit_legacy=emit_legacy)
 
@@ -342,32 +378,34 @@ def _run_stop_service_emits_activate_and_stop_response(self, namespace):
                           {"utterances": ["stop"], "lang": session.lang},
                           {"session": session.serialize()})
 
-        # Do NOT ignore stop.openvoiceos.stop.response here — we want to assert it appears
-        ignore = [m for m in _STOP_RESPONSES if m != "stop.openvoiceos.stop.response"]
-
+        # stop.openvoiceos.stop.response is intentionally NOT ignored: if the
+        # skill machinery ever comes back it would appear as an extra message and
+        # fail the count.
         test = End2EndTest(
             minicroft=minicroft,
             skill_ids=[],
-            eof_msgs=[UTTERANCE_HANDLED],
+            eof_msgs=[SpecMessage.UTTERANCE_HANDLED],
             flip_points=[utt_topic],
             entry_points=[utt_topic],
-            ignore_messages=ignore,
+            ignore_messages=_STOP_RESPONSES,
             source_message=message,
             expected_messages=[
                 message,
                 Message("stop.openvoiceos.activate", {}),
                 Message("stop:global", {}),
+                # StopService wraps the global-stop handler in HandlerLifecycle
+                Message("mycroft.skill.handler.start",
+                        {"name": "StopService.handle_global_stop"}),
                 Message("mycroft.stop", {}),
-                # StopService as OVOSSkill handles mycroft.stop and replies
-                Message("stop.openvoiceos.stop.response",
-                        {"result": False, "skill_id": "stop.openvoiceos"}),
-                Message(UTTERANCE_HANDLED, {}),
+                Message("mycroft.skill.handler.complete",
+                        {"name": "StopService.handle_global_stop"}),
+                Message(SpecMessage.UTTERANCE_HANDLED, {}),
             ]
         )
         test.execute()
         minicroft.stop()
 
-    def test_stop_service_emits_activate_and_stop_response(self):
+    def test_stop_service_is_not_a_skill(self):
         for namespace in NAMESPACE_PATHS:
             with self.subTest(namespace=namespace):
-                self._run_stop_service_emits_activate_and_stop_response(namespace)
+                self._run_stop_service_is_not_a_skill(namespace)
diff --git a/test/unittests/test_converse_service.py b/test/unittests/test_converse_service.py
index 5bc95dd5a37..6a18e0b19af 100644
--- a/test/unittests/test_converse_service.py
+++ b/test/unittests/test_converse_service.py
@@ -19,6 +19,7 @@
 
 from ovos_bus_client.message import Message
 from ovos_bus_client.session import Session, SessionManager, UtteranceState
+from ovos_spec_tools import SpecMessage
 from ovos_utils.fakebus import FakeBus
 from ovos_workshop.permissions import ConverseMode, ConverseActivationMode
 
@@ -705,5 +706,104 @@ def test_shutdown_removes_all_listeners(self):
         self.assertEqual(removed, expected)
 
 
+class TestConverseHandlerLifecycle(unittest.TestCase):
+    """The converse dispatch hop emits the framework done-signal so an
+    orchestrator (OVOS-PIPELINE-1 §8) can resolve the lifecycle of a reserved
+    ``converse`` dispatch instead of hitting its handler timeout."""
+
+    def _service_with_capture(self):
+        svc = _make_service()
+        bus = FakeBus()
+        captured = []
+        # FakeBus emits the "message" catch-all as a serialized string; parse it
+        # back into a Message so assertions can read msg_type/context/data.
+        bus.on("message", lambda s: captured.append(Message.deserialize(s)))
+        svc.bus = bus
+        return svc, captured
+
+    def test_dispatch_emits_handler_start_with_skill_id(self):
+        """handle_converse emits mycroft.skill.handler.start at dispatch,
+        stamped with the targeted skill_id, then the converse.request."""
+        svc, captured = self._service_with_capture()
+        msg = Message("converse:skill", {"skill_id": "skill_a",
+                                         "utterances": ["hello"]})
+        svc.handle_converse(msg)
+
+        topics = [m.msg_type for m in captured]
+        self.assertIn("mycroft.skill.handler.start", topics)
+        self.assertIn("skill_a.converse.request", topics)
+        # start fires before the dispatch
+        self.assertLess(topics.index("mycroft.skill.handler.start"),
+                        topics.index("skill_a.converse.request"))
+        start = next(m for m in captured
+                     if m.msg_type == "mycroft.skill.handler.start")
+        self.assertEqual(start.context.get("skill_id"), "skill_a")
+
+    def test_skill_response_emits_handler_complete(self):
+        """When the targeted skill replies skill.converse.response, the
+        lifecycle completes (mycroft.skill.handler.complete, same skill_id)."""
+        svc, captured = self._service_with_capture()
+        msg = Message("converse:skill", {"skill_id": "skill_a",
+                                         "utterances": ["hello"]})
+        svc.handle_converse(msg)
+        captured.clear()
+
+        svc.bus.emit(Message("skill.converse.response",
+                             {"skill_id": "skill_a", "result": True}))
+
+        topics = [m.msg_type for m in captured]
+        self.assertIn("mycroft.skill.handler.complete", topics)
+        complete = next(m for m in captured
+                        if m.msg_type == "mycroft.skill.handler.complete")
+        self.assertEqual(complete.context.get("skill_id"), "skill_a")
+
+    def test_response_from_other_skill_does_not_complete(self):
+        """A converse.response from a different skill must not resolve the
+        lifecycle for the targeted skill."""
+        svc, captured = self._service_with_capture()
+        msg = Message("converse:skill", {"skill_id": "skill_a",
+                                         "utterances": ["hello"]})
+        svc.handle_converse(msg)
+        captured.clear()
+
+        svc.bus.emit(Message("skill.converse.response",
+                             {"skill_id": "other_skill", "result": True}))
+        topics = [m.msg_type for m in captured]
+        self.assertNotIn("mycroft.skill.handler.complete", topics)
+
+    def test_exactly_one_terminal_on_repeated_response(self):
+        """Only the first converse.response resolves the lifecycle; a duplicate
+        does not emit a second terminal."""
+        svc, captured = self._service_with_capture()
+        msg = Message("converse:skill", {"skill_id": "skill_a",
+                                         "utterances": ["hello"]})
+        svc.handle_converse(msg)
+        captured.clear()
+
+        svc.bus.emit(Message("skill.converse.response",
+                             {"skill_id": "skill_a", "result": True}))
+        svc.bus.emit(Message("skill.converse.response",
+                             {"skill_id": "skill_a", "result": True}))
+        completes = [m for m in captured
+                     if m.msg_type == "mycroft.skill.handler.complete"]
+        self.assertEqual(len(completes), 1)
+
+    def test_timeout_emits_handler_error(self):
+        """When no converse.response arrives, the lifecycle errors out (a
+        mycroft.skill.handler.error terminal), patched to a tiny timeout."""
+        svc, captured = self._service_with_capture()
+        msg = Message("converse:skill", {"skill_id": "skill_a",
+                                         "utterances": ["hello"]})
+        with patch("ovos_core.intent_services.converse_service.CONVERSE_HANDLER_TIMEOUT", 0.05):
+            svc.handle_converse(msg)
+            time.sleep(0.2)
+        topics = [m.msg_type for m in captured]
+        self.assertIn("mycroft.skill.handler.error", topics)
+        err = next(m for m in captured
+                   if m.msg_type == "mycroft.skill.handler.error")
+        self.assertEqual(err.context.get("skill_id"), "skill_a")
+        self.assertIn("exception", err.data)
+
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/test/unittests/test_dispatcher.py b/test/unittests/test_dispatcher.py
new file mode 100644
index 00000000000..820222d04c5
--- /dev/null
+++ b/test/unittests/test_dispatcher.py
@@ -0,0 +1,300 @@
+# Copyright 2024 OpenVoiceOS
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""OVOS-PIPELINE-1 §7 / §8 — orchestrator-owned handler-lifecycle trio.
+
+Validates that the orchestrator's ``IntentDispatcher`` drives the §6.1 matched
+path:
+
+- ``ovos.intent.handler.start`` (§8.1) before the dispatch Message goes out;
+- exactly one terminal — ``complete`` on the framework done-signal, ``error`` on
+  the framework error signal or on the §8.3 timeout;
+- the ``exception`` field is populated on the error path (§8.2);
+- ``context`` (incl. ``session``) preserved unchanged via ``forward``;
+- the §8.3 timeout terminal (error) releases the waiting orchestrator;
+- reserved-name dispatches (§7.0/§7.3) get the trio identically.
+
+The dispatcher does NOT emit the §9.5 ``ovos.utterance.handled`` end-marker — it
+only sets each in-flight entry's ``done`` event on its §8 terminal. The orchestrator
+(``IntentService``) blocks on that and emits the single end-marker itself, uniformly
+with the no-match and cancel paths (see ``TestDispatchFromMatch``).
+"""
+# ruff: noqa: RUF023
+import time
+import unittest
+from collections import defaultdict
+from unittest.mock import MagicMock
+
+from ovos_bus_client.message import Message
+from ovos_bus_client.session import Session
+from ovos_plugin_manager.templates.pipeline import IntentHandlerMatch
+from ovos_spec_tools import SpecMessage
+from ovos_utils.fakebus import FakeBus
+
+from ovos_core.intent_services.service import IntentService
+from ovos_core.intent_services.dispatcher import IntentDispatcher
+
+START = SpecMessage.INTENT_HANDLER_START.value
+COMPLETE = SpecMessage.INTENT_HANDLER_COMPLETE.value
+ERROR = SpecMessage.INTENT_HANDLER_ERROR.value
+HANDLED = SpecMessage.UTTERANCE_HANDLED.value
+# the framework done-signal the orchestrator observes (legacy namespace)
+SKILL_COMPLETE = "mycroft.skill.handler.complete"
+SKILL_ERROR = "mycroft.skill.handler.error"
+
+
+def _skill_complete(dispatch_msg):
+    """The framework's normal-completion signal (forwarded from the dispatch)."""
+    return dispatch_msg.forward(SKILL_COMPLETE, {"name": "handler"})
+
+
+class _Recorder:
+    """Capture the orchestrator-emitted topics (+ dispatch) in bus order.
+
+    Subscribes to the ``"message"`` aggregate (as the real bus / ovoscope harness
+    do) rather than to specific topics: the FakeBus namespace bridge mirrors a
+    counterpart onto specific-topic subscribers but NOT onto the ``"message"``
+    aggregate, so a single emission is recorded once — matching what a
+    spec-namespace consumer observing the wire actually sees."""
+
+    _TRACKED = (START, COMPLETE, ERROR, HANDLED)
+
+    def __init__(self, bus, dispatch_topic=None):
+        self.msgs = []
+        self._tracked = set(self._TRACKED)
+        if dispatch_topic:
+            self._tracked.add(dispatch_topic)
+        bus.on("message", self._on_message)
+
+    def _on_message(self, serialized):
+        msg = Message.deserialize(serialized)
+        if msg.msg_type in self._tracked:
+            self.msgs.append((msg.msg_type, msg))
+
+    def topics(self):
+        return [t for t, _ in self.msgs]
+
+    def by_topic(self, topic):
+        return [m for t, m in self.msgs if t == topic]
+
+
+def _dispatch_msg(skill_id="test.skill", intent_name="do", session_id="s1"):
+    sess = Session(session_id)
+    return Message(f"{skill_id}:{intent_name}",
+                   {"utterance": "hello", "lang": "en-US"},
+                   {"skill_id": skill_id, "session": sess.serialize(),
+                    "source": "B", "destination": "A"})
+
+
+class TestIntentDispatcher(unittest.TestCase):
+
+    def setUp(self):
+        self.bus = FakeBus()
+        self.rec = _Recorder(self.bus, dispatch_topic="test.skill:do")
+        self.disp = IntentDispatcher(self.bus, timeout=0)  # timer off by default
+
+    def tearDown(self):
+        self.disp.shutdown()
+
+    def test_start_before_dispatch(self):
+        self.disp.dispatch(_dispatch_msg(), "test.skill", "do")
+        # §8.1 start, then the §7 dispatch — in that order
+        self.assertEqual(self.rec.topics()[:2], [START, "test.skill:do"])
+
+    def test_start_payload(self):
+        self.disp.dispatch(_dispatch_msg(), "test.skill", "do")
+        self.assertEqual(self.rec.by_topic(START)[0].data,
+                         {"skill_id": "test.skill", "intent_name": "do"})
+
+    def test_intent_name_defaults_from_topic(self):
+        self.disp.dispatch(_dispatch_msg())
+        self.assertEqual(self.rec.by_topic(START)[0].data,
+                         {"skill_id": "test.skill", "intent_name": "do"})
+
+    def test_reserved_name_dispatch_gets_trio(self):
+        # §7.0/§7.3 polymorphism: a reserved-name dispatch (e.g. <skill>:stop) is
+        # a dispatch like any other -> it gets the trio, no special-casing.
+        rec = _Recorder(self.bus, dispatch_topic="stop.openvoiceos:stop")
+        msg = _dispatch_msg(skill_id="stop.openvoiceos", intent_name="stop")
+        self.disp.dispatch(msg, "stop.openvoiceos", "stop")
+        self.assertEqual(rec.topics()[:2], [START, "stop.openvoiceos:stop"])
+        self.bus.emit(msg.forward(SKILL_COMPLETE, {"name": "h"}))
+        self.assertEqual(len(rec.by_topic(COMPLETE)), 1)
+
+    def test_complete_on_done_signal(self):
+        msg = _dispatch_msg()
+        self.disp.dispatch(msg, "test.skill", "do")
+        self.bus.emit(_skill_complete(msg))
+        comps = self.rec.by_topic(COMPLETE)
+        self.assertEqual(len(comps), 1)
+        self.assertEqual(comps[0].data,
+                         {"skill_id": "test.skill", "intent_name": "do"})
+        self.assertEqual(self.rec.by_topic(ERROR), [])
+        # the dispatcher does NOT emit ovos.utterance.handled -- the §9.5 end-marker
+        # is the orchestrator's (emitted in reaction to this terminal).
+        self.assertEqual(self.rec.by_topic(HANDLED), [])
+
+    def test_exactly_one_terminal_on_repeated_done_signal(self):
+        msg = _dispatch_msg()
+        self.disp.dispatch(msg, "test.skill", "do")
+        self.bus.emit(_skill_complete(msg))
+        self.bus.emit(_skill_complete(msg))  # duplicate / nested signal
+        self.assertEqual(len(self.rec.by_topic(COMPLETE)), 1)  # exactly one terminal
+        self.assertEqual(self.rec.by_topic(HANDLED), [])  # dispatcher emits no end-marker
+
+    def test_no_echo_loop_from_bridged_spec_complete(self):
+        # if the bus bridges the orchestrator's spec complete back to the legacy
+        # done-signal, the resolved-guard must keep the terminal count at one.
+        msg = _dispatch_msg()
+        self.disp.dispatch(msg, "test.skill", "do")
+        self.bus.emit(_skill_complete(msg))
+        # simulate the bridged echo arriving as another legacy done-signal
+        self.disp._on_skill_complete(_skill_complete(msg))
+        self.assertEqual(len(self.rec.by_topic(COMPLETE)), 1)
+
+    def test_error_on_done_signal_with_exception(self):
+        msg = _dispatch_msg()
+        self.disp.dispatch(msg, "test.skill", "do")
+        self.bus.emit(msg.forward(SKILL_ERROR, {"exception": "RuntimeError: boom"}))
+        errs = self.rec.by_topic(ERROR)
+        self.assertEqual(len(errs), 1)
+        self.assertEqual(errs[0].data["skill_id"], "test.skill")
+        self.assertEqual(errs[0].data["intent_name"], "do")
+        self.assertEqual(errs[0].data["exception"], "RuntimeError: boom")
+        self.assertEqual(self.rec.by_topic(COMPLETE), [])
+
+    def test_trio_terminal_ordering(self):
+        msg = _dispatch_msg()
+        self.disp.dispatch(msg, "test.skill", "do")
+        self.bus.emit(_skill_complete(msg))
+        trio = [t for t in self.rec.topics() if t in (START, COMPLETE, ERROR)]
+        self.assertEqual(trio, [START, COMPLETE])
+
+    def test_context_session_preserved(self):
+        msg = _dispatch_msg(session_id="abc123")
+        self.disp.dispatch(msg, "test.skill", "do")
+        self.bus.emit(_skill_complete(msg))
+        for topic in (START, COMPLETE):
+            m = self.rec.by_topic(topic)[0]
+            self.assertEqual(m.context["session"]["session_id"], "abc123")
+            self.assertEqual(m.context.get("skill_id"), "test.skill")
+
+    def test_nested_lifecycles_lifo(self):
+        msg_outer = _dispatch_msg(intent_name="outer")
+        msg_inner = _dispatch_msg(intent_name="inner")
+        self.disp.dispatch(msg_outer, "test.skill", "outer")
+        self.disp.dispatch(msg_inner, "test.skill", "inner")
+        self.bus.emit(_skill_complete(msg_inner))  # inner completes first
+        self.bus.emit(_skill_complete(msg_outer))  # outer second
+        comps = [m.data["intent_name"] for m in self.rec.by_topic(COMPLETE)]
+        self.assertEqual(comps, ["inner", "outer"])
+
+    def test_timeout_emits_error(self):
+        disp = IntentDispatcher(self.bus, timeout=0.2)
+        try:
+            disp.dispatch(_dispatch_msg(), "test.skill", "do")
+            # deterministic: poll for the §8.3 terminal rather than a fixed sleep
+            deadline = time.time() + 5
+            while not self.rec.by_topic(ERROR) and time.time() < deadline:
+                time.sleep(0.02)
+            errs = self.rec.by_topic(ERROR)
+            self.assertEqual(len(errs), 1)
+            self.assertIn("timed out", errs[0].data["exception"])
+            # the dispatcher itself emits no §9.5 ovos.utterance.handled end-marker
+            self.assertEqual(self.rec.by_topic(HANDLED), [])
+        finally:
+            disp.shutdown()
+
+    def test_timeout_does_not_double_fire_if_skill_reports(self):
+        disp = IntentDispatcher(self.bus, timeout=0.3)
+        try:
+            msg = _dispatch_msg()
+            disp.dispatch(msg, "test.skill", "do")
+            self.bus.emit(_skill_complete(msg))  # reports before timeout
+            time.sleep(0.5)
+            self.assertEqual(len(self.rec.by_topic(COMPLETE)), 1)
+            self.assertEqual(self.rec.by_topic(ERROR), [])
+        finally:
+            disp.shutdown()
+
+
+class TestDispatchFromMatch(unittest.TestCase):
+    """The dispatch + trio must fire from the orchestrator's match path."""
+
+    def _make_service(self):
+        bus = FakeBus()
+        svc = IntentService.__new__(IntentService)
+        svc.bus = bus
+        svc.config = {}
+        svc.pipeline_plugins = {}
+        svc._deactivations = defaultdict(list)
+        ut = MagicMock(); ut.transform.side_effect = lambda u, c: (u, c)
+        svc.utterance_plugins = ut
+        mt = MagicMock(); mt.transform.side_effect = lambda c: c
+        svc.metadata_plugins = mt
+        it = MagicMock(); it.transform.side_effect = lambda i: i
+        svc.intent_plugins = it
+        svc.status = MagicMock()
+        # mirror IntentService.__init__: the dispatcher notifies the orchestrator on
+        # each §8 terminal, which emits the §9.5 end-marker
+        svc.intent_dispatcher = IntentDispatcher(
+            bus, timeout=0, on_terminal=svc._emit_utterance_handled)
+        return svc, bus
+
+    @staticmethod
+    def _report_complete(bus):
+        """Make the dispatched handler report its framework done-signal so the
+        dispatcher emits its §8 terminal (which drives the orchestrator's §9.5
+        end-marker). FakeBus is in-thread, so this all resolves synchronously."""
+        bus.on("test.skill:do",
+               lambda m: bus.emit(m.forward(SKILL_COMPLETE, {"name": "h"})))
+
+    def test_start_before_dispatch(self):
+        svc, bus = self._make_service()
+        order = []
+        bus.on(START, lambda m: order.append("start"))
+        bus.on("test.skill:do", lambda m: order.append("dispatch"))
+        self._report_complete(bus)
+
+        match = IntentHandlerMatch(match_type="test.skill:do",
+                                   match_data={}, skill_id="test.skill",
+                                   utterance="hello")
+        msg = Message(SpecMessage.UTTERANCE,
+                      {"utterances": ["hello"]},
+                      {"session": Session("s1").serialize()})
+        svc._dispatch_match(match, msg, "en-US", pipeline_id="p1")
+        self.assertEqual(order[:2], ["start", "dispatch"])
+        svc.intent_dispatcher.shutdown()
+
+    def test_orchestrator_emits_handled_on_terminal(self):
+        # §9.5: the orchestrator (not the dispatcher) owns ovos.utterance.handled;
+        # it reacts to the §8 handler-complete terminal and emits exactly one marker.
+        svc, bus = self._make_service()
+        handled = []
+        bus.on(HANDLED, lambda m: handled.append(m))
+        self._report_complete(bus)
+
+        match = IntentHandlerMatch(match_type="test.skill:do",
+                                   match_data={}, skill_id="test.skill",
+                                   utterance="hello")
+        msg = Message(SpecMessage.UTTERANCE,
+                      {"utterances": ["hello"]},
+                      {"session": Session("s1").serialize()})
+        svc._dispatch_match(match, msg, "en-US", pipeline_id="p1")
+        self.assertEqual(len(handled), 1)
+        self.assertEqual(handled[0].data, {})
+        svc.intent_dispatcher.shutdown()
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/test/unittests/test_fallback_service.py b/test/unittests/test_fallback_service.py
index 45331e8ed8c..4b56ecd7c58 100644
--- a/test/unittests/test_fallback_service.py
+++ b/test/unittests/test_fallback_service.py
@@ -34,6 +34,7 @@ def _make_service(config=None) -> FallbackService:
         svc.bus = bus
         svc.config = config or {}
         svc.registered_fallbacks = {}
+        svc._lifecycle_handlers = {}
         svc._fallback_response_event = threading.Event()
         svc.bus.on("ovos.skills.fallback.register", svc.handle_register_fallback)
         svc.bus.on("ovos.skills.fallback.deregister", svc.handle_deregister_fallback)
@@ -218,13 +219,18 @@ def run():
                     svc._collect_fallback_skills(
                         Message("test"), fb_range=FallbackRange(5, 90)))
 
-        t = threading.Thread(target=run)
-        t.start()
-        time.sleep(0.05)
-        if ack_handler:
-            ack_handler(Message("ovos.skills.fallback.pong",
-                                {"skill_id": "skill_a", "can_handle": True}))
-        t.join(timeout=1)
+        t = None
+        try:
+            t = threading.Thread(target=run)
+            t.start()
+            time.sleep(0.05)
+            if ack_handler:
+                ack_handler(Message("ovos.skills.fallback.pong",
+                                    {"skill_id": "skill_a", "can_handle": True}))
+        finally:
+            if t is not None:
+                t.join(timeout=1)
+            svc.shutdown()
 
         self.assertIn("skill_a", result_holder[0])
 
@@ -254,13 +260,18 @@ def run():
                     svc._collect_fallback_skills(
                         Message("test"), fb_range=FallbackRange(5, 90)))
 
-        t = threading.Thread(target=run)
-        t.start()
-        time.sleep(0.05)
-        if ack_handler:
-            ack_handler(Message("ovos.skills.fallback.pong",
-                                {"skill_id": "skill_a", "can_handle": False}))
-        t.join(timeout=1)
+        t = None
+        try:
+            t = threading.Thread(target=run)
+            t.start()
+            time.sleep(0.05)
+            if ack_handler:
+                ack_handler(Message("ovos.skills.fallback.pong",
+                                    {"skill_id": "skill_a", "can_handle": False}))
+        finally:
+            if t is not None:
+                t.join(timeout=1)
+            svc.shutdown()
 
         self.assertEqual(result_holder[0], [])
 
@@ -423,5 +434,94 @@ def test_shutdown_removes_listeners(self):
         self.assertIn("ovos.skills.fallback.deregister", removed)
 
 
+class TestFallbackHandlerLifecycle(unittest.TestCase):
+    """A registered fallback skill's own lifecycle markers are translated into
+    the framework done-signal so an orchestrator (OVOS-PIPELINE-1 §8) can
+    resolve a reserved ``fallback`` dispatch instead of hitting its timeout."""
+
+    def _service_with_capture(self):
+        svc = _make_service()
+        captured = []
+        # FakeBus emits the "message" catch-all as a serialized string; parse it
+        # back into a Message so assertions can read msg_type/context/data.
+        svc.bus.on("message", lambda s: captured.append(Message.deserialize(s)))
+        return svc, captured
+
+    def test_register_wires_lifecycle_listeners(self):
+        """Registering a fallback skill installs its .start/.response bridge."""
+        svc, _ = self._service_with_capture()
+        svc.handle_register_fallback(
+            Message("ovos.skills.fallback.register",
+                    {"skill_id": "skill_a", "priority": 50}))
+        self.assertIn("skill_a", svc._lifecycle_handlers)
+
+    def test_skill_start_emits_handler_start(self):
+        """The skill's fallback .start is re-emitted as handler.start with the
+        skill_id stamped in context."""
+        svc, captured = self._service_with_capture()
+        svc.handle_register_fallback(
+            Message("ovos.skills.fallback.register", {"skill_id": "skill_a"}))
+        captured.clear()
+
+        svc.bus.emit(Message("ovos.skills.fallback.skill_a.start"))
+        starts = [m for m in captured
+                  if m.msg_type == "mycroft.skill.handler.start"]
+        self.assertEqual(len(starts), 1)
+        self.assertEqual(starts[0].context.get("skill_id"), "skill_a")
+
+    def test_skill_response_emits_handler_complete(self):
+        """The skill's fallback .response is re-emitted as handler.complete,
+        regardless of the result bool."""
+        svc, captured = self._service_with_capture()
+        svc.handle_register_fallback(
+            Message("ovos.skills.fallback.register", {"skill_id": "skill_a"}))
+        captured.clear()
+
+        svc.bus.emit(Message("ovos.skills.fallback.skill_a.response",
+                             {"result": False}))
+        completes = [m for m in captured
+                     if m.msg_type == "mycroft.skill.handler.complete"]
+        self.assertEqual(len(completes), 1)
+        self.assertEqual(completes[0].context.get("skill_id"), "skill_a")
+
+    def test_deregister_unwires_lifecycle(self):
+        """Deregistering removes the bridge; later markers emit nothing."""
+        svc, captured = self._service_with_capture()
+        svc.handle_register_fallback(
+            Message("ovos.skills.fallback.register", {"skill_id": "skill_a"}))
+        svc.handle_deregister_fallback(
+            Message("ovos.skills.fallback.deregister", {"skill_id": "skill_a"}))
+        self.assertNotIn("skill_a", svc._lifecycle_handlers)
+        captured.clear()
+
+        svc.bus.emit(Message("ovos.skills.fallback.skill_a.response",
+                             {"result": True}))
+        topics = [m.msg_type for m in captured]
+        self.assertNotIn("mycroft.skill.handler.complete", topics)
+
+    def test_lifecycle_only_for_targeted_skill(self):
+        """A response for skill_a must not be reported under skill_b's id."""
+        svc, captured = self._service_with_capture()
+        svc.handle_register_fallback(
+            Message("ovos.skills.fallback.register", {"skill_id": "skill_a"}))
+        svc.handle_register_fallback(
+            Message("ovos.skills.fallback.register", {"skill_id": "skill_b"}))
+        captured.clear()
+
+        svc.bus.emit(Message("ovos.skills.fallback.skill_a.response",
+                             {"result": True}))
+        completes = [m for m in captured
+                     if m.msg_type == "mycroft.skill.handler.complete"]
+        self.assertEqual(len(completes), 1)
+        self.assertEqual(completes[0].context.get("skill_id"), "skill_a")
+
+    def test_register_without_skill_id_skips_wiring(self):
+        """A register message lacking skill_id must not wire a None lifecycle."""
+        svc, _ = self._service_with_capture()
+        svc.handle_register_fallback(
+            Message("ovos.skills.fallback.register", {}))
+        self.assertNotIn(None, svc._lifecycle_handlers)
+
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/test/unittests/test_intent_service_extended.py b/test/unittests/test_intent_service_extended.py
index 4f424ad7d65..c7aba54c1d7 100644
--- a/test/unittests/test_intent_service_extended.py
+++ b/test/unittests/test_intent_service_extended.py
@@ -26,6 +26,7 @@
 from ovos_spec_tools import SpecMessage
 
 from ovos_core.intent_services.service import IntentService
+from ovos_core.intent_services.dispatcher import IntentDispatcher
 
 
 def _make_service(config=None) -> IntentService:
@@ -36,6 +37,8 @@ def _make_service(config=None) -> IntentService:
     svc.config = config or {}
     svc.pipeline_plugins = {}
     svc._deactivations = defaultdict(list)
+    # PIPELINE-1 §7/§8 dispatcher; timer disabled so unit tests stay deterministic
+    svc.intent_dispatcher = IntentDispatcher(bus, timeout=0)
 
     # Minimal stub objects for transformer services
     ut = MagicMock()
@@ -317,7 +320,7 @@ class TestSendCompleteIntentFailure(unittest.TestCase):
     """Tests for IntentService.send_complete_intent_failure."""
 
     def test_emits_three_messages(self):
-        """Three messages should be emitted: play_sound, complete_intent_failure, handled."""
+        """PIPELINE-1 §9.3/§9.5: play_sound, ovos.intent.unmatched, handled."""
         svc = _make_service()
         emitted = []
         svc.bus.emit = lambda m: emitted.append(m)
@@ -327,8 +330,9 @@ def test_emits_three_messages(self):
             svc.send_complete_intent_failure(msg)
         types = [m.msg_type for m in emitted]
         self.assertIn("mycroft.audio.play_sound", types)
-        self.assertIn("complete_intent_failure", types)
+        self.assertIn("ovos.intent.unmatched", types)
         self.assertIn("ovos.utterance.handled", types)
+        self.assertNotIn("complete_intent_failure", types)
 
     def test_error_sound_from_config_used(self):
         """The error sound path from config is used in the play_sound message."""
@@ -386,11 +390,11 @@ def test_deactivation_tracked_per_session(self):
 
 
 # ---------------------------------------------------------------------------
-# _emit_match_message
+# _dispatch_match
 # ---------------------------------------------------------------------------
 
 class TestEmitMatchMessage(unittest.TestCase):
-    """Tests for IntentService._emit_match_message."""
+    """Tests for IntentService._dispatch_match."""
 
     def test_reply_emitted_on_bus(self):
         """A reply message is emitted on the bus for a valid match."""
@@ -404,7 +408,7 @@ def test_reply_emitted_on_bus(self):
                       context={"session": sess.serialize()})
         with patch("ovos_core.intent_services.service.SessionManager.get",
                    return_value=sess):
-            svc._emit_match_message(match, msg, "en-US")
+            svc._dispatch_match(match, msg, "en-US")
         types = [m.msg_type for m in emitted]
         self.assertIn("test:intent", types)
 
@@ -420,7 +424,7 @@ def test_skill_activated_when_not_deactivated(self):
                       context={"session": sess.serialize()})
         with patch("ovos_core.intent_services.service.SessionManager.get",
                    return_value=sess):
-            svc._emit_match_message(match, msg, "en-US")
+            svc._dispatch_match(match, msg, "en-US")
         types = [m.msg_type for m in emitted]
         self.assertTrue(any("activate" in t for t in types))
 
@@ -437,7 +441,7 @@ def test_skill_not_activated_when_deactivated(self):
                       context={"session": sess.serialize()})
         with patch("ovos_core.intent_services.service.SessionManager.get",
                    return_value=sess):
-            svc._emit_match_message(match, msg, "en-US")
+            svc._dispatch_match(match, msg, "en-US")
         types = [m.msg_type for m in emitted]
         self.assertFalse(any("activate" in t for t in types))
 
@@ -452,7 +456,7 @@ def test_intent_transformer_applied(self):
                       context={"session": sess.serialize()})
         with patch("ovos_core.intent_services.service.SessionManager.get",
                    return_value=sess):
-            svc._emit_match_message(match, msg, "en-US")
+            svc._dispatch_match(match, msg, "en-US")
         svc.intent_plugins.transform.assert_called_once()
 
 
diff --git a/test/unittests/test_stop_service.py b/test/unittests/test_stop_service.py
index 8a33b08b4dc..c10d06a73c9 100644
--- a/test/unittests/test_stop_service.py
+++ b/test/unittests/test_stop_service.py
@@ -28,14 +28,14 @@ def _make_service() -> StopService:
     bus = FakeBus()
     bus.connected_event = Event()
     bus.connected_event.set()
-    with patch("ovos_core.intent_services.stop_service.OVOSAbstractApplication.__init__",
-               lambda self, *a, **kw: None), \
-         patch("ovos_core.intent_services.stop_service.ConfidenceMatcherPipeline.__init__",
+    with patch("ovos_core.intent_services.stop_service.ConfidenceMatcherPipeline.__init__",
                lambda self, *a, **kw: None):
         svc = StopService.__new__(StopService)
         svc.bus = bus
         svc.config = {}
-        svc.skill_id = "stop.openvoiceos"
+        # vocabulary matching is delegated to ovos-spec-tools LocaleResources;
+        # tests patch svc._locale.voc_match / voc_list.
+        svc._locale = MagicMock()
     return svc
 
 
@@ -327,13 +327,13 @@ def setUp(self):
 
     def test_no_vocab_returns_none(self):
         """If voc_list is empty for the language, match_high returns None."""
-        with patch.object(self.svc, "voc_match", return_value=False):
+        with patch.object(self.svc._locale, "voc_match", return_value=False):
             result = self.svc.match_high(["stop"], "en-US", Message("test"))
         self.assertIsNone(result)
 
     def test_exact_stop_with_no_active_skills_is_global_stop(self):
         """'stop' with no active skills → global stop."""
-        with patch.object(self.svc, "voc_match",
+        with patch.object(self.svc._locale, "voc_match",
                           side_effect=lambda utt, voc, lang, exact: voc == "stop"), \
              patch.object(StopService, "get_active_skills", return_value=[]), \
              patch("ovos_core.intent_services.stop_service.SessionManager.get",
@@ -345,7 +345,7 @@ def test_exact_stop_with_no_active_skills_is_global_stop(self):
 
     def test_exact_stop_with_active_skills_pings_skills(self):
         """'stop' with active skills → skill stop ping."""
-        with patch.object(self.svc, "voc_match",
+        with patch.object(self.svc._locale, "voc_match",
                           side_effect=lambda utt, voc, lang, exact: voc == "stop"), \
              patch.object(StopService, "get_active_skills", return_value=["skill_a"]), \
              patch.object(self.svc, "_collect_stop_skills", return_value=["skill_a"]), \
@@ -363,7 +363,7 @@ def test_global_stop_voc_triggers_global_stop(self):
         def voc_match_side_effect(utt, voc, lang, exact):
             return voc == "global_stop"
 
-        with patch.object(self.svc, "voc_match", side_effect=voc_match_side_effect), \
+        with patch.object(self.svc._locale, "voc_match", side_effect=voc_match_side_effect), \
              patch.object(StopService, "get_active_skills", return_value=["skill_a"]), \
              patch("ovos_core.intent_services.stop_service.SessionManager.get",
                    return_value=Session("s")):
@@ -380,14 +380,14 @@ def setUp(self):
 
     def test_no_voc_list_returns_none(self):
         """If voc_list returns empty, match_low returns None."""
-        with patch.object(self.svc, "voc_list", return_value=[]):
+        with patch.object(self.svc._locale, "voc_list", return_value=[]):
             result = self.svc.match_low(["stop please"], "en-US", Message("test"))
         self.assertIsNone(result)
 
     def test_low_confidence_below_threshold_returns_none(self):
         """Fuzzy score below min_conf should return None."""
         self.svc.config = {"min_conf": 0.9}
-        with patch.object(self.svc, "voc_list", return_value=["stop"]), \
+        with patch.object(self.svc._locale, "voc_list", return_value=["stop"]), \
              patch("ovos_core.intent_services.stop_service.match_one",
                    return_value=("stop", 0.3)), \
              patch.object(StopService, "get_active_skills", return_value=[]), \
@@ -399,7 +399,7 @@ def test_low_confidence_below_threshold_returns_none(self):
     def test_active_skills_boost_confidence(self):
         """Active skills add 0.1 to the confidence score."""
         self.svc.config = {"min_conf": 0.5}
-        with patch.object(self.svc, "voc_list", return_value=["stop"]), \
+        with patch.object(self.svc._locale, "voc_list", return_value=["stop"]), \
              patch("ovos_core.intent_services.stop_service.match_one",
                    return_value=("stop", 0.45)), \
              patch.object(StopService, "get_active_skills", return_value=["skill_a"]), \
@@ -416,7 +416,7 @@ def test_above_threshold_with_stoppable_skill(self):
         """A confident match with a stoppable skill → skill stop."""
         self.svc.config = {"min_conf": 0.5}
         self.svc.bus.once = MagicMock()
-        with patch.object(self.svc, "voc_list", return_value=["stop"]), \
+        with patch.object(self.svc._locale, "voc_list", return_value=["stop"]), \
              patch("ovos_core.intent_services.stop_service.match_one",
                    return_value=("stop", 0.8)), \
              patch.object(StopService, "get_active_skills", return_value=["skill_a"]), \
@@ -481,13 +481,13 @@ def setUp(self):
         self.svc = _make_service()
 
     def test_no_stop_voc_and_no_global_stop_returns_none(self):
-        with patch.object(self.svc, "voc_match", return_value=False), \
+        with patch.object(self.svc._locale, "voc_match", return_value=False), \
              patch.object(StopService, "get_active_skills", return_value=[]):
             result = self.svc.match_medium(["hello"], "en-US", Message("test"))
         self.assertIsNone(result)
 
     def test_stop_voc_match_delegates_to_match_low(self):
-        with patch.object(self.svc, "voc_match", return_value=True), \
+        with patch.object(self.svc._locale, "voc_match", return_value=True), \
              patch.object(self.svc, "match_low", return_value="LOW_RESULT") as mock_low:
             result = self.svc.match_medium(["stop"], "en-US", Message("test"))
         self.assertEqual(result, "LOW_RESULT")
@@ -497,7 +497,7 @@ def test_global_stop_voc_delegates_to_match_low(self):
         def voc_match_side_effect(utt, voc, lang, exact):
             return voc == "global_stop"
 
-        with patch.object(self.svc, "voc_match", side_effect=voc_match_side_effect), \
+        with patch.object(self.svc._locale, "voc_match", side_effect=voc_match_side_effect), \
              patch.object(StopService, "get_active_skills", return_value=[]), \
              patch.object(self.svc, "match_low", return_value="LOW_RESULT") as mock_low:
             result = self.svc.match_medium(["stop everything"], "en-US", Message("test"))
@@ -528,8 +528,9 @@ def test_handle_global_stop_emits_mycroft_stop(self):
         msg = Message("stop:global", {})
         svc.handle_global_stop(msg)
         types = [m.msg_type for m in emitted]
+        self.assertIn("mycroft.skill.handler.start", types)
         self.assertIn("mycroft.stop", types)
-        self.assertIn("ovos.utterance.handled", types)
+        self.assertIn("mycroft.skill.handler.complete", types)
 
     def test_handle_skill_stop_forwards_to_skill(self):
         svc = _make_service()
@@ -537,8 +538,10 @@ def test_handle_skill_stop_forwards_to_skill(self):
         svc.bus.emit = lambda m: emitted.append(m)
         msg = Message("stop:skill", {"skill_id": "my_skill"})
         svc.handle_skill_stop(msg)
-        self.assertEqual(len(emitted), 1)
-        self.assertEqual(emitted[0].msg_type, "my_skill.stop")
+        types = [m.msg_type for m in emitted]
+        self.assertIn("mycroft.skill.handler.start", types)
+        self.assertIn("my_skill.stop", types)
+        self.assertIn("mycroft.skill.handler.complete", types)
 
 
 class TestShutdown(unittest.TestCase):