diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index cb297e3..dd42e05 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -25,14 +25,18 @@ jobs:
         run: |
           pip install --upgrade pip
           pip install "Django>=4.2,<5" coverage
-        env:
-          PYTHONPATH: .
 
       - name: Run unit tests
         run: |
-          coverage run -m unittest coldfront_notifications.tests.test_unit -v
+          coverage run -m unittest \
+            coldfront_notifications.tests.test_resolvers \
+            coldfront_notifications.tests.test_validators \
+            coldfront_notifications.tests.test_tasks_unit \
+            coldfront_notifications.tests.test_filters \
+            coldfront_notifications.tests.test_conf \
+            -v
           coverage report --show-missing --fail-under=80 \
-            --include="coldfront_notifications/resolvers.py,coldfront_notifications/validators.py,coldfront_notifications/conf.py,coldfront_notifications/__init__.py"
+            --include="coldfront_notifications/template_variable_value_resolver.py,coldfront_notifications/notification_validator.py,coldfront_notifications/campaign_sender.py,coldfront_notifications/conf.py,coldfront_notifications/__init__.py"
         env:
           PYTHONPATH: .
 
@@ -86,27 +90,10 @@ jobs:
       - name: Check package
         run: twine check dist/*
 
-      - name: Verify wheel contents
+      - name: Verify wheel installs
         run: |
           pip install dist/*.whl
           python -c "
-          import django
-          from django.conf import settings
-          settings.configure(
-              INSTALLED_APPS=[
-                  'django.contrib.contenttypes',
-                  'django.contrib.auth',
-                  'django.contrib.admin',
-                  'django.contrib.sessions',
-                  'django.contrib.messages',
-                  'coldfront_notifications',
-              ],
-              DATABASES={'default': {'ENGINE': 'django.db.backends.sqlite3', 'NAME': ':memory:'}},
-              DEFAULT_AUTO_FIELD='django.db.models.BigAutoField',
-              AUTH_USER_MODEL='auth.User',
-              ROOT_URLCONF='coldfront_notifications.urls',
-          )
-          django.setup()
-          from coldfront_notifications import urls, models, views, resolvers, validators, tasks, conf
-          print('All modules importable')
+          import coldfront_notifications
+          print(f'Installed: coldfront_notifications {coldfront_notifications.__version__}')
           "
diff --git a/.gitignore b/.gitignore
index 0f03392..08da9a7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,7 +7,7 @@ __pycache__/
 dist/
 build/
 *.whl
-
+*bak
 # Virtual environments
 .venv/
 venv/
diff --git a/FILTERS.md b/FILTERS.md
new file mode 100644
index 0000000..2012da6
--- /dev/null
+++ b/FILTERS.md
@@ -0,0 +1,133 @@
+# Compose Notification — Filter System
+
+## Overview
+
+The compose page has 6 recipient filters. All filter data is loaded once on
+page load via `FilterDataBuilder`. The frontend `FilterStore` handles cascade
+narrowing entirely client-side — zero AJAX round-trips for filter changes.
+
+Two cascade directions:
+- **Top-down (narrow):** selecting a department narrows projects, resources,
+  and allocations via the visible set.
+- **Bottom-up (select):** selecting a role auto-selects matching departments.
+  Manual selections take priority over auto-selections.
+
+## Filters
+
+| Filter            | DOM ID          | Value type       | Class                |
+|-------------------|-----------------|------------------|----------------------|
+| Department        | `#f_dept`       | Dept PKs (int)   | `DepartmentFilter`   |
+| Project           | `#f_project`    | Project PKs      | `ProjectFilter`      |
+| Resource          | `#f_resource`   | Resource PKs     | `ResourceFilter`     |
+| Allocation Status | `#f_status`     | Status names     | `StatusFilter`       |
+| Allocation        | `#f_allocation` | Allocation PKs   | `AllocationFilter`   |
+| User Role         | `#f_role`       | Role names       | `RoleFilter`         |
+
+## Database Relationships
+
+```
+Department (Organization, org_tree='Research Computing Storage Billing')
+  └── Lab (OrgRelation, child__rank='lab')
+       └── Project (ProjectOrganization)
+            ├── Allocation
+            │    ├── Resource   (M2M via Allocation.resources)
+            │    └── Status     (FK to AllocationStatusChoice)
+            └── ProjectUser
+                 ├── User
+                 └── Role       (FK to ProjectUserRoleChoice)
+```
+
+Key: Department → Project traversal goes through OrgRelation and
+ProjectOrganization (not a direct FK). The `DepartmentFilter._apply()` method
+and `DepartmentFilter.initial_options()` both use this join chain.
+
+## Filter Cascade
+
+```
+Top-down narrowing:
+
+  Department → Projects → Resources
+                  ↑           ↓
+                  └── Resource narrows Projects too
+                       → Allocations ← Statuses
+
+Bottom-up context (detail cards only, no dropdown changes):
+
+  Allocation → shows Dept, Project, Resource, Status
+  Project    → shows Department
+  Role       → shows Departments and project count
+  Resource   → shows Departments and project count
+  Status     → shows matching allocation count
+```
+
+## State Model
+
+Each filter in the `FilterStore` has:
+- `all` — full server dataset, never changes after page load
+- `visible` — subset of `all` after upstream narrowing
+- `selected` — user's manual picks (subset of visible)
+- `autoSelected` — set by bottom-up propagation (role → departments)
+- `dismissed` — auto-selected items the user explicitly removed
+- `autoSource` — human-readable description of what triggered auto-select
+
+Downstream filters read `getEffectiveIds()` which returns:
+1. `selected` if any exist, else
+2. `visible` IDs if narrowed from `all`, else
+3. `null` (no constraint)
+
+## Backend Architecture
+
+All filter logic lives in `filters.py`:
+
+- **`BaseFilter`** — abstract class with `initial_options()` and `_apply()`
+- **6 filter classes** — each owns both its UI options and queryset filtering
+- **`FilterDataBuilder`** — assembles all filter data into JSON for page load
+- **`RecipientResolver`** — resolves selected filters into actual recipients
+  at send time
+
+## Frontend Architecture
+
+JS modules loaded in order:
+
+1. **`compose_filters.js`** — FilterStore, FilterWidget, narrowing functions,
+   bottom-up propagation, filter details cards, clear filters
+2. **`compose_validate.js`** — validation AJAX, send-bar UI
+3. **`compose_templates.js`** — template list/search/load, variable chips
+4. **`compose_preview.js`** — email preview and recipient preview modals
+5. **`compose_draft.js`** — draft auto-save, resume, dirty tracking
+6. **`compose_init.js`** — Select2 init, form submit serialization (loads last)
+
+## Filter Data Format
+
+Each filter's options from `FilterDataBuilder.build()`:
+
+```json
+{
+  "departments": {
+    "options": [
+      {"id": 1880, "label": "Chemistry and Chemical Biology", "project_ids": [55, 94, ...]}
+    ],
+    "narrowed_by": []
+  },
+  "projects": {
+    "options": [{"id": 1, "label": "alpha_lab"}],
+    "narrowed_by": ["departments"]
+  },
+  "resources": {
+    "options": [{"id": 38, "label": "FASRC Cluster", "project_ids": [2, 3, ...]}],
+    "narrowed_by": ["projects"]
+  },
+  "statuses": {
+    "options": [{"id": "Active", "label": "Active"}],
+    "narrowed_by": []
+  },
+  "allocations": {
+    "options": [{"id": 100, "label": "alpha_lab — Storage", "project_id": 1, "status": "Active", "resource_ids": [38]}],
+    "narrowed_by": ["projects", "resources", "statuses"]
+  },
+  "roles": {
+    "options": [{"id": "PI", "label": "PI", "project_ids": [1, 2, ...]}],
+    "narrowed_by": []
+  }
+}
+```
diff --git a/FUNCTIONAL_TEST_PROTOCOL.md b/FUNCTIONAL_TEST_PROTOCOL.md
new file mode 100644
index 0000000..cd461bb
--- /dev/null
+++ b/FUNCTIONAL_TEST_PROTOCOL.md
@@ -0,0 +1,319 @@
+# Functional Test Protocol — Compose Filters
+
+## Data Model
+
+```
+Department (18 available)
+  └── Labs (via OrgRelation, child rank='lab')
+       └── Projects (via ProjectOrganization) — 1,121 total
+            ├── Allocations — 2,574 total
+            │    ├── Resources — 1,912 total (M2M)
+            │    └── Status (Active, Pending Deactivation, Denied, etc.)
+            └── ProjectUser
+                 ├── User — 5,539 active
+                 └── Role (PI, General Manager, User, Storage Manager, Access Manager)
+```
+
+Selecting a department narrows projects to only those connected via
+the department's labs. Resources, allocations, and statuses narrow
+based on visible projects. Roles can auto-select departments bottom-up.
+
+---
+
+## Test Scenarios
+
+### Scenario 1 — Chemistry + General Manager (Sarah's use case)
+
+> "I want to email all the General Managers that belong to the Chemistry
+> Department, to let them know about an upcoming change to their software."
+
+**Data chain:**
+- Department: Chemistry and Chemical Biology (pk=1880)
+- Labs: 7 (aspuru_lab, kahne_lab, liau_lab, lieber_lab, shair_lab, gordon_lab, zheng_lab)
+- Projects: 7
+- General Managers across those projects: 6
+
+**Steps:**
+1. Open Compose Notification
+2. Select **Department** → "Chemistry and Chemical Biology"
+3. Verify: Projects dropdown narrows to **7 projects**
+4. Verify: Resources and Allocations narrow accordingly
+5. Verify: Detail card shows "Departments: 7 (of 1200) · 1 selected"
+6. Select **User Role** → "General Manager"
+7. Verify: Detail card shows role selected
+8. Click **Validate**
+9. Verify: **5 users** reported, button turns green
+
+**Expected result:** 5 recipients
+
+**Evidence:** [ ] Screenshot / [ ] Video
+
+---
+
+### Scenario 2 — bos-isilon/tier1 + PI (Sarah's use case)
+
+> "I need to let all the PIs that have data on bos-isilon/tier1 resource
+> that the storage will be down for an upgrade."
+
+**Data chain:**
+- Resource: bos-isilon/tier1 — linked to 113 projects
+- PIs across those projects: 110 (project scope)
+- PIs with AllocationUser records on those allocations: 88 (allocation scope)
+
+**Steps:**
+1. Open Compose Notification
+2. Select **Resource** → "bos-isilon/tier1"
+3. Verify: Allocations narrow to only bos-isilon allocations
+4. Select **User Role** → "PI"
+5. Verify: Departments do NOT auto-select (resource already picked)
+6. Click **Validate**
+7. Verify result depends on template:
+   - **No template / project-scoped template:** 110 users
+   - **Allocation-scoped template** (uses `{{allocation_path}}`, etc.): **88 users → 109 emails**
+
+**Expected result:** 110 users (project scope) or 88 users / 109 emails (allocation scope)
+
+**Note:** 22 PIs are on bos-isilon projects but don't have AllocationUser
+records, so they disappear when the template requires allocation-level data.
+
+**Evidence:** [ ] Screenshot / [ ] Video
+
+---
+
+### Scenario 3 — Economics + Pending Deactivation (Sarah's use case)
+
+> "I'm doing some data cleanup work with the Economics department and I
+> need to know what folders are pending deactivation."
+
+**Data chain:**
+- Department: Economics (pk=1883)
+- Projects: 13
+- Pending Deactivation allocations: 3 (manually set for testing)
+- Users on those allocations: 2
+
+**Steps:**
+1. Open Compose Notification
+2. Select **Department** → "Economics"
+3. Verify: Projects narrow to **13 projects**
+4. Select **Allocation Status** → "Pending Deactivation"
+5. Verify: Allocations narrow to only Pending Deactivation
+6. Verify: Detail card shows "Filtered by: Project, Alloc Status"
+7. Click **Validate**
+8. Verify: **2 users** reported
+
+**Expected result:** 2 recipients
+
+**Evidence:** [ ] Screenshot / [ ] Video
+
+---
+
+### Scenario 4 — No filters (all active users)
+
+**Data chain:**
+- All active ProjectUser records → all distinct users
+
+**Steps:**
+1. Open Compose Notification
+2. Do NOT select any filters
+3. Verify: All dropdowns show full counts (18 depts, 1200 projects, etc.)
+4. Verify: No detail cards shown (nothing active)
+5. Click **Validate**
+6. Verify: **5,539 users** reported
+
+**Expected result:** 5,539 recipients
+
+**Evidence:** [ ] Screenshot / [ ] Video
+
+---
+
+### Scenario 5 — Single department only (Astronomy)
+
+**Data chain:**
+- Department: Astronomy (pk=1878)
+- Labs: 9 (Alyssa Goodman, Charlie Conroy, Doug Finkbeiner, etc.)
+- Projects: 9
+
+**Steps:**
+1. Open Compose Notification
+2. Select **Department** → "Astronomy"
+3. Verify: Projects narrow to **9 projects**
+4. Verify: Resources narrow to only those linked to Astronomy allocations
+5. Verify: Detail card shows "Departments: 9 (of 1200) · 1 selected"
+6. Verify: Detail card shows "Filtered by: Department" on projects
+7. Click **Validate**
+8. Verify: **147 users** reported
+
+**Expected result:** 147 recipients
+
+**Evidence:** [ ] Screenshot / [ ] Video
+
+---
+
+### Scenario 6 — Bottom-up: Role auto-selects departments
+
+**Data chain:**
+- Role: Storage Manager — present in 57 projects across multiple departments
+
+**Steps:**
+1. Open Compose Notification
+2. Select **User Role** → "Storage Manager"
+3. Verify: Departments are **auto-selected** (blue pills appear in dropdown)
+4. Verify: Detail card shows "Auto-selected by User Role: Storage Manager"
+5. Verify: Projects narrow based on the auto-selected departments
+6. Click **Validate**
+7. Verify: **66 users** reported
+8. **Deselect** the role
+9. Verify: Auto-selected departments clear
+10. Verify: All filters reset to full counts
+
+**Expected result:** 66 recipients; auto-selection clears on role deselect
+
+**Evidence:** [ ] Screenshot / [ ] Video
+
+---
+
+### Scenario 7 — Resource + Status combo (active isilon users)
+
+**Data chain:**
+- Resource: bos-isilon/tier1 → 113 projects
+- Status: Active → intersection with isilon allocations
+
+**Steps:**
+1. Open Compose Notification
+2. Select **Resource** → "bos-isilon/tier1"
+3. Verify: Allocations narrow
+4. Select **Allocation Status** → "Active"
+5. Verify: Allocations narrow further (only Active + isilon)
+6. Verify: Detail card shows allocation breakdown with Active count
+7. Click **Validate**
+8. Verify: **548 users** reported
+
+**Expected result:** 548 recipients
+
+**Evidence:** [ ] Screenshot / [ ] Video
+
+---
+
+### Scenario 7b — Resource narrows Projects (team feedback fix)
+
+> "I filtered by resource for nesetape/tier3 and it showed 74 allocations.
+> But the project dropdown hadn't removed the projects that did not contain
+> that resource."
+
+**Data chain:**
+- Resource selected → its `project_ids` constrain the projects dropdown
+- Projects narrow → allocations narrow (cascade continues downstream)
+
+**Steps:**
+1. Open Compose Notification
+2. Verify: Projects dropdown shows full count (1200)
+3. Select **Resource** → pick any resource (e.g. "bos-isilon/tier1")
+4. Verify: **Projects dropdown narrows** to only projects with that resource
+5. Verify: Allocations narrow accordingly
+6. Verify: Detail card on Projects shows "Filtered by: Resource"
+7. **Deselect** the resource
+8. Verify: Projects return to full count (1200)
+
+**Expected result:** Projects narrow when resource is selected
+
+**Evidence:** [ ] Screenshot / [ ] Video
+
+---
+
+### Scenario 8 — Multiple departments
+
+**Data chain:**
+- Chemistry (7 projects) + Earth and Planetary Sciences (7 projects)
+- Combined: 14 projects (no overlap)
+
+**Steps:**
+1. Open Compose Notification
+2. Select **Department** → "Chemistry and Chemical Biology"
+3. Verify: Projects narrow to 7
+4. Add **Department** → "Earth and Planetary Sciences"
+5. Verify: Projects expand to **14** (union of both)
+6. Verify: Resources and Allocations reflect the combined scope
+7. Click **Validate**
+8. Verify: **145 users** reported
+9. **Remove** "Earth and Planetary Sciences"
+10. Verify: Projects narrow back to 7
+
+**Expected result:** 145 recipients with both; narrowing works on remove
+
+**Evidence:** [ ] Screenshot / [ ] Video
+
+---
+
+### Scenario 9 — FASRC Cluster + PI (cluster notification)
+
+**Data chain:**
+- Resource: FASRC Cluster — linked to most projects
+- PIs on FASRC Cluster: 127
+
+**Steps:**
+1. Open Compose Notification
+2. Select **Resource** → "FASRC Cluster"
+3. Select **User Role** → "PI"
+4. Verify: Role triggers bottom-up auto-select on departments
+5. Verify: But since resource was selected first, departments should NOT auto-select (manual resource selection takes priority in the cascade)
+6. Click **Validate**
+7. Verify: **127 users** reported
+
+**Expected result:** 127 recipients
+
+**Evidence:** [ ] Screenshot / [ ] Video
+
+---
+
+### Scenario 10 — Three-filter combo (SEAS + Active + PI)
+
+**Data chain:**
+- Department: School of Engineering and Applied Sciences (pk=1956) → 80 projects
+- Status: Active → narrows allocations
+- Role: PI → narrows to PIs only
+- Intersection: 54 users
+
+**Steps:**
+1. Open Compose Notification
+2. Select **Department** → "School of Engineering and Applied Sciences"
+3. Verify: Projects narrow to **80**
+4. Select **Allocation Status** → "Active"
+5. Verify: Allocations narrow to Active only within SEAS
+6. Select **User Role** → "PI"
+7. Verify: No bottom-up auto-select (department already manually selected)
+8. Verify: Detail cards show all three filters active
+9. Click **Validate**
+10. Verify: **54 users** reported
+
+**Expected result:** 54 recipients
+
+**Evidence:** [ ] Screenshot / [ ] Video
+
+---
+
+## Cascade Verification Checklist
+
+For each scenario, verify the following cascade behavior:
+
+| Check | How to verify |
+|---|---|
+| Top-down narrowing | Select a department → projects dropdown count decreases |
+| Resource narrowing from projects | Select a department → resources dropdown count decreases |
+| Allocation narrowing | Select department + status → allocations show fewer options |
+| Bottom-up auto-select | Select a role with no dept selected → departments auto-populate |
+| Manual overrides auto | Select a dept first, then a role → dept stays, no auto-select |
+| Clear Filters | Click "Clear Filters" → all dropdowns reset to full counts |
+| Detail cards update | Every filter change → detail cards reflect current state |
+| Validate button state | Green on success, red on error, gray on change |
+| Validation at top | Error/success message appears under filters AND at send bar |
+| Draft save | Click Save Draft → appears in campaign list with Draft badge |
+
+---
+
+## Test Environment
+
+- **URL:** http://127.0.0.1:2444/notifications/compose/
+- **Login:** antonio / antonio (superuser)
+- **Database:** MySQL in Docker (mysql-custom), database cf-contractor
+- **Data:** cf_contractor_dump.sql + test modifications (Pending Deactivation on Economics, extra General Managers on Chemistry)
+- **Email:** MailHog at http://127.0.0.1:8025 (catches all sent emails)
diff --git a/README.md b/README.md
index 2eb6fbd..17a6d09 100644
--- a/README.md
+++ b/README.md
@@ -5,23 +5,25 @@ A [ColdFront](https://coldfront.readthedocs.io/) plugin for sending bulk email n
 ## Features
 
 ### Compose & Send
-- **Cascading recipient filters** — filter by Project, Department, Allocation, Resource, Allocation Status, and User Role. Each filter narrows the downstream options in real time.
+- **Cascading recipient filters** — filter by Department, Project, Resource, Allocation Status, Allocation, and User Role. All filter data loads once on page load; cross-filter narrowing happens entirely client-side with zero AJAX round-trips. See [FILTERS.md](FILTERS.md) for the full architecture.
+- **Bidirectional cascade** — top-down (department narrows projects, resources, allocations) and bottom-up (selecting a role auto-selects matching departments).
 - **Template-based composition** — pick a saved template or write a one-off. Templates support `{{variable}}` placeholders that resolve per recipient.
 - **Live email preview** — preview the rendered email for sample recipients before sending. A dropdown lets you switch between recipients to see how variable substitution looks for each.
 - **Per-user dedupe control** — users matched on multiple projects/allocations can receive one email per context or be deduped to one. Controlled per-user in the recipient preview with a "Dedupe all" option.
 - **Pre-flight validation** — checks every `{{token}}` resolves for every recipient before enabling Send. Unknown tokens, empty values, and resolution errors are surfaced with clear messages.
+- **Draft auto-save** — compose progress is auto-saved every 30 seconds. Drafts are visible in the notifications list and can be resumed at any time. Navigate away without losing work.
 - **Per-email delivery** — each recipient gets an individually addressed email with their specific variable substitution. No bulk BCC.
 
 ### Template Variables
-- **Query variables** — auto-resolved per recipient from ColdFront data. 28 built-in resolver paths covering Recipient, Project, PI, Department, Role, Allocation, and Resource fields.
+- **Query variables** — auto-resolved per recipient from ColdFront data. Built-in resolver paths covering Recipient, Project, PI, Department, Role, Allocation, and Resource fields.
 - **Manual variables** — fixed values defined once at creation time and reused across all notifications (e.g. a maintenance date, a renewal URL).
 - **Full CRUD UI** — create, edit, soft-delete variables from the plugin's own interface. Query variables pick from a whitelisted dropdown; manual variables store a typed value.
 
 ### Notifications
 - **Dashboard** — stat cards (Total Delivered, Sending Now, Failed 30d, Total Notifications) plus a recent notifications table.
 - **Notification detail** — live delivery progress (AJAX polling), per-recipient log with status badges, and a view icon showing the exact rendered email as delivered.
+- **Notification list** — status filter tabs (All, Sent, Partial, Failed, Draft) with Edit action on drafts.
 - **Resend failed** — one-click resend to failed recipients.
-- **Soft delete** — deleted templates and variables remain visible (crossed out) on past notification details.
 
 ### Settings
 - **Sender & Reply-To management** — configure available From/Reply-To addresses with default flags.
@@ -66,6 +68,14 @@ INSTALLED_APPS += ["coldfront_notifications"]
 EXTRA_APPS_URLS = [
     ("notifications/", "coldfront_notifications.urls", "notifications"),
 ]
+
+# Templates and static files (adjust the path to your install location)
+TEMPLATES[0]['DIRS'] += [
+    '/usr/src/app/coldfront_notifications/coldfront_notifications/templates',
+]
+STATICFILES_DIRS += [
+    '/usr/src/app/coldfront_notifications/coldfront_notifications/static',
+]
 ```
 
 If your ColdFront instance doesn't already wire `EXTRA_APPS_URLS`, add this to your main `urls.py`:
@@ -110,7 +120,7 @@ with open('coldfront_notifications/coldfront_notifications/fixtures/variables.js
 "
 ```
 
-Or create your own variables from the UI: **Notifications → Template Variables → New Variable**.
+Or create your own variables from the UI: **Notifications > Template Variables > New Variable**.
 
 ### Configure sender addresses
 
@@ -120,7 +130,7 @@ If your ColdFront instance has `EMAIL_SENDER`, `EMAIL_TICKET_SYSTEM_ADDRESS`, or
 python manage.py seed_notification_senders
 ```
 
-Safe to re-run — skips addresses that already exist. You can also manage addresses manually at **Notifications → Settings**.
+Safe to re-run — skips addresses that already exist. You can also manage addresses manually at **Notifications > Settings**.
 
 ---
 
@@ -187,13 +197,30 @@ No code changes — the SMTP path is identical.
 
 ---
 
+## Module Structure
+
+| Module | Purpose |
+|---|---|
+| `models.py` | NotificationCampaign, NotificationLog, NotificationTemplate, NotificationVariable, SenderConfig |
+| `filters.py` | FilterDataBuilder, RecipientResolver, 6 filter classes |
+| `template_variable_value_resolver.py` | ResolverRegistry, resolver groups, ResolverContext |
+| `notification_validator.py` | NotificationValidator, extract_tokens, determine_scope |
+| `campaign_sender.py` | CampaignSender, TemplateRenderer, SmtpDelivery, Celery task |
+| `views/compose.py` | ComposeView, RecipientCountView, PreviewRenderView, ValidateView, DraftSaveView |
+| `views/campaigns.py` | CampaignListView, CampaignDetailView, ResendFailedView, ResendComposeView |
+| `views/templates.py` | TemplateListView, TemplateFormView, TemplateDeleteView, TemplateJsonView |
+| `views/settings.py` | VariableListView, VariableFormView, SettingsView, SenderFormView |
+| `views/helpers.py` | StaffRequiredMixin, dispatch_send |
+
+---
+
 ## Navigation
 
 | Menu item | Path | Description |
 |---|---|---|
 | Dashboard | `/notifications/` | Stats + recent notifications |
-| Notifications | `/notifications/campaigns/` | Full list with status filter |
-| Compose Notification | `/notifications/compose/` | Build and send |
+| Notifications | `/notifications/campaigns/` | Full list with status filter (incl. Draft) |
+| Compose Notification | `/notifications/compose/` | Build and send (or `?draft=<pk>` to resume) |
 | Templates | `/notifications/templates/` | Create/edit/delete templates |
 | Template Variables | `/notifications/variables/` | Create/edit/delete `{{token}}` definitions |
 | Settings | `/notifications/settings/` | Sender/reply-to addresses |
diff --git a/coldfront_notifications/admin.py b/coldfront_notifications/admin.py
index 9d25100..070609d 100644
--- a/coldfront_notifications/admin.py
+++ b/coldfront_notifications/admin.py
@@ -8,19 +8,19 @@
     NotificationVariable,
     SenderConfig,
 )
-from .resolvers import QUERY_CHOICES
+from .template_variable_value_resolver import registry as resolver_registry
 
 
 class NotificationVariableForm(forms.ModelForm):
     """
-    Force resolver_key into a whitelisted dropdown built from QUERY_CHOICES.
+    Force resolver_key into a whitelisted dropdown built from resolver_registry.choices.
     When source=manual, the field is hidden/cleared.
     """
     resolver_key = forms.ChoiceField(
         required=False,
         choices=(
             [("", "— choose a query path —")]
-            + [(k, f"{group}: {label}") for (k, label, group) in QUERY_CHOICES]
+            + [(k, f"{group}: {label}") for (k, label, group) in resolver_registry.choices]
         ),
         help_text="Only used when Source = Query.",
     )
@@ -35,9 +35,9 @@ class Meta:
 
     def clean(self):
         cleaned = super().clean()
-        if cleaned.get("source") == NotificationVariable.SOURCE_MANUAL:
+        if cleaned.get("source") == NotificationVariable.Source.MANUAL:
             cleaned["resolver_key"] = ""
-        elif cleaned.get("source") == NotificationVariable.SOURCE_QUERY:
+        elif cleaned.get("source") == NotificationVariable.Source.QUERY:
             if not cleaned.get("resolver_key"):
                 raise forms.ValidationError(
                     "Pick a query source when Source = Query."
diff --git a/coldfront_notifications/campaign_sender.py b/coldfront_notifications/campaign_sender.py
new file mode 100644
index 0000000..abf70eb
--- /dev/null
+++ b/coldfront_notifications/campaign_sender.py
@@ -0,0 +1,312 @@
+"""
+Celery task and sender logic for notification campaigns.
+
+CampaignSender resolves template variables for each recipient, renders
+the subject/body, and sends emails in batches over a single SMTP connection
+with retry on transient errors.
+"""
+from __future__ import annotations
+
+import logging
+import re
+import smtplib
+import time
+
+from django.conf import settings
+from django.core.mail import EmailMessage, get_connection
+from django.utils import timezone
+
+from .conf import BATCH_SIZE, BATCH_DELAY, MAX_RETRIES, RETRY_DELAY
+from .filters import RecipientResolver
+from .models import NotificationCampaign, NotificationLog, NotificationVariable
+from .notification_validator import extract_tokens, determine_scope
+from .template_variable_value_resolver import MissingValue, registry as resolver_registry
+
+logger = logging.getLogger(__name__)
+
+try:
+    from celery import shared_task
+except ImportError:
+    def shared_task(fn):
+        return fn
+
+TOKEN_PATTERN = re.compile(r"\{\{(\w+)\}\}")
+
+
+class TemplateRenderer:
+    """Renders {{token}} placeholders in subject/body strings."""
+
+    def render(self, template_string: str, values: dict) -> str:
+        def replace_token(match):
+            token = match.group(1)
+            return values[token] if token in values else match.group(0)
+        return TOKEN_PATTERN.sub(replace_token, template_string or "")
+
+    def build_values(self, tokens: list[str], variables_by_key: dict, context: dict) -> dict:
+        """Resolve all token values for a single recipient context."""
+        values = {}
+        for token in tokens:
+            variable = variables_by_key.get(token)
+            if variable is None:
+                raise MissingValue(f"unknown token {token!r}")
+
+            if variable.source == NotificationVariable.Source.MANUAL:
+                stored_value = (variable.value or "").strip()
+                if not stored_value and variable.is_required:
+                    raise MissingValue(f"manual variable {token!r} has no stored value")
+                values[token] = variable.value or ""
+            else:
+                try:
+                    values[token] = resolver_registry.resolve(variable.resolver_key, context)
+                except MissingValue:
+                    raise MissingValue(
+                        f"cannot resolve {variable.resolver_key} for {context['user'].email}"
+                    )
+        return values
+
+
+class SmtpDelivery:
+    """Handles SMTP delivery with retry logic for transient errors."""
+
+    def __init__(self, max_retries: int = MAX_RETRIES, retry_delay: float = RETRY_DELAY):
+        self.max_retries = max_retries
+        self.retry_delay = retry_delay
+
+    def is_transient_error(self, exception) -> bool:
+        if isinstance(exception, smtplib.SMTPResponseException):
+            return 400 <= exception.smtp_code < 500
+        if isinstance(exception, smtplib.SMTPServerDisconnected):
+            return True
+        if isinstance(exception, ConnectionError):
+            return True
+        return False
+
+    def send_with_retry(self, message: EmailMessage, connection) -> Exception | None:
+        """Send a message with retry on transient errors.
+
+        Returns None on success or the exception on permanent failure.
+        """
+        last_exception = None
+        for attempt in range(self.max_retries + 1):
+            try:
+                message.connection = connection
+                message.send()
+                return None
+            except Exception as exception:
+                last_exception = exception
+                if not self.is_transient_error(exception) or attempt == self.max_retries:
+                    return exception
+
+                delay = self.retry_delay * (2 ** attempt)
+                logger.warning(
+                    "Transient SMTP error (attempt %d/%d), retrying in %.1fs: %s",
+                    attempt + 1, self.max_retries + 1, delay, exception,
+                )
+                time.sleep(delay)
+                self._reopen_connection(connection)
+        return last_exception
+
+    def _reopen_connection(self, connection):
+        try:
+            connection.close()
+        except Exception:
+            pass
+        try:
+            connection.open()
+        except Exception as reopen_exception:
+            logger.error("Failed to re-open SMTP connection: %s", reopen_exception)
+            raise
+
+
+class CampaignSender:
+    """Orchestrates sending a notification campaign.
+
+    Phase 1: Resolve all template variables for every recipient.
+    Phase 2: Send emails in batches over a single SMTP connection.
+    """
+
+    def __init__(self, campaign: NotificationCampaign):
+        self.campaign = campaign
+        self.renderer = TemplateRenderer()
+        self.delivery = SmtpDelivery()
+
+    def send(self):
+        """Execute the full send pipeline."""
+        campaign = self.campaign
+
+        campaign.status = NotificationCampaign.Status.SENDING
+        campaign.sent_at = timezone.now()
+        campaign.save(update_fields=["status", "sent_at"])
+        campaign.logs.all().delete()
+
+        tokens = extract_tokens(campaign.subject, campaign.body)
+        variables_by_key = {
+            variable.key: variable
+            for variable in NotificationVariable.objects.filter(key__in=tokens)
+        }
+
+        unknown_tokens = [token for token in tokens if token not in variables_by_key]
+        if unknown_tokens:
+            self._fail(f"Unknown tokens: {', '.join(unknown_tokens)}")
+            return
+
+        scope = determine_scope(list(variables_by_key.values()))
+        snapshot = campaign.filters_snapshot or {}
+        dedupe_users = snapshot.get("dedupe_users") or []
+
+        resolved_emails = self._resolve_all_recipients(
+            tokens, variables_by_key, snapshot, scope, dedupe_users,
+        )
+        if resolved_emails is None:
+            return  # _fail already called
+
+        if not resolved_emails:
+            self._fail("No recipients matched the filters.")
+            return
+
+        campaign.recipient_count = len(resolved_emails)
+        campaign.save(update_fields=["recipient_count"])
+
+        logger.info(
+            "Campaign %s: %d emails to send (batch_size=%d, delay=%.1fs)",
+            campaign.pk, len(resolved_emails), BATCH_SIZE, BATCH_DELAY,
+        )
+
+        self._deliver_emails(resolved_emails, snapshot)
+
+    def _resolve_all_recipients(self, tokens, variables_by_key, snapshot, scope, dedupe_users):
+        """Resolve template variables for every recipient.
+
+        Returns a list of (user, project, allocation, rendered_subject, rendered_body)
+        tuples, or None if a resolution error occurred.
+        """
+        resolver = RecipientResolver(snapshot)
+        resolved = []
+
+        for user, project, allocation in resolver.enumerate_deduped(scope, dedupe_users):
+            context = {"user": user, "project": project, "allocation": allocation}
+            try:
+                values = self.renderer.build_values(tokens, variables_by_key, context)
+            except MissingValue as error:
+                self._fail(f"Resolution error: {error}")
+                return None
+
+            resolved.append((
+                user, project, allocation,
+                self.renderer.render(self.campaign.subject, values),
+                self.renderer.render(self.campaign.body, values),
+            ))
+
+        return resolved
+
+    def _deliver_emails(self, resolved_emails, snapshot):
+        """Send resolved emails in batches over a single SMTP connection."""
+        campaign = self.campaign
+        bcc_recipients = list(set(
+            address.strip()
+            for address in snapshot.get("extra_recipients", [])
+            if address.strip()
+        ))
+
+        delivered_count = 0
+        failed_count = 0
+
+        connection = get_connection()
+        try:
+            connection.open()
+        except Exception as exception:
+            self._fail(f"Cannot open SMTP connection: {exception}")
+            return
+
+        try:
+            for index, (user, project, allocation, rendered_subject, rendered_body) in enumerate(resolved_emails):
+                log_entry = NotificationLog.objects.create(
+                    campaign=campaign,
+                    email=user.email,
+                    status=NotificationLog.Status.QUEUED,
+                    rendered_subject=rendered_subject,
+                    rendered_body=rendered_body,
+                    project_id=project.pk if project else None,
+                    allocation_id=allocation.pk if allocation else None,
+                )
+
+                to = [user.email]
+                bcc = bcc_recipients if index == 0 else []
+                if settings.DEBUG:
+                    dev_list = getattr(settings, "EMAIL_DEVELOPMENT_EMAIL_LIST", [])
+                    if dev_list:
+                        to = list(dev_list)
+                        if bcc:
+                            bcc = list(dev_list)
+
+                message = EmailMessage(
+                    subject=rendered_subject,
+                    body=rendered_body,
+                    from_email=campaign.sender,
+                    to=to,
+                    bcc=bcc,
+                    reply_to=[campaign.reply_to] if campaign.reply_to else [],
+                )
+
+                send_error = self.delivery.send_with_retry(message, connection)
+                if send_error is None:
+                    log_entry.status = NotificationLog.Status.DELIVERED
+                    delivered_count += 1
+                else:
+                    log_entry.status = NotificationLog.Status.FAILED
+                    log_entry.notes = str(send_error)[:500]
+                    failed_count += 1
+
+                log_entry.save(update_fields=["status", "notes"])
+
+                if (index + 1) % BATCH_SIZE == 0:
+                    campaign.delivered_count = delivered_count
+                    campaign.failed_count = failed_count
+                    campaign.save(update_fields=["delivered_count", "failed_count"])
+
+                    if index + 1 < len(resolved_emails):
+                        logger.info(
+                            "Campaign %s: batch pause after %d/%d emails",
+                            campaign.pk, index + 1, len(resolved_emails),
+                        )
+                        time.sleep(BATCH_DELAY)
+        finally:
+            try:
+                connection.close()
+            except Exception:
+                pass
+
+        campaign.status = (
+            NotificationCampaign.Status.SENT if failed_count == 0
+            else NotificationCampaign.Status.PARTIAL if delivered_count > 0
+            else NotificationCampaign.Status.FAILED
+        )
+        campaign.delivered_count = delivered_count
+        campaign.failed_count = failed_count
+        campaign.recipient_count = delivered_count + failed_count
+        campaign.completed_at = timezone.now()
+        campaign.save(update_fields=[
+            "status", "delivered_count", "failed_count",
+            "recipient_count", "completed_at",
+        ])
+
+        logger.info(
+            "Campaign %s complete: %d delivered, %d failed (of %d total)",
+            campaign.pk, delivered_count, failed_count, delivered_count + failed_count,
+        )
+
+    def _fail(self, reason: str):
+        self.campaign.status = NotificationCampaign.Status.FAILED
+        self.campaign.completed_at = timezone.now()
+        self.campaign.save(update_fields=["status", "completed_at"])
+        logger.error("Campaign %s FAILED: %s", self.campaign.pk, reason)
+
+
+@shared_task
+def send_notification_campaign(campaign_pk: int):
+    try:
+        campaign = NotificationCampaign.objects.get(pk=campaign_pk)
+    except NotificationCampaign.DoesNotExist:
+        logger.error("Campaign %s not found", campaign_pk)
+        return
+    CampaignSender(campaign).send()
diff --git a/coldfront_notifications/conf.py b/coldfront_notifications/conf.py
index 8d5ab14..2bd0a36 100644
--- a/coldfront_notifications/conf.py
+++ b/coldfront_notifications/conf.py
@@ -11,14 +11,11 @@
 """
 from django.conf import settings
 
-# ── Email dispatch ────────────────────────────────────────────────
 BATCH_SIZE   = getattr(settings, "NOTIFICATION_BATCH_SIZE",  50)
 BATCH_DELAY  = getattr(settings, "NOTIFICATION_BATCH_DELAY", 2.0)   # seconds
 MAX_RETRIES  = getattr(settings, "NOTIFICATION_MAX_RETRIES", 3)
 RETRY_DELAY  = getattr(settings, "NOTIFICATION_RETRY_DELAY", 1.0)   # seconds, doubles each retry
 
-# ── Recipient preview ────────────────────────────────────────────
 PREVIEW_PAGE_SIZE = getattr(settings, "NOTIFICATION_PREVIEW_PAGE_SIZE", 50)
 
-# ── Preview render (email preview modal) ─────────────────────────
 PREVIEW_RENDER_LIMIT = getattr(settings, "NOTIFICATION_PREVIEW_RENDER_LIMIT", 10)
diff --git a/coldfront_notifications/filters.py b/coldfront_notifications/filters.py
new file mode 100644
index 0000000..3b9e3b0
--- /dev/null
+++ b/coldfront_notifications/filters.py
@@ -0,0 +1,411 @@
+"""
+Filter engine for the compose page.
+
+Each filter class owns:
+- ``initial_options()`` — UI dropdown data for the frontend
+- ``_apply(qs, values)`` — queryset narrowing for recipient resolution
+
+``FilterDataBuilder`` assembles all filter data into a single JSON-ready
+payload that the frontend uses for client-side cross-filter cascading.
+"""
+from __future__ import annotations
+
+import json
+from collections import defaultdict
+from typing import Any
+
+from django.contrib.auth import get_user_model
+
+from coldfront.core.allocation.models import (
+    Allocation,
+    AllocationStatusChoice,
+    AllocationUser,
+)
+from coldfront.core.department.models import Department
+from coldfront.core.project.models import Project, ProjectUser, ProjectUserRoleChoice
+from ifxuser.models import OrgRelation
+
+User = get_user_model()
+
+
+class BaseFilter:
+    """Abstract interface for all compose-page filters."""
+
+    def initial_options(self) -> list[dict[str, Any]]:
+        raise NotImplementedError
+
+    def narrowed_by(self) -> list[str]:
+        return []
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "options": self.initial_options(),
+            "narrowed_by": self.narrowed_by(),
+        }
+
+    def apply(self, queryset, values):
+        if not values:
+            return queryset
+        return self._apply(queryset, values)
+
+    def _apply(self, queryset, values):
+        raise NotImplementedError
+
+
+# Concrete filters
+
+class DepartmentFilter(BaseFilter):
+    """Departments linked to projects via OrgRelation → ProjectOrganization."""
+
+    def initial_options(self) -> list[dict[str, Any]]:
+        departments = list(
+            Department.objects.order_by("name")
+            .values_list("pk", "name")
+        )
+        if not departments:
+            return []
+
+        department_ids = {pk for pk, _ in departments}
+
+        department_projects = (
+            OrgRelation.objects
+            .filter(
+                parent_id__in=department_ids,
+                child__rank="lab",
+                child__projectorganization__isnull=False,
+            )
+            .values_list(
+                "parent_id",
+                "child__projectorganization__project_id",
+            )
+            .distinct()
+        )
+
+        project_ids_by_department: dict[int, set[int]] = defaultdict(set)
+        for department_pk, project_id in department_projects:
+            project_ids_by_department[department_pk].add(project_id)
+
+        return [
+            {
+                "id": pk,
+                "label": name,
+                "project_ids": sorted(project_ids_by_department.get(pk, set())),
+            }
+            for pk, name in departments
+        ]
+
+    def _apply(self, project_users, department_pks):
+        project_ids = (
+            OrgRelation.objects
+            .filter(
+                parent_id__in=department_pks,
+                child__rank="lab",
+                child__projectorganization__isnull=False,
+            )
+            .values_list("child__projectorganization__project_id", flat=True)
+            .distinct()
+        )
+        return project_users.filter(project_id__in=project_ids)
+
+
+class ProjectFilter(BaseFilter):
+    """All projects, narrowed by department selections."""
+
+    def initial_options(self) -> list[dict[str, Any]]:
+        return [
+            {"id": pk, "label": title}
+            for pk, title in (
+                Project.objects.order_by("title").values_list("pk", "title")
+            )
+        ]
+
+    def narrowed_by(self) -> list[str]:
+        return ["departments"]
+
+    def _apply(self, project_users, project_pks):
+        return project_users.filter(project__pk__in=project_pks)
+
+
+class ResourceFilter(BaseFilter):
+    """Resources linked to projects through allocations."""
+
+    def initial_options(self) -> list[dict[str, Any]]:
+        resource_allocations = (
+            Allocation.objects
+            .values_list("resources__pk", "resources__name", "project_id")
+            .distinct()
+        )
+
+        resources_by_pk: dict[int, dict[str, Any]] = {}
+        for resource_pk, resource_name, project_id in resource_allocations:
+            if resource_pk is None:
+                continue
+            if resource_pk not in resources_by_pk:
+                resources_by_pk[resource_pk] = {
+                    "id": resource_pk,
+                    "label": resource_name,
+                    "project_ids": set(),
+                }
+            if project_id is not None:
+                resources_by_pk[resource_pk]["project_ids"].add(project_id)
+
+        options = sorted(resources_by_pk.values(), key=lambda r: r["label"])
+        for option in options:
+            option["project_ids"] = sorted(option["project_ids"])
+
+        return options
+
+    def narrowed_by(self) -> list[str]:
+        return ["projects"]
+
+    def _apply(self, allocations, resource_pks):
+        return allocations.filter(resources__pk__in=resource_pks)
+
+
+class StatusFilter(BaseFilter):
+    """Allocation status choices."""
+
+    def initial_options(self) -> list[dict[str, Any]]:
+        return [
+            {"id": name, "label": name}
+            for name in (
+                AllocationStatusChoice.objects
+                .order_by("name")
+                .values_list("name", flat=True)
+            )
+        ]
+
+    def _apply(self, allocations, status_names):
+        return allocations.filter(status__name__in=status_names)
+
+
+class AllocationFilter(BaseFilter):
+    """Allocations with FK columns for cross-filtering."""
+
+    def initial_options(self) -> list[dict[str, Any]]:
+        allocations = (
+            Allocation.objects
+            .select_related("project", "status")
+            .prefetch_related("resources")
+            .order_by("project__title", "pk")
+        )
+
+        options = []
+        for allocation in allocations:
+            parent_resource = allocation.get_parent_resource
+            status_name = allocation.status.name if allocation.status else ""
+            label = f"{allocation.project.title} \u2014 {parent_resource or ''} [{status_name}] (#{allocation.pk})"
+            options.append({
+                "id": allocation.pk,
+                "label": label,
+                "project_id": allocation.project_id,
+                "status": allocation.status.name if allocation.status else "",
+                "resource_ids": sorted(
+                    allocation.resources.values_list("pk", flat=True)
+                ),
+            })
+
+        return options
+
+    def narrowed_by(self) -> list[str]:
+        return ["projects", "resources", "statuses"]
+
+    def _apply(self, allocations, allocation_pks):
+        return allocations.filter(pk__in=allocation_pks)
+
+
+class RoleFilter(BaseFilter):
+    """Project user role choices with project_ids for bottom-up selection."""
+
+    def initial_options(self) -> list[dict[str, Any]]:
+        roles = list(
+            ProjectUserRoleChoice.objects
+            .order_by("name")
+            .values_list("name", flat=True)
+        )
+        if not roles:
+            return []
+
+        role_projects = (
+            ProjectUser.objects
+            .filter(status__name="Active")
+            .values_list("role__name", "project_id")
+            .distinct()
+        )
+
+        project_ids_by_role: dict[str, set[int]] = defaultdict(set)
+        for role_name, project_id in role_projects:
+            if role_name and project_id is not None:
+                project_ids_by_role[role_name].add(project_id)
+
+        return [
+            {
+                "id": name,
+                "label": name,
+                "project_ids": sorted(project_ids_by_role.get(name, set())),
+            }
+            for name in roles
+        ]
+
+    def _apply(self, project_users, role_names):
+        return project_users.filter(role__name__in=role_names)
+
+
+# Registry
+
+FILTER_REGISTRY: dict[str, type[BaseFilter]] = {
+    "departments": DepartmentFilter,
+    "projects": ProjectFilter,
+    "resources": ResourceFilter,
+    "statuses": StatusFilter,
+    "allocations": AllocationFilter,
+    "roles": RoleFilter,
+}
+
+PROJECT_FILTERS = ("departments", "projects", "roles")
+ALLOCATION_FILTERS = ("allocations", "resources", "statuses")
+
+
+# FilterDataBuilder
+
+class FilterDataBuilder:
+    """Assembles all filter data into a single JSON-ready payload."""
+
+    def build(self) -> dict[str, dict[str, Any]]:
+        return {
+            name: cls().to_dict()
+            for name, cls in FILTER_REGISTRY.items()
+        }
+
+    def build_json(self) -> str:
+        return json.dumps(self.build())
+
+
+# RecipientResolver
+
+class RecipientResolver:
+    """Resolves the selected filter values into actual recipients at send time.
+
+    Accepts the filters dict from the compose POST and produces User
+    querysets or (user, project, allocation) tuples for email rendering.
+    """
+
+    def __init__(self, filters: dict):
+        self.filters = filters
+
+    def _apply_project_filters(self, project_users):
+        for name in PROJECT_FILTERS:
+            values = self.filters.get(name) or []
+            if values:
+                project_users = FILTER_REGISTRY[name]().apply(project_users, values)
+        return project_users
+
+    def _apply_allocation_filters(self):
+        allocations = Allocation.objects.all()
+        for name in ALLOCATION_FILTERS:
+            values = self.filters.get(name) or []
+            if values:
+                allocations = FILTER_REGISTRY[name]().apply(allocations, values)
+        return allocations
+
+    def _has_allocation_filters(self):
+        return any(self.filters.get(name) for name in ALLOCATION_FILTERS)
+
+    def queryset(self):
+        """Return a deduplicated User queryset matching the filters."""
+        project_users = self._apply_project_filters(
+            ProjectUser.objects.select_related("user", "project")
+            .filter(status__name="Active"),
+        )
+
+        if self._has_allocation_filters():
+            allocation_user_pks = (
+                AllocationUser.objects
+                .filter(
+                    allocation__in=self._apply_allocation_filters(),
+                    status__name="Active",
+                )
+                .values_list("user__pk", flat=True)
+            )
+            project_users = project_users.filter(user__pk__in=allocation_user_pks)
+
+        user_pks = project_users.values_list("user__pk", flat=True).distinct()
+        return User.objects.filter(pk__in=user_pks)
+
+    def count(self) -> int:
+        return self.queryset().count()
+
+    def enumerate(self, scope: str):
+        """Yield (user, project, allocation) tuples.
+
+        scope:
+          "allocation" — one tuple per (user, project, allocation) match
+          "project"    — one tuple per (user, project); allocation=None
+          "user"       — one tuple per distinct user; project=None, allocation=None
+        """
+        if scope not in ("user", "project", "allocation"):
+            raise ValueError(f"Unknown scope {scope!r}")
+
+        if scope == "user":
+            for user in self.queryset().iterator():
+                yield (user, None, None)
+            return
+
+        project_users = self._apply_project_filters(
+            ProjectUser.objects
+            .select_related(
+                "user", "project", "project__pi", "project__status", "role",
+            )
+            .filter(status__name="Active"),
+        ).order_by("user_id", "project_id", "pk")
+
+        if scope == "project":
+            if self._has_allocation_filters():
+                allocation_user_pks = (
+                    AllocationUser.objects
+                    .filter(
+                        allocation__in=self._apply_allocation_filters(),
+                        status__name="Active",
+                    )
+                    .values_list("user__pk", flat=True)
+                    .distinct()
+                )
+                project_users = project_users.filter(user__pk__in=allocation_user_pks)
+            for project_user in project_users.iterator():
+                yield (project_user.user, project_user.project, None)
+            return
+
+        # scope == "allocation"
+        matched_allocations = self._apply_allocation_filters()
+        allocation_users = (
+            AllocationUser.objects
+            .select_related(
+                "allocation", "allocation__status", "allocation__project",
+            )
+            .filter(allocation__in=matched_allocations, status__name="Active")
+            .order_by("user_id", "allocation_id", "pk")
+        )
+
+        allocations_by_user_project = defaultdict(list)
+        for allocation_user in allocation_users.iterator():
+            key = (allocation_user.user_id, allocation_user.allocation.project_id)
+            allocations_by_user_project[key].append(allocation_user.allocation)
+
+        for project_user in project_users.iterator():
+            key = (project_user.user_id, project_user.project_id)
+            for allocation in allocations_by_user_project.get(key, []):
+                yield (project_user.user, project_user.project, allocation)
+
+    def enumerate_deduped(self, scope: str, dedupe_users):
+        """Wraps enumerate with per-user deduplication."""
+        dedupe = set(dedupe_users or [])
+        if not dedupe:
+            yield from self.enumerate(scope)
+            return
+        seen = set()
+        for user, project, allocation in self.enumerate(scope):
+            if user.username in dedupe:
+                if user.pk in seen:
+                    continue
+                seen.add(user.pk)
+            yield (user, project, allocation)
diff --git a/coldfront_notifications/forms.py b/coldfront_notifications/forms.py
index b2e2ae3..a44a2e4 100644
--- a/coldfront_notifications/forms.py
+++ b/coldfront_notifications/forms.py
@@ -1,18 +1,18 @@
 from django import forms
 from django.utils.text import slugify
 from .models import NotificationTemplate, NotificationVariable, SenderConfig
-from .resolvers import QUERY_CHOICES
+from .template_variable_value_resolver import registry as resolver_registry
 
 
 class NotificationVariableForm(forms.ModelForm):
     """Plugin-side form (Bootstrap-themed). Restricts resolver_key to the
-    whitelisted QUERY_CHOICES so admins can't invent arbitrary ORM paths."""
+    whitelisted resolver_registry.choices so admins can't invent arbitrary ORM paths."""
 
     resolver_key = forms.ChoiceField(
         required=False,
         choices=(
             [("", "— choose a query source —")]
-            + [(k, f"{group}: {label}") for (k, label, group) in QUERY_CHOICES]
+            + [(k, f"{group}: {label}") for (k, label, group) in resolver_registry.choices]
         ),
         widget=forms.Select(attrs={"class": "form-control"}),
     )
@@ -38,12 +38,12 @@ class Meta:
     def clean(self):
         cleaned = super().clean()
         source = cleaned.get("source")
-        if source == NotificationVariable.SOURCE_MANUAL:
+        if source == NotificationVariable.Source.MANUAL:
             cleaned["resolver_key"] = ""
             required = cleaned.get("is_required", True)
             if required and not (cleaned.get("value") or "").strip():
                 self.add_error("value", "Required when source is Manual.")
-        elif source == NotificationVariable.SOURCE_QUERY:
+        elif source == NotificationVariable.Source.QUERY:
             cleaned["value"] = ""
             if not cleaned.get("resolver_key"):
                 self.add_error("resolver_key", "Required when source is Query.")
diff --git a/coldfront_notifications/models.py b/coldfront_notifications/models.py
index a92ca8c..594eaf1 100644
--- a/coldfront_notifications/models.py
+++ b/coldfront_notifications/models.py
@@ -1,7 +1,11 @@
+import re
+
 from django.core.exceptions import ValidationError
 from django.db import models
 from django.contrib.auth import get_user_model
 
+from .template_variable_value_resolver import registry as resolver_registry
+
 User = get_user_model()
 
 
@@ -14,50 +18,42 @@ class NotificationVariable(models.Model):
     source=manual  → admin types a value at compose time; stored on
                      NotificationCampaign.extra_context.
     """
-    SOURCE_QUERY  = "query"
-    SOURCE_MANUAL = "manual"
-    SOURCE_CHOICES = [
-        (SOURCE_QUERY,  "Query (auto-resolved from data)"),
-        (SOURCE_MANUAL, "Manual (admin enters per-campaign)"),
-    ]
-
-    WIDGET_TEXT     = "text"
-    WIDGET_TEXTAREA = "textarea"
-    WIDGET_DATE     = "date"
-    WIDGET_DATETIME = "datetime"
-    WIDGET_URL      = "url"
-    WIDGET_CHOICES = [
-        (WIDGET_TEXT,     "Text"),
-        (WIDGET_TEXTAREA, "Multi-line text"),
-        (WIDGET_DATE,     "Date"),
-        (WIDGET_DATETIME, "Date & Time"),
-        (WIDGET_URL,      "URL"),
-    ]
-
-    key          = models.SlugField(
+
+    class Source(models.TextChoices):
+        QUERY = "query", "Query (auto-resolved from data)"
+        MANUAL = "manual", "Manual (admin enters per-campaign)"
+
+    class Widget(models.TextChoices):
+        TEXT = "text", "Text"
+        TEXTAREA = "textarea", "Multi-line text"
+        DATE = "date", "Date"
+        DATETIME = "datetime", "Date & Time"
+        URL = "url", "URL"
+
+    key = models.SlugField(
         max_length=60, unique=True,
         help_text="Token used in {{key}} placeholders (letters, digits, _)",
     )
-    label        = models.CharField(max_length=120)
-    description  = models.CharField(max_length=255, blank=True)
-    example      = models.CharField(max_length=255, blank=True)
-    source       = models.CharField(max_length=10, choices=SOURCE_CHOICES)
+    label = models.CharField(max_length=120)
+    description = models.CharField(max_length=255, blank=True)
+    example = models.CharField(max_length=255, blank=True)
+    source = models.CharField(max_length=10, choices=Source.choices)
     resolver_key = models.CharField(
         max_length=80, blank=True,
         help_text="Required when source=query; must match a registered resolver",
     )
     input_widget = models.CharField(
-        max_length=10, choices=WIDGET_CHOICES, default=WIDGET_TEXT,
+        max_length=10, choices=Widget.choices, default=Widget.TEXT,
         help_text="Input type for the Value field when source=manual",
     )
-    value        = models.TextField(
+    value = models.TextField(
         blank=True, default="",
         help_text="Fixed value used for every campaign (manual variables only).",
     )
-    is_required  = models.BooleanField(default=True)
-    is_deleted   = models.BooleanField(default=False)
-    created      = models.DateTimeField(auto_now_add=True)
-    modified     = models.DateTimeField(auto_now=True)
+    is_required = models.BooleanField(default=True)
+    is_deleted = models.BooleanField(default=False)
+    created = models.DateTimeField(auto_now_add=True)
+    modified = models.DateTimeField(auto_now=True)
 
     class Meta:
         ordering = ["key"]
@@ -66,11 +62,10 @@ def __str__(self):
         return f"{{{{{self.key}}}}} ({self.get_source_display()})"
 
     def clean(self):
-        from .resolvers import QUERY_RESOLVERS
-        if self.source == self.SOURCE_QUERY:
+        if self.source == self.Source.QUERY:
             if not self.resolver_key:
                 raise ValidationError({"resolver_key": "Required when source is Query."})
-            if self.resolver_key not in QUERY_RESOLVERS:
+            if self.resolver_key not in resolver_registry.resolvers:
                 raise ValidationError({
                     "resolver_key":
                     f"'{self.resolver_key}' is not a registered resolver.",
@@ -87,10 +82,9 @@ def clean(self):
     @property
     def required_scope(self):
         """Which context element the resolver depends on ('user', 'project', 'allocation', or None)."""
-        from .resolvers import QUERY_SCOPES
-        if self.source == self.SOURCE_MANUAL:
+        if self.source == self.Source.MANUAL:
             return None
-        return QUERY_SCOPES.get(self.resolver_key)
+        return resolver_registry.scopes.get(self.resolver_key)
 
 
 class SenderConfig(models.Model):
@@ -121,7 +115,6 @@ def __str__(self):
     @property
     def variables(self):
         """Extract {{variable}} placeholders from subject + body."""
-        import re
         pattern = re.compile(r"\{\{(\w+)\}\}")
         found = pattern.findall(self.subject) + pattern.findall(self.body)
         # deduplicate preserving order
@@ -137,20 +130,14 @@ class Meta:
 
 
 class NotificationCampaign(models.Model):
-    STATUS_QUEUED = "queued"
-    STATUS_SENDING = "sending"
-    STATUS_SENT = "sent"
-    STATUS_PARTIAL = "partial"
-    STATUS_FAILED = "failed"
-    STATUS_DRAFT = "draft"
-    STATUS_CHOICES = [
-        (STATUS_QUEUED,   "Queued"),
-        (STATUS_SENDING,  "Sending"),
-        (STATUS_SENT,     "Sent"),
-        (STATUS_PARTIAL,  "Partial"),
-        (STATUS_FAILED,   "Failed"),
-        (STATUS_DRAFT,    "Draft"),
-    ]
+
+    class Status(models.TextChoices):
+        QUEUED = "queued", "Queued"
+        SENDING = "sending", "Sending"
+        SENT = "sent", "Sent"
+        PARTIAL = "partial", "Partial"
+        FAILED = "failed", "Failed"
+        DRAFT = "draft", "Draft"
 
     template = models.ForeignKey(
         NotificationTemplate,
@@ -162,29 +149,33 @@ class NotificationCampaign(models.Model):
     body = models.TextField()
     sender = models.EmailField()
     reply_to = models.EmailField(blank=True)
-    status = models.CharField(max_length=20, choices=STATUS_CHOICES, default=STATUS_DRAFT)
+    status = models.CharField(max_length=20, choices=Status.choices, default=Status.DRAFT)
 
     # filters snapshot (JSON)
     filters_snapshot = models.JSONField(default=dict, blank=True)
 
     # Admin-supplied values for source=manual variables ({"maint_date": "...", ...})
-    extra_context    = models.JSONField(default=dict, blank=True)
+    extra_context = models.JSONField(default=dict, blank=True)
 
     recipient_count = models.PositiveIntegerField(default=0)
     delivered_count = models.PositiveIntegerField(default=0)
-    failed_count    = models.PositiveIntegerField(default=0)
+    failed_count = models.PositiveIntegerField(default=0)
 
     created_by = models.ForeignKey(
         User, on_delete=models.SET_NULL, null=True, blank=True,
         related_name="notification_campaigns",
     )
-    sent_at      = models.DateTimeField(null=True, blank=True)
+    sent_at = models.DateTimeField(null=True, blank=True)
     completed_at = models.DateTimeField(null=True, blank=True)
-    created_at   = models.DateTimeField(auto_now_add=True)
+    created_at = models.DateTimeField(auto_now_add=True)
 
     def __str__(self):
         return self.subject
 
+    @property
+    def display_subject(self):
+        return self.subject or "No subject (draft)"
+
     @property
     def duration(self):
         if not self.sent_at or not self.completed_at:
@@ -228,28 +219,24 @@ class Meta:
 
 
 class NotificationLog(models.Model):
-    STATUS_QUEUED    = "queued"
-    STATUS_DELIVERED = "delivered"
-    STATUS_BOUNCED   = "bounced"
-    STATUS_FAILED    = "failed"
-    STATUS_CHOICES = [
-        (STATUS_QUEUED,    "Queued"),
-        (STATUS_DELIVERED, "Delivered"),
-        (STATUS_BOUNCED,   "Bounced"),
-        (STATUS_FAILED,    "Failed"),
-    ]
-
-    campaign  = models.ForeignKey(
+
+    class Status(models.TextChoices):
+        QUEUED = "queued", "Queued"
+        DELIVERED = "delivered", "Delivered"
+        BOUNCED = "bounced", "Bounced"
+        FAILED = "failed", "Failed"
+
+    campaign = models.ForeignKey(
         NotificationCampaign,
         on_delete=models.CASCADE,
         related_name="logs",
     )
-    email     = models.EmailField()
-    status    = models.CharField(max_length=20, choices=STATUS_CHOICES, default=STATUS_QUEUED)
+    email = models.EmailField()
+    status = models.CharField(max_length=20, choices=Status.choices, default=Status.QUEUED)
     timestamp = models.DateTimeField(auto_now_add=True)
     notes     = models.TextField(blank=True)
     rendered_subject = models.TextField(blank=True, default="")
-    rendered_body    = models.TextField(blank=True, default="")
+    rendered_body = models.TextField(blank=True, default="")
     # Per-email context (one log row = one sent email)
     project_id    = models.IntegerField(null=True, blank=True, db_index=True)
     allocation_id = models.IntegerField(null=True, blank=True, db_index=True)
diff --git a/coldfront_notifications/notification_validator.py b/coldfront_notifications/notification_validator.py
new file mode 100644
index 0000000..4a7b5af
--- /dev/null
+++ b/coldfront_notifications/notification_validator.py
@@ -0,0 +1,174 @@
+"""
+Pre-flight validation for notification campaigns.
+
+NotificationValidator checks that every {{token}} in the subject and body
+can be resolved for every recipient. It produces a validation result with
+errors, counts, and scope information.
+
+A campaign is sendable when errors == [] and missing_tokens == [].
+"""
+from __future__ import annotations
+
+import re
+from collections import Counter
+
+from .filters import RecipientResolver
+from .models import NotificationVariable
+from .template_variable_value_resolver import MissingValue, registry as resolver_registry
+
+TOKEN_PATTERN = re.compile(r"\{\{(\w+)\}\}")
+
+SCOPE_RANK = {"user": 0, "project": 1, "allocation": 2}
+SCOPE_BY_RANK = {0: "user", 1: "project", 2: "allocation"}
+
+
+class NotificationValidator:
+    """Validates a notification campaign before sending.
+
+    Extracts tokens from subject/body, resolves each against every
+    recipient tuple, and collects errors for unresolvable variables.
+    """
+
+    def __init__(self, subject: str, body: str, filters: dict,
+                 dedupe_users=None, scope_override=None):
+        self.subject = subject
+        self.body = body
+        self.filters = filters
+        self.dedupe_users = dedupe_users
+        self.scope_override = scope_override
+
+    def validate(self) -> dict:
+        """Run validation and return the result dict."""
+        tokens = self._extract_tokens()
+        variables_by_key = self._load_variables(tokens)
+        missing_tokens = [
+            token for token in tokens if token not in variables_by_key
+        ]
+        matched_variables = [
+            variables_by_key[token] for token in tokens if token in variables_by_key
+        ]
+        scope = self.scope_override or self._determine_scope(matched_variables)
+
+        resolution_errors = []
+        unique_user_pks = set()
+        emails_per_user = Counter()
+
+        resolver = RecipientResolver(self.filters)
+        for user, project, allocation in resolver.enumerate_deduped(scope, self.dedupe_users):
+            unique_user_pks.add(user.pk)
+            emails_per_user[user.username] += 1
+            context = {"user": user, "project": project, "allocation": allocation}
+
+            for token in tokens:
+                variable = variables_by_key.get(token)
+                if variable is None:
+                    continue
+
+                error = self._validate_variable(variable, context)
+                if error:
+                    resolution_errors.append({
+                        "email": user.email,
+                        "username": user.username,
+                        "full_name": user.get_full_name() or user.username,
+                        "token": token,
+                        "reason": error,
+                        "project": project.title if project else "",
+                        "project_pk": project.pk if project else None,
+                        "allocation_pk": allocation.pk if allocation else None,
+                        "allocation_label": (
+                            f"{allocation.pk} — {allocation.get_parent_resource}"
+                            if allocation else ""
+                        ),
+                    })
+
+        multi_email_users = sorted(
+            [
+                {"username": username, "count": count}
+                for username, count in emails_per_user.items()
+                if count > 1
+            ],
+            key=lambda entry: -entry["count"],
+        )
+
+        return {
+            "errors": resolution_errors,
+            "user_count": len(unique_user_pks),
+            "email_count": sum(emails_per_user.values()),
+            "multi_emails": multi_email_users,
+            "missing_tokens": missing_tokens,
+            "scope": scope,
+        }
+
+    def _extract_tokens(self) -> list[str]:
+        """Return unique tokens from subject + body in order of first occurrence."""
+        seen = set()
+        tokens = []
+        for text in (self.subject, self.body):
+            for match in TOKEN_PATTERN.finditer(text or ""):
+                token = match.group(1)
+                if token not in seen:
+                    seen.add(token)
+                    tokens.append(token)
+        return tokens
+
+    def _load_variables(self, tokens: list[str]) -> dict:
+        """Load NotificationVariable objects for the given tokens."""
+        return {
+            variable.key: variable
+            for variable in NotificationVariable.objects.filter(key__in=tokens)
+        }
+
+    def _determine_scope(self, variables) -> str:
+        """Return the widest scope required by the given variables."""
+        highest_rank = 0
+        for variable in variables:
+            if variable.source != NotificationVariable.Source.QUERY:
+                continue
+            variable_scope = resolver_registry.scopes.get(variable.resolver_key)
+            rank = SCOPE_RANK.get(variable_scope, 0)
+            if rank > highest_rank:
+                highest_rank = rank
+        return SCOPE_BY_RANK[highest_rank]
+
+    def _validate_variable(self, variable, context: dict) -> str | None:
+        """Validate a single variable against a recipient context.
+
+        Returns an error message string, or None if valid.
+        """
+        try:
+            if variable.source == NotificationVariable.Source.MANUAL:
+                if variable.is_required and not (variable.value or "").strip():
+                    raise MissingValue()
+            else:
+                resolver_registry.resolve(variable.resolver_key, context)
+            return None
+        except MissingValue:
+            if variable.source == NotificationVariable.Source.MANUAL:
+                return f"manual variable {variable.key!r} has no stored value"
+            return f"cannot resolve {variable.resolver_key} for this recipient"
+
+
+def extract_tokens(subject: str, body: str) -> list[str]:
+    """Extract unique {{token}} names from subject and body."""
+    seen = set()
+    tokens = []
+    for text in (subject, body):
+        for match in TOKEN_PATTERN.finditer(text or ""):
+            token = match.group(1)
+            if token not in seen:
+                seen.add(token)
+                tokens.append(token)
+    return tokens
+
+
+def determine_scope(variables) -> str:
+    """Return the widest scope required by the given variables."""
+    highest_rank = 0
+    for variable in variables:
+        if variable.source != NotificationVariable.Source.QUERY:
+            continue
+        variable_scope = resolver_registry.scopes.get(variable.resolver_key)
+        rank = SCOPE_RANK.get(variable_scope, 0)
+        if rank > highest_rank:
+            highest_rank = rank
+    return SCOPE_BY_RANK[highest_rank]
diff --git a/coldfront_notifications/resolvers.py b/coldfront_notifications/resolvers.py
deleted file mode 100644
index 87956f7..0000000
--- a/coldfront_notifications/resolvers.py
+++ /dev/null
@@ -1,191 +0,0 @@
-"""
-Query resolvers for NotificationVariable(source='query').
-
-The admin UI shows QUERY_CHOICES as a dropdown. The chosen value is stored
-as NotificationVariable.resolver_key and dispatches here at send time.
-
-Each resolver takes a context dict:
-    {"user": IfxUser, "project": Project|None, "allocation": Allocation|None}
-and returns a str, or raises MissingValue if the value can't be produced.
-"""
-
-
-class MissingValue(Exception):
-    """Raised by a resolver when it cannot produce a non-empty value."""
-
-
-def _fmt(value):
-    if value is None:
-        raise MissingValue()
-    s = str(value).strip()
-    if not s:
-        raise MissingValue()
-    return s
-
-
-def _need(ctx, key):
-    v = ctx.get(key)
-    if v is None:
-        raise MissingValue()
-    return v
-
-
-def _primary_resource(allocation):
-    """Returns the parent resource of an allocation, or None."""
-    if allocation is None:
-        return None
-    return allocation.get_parent_resource  # @property
-
-
-def _dept_name(project):
-    from ifxuser.models import Organization
-    return Organization.objects.filter(
-        projectorganization__project=project,
-        rank="department",
-    ).values_list("name", flat=True).first()
-
-
-def _project_role(user, project):
-    from coldfront.core.project.models import ProjectUser
-    pu = (
-        ProjectUser.objects.filter(
-            user=user, project=project, status__name="Active",
-        )
-        .select_related("role")
-        .first()
-    )
-    return pu.role.name if pu and pu.role else None
-
-
-# ─────────────────────────────────────────────────────────────────────────
-# Resolver registry.
-# Each entry: resolver_key → callable(ctx) -> str
-# ─────────────────────────────────────────────────────────────────────────
-
-QUERY_RESOLVERS = {
-    # Recipient (user)
-    "user.username": lambda c: _fmt(_need(c, "user").username),
-    "user.email": lambda c: _fmt(_need(c, "user").email),
-    "user.full_name": lambda c: _fmt(_need(c, "user").get_full_name() or _need(c, "user").username),
-    "user.first_name": lambda c: _fmt(_need(c, "user").first_name),
-    "user.last_name": lambda c: _fmt(_need(c, "user").last_name),
-    "user.ifxid": lambda c: _fmt(getattr(_need(c, "user"), "ifxid", None)),
-
-    # Project
-    "project.title": lambda c: _fmt(_need(c, "project").title),
-    "project.description": lambda c: _fmt(_need(c, "project").description),
-    "project.status.name": lambda c: _fmt(_need(c, "project").status.name),
-    "project.field_of_science.description": lambda c: _fmt(
-        _need(c, "project").field_of_science.description if _need(c, "project").field_of_science_id else None
-    ),
-    "project.parent_project.title": lambda c: _fmt(
-        _need(c, "project").parent_project.title if _need(c, "project").parent_project_id else None
-    ),
-
-    # PI (of project)
-    "project.pi.full_name": lambda c: _fmt(
-        _need(c, "project").pi.get_full_name() or _need(c, "project").pi.username if _need(c, "project").pi_id else None
-    ),
-    "project.pi.email": lambda c: _fmt(_need(c, "project").pi.email if _need(c, "project").pi_id else None),
-    "project.pi.username": lambda c: _fmt(_need(c, "project").pi.username if _need(c, "project").pi_id else None),
-
-    # Department (via ProjectOrganization)
-    "project.department.name": lambda c: _fmt(_dept_name(_need(c, "project"))),
-
-    # User's role on the project
-    "projectuser.role.name": lambda c: _fmt(_project_role(_need(c, "user"), _need(c, "project"))),
-
-    # Allocation
-    "allocation.id": lambda c: _fmt(_need(c, "allocation").pk),
-    "allocation.description": lambda c: _fmt(_need(c, "allocation").description),
-    "allocation.justification": lambda c: _fmt(_need(c, "allocation").justification),
-    "allocation.quantity": lambda c: _fmt(_need(c, "allocation").quantity),
-    "allocation.start_date": lambda c: _fmt(_need(c, "allocation").start_date),
-    "allocation.end_date": lambda c: _fmt(_need(c, "allocation").end_date),
-    "allocation.status.name": lambda c: _fmt(_need(c, "allocation").status.name),
-
-    # Resource (primary on matched allocation)
-    "resource.name": lambda c: _fmt(getattr(_primary_resource(_need(c, "allocation")), "name", None)),
-    "resource.description": lambda c: _fmt(getattr(_primary_resource(_need(c, "allocation")), "description", None)),
-    "resource.resource_type.name": lambda c: _fmt(
-        (_primary_resource(_need(c, "allocation")).resource_type.name
-         if _primary_resource(_need(c, "allocation")) and _primary_resource(_need(c, "allocation")).resource_type_id
-         else None)
-    ),
-    "resource.parent_resource.name": lambda c: _fmt(
-        (_primary_resource(_need(c, "allocation")).parent_resource.name
-         if _primary_resource(_need(c, "allocation")) and _primary_resource(_need(c, "allocation")).parent_resource_id
-         else None)
-    ),
-    "resource.names_joined": lambda c: _fmt(
-        ", ".join(r.name for r in _need(c, "allocation").resources.all()) or None
-    ),
-}
-
-
-# Human-readable labels for the admin dropdown, grouped.
-# Order preserved; groups keyed for UI grouping.
-QUERY_CHOICES = [
-    # (resolver_key, label, group)
-    ("user.username",   "User · Username",   "Recipient"),
-    ("user.email",      "User · Email",      "Recipient"),
-    ("user.full_name",  "User · Full Name",  "Recipient"),
-    ("user.first_name", "User · First Name", "Recipient"),
-    ("user.last_name",  "User · Last Name",  "Recipient"),
-    ("user.ifxid",      "User · IFX ID",     "Recipient"),
-
-    ("project.title",                        "Project · Title",             "Project"),
-    ("project.description",                  "Project · Description",       "Project"),
-    ("project.status.name",                  "Project · Status",            "Project"),
-    ("project.field_of_science.description", "Project · Field of Science",  "Project"),
-    ("project.parent_project.title",         "Project · Parent Title",      "Project"),
-
-    ("project.pi.full_name", "PI · Full Name", "PI"),
-    ("project.pi.email",     "PI · Email",     "PI"),
-    ("project.pi.username",  "PI · Username",  "PI"),
-
-    ("project.department.name", "Department · Name", "Department"),
-
-    ("projectuser.role.name", "Role · Name", "Role"),
-
-    ("allocation.id",            "Allocation · ID",             "Allocation"),
-    ("allocation.description",   "Allocation · Description",    "Allocation"),
-    ("allocation.justification", "Allocation · Justification",  "Allocation"),
-    ("allocation.quantity",      "Allocation · Quantity",       "Allocation"),
-    ("allocation.start_date",    "Allocation · Start Date",     "Allocation"),
-    ("allocation.end_date",      "Allocation · End Date",       "Allocation"),
-    ("allocation.status.name",   "Allocation · Status",         "Allocation"),
-
-    ("resource.name",                "Resource · Name (primary)", "Resource"),
-    ("resource.description",         "Resource · Description",    "Resource"),
-    ("resource.resource_type.name",  "Resource · Type",           "Resource"),
-    ("resource.parent_resource.name","Resource · Parent Name",    "Resource"),
-    ("resource.names_joined",        "Resource · All Names",      "Resource"),
-]
-
-
-# Each resolver_key's required scope — used to decide whether to iterate
-# AllocationUsers vs ProjectUsers vs just distinct users during enumeration.
-def _scope_for(key):
-    if key.startswith("allocation.") or key.startswith("resource."):
-        return "allocation"
-    if key.startswith("project.") or key.startswith("projectuser."):
-        return "project"
-    return "user"
-
-
-QUERY_SCOPES = {k: _scope_for(k) for k, _label, _group in QUERY_CHOICES}
-
-
-def resolve(resolver_key: str, ctx: dict) -> str:
-    """Dispatch a resolver_key on a context. Raises MissingValue on failure."""
-    fn = QUERY_RESOLVERS.get(resolver_key)
-    if fn is None:
-        raise MissingValue()
-    try:
-        return fn(ctx)
-    except MissingValue:
-        raise
-    except Exception:
-        # Any attribute traversal failure collapses to a missing value.
-        raise MissingValue()
diff --git a/coldfront_notifications/static/coldfront_notifications/css/compose.css b/coldfront_notifications/static/coldfront_notifications/css/compose.css
index 9b02095..dc5fe0c 100644
--- a/coldfront_notifications/static/coldfront_notifications/css/compose.css
+++ b/coldfront_notifications/static/coldfront_notifications/css/compose.css
@@ -1,5 +1,6 @@
 .flbl { font-weight: 600; font-size: .82rem; margin-bottom: 4px; display: block; color: #343a40; }
 
+
 /* recipients: row 1 — filters */
 .recip-filters {
   display: grid;
@@ -8,16 +9,47 @@
   align-items: end;
 }
 
-/* recipients: row 2 — count pill + buttons */
+/* recipients: row 2 — actions + count pill */
 .recip-actions {
-  display: flex; align-items: center; gap: 10px;
-  margin-top: 14px; padding-top: 12px;
+  display: flex; align-items: center; justify-content: space-between;
+  margin-top: 20px; padding-top: 14px;
   border-top: 1px solid #eef0f3;
 }
+.recip-actions-left {
+  display: flex; gap: 6px; flex-shrink: 0;
+}
 .recip-count-pill {
+  flex-shrink: 0;
   background: #fdf5f6; border: 1px solid #e8b4bb;
   border-radius: 5px; padding: 5px 14px; text-align: center;
 }
+
+/* recipients: row 3 — filter breakdown details */
+.recip-details {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(220px, 1fr));
+  gap: 8px;
+  margin-top: 14px;
+}
+.recip-details:empty { display: none; }
+.recip-detail-card {
+  background: #f8f9fb; border: 1px solid #e2e6ea;
+  border-radius: 4px; padding: 8px 10px; font-size: .75rem; color: #495057;
+}
+.recip-detail-card.narrowed {
+  border-left: 3px solid #A51C30;
+}
+.recip-detail-title {
+  font-weight: 700; font-size: .78rem; color: #343a40;
+  margin-bottom: 3px;
+}
+.recip-detail-title .count { color: #A51C30; }
+.recip-detail-breakdown {
+  font-size: .72rem; color: #495057; line-height: 1.5;
+}
+.recip-detail-filtered-by {
+  font-size: .68rem; color: #888; margin-top: 3px; font-style: italic;
+}
 .recip-count-num { font-size: 1.3rem; font-weight: 700; font-family: monospace; color: #A51C30; line-height: 1; }
 .recip-count-lbl { font-size: .68rem; color: #6c757d; margin-top: 2px; }
 .bcc-badge {
@@ -162,3 +194,36 @@
 }
 .select2-container--default .select2-selection__choice__remove { color: rgba(255,255,255,.7) !important; }
 .select2-container--default .select2-selection__choice__remove:hover { color: #fff !important; }
+
+/* filter summary bar (shown after Validate) */
+.filter-summary-bar {
+  background: #f4f6f9; border: 1px solid #dee2e8; border-radius: 5px;
+  padding: 8px 14px; display: flex; flex-wrap: wrap; gap: 6px; align-items: center;
+}
+.filter-summary-bar .fs-label {
+  font-weight: 600; color: #6c757d; font-size: .75rem; margin-right: 4px;
+}
+.filter-summary-bar .fs-chip {
+  display: inline-block; background: #fff; border: 1px solid #ced4da;
+  border-radius: 3px; padding: 2px 8px; font-size: .75rem; color: #495057;
+}
+.filter-summary-bar .fs-chip strong { color: #A51C30; font-weight: 600; }
+.filter-summary-bar .fs-none {
+  color: #adb5bd; font-style: italic; font-size: .75rem;
+}
+
+/* filter info icon */
+.filter-info {
+  font-size: .68rem; cursor: help; margin-left: 3px; opacity: .5;
+  transition: opacity .15s;
+}
+.filter-info:hover { opacity: 1; }
+
+/* jQuery UI tooltip override for filter summaries */
+.filter-summary-tip {
+  background: #333 !important; color: #fff !important;
+  border: none !important; border-radius: 5px !important;
+  padding: 8px 12px !important; font-size: .78rem !important;
+  max-width: 340px !important; line-height: 1.5 !important;
+  box-shadow: 0 2px 8px rgba(0,0,0,.25) !important;
+}
diff --git a/coldfront_notifications/static/coldfront_notifications/js/compose.js b/coldfront_notifications/static/coldfront_notifications/js/compose.js
deleted file mode 100644
index d6ab45f..0000000
--- a/coldfront_notifications/static/coldfront_notifications/js/compose.js
+++ /dev/null
@@ -1,624 +0,0 @@
-// ── compose.js ──────────────────────────────────────────────────
-// Expects the following globals set inline by the Django template:
-//   TEMPLATES          - array of template objects
-//   VARIABLES          - array of variable objects
-//   URLS.previewRender - URL for preview-render endpoint
-//   URLS.filterOptions - URL for filter-options endpoint
-//   URLS.validate      - URL for validate endpoint
-//   URLS.recipientCount - URL for recipient-count endpoint
-
-// Index VARIABLES by key for O(1) lookup
-var VAR_BY_KEY = {};
-VARIABLES.forEach(function(v) { VAR_BY_KEY[v.key] = v; });
-
-// ── Render chip list ─────────────────────────────────────────────
-function renderVars(vars, filter) {
-  var $list = $('#varsList').empty();
-  var filtered = filter
-    ? vars.filter(function(v) { return v.toLowerCase().indexOf(filter.toLowerCase()) !== -1; })
-    : vars;
-  if (!filtered.length) {
-    $list.append('<div class="vars-empty">No matches</div>');
-    return;
-  }
-  filtered.forEach(function(v) {
-    var token   = '{{' + v + '}}';
-    var def     = VAR_BY_KEY[v] || {};
-    var example = def.example || '';
-    var badge   = def.source === 'manual' ? ' [manual]' : '';
-    var $btn = $('<button type="button" class="var-btn"></button>')
-      .attr('data-var', token)
-      .attr('title', (def.description || def.label || '') + (example ? ' — ' + example : ''))
-      .html(
-        '<span style="display:block;font-family:monospace;font-size:.7rem;">' + token + badge + '</span>' +
-        '<span style="display:block;font-size:.65rem;color:#6c757d;margin-top:1px;">' + example + '</span>'
-      );
-    $list.append($btn);
-  });
-}
-
-// ── Extract tokens from subject + body ───────────────────────────
-var TOKEN_RE = /\{\{(\w+)\}\}/g;
-function extractTokens() {
-  var text = ($('#id_subject').val() || '') + '\n' + ($('#id_body').val() || '');
-  var seen = {};
-  var out = [];
-  var m;
-  while ((m = TOKEN_RE.exec(text))) {
-    if (!seen[m[1]]) { seen[m[1]] = true; out.push(m[1]); }
-  }
-  return out;
-}
-
-// ── Load template into compose fields ────────────────────────────
-// Always fetch fresh content from the server — avoids stale data when
-// an admin edits a template in another tab and returns to compose.
-var ACTIVE_VARS = [];
-function loadTemplate($el) {
-  var id   = parseInt($el.attr('data-id') || 0);
-  var slug = $el.attr('data-slug') || '';
-  $('#active-slug').text(slug);
-  $('#hidden_template_id').val(id);
-  $('#varSearch').val('');
-  $('#validationPanel').hide();
-  $('#sendBtn').prop('disabled', true);
-  $('#sendWarn').hide();
-  setDedupeUsers([]);
-  if (!id) { ACTIVE_VARS = []; renderVars([], ''); return; }
-  $.getJSON('/notifications/templates/' + id + '/json/', function(t) {
-    $('#id_subject').val(t.subject || '');
-    $('#id_body').val(t.body || '');
-    ACTIVE_VARS = t.variables || [];
-    renderVars(ACTIVE_VARS, '');
-    if (HAS_VALIDATED) runValidation();
-  }).fail(function() {
-    ACTIVE_VARS = [];
-    renderVars([], '');
-  });
-}
-
-// ── Template click ───────────────────────────────────────────────
-$(document).on('click', '.tmpl-item', function() {
-  $('.tmpl-item').removeClass('active');
-  $(this).addClass('active');
-  loadTemplate($(this));
-});
-
-// ── Template search ─────────────────────────────────────────────
-$(document).on('input', '#tmplSearch', function() {
-  var q = $(this).val().toLowerCase();
-  $('.tmpl-item').each(function() {
-    var text = $(this).text().toLowerCase();
-    $(this).toggle(!q || text.indexOf(q) !== -1);
-  });
-});
-
-// ── Variable search ──────────────────────────────────────────────
-$(document).on('input', '#varSearch', function() {
-  renderVars(ACTIVE_VARS, $(this).val());
-});
-
-// ── Variable insert at cursor ────────────────────────────────────
-$(document).on('click', '.var-btn', function() {
-  var ta    = document.getElementById('id_body');
-  var token = $(this).attr('data-var');
-  var s = ta.selectionStart, e = ta.selectionEnd;
-  ta.value = ta.value.substring(0, s) + token + ta.value.substring(e);
-  ta.selectionStart = ta.selectionEnd = s + token.length;
-  ta.focus();
-});
-
-// ── Preview modal ────────────────────────────────────────────────
-// Samples returned from /preview-render/; indexed by select option value.
-var PREVIEW_SAMPLES = [];
-
-function renderPreviewSample(idx) {
-  var s = PREVIEW_SAMPLES[idx];
-  if (!s) {
-    // "Template" — no recipient, raw tokens
-    $('#prev-to').text('—');
-    $('#prev-subject').text($('#id_subject').val() || '—');
-    $('#prev-body').text($('#id_body').val() || '—');
-    $('#prev-error').hide();
-    $('#prev-footer').text('Showing template with literal placeholders');
-    return;
-  }
-  $('#prev-to').text((s.recipient.name || s.recipient.username) + ' <' + s.recipient.email + '>');
-  $('#prev-subject').text(s.subject || '—');
-  $('#prev-body').text(s.body || '—');
-  if (s.error) {
-    $('#prev-error').text('Resolution error: ' + s.error).show();
-  } else {
-    $('#prev-error').hide();
-  }
-  var ctx = [];
-  if (s.recipient.project)    ctx.push('project: ' + s.recipient.project);
-  if (s.recipient.allocation) ctx.push('allocation: ' + s.recipient.allocation);
-  $('#prev-footer').text(ctx.join(' · ') || 'recipient-only context');
-}
-
-$(document).on('click', '#previewBtn', function() {
-  $('#prev-from').text($('#id_sender').val());
-  $('#prev-replyto').text($('#id_reply_to').val());
-  // Show the raw template immediately while samples load
-  PREVIEW_SAMPLES = [];
-  $('#prev-recipient-picker').html('<option value="">— Template (raw placeholders) —</option>'
-    + '<option disabled>Loading samples…</option>');
-  renderPreviewSample(null);
-  $('#prev-scope-badge').text('');
-  $('#previewModal').modal('show');
-
-  $.ajax({
-    url: URLS.previewRender,
-    type: 'POST',
-    data: {
-      csrfmiddlewaretoken: $('input[name=csrfmiddlewaretoken]').val(),
-      subject:      $('#id_subject').val() || '',
-      body:         $('#id_body').val()    || '',
-      filters:      JSON.stringify(collectFilters()),
-      dedupe_users: JSON.stringify(getDedupeUsers()),
-    },
-    success: function(data) {
-      PREVIEW_SAMPLES = data.samples || [];
-      var opts = ['<option value="">— Template (raw placeholders) —</option>'];
-      PREVIEW_SAMPLES.forEach(function(s, i) {
-        var lbl = (s.recipient.name || s.recipient.username) + ' <' + s.recipient.email + '>';
-        if (s.recipient.project) lbl += ' · ' + s.recipient.project;
-        opts.push('<option value="' + i + '">' + lbl + '</option>');
-      });
-      if (!PREVIEW_SAMPLES.length) {
-        opts.push('<option disabled>(no matching recipients)</option>');
-      }
-      $('#prev-recipient-picker').html(opts.join(''));
-      if (data.scope) $('#prev-scope-badge').text('scope: ' + data.scope + ' · ' + (data.total_emails || 0) + ' total');
-
-      // Auto-select the first real sample if available
-      if (PREVIEW_SAMPLES.length) {
-        $('#prev-recipient-picker').val('0');
-        renderPreviewSample(0);
-      } else {
-        renderPreviewSample(null);
-      }
-    },
-    error: function() {
-      $('#prev-recipient-picker').html('<option value="">— Template (raw placeholders) —</option>');
-      $('#prev-footer').text('Preview failed to load — showing raw template');
-    },
-  });
-});
-
-$(document).on('change', '#prev-recipient-picker', function() {
-  var v = $(this).val();
-  renderPreviewSample(v === '' ? null : parseInt(v, 10));
-});
-
-// ── Recipient filters stale on change ────────────────────────────
-$(document).on('change', '.s2', function() {
-  $('#recipNum').text('?');
-  $('#recipLbl').text('press Validate');
-  $('#sendBtn').prop('disabled', true);
-  $('#previewRecipBtn').prop('disabled', true);
-  $('#sendWarn').hide();
-  // Changing filters may change the user pool — dedupe choices are user-scoped,
-  // so reset them to avoid stale selections.
-  setDedupeUsers([]);
-});
-
-// ── Cascading filter options ─────────────────────────────────────
-// Rebuild a <select> from an option list, keeping still-valid user picks.
-// items: [{id, label}] or ['name', 'name', ...]
-function rebuildSelect($sel, items) {
-  var current = $sel.val() || [];
-  var normalized = (items || []).map(function(it) {
-    return (typeof it === 'string') ? { id: it, label: it } : it;
-  });
-  var validIds = {};
-  normalized.forEach(function(i) { validIds[String(i.id)] = true; });
-  var keep = current.filter(function(v) { return validIds[String(v)]; });
-  var html = normalized.map(function(i) {
-    var esc = $('<div>').text(i.label).html();
-    return '<option value="' + i.id + '">' + esc + '</option>';
-  }).join('');
-  // change.select2 updates the widget without firing a generic 'change',
-  // so the stale handler above doesn't loop on programmatic rebuilds.
-  $sel.html(html).val(keep).trigger('change.select2');
-}
-
-// Downstream targets for each source filter (top-down cascade).
-var DOWNSTREAM = {
-  project:    { dept: true, alloc: true, resource: true, status: true, role: true },
-  dept:       { alloc: true, resource: true, status: true, role: true },
-  allocation: { resource: true, status: true },
-  resource:   { status: true }
-};
-
-function cascadeFrom(source) {
-  var targets = DOWNSTREAM[source];
-  if (!targets) return;
-
-  $.ajax({
-    url: URLS.filterOptions,
-    type: 'POST',
-    data: {
-      csrfmiddlewaretoken: $('input[name=csrfmiddlewaretoken]').val(),
-      projects:    $('#f_project').val()    || [],
-      allocations: $('#f_allocation').val() || [],
-      resources:   $('#f_resource').val()   || [],
-      departments: $('#f_dept').val()       || []
-    },
-    traditional: true,
-    success: function(data) {
-      if (targets.alloc)    rebuildSelect($('#f_allocation'), data.allocations);
-      if (targets.dept)     rebuildSelect($('#f_dept'),       data.departments);
-      if (targets.resource) rebuildSelect($('#f_resource'),   data.resources);
-      if (targets.status)   rebuildSelect($('#f_status'),     data.statuses);
-      if (targets.role)     rebuildSelect($('#f_role'),       data.roles);
-    }
-  });
-}
-
-$(document).on('change', '#f_project',    function() { cascadeFrom('project'); });
-$(document).on('change', '#f_dept',       function() { cascadeFrom('dept'); });
-$(document).on('change', '#f_allocation', function() { cascadeFrom('allocation'); });
-$(document).on('change', '#f_resource',   function() { cascadeFrom('resource'); });
-
-// ── Validate & count (AJAX) ─────────────────────────────────────
-function collectFilters() {
-  return {
-    projects:    $('#f_project').val()    || [],
-    allocations: $('#f_allocation').val() || [],
-    resources:   $('#f_resource').val()   || [],
-    departments: $('#f_dept').val()       || [],
-    statuses:    $('#f_status').val()     || [],
-    roles:       $('#f_role').val()       || [],
-  };
-}
-function getDedupeUsers() {
-  try {
-    var v = JSON.parse($('#h_dedupe_users').val() || '[]');
-    return Array.isArray(v) ? v : [];
-  } catch (e) { return []; }
-}
-function setDedupeUsers(list) {
-  $('#h_dedupe_users').val(JSON.stringify(list || []));
-}
-
-function runValidation() {
-  var $btn = $('#recalcBtn');
-  $btn.prop('disabled', true).html('<i class="fas fa-spinner fa-spin"></i>');
-
-  $.ajax({
-    url: URLS.validate,
-    type: 'POST',
-    data: {
-      csrfmiddlewaretoken: $('input[name=csrfmiddlewaretoken]').val(),
-      subject:      $('#id_subject').val() || '',
-      body:         $('#id_body').val()    || '',
-      filters:      JSON.stringify(collectFilters()),
-      dedupe_users: JSON.stringify(getDedupeUsers()),
-    },
-    success: function(data) {
-      var users = data.user_count || 0;
-      var emails = data.email_count || 0;
-      $('#recipNum').text(users);
-      $('#recipLbl').text('users');
-      $('#emailCount').text(emails);
-      $('#warnCount').text(emails);
-      $('#sendCount').text(emails);
-      $('#hidden_recip_count').val(emails);
-
-      // Multi-email users
-      if (data.multi_emails && data.multi_emails.length) {
-        $('#multiCount').text(data.multi_emails.length);
-        $('#multiBadge').show();
-        var lines = data.multi_emails.map(function(m) {
-          return '<li><code>' + m.username + '</code> — ' + m.count + ' emails</li>';
-        }).join('');
-        $('#multiList').html(lines);
-        $('#multiWarnText').text(
-          data.multi_emails.length + ' user(s) will receive multiple emails ' +
-          '(different project/allocation context each)'
-        );
-        $('#multiWarn').show();
-      } else {
-        $('#multiBadge').hide();
-        $('#multiWarn').hide();
-      }
-
-      // Preview recipients is independent of variable resolution — as
-      // long as the filter matches anyone, admins can see who's in scope.
-      $('#previewRecipBtn').prop('disabled', users === 0);
-      HAS_VALIDATED = true;
-
-      // Errors and missing tokens
-      $('#validationPanel').show();
-      var errs = data.errors || [];
-      var miss = data.missing_tokens || [];
-      if (errs.length || miss.length) {
-        var title = [];
-        if (miss.length) title.push(miss.length + ' unknown token(s): ' + miss.join(', '));
-        if (errs.length) title.push(errs.length + ' resolution error(s)');
-        $('#validationBadTitle').text('Blocking — ' + title.join('; '));
-        var $ul = $('#validationErrors').empty();
-        errs.slice(0, 30).forEach(function(e) {
-          $ul.append('<li><code>' + e.email + '</code>: <code>{{' + e.token + '}}</code> — ' + e.reason + '</li>');
-        });
-        if (errs.length > 30) $ul.append('<li>… and ' + (errs.length - 30) + ' more</li>');
-        $('#validationBad').show();
-        $('#validationOK').hide();
-        $('#sendBtn').prop('disabled', true);
-        $('#sendWarn').hide();
-      } else {
-        $('#validationOK')
-          .html('<i class="fas fa-check-circle mr-1"></i>' +
-                users + ' users → <strong>' + emails + '</strong> emails. All variables resolve.')
-          .show();
-        $('#validationBad').hide();
-        $('#sendBtn').prop('disabled', emails === 0);
-        if (emails > 0) $('#sendWarn').show();
-      }
-    },
-    error: function() {
-      $('#recipNum').text('—');
-      $('#recipLbl').text('Error — try again');
-    },
-    complete: function() {
-      $btn.prop('disabled', false).html('<i class="fas fa-check-double mr-1"></i>Validate');
-    }
-  });
-}
-
-$(document).on('click', '#recalcBtn, #recalcBtn2', function() { runValidation(); });
-
-$(document).on('click', '#multiShowBtn', function() {
-  $('#multiList').toggle();
-});
-
-// Body/subject input changes invalidate previous validation.
-$(document).on('input', '#id_body, #id_subject', function() {
-  $('#validationPanel').hide();
-  $('#sendBtn').prop('disabled', true);
-  $('#sendWarn').hide();
-});
-
-// ── Recipient preview modal ──────────────────────────────────────
-// Tracks the full set of tuples fetched from the server for this session.
-var PREVIEW_ROWS  = [];   // current page of rows from server
-var PREVIEW_SCOPE = null; // "user" | "project" | "allocation"
-var PREVIEW_PAGE  = 1;
-var PREVIEW_TOTAL_PAGES = 1;
-var PREVIEW_TOTAL = 0;
-var HAS_VALIDATED = false; // true after first validate; triggers auto-revalidation on changes
-
-function renderPreviewRows() {
-  // Group rows by username preserving order.
-  var order = [], byUser = {};
-  PREVIEW_ROWS.forEach(function(r) {
-    var u = r.username;
-    if (!(u in byUser)) { order.push(u); byUser[u] = []; }
-    byUser[u].push(r);
-  });
-
-  var dedupeSet = {};
-  getDedupeUsers().forEach(function(u) { dedupeSet[u] = true; });
-
-  // Build a set from the server's cross-page multi-user list for O(1) lookup.
-  var multiSet = {};
-  ALL_MULTI_USERS.forEach(function(u) { multiSet[u] = true; });
-
-  var html = '';
-  order.forEach(function(u) {
-    var group = byUser[u];
-    var isMulti = !!multiSet[u];  // uses cross-page list, not just this page
-    var isDeduped = !!dedupeSet[u];
-    group.forEach(function(r, idx) {
-      var first = idx === 0;
-      // Strike-through rows after the first for deduped users (on this page)
-      var muted = (isDeduped && !first);
-      // If deduped and only 1 row on this page, still show strike-through
-      if (isDeduped && group.length === 1 && isMulti) muted = true;
-      var styleAttr = muted
-        ? ' style="color:#aab0b7;text-decoration:line-through;font-style:italic;"'
-        : '';
-      var cbCell = '';
-      if (first && isMulti) {
-        cbCell = '<td style="text-align:center;"><input type="checkbox" class="dedupe-cb" '
-               + 'data-username="' + u + '"'
-               + (isDeduped ? ' checked' : '')
-               + ' title="send only one email to ' + u + '"></td>';
-      } else {
-        cbCell = '<td></td>';
-      }
-      html += '<tr' + styleAttr + '>'
-        + cbCell
-        + '<td>' + (r.full_name||'') + (isMulti && first ? ' <span class="badge badge-warning ml-1" style="font-size:.6rem;">multi</span>' : '') + '</td>'
-        + '<td style="font-family:monospace;font-size:.78rem;">' + (r.email||'') + '</td>'
-        + '<td>' + (r.role||'') + '</td>'
-        + '<td>' + (r.project||'') + '</td>'
-        + '<td style="font-size:.78rem;">' + (r.allocation||'') + '</td>'
-        + '</tr>';
-    });
-  });
-  $('#recipRows').html(html || '<tr><td colspan="6" class="text-center text-muted py-3">No recipients matched.</td></tr>');
-
-  // Effective email count = sum of group length, capped at 1 when deduped
-  var effective = 0;
-  order.forEach(function(u) {
-    effective += dedupeSet[u] ? 1 : byUser[u].length;
-  });
-  var scopeLbl = PREVIEW_SCOPE ? 'scope: ' + PREVIEW_SCOPE : '';
-  $('#recipModalCount').text(
-    effective + ' emails → ' + order.length + ' users'
-    + (effective !== PREVIEW_ROWS.length ? ' (was ' + PREVIEW_ROWS.length + ' before dedupe)' : '')
-  );
-  if (PREVIEW_SCOPE) { $('#recipModalScope').text(scopeLbl).show(); } else { $('#recipModalScope').hide(); }
-
-}
-
-function getPageSize() {
-  return parseInt($('#recipPageSize').val(), 10) || 10;
-}
-
-function updatePaginationControls() {
-  var atFirst = PREVIEW_PAGE <= 1;
-  var atLast = PREVIEW_PAGE >= PREVIEW_TOTAL_PAGES;
-  $('#recipPageInfo').text('Page ' + PREVIEW_PAGE + ' of ' + PREVIEW_TOTAL_PAGES);
-  $('#recipFirstBtn').prop('disabled', atFirst);
-  $('#recipPrevBtn').prop('disabled', atFirst);
-  $('#recipNextBtn').prop('disabled', atLast);
-  $('#recipLastBtn').prop('disabled', atLast);
-}
-
-function fetchPreviewPage(page) {
-  PREVIEW_PAGE = page || 1;
-  $('#recipSearch').val('');
-  $('#recipRows').html('<tr><td colspan="6" class="text-center text-muted py-3"><i class="fas fa-spinner fa-spin mr-1"></i>Loading…</td></tr>');
-
-  $.ajax({
-    url: URLS.recipientCount,
-    type: 'POST',
-    data: {
-      csrfmiddlewaretoken: $('input[name=csrfmiddlewaretoken]').val(),
-      projects:     $('#f_project').val()    || [],
-      allocations:  $('#f_allocation').val() || [],
-      departments:  $('#f_dept').val()       || [],
-      resources:    $('#f_resource').val()   || [],
-      alloc_status: $('#f_status').val()     || [],
-      roles:        $('#f_role').val()       || [],
-      subject:      $('#id_subject').val()   || '',
-      body:         $('#id_body').val()      || '',
-      dedupe_users: JSON.stringify(getDedupeUsers()),
-      preview:      'true',
-      page:         PREVIEW_PAGE,
-      page_size:    getPageSize(),
-    },
-    traditional: true,
-    success: function(data) {
-      PREVIEW_ROWS        = data.recipients || [];
-      PREVIEW_SCOPE       = data.scope || null;
-      PREVIEW_TOTAL       = data.count || 0;
-      PREVIEW_TOTAL_PAGES = data.total_pages || 1;
-      PREVIEW_PAGE        = data.page || 1;
-      ALL_MULTI_USERS = (data.multi_users || []).map(function(m) { return m.username; });
-      renderPreviewRows();
-      // Show dedupe-all row if any multi-email users exist across all pages
-      if (ALL_MULTI_USERS.length) {
-        $('#dedupeAllRow').show();
-        var allDeduped = ALL_MULTI_USERS.every(function(u) {
-          return getDedupeUsers().indexOf(u) !== -1;
-        });
-        $('#dedupeAllCb').prop('checked', allDeduped);
-      } else {
-        $('#dedupeAllRow').hide();
-      }
-      updatePaginationControls();
-    },
-    error: function() {
-      $('#recipRows').html('<tr><td colspan="6" class="text-center text-danger py-3">Failed to load.</td></tr>');
-    }
-  });
-}
-
-$(document).on('click', '#previewRecipBtn', function() {
-  $('#recipModal').modal('show');
-  fetchPreviewPage(1);
-});
-$(document).on('click', '#recipFirstBtn', function() {
-  if (PREVIEW_PAGE > 1) fetchPreviewPage(1);
-});
-$(document).on('click', '#recipPrevBtn', function() {
-  if (PREVIEW_PAGE > 1) fetchPreviewPage(PREVIEW_PAGE - 1);
-});
-$(document).on('click', '#recipNextBtn', function() {
-  if (PREVIEW_PAGE < PREVIEW_TOTAL_PAGES) fetchPreviewPage(PREVIEW_PAGE + 1);
-});
-$(document).on('click', '#recipLastBtn', function() {
-  if (PREVIEW_PAGE < PREVIEW_TOTAL_PAGES) fetchPreviewPage(PREVIEW_TOTAL_PAGES);
-});
-$(document).on('change', '#recipPageSize', function() {
-  fetchPreviewPage(1);
-});
-
-// Client-side search: filter visible rows in the current page
-$(document).on('input', '#recipSearch', function() {
-  var q = $(this).val().toLowerCase();
-  $('#recipRows tr').each(function() {
-    var text = $(this).text().toLowerCase();
-    $(this).toggle(!q || text.indexOf(q) !== -1);
-  });
-});
-
-// All multi-email usernames across all pages (from server response).
-var ALL_MULTI_USERS = [];
-
-// Bulk dedupe: toggle ALL multi-email users across all pages.
-$(document).on('change', '#dedupeAllCb', function() {
-  if ($(this).is(':checked')) {
-    setDedupeUsers(ALL_MULTI_USERS.slice());
-  } else {
-    setDedupeUsers([]);
-  }
-  renderPreviewRows();
-  runValidation();
-});
-
-// Per-user dedupe toggle inside the modal.
-$(document).on('change', '.dedupe-cb', function() {
-  var username = $(this).attr('data-username');
-  var cur = getDedupeUsers();
-  var idx = cur.indexOf(username);
-  if ($(this).is(':checked')) {
-    if (idx === -1) cur.push(username);
-  } else {
-    if (idx !== -1) cur.splice(idx, 1);
-  }
-  setDedupeUsers(cur);
-  renderPreviewRows();
-  runValidation();
-});
-
-
-// ── Serialize filter hidden fields before submit ─────────────────
-$('#notifForm').on('submit', function() {
-  $('#h_projects').val(JSON.stringify($('#f_project').val()    || []));
-  $('#h_allocations').val(JSON.stringify($('#f_allocation').val() || []));
-  $('#h_depts').val(JSON.stringify($('#f_dept').val()          || []));
-  $('#h_resources').val(JSON.stringify($('#f_resource').val()  || []));
-  $('#h_statuses').val(JSON.stringify($('#f_status').val()     || []));
-  $('#h_roles').val(JSON.stringify($('#f_role').val()          || []));
-});
-
-// ── Select2 init ─────────────────────────────────────────────────
-$(document).ready(function() {
-  $('.s2').select2({
-    allowClear: true,
-    width: '100%',
-    placeholder: function() { return $(this).data('placeholder'); }
-  });
-
-  // Load first template
-  var $first = $('.tmpl-item').first();
-  if ($first.length) loadTemplate($first);
-});
-
-// ── pageshow: reset validation state + refresh active template ────
-// When a user edits a template in another tab and comes back, bfcache
-// restores the DOM with the OLD textarea content and any stale errors.
-// Force-hide the panel and re-fetch the active template so the textarea
-// reflects the latest body before the next Validate click.
-$(window).on('pageshow', function() {
-  $('#validationPanel').hide();
-  $('#validationOK').hide();
-  $('#validationBad').hide();
-  $('#sendWarn').hide();
-  $('#sendBtn').prop('disabled', true);
-  $('#recipNum').text('?');
-  $('#recipLbl').text('press Validate');
-  $('#emailCount').text('—');
-  $('#multiBadge').hide();
-  $('#multiWarn').hide();
-  setDedupeUsers([]);
-  HAS_VALIDATED = false;
-  var $active = $('.tmpl-item.active');
-  if ($active.length) loadTemplate($active);
-});
diff --git a/coldfront_notifications/static/coldfront_notifications/js/compose_draft.js b/coldfront_notifications/static/coldfront_notifications/js/compose_draft.js
new file mode 100644
index 0000000..4c84a3c
--- /dev/null
+++ b/coldfront_notifications/static/coldfront_notifications/js/compose_draft.js
@@ -0,0 +1,190 @@
+// compose_draft.js — Draft auto-save, resume, and dirty tracking.
+//
+// Loaded after compose_filters.js and before compose_init.js.
+//
+// Globals used: DRAFT_DATA, URLS, FILTER_DATA, FILTERS, FilterStore,
+//               collectFilters (from compose_filters.js)
+// Globals exported: DRAFT_PK, isDraftDirty, restoreDraft
+
+var DRAFT_PK = null;
+var _draftDirty = false;
+var _autoSaveInterval = null;
+var AUTO_SAVE_DELAY_MS = 30000;
+
+function isDraftDirty() {
+  return _draftDirty;
+}
+
+function _markDirty() {
+  _draftDirty = true;
+  $('#draftStatus').text('Unsaved changes').css('color', '#856404');
+}
+
+function _markClean(timestamp) {
+  _draftDirty = false;
+  var time = timestamp || new Date().toLocaleTimeString([], {hour: '2-digit', minute: '2-digit'});
+  $('#draftStatus').text('Draft saved at ' + time).css('color', '#28a745');
+}
+
+function _collectDraftData() {
+  return {
+    csrfmiddlewaretoken: $('input[name=csrfmiddlewaretoken]').val(),
+    draft_pk: DRAFT_PK || '',
+    subject: $('#id_subject').val() || '',
+    body: $('#id_body').val() || '',
+    sender: $('#id_sender').val() || '',
+    reply_to: $('#id_reply_to').val() || '',
+    template_id: $('#hidden_template_id').val() || '',
+    filters: JSON.stringify(collectFilters()),
+    extra_context: JSON.stringify({})
+  };
+}
+
+function saveDraft(callback) {
+  var data = _collectDraftData();
+
+  $('#saveDraftBtn').prop('disabled', true).html('<i class="fas fa-spinner fa-spin mr-1"></i>Saving...');
+
+  $.ajax({
+    url: URLS.draftSave,
+    type: 'POST',
+    data: data,
+    success: function(response) {
+      DRAFT_PK = response.pk;
+      $('#hidden_draft_pk').val(DRAFT_PK);
+      _markClean();
+      if (callback) callback(true);
+    },
+    error: function() {
+      $('#draftStatus').text('Save failed').css('color', '#dc3545');
+      if (callback) callback(false);
+    },
+    complete: function() {
+      $('#saveDraftBtn').prop('disabled', false).html('<i class="fas fa-save mr-1"></i>Save Draft');
+    }
+  });
+}
+
+function _autoSave() {
+  if (_draftDirty) {
+    saveDraft();
+  }
+}
+
+function _startAutoSave() {
+  if (_autoSaveInterval) return;
+  _autoSaveInterval = setInterval(_autoSave, AUTO_SAVE_DELAY_MS);
+}
+
+function _stopAutoSave() {
+  if (_autoSaveInterval) {
+    clearInterval(_autoSaveInterval);
+    _autoSaveInterval = null;
+  }
+}
+
+function restoreDraft(draftData) {
+  if (!draftData) return;
+
+  DRAFT_PK = draftData.pk;
+  $('#hidden_draft_pk').val(DRAFT_PK);
+
+  // Restore form fields
+  if (draftData.subject) $('#id_subject').val(draftData.subject);
+  if (draftData.body) $('#id_body').val(draftData.body);
+  if (draftData.sender) $('#id_sender').val(draftData.sender);
+  if (draftData.reply_to) $('#id_reply_to').val(draftData.reply_to);
+  if (draftData.template_id) $('#hidden_template_id').val(draftData.template_id);
+
+  // Restore filter selections
+  var filters = draftData.filters || {};
+  var filterMap = {
+    departments: '#f_dept',
+    projects: '#f_project',
+    resources: '#f_resource',
+    statuses: '#f_status',
+    allocations: '#f_allocation',
+    roles: '#f_role'
+  };
+
+  // Wait for Select2 and FilterStore to be initialized
+  setTimeout(function() {
+    for (var filterName in filterMap) {
+      var values = filters[filterName] || [];
+      if (!values.length) continue;
+
+      var state = FilterStore.state[filterName];
+      if (!state) continue;
+
+      // Coerce types to match the option IDs
+      var firstOption = state.all.length ? state.all[0] : null;
+      var useInt = firstOption && typeof firstOption.id === 'number';
+      if (useInt) {
+        values = values.map(function(value) { return parseInt(value, 10); });
+      }
+
+      state.selected = values;
+      if (FILTERS[filterName]) {
+        FILTERS[filterName].render();
+        FILTERS[filterName].dispatchChanged();
+      }
+    }
+
+    // Restore extra recipients
+    if (filters.extra_recipients && filters.extra_recipients.length) {
+      $('textarea[name="extra_recipients"]').val(filters.extra_recipients.join('\n'));
+    }
+
+    // Restore dedupe users
+    if (filters.dedupe_users && filters.dedupe_users.length) {
+      $('#h_dedupe_users').val(JSON.stringify(filters.dedupe_users));
+    }
+
+    // Highlight the matching template in the sidebar
+    if (draftData.template_id) {
+      var $templateItem = $('.tmpl-item[data-id="' + draftData.template_id + '"]');
+      if ($templateItem.length) {
+        $templateItem.addClass('active');
+        $('#active-slug').text($templateItem.data('slug'));
+      }
+    }
+
+    _markClean();
+    _updateSummaries();
+  }, 200);
+}
+
+// Dirty tracking — mark dirty on any form input change
+$(document).on('input change', '#id_subject, #id_body, #id_sender, #id_reply_to, textarea[name="extra_recipients"]', _markDirty);
+$(document).on('change', '.s2', function() {
+  // Only mark dirty from user-driven changes (not programmatic)
+  if (!$(this).data('restoring')) {
+    _markDirty();
+  }
+});
+
+// Save Draft button
+$(document).on('click', '#saveDraftBtn', function() {
+  saveDraft();
+});
+
+// Beforeunload warning
+$(window).on('beforeunload', function() {
+  if (_draftDirty) {
+    return 'You have unsaved changes. Leave anyway?';
+  }
+});
+
+// Clear beforeunload on form submit (send)
+$('#notifForm').on('submit', function() {
+  _draftDirty = false;
+  _stopAutoSave();
+});
+
+// Initialize on document ready
+$(document).ready(function() {
+  if (typeof DRAFT_DATA !== 'undefined' && DRAFT_DATA) {
+    restoreDraft(DRAFT_DATA);
+  }
+  _startAutoSave();
+});
diff --git a/coldfront_notifications/static/coldfront_notifications/js/compose_filters.js b/coldfront_notifications/static/coldfront_notifications/js/compose_filters.js
new file mode 100644
index 0000000..78305d5
--- /dev/null
+++ b/coldfront_notifications/static/coldfront_notifications/js/compose_filters.js
@@ -0,0 +1,618 @@
+// compose_filters.js — Client-side state-driven cascading filter system.
+//
+// All filter data is loaded once on page load (FILTER_DATA from Django).
+// Cross-filter narrowing happens entirely in the browser — zero AJAX.
+//
+// State model: each filter has {all, visible, selected}.
+// - "all"      = full server dataset, never changes
+// - "visible"  = subset of all after upstream (top-down) narrowing
+// - "selected" = user's manual picks
+//
+// Cascade directions:
+// - Top-down (narrow): department → projects → resources → allocations.
+//   Resource also narrows projects (bidirectional with cycle guard).
+// - Bottom-up (inform): selecting a child filter shows context in the
+//   detail cards (e.g. which departments/projects an allocation belongs to)
+//   without modifying upstream dropdowns (except resource → projects)
+//
+// Globals used:    FILTER_DATA (from Django template)
+// Globals exported: collectFilters, getDedupeUsers, setDedupeUsers
+
+var FilterStore = {
+  state: {},
+  listeners: {},
+  _dispatching: {},
+
+  register: function(widget, events) {
+    for (var i = 0; i < events.length; i++) {
+      var evt = events[i];
+      if (!this.listeners[evt]) this.listeners[evt] = [];
+      this.listeners[evt].push(widget);
+    }
+  },
+
+  dispatch: function(eventName) {
+    if (this._dispatching[eventName]) return;
+    this._dispatching[eventName] = true;
+    try {
+      var chain = this.listeners[eventName] || [];
+      for (var i = 0; i < chain.length; i++) {
+        chain[i].narrow();
+        chain[i].dispatchChanged();
+      }
+    } finally {
+      this._dispatching[eventName] = false;
+    }
+  },
+
+  getSelected: function(name) {
+    var s = this.state[name];
+    return s ? s.selected : [];
+  },
+
+  getEffectiveIds: function(name) {
+    var s = this.state[name];
+    if (!s) return null;
+    if (s.selected.length) return s.selected;
+    if (s.visible.length < s.all.length) {
+      return s.visible.map(function(v) { return v.id; });
+    }
+    return null;
+  }
+};
+
+
+function FilterWidget(config) {
+  this.name = config.name;
+  this.selector = config.selector;
+  this.emits = config.emits;
+  this.narrowedBy = config.narrowedBy || [];
+  this.narrowFn = config.narrowFn || null;
+  this._isRendering = false;
+}
+
+FilterWidget.prototype.init = function(data) {
+  FilterStore.state[this.name] = {
+    all: data.options || [],
+    visible: data.options || [],
+    selected: []
+  };
+  FilterStore.register(this, this.narrowedBy);
+  this.render();
+  this._bindChange();
+};
+
+FilterWidget.prototype.narrow = function() {
+  var state = FilterStore.state[this.name];
+  if (!this.narrowFn) {
+    state.visible = state.all;
+    return;
+  }
+
+  var visible = [];
+  for (var i = 0; i < state.all.length; i++) {
+    if (this.narrowFn(state.all[i], FilterStore)) {
+      visible.push(state.all[i]);
+    }
+  }
+  state.visible = visible;
+
+  var visibleIds = _toLookup(visible.map(function(v) { return v.id; }));
+  state.selected = state.selected.filter(function(id) {
+    return visibleIds[id] === true;
+  });
+
+  this.render();
+};
+
+FilterWidget.prototype.render = function() {
+  this._isRendering = true;
+  var state = FilterStore.state[this.name];
+  var $sel = $(this.selector);
+  var html = '';
+
+  for (var i = 0; i < state.visible.length; i++) {
+    var opt = state.visible[i];
+    var escaped = $('<div>').text(opt.label).html();
+    html += '<option value="' + opt.id + '">' + escaped + '</option>';
+  }
+
+  $sel.html(html);
+  $sel.val(state.selected.map(String));
+  $sel.trigger('change.select2');
+  this._isRendering = false;
+};
+
+FilterWidget.prototype.dispatchChanged = function() {
+  if (this.emits) FilterStore.dispatch(this.emits);
+};
+
+FilterWidget.prototype._bindChange = function() {
+  var self = this;
+  $(document).on('change', this.selector, function() {
+    if (self._isRendering) return;
+
+    var raw = $(self.selector).val() || [];
+    var state = FilterStore.state[self.name];
+    var firstOpt = state.all.length ? state.all[0] : null;
+    var useInt = firstOpt && typeof firstOpt.id === 'number';
+    state.selected = useInt
+      ? raw.map(function(v) { return parseInt(v, 10); })
+      : raw;
+
+    _invalidateValidation();
+    self.dispatchChanged();
+    _updateSummaries();
+  });
+};
+
+
+// Top-down narrowing functions
+
+function narrowProjects(row, store) {
+  var passedDepartment = true;
+  var passedResource = true;
+
+  // Department filter: check if this project belongs to a selected department
+  var selectedDepts = store.getSelected('departments');
+  if (selectedDepts.length) {
+    passedDepartment = false;
+    var deptState = store.state.departments;
+    for (var i = 0; i < deptState.all.length; i++) {
+      var dept = deptState.all[i];
+      if (selectedDepts.indexOf(dept.id) === -1) continue;
+      if (dept.project_ids && dept.project_ids.indexOf(row.id) !== -1) {
+        passedDepartment = true;
+        break;
+      }
+    }
+  }
+
+  // Resource filter: check if this project has at least one selected resource
+  var selectedResources = store.getSelected('resources');
+  if (selectedResources.length) {
+    passedResource = false;
+    var resState = store.state.resources;
+    for (var i = 0; i < resState.all.length; i++) {
+      var resource = resState.all[i];
+      if (selectedResources.indexOf(resource.id) === -1) continue;
+      if (resource.project_ids && resource.project_ids.indexOf(row.id) !== -1) {
+        passedResource = true;
+        break;
+      }
+    }
+  }
+
+  return passedDepartment && passedResource;
+}
+
+function narrowResources(row, store) {
+  var projectIds = store.getEffectiveIds('projects');
+  if (!projectIds) return true;
+  var lookup = _toLookup(projectIds);
+  var pids = row.project_ids || [];
+  for (var i = 0; i < pids.length; i++) {
+    if (lookup[pids[i]]) return true;
+  }
+  return false;
+}
+
+function narrowAllocations(row, store) {
+  var projectIds = store.getEffectiveIds('projects');
+  if (projectIds && !_toLookup(projectIds)[row.project_id]) return false;
+
+  var selResources = store.getSelected('resources');
+  if (selResources.length) {
+    var rids = row.resource_ids || [];
+    var found = false;
+    for (var i = 0; i < rids.length; i++) {
+      if (selResources.indexOf(rids[i]) !== -1) { found = true; break; }
+    }
+    if (!found) return false;
+  }
+
+  var selStatuses = store.getSelected('statuses');
+  if (selStatuses.length && selStatuses.indexOf(row.status) === -1) return false;
+
+  return true;
+}
+
+function _toLookup(arr) {
+  var m = {};
+  for (var i = 0; i < arr.length; i++) m[arr[i]] = true;
+  return m;
+}
+
+
+// Filter instances
+
+var FILTERS = {
+  departments: new FilterWidget({
+    name: 'departments',
+    selector: '#f_dept',
+    emits: 'DEPARTMENT_CHANGED',
+    narrowedBy: [],
+    narrowFn: null
+  }),
+  projects: new FilterWidget({
+    name: 'projects',
+    selector: '#f_project',
+    emits: 'PROJECT_CHANGED',
+    narrowedBy: ['DEPARTMENT_CHANGED', 'RESOURCE_CHANGED'],
+    narrowFn: narrowProjects
+  }),
+  resources: new FilterWidget({
+    name: 'resources',
+    selector: '#f_resource',
+    emits: 'RESOURCE_CHANGED',
+    narrowedBy: ['PROJECT_CHANGED'],
+    narrowFn: narrowResources
+  }),
+  statuses: new FilterWidget({
+    name: 'statuses',
+    selector: '#f_status',
+    emits: 'STATUS_CHANGED',
+    narrowedBy: [],
+    narrowFn: null
+  }),
+  allocations: new FilterWidget({
+    name: 'allocations',
+    selector: '#f_allocation',
+    emits: 'ALLOCATION_CHANGED',
+    narrowedBy: ['PROJECT_CHANGED', 'RESOURCE_CHANGED', 'STATUS_CHANGED'],
+    narrowFn: narrowAllocations
+  }),
+  roles: new FilterWidget({
+    name: 'roles',
+    selector: '#f_role',
+    emits: 'ROLE_CHANGED',
+    narrowedBy: [],
+    narrowFn: null
+  })
+};
+
+
+// Shared helpers
+
+function collectFilters() {
+  var filters = {};
+  var keys = ['departments', 'projects', 'resources', 'statuses', 'allocations', 'roles'];
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+    var state = FilterStore.state[key];
+    filters[key] = (state && state.selected.length) ? state.selected.map(String) : [];
+  }
+  return filters;
+}
+
+function getDedupeUsers() {
+  try {
+    var v = JSON.parse($('#h_dedupe_users').val() || '[]');
+    return Array.isArray(v) ? v : [];
+  } catch (e) { return []; }
+}
+
+function setDedupeUsers(list) {
+  $('#h_dedupe_users').val(JSON.stringify(list || []));
+}
+
+
+function _invalidateValidation() {
+  $('#recipNum').text('?');
+  $('#recipLbl').text('press Validate');
+  $('#sendBtn').prop('disabled', true);
+  $('#previewRecipBtn').prop('disabled', true);
+  $('#sendWarn').hide();
+  setDedupeUsers([]);
+  if (typeof _setValidateButtonState === 'function') _setValidateButtonState('default');
+  if (typeof _hideTopValidationResult === 'function') _hideTopValidationResult();
+}
+
+
+// Filter details — inline breakdown cards with bottom-up context
+
+var FILTER_LABELS = {
+  departments: 'Departments',
+  projects: 'Projects',
+  resources: 'Resources',
+  statuses: 'Alloc Status',
+  allocations: 'Allocations',
+  roles: 'Roles'
+};
+
+function _updateSummaries() {
+  _renderFilterDetails();
+  _updateClearButton();
+}
+
+function _getBreakdown(name, state) {
+  if (name === 'allocations') {
+    var byStatus = {};
+    for (var i = 0; i < state.visible.length; i++) {
+      var s = state.visible[i].status || 'Unknown';
+      byStatus[s] = (byStatus[s] || 0) + 1;
+    }
+    var parts = [];
+    for (var key in byStatus) parts.push(byStatus[key] + ' ' + key);
+    return parts.join(', ');
+  }
+
+  if (state.selected.length && state.selected.length <= 5) {
+    var labels = [];
+    var selLookup = _toLookup(state.selected);
+    for (var i = 0; i < state.all.length; i++) {
+      if (selLookup[state.all[i].id]) labels.push(state.all[i].label);
+    }
+    return labels.join(', ');
+  }
+
+  return '';
+}
+
+function _getTopDownInfo(name) {
+  var sources = {
+    projects: ['Department', 'Resource'],
+    resources: ['Project'],
+    allocations: ['Project', 'Resource', 'Alloc Status']
+  };
+  var deps = sources[name];
+  if (!deps) return '';
+
+  var active = [];
+  if (deps.indexOf('Department') !== -1 && FilterStore.getSelected('departments').length) {
+    active.push('Department');
+  }
+  if (deps.indexOf('Project') !== -1 && FilterStore.getEffectiveIds('projects')) {
+    active.push('Project');
+  }
+  if (deps.indexOf('Resource') !== -1 && FilterStore.getSelected('resources').length) {
+    active.push('Resource');
+  }
+  if (deps.indexOf('Alloc Status') !== -1 && FilterStore.getSelected('statuses').length) {
+    active.push('Alloc Status');
+  }
+  return active.length ? 'Filtered by: ' + active.join(', ') : '';
+}
+
+function _getBottomUpContext(name, state) {
+  if (!state.selected.length) return '';
+
+  if (name === 'allocations') {
+    var deptNames = {};
+    var projectNames = {};
+    var resourceNames = {};
+    var statuses = {};
+    var deptState = FilterStore.state.departments;
+    var projState = FilterStore.state.projects;
+    var resState = FilterStore.state.resources;
+
+    // Build resource ID → label lookup
+    var resourceLabelById = {};
+    if (resState) {
+      for (var r = 0; r < resState.all.length; r++) {
+        resourceLabelById[resState.all[r].id] = resState.all[r].label;
+      }
+    }
+
+    for (var i = 0; i < state.selected.length; i++) {
+      var alloc = null;
+      for (var j = 0; j < state.all.length; j++) {
+        if (state.all[j].id === state.selected[i]) { alloc = state.all[j]; break; }
+      }
+      if (!alloc) continue;
+
+      if (alloc.status) statuses[alloc.status] = true;
+
+      // Resolve resource names
+      var rids = alloc.resource_ids || [];
+      for (var r = 0; r < rids.length; r++) {
+        var resLabel = resourceLabelById[rids[r]];
+        if (resLabel) resourceNames[resLabel] = true;
+      }
+
+      // Find project label
+      if (projState) {
+        for (var j = 0; j < projState.all.length; j++) {
+          if (projState.all[j].id === alloc.project_id) {
+            projectNames[projState.all[j].label] = true;
+            break;
+          }
+        }
+      }
+
+      // Find department for this project
+      if (deptState) {
+        for (var j = 0; j < deptState.all.length; j++) {
+          var dept = deptState.all[j];
+          if (dept.project_ids && dept.project_ids.indexOf(alloc.project_id) !== -1) {
+            deptNames[dept.label] = true;
+          }
+        }
+      }
+    }
+
+    var parts = [];
+    var deptList = Object.keys(deptNames);
+    if (deptList.length) parts.push('Dept: ' + (deptList.length <= 3 ? deptList.join(', ') : deptList.length + ' departments'));
+    var projList = Object.keys(projectNames);
+    if (projList.length) parts.push('Project: ' + (projList.length <= 3 ? projList.join(', ') : projList.length + ' projects'));
+    var resList = Object.keys(resourceNames);
+    if (resList.length) parts.push('Resource: ' + (resList.length <= 3 ? resList.join(', ') : resList.length + ' resources'));
+    var statusList = Object.keys(statuses);
+    if (statusList.length) parts.push('Status: ' + statusList.join(', '));
+    return parts.length ? 'Context: ' + parts.join(' · ') : '';
+  }
+
+  if (name === 'projects') {
+    var deptState = FilterStore.state.departments;
+    if (!deptState) return '';
+
+    var deptNames = {};
+    var selLookup = _toLookup(state.selected);
+    for (var i = 0; i < deptState.all.length; i++) {
+      var dept = deptState.all[i];
+      var deptPids = dept.project_ids || [];
+      for (var j = 0; j < deptPids.length; j++) {
+        if (selLookup[deptPids[j]]) {
+          deptNames[dept.label] = true;
+          break;
+        }
+      }
+    }
+
+    var deptList = Object.keys(deptNames);
+    if (!deptList.length) return '';
+    return 'Dept: ' + (deptList.length <= 3 ? deptList.join(', ') : deptList.length + ' departments');
+  }
+
+  if (name === 'roles') {
+    var roleState = FilterStore.state.roles;
+    var deptState = FilterStore.state.departments;
+    if (!roleState || !deptState) return '';
+
+    var roleProjectIds = {};
+    for (var i = 0; i < roleState.all.length; i++) {
+      var role = roleState.all[i];
+      if (state.selected.indexOf(role.id) === -1) continue;
+      var pids = role.project_ids || [];
+      for (var j = 0; j < pids.length; j++) roleProjectIds[pids[j]] = true;
+    }
+
+    var matchedDepts = [];
+    for (var i = 0; i < deptState.all.length; i++) {
+      var dept = deptState.all[i];
+      var deptPids = dept.project_ids || [];
+      for (var j = 0; j < deptPids.length; j++) {
+        if (roleProjectIds[deptPids[j]]) { matchedDepts.push(dept.label); break; }
+      }
+    }
+
+    var projectCount = Object.keys(roleProjectIds).length;
+    var parts = [];
+    if (matchedDepts.length) parts.push(matchedDepts.length <= 3 ? matchedDepts.join(', ') : matchedDepts.length + ' departments');
+    if (projectCount) parts.push(projectCount + ' projects');
+    return parts.length ? 'Present in: ' + parts.join(' across ') : '';
+  }
+
+  if (name === 'resources') {
+    var resState = FilterStore.state.resources;
+    var deptState = FilterStore.state.departments;
+    if (!resState || !deptState) return '';
+
+    var resProjectIds = {};
+    for (var i = 0; i < resState.all.length; i++) {
+      var res = resState.all[i];
+      if (state.selected.indexOf(res.id) === -1) continue;
+      var pids = res.project_ids || [];
+      for (var j = 0; j < pids.length; j++) resProjectIds[pids[j]] = true;
+    }
+
+    var matchedDepts = [];
+    for (var i = 0; i < deptState.all.length; i++) {
+      var dept = deptState.all[i];
+      var deptPids = dept.project_ids || [];
+      for (var j = 0; j < deptPids.length; j++) {
+        if (resProjectIds[deptPids[j]]) { matchedDepts.push(dept.label); break; }
+      }
+    }
+
+    var projectCount = Object.keys(resProjectIds).length;
+    var parts = [];
+    if (matchedDepts.length) parts.push(matchedDepts.length <= 3 ? matchedDepts.join(', ') : matchedDepts.length + ' departments');
+    if (projectCount) parts.push(projectCount + ' projects');
+    return parts.length ? 'Spans: ' + parts.join(' across ') : '';
+  }
+
+  if (name === 'statuses') {
+    var allocState = FilterStore.state.allocations;
+    if (!allocState) return '';
+    var matchCount = 0;
+    for (var i = 0; i < allocState.visible.length; i++) {
+      if (state.selected.indexOf(allocState.visible[i].status) !== -1) matchCount++;
+    }
+    return matchCount ? matchCount + ' matching allocations' : '';
+  }
+
+  return '';
+}
+
+function _renderFilterDetails() {
+  var $container = $('#filterDetails').empty();
+  var keys = ['departments', 'projects', 'resources', 'statuses', 'allocations', 'roles'];
+
+  for (var i = 0; i < keys.length; i++) {
+    var k = keys[i];
+    var state = FilterStore.state[k];
+    if (!state) continue;
+
+    var label = FILTER_LABELS[k] || k;
+    var isNarrowed = state.visible.length < state.all.length;
+    var hasSelections = state.selected.length > 0;
+
+    if (!isNarrowed && !hasSelections) continue;
+
+    var countText = '<span class="count">' + state.visible.length + '</span>';
+    if (isNarrowed) {
+      countText += ' <span style="color:#888;">(of ' + state.all.length + ')</span>';
+    }
+    if (hasSelections) {
+      countText += ' · <span style="color:#0c5460;">' + state.selected.length + ' selected</span>';
+    }
+
+    var breakdown = _getBreakdown(k, state);
+    var topDownInfo = _getTopDownInfo(k);
+    var bottomUpContext = _getBottomUpContext(k, state);
+
+    var html = '<div class="recip-detail-card' + (isNarrowed ? ' narrowed' : '') + '">';
+    html += '<div class="recip-detail-title">' + label + ': ' + countText + '</div>';
+    if (breakdown) html += '<div class="recip-detail-breakdown">' + breakdown + '</div>';
+    if (bottomUpContext) html += '<div class="recip-detail-filtered-by" style="color:#0d6efd;">' + bottomUpContext + '</div>';
+    if (topDownInfo) html += '<div class="recip-detail-filtered-by">' + topDownInfo + '</div>';
+    html += '</div>';
+
+    $container.append(html);
+  }
+}
+
+function updateFilterSummaries() { _updateSummaries(); }
+
+function clearAllFilters() {
+  var keys = ['departments', 'projects', 'resources', 'statuses', 'allocations', 'roles'];
+  for (var i = 0; i < keys.length; i++) {
+    var state = FilterStore.state[keys[i]];
+    if (state) {
+      state.selected = [];
+      state.visible = state.all;
+    }
+    if (FILTERS[keys[i]]) FILTERS[keys[i]].render();
+  }
+  _invalidateValidation();
+  _updateSummaries();
+}
+
+function _updateClearButton() {
+  var keys = ['departments', 'projects', 'resources', 'statuses', 'allocations', 'roles'];
+  var hasAny = false;
+  for (var i = 0; i < keys.length; i++) {
+    var state = FilterStore.state[keys[i]];
+    if (state && state.selected.length) { hasAny = true; break; }
+  }
+  $('#clearFiltersBtn').toggle(hasAny);
+}
+
+$(document).on('click', '#clearFiltersBtn', clearAllFilters);
+
+
+// Initialization
+
+$(document).ready(function() {
+  if (typeof FILTER_DATA === 'undefined') return;
+
+  var keys = ['departments', 'projects', 'resources', 'statuses', 'allocations', 'roles'];
+  for (var i = 0; i < keys.length; i++) {
+    var k = keys[i];
+    if (FILTERS[k] && FILTER_DATA[k]) FILTERS[k].init(FILTER_DATA[k]);
+  }
+
+  _updateSummaries();
+});
diff --git a/coldfront_notifications/static/coldfront_notifications/js/compose_init.js b/coldfront_notifications/static/coldfront_notifications/js/compose_init.js
new file mode 100644
index 0000000..d120283
--- /dev/null
+++ b/coldfront_notifications/static/coldfront_notifications/js/compose_init.js
@@ -0,0 +1,51 @@
+// ── compose_init.js ─────────────────────────────────────────────
+// Select2 initialization, form submit serialization, pageshow reset.
+// Must be loaded LAST (after all other compose_*.js files).
+//
+// Globals used: loadTemplate (from compose_templates.js),
+//               setDedupeUsers (from compose_filters.js),
+//               HAS_VALIDATED (from compose_validate.js)
+
+// ── Serialize filter hidden fields before submit ─────────────────
+$('#notifForm').on('submit', function() {
+  $('#h_projects').val(JSON.stringify($('#f_project').val() || []));
+  $('#h_allocations').val(JSON.stringify($('#f_allocation').val() || []));
+  $('#h_depts').val(JSON.stringify($('#f_dept').val() || []));
+  $('#h_resources').val(JSON.stringify($('#f_resource').val() || []));
+  $('#h_statuses').val(JSON.stringify($('#f_status').val() || []));
+  $('#h_roles').val(JSON.stringify($('#f_role').val() || []));
+  if (typeof DRAFT_PK !== 'undefined' && DRAFT_PK) {
+    $('#hidden_draft_pk').val(DRAFT_PK);
+  }
+});
+
+// ── Select2 init ─────────────────────────────────────────────────
+$(document).ready(function() {
+  $('.s2').select2({
+    allowClear: true,
+    width: '100%',
+    placeholder: function() { return $(this).data('placeholder'); }
+  });
+});
+
+// ── pageshow: reset validation state + refresh active template ────
+// When a user edits a template in another tab and comes back, bfcache
+// restores the DOM with the OLD textarea content and any stale errors.
+// Force-hide the panel and re-fetch the active template so the textarea
+// reflects the latest body before the next Validate click.
+$(window).on('pageshow', function() {
+  $('#validationPanel').hide();
+  $('#validationOK').hide();
+  $('#validationBad').hide();
+  $('#sendWarn').hide();
+  $('#sendBtn').prop('disabled', true);
+  $('#recipNum').text('?');
+  $('#recipLbl').text('press Validate');
+  $('#emailCount').text('—');
+  $('#multiBadge').hide();
+  $('#multiWarn').hide();
+  setDedupeUsers([]);
+  HAS_VALIDATED = false;
+  var $active = $('.tmpl-item.active');
+  if ($active.length) loadTemplate($active);
+});
diff --git a/coldfront_notifications/static/coldfront_notifications/js/compose_preview.js b/coldfront_notifications/static/coldfront_notifications/js/compose_preview.js
new file mode 100644
index 0000000..e0557a8
--- /dev/null
+++ b/coldfront_notifications/static/coldfront_notifications/js/compose_preview.js
@@ -0,0 +1,304 @@
+// ── compose_preview.js ──────────────────────────────────────────
+// Email preview modal and recipient preview modal (with dedupe + pagination).
+//
+// Globals used: URLS (from Django template),
+//               collectFilters, getDedupeUsers, setDedupeUsers (from compose_filters.js),
+//               runValidation (from compose_validate.js)
+
+// Blur focused element before modals hide to avoid aria-hidden warning.
+$('#previewModal, #recipModal').on('hide.bs.modal', function() {
+  document.activeElement && document.activeElement.blur();
+});
+
+// ═══════════════════════════════════════════════════════════════════
+// EMAIL PREVIEW MODAL
+// ═══════════════════════════════════════════════════════════════════
+
+var PREVIEW_SAMPLES = [];
+
+function renderPreviewSample(idx) {
+  var s = PREVIEW_SAMPLES[idx];
+  if (!s) {
+    // "Template" — no recipient, raw tokens
+    $('#prev-to').text('—');
+    $('#prev-subject').text($('#id_subject').val() || '—');
+    $('#prev-body').text($('#id_body').val() || '—');
+    $('#prev-error').hide();
+    $('#prev-footer').text('Showing template with literal placeholders');
+    return;
+  }
+  $('#prev-to').text((s.recipient.name || s.recipient.username) + ' <' + s.recipient.email + '>');
+  $('#prev-subject').text(s.subject || '—');
+  $('#prev-body').text(s.body || '—');
+  if (s.error) {
+    $('#prev-error').text('Resolution error: ' + s.error).show();
+  } else {
+    $('#prev-error').hide();
+  }
+  var ctx = [];
+  if (s.recipient.project)    ctx.push('project: ' + s.recipient.project);
+  if (s.recipient.allocation) ctx.push('allocation: ' + s.recipient.allocation);
+  $('#prev-footer').text(ctx.join(' · ') || 'recipient-only context');
+}
+
+$(document).on('click', '#previewBtn', function() {
+  $('#prev-from').text($('#id_sender').val());
+  $('#prev-replyto').text($('#id_reply_to').val());
+  // Show the raw template immediately while samples load
+  PREVIEW_SAMPLES = [];
+  $('#prev-recipient-picker').html('<option value="">— Template (raw placeholders) —</option>'
+    + '<option disabled>Loading samples…</option>');
+  renderPreviewSample(null);
+  $('#prev-scope-badge').text('');
+  $('#previewModal').modal('show');
+
+  $.ajax({
+    url: URLS.previewRender,
+    type: 'POST',
+    data: {
+      csrfmiddlewaretoken: $('input[name=csrfmiddlewaretoken]').val(),
+      subject:      $('#id_subject').val() || '',
+      body:         $('#id_body').val()    || '',
+      filters:      JSON.stringify(collectFilters()),
+      dedupe_users: JSON.stringify(getDedupeUsers()),
+    },
+    success: function(data) {
+      PREVIEW_SAMPLES = data.samples || [];
+      var opts = ['<option value="">— Template (raw placeholders) —</option>'];
+      PREVIEW_SAMPLES.forEach(function(s, i) {
+        var lbl = (s.recipient.name || s.recipient.username) + ' <' + s.recipient.email + '>';
+        if (s.recipient.project) lbl += ' · ' + s.recipient.project;
+        opts.push('<option value="' + i + '">' + lbl + '</option>');
+      });
+      if (!PREVIEW_SAMPLES.length) {
+        opts.push('<option disabled>(no matching recipients)</option>');
+      }
+      $('#prev-recipient-picker').html(opts.join(''));
+      if (data.scope) $('#prev-scope-badge').text('scope: ' + data.scope + ' · ' + (data.total_emails || 0) + ' total');
+
+      // Auto-select the first real sample if available
+      if (PREVIEW_SAMPLES.length) {
+        $('#prev-recipient-picker').val('0');
+        renderPreviewSample(0);
+      } else {
+        renderPreviewSample(null);
+      }
+    },
+    error: function() {
+      $('#prev-recipient-picker').html('<option value="">— Template (raw placeholders) —</option>');
+      $('#prev-footer').text('Preview failed to load — showing raw template');
+    },
+  });
+});
+
+$(document).on('change', '#prev-recipient-picker', function() {
+  var v = $(this).val();
+  renderPreviewSample(v === '' ? null : parseInt(v, 10));
+});
+
+// ═══════════════════════════════════════════════════════════════════
+// RECIPIENT PREVIEW MODAL (with dedupe + pagination)
+// ═══════════════════════════════════════════════════════════════════
+
+var PREVIEW_ROWS  = [];
+var PREVIEW_SCOPE = null;
+var PREVIEW_PAGE  = 1;
+var PREVIEW_TOTAL_PAGES = 1;
+var PREVIEW_TOTAL = 0;
+var PREVIEW_USER_COUNT = 0;
+var ALL_MULTI_USERS = [];
+var ALL_MULTI_COUNTS = {};  // username → email count (for dedup math)
+
+function renderPreviewRows() {
+  // Group rows by username preserving order.
+  var order = [], byUser = {};
+  PREVIEW_ROWS.forEach(function(r) {
+    var u = r.username;
+    if (!(u in byUser)) { order.push(u); byUser[u] = []; }
+    byUser[u].push(r);
+  });
+
+  var dedupeSet = {};
+  getDedupeUsers().forEach(function(u) { dedupeSet[u] = true; });
+
+  // Build a set from the server's cross-page multi-user list for O(1) lookup.
+  var multiSet = {};
+  ALL_MULTI_USERS.forEach(function(u) { multiSet[u] = true; });
+
+  var html = '';
+  order.forEach(function(u) {
+    var group = byUser[u];
+    var isMulti = !!multiSet[u];
+    var isDeduped = !!dedupeSet[u];
+    group.forEach(function(r, idx) {
+      var first = idx === 0;
+      var muted = (isDeduped && !first);
+      if (isDeduped && group.length === 1 && isMulti) muted = true;
+      var styleAttr = muted
+        ? ' style="color:#aab0b7;text-decoration:line-through;font-style:italic;"'
+        : '';
+      var cbCell = '';
+      if (first && isMulti) {
+        cbCell = '<td style="text-align:center;"><input type="checkbox" class="dedupe-cb" '
+               + 'data-username="' + u + '"'
+               + (isDeduped ? ' checked' : '')
+               + ' title="send only one email to ' + u + '"></td>';
+      } else {
+        cbCell = '<td></td>';
+      }
+      html += '<tr' + styleAttr + '>'
+        + cbCell
+        + '<td>' + (r.full_name||'') + (isMulti && first ? ' <span class="badge badge-warning ml-1" style="font-size:.6rem;">multi</span>' : '') + '</td>'
+        + '<td style="font-family:monospace;font-size:.78rem;">' + (r.email||'') + '</td>'
+        + '<td>' + (r.role||'') + '</td>'
+        + '<td>' + (r.project||'') + '</td>'
+        + '<td style="font-size:.78rem;">' + (r.allocation||'') + '</td>'
+        + '</tr>';
+    });
+  });
+  $('#recipRows').html(html || '<tr><td colspan="6" class="text-center text-muted py-3">No recipients matched.</td></tr>');
+
+  // Compute effective email count: deduped users count as 1 email each.
+  var dedupeList = getDedupeUsers();
+  var dedupeSet = {};
+  dedupeList.forEach(function(u) { dedupeSet[u] = true; });
+
+  // For each multi-user that's deduped, subtract (count - 1) from total.
+  var effective = PREVIEW_TOTAL;
+  if (dedupeList.length && PREVIEW_TOTAL > 0) {
+    ALL_MULTI_USERS.forEach(function(u) {
+      if (dedupeSet[u] && ALL_MULTI_COUNTS[u]) {
+        effective -= (ALL_MULTI_COUNTS[u] - 1);
+      }
+    });
+  }
+
+  var countText = effective + ' emails, ' + PREVIEW_USER_COUNT + ' users';
+  if (effective !== PREVIEW_TOTAL) {
+    countText += ' (was ' + PREVIEW_TOTAL + ' before dedupe)';
+  }
+  $('#recipModalCount').text(countText);
+  $('#recipModalScope').hide();
+}
+
+function getPageSize() {
+  return parseInt($('#recipPageSize').val(), 10) || 10;
+}
+
+function updatePaginationControls() {
+  var atFirst = PREVIEW_PAGE <= 1;
+  var atLast = PREVIEW_PAGE >= PREVIEW_TOTAL_PAGES;
+  $('#recipPageInfo').text('Page ' + PREVIEW_PAGE + ' of ' + PREVIEW_TOTAL_PAGES);
+  $('#recipFirstBtn').prop('disabled', atFirst);
+  $('#recipPrevBtn').prop('disabled', atFirst);
+  $('#recipNextBtn').prop('disabled', atLast);
+  $('#recipLastBtn').prop('disabled', atLast);
+}
+
+function fetchPreviewPage(page) {
+  PREVIEW_PAGE = page || 1;
+  $('#recipSearch').val('');
+  $('#recipRows').html('<tr><td colspan="6" class="text-center text-muted py-3"><i class="fas fa-spinner fa-spin mr-1"></i>Loading…</td></tr>');
+
+  $.ajax({
+    url: URLS.recipientCount,
+    type: 'POST',
+    data: {
+      csrfmiddlewaretoken: $('input[name=csrfmiddlewaretoken]').val(),
+      projects:     $('#f_project').val()    || [],
+      allocations:  $('#f_allocation').val() || [],
+      departments:  $('#f_dept').val()       || [],
+      resources:    $('#f_resource').val()   || [],
+      alloc_status: $('#f_status').val()     || [],
+      roles:        $('#f_role').val()       || [],
+      subject:      $('#id_subject').val()   || '',
+      body:         $('#id_body').val()      || '',
+      dedupe_users: JSON.stringify(getDedupeUsers()),
+      preview:      'true',
+      page:         PREVIEW_PAGE,
+      page_size:    getPageSize(),
+    },
+    traditional: true,
+    success: function(data) {
+      PREVIEW_ROWS        = data.recipients || [];
+      PREVIEW_SCOPE       = data.scope || null;
+      PREVIEW_TOTAL       = data.count || 0;
+      PREVIEW_USER_COUNT  = data.user_count || 0;
+      PREVIEW_TOTAL_PAGES = data.total_pages || 1;
+      PREVIEW_PAGE        = data.page || 1;
+      ALL_MULTI_USERS = (data.multi_users || []).map(function(m) { return m.username; });
+      ALL_MULTI_COUNTS = {};
+      (data.multi_users || []).forEach(function(m) { ALL_MULTI_COUNTS[m.username] = m.count; });
+      renderPreviewRows();
+      // Show dedupe-all row if any multi-email users exist across all pages
+      if (ALL_MULTI_USERS.length) {
+        $('#dedupeAllRow').show();
+        var allDeduped = ALL_MULTI_USERS.every(function(u) {
+          return getDedupeUsers().indexOf(u) !== -1;
+        });
+        $('#dedupeAllCb').prop('checked', allDeduped);
+      } else {
+        $('#dedupeAllRow').hide();
+      }
+      updatePaginationControls();
+    },
+    error: function() {
+      $('#recipRows').html('<tr><td colspan="6" class="text-center text-danger py-3">Failed to load.</td></tr>');
+    }
+  });
+}
+
+$(document).on('click', '#previewRecipBtn', function() {
+  $('#recipModal').modal('show');
+  fetchPreviewPage(1);
+});
+$(document).on('click', '#recipFirstBtn', function() {
+  if (PREVIEW_PAGE > 1) fetchPreviewPage(1);
+});
+$(document).on('click', '#recipPrevBtn', function() {
+  if (PREVIEW_PAGE > 1) fetchPreviewPage(PREVIEW_PAGE - 1);
+});
+$(document).on('click', '#recipNextBtn', function() {
+  if (PREVIEW_PAGE < PREVIEW_TOTAL_PAGES) fetchPreviewPage(PREVIEW_PAGE + 1);
+});
+$(document).on('click', '#recipLastBtn', function() {
+  if (PREVIEW_PAGE < PREVIEW_TOTAL_PAGES) fetchPreviewPage(PREVIEW_TOTAL_PAGES);
+});
+$(document).on('change', '#recipPageSize', function() {
+  fetchPreviewPage(1);
+});
+
+// Client-side search: filter visible rows in the current page
+$(document).on('input', '#recipSearch', function() {
+  var q = $(this).val().toLowerCase();
+  $('#recipRows tr').each(function() {
+    var text = $(this).text().toLowerCase();
+    $(this).toggle(!q || text.indexOf(q) !== -1);
+  });
+});
+
+// Bulk dedupe: toggle ALL multi-email users across all pages.
+$(document).on('change', '#dedupeAllCb', function() {
+  if ($(this).is(':checked')) {
+    setDedupeUsers(ALL_MULTI_USERS.slice());
+  } else {
+    setDedupeUsers([]);
+  }
+  renderPreviewRows();
+  runValidation();
+});
+
+// Per-user dedupe toggle inside the modal.
+$(document).on('change', '.dedupe-cb', function() {
+  var username = $(this).attr('data-username');
+  var cur = getDedupeUsers();
+  var idx = cur.indexOf(username);
+  if ($(this).is(':checked')) {
+    if (idx === -1) cur.push(username);
+  } else {
+    if (idx !== -1) cur.splice(idx, 1);
+  }
+  setDedupeUsers(cur);
+  renderPreviewRows();
+  runValidation();
+});
diff --git a/coldfront_notifications/static/coldfront_notifications/js/compose_templates.js b/coldfront_notifications/static/coldfront_notifications/js/compose_templates.js
new file mode 100644
index 0000000..fcbb648
--- /dev/null
+++ b/coldfront_notifications/static/coldfront_notifications/js/compose_templates.js
@@ -0,0 +1,108 @@
+// ── compose_templates.js ────────────────────────────────────────
+// Template list, search, loading, variable chips, and variable insert.
+//
+// Globals used: VARIABLES, VAR_BY_KEY, URLS (from Django template),
+//               HAS_VALIDATED, runValidation (from compose_validate.js),
+//               setDedupeUsers (from compose_filters.js)
+
+// Index VARIABLES by key for O(1) lookup
+var VAR_BY_KEY = {};
+VARIABLES.forEach(function(v) { VAR_BY_KEY[v.key] = v; });
+
+// ── Render chip list ─────────────────────────────────────────────
+var ACTIVE_VARS = [];
+
+function renderVars(vars, filter) {
+  var $list = $('#varsList').empty();
+  var filtered = filter
+    ? vars.filter(function(v) { return v.toLowerCase().indexOf(filter.toLowerCase()) !== -1; })
+    : vars;
+  if (!filtered.length) {
+    $list.append('<div class="vars-empty">No matches</div>');
+    return;
+  }
+  filtered.forEach(function(v) {
+    var token   = '{{' + v + '}}';
+    var def     = VAR_BY_KEY[v] || {};
+    var example = def.example || '';
+    var badge   = def.source === 'manual' ? ' [manual]' : '';
+    var $btn = $('<button type="button" class="var-btn"></button>')
+      .attr('data-var', token)
+      .attr('title', (def.description || def.label || '') + (example ? ' — ' + example : ''))
+      .html(
+        '<span style="display:block;font-family:monospace;font-size:.7rem;">' + token + badge + '</span>' +
+        '<span style="display:block;font-size:.65rem;color:#6c757d;margin-top:1px;">' + example + '</span>'
+      );
+    $list.append($btn);
+  });
+}
+
+// ── Extract tokens from subject + body ───────────────────────────
+var TOKEN_RE = /\{\{(\w+)\}\}/g;
+function extractTokens() {
+  var text = ($('#id_subject').val() || '') + '\n' + ($('#id_body').val() || '');
+  var seen = {};
+  var out = [];
+  var m;
+  while ((m = TOKEN_RE.exec(text))) {
+    if (!seen[m[1]]) { seen[m[1]] = true; out.push(m[1]); }
+  }
+  return out;
+}
+
+// ── Load template into compose fields ────────────────────────────
+// Always fetch fresh content from the server — avoids stale data when
+// an admin edits a template in another tab and returns to compose.
+function loadTemplate($el) {
+  var id   = parseInt($el.attr('data-id') || 0);
+  var slug = $el.attr('data-slug') || '';
+  $('#active-slug').text(slug);
+  $('#hidden_template_id').val(id);
+  $('#varSearch').val('');
+  $('#validationPanel').hide();
+  $('#sendBtn').prop('disabled', true);
+  $('#sendWarn').hide();
+  setDedupeUsers([]);
+  if (!id) { ACTIVE_VARS = []; renderVars([], ''); return; }
+  $.getJSON(URLS.templateJson.replace('{id}', id), function(t) {
+    $('#id_subject').val(t.subject || '');
+    $('#id_body').val(t.body || '');
+    ACTIVE_VARS = t.variables || [];
+    renderVars(ACTIVE_VARS, '');
+    if (HAS_VALIDATED) runValidation();
+  }).fail(function() {
+    ACTIVE_VARS = [];
+    renderVars([], '');
+  });
+}
+
+// ── Template click ───────────────────────────────────────────────
+$(document).on('click', '.tmpl-item', function() {
+  $('.tmpl-item').removeClass('active');
+  $(this).addClass('active');
+  loadTemplate($(this));
+});
+
+// ── Template search ─────────────────────────────────────────────
+$(document).on('input', '#tmplSearch', function() {
+  var q = $(this).val().toLowerCase();
+  $('.tmpl-item').each(function() {
+    var text = $(this).text().toLowerCase();
+    $(this).toggle(!q || text.indexOf(q) !== -1);
+  });
+});
+
+// ── Variable search ──────────────────────────────────────────────
+$(document).on('input', '#varSearch', function() {
+  renderVars(ACTIVE_VARS, $(this).val());
+});
+
+// ── Variable insert at cursor ────────────────────────────────────
+$(document).on('click', '.var-btn', function() {
+  var ta    = document.getElementById('id_body');
+  var token = $(this).attr('data-var');
+  var s = ta.selectionStart, e = ta.selectionEnd;
+  ta.value = ta.value.substring(0, s) + token + ta.value.substring(e);
+  ta.selectionStart = ta.selectionEnd = s + token.length;
+  ta.focus();
+});
diff --git a/coldfront_notifications/static/coldfront_notifications/js/compose_validate.js b/coldfront_notifications/static/coldfront_notifications/js/compose_validate.js
new file mode 100644
index 0000000..48f1947
--- /dev/null
+++ b/coldfront_notifications/static/coldfront_notifications/js/compose_validate.js
@@ -0,0 +1,194 @@
+// compose_validate.js — Validation AJAX, send-bar UI, and input invalidation.
+//
+// Globals used: URLS (from Django template),
+//               collectFilters, getDedupeUsers (from compose_filters.js)
+// Globals exported: HAS_VALIDATED, runValidation,
+//                   _setValidateButtonState, _hideTopValidationResult
+
+var HAS_VALIDATED = false;
+
+function _setValidateButtonState(state) {
+  var classMap = {
+    default: 'btn btn-outline-secondary btn-sm',
+    success: 'btn btn-outline-success btn-sm',
+    error: 'btn btn-outline-danger btn-sm'
+  };
+  var className = classMap[state] || classMap.default;
+  $('#recalcBtn').attr('class', className);
+  // Bottom validate button always stays outline-secondary
+}
+
+function _showTopValidationResult(html, isError) {
+  var alertClass = isError ? 'alert-danger' : 'alert-success';
+  $('#topValidationResult')
+    .html('<div class="alert ' + alertClass + ' py-2 mb-0" style="font-size:.82rem;">' + html + '</div>')
+    .show();
+}
+
+function _hideTopValidationResult() {
+  $('#topValidationResult').hide().empty();
+}
+
+function _buildErrorRow(error) {
+  var parts = ['<code>' + error.email + '</code>'];
+  if (error.project) {
+    parts.push('project <strong>' + $('<span>').text(error.project).html() + '</strong>');
+  }
+  if (error.allocation_label) {
+    parts.push('allocation <strong>' + $('<span>').text(error.allocation_label).html() + '</strong>');
+  }
+  parts.push('<code>{{' + error.token + '}}</code> — ' + error.reason);
+  return '<li>' + parts.join(' · ') + '</li>';
+}
+
+function _buildTopErrorMessage(errorTitle, errors) {
+  var html = '<i class="fas fa-exclamation-triangle mr-1"></i><strong>' + errorTitle + '</strong>';
+  html += '<ul style="margin:6px 0 0 20px;font-size:.78rem;max-height:200px;overflow-y:auto;">';
+  var limit = Math.min(errors.length, 20);
+  for (var i = 0; i < limit; i++) {
+    html += _buildErrorRow(errors[i]);
+  }
+  if (errors.length > 20) {
+    html += '<li>… and ' + (errors.length - 20) + ' more</li>';
+  }
+  html += '</ul>';
+  return html;
+}
+
+function runValidation() {
+  var $btn = $('#recalcBtn');
+  $btn.prop('disabled', true).html('<i class="fas fa-spinner fa-spin"></i>');
+  _setValidateButtonState('default');
+  _hideTopValidationResult();
+
+  $.ajax({
+    url: URLS.validate,
+    type: 'POST',
+    data: {
+      csrfmiddlewaretoken: $('input[name=csrfmiddlewaretoken]').val(),
+      subject: $('#id_subject').val() || '',
+      body: $('#id_body').val() || '',
+      filters: JSON.stringify(collectFilters()),
+      dedupe_users: JSON.stringify(getDedupeUsers()),
+    },
+    success: function(data) {
+      var userCount = data.user_count || 0;
+      var emailCount = data.email_count || 0;
+      $('#recipNum').text(userCount);
+      $('#recipLbl').text('users');
+      $('#emailCount').text(emailCount);
+      $('#warnCount').text(emailCount);
+      $('#sendCount').text(emailCount);
+      $('#hidden_recip_count').val(emailCount);
+
+      // Filter summary bar
+      var activeFilters = data.active_filters || [];
+      if (activeFilters.length) {
+        var chips = activeFilters.map(function(filter) {
+          var values = filter.values.map(function(value) {
+            return '<strong>' + $('<span>').text(value).html() + '</strong>';
+          }).join(', ');
+          return '<span class="fs-chip">' + $('<span>').text(filter.label).html() + ': ' + values + '</span>';
+        }).join('');
+        $('#filterSummaryBar')
+          .html('<div class="filter-summary-bar"><span class="fs-label"><i class="fas fa-filter mr-1"></i>Filters:</span>' + chips + '</div>')
+          .show();
+      } else {
+        $('#filterSummaryBar')
+          .html('<div class="filter-summary-bar"><span class="fs-label"><i class="fas fa-filter mr-1"></i>Filters:</span><span class="fs-none">No filters applied — targeting all active users</span></div>')
+          .show();
+      }
+
+      // Multi-email users
+      if (data.multi_emails && data.multi_emails.length) {
+        $('#multiCount').text(data.multi_emails.length);
+        $('#multiBadge').show();
+        var multiLines = data.multi_emails.map(function(entry) {
+          return '<li><code>' + entry.username + '</code> — ' + entry.count + ' emails</li>';
+        }).join('');
+        $('#multiList').html(multiLines);
+        $('#multiWarnText').text(
+          data.multi_emails.length + ' user(s) will receive multiple emails ' +
+          '(different project/allocation context each)'
+        );
+        $('#multiWarn').show();
+      } else {
+        $('#multiBadge').hide();
+        $('#multiWarn').hide();
+      }
+
+      $('#previewRecipBtn').prop('disabled', userCount === 0);
+      HAS_VALIDATED = true;
+
+      // Errors and missing tokens
+      $('#validationPanel').show();
+      var errors = data.errors || [];
+      var missingTokens = data.missing_tokens || [];
+
+      if (errors.length || missingTokens.length) {
+        _setValidateButtonState('error');
+
+        var titleParts = [];
+        if (missingTokens.length) titleParts.push(missingTokens.length + ' unknown token(s): ' + missingTokens.join(', '));
+        if (errors.length) titleParts.push(errors.length + ' resolution error(s)');
+        var errorTitle = titleParts.join('; ');
+
+        $('#validationBadTitle').text('Blocking — ' + errorTitle);
+        var $errorList = $('#validationErrors').empty();
+        errors.slice(0, 30).forEach(function(error) {
+          $errorList.append(_buildErrorRow(error));
+        });
+        if (errors.length > 30) {
+          $errorList.append('<li>… and ' + (errors.length - 30) + ' more</li>');
+        }
+        $('#validationBad').show();
+        $('#validationOK').hide();
+        $('#sendBtn').prop('disabled', true);
+        $('#sendWarn').hide();
+
+        _showTopValidationResult(_buildTopErrorMessage(errorTitle, errors), true);
+
+      } else {
+        _setValidateButtonState('success');
+
+        var successMessage = '<i class="fas fa-check-circle mr-1"></i>' +
+          userCount + ' users → <strong>' + emailCount + '</strong> emails. All variables resolve.';
+
+        $('#validationOK').html(successMessage).show();
+        $('#validationBad').hide();
+        $('#sendBtn').prop('disabled', emailCount === 0);
+        if (emailCount > 0) $('#sendWarn').show();
+
+        _showTopValidationResult(successMessage, false);
+      }
+    },
+    error: function() {
+      $('#recipNum').text('—');
+      $('#recipLbl').text('Error — try again');
+      _setValidateButtonState('error');
+      _showTopValidationResult(
+        '<i class="fas fa-exclamation-triangle mr-1"></i>Validation request failed. Please try again.',
+        true
+      );
+    },
+    complete: function() {
+      // Restore button text but keep the colored class
+      $btn.prop('disabled', false).html('<i class="fas fa-check-double mr-1"></i>Validate');
+    }
+  });
+}
+
+$(document).on('click', '#recalcBtn, #recalcBtn2', function() { runValidation(); });
+
+$(document).on('click', '#multiShowBtn', function() {
+  $('#multiList').toggle();
+});
+
+// Body/subject input changes invalidate previous validation.
+$(document).on('input', '#id_body, #id_subject', function() {
+  $('#validationPanel').hide();
+  $('#sendBtn').prop('disabled', true);
+  $('#sendWarn').hide();
+  _setValidateButtonState('default');
+  _hideTopValidationResult();
+});
diff --git a/coldfront_notifications/tasks.py b/coldfront_notifications/tasks.py
deleted file mode 100644
index 8888183..0000000
--- a/coldfront_notifications/tasks.py
+++ /dev/null
@@ -1,276 +0,0 @@
-"""
-Celery tasks for async email dispatch.
-
-Sends one email per (user, project, allocation) tuple (scope permitting).
-Hard-fails the campaign if any token cannot be resolved for any recipient.
-
-Batch handling:
-  - Reuses a single SMTP connection across all emails
-  - Sends in batches with a configurable delay between them
-  - Retries transient SMTP errors (4xx) with exponential backoff
-
-Settings (in Django settings / local_settings.py):
-  NOTIFICATION_BATCH_SIZE   = 50     # emails per batch
-  NOTIFICATION_BATCH_DELAY  = 2.0    # seconds between batches
-  NOTIFICATION_MAX_RETRIES  = 3      # retries per email on transient failure
-  NOTIFICATION_RETRY_DELAY  = 1.0    # initial retry delay (doubles each retry)
-"""
-import logging
-import re
-import time
-import smtplib
-
-from django.core.mail import EmailMessage, get_connection
-from django.utils import timezone
-
-from .conf import BATCH_SIZE, BATCH_DELAY, MAX_RETRIES, RETRY_DELAY
-
-logger = logging.getLogger(__name__)
-
-try:
-    from celery import shared_task
-except ImportError:
-    def shared_task(fn):
-        return fn
-
-
-TOKEN_RE = re.compile(r"\{\{(\w+)\}\}")
-
-
-def _render(template_str: str, values: dict) -> str:
-    def repl(m):
-        k = m.group(1)
-        return values[k] if k in values else m.group(0)
-    return TOKEN_RE.sub(repl, template_str or "")
-
-
-def _build_values(tokens, vars_by_key, ctx):
-    from .models import NotificationVariable
-    from .resolvers import MissingValue, resolve
-
-    out = {}
-    for t in tokens:
-        v = vars_by_key.get(t)
-        if v is None:
-            raise MissingValue(f"unknown token {t!r}")
-        if v.source == NotificationVariable.SOURCE_MANUAL:
-            val = (v.value or "").strip()
-            if not val and v.is_required:
-                raise MissingValue(f"manual variable {t!r} has no stored value")
-            out[t] = v.value or ""
-        else:
-            try:
-                out[t] = resolve(v.resolver_key, ctx)
-            except MissingValue:
-                raise MissingValue(
-                    f"cannot resolve {v.resolver_key} for {ctx['user'].email}"
-                )
-    return out
-
-
-def _is_transient(exc):
-    """Return True if the SMTP error is transient (4xx) and worth retrying."""
-    if isinstance(exc, smtplib.SMTPResponseException):
-        return 400 <= exc.smtp_code < 500
-    if isinstance(exc, smtplib.SMTPServerDisconnected):
-        return True
-    if isinstance(exc, ConnectionError):
-        return True
-    return False
-
-
-def _send_with_retry(msg, connection, max_retries=MAX_RETRIES, base_delay=RETRY_DELAY):
-    """
-    Send an EmailMessage with retry on transient SMTP errors.
-    Re-opens the connection on disconnect.
-    Returns None on success or the exception on permanent failure.
-    """
-    last_exc = None
-    for attempt in range(max_retries + 1):
-        try:
-            msg.connection = connection
-            msg.send()
-            return None
-        except Exception as exc:
-            last_exc = exc
-            if not _is_transient(exc) or attempt == max_retries:
-                return exc
-            delay = base_delay * (2 ** attempt)
-            logger.warning(
-                "Transient SMTP error (attempt %d/%d), retrying in %.1fs: %s",
-                attempt + 1, max_retries + 1, delay, exc,
-            )
-            time.sleep(delay)
-            # Re-open connection if it was dropped
-            try:
-                connection.close()
-            except Exception:
-                pass
-            try:
-                connection.open()
-            except Exception as reopen_exc:
-                logger.error("Failed to re-open SMTP connection: %s", reopen_exc)
-                return reopen_exc
-    return last_exc
-
-
-@shared_task
-def send_notification_campaign(campaign_pk: int):
-    from .models import NotificationCampaign, NotificationLog, NotificationVariable
-    from .resolvers import MissingValue
-    from .utils import enumerate_recipients_deduped
-    from .validators import _extract_tokens, _required_scope
-
-    try:
-        campaign = NotificationCampaign.objects.get(pk=campaign_pk)
-    except NotificationCampaign.DoesNotExist:
-        logger.error("Campaign %s not found", campaign_pk)
-        return
-
-    campaign.status  = NotificationCampaign.STATUS_SENDING
-    campaign.sent_at = timezone.now()
-    campaign.save(update_fields=["status", "sent_at"])
-
-    campaign.logs.all().delete()
-
-    tokens = _extract_tokens(campaign.subject, campaign.body)
-    vars_by_key = {v.key: v for v in NotificationVariable.objects.filter(key__in=tokens)}
-
-    unknown = [t for t in tokens if t not in vars_by_key]
-    if unknown:
-        _fail_campaign(campaign, f"Unknown tokens: {', '.join(unknown)}")
-        return
-
-    scope = _required_scope(list(vars_by_key.values()))
-    snapshot = campaign.filters_snapshot or {}
-    dedupe_users = snapshot.get("dedupe_users") or []
-
-    # --- Phase 1: resolve all variables (streaming, no full list in memory) ---
-    # We resolve per-tuple and yield. Hard-fail on first resolution error.
-    tuples = enumerate_recipients_deduped(snapshot, scope, dedupe_users)
-    bcc_pool = list(set(
-        a.strip() for a in snapshot.get("extra_recipients", []) if a.strip()
-    ))
-
-    # Pre-check: collect resolved emails into a generator that hard-fails.
-    # We need to know the total count upfront for progress, so we do a
-    # two-pass approach: resolve all first, then send in batches.
-    resolved = []
-    for user, project, allocation in tuples:
-        ctx = {"user": user, "project": project, "allocation": allocation}
-        try:
-            values = _build_values(tokens, vars_by_key, ctx)
-        except MissingValue as exc:
-            _fail_campaign(campaign, f"Resolution error: {exc}")
-            return
-        resolved.append((
-            user, project, allocation,
-            _render(campaign.subject, values),
-            _render(campaign.body, values),
-        ))
-
-    if not resolved:
-        _fail_campaign(campaign, "No recipients matched the filters.")
-        return
-
-    total = len(resolved)
-    campaign.recipient_count = total
-    campaign.save(update_fields=["recipient_count"])
-
-    logger.info(
-        "Campaign %s: %d emails to send (batch_size=%d, delay=%.1fs)",
-        campaign_pk, total, BATCH_SIZE, BATCH_DELAY,
-    )
-
-    # --- Phase 2: send in batches over a single SMTP connection ---
-    delivered = 0
-    failed    = 0
-
-    connection = get_connection()
-    try:
-        connection.open()
-    except Exception as exc:
-        _fail_campaign(campaign, f"Cannot open SMTP connection: {exc}")
-        return
-
-    try:
-        for i, (user, project, allocation, subj, body) in enumerate(resolved):
-            log = NotificationLog.objects.create(
-                campaign=campaign,
-                email=user.email,
-                status=NotificationLog.STATUS_QUEUED,
-                rendered_subject=subj,
-                rendered_body=body,
-                project_id=project.pk if project else None,
-                allocation_id=allocation.pk if allocation else None,
-            )
-
-            msg = EmailMessage(
-                subject=subj,
-                body=body,
-                from_email=campaign.sender,
-                to=[user.email],
-                bcc=bcc_pool or [],
-                reply_to=[campaign.reply_to] if campaign.reply_to else [],
-            )
-
-            exc = _send_with_retry(msg, connection)
-            if exc is None:
-                log.status = NotificationLog.STATUS_DELIVERED
-                log.save(update_fields=["status"])
-                delivered += 1
-            else:
-                log.status = NotificationLog.STATUS_FAILED
-                log.notes  = str(exc)
-                log.save(update_fields=["status", "notes"])
-                failed += 1
-                logger.error(
-                    "Send failed for campaign %s recipient %s: %s",
-                    campaign_pk, user.email, exc,
-                )
-
-            # Batch boundary: flush counts to DB so the detail page
-            # shows live progress, then pause to avoid SMTP rate limits.
-            seq = i + 1
-            if seq % BATCH_SIZE == 0:
-                campaign.delivered_count = delivered
-                campaign.failed_count    = failed
-                campaign.save(update_fields=["delivered_count", "failed_count"])
-                if seq < total:
-                    logger.info(
-                        "Campaign %s: batch %d done (%d/%d), sleeping %.1fs",
-                        campaign_pk, seq // BATCH_SIZE, seq, total, BATCH_DELAY,
-                    )
-                    time.sleep(BATCH_DELAY)
-
-    finally:
-        try:
-            connection.close()
-        except Exception:
-            pass
-
-    campaign.delivered_count = delivered
-    campaign.failed_count    = failed
-    campaign.recipient_count = delivered + failed
-    campaign.status = (
-        NotificationCampaign.STATUS_SENT if failed == 0
-        else NotificationCampaign.STATUS_PARTIAL if delivered > 0
-        else NotificationCampaign.STATUS_FAILED
-    )
-    campaign.completed_at = timezone.now()
-    campaign.save(update_fields=[
-        "delivered_count", "failed_count", "recipient_count",
-        "status", "completed_at",
-    ])
-    logger.info(
-        "Campaign %s complete: %d delivered, %d failed (of %d total)",
-        campaign_pk, delivered, failed, total,
-    )
-
-
-def _fail_campaign(campaign, reason: str):
-    from .models import NotificationCampaign
-    campaign.status = NotificationCampaign.STATUS_FAILED
-    campaign.completed_at = timezone.now()
-    campaign.save(update_fields=["status", "completed_at"])
-    logger.error("Campaign %s FAILED: %s", campaign.pk, reason)
diff --git a/coldfront_notifications/template_variable_value_resolver.py b/coldfront_notifications/template_variable_value_resolver.py
new file mode 100644
index 0000000..027033e
--- /dev/null
+++ b/coldfront_notifications/template_variable_value_resolver.py
@@ -0,0 +1,327 @@
+"""
+Query resolvers for NotificationVariable(source='query').
+
+Each resolver group is a class that registers its resolver keys, labels,
+scope, and resolve methods. The ResolverRegistry collects all groups and
+provides the public API: resolve(), choices, scopes, and key validation.
+
+Context dict passed to each resolver:
+    {"user": IfxUser, "project": Project|None, "allocation": Allocation|None}
+"""
+from coldfront.core.project.models import ProjectUser
+from ifxuser.models import Organization
+
+
+class MissingValue(Exception):
+    """Raised when a resolver cannot produce a non-empty value."""
+
+
+class ResolverContext:
+    """Wraps the raw context dict with typed accessors that raise MissingValue."""
+
+    def __init__(self, context: dict):
+        self._context = context
+
+    @property
+    def user(self):
+        user = self._context.get("user")
+        if user is None:
+            raise MissingValue("user is required")
+        return user
+
+    @property
+    def project(self):
+        project = self._context.get("project")
+        if project is None:
+            raise MissingValue("project is required")
+        return project
+
+    @property
+    def allocation(self):
+        allocation = self._context.get("allocation")
+        if allocation is None:
+            raise MissingValue("allocation is required")
+        return allocation
+
+    @property
+    def primary_resource(self):
+        resource = self.allocation.get_parent_resource
+        if resource is None:
+            raise MissingValue("allocation has no parent resource")
+        return resource
+
+
+def format_value(value):
+    """Convert a value to a non-empty stripped string, or raise MissingValue."""
+    if value is None:
+        raise MissingValue()
+    formatted = str(value).strip()
+    if not formatted:
+        raise MissingValue()
+    return formatted
+
+
+class BaseResolverGroup:
+    """Each subclass defines resolvers for a scope (user, project, allocation).
+
+    Subclasses populate ``resolvers`` — a list of (key, label, method_name)
+    tuples — and implement the corresponding methods.
+    """
+    scope = None
+    group_label = None
+    resolvers = []
+
+    def get_registry_entries(self):
+        """Return list of (key, label, group, scope, callable) tuples."""
+        entries = []
+        for key, label, method_name in self.resolvers:
+            method = getattr(self, method_name)
+            entries.append((key, label, self.group_label, self.scope, method))
+        return entries
+
+
+class UserResolverGroup(BaseResolverGroup):
+    scope = "user"
+    group_label = "Recipient"
+    resolvers = [
+        ("user.username", "User · Username", "resolve_username"),
+        ("user.email", "User · Email", "resolve_email"),
+        ("user.full_name", "User · Full Name", "resolve_full_name"),
+        ("user.first_name", "User · First Name", "resolve_first_name"),
+        ("user.last_name", "User · Last Name", "resolve_last_name"),
+    ]
+
+    def resolve_username(self, context):
+        return format_value(context.user.username)
+
+    def resolve_email(self, context):
+        return format_value(context.user.email)
+
+    def resolve_full_name(self, context):
+        full_name = context.user.get_full_name()
+        return format_value(full_name or context.user.username)
+
+    def resolve_first_name(self, context):
+        return format_value(context.user.first_name)
+
+    def resolve_last_name(self, context):
+        return format_value(context.user.last_name)
+
+
+class ProjectResolverGroup(BaseResolverGroup):
+    scope = "project"
+    group_label = "Project"
+    resolvers = [
+        ("project.title", "Project · Title", "resolve_title"),
+        ("project.status.name", "Project · Status", "resolve_status"),
+        ("project.field_of_science.description", "Project · Field of Science", "resolve_field_of_science"),
+        ("project.parent_project.title", "Project · Parent Title", "resolve_parent_title"),
+        ("project.user_count", "Users · Quantity", "resolve_user_count"),
+        ("project.usernames", "Users · Usernames", "resolve_usernames"),
+    ]
+
+    def resolve_title(self, context):
+        return format_value(context.project.title)
+
+    def resolve_status(self, context):
+        return format_value(context.project.status.name)
+
+    def resolve_field_of_science(self, context):
+        project = context.project
+        if not project.field_of_science_id:
+            raise MissingValue("project has no field of science")
+        return format_value(project.field_of_science.description)
+
+    def resolve_parent_title(self, context):
+        project = context.project
+        if not project.parent_project_id:
+            raise MissingValue("project has no parent project")
+        return format_value(project.parent_project.title)
+
+    def resolve_user_count(self, context):
+        active_users = context.project.projectuser_set.filter(status__name="Active")
+        return format_value(active_users.count())
+
+    def resolve_usernames(self, context):
+        usernames = list(
+            context.project.projectuser_set
+            .filter(status__name="Active")
+            .order_by("user__username")
+            .values_list("user__username", flat=True)
+        )
+        return format_value(", ".join(usernames) or None)
+
+
+class PIResolverGroup(BaseResolverGroup):
+    scope = "project"
+    group_label = "PI"
+    resolvers = [
+        ("project.pi.full_name", "PI · Full Name", "resolve_pi_full_name"),
+        ("project.pi.email", "PI · Email", "resolve_pi_email"),
+        ("project.pi.username", "PI · Username", "resolve_pi_username"),
+    ]
+
+    def _get_pi(self, context):
+        project = context.project
+        if not project.pi_id:
+            raise MissingValue("project has no PI")
+        return project.pi
+
+    def resolve_pi_full_name(self, context):
+        pi = self._get_pi(context)
+        return format_value(pi.get_full_name() or pi.username)
+
+    def resolve_pi_email(self, context):
+        return format_value(self._get_pi(context).email)
+
+    def resolve_pi_username(self, context):
+        return format_value(self._get_pi(context).username)
+
+
+class DepartmentResolverGroup(BaseResolverGroup):
+    scope = "project"
+    group_label = "Department"
+    resolvers = [
+        ("project.department.name", "Department · Name", "resolve_department_name"),
+    ]
+
+    def resolve_department_name(self, context):
+        department_name = Organization.objects.filter(
+            projectorganization__project=context.project,
+            rank="department",
+        ).values_list("name", flat=True).first()
+        return format_value(department_name)
+
+
+class RoleResolverGroup(BaseResolverGroup):
+    scope = "project"
+    group_label = "Role"
+    resolvers = [
+        ("projectuser.role.name", "Role · Name", "resolve_role_name"),
+    ]
+
+    def resolve_role_name(self, context):
+        project_user = (
+            ProjectUser.objects
+            .filter(
+                user=context.user,
+                project=context.project,
+                status__name="Active",
+            )
+            .select_related("role")
+            .first()
+        )
+        if not project_user or not project_user.role:
+            raise MissingValue("user has no active role on this project")
+        return format_value(project_user.role.name)
+
+
+class AllocationResolverGroup(BaseResolverGroup):
+    scope = "allocation"
+    group_label = "Allocation"
+    resolvers = [
+        ("allocation.quantity", "Allocation · Quantity", "resolve_quantity"),
+        ("allocation.start_date", "Allocation · Start Date", "resolve_start_date"),
+        ("allocation.end_date", "Allocation · End Date", "resolve_end_date"),
+        ("allocation.status.name", "Allocation · Status", "resolve_status"),
+        ("allocation.path", "Allocation · Path", "resolve_path"),
+        ("allocation.quota", "Allocation · Quota (TB)", "resolve_quota"),
+        ("allocation.usage", "Allocation · Usage", "resolve_usage"),
+    ]
+
+    def resolve_quantity(self, context):
+        return format_value(context.allocation.quantity)
+
+    def resolve_start_date(self, context):
+        return format_value(context.allocation.start_date)
+
+    def resolve_end_date(self, context):
+        return format_value(context.allocation.end_date)
+
+    def resolve_status(self, context):
+        return format_value(context.allocation.status.name)
+
+    def resolve_path(self, context):
+        return format_value(context.allocation.path or None)
+
+    def resolve_quota(self, context):
+        return format_value(context.allocation.get_attribute("Storage Quota (TB)"))
+
+    def resolve_usage(self, context):
+        return format_value(context.allocation.usage)
+
+
+class ResourceResolverGroup(BaseResolverGroup):
+    scope = "allocation"
+    group_label = "Resource"
+    resolvers = [
+        ("resource.name", "Resource · Name (primary)", "resolve_name"),
+        ("resource.resource_type.name", "Resource · Type", "resolve_type"),
+        ("resource.parent_resource.name", "Resource · Parent Name", "resolve_parent_name"),
+        ("resource.names_joined", "Resource · All Names", "resolve_names_joined"),
+    ]
+
+    def resolve_name(self, context):
+        return format_value(context.primary_resource.name)
+
+    def resolve_type(self, context):
+        resource = context.primary_resource
+        if not resource.resource_type_id:
+            raise MissingValue("resource has no type")
+        return format_value(resource.resource_type.name)
+
+    def resolve_parent_name(self, context):
+        resource = context.primary_resource
+        if not resource.parent_resource_id:
+            raise MissingValue("resource has no parent resource")
+        return format_value(resource.parent_resource.name)
+
+    def resolve_names_joined(self, context):
+        resource_names = ", ".join(
+            resource.name for resource in context.allocation.resources.all()
+        )
+        return format_value(resource_names or None)
+
+
+class ResolverRegistry:
+    """Collects all resolver groups and provides the public lookup API.
+
+    Builds three structures from the registered groups:
+    - resolvers: key → callable
+    - choices: [(key, label, group)] for admin dropdowns
+    - scopes: key → "user" | "project" | "allocation"
+    """
+
+    def __init__(self, groups):
+        self.resolvers = {}
+        self.choices = []
+        self.scopes = {}
+
+        for group in groups:
+            for key, label, group_label, scope, resolver_callable in group.get_registry_entries():
+                self.resolvers[key] = resolver_callable
+                self.choices.append((key, label, group_label))
+                self.scopes[key] = scope
+
+    def resolve(self, resolver_key: str, context: dict) -> str:
+        """Dispatch a resolver_key against a context dict. Raises MissingValue on failure."""
+        resolver_callable = self.resolvers.get(resolver_key)
+        if resolver_callable is None:
+            raise MissingValue(f"unknown resolver key: {resolver_key!r}")
+        try:
+            return resolver_callable(ResolverContext(context))
+        except MissingValue:
+            raise
+        except Exception:
+            raise MissingValue(f"failed to resolve {resolver_key!r}")
+
+
+registry = ResolverRegistry([
+    UserResolverGroup(),
+    ProjectResolverGroup(),
+    PIResolverGroup(),
+    DepartmentResolverGroup(),
+    RoleResolverGroup(),
+    AllocationResolverGroup(),
+    ResourceResolverGroup(),
+])
diff --git a/coldfront_notifications/templates/campaign_detail.html b/coldfront_notifications/templates/coldfront_notifications/campaign_detail.html
similarity index 95%
rename from coldfront_notifications/templates/campaign_detail.html
rename to coldfront_notifications/templates/coldfront_notifications/campaign_detail.html
index ebafcf1..4fb5252 100644
--- a/coldfront_notifications/templates/campaign_detail.html
+++ b/coldfront_notifications/templates/coldfront_notifications/campaign_detail.html
@@ -7,6 +7,14 @@
     <div class="d-flex justify-content-between align-items-center">
       <h2>Notification #{{ campaign.pk }}</h2>
       <div>
+        {% if campaign.status == 'draft' %}
+        <a href="{% url 'notifications:compose' %}?draft={{ campaign.pk }}" class="btn btn-primary btn-sm">
+          <i class="fas fa-edit mr-1"></i>Edit Draft
+        </a>
+        <a href="{% url 'notifications:draft-delete' campaign.pk %}" class="btn btn-outline-danger btn-sm ml-1">
+          <i class="fas fa-trash mr-1"></i>Delete
+        </a>
+        {% else %}
         <a href="{% url 'notifications:resend-compose' campaign.pk %}" class="btn btn-outline-primary btn-sm">
           <i class="fas fa-clone mr-1"></i>Resend
         </a>
@@ -19,6 +27,7 @@ <h2>Notification #{{ campaign.pk }}</h2>
           </button>
         </form>
         {% endif %}
+        {% endif %}
       </div>
     </div>
     <hr>
diff --git a/coldfront_notifications/templates/campaign_list.html b/coldfront_notifications/templates/coldfront_notifications/campaign_list.html
similarity index 83%
rename from coldfront_notifications/templates/campaign_list.html
rename to coldfront_notifications/templates/coldfront_notifications/campaign_list.html
index f2ec898..7ec4ee4 100644
--- a/coldfront_notifications/templates/campaign_list.html
+++ b/coldfront_notifications/templates/coldfront_notifications/campaign_list.html
@@ -22,6 +22,7 @@ <h3 class="h5 mb-0">All Notifications</h3>
         <a href="?status=sent" class="btn {% if status_filter == 'sent' %}btn-primary{% else %}btn-outline-secondary{% endif %}">Sent</a>
         <a href="?status=partial" class="btn {% if status_filter == 'partial' %}btn-primary{% else %}btn-outline-secondary{% endif %}">Partial</a>
         <a href="?status=failed" class="btn {% if status_filter == 'failed' %}btn-primary{% else %}btn-outline-secondary{% endif %}">Failed</a>
+        <a href="?status=draft" class="btn {% if status_filter == 'draft' %}btn-primary{% else %}btn-outline-secondary{% endif %}">Draft</a>
       </div>
     </div>
   </div>
@@ -31,14 +32,14 @@ <h3 class="h5 mb-0">All Notifications</h3>
         <tr>
           <th>#</th><th>Subject</th><th>Template</th>
           <th class="text-right">Recipients</th><th class="text-right">Delivered</th>
-          <th class="text-right">Failed</th><th>Sent At</th><th>Status</th>
+          <th class="text-right">Failed</th><th>Sent At</th><th>Status</th><th></th>
         </tr>
       </thead>
       <tbody>
         {% for c in campaigns %}
         <tr>
           <td class="text-muted" style="font-family:monospace;">{{ c.pk|stringformat:"03d" }}</td>
-          <td><a href="{% url 'notifications:campaign-detail' c.pk %}">{{ c.subject }}</a></td>
+          <td><a href="{% url 'notifications:campaign-detail' c.pk %}">{{ c.display_subject }}</a></td>
           <td><span class="badge badge-secondary" style="font-family:monospace;font-size:.7rem;">{{ c.template.slug|default:"—" }}</span></td>
           <td class="text-right" style="font-family:monospace;">{{ c.recipient_count }}</td>
           <td class="text-right text-success" style="font-family:monospace;">{{ c.delivered_count }}</td>
@@ -52,9 +53,15 @@ <h3 class="h5 mb-0">All Notifications</h3>
             {% elif c.status == 'draft' %}<span class="badge badge-secondary">Draft</span>
             {% else %}<span class="badge badge-secondary">{{ c.status }}</span>{% endif %}
           </td>
+          <td class="text-right" style="white-space:nowrap;">
+            {% if c.status == 'draft' %}
+            <a href="{% url 'notifications:compose' %}?draft={{ c.pk }}" class="btn btn-link btn-sm p-0 mr-2" title="Edit"><i class="fas fa-edit"></i></a>
+            <a href="{% url 'notifications:draft-delete' c.pk %}" class="btn btn-link btn-sm text-danger p-0" title="Delete"><i class="fas fa-trash"></i></a>
+            {% endif %}
+          </td>
         </tr>
         {% empty %}
-        <tr><td colspan="8" class="text-center text-muted py-4">No notifications yet. <a href="{% url 'notifications:compose' %}">Send one →</a></td></tr>
+        <tr><td colspan="9" class="text-center text-muted py-4">No notifications yet. <a href="{% url 'notifications:compose' %}">Send one →</a></td></tr>
         {% endfor %}
       </tbody>
     </table>
diff --git a/coldfront_notifications/templates/compose.html b/coldfront_notifications/templates/coldfront_notifications/compose.html
similarity index 77%
rename from coldfront_notifications/templates/compose.html
rename to coldfront_notifications/templates/coldfront_notifications/compose.html
index 2ff81d2..033c091 100644
--- a/coldfront_notifications/templates/compose.html
+++ b/coldfront_notifications/templates/coldfront_notifications/compose.html
@@ -23,110 +23,57 @@ <h3 class="h5 mb-0">
         </a>
         <i class="fas fa-users mr-1"></i> Recipients
       </h3>
-      <span class="bcc-badge"><i class="fas fa-eye-slash"></i> All recipients will be BCC'd</span>
     </div>
   </div>
   <div class="collapse show" id="recipients-body">
     <div class="card-body">
-      <!-- Row 1: filters -->
+      <!-- Row 1: filters (ordered by tier: T1 → T2 → T3) -->
       <div class="recip-filters">
         <div>
-          <label class="flbl">Project</label>
-          <select class="s2" id="f_project" multiple data-placeholder="Any project">
-            {% for p in projects %}
-            <option value="{{ p.pk }}">{{ p.title }}</option>
-            {% empty %}
-            <option value="1">astro-gpu-2025</option>
-            <option value="2">climate-hpc-q2</option>
-            <option value="3">bio-seq-pipeline</option>
-            <option value="4">ml-training-lab</option>
-            <option value="5">chem-sim-2024</option>
-            <option value="6">physics-lhc-data</option>
-            <option value="7">neuro-imaging-lab</option>
-            <option value="8">genomics-hpc-2025</option>
-            <option value="9">astrophysics-cannon</option>
-            <option value="10">data-science-fellows</option>
-            {% endfor %}
-          </select>
+          <label class="flbl">Department</label>
+          <select class="s2" id="f_dept" multiple data-placeholder="Any department"></select>
         </div>
 
         <div>
-          <label class="flbl">Allocation</label>
-          <select class="s2" id="f_allocation" multiple data-placeholder="Any allocation">
-            {% for a in allocations %}
-            <option value="{{ a.pk }}">{{ a.project.title }} — {{ a.get_parent_resource }}</option>
-            {% empty %}
-            <option value="101">AL-00101 — Cannon Cluster</option>
-            <option value="102">AL-00102 — Cannon Cluster</option>
-            <option value="103">AL-00103 — FASSE</option>
-            <option value="104">AL-00104 — Holyoke GPU</option>
-            <option value="105">AL-00105 — Cannon Cluster</option>
-            <option value="106">AL-00106 — OpenMind</option>
-            <option value="107">AL-00107 — FASSE</option>
-            <option value="108">AL-00108 — Holyoke GPU</option>
-            <option value="109">AL-00109 — Cannon Cluster</option>
-            <option value="110">AL-00110 — OpenMind</option>
-            {% endfor %}
-          </select>
+          <label class="flbl">Project</label>
+          <select class="s2" id="f_project" multiple data-placeholder="Any project"></select>
         </div>
 
         <div>
-          <label class="flbl">Department</label>
-          <select class="s2" id="f_dept" multiple data-placeholder="Any department">
-            {% for d in departments %}
-            <option value="{{ d }}">{{ d }}</option>
-            {% endfor %}
-          </select>
+          <label class="flbl">Resource</label>
+          <select class="s2" id="f_resource" multiple data-placeholder="Any resource"></select>
         </div>
 
         <div>
-          <label class="flbl">Resource</label>
-          <select class="s2" id="f_resource" multiple data-placeholder="Any resource">
-            {% for r in resources %}
-            <option value="{{ r.pk }}">{{ r.name }}</option>
-            {% empty %}
-            <option value="1">Cannon Cluster</option>
-            <option value="2">FASSE</option>
-            <option value="3">Holyoke GPU</option>
-            <option value="4">OpenMind</option>
-            <option value="5">Odyssey (Legacy)</option>
-            {% endfor %}
-          </select>
+          <label class="flbl">Allocation Status</label>
+          <select class="s2" id="f_status" multiple data-placeholder="Any status"></select>
         </div>
 
         <div>
-          <label class="flbl">Allocation Status</label>
-          <select class="s2" id="f_status" multiple data-placeholder="Any status">
-            {% for s in statuses %}
-            <option value="{{ s }}">{{ s }}</option>
-            {% empty %}
-            <option value="Active">Active</option>
-            <option value="Expiring Soon">Expiring Soon</option>
-            <option value="Expired">Expired</option>
-            <option value="New">New</option>
-            <option value="Pending">Pending</option>
-            <option value="Denied">Denied</option>
-            <option value="Archived">Archived</option>
-            {% endfor %}
-          </select>
+          <label class="flbl">Allocation</label>
+          <select class="s2" id="f_allocation" multiple data-placeholder="Any allocation"></select>
         </div>
 
         <div>
           <label class="flbl">User Role</label>
-          <select class="s2" id="f_role" multiple data-placeholder="Any role">
-            {% for r in roles %}
-            <option value="{{ r }}">{{ r }}</option>
-            {% empty %}
-            <option value="PI">PI</option>
-            <option value="Manager">Manager</option>
-            <option value="User">User</option>
-            {% endfor %}
-          </select>
+          <select class="s2" id="f_role" multiple data-placeholder="Any role"></select>
         </div>
       </div>
 
-      <!-- Row 2: count + actions -->
+      <!-- Row 2: actions + count pill -->
       <div class="recip-actions">
+        <div class="recip-actions-left">
+          <button type="button" class="btn btn-outline-secondary btn-sm" id="recalcBtn">
+            <i class="fas fa-check-double mr-1"></i>Validate
+          </button>
+          <button type="button" class="btn btn-outline-secondary btn-sm"
+                  id="previewRecipBtn" disabled>
+            <i class="fas fa-eye mr-1"></i>Recipient Preview
+          </button>
+          <button type="button" class="btn btn-outline-danger btn-sm" id="clearFiltersBtn" style="display:none;">
+            <i class="fas fa-times mr-1"></i>Clear Filters
+          </button>
+        </div>
         <div class="recip-count-pill">
           <div class="recip-count-num" id="recipNum">—</div>
           <div class="recip-count-lbl" id="recipLbl">recipients</div>
@@ -134,14 +81,13 @@ <h3 class="h5 mb-0">
             <span id="emailCount">—</span> emails<span id="multiBadge" style="display:none;"> · <span id="multiCount">0</span> multi</span>
           </div>
         </div>
-        <button type="button" class="btn btn-outline-secondary btn-sm" id="recalcBtn">
-          <i class="fas fa-check-double mr-1"></i>Validate
-        </button>
-        <button type="button" class="btn btn-outline-secondary btn-sm"
-                id="previewRecipBtn" disabled>
-          <i class="fas fa-eye mr-1"></i>Recipient Preview
-        </button>
       </div>
+
+      <!-- Row 3: filter breakdown details -->
+      <div class="recip-details" id="filterDetails"></div>
+
+      <!-- Row 4: validation result (mirrors the bottom panel) -->
+      <div id="topValidationResult" style="display:none; margin-top:10px;"></div>
     </div>
   </div>
 </div>
@@ -168,7 +114,7 @@ <h3 class="h5 mb-0">
       </div>
       <div class="tmpl-list">
         {% for t in templates %}
-        <div class="tmpl-item {% if forloop.first %}active{% endif %}"
+        <div class="tmpl-item"
              data-id="{{ t.pk }}"
              data-slug="{{ t.slug }}">
           <div class="tmpl-name">{{ t.name }}</div>
@@ -194,6 +140,7 @@ <h3 class="h5 mb-0">
     <form method="post" id="notifForm">
       {% csrf_token %}
       <input type="hidden" name="template_id" id="hidden_template_id">
+      <input type="hidden" name="draft_pk" id="hidden_draft_pk" value="">
       <input type="hidden" name="recipient_count" id="hidden_recip_count" value="0">
       <input type="hidden" name="filter_projects" id="h_projects">
       <input type="hidden" name="filter_allocations" id="h_allocations">
@@ -290,6 +237,7 @@ <h3 class="h5 mb-0">
 
           <!-- Validation results / errors -->
           <div id="validationPanel" style="display:none; margin-bottom:12px;">
+            <div id="filterSummaryBar" style="display:none;margin-bottom:8px;font-size:.8rem;"></div>
             <div id="validationOK" class="alert alert-success py-2" style="display:none;font-size:.84rem;"></div>
             <div id="validationBad" class="alert alert-danger py-2"  style="display:none;font-size:.84rem;">
               <strong id="validationBadTitle"></strong>
@@ -306,19 +254,25 @@ <h3 class="h5 mb-0">
           <div class="send-warn" id="sendWarn" style="display:none;">
             <i class="fas fa-exclamation-triangle"></i>
             <div>
-              <strong>You are about to send <span id="warnCount">0</span> emails via BCC.</strong><br>
+              <strong>You are about to send <span id="warnCount">0</span> emails.</strong><br>
               <span class="text-muted" style="font-size:.79rem;">This action cannot be undone.</span>
             </div>
           </div>
-          <div class="d-flex justify-content-end align-items-center" style="gap:8px;">
-            <button type="button" class="btn btn-outline-secondary" id="recalcBtn2">
-              <i class="fas fa-check-double mr-1"></i>Validate
-            </button>
-            <button type="submit" class="btn btn-primary" id="sendBtn"
-                    name="action" value="send" disabled>
-              <i class="fas fa-paper-plane mr-1"></i>
-              Send <span id="sendCount">—</span> Emails
-            </button>
+          <div class="d-flex justify-content-between align-items-center">
+            <span id="draftStatus" style="font-size:.75rem;color:#6c757d;"></span>
+            <div class="d-flex align-items-center" style="gap:8px;">
+              <button type="button" class="btn btn-outline-secondary" id="recalcBtn2">
+                <i class="fas fa-check-double mr-1"></i>Validate
+              </button>
+              <button type="button" class="btn btn-outline-info" id="saveDraftBtn">
+                <i class="fas fa-save mr-1"></i>Save Draft
+              </button>
+              <button type="submit" class="btn btn-primary" id="sendBtn"
+                      name="action" value="send" disabled>
+                <i class="fas fa-paper-plane mr-1"></i>
+                Send <span id="sendCount">—</span> Emails
+              </button>
+            </div>
           </div>
         </div>
       </div>
@@ -447,6 +401,7 @@ <h5 class="modal-title"><i class="fas fa-users mr-2"></i>Recipient Preview</h5>
   </div>
 </div>
 
+
 {% endblock %}
 
 {% block javascript %}
@@ -454,13 +409,20 @@ <h5 class="modal-title"><i class="fas fa-users mr-2"></i>Recipient Preview</h5>
 // Server-rendered data (needs Django context)
 var TEMPLATES = {{ templates_json|safe }};
 var VARIABLES = {{ variables_json|safe }};
-// Django URL endpoints for AJAX calls
+var FILTER_DATA = {{ filter_data_json|safe }};
+var DRAFT_DATA = {{ draft_json|safe }};
 var URLS = {
-  previewRender:  '{% url "notifications:preview-render" %}',
-  filterOptions:  '{% url "notifications:filter-options" %}',
-  validate:       '{% url "notifications:validate" %}',
-  recipientCount: '{% url "notifications:recipient-count" %}'
+  previewRender:  '{% url "notifications:api-preview-render" %}',
+  validate:       '{% url "notifications:api-validate" %}',
+  recipientCount: '{% url "notifications:api-recipient-count" %}',
+  templateJson:   '{% url "notifications:template-json" pk=0 %}'.replace('/0/', '/{id}/'),
+  draftSave:      '{% url "notifications:api-draft-save" %}'
 };
 </script>
-<script src="{% static 'coldfront_notifications/js/compose.js' %}"></script>
+<script src="{% static 'coldfront_notifications/js/compose_filters.js' %}"></script>
+<script src="{% static 'coldfront_notifications/js/compose_validate.js' %}"></script>
+<script src="{% static 'coldfront_notifications/js/compose_templates.js' %}"></script>
+<script src="{% static 'coldfront_notifications/js/compose_preview.js' %}"></script>
+<script src="{% static 'coldfront_notifications/js/compose_draft.js' %}"></script>
+<script src="{% static 'coldfront_notifications/js/compose_init.js' %}"></script>
 {% endblock %}
\ No newline at end of file
diff --git a/coldfront_notifications/templates/dashboard.html b/coldfront_notifications/templates/coldfront_notifications/dashboard.html
similarity index 99%
rename from coldfront_notifications/templates/dashboard.html
rename to coldfront_notifications/templates/coldfront_notifications/dashboard.html
index f609cd7..13afc83 100644
--- a/coldfront_notifications/templates/dashboard.html
+++ b/coldfront_notifications/templates/coldfront_notifications/dashboard.html
@@ -80,7 +80,7 @@ <h3 class="h5 mb-0">
             <tr>
               <td>
                 <a href="{% url 'notifications:campaign-detail' campaign.pk %}">
-                  {{ campaign.subject }}
+                  {{ campaign.display_subject }}
                 </a>
               </td>
               <td>
diff --git a/coldfront_notifications/templates/coldfront_notifications/draft_delete_confirm.html b/coldfront_notifications/templates/coldfront_notifications/draft_delete_confirm.html
new file mode 100644
index 0000000..01aa3da
--- /dev/null
+++ b/coldfront_notifications/templates/coldfront_notifications/draft_delete_confirm.html
@@ -0,0 +1,52 @@
+{% extends "common/base.html" %}
+{% block title %}Delete Draft | FAS Research Computing{% endblock %}
+{% block content %}
+<div class="mb-3">
+  <h2>Delete Draft</h2>
+  <hr>
+</div>
+
+<div class="row">
+  <div class="col-lg-6">
+    <div class="card border-danger mb-3">
+      <div class="card-header bg-danger text-white">
+        <h5 class="h6 mb-0">Confirm Deletion</h5>
+      </div>
+      <div class="card-body">
+        <p>Are you sure you want to delete this draft notification?</p>
+
+        <table class="table table-sm table-borderless mb-3" style="font-size:.85rem;">
+          <tr><td style="width:80px;" class="font-weight-bold text-muted">Subject</td><td>{{ campaign.subject|default:"(no subject)" }}</td></tr>
+          {% if campaign.template %}
+          <tr><td class="font-weight-bold text-muted">Template</td><td><code>{{ campaign.template.slug }}</code></td></tr>
+          {% endif %}
+          <tr><td class="font-weight-bold text-muted">Created</td><td>{{ campaign.created_at|date:"Y-m-d H:i" }}</td></tr>
+          {% if campaign.filter_summary %}
+          <tr><td class="font-weight-bold text-muted">Filters</td><td>
+            {% for badge in campaign.filter_summary %}
+            <span class="badge badge-light border text-dark mb-1" style="font-size:.72rem;">{{ badge }}</span>
+            {% endfor %}
+          </td></tr>
+          {% endif %}
+        </table>
+
+        <p class="text-muted" style="font-size:.82rem;">
+          This draft has never been sent. Deleting it is permanent and cannot be undone.
+        </p>
+
+        <form method="post">
+          {% csrf_token %}
+          <div class="d-flex justify-content-end" style="gap:8px;">
+            <a href="{% url 'notifications:campaign-list' %}" class="btn btn-outline-secondary btn-sm">
+              Go Back
+            </a>
+            <button type="submit" class="btn btn-danger btn-sm">
+              <i class="fas fa-trash mr-1"></i> Delete Draft
+            </button>
+          </div>
+        </form>
+      </div>
+    </div>
+  </div>
+</div>
+{% endblock %}
diff --git a/coldfront_notifications/templates/resend_compose.html b/coldfront_notifications/templates/coldfront_notifications/resend_compose.html
similarity index 99%
rename from coldfront_notifications/templates/resend_compose.html
rename to coldfront_notifications/templates/coldfront_notifications/resend_compose.html
index 25bbe73..dd21cd2 100644
--- a/coldfront_notifications/templates/resend_compose.html
+++ b/coldfront_notifications/templates/coldfront_notifications/resend_compose.html
@@ -271,9 +271,9 @@ <h5 class="modal-title"><i class="fas fa-users mr-2"></i>Recipient Preview</h5>
 <script>
 var SNAPSHOT = {{ snapshot_json|safe }};
 var URLS = {
-  previewRender:  '{% url "notifications:preview-render" %}',
-  recipientCount: '{% url "notifications:recipient-count" %}',
-  validate:       '{% url "notifications:validate" %}'
+  previewRender:  '{% url "notifications:api-preview-render" %}',
+  recipientCount: '{% url "notifications:api-recipient-count" %}',
+  validate:       '{% url "notifications:api-validate" %}'
 };
 </script>
 <script>
diff --git a/coldfront_notifications/templates/sender_form.html b/coldfront_notifications/templates/coldfront_notifications/sender_form.html
similarity index 100%
rename from coldfront_notifications/templates/sender_form.html
rename to coldfront_notifications/templates/coldfront_notifications/sender_form.html
diff --git a/coldfront_notifications/templates/settings.html b/coldfront_notifications/templates/coldfront_notifications/settings.html
similarity index 100%
rename from coldfront_notifications/templates/settings.html
rename to coldfront_notifications/templates/coldfront_notifications/settings.html
diff --git a/coldfront_notifications/templates/template_delete_confirm.html b/coldfront_notifications/templates/coldfront_notifications/template_delete_confirm.html
similarity index 100%
rename from coldfront_notifications/templates/template_delete_confirm.html
rename to coldfront_notifications/templates/coldfront_notifications/template_delete_confirm.html
diff --git a/coldfront_notifications/templates/template_form.html b/coldfront_notifications/templates/coldfront_notifications/template_form.html
similarity index 100%
rename from coldfront_notifications/templates/template_form.html
rename to coldfront_notifications/templates/coldfront_notifications/template_form.html
diff --git a/coldfront_notifications/templates/template_list.html b/coldfront_notifications/templates/coldfront_notifications/template_list.html
similarity index 100%
rename from coldfront_notifications/templates/template_list.html
rename to coldfront_notifications/templates/coldfront_notifications/template_list.html
diff --git a/coldfront_notifications/templates/variable_delete_confirm.html b/coldfront_notifications/templates/coldfront_notifications/variable_delete_confirm.html
similarity index 100%
rename from coldfront_notifications/templates/variable_delete_confirm.html
rename to coldfront_notifications/templates/coldfront_notifications/variable_delete_confirm.html
diff --git a/coldfront_notifications/templates/variable_form.html b/coldfront_notifications/templates/coldfront_notifications/variable_form.html
similarity index 100%
rename from coldfront_notifications/templates/variable_form.html
rename to coldfront_notifications/templates/coldfront_notifications/variable_form.html
diff --git a/coldfront_notifications/templates/variable_list.html b/coldfront_notifications/templates/coldfront_notifications/variable_list.html
similarity index 100%
rename from coldfront_notifications/templates/variable_list.html
rename to coldfront_notifications/templates/coldfront_notifications/variable_list.html
diff --git a/coldfront_notifications/tests/django_setup.py b/coldfront_notifications/tests/django_setup.py
new file mode 100644
index 0000000..518ee47
--- /dev/null
+++ b/coldfront_notifications/tests/django_setup.py
@@ -0,0 +1,118 @@
+"""
+Django configuration for unit tests.
+
+When ColdFront is installed (Docker, local dev), uses the full app stack.
+When running standalone (CI), stubs the ColdFront modules so that
+top-level imports in plugin code resolve without errors.
+
+Import this module before any Django/plugin imports in test files.
+"""
+import sys
+import types
+
+import django
+from django.conf import settings
+
+
+def _stub_coldfront_modules():
+    """Register stub modules for ColdFront packages not installed in CI.
+
+    This lets top-level ``from coldfront.core.project.models import ...``
+    resolve to MagicMock objects instead of raising ImportError.
+    """
+    from unittest.mock import MagicMock
+
+    stub_paths = [
+        "coldfront",
+        "coldfront.core",
+        "coldfront.core.allocation",
+        "coldfront.core.allocation.models",
+        "coldfront.core.department",
+        "coldfront.core.department.models",
+        "coldfront.core.field_of_science",
+        "coldfront.core.field_of_science.models",
+        "coldfront.core.project",
+        "coldfront.core.project.models",
+        "coldfront.core.resource",
+        "coldfront.core.resource.models",
+        "coldfront.core.user",
+        "coldfront.core.utils",
+        "coldfront.core.portal",
+        "coldfront.core.grant",
+        "coldfront.core.publication",
+        "coldfront.core.research_output",
+        "coldfront.plugins",
+        "coldfront.plugins.ifx",
+        "coldfront.plugins.ifx.models",
+        "ifxuser",
+        "ifxuser.models",
+        "ifxbilling",
+        "ifxbilling.models",
+    ]
+    for path in stub_paths:
+        if path not in sys.modules:
+            sys.modules[path] = MagicMock()
+
+
+def _has_coldfront():
+    """Check if ColdFront is actually installed."""
+    try:
+        import coldfront  # noqa: F401
+        return True
+    except ImportError:
+        return False
+
+
+if not settings.configured:
+    if _has_coldfront():
+        settings.configure(
+            INSTALLED_APPS=[
+                "django.contrib.contenttypes",
+                "django.contrib.auth",
+                "django.contrib.admin",
+                "django.contrib.sessions",
+                "django.contrib.messages",
+                "coldfront.core.field_of_science",
+                "coldfront.core.project",
+                "coldfront.core.resource",
+                "coldfront.core.allocation",
+                "coldfront.core.department",
+                "coldfront.core.user",
+                "coldfront.core.utils",
+                "coldfront.plugins.ifx",
+                "ifxuser",
+                "ifxbilling",
+                "simple_history",
+                "django_q",
+                "coldfront_notifications",
+            ],
+            DATABASES={
+                "default": {
+                    "ENGINE": "django.db.backends.sqlite3",
+                    "NAME": ":memory:",
+                }
+            },
+            DEFAULT_AUTO_FIELD="django.db.models.BigAutoField",
+            AUTH_USER_MODEL="ifxuser.IfxUser",
+            SECRET_KEY="test-secret-key-not-for-production",
+            IFX_APP={"token": "test-token"},
+        )
+    else:
+        _stub_coldfront_modules()
+        settings.configure(
+            INSTALLED_APPS=[
+                "django.contrib.contenttypes",
+                "django.contrib.auth",
+                "coldfront_notifications",
+            ],
+            DATABASES={
+                "default": {
+                    "ENGINE": "django.db.backends.sqlite3",
+                    "NAME": ":memory:",
+                }
+            },
+            DEFAULT_AUTO_FIELD="django.db.models.BigAutoField",
+            SECRET_KEY="test-secret-key-not-for-production",
+        )
+
+    django.setup()
diff --git a/coldfront_notifications/tests/test_conf.py b/coldfront_notifications/tests/test_conf.py
new file mode 100644
index 0000000..744e873
--- /dev/null
+++ b/coldfront_notifications/tests/test_conf.py
@@ -0,0 +1,36 @@
+"""Unit tests for coldfront_notifications.conf defaults."""
+import unittest
+
+import coldfront_notifications.tests.django_setup  # noqa: F401
+
+
+class TestConfDefaults(unittest.TestCase):
+    """Tests that conf.py exports sensible defaults."""
+
+    def test_batch_size_default(self):
+        from coldfront_notifications.conf import BATCH_SIZE
+        self.assertEqual(BATCH_SIZE, 50)
+
+    def test_batch_delay_default(self):
+        from coldfront_notifications.conf import BATCH_DELAY
+        self.assertEqual(BATCH_DELAY, 2.0)
+
+    def test_max_retries_default(self):
+        from coldfront_notifications.conf import MAX_RETRIES
+        self.assertEqual(MAX_RETRIES, 3)
+
+    def test_retry_delay_default(self):
+        from coldfront_notifications.conf import RETRY_DELAY
+        self.assertEqual(RETRY_DELAY, 1.0)
+
+    def test_preview_page_size_default(self):
+        from coldfront_notifications.conf import PREVIEW_PAGE_SIZE
+        self.assertEqual(PREVIEW_PAGE_SIZE, 50)
+
+    def test_preview_render_limit_default(self):
+        from coldfront_notifications.conf import PREVIEW_RENDER_LIMIT
+        self.assertEqual(PREVIEW_RENDER_LIMIT, 10)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/coldfront_notifications/tests/test_filters.py b/coldfront_notifications/tests/test_filters.py
new file mode 100644
index 0000000..754023f
--- /dev/null
+++ b/coldfront_notifications/tests/test_filters.py
@@ -0,0 +1,367 @@
+"""Unit tests for coldfront_notifications.filters."""
+import unittest
+from unittest.mock import MagicMock, patch
+
+import coldfront_notifications.tests.django_setup  # noqa: F401
+
+from coldfront_notifications.filters import (
+    ALLOCATION_FILTERS,
+    AllocationFilter,
+    BaseFilter,
+    DepartmentFilter,
+    FILTER_REGISTRY,
+    FilterDataBuilder,
+    PROJECT_FILTERS,
+    ProjectFilter,
+    RecipientResolver,
+    ResourceFilter,
+    RoleFilter,
+    StatusFilter,
+)
+
+
+class TestBaseFilter(unittest.TestCase):
+    """BaseFilter enforces the interface contract."""
+
+    def test_initial_options_is_abstract(self):
+        with self.assertRaises(NotImplementedError):
+            BaseFilter().initial_options()
+
+    def test_apply_is_abstract(self):
+        with self.assertRaises(NotImplementedError):
+            BaseFilter()._apply(None, ["x"])
+
+    def test_narrowed_by_default_empty(self):
+        # Can't instantiate BaseFilter directly (abstract), so check
+        # via a concrete subclass that doesn't override narrowed_by.
+        self.assertEqual(StatusFilter().narrowed_by(), [])
+
+    def test_to_dict_shape(self):
+        """to_dict returns options + narrowed_by keys."""
+        f = StatusFilter()
+        with patch.object(f, "initial_options", return_value=[{"id": "x", "label": "X"}]):
+            d = f.to_dict()
+        self.assertIn("options", d)
+        self.assertIn("narrowed_by", d)
+        self.assertIsInstance(d["options"], list)
+        self.assertIsInstance(d["narrowed_by"], list)
+
+
+class TestDepartmentFilter(unittest.TestCase):
+    """DepartmentFilter uses the Department proxy model and batches queries."""
+
+    @patch("coldfront_notifications.filters.DepartmentFilter.initial_options")
+    def test_narrowed_by_is_empty(self, _mock):
+        self.assertEqual(DepartmentFilter().narrowed_by(), [])
+
+    @patch("coldfront_notifications.filters.DepartmentFilter.initial_options")
+    def test_option_shape(self, mock_opts):
+        """Each option must have id (pk), label, and project_ids."""
+        mock_opts.return_value = [
+            {"id": 1, "label": "Physics", "project_ids": [1, 2]},
+            {"id": 2, "label": "Math", "project_ids": [3]},
+        ]
+        options = DepartmentFilter().initial_options()
+        for opt in options:
+            self.assertIn("id", opt)
+            self.assertIn("label", opt)
+            self.assertIn("project_ids", opt)
+            self.assertIsInstance(opt["id"], int)
+            self.assertIsInstance(opt["project_ids"], list)
+
+
+class TestProjectFilter(unittest.TestCase):
+    """ProjectFilter returns all projects, narrowed by departments."""
+
+    def test_narrowed_by_departments(self):
+        self.assertEqual(ProjectFilter().narrowed_by(), ["departments"])
+
+    @patch("coldfront_notifications.filters.ProjectFilter.initial_options")
+    def test_option_shape(self, mock_opts):
+        mock_opts.return_value = [
+            {"id": 1, "label": "Alpha"},
+            {"id": 2, "label": "Beta"},
+        ]
+        options = ProjectFilter().initial_options()
+        for opt in options:
+            self.assertIn("id", opt)
+            self.assertIn("label", opt)
+            self.assertIsInstance(opt["id"], int)
+
+
+class TestResourceFilter(unittest.TestCase):
+    """ResourceFilter carries project_ids for cross-filtering."""
+
+    def test_narrowed_by_projects(self):
+        self.assertEqual(ResourceFilter().narrowed_by(), ["projects"])
+
+    @patch("coldfront_notifications.filters.ResourceFilter.initial_options")
+    def test_option_shape(self, mock_opts):
+        mock_opts.return_value = [
+            {"id": 10, "label": "Storage", "project_ids": [1, 2]},
+        ]
+        options = ResourceFilter().initial_options()
+        for opt in options:
+            self.assertIn("id", opt)
+            self.assertIn("label", opt)
+            self.assertIn("project_ids", opt)
+            self.assertIsInstance(opt["project_ids"], list)
+
+
+class TestStatusFilter(unittest.TestCase):
+    """StatusFilter is independent — name strings as IDs."""
+
+    def test_narrowed_by_empty(self):
+        self.assertEqual(StatusFilter().narrowed_by(), [])
+
+    @patch("coldfront_notifications.filters.StatusFilter.initial_options")
+    def test_option_shape(self, mock_opts):
+        mock_opts.return_value = [
+            {"id": "Active", "label": "Active"},
+            {"id": "Denied", "label": "Denied"},
+        ]
+        options = StatusFilter().initial_options()
+        for opt in options:
+            self.assertIn("id", opt)
+            self.assertIn("label", opt)
+            self.assertIsInstance(opt["id"], str)
+
+
+class TestAllocationFilter(unittest.TestCase):
+    """AllocationFilter carries project_id, status, and resource_ids."""
+
+    def test_narrowed_by_three_filters(self):
+        self.assertEqual(
+            AllocationFilter().narrowed_by(),
+            ["projects", "resources", "statuses"],
+        )
+
+    @patch("coldfront_notifications.filters.AllocationFilter.initial_options")
+    def test_option_shape(self, mock_opts):
+        mock_opts.return_value = [
+            {
+                "id": 100,
+                "label": "Alpha \u2014 Storage",
+                "project_id": 1,
+                "status": "Active",
+                "resource_ids": [10, 11],
+            },
+        ]
+        options = AllocationFilter().initial_options()
+        for opt in options:
+            self.assertIn("id", opt)
+            self.assertIn("label", opt)
+            self.assertIn("project_id", opt)
+            self.assertIn("status", opt)
+            self.assertIn("resource_ids", opt)
+            self.assertIsInstance(opt["resource_ids"], list)
+
+
+class TestRoleFilter(unittest.TestCase):
+    """RoleFilter is independent — name strings as IDs."""
+
+    def test_narrowed_by_empty(self):
+        self.assertEqual(RoleFilter().narrowed_by(), [])
+
+    @patch("coldfront_notifications.filters.RoleFilter.initial_options")
+    def test_option_shape(self, mock_opts):
+        mock_opts.return_value = [
+            {"id": "Manager", "label": "Manager"},
+            {"id": "User", "label": "User"},
+        ]
+        options = RoleFilter().initial_options()
+        for opt in options:
+            self.assertIsInstance(opt["id"], str)
+
+
+class TestFilterRegistry(unittest.TestCase):
+    """FILTER_REGISTRY maps all six filter names to classes."""
+
+    def test_all_six_filters_registered(self):
+        expected = {
+            "departments", "projects", "resources",
+            "statuses", "allocations", "roles",
+        }
+        self.assertEqual(set(FILTER_REGISTRY.keys()), expected)
+
+    def test_all_values_are_base_filter_subclasses(self):
+        for name, cls in FILTER_REGISTRY.items():
+            self.assertTrue(
+                issubclass(cls, BaseFilter),
+                f"{name} -> {cls} is not a BaseFilter subclass",
+            )
+
+
+class TestFilterDataBuilder(unittest.TestCase):
+    """FilterDataBuilder.build() returns a JSON-serializable dict."""
+
+    @patch("coldfront_notifications.filters.FILTER_REGISTRY", {
+        "test_filter": MagicMock(
+            return_value=MagicMock(
+                to_dict=MagicMock(return_value={
+                    "options": [{"id": 1, "label": "X"}],
+                    "narrowed_by": [],
+                }),
+            ),
+        ),
+    })
+    def test_structure(self):
+        data = FilterDataBuilder().build()
+        self.assertIn("test_filter", data)
+        self.assertIn("options", data["test_filter"])
+        self.assertIn("narrowed_by", data["test_filter"])
+
+    @patch("coldfront_notifications.filters.FILTER_REGISTRY", {
+        "empty": MagicMock(
+            return_value=MagicMock(
+                to_dict=MagicMock(return_value={
+                    "options": [],
+                    "narrowed_by": [],
+                }),
+            ),
+        ),
+    })
+    def test_empty_options(self):
+        data = FilterDataBuilder().build()
+        self.assertEqual(data["empty"]["options"], [])
+        self.assertEqual(data["empty"]["narrowed_by"], [])
+
+
+class TestBaseFilterApply(unittest.TestCase):
+    """BaseFilter.apply() skips _apply when values is empty."""
+
+    def test_apply_returns_qs_unchanged_when_values_empty(self):
+        qs = MagicMock()
+        f = StatusFilter()
+        result = f.apply(qs, [])
+        self.assertIs(result, qs)
+
+    def test_apply_calls_apply_when_values_present(self):
+        qs = MagicMock()
+        filtered = MagicMock()
+        qs.filter.return_value = filtered
+        f = RoleFilter()
+        result = f.apply(qs, ["PI"])
+        self.assertIsNot(result, qs)
+
+
+class TestDepartmentFilterApply(unittest.TestCase):
+    """DepartmentFilter._apply uses org_relation tree traversal."""
+
+    def test_apply_filters_project_users(self):
+        import sys
+
+        MockRel = MagicMock()
+        saved = sys.modules.get("ifxuser.models")
+        sys.modules["ifxuser.models"] = MagicMock(OrgRelation=MockRel)
+
+        try:
+            project_users = MagicMock()
+            DepartmentFilter()._apply(project_users, [1880])
+            project_users.filter.assert_called_once()
+        finally:
+            if saved is None:
+                sys.modules.pop("ifxuser.models", None)
+            else:
+                sys.modules["ifxuser.models"] = saved
+
+
+class TestProjectFilterApply(unittest.TestCase):
+    def test_filters_by_project_pk(self):
+        qs = MagicMock()
+        ProjectFilter()._apply(qs, [1, 2])
+        qs.filter.assert_called_once_with(project__pk__in=[1, 2])
+
+
+class TestRoleFilterApply(unittest.TestCase):
+    def test_filters_by_role_name(self):
+        qs = MagicMock()
+        RoleFilter()._apply(qs, ["PI", "User"])
+        qs.filter.assert_called_once_with(role__name__in=["PI", "User"])
+
+
+class TestResourceFilterApply(unittest.TestCase):
+    def test_filters_by_resource_pk(self):
+        qs = MagicMock()
+        ResourceFilter()._apply(qs, [10, 20])
+        qs.filter.assert_called_once_with(resources__pk__in=[10, 20])
+
+
+class TestStatusFilterApply(unittest.TestCase):
+    def test_filters_by_status_name(self):
+        qs = MagicMock()
+        StatusFilter()._apply(qs, ["Active", "Denied"])
+        qs.filter.assert_called_once_with(status__name__in=["Active", "Denied"])
+
+
+class TestAllocationFilterApply(unittest.TestCase):
+    def test_filters_by_pk(self):
+        qs = MagicMock()
+        AllocationFilter()._apply(qs, [100, 200])
+        qs.filter.assert_called_once_with(pk__in=[100, 200])
+
+
+class TestHasAllocationFilters(unittest.TestCase):
+    def test_true_when_resources_present(self):
+        self.assertTrue(RecipientResolver({"resources": [1]})._has_allocation_filters())
+
+    def test_true_when_statuses_present(self):
+        self.assertTrue(RecipientResolver({"statuses": ["Active"]})._has_allocation_filters())
+
+    def test_true_when_allocations_present(self):
+        self.assertTrue(RecipientResolver({"allocations": [1]})._has_allocation_filters())
+
+    def test_false_when_only_project_filters(self):
+        self.assertFalse(RecipientResolver({"projects": [1], "roles": ["PI"]})._has_allocation_filters())
+
+    def test_false_when_empty(self):
+        self.assertFalse(RecipientResolver({})._has_allocation_filters())
+
+
+class TestFilterConstants(unittest.TestCase):
+    def test_project_filters(self):
+        self.assertEqual(
+            set(PROJECT_FILTERS),
+            {"departments", "projects", "roles"},
+        )
+
+    def test_allocation_filters(self):
+        self.assertEqual(
+            set(ALLOCATION_FILTERS),
+            {"allocations", "resources", "statuses"},
+        )
+
+    def test_all_filters_covered(self):
+        self.assertEqual(
+            set(PROJECT_FILTERS) | set(ALLOCATION_FILTERS),
+            set(FILTER_REGISTRY.keys()),
+        )
+
+
+class TestNarrowingRules(unittest.TestCase):
+    """Verify the declared narrowing graph matches the design spec."""
+
+    def test_department_narrows_nothing(self):
+        self.assertEqual(DepartmentFilter().narrowed_by(), [])
+
+    def test_project_narrowed_by_department(self):
+        self.assertEqual(ProjectFilter().narrowed_by(), ["departments"])
+
+    def test_resource_narrowed_by_project(self):
+        self.assertEqual(ResourceFilter().narrowed_by(), ["projects"])
+
+    def test_status_narrows_nothing(self):
+        self.assertEqual(StatusFilter().narrowed_by(), [])
+
+    def test_allocation_narrowed_by_three(self):
+        result = AllocationFilter().narrowed_by()
+        self.assertIn("projects", result)
+        self.assertIn("resources", result)
+        self.assertIn("statuses", result)
+
+    def test_role_narrows_nothing(self):
+        self.assertEqual(RoleFilter().narrowed_by(), [])
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/coldfront_notifications/tests/test_integration.py b/coldfront_notifications/tests/test_integration.py
index f529d0a..1c8925d 100644
--- a/coldfront_notifications/tests/test_integration.py
+++ b/coldfront_notifications/tests/test_integration.py
@@ -5,6 +5,7 @@
 """
 import json
 from datetime import timedelta
+import sys
 from unittest.mock import patch
 
 from django.contrib.auth import get_user_model
@@ -38,11 +39,7 @@
     NotificationVariable,
     SenderConfig,
 )
-from coldfront_notifications.utils import (
-    build_recipient_queryset,
-    enumerate_recipients,
-    enumerate_recipients_deduped,
-)
+from coldfront_notifications.filters import RecipientResolver
 
 User = get_user_model()
 
@@ -193,15 +190,15 @@ def setUpTestData(cls):
         cls.var_query = NotificationVariable.objects.create(
             key="project_title",
             label="Project Title",
-            source=NotificationVariable.SOURCE_QUERY,
+            source=NotificationVariable.Source.QUERY,
             resolver_key="project.title",
         )
         cls.var_manual = NotificationVariable.objects.create(
             key="maint_date",
             label="Maintenance Date",
-            source=NotificationVariable.SOURCE_MANUAL,
+            source=NotificationVariable.Source.MANUAL,
             value="2026-05-01",
-            input_widget=NotificationVariable.WIDGET_DATE,
+            input_widget=NotificationVariable.Widget.DATE,
         )
 
         # --- NotificationTemplate ---
@@ -229,10 +226,10 @@ def setUp(self):
 # =============================================================================
 
 class BuildRecipientQuerysetTest(NotificationIntegrationTestCase):
-    """Tests for build_recipient_queryset."""
+    """Tests for RecipientResolver.queryset()."""
 
     def test_no_filters_returns_all_active_users(self):
-        qs = build_recipient_queryset({})
+        qs = RecipientResolver({}).queryset()
         user_pks = set(qs.values_list("pk", flat=True))
         # All 3 users have active ProjectUser memberships
         self.assertIn(self.user1.pk, user_pks)
@@ -240,7 +237,7 @@ def test_no_filters_returns_all_active_users(self):
         self.assertIn(self.user3.pk, user_pks)
 
     def test_project_filter(self):
-        qs = build_recipient_queryset({"projects": [self.proj1.pk]})
+        qs = RecipientResolver({"projects": [self.proj1.pk]}).queryset()
         user_pks = set(qs.values_list("pk", flat=True))
         # proj1 has user1 (PI) and user2 (User)
         self.assertIn(self.user1.pk, user_pks)
@@ -248,7 +245,7 @@ def test_project_filter(self):
         self.assertNotIn(self.user3.pk, user_pks)
 
     def test_role_filter(self):
-        qs = build_recipient_queryset({"roles": ["Principal Investigator"]})
+        qs = RecipientResolver({"roles": ["Principal Investigator"]}).queryset()
         user_pks = set(qs.values_list("pk", flat=True))
         # Only user1 is PI
         self.assertIn(self.user1.pk, user_pks)
@@ -256,7 +253,7 @@ def test_role_filter(self):
         self.assertNotIn(self.user3.pk, user_pks)
 
     def test_department_filter(self):
-        qs = build_recipient_queryset({"departments": ["Engineering Dept"]})
+        qs = RecipientResolver({"departments": ["Engineering Dept"]}).queryset()
         user_pks = set(qs.values_list("pk", flat=True))
         # Only proj1 linked to dept → user1, user2
         self.assertIn(self.user1.pk, user_pks)
@@ -264,7 +261,7 @@ def test_department_filter(self):
         self.assertNotIn(self.user3.pk, user_pks)
 
     def test_allocation_status_filter(self):
-        qs = build_recipient_queryset({"statuses": ["Active"]})
+        qs = RecipientResolver({"statuses": ["Active"]}).queryset()
         user_pks = set(qs.values_list("pk", flat=True))
         # All users have active AllocationUser records
         self.assertIn(self.user1.pk, user_pks)
@@ -272,15 +269,15 @@ def test_allocation_status_filter(self):
         self.assertIn(self.user3.pk, user_pks)
 
     def test_allocation_status_filter_expired_returns_none(self):
-        qs = build_recipient_queryset({"statuses": ["Expired"]})
+        qs = RecipientResolver({"statuses": ["Expired"]}).queryset()
         self.assertEqual(qs.count(), 0)
 
 
 class EnumerateRecipientsTest(NotificationIntegrationTestCase):
-    """Tests for enumerate_recipients."""
+    """Tests for RecipientResolver.enumerate()."""
 
     def test_scope_user_returns_distinct_users(self):
-        results = list(enumerate_recipients({}, "user"))
+        results = list(RecipientResolver({}).enumerate("user"))
         users = [r[0] for r in results]
         user_pks = [u.pk for u in users]
         # Each user appears once, project and allocation are None
@@ -290,7 +287,7 @@ def test_scope_user_returns_distinct_users(self):
             self.assertIsNone(allocation)
 
     def test_scope_project_returns_per_project_user(self):
-        results = list(enumerate_recipients({}, "project"))
+        results = list(RecipientResolver({}).enumerate("project"))
         # user1 on 2 projects, user2 on 1, user3 on 1 → 4 tuples
         self.assertEqual(len(results), 4)
         for user, project, allocation in results:
@@ -298,7 +295,7 @@ def test_scope_project_returns_per_project_user(self):
             self.assertIsNone(allocation)
 
     def test_scope_allocation_returns_per_allocation_user(self):
-        results = list(enumerate_recipients({}, "allocation"))
+        results = list(RecipientResolver({}).enumerate("allocation"))
         # alloc1: user1, user2; alloc2: user1, user3 → 4 tuples
         self.assertEqual(len(results), 4)
         for user, project, allocation in results:
@@ -306,7 +303,7 @@ def test_scope_allocation_returns_per_allocation_user(self):
             self.assertIsNotNone(allocation)
 
     def test_scope_project_with_project_filter(self):
-        results = list(enumerate_recipients({"projects": [self.proj1.pk]}, "project"))
+        results = list(RecipientResolver({"projects": [self.proj1.pk]}).enumerate("project"))
         # proj1 has user1 and user2
         self.assertEqual(len(results), 2)
         user_pks = {r[0].pk for r in results}
@@ -314,20 +311,16 @@ def test_scope_project_with_project_filter(self):
 
 
 class EnumerateRecipientsDedupedTest(NotificationIntegrationTestCase):
-    """Tests for enumerate_recipients_deduped."""
+    """Tests for RecipientResolver.enumerate_deduped()."""
 
     def test_deduped_user_gets_only_first_tuple(self):
         # user1 appears on both projects; with dedup they get only 1 tuple
-        results = list(enumerate_recipients_deduped(
-            {}, "project", dedupe_users=["user1"]
-        ))
+        results = list(RecipientResolver({}).enumerate_deduped("project", ["user1"]))
         user1_tuples = [r for r in results if r[0].pk == self.user1.pk]
         self.assertEqual(len(user1_tuples), 1)
 
     def test_non_deduped_users_unchanged(self):
-        results = list(enumerate_recipients_deduped(
-            {}, "project", dedupe_users=["user1"]
-        ))
+        results = list(RecipientResolver({}).enumerate_deduped("project", ["user1"]))
         # user2 and user3 still have their single tuples
         user2_tuples = [r for r in results if r[0].pk == self.user2.pk]
         user3_tuples = [r for r in results if r[0].pk == self.user3.pk]
@@ -335,8 +328,8 @@ def test_non_deduped_users_unchanged(self):
         self.assertEqual(len(user3_tuples), 1)
 
     def test_empty_dedupe_list_is_passthrough(self):
-        full = list(enumerate_recipients({}, "project"))
-        deduped = list(enumerate_recipients_deduped({}, "project", []))
+        full = list(RecipientResolver({}).enumerate("project"))
+        deduped = list(RecipientResolver({}).enumerate_deduped("project", []))
         self.assertEqual(len(full), len(deduped))
 
 
@@ -467,20 +460,263 @@ def test_soft_deleted_variable_excluded_from_list(self):
 
 
 class FilterOptionsViewTest(NotificationIntegrationTestCase):
-    """Tests for the filter-options AJAX endpoint."""
+    """Tests for the event-driven filter-options AJAX endpoint."""
 
-    def test_filter_options_with_project(self):
+    @classmethod
+    def setUpTestData(cls):
+        super().setUpTestData()
+        # Extra fixtures for richer cascade testing.
+        cls.resource2 = Resource.objects.create(
+            name="GPU Cluster",
+            resource_type=cls.resource_type,
+            is_allocatable=True,
+        )
+        # An expired allocation on proj2 with resource2.
+        cls.alloc3 = Allocation.objects.create(
+            project=cls.proj2,
+            status=cls.alloc_status_expired,
+            justification="Old GPU allocation",
+        )
+        cls.alloc3.resources.add(cls.resource2)
+
+    def _post_event(self, event, selections=None):
+        """Helper: POST an event to filter-options and return parsed JSON."""
+        sel = {
+            "projects": [], "allocations": [], "departments": [],
+            "resources": [], "statuses": [], "roles": [],
+        }
+        if selections:
+            sel.update(selections)
         resp = self.client.post(
             reverse("notifications:filter-options"),
-            {"projects": [self.proj1.pk]},
+            json.dumps({"event": event, "selections": sel}),
+            content_type="application/json",
         )
         self.assertEqual(resp.status_code, 200)
-        data = resp.json()
-        self.assertIn("allocations", data)
-        # Should include alloc1 (proj1) but not alloc2 (proj2)
-        alloc_ids = [a["id"] for a in data["allocations"]]
+        return resp.json()
+
+    def _ids(self, data, key):
+        """Extract option ids from the response for a given filter key."""
+        return [o["id"] for o in data[key]["options"]]
+
+    def test_response_contains_all_six_filters(self):
+        data = self._post_event("ROLE_UPDATED")
+        for key in ("projects", "allocations", "departments",
+                    "resources", "statuses", "roles"):
+            self.assertIn(key, data)
+            self.assertIn("options", data[key])
+            self.assertIn("selected", data[key])
+
+    def test_project_updated_narrows_allocations(self):
+        data = self._post_event("PROJECT_UPDATED", {
+            "projects": [self.proj1.pk],
+        })
+        alloc_ids = self._ids(data, "allocations")
+        self.assertIn(self.alloc1.pk, alloc_ids)
+        self.assertNotIn(self.alloc2.pk, alloc_ids)
+        self.assertNotIn(self.alloc3.pk, alloc_ids)
+
+    def test_project_updated_narrows_departments(self):
+        data = self._post_event("PROJECT_UPDATED", {
+            "projects": [self.proj1.pk],
+        })
+        dept_ids = self._ids(data, "departments")
+        self.assertIn("Engineering Dept", dept_ids)
+
+    def test_project_updated_narrows_departments_excludes_unlinked(self):
+        data = self._post_event("PROJECT_UPDATED", {
+            "projects": [self.proj2.pk],
+        })
+        # proj2 has no department link
+        dept_ids = self._ids(data, "departments")
+        self.assertNotIn("Engineering Dept", dept_ids)
+
+    def test_project_updated_narrows_resources(self):
+        data = self._post_event("PROJECT_UPDATED", {
+            "projects": [self.proj2.pk],
+        })
+        res_ids = self._ids(data, "resources")
+        # proj2 has alloc2 (Test Storage) and alloc3 (GPU Cluster)
+        self.assertIn(self.resource.pk, res_ids)
+        self.assertIn(self.resource2.pk, res_ids)
+
+    def test_project_updated_narrows_statuses(self):
+        data = self._post_event("PROJECT_UPDATED", {
+            "projects": [self.proj2.pk],
+        })
+        status_ids = self._ids(data, "statuses")
+        # proj2 has Active (alloc2) and Expired (alloc3)
+        self.assertIn("Active", status_ids)
+        self.assertIn("Expired", status_ids)
+
+    def test_project_updated_narrows_roles(self):
+        data = self._post_event("PROJECT_UPDATED", {
+            "projects": [self.proj1.pk],
+        })
+        role_ids = self._ids(data, "roles")
+        # proj1 has PI (user1) and User (user2), no Manager
+        self.assertIn("Principal Investigator", role_ids)
+        self.assertIn("User", role_ids)
+        self.assertNotIn("Manager", role_ids)
+
+    def test_department_updated_narrows_projects(self):
+        data = self._post_event("DEPARTMENT_UPDATED", {
+            "departments": ["Engineering Dept"],
+        })
+        proj_ids = self._ids(data, "projects")
+        self.assertIn(self.proj1.pk, proj_ids)
+        self.assertNotIn(self.proj2.pk, proj_ids)
+
+    def test_department_updated_narrows_allocations(self):
+        data = self._post_event("DEPARTMENT_UPDATED", {
+            "departments": ["Engineering Dept"],
+        })
+        alloc_ids = self._ids(data, "allocations")
+        self.assertIn(self.alloc1.pk, alloc_ids)
+        self.assertNotIn(self.alloc2.pk, alloc_ids)
+
+    def test_allocation_updated_narrows_resources(self):
+        data = self._post_event("ALLOCATION_UPDATED", {
+            "allocations": [self.alloc3.pk],
+        })
+        res_ids = self._ids(data, "resources")
+        self.assertIn(self.resource2.pk, res_ids)
+        self.assertNotIn(self.resource.pk, res_ids)
+
+    def test_allocation_updated_does_not_narrow_statuses(self):
+        """Status is an independent peer — not narrowed by allocation selection."""
+        data = self._post_event("ALLOCATION_UPDATED", {
+            "allocations": [self.alloc3.pk],
+        })
+        status_ids = self._ids(data, "statuses")
+        # All statuses in the project scope remain available.
+        self.assertIn("Expired", status_ids)
+        self.assertIn("Active", status_ids)
+
+    def test_allocation_updated_preserves_status_scoping(self):
+        """Allocation options should still reflect status selections."""
+        data = self._post_event("ALLOCATION_UPDATED", {
+            "allocations": [self.alloc3.pk],
+            "statuses": ["Expired"],
+        })
+        alloc_ids = self._ids(data, "allocations")
+        # Only expired allocations in the allocation options.
+        self.assertIn(self.alloc3.pk, alloc_ids)
+        self.assertNotIn(self.alloc1.pk, alloc_ids)
+        self.assertNotIn(self.alloc2.pk, alloc_ids)
+
+    def test_allocation_updated_does_not_narrow_projects(self):
+        """Upstream filters must not be narrowed."""
+        data = self._post_event("ALLOCATION_UPDATED", {
+            "allocations": [self.alloc1.pk],
+        })
+        proj_ids = self._ids(data, "projects")
+        # Both projects should still appear.
+        self.assertIn(self.proj1.pk, proj_ids)
+        self.assertIn(self.proj2.pk, proj_ids)
+
+    def test_resource_updated_narrows_allocations(self):
+        data = self._post_event("RESOURCE_UPDATED", {
+            "resources": [self.resource2.pk],
+        })
+        alloc_ids = self._ids(data, "allocations")
+        # Only alloc3 uses resource2
+        self.assertIn(self.alloc3.pk, alloc_ids)
+        self.assertNotIn(self.alloc1.pk, alloc_ids)
+        self.assertNotIn(self.alloc2.pk, alloc_ids)
+
+    def test_resource_updated_narrows_statuses(self):
+        data = self._post_event("RESOURCE_UPDATED", {
+            "resources": [self.resource2.pk],
+        })
+        status_ids = self._ids(data, "statuses")
+        self.assertIn("Expired", status_ids)
+        self.assertNotIn("Active", status_ids)
+
+    def test_resource_updated_does_not_narrow_projects(self):
+        data = self._post_event("RESOURCE_UPDATED", {
+            "resources": [self.resource2.pk],
+        })
+        proj_ids = self._ids(data, "projects")
+        self.assertIn(self.proj1.pk, proj_ids)
+        self.assertIn(self.proj2.pk, proj_ids)
+
+    def test_status_updated_narrows_allocations(self):
+        data = self._post_event("ALLOCATION_STATUS_UPDATED", {
+            "statuses": ["Expired"],
+        })
+        alloc_ids = self._ids(data, "allocations")
+        self.assertIn(self.alloc3.pk, alloc_ids)
+        self.assertNotIn(self.alloc1.pk, alloc_ids)
+        self.assertNotIn(self.alloc2.pk, alloc_ids)
+
+    def test_status_updated_narrows_resources(self):
+        data = self._post_event("ALLOCATION_STATUS_UPDATED", {
+            "statuses": ["Expired"],
+        })
+        res_ids = self._ids(data, "resources")
+        self.assertIn(self.resource2.pk, res_ids)
+        self.assertNotIn(self.resource.pk, res_ids)
+
+    def test_status_updated_does_not_narrow_projects(self):
+        data = self._post_event("ALLOCATION_STATUS_UPDATED", {
+            "statuses": ["Expired"],
+        })
+        proj_ids = self._ids(data, "projects")
+        self.assertIn(self.proj1.pk, proj_ids)
+        self.assertIn(self.proj2.pk, proj_ids)
+
+    def test_role_updated_is_leaf(self):
+        """Role is a leaf filter — nothing should be narrowed."""
+        data_all = self._post_event("ROLE_UPDATED")
+        data_pi  = self._post_event("ROLE_UPDATED", {
+            "roles": ["Principal Investigator"],
+        })
+        # All other filters should have the same options regardless of role.
+        for key in ("projects", "allocations", "departments", "resources", "statuses"):
+            self.assertEqual(
+                self._ids(data_all, key), self._ids(data_pi, key),
+                f"{key} options should not change on ROLE_UPDATED",
+            )
+
+    def test_stale_selection_pruned_from_selected(self):
+        """Selections that are no longer valid should be dropped."""
+        data = self._post_event("PROJECT_UPDATED", {
+            "projects": [self.proj1.pk],
+            # alloc2 belongs to proj2, not proj1 — should be pruned.
+            "allocations": [self.alloc1.pk, self.alloc2.pk],
+        })
+        self.assertIn(self.alloc1.pk, data["allocations"]["selected"])
+        self.assertNotIn(self.alloc2.pk, data["allocations"]["selected"])
+
+    def test_status_respects_upstream_project_scope(self):
+        """When both project and status are set, allocations should be
+        scoped to the project first, then filtered by status."""
+        data = self._post_event("ALLOCATION_STATUS_UPDATED", {
+            "projects": [self.proj1.pk],
+            "statuses": ["Active"],
+        })
+        alloc_ids = self._ids(data, "allocations")
+        # Only alloc1 is Active in proj1.
         self.assertIn(self.alloc1.pk, alloc_ids)
         self.assertNotIn(self.alloc2.pk, alloc_ids)
+        self.assertNotIn(self.alloc3.pk, alloc_ids)
+
+    def test_unknown_event_returns_400(self):
+        resp = self.client.post(
+            reverse("notifications:filter-options"),
+            json.dumps({"event": "BOGUS_EVENT", "selections": {}}),
+            content_type="application/json",
+        )
+        self.assertEqual(resp.status_code, 400)
+
+    def test_invalid_json_returns_400(self):
+        resp = self.client.post(
+            reverse("notifications:filter-options"),
+            "not json",
+            content_type="application/json",
+        )
+        self.assertEqual(resp.status_code, 400)
 
 
 class ValidateViewTest(NotificationIntegrationTestCase):
@@ -488,7 +724,7 @@ class ValidateViewTest(NotificationIntegrationTestCase):
 
     def test_validate_returns_counts(self):
         resp = self.client.post(
-            reverse("notifications:validate"),
+            reverse("notifications:api-validate"),
             {
                 "subject": "Hi {{maint_date}}",
                 "body": "Body",
@@ -504,7 +740,9 @@ def test_validate_returns_counts(self):
         self.assertIn("user_count", data)
         self.assertIn("email_count", data)
         self.assertIn("scope", data)
-        self.assertEqual(data["scope"], "user")
+        # Scope is elevated to at least "project" so counts match the
+        # preview modal (which always shows project-level tuples).
+        self.assertEqual(data["scope"], "project")
 
 
 class RecipientCountViewTest(NotificationIntegrationTestCase):
@@ -512,7 +750,7 @@ class RecipientCountViewTest(NotificationIntegrationTestCase):
 
     def test_preview_returns_paginated_recipients(self):
         resp = self.client.post(
-            reverse("notifications:recipient-count"),
+            reverse("notifications:api-recipient-count"),
             {
                 "preview": "true",
                 "subject": "Hi {{project_title}}",
@@ -539,30 +777,32 @@ def test_preview_returns_paginated_recipients(self):
 class ComposeViewTest(NotificationIntegrationTestCase):
     """Tests for the compose view POST (send action)."""
 
-    @patch("coldfront_notifications.views._dispatch_send")
-    def test_compose_send_creates_campaign(self, mock_dispatch):
-        resp = self.client.post(reverse("notifications:compose"), {
-            "action": "send",
-            "subject": "Hello {{maint_date}}",
-            "body": "Maintenance on {{maint_date}}.",
-            "sender": "rchelp@example.com",
-            "reply_to": "",
-            "template_id": "",
-            "filter_projects": json.dumps([]),
-            "filter_allocations": json.dumps([]),
-            "filter_resources": json.dumps([]),
-            "filter_departments": json.dumps([]),
-            "filter_statuses": json.dumps([]),
-            "filter_roles": json.dumps([]),
-            "extra_recipients": "",
-            "dedupe_users": "[]",
-        })
-        # Should redirect to campaign detail
-        self.assertEqual(resp.status_code, 302)
-        campaign = NotificationCampaign.objects.latest("created_at")
-        self.assertEqual(campaign.subject, "Hello {{maint_date}}")
-        self.assertEqual(campaign.status, NotificationCampaign.STATUS_QUEUED)
-        mock_dispatch.assert_called_once_with(campaign.pk)
+    def test_compose_send_creates_campaign(self):
+        # patch.object on the module directly to avoid __init__.py name shadowing
+        compose_mod = sys.modules["coldfront_notifications.views.compose"]
+        with patch.object(compose_mod, "_dispatch_send") as mock_dispatch:
+            resp = self.client.post(reverse("notifications:compose"), {
+                "action": "send",
+                "subject": "Hello {{maint_date}}",
+                "body": "Maintenance on {{maint_date}}.",
+                "sender": "rchelp@example.com",
+                "reply_to": "",
+                "template_id": "",
+                "filter_projects": json.dumps([]),
+                "filter_allocations": json.dumps([]),
+                "filter_resources": json.dumps([]),
+                "filter_departments": json.dumps([]),
+                "filter_statuses": json.dumps([]),
+                "filter_roles": json.dumps([]),
+                "extra_recipients": "",
+                "dedupe_users": "[]",
+            })
+            # Should redirect to campaign detail
+            self.assertEqual(resp.status_code, 302)
+            campaign = NotificationCampaign.objects.latest("created_at")
+            self.assertEqual(campaign.subject, "Hello {{maint_date}}")
+            self.assertEqual(campaign.status, NotificationCampaign.Status.QUEUED)
+            mock_dispatch.assert_called_once_with(campaign.pk)
 
 
 class StaffRequiredTest(NotificationIntegrationTestCase):
@@ -653,7 +893,7 @@ def test_progress_returns_json(self):
             subject="Test Progress",
             body="Body",
             sender="rchelp@example.com",
-            status=NotificationCampaign.STATUS_SENDING,
+            status=NotificationCampaign.Status.SENDING,
             recipient_count=10,
             delivered_count=5,
             failed_count=1,
@@ -794,13 +1034,13 @@ class SendNotificationCampaignTaskTest(NotificationIntegrationTestCase):
     """Tests for the send_notification_campaign task."""
 
     def test_send_campaign_delivers_emails(self):
-        from coldfront_notifications.tasks import send_notification_campaign
+        from coldfront_notifications.campaign_sender import send_notification_campaign
 
         campaign = NotificationCampaign.objects.create(
             subject="Hello {{maint_date}}",
             body="Maintenance on {{maint_date}}.",
             sender="rchelp@example.com",
-            status=NotificationCampaign.STATUS_QUEUED,
+            status=NotificationCampaign.Status.QUEUED,
             filters_snapshot={
                 "projects": [self.proj1.pk],
                 "allocations": [], "resources": [],
@@ -811,20 +1051,20 @@ def test_send_campaign_delivers_emails(self):
         send_notification_campaign(campaign.pk)
 
         campaign.refresh_from_db()
-        self.assertEqual(campaign.status, NotificationCampaign.STATUS_SENT)
+        self.assertEqual(campaign.status, NotificationCampaign.Status.SENT)
         self.assertGreater(campaign.delivered_count, 0)
         self.assertEqual(campaign.failed_count, 0)
         # Should have logs
         self.assertEqual(campaign.logs.count(), campaign.delivered_count)
 
     def test_send_campaign_fails_on_unknown_token(self):
-        from coldfront_notifications.tasks import send_notification_campaign
+        from coldfront_notifications.campaign_sender import send_notification_campaign
 
         campaign = NotificationCampaign.objects.create(
             subject="Hello {{nonexistent_token}}",
             body="Body",
             sender="rchelp@example.com",
-            status=NotificationCampaign.STATUS_QUEUED,
+            status=NotificationCampaign.Status.QUEUED,
             filters_snapshot={
                 "projects": [], "allocations": [], "resources": [],
                 "departments": [], "statuses": [], "roles": [],
@@ -834,17 +1074,17 @@ def test_send_campaign_fails_on_unknown_token(self):
         send_notification_campaign(campaign.pk)
 
         campaign.refresh_from_db()
-        self.assertEqual(campaign.status, NotificationCampaign.STATUS_FAILED)
+        self.assertEqual(campaign.status, NotificationCampaign.Status.FAILED)
 
     def test_send_campaign_fails_on_empty_recipients(self):
-        from coldfront_notifications.tasks import send_notification_campaign
+        from coldfront_notifications.campaign_sender import send_notification_campaign
 
         # Use an allocation status filter that matches nothing
         campaign = NotificationCampaign.objects.create(
             subject="Hello {{maint_date}}",
             body="Body with {{maint_date}}.",
             sender="rchelp@example.com",
-            status=NotificationCampaign.STATUS_QUEUED,
+            status=NotificationCampaign.Status.QUEUED,
             filters_snapshot={
                 "projects": [], "allocations": [], "resources": [],
                 "departments": [], "statuses": ["Expired"], "roles": [],
@@ -854,4 +1094,4 @@ def test_send_campaign_fails_on_empty_recipients(self):
         send_notification_campaign(campaign.pk)
 
         campaign.refresh_from_db()
-        self.assertEqual(campaign.status, NotificationCampaign.STATUS_FAILED)
+        self.assertEqual(campaign.status, NotificationCampaign.Status.FAILED)
diff --git a/coldfront_notifications/tests/test_resolvers.py b/coldfront_notifications/tests/test_resolvers.py
new file mode 100644
index 0000000..e24d7b8
--- /dev/null
+++ b/coldfront_notifications/tests/test_resolvers.py
@@ -0,0 +1,477 @@
+"""Unit tests for coldfront_notifications.resolvers."""
+import unittest
+from unittest.mock import MagicMock
+
+import coldfront_notifications.tests.django_setup  # noqa: F401
+
+from coldfront_notifications.template_variable_value_resolver import (
+    MissingValue,
+    ResolverContext,
+    format_value,
+    registry as resolver_registry,
+)
+
+
+class TestFormatValue(unittest.TestCase):
+    """Tests for format_value()."""
+
+    def test_valid_string(self):
+        self.assertEqual(format_value("hello"), "hello")
+
+    def test_strips_whitespace(self):
+        self.assertEqual(format_value("  world  "), "world")
+
+    def test_none_raises_missing(self):
+        with self.assertRaises(MissingValue):
+            format_value(None)
+
+    def test_empty_string_raises_missing(self):
+        with self.assertRaises(MissingValue):
+            format_value("")
+
+    def test_whitespace_only_raises_missing(self):
+        with self.assertRaises(MissingValue):
+            format_value("   ")
+
+    def test_coerces_to_string(self):
+        self.assertEqual(format_value(42), "42")
+
+
+class TestResolverContext(unittest.TestCase):
+    """Tests for ResolverContext typed accessors."""
+
+    def test_user_returns_value(self):
+        context = ResolverContext({"user": "alice"})
+        self.assertEqual(context.user, "alice")
+
+    def test_user_none_raises_missing(self):
+        context = ResolverContext({"user": None})
+        with self.assertRaises(MissingValue):
+            _ = context.user
+
+    def test_user_missing_key_raises_missing(self):
+        context = ResolverContext({})
+        with self.assertRaises(MissingValue):
+            _ = context.user
+
+    def test_project_returns_value(self):
+        context = ResolverContext({"project": "proj1"})
+        self.assertEqual(context.project, "proj1")
+
+    def test_project_none_raises_missing(self):
+        context = ResolverContext({"project": None})
+        with self.assertRaises(MissingValue):
+            _ = context.project
+
+    def test_allocation_returns_value(self):
+        context = ResolverContext({"allocation": "alloc1"})
+        self.assertEqual(context.allocation, "alloc1")
+
+    def test_allocation_none_raises_missing(self):
+        context = ResolverContext({"allocation": None})
+        with self.assertRaises(MissingValue):
+            _ = context.allocation
+
+    def test_primary_resource_returns_parent(self):
+        allocation = MagicMock()
+        allocation.get_parent_resource = "StorageA"
+        context = ResolverContext({"allocation": allocation})
+        self.assertEqual(context.primary_resource, "StorageA")
+
+    def test_primary_resource_none_raises_missing(self):
+        allocation = MagicMock()
+        allocation.get_parent_resource = None
+        context = ResolverContext({"allocation": allocation})
+        with self.assertRaises(MissingValue):
+            _ = context.primary_resource
+
+
+class TestResolve(unittest.TestCase):
+    """Tests for resolver_registry.resolve()."""
+
+    def test_valid_resolver_key_dispatches(self):
+        user = MagicMock()
+        user.username = "jdoe"
+        context = {"user": user, "project": None, "allocation": None}
+        result = resolver_registry.resolve("user.username", context)
+        self.assertEqual(result, "jdoe")
+
+    def test_unknown_key_raises_missing(self):
+        context = {"user": MagicMock(), "project": None, "allocation": None}
+        with self.assertRaises(MissingValue):
+            resolver_registry.resolve("nonexistent.key", context)
+
+    def test_attribute_error_raises_missing(self):
+        user = MagicMock(spec=[])
+        context = {"user": user, "project": None, "allocation": None}
+        with self.assertRaises(MissingValue):
+            resolver_registry.resolve("user.username", context)
+
+    def test_resolve_user_email(self):
+        user = MagicMock()
+        user.email = "alice@example.com"
+        context = {"user": user, "project": None, "allocation": None}
+        self.assertEqual(resolver_registry.resolve("user.email", context), "alice@example.com")
+
+    def test_resolve_user_full_name(self):
+        user = MagicMock()
+        user.get_full_name.return_value = "Jane Doe"
+        context = {"user": user, "project": None, "allocation": None}
+        self.assertEqual(resolver_registry.resolve("user.full_name", context), "Jane Doe")
+
+    def test_resolve_user_full_name_falls_back_to_username(self):
+        user = MagicMock()
+        user.get_full_name.return_value = ""
+        user.username = "jdoe"
+        context = {"user": user, "project": None, "allocation": None}
+        self.assertEqual(resolver_registry.resolve("user.full_name", context), "jdoe")
+
+
+class TestQueryChoicesConsistency(unittest.TestCase):
+    """Tests that resolver_registry.choices, resolver_registry.resolvers, and resolver_registry.scopes are consistent."""
+
+    def test_choices_keys_match_resolvers(self):
+        choice_keys = {key for key, _label, _group in resolver_registry.choices}
+        resolver_keys = set(resolver_registry.resolvers.keys())
+        self.assertEqual(choice_keys, resolver_keys)
+
+    def test_scopes_maps_every_choice(self):
+        choice_keys = {key for key, _label, _group in resolver_registry.choices}
+        scope_keys = set(resolver_registry.scopes.keys())
+        self.assertEqual(choice_keys, scope_keys)
+
+    def test_all_scopes_are_valid(self):
+        valid_scopes = {"user", "project", "allocation"}
+        for key, scope in resolver_registry.scopes.items():
+            self.assertIn(scope, valid_scopes, f"invalid scope for {key}")
+
+
+class TestScopeClassification(unittest.TestCase):
+    """Tests that resolver keys map to the correct scope."""
+
+    def test_user_scope(self):
+        self.assertEqual(resolver_registry.scopes["user.username"], "user")
+        self.assertEqual(resolver_registry.scopes["user.email"], "user")
+
+    def test_project_scope(self):
+        self.assertEqual(resolver_registry.scopes["project.title"], "project")
+        self.assertEqual(resolver_registry.scopes["project.pi.email"], "project")
+        self.assertEqual(resolver_registry.scopes["project.user_count"], "project")
+        self.assertEqual(resolver_registry.scopes["project.usernames"], "project")
+        self.assertEqual(resolver_registry.scopes["projectuser.role.name"], "project")
+
+    def test_allocation_scope(self):
+        self.assertEqual(resolver_registry.scopes["allocation.path"], "allocation")
+        self.assertEqual(resolver_registry.scopes["allocation.quota"], "allocation")
+        self.assertEqual(resolver_registry.scopes["allocation.usage"], "allocation")
+        self.assertEqual(resolver_registry.scopes["allocation.status.name"], "allocation")
+
+    def test_resource_scope(self):
+        self.assertEqual(resolver_registry.scopes["resource.name"], "allocation")
+
+
+class TestResolveExceptionHandling(unittest.TestCase):
+
+    def test_arbitrary_exception_becomes_missing_value(self):
+        user = MagicMock()
+        type(user).username = property(lambda self: (_ for _ in ()).throw(TypeError("boom")))
+        context = {"user": user, "project": None, "allocation": None}
+        with self.assertRaises(MissingValue):
+            resolver_registry.resolve("user.username", context)
+
+
+class TestProjectResolvers(unittest.TestCase):
+    """Tests for project-scoped resolvers."""
+
+    def _make_context(self, user=None, project=None, allocation=None):
+        return {
+            "user": user or MagicMock(),
+            "project": project,
+            "allocation": allocation,
+        }
+
+    def test_project_user_count(self):
+        project = MagicMock()
+        active_users_qs = MagicMock()
+        active_users_qs.count.return_value = 5
+        project.projectuser_set.filter.return_value = active_users_qs
+        context = self._make_context(project=project)
+        self.assertEqual(resolver_registry.resolve("project.user_count", context), "5")
+        project.projectuser_set.filter.assert_called_once_with(status__name="Active")
+
+    def test_project_user_count_zero_returns_zero(self):
+        project = MagicMock()
+        active_users_qs = MagicMock()
+        active_users_qs.count.return_value = 0
+        project.projectuser_set.filter.return_value = active_users_qs
+        context = self._make_context(project=project)
+        self.assertEqual(resolver_registry.resolve("project.user_count", context), "0")
+
+    def test_project_user_count_no_project_raises(self):
+        context = self._make_context(project=None)
+        with self.assertRaises(MissingValue):
+            resolver_registry.resolve("project.user_count", context)
+
+    def test_project_usernames(self):
+        project = MagicMock()
+        queryset = MagicMock()
+        queryset.order_by.return_value = queryset
+        queryset.values_list.return_value = ["alice", "bob", "carol"]
+        project.projectuser_set.filter.return_value = queryset
+        context = self._make_context(project=project)
+        self.assertEqual(resolver_registry.resolve("project.usernames", context), "alice, bob, carol")
+
+    def test_project_usernames_empty_raises(self):
+        project = MagicMock()
+        queryset = MagicMock()
+        queryset.order_by.return_value = queryset
+        queryset.values_list.return_value = []
+        project.projectuser_set.filter.return_value = queryset
+        context = self._make_context(project=project)
+        with self.assertRaises(MissingValue):
+            resolver_registry.resolve("project.usernames", context)
+
+
+class TestAllocationResolvers(unittest.TestCase):
+    """Tests for allocation-scoped resolvers."""
+
+    def _make_context(self, user=None, project=None, allocation=None):
+        return {
+            "user": user or MagicMock(),
+            "project": project,
+            "allocation": allocation,
+        }
+
+    def test_allocation_path(self):
+        allocation = MagicMock()
+        allocation.path = "/n/holylfs/LABS/mylab"
+        context = self._make_context(allocation=allocation)
+        self.assertEqual(resolver_registry.resolve("allocation.path", context), "/n/holylfs/LABS/mylab")
+
+    def test_allocation_path_empty_raises(self):
+        allocation = MagicMock()
+        allocation.path = ""
+        context = self._make_context(allocation=allocation)
+        with self.assertRaises(MissingValue):
+            resolver_registry.resolve("allocation.path", context)
+
+    def test_allocation_path_no_allocation_raises(self):
+        context = self._make_context(allocation=None)
+        with self.assertRaises(MissingValue):
+            resolver_registry.resolve("allocation.path", context)
+
+    def test_allocation_quota(self):
+        allocation = MagicMock()
+        allocation.get_attribute.return_value = 10.5
+        context = self._make_context(allocation=allocation)
+        self.assertEqual(resolver_registry.resolve("allocation.quota", context), "10.5")
+        allocation.get_attribute.assert_called_once_with("Storage Quota (TB)")
+
+    def test_allocation_quota_none_raises(self):
+        allocation = MagicMock()
+        allocation.get_attribute.return_value = None
+        context = self._make_context(allocation=allocation)
+        with self.assertRaises(MissingValue):
+            resolver_registry.resolve("allocation.quota", context)
+
+    def test_allocation_usage(self):
+        allocation = MagicMock()
+        allocation.usage = 7.3
+        context = self._make_context(allocation=allocation)
+        self.assertEqual(resolver_registry.resolve("allocation.usage", context), "7.3")
+
+    def test_allocation_usage_none_raises(self):
+        allocation = MagicMock()
+        allocation.usage = None
+        context = self._make_context(allocation=allocation)
+        with self.assertRaises(MissingValue):
+            resolver_registry.resolve("allocation.usage", context)
+
+    def test_removed_resolvers_raise(self):
+        removed_keys = (
+            "user.ifxid", "allocation.id", "project.description",
+            "allocation.description", "allocation.justification",
+            "resource.description",
+        )
+        for key in removed_keys:
+            context = self._make_context(project=MagicMock(), allocation=MagicMock())
+            with self.assertRaises(MissingValue, msg=f"{key} should not resolve"):
+                resolver_registry.resolve(key, context)
+
+
+class TestUserResolverGroup(unittest.TestCase):
+    """Tests for user-scoped resolvers not covered above."""
+
+    def _make_context(self, user=None):
+        return {"user": user or MagicMock(), "project": None, "allocation": None}
+
+    def test_resolve_first_name(self):
+        user = MagicMock()
+        user.first_name = "Jane"
+        self.assertEqual(resolver_registry.resolve("user.first_name", self._make_context(user)), "Jane")
+
+    def test_resolve_last_name(self):
+        user = MagicMock()
+        user.last_name = "Doe"
+        self.assertEqual(resolver_registry.resolve("user.last_name", self._make_context(user)), "Doe")
+
+
+class TestProjectResolverGroupExtended(unittest.TestCase):
+    """Tests for project resolvers not covered above."""
+
+    def _make_context(self, user=None, project=None, allocation=None):
+        return {"user": user or MagicMock(), "project": project, "allocation": allocation}
+
+    def test_resolve_title(self):
+        project = MagicMock()
+        project.title = "smith_lab"
+        self.assertEqual(resolver_registry.resolve("project.title", self._make_context(project=project)), "smith_lab")
+
+    def test_resolve_status(self):
+        project = MagicMock()
+        project.status.name = "Active"
+        self.assertEqual(resolver_registry.resolve("project.status.name", self._make_context(project=project)), "Active")
+
+    def test_resolve_field_of_science(self):
+        project = MagicMock()
+        project.field_of_science_id = 1
+        project.field_of_science.description = "Computer Science"
+        self.assertEqual(resolver_registry.resolve("project.field_of_science.description", self._make_context(project=project)), "Computer Science")
+
+    def test_resolve_field_of_science_missing_raises(self):
+        project = MagicMock()
+        project.field_of_science_id = None
+        with self.assertRaises(MissingValue):
+            resolver_registry.resolve("project.field_of_science.description", self._make_context(project=project))
+
+    def test_resolve_parent_title(self):
+        project = MagicMock()
+        project.parent_project_id = 1
+        project.parent_project.title = "Parent Lab"
+        self.assertEqual(resolver_registry.resolve("project.parent_project.title", self._make_context(project=project)), "Parent Lab")
+
+    def test_resolve_parent_title_missing_raises(self):
+        project = MagicMock()
+        project.parent_project_id = None
+        with self.assertRaises(MissingValue):
+            resolver_registry.resolve("project.parent_project.title", self._make_context(project=project))
+
+
+class TestPIResolverGroup(unittest.TestCase):
+    """Tests for PI resolvers."""
+
+    def _make_context(self, project=None):
+        return {"user": MagicMock(), "project": project, "allocation": None}
+
+    def test_resolve_pi_full_name(self):
+        project = MagicMock()
+        project.pi_id = 1
+        project.pi.get_full_name.return_value = "Dr. Smith"
+        self.assertEqual(resolver_registry.resolve("project.pi.full_name", self._make_context(project)), "Dr. Smith")
+
+    def test_resolve_pi_full_name_falls_back_to_username(self):
+        project = MagicMock()
+        project.pi_id = 1
+        project.pi.get_full_name.return_value = ""
+        project.pi.username = "smith"
+        self.assertEqual(resolver_registry.resolve("project.pi.full_name", self._make_context(project)), "smith")
+
+    def test_resolve_pi_email(self):
+        project = MagicMock()
+        project.pi_id = 1
+        project.pi.email = "smith@test.com"
+        self.assertEqual(resolver_registry.resolve("project.pi.email", self._make_context(project)), "smith@test.com")
+
+    def test_resolve_pi_username(self):
+        project = MagicMock()
+        project.pi_id = 1
+        project.pi.username = "smith"
+        self.assertEqual(resolver_registry.resolve("project.pi.username", self._make_context(project)), "smith")
+
+    def test_resolve_pi_missing_raises(self):
+        project = MagicMock()
+        project.pi_id = None
+        with self.assertRaises(MissingValue):
+            resolver_registry.resolve("project.pi.full_name", self._make_context(project))
+
+
+class TestResourceResolverGroup(unittest.TestCase):
+    """Tests for resource resolvers."""
+
+    def _make_context(self, allocation=None):
+        return {"user": MagicMock(), "project": MagicMock(), "allocation": allocation}
+
+    def test_resolve_resource_name(self):
+        allocation = MagicMock()
+        allocation.get_parent_resource.name = "bos-isilon/tier1"
+        self.assertEqual(resolver_registry.resolve("resource.name", self._make_context(allocation)), "bos-isilon/tier1")
+
+    def test_resolve_resource_type(self):
+        allocation = MagicMock()
+        allocation.get_parent_resource.resource_type_id = 1
+        allocation.get_parent_resource.resource_type.name = "Storage"
+        self.assertEqual(resolver_registry.resolve("resource.resource_type.name", self._make_context(allocation)), "Storage")
+
+    def test_resolve_resource_type_missing_raises(self):
+        allocation = MagicMock()
+        allocation.get_parent_resource.resource_type_id = None
+        with self.assertRaises(MissingValue):
+            resolver_registry.resolve("resource.resource_type.name", self._make_context(allocation))
+
+    def test_resolve_parent_resource_name(self):
+        allocation = MagicMock()
+        allocation.get_parent_resource.parent_resource_id = 1
+        allocation.get_parent_resource.parent_resource.name = "isilon"
+        self.assertEqual(resolver_registry.resolve("resource.parent_resource.name", self._make_context(allocation)), "isilon")
+
+    def test_resolve_parent_resource_missing_raises(self):
+        allocation = MagicMock()
+        allocation.get_parent_resource.parent_resource_id = None
+        with self.assertRaises(MissingValue):
+            resolver_registry.resolve("resource.parent_resource.name", self._make_context(allocation))
+
+    def test_resolve_names_joined(self):
+        allocation = MagicMock()
+        resource1 = MagicMock()
+        resource1.name = "storage-a"
+        resource2 = MagicMock()
+        resource2.name = "storage-b"
+        allocation.resources.all.return_value = [resource1, resource2]
+        self.assertEqual(resolver_registry.resolve("resource.names_joined", self._make_context(allocation)), "storage-a, storage-b")
+
+    def test_resolve_names_joined_empty_raises(self):
+        allocation = MagicMock()
+        allocation.resources.all.return_value = []
+        with self.assertRaises(MissingValue):
+            resolver_registry.resolve("resource.names_joined", self._make_context(allocation))
+
+
+class TestAllocationResolverGroupExtended(unittest.TestCase):
+    """Tests for allocation resolvers not covered above."""
+
+    def _make_context(self, allocation=None):
+        return {"user": MagicMock(), "project": MagicMock(), "allocation": allocation}
+
+    def test_resolve_quantity(self):
+        allocation = MagicMock()
+        allocation.quantity = 100
+        self.assertEqual(resolver_registry.resolve("allocation.quantity", self._make_context(allocation)), "100")
+
+    def test_resolve_start_date(self):
+        allocation = MagicMock()
+        allocation.start_date = "2026-01-01"
+        self.assertEqual(resolver_registry.resolve("allocation.start_date", self._make_context(allocation)), "2026-01-01")
+
+    def test_resolve_end_date(self):
+        allocation = MagicMock()
+        allocation.end_date = "2027-01-01"
+        self.assertEqual(resolver_registry.resolve("allocation.end_date", self._make_context(allocation)), "2027-01-01")
+
+    def test_resolve_status(self):
+        allocation = MagicMock()
+        allocation.status.name = "Active"
+        self.assertEqual(resolver_registry.resolve("allocation.status.name", self._make_context(allocation)), "Active")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/coldfront_notifications/tests/test_tasks_unit.py b/coldfront_notifications/tests/test_tasks_unit.py
new file mode 100644
index 0000000..eb07eec
--- /dev/null
+++ b/coldfront_notifications/tests/test_tasks_unit.py
@@ -0,0 +1,327 @@
+"""Unit tests for coldfront_notifications.campaign_sender (pure logic, no DB)."""
+import smtplib
+import unittest
+from unittest.mock import MagicMock, patch
+
+import coldfront_notifications.tests.django_setup  # noqa: F401
+
+from coldfront_notifications.template_variable_value_resolver import MissingValue
+from coldfront_notifications.campaign_sender import (
+    TemplateRenderer,
+    SmtpDelivery,
+)
+
+
+class TestTemplateRendererRender(unittest.TestCase):
+    """Tests for TemplateRenderer.render()."""
+
+    def setUp(self):
+        self.renderer = TemplateRenderer()
+
+    def test_no_tokens_passthrough(self):
+        self.assertEqual(self.renderer.render("Hello world", {}), "Hello world")
+
+    def test_one_token_substituted(self):
+        self.assertEqual(self.renderer.render("Hello {{name}}", {"name": "Alice"}), "Hello Alice")
+
+    def test_missing_key_left_as_literal(self):
+        self.assertEqual(self.renderer.render("Hello {{name}}", {}), "Hello {{name}}")
+
+    def test_multiple_tokens_all_substituted(self):
+        template = "Dear {{first}} {{last}}, welcome to {{org}}."
+        values = {"first": "Jane", "last": "Doe", "org": "FASRC"}
+        self.assertEqual(self.renderer.render(template, values), "Dear Jane Doe, welcome to FASRC.")
+
+    def test_repeated_token_substituted(self):
+        self.assertEqual(self.renderer.render("{{x}} and {{x}}", {"x": "hi"}), "hi and hi")
+
+    def test_none_template_returns_empty(self):
+        self.assertEqual(self.renderer.render(None, {"foo": "bar"}), "")
+
+    def test_empty_template(self):
+        self.assertEqual(self.renderer.render("", {"foo": "bar"}), "")
+
+    def test_partial_match(self):
+        result = self.renderer.render("{{a}} {{b}}", {"a": "X"})
+        self.assertEqual(result, "X {{b}}")
+
+
+class TestSmtpDeliveryIsTransient(unittest.TestCase):
+    """Tests for SmtpDelivery.is_transient_error()."""
+
+    def setUp(self):
+        self.delivery = SmtpDelivery()
+
+    def test_smtp_421_is_transient(self):
+        exception = smtplib.SMTPResponseException(421, "Service not available")
+        self.assertTrue(self.delivery.is_transient_error(exception))
+
+    def test_smtp_450_is_transient(self):
+        exception = smtplib.SMTPResponseException(450, "Mailbox busy")
+        self.assertTrue(self.delivery.is_transient_error(exception))
+
+    def test_smtp_499_is_transient(self):
+        exception = smtplib.SMTPResponseException(499, "Custom 4xx")
+        self.assertTrue(self.delivery.is_transient_error(exception))
+
+    def test_smtp_550_is_not_transient(self):
+        exception = smtplib.SMTPResponseException(550, "Mailbox not found")
+        self.assertFalse(self.delivery.is_transient_error(exception))
+
+    def test_smtp_500_is_not_transient(self):
+        exception = smtplib.SMTPResponseException(500, "Syntax error")
+        self.assertFalse(self.delivery.is_transient_error(exception))
+
+    def test_smtp_354_is_not_transient(self):
+        exception = smtplib.SMTPResponseException(354, "Start mail input")
+        self.assertFalse(self.delivery.is_transient_error(exception))
+
+    def test_smtp_server_disconnected_is_transient(self):
+        exception = smtplib.SMTPServerDisconnected("Connection lost")
+        self.assertTrue(self.delivery.is_transient_error(exception))
+
+    def test_connection_error_is_transient(self):
+        exception = ConnectionError("refused")
+        self.assertTrue(self.delivery.is_transient_error(exception))
+
+    def test_connection_reset_is_transient(self):
+        exception = ConnectionResetError("reset by peer")
+        self.assertTrue(self.delivery.is_transient_error(exception))
+
+    def test_value_error_is_not_transient(self):
+        exception = ValueError("bad value")
+        self.assertFalse(self.delivery.is_transient_error(exception))
+
+    def test_runtime_error_is_not_transient(self):
+        exception = RuntimeError("something broke")
+        self.assertFalse(self.delivery.is_transient_error(exception))
+
+
+class TestTemplateRendererBuildValues(unittest.TestCase):
+    """Tests for TemplateRenderer.build_values()."""
+
+    def setUp(self):
+        self.renderer = TemplateRenderer()
+
+    def _make_variable(self, source="manual", resolver_key="", value="", is_required=True):
+        variable = MagicMock()
+        variable.source = source
+        variable.Source.MANUAL = "manual"
+        variable.resolver_key = resolver_key
+        variable.value = value
+        variable.is_required = is_required
+        variable.key = "test_var"
+        return variable
+
+    def test_manual_variable_with_value(self):
+        variable = self._make_variable(value="2026-06-01")
+        result = self.renderer.build_values(["date"], {"date": variable}, {"user": MagicMock()})
+        self.assertEqual(result["date"], "2026-06-01")
+
+    def test_manual_variable_required_empty_raises(self):
+        variable = self._make_variable(value="", is_required=True)
+        with self.assertRaises(MissingValue):
+            self.renderer.build_values(["date"], {"date": variable}, {"user": MagicMock()})
+
+    def test_manual_variable_not_required_empty_returns_empty(self):
+        variable = self._make_variable(value="", is_required=False)
+        result = self.renderer.build_values(["date"], {"date": variable}, {"user": MagicMock()})
+        self.assertEqual(result["date"], "")
+
+    @patch("coldfront_notifications.campaign_sender.resolver_registry.resolve", return_value="alice@test.com")
+    def test_query_variable_delegates_to_resolver(self, mock_resolve):
+        variable = self._make_variable(source="query", resolver_key="user.email")
+        context = {"user": MagicMock(email="alice@test.com")}
+        result = self.renderer.build_values(["email"], {"email": variable}, context)
+        self.assertEqual(result["email"], "alice@test.com")
+
+    @patch("coldfront_notifications.campaign_sender.resolver_registry.resolve", side_effect=MissingValue("no value"))
+    def test_query_variable_resolution_failure_includes_context(self, _mock):
+        variable = self._make_variable(source="query", resolver_key="project.title")
+        user = MagicMock()
+        user.email = "bob@test.com"
+        with self.assertRaises(MissingValue) as error_context:
+            self.renderer.build_values(["title"], {"title": variable}, {"user": user})
+        self.assertIn("project.title", str(error_context.exception))
+        self.assertIn("bob@test.com", str(error_context.exception))
+
+    def test_unknown_token_raises(self):
+        with self.assertRaises(MissingValue) as error_context:
+            self.renderer.build_values(["nonexistent"], {}, {"user": MagicMock()})
+        self.assertIn("nonexistent", str(error_context.exception))
+
+
+class TestSmtpDeliverySendWithRetry(unittest.TestCase):
+    """Tests for SmtpDelivery.send_with_retry()."""
+
+    def setUp(self):
+        self.delivery = SmtpDelivery(max_retries=2, retry_delay=0.01)
+
+    def _make_message_and_connection(self):
+        message = MagicMock()
+        connection = MagicMock()
+        return message, connection
+
+    def test_success_first_try(self):
+        message, connection = self._make_message_and_connection()
+        result = self.delivery.send_with_retry(message, connection)
+        self.assertIsNone(result)
+        message.send.assert_called_once()
+
+    def test_permanent_error_returns_immediately(self):
+        message, connection = self._make_message_and_connection()
+        exception = smtplib.SMTPResponseException(550, "Mailbox not found")
+        message.send.side_effect = exception
+        result = self.delivery.send_with_retry(message, connection)
+        self.assertIs(result, exception)
+        self.assertEqual(message.send.call_count, 1)
+
+    @patch("coldfront_notifications.campaign_sender.time.sleep")
+    def test_transient_then_success(self, _mock_sleep):
+        message, connection = self._make_message_and_connection()
+        exception = smtplib.SMTPResponseException(421, "Try again")
+        message.send.side_effect = [exception, None]
+        result = self.delivery.send_with_retry(message, connection)
+        self.assertIsNone(result)
+        self.assertEqual(message.send.call_count, 2)
+
+    @patch("coldfront_notifications.campaign_sender.time.sleep")
+    def test_transient_exhausts_retries(self, _mock_sleep):
+        message, connection = self._make_message_and_connection()
+        exception = smtplib.SMTPResponseException(450, "Busy")
+        message.send.side_effect = exception
+        result = self.delivery.send_with_retry(message, connection)
+        self.assertIs(result, exception)
+        self.assertEqual(message.send.call_count, 3)
+
+    @patch("coldfront_notifications.campaign_sender.time.sleep")
+    def test_disconnect_reopens_connection(self, _mock_sleep):
+        message, connection = self._make_message_and_connection()
+        exception = smtplib.SMTPServerDisconnected("gone")
+        message.send.side_effect = [exception, None]
+        result = self.delivery.send_with_retry(message, connection)
+        self.assertIsNone(result)
+        connection.close.assert_called()
+        connection.open.assert_called()
+
+    @patch("coldfront_notifications.campaign_sender.time.sleep")
+    def test_reopen_failure_raises(self, _mock_sleep):
+        message, connection = self._make_message_and_connection()
+        message.send.side_effect = smtplib.SMTPServerDisconnected("gone")
+        reopen_exception = ConnectionError("cannot reopen")
+        connection.open.side_effect = reopen_exception
+        with self.assertRaises(ConnectionError):
+            self.delivery.send_with_retry(message, connection)
+
+    @patch("coldfront_notifications.campaign_sender.time.sleep")
+    def test_close_failure_is_swallowed(self, _mock_sleep):
+        """connection.close() throwing should not prevent the retry."""
+        message, connection = self._make_message_and_connection()
+        exception = smtplib.SMTPResponseException(421, "Try again")
+        message.send.side_effect = [exception, None]
+        connection.close.side_effect = OSError("close failed")
+        result = self.delivery.send_with_retry(message, connection)
+        self.assertIsNone(result)
+        self.assertEqual(message.send.call_count, 2)
+
+
+class TestSmtpDeliveryReopenConnection(unittest.TestCase):
+    """Tests for SmtpDelivery._reopen_connection()."""
+
+    def setUp(self):
+        self.delivery = SmtpDelivery()
+
+    def test_reopen_closes_and_opens(self):
+        connection = MagicMock()
+        self.delivery._reopen_connection(connection)
+        connection.close.assert_called_once()
+        connection.open.assert_called_once()
+
+    def test_close_failure_swallowed(self):
+        connection = MagicMock()
+        connection.close.side_effect = OSError("close failed")
+        self.delivery._reopen_connection(connection)
+        connection.open.assert_called_once()
+
+    def test_open_failure_raises(self):
+        connection = MagicMock()
+        connection.open.side_effect = ConnectionError("cannot open")
+        with self.assertRaises(ConnectionError):
+            self.delivery._reopen_connection(connection)
+
+
+class TestCampaignSender(unittest.TestCase):
+    """Tests for CampaignSender orchestration."""
+
+    @patch("coldfront_notifications.campaign_sender.NotificationVariable")
+    @patch("coldfront_notifications.campaign_sender.extract_tokens", return_value=["name"])
+    @patch("coldfront_notifications.campaign_sender.determine_scope", return_value="project")
+    @patch("coldfront_notifications.campaign_sender.RecipientResolver")
+    @patch("coldfront_notifications.campaign_sender.get_connection")
+    @patch("coldfront_notifications.campaign_sender.timezone")
+    @patch("coldfront_notifications.campaign_sender.NotificationLog")
+    def test_send_with_no_recipients_fails(self, mock_log, mock_tz, mock_conn,
+                                            mock_resolver_cls, mock_scope,
+                                            mock_tokens, mock_nv):
+        from coldfront_notifications.campaign_sender import CampaignSender
+
+        campaign = MagicMock()
+        campaign.filters_snapshot = {}
+        campaign.subject = "Hi {{name}}"
+        campaign.body = "Body"
+        campaign.logs.all.return_value.delete.return_value = None
+
+        mock_var = MagicMock()
+        mock_var.key = "name"
+        mock_nv.objects.filter.return_value = [mock_var]
+
+        mock_resolver = MagicMock()
+        mock_resolver.enumerate_deduped.return_value = iter([])
+        mock_resolver_cls.return_value = mock_resolver
+
+        sender = CampaignSender(campaign)
+        sender.send()
+
+        campaign.save.assert_called()
+        self.assertEqual(campaign.status, "failed")
+
+    def test_fail_sets_status_and_saves(self):
+        from coldfront_notifications.campaign_sender import CampaignSender
+
+        campaign = MagicMock()
+        sender = CampaignSender(campaign)
+        sender._fail("test reason")
+
+        self.assertEqual(campaign.status, "failed")
+        campaign.save.assert_called_once()
+
+
+class TestSendNotificationCampaignTask(unittest.TestCase):
+    """Tests for the celery task wrapper."""
+
+    @patch("coldfront_notifications.campaign_sender.NotificationCampaign")
+    def test_missing_campaign_logs_error(self, mock_model):
+        from coldfront_notifications.campaign_sender import send_notification_campaign
+        from coldfront_notifications.models import NotificationCampaign
+
+        mock_model.DoesNotExist = NotificationCampaign.DoesNotExist
+        mock_model.objects.get.side_effect = NotificationCampaign.DoesNotExist
+        send_notification_campaign(999)
+        mock_model.objects.get.assert_called_once_with(pk=999)
+
+    @patch("coldfront_notifications.campaign_sender.CampaignSender")
+    @patch("coldfront_notifications.campaign_sender.NotificationCampaign")
+    def test_delegates_to_campaign_sender(self, mock_model, mock_sender_cls):
+        from coldfront_notifications.campaign_sender import send_notification_campaign
+
+        campaign = MagicMock()
+        mock_model.objects.get.return_value = campaign
+
+        send_notification_campaign(1)
+
+        mock_sender_cls.assert_called_once_with(campaign)
+        mock_sender_cls.return_value.send.assert_called_once()
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/coldfront_notifications/tests/test_unit.py b/coldfront_notifications/tests/test_unit.py
deleted file mode 100644
index 8e805cd..0000000
--- a/coldfront_notifications/tests/test_unit.py
+++ /dev/null
@@ -1,726 +0,0 @@
-"""
-Unit tests for coldfront_notifications plugin.
-
-These tests exercise pure logic functions and do NOT require a database.
-Run with: python -m pytest coldfront_notifications/tests/test_unit.py
-"""
-import re
-import smtplib
-import unittest
-from unittest.mock import MagicMock, patch
-
-
-# ---------------------------------------------------------------------------
-# We need Django settings configured before importing plugin modules.
-# ---------------------------------------------------------------------------
-import django
-from django.conf import settings
-
-if not settings.configured:
-    settings.configure(
-        INSTALLED_APPS=[
-            "django.contrib.contenttypes",
-            "django.contrib.auth",
-            "coldfront_notifications",
-        ],
-        DATABASES={
-            "default": {
-                "ENGINE": "django.db.backends.sqlite3",
-                "NAME": ":memory:",
-            }
-        },
-        DEFAULT_AUTO_FIELD="django.db.models.BigAutoField",
-    )
-    django.setup()
-
-
-from coldfront_notifications.resolvers import (
-    QUERY_CHOICES,
-    QUERY_RESOLVERS,
-    QUERY_SCOPES,
-    MissingValue,
-    _fmt,
-    _need,
-    _primary_resource,
-    _scope_for,
-    resolve,
-)
-from coldfront_notifications.tasks import (
-    TOKEN_RE as TASKS_TOKEN_RE,
-    _build_values,
-    _is_transient,
-    _render,
-    _send_with_retry,
-)
-from coldfront_notifications.validators import (
-    TOKEN_RE as VALIDATORS_TOKEN_RE,
-    _extract_tokens,
-    _required_scope,
-    validate_campaign,
-)
-
-
-# ===========================================================================
-# resolvers.py tests
-# ===========================================================================
-
-
-class TestFmt(unittest.TestCase):
-    """Tests for _fmt()."""
-
-    def test_valid_string(self):
-        self.assertEqual(_fmt("hello"), "hello")
-
-    def test_strips_whitespace(self):
-        self.assertEqual(_fmt("  world  "), "world")
-
-    def test_none_raises_missing(self):
-        with self.assertRaises(MissingValue):
-            _fmt(None)
-
-    def test_empty_string_raises_missing(self):
-        with self.assertRaises(MissingValue):
-            _fmt("")
-
-    def test_whitespace_only_raises_missing(self):
-        with self.assertRaises(MissingValue):
-            _fmt("   ")
-
-    def test_coerces_to_string(self):
-        self.assertEqual(_fmt(42), "42")
-
-
-class TestNeed(unittest.TestCase):
-    """Tests for _need()."""
-
-    def test_present_key_returns_value(self):
-        ctx = {"user": "alice"}
-        self.assertEqual(_need(ctx, "user"), "alice")
-
-    def test_missing_key_raises_missing(self):
-        ctx = {"user": "alice"}
-        with self.assertRaises(MissingValue):
-            _need(ctx, "project")
-
-    def test_none_value_raises_missing(self):
-        ctx = {"project": None}
-        with self.assertRaises(MissingValue):
-            _need(ctx, "project")
-
-
-class TestResolve(unittest.TestCase):
-    """Tests for resolve()."""
-
-    def test_valid_resolver_key_dispatches(self):
-        user = MagicMock()
-        user.username = "jdoe"
-        ctx = {"user": user, "project": None, "allocation": None}
-        result = resolve("user.username", ctx)
-        self.assertEqual(result, "jdoe")
-
-    def test_unknown_key_raises_missing(self):
-        ctx = {"user": MagicMock(), "project": None, "allocation": None}
-        with self.assertRaises(MissingValue):
-            resolve("nonexistent.key", ctx)
-
-    def test_attribute_error_raises_missing(self):
-        # user with no .username attribute at all
-        user = MagicMock(spec=[])
-        ctx = {"user": user, "project": None, "allocation": None}
-        with self.assertRaises(MissingValue):
-            resolve("user.username", ctx)
-
-    def test_resolve_user_email(self):
-        user = MagicMock()
-        user.email = "alice@example.com"
-        ctx = {"user": user, "project": None, "allocation": None}
-        self.assertEqual(resolve("user.email", ctx), "alice@example.com")
-
-    def test_resolve_user_full_name(self):
-        user = MagicMock()
-        user.get_full_name.return_value = "Jane Doe"
-        ctx = {"user": user, "project": None, "allocation": None}
-        self.assertEqual(resolve("user.full_name", ctx), "Jane Doe")
-
-    def test_resolve_user_full_name_falls_back_to_username(self):
-        user = MagicMock()
-        user.get_full_name.return_value = ""
-        user.username = "jdoe"
-        ctx = {"user": user, "project": None, "allocation": None}
-        self.assertEqual(resolve("user.full_name", ctx), "jdoe")
-
-
-class TestQueryChoicesConsistency(unittest.TestCase):
-    """Tests that QUERY_CHOICES, QUERY_RESOLVERS, and QUERY_SCOPES are consistent."""
-
-    def test_choices_keys_match_resolvers(self):
-        choice_keys = {k for k, _label, _group in QUERY_CHOICES}
-        resolver_keys = set(QUERY_RESOLVERS.keys())
-        self.assertEqual(choice_keys, resolver_keys)
-
-    def test_scopes_maps_every_choice(self):
-        choice_keys = {k for k, _label, _group in QUERY_CHOICES}
-        scope_keys = set(QUERY_SCOPES.keys())
-        self.assertEqual(choice_keys, scope_keys)
-
-
-class TestScopeFor(unittest.TestCase):
-    """Tests for _scope_for() classification."""
-
-    def test_user_scope(self):
-        self.assertEqual(_scope_for("user.username"), "user")
-        self.assertEqual(_scope_for("user.email"), "user")
-        self.assertEqual(_scope_for("user.ifxid"), "user")
-
-    def test_project_scope(self):
-        self.assertEqual(_scope_for("project.title"), "project")
-        self.assertEqual(_scope_for("project.pi.email"), "project")
-        self.assertEqual(_scope_for("projectuser.role.name"), "project")
-
-    def test_allocation_scope(self):
-        self.assertEqual(_scope_for("allocation.id"), "allocation")
-        self.assertEqual(_scope_for("allocation.status.name"), "allocation")
-
-    def test_resource_scope(self):
-        self.assertEqual(_scope_for("resource.name"), "allocation")
-        self.assertEqual(_scope_for("resource.description"), "allocation")
-
-
-# ===========================================================================
-# validators.py tests
-# ===========================================================================
-
-
-class TestExtractTokens(unittest.TestCase):
-    """Tests for _extract_tokens()."""
-
-    def test_no_tokens(self):
-        self.assertEqual(_extract_tokens("Hello world", "No tokens here"), [])
-
-    def test_one_token_in_subject(self):
-        self.assertEqual(_extract_tokens("Hello {{name}}", "body"), ["name"])
-
-    def test_one_token_in_body(self):
-        self.assertEqual(_extract_tokens("subj", "Hello {{name}}"), ["name"])
-
-    def test_duplicates_deduped_order_preserved(self):
-        result = _extract_tokens("{{a}} {{b}} {{a}}", "{{b}} {{c}}")
-        self.assertEqual(result, ["a", "b", "c"])
-
-    def test_nested_braces_only_valid_matches(self):
-        # {{{foo}}} should still find 'foo' via \w+ inside {{ }}
-        result = _extract_tokens("{{{foo}}}", "")
-        self.assertEqual(result, ["foo"])
-
-    def test_invalid_tokens_ignored(self):
-        # Tokens with spaces or special chars shouldn't match \w+
-        result = _extract_tokens("{{hello world}} {{good}}", "")
-        self.assertEqual(result, ["good"])
-
-    def test_empty_strings(self):
-        self.assertEqual(_extract_tokens("", ""), [])
-
-    def test_none_subject(self):
-        self.assertEqual(_extract_tokens(None, "{{x}}"), ["x"])
-
-    def test_multiple_tokens(self):
-        result = _extract_tokens("{{first}} {{last}}", "Dear {{first}}")
-        self.assertEqual(result, ["first", "last"])
-
-
-class TestRequiredScope(unittest.TestCase):
-    """Tests for _required_scope()."""
-
-    def _make_var(self, resolver_key, source="query"):
-        v = MagicMock()
-        v.source = "query"
-        v.SOURCE_QUERY = "query"
-        v.resolver_key = resolver_key
-        return v
-
-    def _make_manual_var(self):
-        v = MagicMock()
-        v.source = "manual"
-        v.SOURCE_QUERY = "query"
-        v.resolver_key = None
-        return v
-
-    def test_no_vars_returns_user(self):
-        self.assertEqual(_required_scope([]), "user")
-
-    def test_only_user_vars_returns_user(self):
-        vars_list = [self._make_var("user.email"), self._make_var("user.username")]
-        self.assertEqual(_required_scope(vars_list), "user")
-
-    def test_project_vars_returns_project(self):
-        vars_list = [self._make_var("project.title")]
-        self.assertEqual(_required_scope(vars_list), "project")
-
-    def test_allocation_vars_returns_allocation(self):
-        vars_list = [self._make_var("allocation.id")]
-        self.assertEqual(_required_scope(vars_list), "allocation")
-
-    def test_resource_vars_returns_allocation(self):
-        vars_list = [self._make_var("resource.name")]
-        self.assertEqual(_required_scope(vars_list), "allocation")
-
-    def test_mix_highest_wins_allocation(self):
-        vars_list = [
-            self._make_var("user.email"),
-            self._make_var("project.title"),
-            self._make_var("allocation.id"),
-        ]
-        self.assertEqual(_required_scope(vars_list), "allocation")
-
-    def test_mix_project_beats_user(self):
-        vars_list = [
-            self._make_var("user.email"),
-            self._make_var("project.title"),
-        ]
-        self.assertEqual(_required_scope(vars_list), "project")
-
-    def test_manual_vars_dont_affect_scope(self):
-        vars_list = [self._make_manual_var()]
-        self.assertEqual(_required_scope(vars_list), "user")
-
-    def test_manual_with_allocation_still_allocation(self):
-        vars_list = [self._make_manual_var(), self._make_var("allocation.id")]
-        self.assertEqual(_required_scope(vars_list), "allocation")
-
-
-# ===========================================================================
-# tasks.py tests
-# ===========================================================================
-
-
-class TestRender(unittest.TestCase):
-    """Tests for _render()."""
-
-    def test_no_tokens_passthrough(self):
-        self.assertEqual(_render("Hello world", {}), "Hello world")
-
-    def test_one_token_substituted(self):
-        self.assertEqual(_render("Hello {{name}}", {"name": "Alice"}), "Hello Alice")
-
-    def test_missing_key_left_as_literal(self):
-        self.assertEqual(_render("Hello {{name}}", {}), "Hello {{name}}")
-
-    def test_multiple_tokens_all_substituted(self):
-        template = "Dear {{first}} {{last}}, welcome to {{org}}."
-        values = {"first": "Jane", "last": "Doe", "org": "FASRC"}
-        self.assertEqual(_render(template, values), "Dear Jane Doe, welcome to FASRC.")
-
-    def test_repeated_token_substituted(self):
-        self.assertEqual(
-            _render("{{x}} and {{x}}", {"x": "hi"}),
-            "hi and hi",
-        )
-
-    def test_none_template_returns_empty(self):
-        self.assertEqual(_render(None, {"foo": "bar"}), "")
-
-    def test_empty_template(self):
-        self.assertEqual(_render("", {"foo": "bar"}), "")
-
-    def test_partial_match(self):
-        # Only some tokens have values
-        result = _render("{{a}} {{b}}", {"a": "X"})
-        self.assertEqual(result, "X {{b}}")
-
-
-class TestIsTransient(unittest.TestCase):
-    """Tests for _is_transient()."""
-
-    def test_smtp_421_is_transient(self):
-        exc = smtplib.SMTPResponseException(421, "Service not available")
-        self.assertTrue(_is_transient(exc))
-
-    def test_smtp_450_is_transient(self):
-        exc = smtplib.SMTPResponseException(450, "Mailbox busy")
-        self.assertTrue(_is_transient(exc))
-
-    def test_smtp_499_is_transient(self):
-        exc = smtplib.SMTPResponseException(499, "Custom 4xx")
-        self.assertTrue(_is_transient(exc))
-
-    def test_smtp_550_is_not_transient(self):
-        exc = smtplib.SMTPResponseException(550, "Mailbox not found")
-        self.assertFalse(_is_transient(exc))
-
-    def test_smtp_500_is_not_transient(self):
-        exc = smtplib.SMTPResponseException(500, "Syntax error")
-        self.assertFalse(_is_transient(exc))
-
-    def test_smtp_354_is_not_transient(self):
-        exc = smtplib.SMTPResponseException(354, "Start mail input")
-        self.assertFalse(_is_transient(exc))
-
-    def test_smtp_server_disconnected_is_transient(self):
-        exc = smtplib.SMTPServerDisconnected("Connection lost")
-        self.assertTrue(_is_transient(exc))
-
-    def test_connection_error_is_transient(self):
-        exc = ConnectionError("refused")
-        self.assertTrue(_is_transient(exc))
-
-    def test_connection_reset_is_transient(self):
-        exc = ConnectionResetError("reset by peer")
-        self.assertTrue(_is_transient(exc))
-
-    def test_value_error_is_not_transient(self):
-        exc = ValueError("bad value")
-        self.assertFalse(_is_transient(exc))
-
-    def test_runtime_error_is_not_transient(self):
-        exc = RuntimeError("something broke")
-        self.assertFalse(_is_transient(exc))
-
-
-# ===========================================================================
-# conf.py tests
-# ===========================================================================
-
-
-class TestConfDefaults(unittest.TestCase):
-    """Tests that conf.py exports sensible defaults."""
-
-    def test_batch_size_default(self):
-        from coldfront_notifications.conf import BATCH_SIZE
-        self.assertEqual(BATCH_SIZE, 50)
-
-    def test_batch_delay_default(self):
-        from coldfront_notifications.conf import BATCH_DELAY
-        self.assertEqual(BATCH_DELAY, 2.0)
-
-    def test_max_retries_default(self):
-        from coldfront_notifications.conf import MAX_RETRIES
-        self.assertEqual(MAX_RETRIES, 3)
-
-    def test_retry_delay_default(self):
-        from coldfront_notifications.conf import RETRY_DELAY
-        self.assertEqual(RETRY_DELAY, 1.0)
-
-    def test_preview_page_size_default(self):
-        from coldfront_notifications.conf import PREVIEW_PAGE_SIZE
-        self.assertEqual(PREVIEW_PAGE_SIZE, 50)
-
-    def test_preview_render_limit_default(self):
-        from coldfront_notifications.conf import PREVIEW_RENDER_LIMIT
-        self.assertEqual(PREVIEW_RENDER_LIMIT, 10)
-
-
-# ===========================================================================
-# TOKEN_RE pattern tests (shared pattern used in tasks and validators)
-# ===========================================================================
-
-
-class TestTokenRegex(unittest.TestCase):
-    """Tests for the TOKEN_RE pattern used across modules."""
-
-    def test_matches_simple_token(self):
-        m = TASKS_TOKEN_RE.search("{{foo}}")
-        self.assertIsNotNone(m)
-        self.assertEqual(m.group(1), "foo")
-
-    def test_matches_underscore_token(self):
-        m = TASKS_TOKEN_RE.search("{{first_name}}")
-        self.assertIsNotNone(m)
-        self.assertEqual(m.group(1), "first_name")
-
-    def test_no_match_spaces(self):
-        m = TASKS_TOKEN_RE.search("{{ foo }}")
-        self.assertIsNone(m)
-
-    def test_no_match_special_chars(self):
-        m = TASKS_TOKEN_RE.search("{{foo-bar}}")
-        self.assertIsNone(m)
-
-    def test_validators_and_tasks_same_pattern(self):
-        self.assertEqual(TASKS_TOKEN_RE.pattern, VALIDATORS_TOKEN_RE.pattern)
-
-
-# ===========================================================================
-# resolvers.py — _primary_resource + resolve exception handling
-# ===========================================================================
-
-
-class TestPrimaryResource(unittest.TestCase):
-
-    def test_none_allocation_returns_none(self):
-        self.assertIsNone(_primary_resource(None))
-
-    def test_returns_get_parent_resource(self):
-        alloc = MagicMock()
-        alloc.get_parent_resource = "StorageA"
-        self.assertEqual(_primary_resource(alloc), "StorageA")
-
-
-class TestResolveExceptionHandling(unittest.TestCase):
-
-    def test_arbitrary_exception_becomes_missing_value(self):
-        """resolve() must not let random exceptions (TypeError, KeyError, etc.)
-        bubble up — they should all collapse to MissingValue."""
-        user = MagicMock()
-        # Force .username to raise TypeError when _fmt calls str()
-        type(user).username = property(lambda self: (_ for _ in ()).throw(TypeError("boom")))
-        ctx = {"user": user, "project": None, "allocation": None}
-        with self.assertRaises(MissingValue):
-            resolve("user.username", ctx)
-
-
-# ===========================================================================
-# tasks.py — _build_values
-# ===========================================================================
-
-
-class TestBuildValues(unittest.TestCase):
-
-    def _make_var(self, source="manual", resolver_key="", value="", is_required=True):
-        v = MagicMock()
-        v.source = source
-        v.SOURCE_MANUAL = "manual"
-        v.resolver_key = resolver_key
-        v.value = value
-        v.is_required = is_required
-        v.key = "test_var"
-        return v
-
-    def test_manual_var_with_value(self):
-        var = self._make_var(value="2026-06-01")
-        result = _build_values(["date"], {"date": var}, {"user": MagicMock()})
-        self.assertEqual(result["date"], "2026-06-01")
-
-    def test_manual_var_required_empty_raises(self):
-        var = self._make_var(value="", is_required=True)
-        with self.assertRaises(MissingValue):
-            _build_values(["date"], {"date": var}, {"user": MagicMock()})
-
-    def test_manual_var_not_required_empty_returns_empty(self):
-        var = self._make_var(value="", is_required=False)
-        result = _build_values(["date"], {"date": var}, {"user": MagicMock()})
-        self.assertEqual(result["date"], "")
-
-    @patch("coldfront_notifications.resolvers.resolve", return_value="alice@test.com")
-    def test_query_var_delegates_to_resolve(self, mock_resolve):
-        var = self._make_var(source="query", resolver_key="user.email")
-        ctx = {"user": MagicMock(email="alice@test.com")}
-        result = _build_values(["email"], {"email": var}, ctx)
-        self.assertEqual(result["email"], "alice@test.com")
-        mock_resolve.assert_called_once_with("user.email", ctx)
-
-    @patch("coldfront_notifications.resolvers.resolve", side_effect=MissingValue("no value"))
-    def test_query_var_resolution_failure_includes_context(self, _):
-        var = self._make_var(source="query", resolver_key="project.title")
-        user = MagicMock()
-        user.email = "bob@test.com"
-        with self.assertRaises(MissingValue) as ctx:
-            _build_values(["title"], {"title": var}, {"user": user})
-        self.assertIn("project.title", str(ctx.exception))
-        self.assertIn("bob@test.com", str(ctx.exception))
-
-    def test_unknown_token_raises(self):
-        with self.assertRaises(MissingValue) as ctx:
-            _build_values(["nonexistent"], {}, {"user": MagicMock()})
-        self.assertIn("nonexistent", str(ctx.exception))
-
-
-# ===========================================================================
-# tasks.py — _send_with_retry
-# ===========================================================================
-
-
-class TestSendWithRetry(unittest.TestCase):
-
-    def _make_msg_and_conn(self):
-        msg = MagicMock()
-        conn = MagicMock()
-        return msg, conn
-
-    def test_success_first_try(self):
-        msg, conn = self._make_msg_and_conn()
-        result = _send_with_retry(msg, conn, max_retries=2, base_delay=0)
-        self.assertIsNone(result)
-        msg.send.assert_called_once()
-
-    def test_permanent_error_returns_immediately(self):
-        msg, conn = self._make_msg_and_conn()
-        exc = smtplib.SMTPResponseException(550, "Mailbox not found")
-        msg.send.side_effect = exc
-        result = _send_with_retry(msg, conn, max_retries=2, base_delay=0)
-        self.assertIs(result, exc)
-        # Should NOT retry on 5xx
-        self.assertEqual(msg.send.call_count, 1)
-
-    @patch("coldfront_notifications.tasks.time.sleep")
-    def test_transient_then_success(self, mock_sleep):
-        msg, conn = self._make_msg_and_conn()
-        exc = smtplib.SMTPResponseException(421, "Try again")
-        msg.send.side_effect = [exc, None]  # fail once, then succeed
-        result = _send_with_retry(msg, conn, max_retries=2, base_delay=0.01)
-        self.assertIsNone(result)
-        self.assertEqual(msg.send.call_count, 2)
-
-    @patch("coldfront_notifications.tasks.time.sleep")
-    def test_transient_exhausts_retries(self, mock_sleep):
-        msg, conn = self._make_msg_and_conn()
-        exc = smtplib.SMTPResponseException(450, "Busy")
-        msg.send.side_effect = exc  # always fails
-        result = _send_with_retry(msg, conn, max_retries=2, base_delay=0.01)
-        self.assertIs(result, exc)
-        # 1 initial + 2 retries = 3 attempts
-        self.assertEqual(msg.send.call_count, 3)
-
-    @patch("coldfront_notifications.tasks.time.sleep")
-    def test_disconnect_reopens_connection(self, mock_sleep):
-        msg, conn = self._make_msg_and_conn()
-        exc = smtplib.SMTPServerDisconnected("gone")
-        msg.send.side_effect = [exc, None]
-        result = _send_with_retry(msg, conn, max_retries=2, base_delay=0.01)
-        self.assertIsNone(result)
-        conn.close.assert_called()
-        conn.open.assert_called()
-
-    @patch("coldfront_notifications.tasks.time.sleep")
-    def test_reopen_failure_returns_exception(self, mock_sleep):
-        msg, conn = self._make_msg_and_conn()
-        msg.send.side_effect = smtplib.SMTPServerDisconnected("gone")
-        reopen_exc = ConnectionError("cannot reopen")
-        conn.open.side_effect = reopen_exc
-        result = _send_with_retry(msg, conn, max_retries=2, base_delay=0.01)
-        self.assertIs(result, reopen_exc)
-
-    @patch("coldfront_notifications.tasks.time.sleep")
-    def test_close_failure_is_swallowed(self, mock_sleep):
-        """connection.close() throwing should not prevent the retry."""
-        msg, conn = self._make_msg_and_conn()
-        exc = smtplib.SMTPResponseException(421, "Try again")
-        msg.send.side_effect = [exc, None]
-        conn.close.side_effect = OSError("close failed")
-        result = _send_with_retry(msg, conn, max_retries=2, base_delay=0.01)
-        self.assertIsNone(result)
-        self.assertEqual(msg.send.call_count, 2)
-
-
-# ===========================================================================
-# validators.py — validate_campaign
-# ===========================================================================
-
-
-class TestValidateCampaign(unittest.TestCase):
-
-    PATCH_ENUM = "coldfront_notifications.validators.enumerate_recipients_deduped"
-    PATCH_RESOLVE = "coldfront_notifications.validators.resolve"
-
-    def _patch_nv_objects(self, return_value):
-        """Patch the local `from .models import NotificationVariable` inside
-        validate_campaign so .objects.filter() returns our fake vars."""
-        patcher = patch(
-            "coldfront_notifications.models.NotificationVariable.objects"
-        )
-        mock_objects = patcher.start()
-        mock_objects.filter.return_value = return_value
-        self.addCleanup(patcher.stop)
-
-    def _make_var(self, key, source="query", resolver_key="user.email",
-                  value="", is_required=True):
-        v = MagicMock()
-        v.key = key
-        v.source = source
-        v.SOURCE_QUERY = "query"
-        v.SOURCE_MANUAL = "manual"
-        v.resolver_key = resolver_key
-        v.value = value
-        v.is_required = is_required
-        return v
-
-    def _make_user(self, pk, username, email):
-        u = MagicMock()
-        u.pk = pk
-        u.username = username
-        u.email = email
-        return u
-
-    @patch(PATCH_ENUM)
-    def test_all_tokens_resolve_cleanly(self, mock_enum):
-        var = self._make_var("name", resolver_key="user.full_name")
-        self._patch_nv_objects([var])
-
-        user = self._make_user(1, "alice", "alice@test.com")
-        mock_enum.return_value = [(user, None, None)]
-
-        with patch(self.PATCH_RESOLVE, return_value="Alice"):
-            result = validate_campaign("Hi {{name}}", "body", {}, {})
-
-        self.assertEqual(result["errors"], [])
-        self.assertEqual(result["missing_tokens"], [])
-        self.assertEqual(result["user_count"], 1)
-        self.assertEqual(result["email_count"], 1)
-
-    @patch(PATCH_ENUM)
-    def test_unknown_token_in_missing_tokens(self, mock_enum):
-        self._patch_nv_objects([])  # no vars match
-        mock_enum.return_value = []
-        result = validate_campaign("Hi {{bogus}}", "body", {}, {})
-        self.assertIn("bogus", result["missing_tokens"])
-
-    @patch(PATCH_ENUM)
-    def test_manual_var_empty_value_reported(self, mock_enum):
-        var = self._make_var("date", source="manual", value="", is_required=True)
-        self._patch_nv_objects([var])
-
-        user = self._make_user(1, "bob", "bob@test.com")
-        mock_enum.return_value = [(user, None, None)]
-
-        result = validate_campaign("Due {{date}}", "body", {}, {})
-        self.assertEqual(len(result["errors"]), 1)
-        self.assertEqual(result["errors"][0]["token"], "date")
-
-    @patch(PATCH_ENUM)
-    def test_query_var_resolution_failure_reported(self, mock_enum):
-        var = self._make_var("title", resolver_key="project.title")
-        self._patch_nv_objects([var])
-
-        user = self._make_user(1, "carol", "carol@test.com")
-        mock_enum.return_value = [(user, None, None)]
-
-        with patch(self.PATCH_RESOLVE, side_effect=MissingValue()):
-            result = validate_campaign("Re: {{title}}", "body", {}, {})
-
-        self.assertEqual(len(result["errors"]), 1)
-        self.assertIn("project.title", result["errors"][0]["reason"])
-
-    @patch(PATCH_ENUM)
-    def test_multi_email_users_reported(self, mock_enum):
-        var = self._make_var("ptitle", resolver_key="project.title")
-        self._patch_nv_objects([var])
-
-        user = self._make_user(1, "alice", "alice@test.com")
-        proj1, proj2 = MagicMock(), MagicMock()
-        # alice appears on 2 projects → 2 tuples
-        mock_enum.return_value = [(user, proj1, None), (user, proj2, None)]
-
-        with patch(self.PATCH_RESOLVE, return_value="Proj"):
-            result = validate_campaign("{{ptitle}}", "body", {}, {})
-
-        self.assertEqual(result["email_count"], 2)
-        self.assertEqual(result["user_count"], 1)
-        self.assertEqual(len(result["multi_emails"]), 1)
-        self.assertEqual(result["multi_emails"][0]["username"], "alice")
-        self.assertEqual(result["multi_emails"][0]["count"], 2)
-
-    @patch(PATCH_ENUM)
-    def test_scope_propagated_correctly(self, mock_enum):
-        var = self._make_var("aid", resolver_key="allocation.id")
-        self._patch_nv_objects([var])
-        mock_enum.return_value = []
-
-        result = validate_campaign("Alloc {{aid}}", "body", {}, {})
-        self.assertEqual(result["scope"], "allocation")
-        # Verify enumerate was called with allocation scope
-        mock_enum.assert_called_once()
-        call_args = mock_enum.call_args
-        self.assertEqual(call_args[0][1], "allocation")
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/coldfront_notifications/tests/test_validators.py b/coldfront_notifications/tests/test_validators.py
new file mode 100644
index 0000000..876dadb
--- /dev/null
+++ b/coldfront_notifications/tests/test_validators.py
@@ -0,0 +1,251 @@
+"""Unit tests for coldfront_notifications.notification_validator."""
+import unittest
+from unittest.mock import MagicMock, patch
+
+import coldfront_notifications.tests.django_setup  # noqa: F401
+
+from coldfront_notifications.template_variable_value_resolver import MissingValue
+from coldfront_notifications.campaign_sender import TOKEN_PATTERN as TASKS_TOKEN_RE
+from coldfront_notifications.notification_validator import (
+    TOKEN_PATTERN as VALIDATORS_TOKEN_RE,
+    NotificationValidator,
+    extract_tokens,
+    determine_scope,
+)
+
+
+class TestExtractTokens(unittest.TestCase):
+    """Tests for extract_tokens()."""
+
+    def test_no_tokens(self):
+        self.assertEqual(extract_tokens("Hello world", "No tokens here"), [])
+
+    def test_one_token_in_subject(self):
+        self.assertEqual(extract_tokens("Hello {{name}}", "body"), ["name"])
+
+    def test_one_token_in_body(self):
+        self.assertEqual(extract_tokens("subj", "Hello {{name}}"), ["name"])
+
+    def test_duplicates_deduped_order_preserved(self):
+        result = extract_tokens("{{a}} {{b}} {{a}}", "{{b}} {{c}}")
+        self.assertEqual(result, ["a", "b", "c"])
+
+    def test_nested_braces_only_valid_matches(self):
+        result = extract_tokens("{{{foo}}}", "")
+        self.assertEqual(result, ["foo"])
+
+    def test_invalid_tokens_ignored(self):
+        result = extract_tokens("{{hello world}} {{good}}", "")
+        self.assertEqual(result, ["good"])
+
+    def test_empty_strings(self):
+        self.assertEqual(extract_tokens("", ""), [])
+
+    def test_none_subject(self):
+        self.assertEqual(extract_tokens(None, "{{x}}"), ["x"])
+
+    def test_multiple_tokens(self):
+        result = extract_tokens("{{first}} {{last}}", "Dear {{first}}")
+        self.assertEqual(result, ["first", "last"])
+
+
+class TestDetermineScope(unittest.TestCase):
+    """Tests for determine_scope()."""
+
+    def _make_var(self, resolver_key, source="query"):
+        variable = MagicMock()
+        variable.source = "query"
+        variable.Source.QUERY = "query"
+        variable.resolver_key = resolver_key
+        return variable
+
+    def _make_manual_var(self):
+        variable = MagicMock()
+        variable.source = "manual"
+        variable.Source.QUERY = "query"
+        variable.resolver_key = None
+        return variable
+
+    def test_no_vars_returns_user(self):
+        self.assertEqual(determine_scope([]), "user")
+
+    def test_only_user_vars_returns_user(self):
+        variables = [self._make_var("user.email"), self._make_var("user.username")]
+        self.assertEqual(determine_scope(variables), "user")
+
+    def test_project_vars_returns_project(self):
+        variables = [self._make_var("project.title")]
+        self.assertEqual(determine_scope(variables), "project")
+
+    def test_allocation_vars_returns_allocation(self):
+        variables = [self._make_var("allocation.status.name")]
+        self.assertEqual(determine_scope(variables), "allocation")
+
+    def test_resource_vars_returns_allocation(self):
+        variables = [self._make_var("resource.name")]
+        self.assertEqual(determine_scope(variables), "allocation")
+
+    def test_mix_highest_wins_allocation(self):
+        variables = [
+            self._make_var("user.email"),
+            self._make_var("project.title"),
+            self._make_var("allocation.status.name"),
+        ]
+        self.assertEqual(determine_scope(variables), "allocation")
+
+    def test_mix_project_beats_user(self):
+        variables = [
+            self._make_var("user.email"),
+            self._make_var("project.title"),
+        ]
+        self.assertEqual(determine_scope(variables), "project")
+
+    def test_manual_vars_dont_affect_scope(self):
+        variables = [self._make_manual_var()]
+        self.assertEqual(determine_scope(variables), "user")
+
+    def test_manual_with_allocation_still_allocation(self):
+        variables = [self._make_manual_var(), self._make_var("allocation.status.name")]
+        self.assertEqual(determine_scope(variables), "allocation")
+
+
+class TestTokenRegex(unittest.TestCase):
+    """Tests for the TOKEN_PATTERN used across modules."""
+
+    def test_matches_simple_token(self):
+        match = TASKS_TOKEN_RE.search("{{foo}}")
+        self.assertIsNotNone(match)
+        self.assertEqual(match.group(1), "foo")
+
+    def test_matches_underscore_token(self):
+        match = TASKS_TOKEN_RE.search("{{first_name}}")
+        self.assertIsNotNone(match)
+        self.assertEqual(match.group(1), "first_name")
+
+    def test_no_match_spaces(self):
+        match = TASKS_TOKEN_RE.search("{{ foo }}")
+        self.assertIsNone(match)
+
+    def test_no_match_special_chars(self):
+        match = TASKS_TOKEN_RE.search("{{foo-bar}}")
+        self.assertIsNone(match)
+
+    def test_validators_and_tasks_same_pattern(self):
+        self.assertEqual(TASKS_TOKEN_RE.pattern, VALIDATORS_TOKEN_RE.pattern)
+
+
+class TestNotificationValidator(unittest.TestCase):
+
+    PATCH_RESOLVER = "coldfront_notifications.notification_validator.RecipientResolver"
+    PATCH_RESOLVE = "coldfront_notifications.notification_validator.resolver_registry.resolve"
+
+    def _patch_nv_objects(self, return_value):
+        patcher = patch(
+            "coldfront_notifications.models.NotificationVariable.objects"
+        )
+        mock_objects = patcher.start()
+        mock_objects.filter.return_value = return_value
+        self.addCleanup(patcher.stop)
+
+    def _make_var(self, key, source="query", resolver_key="user.email",
+                  value="", is_required=True):
+        variable = MagicMock()
+        variable.key = key
+        variable.source = source
+        variable.Source.QUERY = "query"
+        variable.Source.MANUAL = "manual"
+        variable.resolver_key = resolver_key
+        variable.value = value
+        variable.is_required = is_required
+        return variable
+
+    def _make_user(self, pk, username, email):
+        user = MagicMock()
+        user.pk = pk
+        user.username = username
+        user.email = email
+        return user
+
+    def _patch_recipient_resolver(self, tuples):
+        mock_resolver_instance = MagicMock()
+        mock_resolver_instance.enumerate_deduped.return_value = iter(tuples)
+        patcher = patch(
+            self.PATCH_RESOLVER,
+            return_value=mock_resolver_instance,
+        )
+        patcher.start()
+        self.addCleanup(patcher.stop)
+
+    def test_all_tokens_resolve_cleanly(self):
+        variable = self._make_var("name", resolver_key="user.full_name")
+        self._patch_nv_objects([variable])
+
+        user = self._make_user(1, "alice", "alice@test.com")
+        self._patch_recipient_resolver([(user, None, None)])
+
+        with patch(self.PATCH_RESOLVE, return_value="Alice"):
+            result = NotificationValidator("Hi {{name}}", "body", {}).validate()
+
+        self.assertEqual(result["errors"], [])
+        self.assertEqual(result["missing_tokens"], [])
+        self.assertEqual(result["user_count"], 1)
+        self.assertEqual(result["email_count"], 1)
+
+    def test_unknown_token_in_missing_tokens(self):
+        self._patch_nv_objects([])
+        self._patch_recipient_resolver([])
+        result = NotificationValidator("Hi {{bogus}}", "body", {}).validate()
+        self.assertIn("bogus", result["missing_tokens"])
+
+    def test_manual_var_empty_value_reported(self):
+        variable = self._make_var("date", source="manual", value="", is_required=True)
+        self._patch_nv_objects([variable])
+
+        user = self._make_user(1, "bob", "bob@test.com")
+        self._patch_recipient_resolver([(user, None, None)])
+
+        result = NotificationValidator("Due {{date}}", "body", {}).validate()
+        self.assertEqual(len(result["errors"]), 1)
+        self.assertEqual(result["errors"][0]["token"], "date")
+
+    def test_query_var_resolution_failure_reported(self):
+        variable = self._make_var("title", resolver_key="project.title")
+        self._patch_nv_objects([variable])
+
+        user = self._make_user(1, "carol", "carol@test.com")
+        self._patch_recipient_resolver([(user, None, None)])
+
+        with patch(self.PATCH_RESOLVE, side_effect=MissingValue()):
+            result = NotificationValidator("Re: {{title}}", "body", {}).validate()
+
+        self.assertEqual(len(result["errors"]), 1)
+        self.assertIn("project.title", result["errors"][0]["reason"])
+
+    def test_multi_email_users_reported(self):
+        variable = self._make_var("ptitle", resolver_key="project.title")
+        self._patch_nv_objects([variable])
+
+        user = self._make_user(1, "alice", "alice@test.com")
+        project_1, project_2 = MagicMock(), MagicMock()
+        self._patch_recipient_resolver([(user, project_1, None), (user, project_2, None)])
+
+        with patch(self.PATCH_RESOLVE, return_value="Proj"):
+            result = NotificationValidator("{{ptitle}}", "body", {}).validate()
+
+        self.assertEqual(result["email_count"], 2)
+        self.assertEqual(result["user_count"], 1)
+        self.assertEqual(len(result["multi_emails"]), 1)
+        self.assertEqual(result["multi_emails"][0]["username"], "alice")
+        self.assertEqual(result["multi_emails"][0]["count"], 2)
+
+    def test_scope_propagated_correctly(self):
+        variable = self._make_var("aid", resolver_key="allocation.status.name")
+        self._patch_nv_objects([variable])
+        self._patch_recipient_resolver([])
+
+        result = NotificationValidator("Alloc {{aid}}", "body", {}).validate()
+        self.assertEqual(result["scope"], "allocation")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/coldfront_notifications/urls.py b/coldfront_notifications/urls.py
index ef2ce13..4056d35 100644
--- a/coldfront_notifications/urls.py
+++ b/coldfront_notifications/urls.py
@@ -4,29 +4,147 @@
 app_name = "notifications"
 
 urlpatterns = [
-    path("",                          views.dashboard,            name="dashboard"),
-    path("compose/",                  views.compose,              name="compose"),
-    path("campaigns/",                views.campaign_list,        name="campaign-list"),
-    path("campaigns/<int:pk>/",       views.campaign_detail,      name="campaign-detail"),
-    path("campaigns/<int:pk>/resend/",views.resend_failed,        name="resend"),
-    path("campaigns/<int:pk>/resend-compose/",views.resend_compose, name="resend-compose"),
-    path("campaigns/<int:pk>/progress/",views.campaign_progress, name="campaign-progress"),
-    path("templates/",                views.template_list,        name="template-list"),
-    path("templates/new/",            views.template_form,        name="template-create"),
-    path("templates/<int:pk>/edit/",  views.template_form,        name="template-update"),
-    path("templates/<int:pk>/json/",  views.template_json,        name="template-json"),
-    path("templates/<int:pk>/delete/",views.template_delete,      name="template-delete"),
-    path("variables/",                views.variable_list,        name="variable-list"),
-    path("variables/new/",            views.variable_form,        name="variable-create"),
-    path("variables/<int:pk>/edit/",  views.variable_form,        name="variable-update"),
-    path("variables/<int:pk>/delete/",views.variable_delete,      name="variable-delete"),
-    path("settings/",                 views.settings_view,        name="settings"),
-    path("settings/senders/new/",     views.sender_form,          name="sender-create"),
-    path("settings/senders/<int:pk>/edit/", views.sender_form,    name="sender-update"),
-    path("settings/senders/<int:pk>/delete/", views.sender_delete,name="sender-delete"),
-    path("recipient-count/",          views.recipient_count_view, name="recipient-count"),
-    path("filter-options/",           views.filter_options,       name="filter-options"),
-    path("variables.json",            views.variables_view,       name="variables"),
-    path("validate/",                 views.validate_view,        name="validate"),
-    path("preview-render/",           views.preview_render_view,  name="preview-render"),
+    # Dashboard
+    path(
+        "",
+        views.DashboardView.as_view(),
+        name="dashboard",
+    ),
+
+    # Compose
+    path(
+        "compose/",
+        views.ComposeView.as_view(),
+        name="compose",
+    ),
+
+    # Campaigns
+    path(
+        "campaigns/",
+        views.CampaignListView.as_view(),
+        name="campaign-list",
+    ),
+    path(
+        "campaigns/<int:pk>/",
+        views.CampaignDetailView.as_view(),
+        name="campaign-detail",
+    ),
+    path(
+        "campaigns/<int:pk>/delete-draft/",
+        views.DraftDeleteView.as_view(),
+        name="draft-delete",
+    ),
+    path(
+        "campaigns/<int:pk>/resend/",
+        views.ResendFailedView.as_view(),
+        name="resend",
+    ),
+    path(
+        "campaigns/<int:pk>/resend-compose/",
+        views.ResendComposeView.as_view(),
+        name="resend-compose",
+    ),
+    path(
+        "campaigns/<int:pk>/progress/",
+        views.CampaignProgressView.as_view(),
+        name="campaign-progress",
+    ),
+
+    # Templates
+    path(
+        "templates/",
+        views.TemplateListView.as_view(),
+        name="template-list",
+    ),
+    path(
+        "templates/new/",
+        views.TemplateFormView.as_view(),
+        name="template-create",
+    ),
+    path(
+        "templates/<int:pk>/edit/",
+        views.TemplateFormView.as_view(),
+        name="template-update",
+    ),
+    path(
+        "templates/<int:pk>/json/",
+        views.TemplateJsonView.as_view(),
+        name="template-json",
+    ),
+    path(
+        "templates/<int:pk>/delete/",
+        views.TemplateDeleteView.as_view(),
+        name="template-delete",
+    ),
+
+    # Variables
+    path(
+        "variables/",
+        views.VariableListView.as_view(),
+        name="variable-list",
+    ),
+    path(
+        "variables/new/",
+        views.VariableFormView.as_view(),
+        name="variable-create",
+    ),
+    path(
+        "variables/<int:pk>/edit/",
+        views.VariableFormView.as_view(),
+        name="variable-update",
+    ),
+    path(
+        "variables/<int:pk>/delete/",
+        views.VariableDeleteView.as_view(),
+        name="variable-delete",
+    ),
+
+    # Settings & senders
+    path(
+        "settings/",
+        views.SettingsView.as_view(),
+        name="settings",
+    ),
+    path(
+        "settings/senders/new/",
+        views.SenderFormView.as_view(),
+        name="sender-create",
+    ),
+    path(
+        "settings/senders/<int:pk>/edit/",
+        views.SenderFormView.as_view(),
+        name="sender-update",
+    ),
+    path(
+        "settings/senders/<int:pk>/delete/",
+        views.SenderDeleteView.as_view(),
+        name="sender-delete",
+    ),
+
+    # API endpoints
+    path(
+        "api/recipient-count/",
+        views.RecipientCountView.as_view(),
+        name="api-recipient-count",
+    ),
+    path(
+        "api/variables/",
+        views.VariablesJsonView.as_view(),
+        name="api-variables",
+    ),
+    path(
+        "api/validate/",
+        views.ValidateView.as_view(),
+        name="api-validate",
+    ),
+    path(
+        "api/preview-render/",
+        views.PreviewRenderView.as_view(),
+        name="api-preview-render",
+    ),
+    path(
+        "api/draft/save/",
+        views.DraftSaveView.as_view(),
+        name="api-draft-save",
+    ),
 ]
diff --git a/coldfront_notifications/utils.py b/coldfront_notifications/utils.py
deleted file mode 100644
index 7f05598..0000000
--- a/coldfront_notifications/utils.py
+++ /dev/null
@@ -1,187 +0,0 @@
-"""
-Recipient filter engine.
-
-Two entry points:
-  - build_recipient_queryset(filters)  → distinct User queryset (for counts)
-  - enumerate_recipients(filters, scope)
-        → yields (user, project, allocation) tuples; allocation may be None
-          when scope doesn't require one.
-
-`scope` is the broadest variable type referenced by the template:
-  "allocation" → iterate per AllocationUser
-  "project"    → iterate per ProjectUser
-  "user"       → distinct users only
-"""
-from django.contrib.auth import get_user_model
-
-User = get_user_model()
-
-
-def _apply_project_filters(pu_qs, filters):
-    projects    = filters.get("projects") or []
-    roles       = filters.get("roles") or []
-    departments = filters.get("departments") or []
-    if projects:
-        pu_qs = pu_qs.filter(project__pk__in=projects)
-    if roles:
-        pu_qs = pu_qs.filter(role__name__in=roles)
-    if departments:
-        pu_qs = pu_qs.filter(
-            project__projectorganization__organization__rank="department",
-            project__projectorganization__organization__name__in=departments,
-        )
-    return pu_qs
-
-
-def _allocation_queryset(filters):
-    from coldfront.core.allocation.models import Allocation
-    allocations = filters.get("allocations") or []
-    resources   = filters.get("resources") or []
-    statuses    = filters.get("statuses") or []
-    qs = Allocation.objects.all()
-    if allocations:
-        qs = qs.filter(pk__in=allocations)
-    if resources:
-        qs = qs.filter(resources__pk__in=resources)
-    if statuses:
-        qs = qs.filter(status__name__in=statuses)
-    return qs
-
-
-def _has_alloc_filters(filters):
-    return bool(
-        filters.get("allocations")
-        or filters.get("resources")
-        or filters.get("statuses")
-    )
-
-
-def build_recipient_queryset(filters: dict):
-    """
-    filters keys (all optional, all lists):
-        projects     - Project pk list
-        allocations  - Allocation pk list
-        resources    - Resource pk list
-        departments  - dept Organization name strings (deduped across org_trees)
-        statuses     - AllocationStatusChoice name strings
-        roles        - ProjectUserRoleChoice name strings
-
-    Returns a QuerySet[User] deduplicated.
-    """
-    from coldfront.core.project.models import ProjectUser
-    from coldfront.core.allocation.models import AllocationUser
-
-    pu_qs = _apply_project_filters(
-        ProjectUser.objects.select_related("user", "project").filter(status__name="Active"),
-        filters,
-    )
-
-    if _has_alloc_filters(filters):
-        alloc_user_pks = AllocationUser.objects.filter(
-            allocation__in=_allocation_queryset(filters),
-            status__name="Active",
-        ).values_list("user__pk", flat=True)
-        pu_qs = pu_qs.filter(user__pk__in=alloc_user_pks)
-
-    user_pks = pu_qs.values_list("user__pk", flat=True).distinct()
-    return User.objects.filter(pk__in=user_pks)
-
-
-def recipient_count(filters: dict) -> int:
-    return build_recipient_queryset(filters).count()
-
-
-def recipient_emails(filters: dict, extra: list = None) -> list:
-    emails = list(
-        build_recipient_queryset(filters)
-        .exclude(email="")
-        .values_list("email", flat=True)
-        .distinct()
-    )
-    if extra:
-        for addr in extra:
-            addr = addr.strip()
-            if addr and addr not in emails:
-                emails.append(addr)
-    return emails
-
-
-def enumerate_recipients_deduped(filters: dict, scope: str, dedupe_users):
-    """
-    Wraps enumerate_recipients. For any user whose username is in the
-    dedupe_users set, only the first yielded tuple is kept.
-    """
-    dedupe = set(dedupe_users or [])
-    if not dedupe:
-        yield from enumerate_recipients(filters, scope)
-        return
-    seen = set()
-    for user, project, allocation in enumerate_recipients(filters, scope):
-        if user.username in dedupe:
-            if user.pk in seen:
-                continue
-            seen.add(user.pk)
-        yield (user, project, allocation)
-
-
-def enumerate_recipients(filters: dict, scope: str):
-    """
-    Yield (user, project, allocation) tuples for sending.
-
-    scope:
-      "allocation" → one tuple per (user, project, allocation) match
-      "project"    → one tuple per (user, project) match; allocation=None
-      "user"       → one tuple per distinct user;        project=None, allocation=None
-
-    With scope='allocation', if a user has multiple matching allocations under
-    a project, one tuple (and therefore one email) is emitted for each.
-    """
-    from coldfront.core.project.models import ProjectUser
-    from coldfront.core.allocation.models import AllocationUser
-
-    if scope not in ("user", "project", "allocation"):
-        raise ValueError(f"Unknown scope {scope!r}")
-
-    if scope == "user":
-        for u in build_recipient_queryset(filters).iterator():
-            yield (u, None, None)
-        return
-
-    pu_qs = _apply_project_filters(
-        ProjectUser.objects
-        .select_related("user", "project", "project__pi", "project__status", "role")
-        .filter(status__name="Active"),
-        filters,
-    ).order_by("user_id", "project_id", "pk")
-
-    if scope == "project":
-        if _has_alloc_filters(filters):
-            alloc_qs = _allocation_queryset(filters)
-            # Only keep PUs that have at least one active AllocationUser on a matching allocation.
-            au_user_pks = AllocationUser.objects.filter(
-                allocation__in=alloc_qs, status__name="Active",
-            ).values_list("user__pk", flat=True).distinct()
-            pu_qs = pu_qs.filter(user__pk__in=au_user_pks)
-        for pu in pu_qs.iterator():
-            yield (pu.user, pu.project, None)
-        return
-
-    # scope == "allocation"
-    alloc_qs = _allocation_queryset(filters)
-    # Pull AllocationUsers for the allocation scope; we'll cross-reference per PU.
-    au_qs = (
-        AllocationUser.objects
-        .select_related("allocation", "allocation__status", "allocation__project")
-        .filter(allocation__in=alloc_qs, status__name="Active")
-        .order_by("user_id", "allocation_id", "pk")
-    )
-    # Index AllocationUsers by (user_id, project_id) → list of allocations
-    from collections import defaultdict
-    by_pair = defaultdict(list)
-    for au in au_qs.iterator():
-        by_pair[(au.user_id, au.allocation.project_id)].append(au.allocation)
-
-    for pu in pu_qs.iterator():
-        allocs = by_pair.get((pu.user_id, pu.project_id), [])
-        for a in allocs:
-            yield (pu.user, pu.project, a)
diff --git a/coldfront_notifications/validators.py b/coldfront_notifications/validators.py
deleted file mode 100644
index 37f5a6f..0000000
--- a/coldfront_notifications/validators.py
+++ /dev/null
@@ -1,107 +0,0 @@
-"""
-Pre-flight validation for NotificationCampaign.
-
-validate_campaign(subject, body, filters, extra_context) runs every
-{{token}} against every recipient tuple and returns:
-
-    {
-      "errors":         [{"email":..., "token":..., "reason":...}, ...],
-      "user_count":     N,     # distinct users that would receive >= 1 email
-      "email_count":    M,     # total emails to send (M >= N under scope=allocation)
-      "multi_emails":   [{"username":..., "count":...}, ...],
-      "missing_tokens": [...]  # tokens in subject/body with no matching NotificationVariable
-      "scope":          "user" | "project" | "allocation",
-    }
-
-Campaign is sendable iff errors == [] and missing_tokens == [].
-"""
-import re
-from collections import Counter
-
-from .resolvers import QUERY_SCOPES, MissingValue, resolve
-from .utils import enumerate_recipients_deduped
-
-TOKEN_RE = re.compile(r"\{\{(\w+)\}\}")
-
-
-def _extract_tokens(subject: str, body: str) -> list:
-    """Return unique list of tokens in order of first occurrence."""
-    seen = set()
-    out = []
-    for s in (subject, body):
-        for m in TOKEN_RE.finditer(s or ""):
-            k = m.group(1)
-            if k not in seen:
-                seen.add(k)
-                out.append(k)
-    return out
-
-
-_SCOPE_RANK = {None: -1, "user": 0, "project": 1, "allocation": 2}
-
-
-def _required_scope(variables) -> str:
-    """Widest scope across used query variables (manuals don't affect scope)."""
-    rank = 0  # user
-    for v in variables:
-        if v.source != v.SOURCE_QUERY:
-            continue
-        r = _SCOPE_RANK.get(QUERY_SCOPES.get(v.resolver_key), 0)
-        if r > rank:
-            rank = r
-    return {0: "user", 1: "project", 2: "allocation"}[rank]
-
-
-def validate_campaign(subject: str, body: str, filters: dict, extra_context: dict,
-                      dedupe_users=None) -> dict:
-    from .models import NotificationVariable
-
-    tokens = _extract_tokens(subject, body)
-    vars_by_key = {v.key: v for v in NotificationVariable.objects.filter(key__in=tokens)}
-
-    missing_tokens = [t for t in tokens if t not in vars_by_key]
-    used_vars = [vars_by_key[t] for t in tokens if t in vars_by_key]
-    scope = _required_scope(used_vars)
-
-    errors = []
-    user_pks = set()
-    user_email_counter = Counter()
-
-    for (user, project, allocation) in enumerate_recipients_deduped(filters, scope, dedupe_users):
-        user_pks.add(user.pk)
-        user_email_counter[user.username] += 1
-        ctx = {"user": user, "project": project, "allocation": allocation}
-        for token in tokens:
-            v = vars_by_key.get(token)
-            if v is None:
-                continue  # already reported in missing_tokens
-            try:
-                if v.source == NotificationVariable.SOURCE_MANUAL:
-                    if v.is_required and not (v.value or "").strip():
-                        raise MissingValue()
-                else:
-                    resolve(v.resolver_key, ctx)
-            except MissingValue:
-                errors.append({
-                    "email":  user.email,
-                    "token":  token,
-                    "reason": (
-                        f"manual variable {v.key!r} has no stored value"
-                        if v.source == NotificationVariable.SOURCE_MANUAL
-                        else f"cannot resolve {v.resolver_key} for this recipient"
-                    ),
-                })
-
-    multi_emails = sorted(
-        [{"username": u, "count": c} for u, c in user_email_counter.items() if c > 1],
-        key=lambda x: -x["count"],
-    )
-
-    return {
-        "errors":         errors,
-        "user_count":     len(user_pks),
-        "email_count":    sum(user_email_counter.values()),
-        "multi_emails":   multi_emails,
-        "missing_tokens": missing_tokens,
-        "scope":          scope,
-    }
diff --git a/coldfront_notifications/views.py b/coldfront_notifications/views.py
deleted file mode 100644
index 348d513..0000000
--- a/coldfront_notifications/views.py
+++ /dev/null
@@ -1,809 +0,0 @@
-import json
-import logging
-
-from django.contrib import messages
-from django.contrib.admin.views.decorators import staff_member_required as staff_required
-from django.http import JsonResponse
-from django.shortcuts import get_object_or_404, redirect, render
-from django.utils import timezone
-from django.utils.text import slugify
-from django.views.decorators.http import require_POST
-
-from .forms import NotificationTemplateForm, NotificationVariableForm, SenderConfigForm
-from .models import (
-    NotificationCampaign,
-    NotificationLog,
-    NotificationTemplate,
-    NotificationVariable,
-    SenderConfig,
-)
-from .utils import recipient_count
-from .validators import validate_campaign
-
-logger = logging.getLogger(__name__)
-
-
-def _dispatch_send(campaign_pk: int):
-    """
-    Queue the send task on Celery. Falls back to a background thread when
-    the broker is unreachable so the HTTP response returns immediately.
-    """
-    from .tasks import send_notification_campaign
-    try:
-        send_notification_campaign.delay(campaign_pk)
-    except Exception as exc:
-        import threading
-        logger.warning("Celery broker unreachable (%s) — sending in background thread", exc)
-
-        def _run():
-            from django import db
-            try:
-                db.close_old_connections()
-                send_notification_campaign(campaign_pk)
-            except Exception as thread_exc:
-                logger.error("Background send thread crashed for campaign %s: %s",
-                             campaign_pk, thread_exc, exc_info=True)
-
-        t = threading.Thread(target=_run, daemon=True)
-        t.start()
-
-
-def _get_filter_context():
-    from coldfront.core.project.models import Project, ProjectUserRoleChoice
-    from coldfront.core.allocation.models import Allocation, AllocationStatusChoice
-    from coldfront.core.resource.models import Resource
-    from ifxuser.models import Organization
-
-    return {
-        "projects":    Project.objects.order_by("title"),
-        "allocations": Allocation.objects.select_related("project").order_by("project__title", "pk"),
-        "resources":   Resource.objects.order_by("name"),
-        # Dedupe by name — same dept name often exists across multiple org_trees.
-        "departments": sorted(set(
-            Organization.objects.filter(rank="department").values_list("name", flat=True)
-        )),
-        "statuses":    AllocationStatusChoice.objects.values_list("name", flat=True).order_by("name"),
-        "roles":       ProjectUserRoleChoice.objects.values_list("name", flat=True).order_by("name"),
-        "senders":     SenderConfig.objects.all(),
-        "reply_tos":   SenderConfig.objects.all(),
-    }
-
-
-@staff_required
-def dashboard(request):
-    from datetime import timedelta
-    thirty_days_ago = timezone.now() - timedelta(days=30)
-
-    recent = NotificationCampaign.objects.select_related("template")[:10]
-    stats = {
-        "total_sent":      NotificationLog.objects.filter(status="delivered").count(),
-        "total_failed_30": NotificationCampaign.objects.filter(
-            status=NotificationCampaign.STATUS_FAILED,
-            created_at__gte=thirty_days_ago,
-        ).count(),
-        "sending_now":     NotificationCampaign.objects.filter(status="sending").count(),
-        "total_campaigns": NotificationCampaign.objects.count(),
-    }
-    return render(request, "dashboard.html", {
-        "recent_campaigns": recent,
-        **stats,
-    })
-
-
-@staff_required
-def campaign_list(request):
-    status_filter = request.GET.get("status", "")
-    qs = NotificationCampaign.objects.select_related("template")
-    if status_filter:
-        qs = qs.filter(status=status_filter)
-    return render(request, "campaign_list.html", {
-        "campaigns": qs,
-        "status_filter": status_filter,
-    })
-
-
-@staff_required
-def campaign_detail(request, pk):
-    campaign = get_object_or_404(NotificationCampaign, pk=pk)
-    logs = campaign.logs.all()
-    return render(request, "campaign_detail.html", {
-        "campaign": campaign,
-        "recipient_logs": logs,
-    })
-
-
-@staff_required
-def campaign_progress(request, pk):
-    """Lightweight JSON endpoint for AJAX progress polling."""
-    campaign = get_object_or_404(NotificationCampaign, pk=pk)
-    return JsonResponse({
-        "status":          campaign.status,
-        "status_display":  campaign.get_status_display(),
-        "recipient_count": campaign.recipient_count,
-        "delivered_count": campaign.delivered_count,
-        "failed_count":    campaign.failed_count,
-        "delivery_pct":    campaign.delivery_pct,
-    })
-
-
-@staff_required
-@require_POST
-def resend_failed(request, pk):
-    campaign = get_object_or_404(NotificationCampaign, pk=pk)
-    failed_emails = list(
-        campaign.logs.filter(status=NotificationLog.STATUS_FAILED)
-        .values_list("email", flat=True)
-    )
-    if not failed_emails:
-        messages.info(request, "No failed recipients to resend.")
-        return redirect("notifications:campaign-detail", pk=pk)
-
-    campaign.logs.filter(status=NotificationLog.STATUS_FAILED).update(
-        status=NotificationLog.STATUS_QUEUED
-    )
-    campaign.status = NotificationCampaign.STATUS_QUEUED
-    campaign.save(update_fields=["status"])
-
-    _dispatch_send(campaign.pk)
-    messages.info(request, "Resend queued — delivery in progress.")
-
-    return redirect("notifications:campaign-detail", pk=pk)
-
-
-@staff_required
-def compose(request):
-    templates = NotificationTemplate.objects.filter(is_deleted=False)
-    ctx = _get_filter_context()
-
-    templates_json = json.dumps([
-        {
-            "id":        t.pk,
-            "slug":      t.slug,
-            "name":      t.name,
-            "subject":   t.subject,
-            "body":      t.body,
-            "variables": t.variables,
-        }
-        for t in templates
-    ])
-
-    variables_json = json.dumps([
-        {
-            "key":          v.key,
-            "label":        v.label,
-            "description":  v.description,
-            "example":      v.example,
-            "source":       v.source,
-            "input_widget": v.input_widget,
-            "is_required":  v.is_required,
-        }
-        for v in NotificationVariable.objects.filter(is_deleted=False)
-    ])
-
-    if request.method == "POST":
-        action = request.POST.get("action", "send")
-
-        def _filter(field):
-            # JS submits each filter as one JSON-encoded hidden field.
-            raw = request.POST.get(field, "")
-            if not raw:
-                return []
-            try:
-                val = json.loads(raw)
-                return val if isinstance(val, list) else [val]
-            except (ValueError, TypeError):
-                return request.POST.getlist(field)
-
-        filters = {
-            "projects":    _filter("filter_projects"),
-            "allocations": _filter("filter_allocations"),
-            "resources":   _filter("filter_resources"),
-            "departments": _filter("filter_departments"),
-            "statuses":    _filter("filter_statuses"),
-            "roles":       _filter("filter_roles"),
-        }
-        extra = [
-            line.strip()
-            for line in request.POST.get("extra_recipients", "").splitlines()
-            if line.strip()
-        ]
-
-        subject  = request.POST.get("subject", "").strip()
-        body     = request.POST.get("body", "").strip()
-        sender   = request.POST.get("sender", "")
-        reply_to = request.POST.get("reply_to", "")
-        tmpl_id  = request.POST.get("template_id")
-
-        # Per-user dedupe list (chosen in the preview modal)
-        try:
-            dedupe_users = json.loads(request.POST.get("dedupe_users", "[]") or "[]")
-            if not isinstance(dedupe_users, list):
-                dedupe_users = []
-        except (ValueError, TypeError):
-            dedupe_users = []
-
-        if not subject or not body:
-            messages.error(request, "Subject and body are required.")
-            ctx.update({
-                "templates": templates,
-                "templates_json": templates_json,
-            })
-            return render(request, "compose.html", ctx)
-
-        # Pre-flight validation; block send (and draft) on hard errors.
-        if action == "send":
-            v = validate_campaign(subject, body, filters, {},
-                                  dedupe_users=dedupe_users)
-            if v["errors"] or v["missing_tokens"]:
-                messages.error(
-                    request,
-                    f"Cannot send: {len(v['errors'])} resolution error(s), "
-                    f"{len(v['missing_tokens'])} unknown token(s).",
-                )
-                ctx.update({
-                    "validation": v,
-                    "templates": templates,
-                    "templates_json": templates_json,
-                })
-                return render(request, "compose.html", ctx)
-
-        filters["extra_recipients"] = extra  # preserved in snapshot
-        filters["dedupe_users"]     = dedupe_users
-        campaign = NotificationCampaign.objects.create(
-            template_id=tmpl_id or None,
-            subject=subject,
-            body=body,
-            sender=sender,
-            reply_to=reply_to,
-            status=(NotificationCampaign.STATUS_DRAFT
-                    if action == "draft"
-                    else NotificationCampaign.STATUS_QUEUED),
-            filters_snapshot=filters,
-            extra_context={},
-            recipient_count=0,
-            created_by=request.user,
-        )
-
-        # Logs are created per-tuple during send; drafts carry no logs.
-        if action == "send":
-            _dispatch_send(campaign.pk)
-            messages.info(request, "Notification queued — sending in progress. This page refreshes automatically.")
-            return redirect("notifications:campaign-detail", pk=campaign.pk)
-
-        messages.success(request, f"Draft \"{subject[:50]}\" saved.")
-        return redirect("notifications:campaign-list")
-
-    ctx.update({
-        "templates":      templates,
-        "templates_json": templates_json,
-        "variables_json": variables_json,
-    })
-    return render(request, "compose.html", ctx)
-
-
-@staff_required
-@require_POST
-def filter_options(request):
-    """
-    Return downstream filter option lists given the current selection.
-
-    Cascade direction: (project | department) → allocation → resource → status.
-    Roles are narrowed by projects-linked-to-dept only.
-    """
-    from coldfront.core.project.models import Project, ProjectUser, ProjectUserRoleChoice
-    from coldfront.core.allocation.models import Allocation
-    from coldfront.core.resource.models import Resource
-    from ifxuser.models import Organization
-
-    projects    = request.POST.getlist("projects")
-    allocations = request.POST.getlist("allocations")
-    resources   = request.POST.getlist("resources")
-    departments = request.POST.getlist("departments")  # names
-
-    # Eligible project set given project + dept filters.
-    project_scope = Project.objects.all()
-    if projects:
-        project_scope = project_scope.filter(pk__in=projects)
-    if departments:
-        project_scope = project_scope.filter(
-            projectorganization__organization__rank="department",
-            projectorganization__organization__name__in=departments,
-        )
-
-    # Narrow allocations progressively so each facet only sees its upstream.
-    alloc_by_p = Allocation.objects.filter(project__in=project_scope)
-    alloc_by_pa = alloc_by_p.filter(pk__in=allocations) if allocations else alloc_by_p
-    alloc_by_par = alloc_by_pa.filter(resources__pk__in=resources) if resources else alloc_by_pa
-
-    allocations_out = [
-        {"id": a.pk, "label": f"{a.project.title} — {a.get_parent_resource or ''}"}
-        for a in alloc_by_p.select_related("project").distinct().order_by("project__title", "pk")
-    ]
-
-    resource_pks = alloc_by_pa.values_list("resources__pk", flat=True).distinct()
-    resources_out = [
-        {"id": r.pk, "label": r.name}
-        for r in Resource.objects.filter(pk__in=resource_pks).order_by("name")
-    ]
-
-    status_names = alloc_by_par.values_list("status__name", flat=True).distinct()
-    statuses_out = sorted({n for n in status_names if n})
-
-    role_pks = (
-        ProjectUser.objects.filter(project__in=project_scope)
-        .values_list("role__pk", flat=True)
-        .distinct()
-    )
-    roles_out = sorted(
-        ProjectUserRoleChoice.objects.filter(pk__in=role_pks).values_list("name", flat=True)
-    )
-
-    # Departments narrow by project scope but ignore their own selection so users
-    # can switch between depts without the others disappearing.
-    dept_project_scope = Project.objects.all()
-    if projects:
-        dept_project_scope = dept_project_scope.filter(pk__in=projects)
-    dept_names = (
-        Organization.objects.filter(
-            rank="department",
-            projectorganization__project__in=dept_project_scope,
-        )
-        .values_list("name", flat=True)
-        .distinct()
-    )
-    departments_out = sorted(set(dept_names))
-
-    return JsonResponse({
-        "allocations": allocations_out,
-        "resources":   resources_out,
-        "statuses":    statuses_out,
-        "roles":       roles_out,
-        "departments": departments_out,
-    })
-
-
-@staff_required
-@require_POST
-def recipient_count_view(request):
-    filters = {
-        "projects":    request.POST.getlist("projects"),
-        "allocations": request.POST.getlist("allocations"),
-        "resources":   request.POST.getlist("resources"),
-        "departments": request.POST.getlist("departments"),
-        "statuses":    request.POST.getlist("alloc_status"),
-        "roles":       request.POST.getlist("roles"),
-    }
-    preview = request.POST.get("preview") == "true"
-    subject = request.POST.get("subject", "")
-    body    = request.POST.get("body", "")
-    try:
-        dedupe_users = json.loads(request.POST.get("dedupe_users", "[]") or "[]")
-    except (ValueError, TypeError):
-        dedupe_users = []
-
-    if not preview:
-        return JsonResponse({"count": recipient_count(filters)})
-
-    try:
-        page = max(1, int(request.POST.get("page", 1)))
-    except (ValueError, TypeError):
-        page = 1
-    from .conf import PREVIEW_PAGE_SIZE
-    try:
-        page_size = max(10, min(100, int(request.POST.get("page_size", PREVIEW_PAGE_SIZE))))
-    except (ValueError, TypeError):
-        page_size = PREVIEW_PAGE_SIZE
-
-    # Determine scope the same way the validator/sender will.
-    from .utils import enumerate_recipients_deduped
-    from .validators import _extract_tokens, _required_scope
-    from collections import Counter
-
-    tokens = _extract_tokens(subject, body)
-    used_vars = list(NotificationVariable.objects.filter(key__in=tokens))
-    scope = _required_scope(used_vars)
-
-    # Single pass: collect counts + page rows in one iteration.
-    from coldfront.core.project.models import ProjectUser
-
-    user_info = {}       # username → {email, full_name}
-    user_counts = Counter()
-    page_rows = []
-    total = 0
-    want_start = (page - 1) * page_size
-    want_end   = want_start + page_size
-
-    for user, project, allocation in enumerate_recipients_deduped(filters, scope, dedupe_users):
-        u = user.username
-        user_counts[u] += 1
-        if u not in user_info:
-            user_info[u] = {
-                "email": user.email,
-                "full_name": user.get_full_name() or user.username,
-            }
-
-        # Only collect details for rows in the requested page.
-        if want_start <= total < want_end:
-            page_rows.append({
-                "username":      u,
-                "full_name":     user.get_full_name() or u,
-                "email":         user.email,
-                "user_pk":       user.pk,
-                "project_pk":    project.pk if project else None,
-                "project_title": project.title if project else "",
-                "allocation": (
-                    f"{allocation.pk} — {allocation.get_parent_resource}"
-                    if allocation else ""
-                ),
-            })
-
-        total += 1
-
-    total_pages = max(1, (total + page_size - 1) // page_size)
-    page = min(page, total_pages)
-
-    # Batch-load roles for the page's rows in one query.
-    if page_rows:
-        pairs = [(r["user_pk"], r["project_pk"]) for r in page_rows if r["project_pk"]]
-        if pairs:
-            from django.db.models import Q
-            q = Q()
-            for uid, pid in pairs:
-                q |= Q(user_id=uid, project_id=pid)
-            role_map = {}
-            for pu in ProjectUser.objects.filter(q, status__name="Active").select_related("role"):
-                role_map[(pu.user_id, pu.project_id)] = pu.role.name if pu.role else ""
-        else:
-            role_map = {}
-        for r in page_rows:
-            r["role"] = role_map.get((r["user_pk"], r["project_pk"]), "")
-            r["project"] = r.pop("project_title")
-            del r["user_pk"]
-            del r["project_pk"]
-
-    multi_users = sorted([
-        {"username": u, "email": user_info[u]["email"],
-         "full_name": user_info[u]["full_name"], "count": c}
-        for u, c in user_counts.items() if c > 1
-    ], key=lambda x: -x["count"])
-
-    return JsonResponse({
-        "count":       total,
-        "user_count":  len(user_info),
-        "recipients":  page_rows,
-        "multi_users": multi_users,
-        "scope":       scope,
-        "page":        page,
-        "page_size":   page_size,
-        "total_pages": total_pages,
-    })
-
-
-@staff_required
-def template_list(request):
-    return render(request, "template_list.html", {
-        "templates": NotificationTemplate.objects.filter(is_deleted=False),
-    })
-
-
-@staff_required
-def template_form(request, pk=None):
-    instance = get_object_or_404(NotificationTemplate, pk=pk) if pk else None
-    if request.method == "POST":
-        form = NotificationTemplateForm(request.POST, instance=instance)
-        if form.is_valid():
-            obj = form.save(commit=False)
-            if not obj.slug:
-                obj.slug = slugify(obj.name)
-            obj.save()
-            action_word = "updated" if instance else "created"
-            messages.success(request, f'Template "{obj.name}" {action_word}.')
-            return redirect("notifications:template-list")
-    else:
-        form = NotificationTemplateForm(instance=instance)
-
-    variables_json = json.dumps([
-        {
-            "key":         v.key,
-            "label":       v.label,
-            "description": v.description,
-            "example":     v.example,
-            "source":      v.source,
-        }
-        for v in NotificationVariable.objects.filter(is_deleted=False)
-    ])
-
-    return render(request, "template_form.html", {
-        "form":     form,
-        "template": instance,
-        "variables_json": variables_json,
-    })
-
-
-@staff_required
-def template_delete(request, pk):
-    instance = get_object_or_404(NotificationTemplate, pk=pk)
-    # Count notifications that used this template
-    notification_count = NotificationCampaign.objects.filter(template=instance).count()
-    if request.method == "POST":
-        instance.is_deleted = True
-        instance.save(update_fields=["is_deleted"])
-        messages.success(request, f'Template "{instance.name}" deleted.')
-        return redirect("notifications:template-list")
-    return render(request, "template_delete_confirm.html", {
-        "template": instance,
-        "notification_count": notification_count,
-    })
-
-
-@staff_required
-def variable_list(request):
-    return render(request, "variable_list.html", {
-        "variables": NotificationVariable.objects.filter(is_deleted=False),
-    })
-
-
-@staff_required
-def variable_form(request, pk=None):
-    instance = get_object_or_404(NotificationVariable, pk=pk) if pk else None
-    if request.method == "POST":
-        form = NotificationVariableForm(request.POST, instance=instance)
-        if form.is_valid():
-            obj = form.save()
-            action_word = "updated" if instance else "created"
-            messages.success(request, f'Variable "{{{{{obj.key}}}}}" {action_word}.')
-            return redirect("notifications:variable-list")
-    else:
-        form = NotificationVariableForm(instance=instance)
-
-    # Dropdown metadata for conditional UI rendering
-    from .resolvers import QUERY_CHOICES
-    return render(request, "variable_form.html", {
-        "form":     form,
-        "variable": instance,
-        "query_choices": QUERY_CHOICES,
-    })
-
-
-@staff_required
-def variable_delete(request, pk):
-    instance = get_object_or_404(NotificationVariable, pk=pk)
-    # Find templates that reference this variable's key
-    affected = [
-        t for t in NotificationTemplate.objects.filter(is_deleted=False)
-        if instance.key in t.variables
-    ]
-    if request.method == "POST":
-        instance.is_deleted = True
-        instance.save(update_fields=["is_deleted"])
-        messages.success(request, f'Variable "{{{{{instance.key}}}}}" deleted.')
-        return redirect("notifications:variable-list")
-    return render(request, "variable_delete_confirm.html", {
-        "variable": instance,
-        "affected_templates": affected,
-    })
-
-
-@staff_required
-def settings_view(request):
-    senders = SenderConfig.objects.all()
-    return render(request, "settings.html", {"senders": senders})
-
-
-@staff_required
-def sender_form(request, pk=None):
-    instance = get_object_or_404(SenderConfig, pk=pk) if pk else None
-    if request.method == "POST":
-        form = SenderConfigForm(request.POST, instance=instance)
-        if form.is_valid():
-            obj = form.save()
-            action_word = "updated" if instance else "added"
-            messages.success(request, f'Address "{obj.email}" {action_word}.')
-            return redirect("notifications:settings")
-    else:
-        form = SenderConfigForm(instance=instance)
-    return render(request, "sender_form.html", {
-        "form": form,
-        "sender": instance,
-    })
-
-
-@staff_required
-@require_POST
-def sender_delete(request, pk):
-    obj = get_object_or_404(SenderConfig, pk=pk)
-    email = obj.email
-    obj.delete()
-    messages.success(request, f'Address "{email}" removed.')
-    return redirect("notifications:settings")
-
-
-@staff_required
-def template_json(request, pk):
-    """Return a single template's live content for the compose-page sidebar."""
-    t = get_object_or_404(NotificationTemplate, pk=pk)
-    return JsonResponse({
-        "id":        t.pk,
-        "slug":      t.slug,
-        "name":      t.name,
-        "subject":   t.subject,
-        "body":      t.body,
-        "variables": t.variables,
-    })
-
-
-@staff_required
-def variables_view(request):
-    """Return the full catalog of NotificationVariables as JSON."""
-    return JsonResponse({
-        "variables": [
-            {
-                "key":          v.key,
-                "label":        v.label,
-                "description":  v.description,
-                "example":      v.example,
-                "source":       v.source,
-                "input_widget": v.input_widget,
-                "is_required":  v.is_required,
-            }
-            for v in NotificationVariable.objects.filter(is_deleted=False)
-        ]
-    })
-
-
-@staff_required
-@require_POST
-def preview_render_view(request):
-    """
-    Render the subject+body for up to N sample recipient tuples so the admin
-    can see substitution in action before sending. Does NOT hard-fail on
-    resolution errors — it annotates the sample instead.
-    """
-    from .utils import enumerate_recipients_deduped
-    from .validators import _extract_tokens, _required_scope
-    from .resolvers import MissingValue
-    from .tasks import _build_values, _render
-
-    def _json(field, default):
-        raw = request.POST.get(field, "")
-        if not raw:
-            return default
-        try:
-            return json.loads(raw)
-        except (ValueError, TypeError):
-            return default
-
-    subject      = request.POST.get("subject", "")
-    body         = request.POST.get("body", "")
-    filters      = _json("filters", {}) or {}
-    dedupe_users = _json("dedupe_users", []) or []
-    try:
-        from .conf import PREVIEW_RENDER_LIMIT
-        limit = max(1, min(10, int(request.POST.get("limit", PREVIEW_RENDER_LIMIT))))
-    except (ValueError, TypeError):
-        limit = 3
-
-    for k in ("projects","allocations","resources","departments","statuses","roles"):
-        filters.setdefault(k, [])
-        if not isinstance(filters[k], list):
-            filters[k] = [filters[k]]
-
-    tokens = _extract_tokens(subject, body)
-    vars_by_key = {v.key: v for v in NotificationVariable.objects.filter(key__in=tokens)}
-    scope = _required_scope(list(vars_by_key.values()))
-
-    samples = []
-    total = 0
-    for user, project, allocation in enumerate_recipients_deduped(filters, scope, dedupe_users):
-        total += 1
-        if len(samples) >= limit:
-            continue
-        ctx = {"user": user, "project": project, "allocation": allocation}
-        try:
-            values = _build_values(tokens, vars_by_key, ctx)
-            rendered_subject = _render(subject, values)
-            rendered_body    = _render(body,    values)
-            error = None
-        except MissingValue as exc:
-            rendered_subject = subject
-            rendered_body    = body
-            error = str(exc)
-        samples.append({
-            "recipient": {
-                "name":       user.get_full_name() or user.username,
-                "email":      user.email,
-                "username":   user.username,
-                "project":    project.title if project else "",
-                "allocation": (f"{allocation.pk} — {allocation.get_parent_resource}"
-                               if allocation else ""),
-            },
-            "subject": rendered_subject,
-            "body":    rendered_body,
-            "error":   error,
-        })
-
-    return JsonResponse({
-        "samples":      samples,
-        "total_emails": total,
-        "scope":        scope,
-    })
-
-
-@staff_required
-@require_POST
-def validate_view(request):
-    """
-    Pre-flight validation — called from compose JS before Send is enabled.
-    POST payload:
-      subject, body (str)
-      filters (JSON-encoded dict with projects/allocations/resources/departments/statuses/roles)
-      extra_context (JSON-encoded dict {var_key: user_value})
-    """
-    def _json(field, default):
-        raw = request.POST.get(field, "")
-        if not raw:
-            return default
-        try:
-            return json.loads(raw)
-        except (ValueError, TypeError):
-            return default
-
-    subject       = request.POST.get("subject", "")
-    body          = request.POST.get("body", "")
-    filters       = _json("filters", {}) or {}
-    extra_context = _json("extra_context", {}) or {}
-    dedupe_users  = _json("dedupe_users", []) or []
-    # Normalize every filter key to a list (validate_campaign expects lists)
-    for k in ("projects","allocations","resources","departments","statuses","roles"):
-        v = filters.get(k)
-        if v is None:
-            filters[k] = []
-        elif not isinstance(v, list):
-            filters[k] = [v]
-
-    result = validate_campaign(subject, body, filters, extra_context,
-                               dedupe_users=dedupe_users)
-    return JsonResponse(result)
-
-
-@staff_required
-def resend_compose(request, pk):
-    """
-    Show a review-and-resend page pre-filled from an existing campaign.
-    POST creates a new campaign and dispatches it.
-    """
-    source = get_object_or_404(NotificationCampaign, pk=pk)
-    snapshot = source.filters_snapshot or {}
-
-    if request.method == "POST":
-        subject = request.POST.get("subject", "").strip()
-        body = request.POST.get("body", "").strip()
-        sender = request.POST.get("sender", "")
-        reply_to = request.POST.get("reply_to", "")
-
-        if not subject or not body:
-            messages.error(request, "Subject and body are required.")
-            return redirect("notifications:resend-compose", pk=pk)
-
-        campaign = NotificationCampaign.objects.create(
-            template=source.template,
-            subject=subject,
-            body=body,
-            sender=sender,
-            reply_to=reply_to,
-            status=NotificationCampaign.STATUS_QUEUED,
-            filters_snapshot=snapshot,
-            extra_context=source.extra_context or {},
-            recipient_count=0,
-            created_by=request.user,
-        )
-        _dispatch_send(campaign.pk)
-        messages.info(request, "Resend queued — sending in progress.")
-        return redirect("notifications:campaign-detail", pk=campaign.pk)
-
-    return render(request, "resend_compose.html", {
-        "source": source,
-        "snapshot": snapshot,
-        "snapshot_json": json.dumps(snapshot),
-        "senders": SenderConfig.objects.all(),
-    })
\ No newline at end of file
diff --git a/coldfront_notifications/views/__init__.py b/coldfront_notifications/views/__init__.py
new file mode 100644
index 0000000..5bc11b0
--- /dev/null
+++ b/coldfront_notifications/views/__init__.py
@@ -0,0 +1,21 @@
+# Re-export all views so urls.py can use `from . import views`.
+from .dashboard import DashboardView  # noqa: F401
+from .campaigns import (  # noqa: F401
+    CampaignListView, CampaignDetailView, CampaignProgressView,
+    DraftDeleteView, ResendFailedView, ResendComposeView,
+)
+from .compose import (  # noqa: F401
+    ComposeView, RecipientCountView,
+    PreviewRenderView, ValidateView,
+    DraftSaveView,
+)
+from .helpers import dispatch_send  # noqa: F401
+from .templates import (  # noqa: F401
+    TemplateListView, TemplateFormView,
+    TemplateDeleteView, TemplateJsonView,
+)
+from .settings import (  # noqa: F401
+    VariableListView, VariableFormView,
+    VariableDeleteView, VariablesJsonView,
+    SettingsView, SenderFormView, SenderDeleteView,
+)
diff --git a/coldfront_notifications/views/campaigns.py b/coldfront_notifications/views/campaigns.py
new file mode 100644
index 0000000..0cbede7
--- /dev/null
+++ b/coldfront_notifications/views/campaigns.py
@@ -0,0 +1,164 @@
+"""Campaign views: list, detail, progress polling, resend, resend-compose."""
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any
+
+from django.contrib import messages
+from django.http import JsonResponse
+from django.shortcuts import get_object_or_404, redirect
+from django.views import View
+from django.views.generic import DetailView, ListView, TemplateView
+
+from ..models import NotificationCampaign, NotificationLog, SenderConfig
+from .helpers import StaffRequiredMixin, dispatch_send
+
+logger = logging.getLogger(__name__)
+
+
+class CampaignListView(StaffRequiredMixin, ListView):
+    """List all campaigns, optionally filtered by status."""
+
+    model = NotificationCampaign
+    template_name = "coldfront_notifications/campaign_list.html"
+    context_object_name = "campaigns"
+
+    def get_queryset(self):
+        queryset = super().get_queryset().select_related("template")
+        status_filter = self.request.GET.get("status", "")
+        if status_filter:
+            queryset = queryset.filter(status=status_filter)
+        return queryset
+
+    def get_context_data(self, **kwargs: Any) -> dict[str, Any]:
+        context = super().get_context_data(**kwargs)
+        context["status_filter"] = self.request.GET.get("status", "")
+        return context
+
+
+class CampaignDetailView(StaffRequiredMixin, DetailView):
+    """Campaign detail with delivery logs."""
+
+    model = NotificationCampaign
+    template_name = "coldfront_notifications/campaign_detail.html"
+    context_object_name = "campaign"
+
+    def get_context_data(self, **kwargs: Any) -> dict[str, Any]:
+        context = super().get_context_data(**kwargs)
+        context["recipient_logs"] = self.object.logs.all()
+        return context
+
+
+class CampaignProgressView(StaffRequiredMixin, View):
+    """Lightweight JSON endpoint for AJAX progress polling."""
+
+    def get(self, request, *args: Any, **kwargs: Any) -> JsonResponse:
+        campaign = get_object_or_404(NotificationCampaign, pk=kwargs["pk"])
+        return JsonResponse({
+            "status": campaign.status,
+            "status_display": campaign.get_status_display(),
+            "recipient_count": campaign.recipient_count,
+            "delivered_count": campaign.delivered_count,
+            "failed_count": campaign.failed_count,
+            "delivery_pct": campaign.delivery_pct,
+        })
+
+
+class ResendFailedView(StaffRequiredMixin, View):
+    """Re-queue failed recipients for an existing campaign."""
+
+    def post(self, request, *args: Any, **kwargs: Any):
+        campaign = get_object_or_404(NotificationCampaign, pk=kwargs["pk"])
+        failed_emails = list(
+            campaign.logs
+            .filter(status=NotificationLog.Status.FAILED)
+            .values_list("email", flat=True)
+        )
+
+        if not failed_emails:
+            messages.info(request, "No failed recipients to resend.")
+            return redirect("notifications:campaign-detail", pk=campaign.pk)
+
+        campaign.logs.filter(
+            status=NotificationLog.Status.FAILED,
+        ).update(status=NotificationLog.Status.QUEUED)
+        campaign.status = NotificationCampaign.Status.QUEUED
+        campaign.save(update_fields=["status"])
+
+        dispatch_send(campaign.pk)
+        messages.info(request, "Resend queued \u2014 delivery in progress.")
+        return redirect("notifications:campaign-detail", pk=campaign.pk)
+
+
+class DraftDeleteView(StaffRequiredMixin, TemplateView):
+    """Confirm and hard-delete a draft campaign."""
+
+    template_name = "coldfront_notifications/draft_delete_confirm.html"
+
+    def get_context_data(self, **kwargs: Any) -> dict[str, Any]:
+        context = super().get_context_data(**kwargs)
+        context["campaign"] = get_object_or_404(
+            NotificationCampaign,
+            pk=kwargs["pk"],
+            status=NotificationCampaign.Status.DRAFT,
+        )
+        return context
+
+    def post(self, request, *args: Any, **kwargs: Any):
+        campaign = get_object_or_404(
+            NotificationCampaign,
+            pk=kwargs["pk"],
+            status=NotificationCampaign.Status.DRAFT,
+        )
+        subject = campaign.subject[:50] or "(no subject)"
+        campaign.delete()
+        messages.success(request, f'Draft "{subject}" deleted.')
+        return redirect("notifications:campaign-list")
+
+
+class ResendComposeView(StaffRequiredMixin, TemplateView):
+    """Review-and-resend page pre-filled from an existing campaign."""
+
+    template_name = "coldfront_notifications/resend_compose.html"
+
+    def get_context_data(self, **kwargs: Any) -> dict[str, Any]:
+        context = super().get_context_data(**kwargs)
+        source_campaign = get_object_or_404(NotificationCampaign, pk=kwargs["pk"])
+        snapshot = source_campaign.filters_snapshot or {}
+        context.update({
+            "source": source_campaign,
+            "snapshot": snapshot,
+            "snapshot_json": json.dumps(snapshot),
+            "senders": SenderConfig.objects.all(),
+        })
+        return context
+
+    def post(self, request, *args: Any, **kwargs: Any):
+        source_campaign = get_object_or_404(NotificationCampaign, pk=kwargs["pk"])
+        snapshot = source_campaign.filters_snapshot or {}
+
+        subject = request.POST.get("subject", "").strip()
+        body = request.POST.get("body", "").strip()
+        sender = request.POST.get("sender", "")
+        reply_to = request.POST.get("reply_to", "")
+
+        if not subject or not body:
+            messages.error(request, "Subject and body are required.")
+            return redirect("notifications:resend-compose", pk=source_campaign.pk)
+
+        campaign = NotificationCampaign.objects.create(
+            template=source_campaign.template,
+            subject=subject,
+            body=body,
+            sender=sender,
+            reply_to=reply_to,
+            status=NotificationCampaign.Status.QUEUED,
+            filters_snapshot=snapshot,
+            extra_context=source_campaign.extra_context or {},
+            recipient_count=0,
+            created_by=request.user,
+        )
+        dispatch_send(campaign.pk)
+        messages.info(request, "Resend queued \u2014 sending in progress.")
+        return redirect("notifications:campaign-detail", pk=campaign.pk)
diff --git a/coldfront_notifications/views/compose.py b/coldfront_notifications/views/compose.py
new file mode 100644
index 0000000..c2e0b9d
--- /dev/null
+++ b/coldfront_notifications/views/compose.py
@@ -0,0 +1,610 @@
+"""
+Compose notification views: compose form, recipient preview, email
+preview render, and pre-flight validation.
+
+All views use Django class-based views with LoginRequiredMixin +
+UserPassesTestMixin following ColdFront core conventions.
+"""
+from __future__ import annotations
+
+import json
+import logging
+from collections import Counter
+from typing import Any
+
+from django.contrib import messages
+from django.db.models import Q
+from django.http import JsonResponse
+from django.shortcuts import redirect
+from django.views import View
+from django.views.generic import TemplateView
+
+from coldfront.core.project.models import Project, ProjectUser
+from coldfront.core.resource.models import Resource
+
+from ..campaign_sender import TemplateRenderer
+from ..conf import PREVIEW_PAGE_SIZE, PREVIEW_RENDER_LIMIT
+from ..filters import FilterDataBuilder, RecipientResolver
+from ..models import (
+    NotificationCampaign,
+    NotificationTemplate,
+    NotificationVariable,
+    SenderConfig,
+)
+from ..notification_validator import NotificationValidator, extract_tokens, determine_scope
+from ..template_variable_value_resolver import MissingValue
+from .helpers import StaffRequiredMixin, dispatch_send
+
+logger = logging.getLogger(__name__)
+
+
+class ComposeView(StaffRequiredMixin, TemplateView):
+    """Main compose page: GET renders the form, POST handles send/draft."""
+
+    template_name = "coldfront_notifications/compose.html"
+
+    def get_context_data(self, **kwargs: Any) -> dict[str, Any]:
+        context = super().get_context_data(**kwargs)
+        templates = NotificationTemplate.objects.filter(is_deleted=False)
+
+        templates_json = json.dumps([
+            {
+                "id": template.pk,
+                "slug": template.slug,
+                "name": template.name,
+                "subject": template.subject,
+                "body": template.body,
+                "variables": template.variables,
+            }
+            for template in templates
+        ])
+
+        variables_json = json.dumps([
+            {
+                "key": variable.key,
+                "label": variable.label,
+                "description": variable.description,
+                "example": variable.example,
+                "source": variable.source,
+                "input_widget": variable.input_widget,
+                "is_required": variable.is_required,
+            }
+            for variable in NotificationVariable.objects.filter(is_deleted=False)
+        ])
+
+        draft_json = "null"
+        draft_pk = self.request.GET.get("draft")
+        if draft_pk:
+            try:
+                draft = NotificationCampaign.objects.get(
+                    pk=draft_pk,
+                    status=NotificationCampaign.Status.DRAFT,
+                    created_by=self.request.user,
+                )
+                draft_json = json.dumps({
+                    "pk": draft.pk,
+                    "subject": draft.subject,
+                    "body": draft.body,
+                    "sender": draft.sender,
+                    "reply_to": draft.reply_to,
+                    "template_id": draft.template_id,
+                    "filters": draft.filters_snapshot or {},
+                    "extra_context": draft.extra_context or {},
+                })
+            except NotificationCampaign.DoesNotExist:
+                pass
+
+        context.update({
+            "templates": templates,
+            "templates_json": templates_json,
+            "variables_json": variables_json,
+            "filter_data_json": FilterDataBuilder().build_json(),
+            "draft_json": draft_json,
+            "senders": SenderConfig.objects.all(),
+            "reply_tos": SenderConfig.objects.all(),
+        })
+        return context
+
+    def post(self, request, *args: Any, **kwargs: Any):
+        """Handle send or draft submission."""
+        action = request.POST.get("action", "send")
+
+        filters = self._parse_filters_from_post(request)
+        extra_recipients = [
+            line.strip()
+            for line in request.POST.get("extra_recipients", "").splitlines()
+            if line.strip()
+        ]
+
+        subject = request.POST.get("subject", "").strip()
+        body = request.POST.get("body", "").strip()
+        sender = request.POST.get("sender", "")
+        reply_to = request.POST.get("reply_to", "")
+        template_id = request.POST.get("template_id")
+        draft_pk = request.POST.get("draft_pk")
+
+        dedupe_users = self._parse_json(request.POST.get("dedupe_users", "[]"), [])
+        if not isinstance(dedupe_users, list):
+            dedupe_users = []
+
+        if not subject or not body:
+            messages.error(request, "Subject and body are required.")
+            return self.render_to_response(self.get_context_data())
+
+        if action == "send":
+            validation_result = NotificationValidator(
+                subject, body, filters,
+                dedupe_users=dedupe_users,
+            ).validate()
+            if validation_result["errors"] or validation_result["missing_tokens"]:
+                messages.error(
+                    request,
+                    f"Cannot send: {len(validation_result['errors'])} resolution error(s), "
+                    f"{len(validation_result['missing_tokens'])} unknown token(s).",
+                )
+                context = self.get_context_data()
+                context["validation"] = validation_result
+                return self.render_to_response(context)
+
+        filters["extra_recipients"] = extra_recipients
+        filters["dedupe_users"] = dedupe_users
+
+        if draft_pk:
+            campaign = self._update_draft(draft_pk, request.user, action, {
+                "template_id": template_id or None,
+                "subject": subject,
+                "body": body,
+                "sender": sender,
+                "reply_to": reply_to,
+                "filters_snapshot": filters,
+            })
+            if campaign is None:
+                messages.error(request, "Draft not found or not editable.")
+                return redirect("notifications:campaign-list")
+        else:
+            campaign = NotificationCampaign.objects.create(
+                template_id=template_id or None,
+                subject=subject,
+                body=body,
+                sender=sender,
+                reply_to=reply_to,
+                status=(
+                    NotificationCampaign.Status.DRAFT
+                    if action == "draft"
+                    else NotificationCampaign.Status.QUEUED
+                ),
+                filters_snapshot=filters,
+                extra_context={},
+                recipient_count=0,
+                created_by=request.user,
+            )
+
+        if action == "send":
+            dispatch_send(campaign.pk)
+            messages.info(
+                request,
+                "Notification queued — sending in progress. "
+                "This page refreshes automatically.",
+            )
+            return redirect("notifications:campaign-detail", pk=campaign.pk)
+
+        messages.success(request, f'Draft "{subject[:50]}" saved.')
+        return redirect("notifications:campaign-list")
+
+    @staticmethod
+    def _update_draft(draft_pk, user, action, fields):
+        """Update an existing draft campaign. Returns the campaign or None."""
+        try:
+            campaign = NotificationCampaign.objects.get(
+                pk=draft_pk,
+                status=NotificationCampaign.Status.DRAFT,
+                created_by=user,
+            )
+        except NotificationCampaign.DoesNotExist:
+            return None
+
+        for field_name, value in fields.items():
+            setattr(campaign, field_name, value)
+
+        campaign.status = (
+            NotificationCampaign.Status.DRAFT
+            if action == "draft"
+            else NotificationCampaign.Status.QUEUED
+        )
+        campaign.save()
+        return campaign
+
+    @staticmethod
+    def _parse_filters_from_post(request) -> dict:
+        return {
+            "projects": ComposeView._parse_filter_list(request.POST.get("filter_projects", "")),
+            "allocations": ComposeView._parse_filter_list(request.POST.get("filter_allocations", "")),
+            "resources": ComposeView._parse_filter_list(request.POST.get("filter_resources", "")),
+            "departments": ComposeView._parse_filter_list(request.POST.get("filter_departments", "")),
+            "statuses": ComposeView._parse_filter_list(request.POST.get("filter_statuses", "")),
+            "roles": ComposeView._parse_filter_list(request.POST.get("filter_roles", "")),
+        }
+
+    @staticmethod
+    def _parse_filter_list(raw: str) -> list:
+        if not raw:
+            return []
+        try:
+            value = json.loads(raw)
+            return value if isinstance(value, list) else [value]
+        except (ValueError, TypeError):
+            return [raw]
+
+    @staticmethod
+    def _parse_json(raw: str, default: Any = None) -> Any:
+        if not raw:
+            return default
+        try:
+            return json.loads(raw)
+        except (ValueError, TypeError):
+            return default
+
+
+class RecipientCountView(StaffRequiredMixin, View):
+    """Return recipient count or paginated preview as JSON."""
+
+    def post(self, request, *args: Any, **kwargs: Any) -> JsonResponse:
+        filters = {
+            "projects": request.POST.getlist("projects"),
+            "allocations": request.POST.getlist("allocations"),
+            "resources": request.POST.getlist("resources"),
+            "departments": request.POST.getlist("departments"),
+            "statuses": request.POST.getlist("alloc_status"),
+            "roles": request.POST.getlist("roles"),
+        }
+        is_preview = request.POST.get("preview") == "true"
+        subject = request.POST.get("subject", "")
+        body = request.POST.get("body", "")
+
+        if not is_preview:
+            return JsonResponse({"count": RecipientResolver(filters).count()})
+
+        return self._build_paginated_preview(request, filters, subject, body)
+
+    def _build_paginated_preview(self, request, filters, subject, body) -> JsonResponse:
+        page, page_size = self._parse_pagination(request)
+        scope = self._determine_preview_scope(filters, subject, body)
+        resolver = RecipientResolver(filters)
+
+        user_info, emails_per_user, total_count = self._collect_user_stats(resolver, scope)
+        total_pages = max(1, (total_count + page_size - 1) // page_size)
+        page = min(page, total_pages)
+
+        page_rows = self._collect_page_rows(resolver, scope, page, page_size)
+        self._enrich_with_roles(page_rows)
+        multi_email_users = self._build_multi_email_list(emails_per_user, user_info)
+
+        return JsonResponse({
+            "count": total_count,
+            "user_count": len(user_info),
+            "recipients": page_rows,
+            "multi_users": multi_email_users,
+            "scope": scope,
+            "page": page,
+            "page_size": page_size,
+            "total_pages": total_pages,
+        })
+
+    @staticmethod
+    def _parse_pagination(request) -> tuple[int, int]:
+        try:
+            page = max(1, int(request.POST.get("page", 1)))
+        except (ValueError, TypeError):
+            page = 1
+        try:
+            page_size = max(10, min(100, int(request.POST.get("page_size", PREVIEW_PAGE_SIZE))))
+        except (ValueError, TypeError):
+            page_size = PREVIEW_PAGE_SIZE
+        return page, page_size
+
+    @staticmethod
+    def _determine_preview_scope(filters, subject, body) -> str:
+        tokens = extract_tokens(subject, body)
+        used_variables = list(NotificationVariable.objects.filter(key__in=tokens))
+        token_scope = determine_scope(used_variables)
+
+        return max(token_scope, "project", key=["user", "project", "allocation"].index)
+
+    @staticmethod
+    def _collect_user_stats(resolver, scope) -> tuple[dict, Counter, int]:
+        user_info = {}
+        emails_per_user = Counter()
+        total_count = 0
+
+        for user, project, allocation in resolver.enumerate(scope):
+            username = user.username
+            emails_per_user[username] += 1
+            if username not in user_info:
+                user_info[username] = {
+                    "email": user.email,
+                    "full_name": user.get_full_name() or user.username,
+                }
+            total_count += 1
+
+        return user_info, emails_per_user, total_count
+
+    @staticmethod
+    def _collect_page_rows(resolver, scope, page, page_size) -> list[dict]:
+        start_index = (page - 1) * page_size
+        end_index = start_index + page_size
+        page_rows = []
+
+        for index, (user, project, allocation) in enumerate(resolver.enumerate(scope)):
+            if index >= end_index:
+                break
+            if index >= start_index:
+                page_rows.append({
+                    "username": user.username,
+                    "full_name": user.get_full_name() or user.username,
+                    "email": user.email,
+                    "user_pk": user.pk,
+                    "project_pk": project.pk if project else None,
+                    "project_title": project.title if project else "",
+                    "allocation": (
+                        f"{allocation.pk} \u2014 {allocation.get_parent_resource}"
+                        if allocation
+                        else ""
+                    ),
+                })
+
+        return page_rows
+
+    @staticmethod
+    def _enrich_with_roles(page_rows: list[dict]):
+        user_project_pairs = [
+            (row["user_pk"], row["project_pk"])
+            for row in page_rows
+            if row["project_pk"]
+        ]
+        role_lookup = {}
+        if user_project_pairs:
+            query = Q()
+            for user_pk, project_pk in user_project_pairs:
+                query |= Q(user_id=user_pk, project_id=project_pk)
+            for project_user in (
+                ProjectUser.objects
+                .filter(query, status__name="Active")
+                .select_related("role")
+            ):
+                role_lookup[(project_user.user_id, project_user.project_id)] = (
+                    project_user.role.name if project_user.role else ""
+                )
+
+        for row in page_rows:
+            row["role"] = role_lookup.get((row["user_pk"], row["project_pk"]), "")
+            row["project"] = row.pop("project_title")
+            del row["user_pk"]
+            del row["project_pk"]
+
+    @staticmethod
+    def _build_multi_email_list(emails_per_user, user_info) -> list[dict]:
+        return sorted(
+            [
+                {
+                    "username": username,
+                    "email": user_info[username]["email"],
+                    "full_name": user_info[username]["full_name"],
+                    "count": count,
+                }
+                for username, count in emails_per_user.items()
+                if count > 1
+            ],
+            key=lambda entry: -entry["count"],
+        )
+
+
+class PreviewRenderView(StaffRequiredMixin, View):
+    """Render subject+body for sample recipients so the admin can preview."""
+
+    def post(self, request, *args: Any, **kwargs: Any) -> JsonResponse:
+        subject = request.POST.get("subject", "")
+        body = request.POST.get("body", "")
+        filters = self._parse_json(request.POST.get("filters", ""), {}) or {}
+        dedupe_users = self._parse_json(request.POST.get("dedupe_users", ""), []) or []
+
+        try:
+            limit = max(1, min(10, int(request.POST.get("limit", PREVIEW_RENDER_LIMIT))))
+        except (ValueError, TypeError):
+            limit = 3
+
+        self._normalize_filter_keys(filters)
+
+        tokens = extract_tokens(subject, body)
+        variables_by_key = {
+            variable.key: variable
+            for variable in NotificationVariable.objects.filter(key__in=tokens)
+        }
+        scope = determine_scope(list(variables_by_key.values()))
+        renderer = TemplateRenderer()
+
+        samples = []
+        total_count = 0
+        for user, project, allocation in RecipientResolver(filters).enumerate_deduped(
+            scope, dedupe_users,
+        ):
+            total_count += 1
+            if len(samples) >= limit:
+                continue
+            context = {"user": user, "project": project, "allocation": allocation}
+            try:
+                values = renderer.build_values(tokens, variables_by_key, context)
+                rendered_subject = renderer.render(subject, values)
+                rendered_body = renderer.render(body, values)
+                error = None
+            except MissingValue as exception:
+                rendered_subject = subject
+                rendered_body = body
+                error = str(exception)
+
+            samples.append({
+                "recipient": {
+                    "name": user.get_full_name() or user.username,
+                    "email": user.email,
+                    "username": user.username,
+                    "project": project.title if project else "",
+                    "allocation": (
+                        f"{allocation.pk} \u2014 {allocation.get_parent_resource}"
+                        if allocation
+                        else ""
+                    ),
+                },
+                "subject": rendered_subject,
+                "body": rendered_body,
+                "error": error,
+            })
+
+        return JsonResponse({
+            "samples": samples,
+            "total_emails": total_count,
+            "scope": scope,
+        })
+
+    @staticmethod
+    def _parse_json(raw: str, default: Any = None) -> Any:
+        if not raw:
+            return default
+        try:
+            return json.loads(raw)
+        except (ValueError, TypeError):
+            return default
+
+    @staticmethod
+    def _normalize_filter_keys(filters: dict):
+        for key in ("projects", "allocations", "resources", "departments", "statuses", "roles"):
+            filters.setdefault(key, [])
+            if not isinstance(filters[key], list):
+                filters[key] = [filters[key]]
+
+
+class ValidateView(StaffRequiredMixin, View):
+    """Pre-flight validation — called from compose JS before Send."""
+
+    def post(self, request, *args: Any, **kwargs: Any) -> JsonResponse:
+        subject = request.POST.get("subject", "")
+        body = request.POST.get("body", "")
+        filters = PreviewRenderView._parse_json(request.POST.get("filters", ""), {}) or {}
+        dedupe_users = PreviewRenderView._parse_json(request.POST.get("dedupe_users", ""), []) or []
+
+        PreviewRenderView._normalize_filter_keys(filters)
+
+        tokens = extract_tokens(subject, body)
+        used_variables = list(NotificationVariable.objects.filter(key__in=tokens))
+        token_scope = determine_scope(used_variables)
+
+        elevated_scope = max(
+            token_scope,
+            "project",
+            key=["user", "project", "allocation"].index,
+        )
+
+        result = NotificationValidator(
+            subject,
+            body,
+            filters,
+            dedupe_users=dedupe_users,
+            scope_override=elevated_scope,
+        ).validate()
+
+        result["active_filters"] = self._build_active_filters(filters)
+        return JsonResponse(result)
+
+    @staticmethod
+    def _build_active_filters(filters: dict) -> list[dict]:
+        """Build human-readable active filter labels."""
+        active = []
+
+        if filters.get("projects"):
+            project_names = list(
+                Project.objects
+                .filter(pk__in=filters["projects"])
+                .values_list("title", flat=True)
+            )
+            if project_names:
+                active.append({"label": "Project", "values": project_names})
+
+        if filters.get("departments"):
+            active.append({
+                "label": "Department",
+                "values": filters["departments"],
+            })
+
+        if filters.get("allocations"):
+            active.append({
+                "label": "Allocation",
+                "values": [str(pk) for pk in filters["allocations"]],
+            })
+
+        if filters.get("resources"):
+            resource_names = list(
+                Resource.objects
+                .filter(pk__in=filters["resources"])
+                .values_list("name", flat=True)
+            )
+            if resource_names:
+                active.append({"label": "Resource", "values": resource_names})
+
+        if filters.get("statuses"):
+            active.append({
+                "label": "Allocation Status",
+                "values": filters["statuses"],
+            })
+
+        if filters.get("roles"):
+            active.append({
+                "label": "User Role",
+                "values": filters["roles"],
+            })
+
+        return active
+
+
+class DraftSaveView(StaffRequiredMixin, View):
+    """AJAX endpoint to create or update a draft campaign."""
+
+    def post(self, request, *args: Any, **kwargs: Any) -> JsonResponse:
+        draft_pk = request.POST.get("draft_pk")
+        subject = request.POST.get("subject", "").strip()
+        body = request.POST.get("body", "").strip()
+        sender = request.POST.get("sender", "")
+        reply_to = request.POST.get("reply_to", "")
+        template_id = request.POST.get("template_id") or None
+
+        filters = PreviewRenderView._parse_json(request.POST.get("filters", ""), {}) or {}
+        extra_context = PreviewRenderView._parse_json(request.POST.get("extra_context", ""), {}) or {}
+
+        draft_fields = {
+            "subject": subject,
+            "body": body,
+            "sender": sender,
+            "reply_to": reply_to,
+            "template_id": template_id,
+            "filters_snapshot": filters,
+            "extra_context": extra_context,
+        }
+
+        if draft_pk:
+            try:
+                campaign = NotificationCampaign.objects.get(
+                    pk=draft_pk,
+                    status=NotificationCampaign.Status.DRAFT,
+                    created_by=request.user,
+                )
+                for field_name, value in draft_fields.items():
+                    setattr(campaign, field_name, value)
+                campaign.save()
+            except NotificationCampaign.DoesNotExist:
+                return JsonResponse({"error": "Draft not found"}, status=404)
+        else:
+            campaign = NotificationCampaign.objects.create(
+                **draft_fields,
+                status=NotificationCampaign.Status.DRAFT,
+                recipient_count=0,
+                created_by=request.user,
+            )
+
+        return JsonResponse({"pk": campaign.pk})
diff --git a/coldfront_notifications/views/dashboard.py b/coldfront_notifications/views/dashboard.py
new file mode 100644
index 0000000..a32935c
--- /dev/null
+++ b/coldfront_notifications/views/dashboard.py
@@ -0,0 +1,48 @@
+"""Dashboard view showing recent campaigns and delivery stats."""
+from __future__ import annotations
+
+from datetime import timedelta
+from typing import Any
+
+from django.utils import timezone
+from django.views.generic import TemplateView
+
+from ..models import NotificationCampaign, NotificationLog
+from .helpers import StaffRequiredMixin
+
+
+class DashboardView(StaffRequiredMixin, TemplateView):
+    """Notification dashboard with recent campaigns and 30-day stats."""
+
+    template_name = "coldfront_notifications/dashboard.html"
+
+    def get_context_data(self, **kwargs: Any) -> dict[str, Any]:
+        context = super().get_context_data(**kwargs)
+        thirty_days_ago = timezone.now() - timedelta(days=30)
+
+        context.update({
+            "recent_campaigns": (
+                NotificationCampaign.objects
+                .select_related("template")[:10]
+            ),
+            "total_sent": (
+                NotificationLog.objects
+                .filter(status=NotificationLog.Status.DELIVERED)
+                .count()
+            ),
+            "total_failed_30": (
+                NotificationCampaign.objects
+                .filter(
+                    status=NotificationCampaign.Status.FAILED,
+                    created_at__gte=thirty_days_ago,
+                )
+                .count()
+            ),
+            "sending_now": (
+                NotificationCampaign.objects
+                .filter(status=NotificationCampaign.Status.SENDING)
+                .count()
+            ),
+            "total_campaigns": NotificationCampaign.objects.count(),
+        })
+        return context
diff --git a/coldfront_notifications/views/helpers.py b/coldfront_notifications/views/helpers.py
new file mode 100644
index 0000000..6532ffc
--- /dev/null
+++ b/coldfront_notifications/views/helpers.py
@@ -0,0 +1,53 @@
+"""Shared view helpers: mixins and utility functions."""
+import logging
+import threading
+
+from django.contrib import messages
+from django.contrib.auth.mixins import LoginRequiredMixin, UserPassesTestMixin
+from django.db import close_old_connections
+
+from ..campaign_sender import send_notification_campaign
+
+logger = logging.getLogger(__name__)
+
+
+class StaffRequiredMixin(LoginRequiredMixin, UserPassesTestMixin):
+    """Restrict access to staff users, following ColdFront conventions."""
+
+    def test_func(self) -> bool:
+        if not self.request.user.is_staff:
+            messages.error(
+                self.request,
+                "You do not have permission to view the previous page.",
+            )
+            return False
+        return True
+
+
+def dispatch_send(campaign_pk: int) -> None:
+    """Queue the send task on Celery.
+
+    Falls back to a background thread when the broker is unreachable so
+    the HTTP response returns immediately.
+    """
+    try:
+        send_notification_campaign.delay(campaign_pk)
+    except Exception as exc:
+        logger.warning(
+            "Celery broker unreachable (%s) — sending in background thread",
+            exc,
+        )
+
+        def _run() -> None:
+            try:
+                close_old_connections()
+                send_notification_campaign(campaign_pk)
+            except Exception as thread_exc:
+                logger.error(
+                    "Background send thread crashed for campaign %s: %s",
+                    campaign_pk,
+                    thread_exc,
+                    exc_info=True,
+                )
+
+        threading.Thread(target=_run, daemon=True).start()
diff --git a/coldfront_notifications/views/settings.py b/coldfront_notifications/views/settings.py
new file mode 100644
index 0000000..69394fd
--- /dev/null
+++ b/coldfront_notifications/views/settings.py
@@ -0,0 +1,170 @@
+"""Settings views: variables CRUD, senders CRUD, variables JSON, settings page."""
+from __future__ import annotations
+
+from typing import Any
+
+from django.contrib import messages
+from django.http import JsonResponse
+from django.shortcuts import get_object_or_404, redirect
+from django.views import View
+from django.views.generic import ListView, TemplateView
+
+from ..forms import NotificationVariableForm, SenderConfigForm
+from ..models import NotificationTemplate, NotificationVariable, SenderConfig
+from ..template_variable_value_resolver import registry as resolver_registry
+from .helpers import StaffRequiredMixin
+
+
+class VariableListView(StaffRequiredMixin, ListView):
+    """List all active notification variables."""
+
+    model = NotificationVariable
+    template_name = "coldfront_notifications/variable_list.html"
+    context_object_name = "variables"
+
+    def get_queryset(self):
+        return super().get_queryset().filter(is_deleted=False)
+
+
+class VariableFormView(StaffRequiredMixin, TemplateView):
+    """Create or edit a notification variable."""
+
+    template_name = "coldfront_notifications/variable_form.html"
+    model = NotificationVariable
+
+    def get_instance(self):
+        pk = self.kwargs.get("pk")
+        return get_object_or_404(self.model, pk=pk) if pk else None
+
+    def get_context_data(self, **kwargs: Any) -> dict[str, Any]:
+        context = super().get_context_data(**kwargs)
+        instance = self.get_instance()
+        form = kwargs.get("form") or NotificationVariableForm(instance=instance)
+
+        context.update({
+            "form": form,
+            "variable": instance,
+            "query_choices": resolver_registry.choices,
+        })
+        return context
+
+    def post(self, request, *args: Any, **kwargs: Any):
+        instance = self.get_instance()
+        form = NotificationVariableForm(request.POST, instance=instance)
+
+        if form.is_valid():
+            saved_variable = form.save()
+            action_word = "updated" if instance else "created"
+            messages.success(
+                request,
+                f'Variable "{{{{{saved_variable.key}}}}}" {action_word}.',
+            )
+            return redirect("notifications:variable-list")
+
+        return self.render_to_response(self.get_context_data(form=form))
+
+
+class VariableDeleteView(StaffRequiredMixin, TemplateView):
+    """Confirm and soft-delete a notification variable."""
+
+    template_name = "coldfront_notifications/variable_delete_confirm.html"
+
+    def get_context_data(self, **kwargs: Any) -> dict[str, Any]:
+        context = super().get_context_data(**kwargs)
+        instance = get_object_or_404(NotificationVariable, pk=kwargs["pk"])
+        affected_templates = [
+            template
+            for template in NotificationTemplate.objects.filter(is_deleted=False)
+            if instance.key in template.variables
+        ]
+        context.update({
+            "variable": instance,
+            "affected_templates": affected_templates,
+        })
+        return context
+
+    def post(self, request, *args: Any, **kwargs: Any):
+        instance = get_object_or_404(NotificationVariable, pk=kwargs["pk"])
+        instance.is_deleted = True
+        instance.save(update_fields=["is_deleted"])
+        messages.success(
+            request,
+            f'Variable "{{{{{instance.key}}}}}" deleted.',
+        )
+        return redirect("notifications:variable-list")
+
+
+class VariablesJsonView(StaffRequiredMixin, View):
+    """Return the full catalog of notification variables as JSON."""
+
+    def get(self, request, *args: Any, **kwargs: Any) -> JsonResponse:
+        variables = NotificationVariable.objects.filter(is_deleted=False)
+        return JsonResponse({
+            "variables": [
+                {
+                    "key": variable.key,
+                    "label": variable.label,
+                    "description": variable.description,
+                    "example": variable.example,
+                    "source": variable.source,
+                    "input_widget": variable.input_widget,
+                    "is_required": variable.is_required,
+                }
+                for variable in variables
+            ]
+        })
+
+
+class SettingsView(StaffRequiredMixin, TemplateView):
+    """Plugin settings page showing sender configurations."""
+
+    template_name = "coldfront_notifications/settings.html"
+
+    def get_context_data(self, **kwargs: Any) -> dict[str, Any]:
+        context = super().get_context_data(**kwargs)
+        context["senders"] = SenderConfig.objects.all()
+        return context
+
+
+class SenderFormView(StaffRequiredMixin, TemplateView):
+    """Create or edit a sender email configuration."""
+
+    template_name = "coldfront_notifications/sender_form.html"
+    model = SenderConfig
+
+    def get_instance(self):
+        pk = self.kwargs.get("pk")
+        return get_object_or_404(self.model, pk=pk) if pk else None
+
+    def get_context_data(self, **kwargs: Any) -> dict[str, Any]:
+        context = super().get_context_data(**kwargs)
+        instance = self.get_instance()
+        form = kwargs.get("form") or SenderConfigForm(instance=instance)
+        context.update({
+            "form": form,
+            "sender": instance,
+        })
+        return context
+
+    def post(self, request, *args: Any, **kwargs: Any):
+        instance = self.get_instance()
+        form = SenderConfigForm(request.POST, instance=instance)
+
+        if form.is_valid():
+            saved_sender = form.save()
+            action_word = "updated" if instance else "added"
+            messages.success(request, f'Address "{saved_sender.email}" {action_word}.')
+            return redirect("notifications:settings")
+
+        return self.render_to_response(self.get_context_data(form=form))
+
+
+class SenderDeleteView(StaffRequiredMixin, View):
+    """Delete a sender email configuration."""
+
+    def post(self, request, *args: Any, **kwargs: Any):
+        sender = get_object_or_404(SenderConfig, pk=kwargs["pk"])
+        email = sender.email
+        sender.delete()
+        messages.success(request, f'Address "{email}" removed.')
+        return redirect("notifications:settings")
diff --git a/coldfront_notifications/views/templates.py b/coldfront_notifications/views/templates.py
new file mode 100644
index 0000000..9ab711c
--- /dev/null
+++ b/coldfront_notifications/views/templates.py
@@ -0,0 +1,117 @@
+"""Template CRUD views: list, create/edit, delete, and JSON endpoint."""
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from django.contrib import messages
+from django.http import JsonResponse
+from django.shortcuts import get_object_or_404, redirect
+from django.utils.text import slugify
+from django.views import View
+from django.views.generic import ListView, TemplateView
+
+from ..forms import NotificationTemplateForm
+from ..models import NotificationCampaign, NotificationTemplate, NotificationVariable
+from .helpers import StaffRequiredMixin
+
+
+class TemplateListView(StaffRequiredMixin, ListView):
+    """List all active notification templates."""
+
+    model = NotificationTemplate
+    template_name = "coldfront_notifications/template_list.html"
+    context_object_name = "templates"
+
+    def get_queryset(self):
+        return super().get_queryset().filter(is_deleted=False)
+
+
+class TemplateFormView(StaffRequiredMixin, TemplateView):
+    """Create or edit a notification template."""
+
+    template_name = "coldfront_notifications/template_form.html"
+    model = NotificationTemplate
+
+    def get_instance(self):
+        pk = self.kwargs.get("pk")
+        return get_object_or_404(self.model, pk=pk) if pk else None
+
+    def get_context_data(self, **kwargs: Any) -> dict[str, Any]:
+        context = super().get_context_data(**kwargs)
+        instance = self.get_instance()
+        form = kwargs.get("form") or NotificationTemplateForm(instance=instance)
+
+        variables_json = json.dumps([
+            {
+                "key": variable.key,
+                "label": variable.label,
+                "description": variable.description,
+                "example": variable.example,
+                "source": variable.source,
+            }
+            for variable in NotificationVariable.objects.filter(is_deleted=False)
+        ])
+
+        context.update({
+            "form": form,
+            "template": instance,
+            "variables_json": variables_json,
+        })
+        return context
+
+    def post(self, request, *args: Any, **kwargs: Any):
+        instance = self.get_instance()
+        form = NotificationTemplateForm(request.POST, instance=instance)
+
+        if form.is_valid():
+            saved_template = form.save(commit=False)
+            if not saved_template.slug:
+                saved_template.slug = slugify(saved_template.name)
+            saved_template.save()
+            action_word = "updated" if instance else "created"
+            messages.success(request, f'Template "{saved_template.name}" {action_word}.')
+            return redirect("notifications:template-list")
+
+        return self.render_to_response(self.get_context_data(form=form))
+
+
+class TemplateDeleteView(StaffRequiredMixin, TemplateView):
+    """Confirm and soft-delete a notification template."""
+
+    template_name = "coldfront_notifications/template_delete_confirm.html"
+
+    def get_context_data(self, **kwargs: Any) -> dict[str, Any]:
+        context = super().get_context_data(**kwargs)
+        instance = get_object_or_404(NotificationTemplate, pk=kwargs["pk"])
+        context.update({
+            "template": instance,
+            "notification_count": (
+                NotificationCampaign.objects
+                .filter(template=instance)
+                .count()
+            ),
+        })
+        return context
+
+    def post(self, request, *args: Any, **kwargs: Any):
+        instance = get_object_or_404(NotificationTemplate, pk=kwargs["pk"])
+        instance.is_deleted = True
+        instance.save(update_fields=["is_deleted"])
+        messages.success(request, f'Template "{instance.name}" deleted.')
+        return redirect("notifications:template-list")
+
+
+class TemplateJsonView(StaffRequiredMixin, View):
+    """Return a single template's live content as JSON for the compose sidebar."""
+
+    def get(self, request, *args: Any, **kwargs: Any) -> JsonResponse:
+        template = get_object_or_404(NotificationTemplate, pk=kwargs["pk"])
+        return JsonResponse({
+            "id": template.pk,
+            "slug": template.slug,
+            "name": template.name,
+            "subject": template.subject,
+            "body": template.body,
+            "variables": template.variables,
+        })
diff --git a/static/coldfront_notifications/css/compose.css b/static/coldfront_notifications/css/compose.css
deleted file mode 100644
index 9b02095..0000000
--- a/static/coldfront_notifications/css/compose.css
+++ /dev/null
@@ -1,164 +0,0 @@
-.flbl { font-weight: 600; font-size: .82rem; margin-bottom: 4px; display: block; color: #343a40; }
-
-/* recipients: row 1 — filters */
-.recip-filters {
-  display: grid;
-  grid-template-columns: repeat(6, minmax(0, 1fr));
-  gap: 12px;
-  align-items: end;
-}
-
-/* recipients: row 2 — count pill + buttons */
-.recip-actions {
-  display: flex; align-items: center; gap: 10px;
-  margin-top: 14px; padding-top: 12px;
-  border-top: 1px solid #eef0f3;
-}
-.recip-count-pill {
-  background: #fdf5f6; border: 1px solid #e8b4bb;
-  border-radius: 5px; padding: 5px 14px; text-align: center;
-}
-.recip-count-num { font-size: 1.3rem; font-weight: 700; font-family: monospace; color: #A51C30; line-height: 1; }
-.recip-count-lbl { font-size: .68rem; color: #6c757d; margin-top: 2px; }
-.bcc-badge {
-  display: inline-flex; align-items: center; gap: 5px; font-size: .72rem;
-  background: #e8f4fd; border: 1px solid #bee5fb; color: #0c5460;
-  border-radius: 4px; padding: 3px 8px; white-space: nowrap;
-}
-
-/* two col layout */
-.compose-layout { display: flex; gap: 16px; align-items: flex-start; }
-.tmpl-col { width: 200px; flex-shrink: 0; position: sticky; top: 16px; }
-.compose-col { flex: 1; min-width: 0; }
-
-/* template search */
-.tmpl-search-wrap { padding: 6px 8px; border-bottom: 1px solid #e9ecef; }
-.tmpl-search-input {
-  width: 100%; border: 1px solid #ced4da; border-radius: 3px;
-  padding: 4px 8px; font-size: .76rem; outline: none;
-}
-.tmpl-search-input:focus { border-color: #A51C30; }
-
-/* template list */
-.tmpl-list { max-height: 520px; overflow-y: auto; }
-.tmpl-list::-webkit-scrollbar { width: 3px; }
-.tmpl-list::-webkit-scrollbar-thumb { background: #ced4da; border-radius: 2px; }
-.tmpl-item {
-  padding: 10px 12px; border-bottom: 1px solid #f0f2f5;
-  cursor: pointer; transition: background .12s; border-left: 3px solid transparent;
-}
-.tmpl-item:last-child { border-bottom: none; }
-.tmpl-item:hover { background: #f8f9fa; }
-.tmpl-item.active { background: #fdf0f2; border-left-color: #A51C30; }
-.tmpl-item.active .tmpl-name { color: #A51C30; }
-.tmpl-name  { font-weight: 600; font-size: .8rem; margin-bottom: 2px; }
-.tmpl-slug  { font-family: monospace; font-size: .65rem; color: #6c757d; margin-bottom: 4px; }
-.tmpl-vars  { display: flex; flex-wrap: wrap; gap: 2px; }
-.tmpl-var-sm {
-  font-family: monospace; font-size: .62rem; background: #eef2f9; color: #3d5080;
-  border: 1px solid #c8d4ec; padding: 1px 4px; border-radius: 2px;
-}
-
-/* vars + body */
-.vars-body-wrap {
-  display: flex; border: 1px solid #ced4da; border-radius: 4px; overflow: hidden;
-}
-.vars-col {
-  width: 155px; flex-shrink: 0; border-right: 1px solid #dee2e6;
-  background: #f8f9fa; display: flex; flex-direction: column;
-}
-.vars-col-hdr {
-  padding: 6px 9px; font-size: .67rem; font-weight: 700; text-transform: uppercase;
-  letter-spacing: .07em; color: #6c757d; background: #f0f2f5; border-bottom: 1px solid #dee2e6;
-}
-.vars-col-search { padding: 6px 7px; border-bottom: 1px solid #dee2e6; }
-.vars-col-search input {
-  width: 100%; border: 1px solid #ced4da; border-radius: 3px;
-  padding: 3px 6px; font-size: .74rem; outline: none; background: #fff;
-}
-.vars-col-search input:focus { border-color: #A51C30; }
-.vars-col-list {
-  overflow-y: auto; padding: 5px 6px; display: flex; flex-direction: column;
-  gap: 3px; max-height: 340px; flex: 1;
-}
-.vars-col-list::-webkit-scrollbar { width: 3px; }
-.vars-col-list::-webkit-scrollbar-thumb { background: #ced4da; border-radius: 2px; }
-.var-btn {
-  font-family: monospace; font-size: .71rem; background: #fff; color: #3d5080;
-  border: 1px solid #c8d4ec; padding: 4px 7px; border-radius: 3px; cursor: pointer;
-  transition: background .1s; text-align: left;
-  display: block; width: 100%;
-}
-.var-btn:hover { background: #d5e0f5; color: #1a2d5a; border-color: #a0b8e0; }
-.vars-empty { font-size: .74rem; color: #adb5bd; padding: 6px 4px; }
-
-.body-col-inner { flex: 1; min-width: 0; display: flex; }
-#id_body {
-  flex: 1; border: none; border-radius: 0; outline: none;
-  font-family: 'SFMono-Regular', Consolas, monospace;
-  font-size: .82rem; line-height: 1.65; padding: 10px;
-  resize: none; min-height: 340px; width: 100%;
-}
-#id_body:focus { box-shadow: none; }
-
-/* send bar */
-.send-warn {
-  display: flex; gap: 9px; align-items: flex-start;
-  background: #fff8e1; border: 1px solid #ffe082; border-radius: 4px;
-  padding: 9px 12px; font-size: .82rem; margin-bottom: 12px;
-}
-.send-warn i { color: #e65100; margin-top: 1px; flex-shrink: 0; }
-
-/* recipient modal — top bar with search */
-.recip-topbar {
-  display: flex; justify-content: space-between; align-items: center;
-  padding: 8px 12px; background: #f8f9fa; border-bottom: 1px solid #dee2e6;
-  font-size: .78rem; color: #6c757d; gap: 12px;
-}
-.recip-search { width: 220px !important; font-size: .78rem !important; flex-shrink: 0; }
-
-/* recipient modal — fixed-height scrollable table */
-.recip-table-wrap {
-  height: 530px; overflow-y: auto;
-}
-.recip-table-wrap .table { margin-bottom: 0; }
-.recip-table-wrap thead th {
-  position: sticky; top: 0; z-index: 1; background: #e9ecef;
-}
-
-/* recipient toolbar — always visible below the scroll area */
-.recip-toolbar {
-  display: flex; align-items: center; justify-content: space-between;
-  padding: 8px 16px; border-top: 1px solid #dee2e6; background: #f8f9fa;
-  border-radius: 0 0 .3rem .3rem;
-}
-.recip-toolbar-left { font-size: .78rem; color: #6c757d; flex-shrink: 0; }
-.recip-toolbar-center { display: flex; align-items: center; gap: 4px; }
-.recip-toolbar-right { display: flex; align-items: center; flex-shrink: 0; }
-.recip-page-info {
-  font-size: .78rem; margin: 0 6px; white-space: nowrap; min-width: 100px; text-align: center;
-}
-.recip-page-size-label {
-  font-size: .78rem; font-weight: 400; color: #6c757d;
-  display: inline-flex; align-items: center; gap: 4px; margin: 0; white-space: nowrap;
-}
-.recip-page-size-select {
-  width: auto !important; display: inline-block; padding: 2px 6px;
-  font-size: .78rem; height: auto !important;
-}
-
-/* select2 overrides */
-.select2-container { width: 100% !important; }
-.select2-container--default .select2-selection--multiple {
-  border-color: #ced4da; border-radius: 4px; min-height: 36px;
-  max-height: 90px; overflow-y: auto;
-}
-.select2-container--default.select2-container--focus .select2-selection--multiple { border-color: #A51C30; box-shadow: 0 0 0 .15rem rgba(165,28,48,.13); }
-.select2-container--default .select2-results__option--highlighted[aria-selected] { background: #A51C30 !important; }
-.select2-container--default .select2-selection__choice {
-  background: #A51C30 !important; border-color: #8a1728 !important; color: #fff !important;
-  border-radius: 3px; font-size: .75rem;
-  max-width: 100%; overflow: hidden; text-overflow: ellipsis; word-break: break-word;
-}
-.select2-container--default .select2-selection__choice__remove { color: rgba(255,255,255,.7) !important; }
-.select2-container--default .select2-selection__choice__remove:hover { color: #fff !important; }
diff --git a/static/coldfront_notifications/css/template_form.css b/static/coldfront_notifications/css/template_form.css
deleted file mode 100644
index de474fd..0000000
--- a/static/coldfront_notifications/css/template_form.css
+++ /dev/null
@@ -1,44 +0,0 @@
-.flbl { font-weight: 600; font-size: .82rem; margin-bottom: 4px; display: block; color: #343a40; }
-
-.vars-body-wrap {
-  display: flex; border: 1px solid #ced4da; border-radius: 4px; overflow: hidden;
-}
-.vars-col {
-  width: 155px; flex-shrink: 0; border-right: 1px solid #dee2e6;
-  background: #f8f9fa; display: flex; flex-direction: column;
-}
-.vars-col-hdr {
-  padding: 6px 9px; font-size: .67rem; font-weight: 700; text-transform: uppercase;
-  letter-spacing: .07em; color: #6c757d; background: #f0f2f5;
-  border-bottom: 1px solid #dee2e6; white-space: nowrap;
-}
-.vars-col-search { padding: 6px 7px; border-bottom: 1px solid #dee2e6; }
-.vars-col-search input {
-  width: 100%; border: 1px solid #ced4da; border-radius: 3px;
-  padding: 3px 6px; font-size: .74rem; outline: none; background: #fff;
-}
-.vars-col-search input:focus { border-color: #A51C30; }
-.vars-col-list {
-  overflow-y: auto; padding: 5px 6px;
-  display: flex; flex-direction: column; gap: 3px;
-  max-height: 380px; flex: 1;
-}
-.vars-col-list::-webkit-scrollbar { width: 3px; }
-.vars-col-list::-webkit-scrollbar-thumb { background: #ced4da; border-radius: 2px; }
-.var-btn {
-  font-family: monospace; font-size: .71rem; background: #fff; color: #3d5080;
-  border: 1px solid #c8d4ec; padding: 4px 7px; border-radius: 3px; cursor: pointer;
-  transition: background .1s; text-align: left;
-  display: block; width: 100%;
-}
-.var-btn:hover { background: #d5e0f5; color: #1a2d5a; border-color: #a0b8e0; }
-.vars-empty { font-size: .74rem; color: #adb5bd; padding: 6px 4px; }
-
-.body-col-inner { flex: 1; min-width: 0; display: flex; }
-#id_body {
-  flex: 1; border: none; border-radius: 0; outline: none;
-  font-family: 'SFMono-Regular', Consolas, monospace;
-  font-size: .82rem; line-height: 1.65; padding: 10px;
-  resize: none; min-height: 380px; width: 100%;
-}
-#id_body:focus { box-shadow: none; }
diff --git a/static/coldfront_notifications/css/variable_form.css b/static/coldfront_notifications/css/variable_form.css
deleted file mode 100644
index 7fc5507..0000000
--- a/static/coldfront_notifications/css/variable_form.css
+++ /dev/null
@@ -1,16 +0,0 @@
-.flbl { font-weight: 600; font-size: .82rem; margin-bottom: 4px; display: block; color: #343a40; }
-.radio-card {
-  border: 1px solid #ced4da; border-radius: 5px; padding: 10px 12px;
-  cursor: pointer; transition: border-color .1s, background .1s;
-  margin-bottom: 0;
-}
-.radio-card input[type=radio] { margin-right: 8px; }
-.radio-card:hover { background: #f8f9fa; }
-.radio-card.active { border-color: #A51C30; background: #fdf5f6; }
-.conditional { display: none; }
-.conditional.show { display: block; }
-.example-box {
-  background: #f8f9fa; border: 1px solid #dee2e6; border-radius: 4px;
-  padding: 10px 14px; font-size: .8rem;
-}
-.example-box code { font-size: .78rem; }
diff --git a/static/coldfront_notifications/js/campaign_detail.js b/static/coldfront_notifications/js/campaign_detail.js
deleted file mode 100644
index 2ff440c..0000000
--- a/static/coldfront_notifications/js/campaign_detail.js
+++ /dev/null
@@ -1,67 +0,0 @@
-// ── campaign_detail.js ──────────────────────────────────────────
-// Expects globals set inline by the Django template:
-//   CAMPAIGN_STATUS       - string ('queued', 'sending', 'sent', etc.)
-//   CAMPAIGN_PROGRESS_URL - URL for the progress JSON endpoint
-
-var STATUS_CLASSES = {
-  sent:    'badge-success',
-  sending: 'badge-primary',
-  partial: 'badge-warning',
-  queued:  'badge-info',
-  draft:   'badge-secondary',
-  failed:  'badge-danger'
-};
-
-function updateProgress(data) {
-  CAMPAIGN_STATUS = data.status;
-  $('#statusBadge')
-    .text(data.status_display)
-    .attr('class', 'badge ' + (STATUS_CLASSES[data.status] || 'badge-secondary'));
-  $('#totalCount').text(data.recipient_count);
-  $('#deliveredCount').text(data.delivered_count);
-  $('#failedCount').text(data.failed_count);
-  if (data.failed_count > 0) {
-    $('#failedCount').css('color', '#dc3545');
-  }
-  $('#progressBar').css('width', data.delivery_pct + '%');
-  $('#progressPct').text(data.delivery_pct + '% delivery rate');
-  if (data.recipient_count > 0) {
-    $('#progressWrap').show();
-  }
-}
-
-function pollProgress() {
-  if (CAMPAIGN_STATUS !== 'sending' && CAMPAIGN_STATUS !== 'queued') return;
-  $.getJSON(CAMPAIGN_PROGRESS_URL, function(data) {
-    updateProgress(data);
-    if (data.status === 'sending' || data.status === 'queued') {
-      setTimeout(pollProgress, 3000);
-    } else {
-      // Final state reached — reload to get the full log table.
-      location.reload();
-    }
-  }).fail(function() {
-    setTimeout(pollProgress, 5000);
-  });
-}
-
-$(function(){
-  // Only init DataTable when there are real data rows.
-  var realRows = $('#logTable tbody tr td:not([colspan])').length;
-  if (realRows > 0) {
-    $('#logTable').DataTable({ order:[[2,'asc']], columnDefs:[{orderable:false,targets:[3]}] });
-  }
-  // Start polling if campaign is in-flight.
-  if (CAMPAIGN_STATUS === 'sending' || CAMPAIGN_STATUS === 'queued') {
-    setTimeout(pollProgress, 3000);
-  }
-});
-
-$(document).on('click', '.view-email-btn', function() {
-  $('#em-from').text($(this).attr('data-from'));
-  $('#em-replyto').text($(this).attr('data-replyto') || '—');
-  $('#em-to').text($(this).attr('data-email'));
-  $('#em-subject').text($(this).attr('data-subject'));
-  $('#em-body').text($(this).attr('data-body'));
-  $('#emailViewModal').modal('show');
-});
diff --git a/static/coldfront_notifications/js/compose.js b/static/coldfront_notifications/js/compose.js
deleted file mode 100644
index d6ab45f..0000000
--- a/static/coldfront_notifications/js/compose.js
+++ /dev/null
@@ -1,624 +0,0 @@
-// ── compose.js ──────────────────────────────────────────────────
-// Expects the following globals set inline by the Django template:
-//   TEMPLATES          - array of template objects
-//   VARIABLES          - array of variable objects
-//   URLS.previewRender - URL for preview-render endpoint
-//   URLS.filterOptions - URL for filter-options endpoint
-//   URLS.validate      - URL for validate endpoint
-//   URLS.recipientCount - URL for recipient-count endpoint
-
-// Index VARIABLES by key for O(1) lookup
-var VAR_BY_KEY = {};
-VARIABLES.forEach(function(v) { VAR_BY_KEY[v.key] = v; });
-
-// ── Render chip list ─────────────────────────────────────────────
-function renderVars(vars, filter) {
-  var $list = $('#varsList').empty();
-  var filtered = filter
-    ? vars.filter(function(v) { return v.toLowerCase().indexOf(filter.toLowerCase()) !== -1; })
-    : vars;
-  if (!filtered.length) {
-    $list.append('<div class="vars-empty">No matches</div>');
-    return;
-  }
-  filtered.forEach(function(v) {
-    var token   = '{{' + v + '}}';
-    var def     = VAR_BY_KEY[v] || {};
-    var example = def.example || '';
-    var badge   = def.source === 'manual' ? ' [manual]' : '';
-    var $btn = $('<button type="button" class="var-btn"></button>')
-      .attr('data-var', token)
-      .attr('title', (def.description || def.label || '') + (example ? ' — ' + example : ''))
-      .html(
-        '<span style="display:block;font-family:monospace;font-size:.7rem;">' + token + badge + '</span>' +
-        '<span style="display:block;font-size:.65rem;color:#6c757d;margin-top:1px;">' + example + '</span>'
-      );
-    $list.append($btn);
-  });
-}
-
-// ── Extract tokens from subject + body ───────────────────────────
-var TOKEN_RE = /\{\{(\w+)\}\}/g;
-function extractTokens() {
-  var text = ($('#id_subject').val() || '') + '\n' + ($('#id_body').val() || '');
-  var seen = {};
-  var out = [];
-  var m;
-  while ((m = TOKEN_RE.exec(text))) {
-    if (!seen[m[1]]) { seen[m[1]] = true; out.push(m[1]); }
-  }
-  return out;
-}
-
-// ── Load template into compose fields ────────────────────────────
-// Always fetch fresh content from the server — avoids stale data when
-// an admin edits a template in another tab and returns to compose.
-var ACTIVE_VARS = [];
-function loadTemplate($el) {
-  var id   = parseInt($el.attr('data-id') || 0);
-  var slug = $el.attr('data-slug') || '';
-  $('#active-slug').text(slug);
-  $('#hidden_template_id').val(id);
-  $('#varSearch').val('');
-  $('#validationPanel').hide();
-  $('#sendBtn').prop('disabled', true);
-  $('#sendWarn').hide();
-  setDedupeUsers([]);
-  if (!id) { ACTIVE_VARS = []; renderVars([], ''); return; }
-  $.getJSON('/notifications/templates/' + id + '/json/', function(t) {
-    $('#id_subject').val(t.subject || '');
-    $('#id_body').val(t.body || '');
-    ACTIVE_VARS = t.variables || [];
-    renderVars(ACTIVE_VARS, '');
-    if (HAS_VALIDATED) runValidation();
-  }).fail(function() {
-    ACTIVE_VARS = [];
-    renderVars([], '');
-  });
-}
-
-// ── Template click ───────────────────────────────────────────────
-$(document).on('click', '.tmpl-item', function() {
-  $('.tmpl-item').removeClass('active');
-  $(this).addClass('active');
-  loadTemplate($(this));
-});
-
-// ── Template search ─────────────────────────────────────────────
-$(document).on('input', '#tmplSearch', function() {
-  var q = $(this).val().toLowerCase();
-  $('.tmpl-item').each(function() {
-    var text = $(this).text().toLowerCase();
-    $(this).toggle(!q || text.indexOf(q) !== -1);
-  });
-});
-
-// ── Variable search ──────────────────────────────────────────────
-$(document).on('input', '#varSearch', function() {
-  renderVars(ACTIVE_VARS, $(this).val());
-});
-
-// ── Variable insert at cursor ────────────────────────────────────
-$(document).on('click', '.var-btn', function() {
-  var ta    = document.getElementById('id_body');
-  var token = $(this).attr('data-var');
-  var s = ta.selectionStart, e = ta.selectionEnd;
-  ta.value = ta.value.substring(0, s) + token + ta.value.substring(e);
-  ta.selectionStart = ta.selectionEnd = s + token.length;
-  ta.focus();
-});
-
-// ── Preview modal ────────────────────────────────────────────────
-// Samples returned from /preview-render/; indexed by select option value.
-var PREVIEW_SAMPLES = [];
-
-function renderPreviewSample(idx) {
-  var s = PREVIEW_SAMPLES[idx];
-  if (!s) {
-    // "Template" — no recipient, raw tokens
-    $('#prev-to').text('—');
-    $('#prev-subject').text($('#id_subject').val() || '—');
-    $('#prev-body').text($('#id_body').val() || '—');
-    $('#prev-error').hide();
-    $('#prev-footer').text('Showing template with literal placeholders');
-    return;
-  }
-  $('#prev-to').text((s.recipient.name || s.recipient.username) + ' <' + s.recipient.email + '>');
-  $('#prev-subject').text(s.subject || '—');
-  $('#prev-body').text(s.body || '—');
-  if (s.error) {
-    $('#prev-error').text('Resolution error: ' + s.error).show();
-  } else {
-    $('#prev-error').hide();
-  }
-  var ctx = [];
-  if (s.recipient.project)    ctx.push('project: ' + s.recipient.project);
-  if (s.recipient.allocation) ctx.push('allocation: ' + s.recipient.allocation);
-  $('#prev-footer').text(ctx.join(' · ') || 'recipient-only context');
-}
-
-$(document).on('click', '#previewBtn', function() {
-  $('#prev-from').text($('#id_sender').val());
-  $('#prev-replyto').text($('#id_reply_to').val());
-  // Show the raw template immediately while samples load
-  PREVIEW_SAMPLES = [];
-  $('#prev-recipient-picker').html('<option value="">— Template (raw placeholders) —</option>'
-    + '<option disabled>Loading samples…</option>');
-  renderPreviewSample(null);
-  $('#prev-scope-badge').text('');
-  $('#previewModal').modal('show');
-
-  $.ajax({
-    url: URLS.previewRender,
-    type: 'POST',
-    data: {
-      csrfmiddlewaretoken: $('input[name=csrfmiddlewaretoken]').val(),
-      subject:      $('#id_subject').val() || '',
-      body:         $('#id_body').val()    || '',
-      filters:      JSON.stringify(collectFilters()),
-      dedupe_users: JSON.stringify(getDedupeUsers()),
-    },
-    success: function(data) {
-      PREVIEW_SAMPLES = data.samples || [];
-      var opts = ['<option value="">— Template (raw placeholders) —</option>'];
-      PREVIEW_SAMPLES.forEach(function(s, i) {
-        var lbl = (s.recipient.name || s.recipient.username) + ' <' + s.recipient.email + '>';
-        if (s.recipient.project) lbl += ' · ' + s.recipient.project;
-        opts.push('<option value="' + i + '">' + lbl + '</option>');
-      });
-      if (!PREVIEW_SAMPLES.length) {
-        opts.push('<option disabled>(no matching recipients)</option>');
-      }
-      $('#prev-recipient-picker').html(opts.join(''));
-      if (data.scope) $('#prev-scope-badge').text('scope: ' + data.scope + ' · ' + (data.total_emails || 0) + ' total');
-
-      // Auto-select the first real sample if available
-      if (PREVIEW_SAMPLES.length) {
-        $('#prev-recipient-picker').val('0');
-        renderPreviewSample(0);
-      } else {
-        renderPreviewSample(null);
-      }
-    },
-    error: function() {
-      $('#prev-recipient-picker').html('<option value="">— Template (raw placeholders) —</option>');
-      $('#prev-footer').text('Preview failed to load — showing raw template');
-    },
-  });
-});
-
-$(document).on('change', '#prev-recipient-picker', function() {
-  var v = $(this).val();
-  renderPreviewSample(v === '' ? null : parseInt(v, 10));
-});
-
-// ── Recipient filters stale on change ────────────────────────────
-$(document).on('change', '.s2', function() {
-  $('#recipNum').text('?');
-  $('#recipLbl').text('press Validate');
-  $('#sendBtn').prop('disabled', true);
-  $('#previewRecipBtn').prop('disabled', true);
-  $('#sendWarn').hide();
-  // Changing filters may change the user pool — dedupe choices are user-scoped,
-  // so reset them to avoid stale selections.
-  setDedupeUsers([]);
-});
-
-// ── Cascading filter options ─────────────────────────────────────
-// Rebuild a <select> from an option list, keeping still-valid user picks.
-// items: [{id, label}] or ['name', 'name', ...]
-function rebuildSelect($sel, items) {
-  var current = $sel.val() || [];
-  var normalized = (items || []).map(function(it) {
-    return (typeof it === 'string') ? { id: it, label: it } : it;
-  });
-  var validIds = {};
-  normalized.forEach(function(i) { validIds[String(i.id)] = true; });
-  var keep = current.filter(function(v) { return validIds[String(v)]; });
-  var html = normalized.map(function(i) {
-    var esc = $('<div>').text(i.label).html();
-    return '<option value="' + i.id + '">' + esc + '</option>';
-  }).join('');
-  // change.select2 updates the widget without firing a generic 'change',
-  // so the stale handler above doesn't loop on programmatic rebuilds.
-  $sel.html(html).val(keep).trigger('change.select2');
-}
-
-// Downstream targets for each source filter (top-down cascade).
-var DOWNSTREAM = {
-  project:    { dept: true, alloc: true, resource: true, status: true, role: true },
-  dept:       { alloc: true, resource: true, status: true, role: true },
-  allocation: { resource: true, status: true },
-  resource:   { status: true }
-};
-
-function cascadeFrom(source) {
-  var targets = DOWNSTREAM[source];
-  if (!targets) return;
-
-  $.ajax({
-    url: URLS.filterOptions,
-    type: 'POST',
-    data: {
-      csrfmiddlewaretoken: $('input[name=csrfmiddlewaretoken]').val(),
-      projects:    $('#f_project').val()    || [],
-      allocations: $('#f_allocation').val() || [],
-      resources:   $('#f_resource').val()   || [],
-      departments: $('#f_dept').val()       || []
-    },
-    traditional: true,
-    success: function(data) {
-      if (targets.alloc)    rebuildSelect($('#f_allocation'), data.allocations);
-      if (targets.dept)     rebuildSelect($('#f_dept'),       data.departments);
-      if (targets.resource) rebuildSelect($('#f_resource'),   data.resources);
-      if (targets.status)   rebuildSelect($('#f_status'),     data.statuses);
-      if (targets.role)     rebuildSelect($('#f_role'),       data.roles);
-    }
-  });
-}
-
-$(document).on('change', '#f_project',    function() { cascadeFrom('project'); });
-$(document).on('change', '#f_dept',       function() { cascadeFrom('dept'); });
-$(document).on('change', '#f_allocation', function() { cascadeFrom('allocation'); });
-$(document).on('change', '#f_resource',   function() { cascadeFrom('resource'); });
-
-// ── Validate & count (AJAX) ─────────────────────────────────────
-function collectFilters() {
-  return {
-    projects:    $('#f_project').val()    || [],
-    allocations: $('#f_allocation').val() || [],
-    resources:   $('#f_resource').val()   || [],
-    departments: $('#f_dept').val()       || [],
-    statuses:    $('#f_status').val()     || [],
-    roles:       $('#f_role').val()       || [],
-  };
-}
-function getDedupeUsers() {
-  try {
-    var v = JSON.parse($('#h_dedupe_users').val() || '[]');
-    return Array.isArray(v) ? v : [];
-  } catch (e) { return []; }
-}
-function setDedupeUsers(list) {
-  $('#h_dedupe_users').val(JSON.stringify(list || []));
-}
-
-function runValidation() {
-  var $btn = $('#recalcBtn');
-  $btn.prop('disabled', true).html('<i class="fas fa-spinner fa-spin"></i>');
-
-  $.ajax({
-    url: URLS.validate,
-    type: 'POST',
-    data: {
-      csrfmiddlewaretoken: $('input[name=csrfmiddlewaretoken]').val(),
-      subject:      $('#id_subject').val() || '',
-      body:         $('#id_body').val()    || '',
-      filters:      JSON.stringify(collectFilters()),
-      dedupe_users: JSON.stringify(getDedupeUsers()),
-    },
-    success: function(data) {
-      var users = data.user_count || 0;
-      var emails = data.email_count || 0;
-      $('#recipNum').text(users);
-      $('#recipLbl').text('users');
-      $('#emailCount').text(emails);
-      $('#warnCount').text(emails);
-      $('#sendCount').text(emails);
-      $('#hidden_recip_count').val(emails);
-
-      // Multi-email users
-      if (data.multi_emails && data.multi_emails.length) {
-        $('#multiCount').text(data.multi_emails.length);
-        $('#multiBadge').show();
-        var lines = data.multi_emails.map(function(m) {
-          return '<li><code>' + m.username + '</code> — ' + m.count + ' emails</li>';
-        }).join('');
-        $('#multiList').html(lines);
-        $('#multiWarnText').text(
-          data.multi_emails.length + ' user(s) will receive multiple emails ' +
-          '(different project/allocation context each)'
-        );
-        $('#multiWarn').show();
-      } else {
-        $('#multiBadge').hide();
-        $('#multiWarn').hide();
-      }
-
-      // Preview recipients is independent of variable resolution — as
-      // long as the filter matches anyone, admins can see who's in scope.
-      $('#previewRecipBtn').prop('disabled', users === 0);
-      HAS_VALIDATED = true;
-
-      // Errors and missing tokens
-      $('#validationPanel').show();
-      var errs = data.errors || [];
-      var miss = data.missing_tokens || [];
-      if (errs.length || miss.length) {
-        var title = [];
-        if (miss.length) title.push(miss.length + ' unknown token(s): ' + miss.join(', '));
-        if (errs.length) title.push(errs.length + ' resolution error(s)');
-        $('#validationBadTitle').text('Blocking — ' + title.join('; '));
-        var $ul = $('#validationErrors').empty();
-        errs.slice(0, 30).forEach(function(e) {
-          $ul.append('<li><code>' + e.email + '</code>: <code>{{' + e.token + '}}</code> — ' + e.reason + '</li>');
-        });
-        if (errs.length > 30) $ul.append('<li>… and ' + (errs.length - 30) + ' more</li>');
-        $('#validationBad').show();
-        $('#validationOK').hide();
-        $('#sendBtn').prop('disabled', true);
-        $('#sendWarn').hide();
-      } else {
-        $('#validationOK')
-          .html('<i class="fas fa-check-circle mr-1"></i>' +
-                users + ' users → <strong>' + emails + '</strong> emails. All variables resolve.')
-          .show();
-        $('#validationBad').hide();
-        $('#sendBtn').prop('disabled', emails === 0);
-        if (emails > 0) $('#sendWarn').show();
-      }
-    },
-    error: function() {
-      $('#recipNum').text('—');
-      $('#recipLbl').text('Error — try again');
-    },
-    complete: function() {
-      $btn.prop('disabled', false).html('<i class="fas fa-check-double mr-1"></i>Validate');
-    }
-  });
-}
-
-$(document).on('click', '#recalcBtn, #recalcBtn2', function() { runValidation(); });
-
-$(document).on('click', '#multiShowBtn', function() {
-  $('#multiList').toggle();
-});
-
-// Body/subject input changes invalidate previous validation.
-$(document).on('input', '#id_body, #id_subject', function() {
-  $('#validationPanel').hide();
-  $('#sendBtn').prop('disabled', true);
-  $('#sendWarn').hide();
-});
-
-// ── Recipient preview modal ──────────────────────────────────────
-// Tracks the full set of tuples fetched from the server for this session.
-var PREVIEW_ROWS  = [];   // current page of rows from server
-var PREVIEW_SCOPE = null; // "user" | "project" | "allocation"
-var PREVIEW_PAGE  = 1;
-var PREVIEW_TOTAL_PAGES = 1;
-var PREVIEW_TOTAL = 0;
-var HAS_VALIDATED = false; // true after first validate; triggers auto-revalidation on changes
-
-function renderPreviewRows() {
-  // Group rows by username preserving order.
-  var order = [], byUser = {};
-  PREVIEW_ROWS.forEach(function(r) {
-    var u = r.username;
-    if (!(u in byUser)) { order.push(u); byUser[u] = []; }
-    byUser[u].push(r);
-  });
-
-  var dedupeSet = {};
-  getDedupeUsers().forEach(function(u) { dedupeSet[u] = true; });
-
-  // Build a set from the server's cross-page multi-user list for O(1) lookup.
-  var multiSet = {};
-  ALL_MULTI_USERS.forEach(function(u) { multiSet[u] = true; });
-
-  var html = '';
-  order.forEach(function(u) {
-    var group = byUser[u];
-    var isMulti = !!multiSet[u];  // uses cross-page list, not just this page
-    var isDeduped = !!dedupeSet[u];
-    group.forEach(function(r, idx) {
-      var first = idx === 0;
-      // Strike-through rows after the first for deduped users (on this page)
-      var muted = (isDeduped && !first);
-      // If deduped and only 1 row on this page, still show strike-through
-      if (isDeduped && group.length === 1 && isMulti) muted = true;
-      var styleAttr = muted
-        ? ' style="color:#aab0b7;text-decoration:line-through;font-style:italic;"'
-        : '';
-      var cbCell = '';
-      if (first && isMulti) {
-        cbCell = '<td style="text-align:center;"><input type="checkbox" class="dedupe-cb" '
-               + 'data-username="' + u + '"'
-               + (isDeduped ? ' checked' : '')
-               + ' title="send only one email to ' + u + '"></td>';
-      } else {
-        cbCell = '<td></td>';
-      }
-      html += '<tr' + styleAttr + '>'
-        + cbCell
-        + '<td>' + (r.full_name||'') + (isMulti && first ? ' <span class="badge badge-warning ml-1" style="font-size:.6rem;">multi</span>' : '') + '</td>'
-        + '<td style="font-family:monospace;font-size:.78rem;">' + (r.email||'') + '</td>'
-        + '<td>' + (r.role||'') + '</td>'
-        + '<td>' + (r.project||'') + '</td>'
-        + '<td style="font-size:.78rem;">' + (r.allocation||'') + '</td>'
-        + '</tr>';
-    });
-  });
-  $('#recipRows').html(html || '<tr><td colspan="6" class="text-center text-muted py-3">No recipients matched.</td></tr>');
-
-  // Effective email count = sum of group length, capped at 1 when deduped
-  var effective = 0;
-  order.forEach(function(u) {
-    effective += dedupeSet[u] ? 1 : byUser[u].length;
-  });
-  var scopeLbl = PREVIEW_SCOPE ? 'scope: ' + PREVIEW_SCOPE : '';
-  $('#recipModalCount').text(
-    effective + ' emails → ' + order.length + ' users'
-    + (effective !== PREVIEW_ROWS.length ? ' (was ' + PREVIEW_ROWS.length + ' before dedupe)' : '')
-  );
-  if (PREVIEW_SCOPE) { $('#recipModalScope').text(scopeLbl).show(); } else { $('#recipModalScope').hide(); }
-
-}
-
-function getPageSize() {
-  return parseInt($('#recipPageSize').val(), 10) || 10;
-}
-
-function updatePaginationControls() {
-  var atFirst = PREVIEW_PAGE <= 1;
-  var atLast = PREVIEW_PAGE >= PREVIEW_TOTAL_PAGES;
-  $('#recipPageInfo').text('Page ' + PREVIEW_PAGE + ' of ' + PREVIEW_TOTAL_PAGES);
-  $('#recipFirstBtn').prop('disabled', atFirst);
-  $('#recipPrevBtn').prop('disabled', atFirst);
-  $('#recipNextBtn').prop('disabled', atLast);
-  $('#recipLastBtn').prop('disabled', atLast);
-}
-
-function fetchPreviewPage(page) {
-  PREVIEW_PAGE = page || 1;
-  $('#recipSearch').val('');
-  $('#recipRows').html('<tr><td colspan="6" class="text-center text-muted py-3"><i class="fas fa-spinner fa-spin mr-1"></i>Loading…</td></tr>');
-
-  $.ajax({
-    url: URLS.recipientCount,
-    type: 'POST',
-    data: {
-      csrfmiddlewaretoken: $('input[name=csrfmiddlewaretoken]').val(),
-      projects:     $('#f_project').val()    || [],
-      allocations:  $('#f_allocation').val() || [],
-      departments:  $('#f_dept').val()       || [],
-      resources:    $('#f_resource').val()   || [],
-      alloc_status: $('#f_status').val()     || [],
-      roles:        $('#f_role').val()       || [],
-      subject:      $('#id_subject').val()   || '',
-      body:         $('#id_body').val()      || '',
-      dedupe_users: JSON.stringify(getDedupeUsers()),
-      preview:      'true',
-      page:         PREVIEW_PAGE,
-      page_size:    getPageSize(),
-    },
-    traditional: true,
-    success: function(data) {
-      PREVIEW_ROWS        = data.recipients || [];
-      PREVIEW_SCOPE       = data.scope || null;
-      PREVIEW_TOTAL       = data.count || 0;
-      PREVIEW_TOTAL_PAGES = data.total_pages || 1;
-      PREVIEW_PAGE        = data.page || 1;
-      ALL_MULTI_USERS = (data.multi_users || []).map(function(m) { return m.username; });
-      renderPreviewRows();
-      // Show dedupe-all row if any multi-email users exist across all pages
-      if (ALL_MULTI_USERS.length) {
-        $('#dedupeAllRow').show();
-        var allDeduped = ALL_MULTI_USERS.every(function(u) {
-          return getDedupeUsers().indexOf(u) !== -1;
-        });
-        $('#dedupeAllCb').prop('checked', allDeduped);
-      } else {
-        $('#dedupeAllRow').hide();
-      }
-      updatePaginationControls();
-    },
-    error: function() {
-      $('#recipRows').html('<tr><td colspan="6" class="text-center text-danger py-3">Failed to load.</td></tr>');
-    }
-  });
-}
-
-$(document).on('click', '#previewRecipBtn', function() {
-  $('#recipModal').modal('show');
-  fetchPreviewPage(1);
-});
-$(document).on('click', '#recipFirstBtn', function() {
-  if (PREVIEW_PAGE > 1) fetchPreviewPage(1);
-});
-$(document).on('click', '#recipPrevBtn', function() {
-  if (PREVIEW_PAGE > 1) fetchPreviewPage(PREVIEW_PAGE - 1);
-});
-$(document).on('click', '#recipNextBtn', function() {
-  if (PREVIEW_PAGE < PREVIEW_TOTAL_PAGES) fetchPreviewPage(PREVIEW_PAGE + 1);
-});
-$(document).on('click', '#recipLastBtn', function() {
-  if (PREVIEW_PAGE < PREVIEW_TOTAL_PAGES) fetchPreviewPage(PREVIEW_TOTAL_PAGES);
-});
-$(document).on('change', '#recipPageSize', function() {
-  fetchPreviewPage(1);
-});
-
-// Client-side search: filter visible rows in the current page
-$(document).on('input', '#recipSearch', function() {
-  var q = $(this).val().toLowerCase();
-  $('#recipRows tr').each(function() {
-    var text = $(this).text().toLowerCase();
-    $(this).toggle(!q || text.indexOf(q) !== -1);
-  });
-});
-
-// All multi-email usernames across all pages (from server response).
-var ALL_MULTI_USERS = [];
-
-// Bulk dedupe: toggle ALL multi-email users across all pages.
-$(document).on('change', '#dedupeAllCb', function() {
-  if ($(this).is(':checked')) {
-    setDedupeUsers(ALL_MULTI_USERS.slice());
-  } else {
-    setDedupeUsers([]);
-  }
-  renderPreviewRows();
-  runValidation();
-});
-
-// Per-user dedupe toggle inside the modal.
-$(document).on('change', '.dedupe-cb', function() {
-  var username = $(this).attr('data-username');
-  var cur = getDedupeUsers();
-  var idx = cur.indexOf(username);
-  if ($(this).is(':checked')) {
-    if (idx === -1) cur.push(username);
-  } else {
-    if (idx !== -1) cur.splice(idx, 1);
-  }
-  setDedupeUsers(cur);
-  renderPreviewRows();
-  runValidation();
-});
-
-
-// ── Serialize filter hidden fields before submit ─────────────────
-$('#notifForm').on('submit', function() {
-  $('#h_projects').val(JSON.stringify($('#f_project').val()    || []));
-  $('#h_allocations').val(JSON.stringify($('#f_allocation').val() || []));
-  $('#h_depts').val(JSON.stringify($('#f_dept').val()          || []));
-  $('#h_resources').val(JSON.stringify($('#f_resource').val()  || []));
-  $('#h_statuses').val(JSON.stringify($('#f_status').val()     || []));
-  $('#h_roles').val(JSON.stringify($('#f_role').val()          || []));
-});
-
-// ── Select2 init ─────────────────────────────────────────────────
-$(document).ready(function() {
-  $('.s2').select2({
-    allowClear: true,
-    width: '100%',
-    placeholder: function() { return $(this).data('placeholder'); }
-  });
-
-  // Load first template
-  var $first = $('.tmpl-item').first();
-  if ($first.length) loadTemplate($first);
-});
-
-// ── pageshow: reset validation state + refresh active template ────
-// When a user edits a template in another tab and comes back, bfcache
-// restores the DOM with the OLD textarea content and any stale errors.
-// Force-hide the panel and re-fetch the active template so the textarea
-// reflects the latest body before the next Validate click.
-$(window).on('pageshow', function() {
-  $('#validationPanel').hide();
-  $('#validationOK').hide();
-  $('#validationBad').hide();
-  $('#sendWarn').hide();
-  $('#sendBtn').prop('disabled', true);
-  $('#recipNum').text('?');
-  $('#recipLbl').text('press Validate');
-  $('#emailCount').text('—');
-  $('#multiBadge').hide();
-  $('#multiWarn').hide();
-  setDedupeUsers([]);
-  HAS_VALIDATED = false;
-  var $active = $('.tmpl-item.active');
-  if ($active.length) loadTemplate($active);
-});
diff --git a/static/coldfront_notifications/js/datatables_init.js b/static/coldfront_notifications/js/datatables_init.js
deleted file mode 100644
index 269b49b..0000000
--- a/static/coldfront_notifications/js/datatables_init.js
+++ /dev/null
@@ -1,23 +0,0 @@
-// ── datatables_init.js ──────────────────────────────────────────
-// Shared DataTable initializer for list pages.
-// Expects the following global set inline by the Django template:
-//   DT_CONFIG - object with: { tableId, order, nonOrderableTargets, paging, searching, info }
-// All fields except tableId are optional.
-
-$(function() {
-  if (typeof DT_CONFIG === 'undefined') return;
-
-  var opts = {
-    order: DT_CONFIG.order || [[0, 'asc']]
-  };
-
-  if (DT_CONFIG.nonOrderableTargets) {
-    opts.columnDefs = [{ orderable: false, targets: DT_CONFIG.nonOrderableTargets }];
-  }
-
-  if (DT_CONFIG.paging === false) opts.paging = false;
-  if (DT_CONFIG.searching === false) opts.searching = false;
-  if (DT_CONFIG.info === false) opts.info = false;
-
-  $('#' + DT_CONFIG.tableId).DataTable(opts);
-});
diff --git a/static/coldfront_notifications/js/template_form.js b/static/coldfront_notifications/js/template_form.js
deleted file mode 100644
index f394522..0000000
--- a/static/coldfront_notifications/js/template_form.js
+++ /dev/null
@@ -1,73 +0,0 @@
-// ── template_form.js ────────────────────────────────────────────
-// Expects the following global set inline by the Django template:
-//   ALL_VARS - array of variable objects
-//   IS_EDIT  - boolean, true when editing an existing template
-
-function renderVars(filter) {
-  var $list = $('#varsList').empty();
-  var q = (filter || '').toLowerCase();
-  var filtered = q
-    ? ALL_VARS.filter(function(v) {
-        return (v.key || '').toLowerCase().indexOf(q) !== -1
-            || (v.label || '').toLowerCase().indexOf(q) !== -1; })
-    : ALL_VARS;
-  if (!filtered.length) {
-    $list.append('<div class="vars-empty">No matches</div>');
-    return;
-  }
-  filtered.forEach(function(v) {
-    var token = '{{' + v.key + '}}';
-    var tag = v.source === 'manual' ? ' [manual]' : '';
-    var $btn = $('<button type="button" class="var-btn"></button>')
-      .attr('data-var', token)
-      .attr('title', (v.description || v.label || '') + (v.example ? ' — ' + v.example : ''))
-      .html(
-        '<span style="display:block;font-family:monospace;font-size:.7rem;">' + token + tag + '</span>' +
-        '<span style="display:block;font-size:.65rem;color:#6c757d;margin-top:1px;">' + (v.example || '') + '</span>'
-      );
-    $list.append($btn);
-  });
-}
-
-function renderVarRef() {
-  var $body = $('#varRefBody').empty();
-  if (!ALL_VARS.length) {
-    $body.append('<tr><td colspan="3" class="text-muted text-center py-3">No variables defined.</td></tr>');
-    return;
-  }
-  ALL_VARS.forEach(function(v) {
-    var badgeClass = v.source === 'manual' ? 'badge-warning' : 'badge-success';
-    var badgeText  = v.source === 'manual' ? 'Manual' : 'Query';
-    $body.append(
-      '<tr>'
-      + '<td style="font-family:monospace;">{{' + v.key + '}}</td>'
-      + '<td><span class="badge ' + badgeClass + '" style="font-size:.62rem;">' + badgeText + '</span></td>'
-      + '<td>' + (v.example || '—') + '</td>'
-      + '</tr>'
-    );
-  });
-}
-
-$(document).on('click', '.var-btn', function() {
-  var ta    = document.getElementById('id_body');
-  var token = $(this).attr('data-var');
-  var s = ta.selectionStart, e = ta.selectionEnd;
-  ta.value = ta.value.substring(0, s) + token + ta.value.substring(e);
-  ta.selectionStart = ta.selectionEnd = s + token.length;
-  ta.focus();
-});
-
-$(document).on('input', '#varSearch', function() {
-  renderVars($(this).val());
-});
-
-$(document).ready(function() { renderVars(''); renderVarRef(); });
-
-if (!IS_EDIT) {
-  $(document).on('input', '#id_name', function() {
-    var slug = $(this).val().toLowerCase()
-      .replace(/[^a-z0-9]+/g, '-')
-      .replace(/^-|-$/g, '');
-    $('#id_slug').val(slug);
-  });
-}
diff --git a/static/coldfront_notifications/js/variable_form.js b/static/coldfront_notifications/js/variable_form.js
deleted file mode 100644
index ad78cd6..0000000
--- a/static/coldfront_notifications/js/variable_form.js
+++ /dev/null
@@ -1,90 +0,0 @@
-// ── variable_form.js ────────────────────────────────────────────
-// No server-rendered globals required.
-
-// Example values per resolver_key
-var QUERY_EXAMPLES = {
-  "user.username":   "jdoe",
-  "user.email":      "jdoe@example.com",
-  "user.full_name":  "John Doe",
-  "user.first_name": "John",
-  "user.last_name":  "Doe",
-  "user.ifxid":      "IFX000123",
-  "project.title":                        "astro-gpu-2025",
-  "project.description":                  "(project description)",
-  "project.status.name":                  "Active",
-  "project.field_of_science.description": "Physics",
-  "project.parent_project.title":         "FASRC",
-  "project.pi.full_name":    "Dr. Jane Smith",
-  "project.pi.email":        "pi@example.com",
-  "project.pi.username":     "jsmith",
-  "project.department.name": "Astronomy",
-  "projectuser.role.name":   "PI",
-  "allocation.id":            "412",
-  "allocation.description":   "(allocation description)",
-  "allocation.justification": "(justification text)",
-  "allocation.quantity":      "1",
-  "allocation.start_date":    "2025-01-01",
-  "allocation.end_date":      "2025-12-31",
-  "allocation.status.name":   "Active",
-  "resource.name":                 "Cannon Cluster",
-  "resource.description":          "(resource description)",
-  "resource.resource_type.name":   "Cluster",
-  "resource.parent_resource.name": "Cannon Cluster",
-  "resource.names_joined":         "Cannon Cluster, Holyoke GPU"
-};
-
-function syncSource() {
-  var val = $('input[name=source]:checked').val();
-  $('#card-manual, #card-query').removeClass('active');
-  if (val === 'manual') {
-    $('#card-manual').addClass('active');
-    $('#query-config').removeClass('show');
-    $('#manual-config').addClass('show');
-    syncValueWidget();
-  } else if (val === 'query') {
-    $('#card-query').addClass('active');
-    $('#query-config').addClass('show');
-    $('#manual-config').removeClass('show');
-    updateQueryExample();
-  } else {
-    $('#query-config').removeClass('show');
-    $('#manual-config').removeClass('show');
-  }
-}
-
-// Swap the Value input's type based on input_widget selection so the admin
-// gets a proper date/url/textarea control while entering the stored value.
-function syncValueWidget() {
-  var widget = $('#id_input_widget').val() || 'text';
-  var $cur = $('#id_value');
-  if (!$cur.length) return;
-  var current = $cur.val();
-  var name = $cur.attr('name') || 'value';
-  var $new;
-  if (widget === 'textarea') {
-    $new = $('<textarea rows="3"></textarea>');
-  } else if (widget === 'date') {
-    $new = $('<input type="date">');
-  } else if (widget === 'datetime') {
-    $new = $('<input type="datetime-local">');
-  } else if (widget === 'url') {
-    $new = $('<input type="url">');
-  } else {
-    $new = $('<input type="text">');
-  }
-  $new.attr({ id: 'id_value', name: name, class: 'form-control' }).val(current);
-  $cur.replaceWith($new);
-}
-
-function updateQueryExample() {
-  var k = $('#id_resolver_key').val();
-  if (!k) { $('#query-example').hide(); return; }
-  var ex = QUERY_EXAMPLES[k] || '(depends on recipient)';
-  $('#query-example-text').html('<code>' + k + '</code> → <strong>' + ex + '</strong>');
-  $('#query-example').show();
-}
-
-$(document).on('change', 'input[name=source]', syncSource);
-$(document).on('change', '#id_resolver_key', updateQueryExample);
-$(document).on('change', '#id_input_widget', syncValueWidget);
-$(document).ready(syncSource);