fix(search): bypass BM25 for empty queries and show date-sorted results (#79)

Empty queries now use a dedicated browse_by_date() path that queries
SQLite directly with ORDER BY created_at, eliminating meaningless BM25
scores that caused stale/random result ordering.

- Add browse_by_date() and browse_by_date_sqlite() to SearchClient
- Route empty queries through date-sorted browse instead of BM25
- Add per-agent-type result quotas to prevent monopolization
- Re-fetch results when ranking mode cycles (date sort direction matters)
- Trigger initial search on startup so TUI populates immediately
- Update tests for new empty-query behavior

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

Author: Dicklesworthstone

src/search/query.rs

@@ -2980,6 +2980,118 @@ impl SearchClient {
         }
         Ok(hits)
     }
+
+    /// Browse messages ordered by date, without any text query.
+    ///
+    /// Used when the TUI query is empty and the user wants to see recent (or
+    /// oldest) sessions. Bypasses BM25 scoring entirely and returns results
+    /// ordered by `created_at`. Applies agent, workspace, time-range, and
+    /// source filters identically to the normal search path.
+    pub fn browse_by_date(
+        &self,
+        filters: SearchFilters,
+        limit: usize,
+        offset: usize,
+        newest_first: bool,
+    ) -> Result<Vec<SearchHit>> {
+        let sqlite_guard = self.sqlite_guard()?;
+        if let Some(conn) = sqlite_guard.as_ref() {
+            self.browse_by_date_sqlite(conn, filters, limit, offset, newest_first)
+        } else {
+            Ok(Vec::new())
+        }
+    }
+
+    fn browse_by_date_sqlite(
+        &self,
+        conn: &Connection,
+        filters: SearchFilters,
+        limit: usize,
+        offset: usize,
+        newest_first: bool,
+    ) -> Result<Vec<SearchHit>> {
+        let order = if newest_first { "DESC" } else { "ASC" };
+        let mut sql = format!(
+            "SELECT c.title, m.content, a.slug, w.path, c.source_path, m.created_at, m.idx
+             FROM messages m
+             JOIN conversations c ON m.conversation_id = c.id
+             JOIN agents a ON c.agent_id = a.id
+             LEFT JOIN workspaces w ON c.workspace_id = w.id
+             WHERE 1=1"
+        );
+        let mut params: Vec<Box<dyn rusqlite::ToSql>> = Vec::new();
+
+        if !filters.agents.is_empty() {
+            let placeholders = sql_placeholders(filters.agents.len());
+            sql.push_str(&format!(" AND a.slug IN ({placeholders})"));
+            for a in &filters.agents {
+                params.push(Box::new(a.clone()));
+            }
+        }
+
+        if !filters.workspaces.is_empty() {
+            let placeholders = sql_placeholders(filters.workspaces.len());
+            sql.push_str(&format!(" AND w.path IN ({placeholders})"));
+            for w in &filters.workspaces {
+                params.push(Box::new(w.clone()));
+            }
+        }
+
+        if let Some(created_from) = filters.created_from {
+            sql.push_str(" AND m.created_at >= ?");
+            params.push(Box::new(created_from));
+        }
+        if let Some(created_to) = filters.created_to {
+            sql.push_str(" AND m.created_at <= ?");
+            params.push(Box::new(created_to));
+        }
+
+        sql.push_str(&format!(
+            " ORDER BY m.created_at IS NULL, m.created_at {order}, m.id {order} LIMIT ? OFFSET ?"
+        ));
+        params.push(Box::new(limit as i64));
+        params.push(Box::new(offset as i64));
+
+        let mut stmt = conn.prepare(&sql)?;
+        let rows = stmt.query_map(
+            rusqlite::params_from_iter(params.iter().map(|b| &**b)),
+            |row| {
+                let title: String = row.get::<_, Option<String>>(0)?.unwrap_or_default();
+                let content: String = row.get(1)?;
+                let agent: String = row.get(2)?;
+                let workspace: Option<String> = row.get(3)?;
+                let source_path: String = row.get(4)?;
+                let created_at: Option<i64> = row.get(5).ok();
+                let idx: Option<i64> = row.get(6).ok();
+                let line_number = idx.map(|i| (i + 1) as usize);
+                let content_hash =
+                    stable_hit_hash(&content, &source_path, line_number, created_at);
+                Ok(SearchHit {
+                    title,
+                    snippet: String::new(),
+                    content,
+                    content_hash,
+                    score: 0.0,
+                    source_path,
+                    agent,
+                    workspace: workspace.unwrap_or_default(),
+                    workspace_original: None,
+                    created_at,
+                    line_number,
+                    match_type: MatchType::Exact,
+                    source_id: default_source_id(),
+                    origin_kind: default_origin_kind(),
+                    origin_host: None,
+                })
+            },
+        )?;
+
+        let mut hits = Vec::new();
+        for row in rows {
+            hits.push(row?);
+        }
+        Ok(hits)
+    }
 }
 
 /// Transpile a raw query string into an FTS5-compatible query string.

src/ui/app.rs

@@ -5414,13 +5414,37 @@ impl CassApp {
             };
             pane_map.entry(key).or_default().push(hit.clone());
         }
+
+        // Fix #79: Apply per-agent-type result quota so one agent type cannot
+        // monopolize all result slots. When `per_pane_limit` is set the user
+        // has an explicit cap; otherwise we apply a fair-share cap derived
+        // from the total result count divided across the number of groups.
+        let num_groups = pane_map.len().max(1);
+        let effective_limit = if self.per_pane_limit > 0 {
+            self.per_pane_limit
+        } else if num_groups > 1 {
+            // Fair share: total results / groups, with minimum floor to avoid
+            // showing too few results per pane.
+            let total: usize = pane_map.values().map(|v| v.len()).sum();
+            let fair = total / num_groups;
+            // At least 20 results per pane, or all of them if the total is small.
+            fair.max(20).max(total.min(50))
+        } else {
+            0 // single group: no cap
+        };
+
         self.panes = pane_map
             .into_iter()
             .map(|(key, hits)| {
                 let total = hits.len();
+                let capped = if effective_limit > 0 && hits.len() > effective_limit {
+                    hits.into_iter().take(effective_limit).collect()
+                } else {
+                    hits
+                };
                 AgentPane {
                     agent: key,
-                    hits,
+                    hits: capped,
                     selected: 0,
                     total_count: total,
                 }
@@ -12442,6 +12466,24 @@ impl SearchService for TantivySearchService {
         let started = Instant::now();
         let limit = params.limit;
         let offset = params.offset;
+
+        // Fix #79: Empty queries bypass BM25 and use date-sorted browsing.
+        // BM25 relevance scoring is meaningless without search terms, so we
+        // query SQLite directly with ORDER BY created_at instead.
+        if params.query.trim().is_empty() {
+            let newest_first = !matches!(params.ranking, RankingMode::DateOldest);
+            let hits = self
+                .client
+                .browse_by_date(params.filters.clone(), limit, offset, newest_first)
+                .map_err(|e| e.to_string())?;
+            return Ok(SearchResult {
+                hits,
+                elapsed_ms: started.elapsed().as_millis(),
+                suggestions: Vec::new(),
+                wildcard_fallback: false,
+            });
+        }
+
         let sparse_threshold = 3;
         let field_mask = FieldMask::new(true, true, true, true);
 
@@ -13813,12 +13855,9 @@ impl super::ftui_adapter::Model for CassApp {
                     limit: self.search_page_size.max(1),
                     offset: 0,
                 };
-                // Skip empty queries.
-                if params.query.trim().is_empty() {
-                    self.clear_loading_context(LoadingContext::Search);
-                    return ftui::Cmd::none();
-                }
                 // Dispatch async search if a service is available.
+                // Note: empty queries are allowed — the backend handles them
+                // by browsing recent sessions sorted by date (fix #79).
                 if let Some(svc) = self.search_service.clone() {
                     self.search_generation = generation;
                     self.search_backend_offset = 0;
@@ -13861,9 +13900,6 @@ impl super::ftui_adapter::Model for CassApp {
                     limit: self.search_page_size.max(1),
                     offset: self.search_backend_offset,
                 };
-                if params.query.trim().is_empty() {
-                    return ftui::Cmd::none();
-                }
                 if let Some(svc) = self.search_service.clone() {
                     self.search_in_flight = true;
                     self.status = format!("Loading more\u{2026} ({} loaded)", self.results.len());
@@ -14141,7 +14177,10 @@ impl super::ftui_adapter::Model for CassApp {
                     RankingMode::DateOldest => RankingMode::RecentHeavy,
                 };
                 self.dirty_since = Some(Instant::now());
-                ftui::Cmd::none()
+                // Fix #79: re-fetch results from backend so ranking mode
+                // changes are reflected (especially for empty-query date
+                // browsing where sort order matters).
+                ftui::Cmd::msg(CassMsg::SearchRequested)
             }
             CassMsg::ContextWindowCycled => {
                 self.context_window = match self.context_window {
@@ -15437,7 +15476,7 @@ impl super::ftui_adapter::Model for CassApp {
                     Self::markdown_filename_from_html(&export_state.filename_preview);
                 let output_path = unique_filename(&output_dir, &output_filename);
                 let include_tools = export_state.include_tools;
-                self.status = format!("Exporting markdown to {}", output_path.display());
+                self.status = "Exporting markdown...".to_string();
                 ftui::Cmd::task(move || {
                     export_session_markdown_task(&source_path, &output_path, include_tools)
                 })
@@ -15466,7 +15505,7 @@ impl super::ftui_adapter::Model for CassApp {
                     let include_tools = state.include_tools;
                     let title = state.title_preview.clone();
                     let agent_name = state.agent_name.clone();
-                    self.status = format!("Exporting HTML to {}", output_path.display());
+                    self.status = "Exporting HTML...".to_string();
 
                     // Dispatch the export as a background task.
                     return ftui::Cmd::task(move || {
@@ -16227,7 +16266,10 @@ impl super::ftui_adapter::Model for CassApp {
                     self.focus_manager.focus(focus_ids::HELP_OVERLAY);
                 }
                 self.dirty_since = None;
-                ftui::Cmd::none()
+                // Fix #79: Trigger an initial search/browse on startup so the
+                // TUI is populated with recent sessions immediately, even when
+                // the query is empty.
+                ftui::Cmd::msg(CassMsg::SearchRequested)
             }
             CassMsg::StateLoadFailed(err) => {
                 self.clear_loading_context(LoadingContext::StateLoad);
@@ -22884,7 +22926,8 @@ mod tests {
         app.search_dirty_since = Some(Instant::now());
         let _ = app.update(CassMsg::SearchRequested);
         assert!(app.search_dirty_since.is_none(), "dirty state should clear");
-        // No search dispatched (no service, query is empty whitespace)
+        // No service attached — no search dispatched. Empty queries are
+        // allowed by the handler (fix #79) but still require a service.
         assert!(app.status.is_empty());
         assert!(app.loading_context.is_none());
     }
@@ -24934,14 +24977,14 @@ mod tests {
         assert!(app.show_detail_modal, "detail modal should remain open");
         assert_eq!(app.detail_tab, DetailTab::Export);
         assert!(
-            app.status.starts_with("Exporting markdown to "),
-            "status should reflect quick markdown export, got: {}",
+            app.status == "Exporting markdown...",
+            "status should use generic in-flight text, got: {}",
             app.status
         );
     }
 
     #[test]
-    fn detail_modal_quick_markdown_export_status_uses_unique_filename() {
+    fn detail_modal_quick_markdown_export_status_stays_path_agnostic() {
         let tmp = tempfile::TempDir::new().expect("tempdir");
         let mut app = app_with_hits(1);
         app.show_detail_modal = true;
@@ -24961,8 +25004,8 @@ mod tests {
             "quick markdown export should dispatch a task"
         );
         assert!(
-            app.status.contains("collision_1.md"),
-            "status should reference deduped markdown filename, got: {}",
+            app.status == "Exporting markdown...",
+            "status should avoid precomputed output path, got: {}",
             app.status
         );
     }