Struct MemoryCommit 

pub struct MemoryCommit {

    pub commit_id: Uuid,
    pub trajectory_id: TrajectoryId,
    pub scope_id: ScopeId,
    pub agent_id: Option<AgentId>,
    pub query: String,
    pub response: String,
    pub mode: String,
    pub reasoning_trace: Option<Value>,
    pub rag_contributed: bool,
    pub artifacts_referenced: Vec<ArtifactId>,
    pub notes_referenced: Vec<NoteId>,
    pub tools_invoked: Vec<String>,
    pub tokens_input: i64,
    pub tokens_output: i64,
    pub estimated_cost: Option<f64>,
    pub created_at: DateTime<Utc>,
}

Memory commit - versioned record of an interaction. Enables: “Last time we decided X because Y” Every interaction creates a versioned commit for recall, rollback, audit, and rehydration.

Fields

commit_id: Uuid

Unique identifier for this commit

trajectory_id: TrajectoryId

Trajectory this commit belongs to

scope_id: ScopeId

Scope this commit belongs to

agent_id: Option<AgentId>

Agent that created this commit (if multi-agent)

query: String

The user’s query/input

response: String

The system’s response

mode: String

Mode of interaction (e.g., “standard”, “deep_work”, “super_think”)

reasoning_trace: Option<Value>

Reasoning trace (if available)

rag_contributed: bool

Whether RAG contributed to this response

artifacts_referenced: Vec<ArtifactId>

Artifacts referenced in this interaction

notes_referenced: Vec<NoteId>

Notes referenced in this interaction

tools_invoked: Vec<String>

Tools invoked during this interaction

tokens_input: i64

Input token count

tokens_output: i64

Output token count

estimated_cost: Option<f64>

Estimated cost (if available)

created_at: DateTime<Utc>

When this commit was created

Implementations

impl MemoryCommit

pub fn new( trajectory_id: TrajectoryId, scope_id: ScopeId, query: String, response: String, mode: String, ) -> MemoryCommit

Create a new memory commit.

pub fn with_agent_id(self, agent_id: AgentId) -> MemoryCommit

Set the agent ID.

pub fn with_reasoning_trace(self, trace: Value) -> MemoryCommit

Set the reasoning trace.

pub fn with_rag_contributed(self, contributed: bool) -> MemoryCommit

Set RAG contribution flag.

pub fn with_artifacts_referenced( self, artifacts: Vec<ArtifactId>, ) -> MemoryCommit

Set referenced artifacts.

pub fn with_notes_referenced(self, notes: Vec<NoteId>) -> MemoryCommit

Set referenced notes.

pub fn with_tools_invoked(self, tools: Vec<String>) -> MemoryCommit

Set tools invoked.

pub fn with_tokens(self, input: i64, output: i64) -> MemoryCommit

Set token counts.

pub fn with_estimated_cost(self, cost: f64) -> MemoryCommit

Set estimated cost.

pub fn total_tokens(&self) -> i64

Get total tokens (input + output).

Trait Implementations

impl Clone for MemoryCommit

fn clone(&self) -> MemoryCommit

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MemoryCommit

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MemoryCommit

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for MemoryCommit

fn eq(&self, other: &MemoryCommit) -> 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 MemoryCommit

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 MemoryCommit