feat(dashboard): bulk memory selection with collapsible categories (closes #28)

Issue #28 requested a selectable table in the Memory page with
select/delete/archive and select-all operations. This extends that
request with collapsible category groups (navigation for users with
100+ memories across many categories).

Multi-select model:
  - Checkbox per memory row
  - Tri-state checkbox per category (none / some / all)
  - Tri-state "select all visible" in the bulk-action bar
  - Selection resets automatically when filters change so bulk actions
    can't silently target hidden memories.

Bulk actions:
  - Archive (reversible, flips status to 'archived')
  - Delete (destructive, confirms count)
  Both run in one SQLite transaction per action, not a frontend loop,
  so 100+ memories clear in a single round-trip without partial-failure
  states. Count-based ask() confirmation.

Collapsible categories:
  - Chevron on the right side of each category header rotates when
    collapsed
  - Entire header is clickable; tri-state checkbox is a nested
    stopPropagation region
  - Collapse state persisted per-dashboard in localStorage
    (mc.memory.collapsedCategories.v1) so navigation focus survives
    reload. Versioned key so future schema changes can't poison old
    clients.
  - Expand all / Collapse all links above the list.

Rust commands (packages/dashboard/src-tauri/src):
  - db::bulk_update_memory_status - IN (?,...) under one transaction
  - db::bulk_delete_memory - explicit memory_embeddings DELETE first,
    then memories; documents intent even though the FK would cascade
  - commands::bulk_update_memory_status /
    commands::bulk_delete_memory - thin Tauri wrappers
  - main.rs registers both invoke handlers

Frontend (packages/dashboard/src):
  - lib/api.ts: bulkUpdateMemoryStatus / bulkDeleteMemory
  - components/MemoryBrowser/MemoryBrowser.tsx: full rewrite with
    selection + collapse state. Local TriStateCheckbox uses a ref
    + createEffect to set indeterminate (Solid doesn't bind it
    declaratively).
  - styles.css: chevron rotation, checkbox column, sticky bulk-action
    bar (only rendered when >=1 selected), memory card layout with
    checkbox gutter, tri-state checkbox styling with explicit check
    and dash marks.

Verified: cargo check clean, frontend build clean, bunx tsc clean,
plugin test suite still passes (no plugin changes).

Author: ualtinok

packages/dashboard/src-tauri/src/commands.rs

@@ -73,6 +73,27 @@ pub fn delete_memory(state: State<'_, AppState>, memory_id: i64) -> Result<(), S
     db::delete_memory(&conn, memory_id).map_err(|e| e.to_string())
 }
 
+#[tauri::command]
+pub fn bulk_update_memory_status(
+    state: State<'_, AppState>,
+    memory_ids: Vec<i64>,
+    status: String,
+) -> Result<usize, String> {
+    let path = state.get_db_path()?;
+    let mut conn = db::open_readwrite(&path).map_err(|e| e.to_string())?;
+    db::bulk_update_memory_status(&mut conn, &memory_ids, &status).map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+pub fn bulk_delete_memory(
+    state: State<'_, AppState>,
+    memory_ids: Vec<i64>,
+) -> Result<usize, String> {
+    let path = state.get_db_path()?;
+    let mut conn = db::open_readwrite(&path).map_err(|e| e.to_string())?;
+    db::bulk_delete_memory(&mut conn, &memory_ids).map_err(|e| e.to_string())
+}
+
 // ── Session commands ────────────────────────────────────────
 
 #[tauri::command]

packages/dashboard/src-tauri/src/db.rs

@@ -1281,6 +1281,81 @@ pub fn delete_memory(conn: &Connection, memory_id: i64) -> Result<(), rusqlite::
     Ok(())
 }
 
+/// Bulk-update status for a set of memory IDs in one transaction.
+///
+/// We assemble an `IN (?,?,...)` clause dynamically because rusqlite has no
+/// first-class array binding. IDs are integers so SQL-injection is not a
+/// concern; each ID is still bound as a parameter.
+///
+/// Empty input is a no-op and returns 0 (affected rows).
+pub fn bulk_update_memory_status(
+    conn: &mut Connection,
+    memory_ids: &[i64],
+    new_status: &str,
+) -> Result<usize, rusqlite::Error> {
+    if memory_ids.is_empty() {
+        return Ok(0);
+    }
+
+    let now = chrono::Utc::now().timestamp_millis();
+    let placeholders = memory_ids.iter().map(|_| "?").collect::<Vec<_>>().join(",");
+    let sql = format!(
+        "UPDATE memories SET status = ?1, updated_at = ?2 WHERE id IN ({})",
+        placeholders,
+    );
+
+    let tx = conn.transaction()?;
+    let affected = {
+        let mut stmt = tx.prepare(&sql)?;
+        let mut params: Vec<&dyn rusqlite::ToSql> = Vec::with_capacity(2 + memory_ids.len());
+        params.push(&new_status as &dyn rusqlite::ToSql);
+        params.push(&now as &dyn rusqlite::ToSql);
+        for id in memory_ids {
+            params.push(id as &dyn rusqlite::ToSql);
+        }
+        stmt.execute(&params[..])?
+    };
+    tx.commit()?;
+    Ok(affected)
+}
+
+/// Bulk-delete memories and their embeddings in one transaction.
+///
+/// Deletes from `memory_embeddings` first, then `memories`. Though
+/// `memory_embeddings.memory_id` has a foreign key, we don't rely on
+/// cascade delete here — explicit delete keeps the intent readable and
+/// matches what single `delete_memory` implicitly gets via the FK.
+pub fn bulk_delete_memory(
+    conn: &mut Connection,
+    memory_ids: &[i64],
+) -> Result<usize, rusqlite::Error> {
+    if memory_ids.is_empty() {
+        return Ok(0);
+    }
+
+    let placeholders = memory_ids.iter().map(|_| "?").collect::<Vec<_>>().join(",");
+
+    let tx = conn.transaction()?;
+    // Explicitly clear embeddings first; the FK would handle this too but
+    // being explicit documents the intent and matches single-row delete logs.
+    {
+        let sql = format!("DELETE FROM memory_embeddings WHERE memory_id IN ({})", placeholders);
+        let mut stmt = tx.prepare(&sql)?;
+        let params: Vec<&dyn rusqlite::ToSql> =
+            memory_ids.iter().map(|id| id as &dyn rusqlite::ToSql).collect();
+        stmt.execute(&params[..])?;
+    }
+    let affected = {
+        let sql = format!("DELETE FROM memories WHERE id IN ({})", placeholders);
+        let mut stmt = tx.prepare(&sql)?;
+        let params: Vec<&dyn rusqlite::ToSql> =
+            memory_ids.iter().map(|id| id as &dyn rusqlite::ToSql).collect();
+        stmt.execute(&params[..])?
+    };
+    tx.commit()?;
+    Ok(affected)
+}
+
 // ── Session queries ─────────────────────────────────────────
 
 pub fn get_sessions(conn: &Connection) -> Result<Vec<SessionSummary>, rusqlite::Error> {

packages/dashboard/src-tauri/src/main.rs

@@ -34,6 +34,8 @@ fn main() {
             commands::update_memory_status,
             commands::update_memory_content,
             commands::delete_memory,
+            commands::bulk_update_memory_status,
+            commands::bulk_delete_memory,
             // Sessions
             commands::get_sessions,
             commands::get_compartments,