new files

Author: pbustos

api/dsr_agent_info_api.cpp

@@ -6,9 +6,14 @@
 #include <dsr/api/dsr_agent_info_api.h>
 #include <dsr/api/dsr_api.h>
 #include <unistd.h>
+#include <limits.h>
 #include <sys/stat.h>
 #include <sys/times.h>
 #include <QMetaObject>
+#include <fstream>
+#include <sstream>
+#include <vector>
+#include <string>
 
 namespace DSR {
 
@@ -32,6 +37,71 @@ void AgentInfoAPI::heartbeat_tick()
                     pclose(pipe);
             }
         };
+
+        // ── Deployment self-report helpers ──────────────────────────────────────────────────────────
+        // Read this process's argv from /proc/self/cmdline (NUL-separated). Empty on failure.
+        std::vector<std::string> proc_argv()
+        {
+            std::vector<std::string> argv;
+            std::ifstream f("/proc/self/cmdline", std::ios::binary);
+            if (!f)
+                return argv;
+            std::string tok;
+            for (char ch; f.get(ch); )
+            {
+                if (ch == '\0') { if (!tok.empty()) argv.push_back(tok); tok.clear(); }
+                else            tok.push_back(ch);
+            }
+            if (!tok.empty()) argv.push_back(tok);
+            return argv;
+        }
+
+        // This process's current working directory via /proc/self/cwd. Empty on failure.
+        std::string proc_cwd()
+        {
+            char buf[PATH_MAX];
+            const ssize_t n = ::readlink("/proc/self/cwd", buf, sizeof(buf) - 1);
+            return n > 0 ? std::string(buf, static_cast<size_t>(n)) : std::string{};
+        }
+
+        // Pick the config path out of argv, mirroring the launcher's topology.py::_config_path:
+        // the last token that looks like a config (under etc/, or ending in config/.toml/.conf),
+        // unwrapping an --Ice.Config= prefix. Relative paths are resolved against cwd.
+        std::string derive_config_path(const std::vector<std::string>& argv, const std::string& cwd)
+        {
+            std::string cand;
+            for (std::string tok : argv)
+            {
+                constexpr const char* kIcePrefix = "--Ice.Config=";
+                if (tok.rfind(kIcePrefix, 0) == 0)
+                    tok = tok.substr(std::string(kIcePrefix).size());
+                const bool looks_config =
+                    tok.find("etc/") != std::string::npos ||
+                    (tok.size() >= 6 && tok.compare(tok.size() - 6, 6, "config") == 0) ||
+                    tok.find(".toml") != std::string::npos ||
+                    tok.find(".conf")  != std::string::npos;
+                if (looks_config)
+                    cand = tok;
+            }
+            if (cand.empty())
+                return cand;
+            if (!cand.empty() && cand.front() != '/' && !cwd.empty())
+                cand = cwd + "/" + cand;
+            return cand;
+        }
+
+        // Slurp a text file whole. Empty on failure.
+        std::string slurp_file(const std::string& path)
+        {
+            if (path.empty())
+                return {};
+            std::ifstream f(path, std::ios::binary);
+            if (!f)
+                return {};
+            std::ostringstream ss;
+            ss << f.rdbuf();
+            return ss.str();
+        }
     }
 
 
@@ -169,6 +239,12 @@ void AgentInfoAPI::heartbeat_tick()
 
             uint64_t times = get_unix_timestamp();
             auto &node_ref = node.value();
+            // Keep the PID fresh across restarts: the node can outlive the process (persisted graph),
+            // so a re-launched agent finds its old node here and must overwrite the stale pid. Only
+            // written when it actually changed, to avoid needless 1 Hz attribute churn/signals.
+            const auto cur_pid = static_cast<std::uint32_t>(getpid());
+            if (const auto p = G->get_attrib_by_name<agent_pid_att>(node_ref); not p.has_value() or p.value() != cur_pid)
+                G->add_or_modify_attrib_local<agent_pid_att>(node_ref, cur_pid);
             G->add_or_modify_attrib_local<timestamp_agent_att>(node_ref, times);
             G->add_or_modify_attrib_local<timestamp_alivetime_att>(node_ref,
                static_cast<uint64_t>(std::chrono::duration_cast<std::chrono::seconds>(std::chrono::nanoseconds(times - timestamp_start)).count()));
@@ -207,7 +283,22 @@ void AgentInfoAPI::heartbeat_tick()
             G->add_or_modify_attrib_local<pos_x_att>(new_node, (float) 10);
             G->add_or_modify_attrib_local<pos_y_att>(new_node, (float) 10);
             G->add_or_modify_attrib_local<parent_att>(new_node, parent_id);
-            G->add_or_modify_attrib_local<agent_description_att>(new_node, std::string{"TODO"});
+
+            // Deployment self-report (once, at creation): launch command, working dir and the raw
+            // etc/config used to start this agent. Feeds the "mind" node network view. Best-effort:
+            // any field that can't be resolved is simply left empty.
+            const auto argv       = proc_argv();
+            const auto cwd        = proc_cwd();
+            const auto cfg_path   = derive_config_path(argv, cwd);
+            std::string cmd_line;
+            for (const auto& a : argv) { if (!cmd_line.empty()) cmd_line += ' '; cmd_line += a; }
+            G->add_or_modify_attrib_local<agent_cmd_att>(new_node, cmd_line);
+            G->add_or_modify_attrib_local<agent_cwd_att>(new_node, cwd);
+            G->add_or_modify_attrib_local<agent_config_att>(new_node, slurp_file(cfg_path));
+            G->add_or_modify_attrib_local<agent_pid_att>(new_node, static_cast<std::uint32_t>(getpid()));
+            const std::string desc = cfg_path.empty() ? G->get_agent_name()
+                                                      : G->get_agent_name() + " (" + cfg_path + ")";
+            G->add_or_modify_attrib_local<agent_description_att>(new_node, desc);
             //CPU usage
             if (cpu >= 0.0)
             {

api/dsr_api.cpp

@@ -496,9 +496,12 @@ DSRGraph::SampleCallback<Batch> DSRGraph::make_node_attrs_subscription_functor_i
 }
 
 template <typename GraphSample>
-DSRGraph::SampleCallback<GraphSample> DSRGraph::make_fullgraph_request_functor_impl(const char* channel, std::atomic<bool>& sync, std::atomic<bool>& repeated)
+DSRGraph::SampleCallback<GraphSample> DSRGraph::make_fullgraph_request_functor_impl(const char* channel, std::shared_ptr<std::atomic<bool>> sync, std::shared_ptr<std::atomic<bool>> repeated)
 {
-    return [this, channel, &sync, &repeated](GraphSample&& sample, const DSR::Transport::ReceivedSampleInfo& m_info)
+    // Capture sync/repeated BY VALUE (shared_ptr): this callback is stored in a permanent DDS subscription
+    // and must keep the flags alive — capturing raw refs to fullgraph_request_thread()'s stack was the
+    // dangling-write bug. (Fixed 2026-07-21.)
+    return [this, channel, sync, repeated](GraphSample&& sample, const DSR::Transport::ReceivedSampleInfo& m_info)
     {
         [[maybe_unused]] static thread_local bool _named = []{ CORTEX_PROFILE_THREAD_NAME("fg_request"); return true; }();
         CORTEX_PROFILE_ZONE_N("DSRGraph::fullgraph_request_thread callback");
@@ -522,9 +525,9 @@ DSRGraph::SampleCallback<GraphSample> DSRGraph::make_fullgraph_request_functor_i
                     }
                 }, Qt::QueuedConnection);
                 qDebug() << "Synchronized.";
-                sync = true;
-            } else if (!sync && sample.to_id == agent_id) {
-                repeated = true;
+                *sync = true;
+            } else if (!*sync && sample.to_id == agent_id) {
+                *repeated = true;
             }
         }
     };
@@ -1332,8 +1335,14 @@ void DSRGraph::fullgraph_server_thread()
 std::pair<bool, bool> DSRGraph::fullgraph_request_thread()
 {
     CORTEX_PROFILE_MIN_N("DSRGraph::fullgraph_request_thread");
-    std::atomic<bool> sync{false};
-    std::atomic<bool> repeated{false};
+    // sync/repeated are shared_ptr, NOT stack locals: the GRAPH_ANSWER subscription below is PERMANENT and
+    // its callback captures them by value, so they must outlive this function. Previously they were stack
+    // atomics captured by reference — they dangled once this function returned, so a later peer's
+    // GRAPH_ANSWER (on a FastDDS reader thread) ran `*sync = true` through the dangling reference, writing
+    // 1 byte into freed/reused stack memory (the bit-48 wild write that randomly smashed cv::Mat headers
+    // etc. under peer churn). (Fixed 2026-07-21.)
+    auto sync     = std::make_shared<std::atomic<bool>>(false);
+    auto repeated = std::make_shared<std::atomic<bool>>(false);
     if (sync_mode == SyncMode::LWW) {
         dsrparticipant.subscribe_graph_answers<LWWGraphSnapshot>(make_fullgraph_request_functor_impl<LWWGraphSnapshot>("LWW_GRAPH_ANSWER", sync, repeated), mtx_entity_creation);
     } else {
@@ -1360,7 +1369,7 @@ std::pair<bool, bool> DSRGraph::fullgraph_request_thread()
 
     bool timeout = false;
     std::chrono::steady_clock::time_point begin = std::chrono::steady_clock::now();
-    while (!sync and !timeout and !repeated) {
+    while (!*sync and !timeout and !*repeated) {
         CORTEX_PROFILE_DETAIL_N("DSRGraph::fullgraph_request_thread wait loop");
         std::this_thread::sleep_for(1000ms);
         std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();
@@ -1371,7 +1380,7 @@ std::pair<bool, bool> DSRGraph::fullgraph_request_thread()
         dsrparticipant.publish_graph_request(gr);
     }
 
-    return { sync, repeated };
+    return { sync->load(), repeated->load() };
 }
 
 

api/include/dsr/api/dsr_api.h

@@ -796,7 +796,13 @@ namespace DSR
         template <typename Batch>
         SampleCallback<Batch> make_node_attrs_subscription_functor_impl(const char* channel);
         template <typename GraphSample>
-        SampleCallback<GraphSample> make_fullgraph_request_functor_impl(const char* channel, std::atomic<bool>& sync, std::atomic<bool>& repeated);
+        // sync/repeated are shared_ptr (not raw refs) so the returned callback — stored in a PERMANENT DDS
+        // subscription — captures them BY VALUE and keeps them alive. Previously they were refs to stack
+        // locals in fullgraph_request_thread() that dangled after it returned (a later peer's GRAPH_ANSWER
+        // then wrote through them into freed stack memory: the bit-48 wild write). Fixed 2026-07-21.
+        SampleCallback<GraphSample> make_fullgraph_request_functor_impl(const char* channel,
+                                                                        std::shared_ptr<std::atomic<bool>> sync,
+                                                                        std::shared_ptr<std::atomic<bool>> repeated);
 
         //Custom function for each rtps topic
         class ParticipantChangeFn {

core/include/dsr/core/types/type_checking/dsr_attr_name.h

@@ -476,6 +476,27 @@ REGISTER_TYPE(cpu_usage, float, false)
 REGISTER_TYPE(memory_usage, uint32_t , false)
 REGISTER_TYPE(num_procs, uint32_t, false)
 REGISTER_TYPE(agent_description, std::reference_wrapper<const std::string>, false)
+// Deployment metadata, self-reported once at agent-node creation (see AgentInfoAPI). Feeds the
+// "mind" node network view: agent_cmd/agent_cwd are the launch command + working dir read from
+// /proc/self, agent_config is the raw contents of the etc/config passed on the command line.
+REGISTER_TYPE(agent_cmd, std::reference_wrapper<const std::string>, false)
+REGISTER_TYPE(agent_cwd, std::reference_wrapper<const std::string>, false)
+REGISTER_TYPE(agent_config, std::reference_wrapper<const std::string>, false)
+// Process id of the agent (getpid). Lets the mind network view attribute each loopback TCP
+// connection to the exact client agent (inode→pid→agent), i.e. per-connection bandwidth.
+REGISTER_TYPE(agent_pid, std::uint32_t, false)
+// Live health of the agent, self-reported on every state transition (see rc::AgentStatePublisher).
+// Two independent axes: the generated GRAFCET/QStateMachine step the agent is executing, and the
+// agent-presence lifecycle (are its required peers there?). They are NOT redundant: an agent parked
+// in on_waiting_loop waiting for peers still reports FSM "Compute". The publisher also derives a
+// worst-wins `color` from the pair so any graph viewer paints the agent node without duplicating
+// the mapping.
+REGISTER_TYPE(agent_fsm_state, std::string, false)      /* Initialize | Compute | Emergency | Restore */
+REGISTER_TYPE(agent_presence_state, std::string, false) /* Waiting | Operating | Degraded */
+// Live media-plane throughput (bytes/s) the producer (SensorMediaPublisher) writes onto a sensor's
+// descriptor node. The heavy frames travel over zero-copy DDS shared memory, invisible to packet
+// capture, so this self-reported figure is the only way the mind view can show real media bandwidth.
+REGISTER_TYPE(media_bps, float, false)
 
 
 /*
@@ -573,6 +594,44 @@ REGISTER_TYPE(grid_occupancy_var,  std::reference_wrapper<const std::vector<floa
 REGISTER_TYPE(grid_field_meta,     std::reference_wrapper<const std::vector<float>>, false)  // [xmin,ymin,cell,w,h]
 
 
+// ── table-concept VOXEL MEMORY + active-perception ROI channel (written by table_concept) ──────
+//    Registered 2026-07-21 so table_scene_graph.cpp can use the TYPE-ATTRIBUTED setters instead of the
+//    runtime_checked_* string form (see CLAUDE.md). table_voxel_bank_pts / table_roi_offset are [x,y,z]-
+//    and [ox,oy]-packed float arrays; the ROI + detection scalars drive the controller's lock-on search
+//    via common/affordance_protocol (its attr_scalar() coerces int/float/bool alike).
+//    WIRE-TYPE WARNING for whoever edits these next: an attribute's registered type is part of its CONTRACT
+//    with every consumer. table_detection_alive was int 0/1 until 2026-07-21; flipping it to bool without
+//    migrating the readers made room_concept throw "INT is not selected, selected is BOOL" at runtime,
+//    because it read the raw attrs map with Attribute::dec(). Both readers now use the TYPE-ATTRIBUTED
+//    getter (get_attrib_by_name<table_detection_alive_att>), so a future type change is a COMPILE error
+//    there instead of a runtime throw. Never change a registered type without migrating every reader.
+REGISTER_TYPE(table_voxel_bank_pts,         std::reference_wrapper<const std::vector<float>>, false)  // [x,y,z]×N
+REGISTER_TYPE(table_roi_offset,             std::reference_wrapper<const std::vector<float>>, false)  // [ox,oy] ∈[-1,1]
+REGISTER_TYPE(table_roi_fill,               float,                                            false)  // projected extent frac
+REGISTER_TYPE(table_roi_valid,              bool,                                             false)  // projects in front of cam
+REGISTER_TYPE(table_detection_alive,        bool,                                             false)  // YOLO firing here
+REGISTER_TYPE(table_detection_confidence,   float,                                            false)  // last mask confidence
+REGISTER_TYPE(table_frames_since_detection, int,                                              false)  // cycles since fresh mask
+
+// ── chair-concept / cabinet-concept: same voxel-memory + ROI channel as table-concept above ────
+//    These agents are copies of the table_concept pattern and carry the identical interface, so they get
+//    the identical types. Readers are common/affordance_protocol (attr_scalar coerces int/float/bool), and
+//    no consumer reads them with a raw Attribute accessor — verified 2026-07-21 before choosing bool.
+REGISTER_TYPE(chair_voxel_bank_pts,           std::reference_wrapper<const std::vector<float>>, false)  // [x,y,z]xN
+REGISTER_TYPE(chair_roi_offset,               std::reference_wrapper<const std::vector<float>>, false)  // [ox,oy]
+REGISTER_TYPE(chair_roi_fill,                 float,                                            false)
+REGISTER_TYPE(chair_roi_valid,                bool,                                             false)
+REGISTER_TYPE(chair_detection_alive,          bool,                                             false)
+REGISTER_TYPE(chair_detection_confidence,     float,                                            false)
+REGISTER_TYPE(chair_frames_since_detection,   int,                                              false)
+REGISTER_TYPE(cabinet_voxel_bank_pts,         std::reference_wrapper<const std::vector<float>>, false)  // [x,y,z]xN
+REGISTER_TYPE(cabinet_roi_offset,             std::reference_wrapper<const std::vector<float>>, false)  // [ox,oy]
+REGISTER_TYPE(cabinet_roi_fill,               float,                                            false)
+REGISTER_TYPE(cabinet_roi_valid,              bool,                                             false)
+REGISTER_TYPE(cabinet_detection_alive,        bool,                                             false)
+REGISTER_TYPE(cabinet_detection_confidence,   float,                                            false)
+REGISTER_TYPE(cabinet_frames_since_detection, int,                                              false)
+
 // ── table-concept inference outputs (written by table-concept) ────────────────────────────────
 REGISTER_TYPE(free_energy,         float,                                             false)
 REGISTER_TYPE(model_stable,        bool,                                              false)