Enum MemoryKind 

pub enum MemoryKind {
    Observation,
    Reflection,
    Persona,
    Concept,
    Entity,
    Claim,
    Relation,
    Event,
    Conversation,
    Decision,
}

L1-1 (v0.7.0) — typed memory-kind discriminator stored in the memories.memory_kind column (schema v30).

Observation and Reflection exist since v0.7.0. Persona landed in v0.7.0 QW-2 (schema v36) as the substrate-native Tencent-pattern L3 persona artefact.

v0.7.x Form 6 (issue #759) — Batman taxonomy extension. The Concept | Entity | Claim | Relation | Event | Conversation | Decision variants give downstream readers a richer atom-type vocabulary aligned with the Batman framework’s exemplar (Tolaria’s frontmatter-as-type schema). All seven variants serialize as snake_case strings via the existing memory_kind TEXT column — no schema migration is required because the column has no CHECK constraint. Old rows with no kind read as Observation (the SQL DEFAULT 'observation'). A future-schema variant a binary doesn’t recognise reads as Observation via the unwrap_or_default() chain in row_to_memory (forward-compat).

Observation is the default for every memory created before v30 (the DEFAULT 'observation' SQL column handles the backfill contract for rows that pre-date the migration; new inserts that omit the field also land at Observation). Reflection is set by the memory_reflect write path in addition to the existing metadata.type='reflection' back-compat marker. Persona is set by the QW-2 PersonaGenerator and the memory_persona_generate MCP tool.

Variants

Observation

Default — a direct observation or note from the caller.

Reflection

A memory synthesised by the reflection pass over lower-depth peers (set by memory_reflect and the curator reflection pass).

Persona

v0.7.0 QW-2 — Persona-as-artifact. A curator-generated Markdown profile summarising an entity, derived from a cluster of Reflection-kind memories about that entity. The entity_id + persona_version columns on memories are populated only for this variant.

Concept

v0.7.x Form 6 — abstract definition / vocabulary term (“ownership is a Rust borrow-checker rule”).

Entity

v0.7.x Form 6 — named real-world thing (person, org, product, system component). Pairs with entity_id on the row when the caller has registered the entity in the KG.

Claim

v0.7.x Form 6 — factual assertion the caller is recording (“the build broke at 14:32 UTC”). Distinct from Observation in that a Claim is a propositional commitment; a Reflection chain may agree or contradict it.

Relation

v0.7.x Form 6 — typed pair / triple. Anchors a KG relation inside the memory substrate so an operator can query the relation set with the same recall pipeline used for free-text.

Event

v0.7.x Form 6 — temporally-bounded happening (“deploy at 09:00”, “incident at 14:32”). Distinct from Observation only when the caller wants the downstream-filtering surface to separate “what I saw” from “what happened”.

Conversation

v0.7.x Form 6 — captured dialogue turn (the substrate also stores conversations as Observation-kind today; this kind makes the type explicit for callers that want to filter to just conversational atoms).

Decision

v0.7.x Form 6 (L1-6 reservation) — choice point with rationale. Distinct from Reflection in that a Decision commits to a course of action; reflections summarise. The L1-6 work (v0.8.0) will likely add columns for rationale / alternatives, but the variant lands now so callers can start typing decisions.

Implementations

impl MemoryKind

pub fn as_str(&self) -> &'static str

Column-wire string (matches the SQL DEFAULT 'observation' value).

pub fn from_str(s: &str) -> Option<Self>

Parse the column-wire string. Returns None on unrecognised values so callers can fall back to Observation (forward-compat with future variants that land in a newer DB on an older binary).

pub fn all() -> &'static [Self]

Enumerate every variant in declaration order. Used by the capabilities surface (Form 6 CapabilityMemoryKindVocab) and by the recall filter parser when the caller passes "all".

pub fn parse_csv(s: &str) -> Option<Vec<Self>>

v0.7.x Form 6 — parse a comma-separated list of kind names into a deduplicated Vec<MemoryKind>.

Two distinct empty cases are intentionally preserved (Cluster E audit COR-4 — issue #767):

• Input is empty (whitespace-only or zero non-empty tokens after trim) → None. Callers treat this as “no filter declared, return everything”.
• Input is non-empty but every token is unrecognised (e.g. "reflektion,observetion") → Some(vec![]). Callers treat this as “an intentional filter was declared and matched nothing”, returning zero rows. Collapsing this case to None (the pre-COR-4 behaviour) silently inverted a typo into “show ALL kinds”, which is the bug the v0.7.0 audit flagged.

Known tokens are deduplicated; unknown tokens are dropped silently (forward-compat — a future variant emitted by a newer client should not break recall on an older binary), but the distinction above means dropping every token does NOT collapse into “no filter”.

Trait Implementations

impl Clone for MemoryKind

fn clone(&self) -> MemoryKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for MemoryKind

impl Debug for MemoryKind

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

Formats the value using the given formatter.

impl Default for MemoryKind

fn default() -> MemoryKind

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for MemoryKind

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for MemoryKind

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

Formats the value using the given formatter.

impl Eq for MemoryKind

impl Hash for MemoryKind

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for MemoryKind

fn eq(&self, other: &MemoryKind) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for MemoryKind

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for MemoryKind