feat(notifications): follow modes, milestone alerts, notification enhancements

Follow Modes (neutral / pocket_veto / pocket_boost):
- Alembic migration 0013 adds follow_mode column to follows table
- FollowButton rewritten as mode-aware dropdown for bills; simple toggle for members/topics
- PATCH /api/follows/{id}/mode endpoint with validation
- Dispatcher filters pocket_veto follows (suppress new_document/new_amendment events)
- Dispatcher adds ntfy Actions header for pocket_boost follows

Change-driven (milestone) Alerts:
- New notification_utils.py with shared emit helpers and 30-min dedup
- congress_poller emits bill_updated events on milestone action text
- llm_processor replaced with shared emit util (also notifies member/topic followers)

Notification Enhancements:
- ntfy priority levels (high for bill_updated, default for others)
- Quiet hours (UTC): dispatcher holds events outside allowed window
- Digest mode (daily/weekly): send_notification_digest Celery beat task
- Notification history endpoint + Recent Alerts UI section
- Enriched following page (bill titles, member photos/details via sub-components)
- Follow mode test buttons in admin settings panel

Infrastructure:
- nginx: switch upstream blocks to set $variable proxy_pass so Docker DNS
  re-resolves upstream IPs after container rebuilds (valid=10s)
- TROUBLESHOOTING.md documenting common Docker/nginx/postgres gotchas

Authored-By: Jack Levy

backend/app/api/follows.py

@@ -7,11 +7,12 @@ from app.core.dependencies import get_current_user
 from app.database import get_db
 from app.models import Follow
 from app.models.user import User
-from app.schemas.schemas import FollowCreate, FollowSchema
+from app.schemas.schemas import FollowCreate, FollowModeUpdate, FollowSchema
 
 router = APIRouter()
 
 VALID_FOLLOW_TYPES = {"bill", "member", "topic"}
+VALID_MODES = {"neutral", "pocket_veto", "pocket_boost"}
 
 
 @router.get("", response_model=list[FollowSchema])
@@ -58,6 +59,26 @@ async def add_follow(
     return follow
 
 
+@router.patch("/{follow_id}/mode", response_model=FollowSchema)
+async def update_follow_mode(
+    follow_id: int,
+    body: FollowModeUpdate,
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    if body.follow_mode not in VALID_MODES:
+        raise HTTPException(status_code=400, detail=f"follow_mode must be one of {VALID_MODES}")
+    follow = await db.get(Follow, follow_id)
+    if not follow:
+        raise HTTPException(status_code=404, detail="Follow not found")
+    if follow.user_id != current_user.id:
+        raise HTTPException(status_code=403, detail="Not your follow")
+    follow.follow_mode = body.follow_mode
+    await db.commit()
+    await db.refresh(follow)
+    return follow
+
+
 @router.delete("/{follow_id}", status_code=204)
 async def remove_follow(
     follow_id: int,

backend/app/api/notifications.py

@@ -17,6 +17,8 @@ from app.database import get_db
 from app.models.notification import NotificationEvent
 from app.models.user import User
 from app.schemas.schemas import (
+    FollowModeTestRequest,
+    NotificationEventSchema,
     NotificationSettingsResponse,
     NotificationSettingsUpdate,
     NotificationTestResult,
@@ -42,6 +44,10 @@ def _prefs_to_response(prefs: dict, rss_token: str | None) -> NotificationSettin
         ntfy_enabled=prefs.get("ntfy_enabled", False),
         rss_enabled=prefs.get("rss_enabled", False),
         rss_token=rss_token,
+        digest_enabled=prefs.get("digest_enabled", False),
+        digest_frequency=prefs.get("digest_frequency", "daily"),
+        quiet_hours_start=prefs.get("quiet_hours_start"),
+        quiet_hours_end=prefs.get("quiet_hours_end"),
     )
 
 
@@ -82,6 +88,18 @@ async def update_notification_settings(
         prefs["ntfy_enabled"] = body.ntfy_enabled
     if body.rss_enabled is not None:
         prefs["rss_enabled"] = body.rss_enabled
+    if body.digest_enabled is not None:
+        prefs["digest_enabled"] = body.digest_enabled
+    if body.digest_frequency is not None:
+        prefs["digest_frequency"] = body.digest_frequency
+    if body.quiet_hours_start is not None:
+        prefs["quiet_hours_start"] = body.quiet_hours_start
+    if body.quiet_hours_end is not None:
+        prefs["quiet_hours_end"] = body.quiet_hours_end
+    # Allow clearing quiet hours by passing -1
+    if body.quiet_hours_start == -1:
+        prefs.pop("quiet_hours_start", None)
+        prefs.pop("quiet_hours_end", None)
 
     user.notification_prefs = prefs
 
@@ -171,6 +189,126 @@ async def test_rss(
     )
 
 
+@router.get("/history", response_model=list[NotificationEventSchema])
+async def get_notification_history(
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """Return the 50 most recent notification events for the current user."""
+    result = await db.execute(
+        select(NotificationEvent)
+        .where(NotificationEvent.user_id == current_user.id)
+        .order_by(NotificationEvent.created_at.desc())
+        .limit(50)
+    )
+    return result.scalars().all()
+
+
+@router.post("/test/follow-mode", response_model=NotificationTestResult)
+async def test_follow_mode(
+    body: FollowModeTestRequest,
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """Simulate dispatcher behaviour for a given follow mode + event type."""
+    from sqlalchemy import select as sa_select
+    from app.models.follow import Follow
+
+    VALID_MODES = {"pocket_veto", "pocket_boost"}
+    VALID_EVENTS = {"new_document", "new_amendment", "bill_updated"}
+    if body.mode not in VALID_MODES:
+        return NotificationTestResult(status="error", detail=f"mode must be one of {VALID_MODES}")
+    if body.event_type not in VALID_EVENTS:
+        return NotificationTestResult(status="error", detail=f"event_type must be one of {VALID_EVENTS}")
+
+    result = await db.execute(
+        sa_select(Follow).where(
+            Follow.user_id == current_user.id,
+            Follow.follow_type == "bill",
+        ).limit(1)
+    )
+    follow = result.scalar_one_or_none()
+    if not follow:
+        return NotificationTestResult(
+            status="error",
+            detail="No bill follows found — follow at least one bill first",
+        )
+
+    # Pocket Veto suppression: brief events are silently dropped
+    if body.mode == "pocket_veto" and body.event_type in ("new_document", "new_amendment"):
+        return NotificationTestResult(
+            status="ok",
+            detail=(
+                f"✓ Suppressed — Pocket Veto correctly blocked a '{body.event_type}' event. "
+                "No ntfy was sent (this is the expected behaviour)."
+            ),
+        )
+
+    # Everything else would send ntfy — check the user has it configured
+    user = await db.get(User, current_user.id)
+    prefs = user.notification_prefs or {}
+    ntfy_url = prefs.get("ntfy_topic_url", "").strip()
+    ntfy_enabled = prefs.get("ntfy_enabled", False)
+    if not ntfy_enabled or not ntfy_url:
+        return NotificationTestResult(
+            status="error",
+            detail="ntfy not configured or disabled — enable it in Notification Settings first.",
+        )
+
+    bill_url = f"{(app_settings.PUBLIC_URL or app_settings.LOCAL_URL).rstrip('/')}/bills/{follow.follow_value}"
+    event_titles = {
+        "new_document": "New Bill Text",
+        "new_amendment": "Amendment Filed",
+        "bill_updated": "Bill Updated",
+    }
+    mode_label = body.mode.replace("_", " ").title()
+    headers: dict[str, str] = {
+        "Title": f"[{mode_label} Test] {event_titles[body.event_type]}: {follow.follow_value.upper()}",
+        "Priority": "default",
+        "Tags": "test_tube",
+        "Click": bill_url,
+    }
+    if body.mode == "pocket_boost":
+        headers["Actions"] = (
+            f"view, View Bill, {bill_url}; "
+            "view, Find Your Rep, https://www.house.gov/representatives/find-your-representative"
+        )
+
+    auth_method = prefs.get("ntfy_auth_method", "none")
+    ntfy_token = prefs.get("ntfy_token", "").strip()
+    ntfy_username = prefs.get("ntfy_username", "").strip()
+    ntfy_password = prefs.get("ntfy_password", "").strip()
+    if auth_method == "token" and ntfy_token:
+        headers["Authorization"] = f"Bearer {ntfy_token}"
+    elif auth_method == "basic" and ntfy_username:
+        creds = base64.b64encode(f"{ntfy_username}:{ntfy_password}".encode()).decode()
+        headers["Authorization"] = f"Basic {creds}"
+
+    message_lines = [
+        f"This is a test of {mode_label} mode for bill {follow.follow_value.upper()}.",
+        f"Event type: {event_titles[body.event_type]}",
+    ]
+    if body.mode == "pocket_boost":
+        message_lines.append("Tap the action buttons below to view the bill or find your representative.")
+
+    try:
+        async with httpx.AsyncClient(timeout=10) as client:
+            resp = await client.post(
+                ntfy_url,
+                content="\n".join(message_lines).encode("utf-8"),
+                headers=headers,
+            )
+            resp.raise_for_status()
+        detail = f"✓ ntfy sent (HTTP {resp.status_code})"
+        if body.mode == "pocket_boost":
+            detail += " — check your phone for 'View Bill' and 'Find Your Rep' action buttons"
+        return NotificationTestResult(status="ok", detail=detail)
+    except httpx.HTTPStatusError as e:
+        return NotificationTestResult(status="error", detail=f"HTTP {e.response.status_code}: {e.response.text[:200]}")
+    except httpx.RequestError as e:
+        return NotificationTestResult(status="error", detail=f"Connection error: {e}")
+
+
 @router.get("/feed/{rss_token}.xml", include_in_schema=False)
 async def rss_feed(rss_token: str, db: AsyncSession = Depends(get_db)):
     """Public tokenized RSS feed — no auth required."""