fix: repair rotted grpc feature caught by the new CI lane (#354)

The grpc feature did not compile at all: prost 0.14 vs tonic 0.13 Message
mismatch, tokio-stream missing from the feature list, and src/grpc.rs
drifted behind the Database/models APIs (Entity/RecallParams fields,
state_set signature, Stats field names, health_check, private
get_entity_by_id, moved-value in recall, and remember inserting an
empty id).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: tcconnally

Cargo.lock

@@ -45,9 +45,14 @@ ort = { version = "2.0.0-rc.12", optional = true, features = ["download-binaries
 # defaults) so tokenizer behavior is otherwise unchanged. (#222)
 tokenizers = { version = "0.23", optional = true, default-features = false, features = ["onig", "progressbar"] }
 ndarray = { version = "0.17", optional = true }  # MUST match the ndarray version ort rc.12 depends on, else our arrays are a different crate-version type and TensorArrayData (from_array_view) won't accept them (#212)
+# prost/prost-types MUST stay on the same minor as tonic's own prost dep
+# (tonic 0.13 -> prost 0.13): tonic-build's generated code derives OUR prost's
+# `Message`, but tonic's codec requires ITS prost's `Message` — mixing 0.14
+# with tonic 0.13 fails every RPC with "trait bound `X: prost::message::Message`
+# is not satisfied". Caught by the grpc CI lane (#354).
 tonic = { version = "0.13", optional = true, features = ["transport"] }
-prost = { version = "0.14", optional = true }
-prost-types = { version = "0.14", optional = true }
+prost = { version = "0.13", optional = true }
+prost-types = { version = "0.13", optional = true }
 tokio-stream = { version = "0.1", optional = true }
 
 # Optional: local multimodal document text extraction (#236). DOCX via `zip` +
@@ -64,7 +69,11 @@ pdf-extract = { version = "0.7", optional = true }
 # Build a lean binary without it via `cargo build --no-default-features`.
 default = ["bundled-embeddings"]
 bundled-embeddings = ["ort", "tokenizers", "ndarray"]
-grpc = ["tonic", "prost", "prost-types", "tonic-build"]
+# tokio-stream must be in this list: src/grpc.rs names it for the server
+# streaming types (WatchJournalStream/StreamContextStream). It was optional
+# but never wired to the feature, so the grpc build failed with
+# "unresolved module or unlinked crate `tokio_stream`" (#354).
+grpc = ["tonic", "prost", "prost-types", "tokio-stream", "tonic-build"]
 # Local document text extraction for mimir_ingest_file (DOCX/PDF). Opt-in.
 multimodal = ["zip", "pdf-extract"]
 

Cargo.toml

@@ -12,7 +12,7 @@ pub mod grpc {
     tonic::include_proto!("mneme.v1");
 
     use std::sync::{Arc, Mutex};
-    use tonic::{Request, Response, Status, Streaming};
+    use tonic::{Request, Response, Status};
 
     use crate::db::Database;
     use crate::models;
@@ -62,8 +62,13 @@ pub mod grpc {
         async fn remember(&self, req: Request<RememberRequest>) -> Result<Response<RememberResponse>, Status> {
             let r = req.into_inner();
             with_db(self, |db| {
+                // Same id convention as the MCP surface (handle_remember):
+                // db.remember does NOT generate ids — an empty id here would be
+                // inserted verbatim, producing an entity unreachable by id.
+                let raw_id = uuid::Uuid::new_v4().to_string().replace('-', "");
+                let id = format!("mem-{}", &raw_id[..12.min(raw_id.len())]);
                 let entity = models::Entity {
-                    id: String::new(),
+                    id,
                     category: r.category,
                     key: r.key,
                     body_json: r.body_json,
@@ -86,6 +91,10 @@ pub mod grpc {
                     visibility: r.visibility,
                     created_at_unix_ms: crate::db::now_ms(),
                     last_accessed_unix_ms: crate::db::now_ms(),
+                    follow_count: 0,
+                    miss_count: 0,
+                    follow_rate: 0.0,
+                    efficacy_status: "unverified".to_string(),
                     embedding: None,
                 };
                 let (id, action) = db.remember(&entity)?;
@@ -111,22 +120,28 @@ pub mod grpc {
                     preview_cap: r.preview_cap,
                     always_on: r.always_on,
                     content_weight: r.content_weight,
+                    trust_weight: 0.0,
                     diversity_halving: r.diversity_halving,
                     diversity_per_query_share: 0.0,
+                    recency_half_life_secs: None,
                     workspace_hash: r.workspace_hash,
                     agent_id: r.agent_id,
                     visibility: r.visibility,
+                    layer: None,
+                    reinforce: false,
                 };
                 let entities = db.recall(&params)?;
-                let items = entities.into_iter().map(|e| entity_to_proto(&e)).collect();
-                Ok(Response::new(RecallResponse { items, total: items.len() as i64 }))
+                let items: Vec<EntityMessage> =
+                    entities.iter().map(entity_to_proto).collect();
+                let total = items.len() as i64;
+                Ok(Response::new(RecallResponse { items, total }))
             })
         }
 
         async fn get_entity(&self, req: Request<GetEntityRequest>) -> Result<Response<EntityMessage>, Status> {
             let r = req.into_inner();
             with_db(self, |db| {
-                let entity = db.get_entity_by_id(&r.id)
+                let entity = db.get_entity_by_id_public(&r.id)
                     .map_err(|_| Status::not_found("entity not found"))?
                     .ok_or_else(|| Status::not_found("entity not found"))?;
                 Ok(Response::new(entity_to_proto(&entity)))
@@ -181,7 +196,15 @@ pub mod grpc {
         async fn state_set(&self, req: Request<StateSetRequest>) -> Result<Response<StateSetResponse>, Status> {
             let r = req.into_inner();
             with_db(self, |db| {
-                db.state_set(&r.key, &r.value_json, r.ttl_seconds.map(|t| t as i64))?;
+                let now = crate::db::now_ms();
+                let entry = models::StateEntry {
+                    key: r.key,
+                    value_json: r.value_json,
+                    // Same TTL convention as the MCP surface (handle_state_set).
+                    expires_at_unix_ms: r.ttl_seconds.map(|ttl| now + (ttl as i64) * 1000),
+                    created_at_unix_ms: now,
+                };
+                db.state_set(&entry)?;
                 Ok(Response::new(StateSetResponse { ok: true }))
             })
         }
@@ -198,18 +221,17 @@ pub mod grpc {
         // ── Ops ──
         async fn health(&self, _req: Request<HealthRequest>) -> Result<Response<HealthResponse>, Status> {
             with_db(self, |db| {
-                db.health()?;
-                Ok(Response::new(HealthResponse { healthy: true }))
+                Ok(Response::new(HealthResponse { healthy: db.health_check() }))
             })
         }
         async fn stats(&self, _req: Request<StatsRequest>) -> Result<Response<StatsResponse>, Status> {
             with_db(self, |db| {
                 let s = db.stats()?;
                 Ok(Response::new(StatsResponse {
                     total_entities: s.total_entities,
-                    total_journal: s.total_journal,
-                    total_state: s.total_state,
-                    db_size_bytes: s.db_size_bytes,
+                    total_journal: s.total_journal_events,
+                    total_state: s.total_state_entries,
+                    db_size_bytes: s.db_file_size_bytes as i64,
                 }))
             })
         }
@@ -378,6 +400,10 @@ pub mod grpc {
                 visibility: "workspace".to_string(),
                 created_at_unix_ms: 1,
                 last_accessed_unix_ms: 2,
+                follow_count: 0,
+                miss_count: 0,
+                follow_rate: 0.0,
+                efficacy_status: "unverified".to_string(),
                 embedding: None,
             };
             let p = entity_to_proto(&e);