feat(memory): dual-pool memory namespace, FTS search, and prompt injection

Add a virtual memory namespace backed by SQLite, surfaced through the
fs-tools, with private (per-user) and shared (system) stores.

Storage
- `memory_docs` owner table + external-content FTS5 index with sync triggers.
- `db/memory_docs.rs` accessor: get / upsert / list / search (bm25+snippet) / delete.

Routing (tools/fs)
- `classify_memory` splits paths on the raw first component; `..` clamps inside
  the store, never escaping to disk.
- read/write/list/edit/insert/replace/search_file route `user-memory/` to the
  owner pool and `shared-memory/` to the system pool (a singleton captured in
  `register_all`); every other path stays on disk. Each tool extracts a pure
  transform shared between its disk and memory paths.
- New `memory_search` tool over the FTS index (scope private/shared/all),
  with a sanitised FTS5 query. grep_files stays disk-only.

Approval
- `user-memory/*` allow (read+write); `shared-memory/*` reads allow,
  writes require approval so the agent can't silently push one person's data
  into shared memory. `memory_search` allowed via a path-less rule.
- migrate away the old `memory/*` and blanket `shared-memory/*` rows.

Prompt injection
- `MessageBuilder::load_inject_memory` reads `user-memory/` (owner pool) and
  `shared-memory/` (system pool) inject entries from SQLite; disk paths
  unchanged. The system pool is threaded ChatSessionManager -> handler ->
  MessageBuilder.
- main and project-coordinator inject `user-memory/index.md` +
  `shared-memory/index.md`; common/memory.md rewritten for the two stores.

crates/skald-core/src/session/handler/message_builder.rs

@@ -34,6 +34,9 @@ fn system_timezone() -> Option<&'static str> {
 /// without needing the full handler and all its dependencies.
 pub struct MessageBuilder {
     pub pool:                  Arc<SqlitePool>,
+    /// The shared (`system.db`) pool, for injecting `shared-memory/` notes. The
+    /// owner `pool` above backs `user-memory/`.
+    pub shared_pool:           Arc<SqlitePool>,
     pub session_id:            i64,
     pub mcp:                   Arc<McpManager>,
     pub datetime_config:       DatetimeConfig,
@@ -93,9 +96,7 @@ impl MessageBuilder {
                  You can edit them with `edit_file` or `write_file` using the path shown.\n"
             );
             for mem_path in &meta.inject_memory {
-                // Resolve the entry to (absolute path to read, path to show the agent).
-                let (abs, display) = self.resolve_memory_path(mem_path);
-                let content = tokio::fs::read_to_string(&abs).await.ok();
+                let (content, display) = self.load_inject_memory(mem_path).await;
                 match content {
                     Some(c) => static_content.push_str(&format!(
                         "\n<memory_file path=\"{display}\">\n{c}\n</memory_file>\n"
@@ -405,6 +406,27 @@ impl MessageBuilder {
     /// when the file lives under it, absolute otherwise** — so when the agent references
     /// it back via `edit_file`/`write_file`, the loop's working-directory injection
     /// (which rewrites relative paths against the WD) resolves to the very same file.
+    /// Loads an `inject_memory` entry, returning `(content, display_path)`.
+    ///
+    /// Virtual memory paths are read from SQLite: `user-memory/…` from the owner
+    /// `pool`, `shared-memory/…` from the `shared_pool` (`system.db`). Everything
+    /// else (`data/…`, `$WD/…`) is an ordinary disk read. A missing note / file
+    /// yields `None`, rendered as "(file not created yet)".
+    async fn load_inject_memory(&self, mem_path: &str) -> (Option<String>, String) {
+        use crate::tools::fs::{classify_memory, MemScope};
+        if let Some(m) = classify_memory(mem_path) {
+            let pool = match m.scope {
+                MemScope::User   => &self.pool,
+                MemScope::Shared => &self.shared_pool,
+            };
+            let content = crate::db::memory_docs::get(pool, &m.rel)
+                .await.ok().flatten().map(|d| d.content);
+            return (content, mem_path.to_string());
+        }
+        let (abs, display) = self.resolve_memory_path(mem_path);
+        (tokio::fs::read_to_string(&abs).await.ok(), display)
+    }
+
     fn resolve_memory_path(&self, mem_path: &str) -> (std::path::PathBuf, String) {
         let wd = self.working_directory.clone()
             .unwrap_or_else(|| std::env::current_dir().unwrap_or_default());

crates/skald-core/src/session/handler/messages.rs

@@ -28,6 +28,7 @@ impl ChatSessionHandler {
             .map(|rc| rc.effective_working_dir());
         let builder = MessageBuilder {
             pool:                  Arc::clone(&self.db),
+            shared_pool:           Arc::clone(&self.shared_pool),
             session_id:            self.scratchpad_sid(),
             mcp:                   Arc::clone(&self.mcp),
             datetime_config:       self.datetime_config.clone(),

crates/skald-core/src/session/handler/mod.rs

@@ -262,6 +262,9 @@ impl ApprovalDecision {
 pub struct ChatSessionHandler {
     pub session_id:              i64,
     pub(super) db:               Arc<SqlitePool>,
+    /// The shared (`system.db`) pool. Owner-bound work uses `db`; this is only for
+    /// cross-owner reads, e.g. injecting `shared-memory/` notes into the prompt.
+    pub(super) shared_pool:      Arc<SqlitePool>,
     /// The authenticated user who owns this session. Threaded into `ChatOptions`
     /// so the telemetry metadata row in `system.db` carries `user_id`.
     pub(super) user_id:          String,
@@ -332,6 +335,7 @@ impl ChatSessionHandler {
     pub fn new(
         session_id:            i64,
         db:                    Arc<SqlitePool>,
+        shared_pool:           Arc<SqlitePool>,
         user_id:               String,
         llm_manager:           Arc<LlmManager>,
         max_history_messages:  usize,
@@ -357,6 +361,7 @@ impl ChatSessionHandler {
         Self {
             session_id,
             db,
+            shared_pool,
             user_id,
             llm_manager,
             max_history_messages,

crates/skald-core/src/session/manager.rs

@@ -22,6 +22,9 @@ use super::handler::ChatSessionHandler;
 
 pub struct ChatSessionManager {
     db:                    Arc<SqlitePool>,
+    /// The shared (`system.db`) pool, threaded to each handler for cross-owner
+    /// reads such as injecting `shared-memory/` notes.
+    shared_pool:           Arc<SqlitePool>,
     user_id:               String,
     llm_manager:           Arc<LlmManager>,
     max_history_messages:  usize,
@@ -48,6 +51,7 @@ pub struct ChatSessionManager {
 impl ChatSessionManager {
     pub fn new(
         db:                    Arc<SqlitePool>,
+        shared_pool:           Arc<SqlitePool>,
         user_id:               String,
         llm_manager:           Arc<LlmManager>,
         max_history_messages:  usize,
@@ -68,6 +72,7 @@ impl ChatSessionManager {
     ) -> Self {
         Self {
             db,
+            shared_pool,
             user_id,
             llm_manager,
             max_history_messages,
@@ -155,6 +160,7 @@ impl ChatSessionManager {
         let handler = Arc::new(ChatSessionHandler::new(
             session_id,
             self.db.clone(),
+            self.shared_pool.clone(),
             self.user_id.clone(),
             Arc::clone(&self.llm_manager),
             self.max_history_messages,