feat: role-aware insight assembler from Brain stores

Implements PR2 of the thinking database feature: role-aware, personalized
digest content assembly.

New components:
- DigestInsight: ranked insight model with severity, freshness, actionability
- InsightCategory: enum mapping insight types to persona relevance weights
- DigestAssemblyResult: assembled digest with metadata and executive summary
- DigestInsightAssemblerService: mines and ranks insights from Brain stores

Signal mining from existing stores:
- BrainV2Alert: workload changes, config drift, plan regressions
- BrainScore: low health score alerts
- BrainLearningProgress: tuning milestones
- IndexRecommendation: pending index recommendations by priority
- SchemaChange: breaking/critical schema changes
- GrowthAnomaly: table growth spikes
- PlaybookAlert: system alerts
- SlowQueryHistory: critical/high slow query counts

Ranking formula:
  score = categoryWeight × severityMultiplier × freshnessMultiplier
        × personaRelevance × roleMultiplier × actionabilityBonus

Persona-aware weighting (examples):
- DBA: 2x on QUERY_PERFORMANCE, INDEX_RECOMMENDATIONS, CONFIG_TUNING
- DATA_ENG: 2x on DOCUMENTATION_GAPS, SCHEMA_CHANGES
- APP_ENG: 2x on SCHEMA_CHANGES, 1.8x on QUERY_PERFORMANCE
- EXEC: 2x on COST_CAPACITY, limited to 5 insights with summary

Suppression logic:
- Filters acknowledged insights
- Suppresses duplicates from last digest (via signature key)
- High-severity insights (>=80) bypass suppression

Tests cover:
- Different personas get differently ranked digests
- Duplicate suppression across digests
- Acknowledged insight filtering
- Severity/freshness/actionability ranking
- Signal mining from all Brain stores

Depends on PR #103 (cursor/per-user-digest-prefs-3784) for UserDigestPreference,
PersonaTag, and SlackDigestLog models.

Part of: Thinking database — continuous-learning Brain + role-aware digests

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

Author: cursoragent

backend/src/main/java/com/dbaagent/model/digest/DigestAssemblyResult.java

@@ -0,0 +1,171 @@
+package com.dbaagent.model.digest;
+
+import com.dbaagent.model.PersonaTag;
+import com.dbaagent.model.Role;
+import lombok.Builder;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Result of assembling a personalized digest for a user.
+ *
+ * <p>Contains the ranked insights tailored to the user's role and persona,
+ * along with metadata about the assembly process.
+ */
+@Data
+@Builder
+public class DigestAssemblyResult {
+
+    /**
+     * Username this digest was assembled for.
+     */
+    private String username;
+
+    /**
+     * Connection ID this digest covers.
+     */
+    private String connectionId;
+
+    /**
+     * User's RBAC role at assembly time.
+     */
+    private Role role;
+
+    /**
+     * User's persona tag (may be null for role-only personalization).
+     */
+    private PersonaTag personaTag;
+
+    /**
+     * When this digest was assembled.
+     */
+    private LocalDateTime assembledAt;
+
+    /**
+     * Time window start for insights (e.g., since last digest).
+     */
+    private LocalDateTime windowStart;
+
+    /**
+     * Time window end for insights.
+     */
+    private LocalDateTime windowEnd;
+
+    /**
+     * Ranked insights for this user (highest rank first).
+     */
+    private List<DigestInsight> insights;
+
+    /**
+     * Summary counts by category for quick overview.
+     */
+    private Map<InsightCategory, Integer> categoryCounts;
+
+    /**
+     * Total insights considered before filtering/ranking.
+     */
+    private int totalCandidates;
+
+    /**
+     * Insights suppressed as duplicates from last digest.
+     */
+    private int suppressedDuplicates;
+
+    /**
+     * Insights filtered out due to acknowledgment.
+     */
+    private int filteredAcknowledged;
+
+    /**
+     * Whether this is an empty digest (no actionable insights).
+     */
+    @Builder.Default
+    private boolean empty = false;
+
+    /**
+     * Executive summary for EXEC personas (3 bullets max).
+     * Null for other personas.
+     */
+    private List<String> executiveSummary;
+
+    /**
+     * Top decision ask for EXEC personas.
+     * Null for other personas.
+     */
+    private String decisionAsk;
+
+    /**
+     * Get insights by category.
+     */
+    public List<DigestInsight> getInsightsByCategory(InsightCategory category) {
+        if (insights == null) return List.of();
+        return insights.stream()
+            .filter(i -> i.getCategory() == category)
+            .toList();
+    }
+
+    /**
+     * Get top N insights.
+     */
+    public List<DigestInsight> getTopInsights(int n) {
+        if (insights == null) return List.of();
+        return insights.stream().limit(n).toList();
+    }
+
+    /**
+     * Check if digest has critical insights.
+     */
+    public boolean hasCriticalInsights() {
+        return insights != null && insights.stream()
+            .anyMatch(i -> i.getSeverity() >= 90);
+    }
+
+    /**
+     * Check if digest has high-severity insights.
+     */
+    public boolean hasHighSeverityInsights() {
+        return insights != null && insights.stream()
+            .anyMatch(i -> i.getSeverity() >= 70);
+    }
+
+    /**
+     * Get the headline for the digest.
+     */
+    public String getHeadline() {
+        if (empty || insights == null || insights.isEmpty()) {
+            return "No new insights since your last digest";
+        }
+        int count = insights.size();
+        if (hasCriticalInsights()) {
+            long criticalCount = insights.stream().filter(i -> i.getSeverity() >= 90).count();
+            return String.format("%d insight%s (%d critical)",
+                count, count != 1 ? "s" : "", criticalCount);
+        }
+        if (hasHighSeverityInsights()) {
+            long highCount = insights.stream().filter(i -> i.getSeverity() >= 70).count();
+            return String.format("%d insight%s (%d high priority)",
+                count, count != 1 ? "s" : "", highCount);
+        }
+        return String.format("%d new insight%s", count, count != 1 ? "s" : "");
+    }
+
+    /**
+     * Create an empty result for a user with no insights.
+     */
+    public static DigestAssemblyResult empty(String username, String connectionId,
+                                              Role role, PersonaTag personaTag) {
+        return DigestAssemblyResult.builder()
+            .username(username)
+            .connectionId(connectionId)
+            .role(role)
+            .personaTag(personaTag)
+            .assembledAt(LocalDateTime.now())
+            .insights(List.of())
+            .categoryCounts(Map.of())
+            .empty(true)
+            .build();
+    }
+}

backend/src/main/java/com/dbaagent/model/digest/DigestInsight.java

@@ -0,0 +1,209 @@
+package com.dbaagent.model.digest;
+
+import lombok.Builder;
+import lombok.Data;
+import lombok.With;
+
+import java.time.LocalDateTime;
+import java.util.Map;
+
+/**
+ * A single ranked insight for inclusion in a digest.
+ *
+ * <p>Insights are mined from Brain stores, slow-query analysis, schema changes,
+ * growth anomalies, and other sources. Each insight carries enough context
+ * for rendering in Slack/email and for suppression logic.
+ *
+ * <h3>Ranking Formula</h3>
+ * <pre>
+ * finalScore = baseScore
+ *            × severityMultiplier
+ *            × freshnessMultiplier
+ *            × roleRelevanceMultiplier
+ *            × actionabilityBonus
+ * </pre>
+ *
+ * <h3>Suppression</h3>
+ * <p>The {@code signatureKey} is used to detect duplicates across digests.
+ * If the same signature was included in a recent digest and the insight
+ * has not materially changed, it is suppressed to avoid "blast of the same
+ * top item" syndrome.
+ */
+@Data
+@Builder
+@With
+public class DigestInsight {
+
+    /**
+     * Category of this insight.
+     */
+    private InsightCategory category;
+
+    /**
+     * Short headline for the insight (one line).
+     * Example: "3 high-impact index recommendations pending"
+     */
+    private String headline;
+
+    /**
+     * Detailed description with context.
+     * Example: "Index on orders(customer_id) could save 2.3s/query..."
+     */
+    private String description;
+
+    /**
+     * Severity level (0-100). Higher = more urgent.
+     * Maps to CRITICAL=100, HIGH=75, WARNING=50, INFO=25.
+     */
+    private int severity;
+
+    /**
+     * When this insight was detected or last updated.
+     */
+    private LocalDateTime timestamp;
+
+    /**
+     * Whether this insight is actionable (user can do something about it).
+     * Actionable insights get a ranking bonus.
+     */
+    @Builder.Default
+    private boolean actionable = true;
+
+    /**
+     * Suggested action for the user, if any.
+     * Example: "Run ANALYZE on affected tables"
+     */
+    private String suggestedAction;
+
+    /**
+     * Source entity ID (e.g., alert ID, recommendation ID).
+     * Used for deduplication and linking back to the source.
+     */
+    private String sourceId;
+
+    /**
+     * Source entity type (e.g., "BrainV2Alert", "IndexRecommendation").
+     */
+    private String sourceType;
+
+    /**
+     * Unique signature for deduplication across digests.
+     * Format: "{category}:{sourceType}:{key-fields-hash}"
+     * Example: "INDEX_RECOMMENDATIONS:IndexRecommendation:orders_customer_id_idx"
+     */
+    private String signatureKey;
+
+    /**
+     * Connection ID this insight belongs to.
+     */
+    private String connectionId;
+
+    /**
+     * Additional context data for rendering.
+     * Keys depend on the insight type.
+     */
+    private Map<String, Object> contextData;
+
+    /**
+     * The final computed rank score (higher = more important).
+     * Set by the assembler after applying all multipliers.
+     */
+    private double rankScore;
+
+    /**
+     * Whether this insight was acknowledged by the user.
+     * Acknowledged insights are typically suppressed from digests.
+     */
+    @Builder.Default
+    private boolean acknowledged = false;
+
+    /**
+     * Whether this insight appeared in the last digest to this recipient.
+     * Used for "since last digest" filtering.
+     */
+    @Builder.Default
+    private boolean appearedInLastDigest = false;
+
+    /**
+     * Tables involved in this insight (for schema-based filtering).
+     */
+    private String[] involvedTables;
+
+    /**
+     * Get severity as a display string.
+     */
+    public String getSeverityLabel() {
+        if (severity >= 90) return "CRITICAL";
+        if (severity >= 70) return "HIGH";
+        if (severity >= 40) return "WARNING";
+        return "INFO";
+    }
+
+    /**
+     * Get the severity multiplier for ranking (1.0 to 2.0).
+     */
+    public double getSeverityMultiplier() {
+        return 1.0 + (severity / 100.0);
+    }
+
+    /**
+     * Get the freshness multiplier for ranking (0.5 to 1.5).
+     * Insights from the last hour are boosted; older insights decay.
+     */
+    public double getFreshnessMultiplier() {
+        if (timestamp == null) {
+            return 1.0;
+        }
+        LocalDateTime now = LocalDateTime.now();
+        long hoursAgo = java.time.Duration.between(timestamp, now).toHours();
+
+        if (hoursAgo <= 1) return 1.5;
+        if (hoursAgo <= 6) return 1.3;
+        if (hoursAgo <= 24) return 1.1;
+        if (hoursAgo <= 72) return 1.0;
+        if (hoursAgo <= 168) return 0.8;
+        return 0.5;
+    }
+
+    /**
+     * Get the actionability bonus (1.0 or 1.2).
+     */
+    public double getActionabilityBonus() {
+        return actionable && suggestedAction != null ? 1.2 : 1.0;
+    }
+
+    /**
+     * Convenience builder method for creating from an alert.
+     */
+    public static DigestInsightBuilder fromBrainAlert() {
+        return DigestInsight.builder()
+            .sourceType("BrainV2Alert");
+    }
+
+    /**
+     * Convenience builder method for creating from a recommendation.
+     */
+    public static DigestInsightBuilder fromIndexRecommendation() {
+        return DigestInsight.builder()
+            .sourceType("IndexRecommendation")
+            .category(InsightCategory.INDEX_RECOMMENDATIONS);
+    }
+
+    /**
+     * Convenience builder method for creating from a schema change.
+     */
+    public static DigestInsightBuilder fromSchemaChange() {
+        return DigestInsight.builder()
+            .sourceType("SchemaChange")
+            .category(InsightCategory.SCHEMA_CHANGES);
+    }
+
+    /**
+     * Convenience builder method for creating from a growth anomaly.
+     */
+    public static DigestInsightBuilder fromGrowthAnomaly() {
+        return DigestInsight.builder()
+            .sourceType("GrowthAnomaly")
+            .category(InsightCategory.GROWTH_ANOMALIES);
+    }
+}