diff --git a/src/gui/ctrl/nexus.hpp b/src/gui/ctrl/nexus.hpp
index b99d604ec..3f0c7b08e 100644
--- a/src/gui/ctrl/nexus.hpp
+++ b/src/gui/ctrl/nexus.hpp
@@ -103,8 +103,12 @@ namespace ctrl{
       /** add a new down-link connection to the routing table
        * @param identity the [endpoint-ID](\ref BusTerm::endpointID_) used
        *         to address the new element to be connected to the bus.
+       * @param newNode to add the address (!) into the routing table
        * @return backlink for the new Tangible's BusTerm to
        *         attach itself to the Nexus.
+       * @note at call time, the second param, the newNode will typically
+       *         be just a Tangible (and not a subclass yet),
+       *         since this function is invoked from ctor.
        */
       virtual BusTerm&
       routeAdd (ID identity, Tangible& newNode)  override
diff --git a/src/lib/test/event-log.hpp b/src/lib/test/event-log.hpp
index 9eb22c2c4..4f822399c 100644
--- a/src/lib/test/event-log.hpp
+++ b/src/lib/test/event-log.hpp
@@ -193,6 +193,7 @@ namespace test{
                              or entry.getType() == "destroy"
                              or entry.getType() == "logJoin"
                              )
+                         and !isnil(entry.scope())
                          and contains (*entry.scope(), match);
                     };
         }
@@ -210,6 +211,7 @@ namespace test{
                              or entry.getType() == classifier
                              or (entry.hasAttribute("ID") and contains (entry.get("ID"), classifier))
                              )
+                         and !isnil(entry.scope())
                          and contains (*entry.scope(), match);
                     };
         }
@@ -682,9 +684,9 @@ namespace test{
       EventLog&
       event (string text)
         {
-          log({"type=event", text});
-          return *this;
-        }
+          log ("event", ArgSeq{}, ArgSeq{text});  // we use this ctor variant to ensure
+          return *this;                          //  that text is not misinterpreted as attribute,
+        }                                       //   which might happen when text contains a '='
       
       /** log some event, with additional ID or classifier
        * @param classifier info to be saved into the `ID` attribute
@@ -693,7 +695,7 @@ namespace test{
       EventLog&
       event (string classifier, string text)
         {
-          log({"type=event", "ID="+classifier, text});
+          log ("event", ArgSeq{"ID="+classifier}, ArgSeq{text});
           return *this;
         }
       
diff --git a/tests/gui/bus-term-test.cpp b/tests/gui/bus-term-test.cpp
index e27ae5b56..b6b3e0235 100644
--- a/tests/gui/bus-term-test.cpp
+++ b/tests/gui/bus-term-test.cpp
@@ -36,6 +36,7 @@
 //#include <map>
 
 using lib::idi::EntryID;
+using lib::idi::BareEntryID;
 using gui::test::MockElm;
 using lib::diff::GenNode;
 //using boost::lexical_cast;
@@ -111,14 +112,14 @@ namespace test {
       attachNewBusTerm ()
         {
           // our dummy will be linked with this identity
-          EntryID<MockElm> elmID{"zeitgeist"};
+          BareEntryID elmID = EntryID<MockElm>{"zeitgeist"};
           
           // Access the log on the Test-Nexus hub
           EventLog nexusLog = gui::test::Nexus::startNewLog();
           CHECK (nexusLog.ensureNot("zeitgeist"));
           
           MockElm mock(elmID);
-          CHECK (nexusLog.verifyCall("routeAdd").on("TestNexus").arg(elmID,"MockElm")
+          CHECK (nexusLog.verifyCall("routeAdd").on("TestNexus").arg(elmID,"Tangible")       // Note: invoked from ctor, so it is just a tangible at the moment
                          .beforeEvent("TestNexus", "added route to bID-zeitgeist"));
           
           EventLog elmLog = mock.getLog();
@@ -135,7 +136,7 @@ namespace test {
           // invoke action on element to cause upstream message (with a "state mark")
           mock.slotCollapse();
           CHECK (elmLog.verifyEvent("collapsed"));
-          CHECK (nexusLog.verifyCall("note").on("TestNexus").arg("zeitgeist", "collapse"));
+          CHECK (nexusLog.verifyCall("note").on("TestNexus").arg(elmID, "collapse"));
           
           // send a state mark down to the mock element
           gui::test::Nexus::testUI().mark (elmID, GenNode("Flash", 23));
@@ -159,7 +160,7 @@ namespace test {
           
           
           cout << "____Probe-Log_________________\n"
-               << util::join(mock.getLog(), "\n")
+               << util::join(elmLog, "\n")
                << "\n───╼━━━━━━━━━╾────────────────"<<endl;
           
           cout << "____Nexus-Log_________________\n"
diff --git a/tests/gui/test/test-nexus.cpp b/tests/gui/test/test-nexus.cpp
index 9c8f01700..fa08231e5 100644
--- a/tests/gui/test/test-nexus.cpp
+++ b/tests/gui/test/test-nexus.cpp
@@ -55,8 +55,12 @@ using std::cerr;
 using std::endl;
 using std::string;
 
-using lib::test::EventLog;
+using lib::Variant;
+using lib::diff::Rec;
 using lib::diff::GenNode;
+using lib::diff::DataValues;
+using lib::idi::instanceTypeID;
+using lib::test::EventLog;
 using gui::ctrl::BusTerm;
 using util::_Fmt;
 //using util::contains;
@@ -67,10 +71,6 @@ namespace test{
   
   namespace { // internal details
     
-    using lib::Variant;
-    using lib::diff::Rec;
-    using lib::diff::DataValues;
-    
     using BusHub = gui::ctrl::Nexus;
     
     
@@ -123,12 +123,19 @@ namespace test{
       {
         EventLog log_{this};
         
+        using CommandHandler = test::Nexus::CommandHandler;
+        using StateMarkHandler = test::Nexus::StateMarkHandler;
+        
+        CommandHandler commandHandler_;
+        StateMarkHandler stateMarkHandler_;
+        
+        
         
         virtual void
         act (GenNode const& command)
           {
             log_.call(this, "act", command);
-            BusHub::act (command);
+            commandHandler_(command);
             log_.event("TestNexus", _Fmt("%s command \"%s\"%s")
                                         % invocationStage(command)
                                         % command.idi.getSym()
@@ -139,7 +146,7 @@ namespace test{
         note (ID subject, GenNode const& mark)  override
           {
             log_.call(this, "note", subject, mark);
-            BusHub::note (subject, mark);
+            stateMarkHandler_(subject, mark);
             log_.event("TestNexus", _Fmt("processed note from %s |%s") % subject % mark);
           }
         
@@ -151,19 +158,14 @@ namespace test{
             log_.event("TestNexus", _Fmt("delivered mark to %s |%s") % subject % mark);
           }
         
-        virtual operator string()  const
-          {
-            return getID().getSym()+"."+lib::idi::instanceTypeID(this);
-          }
-        
         virtual BusTerm&
         routeAdd (ID identity, Tangible& newNode)  override
           {
-            log_.call(this, "routeAdd", identity, newNode);
+            log_.call(this, "routeAdd", identity, instanceTypeID(&newNode));
             BusHub::routeAdd (identity, newNode);
             log_.event("TestNexus", _Fmt("added route to %s |%s| table-size=%2d")
                                         % identity
-                                        % lib::idi::instanceTypeID(&newNode)
+                                        % instanceTypeID(&newNode)
                                         % BusHub::size());
             return *this;
           }
@@ -176,11 +178,19 @@ namespace test{
             log_.event("TestNexus", _Fmt("removed route to %s | table-size=%2d") % node % BusHub::size());
           }
         
+        virtual operator string()  const
+          {
+            return getID().getSym()+"."+instanceTypeID(this);
+          }
+        
         
       public:
         TestNexus()
           : BusHub(*this, lib::idi::EntryID<TestNexus>("mock-UI"))
-          { }
+          {
+            installCommandHandler();
+            installStateMarkHandler();
+          }
         
         // standard copy operations
         
@@ -190,6 +200,33 @@ namespace test{
           {
             return log_;
           }
+        
+        void
+        installCommandHandler (CommandHandler newHandler =CommandHandler())
+          {
+            if (newHandler)
+              commandHandler_ = newHandler;
+            else
+              commandHandler_ =
+                [=](GenNode const& cmd)
+                  {
+                    log_.warn(_Fmt("NOT handling command-message %s in test-mode") % cmd);
+                  };
+          }
+        
+        void
+        installStateMarkHandler (StateMarkHandler newHandler =StateMarkHandler())
+          {
+            if (newHandler)
+              stateMarkHandler_ = newHandler;
+            else
+              stateMarkHandler_ =
+                [=](ID subject, GenNode const& mark)
+                  {
+                    log_.warn(_Fmt("NOT handling state-mark %s passed from %s in test-mode")
+                                                            % mark         % subject);
+                  };
+          }
       };
 
     /** singleton instance of the [TestNexus]
@@ -198,6 +235,7 @@ namespace test{
     
     
     
+    
     /**
      * @internal a defunct interface backbone.
      * All UI-Bus operations are implemented NOP, but warning on STDRR
@@ -244,11 +282,6 @@ namespace test{
             cerr << "mark message -> ZombieNexus" <<endl;
           }
         
-        virtual operator string()  const
-          {
-            return getID().getSym()+"."+lib::idi::instanceTypeID(this);
-          }
-        
         virtual BusTerm&
         routeAdd (ID identity, Tangible& newNode)  override
           {
@@ -266,6 +299,11 @@ namespace test{
             cerr << "disconnect("<<string(node)<<" -> ZombieNexus" <<endl;
           }
         
+        virtual operator string()  const
+          {
+            return getID().getSym()+"."+instanceTypeID(this);
+          }
+        
         
       public:
         /** fabricate a "dead terminal", marked as deceased, viciously connected to itself.
@@ -319,6 +357,42 @@ namespace test{
   }
   
   
+  /**
+   * install a closure (custom handler function)
+   * to deal with any command invocations encountered
+   * in the test-UI-Bus. In the real Lumiera-UI, the UI-Bus
+   * is wired with a [core service handler](\ref core-service.hpp),
+   * which processes command messages by actually triggering
+   * command invocation on the Session within Proc-Layer
+   * @note when called without arguments, a default handler
+   *       will be installed, which just logs and discards
+   *       any command invocation message.
+   * @warning when you install a closure from within unit test code,
+   *       be sure to re-install the default handler prior to leaving
+   *       the definition scope; since the "test nexus" is actually
+   *       implemented as singleton, an installed custom handler
+   *       will outlive the immediate usage scope, possibly
+   *       leading to segfault
+   */
+  void
+  Nexus::setCommandHandler (CommandHandler newHandler)
+  {
+    testNexus().installCommandHandler (newHandler);
+  }
+  
+  /**
+   * similar to the [custom command handler](::setCommandHandler)
+   * this hook allows to install a closure to intercept any
+   * "state mark" messages passed over the test-UI-Bus
+   */
+  void
+  Nexus::setStateMarkHandler(StateMarkHandler newHandler)
+  {
+    testNexus().installStateMarkHandler (newHandler);
+  }
+  
+  
+  
   
   /**
    * @return a defunct BusTerm with up-link to [ZombieNexus]
diff --git a/tests/gui/test/test-nexus.hpp b/tests/gui/test/test-nexus.hpp
index 84545becc..666530e66 100644
--- a/tests/gui/test/test-nexus.hpp
+++ b/tests/gui/test/test-nexus.hpp
@@ -47,9 +47,12 @@
 
 #include "lib/error.hpp"
 #include "gui/ctrl/bus-term.hpp"
+#include "gui/model/tangible.hpp"
 #include "lib/test/event-log.hpp"
+#include "lib/diff/gen-node.hpp"
 
 #include <boost/noncopyable.hpp>
+#include <functional>
 #include <string>
 
 
@@ -81,6 +84,15 @@ namespace test{
       
       static lib::test::EventLog const& getLog();
       static lib::test::EventLog const& startNewLog();
+      
+      
+      /* == allow to set custom handlers for commands and state changes == */
+      
+      using CommandHandler   = std::function<void(lib::diff::GenNode const&)>;
+      using StateMarkHandler = std::function<void(lib::idi::BareEntryID, lib::diff::GenNode const&)>;
+      
+      static void setCommandHandler (CommandHandler  =CommandHandler());
+      static void setStateMarkHandler (StateMarkHandler  =StateMarkHandler());
     };