Struct AgentRegistry 

pub struct AgentRegistry {
    pub agents: Vec<AgentEntry>,
    pub scratchpad: Vec<ScratchpadEntry>,
    pub logical_sessions: Vec<LogicalSessionPresence>,
    pub logical_session_telemetry_seen: bool,
    pub updated_at: DateTime<Utc>,
}

Fields

agents: Vec<AgentEntry>

scratchpad: Vec<ScratchpadEntry>

logical_sessions: Vec<LogicalSessionPresence>

logical_session_telemetry_seen: bool

updated_at: DateTime<Utc>

Implementations

impl AgentRegistry

pub fn new() -> Self

pub fn register( &mut self, agent_type: &str, role: Option<&str>, project_root: &str, ) -> String

pub fn register_mcp_process(project_root: &str) -> Result<String, String>

Atomically registers this MCP process in the shared on-disk registry.

pub fn heartbeat_persistent(agent_id: &str) -> Result<(), String>

Atomically refreshes a registered MCP process heartbeat.

pub fn finish_persistent(agent_id: &str) -> Result<(), String>

Atomically marks a registered MCP process as finished.

pub fn update_heartbeat(&mut self, agent_id: &str)

pub fn set_status( &mut self, agent_id: &str, status: AgentStatus, message: Option<&str>, )

pub fn open_or_heartbeat_logical_session( &mut self, source: &str, workspace: &str, session_id: &str, )

Records explicit logical-session presence supplied by an owning editor integration. Tool activity is deliberately never treated as a session.

pub fn close_logical_session( &mut self, source: &str, workspace: &str, session_id: &str, ) -> bool

pub fn cleanup_stale_logical_sessions(&mut self, max_age_seconds: u64)

pub fn record_logical_session_presence( event: &str, source: &str, workspace: &str, session_id: &str, ) -> Result<(), String>

pub fn list_active(&self, project_root: Option<&str>) -> Vec<&AgentEntry>

pub fn list_all(&self) -> &[AgentEntry]

pub fn post_message( &mut self, from_agent: &str, to_agent: Option<&str>, category: &str, message: &str, ) -> String

pub fn post_message_full( &mut self, from_agent: &str, to_agent: Option<&str>, category: &str, message: &str, privacy: PrivacyLevel, priority: MessagePriority, ttl_hours: Option<u64>, ) -> String

pub fn read_messages(&mut self, agent_id: &str) -> Vec<&ScratchpadEntry>

pub fn read_unread(&mut self, agent_id: &str) -> Vec<&ScratchpadEntry>

pub fn cleanup_stale(&mut self, max_age_hours: u64)

pub fn save(&self) -> Result<(), String>

pub fn load() -> Option<Self>

pub fn load_or_create() -> Self

pub fn mutate_locked<T>( f: impl FnOnce(&mut Self) -> T, ) -> Result<(Self, T), String>

Atomically load, mutate, and persist the registry under a single file lock. load_or_create() + mutate + save() is a read-modify-write race: save() only locks the final write, so two concurrent callers (two MCP sessions registering, or the dashboard’s own poll-triggered cleanup_stale + save) can each load a stale snapshot and the last writer silently drops the other’s changes — e.g. a second session’s registration vanishing from the dashboard. Holding the lock across the re-read closes that window: the read inside always sees the latest on-disk state.

impl AgentRegistry

pub fn share_knowledge( &mut self, from: &str, category: &str, facts: &[(String, String)], )

pub fn receive_shared_knowledge(&mut self, agent_id: &str) -> Vec<SharedFact>

Trait Implementations

impl Clone for AgentRegistry

fn clone(&self) -> AgentRegistry

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AgentRegistry

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for AgentRegistry

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for AgentRegistry

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for AgentRegistry

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.