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

<!-- CURSOR_AGENT_PR_BODY_BEGIN -->
## Summary

**Same Brain, different lens per role.**

This PR implements per-recipient Slack delivery for digests, consuming
the `DigestAssemblyResult` API from PR2. Two users with different
personas on the same connection now get different Slack digests for the
same time window.

### Honesty-gap fix (per-user cron)

UI schedule presets and `UserDigestPreference.cronExpression` (+
timezone) were stored but ignored: `SlackDailyDigestTaskConfig` only ran
the global `slack.daily-digest.cron` and then delivered to every
preference. Product Evangelist blocked marketing “your own schedule”
until this was fixed.

The scheduler now ticks every minute (`slack.daily-digest.tick-cron`,
default `0 * * * * *`) via `processDigestTick()`:

- **No enabled prefs** → legacy channel broadcast only when the global
cron is due (UTC)
- **Prefs exist** → each enabled `SLACK_DM` preference is evaluated with
Spring `CronExpression` in that user’s timezone; already-logged fire
windows are skipped (`SlackDigestLog` idempotency)
- Blank preference cron still falls back to `slack.daily-digest.cron`
- Manual/admin trigger still uses `sendDailyDigestHybrid()` (force all
recipients)

## Changes

### Backend

- **`SlackDailyDigestService`**: `sendPersonalizedDigests()` /
`sendDailyDigestHybrid()` / **`processDigestTick()`** — per-recipient
DMs, EXEC formatting, personalized logs, and per-user cron on the minute
tick
- **`DigestCronMatcher`**: Spring `CronExpression` due-window helper
(timezone-aware)
- **`DigestPreferenceSeedService`**: seed from singleton; persona
inference; skips inactive users
- **`SlackDailyDigestTaskConfig`**: minute tick → `processDigestTick()`
- **`DigestPreferenceController`**: seed/status; refuses EMAIL

### Frontend

- Digest preferences API + panel (persona, schedule presets, seed) +
DigestSection bell icon

### Documentation

- `docs/DIGEST_PREFERENCES.md` updated for tick vs global cron and
accurate “your own schedule”

## Acceptance Criteria

- [x] Two users, different roles/personas, same connection → different
Slack digests same window
- [x] Cron/config not singleton-only (**per-user cron honored on tick**)
- [x] Tests for per-recipient delivery + seed/legacy + due-cron /
timezone / idempotency
- [x] UI prefs for role/schedule/persona
- [x] Docs updated — “your own schedule” is accurate
- [x] No fake EMAIL / WhatsApp delivery advertised

## Out of Scope (Follow-ups)

1. Idle-in-transaction insight when Brain has data
2. `join_collapse_limit` cliffs under CONFIG_TUNING
3. DOCUMENTATION_GAPS miner
4. COST_CAPACITY dedicated cost miner for EXEC
5. Hermes/WhatsApp = PR4

## Dependencies

- PR1 #103: per-user digest prefs
- PR2 #104: role-aware insight assembler

## Testing

```bash
cd backend
./mvnw test -Dtest=PerRecipientDigestDeliveryTest,PerRecipientDigestCronSchedulingTest,DigestCronMatcherTest,DigestPreferenceSeedServiceTest,SlackDailyDigestServiceTest
```

Key scenarios: different crons → only due user; timezone
America/New_York 9AM = 13:00 UTC; idempotent window skip; EXEC 3
bullets; EMAIL skipped; seed idempotent; legacy when no enabled prefs.

<!-- CURSOR_AGENT_PR_BODY_END -->

---------

Co-authored-by: Cursor Agent <cursoragent@cursor.com>

Author: venkateshsakamuri-lab

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.
@@ -44,9 +49,23 @@ public ResponseEntity<List<UserDigestPreference>> getMyPreferences() {
     public ResponseEntity<UserDigestPreference> createPreference(@RequestBody CreatePreferenceRequest request) {
         String username = accessControlService.requireCurrentUsername();
 
-        DigestDeliveryMethod method = request.deliveryMethod != null
-            ? DigestDeliveryMethod.fromString(request.deliveryMethod)
-            : DigestDeliveryMethod.SLACK_DM;
+        DigestDeliveryMethod method;
+        if (request.deliveryMethod == null || request.deliveryMethod.isBlank()) {
+            method = DigestDeliveryMethod.SLACK_DM;
+        } else {
+            method = DigestDeliveryMethod.fromString(request.deliveryMethod);
+            if (method == null) {
+                throw new IllegalArgumentException("Unknown delivery method: " + request.deliveryMethod);
+            }
+        }
+
+        if (method == DigestDeliveryMethod.EMAIL) {
+            throw new IllegalArgumentException("Email digest delivery is not available yet");
+        }
+
+        if (request.connectionId != null && !request.connectionId.isBlank()) {
+            accessControlService.assertCanReadConnectionContent(request.connectionId);
+        }
 
         PersonaTag persona = request.personaTag != null
             ? PersonaTag.fromString(request.personaTag)
@@ -159,10 +178,10 @@ public ResponseEntity<List<Map<String, String>>> getPersonaTags() {
      */
     @GetMapping("/delivery-methods")
     public ResponseEntity<List<Map<String, String>>> getDeliveryMethods() {
+        // Only advertise methods this PR actually delivers. EMAIL/WhatsApp are PR4.
         List<Map<String, String>> methods = List.of(
             Map.of("value", "SLACK_DM", "label", DigestDeliveryMethod.SLACK_DM.getDisplayName(), "description", DigestDeliveryMethod.SLACK_DM.getDescription()),
-            Map.of("value", "SLACK_CHANNEL", "label", DigestDeliveryMethod.SLACK_CHANNEL.getDisplayName(), "description", DigestDeliveryMethod.SLACK_CHANNEL.getDescription()),
-            Map.of("value", "EMAIL", "label", DigestDeliveryMethod.EMAIL.getDisplayName(), "description", DigestDeliveryMethod.EMAIL.getDescription())
+            Map.of("value", "SLACK_CHANNEL", "label", DigestDeliveryMethod.SLACK_CHANNEL.getDisplayName(), "description", DigestDeliveryMethod.SLACK_CHANNEL.getDescription())
         );
         return ResponseEntity.ok(methods);
     }
@@ -181,4 +200,90 @@ 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) {}
+
+    @ExceptionHandler(IllegalArgumentException.class)
+    public ResponseEntity<Map<String, String>> handleBadRequest(IllegalArgumentException e) {
+        return ResponseEntity.badRequest().body(Map.of("message", e.getMessage() != null ? e.getMessage() : "Bad request"));
+    }
 }

backend/src/main/java/com/dbaagent/model/UserDigestPreference.java

@@ -103,7 +103,7 @@ public class UserDigestPreference {
 
     /**
      * Optional timezone for schedule interpretation.
-     * When null, uses system default (typically UTC).
+     * When null or invalid, the digest tick evaluates the cron in UTC.
      * Format: IANA timezone ID (e.g., "America/New_York", "Europe/London").
      */
     @Column(name = "timezone", length = 64)

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

@@ -91,4 +91,29 @@ 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);
+
+    /**
+     * Idempotency for per-preference scheduling: true if this preference already
+     * produced a digest log for the connection at or after the cron fire time.
+     */
+    boolean existsByPreferenceIdAndConnectionIdAndSentAtGreaterThanEqual(
+        Long preferenceId,
+        String connectionId,
+        LocalDateTime sentAt
+    );
+
+    /**
+     * Fallback idempotency when preferenceId is missing on older rows.
+     */
+    boolean existsByConnectionIdAndRecipientUsernameAndSentAtGreaterThanEqual(
+        String connectionId,
+        String recipientUsername,
+        LocalDateTime sentAt
+    );
 }

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();
 }