Enum NoteKind 

pub enum NoteKind {
    Fact,
    Preference,
    Procedure,
}

The on-disk note format and the memory taxonomy now live in car_memgine::note_store, so the MCP server can read and write the SAME store this assistant does. Re-exported here because NoteKind is part of this module’s published surface (car_server_core::assistant::NoteKind) and callers should not have to care that it moved. The model-facing memory taxonomy. Each variant routes to genuinely different downstream behavior in memgine — this is the behavioral hint the tool schema carries instead of prose in a system prompt telling the model what is “worth keeping”.

Variants

Fact

Retrieved when relevant to the query (the Facts layer).

Preference

A standing instruction. Saved as a memgine constraint, so it lands in the Active Constraints layer that context assembly includes in every session regardless of query.

Procedure

Procedural evidence — what was attempted and whether it worked.

Implementations

impl NoteKind

pub fn parse(raw: Option<&str>) -> Result<NoteKind, String>

Strict parse for a value a model supplied. An unknown kind is an error the model can see and correct.

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

The wire spelling, matching the serde rename_all = "lowercase" and the vocabulary Self::parse accepts.

pub fn from_wire(raw: Option<&str>) -> NoteKind

Lenient read-side parse for a value that came off the sync wire.

Unlike Self::parse, an unrecognized kind is NOT an error: it means a peer running a newer build used a variant this device does not know about, and degrading that to a plain fact is strictly better than dropping the fact or failing the recall.

pub fn from_constraint_dialect(raw: Option<&str>) -> NoteKind

Map the constraint/pattern vocabulary the MCP tool schema and the memory.persist wire format use onto this one.

Those surfaces predate NoteKind and speak a different dialect: they carry a free-form kind where only the exact string "constraint" means anything, and everything else (including the documented default "pattern") is a plain fact. Both dialects now write the SAME file, so the translation has to live somewhere explicit rather than being re-derived — a "constraint" that round-trips as a Fact silently demotes a standing rule to something recall only sometimes surfaces.

pub fn is_constraint(self) -> bool

Whether this note is a standing rule, and therefore a memgine constraint rather than a query-matched fact.

Trait Implementations

impl Clone for NoteKind

fn clone(&self) -> NoteKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for NoteKind

impl Debug for NoteKind

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

Formats the value using the given formatter.

impl Default for NoteKind

fn default() -> NoteKind

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for NoteKind

fn deserialize<__D>( __deserializer: __D, ) -> Result<NoteKind, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for NoteKind

impl PartialEq for NoteKind

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for NoteKind

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for NoteKind