fix: smarter person search + suppress llama.cpp logs

- context_who uses FTS search to find person notes instead of exact
  filename matching. Checks People folder, 'person' tag, then fuzzy
  filename. Works with hyphens, underscores, any vault structure.
- find_files_by_prefix added to Store for folder-scoped queries
- find_file_by_basename normalizes hyphens/underscores/spaces
- llama.cpp stderr logs suppressed via backend.void_logs()

Author: devwhodevs

src/context.rs

@@ -114,6 +114,60 @@ fn resolve_file(
     params.store.find_file_by_basename(file_or_docid)
 }
 
+/// Find a person note using engraph's full search pipeline (FTS + semantic + graph).
+/// Picks the best match from the People folder, or any note tagged "person".
+fn find_person_by_search(
+    params: &ContextParams,
+    name: &str,
+) -> Result<Option<crate::store::FileRecord>> {
+    // Use FTS to find candidates (lightweight, no embedder needed).
+    let fts_results = params.store.fts_search(name, 20).unwrap_or_default();
+
+    let people_folder = params
+        .profile
+        .and_then(|p| p.structure.folders.people.as_deref());
+    let name_normalized = name.to_lowercase().replace(['-', '_'], " ");
+
+    // Pass 1: prefer People folder matches.
+    if let Some(pf) = people_folder {
+        for result in &fts_results {
+            if let Some(file) = params.store.get_file_by_id(result.file_id)?
+                && file.path.starts_with(pf)
+            {
+                return Ok(Some(file));
+            }
+        }
+    }
+
+    // Pass 2: any note tagged "person"/"people".
+    for result in &fts_results {
+        if let Some(file) = params.store.get_file_by_id(result.file_id)?
+            && file.tags.iter().any(|t| t == "person" || t == "people")
+        {
+            return Ok(Some(file));
+        }
+    }
+
+    // Pass 3: filename fuzzy match (handles hyphens, underscores, case).
+    for result in &fts_results {
+        if let Some(file) = params.store.get_file_by_id(result.file_id)? {
+            let basename = file
+                .path
+                .rsplit('/')
+                .next()
+                .unwrap_or(&file.path)
+                .trim_end_matches(".md")
+                .to_lowercase()
+                .replace(['-', '_'], " ");
+            if basename == name_normalized {
+                return Ok(Some(file));
+            }
+        }
+    }
+
+    Ok(None)
+}
+
 /// Split content into (frontmatter YAML, body) parts.
 fn split_frontmatter(content: &str) -> (String, String) {
     let trimmed = content.trim_start();
@@ -266,9 +320,13 @@ pub fn vault_map(params: &ContextParams) -> Result<VaultMap> {
 
 /// Build a person context bundle: note content, mentions, wikilink connections.
 pub fn context_who(params: &ContextParams, name: &str) -> Result<PersonContext> {
+    // Try to find the person note: exact resolve first, then search People folder.
     let (note, person_id) = if let Some(pf) = resolve_file(params, name)? {
         let n = context_read(params, &pf.path)?;
         (Some(n), Some(pf.id))
+    } else if let Some(pf) = find_person_by_search(params, name)? {
+        let n = context_read(params, &pf.path)?;
+        (Some(n), Some(pf.id))
     } else {
         (None, None)
     };

src/llm.rs

@@ -28,8 +28,10 @@ pub fn llama_backend() -> Result<&'static LlamaBackend> {
     if let Some(b) = BACKEND.get() {
         return Ok(b);
     }
-    let backend =
+    let mut backend =
         LlamaBackend::init().map_err(|e| anyhow::anyhow!("initializing llama backend: {e}"))?;
+    // Suppress llama.cpp's noisy Metal/model loading logs to stderr.
+    backend.void_logs();
     Ok(BACKEND.get_or_init(|| backend))
 }
 

src/store.rs

@@ -1086,24 +1086,13 @@ impl Store {
         Ok(map)
     }
 
-    /// Find a file by case-insensitive basename match. Returns first match (shortest path).
-    pub fn find_file_by_basename(&self, basename: &str) -> Result<Option<FileRecord>> {
-        let target = if basename.ends_with(".md") {
-            basename.to_string()
-        } else {
-            format!("{}.md", basename)
-        };
-        // Try exact path first
-        if let Some(f) = self.get_file(&target)? {
-            return Ok(Some(f));
-        }
-        // Basename match via SQL
+    /// Find all files whose path matches a LIKE pattern (e.g., "03-Resources/People/%").
+    pub fn find_files_by_prefix(&self, pattern: &str) -> Result<Vec<FileRecord>> {
         let mut stmt = self.conn.prepare(
-            "SELECT id, path, content_hash, mtime, tags, indexed_at, docid, created_by FROM files
-             WHERE lower(path) LIKE '%/' || lower(?1) OR lower(path) = lower(?1)
-             ORDER BY length(path) ASC LIMIT 1",
+            "SELECT id, path, content_hash, mtime, tags, indexed_at, docid, created_by
+             FROM files WHERE path LIKE ?1",
         )?;
-        let mut rows = stmt.query_map(params![target], |row| {
+        let rows = stmt.query_map(params![pattern], |row| {
             Ok(FileRecord {
                 id: row.get(0)?,
                 path: row.get(1)?,
@@ -1115,10 +1104,65 @@ impl Store {
                 created_by: row.get(7)?,
             })
         })?;
-        match rows.next() {
-            Some(r) => Ok(Some(r?)),
-            None => Ok(None),
+        rows.collect::<rusqlite::Result<Vec<_>>>()
+            .map_err(|e| anyhow::anyhow!("find_files_by_prefix: {e}"))
+    }
+
+    /// Find a file by case-insensitive basename match. Returns first match (shortest path).
+    pub fn find_file_by_basename(&self, basename: &str) -> Result<Option<FileRecord>> {
+        let base = if basename.ends_with(".md") {
+            basename.to_string()
+        } else {
+            format!("{basename}.md")
+        };
+
+        // Try exact path first.
+        if let Some(f) = self.get_file(&base)? {
+            return Ok(Some(f));
+        }
+
+        // Build candidate names: exact, spaces→hyphens, hyphens→spaces, spaces→underscores.
+        let normalized = basename.replace(['-', '_'], " ");
+        let hyphenated = basename.replace(' ', "-");
+        let underscored = basename.replace(' ', "_");
+        let mut candidates = vec![base];
+        for v in [normalized, hyphenated, underscored] {
+            let c = if v.ends_with(".md") {
+                v
+            } else {
+                format!("{v}.md")
+            };
+            if !candidates.contains(&c) {
+                candidates.push(c);
+            }
         }
+
+        // Try each candidate as a case-insensitive basename match.
+        for candidate in &candidates {
+            let mut stmt = self.conn.prepare(
+                "SELECT id, path, content_hash, mtime, tags, indexed_at, docid, created_by
+                 FROM files
+                 WHERE lower(path) LIKE '%/' || lower(?1) OR lower(path) = lower(?1)
+                 ORDER BY length(path) ASC LIMIT 1",
+            )?;
+            let mut rows = stmt.query_map(params![candidate], |row| {
+                Ok(FileRecord {
+                    id: row.get(0)?,
+                    path: row.get(1)?,
+                    content_hash: row.get(2)?,
+                    mtime: row.get(3)?,
+                    tags: parse_tags(&row.get::<_, String>(4)?),
+                    indexed_at: row.get(5)?,
+                    docid: row.get(6)?,
+                    created_by: row.get(7)?,
+                })
+            })?;
+            if let Some(row) = rows.next() {
+                return Ok(Some(row?));
+            }
+        }
+
+        Ok(None)
     }
 
     /// Rename a file's path in the store, preserving its row ID (and thus edge integrity).