fix(web): workspace-scope dashboard endpoints + zero test coverage + hardening (#346)

The web dashboard (src/web/mod.rs, dashboard.html) had no test coverage
and three of its four data-fetching paths (list_entities, search, graph)
ignored workspace_hash entirely -- the same information-disclosure class
already fixed for context()/recall_when()/prepare in #338. In a federated
(multi-workspace) vault, the dashboard showed every workspace's memories,
including cross-workspace entity-graph edges, in one unfiltered view.

Fixes:
- db::list_entities/get_entity_graph gain workspace_hash: Option<&str>,
  same exact-match scoping recall()/context() use since v1.2.0. None
  preserves prior unscoped behavior (backward compatible).
- New db::count_entities(): a real COUNT(*) with the same filters, no
  LIMIT/OFFSET -- fixes the dashboard's list_entities/search 'total'
  field, which was actually 'items in this page' (items.len()), making
  client-side pagination (has-more-pages?) impossible to implement
  correctly. list_entities now reports a true total; search's total
  remains page-count (documented why: FTS5 relevance ranking has no
  cheap unlimited-count backing query without doubling recall cost).
- get_entity_graph drops edges whose target falls outside the scoped
  node set, rather than emitting a dangling edge to a node the caller
  never receives (which would also leak the target id's existence
  across workspaces).
- web/mod.rs: list_entities/search/graph endpoints accept an optional
  ?workspace= query param, threaded through to the new db.rs params.
  journal/get_recent_journal is NOT scoped -- the journal table has no
  workspace_hash column; fixing that needs a schema migration and is
  documented as a follow-up rather than folded into this pass.
- Injection audit: verified every dashboard.html render site that
  interpolates untrusted entity content (key, category, layer,
  body_json via JSON.stringify, timeline event fields) already goes
  through the esc() HTML-escaping helper -- no missing site found, no
  code change needed here, confirmed by inspection given the sibling
  <memory-prep> injection fix in #337.
- Cosmetic: dashboard <title>/<h1> said 'Mneme', not updated in the
  #341 Perseus Vault rebrand -- fixed.
- Hardening: vis-network@9.1.6 CDN <script> tag gains a real SRI
  integrity hash (computed from the fetched artifact, sha384) +
  crossorigin="anonymous", closing a supply-chain gap for any
  deployment that binds --web-bind beyond 127.0.0.1.

Tests: 12 new tests in src/web/mod.rs (zero before this change) using
Axum's tower::ServiceExt::oneshot -- auth middleware (mirrors the
existing gRPC transport auth test pattern), list_entities/search/graph
workspace scoping (with and without ?workspace=), true-total pagination,
entity_detail 404, stats/journal smoke tests. Full suite: 167 passed,
0 failed, 2 ignored (was 155/0/2 before this change), stable across 3
repeated runs.

Manually verified end-to-end against the compiled binary's live --web
server: seeded two workspaces via real MCP mimir_remember calls,
confirmed unscoped /api/entities shows both (backward compat), scoped
?workspace= isolates correctly for entities/search/graph, cross-
workspace graph edges are dropped, dashboard title/h1/SRI hash render
as expected in the served HTML.

Version bump 2.12.0 -> 2.13.0.

Author: tcconnally

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "perseus-vault"
-version = "2.12.0"
+version = "2.13.0"
 edition = "2021"
 description = "Persistent memory engine for AI agents — MCP JSON-RPC stdio server (formerly Mneme/Mimir)"
 repository = "https://github.com/Perseus-Computing-LLC/perseus-vault"

Cargo.toml

@@ -3347,12 +3347,17 @@ impl Database {
     }
 
     /// List entities with pagination and optional filters.
+    /// `workspace_hash`: when `Some(non-empty)`, only entities with a matching
+    /// workspace_hash are returned — same exact-match scoping `recall()` and
+    /// `context()` use (#338/#343). Without it, the web dashboard's entity
+    /// list leaked every workspace's memory into one view.
     pub fn list_entities(
         &self,
         offset: i64,
         limit: i64,
         category: Option<&str>,
         layer: Option<&str>,
+        workspace_hash: Option<&str>,
     ) -> Result<Vec<Entity>, Box<dyn std::error::Error>> {
         let conn = self.conn()?;
         let mut sql = String::from(
@@ -3378,6 +3383,12 @@ impl Database {
                 params.push(Box::new(l.to_string()));
             }
         }
+        if let Some(ws) = workspace_hash {
+            if !ws.is_empty() {
+                sql.push_str(&format!(" AND workspace_hash = ?{}", params.len() + 1));
+                params.push(Box::new(ws.to_string()));
+            }
+        }
 
         sql.push_str(" ORDER BY last_accessed_unix_ms DESC");
         sql.push_str(&format!(
@@ -3401,7 +3412,53 @@ impl Database {
         Ok(items)
     }
 
+    /// Count entities matching the same filters as `list_entities`, with no
+    /// LIMIT/OFFSET — lets callers (the web dashboard) report a true total
+    /// instead of "count of items in this page".
+    pub fn count_entities(
+        &self,
+        category: Option<&str>,
+        layer: Option<&str>,
+        workspace_hash: Option<&str>,
+    ) -> Result<i64, Box<dyn std::error::Error>> {
+        let conn = self.conn()?;
+        let mut sql = String::from("SELECT COUNT(*) FROM entities WHERE archived = 0");
+        let mut params: Vec<Box<dyn rusqlite::types::ToSql>> = Vec::new();
+
+        if let Some(cat) = category {
+            if !cat.is_empty() {
+                sql.push_str(&format!(" AND category = ?{}", params.len() + 1));
+                params.push(Box::new(cat.to_string()));
+            }
+        }
+        if let Some(l) = layer {
+            if !l.is_empty() {
+                sql.push_str(&format!(" AND layer = ?{}", params.len() + 1));
+                params.push(Box::new(l.to_string()));
+            }
+        }
+        if let Some(ws) = workspace_hash {
+            if !ws.is_empty() {
+                sql.push_str(&format!(" AND workspace_hash = ?{}", params.len() + 1));
+                params.push(Box::new(ws.to_string()));
+            }
+        }
+
+        let param_refs: Vec<&dyn rusqlite::types::ToSql> =
+            params.iter().map(|p| p.as_ref()).collect();
+        let count: i64 = conn.query_row(&sql, param_refs.as_slice(), |r| r.get(0))?;
+        Ok(count)
+    }
+
     /// Get recent journal events.
+    ///
+    /// NOTE: the `journal` table has no `workspace_hash` column, so
+    /// this cannot be scoped to a workspace the way `list_entities`/
+    /// `get_entity_graph`/`context`/`recall_when` now are. In a federated
+    /// vault, journal events from every workspace are visible here. Fixing
+    /// this properly needs a schema migration (new column + SCHEMA_VERSION
+    /// bump + JournalEvent struct + every journal() call site) — tracked as
+    /// a follow-up rather than folded into this pass.
     pub fn get_recent_journal(
         &self,
         limit: i64,
@@ -3434,42 +3491,70 @@ impl Database {
     }
 
     /// Build an entity link graph: nodes + edges for visualization.
+    /// `workspace_hash`: when `Some(non-empty)`, only entities (nodes) whose
+    /// workspace_hash matches are included; edges to a target outside that
+    /// scope are dropped rather than pointing at a node the caller never
+    /// receives (the dashboard's graph tab leaked cross-workspace
+    /// nodes/edges before this).
     pub fn get_entity_graph(
         &self,
+        workspace_hash: Option<&str>,
     ) -> Result<(Vec<GraphNode>, Vec<GraphEdge>), Box<dyn std::error::Error>> {
         let conn = self.conn()?;
-        let mut stmt = conn
-            .prepare("SELECT id, category, key, links FROM entities WHERE archived = 0")?;
-        let rows = stmt.query_map([], |row| {
+        let (sql, scoped) = match workspace_hash.filter(|ws| !ws.is_empty()) {
+            Some(_) => (
+                "SELECT id, category, key, links FROM entities WHERE archived = 0 AND workspace_hash = ?1",
+                true,
+            ),
+            None => (
+                "SELECT id, category, key, links FROM entities WHERE archived = 0",
+                false,
+            ),
+        };
+        let mut stmt = conn.prepare(sql)?;
+        let map_row = |row: &rusqlite::Row| {
             let id: String = row.get(0)?;
             let category: String = row.get(1)?;
             let key: String = row.get(2)?;
             let links_str: String = row.get::<_, String>(3).unwrap_or_else(|_| "[]".to_string());
             let links: Vec<MemoryLink> = serde_json::from_str(&links_str).unwrap_or_default();
             Ok((id, category, key, links))
-        })?;
+        };
+        let rows: Vec<(String, String, String, Vec<MemoryLink>)> = if scoped {
+            stmt.query_map(params![workspace_hash.unwrap()], map_row)?
+                .collect::<rusqlite::Result<Vec<_>>>()?
+        } else {
+            stmt.query_map([], map_row)?
+                .collect::<rusqlite::Result<Vec<_>>>()?
+        };
 
         let mut nodes = Vec::new();
         let mut edges = Vec::new();
         let mut seen_ids = std::collections::HashSet::new();
 
-        for row in rows {
-            let (id, category, key, links) = row?;
+        for (id, category, key, links) in &rows {
             if seen_ids.insert(id.clone()) {
                 nodes.push(GraphNode {
                     id: id.clone(),
-                    label: key,
-                    category,
+                    label: key.clone(),
+                    category: category.clone(),
                 });
             }
-            for link in &links {
+            for link in links {
                 edges.push(GraphEdge {
                     from: id.clone(),
                     to: link.target_id.clone(),
                     relationship: link.relationship.clone(),
                 });
             }
         }
+        if scoped {
+            // Drop edges pointing outside the scoped node set: the target
+            // entity is in a different workspace, so the caller never
+            // receives that node and a dangling edge would be meaningless
+            // (or, worse, leak the existence/id of a cross-workspace entity).
+            edges.retain(|e| seen_ids.contains(&e.to));
+        }
         Ok((nodes, edges))
     }
 

src/db.rs

@@ -3,7 +3,7 @@
 <head>
 <meta charset="UTF-8">
 <meta name="viewport" content="width=device-width, initial-scale=1.0">
-<title>Mneme Dashboard</title>
+<title>Perseus Vault Dashboard</title>
 <style>
   :root {
     --bg: #0d1117;
@@ -132,7 +132,7 @@
 </head>
 <body>
 <header>
-  <h1>Mneme</h1>
+  <h1>Perseus Vault</h1>
   <span class="version">dashboard</span>
   <div class="search-bar">
     <input type="text" id="search-input" placeholder="Search memories..." autofocus>
@@ -167,7 +167,9 @@ <h1>Mneme</h1>
     </table>
   </div>
 </main>
-<script src="https://cdn.jsdelivr.net/npm/vis-network@9.1.6/dist/vis-network.min.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/vis-network@9.1.6/dist/vis-network.min.js"
+        integrity="sha384-MMLxWP/84QroX0uegDzRv7ib1nuKjUbUjLk2Li3jkwKWohW506l5X7B3AnChTXER"
+        crossorigin="anonymous"></script>
 <script>
 const state = { entities: [], expandedId: null };