feat(save_memory): enrich observations via LLM metadata and extract knowledge

Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-opencode)

Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai>

Author: Stranmor

crates/core/src/observation/mod.rs

@@ -25,6 +25,15 @@ use std::fmt;
 
 use serde::{Deserialize, Serialize};
 
+/// Extracted metadata fields for enriching save_memory observations.
+pub struct ObservationMetadata {
+    pub facts: Vec<String>,
+    pub concepts: Vec<Concept>,
+    pub keywords: Vec<String>,
+    pub files_read: Vec<String>,
+    pub files_modified: Vec<String>,
+}
+
 /// Ordinal position of a prompt within a session.
 ///
 /// Semantically distinct from token counts or other numeric identifiers —

crates/llm/src/ai_types.rs

@@ -124,3 +124,18 @@ pub struct ObservationJson {
 pub struct SummaryJson {
     pub summary: String,
 }
+
+/// LLM response for metadata enrichment of save_memory observations.
+#[derive(Deserialize)]
+pub struct MetadataJson {
+    #[serde(default, deserialize_with = "null_or_invalid_as_default_vec")]
+    pub facts: Vec<String>,
+    #[serde(default, deserialize_with = "null_or_invalid_as_default_vec")]
+    pub concepts: Vec<String>,
+    #[serde(default, deserialize_with = "null_or_invalid_as_default_vec")]
+    pub keywords: Vec<String>,
+    #[serde(default, deserialize_with = "null_or_invalid_as_default_vec")]
+    pub files_read: Vec<String>,
+    #[serde(default, deserialize_with = "null_or_invalid_as_default_vec")]
+    pub files_modified: Vec<String>,
+}

crates/llm/src/observation.rs

@@ -1,10 +1,13 @@
 use chrono::Utc;
 use opencode_mem_core::{
-    Concept, NoiseLevel, Observation, ObservationInput, ObservationType, sanitize_input,
+    Concept, NoiseLevel, Observation, ObservationInput, ObservationMetadata, ObservationType,
+    sanitize_input,
 };
 use std::str::FromStr as _;
 
-use crate::ai_types::{ChatRequest, Message, ObservationJson, ResponseFormat, ResponseFormatType};
+use crate::ai_types::{
+    ChatRequest, Message, MetadataJson, ObservationJson, ResponseFormat, ResponseFormatType,
+};
 use crate::client::LlmClient;
 use crate::compression_prompt::build_compression_prompt;
 use crate::error::LlmError;
@@ -176,4 +179,65 @@ impl LlmClient {
             &candidate_ids,
         )
     }
+
+    /// Extract structured metadata from an observation's title and narrative.
+    ///
+    /// # Errors
+    /// Returns an error if the API call or JSON parsing fails.
+    pub async fn enrich_observation_metadata(
+        &self,
+        title: &str,
+        narrative: &str,
+    ) -> Result<ObservationMetadata, LlmError> {
+        let prompt = format!(
+            "Extract structured metadata from this observation.\n\n\
+             Title: {title}\n\
+             Narrative: {narrative}\n\n\
+             Return JSON with these fields:\n\
+             - \"facts\": array of specific facts (file paths, function names, decisions, concrete details)\n\
+             - \"concepts\": array from [{concepts}]\n\
+             - \"keywords\": array of search keywords (3-8 terms)\n\
+             - \"files_read\": array of file paths mentioned as read/referenced\n\
+             - \"files_modified\": array of file paths mentioned as modified/created\n\n\
+             If a field has no relevant data, return an empty array.",
+            concepts = Concept::ALL_VARIANTS_STR,
+        );
+
+        let request = ChatRequest {
+            model: self.model(),
+            messages: vec![Message {
+                role: "user".to_owned(),
+                content: prompt,
+            }],
+            response_format: ResponseFormat {
+                format_type: ResponseFormatType::JsonObject,
+            },
+            max_tokens: None,
+        };
+
+        let response = self.chat_completion(&request).await?;
+        let stripped = opencode_mem_core::strip_markdown_json(&response);
+        let meta: MetadataJson =
+            serde_json::from_str(stripped).map_err(|e| LlmError::JsonParse {
+                context: format!(
+                    "metadata enrichment (content: {})",
+                    response.get(..300).unwrap_or(&response)
+                ),
+                source: e,
+            })?;
+
+        let concepts = meta
+            .concepts
+            .iter()
+            .filter_map(|s| Concept::from_str(s).ok())
+            .collect();
+
+        Ok(ObservationMetadata {
+            facts: meta.facts,
+            concepts,
+            keywords: meta.keywords,
+            files_read: meta.files_read,
+            files_modified: meta.files_modified,
+        })
+    }
 }

crates/service/src/observation_service/save_memory.rs

@@ -1,6 +1,7 @@
 //! Direct memory storage — bypasses LLM compression pipeline.
 
 use opencode_mem_core::{NoiseLevel, Observation, ObservationType, sanitize_input};
+use opencode_mem_storage::traits::ObservationStore;
 
 use super::{ObservationService, SaveMemoryResult};
 use crate::ServiceError;
@@ -42,13 +43,12 @@ impl ObservationService {
         }
 
         // Project filter check (Privacy)
-        if let Some(p) = project {
-            if let Some(ref filter) = self.project_filter {
-                if filter.is_excluded(p) {
-                    tracing::info!(project = %p, "Skipping save_memory — project is excluded by privacy policy");
-                    return Ok(SaveMemoryResult::Filtered);
-                }
-            }
+        if let Some(p) = project
+            && let Some(ref filter) = self.project_filter
+            && filter.is_excluded(p)
+        {
+            tracing::info!(project = %p, "Skipping save_memory — project is excluded by privacy policy");
+            return Ok(SaveMemoryResult::Filtered);
         }
 
         let title_str = match title {
@@ -92,8 +92,61 @@ impl ObservationService {
 
         let result = self.persist_and_notify(&obs, None).await?;
         match result {
-            Some((persisted_obs, _was_new)) => Ok(SaveMemoryResult::Created(persisted_obs)),
+            Some((persisted_obs, _was_new)) => {
+                self.spawn_enrichment(persisted_obs.clone());
+                Ok(SaveMemoryResult::Created(persisted_obs))
+            }
             None => Ok(SaveMemoryResult::Duplicate(obs)),
         }
     }
+
+    fn spawn_enrichment(&self, obs: Observation) {
+        let llm = self.llm.clone();
+        let storage = self.storage.clone();
+        let svc = self.clone();
+
+        tokio::spawn(async move {
+            let narrative = obs.narrative.as_deref().unwrap_or("");
+            if narrative.is_empty() && obs.title.is_empty() {
+                return;
+            }
+
+            match llm.enrich_observation_metadata(&obs.title, narrative).await {
+                Ok(metadata) => {
+                    let result = storage
+                        .guarded(|| storage.update_observation_metadata(obs.id.as_ref(), &metadata))
+                        .await;
+                    if let Err(e) = result {
+                        tracing::warn!(
+                            observation_id = %obs.id,
+                            error = %e,
+                            "Failed to persist enriched metadata"
+                        );
+                    } else {
+                        tracing::info!(
+                            observation_id = %obs.id,
+                            facts = metadata.facts.len(),
+                            keywords = metadata.keywords.len(),
+                            "Enriched save_memory observation with metadata"
+                        );
+                    }
+                }
+                Err(e) => {
+                    tracing::warn!(
+                        observation_id = %obs.id,
+                        error = %e,
+                        "LLM metadata enrichment failed"
+                    );
+                }
+            }
+
+            if let Err(e) = svc.extract_knowledge(&obs).await {
+                tracing::warn!(
+                    observation_id = %obs.id,
+                    error = %e,
+                    "Knowledge extraction failed for save_memory observation"
+                );
+            }
+        });
+    }
 }

crates/storage/src/pg_storage/observations.rs

@@ -5,7 +5,7 @@ use super::*;
 use crate::error::StorageError;
 use crate::traits::ObservationStore;
 use async_trait::async_trait;
-use opencode_mem_core::{Observation, SearchResult};
+use opencode_mem_core::{Observation, ObservationMetadata, SearchResult};
 
 impl PgStorage {
     async fn update_observation_fields(
@@ -372,4 +372,27 @@ impl ObservationStore for PgStorage {
         tx.commit().await?;
         Ok(())
     }
+
+    async fn update_observation_metadata(
+        &self,
+        id: &str,
+        metadata: &ObservationMetadata,
+    ) -> Result<(), StorageError> {
+        let concepts_str: Vec<String> = metadata.concepts.iter().map(|c| c.to_string()).collect();
+        sqlx::query(
+            "UPDATE observations \
+             SET facts = $1, concepts = $2, keywords = $3, \
+                 files_read = $4, files_modified = $5 \
+             WHERE id = $6",
+        )
+        .bind(serde_json::to_value(&metadata.facts)?)
+        .bind(serde_json::to_value(&concepts_str)?)
+        .bind(serde_json::to_value(&metadata.keywords)?)
+        .bind(serde_json::to_value(&metadata.files_read)?)
+        .bind(serde_json::to_value(&metadata.files_modified)?)
+        .bind(id)
+        .execute(&self.pool)
+        .await?;
+        Ok(())
+    }
 }

crates/storage/src/traits/observation.rs

@@ -1,5 +1,5 @@
 use async_trait::async_trait;
-use opencode_mem_core::{Observation, SearchResult};
+use opencode_mem_core::{Observation, ObservationMetadata, SearchResult};
 
 use crate::error::StorageError;
 
@@ -67,4 +67,12 @@ pub trait ObservationStore: Send + Sync {
         newer: &Observation,
         force_newer: bool,
     ) -> Result<(), StorageError>;
+
+    /// Update only metadata fields (facts, concepts, keywords, files_read, files_modified)
+    /// on an existing observation.
+    async fn update_observation_metadata(
+        &self,
+        id: &str,
+        metadata: &ObservationMetadata,
+    ) -> Result<(), StorageError>;
 }