Struct Memory 

pub struct Memory {
    pub metadata: MemoryMetadata,
    pub content: String,
    pub embedding: Option<Vec<f32>>,
}

A complete memory entry: metadata + content.

Fields

metadata: MemoryMetadata

Metadata

content: String

Content (text, JSON, or binary encoded as base64)

embedding: Option<Vec<f32>>

Optional embedding vector (stored separately in Embeddings galaxy)

Implementations

impl Memory

pub fn new(galaxy: Galaxy, content: String) -> Self

Create a new memory in the given galaxy.

pub fn with_tags(self, tags: Vec<String>) -> Self

Set tags on this memory.

pub const fn with_importance(self, importance: f32) -> Self

Set importance score (0.0 to 1.0).

pub const fn with_memory_type(self, memory_type: MemoryType) -> Self

Set memory type.

pub const fn with_emotional_valence(self, valence: f32, weight: f32) -> Self

Set emotional valence (-1.0 to 1.0) and weight (0.0 to 1.0).

pub const fn with_protection(self, protected: bool) -> Self

Mark this memory as protected from forgetting.

pub fn with_source(self, source: String, trust: f32) -> Self

Set provenance source and trust score.

pub const fn with_half_life_days(self, days: f32) -> Self

Set per-memory decay half-life in days.

pub const fn with_neuro_score(self, score: f32) -> Self

Set initial neuro_score (0.0 to 1.0).

pub const fn with_novelty_score(self, score: f32) -> Self

Set initial novelty_score (0.0 to 1.0).

pub const fn with_privacy(self, is_private: bool, model_exclude: bool) -> Self

Set privacy flags.

pub fn transition_tier(&mut self, to: Tier) -> Result<(), CoreError>

Transition the serving tier (MEMORY_TYPOLOGY_V8.md §6).

The dream cycle is the ONLY legitimate caller — tier moves are a sleep-time lifecycle decision, never a request-path one (no tool accepts a tier argument; memory.update whitelists its fields). Legal moves:

• Working → Episodic — age-out of the current-session working set
• Episodic → Semantic — consolidation promotion
• Working | Episodic | Semantic → Archival — decay-out
• Archival → Episodic — promotion on read (warm re-serving)

Anything else — demotion out of a consolidated or sealed state, skipping ahead on the ladder — is refused. One move per call: the dream cycle paces the ladder one step per cycle.

pub fn transition_validity( &mut self, transition: MemoryTransition, ) -> Result<(), ValidityTransitionError>

Transition the lifecycle validity (V8 Slice B, D1+D2).

The dream cycle’s validity_sweep is the ONLY legitimate caller — validity moves are a sleep-time lifecycle decision, never a request-path one (no tool accepts a validity argument). Legality is exactly wm_core::episodic::ValidityState::transition; this wrapper only supplies the record id so callers cannot fabricate a mismatched identity.

pub fn with_agent(self, agent_id: String, version: u64) -> Self

Set agent identity and version.

pub fn with_embedding(self, embedding: Vec<f32>) -> Self

Attach an embedding vector.

pub fn record_access(&mut self)

Record an access (updates accessed_at and increments access_count).

pub fn recall(&mut self)

Record a recall — Hebbian-style strengthening of neuro_score.

Boosts neuro_score by 0.05 * (1.0 - current_neuro_score) (diminishing returns), increments recall_count, updates accessed_at, and decays novelty_score (familiarity reduces novelty).

pub fn decay(&mut self, now: DateTime<Utc>)

Apply exponential decay to neuro_score based on time since last access and the memory’s half_life_days.

neuro_score *= 0.5 ^ (days_since_access / half_life_days) Protected memories are exempt from decay.

pub fn decay_importance(&mut self, factor: f32)

Decay importance by a given factor (used by mindful forgetting).

pub fn should_forget(&self, threshold: f32) -> bool

Whether this memory should be forgotten (importance below threshold). Protected memories are never forgotten.

pub fn is_telemetry_or_noise(&self) -> bool

Checks whether this memory is operational telemetry, friction logging, or raw noise that should be excluded from dream consolidation, tier promotion, and serendipity association mining (D1/D5/D8 hygiene rules).

Trait Implementations

impl Clone for Memory

fn clone(&self) -> Memory

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Memory

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Memory

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Memory

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

where __S: Serializer,

Serialize this value into the given Serde serializer.