Struct SignableWrite 

pub struct SignableWrite<'a> {
    pub agent_id: &'a str,
    pub namespace: &'a str,
    pub title: &'a str,
    pub kind: &'a str,
    pub created_at: &'a str,
    pub content_sha256: &'a [u8; 32],
}

The six fields the store-path write signature commits to.

Decoupled from crate::models::Memory on purpose: the signed bundle pins exactly the identity-bearing surface of a write (who, where, what title, what content, what kind, when) without dragging the full Memory shape — so the verifier can re-derive the bytes directly from the persisted row, and the canonical encoder has a single, audited shape to commit to.

content_sha256 is the SHA-256 of the UTF-8 bytes of the memory content (the same string that lands in memories.content). Hashing it before signing keeps the canonical payload bounded regardless of body length — a multi-kilobyte memory would otherwise dominate the signed envelope and inflate every signed_events.payload_hash recomputation.

Fields

agent_id: &'a str

The claiming agent’s id. This is the field the attestation gate exists to bind: the signature proves the signer held the keypair registered to this id, upgrading the write from claimed to attested.

namespace: &'a str

Namespace the write targets.

title: &'a str

Memory title (the (title, namespace) pair is the upsert key, so it is identity-bearing and must be inside the signed surface).

kind: &'a str

Memory kind discriminant (e.g. "fact", "plan"). Pinned so a signature minted for one kind cannot be replayed onto another.

created_at: &'a str

RFC3339 creation timestamp pinned at insert time. Inside the signed surface so a captured signature cannot be replayed to back- or forward-date a write.

content_sha256: &'a [u8; 32]

SHA-256 (32 bytes) over the rendered memory content’s UTF-8 bytes. Bounds the signed payload size.

Trait Implementations

impl<'a> Clone for SignableWrite<'a>

fn clone(&self) -> SignableWrite<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for SignableWrite<'a>

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

Formats the value using the given formatter.

impl<'a> Eq for SignableWrite<'a>

impl<'a> PartialEq for SignableWrite<'a>

fn eq(&self, other: &SignableWrite<'a>) -> 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<'a> StructuralPartialEq for SignableWrite<'a>