Pydsr agents did not connect to G

  A clean pydsr agent joining a live fleet matched every DDS participant, received
  the full-graph answer and reported "Synchronized" — then stayed empty forever
  (get_nodes() -> []). Live deltas were equally dead.

  dsr_api.cpp marshals every remote apply — the initial import_full_graph and the
  node/edge/node-attr/edge-attr delta batches — with
  QMetaObject::invokeMethod(this, ..., Qt::QueuedConnection). A queued invoke only
  runs when the target object's thread spins a Qt event loop. The wrapper never
  created one, so the applies were posted and never executed. The DDS and CRDT
  layers were healthy the whole time; only the delivery hop was missing.

  pydsr now owns a GraphEventPump: a dedicated QThread running an event loop. The
  DSRGraph is both constructed and destroyed on it (BlockingQueuedConnection), so
  its Qt affinity is that thread for its whole lifetime and no posted event is
  ever delivered to a thread with no loop or one already gone. The holder becomes
  std::unique_ptr<DSRGraph, GraphOnPumpThreadDeleter> so teardown is routed there
  too, with the GIL released.

  A QThread only dispatches posted events if a QCoreApplication instance exists —
  without one invokeMethod silently no-ops. ensure_qapp() creates one lazily (at
  first DSRGraph construction, not module import) and only when none exists, so a
  PySide/PyQt host's own QApplication is reused instead of tripping Qt's
  "instance already exists" fatal.

  Signals were never affected: pydsr builds with SignalMode::Queue, whose
  QueuedSignalRunner dispatches on its own ThreadPool.

  Wrapper-only change; api/ is untouched, so C++ agent behaviour is unchanged.

  Verified against a live 4-agent fleet: plain script with no user-side Qt syncs
  0 -> 47 nodes; deltas alive (~35 node-attr signals/s); explicit del is clean;
  3x construct/destroy cycles clean; PySide6 coexistence reuses the host app.

  Known nit: the constructor blocks the pump's event loop while it waits for the
  full-graph answer, so the graph populates immediately after the ctor returns
  rather than during it.

Author: pbustos

gui/CMakeLists.txt

@@ -33,6 +33,7 @@ set(headers_to_moc
         include/dsr/gui/viewers/graph_viewer/graph_node_laser_widget.h
         include/dsr/gui/viewers/graph_viewer/graph_node_rgbd_widget.h
         include/dsr/gui/viewers/graph_viewer/graph_node_person_widget.h
+        include/dsr/gui/viewers/graph_viewer/graph_node_mind_widget.h
         include/dsr/gui/viewers/graph_viewer/graph_node_widget.h
         include/dsr/gui/viewers/tree_viewer/tree_viewer.h
         include/dsr/gui/viewers/_abstract_graphic_view.h
@@ -84,6 +85,21 @@ set_target_properties(dsr_gui
 
 target_compile_options(dsr_gui PUBLIC -O3 -g -fmax-errors=5 -std=c++20 -fno-char8_t )
 
+# Fast DDS Statistics consumer for the mind view (opt-in, dev/debug only). OFF by default so normal
+# and DEPLOYMENT builds contain ZERO statistics code. eProsima installs the statistics *type* headers
+# only as .idl, so enabling this also needs a Fast-DDS SOURCE tree to include the generated types from:
+#   cmake -B build -DRC_DDS_STATS=ON -DRC_DDS_STATS_SRC=/path/to/Fast-DDS/src/cpp
+# At runtime it is still inert unless the env var RC_DDS_STATS=1 is set (a second, no-rebuild gate).
+option(RC_DDS_STATS "Build the Fast DDS Statistics consumer into the mind view (dev only)" OFF)
+if(RC_DDS_STATS)
+  if(NOT RC_DDS_STATS_SRC OR NOT EXISTS "${RC_DDS_STATS_SRC}/statistics/types/typesPubSubTypes.hpp")
+    message(FATAL_ERROR "RC_DDS_STATS=ON requires -DRC_DDS_STATS_SRC=<Fast-DDS>/src/cpp (statistics type headers)")
+  endif()
+  message(STATUS "DDS Statistics consumer ENABLED for dsr_gui (types from ${RC_DDS_STATS_SRC})")
+  target_compile_definitions(dsr_gui PRIVATE RC_DDS_STATS=1)
+  target_include_directories(dsr_gui PRIVATE $<BUILD_INTERFACE:${RC_DDS_STATS_SRC}>)
+endif()
+
 # AddressSanitizer (opt-in): cmake -B build-asan -DENABLE_ASAN=ON
 # Only needed for redzone-precise detection INSIDE the graph viewer. Do NOT `make install`
 # an ASan build to /usr/local/lib — it would break every non-ASan agent. Build it locally and

gui/include/dsr/gui/viewers/graph_viewer/graph_colors.h

@@ -29,8 +29,13 @@ class GraphColors
         }
         if(colors.count(key)>0)
             return colors[key];
-        else
-            return default_color;
+        // An unlisted NODE type gets a stable, distinct colour derived from its name instead of one
+        // flat default — otherwise every new type in the system renders identically and the graph
+        // stops carrying information (see stable_fallback_color in node_colors.h). Edges keep their
+        // single default: they are thin lines where a colour-per-type would be noise, not signal.
+        if constexpr(std::is_same_v<Ta, DSR::Node>)
+            return stable_fallback_color(key);
+        return default_color;
     };
 };
 

gui/include/dsr/gui/viewers/graph_viewer/graph_node.h

@@ -42,6 +42,9 @@ using namespace DSR;
 
 class GraphEdge;
 class QGraphicsSceneMouseEvent;
+// Small "+"/"-" child item drawn beside a node that has collapsible children. Defined in
+// graph_node.cpp — it only needs to handle its own clicks.
+class CollapseBadge;
 
 
 class GraphNode : public QObject, public QGraphicsEllipseItem
@@ -50,7 +53,7 @@ Q_OBJECT
     Q_PROPERTY(QColor node_color READ _node_color WRITE set_node_color)
 private:
     QPointF newPos;
-    QGraphicsSimpleTextItem *tag;
+    QGraphicsSimpleTextItem *tag = nullptr;   // created on first setTag(), reused after (see setTag)
     std::string type;
     std::shared_ptr<DSR::GraphViewer> graph_viewer;
     QBrush node_brush;
@@ -60,6 +63,7 @@ Q_OBJECT
     std::unique_ptr<QWidget> node_widget;
     std::set<std::string> cached_edge_types;
     QPoint press_screen_pos_;   // where the last left press started (click-vs-drag discrimination)
+    CollapseBadge *collapse_badge = nullptr;   // created on first set_collapse_indicator()
 
 public:
     static constexpr int DEFAULT_DIAMETER = 20;
@@ -86,6 +90,9 @@ Q_OBJECT
     std::string getColor() const { return plain_color.toStdString(); };
     void setType(const std::string &type_);
     std::string getType() const { return type;};
+    // Shows/hides the "+"/"-" collapse handle beside the node. The node holds no policy: what
+    // "collapsed" hides is decided by GraphViewer, which owns the parent/child index.
+    void set_collapse_indicator(bool has_collapsible_children, bool collapsed);
     QRectF boundingRect() const override;
     QPainterPath shape() const override;
     void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) override;
@@ -118,6 +125,8 @@ public slots:
     // stored inline in the graph. The agent, which owns the media-plane (DDS)
     // subscriber, connects to this (QueuedConnection) and opens its own viewer.
     void view_data_signal(uint64_t id, const std::string &type);
+    // The user clicked the "+"/"-" badge. GraphViewer decides which children to hide/show.
+    void toggle_children_signal(uint64_t id);
 
 private:
     // True if the node still holds its type's raw payload as a graph attribute.

gui/include/dsr/gui/viewers/graph_viewer/graph_viewer.h

@@ -55,6 +55,8 @@ namespace DSR
 			void del_edge_SLOT(std::uint64_t from, std::uint64_t to,  const std::string &edge_tag);
 			void del_node_SLOT(uint64_t id);  // remove node from visual graph
 			void hide_show_node_SLOT(uint64_t id, bool visible);
+			// Collapse/expand the RT subtree hanging from a node (the "+"/"-" badge)
+			void toggle_children_SLOT(uint64_t parent_id);
 			// Others
 			void toggle_animation(bool state);
             void compute_layout(const char * alg = "dot");
@@ -79,6 +81,22 @@ namespace DSR
 			QGraphicsEllipseItem *central_point;
 			QMenu *contextMenu, *showMenu;
 			std::map<std::string,std::set<std::uint64_t>> type_id_map;
+
+			// ---- collapsible children (any RT subtree folded away from its parent) ----
+			// Edge type that defines parenthood in DSR (see dsr_rt_api.cpp, which also maintains
+			// parent_att/level_att). Any node with at least one RT child gets a "+"/"-" badge.
+			static constexpr const char *PARENT_EDGE_TYPE = "RT";
+			std::map<std::uint64_t, std::set<std::uint64_t>> collapsible_children;  // parent -> RT children
+			std::set<std::uint64_t> collapsed_parents;   // parents currently folded (purely visual)
+			// Keeps `collapsible_children` in sync with the RT edges arriving/leaving from G
+			void note_parent_edge(std::uint64_t from, std::uint64_t to, const std::string &edge_tag, bool added);
+			// All descendants of `root` reachable through RT edges, root NOT included. With
+			// stop_at_collapsed the walk does not descend past a node the user folded on its own.
+			std::vector<std::uint64_t> subtree_ids(std::uint64_t root, bool stop_at_collapsed) const;
+			void refresh_collapse_badge(std::uint64_t parent_id);
+			// Re-applies the stored collapsed/expanded state (used when new nodes or edges arrive
+			// into an already collapsed parent, and after a full createGraph())
+			void apply_collapse_state(std::uint64_t parent_id);
 			int timerId = 0;
 			// Coalesces the (expensive, full-scene) setSceneRect/fitInView refit so a burst of
 			// high-frequency node/attribute updates triggers it at most a few times per second

gui/include/dsr/gui/viewers/graph_viewer/node_colors.h

@@ -5,90 +5,163 @@
 #ifndef DSR_NODE_COLORS_H
 #define DSR_NODE_COLORS_H
 
+#include <cstdint>
 #include <map>
 #include <string>
+#include <vector>
 
+/*
+ * Node colours, keyed by node type.
+ *
+ * Grouped into semantic FAMILIES so a graph reads at a glance: blues are the robot platform,
+ * cyans/teals are sensors, greens are cognition/navigation, browns are structure and furniture,
+ * pinks/magentas are a detected person. You should be able to spot "that is a sensor" without
+ * reading the label.
+ *
+ * Two rules to preserve when editing:
+ *
+ *  1. `agent` MUST stay a neutral grey. It is the "this agent has not reported its health yet"
+ *     state; rc::AgentStatePublisher overwrites it live with green/orange/red (see
+ *     common/agent_state_publisher/agent_status.h in active_inference). Giving `agent` a real
+ *     colour here would make a silent or dead agent look meaningful.
+ *  2. Avoid plain "green" / "orange" / "red" for ordinary node types, so those three keep reading
+ *     as agent health rather than as a node category.
+ *
+ * Every value must be a CSS3 colour name (list at the bottom of this file). QColor yields BLACK for
+ * anything it cannot parse; GraphNode::set_color now rejects and logs such values rather than
+ * painting the node black, but keep them valid anyway.
+ *
+ * A type NOT listed here no longer collapses onto one flat default — see stable_fallback_color().
+ */
 static const std::map<std::string, std::string> node_colors = {
-        { "root", "red"},
+// -- Structure / world ------------------------------------------------------------------------
+        { "root", "red"},                   // the single graph root; long-standing, kept
         { "transform", "SteelBlue"},
-        { "room", "Gray"},
-        { "differentialrobot", "GoldenRod"},
-        { "omnirobot", "Gray"},
-        { "robot", "Gray"},
-        { "path_to_target", "Gray"},
-        { "intention", "Gray"},
-        { "rgbd", "Gray"},
-        { "pan_tilt", "Gray"},
-        { "battery", "Gray"},
-        { "pose", "Gray"},
-        { "laser", "GreenYellow"},
-        { "camera", "Gray"},
-        { "imu", "LightSalmon"},
-        { "slam_device", "Gray"},
-        { "object", "Gray"},
-        { "affordance_space", "Gray"},
-        { "person", "Gray"},
-        { "personal_space", "Gray"},
+        { "mind", "MediumPurple"},          // parent of the agent nodes
+        { "room", "Tan"},
+        { "wall", "CadetBlue"},
+        { "floor", "BurlyWood"},
         { "plane", "Khaki"},
-        { "box", "Gray"},
-        { "cylinder", "Gray"},
-        { "ball", "Gray"},
+        { "grid", "Wheat"},
         { "mesh", "LightBlue"},
-        { "face", "Gray"},
-        { "body", "Gray"},
-        { "chest", "Gray"},
-        { "nose", "Gray"},
-        { "left_eye", "Gray"},
-        { "right_eye", "Gray"},
-        { "left_ear", "Gray"},
-        { "right_ear", "Gray"},
-        { "left_arm", "Gray"},
-        { "right_arm", "Gray"},
-        { "left_shoulder", "Gray"},
-        { "right_shoulder", "Gray"},
-        { "left_elbow", "Gray"},
-        { "right_elbow", "Gray"},
-        { "left_wrist", "Gray"},
-        { "right_wrist", "Gray"},
-        { "left_hand", "Gray"},
-        { "right_hand", "Gray"},
-        { "left_hip", "Gray"},
-        { "right_hip", "Gray"},
-        { "left_leg", "Gray"},
-        { "right_leg", "Gray"},
-        { "left_knee", "Gray"},
-        { "right_knee", "Gray"},
-        { "mug", "Gray"},
-        { "cup", "Gray"},
-        { "noodles", "Gray"},
-        { "table", "Gray"},
-        { "chair", "Gray"},
-        { "shelve", "Gray"},
-        { "dish", "Gray"},
-        { "spoon", "Gray"},
-        { "testtype", "Gray"},
-        { "glass", "Gray"},
-        { "plant", "Gray"},
-        { "microwave", "Gray"},
-        { "oven", "Gray"},
-        { "vase", "Gray"},
-        { "refrigerator", "Gray"},
 
-//melex-rodao types
-        { "road", "Gray"},
-        { "building", "Gray"},
-        { "vehicle", "Gray"},
-        { "gps", "Gray"},
-        { "grid", "Gray"},
+// -- Robot platform ---------------------------------------------------------------------------
+        { "robot", "RoyalBlue"},
+        { "omnirobot", "CornflowerBlue"},
+        { "differentialrobot", "GoldenRod"},
+        { "body", "LightSteelBlue"},
+        { "pan_tilt", "PowderBlue"},
+        { "battery", "YellowGreen"},
 
-        { "wall", "SteelBlue"},
-        { "floor", "BurlyWood"},
+// -- Sensors ----------------------------------------------------------------------------------
+        { "rgbd", "MediumTurquoise"},
+        { "camera", "Turquoise"},
+        { "laser", "GreenYellow"},
+        { "imu", "LightSalmon"},
+        { "slam_device", "DarkCyan"},
+        { "gps", "DeepSkyBlue"},
+
+// -- Cognition / navigation -------------------------------------------------------------------
+        { "path_to_target", "SpringGreen"},
+        { "intention", "MediumSpringGreen"},
+        { "pose", "Aquamarine"},
         { "affordance", "DarkOrange"},
+        { "affordance_space", "Coral"},
+        { "object", "DarkSeaGreen"},
+
+// -- Geometric primitives ---------------------------------------------------------------------
+        { "box", "SlateBlue"},
+        { "cylinder", "MediumSlateBlue"},
+        { "ball", "DarkSlateBlue"},
+
+// -- Furniture / household objects --------------------------------------------------------------
+        { "table", "Peru"},
+        { "chair", "Sienna"},
+        { "shelve", "Chocolate"},
+        { "microwave", "DarkOliveGreen"},
+        { "oven", "IndianRed"},
+        { "refrigerator", "PaleTurquoise"},
+        { "vase", "MediumSeaGreen"},
+        { "plant", "ForestGreen"},
+        { "mug", "Plum"},
+        { "cup", "Violet"},
+        { "glass", "PaleGreen"},
+        { "dish", "Moccasin"},
+        { "spoon", "PaleGoldenRod"},
+        { "noodles", "NavajoWhite"},
+        { "testtype", "Gold"},
 
-//Agent
+// -- Person & skeleton --------------------------------------------------------------------------
+// One pink/magenta family so a detected person reads as a single cluster. Left/right pairs share a
+// colour ON PURPOSE (the symmetry is the point), and joints are separated from limbs: 22 near
+// identical pinks would carry less information than two clearly different ones.
+        { "person", "HotPink"},
+        { "personal_space", "Pink"},
+        { "face", "LightPink"},
+        { "nose", "PaleVioletRed"},
+        { "left_eye", "Orchid"},
+        { "right_eye", "Orchid"},
+        { "left_ear", "Orchid"},
+        { "right_ear", "Orchid"},
+        { "chest", "DeepPink"},
+        // joints
+        { "left_shoulder", "MediumOrchid"},
+        { "right_shoulder", "MediumOrchid"},
+        { "left_elbow", "MediumOrchid"},
+        { "right_elbow", "MediumOrchid"},
+        { "left_wrist", "MediumOrchid"},
+        { "right_wrist", "MediumOrchid"},
+        { "left_hip", "MediumOrchid"},
+        { "right_hip", "MediumOrchid"},
+        { "left_knee", "MediumOrchid"},
+        { "right_knee", "MediumOrchid"},
+        // limbs / extremities
+        { "left_arm", "MediumVioletRed"},
+        { "right_arm", "MediumVioletRed"},
+        { "left_hand", "MediumVioletRed"},
+        { "right_hand", "MediumVioletRed"},
+        { "left_leg", "MediumVioletRed"},
+        { "right_leg", "MediumVioletRed"},
+
+// -- melex-rodao types ---------------------------------------------------------------------------
+        { "road", "DarkKhaki"},
+        { "building", "SaddleBrown"},
+        { "vehicle", "DarkSalmon"},
+
+// -- Agent ---------------------------------------------------------------------------------------
+// KEEP NEUTRAL GREY - see rule 1 above. This is the "health not reported yet" colour; the live
+// value is written over it by rc::AgentStatePublisher.
         { "agent", "Gray"}
 };
 
+/*
+ * Colour for a type with no entry above.
+ *
+ * Unlisted types used to collapse onto a single flat default, so a graph full of new types was a
+ * wall of identical nodes carrying no information. Instead, hash the type name into a curated
+ * palette: distinct, readable, never grey, never the three agent-health colours.
+ *
+ * The hash is FNV-1a spelled out here rather than std::hash, because the colour must be THE SAME in
+ * every agent's viewer and across rebuilds - std::hash offers no such guarantee. The same type name
+ * always yields the same colour, and a newly introduced type gets a distinct one for free.
+ */
+inline std::string stable_fallback_color(const std::string &type)
+{
+    static const std::vector<std::string> palette = {
+        "DodgerBlue",    "MediumAquamarine", "SandyBrown",  "MediumOrchid",
+        "LightSeaGreen", "Chocolate",        "CadetBlue",   "DarkKhaki",
+        "PaleVioletRed", "OliveDrab",        "SlateBlue",   "MediumPurple",
+        "DarkTurquoise", "IndianRed",        "Thistle",     "YellowGreen",
+    };
+    std::uint32_t h = 2166136261u;                 // FNV-1a offset basis
+    for (const unsigned char c : type)
+    {
+        h ^= c;
+        h *= 16777619u;                            // FNV-1a prime
+    }
+    return palette[h % palette.size()];
+}
+
 #endif //DSR_NODE_COLORS_H
 
 // VALID COLOR NAMES https://www.w3.org/TR/2018/REC-css-color-3-20180619/

gui/viewers/graph_viewer/graph_edge.cpp

@@ -194,7 +194,7 @@ void GraphEdge::draw_arc(QPainter* painter) const
 
 void GraphEdge::mouseDoubleClickEvent(QGraphicsSceneMouseEvent* event)
 {
-    if (event->button()==Qt::RightButton) {
+    if (event->button()==Qt::LeftButton) {
         mouse_double_clicked();
     }
     QGraphicsLineItem::mouseDoubleClickEvent(event);
@@ -207,7 +207,7 @@ bool GraphEdge::eventFilter(QObject* object, QEvent* event)
     {
         if(event->type() == QEvent::GraphicsSceneMouseDoubleClick){
             auto mouseEvent = static_cast<QGraphicsSceneMouseEvent*>(event);
-            if (mouseEvent->button()==Qt::RightButton) {
+            if (mouseEvent->button()==Qt::LeftButton) {
                 mouse_double_clicked();
             }
             return true;