Struct Commit 

pub struct Commit {

    pub change_id: ChangeId,
    pub parents: Vec<Cid>,
    pub nodes: Cid,
    pub edges: Cid,
    pub schema: Cid,
    pub delta: Option<Cid>,
    pub indexes: Option<Cid>,
    pub embeddings: Option<Cid>,
    pub author: String,
    pub agent_id: Option<String>,
    pub task_id: Option<String>,
    pub time: u64,
    pub message: String,
    pub signature: Option<Signature>,
    pub extra: BTreeMap<String, Ipld>,
}

A versioned snapshot of the graph.

Fields

change_id: ChangeId

Stable change identity (survives rewrite / rebase / amend).

parents: Vec<Cid>

Parent commits (empty = root, ≥2 = merge).

nodes: Cid

Root of the node Prolly tree.

edges: Cid

Root of the edge Prolly tree.

schema: Cid

Root of the schema Prolly tree.

delta: Option<Cid>

Optional DeltaSet link (reserved; not emitted in mnem/0.1).

indexes: Option<Cid>

Optional secondary-index root (crate::objects::IndexSet, SPEC §4.8). Agents that only need Prolly-lookup by stable id can ignore this; query paths (label / property / adjacency) use it when present.

embeddings: Option<Cid>

Optional embedding-sidecar Prolly root. Tree keyed by 32-byte NodeCid digest, value = crate::objects::EmbeddingBucket. Lifts dense embedding vectors out of Node canonical bytes so the Node CID stays byte-stable across ORT thread counts (f32 reduction ordering is non-deterministic; vectors drift by the LSB across thread counts). None on commits that carry no embed-bearing nodes.

Intentionally excluded from content_cid. Content CID is the deterministic “what graph is this” digest; including the embeddings root would re-couple it to ORT thread count and undo the determinism guarantee. Two machines re-deriving the same source text on different cores produce the same content_cid, just with per-machine drift in commit.embeddings.

author: String

Free-form author identifier.

agent_id: Option<String>

AI agent identifier (when the commit was machine-generated).

task_id: Option<String>

Task / tool-call identifier for provenance.

time: u64

Microseconds since Unix epoch.

message: String

UTF-8 commit message. May be empty.

signature: Option<Signature>

Optional cryptographic signature.

extra: BTreeMap<String, Ipld>

Forward-compat extension map (SPEC §3.2).

Implementations

impl Commit

pub const KIND: &'static str = "commit"

The _kind discriminator on the wire.

pub fn new( change_id: ChangeId, nodes: Cid, edges: Cid, schema: Cid, author: impl Into<String>, time: u64, message: impl Into<String>, ) -> Self

Build a commit with the required fields, empty optionals / parents / extras.

pub fn with_parent(self, parent: Cid) -> Self

Append a parent commit. Returns self for chaining.

pub fn with_agent(self, agent_id: impl Into<String>) -> Self

Attach an agent identifier.

pub fn with_task(self, task_id: impl Into<String>) -> Self

Attach a task identifier.

pub fn content_cid(&self) -> Result<Cid, CodecError>

(partial): a deterministic CID over only the data-DAG portion of the commit – the three Prolly tree roots (nodes, edges, schema), the optional indexes root, and the parents list. Excludes time, change_id, author, message, agent_id, task_id, signature, and extra.

Two ingest runs against byte-identical input on different machines (or at different times) MUST produce the same content_cid. The standard commit_cid continues to embed wall-clock + UUIDv7 metadata for audit-trail purposes; that CID is intentionally time-varying.

Errors

Propagates encoding failures from crate::codec::dagcbor::hash_to_cid.

Migration note

Wire format is unchanged: content_cid is computed from existing fields, so older blockstores stay readable. A follow-up may persist content_cid alongside commit_cid in the operation log for cheap lookup.

Trait Implementations

impl Clone for Commit

fn clone(&self) -> Commit

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Commit

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Commit

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl PartialEq for Commit

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

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl Eq for Commit

impl StructuralPartialEq for Commit