provenance: convert from enum to freeform string

The Provenance enum couldn't represent agents defined outside the
source code. Replace it with a Text field in the capnp schema so any
agent can write its own provenance label (e.g. "extractor:write",
"rename:tombstone") without a code change.

Schema: rename old enum fields to provenanceOld, add new Text
provenance fields. Old enum kept for reading legacy records.
Migration: from_capnp_migrate() falls back to old enum when the
new text field is empty.

Also adds `poc-memory tail` command for viewing recent store writes.

Co-Authored-By: ProofOfConcept <poc@bcachefs.org>

poc-memory/src/store/ops.rs

@@ -37,13 +37,15 @@ impl Store {
     /// Provenance is determined by the POC_PROVENANCE env var if set,
     /// otherwise defaults to Manual.
     pub fn upsert(&mut self, key: &str, content: &str) -> Result<&'static str, String> {
-        let prov = Provenance::from_env().unwrap_or(Provenance::Manual);
-        self.upsert_provenance(key, content, prov)
+        let prov = Provenance::from_env()
+            .map(|p| p.label().to_string())
+            .unwrap_or_else(|| "manual".to_string());
+        self.upsert_provenance(key, content, &prov)
     }
 
     /// Upsert with explicit provenance (for agent-created nodes).
     /// Holds StoreLock across refresh + check + write to prevent duplicate UUIDs.
-    pub fn upsert_provenance(&mut self, key: &str, content: &str, provenance: Provenance) -> Result<&'static str, String> {
+    pub fn upsert_provenance(&mut self, key: &str, content: &str, provenance: &str) -> Result<&'static str, String> {
         let _lock = StoreLock::acquire()?;
         self.refresh_nodes()?;
 
@@ -53,14 +55,14 @@ impl Store {
             }
             let mut node = existing.clone();
             node.content = content.to_string();
-            node.provenance = provenance;
+            node.provenance = provenance.to_string();
             node.version += 1;
             self.append_nodes_unlocked(std::slice::from_ref(&node))?;
             self.nodes.insert(key.to_string(), node);
             Ok("updated")
         } else {
             let mut node = new_node(key, content);
-            node.provenance = provenance;
+            node.provenance = provenance.to_string();
             self.append_nodes_unlocked(std::slice::from_ref(&node))?;
             self.uuid_to_key.insert(node.uuid, node.key.clone());
             self.nodes.insert(key.to_string(), node);

poc-memory/src/store/persist.rs

@@ -117,7 +117,7 @@ impl Store {
                 .map_err(|e| format!("read node log: {}", e))?;
             for node_reader in log.get_nodes()
                 .map_err(|e| format!("get nodes: {}", e))? {
-                let node = Node::from_capnp(node_reader)?;
+                let node = Node::from_capnp_migrate(node_reader)?;
                 let existing_version = self.nodes.get(&node.key)
                     .map(|n| n.version)
                     .unwrap_or(0);
@@ -164,7 +164,7 @@ impl Store {
                 .map_err(|e| format!("read relation log: {}", e))?;
             for rel_reader in log.get_relations()
                 .map_err(|e| format!("get relations: {}", e))? {
-                let rel = Relation::from_capnp(rel_reader)?;
+                let rel = Relation::from_capnp_migrate(rel_reader)?;
                 let existing_version = by_uuid.get(&rel.uuid)
                     .map(|r| r.version)
                     .unwrap_or(0);
@@ -199,7 +199,7 @@ impl Store {
                 .map_err(|e| format!("read node log: {}", e))?;
             for node_reader in log.get_nodes()
                 .map_err(|e| format!("get nodes: {}", e))? {
-                let node = Node::from_capnp(node_reader)?;
+                let node = Node::from_capnp_migrate(node_reader)?;
                 let dominated = by_uuid.get(&node.uuid)
                     .map(|n| node.version >= n.version)
                     .unwrap_or(true);
@@ -276,7 +276,7 @@ impl Store {
                 .map_err(|e| format!("read node log delta: {}", e))?;
             for node_reader in log.get_nodes()
                 .map_err(|e| format!("get nodes delta: {}", e))? {
-                let node = Node::from_capnp(node_reader)?;
+                let node = Node::from_capnp_migrate(node_reader)?;
                 let dominated = self.nodes.get(&node.key)
                     .map(|n| node.version >= n.version)
                     .unwrap_or(true);

poc-memory/src/store/types.rs

@@ -190,7 +190,7 @@ pub struct Node {
     pub version: u32,
     pub timestamp: i64,
     pub node_type: NodeType,
-    pub provenance: Provenance,
+    pub provenance: String,
     pub key: String,
     pub content: String,
     pub weight: f32,
@@ -233,7 +233,7 @@ pub struct Relation {
     pub target: [u8; 16],
     pub rel_type: RelationType,
     pub strength: f32,
-    pub provenance: Provenance,
+    pub provenance: String,
     pub deleted: bool,
     pub source_key: String,
     pub target_key: String,
@@ -338,25 +338,51 @@ capnp_enum!(RelationType, memory_capnp::RelationType,
 capnp_message!(Node,
     reader: memory_capnp::content_node::Reader<'_>,
     builder: memory_capnp::content_node::Builder<'_>,
-    text: [key, content, source_ref, created, state_tag],
+    text: [key, content, source_ref, created, state_tag, provenance],
     uuid: [uuid],
     prim: [version, timestamp, weight, emotion, deleted,
            retrievals, uses, wrongs, last_replayed,
            spaced_repetition_interval, position, created_at],
-    enm:  [node_type: NodeType, provenance: Provenance],
+    enm:  [node_type: NodeType],
     skip: [community_id, clustering_coefficient, degree],
 );
 
+impl Node {
+    /// Read from capnp with migration: if the new provenance text field
+    /// is empty (old record), fall back to the deprecated provenanceOld enum.
+    pub fn from_capnp_migrate(r: memory_capnp::content_node::Reader<'_>) -> Result<Self, String> {
+        let mut node = Self::from_capnp(r)?;
+        if node.provenance.is_empty() {
+            if let Ok(old) = r.get_provenance_old() {
+                node.provenance = Provenance::from_capnp(old).label().to_string();
+            }
+        }
+        Ok(node)
+    }
+}
+
 capnp_message!(Relation,
     reader: memory_capnp::relation::Reader<'_>,
     builder: memory_capnp::relation::Builder<'_>,
-    text: [source_key, target_key],
+    text: [source_key, target_key, provenance],
     uuid: [uuid, source, target],
     prim: [version, timestamp, strength, deleted],
-    enm:  [rel_type: RelationType, provenance: Provenance],
+    enm:  [rel_type: RelationType],
     skip: [],
 );
 
+impl Relation {
+    pub fn from_capnp_migrate(r: memory_capnp::relation::Reader<'_>) -> Result<Self, String> {
+        let mut rel = Self::from_capnp(r)?;
+        if rel.provenance.is_empty() {
+            if let Ok(old) = r.get_provenance_old() {
+                rel.provenance = Provenance::from_capnp(old).label().to_string();
+            }
+        }
+        Ok(rel)
+    }
+}
+
 #[derive(Clone, Debug, Serialize, Deserialize, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)]
 #[archive(check_bytes)]
 pub struct RetrievalEvent {
@@ -480,7 +506,7 @@ pub fn new_node(key: &str, content: &str) -> Node {
         version: 1,
         timestamp: now_epoch(),
         node_type: NodeType::Semantic,
-        provenance: Provenance::Manual,
+        provenance: "manual".to_string(),
         key: key.to_string(),
         content: content.to_string(),
         weight: 0.7,
@@ -551,7 +577,7 @@ pub fn new_relation(
         target: target_uuid,
         rel_type,
         strength,
-        provenance: Provenance::Manual,
+        provenance: "manual".to_string(),
         deleted: false,
         source_key: source_key.to_string(),
         target_key: target_key.to_string(),