feat(runtime): update memory context integration with skill wiring system

Author: Akagi201

Cargo.toml

@@ -1,5 +1,5 @@
 [workspace.package]
-version = "0.1.2"
+version = "0.1.3"
 edition = "2024"
 license = "Apache-2.0"
 authors = ["Bob Liu <akagi201@gmail.com>"]
@@ -15,31 +15,32 @@ resolver = "3"
 
 [workspace.dependencies]
 # local crates
-alice-adapters = { path = "crates/alice-adapters", version = "0.1.2" }
-alice-cli = { path = "crates/alice-cli", version = "0.1.2" }
-alice-core = { path = "crates/alice-core", version = "0.1.2" }
-alice-runtime = { path = "crates/alice-runtime", version = "0.1.2" }
+alice-adapters = { path = "crates/alice-adapters", version = "0.1.3" }
+alice-cli = { path = "crates/alice-cli", version = "0.1.3" }
+alice-core = { path = "crates/alice-core", version = "0.1.3" }
+alice-runtime = { path = "crates/alice-runtime", version = "0.1.3" }
 
 # external crates
 agent-client-protocol = "0.10.4"
 async-trait = "0.1.89"
-bob-adapters = "0.3.1"
-bob-chat = "0.3.1"
-bob-core = "0.3.1"
-bob-runtime = "0.3.1"
-bob-skills = "0.3.1"
+bob-adapters = "0.3.2"
+bob-chat = "0.3.2"
+bob-core = "0.3.2"
+bob-runtime = "0.3.2"
+bob-skills = "0.3.2"
 clap = "4.6.0"
 config = "0.15.22"
 eyre = "0.6.12"
 futures-util = "0.3.32"
-liter-llm = "1.1.1"
+liter-llm = "1.2.0"
 parking_lot = "0.12.5"
 rusqlite = "0.39.0"
 serde = "1.0.228"
 serde_json = "1.0.149"
 sqlite-vec = "0.1.9"
+tempfile = "3.26.0"
 thiserror = "2.0.18"
-tokio = "1.50.0"
+tokio = "1.51.0"
 tokio-util = "0.7.18"
 tracing = "0.1.44"
 tracing-subscriber = "0.3.23"

bin/alice-cli/tests/alice_once_smoke.rs

@@ -385,7 +385,7 @@ async fn handle_input_with_skills_nl_input() {
     assert!(output.is_ok(), "handle_input_with_skills should succeed for NL input");
     let Ok(output) = output else { return };
     assert!(
-        matches!(output, AgentLoopOutput::CommandOutput(_)),
-        "NL input should return AgentLoopOutput::CommandOutput, got: {output:?}"
+        matches!(output, AgentLoopOutput::Response(_)),
+        "NL input should return AgentLoopOutput::Response, got: {output:?}"
     );
 }

crates/alice-adapters/Cargo.toml

@@ -31,3 +31,6 @@ tracing.workspace = true
 [features]
 discord = ["dep:serenity", "dep:eyre"]
 telegram = ["dep:teloxide", "dep:eyre"]
+
+[dev-dependencies]
+tempfile.workspace = true

crates/alice-adapters/src/memory/sqlite_store.rs

@@ -374,3 +374,137 @@ impl MemoryStorePort for SqliteMemoryStore {
         Ok(hits)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use alice_core::memory::domain::{HybridWeights, MemoryEntry, MemoryImportance, RecallQuery};
+    use tempfile::NamedTempFile;
+
+    use super::*;
+
+    fn create_temp_db() -> SqliteMemoryStore {
+        let temp_file = NamedTempFile::new().unwrap();
+        let path = temp_file.path();
+        SqliteMemoryStore::open(path, 384, true).unwrap()
+    }
+
+    #[test]
+    fn open_creates_schema() {
+        let store = create_temp_db();
+        // Should not panic - schema creation should work
+        let conn = store.conn.lock();
+        let count: i64 = conn
+            .query_row("SELECT COUNT(*) FROM sqlite_master WHERE type='table'", [], |row| {
+                row.get(0)
+            })
+            .unwrap();
+        assert!(count > 0, "schema should be created");
+    }
+
+    #[test]
+    fn insert_and_recall_memory() {
+        let store = create_temp_db();
+        let entry = MemoryEntry {
+            id: "test-id".to_string(),
+            session_id: "test-session".to_string(),
+            topic: "test topic".to_string(),
+            summary: "test summary".to_string(),
+            raw_excerpt: "The quick brown fox jumps over the lazy dog".to_string(),
+            keywords: vec!["test".to_string(), "fox".to_string()],
+            importance: MemoryImportance::Medium,
+            embedding: Some(vec![0.1, 0.2, 0.3]),
+            created_at_epoch_ms: 1234567890,
+        };
+
+        // Store the entry
+        store.insert(&entry).unwrap();
+
+        // Recall using hybrid search
+        let query = RecallQuery {
+            session_id: Some("test-session".to_string()),
+            text: "fox".to_string(),
+            query_embedding: None,
+            limit: 10,
+        };
+
+        let hits = store.recall_hybrid(&query, HybridWeights::default()).unwrap();
+        assert_eq!(hits.len(), 1);
+        assert_eq!(hits[0].entry.id, entry.id);
+        assert_eq!(hits[0].entry.raw_excerpt, entry.raw_excerpt);
+    }
+
+    #[test]
+    fn recall_with_different_queries() {
+        let store = create_temp_db();
+        let entry1 = MemoryEntry {
+            id: "test-1".to_string(),
+            session_id: "test-session".to_string(),
+            topic: "fox story".to_string(),
+            summary: "A story about a fox".to_string(),
+            raw_excerpt: "The quick brown fox jumps over the lazy dog".to_string(),
+            keywords: vec!["fox".to_string(), "dog".to_string()],
+            importance: MemoryImportance::High,
+            embedding: None,
+            created_at_epoch_ms: 1234567890,
+        };
+        let entry2 = MemoryEntry {
+            id: "test-2".to_string(),
+            session_id: "test-session".to_string(),
+            topic: "cat story".to_string(),
+            summary: "A story about cats".to_string(),
+            raw_excerpt: "A completely different story about cats".to_string(),
+            keywords: vec!["cat".to_string()],
+            importance: MemoryImportance::Medium,
+            embedding: None,
+            created_at_epoch_ms: 1234567891,
+        };
+
+        store.insert(&entry1).unwrap();
+        store.insert(&entry2).unwrap();
+
+        let query = RecallQuery {
+            session_id: Some("test-session".to_string()),
+            text: "fox".to_string(),
+            query_embedding: None,
+            limit: 10,
+        };
+
+        let hits = store.recall_hybrid(&query, HybridWeights::default()).unwrap();
+        assert_eq!(hits.len(), 1);
+        assert_eq!(hits[0].entry.id, "test-1");
+    }
+
+    #[test]
+    fn vector_disabled_fallback() {
+        let temp_path =
+            std::env::temp_dir().join(format!("alice-test-vector-{}.db", std::process::id()));
+        let store = SqliteMemoryStore::open(&temp_path, 384, false).unwrap();
+
+        let entry = MemoryEntry {
+            id: "test-vector-disabled".to_string(),
+            session_id: "test-session".to_string(),
+            topic: "vector test".to_string(),
+            summary: "test content".to_string(),
+            raw_excerpt: "test content".to_string(),
+            keywords: vec!["test".to_string()],
+            importance: MemoryImportance::Medium,
+            embedding: Some(vec![0.1, 0.2, 0.3]), // Embedding provided but vector disabled
+            created_at_epoch_ms: 1234567890,
+        };
+
+        // Should store successfully even with embedding when vector is disabled
+        store.insert(&entry).unwrap();
+
+        // Test recall still works with FTS only
+        let query = RecallQuery {
+            session_id: Some("test-session".to_string()),
+            text: "test".to_string(),
+            query_embedding: None,
+            limit: 10,
+        };
+
+        let hits = store.recall_hybrid(&query, HybridWeights::default()).unwrap();
+        assert_eq!(hits.len(), 1);
+        assert_eq!(hits[0].entry.id, "test-vector-disabled");
+    }
+}

crates/alice-runtime/src/handle_input.rs

@@ -2,12 +2,13 @@
 
 use bob_runtime::agent_loop::AgentLoopOutput;
 
-use crate::{context::AliceRuntimeContext, memory_context::run_turn_with_memory};
+use crate::context::AliceRuntimeContext;
 
 /// Handle a single user input with full pipeline: slash commands, skills, memory.
 ///
 /// For slash commands: delegates to `AgentLoop` for deterministic handling.
-/// For natural language: runs through `run_turn_with_memory` with skill injection.
+/// For natural language: uses `AgentLoop::handle_input_with_context` with injected memory and
+/// skills.
 ///
 /// # Errors
 ///
@@ -30,13 +31,73 @@ pub async fn handle_input_with_skills(
             Ok(output)
         }
         bob_runtime::router::RouteResult::NaturalLanguage(_) => {
-            // NL input: memory + skills + runtime via agent backend
-            let response = run_turn_with_memory(context, session_id, trimmed).await?;
-            if response.is_quit {
-                return Ok(AgentLoopOutput::Quit);
+            // NL input: inject memory + skills into RequestContext for AgentLoop
+            let recalled = match context.memory_service().recall_for_turn(session_id, trimmed) {
+                Ok(hits) => hits,
+                Err(error) => {
+                    tracing::warn!("memory recall failed: {error}");
+                    Vec::new()
+                }
+            };
+            let memory_prompt =
+                alice_core::memory::service::MemoryService::render_recall_context(&recalled);
+
+            let skills_bundle = context.skill_composer().map(|composer| {
+                crate::skill_wiring::inject_skills_context(
+                    composer,
+                    trimmed,
+                    context.skill_token_budget(),
+                )
+            });
+
+            // Compose system prompt: memory + skills
+            let mut system_parts = Vec::new();
+            if let Some(ref mem) = memory_prompt {
+                system_parts.push(mem.as_str());
+            }
+            if let Some(ref bundle) = skills_bundle &&
+                !bundle.prompt.is_empty()
+            {
+                system_parts.push(&bundle.prompt);
+            }
+            let system_prompt =
+                if system_parts.is_empty() { None } else { Some(system_parts.join("\n\n")) };
+
+            // Build request context with skills metadata
+            let (selected_skills, tool_policy) = if let Some(ref bundle) = skills_bundle {
+                let policy = if bundle.selected_allowed_tools.is_empty() {
+                    bob_core::types::RequestToolPolicy::default()
+                } else {
+                    bob_core::types::RequestToolPolicy {
+                        allow_tools: Some(bundle.selected_allowed_tools.clone()),
+                        ..bob_core::types::RequestToolPolicy::default()
+                    }
+                };
+                (bundle.selected_skill_names.clone(), policy)
+            } else {
+                (Vec::new(), bob_core::types::RequestToolPolicy::default())
+            };
+
+            let request_context =
+                bob_core::types::RequestContext { system_prompt, selected_skills, tool_policy };
+
+            // Use AgentLoop.handle_input_with_context for per-request context injection
+            let output = context
+                .agent_loop()
+                .handle_input_with_context(trimmed, session_id, request_context)
+                .await?;
+
+            // Handle memory persistence (AgentLoop doesn't do this automatically)
+            if let AgentLoopOutput::Response(response) = &output {
+                let bob_core::types::AgentRunResult::Finished(finished) = response;
+                if let Err(error) =
+                    context.memory_service().persist_turn(session_id, trimmed, &finished.content)
+                {
+                    tracing::warn!("memory persistence failed: {error}");
+                }
             }
-            // Convert bob_runtime::AgentResponse → AgentLoopOutput
-            Ok(AgentLoopOutput::CommandOutput(response.content))
+
+            Ok(output)
         }
     }
 }

crates/alice-runtime/src/memory_context.rs

@@ -7,6 +7,10 @@ use crate::context::AliceRuntimeContext;
 
 /// Execute one turn with memory-aware + skill-augmented prompt context.
 ///
+/// This function is primarily used for CLI commands that need direct agent backend access.
+/// For interactive chat scenarios, use `handle_input_with_skills` which properly integrates
+/// with AgentLoop and supports slash command routing.
+///
 /// # Errors
 ///
 /// Returns an error if the agent runtime fails to execute the turn.

crates/alice-runtime/src/skill_wiring.rs

@@ -1,4 +1,9 @@
 //! Skill system wiring: bootstrap + per-turn injection.
+//!
+//! Skills are integrated using Bob 0.3.2's AgentLoop.handle_input_with_context(),
+//! which supports per-request system prompt injection via RequestContext.
+//! This allows memory and skill context to be injected into each turn without
+//! bypassing the AgentLoop's slash command routing and tape recording features.
 
 use std::path::PathBuf;
 
@@ -34,6 +39,15 @@ pub fn build_skill_composer(cfg: &SkillsConfig) -> eyre::Result<Option<SkillProm
 /// Render skill context for a given user input.
 ///
 /// Returns the rendered prompt, selected skill names, and allowed tool list.
+/// This context is used with Bob 0.3.2's AgentLoop.handle_input_with_context()
+/// to inject per-request system prompts, selected skills, and tool policies.
+///
+/// # Returns
+///
+/// A [`RenderedSkillsPrompt`] containing:
+/// - `prompt`: Skill-augmented system prompt text
+/// - `selected_skill_names`: Names of skills selected for this input
+/// - `selected_allowed_tools`: Tool names that should be allowed for this turn
 pub fn inject_skills_context(
     composer: &SkillPromptComposer,
     input: &str,