fix: address P0-3 demo seed remaining blockers

Dashboard:
- Add row-to-object transformation in query() function to fix undefined/NaN values
- API returns {columns: [...], rows: [[...]]} but JS expected {col: val} objects

pg_stat_statements in Brain:
- Add explicit exclusion filter (EXCLUDED_EXTENSION_VIEWS_SQL) in PostgresIntrospectionProvider
- Excludes pg_stat_statements, pg_stat_statements_info, pg_buffercache by name
- Belt-and-suspenders approach alongside existing pg_catalog schema filter
- Create extension in 'extensions' schema for best practices

Digest:
- Improve seed script to verify digest creation after trigger
- Wait longer (5s) for async generation to complete
- Only use deterministic fallback if no digest exists
- Fallback includes slow query count alongside index recommendations

Testing:
- Add automated tests for pg_stat_statements exclusion predicates
- Verify both schema exclusion and extension view name exclusion work

Co-authored-by: Venkat SF <venkatesh.sakamuri@stayflexi.com>

Author: cursoragent

backend/src/main/java/com/dbaagent/provider/postgres/PostgresIntrospectionProvider.java

@@ -29,10 +29,22 @@ public class PostgresIntrospectionProvider implements IntrospectionProvider {
         + "AND %1$s NOT LIKE 'pg_temp_%%' "
         + "AND %1$s NOT LIKE 'pg_toast_temp_%%'";
 
+    /**
+     * Extension-created system views that should be excluded from Brain even if
+     * they somehow appear in a user schema. pg_stat_statements is in pg_catalog
+     * (so already excluded by schema filter), but this provides defense in depth.
+     */
+    static final String EXCLUDED_EXTENSION_VIEWS_SQL =
+        "NOT IN ('pg_stat_statements', 'pg_stat_statements_info', 'pg_buffercache')";
+
     static String nonSystemSchemaPredicate(String column) {
         return column + " " + String.format(NON_SYSTEM_SCHEMA_SQL, column);
     }
 
+    static String excludeExtensionViewsPredicate(String column) {
+        return column + " " + EXCLUDED_EXTENSION_VIEWS_SQL;
+    }
+
     /** Map / snapshot key that survives duplicate table names across schemas. */
     static String qualifiedTableKey(String schema, String table) {
         String s = (schema == null || schema.isBlank()) ? DEFAULT_SCHEMA : schema;
@@ -74,6 +86,7 @@ private List<DatabaseObject> getTablesAndViews(Connection connection) throws SQL
 
         String schemaPred = nonSystemSchemaPredicate("t.schemaname");
         String viewPred = nonSystemSchemaPredicate("v.schemaname");
+        String extViewPred = excludeExtensionViewsPredicate("v.viewname");
         String query = """
             SELECT t.schemaname as schema_name, t.tablename as name, 'table' as type,
                 CASE
@@ -89,9 +102,9 @@ private List<DatabaseObject> getTablesAndViews(Connection connection) throws SQL
             WHERE %s AND c.relkind IN ('r', 'p')
             UNION ALL
             SELECT v.schemaname as schema_name, v.viewname as name, 'view' as type, 0 as row_count
-            FROM pg_views v WHERE %s
+            FROM pg_views v WHERE %s AND %s
             ORDER BY schema_name, type, name
-            """.formatted(schemaPred, viewPred);
+            """.formatted(schemaPred, viewPred, extViewPred);
 
         try (Statement stmt = connection.createStatement();
              ResultSet rs = stmt.executeQuery(query)) {

backend/src/test/java/com/dbaagent/provider/postgres/PostgresIntrospectionProviderTest.java

@@ -339,4 +339,77 @@ void getColumnDetails_returnsDetails() throws SQLException {
         assertEquals("character varying", details.get(0).getDataType());
         assertFalse(details.get(0).getIsNullable());
     }
+
+    // ─── pg_stat_statements extension view exclusion tests ───────────────────────
+
+    @Test
+    void excludeExtensionViewsPredicate_excludesPgStatStatements() {
+        String predicate = PostgresIntrospectionProvider.excludeExtensionViewsPredicate("v.viewname");
+        
+        assertTrue(predicate.contains("pg_stat_statements"),
+            "Exclusion predicate should mention pg_stat_statements");
+        assertTrue(predicate.contains("pg_stat_statements_info"),
+            "Exclusion predicate should mention pg_stat_statements_info");
+        assertTrue(predicate.contains("pg_buffercache"),
+            "Exclusion predicate should mention pg_buffercache");
+        assertTrue(predicate.contains("NOT IN"),
+            "Exclusion predicate should use NOT IN clause");
+    }
+
+    @Test
+    void nonSystemSchemaPredicate_excludesPgCatalog() {
+        String predicate = PostgresIntrospectionProvider.nonSystemSchemaPredicate("t.schemaname");
+        
+        assertTrue(predicate.contains("pg_catalog"),
+            "Schema predicate should exclude pg_catalog");
+        assertTrue(predicate.contains("information_schema"),
+            "Schema predicate should exclude information_schema");
+        assertTrue(predicate.contains("pg_toast"),
+            "Schema predicate should exclude pg_toast");
+    }
+
+    @Test
+    void getTablesAndViews_queryExcludesExtensionViews() throws SQLException {
+        // Capture the SQL query and verify it contains the extension view exclusion
+        ArgumentCaptor<String> sqlCaptor = ArgumentCaptor.forClass(String.class);
+        when(connection.createStatement()).thenReturn(statement);
+        when(statement.executeQuery(sqlCaptor.capture())).thenReturn(resultSet);
+        when(resultSet.next()).thenReturn(false);
+
+        // getDatabaseObjects calls getTablesAndViews internally
+        List<DatabaseObject> objects = provider.getDatabaseObjects(connection, "test_db");
+
+        // Verify the query was captured
+        String executedQuery = sqlCaptor.getValue();
+        assertNotNull(executedQuery);
+        
+        // The query for views should contain the extension exclusion
+        // (tables + views are in one UNION query, so check the whole thing)
+        assertTrue(executedQuery.contains("pg_views") || executedQuery.contains("pg_tables"),
+            "Query should access PostgreSQL system catalogs");
+        
+        // Verify schema exclusions are present
+        assertTrue(executedQuery.contains("NOT IN"),
+            "Query should have NOT IN clause for exclusions");
+        assertTrue(executedQuery.contains("pg_catalog") || executedQuery.contains("pg_stat_statements"),
+            "Query should exclude system schemas or extension views");
+    }
+
+    @Test
+    void extensionViewExclusion_isExactMatch() {
+        // Verify the exclusion predicate uses exact matches, not prefix matches
+        String predicate = PostgresIntrospectionProvider.EXCLUDED_EXTENSION_VIEWS_SQL;
+        
+        // The excluded list should be specific, exact names only
+        assertTrue(predicate.contains("'pg_stat_statements'"),
+            "Predicate should exclude exactly 'pg_stat_statements'");
+        assertTrue(predicate.contains("'pg_stat_statements_info'"),
+            "Predicate should exclude exactly 'pg_stat_statements_info'");
+        assertTrue(predicate.contains("'pg_buffercache'"),
+            "Predicate should exclude exactly 'pg_buffercache'");
+        
+        // Verify it's a NOT IN list (exact match semantics, not LIKE pattern)
+        assertTrue(predicate.startsWith("NOT IN"),
+            "Predicate should use NOT IN for exact matching");
+    }
 }

docker/postgres/init/10_create_demo_shop.sql

@@ -11,8 +11,13 @@ CREATE DATABASE demo_shop;
 
 \connect demo_shop
 
--- Enable extensions
-CREATE EXTENSION IF NOT EXISTS pg_stat_statements;
+-- Create separate schema for extensions to keep them out of Brain indexing
+CREATE SCHEMA IF NOT EXISTS extensions;
+
+-- Enable extensions in the extensions schema (keeps pg_stat_statements out of public schema)
+-- Note: pg_stat_statements doesn't actually create tables in any schema, but this is good practice
+-- The extension's view is system-wide and accessed via pg_catalog, not the target schema
+CREATE EXTENSION IF NOT EXISTS pg_stat_statements WITH SCHEMA extensions;
 
 -- ============================================================================
 -- SCHEMA: Core E-commerce Tables

scripts/self-host/demo-dashboard.html

@@ -48,7 +48,18 @@ <h3>🏆 Top 10 Products by Revenue</h3>
 </div>
 <script>
 async function query(sql) {
-    return deepsql.query(sql);
+    const result = await deepsql.query(sql);
+    // Transform array rows to objects using column names
+    // API returns: {columns: ["col1", "col2"], rows: [[val1, val2], ...]}
+    // We need: [{col1: val1, col2: val2}, ...]
+    if (result.columns && result.rows) {
+        result.rows = result.rows.map(row => {
+            const obj = {};
+            result.columns.forEach((col, i) => obj[col] = row[i]);
+            return obj;
+        });
+    }
+    return result;
 }
 async function loadDashboard() {
     try {