feat(digest): per-recipient Slack delivery with UI prefs (PR3)

- Extend SlackDailyDigestService with sendPersonalizedDigests() consuming DigestAssemblyResult
- Add DigestPreferenceSeedService to seed preferences from singleton config
- Update scheduler to use hybrid mode (per-user when prefs exist, legacy otherwise)
- Add digest preferences API endpoints to client.js
- Create DigestPreferencesPanel UI component with persona selection
- Integrate preferences panel into DigestSection (bell icon)
- Add tests for per-recipient delivery and seed/legacy fallback
- Update DIGEST_PREFERENCES.md documentation

Two users with different personas on same connection get different digests.
EXEC persona gets tight 3-bullet executive summary.
Cron/config not singleton-only in the delivery path.

Depends on: PR1 #103 (per-user digest prefs), PR2 #104 (role-aware assembler)
GTM: Same Brain, different lens per role

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

Author: cursoragent

backend/src/main/java/com/dbaagent/controller/DigestPreferenceController.java

@@ -3,11 +3,14 @@
 import com.dbaagent.model.DigestDeliveryMethod;
 import com.dbaagent.model.PersonaTag;
 import com.dbaagent.model.UserDigestPreference;
+import com.dbaagent.service.DigestPreferenceSeedService;
 import com.dbaagent.service.security.AccessControlService;
 import com.dbaagent.service.UserDigestPreferenceService;
+import com.dbaagent.service.SlackDailyDigestService;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.http.ResponseEntity;
+import org.springframework.security.access.prepost.PreAuthorize;
 import org.springframework.web.bind.annotation.*;
 
 import java.util.List;
@@ -27,6 +30,8 @@ public class DigestPreferenceController {
 
     private final UserDigestPreferenceService preferenceService;
     private final AccessControlService accessControlService;
+    private final DigestPreferenceSeedService seedService;
+    private final SlackDailyDigestService digestService;
 
     /**
      * Get the current user's digest preferences.
@@ -181,4 +186,85 @@ public record UpdatePreferenceRequest(
         String cronExpression,
         String timezone
     ) {}
+
+    // ─────────────────────────────────────────────────────────────────────────
+    // Admin: Seed & Status endpoints
+    // ─────────────────────────────────────────────────────────────────────────
+
+    /**
+     * Preview what preferences would be seeded from singleton config.
+     * Admin only.
+     */
+    @GetMapping("/admin/seed/preview")
+    @PreAuthorize("hasRole('ADMIN')")
+    public ResponseEntity<SeedPreviewResponse> previewSeed() {
+        DigestPreferenceSeedService.SeedResult result = seedService.previewSeed();
+        return ResponseEntity.ok(new SeedPreviewResponse(
+            result.usersProcessed(),
+            result.preferencesCreated(),
+            result.skipped(),
+            result.preferences().stream()
+                .map(p -> new PreferencePreview(p.getUsername(), p.getConnectionId(),
+                    p.getPersonaTag() != null ? p.getPersonaTag().name() : null))
+                .toList()
+        ));
+    }
+
+    /**
+     * Seed preferences for all Slack-linked users from singleton config.
+     * Admin only. Idempotent: skips users with existing preferences.
+     */
+    @PostMapping("/admin/seed")
+    @PreAuthorize("hasRole('ADMIN')")
+    public ResponseEntity<SeedResultResponse> executeSeed() {
+        DigestPreferenceSeedService.SeedResult result = seedService.executeSeed();
+        log.info("Admin seeded {} digest preferences for {} users",
+            result.preferencesCreated(), result.usersProcessed());
+        return ResponseEntity.ok(new SeedResultResponse(
+            result.usersProcessed(),
+            result.preferencesCreated(),
+            result.skipped()
+        ));
+    }
+
+    /**
+     * Seed preferences for the current user.
+     * Available to any authenticated user.
+     */
+    @PostMapping("/seed/me")
+    public ResponseEntity<SeedResultResponse> seedForCurrentUser() {
+        String username = accessControlService.requireCurrentUsername();
+        DigestPreferenceSeedService.SeedResult result = seedService.seedPreferencesForUser(username, false);
+        return ResponseEntity.ok(new SeedResultResponse(
+            1,
+            result.preferencesCreated(),
+            result.skipped()
+        ));
+    }
+
+    /**
+     * Get current digest mode info.
+     */
+    @GetMapping("/status")
+    public ResponseEntity<DigestStatusResponse> getStatus() {
+        SlackDailyDigestService.DigestModeInfo modeInfo = digestService.getDigestModeInfo();
+        return ResponseEntity.ok(new DigestStatusResponse(
+            modeInfo.perUserMode(),
+            modeInfo.enabledPreferences(),
+            modeInfo.distinctUsers()
+        ));
+    }
+
+    public record SeedPreviewResponse(
+        int usersProcessed,
+        int wouldCreate,
+        List<String> wouldSkip,
+        List<PreferencePreview> preferences
+    ) {}
+
+    public record PreferencePreview(String username, String connectionId, String personaTag) {}
+
+    public record SeedResultResponse(int usersProcessed, int preferencesCreated, List<String> skipped) {}
+
+    public record DigestStatusResponse(boolean perUserMode, long enabledPreferences, int distinctUsers) {}
 }

backend/src/main/java/com/dbaagent/repository/SlackDigestLogRepository.java

@@ -91,4 +91,10 @@ SELECT DISTINCT ON (recipient_username) *
      * Count personalized vs non-personalized digests since a date.
      */
     long countByPersonalizedAndSentAtAfter(boolean personalized, LocalDateTime since);
+
+    /**
+     * Find the most recent digest for a connection (any type).
+     * Used for determining the window start for new digests.
+     */
+    Optional<SlackDigestLog> findTopByConnectionIdOrderBySentAtDesc(String connectionId);
 }

backend/src/main/java/com/dbaagent/repository/SlackUserLinkRepository.java

@@ -2,10 +2,26 @@
 
 import com.dbaagent.model.SlackUserLink;
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
 
+import java.util.List;
 import java.util.Optional;
 
 public interface SlackUserLinkRepository extends JpaRepository<SlackUserLink, Long> {
     Optional<SlackUserLink> findByTeamIdAndSlackUserId(String teamId, String slackUserId);
     Optional<SlackUserLink> findByTeamIdAndSlackUserIdAndLinkStatus(String teamId, String slackUserId, String linkStatus);
+
+    /**
+     * Find all linked Slack accounts for a DeepSQL username.
+     * Returns only LINKED entries (not PENDING or REVOKED).
+     */
+    @Query("SELECT l FROM SlackUserLink l WHERE l.deepsqlUsername = :username AND l.linkStatus = 'LINKED'")
+    List<SlackUserLink> findLinkedByDeepsqlUsername(@Param("username") String username);
+
+    /**
+     * Find all linked users (for seeding digest preferences).
+     */
+    @Query("SELECT DISTINCT l.deepsqlUsername FROM SlackUserLink l WHERE l.linkStatus = 'LINKED'")
+    List<String> findAllLinkedDeepsqlUsernames();
 }

backend/src/main/java/com/dbaagent/service/DigestPreferenceSeedService.java

@@ -0,0 +1,237 @@
+package com.dbaagent.service;
+
+import com.dbaagent.model.DigestDeliveryMethod;
+import com.dbaagent.model.PersonaTag;
+import com.dbaagent.model.Role;
+import com.dbaagent.model.SlackDigestConfig;
+import com.dbaagent.model.User;
+import com.dbaagent.model.UserDigestPreference;
+import com.dbaagent.repository.SlackDigestConfigRepository;
+import com.dbaagent.repository.UserDigestPreferenceRepository;
+import com.dbaagent.repository.UserRepository;
+import com.dbaagent.service.security.ConnectionAccessService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * Service for seeding digest preferences from singleton config.
+ *
+ * <p>Provides migration helpers so existing deployments (like Stayflexi) don't stay
+ * on legacy broadcast forever after the first per-user preferences appear.
+ *
+ * <h3>Seed Strategy</h3>
+ * <ol>
+ *   <li>Find all users with linked Slack accounts (candidates for DM delivery)</li>
+ *   <li>For each user, create a SLACK_DM preference for each connection they can access</li>
+ *   <li>Persona tag is inferred from the user's role (can be edited later in UI)</li>
+ *   <li>Cron expression defaults to the global singleton config</li>
+ * </ol>
+ */
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class DigestPreferenceSeedService {
+
+    private final UserDigestPreferenceRepository preferenceRepository;
+    private final SlackDigestConfigRepository configRepository;
+    private final SlackUserLinkService slackUserLinkService;
+    private final ConnectionAccessService connectionAccessService;
+    private final UserRepository userRepository;
+
+    /**
+     * Seed digest preferences for all Slack-linked users.
+     *
+     * <p>This creates one SLACK_DM preference per connection the user can access.
+     * Existing preferences are not overwritten.
+     *
+     * @param dryRun if true, return what would be created without persisting
+     * @return summary of seeded preferences
+     */
+    @Transactional
+    public SeedResult seedPreferencesFromSingleton(boolean dryRun) {
+        List<String> linkedUsernames = slackUserLinkService.getAllLinkedUsernames();
+        if (linkedUsernames.isEmpty()) {
+            log.info("No Slack-linked users found; nothing to seed");
+            return new SeedResult(0, 0, List.of(), List.of());
+        }
+
+        String globalCron = getGlobalCronExpression();
+        List<UserDigestPreference> created = new ArrayList<>();
+        List<String> skipped = new ArrayList<>();
+
+        for (String username : linkedUsernames) {
+            Optional<User> userOpt = userRepository.findByUsernameIgnoreCase(username);
+            if (userOpt.isEmpty()) {
+                skipped.add(username + ": user not found");
+                continue;
+            }
+
+            User user = userOpt.get();
+            if (!user.isActive()) {
+                skipped.add(username + ": user inactive");
+                continue;
+            }
+
+            List<String> connectionIds = connectionAccessService
+                .getVisibleConnections(username, user.isAdmin())
+                .stream()
+                .map(conn -> conn.getId())
+                .toList();
+
+            if (connectionIds.isEmpty()) {
+                skipped.add(username + ": no accessible connections");
+                continue;
+            }
+
+            PersonaTag inferredPersona = inferPersonaFromRole(user.getRoleEnum());
+
+            for (String connectionId : connectionIds) {
+                // Check if preference already exists
+                Optional<UserDigestPreference> existing = preferenceRepository
+                    .findByUsernameAndConnectionIdAndDeliveryMethod(
+                        username, connectionId, DigestDeliveryMethod.SLACK_DM);
+
+                if (existing.isPresent()) {
+                    skipped.add(username + "/" + connectionId + ": preference exists");
+                    continue;
+                }
+
+                UserDigestPreference pref = UserDigestPreference.builder()
+                    .username(username)
+                    .connectionId(connectionId)
+                    .enabled(true)
+                    .deliveryMethod(DigestDeliveryMethod.SLACK_DM)
+                    .personaTag(inferredPersona)
+                    .cronExpression(null)  // Use global default
+                    .timezone(null)        // Use system default
+                    .build();
+
+                if (!dryRun) {
+                    preferenceRepository.save(pref);
+                }
+                created.add(pref);
+            }
+        }
+
+        log.info("Digest preference seed: {} users, {} created, {} skipped (dryRun={})",
+            linkedUsernames.size(), created.size(), skipped.size(), dryRun);
+
+        return new SeedResult(linkedUsernames.size(), created.size(), skipped, created);
+    }
+
+    /**
+     * Seed preferences for a single user.
+     */
+    @Transactional
+    public SeedResult seedPreferencesForUser(String username, boolean dryRun) {
+        Optional<User> userOpt = userRepository.findByUsernameIgnoreCase(username);
+        if (userOpt.isEmpty()) {
+            return new SeedResult(0, 0, List.of(username + ": user not found"), List.of());
+        }
+
+        User user = userOpt.get();
+        if (!user.isActive()) {
+            return new SeedResult(0, 0, List.of(username + ": user inactive"), List.of());
+        }
+
+        // Check if user has Slack linked
+        List<com.dbaagent.model.SlackUserLink> links = slackUserLinkService.getLinkedSlackAccounts(username);
+        if (links.isEmpty()) {
+            return new SeedResult(0, 0, List.of(username + ": not linked to Slack"), List.of());
+        }
+
+        List<String> connectionIds = connectionAccessService
+            .getVisibleConnections(username, user.isAdmin())
+            .stream()
+            .map(conn -> conn.getId())
+            .toList();
+
+        if (connectionIds.isEmpty()) {
+            return new SeedResult(0, 0, List.of(username + ": no accessible connections"), List.of());
+        }
+
+        PersonaTag inferredPersona = inferPersonaFromRole(user.getRoleEnum());
+        List<UserDigestPreference> created = new ArrayList<>();
+        List<String> skipped = new ArrayList<>();
+
+        for (String connectionId : connectionIds) {
+            Optional<UserDigestPreference> existing = preferenceRepository
+                .findByUsernameAndConnectionIdAndDeliveryMethod(
+                    username, connectionId, DigestDeliveryMethod.SLACK_DM);
+
+            if (existing.isPresent()) {
+                skipped.add(connectionId + ": preference exists");
+                continue;
+            }
+
+            UserDigestPreference pref = UserDigestPreference.builder()
+                .username(username)
+                .connectionId(connectionId)
+                .enabled(true)
+                .deliveryMethod(DigestDeliveryMethod.SLACK_DM)
+                .personaTag(inferredPersona)
+                .build();
+
+            if (!dryRun) {
+                preferenceRepository.save(pref);
+            }
+            created.add(pref);
+        }
+
+        log.info("Seeded {} preferences for user {} (dryRun={})", created.size(), username, dryRun);
+
+        return new SeedResult(1, created.size(), skipped, created);
+    }
+
+    /**
+     * Infer a persona tag from the user's role.
+     */
+    private PersonaTag inferPersonaFromRole(Role role) {
+        if (role == null) {
+            return null;  // No persona; use role-based prioritization only
+        }
+        return switch (role) {
+            case ADMIN -> null;  // Admins often wear multiple hats; let them pick
+            case DBA -> PersonaTag.DBA;
+            case DATA_ENGINEER -> PersonaTag.DATA_ENG;
+            case DEVELOPER -> PersonaTag.APP_ENG;
+        };
+    }
+
+    private String getGlobalCronExpression() {
+        return configRepository.findById(1L)
+            .map(SlackDigestConfig::getCronExpression)
+            .orElse("0 0 9 * * *");
+    }
+
+    /**
+     * Get seed preview: what would be created without actually seeding.
+     */
+    public SeedResult previewSeed() {
+        return seedPreferencesFromSingleton(true);
+    }
+
+    /**
+     * Execute seed: create preferences for all eligible users.
+     */
+    public SeedResult executeSeed() {
+        return seedPreferencesFromSingleton(false);
+    }
+
+    public record SeedResult(
+        int usersProcessed,
+        int preferencesCreated,
+        List<String> skipped,
+        List<UserDigestPreference> preferences
+    ) {
+        public boolean hasCreations() {
+            return preferencesCreated > 0;
+        }
+    }
+}