Enum GraphOp 

pub enum GraphOp {
    AddNode {
        id: Uuid,
        kind: String,
        name: String,
        summary: String,
        attrs: Value,
        group_id: String,
    },
    AddEdge {
        id: Uuid,
        src: Uuid,
        dst: Uuid,
        rel: String,
        fact: String,
        attrs: Value,
        group_id: String,
        valid_at: Option<TimestampMs>,
        invalid_at: Option<TimestampMs>,
    },
    AddEpisode {
        id: Uuid,
        source: String,
        kind: String,
        content: String,
        occurred_at: TimestampMs,
        group_id: String,
        mentions: Vec<Uuid>,
    },
    UpdateNode {
        id: Uuid,
        name: Option<String>,
        summary: Option<String>,
        kind: Option<String>,
        attrs: Option<Value>,
    },
    InvalidateEdge {
        edge_id: Uuid,
        invalid_at: TimestampMs,
    },
    MergeNodes {
        from: Uuid,
        into: Uuid,
    },
    Purge {
        ids: Vec<Uuid>,
    },
}

A single append-only write. See module docs.

Variants

AddNode

Create an entity node.

Fields

id: Uuid

UUIDv7 identity, minted by the caller (crate::Grit::new_id).

kind: String

Entity kind, free-form (e.g. "person", "concept").

name: String

Display name; FTS-indexed.

summary: String

One-paragraph summary; FTS-indexed.

attrs: Value

Arbitrary JSON attributes.

group_id: String

Namespace; filtered in every query.

AddEdge

Create a fact edge between two nodes (“fat edge”: the fact sentence lives on the edge).

Fields

id: Uuid

UUIDv7 identity.

src: Uuid

Source node id.

dst: Uuid

Destination node id.

rel: String

Relation label (e.g. "WORKS_AT").

fact: String

Natural-language fact sentence; FTS-indexed.

attrs: Value

Arbitrary JSON attributes.

group_id: String

Namespace.

valid_at: Option<TimestampMs>

Event time the fact became true; None = unknown / always.

invalid_at: Option<TimestampMs>

Event time the fact stopped being true, when already known at creation (e.g. the source text states the end). Unlike GraphOp::InvalidateEdge this is NOT a belief retraction and sets no expired_at — the fact was recorded with a bounded interval from the start.

AddEpisode

Record raw provenance (a chat turn, a document chunk, a sensor-event summary) and link it to the nodes/edges it mentions.

Fields

id: Uuid

UUIDv7 identity.

source: String

Where this came from (e.g. "chat", "doc:notes.md").

kind: String

Free-form source-kind tag (e.g. "message", "text", "json"). Opaque to grit — callers filter on it.

content: String

Raw text; FTS-indexed.

occurred_at: TimestampMs

Event time of the episode.

group_id: String

Namespace.

mentions: Vec<Uuid>

Node/edge ids this episode is provenance for.

UpdateNode

Revise a node’s entity metadata (Layer 2 decides the new values — summary refresh, name/label promotion; grit executes). None fields are untouched.

Each provided field is a last-writer-wins register: concurrent updates converge to the highest HLC per field, independently of apply order (recorded append-only in node_updates, folded into the node row — the same out-of-order machinery as edge invalidations). Prior values remain in the oplog; this is metadata revision with an audit trail, not fact mutation — facts live on edges and stay append-only (Design Invariant 4).

Deliberately cannot touch identity (id, group_id), lifecycle (expired_at, merged_into), or anything on edges.

Fields

id: Uuid

Node to update.

name: Option<String>

New display name, if changing.

summary: Option<String>

New summary, if changing.

kind: Option<String>

New entity kind, if changing.

attrs: Option<Value>

New attributes (whole-value replace — grit does not deep-merge; the caller composes the full object), if changing.

InvalidateEdge

Close an edge’s event-time interval: the fact stopped being true at invalid_at. Never deletes; concurrent invalidations converge to the minimum (earliest) time. The edge row’s expired_at is untouched (that means full belief retraction in grit’s read model); when the invalidation itself was learned is edge_invalidations.recorded_at.

Fields

edge_id: Uuid

Edge to invalidate.

invalid_at: TimestampMs

Event time the fact stopped holding.

MergeNodes

Fold node from into node into. Layer 2 decides whether (an LLM judgment); grit only executes. Re-points edges and mentions, marks from expired with a merged_into audit pointer.

Fields

from: Uuid

The node that disappears.

into: Uuid

The node that absorbs it.

Purge

Explicit, audited right-to-forget. The ONLY destructive op: hard-deletes and permanently tombstones exactly the listed ids (a tombstoned id can never be re-added, which is what makes purge commute with concurrent adds). List incident edge ids explicitly — their fact sentences carry the content being forgotten; crate::Grit::node_history enumerates them. The purge op itself stays in the oplog as the audit record.

Fields

ids: Vec<Uuid>

Node/edge/episode ids to erase.

Trait Implementations

impl Clone for GraphOp

fn clone(&self) -> GraphOp

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GraphOp

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for GraphOp

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for GraphOp

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for GraphOp

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 GraphOp