Struct Sentinel 

pub struct Sentinel { /* private fields */ }

The Sentinel agent — the immune system’s anomaly detector.

Implementations

impl Sentinel

pub fn new(position: Position) -> Sentinel

pub fn with_seed(position: Position, seed: u64) -> Sentinel

Create a sentinel with a deterministic ID (for testing).

pub fn anomalies_detected(&self) -> u64

Trait Implementations

impl Agent for Sentinel

fn id(&self) -> AgentId

The agent’s unique identity.

fn position(&self) -> Position

The agent’s current position in the substrate.

fn set_position(&mut self, position: Position)

Set the agent’s position.

fn agent_type(&self) -> &str

The agent’s type name (for display and logging).

fn tick(&mut self, substrate: &dyn Substrate) -> AgentAction

Execute one tick of the agent’s lifecycle.

fn age(&self) -> u64

How many ticks this agent has been alive.

fn export_vocabulary(&self) -> Option<Vec<u8>>

Export this agent’s vocabulary as serialized bytes. Returns None if the agent has no vocabulary to export.

fn profile(&self) -> AgentProfile

Build a profile describing this agent’s capabilities.

fn integrate_vocabulary(&mut self, _data: &[u8]) -> bool

Integrate foreign vocabulary from serialized bytes. Returns true if integration succeeded.

fn evaluate_symbiosis(&self, _other: &AgentProfile) -> Option<SymbiosisEval>

Evaluate whether to absorb another agent as a symbiont.

fn absorb_symbiont(&mut self, _profile: AgentProfile, _data: Vec<u8>) -> bool

Absorb another agent’s profile and vocabulary data as a symbiont. Returns true if absorption succeeded.

fn permeability(&self) -> f64

Current boundary permeability (0.0 = rigid, 1.0 = fully dissolved).

fn modulate_boundary(&mut self, _context: &BoundaryContext)

Adjust boundary permeability based on environmental context.

fn externalize_vocabulary(&self) -> Vec<String>

Return vocabulary terms to externalize (reinforce in the substrate).

fn internalize_vocabulary(&mut self, _terms: &[String])

Absorb nearby concept terms from the substrate.

fn vocabulary_size(&self) -> usize

Return the size of this agent’s vocabulary (for metrics).

impl Apoptose for Sentinel

fn self_assess(&self) -> CellHealth

Evaluate own health and usefulness.

fn prepare_death_signal(&self) -> DeathSignal

Package final state into a death signal before destruction.

fn should_die(&self) -> bool

Whether the agent should initiate death.

fn trigger_apoptosis(self) -> DeathSignal

where Self: Sized,

Initiate orderly self-destruction (for concrete types).

impl Digest for Sentinel

type Input = String

The raw input to consume. Ownership is transferred — the input is destroyed.

type Fragment = String

Structural fragments extracted during digestion.

type Presentation = Vec<String>

What is presented to other agents after digestion.

fn engulf(&mut self, input: String) -> DigestionResult

Engulf: take ownership of input.

fn lyse(&mut self) -> Vec<String>

Lyse: break the engulfed material into fragments.

fn present(&self) -> Vec<String>

Present: expose fragments on the agent’s surface.

fn digest(&mut self, input: Self::Input) -> Self::Presentation

Run the full digestion cycle: engulf → lyse → present.

impl Negate for Sentinel

type Observation = Vec<(String, u64)>

An observation that can be classified as self or non-self.

type SelfModel = ConceptSelfModel

The internal self-model (what the agent considers “normal”).

fn learn_self(&mut self, observations: &[<Sentinel as Negate>::Observation])

Build or update the self-model from observations.

fn self_model(&self) -> &ConceptSelfModel

Get a reference to the current self-model.

fn is_mature(&self) -> bool

Whether the self-model has been sufficiently trained.

fn classify( &self, observation: &<Sentinel as Negate>::Observation, ) -> Classification

Classify an observation as self (normal) or non-self (anomalous).

impl Sense for Sentinel

fn sense_radius(&self) -> f64

The radius within which this agent can sense signals.

fn sense_position(&self) -> Position

The position from which this agent senses.

fn gradient(&self, _substrate: &dyn Substrate) -> Vec<Gradient>

Compute the gradient — direction of increasing signal strength.

fn orient(&self, _gradients: &[Gradient]) -> Orientation

Determine next orientation based on sensed gradients.

fn sense(&self, substrate: &dyn Substrate) -> Vec<Signal>

Read signals from the local environment.

fn emit(&self, signal: Signal, substrate: &mut dyn Substrate)

Emit a signal into the substrate.

impl SerializableAgent for Sentinel

fn export_state(&self) -> SerializedAgent

Export the agent’s state for serialization.

fn from_state(state: &SerializedAgent) -> Option<Sentinel>

Create an agent from serialized state.