From c64fd84f6aa0a070a376bfb68f5e3e63862791be Mon Sep 17 00:00:00 2001
From: s-aga-r <sagarsharma.s312@gmail.com>
Date: Thu, 25 Jun 2026 09:21:11 +0530
Subject: [PATCH 1/2] feat: Hey-style email screening; unify Blocked/Junk into
 Screened Email Address (backport #600 to v0)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Backport of PR #600 (frappe/mail, merged into develop) onto v0.

Merges the legacy "Blocked Email Address" and "Junk Email Address" doctypes
into a single account-scoped "Screened Email Address" doctype (Reject / Spam /
Accepted actions), adds the Hey-style screening flow (Screener view +
screening endpoints), and generates the frappe_mail_automation sieve through
the unified build_automation_sieve layer (create-if-missing, build all four
sections — Reject -> Mailbox -> Spam -> Screening — and optionally activate).
A migration converts existing Blocked -> Reject and Junk -> Spam rules and
drops the old doctypes.

v0 adaptations during the backport:
- mail/api/mail.py: kept v0's get_mail_config (develop renamed it to
  get_config) and v0's import layout while adding the screening imports.
- mail/hooks.py: applied only #600's change (drop Blocked/Junk permission and
  ignore-links entries, add Screened Email Address); did not pull in the
  unrelated develop-only Calendar Exchange permission entry that v0 doesn't
  register.
- frontend/src/types/doctypes.ts: kept v0's generated types; #600's only diff
  here was unrelated MailSettings log-field regeneration.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 frontend/components.d.ts                      |   1 +
 frontend/src/App.vue                          |  27 +-
 frontend/src/components/AppSidebar.vue        | 104 ++-
 frontend/src/components/EmailContent.vue      | 116 ++-
 frontend/src/components/MailActions.vue       |  63 +-
 .../src/components/MailDetailsPopover.vue     |   2 +-
 frontend/src/components/MailThread.vue        | 663 ++++++++++--------
 .../src/components/MailThreadSkeleton.vue     |  39 ++
 .../src/components/Modals/FolderModal.vue     |  61 +-
 .../src/components/Modals/SettingsModal.vue   |   2 +-
 frontend/src/components/SendMail.vue          |   2 +-
 .../components/Settings/AccountSettings.vue   |  87 ++-
 .../Settings/AutomationSettings.vue           |  29 +-
 .../components/Settings/BlockListSettings.vue | 167 +++--
 frontend/src/components/ThreadHeader.vue      |   8 +-
 frontend/src/constants.ts                     |   4 +
 frontend/src/pages/MailboxView.vue            |  70 +-
 frontend/src/pages/ScreenerView.vue           | 426 +++++++++++
 frontend/src/router.ts                        |   6 +
 frontend/src/stores/user.ts                   |  22 +-
 frontend/src/types/index.ts                   |  31 +
 frontend/src/utils/composables.ts             |  97 ++-
 frontend/src/utils/index.ts                   |  70 +-
 frontend/src/utils/useThreadActions.ts        |  62 +-
 mail/api/account.py                           |  10 +-
 mail/api/mail.py                              | 424 ++++++++---
 mail/api/sieve.py                             | 372 +++++++---
 .../account_settings/account_settings.json    |  60 +-
 .../account_settings/account_settings.py      |  14 +
 .../blocked_email_address.py                  |  84 ---
 .../blocked_email_address_list.js             |   4 -
 .../doctype/junk_email_address/__init__.py    |   0
 .../junk_email_address.json                   |  80 ---
 .../junk_email_address/junk_email_address.py  |  84 ---
 .../junk_email_address_list.js                |   4 -
 .../test_junk_email_address.py                |  20 -
 mail/client/doctype/mailbox/mailbox.py        |   9 +-
 .../mailbox_settings/mailbox_settings.json    |  55 +-
 .../mailbox_settings/mailbox_settings.py      |  56 ++
 .../__init__.py                               |   0
 .../screened_email_address.js}                |   2 +-
 .../screened_email_address.json}              |  17 +-
 .../screened_email_address.py                 |  93 +++
 .../screened_email_address_list.js}           |   2 +-
 .../test_screened_email_address.py}           |   4 +-
 mail/hooks.py                                 |   8 +-
 mail/patches.txt                              |   2 +
 .../backfill_blocked_email_account_id.py      |   9 +-
 .../backfill_mailbox_automation_rules.py      |  15 +
 .../migrate_to_screened_email_address.py      |  72 ++
 50 files changed, 2525 insertions(+), 1134 deletions(-)
 create mode 100644 frontend/src/components/MailThreadSkeleton.vue
 create mode 100644 frontend/src/pages/ScreenerView.vue
 delete mode 100644 mail/client/doctype/blocked_email_address/blocked_email_address.py
 delete mode 100644 mail/client/doctype/blocked_email_address/blocked_email_address_list.js
 delete mode 100644 mail/client/doctype/junk_email_address/__init__.py
 delete mode 100644 mail/client/doctype/junk_email_address/junk_email_address.json
 delete mode 100644 mail/client/doctype/junk_email_address/junk_email_address.py
 delete mode 100644 mail/client/doctype/junk_email_address/junk_email_address_list.js
 delete mode 100644 mail/client/doctype/junk_email_address/test_junk_email_address.py
 rename mail/client/doctype/{blocked_email_address => screened_email_address}/__init__.py (100%)
 rename mail/client/doctype/{blocked_email_address/blocked_email_address.js => screened_email_address/screened_email_address.js} (71%)
 rename mail/client/doctype/{blocked_email_address/blocked_email_address.json => screened_email_address/screened_email_address.json} (75%)
 create mode 100644 mail/client/doctype/screened_email_address/screened_email_address.py
 rename mail/client/doctype/{junk_email_address/junk_email_address.js => screened_email_address/screened_email_address_list.js} (68%)
 rename mail/client/doctype/{blocked_email_address/test_blocked_email_address.py => screened_email_address/test_screened_email_address.py} (82%)
 create mode 100644 mail/patches/backfill_mailbox_automation_rules.py
 create mode 100644 mail/patches/migrate_to_screened_email_address.py

diff --git a/frontend/components.d.ts b/frontend/components.d.ts
index 48ea0bdd5..98d09e713 100644
--- a/frontend/components.d.ts
+++ b/frontend/components.d.ts
@@ -81,6 +81,7 @@ declare module 'vue' {
     MailListItemActions: typeof import('./src/components/MailListItemActions.vue')['default']
     MailLogo: typeof import('./src/components/Icons/MailLogo.vue')['default']
     MailThread: typeof import('./src/components/MailThread.vue')['default']
+    MailThreadSkeleton: typeof import('./src/components/MailThreadSkeleton.vue')['default']
     NoMails: typeof import('./src/components/Icons/NoMails.vue')['default']
     PDFIcon: typeof import('./src/components/Icons/PDFIcon.vue')['default']
     ProfileSettings: typeof import('./src/components/Settings/ProfileSettings.vue')['default']
diff --git a/frontend/src/App.vue b/frontend/src/App.vue
index ea2a944b3..c192275cc 100644
--- a/frontend/src/App.vue
+++ b/frontend/src/App.vue
@@ -7,10 +7,11 @@
 	</FrappeUIProvider>
 </template>
 <script setup lang="ts">
-import { computed, onMounted, watchEffect } from 'vue'
+import { computed, onMounted, onUnmounted, watchEffect } from 'vue'
 import { useRoute } from 'vue-router'
 import { FrappeUIProvider } from 'frappe-ui'
 
+import { shouldIgnoreKeypress } from '@/utils'
 import { useScreenSize, useTheme } from '@/utils/composables'
 import { showNotification } from '@/utils/push-notifications'
 import DefaultLayout from '@/components/DefaultLayout.vue'
@@ -19,7 +20,7 @@ import LoginLayout from '@/components/LoginLayout.vue'
 
 import type { NotificationPayload } from '@/types'
 
-const { dataTheme } = useTheme()
+const { dataTheme, cycleTheme } = useTheme()
 const { isMobile } = useScreenSize()
 const route = useRoute()
 
@@ -31,9 +32,25 @@ const Layout = computed(() => {
 
 watchEffect(() => document.documentElement.setAttribute('data-theme', dataTheme.value))
 
-onMounted(() =>
+// App-wide Cmd/Ctrl+Shift+L to cycle the color scheme (works on every page, not just the mailbox).
+const handleThemeShortcut = (e: KeyboardEvent) => {
+	if (
+		(e.metaKey || e.ctrlKey) &&
+		e.shiftKey &&
+		e.key.toLowerCase() === 'l' &&
+		!shouldIgnoreKeypress(e, true)
+	) {
+		e.preventDefault()
+		cycleTheme()
+	}
+}
+
+onMounted(() => {
 	window.frappePushNotification?.onMessage((payload: NotificationPayload) =>
 		showNotification(payload),
-	),
-)
+	)
+	window.addEventListener('keydown', handleThemeShortcut)
+})
+
+onUnmounted(() => window.removeEventListener('keydown', handleThemeShortcut))
 </script>
diff --git a/frontend/src/components/AppSidebar.vue b/frontend/src/components/AppSidebar.vue
index df2e61035..43e98c818 100644
--- a/frontend/src/components/AppSidebar.vue
+++ b/frontend/src/components/AppSidebar.vue
@@ -49,7 +49,10 @@
 									</template>
 								</Button>
 							</Dropdown>
-							<span class="text-ink-gray-4 text-sm group-hover:hidden">
+							<span
+								class="text-ink-gray-4 text-sm"
+								:class="{ 'group-hover:hidden': item.menuOptions }"
+							>
 								{{ item.suffix }}
 							</span>
 						</div>
@@ -75,7 +78,7 @@ import { Check, Keyboard, User } from 'lucide-vue-next'
 import { Avatar, Button, Dropdown, Sidebar, SidebarItem, createResource } from 'frappe-ui'
 
 import { FOLDER_ICON_COLOR_MAP } from '@/constants'
-import { getIcon, toTitleCase } from '@/utils'
+import { getIcon, getMailboxName, toTitleCase } from '@/utils'
 import { useScreenSize, useSettings, useSidebar } from '@/utils/composables'
 import { sessionStore } from '@/stores/session'
 import { userStore } from '@/stores/user'
@@ -277,45 +280,67 @@ const mailboxItems = computed(
 	() =>
 		mailboxes.data
 			?.filter((mailbox: MailboxData) => mailbox.subscribed)
-			?.map((mailbox: MailboxData) => ({
-				label: mailbox._name,
-				icon: h(Icon, {
-					name: getIcon(mailbox),
-					class: FOLDER_ICON_COLOR_MAP[mailbox.color],
-				}),
-				to: {
-					name: 'Mailbox',
-					params: { accountId: store.accountId, mailbox: mailbox.id },
-				},
-				suffix: mailbox.unread_threads ? String(mailbox.unread_threads) : '',
-				activeFor: [mailbox.id],
-				menuOptions: [
-					{
-						label: __('Configure'),
-						icon: Settings,
-						onClick: () => {
-							selectedMailbox.value = mailbox
-							showFolderModal.value = true
-						},
-					},
-					{
-						label: __('Delete'),
-						theme: 'red',
-						icon: Trash2,
-						onClick: () => {
-							selectedMailbox.value = mailbox
-							showDeleteMailbox.value = true
-						},
-					},
-				],
-			})) || [],
+			?.map((mailbox: MailboxData) => {
+				// The Screening folder opens the dedicated Screener page, not the thread list.
+				const isScreener = mailbox.id === store.mailboxIds.screening
+				return {
+					mailboxId: mailbox.id,
+					label: getMailboxName(mailbox),
+					icon: h(Icon, {
+						name: getIcon(mailbox),
+						class: FOLDER_ICON_COLOR_MAP[mailbox.color],
+					}),
+					to: isScreener
+						? { name: 'Screener', params: { accountId: store.accountId } }
+						: {
+								name: 'Mailbox',
+								params: { accountId: store.accountId, mailbox: mailbox.id },
+							},
+					suffix: mailbox.unread_threads ? String(mailbox.unread_threads) : '',
+					activeFor: isScreener ? ['Screener'] : [mailbox.id],
+					menuOptions: isScreener
+						? undefined
+						: [
+								{
+									label: __('Configure'),
+									icon: Settings,
+									onClick: () => {
+										selectedMailbox.value = mailbox
+										showFolderModal.value = true
+									},
+								},
+								{
+									label: __('Delete'),
+									theme: 'red',
+									icon: Trash2,
+									onClick: () => {
+										selectedMailbox.value = mailbox
+										showDeleteMailbox.value = true
+									},
+								},
+							],
+				}
+			}) || [],
+)
+
+const screeningEnabled = computed(
+	() =>
+		!!store.userResource?.data?.accounts?.find((a) => a.id === store.accountId)
+			?.enable_screening,
 )
 
 const sidebarItems = computed(() => {
 	if (route.meta.isDashboard) return dashboardItems
 
+	// Screening is a roleless folder; it gets its own nameless group pinned to the top of the
+	// sidebar, separate from the default and custom mailboxes.
+	const isScreening = (item: { mailboxId?: string }) =>
+		!!store.mailboxIds.screening && item.mailboxId === store.mailboxIds.screening
+
+	const screenerItem = mailboxItems.value.find((item) => isScreening(item))
+
 	const defaultMailboxes = mailboxItems.value.filter(
-		(item) => mailboxes.data?.find((m) => m.id === item.activeFor[0])?.role,
+		(item) => mailboxes.data?.find((m) => m.id === item.mailboxId)?.role,
 	)
 	const starredItem = {
 		label: __('Starred'),
@@ -326,7 +351,8 @@ const sidebarItems = computed(() => {
 	const defaultItems = [...defaultMailboxes, starredItem]
 
 	const customMailboxes = mailboxItems.value.filter(
-		(item) => !mailboxes.data?.find((m) => m.id === item.activeFor[0])?.role,
+		(item) =>
+			!mailboxes.data?.find((m) => m.id === item.mailboxId)?.role && !isScreening(item),
 	)
 	const addMailboxItem = {
 		label: __('New Folder'),
@@ -353,11 +379,15 @@ const sidebarItems = computed(() => {
 		},
 	]
 
-	return [
+	const groups = [
 		{ label: __('Default'), items: defaultItems },
 		{ label: __('Custom'), items: customItems },
 		{ label: __('People'), items: contactsItems },
 	]
+	// Screener is its own nameless group, pinned first — only when screening is enabled.
+	if (screenerItem && screeningEnabled.value)
+		groups.unshift({ label: '', items: [screenerItem] })
+	return groups
 })
 
 // Shortcuts
diff --git a/frontend/src/components/EmailContent.vue b/frontend/src/components/EmailContent.vue
index 40aac5ad7..081d1e4fb 100644
--- a/frontend/src/components/EmailContent.vue
+++ b/frontend/src/components/EmailContent.vue
@@ -1,4 +1,18 @@
 <template>
+	<div
+		v-if="showImagesBanner"
+		class="text-ink-gray-6 mb-3 flex items-center gap-3 rounded border p-2.5 px-4"
+	>
+		<ImageOff class="h-4.5 w-4.5 stroke-1.5" />
+		<span class="text-ink-gray-8 min-w-0 flex-1"> {{ blockedLabel }} </span>
+		<Button
+			v-if="canTrust"
+			variant="ghost"
+			:label="__('Mark Sender as Trusted')"
+			@click="handleTrust"
+		/>
+		<Button :label="__('Load Images')" class="w-28" @click="imagesLoaded = true" />
+	</div>
 	<div v-if="!isIframeReady" class="animate-pulse space-y-2 py-4">
 		<div
 			v-for="i in 5"
@@ -23,15 +37,50 @@ import iframeResizerChildScript from '@iframe-resizer/child/index.umd.js?raw'
 // eslint-disable-next-line import/no-unresolved
 import IframeResizer from '@iframe-resizer/vue/sfc'
 import DOMPurify from 'dompurify'
+import { ImageOff } from 'lucide-vue-next'
+import { Button } from 'frappe-ui'
 
+import { analyzeRemoteAssets, blockRemoteAssets } from '@/utils'
 import { useTheme } from '@/utils/composables'
 
-const { content } = defineProps<{ content: string }>()
+const {
+	content,
+	blockImages = false,
+	canTrust = true,
+} = defineProps<{ content: string; blockImages?: boolean; canTrust?: boolean }>()
+const emit = defineEmits<{ trust: [] }>()
 
 const { dataTheme } = useTheme()
 
 const isIframeReady = ref(false)
 
+// Remote images are withheld until the reader opts in (per message), so a sender can't use them to track
+// when their mail was opened.
+const imagesLoaded = ref(false)
+// Trusting dismisses the banner instantly (and reveals images) without waiting for the sender's accept to
+// round-trip — otherwise the bar lingers before it disappears.
+const trusted = ref(false)
+const effectiveBlock = computed(() => blockImages && !imagesLoaded.value && !trusted.value)
+const remoteAssets = computed(() => analyzeRemoteAssets(content))
+// The banner is dismissed once the reader loads the images (or trusts the sender) — there's nothing
+// left to act on after that.
+const showImagesBanner = computed(
+	() => blockImages && !imagesLoaded.value && !trusted.value && remoteAssets.value.hasRemote,
+)
+const blockedLabel = computed(() => {
+	const n = remoteAssets.value.images
+	if (n === 0) return __('Remote content hidden to protect your privacy.')
+	return n === 1
+		? __('1 remote image hidden to protect your privacy.')
+		: __('{0} remote images hidden to protect your privacy.', [String(n)])
+})
+
+// Trusting reveals images and dismisses the banner now; the parent accepts the sender for future mail.
+const handleTrust = () => {
+	trusted.value = true
+	emit('trust')
+}
+
 // Listen for keyboard events from iframe
 const handleMessage = (event: MessageEvent) => {
 	if (event.data?.type !== 'keyboard') return
@@ -51,39 +100,36 @@ const handleMessage = (event: MessageEvent) => {
 onMounted(() => window.addEventListener('message', handleMessage))
 onUnmounted(() => window.removeEventListener('message', handleMessage))
 
-const srcdoc = computed(() => {
-	const collapseButton = `
-		<button
-			style="
-			background: ${colors.value.button};
-			color: ${colors.value.text};
-			padding: 0.5px 6px;
-			border-radius: 8px;
-			cursor: pointer;
-			transition: background 0.2s;
-			margin: 12px 0;
-			"
-			onmouseover="this.style.background='${colors.value.buttonHover}'"
-			onmouseout="this.style.background='${colors.value.button}'"
-			onclick="this.nextElementSibling.classList.toggle('quote-hidden');"
-		>
-			&middot;&middot;&middot;
-		</button>
-	`
-	const transformedContent = DOMPurify.sanitize(content, DOMPURIFY_CONFIG)
-		.replace(
-			/<div\s+([^>]*)\bclass="([^"]*)"\s*([^>]*)>([\s\S]*?)<\/div>/gi,
-			(match, beforeAttrs, classValue, afterAttrs, innerHtml) => {
-				// Check if this div has gmail_quote or frappe_mail_quote class
-				if (/\b(gmail_quote|frappe_mail_quote)\b/.test(classValue)) {
-					const allAttrs = `${beforeAttrs} ${afterAttrs}`.trim()
-					const attrString = allAttrs ? ` ${allAttrs}` : ''
-					return `${collapseButton}<div class="quote-hidden ${classValue}"${attrString}>${innerHtml}</div>`
-				}
-				return match
-			},
+// Collapse each top-level quoted reply (gmail_quote / frappe_mail_quote) behind a "···" toggle. Done on
+// the DOM, not regex: a quote with nested divs is wrapped as one unit, instead of the old regex stopping
+// at the first </div> and collapsing the wrong region.
+const collapseQuotes = (html: string) => {
+	const doc = new DOMParser().parseFromString(html, 'text/html')
+	doc.querySelectorAll('.gmail_quote, .frappe_mail_quote').forEach((quote) => {
+		// Only the outermost quote gets a toggle — hiding it hides any quotes nested inside.
+		if (quote.parentElement?.closest('.gmail_quote, .frappe_mail_quote')) return
+		quote.classList.add('quote-hidden')
+		const button = doc.createElement('button')
+		button.textContent = '···'
+		button.setAttribute(
+			'style',
+			`background:${colors.value.button};color:${colors.value.text};padding:0.5px 6px;border-radius:8px;cursor:pointer;transition:background .2s;margin:12px 0;`,
 		)
-		.replace(/<([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})>/g, '<b>&lt;$1&gt;</b>')
+		button.setAttribute('onmouseover', `this.style.background='${colors.value.buttonHover}'`)
+		button.setAttribute('onmouseout', `this.style.background='${colors.value.button}'`)
+		button.setAttribute('onclick', "this.nextElementSibling.classList.toggle('quote-hidden');")
+		quote.parentNode?.insertBefore(button, quote)
+	})
+	return doc.documentElement.outerHTML
+}
+
+const srcdoc = computed(() => {
+	let sanitized = DOMPurify.sanitize(content, DOMPURIFY_CONFIG)
+	if (effectiveBlock.value) sanitized = blockRemoteAssets(sanitized)
+	const transformedContent = collapseQuotes(sanitized).replace(
+		/<([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})>/g,
+		'<b>&lt;$1&gt;</b>',
+	)
 
 	/* eslint-disable no-useless-escape */
 	return `
@@ -131,6 +177,10 @@ const srcdoc = computed(() => {
 					overflow: hidden !important;
 				}
 
+				img[data-blocked-image] {
+					display: none !important;
+				}
+
 				pre, code {
 					font-family: 'Courier New', Courier, monospace;
 					white-space: pre;
diff --git a/frontend/src/components/MailActions.vue b/frontend/src/components/MailActions.vue
index 35fd859c0..c818d9624 100644
--- a/frontend/src/components/MailActions.vue
+++ b/frontend/src/components/MailActions.vue
@@ -46,7 +46,7 @@ import { downloadUrlAsFile, raisePromiseToast, raiseToast } from '@/utils'
 import { useBlockSender, useScreenSize, useUndo } from '@/utils/composables'
 import { userStore } from '@/stores/user'
 
-import type { ComposeMailData, Identity, Mail } from '@/types'
+import type { ComposeMailData, Identity, Mail, ScreenedAddress } from '@/types'
 
 const {
 	mailbox,
@@ -79,11 +79,17 @@ const emit = defineEmits(['setFlagged', 'syncUnseen'])
 const { isMobile } = useScreenSize()
 const route = useRoute()
 const router = useRouter()
-const { accountId, mailboxes, mailboxIds, identities, blockedAddresses } = userStore()
+const { accountId, mailboxes, mailboxIds, identities, screenedAddresses } = userStore()
 const { setUndoAction, undo } = useUndo()
 const { promptBlockSenders, willJunkSenders } = useBlockSender()
 const user = inject('$user')
 
+// A sender is "blocked" when screened with the Reject action (their mail is discarded).
+const isSenderBlocked = (email: string) =>
+	screenedAddresses.data?.some(
+		(a: ScreenedAddress) => a.email === email && a.action === 'Reject',
+	)
+
 const primaryActions = (mail: Mail): MailAction[] => [
 	{
 		label: __('Unstar'),
@@ -193,19 +199,33 @@ const moreActions = (mail: Mail): GroupedAction[] => [
 				icon: MailOpen,
 				condition: () => !mail.draft,
 			},
+			{
+				label: __('Accept Sender'),
+				onClick: () => handleScreenSender('Accepted'),
+				icon: CircleCheck,
+				condition: () => mailbox === mailboxIds.screening,
+			},
+			{
+				label: __('Reject Sender'),
+				onClick: () => handleScreenSender('Reject'),
+				icon: Ban,
+				condition: () => mailbox === mailboxIds.screening,
+			},
 			{
 				label: __('Block Sender'),
 				onClick: () => handleBlockAddress(true),
 				icon: Ban,
 				condition: () =>
+					mailbox !== mailboxIds.screening &&
 					!identities.data.some((i: Identity) => i.email === mail.from_email) &&
-					!blockedAddresses.data?.includes(mail.from_email),
+					!isSenderBlocked(mail.from_email),
 			},
 			{
 				label: __('Unblock Sender'),
 				onClick: () => handleBlockAddress(false),
 				icon: LockOpen,
-				condition: () => blockedAddresses.data?.includes(mail.from_email),
+				condition: () =>
+					mailbox !== mailboxIds.screening && isSenderBlocked(mail.from_email),
 			},
 		],
 	},
@@ -347,13 +367,40 @@ const handleMarkUnreadFromHere = () => {
 	if (ids.length) setMailsSeen.submit({ ids })
 }
 
+// Screening-folder decisions: accept the sender (let future mail in, move this one to Inbox) or
+// reject them (discard future mail, move this one to Trash). The sieve regenerates from the list.
+const screenSender = createResource({
+	url: 'mail.api.mail.screen_email_address',
+	makeParams: ({ action }: { action: string }) => ({
+		account_id: accountId,
+		email: mail.from_email,
+		action,
+	}),
+})
+
+const handleScreenSender = (action: 'Accepted' | 'Reject') => {
+	const accepted = action === 'Accepted'
+	const target = accepted ? mailboxIds.inbox : mailboxIds.trash
+	const run = async () => {
+		await screenSender.submit({ action })
+		screenedAddresses.reload()
+		await moveMail.submit(target)
+		reloadMails()
+	}
+	raisePromiseToast(
+		run,
+		accepted ? __('Accepting sender...') : __('Rejecting sender...'),
+		accepted ? __('Sender accepted.') : __('Sender rejected.'),
+	)
+}
+
 const blockEmailAddress = createResource({
-	url: 'mail.api.mail.block_email_address',
-	makeParams: () => ({ account_id: accountId, email: mail.from_email }),
+	url: 'mail.api.mail.screen_email_address',
+	makeParams: () => ({ account_id: accountId, email: mail.from_email, action: 'Reject' }),
 })
 
 const unblockEmailAddress = createResource({
-	url: 'mail.api.mail.unblock_email_addresses',
+	url: 'mail.api.mail.unscreen_email_addresses',
 	makeParams: () => ({ account_id: accountId, emails: [mail.from_email] }),
 })
 
@@ -361,7 +408,7 @@ const handleBlockAddress = (block: boolean, isUndo = false) => {
 	const action = () =>
 		(block ? blockEmailAddress : unblockEmailAddress)
 			.submit()
-			.then(() => blockedAddresses.reload())
+			.then(() => screenedAddresses.reload())
 	const successMessage = block ? __('Sender blocked.') : __('Sender unblocked.')
 
 	if (isUndo) return raisePromiseToast(action, __('Undoing...'), successMessage)
diff --git a/frontend/src/components/MailDetailsPopover.vue b/frontend/src/components/MailDetailsPopover.vue
index 32c0caea0..2a77ed0a4 100644
--- a/frontend/src/components/MailDetailsPopover.vue
+++ b/frontend/src/components/MailDetailsPopover.vue
@@ -2,7 +2,7 @@
 	<Popover>
 		<template #target="{ togglePopover }">
 			<ChevronDown
-				class="text-ink-gray-6 hover:bg-surface-gray-2 h-3.5 w-3.5 cursor-pointer rounded-sm"
+				class="text-ink-gray-5 hover:bg-surface-gray-2 h-3.5 w-3.5 cursor-pointer rounded-sm"
 				@click.stop="togglePopover()"
 			/>
 		</template>
diff --git a/frontend/src/components/MailThread.vue b/frontend/src/components/MailThread.vue
index 57aaf2cfe..b30a4173b 100644
--- a/frontend/src/components/MailThread.vue
+++ b/frontend/src/components/MailThread.vue
@@ -1,6 +1,7 @@
 <template>
 	<div v-if="threadID" class="relative flex h-full flex-col overflow-hidden">
 		<ThreadHeader
+			v-if="!readonly"
 			:threads
 			:thread
 			:can-go-prev="canGoPrev"
@@ -18,317 +19,335 @@
 			@next-thread="emit('nextThread')"
 		/>
 		<div ref="threadContainer" class="flex-1 overflow-y-auto">
-			<div v-if="isMobile && thread?.length" class="border-b px-3 py-3.5">
-				<h2 class="text-lg font-semibold leading-5">
-					{{ thread[0].subject || __('[No subject]') }}
-				</h2>
-			</div>
+			<MailThreadSkeleton v-if="isLoading" />
+			<template v-else>
+				<div v-if="isMobile && thread?.length" class="border-b px-3 py-3.5">
+					<h2 class="text-lg font-semibold leading-5">
+						{{ thread[0].subject || __('[No subject]') }}
+					</h2>
+				</div>
 
-			<div
-				class="sm:space-y-4 sm:px-5 sm:py-6"
-				:class="{ 'pb-16': isMobile && !thread?.at(-1)?.draft }"
-			>
-				<template v-for="group in mailsByDay" :key="group.date">
-					<ThreadDivider
-						v-if="shouldShowDateDivider(group.mails)"
-						:message="getFormattedDate(group.date)"
-					/>
-					<template v-for="mail in group.mails" :key="mail.name">
+				<div
+					class="sm:space-y-4 sm:px-5 sm:py-6"
+					:class="{ 'pb-16': isMobile && !thread?.at(-1)?.draft }"
+				>
+					<template v-for="group in mailsByDay" :key="group.date">
 						<ThreadDivider
-							v-if="shouldShowUnseenMarker(mail.id)"
-							class="!text-ink-blue-2 [&_.border-t]:border-[var(--outline-blue-1)] [&_span:not(.border-t)]:border-[var(--outline-blue-1)]"
-							:message="unseenMessage"
+							v-if="shouldShowDateDivider(group.mails)"
+							:message="getFormattedDate(group.date)"
 						/>
-
-						<button
-							v-if="mail.name === firstMailOfCollapsedGroup"
-							class="w-full cursor-pointer transition-colors"
-							@click="resetCollapsedGroup"
-						>
+						<template v-for="mail in group.mails" :key="mail.name">
 							<ThreadDivider
-								:message="
-									__('{0} more messages', [String(collapsedMailNames.size)])
-								"
-								class="hover:text-ink-gray-8"
-							/>
-						</button>
-						<div
-							v-if="!collapsedMailNames.has(mail.name)"
-							:data-mail-name="mail.name"
-							:class="{
-								'px-3 py-5': isMobile,
-								'max-sm:border-b':
-									(thread.length > 1 || mail.draft) &&
-									mail.name !== mailBeforeCollapsedGroup &&
-									mail.name !== mailBeforeUnseenMarker,
-								'sm:rounded-xl sm:p-5': thread.length > 1 || mail.draft,
-								'sm:border':
-									(thread.length > 1 && !mail.draft) ||
-									(mail.draft && dataTheme === 'dark'),
-								'cursor-pointer': isCollapsed(mail),
-								'sm:shadow-elevation-light-md':
-									mail.draft && dataTheme === 'light',
-							}"
-							@click="mail.collapsed = false"
-						>
-							<ComposeMailEditor
-								v-if="mail.draft && !isMobile"
-								v-model="mail.show"
-								:reload-mails="reload"
-								:mail-details="draftMails[mail.name]"
-								:is-in-thread="true"
-								@discard-mail="discardLocalDraft(mail.name)"
-								@reply="reply(getSourceMail(mail.name))"
-								@reply-all="replyAll(getSourceMail(mail.name))"
-								@forward="forward(getSourceMail(mail.name))"
-								@pop-out="
-									(mailDetails: ComposeMailData) => popOutDraft(mailDetails)
-								"
+								v-if="shouldShowUnseenMarker(mail.id)"
+								class="!text-ink-blue-2 [&_.border-t]:border-[var(--outline-blue-1)] [&_span:not(.border-t)]:border-[var(--outline-blue-1)]"
+								:message="unseenMessage"
 							/>
 
-							<template v-else-if="!mail.name.startsWith('draft')">
-								<div
-									v-if="isMobile && !isCollapsed(mail)"
-									class="flex items-center justify-between pb-2"
-									@click.stop="mail.collapsed = !mail.collapsed"
-								>
-									<div class="flex items-center space-x-2">
-										<Badge
-											v-if="mail.draft"
-											:label="__('Draft')"
-											theme="red"
-											class="w-fit"
+							<button
+								v-if="mail.name === firstMailOfCollapsedGroup"
+								class="w-full cursor-pointer transition-colors"
+								@click="resetCollapsedGroup"
+							>
+								<ThreadDivider
+									:message="
+										__('{0} more messages', [String(collapsedMailNames.size)])
+									"
+									class="hover:text-ink-gray-8"
+								/>
+							</button>
+							<div
+								v-if="!collapsedMailNames.has(mail.name)"
+								:data-mail-name="mail.name"
+								:class="{
+									'px-3 py-5': isMobile,
+									'max-sm:border-b':
+										(thread.length > 1 || mail.draft) &&
+										mail.name !== mailBeforeCollapsedGroup &&
+										mail.name !== mailBeforeUnseenMarker,
+									'sm:rounded-xl sm:p-5': thread.length > 1 || mail.draft,
+									'sm:border':
+										(thread.length > 1 && !mail.draft) ||
+										(mail.draft && dataTheme === 'dark'),
+									'cursor-pointer': isCollapsed(mail),
+									'sm:shadow-elevation-light-md':
+										mail.draft && dataTheme === 'light',
+								}"
+								@click="mail.collapsed = false"
+							>
+								<ComposeMailEditor
+									v-if="mail.draft && !isMobile"
+									v-model="mail.show"
+									:reload-mails="reload"
+									:mail-details="draftMails[mail.name]"
+									:is-in-thread="true"
+									@discard-mail="discardLocalDraft(mail.name)"
+									@reply="reply(getSourceMail(mail.name))"
+									@reply-all="replyAll(getSourceMail(mail.name))"
+									@forward="forward(getSourceMail(mail.name))"
+									@pop-out="
+										(mailDetails: ComposeMailData) => popOutDraft(mailDetails)
+									"
+								/>
+
+								<template v-else-if="!mail.name.startsWith('draft')">
+									<div
+										v-if="isMobile && !isCollapsed(mail)"
+										class="flex items-center justify-between pb-2"
+										@click.stop="mail.collapsed = !mail.collapsed"
+									>
+										<div class="flex items-center space-x-2">
+											<Badge
+												v-if="mail.draft"
+												:label="__('Draft')"
+												theme="red"
+												class="w-fit"
+											/>
+											<MailDate :datetime="mail.received_at" />
+										</div>
+										<MailActions
+											v-if="!readonly"
+											:mailbox
+											:mail
+											:draft-mail="draftMails[mail.name]"
+											:is-collapsed="isCollapsed(mail)"
+											:show-reply-all="showReplyAll(mail)"
+											:pop-out-draft
+											:reply
+											:reply-all
+											:forward
+											:reload-mails="handleReload"
+											:thread="thread"
+											@set-flagged="
+												(id: string, flagged: boolean) =>
+													emit('setFlagged', [id], flagged)
+											"
+											@sync-unseen="handleSyncUnseen"
 										/>
-										<MailDate :datetime="mail.received_at" />
 									</div>
-									<MailActions
-										:mailbox
-										:mail
-										:draft-mail="draftMails[mail.name]"
-										:is-collapsed="isCollapsed(mail)"
-										:show-reply-all="showReplyAll(mail)"
-										:pop-out-draft
-										:reply
-										:reply-all
-										:forward
-										:reload-mails="handleReload"
-										:thread="thread"
-										@set-flagged="
-											(id: string, flagged: boolean) =>
-												emit('setFlagged', [id], flagged)
-										"
-										@sync-unseen="handleSyncUnseen"
-									/>
-								</div>
-								<div
-									class="flex items-center space-x-3"
-									:class="{
-										'cursor-pointer': mail !== thread[thread.length - 1],
-										'pb-6': mail.preview,
-									}"
-									@click.stop="mail.collapsed = !mail.collapsed"
-								>
-									<Avatar
-										:label="
-											getFirstAlphabet(mail.from_name) ||
-											getFirstAlphabet(mail.from_email)
-										"
-										:image="mail.user_image"
-										size="xl"
-									/>
-									<div class="flex flex-1 justify-between truncate text-sm">
-										<div class="mr-3 flex flex-col space-y-1 truncate">
-											<div class="flex items-center space-x-1.5">
-												<span
-													class="truncate text-[15px] !font-semibold sm:text-base"
-												>
-													{{ mail.from_name || mail.from_email }}
-												</span>
-												<span
-													v-if="mail.from_name && !isMobile"
-													class="text-ink-gray-5 truncate"
-												>
-													{{ `<${mail.from_email}>` }}
-												</span>
-												<template
-													v-if="!(isCollapsed(mail) || mail.draft)"
-												>
-													<ChevronDown
-														v-if="isMobile"
-														class="text-ink-gray-6 h-3.5 w-3.5 rounded-sm transition-transform duration-200"
-														:class="{
-															'rotate-180':
-																showMailDetails === mail.name,
-														}"
-														@click.stop="
-															showMailDetails =
-																showMailDetails === mail.name
-																	? undefined
-																	: mail.name
-														"
-													/>
-													<MailDetailsPopover v-else :mail />
-												</template>
+									<div
+										class="flex select-none items-center space-x-3"
+										:class="{
+											'cursor-pointer': mail !== thread[thread.length - 1],
+											'pb-6': mail.preview,
+										}"
+										@click.stop="mail.collapsed = !mail.collapsed"
+									>
+										<Avatar
+											:label="
+												getFirstAlphabet(mail.from_name) ||
+												getFirstAlphabet(mail.from_email)
+											"
+											:image="mail.user_image"
+											size="xl"
+										/>
+										<div class="flex flex-1 justify-between truncate text-sm">
+											<div class="mr-3 flex flex-col space-y-1 truncate">
+												<div class="flex items-center space-x-1.5">
+													<span
+														class="truncate text-[15px] !font-semibold sm:text-base"
+													>
+														{{ mail.from_name || mail.from_email }}
+													</span>
+													<span
+														v-if="mail.from_name && !isMobile"
+														class="text-ink-gray-5 truncate"
+													>
+														{{ mail.from_email }}
+													</span>
+													<template
+														v-if="!(isCollapsed(mail) || mail.draft)"
+													>
+														<ChevronDown
+															v-if="isMobile"
+															class="text-ink-gray-5 h-3.5 w-3.5 rounded-sm transition-transform duration-200"
+															:class="{
+																'rotate-180':
+																	showMailDetails === mail.name,
+															}"
+															@click.stop="
+																showMailDetails =
+																	showMailDetails === mail.name
+																		? undefined
+																		: mail.name
+															"
+														/>
+														<MailDetailsPopover v-else :mail />
+													</template>
+												</div>
+												<div class="truncate">
+													{{ getFormattedRecipients(mail.recipients) }}
+												</div>
 											</div>
-											<div class="truncate">
-												{{ getFormattedRecipients(mail.recipients) }}
+											<div class="flex items-center space-x-1 self-start">
+												<MailDate
+													v-if="!isMobile || isCollapsed(mail)"
+													:datetime="mail.received_at"
+												/>
+												<MailActions
+													v-if="!isMobile && !readonly"
+													:mailbox
+													:mail
+													:is-collapsed="isCollapsed(mail)"
+													:show-reply-all="showReplyAll(mail)"
+													:pop-out-draft
+													:reply
+													:reply-all
+													:forward
+													:reload-mails="handleReload"
+													:thread="thread"
+													@set-flagged="
+														(id: string, flagged: boolean) =>
+															emit('setFlagged', [id], flagged)
+													"
+													@sync-unseen="handleSyncUnseen"
+												/>
 											</div>
 										</div>
-										<div class="flex items-center space-x-1 self-start">
-											<MailDate
-												v-if="!isMobile || isCollapsed(mail)"
-												:datetime="mail.received_at"
-											/>
-											<MailActions
-												v-if="!isMobile"
-												:mailbox
-												:mail
-												:is-collapsed="isCollapsed(mail)"
-												:show-reply-all="showReplyAll(mail)"
-												:pop-out-draft
-												:reply
-												:reply-all
-												:forward
-												:reload-mails="handleReload"
-												:thread="thread"
-												@set-flagged="
-													(id: string, flagged: boolean) =>
-														emit('setFlagged', [id], flagged)
-												"
-												@sync-unseen="handleSyncUnseen"
-											/>
-										</div>
 									</div>
-								</div>
 
-								<MailDetails
-									v-if="!isCollapsed(mail) && showMailDetails === mail.name"
-									:mail
-									class="mb-4"
-								/>
+									<MailDetails
+										v-if="!isCollapsed(mail) && showMailDetails === mail.name"
+										:mail
+										class="mb-4"
+									/>
 
-								<div v-show="isCollapsed(mail)" class="truncate">
-									{{ mail.preview }}
-								</div>
+									<div v-show="isCollapsed(mail)" class="truncate">
+										{{ mail.preview }}
+									</div>
 
-								<div v-show="!isCollapsed(mail)">
-									<Alert
-										v-if="blockedAddresses.data.includes(mail.from_email)"
-										:title="__('This sender is blocked')"
-										class="mb-4"
-										:dismissable="false"
-									>
-										<template #description>
-											<p class="text-ink-gray-6 prose-sm">
-												{{
-													__('{0} is currently on your', [
-														mail.from_name || mail.from_email,
-													])
-												}}
+									<div v-show="!isCollapsed(mail)">
+										<Alert
+											v-if="!readonly && isSenderBlocked(mail.from_email)"
+											:title="__('This sender is blocked')"
+											class="mb-4"
+											:dismissible="false"
+										>
+											<template #description>
+												<p class="text-ink-gray-6 prose-sm">
+													{{
+														__('{0} is currently on your', [
+															mail.from_name || mail.from_email,
+														])
+													}}
+													<button
+														type="button"
+														class="hover:text-ink-gray-8 underline"
+														@click="
+															openSettings(__('Screened Senders'))
+														"
+													>
+														{{ __('block list') }}</button
+													>{{
+														__(
+															". You won't receive new messages from this source until you unblock them.",
+														)
+													}}
+												</p>
+											</template>
+											<template #footer>
+												<div class="col-span-full">
+													<Button
+														:label="__('Unblock')"
+														variant="outline"
+														@click="
+															unblockEmailAddress.submit(
+																mail.from_email,
+															)
+														"
+													/>
+												</div>
+											</template>
+										</Alert>
+										<EmailContent
+											v-if="hasHtmlContent(mail.html_body)"
+											:content="mail.html_body"
+											:block-images="shouldBlockImages(mail)"
+											:can-trust="!readonly"
+											@trust="trustSender.submit(mail.from_email)"
+										/>
+
+										<LinkifiedText
+											v-else
+											:text="mail.html_body || mail.text_body"
+										/>
+
+										<div v-if="filteredAttachments(mail).length" class="mt-8">
+											<div
+												v-if="zippableAttachments(mail).length > 1"
+												class="text-ink-gray-5 mb-3 flex items-center gap-1.5 text-sm"
+											>
+												<span>
+													{{
+														__('{0} attachments', [
+															String(
+																filteredAttachments(mail).length,
+															),
+														])
+													}}
+												</span>
+												<span aria-hidden="true">·</span>
 												<button
-													type="button"
-													class="hover:text-ink-gray-8 underline"
-													@click="openSettings(__('Block List'))"
+													class="hover:text-ink-gray-8 disabled:opacity-70"
+													:disabled="downloadingZipMail === mail.name"
+													:title="__('Download all')"
+													@click.stop.prevent="
+														downloadAttachmentsAsZip(mail)
+													"
 												>
-													{{ __('block list') }}</button
-												>{{
-													__(
-														". You won't receive new messages from this source until you unblock them.",
-													)
-												}}
-											</p>
-										</template>
-										<template #footer>
-											<div class="col-span-full">
-												<Button
-													:label="__('Unblock')"
-													variant="outline"
-													@click="
-														unblockEmailAddress.submit(mail.from_email)
+													<LoaderCircle
+														v-if="downloadingZipMail === mail.name"
+														class="h-3.5 w-3.5 animate-spin"
+													/>
+													<Download v-else class="h-3.5 w-3.5" />
+												</button>
+											</div>
+											<div class="flex flex-wrap">
+												<AttachmentCapsule
+													v-for="(
+														attachment, idx
+													) in filteredAttachments(mail)"
+													:key="idx"
+													:file-name="attachment.filename"
+													:blob-i-d="attachment.blob_id"
+													:type="attachment.type"
+													class="mb-2 mr-2"
+													@click.stop.prevent="
+														openAttachment(
+															filteredAttachments(mail),
+															Number(idx),
+														)
 													"
 												/>
 											</div>
-										</template>
-									</Alert>
-									<EmailContent
-										v-if="hasHtmlContent(mail.html_body)"
-										:content="mail.html_body"
-									/>
-
-									<LinkifiedText
-										v-else
-										:text="mail.html_body || mail.text_body"
-									/>
-
-									<div v-if="filteredAttachments(mail).length" class="mt-8">
-										<div
-											v-if="zippableAttachments(mail).length > 1"
-											class="mb-3 flex items-center justify-between"
-										>
-											<span class="text-ink-gray-5 text-sm">
-												{{
-													__('{0} attachments', [
-														String(filteredAttachments(mail).length),
-													])
-												}}
-											</span>
-											<Button
-												variant="ghost"
-												:icon="Download"
-												:label="__('Download all')"
-												:tooltip="__('Download all')"
-												:loading="downloadingZipMail === mail.name"
-												@click.stop.prevent="
-													downloadAttachmentsAsZip(mail)
-												"
-											/>
-										</div>
-										<div class="flex flex-wrap">
-											<AttachmentCapsule
-												v-for="(attachment, idx) in filteredAttachments(
-													mail,
-												)"
-												:key="idx"
-												:file-name="attachment.filename"
-												:blob-i-d="attachment.blob_id"
-												:type="attachment.type"
-												class="mb-2 mr-2"
-												@click.stop.prevent="
-													openAttachment(
-														filteredAttachments(mail),
-														Number(idx),
-													)
-												"
-											/>
 										</div>
 									</div>
-								</div>
-							</template>
-						</div>
+								</template>
+							</div>
+						</template>
 					</template>
-				</template>
 
-				<div
-					v-if="thread.length && !thread?.at(-1)?.draft"
-					class="flex"
-					:class="
-						isMobile
-							? 'bg-surface-white absolute bottom-0 left-0 right-0 z-20 items-stretch border-t'
-							: 'items-center space-x-2'
-					"
-				>
-					<Button
-						v-for="action in replyForwardActions"
-						:key="action.label"
-						:icon-left="action.icon"
-						:label="action.label"
-						:tooltip="action.tooltip"
-						:variant="isMobile ? 'ghost' : 'outline'"
-						:class="{ '!h-16 flex-1 rounded-none': isMobile }"
-						@click="action.onClick"
-					/>
+					<div
+						v-if="!readonly && thread.length && !thread?.at(-1)?.draft"
+						class="flex"
+						:class="
+							isMobile
+								? 'bg-surface-white absolute bottom-0 left-0 right-0 z-20 items-stretch border-t'
+								: 'items-center space-x-2'
+						"
+					>
+						<Button
+							v-for="action in replyForwardActions"
+							:key="action.label"
+							:icon-left="action.icon"
+							:label="action.label"
+							:tooltip="action.tooltip"
+							:variant="isMobile ? 'ghost' : 'outline'"
+							:class="{ '!h-16 flex-1 rounded-none': isMobile }"
+							@click="action.onClick"
+						/>
+					</div>
 				</div>
-			</div>
+			</template>
 		</div>
 		<SendMail
 			v-if="focusedDraft"
@@ -371,7 +390,7 @@ import {
 	watch,
 } from 'vue'
 import { useRoute, useRouter } from 'vue-router'
-import { ChevronDown, Download, Forward, Reply, ReplyAll } from 'lucide-vue-next'
+import { ChevronDown, Download, Forward, LoaderCircle, Reply, ReplyAll } from 'lucide-vue-next'
 import { Alert, Avatar, Badge, Button, createResource } from 'frappe-ui'
 
 import { getAttachmentsZipUrl } from '@/resources'
@@ -398,19 +417,30 @@ import MailActions from '@/components/MailActions.vue'
 import MailDate from '@/components/MailDate.vue'
 import MailDetails from '@/components/MailDetails.vue'
 import MailDetailsPopover from '@/components/MailDetailsPopover.vue'
+import MailThreadSkeleton from '@/components/MailThreadSkeleton.vue'
 import SendMail from '@/components/SendMail.vue'
 import ThreadDivider from '@/components/ThreadDivider.vue'
 import ThreadHeader from '@/components/ThreadHeader.vue'
 
-import type { Attachment, ComposeMailData, Identity, Mail, Mailbox } from '@/types'
+import type {
+	Attachment,
+	ComposeMailData,
+	Identity,
+	Mail,
+	Mailbox,
+	ScreenedAddress,
+} from '@/types'
 
-const { mailbox, threadID, threads, messages, canGoPrev, canGoNext } = defineProps<{
+const { mailbox, threadID, threads, messages, canGoPrev, canGoNext, readonly } = defineProps<{
 	mailbox: string
 	threadID?: string
 	threads: string[]
 	messages?: Mail[]
 	canGoPrev?: boolean
 	canGoNext?: boolean
+	// Read-only thread (e.g. the Screener): renders the messages but hides every action — the thread
+	// toolbar, per-message actions, the block banner and the reply/forward bar — and never marks read.
+	readonly?: boolean
 }>()
 
 const emit = defineEmits([
@@ -433,9 +463,30 @@ const { openSettings } = useSettings()
 const dayjs = inject('$dayjs')
 const user = inject('$user')
 const store = userStore()
-const { mailboxes, mailboxIds, identities, blockedAddresses } = store
+const { mailboxes, mailboxIds, identities, screenedAddresses } = store
 const { dataTheme } = useTheme()
 
+// A sender is "blocked" when screened with the Reject action (their mail is discarded).
+const isSenderBlocked = (email: string) =>
+	screenedAddresses.data?.some(
+		(a: ScreenedAddress) => a.email === email && a.action === 'Reject',
+	)
+
+// Trusted senders — you, or anyone you've accepted — load images normally. For everyone else, the
+// account's "Block Remote Images" setting withholds remote images (read-tracking pixels) until you opt in.
+const blockRemoteImagesEnabled = computed(
+	() =>
+		store.userResource?.data?.accounts?.find((a) => a.id === store.accountId)
+			?.block_remote_images ?? true,
+)
+const isScreenedIn = (email: string) =>
+	!!identities.data?.some((i: Identity) => i.email === email) ||
+	!!screenedAddresses.data?.some(
+		(a: ScreenedAddress) => a.email === email && a.action === 'Accepted',
+	)
+const shouldBlockImages = (mail: { from_email: string }) =>
+	blockRemoteImagesEnabled.value && !isScreenedIn(mail.from_email)
+
 const route = useRoute()
 const router = useRouter()
 
@@ -497,6 +548,10 @@ const goToMailbox = () => router.push({ name: 'Mailbox', params: { mailbox }, qu
 // directly via `get_thread`.
 const thread = ref<Mail[]>([])
 
+// A thread is selected but its messages aren't ready yet (still resolving from the list prop or being
+// fetched directly) — show the skeleton instead of a blank pane.
+const isLoading = computed(() => !!threadID && !thread.value.length)
+
 const threadFallback = createResource({
 	url: 'mail.api.mail.get_thread',
 	makeParams: () => ({ account_id: store.accountId, thread_id: threadID }),
@@ -514,7 +569,8 @@ const threadFallback = createResource({
 
 const transformThreadMails = (mails: Mail[]) =>
 	mails
-		.filter((mail) => filterRelevantMails(mail))
+		// Read-only views (the Screener) pass an explicit message list that isn't scoped to a mailbox.
+		.filter((mail) => readonly || filterRelevantMails(mail))
 		.map((mail) => ({
 			...mail,
 			groupedRecipients: getGroupedRecipients(mail.recipients, false),
@@ -559,8 +615,8 @@ const loadThread = () => {
 	})
 
 	// Opening a thread marks every message in the whole conversation read — including copies in other
-	// mailboxes (e.g. Sent) that aren't shown in this view.
-	if (source.some((mail) => !mail.seen)) setThreadSeen(true)
+	// mailboxes (e.g. Sent) that aren't shown in this view. Read-only views (the Screener) never do this.
+	if (!readonly && source.some((mail) => !mail.seen)) setThreadSeen(true)
 }
 
 // Mark the whole conversation seen/unseen — every message across all mailboxes, not just the ones
@@ -686,11 +742,25 @@ watch(
 onMounted(() => loadThread())
 
 const unblockEmailAddress = createResource({
-	url: 'mail.api.mail.unblock_email_addresses',
+	url: 'mail.api.mail.unscreen_email_addresses',
 	makeParams: (email) => ({ account_id: store.accountId, emails: [email] }),
 	onSuccess: () => {
 		raiseToast(__('Sender unblocked.'))
-		blockedAddresses.reload()
+		screenedAddresses.reload()
+	},
+})
+
+// Trusting a sender accepts them (screened in), so their remote images load now and going forward.
+const trustSender = createResource({
+	url: 'mail.api.mail.screen_email_addresses',
+	makeParams: (email: string) => ({
+		account_id: store.accountId,
+		emails: [email],
+		action: 'Accepted',
+	}),
+	onSuccess: () => {
+		raiseToast(__('Sender marked as trusted.'))
+		screenedAddresses.reload()
 	},
 })
 
@@ -837,7 +907,8 @@ const discardLocalDraft = (mail: string) => {
 // Shortcuts
 
 const handleKeydown = (e: KeyboardEvent) => {
-	if (shouldIgnoreKeypress(e)) return
+	// Read-only views (the Screener) expose no reply/forward, so their shortcuts are inert too.
+	if (readonly || shouldIgnoreKeypress(e)) return
 
 	const key = e.key.toLowerCase()
 	const lastMail = thread.value?.at(-1)
diff --git a/frontend/src/components/MailThreadSkeleton.vue b/frontend/src/components/MailThreadSkeleton.vue
new file mode 100644
index 000000000..c1eaea2f6
--- /dev/null
+++ b/frontend/src/components/MailThreadSkeleton.vue
@@ -0,0 +1,39 @@
+<template>
+	<div class="animate-pulse sm:space-y-4 sm:px-5 sm:py-6">
+		<div :class="{ 'px-3 py-5': isMobile }">
+			<!-- Header: avatar, sender/recipients, date -->
+			<div class="flex items-center space-x-3 pb-6">
+				<div class="bg-surface-gray-3 h-8 w-8 shrink-0 rounded-full" />
+				<div class="flex flex-1 justify-between">
+					<div class="flex flex-col space-y-2">
+						<div class="flex items-center space-x-2">
+							<div class="bg-surface-gray-3 h-3.5 w-32 rounded" />
+							<div class="bg-surface-gray-3 hidden h-3.5 w-48 rounded sm:block" />
+						</div>
+						<div class="bg-surface-gray-3 h-3 w-40 rounded" />
+					</div>
+					<div class="bg-surface-gray-3 h-3 w-16 shrink-0 self-start rounded" />
+				</div>
+			</div>
+
+			<!-- Body: heading + paragraph lines -->
+			<div class="space-y-2 py-4">
+				<div class="bg-surface-gray-3 mb-6 h-5 w-3/5 rounded" />
+				<div
+					v-for="(width, i) in lineWidths"
+					:key="i"
+					class="bg-surface-gray-3 h-2 rounded"
+					:style="{ width }"
+				/>
+			</div>
+		</div>
+	</div>
+</template>
+
+<script setup lang="ts">
+import { useScreenSize } from '@/utils/composables'
+
+const { isMobile } = useScreenSize()
+
+const lineWidths = ['90%', '75%', '82%', '60%', '88%', '45%']
+</script>
diff --git a/frontend/src/components/Modals/FolderModal.vue b/frontend/src/components/Modals/FolderModal.vue
index b4c4f1ee9..6d20abc86 100644
--- a/frontend/src/components/Modals/FolderModal.vue
+++ b/frontend/src/components/Modals/FolderModal.vue
@@ -286,9 +286,17 @@ watch(show, (val) => {
 	folder.disable_push_notification = original.disable_push_notification =
 		isNotificationsDisabled.value ? true : !!mailbox.disable_push_notification
 
-	if (parsedAutomationRules.value) {
-		Object.assign(automationRules, parsedAutomationRules.value)
-		Object.assign(originalAutomationRules, parsedAutomationRules.value)
+	// Rules come from the Mailbox Settings backup (mailbox.automation_rules), so they survive even if
+	// the sieve script was deleted by a third-party client.
+	if (mailbox.automation_rules) {
+		Object.assign(automationRules, {
+			...DEFAULT_AUTOMATION_RULES,
+			...mailbox.automation_rules,
+		})
+		Object.assign(originalAutomationRules, {
+			...DEFAULT_AUTOMATION_RULES,
+			...mailbox.automation_rules,
+		})
 	}
 })
 
@@ -312,53 +320,6 @@ const DEFAULT_AUTOMATION_RULES = {
 const automationRules = reactive({ ...DEFAULT_AUTOMATION_RULES })
 const originalAutomationRules = reactive({ ...DEFAULT_AUTOMATION_RULES })
 
-const parsedAutomationRules = computed(() => {
-	if (isNew.value || !automationScript.value || !original.name) return null
-
-	const content = automationScript.value.content
-
-	const commentPattern = `# Mailbox: ${original.name}\n`
-	const commentIndex = content.indexOf(commentPattern)
-
-	if (commentIndex === -1) return null
-
-	// Extract the block (from comment to closing brace)
-	const blockStart = commentIndex
-	const blockEnd = content.indexOf('\n}', blockStart)
-
-	if (blockEnd === -1) return null
-
-	const block = content.substring(blockStart, blockEnd + 2)
-
-	const rules = { ...DEFAULT_AUTOMATION_RULES }
-
-	// Parse emails_from
-	const emailsMatch = block.match(/address :matches "from" \[(.*?)\]/)
-	if (emailsMatch)
-		rules.emails_from = emailsMatch[1]
-			.split(',')
-			.map((email: string) => email.trim().replace(/"/g, ''))
-			.join(', ')
-
-	// Parse subject_contains
-	const subjectMatch = block.match(/header :contains "subject" \[(.*?)\]/)
-	if (subjectMatch)
-		rules.subject_contains = subjectMatch[1]
-			.split(',')
-			.map((keyword: string) => keyword.trim().replace(/"/g, ''))
-			.join(', ')
-
-	// Parse match_if (anyof vs allof)
-	if (block.includes('allof')) rules.match_if = 'all'
-	else if (block.includes('anyof')) rules.match_if = 'any'
-
-	// Parse flags
-	rules.mark_as_read = block.includes('addflag "\\\\Seen"')
-	rules.add_star = block.includes('addflag "\\\\Flagged"')
-
-	return rules
-})
-
 const isDefaultAutomation = computed(
 	() => JSON.stringify(automationRules) === JSON.stringify(DEFAULT_AUTOMATION_RULES),
 )
diff --git a/frontend/src/components/Modals/SettingsModal.vue b/frontend/src/components/Modals/SettingsModal.vue
index 439de4715..96b8be394 100644
--- a/frontend/src/components/Modals/SettingsModal.vue
+++ b/frontend/src/components/Modals/SettingsModal.vue
@@ -123,7 +123,7 @@ const tabs = computed(() => {
 			condition: user.data.is_jmap_configure,
 		},
 		{
-			label: __('Block List'),
+			label: __('Screened Senders'),
 			icon: Ban,
 			component: markRaw(BlockListSettings),
 			condition: user.data.is_jmap_configured,
diff --git a/frontend/src/components/SendMail.vue b/frontend/src/components/SendMail.vue
index 1afafb48e..d868497fd 100644
--- a/frontend/src/components/SendMail.vue
+++ b/frontend/src/components/SendMail.vue
@@ -2,7 +2,7 @@
 	<component
 		:is="isMobile ? SendMailMobileLayout : Dialog"
 		v-model="show"
-		:options="{ title: __('Compose Mail'), size: '6xl' }"
+		:options="{ title: __('Compose Mail'), size: '5xl' }"
 		@reload-mails="() => emit('reloadMails')"
 		@send-mail="editor?.sendMail()"
 		@discard-mail="editor?.discardMail()"
diff --git a/frontend/src/components/Settings/AccountSettings.vue b/frontend/src/components/Settings/AccountSettings.vue
index 45d9ad616..6b1c05b32 100644
--- a/frontend/src/components/Settings/AccountSettings.vue
+++ b/frontend/src/components/Settings/AccountSettings.vue
@@ -33,6 +33,22 @@
 		/>
 
 		<h1>{{ __('Incoming') }}</h1>
+		<Switch
+			v-model="enableScreening"
+			:label="__('Screen New Senders')"
+			:description="
+				__(
+					'Emails from new senders go to the Screener instead of your Inbox. Only accepted senders reach your Inbox.',
+				)
+			"
+			class="!p-0"
+		/>
+		<Switch
+			v-model="blockRemoteImages"
+			:label="__('Block Remote Images')"
+			:description="__(`Don't load remote images from untrusted sources by default.`)"
+			class="!p-0"
+		/>
 		<FormControl
 			v-model="accountSettings.doc.on_mark_as_junk"
 			type="select"
@@ -62,20 +78,30 @@
 			class="min-h-7"
 			@click="save"
 		/>
+
+		<Dialog v-model="showMoveToInbox" :options="moveToInboxOptions" />
 	</template>
 </template>
 
 <script setup lang="ts">
-import { computed, inject } from 'vue'
-import { Button, ErrorMessage, FormControl, Switch, createDocumentResource } from 'frappe-ui'
+import { computed, inject, ref } from 'vue'
+import {
+	Button,
+	Dialog,
+	ErrorMessage,
+	FormControl,
+	Switch,
+	createDocumentResource,
+	createResource,
+} from 'frappe-ui'
 
 import { raiseToast } from '@/utils'
 import { userStore } from '@/stores/user'
 
-import type { Identity } from '@/types'
+import type { Identity, MailboxData } from '@/types'
 
 const user = inject('$user')
-const { accountId, identities } = userStore()
+const { accountId, identities, mailboxes, mailboxIds } = userStore()
 
 // Outgoing settings now live on the active account's Account Settings; backup_email
 // (Recovery) is still per-user on User Settings.
@@ -106,9 +132,19 @@ const destroyNewsletterAfterSubmit = computed({
 	set: (val: boolean) => (accountSettings.doc.destroy_newsletter_after_submit = val ? 1 : 0),
 })
 
+const enableScreening = computed({
+	get: () => !!accountSettings.doc.enable_screening,
+	set: (val: boolean) => (accountSettings.doc.enable_screening = val ? 1 : 0),
+})
+
+const blockRemoteImages = computed({
+	get: () => !!accountSettings.doc.block_remote_images,
+	set: (val: boolean) => (accountSettings.doc.block_remote_images = val ? 1 : 0),
+})
+
 const ON_MARK_AS_JUNK_OPTIONS = [
 	{
-		label: __("Move the sender's future mail to Junk automatically"),
+		label: __("Move the sender's future emails to Junk automatically"),
 		value: "Junk Sender's Mail",
 	},
 	{ label: __('Ask whether to block the sender'), value: 'Ask to Block Sender' },
@@ -124,17 +160,58 @@ const isDirty = computed(() => accountDirty.value || userDirty.value)
 const loading = computed(() => accountSettings.get.loading || userSettings.get.loading)
 const saving = computed(() => accountSettings.save.loading || userSettings.save.loading)
 
+const showMoveToInbox = ref(false)
+
+const moveScreeningToInbox = createResource({
+	url: 'mail.api.mail.move_screening_mails_to_inbox',
+	makeParams: () => ({ account_id: accountId }),
+	onSuccess: () => {
+		raiseToast(__('Unscreened messages moved to Inbox.'))
+		showMoveToInbox.value = false
+		mailboxes.reload()
+	},
+})
+
+const moveToInboxOptions = computed(() => ({
+	title: __('Move unscreened messages?'),
+	message: __('Screening is off. Move the messages currently in the Screener to your Inbox?'),
+	actions: [
+		{
+			label: __('Move to Inbox'),
+			variant: 'solid',
+			onClick: () => moveScreeningToInbox.submit(),
+			loading: moveScreeningToInbox.loading,
+		},
+	],
+}))
+
 const save = async () => {
+	let askMoveToInbox = false
 	if (accountDirty.value) {
+		const screeningChanged =
+			!!accountSettings.doc.enable_screening !==
+			!!accountSettings.originalDoc?.enable_screening
+		// Turning screening off leaves the already-screened mail in the Screening folder — offer to move
+		// it to the inbox (only worth asking when there's something there).
+		askMoveToInbox =
+			screeningChanged &&
+			!accountSettings.doc.enable_screening &&
+			(mailboxes.data?.find((m: MailboxData) => m.id === mailboxIds.screening)
+				?.total_threads ?? 0) > 0
 		await accountSettings.save.submit()
 		// Sync the shared user data so compose picks up the new default and the junk flow picks up
 		// the "on mark as junk" choice without a page reload (both read from user.data.accounts).
 		if (activeAccount) {
 			activeAccount.default_outgoing_email = accountSettings.doc.default_outgoing_email
 			activeAccount.on_mark_as_junk = accountSettings.doc.on_mark_as_junk
+			activeAccount.enable_screening = !!accountSettings.doc.enable_screening
+			activeAccount.block_remote_images = !!accountSettings.doc.block_remote_images
 		}
+		// Enabling screening creates the Screening folder server-side; reload so it shows up.
+		if (screeningChanged) mailboxes.reload()
 	}
 	if (userDirty.value) await userSettings.save.submit()
 	raiseToast(__('Account updated.'))
+	if (askMoveToInbox) showMoveToInbox.value = true
 }
 </script>
diff --git a/frontend/src/components/Settings/AutomationSettings.vue b/frontend/src/components/Settings/AutomationSettings.vue
index 8bc689647..d0d927c7a 100644
--- a/frontend/src/components/Settings/AutomationSettings.vue
+++ b/frontend/src/components/Settings/AutomationSettings.vue
@@ -1,7 +1,18 @@
 <template>
 	<div class="flex items-center justify-between">
 		<h1>{{ __('Sieve Scripts') }}</h1>
-		<Button icon-left="plus" :label="__('New')" @click="addScript" />
+		<div class="flex items-center gap-2">
+			<Button
+				icon-left="refresh-cw"
+				:label="__('Rebuild Automation')"
+				:loading="rebuildAutomation.loading"
+				:tooltip="
+					__('Regenerate the folder automation script from your saved mailbox rules.')
+				"
+				@click="rebuildAutomation.submit()"
+			/>
+			<Button icon-left="plus" :label="__('New')" @click="addScript" />
+		</div>
 	</div>
 
 	<div v-if="filteredScripts.length">
@@ -59,8 +70,9 @@
 <script setup lang="ts">
 import { computed, ref } from 'vue'
 import { Ellipsis } from 'lucide-vue-next'
-import { Badge, Button, Dropdown } from 'frappe-ui'
+import { Badge, Button, Dropdown, createResource } from 'frappe-ui'
 
+import { raiseToast } from '@/utils'
 import { userStore } from '@/stores/user'
 import DeleteSieveScriptModal from '@/components/Modals/DeleteSieveScriptModal.vue'
 import SetSieveScriptStateModal from '@/components/Modals/SetSieveScriptStateModal.vue'
@@ -68,7 +80,18 @@ import SieveScriptModal from '@/components/Modals/SieveScriptModal.vue'
 
 import type { SieveScript } from '@/types'
 
-const { sieveScripts } = userStore()
+const store = userStore()
+const { sieveScripts } = store
+
+const rebuildAutomation = createResource({
+	url: 'mail.api.sieve.rebuild_automation_script_for_account',
+	makeParams: () => ({ account_id: store.accountId }),
+	onSuccess: () => {
+		raiseToast(__('Folder automation rebuilt from your saved rules.'))
+		sieveScripts.reload()
+	},
+	onError: (error) => raiseToast(error.messages?.[0] || error.message, 'error'),
+})
 
 const showSieveScript = ref(false)
 const selectedScript = ref<SieveScript>()
diff --git a/frontend/src/components/Settings/BlockListSettings.vue b/frontend/src/components/Settings/BlockListSettings.vue
index f9edba93d..1097b8987 100644
--- a/frontend/src/components/Settings/BlockListSettings.vue
+++ b/frontend/src/components/Settings/BlockListSettings.vue
@@ -1,45 +1,64 @@
 <template>
-	<h1>{{ __('Block List') }}</h1>
-
-	<div class="flex gap-4">
-		<FormControl
-			v-model="email"
-			type="text"
-			variant="outline"
-			:placeholder="__('Enter email address')"
-			class="flex-1"
-			@keydown.enter="blockEmailAddress.submit()"
-		/>
-		<Button
-			:label="__('Block')"
-			variant="solid"
-			:loading="blockEmailAddress.loading"
-			:disabled="!isEmail(email) || blockedAddresses.data.includes(email)"
-			@click="blockEmailAddress.submit()"
-		/>
-	</div>
+	<!-- A single h-full flex column gives the ListView a bounded flex parent so it fills the panel and
+	scrolls within itself, instead of taking a small intrinsic height with empty space below. -->
+	<div class="flex min-h-0 flex-1 flex-col gap-5">
+		<h1>{{ __('Screened Senders') }}</h1>
 
-	<ListView
-		v-if="blockedAddresses.data.length"
-		ref="listView"
-		:columns="COLUMNS"
-		:rows="rows"
-		row-key="name"
-	>
-		<ListHeader />
-		<ListRows />
-		<ListSelectBanner>
-			<template #actions>
-				<Button variant="ghost" :label="__('Unblock')" @click="showUnblockModal = true" />
-			</template>
-		</ListSelectBanner>
-	</ListView>
-	<div v-else class="text-ink-gray-6 flex flex-col space-y-2 text-sm">
-		<p class="text-base font-medium">{{ __('No blocked email addresses.') }}</p>
-		<p>{{ MESSAGE }}</p>
-	</div>
+		<div class="flex gap-4">
+			<FormControl
+				v-model="email"
+				type="text"
+				variant="outline"
+				:placeholder="__('Enter email address')"
+				class="flex-1"
+				@keydown.enter="screenEmailAddress.submit()"
+			/>
+			<!-- FormControl forces `w-full` on selects, so constrain it with a fixed-width wrapper
+			instead of letting it claim the whole row and squeeze the email input. -->
+			<div class="w-36 shrink-0">
+				<FormControl
+					v-model="action"
+					type="select"
+					variant="outline"
+					:options="ACTION_OPTIONS"
+				/>
+			</div>
+			<Button
+				:label="__('Add')"
+				variant="solid"
+				:loading="screenEmailAddress.loading"
+				:disabled="!isEmail(email) || isAlreadyScreened"
+				@click="screenEmailAddress.submit()"
+			/>
+		</div>
+
+		<ListView
+			v-if="rows.length"
+			ref="listView"
+			class="min-h-0 flex-1"
+			:columns="COLUMNS"
+			:rows="rows"
+			row-key="email"
+		>
+			<ListHeader />
+			<ListRows />
+			<ListSelectBanner>
+				<template #actions>
+					<Button
+						variant="ghost"
+						:label="__('Remove')"
+						@click="showRemoveModal = true"
+					/>
+				</template>
+			</ListSelectBanner>
+		</ListView>
+		<div v-else class="text-ink-gray-6 flex flex-col space-y-2 text-sm">
+			<p class="text-base font-medium">{{ __('No screened senders.') }}</p>
+			<p>{{ MESSAGE }}</p>
+		</div>
 
-	<Dialog v-model="showUnblockModal" :options="unblockModalOptions" />
+		<Dialog v-model="showRemoveModal" :options="removeModalOptions" />
+	</div>
 </template>
 
 <script setup lang="ts">
@@ -58,55 +77,85 @@ import {
 import { isEmail, raiseToast } from '@/utils'
 import { userStore } from '@/stores/user'
 
+import type { ScreenedAddress, ScreeningAction } from '@/types'
+
 const store = userStore()
-const { blockedAddresses } = store
+const { screenedAddresses } = store
 
 const email = ref('')
+const action = ref<ScreeningAction>('Reject')
 const listViewRef = useTemplateRef('listView')
-const showUnblockModal = ref(false)
+const showRemoveModal = ref(false)
 
-const rows = computed(() => blockedAddresses.data.map((address: string) => ({ name: address })))
+// 'Accepted' lets the sender's mail reach the inbox; 'Reject' discards it silently; 'Spam' files it
+// into the Spam folder.
+const ACTION_OPTIONS = [
+	{ label: __('Accept'), value: 'Accepted' },
+	{ label: __('Block'), value: 'Reject' },
+	{ label: __('Move to Junk'), value: 'Spam' },
+]
+const ACTION_LABELS: Partial<Record<ScreeningAction, string>> = {
+	Accepted: __('Accept'),
+	Reject: __('Block'),
+	Spam: __('Move to Junk'),
+}
+
+const isAlreadyScreened = computed(() =>
+	(screenedAddresses.data ?? []).some((a: ScreenedAddress) => a.email === email.value),
+)
+
+const rows = computed(() =>
+	(screenedAddresses.data ?? []).map((a: ScreenedAddress) => ({
+		email: a.email,
+		action: ACTION_LABELS[a.action] ?? a.action,
+	})),
+)
 
-const blockEmailAddress = createResource({
-	url: 'mail.api.mail.block_email_address',
-	makeParams: () => ({ account_id: store.accountId, email: email.value }),
+const screenEmailAddress = createResource({
+	url: 'mail.api.mail.screen_email_address',
+	makeParams: () => ({ account_id: store.accountId, email: email.value, action: action.value }),
 	onSuccess: () => {
-		raiseToast(__('Email address blocked.'))
+		raiseToast(__('Sender screened.'))
 		email.value = ''
-		blockedAddresses.reload()
+		screenedAddresses.reload()
 	},
 })
 
-const unblockEmailAddresses = createResource({
-	url: 'mail.api.mail.unblock_email_addresses',
+const unscreenEmailAddresses = createResource({
+	url: 'mail.api.mail.unscreen_email_addresses',
 	makeParams: () => ({
 		account_id: store.accountId,
 		emails: Array.from(listViewRef.value?.selections),
 	}),
 	onSuccess: () => {
-		raiseToast(__('Email addresses unblocked.'))
-		showUnblockModal.value = false
+		raiseToast(__('Senders removed.'))
+		showRemoveModal.value = false
 		listViewRef.value?.toggleAllRows()
-		blockedAddresses.reload()
+		screenedAddresses.reload()
 	},
 })
 
-const unblockModalOptions = computed(() => ({
-	title: __('Unblock Email Addresses'),
-	message: __('Are you sure you want to unblock the selected email addresses?'),
+const removeModalOptions = computed(() => ({
+	title: __('Remove Screened Senders'),
+	message: __('Are you sure you want to remove the selected senders from your screened list?'),
 	actions: [
 		{
 			label: __('Confirm'),
 			variant: 'solid',
-			onClick: () => unblockEmailAddresses.submit(),
-			loading: unblockEmailAddresses.loading,
+			onClick: () => unscreenEmailAddresses.submit(),
+			loading: unscreenEmailAddresses.loading,
 		},
 	],
 }))
 
-const COLUMNS = [{ label: __('Email Address'), key: 'name' }]
+// `fr` units (numbers) so the columns share the row width instead of overflowing (percentages plus the
+// checkbox column would exceed 100% and add a horizontal scrollbar).
+const COLUMNS = [
+	{ label: __('Email Address'), key: 'email', width: 4 },
+	{ label: __('Action'), key: 'action', width: 1 },
+]
 
 const MESSAGE = __(
-	'Block specific addresses to prevent their messages from appearing in your inbox.',
+	'Screen specific senders to either reject their messages or send them straight to Spam.',
 )
 </script>
diff --git a/frontend/src/components/ThreadHeader.vue b/frontend/src/components/ThreadHeader.vue
index 4401477b9..31a981cf3 100644
--- a/frontend/src/components/ThreadHeader.vue
+++ b/frontend/src/components/ThreadHeader.vue
@@ -1,12 +1,12 @@
 <template>
-	<div class="bg-surface-white sticky top-0 flex items-center border-b p-2.5 sm:px-5">
+	<div class="bg-surface-white sticky top-0 flex items-center border-b py-2.5 sm:px-3.5">
 		<Button
 			variant="ghost"
 			class="mr-2 shrink-0"
 			@click="$router.push({ name: 'Mailbox', params: { mailbox }, query: route.query })"
 		>
 			<template #icon>
-				<ChevronLeft class="text-ink-gray-7 icon" />
+				<ChevronLeft class="icon" />
 			</template>
 		</Button>
 		<template v-if="thread?.length">
@@ -109,7 +109,7 @@ import {
 import { Button, Dropdown, Tooltip } from 'frappe-ui'
 
 import { FOLDER_ICON_COLOR_MAP } from '@/constants'
-import { getIcon } from '@/utils'
+import { getIcon, getMailboxName } from '@/utils'
 import { useScreenSize } from '@/utils/composables'
 import { userStore } from '@/stores/user'
 
@@ -270,7 +270,7 @@ const getMailboxOption = (
 	mailbox: MailboxData,
 	emitName: 'moveThread' | 'addThreadToMailbox' | 'removeThreadFromMailbox',
 ) => ({
-	label: mailbox._name,
+	label: getMailboxName(mailbox),
 	icon: h(Icon, { name: getIcon(mailbox), class: FOLDER_ICON_COLOR_MAP[mailbox.color!] }),
 	onClick: () => emit(emitName, mailbox.id),
 })
diff --git a/frontend/src/constants.ts b/frontend/src/constants.ts
index aa1a1aa4f..7b0ca2512 100644
--- a/frontend/src/constants.ts
+++ b/frontend/src/constants.ts
@@ -1,3 +1,7 @@
+// The Screening mailbox is a plain named folder (no JMAP role), created server-side as "Screening";
+// it's surfaced to users as the "Screener".
+export const SCREENING_MAILBOX_NAME = 'Screener'
+
 export const getAttachmentOptions = () => [
 	{ label: __('All'), value: ' ' },
 	{ label: __('With Attachments'), value: 'true' },
diff --git a/frontend/src/pages/MailboxView.vue b/frontend/src/pages/MailboxView.vue
index f291e1ad6..c80810efa 100644
--- a/frontend/src/pages/MailboxView.vue
+++ b/frontend/src/pages/MailboxView.vue
@@ -14,6 +14,14 @@
 		</div>
 		<HeaderActions @reload-mails="reloadThreads(true, ['drafts', 'sent'])" />
 	</header>
+
+	<!-- Unscreened-thread nudge on the inbox, mirroring the trash/junk info bar: shown while Hey-style
+	     screening is on and threads are waiting to be screened. -->
+	<div v-if="showScreenerBanner" class="space-x-1 border-b px-3 py-2.5 sm:px-5">
+		<span class="text-ink-gray-5">{{ screenerBannerLabel }}</span>
+		<Button :label="__('Review Now')" variant="ghost" @click="goToScreener" />
+	</div>
+
 	<div
 		v-if="
 			[mailboxIds.trash, mailboxIds.junk].includes(mailbox) &&
@@ -32,7 +40,7 @@
 	<div
 		class="relative flex"
 		:class="
-			[mailboxIds.trash, mailboxIds.junk].includes(mailbox)
+			[mailboxIds.trash, mailboxIds.junk].includes(mailbox) || showScreenerBanner
 				? 'h-[calc(100dvh-6.1rem)]'
 				: 'h-[calc(100dvh-3.05rem)]'
 		"
@@ -398,7 +406,7 @@ import MailThread from '@/components/MailThread.vue'
 import BlockSenderModal from '@/components/Modals/BlockSenderModal.vue'
 import ShortcutsModal from '@/components/Modals/ShortcutsModal.vue'
 
-import type { COLOR_SCHEME, Thread, UserResource } from '@/types'
+import type { MailboxData, Thread, UserResource } from '@/types'
 
 const { accountId, mailbox, threadID } = defineProps<{
 	accountId: string
@@ -410,7 +418,7 @@ const route = useRoute()
 const router = useRouter()
 const { isMobile } = useScreenSize()
 const { openSidebar } = useSidebar()
-const { undo } = useUndo()
+const { undo, setUndoAction } = useUndo()
 
 const socket = inject('$socket')
 const user = inject('$user') as UserResource
@@ -550,13 +558,6 @@ const handleKeyDown = (e: KeyboardEvent) => {
 	isShiftPressed.value = e.shiftKey
 	const key = e.key.toLowerCase()
 
-	// Handle Ctrl/Cmd+Shift+L (Cycle Theme)
-	if ((e.metaKey || e.ctrlKey) && e.shiftKey && key === 'l' && !shouldIgnoreKeypress(e, true)) {
-		e.preventDefault()
-		isGPressed.value = false
-		return cycleTheme()
-	}
-
 	// Handle Ctrl/Cmd+A (Select All)
 	if ((e.metaKey || e.ctrlKey) && key === 'a' && !shouldIgnoreKeypress(e, true)) {
 		e.preventDefault()
@@ -628,28 +629,6 @@ const handleShowShortcuts = (e: KeyboardEvent) => {
 	showShortcuts.value = true
 }
 
-const COLOR_SCHEME_CYCLE = ['System Default', 'Light Mode', 'Dark Mode'] as const
-
-const cycleTheme = () => {
-	const current = user.data.color_scheme
-	const idx = COLOR_SCHEME_CYCLE.indexOf(current as COLOR_SCHEME)
-	const next = COLOR_SCHEME_CYCLE[(idx + 1) % COLOR_SCHEME_CYCLE.length]
-	updateColorScheme.submit(next)
-}
-
-const updateColorScheme = createResource({
-	url: 'frappe.client.set_value',
-	makeParams: (color_scheme: COLOR_SCHEME) => ({
-		doctype: 'User Settings',
-		name: user.data.user_settings,
-		fieldname: { color_scheme },
-	}),
-	onSuccess: (data) => {
-		raiseToast(__('Color scheme updated to {0}.', [data.color_scheme]))
-		user.reload()
-	},
-})
-
 const handleEnter = (e: KeyboardEvent) => {
 	e.preventDefault()
 	if (threadInFocus.value) goToThread(threadInFocus.value)
@@ -842,6 +821,31 @@ const hasMore = ref(false) // lookahead: an extra row was returned, so a next pa
 // detect count changes and by the tab title's unread badge.
 const mailboxObj = computed(() => mailboxes.data?.find((m) => m.id === mailbox))
 
+// ── Screener banner ─────────────────────────────────────────────────────────────────────────────
+// An info bar mirroring the trash/junk one, shown on the inbox while Hey-style screening is on and
+// unscreened threads are waiting. The count is the Screening folder's unread count, kept fresh by the
+// periodic mailbox poll below.
+const activeAccount = computed(() => user.data?.accounts?.find((a) => a.id === accountId))
+const screeningEnabled = computed(() => !!activeAccount.value?.enable_screening)
+const screenerCount = computed(
+	() =>
+		mailboxes.data?.find((m: MailboxData) => m.id === mailboxIds.screening)?.unread_threads ??
+		0,
+)
+const showScreenerBanner = computed(
+	() =>
+		mailbox === mailboxIds.inbox &&
+		screeningEnabled.value &&
+		screenerCount.value > 0 &&
+		(showReadingPane.value || !threadID),
+)
+const screenerBannerLabel = computed(() =>
+	screenerCount.value === 1
+		? __('1 new thread is waiting to be screened.')
+		: __('{0} new threads are waiting to be screened.', [String(screenerCount.value)]),
+)
+const goToScreener = () => router.push({ name: 'Screener', params: { accountId } })
+
 // Called once a page's data has loaded: reveal it (range + list update together) and scroll to top.
 // No-op for same-page reloads (e.g. the periodic refresh) so those don't yank the scroll position.
 const syncDisplayedPage = () => {
@@ -1072,6 +1076,8 @@ onUnmounted(() => {
 	window.removeEventListener('keydown', handleKeyDown)
 	window.removeEventListener('keyup', handleKeyUp)
 	if (reloadInterval.value) clearInterval(reloadInterval.value)
+	// Leaving the mailbox drops any pending undo so a lingering toast can't undo into another view.
+	setUndoAction(undefined)
 })
 
 const goToMailbox = () =>
diff --git a/frontend/src/pages/ScreenerView.vue b/frontend/src/pages/ScreenerView.vue
new file mode 100644
index 000000000..bd21bbdd3
--- /dev/null
+++ b/frontend/src/pages/ScreenerView.vue
@@ -0,0 +1,426 @@
+<template>
+	<div v-if="screeningEnabled" class="flex h-full flex-col">
+		<header class="flex items-center justify-between border-b px-3 py-2.5 sm:px-5">
+			<div class="flex items-center space-x-2">
+				<Button v-if="isMobile" icon="menu" variant="ghost" @click="openSidebar" />
+				<Breadcrumbs :items="[{ label: __('Screener') }]" />
+			</div>
+			<HeaderActions @reload-mails="senders.reload()" />
+		</header>
+
+		<div class="relative flex flex-1 overflow-hidden">
+			<!-- Loading the sender list — centered like the mailbox empty/loading states. -->
+			<div
+				v-if="senders.loading && !senders.data"
+				class="flex h-[calc(100dvh-6.1rem)] w-full flex-col items-center justify-center"
+			>
+				<div class="text-ink-gray-5 flex items-center space-x-2">
+					<LoaderCircle class="h-5 w-5 animate-spin" />
+					<span>{{ __('Loading...') }}</span>
+				</div>
+			</div>
+
+			<!-- Nothing to screen — one centered empty screen, no split. -->
+			<div
+				v-else-if="!senders.data?.length"
+				class="text-ink-gray-5 flex h-[calc(100dvh-6.1rem)] w-full flex-col items-center justify-center"
+			>
+				<NoMails class="text-ink-gray-2 mb-2 h-16 w-16" />
+				<p>{{ __('You have no new senders to screen.') }}</p>
+			</div>
+
+			<template v-else>
+				<!-- Sender list -->
+				<div
+					class="flex flex-col overflow-y-auto"
+					:class="!isMobile && showReadingPane ? 'w-1/3 border-r' : 'w-full'"
+				>
+					<div class="pb-20">
+						<!-- Count bar — matches the mailbox "All Mails" toolbar height/style. -->
+						<div class="flex min-h-[49px] items-center justify-between border-b px-5">
+							<span class="text-ink-gray-5 truncate">{{ waitingLabel }}</span>
+							<Button
+								:label="__('Clear All')"
+								variant="ghost"
+								class="-mr-2"
+								@click="showClearAll = true"
+							/>
+						</div>
+
+						<div
+							v-for="sender in senders.data"
+							:key="sender.from_email"
+							:data-sender-email="sender.from_email"
+							class="sm:hover:bg-surface-gray-1 flex cursor-default select-none items-stretch gap-4 border-b px-5 py-2.5"
+							:class="{
+								'!bg-surface-blue-1': openSender?.from_email === sender.from_email,
+							}"
+							@click="selectSender(sender)"
+						>
+							<div class="min-w-0 flex-1 space-y-1">
+								<div class="flex min-w-0 items-baseline gap-2">
+									<span
+										class="text-ink-gray-8 truncate text-[15px] !font-semibold sm:text-base"
+									>
+										{{ sender.from_name || sender.from_email }}
+									</span>
+									<span class="text-ink-gray-5 truncate text-[13px]">
+										{{ sender.from_email }}
+									</span>
+								</div>
+								<div
+									class="text-ink-gray-8 truncate text-sm !font-semibold !leading-[1.5]"
+								>
+									{{ sender.subject || __('[No subject]') }}
+								</div>
+								<div
+									v-if="sender.preview || sender.count > 1"
+									class="text-ink-gray-5 truncate text-sm !leading-[1.5]"
+								>
+									<span v-if="sender.preview">{{ sender.preview }}</span>
+									<span v-if="sender.count > 1">
+										{{ sender.preview ? ' · ' : ''
+										}}{{ __('{0} messages', [String(sender.count)]) }}
+									</span>
+								</div>
+							</div>
+
+							<!-- Time top-right, persistent Block / Allow parked bottom-right -->
+							<div class="flex shrink-0 flex-col items-end justify-between">
+								<MailDate
+									:datetime="sender.received_at"
+									:in-list="true"
+									class="text-ink-gray-4 whitespace-nowrap pt-px text-xs tabular-nums"
+								/>
+								<div class="-mr-2 flex gap-2">
+									<Button
+										variant="outline"
+										:label="__('Block')"
+										@click.stop="screenOut([sender.from_email])"
+									/>
+									<Button
+										variant="outline"
+										:label="__('Allow')"
+										@click.stop="allow([sender.from_email])"
+									/>
+								</div>
+							</div>
+						</div>
+					</div>
+				</div>
+
+				<!-- Read-only thread preview — split when the reading pane is on, full-width otherwise -->
+				<div
+					class="bg-surface-white flex flex-col"
+					:class="{
+						'w-2/3': !isMobile && showReadingPane,
+						'absolute bottom-0 left-0 right-0 top-0': !isMobile && !showReadingPane,
+						'fixed inset-0': isMobile,
+						hidden: (isMobile || !showReadingPane) && !openSender,
+					}"
+				>
+					<template v-if="openSender">
+						<!-- Subject + Block/Allow; back button only when the preview owns the whole pane -->
+						<div
+							class="bg-surface-white sticky top-0 z-10 flex shrink-0 items-center justify-between gap-3 border-b p-2.5 sm:px-5"
+						>
+							<div class="flex min-w-0 items-center">
+								<Button
+									variant="ghost"
+									class="-ml-1.5 mr-2 shrink-0"
+									@click="closeSender"
+								>
+									<template #icon>
+										<ChevronLeft class="icon" />
+									</template>
+								</Button>
+								<h2 class="truncate font-semibold leading-5">
+									{{ openSender.subject || __('[No subject]') }}
+								</h2>
+							</div>
+							<div class="flex shrink-0 gap-2">
+								<Button
+									variant="outline"
+									:label="__('Block')"
+									@click="screenOut([openSender.from_email])"
+								/>
+								<Button
+									variant="solid"
+									:label="__('Allow')"
+									@click="allow([openSender.from_email])"
+								/>
+							</div>
+						</div>
+
+						<MailThreadSkeleton v-if="previewLoading" />
+						<MailThread
+							v-else-if="previewMails?.length"
+							:key="openSender.from_email"
+							class="min-h-0 flex-1"
+							readonly
+							mailbox=""
+							:thread-i-d="openSender.from_email"
+							:threads="[]"
+							:messages="previewMails"
+						/>
+					</template>
+
+					<div v-else class="flex-1 overflow-hidden">
+						<div
+							class="bg-surface-gray-1 m-5 flex h-[calc(100%-2.9em)] items-center justify-center rounded-md"
+						>
+							<div class="flex flex-col items-center space-y-3">
+								<NoMails class="text-ink-gray-2 h-16 w-16" />
+								<p class="text-ink-gray-4">
+									{{ __('Select a sender to view their emails.') }}
+								</p>
+							</div>
+						</div>
+					</div>
+				</div>
+			</template>
+		</div>
+
+		<Dialog v-model="showClearAll" :options="clearAllOptions" />
+	</div>
+</template>
+
+<script setup lang="ts">
+import { computed, nextTick, onMounted, onUnmounted, ref, watch } from 'vue'
+import { useRouter } from 'vue-router'
+import { ChevronLeft, LoaderCircle } from 'lucide-vue-next'
+import { Breadcrumbs, Button, Dialog, createResource, usePageMeta } from 'frappe-ui'
+
+import { raiseToast, shouldIgnoreKeypress } from '@/utils'
+import { useScreenSize, useSidebar } from '@/utils/composables'
+import { userStore } from '@/stores/user'
+import HeaderActions from '@/components/HeaderActions.vue'
+import NoMails from '@/components/Icons/NoMails.vue'
+import MailDate from '@/components/MailDate.vue'
+import MailThread from '@/components/MailThread.vue'
+import MailThreadSkeleton from '@/components/MailThreadSkeleton.vue'
+
+import type { Mail, MailboxData, ScreeningSender } from '@/types'
+
+const store = userStore()
+const router = useRouter()
+const { isMobile } = useScreenSize()
+const { openSidebar } = useSidebar()
+
+const showReadingPane = computed(() => !!store.userResource?.data?.show_reading_pane)
+
+// The Screener only exists when screening is enabled. If it's off, render nothing and send the user to
+// their inbox (the route is still reachable by URL even though the sidebar hides it).
+const screeningEnabled = computed(
+	() =>
+		!!store.userResource?.data?.accounts?.find((a) => a.id === store.accountId)
+			?.enable_screening,
+)
+watch(
+	() => [!!store.userResource?.data, screeningEnabled.value, store.mailboxIds.inbox] as const,
+	([ready, enabled, inboxId]) => {
+		if (ready && !enabled && inboxId)
+			router.replace({
+				name: 'Mailbox',
+				params: { accountId: store.accountId, mailbox: inboxId },
+			})
+	},
+	{ immediate: true },
+)
+
+// The sender whose mail is open in the read-only preview, and that sender's messages.
+const openSender = ref<ScreeningSender | null>(null)
+const senderMails = createResource({
+	url: 'mail.api.mail.get_screening_sender_mails',
+	makeParams: () => ({ account_id: store.accountId, from_email: openSender.value?.from_email }),
+})
+
+// The preview reads `previewMails`, not the resource's `.data`: fast navigation fires several fetches
+// at once and the resource flips `loading` off on the first reply that lands, so an out-of-order reply
+// could otherwise leak the previous sender in (and the thread then appends the next one onto it). Each
+// fetch carries a token; only the most recent one is applied.
+const previewMails = ref<Mail[]>()
+const previewLoading = ref(false)
+let previewToken = 0
+
+const selectSender = (sender: ScreeningSender) => {
+	if (openSender.value?.from_email === sender.from_email) return
+	openSender.value = sender
+
+	const token = ++previewToken
+	previewMails.value = undefined
+	previewLoading.value = true
+	;(senderMails.reload() as Promise<Mail[]>)
+		.then((mails) => {
+			if (token !== previewToken) return
+			previewMails.value = mails ?? []
+			previewLoading.value = false
+		})
+		.catch(() => {
+			if (token === previewToken) previewLoading.value = false
+		})
+}
+
+const closeSender = () => {
+	openSender.value = null
+}
+
+const senders = createResource({
+	url: 'mail.api.mail.get_screening_senders',
+	makeParams: () => ({ account_id: store.accountId }),
+	auto: true,
+})
+
+// Once a mail is open, ↑/↓ (or k/j) step to the previous/next sender and Esc closes it. Else inert.
+const handleKeydown = (e: KeyboardEvent) => {
+	if (!openSender.value || shouldIgnoreKeypress(e)) return
+	const key = e.key.toLowerCase()
+
+	if (key === 'escape') {
+		e.preventDefault()
+		closeSender()
+		return
+	}
+
+	const offset =
+		key === 'arrowup' || key === 'k' ? -1 : key === 'arrowdown' || key === 'j' ? 1 : 0
+	if (!offset) return
+
+	e.preventDefault()
+	const list = senders.data ?? []
+	const cur = list.findIndex(
+		(s: ScreeningSender) => s.from_email === openSender.value!.from_email,
+	)
+	const next = list[cur + offset]
+	if (!next) return
+
+	selectSender(next)
+	nextTick(() =>
+		document
+			.querySelector(`[data-sender-email="${next.from_email}"]`)
+			?.scrollIntoView({ block: 'nearest' }),
+	)
+}
+
+// Poll the Screening folder's count and only refetch the (heavier) sender list when it changes — the
+// same cheap-count-then-reload approach the mailbox uses, so a quiet screener isn't reloaded every tick.
+const screeningCount = () =>
+	store.mailboxes.data?.find((m: MailboxData) => m.id === store.mailboxIds.screening)
+		?.total_threads
+
+const pollForChanges = async () => {
+	const prev = screeningCount()
+	await store.mailboxes.reload()
+	if (screeningCount() !== prev) senders.reload()
+}
+
+let pollInterval: ReturnType<typeof setInterval>
+
+onMounted(() => {
+	window.addEventListener('keydown', handleKeydown)
+	pollInterval = setInterval(pollForChanges, 30000)
+})
+
+onUnmounted(() => {
+	window.removeEventListener('keydown', handleKeydown)
+	clearInterval(pollInterval)
+})
+
+usePageMeta(() => {
+	const n = senders.data?.length ?? 0
+	return { title: n ? `(${n}) ${__('Screener')}` : __('Screener') }
+})
+
+const waitingLabel = computed(() => {
+	const n = senders.data?.length ?? 0
+	return n === 1 ? __('1 new sender.') : __('{0} new senders.', [String(n)])
+})
+
+const allowResource = createResource({
+	url: 'mail.api.mail.allow_screening_senders',
+	makeParams: ({ from_emails }: { from_emails: string[] }) => ({
+		account_id: store.accountId,
+		from_emails,
+	}),
+})
+
+const screenOutResource = createResource({
+	url: 'mail.api.mail.screen_out_senders',
+	makeParams: ({ from_emails }: { from_emails: string[] }) => ({
+		account_id: store.accountId,
+		from_emails,
+	}),
+})
+
+const runAction = async (resource: typeof allowResource, fromEmails: string[]) => {
+	if (!fromEmails.length) return
+
+	// When acting on the sender open in the detail view, line up the next one down so you can triage
+	// straight through — resolved before the optimistic removal.
+	const list = senders.data ?? []
+	const actingOnOpen = !!openSender.value && fromEmails.includes(openSender.value.from_email)
+	let nextSender: ScreeningSender | undefined
+	if (actingOnOpen) {
+		const idx = list.findIndex(
+			(s: ScreeningSender) => s.from_email === openSender.value!.from_email,
+		)
+		nextSender = list
+			.slice(idx + 1)
+			.find((s: ScreeningSender) => !fromEmails.includes(s.from_email))
+	}
+
+	// Optimistically drop the acted senders so the rows leave immediately and every other row stays
+	// interactive. The row leaving is the only success feedback (no toast); only failures are surfaced
+	// — with a resync to bring the rows back.
+	senders.data = list.filter((s: ScreeningSender) => !fromEmails.includes(s.from_email))
+
+	// Advance to the next sender (or close the preview if there's nothing below).
+	if (actingOnOpen) {
+		if (nextSender) selectSender(nextSender)
+		else closeSender()
+	}
+
+	try {
+		await resource.submit({ from_emails: fromEmails })
+		// Allowing/screening senders changes inbox/junk counts too.
+		store.mailboxes.reload()
+	} catch (error) {
+		senders.reload()
+		raiseToast((error as Error).message || __('Action failed.'), 'error')
+	}
+}
+
+const allow = (fromEmails: string[]) => runAction(allowResource, fromEmails)
+const screenOut = (fromEmails: string[]) => runAction(screenOutResource, fromEmails)
+
+// Clear All empties the queue without judging anyone: it moves all screened mail to the inbox but
+// creates no Block/Allow rule, so a mixed queue can't accidentally whitelist spam or block a real sender.
+const showClearAll = ref(false)
+
+const clearAllResource = createResource({
+	url: 'mail.api.mail.move_screening_mails_to_inbox',
+	makeParams: () => ({ account_id: store.accountId }),
+	onSuccess: () => {
+		senders.data = []
+		closeSender()
+		showClearAll.value = false
+		store.mailboxes.reload()
+		raiseToast(__('Unscreened messages moved to Inbox.'))
+	},
+})
+
+const clearAllOptions = computed(() => ({
+	title: __('Clear the Screener?'),
+	message: __(
+		'This will move current unscreened messages to your Inbox. Future emails from these senders will still go to the Screener.',
+	),
+	actions: [
+		{
+			label: __('Move to Inbox'),
+			variant: 'solid',
+			onClick: () => clearAllResource.submit(),
+			loading: clearAllResource.loading,
+		},
+	],
+}))
+</script>
diff --git a/frontend/src/router.ts b/frontend/src/router.ts
index 18a34151e..66d7b14b3 100644
--- a/frontend/src/router.ts
+++ b/frontend/src/router.ts
@@ -52,6 +52,12 @@ const routes = [
 		component: () => import('@/pages/MailboxView.vue'),
 		props: true,
 	},
+	{
+		path: '/account/:accountId/screener',
+		name: 'Screener',
+		component: () => import('@/pages/ScreenerView.vue'),
+		props: true,
+	},
 	{
 		path: '/account/:accountId/address-books/',
 		name: 'AddressBooks',
diff --git a/frontend/src/stores/user.ts b/frontend/src/stores/user.ts
index dae7eed9c..3a8fa6361 100644
--- a/frontend/src/stores/user.ts
+++ b/frontend/src/stores/user.ts
@@ -2,6 +2,8 @@ import { computed, ref } from 'vue'
 import { defineStore } from 'pinia'
 import { createResource } from 'frappe-ui'
 
+import { SCREENING_MAILBOX_NAME } from '@/constants'
+
 import type { UserAccount, UserResource } from '@/types'
 
 export type MailboxRole = 'inbox' | 'sent' | 'drafts' | 'trash' | 'junk' | 'archive' | 'important'
@@ -39,7 +41,7 @@ export const userStore = defineStore('mail-user', () => {
 		mailboxes.fetch()
 		addressBooks.fetch()
 		identities.fetch()
-		blockedAddresses.fetch()
+		screenedAddresses.fetch()
 		sieveScripts.fetch()
 	}
 
@@ -64,7 +66,7 @@ export const userStore = defineStore('mail-user', () => {
 	})
 
 	const mailboxIds = computed(() => {
-		const ids: Record<MailboxRole, string> = {
+		const ids: Record<MailboxRole | 'screening', string> = {
 			inbox: '',
 			sent: '',
 			drafts: '',
@@ -72,9 +74,11 @@ export const userStore = defineStore('mail-user', () => {
 			junk: '',
 			archive: '',
 			important: '',
+			screening: '',
 		}
-		mailboxes.data?.forEach((m: { role?: MailboxRole; id: string }) => {
+		mailboxes.data?.forEach((m: { role?: MailboxRole; _name?: string; id: string }) => {
 			if (m.role) ids[m.role] = m.id
+			else if (m._name === SCREENING_MAILBOX_NAME) ids.screening = m.id
 		})
 		return ids
 	})
@@ -91,10 +95,12 @@ export const userStore = defineStore('mail-user', () => {
 		cache: ['identities', accountId.value],
 	})
 
-	const blockedAddresses = createResource({
-		url: 'mail.api.mail.get_blocked_addresses',
+	// Screened senders for the account: each is `{ email, action }` where action is 'Reject'
+	// (discard incoming mail), 'Spam' (file it into the Spam folder), or 'Accepted'.
+	const screenedAddresses = createResource({
+		url: 'mail.api.mail.get_screened_addresses',
 		makeParams: () => ({ account_id: accountId.value }),
-		cache: ['blockedAddresses', accountId.value],
+		cache: ['screenedAddresses', accountId.value],
 	})
 
 	const sieveScripts = createResource({
@@ -115,7 +121,7 @@ export const userStore = defineStore('mail-user', () => {
 		mailboxes.reset()
 		addressBooks.reset()
 		identities.reset()
-		blockedAddresses.reset()
+		screenedAddresses.reset()
 		sieveScripts.reset()
 		domains.reset()
 	}
@@ -131,7 +137,7 @@ export const userStore = defineStore('mail-user', () => {
 		identities,
 		domains,
 		sieveScripts,
-		blockedAddresses,
+		screenedAddresses,
 		reset,
 	}
 })
diff --git a/frontend/src/types/index.ts b/frontend/src/types/index.ts
index c96923227..3deae587c 100644
--- a/frontend/src/types/index.ts
+++ b/frontend/src/types/index.ts
@@ -7,6 +7,26 @@ export type COLOR_SCHEME = 'System Default' | 'Light Mode' | 'Dark Mode'
 // What happens to a sender when one of their messages is marked as Junk (Account Settings).
 export type OnMarkAsJunk = "Junk Sender's Mail" | 'Ask to Block Sender'
 
+// A screened sender: how their future mail is handled. 'Reject' discards it silently; 'Spam' files
+// it into the Spam (Junk) folder; 'Accepted' lets it reach the inbox. (Doctype: Screened Email Address.)
+export type ScreeningAction = 'Reject' | 'Spam' | 'Accepted'
+
+export interface ScreenedAddress {
+	email: string
+	action: ScreeningAction
+}
+
+// A row in the Screener: one unique sender in the Screening folder, summarised by their latest mail.
+export interface ScreeningSender {
+	from_email: string
+	from_name: string
+	subject: string
+	preview: string
+	received_at: number
+	count: number
+	unread: number
+}
+
 export interface User {
 	name: string
 	email: string
@@ -33,6 +53,8 @@ export interface User {
 		default_outgoing_email?: string
 		account_settings?: string
 		on_mark_as_junk?: OnMarkAsJunk
+		enable_screening?: boolean
+		block_remote_images?: boolean
 	})[]
 }
 
@@ -150,6 +172,15 @@ export interface MailboxData {
 	icon?: string
 	color?: 'Blue' | 'Green' | 'Amber' | 'Red' | 'Purple'
 	disable_push_notification?: 0 | 1
+	automation_rules?: AutomationRules | null
+}
+
+export interface AutomationRules {
+	emails_from: string
+	subject_contains: string
+	match_if: 'any' | 'all'
+	mark_as_read: boolean
+	add_star: boolean
 }
 
 export interface NotificationPayload {
diff --git a/frontend/src/utils/composables.ts b/frontend/src/utils/composables.ts
index 820b00191..ee2a2e548 100644
--- a/frontend/src/utils/composables.ts
+++ b/frontend/src/utils/composables.ts
@@ -1,10 +1,10 @@
 import { computed, onMounted, onUnmounted, reactive, ref } from 'vue'
 import { createResource } from 'frappe-ui'
 
-import { raisePromiseToast } from '@/utils'
+import { raisePromiseToast, raiseToast } from '@/utils'
 import { userStore } from '@/stores/user'
 
-import type { Identity } from '@/types'
+import type { COLOR_SCHEME, Identity, ScreenedAddress } from '@/types'
 
 export const useScreenSize = () => {
 	const size = reactive({ width: window.innerWidth, height: window.innerHeight })
@@ -116,8 +116,8 @@ const sendersToBlock = ref<BlockableSender[]>([])
 
 export const useBlockSender = () => {
 	const store = userStore()
-	const { userResource, identities, blockedAddresses } = store
-	const { setUndoAction, undo, prependUndoAction } = useUndo()
+	const { userResource, identities, screenedAddresses } = store
+	const { setUndoAction, undo } = useUndo()
 
 	// Read account/accountId off the store at call time — destructuring would snapshot the unwrapped
 	// values and miss account switches while a component stays mounted.
@@ -125,11 +125,15 @@ export const useBlockSender = () => {
 		userResource.data?.accounts?.find((a) => a.id === store.accountId),
 	)
 
-	// Senders worth offering to block: drop the user's own identities and addresses already blocked,
-	// and de-duplicate by email (keeping the first occurrence's display name).
+	// Senders worth offering to block: drop the user's own identities and addresses already blocked
+	// (screened as Reject), and de-duplicate by email (keeping the first occurrence's display name).
 	const blockableSenders = (senders: { name?: string; email?: string }[]) => {
 		const own = new Set((identities.data ?? []).map((i: Identity) => i.email))
-		const blocked = new Set<string>(blockedAddresses.data ?? [])
+		const blocked = new Set<string>(
+			(screenedAddresses.data ?? [])
+				.filter((a: ScreenedAddress) => a.action === 'Reject')
+				.map((a: ScreenedAddress) => a.email),
+		)
 		const seen = new Set<string>()
 		const result: BlockableSender[] = []
 		for (const { name, email } of senders) {
@@ -141,37 +145,22 @@ export const useBlockSender = () => {
 	}
 
 	const blockResource = createResource({
-		url: 'mail.api.mail.block_email_addresses',
+		url: 'mail.api.mail.screen_email_addresses',
 		makeParams: ({ emails }: { emails: string[] }) => ({
 			account_id: store.accountId,
 			emails,
+			action: 'Reject',
 		}),
-		onSuccess: () => blockedAddresses.reload(),
+		onSuccess: () => screenedAddresses.reload(),
 	})
 
-	const junkResource = createResource({
-		url: 'mail.api.mail.junk_senders',
+	const unscreenResource = createResource({
+		url: 'mail.api.mail.unscreen_email_addresses',
 		makeParams: ({ emails }: { emails: string[] }) => ({
 			account_id: store.accountId,
 			emails,
 		}),
-	})
-
-	const unjunkResource = createResource({
-		url: 'mail.api.mail.unjunk_senders',
-		makeParams: ({ emails }: { emails: string[] }) => ({
-			account_id: store.accountId,
-			emails,
-		}),
-	})
-
-	const unblockResource = createResource({
-		url: 'mail.api.mail.unblock_email_addresses',
-		makeParams: ({ emails }: { emails: string[] }) => ({
-			account_id: store.accountId,
-			emails,
-		}),
-		onSuccess: () => blockedAddresses.reload(),
+		onSuccess: () => screenedAddresses.reload(),
 	})
 
 	// Block the senders chosen in the prompt ('Ask to Block Sender' confirm). Blocking becomes the new
@@ -181,7 +170,7 @@ export const useBlockSender = () => {
 		if (!emails.length) return
 
 		setUndoAction(() => {
-			const undoAction = () => unblockResource.submit({ emails })
+			const undoAction = () => unscreenResource.submit({ emails })
 			const restored =
 				emails.length === 1 ? __('Sender unblocked.') : __('Senders unblocked.')
 			raisePromiseToast(undoAction, __('Undoing...'), restored)
@@ -192,35 +181,22 @@ export const useBlockSender = () => {
 		raisePromiseToast(action, __('Blocking...'), success, undo)
 	}
 
-	// File the senders' future mail into Junk (the default 'Junk Sender's Mail'). Side effect only — the
-	// caller renders the toast (see willJunkSenders) so the junk action shows a single toast, not two.
-	// Undoing the junk move also drops them from the junk list (composed onto that move's undo).
-	const junkSenders = (senders: BlockableSender[]) => {
-		const emails = senders.map((sender) => sender.email)
-		if (!emails.length) return
-
-		junkResource.submit({ emails })
-		prependUndoAction(() => unjunkResource.submit({ emails }))
-	}
-
 	// Whether marking these senders as junk will auto-file their future mail into Junk (vs prompting
 	// to block, or doing nothing when there's nothing blockable). Lets the caller show one accurate toast.
 	const willJunkSenders = (senders: { name?: string; email?: string }[]) =>
 		blockableSenders(senders).length > 0 &&
 		activeAccount.value?.on_mark_as_junk !== 'Ask to Block Sender'
 
-	// Apply the account's 'on mark as junk' behaviour to the senders of a just-junked message:
-	// 'Ask to Block Sender' opens the prompt; otherwise silently junk their future mail.
+	// Open the block prompt for the senders of a just-junked message, in 'Ask to Block Sender' mode. The
+	// default 'Junk Sender's Mail' screening now rides on the junk API call, so it's not handled here.
 	const promptBlockSenders = (senders: { name?: string; email?: string }[]) => {
+		if (activeAccount.value?.on_mark_as_junk !== 'Ask to Block Sender') return
+
 		const list = blockableSenders(senders)
 		if (!list.length) return
 
-		if (activeAccount.value?.on_mark_as_junk === 'Ask to Block Sender') {
-			sendersToBlock.value = list
-			showBlockSender.value = true
-			return
-		}
-		junkSenders(list)
+		sendersToBlock.value = list
+		showBlockSender.value = true
 	}
 
 	return { showBlockSender, sendersToBlock, willJunkSenders, promptBlockSenders, blockSenders }
@@ -245,6 +221,8 @@ const mediaQuery = window.matchMedia('(prefers-color-scheme: dark)')
 const systemIsDark = ref(mediaQuery.matches)
 mediaQuery.addEventListener('change', () => (systemIsDark.value = mediaQuery.matches))
 
+const COLOR_SCHEME_CYCLE = ['System Default', 'Light Mode', 'Dark Mode'] as const
+
 export const useTheme = () => {
 	const { userResource } = userStore()
 
@@ -254,5 +232,26 @@ export const useTheme = () => {
 		return colorScheme === 'Dark Mode' ? 'dark' : 'light'
 	})
 
-	return { dataTheme }
+	const updateColorScheme = createResource({
+		url: 'frappe.client.set_value',
+		makeParams: (color_scheme: COLOR_SCHEME) => ({
+			doctype: 'User Settings',
+			name: userResource.data?.user_settings,
+			fieldname: { color_scheme },
+		}),
+		onSuccess: (data: { color_scheme: COLOR_SCHEME }) => {
+			raiseToast(__('Color scheme updated to {0}.', [data.color_scheme]))
+			userResource.reload()
+		},
+	})
+
+	// Cycle System Default → Light → Dark. Bound to Cmd/Ctrl+Shift+L app-wide (see App.vue).
+	const cycleTheme = () => {
+		const current = userResource.data?.color_scheme
+		const idx = COLOR_SCHEME_CYCLE.indexOf(current as COLOR_SCHEME)
+		const next = COLOR_SCHEME_CYCLE[(idx + 1) % COLOR_SCHEME_CYCLE.length]
+		updateColorScheme.submit(next)
+	}
+
+	return { dataTheme, cycleTheme }
 }
diff --git a/frontend/src/utils/index.ts b/frontend/src/utils/index.ts
index 4294472ca..09f580acc 100644
--- a/frontend/src/utils/index.ts
+++ b/frontend/src/utils/index.ts
@@ -2,7 +2,7 @@ import * as cheerio from 'cheerio'
 import { File, Paperclip } from 'lucide-vue-next'
 import { toast } from 'frappe-ui'
 
-import { FOLDER_ICON_MAP } from '@/constants'
+import { FOLDER_ICON_MAP, SCREENING_MAILBOX_NAME } from '@/constants'
 import dayjs from '@/utils/dayjs'
 import AudioIcon from '@/components/Icons/AudioIcon.vue'
 import ImageIcon from '@/components/Icons/ImageIcon.vue'
@@ -243,6 +243,69 @@ export const convertHtmlToText = (html: string) => {
 
 export const isEmail = (s: string) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(s)
 
+// An externally-hosted reference (http/https or protocol-relative //). cid: (inline attachments) and
+// data: URIs are part of the message, so they're never remote.
+const REMOTE_URL = /^\s*(?:https?:)?\/\//i
+const REMOTE_CSS_URL = /url\(\s*['"]?(?:https?:)?\/\//i
+
+// Inspect the HTML for externally-hosted assets via the DOM (one parse): counts remote <img>, and flags
+// whether any remote asset is present at all — a remote <img>, or a remote url(...) in an inline style or
+// <style> block (background images, fonts). Used to decide the "images blocked" banner and its count.
+export const analyzeRemoteAssets = (html?: string): { images: number; hasRemote: boolean } => {
+	if (!html) return { images: 0, hasRemote: false }
+
+	const doc = new DOMParser().parseFromString(html, 'text/html')
+
+	const images = Array.from(doc.querySelectorAll('img')).filter((img) =>
+		REMOTE_URL.test(img.getAttribute('src') || ''),
+	).length
+
+	const hasRemoteCss =
+		Array.from(doc.querySelectorAll('[style]')).some((el) =>
+			REMOTE_CSS_URL.test(el.getAttribute('style') || ''),
+		) ||
+		Array.from(doc.querySelectorAll('style')).some((el) =>
+			REMOTE_CSS_URL.test(el.textContent || ''),
+		)
+
+	return { images, hasRemote: images > 0 || hasRemoteCss }
+}
+
+// Blank remote url(...) in a CSS string. Regex here is unavoidable — there's no DOM API to rewrite a
+// url() inside a style string without pulling in the full CSSOM.
+const blankRemoteCssUrls = (css: string) =>
+	css.replace(/url\(\s*(['"]?)(?:https?:)?\/\/[^'")]*\1\s*\)/gi, 'url()')
+
+// Neutralize remote assets so the browser never requests them. Parses the (already-sanitized) HTML into a
+// DOM and edits it there — robust against markup/attribute quirks regex would trip on: each remote <img>
+// has its src stashed on data-blocked-src (and is tagged for hiding), and remote url(...) in inline styles
+// and <style> blocks is blanked. Inline (cid:) and data: assets are left to load as normal.
+export const blockRemoteAssets = (html: string) => {
+	const doc = new DOMParser().parseFromString(html, 'text/html')
+
+	doc.querySelectorAll('img').forEach((img) => {
+		const src = img.getAttribute('src') || ''
+		if (!REMOTE_URL.test(src)) return
+		img.setAttribute('data-blocked-src', src)
+		img.removeAttribute('src')
+		img.setAttribute('data-blocked-image', '')
+	})
+
+	doc.querySelectorAll('[style]').forEach((el) => {
+		const style = el.getAttribute('style') || ''
+		const cleaned = blankRemoteCssUrls(style)
+		if (cleaned !== style) el.setAttribute('style', cleaned)
+	})
+
+	doc.querySelectorAll('style').forEach((styleEl) => {
+		const css = styleEl.textContent || ''
+		const cleaned = blankRemoteCssUrls(css)
+		if (cleaned !== css) styleEl.textContent = cleaned
+	})
+
+	return doc.documentElement.outerHTML
+}
+
 export const getFileIcon = (type?: string) => {
 	if (!type) return Paperclip
 	if (type?.startsWith('image/')) return ImageIcon
@@ -321,9 +384,14 @@ export const hasHtmlContent = (content: string | null | undefined): boolean => {
 export const getIcon = (mailbox: MailboxData) => {
 	if (mailbox.icon) return mailbox.icon
 	if (mailbox.role && mailbox.role in FOLDER_ICON_MAP) return FOLDER_ICON_MAP[mailbox.role]
+	if (mailbox._name === SCREENING_MAILBOX_NAME) return 'eye'
 	return 'folder'
 }
 
+// The Screening folder is surfaced to users as the "Screener".
+export const getMailboxName = (mailbox: MailboxData) =>
+	mailbox._name === SCREENING_MAILBOX_NAME ? __('Screener') : mailbox._name
+
 export const downloadUrlAsFile = (url: string, filename: string) => {
 	const link = document.createElement('a')
 	link.href = url
diff --git a/frontend/src/utils/useThreadActions.ts b/frontend/src/utils/useThreadActions.ts
index c7f1a10fb..f1271fc46 100644
--- a/frontend/src/utils/useThreadActions.ts
+++ b/frontend/src/utils/useThreadActions.ts
@@ -3,11 +3,11 @@ import { Icon } from 'frappe-ui/icons'
 import { createResource, toast } from 'frappe-ui'
 
 import { FOLDER_ICON_COLOR_MAP } from '@/constants'
-import { getIcon, raisePromiseToast, raiseToast } from '@/utils'
+import { getIcon, getMailboxName, raisePromiseToast, raiseToast } from '@/utils'
 import { useBlockSender, useUndo } from '@/utils/composables'
 import { userStore } from '@/stores/user'
 
-import type { Mail, Thread } from '@/types'
+import type { Mail, MailboxData, Thread } from '@/types'
 
 export type SetSeenParams = {
 	0?: string[]
@@ -123,7 +123,7 @@ export function useThreadActions(deps: {
 		mailboxes.data
 			?.filter((m) => ![mailbox.value, mailboxIds.sent, mailboxIds.drafts].includes(m.id))
 			.map((m) => ({
-				label: m._name,
+				label: getMailboxName(m),
 				icon: h(Icon, { name: getIcon(m), class: FOLDER_ICON_COLOR_MAP[m.color] }),
 				onClick: () => handleMoveThreads({ [m.id]: selections.value }),
 			})),
@@ -151,10 +151,13 @@ export function useThreadActions(deps: {
 	type MailSnapshot = { id: string; mailbox_ids: string[]; junk: 0 | 1 }
 	const setMailsMailboxes = createResource({
 		url: 'mail.api.mail.set_mails_mailboxes',
-		makeParams: ({ mails }: { mails: MailSnapshot[] }) => ({
-			account_id: store.accountId,
+		makeParams: ({
 			mails,
-		}),
+			screen_action,
+		}: {
+			mails: MailSnapshot[]
+			screen_action?: string | null
+		}) => ({ account_id: store.accountId, mails, screen_action }),
 	})
 
 	const showAddTo = computed(
@@ -183,14 +186,16 @@ export function useThreadActions(deps: {
 				)
 			})
 			.map((m) => ({
-				label: m._name,
+				label: getMailboxName(m),
 				icon: h(Icon, { name: getIcon(m), class: FOLDER_ICON_COLOR_MAP[m.color] }),
 				onClick: () => handleAddThreadsToMailbox(m.id, selections.value),
 			})),
 	)
 
 	const handleAddThreadsToMailbox = (mailboxId: string, threadIds: string[], isUndo = false) => {
-		const mailboxName = mailboxes.data?.find((m) => m.id === mailboxId)?._name
+		const mailboxName = getMailboxName(
+			mailboxes.data?.find((m) => m.id === mailboxId) ?? ({} as MailboxData),
+		)
 		const action = async () => {
 			await addMails.submit({ ids: allMailIds(threadIds), mailbox_id: mailboxId })
 			reloadThreads()
@@ -224,7 +229,7 @@ export function useThreadActions(deps: {
 					![mailboxIds.sent, mailboxIds.drafts].includes(m.id),
 			)
 			.map((m) => ({
-				label: m._name,
+				label: getMailboxName(m),
 				icon: h(Icon, { name: getIcon(m), class: FOLDER_ICON_COLOR_MAP[m.color] }),
 				onClick: () => handleRemoveThreadsFromMailbox(m.id, selections.value),
 			}))
@@ -255,7 +260,9 @@ export function useThreadActions(deps: {
 			}
 		}
 
-		const mailboxName = mailboxes.data?.find((m) => m.id === mailboxId)?._name
+		const mailboxName = getMailboxName(
+			mailboxes.data?.find((m) => m.id === mailboxId) ?? ({} as MailboxData),
+		)
 		const success =
 			threadIdsToBeUpdated.length === 1
 				? __('Thread removed from {0}.', [mailboxName])
@@ -270,11 +277,15 @@ export function useThreadActions(deps: {
 
 	const setMailsSpam = createResource({
 		url: 'mail.api.mail.set_mails_spam_status',
-		makeParams: ({ ids, spam }: { ids: string[]; spam: boolean }) => ({
-			account_id: store.accountId,
+		makeParams: ({
 			ids,
 			spam,
-		}),
+			screen_action,
+		}: {
+			ids: string[]
+			spam: boolean
+			screen_action?: string | null
+		}) => ({ account_id: store.accountId, ids, spam, screen_action }),
 	})
 
 	const showJunkOrDeleteThreads = ref(false)
@@ -492,9 +503,9 @@ export function useThreadActions(deps: {
 			)
 		})
 
-		const moveToMailboxName = mailboxes.data?.find(
-			(m) => m.id === Object.keys(threadIDs)[0],
-		)?._name
+		const moveToMailboxName = getMailboxName(
+			mailboxes.data?.find((m) => m.id === Object.keys(threadIDs)[0]) ?? ({} as MailboxData),
+		)
 		const loading = __('Moving to {0}...', [moveToMailboxName])
 		const success =
 			selectedThreads.length === 1
@@ -520,17 +531,25 @@ export function useThreadActions(deps: {
 		}))
 		const senders = mails.map((m) => ({ name: m.from_name, email: m.from_email }))
 		const ids = snapshot.map((m) => m.id)
+
+		// Screen the senders in the SAME call as the mail change (no second request, no undo race): Junk
+		// → Spam (unless the account prompts to block instead), Not Junk → Accept. Undo flips it, also in
+		// the same call as the mailbox restore.
+		const screenForward = spam ? (willJunkSenders(senders) ? 'Spam' : null) : 'Accepted'
+
 		const action = async () => {
-			await setMailsSpam.submit({ ids, spam })
+			await setMailsSpam.submit({ ids, spam, screen_action: screenForward })
 			handleSuccessAndRemoveFromList(threadIDs)
-			// After marking as Junk, apply the account's "on mark as junk" behaviour (silently junk the
-			// sender's future mail, or prompt to block).
-			if (spam) promptBlockSenders(senders)
+			// 'Ask to Block Sender' mode: junking still prompts to fully block the sender (Reject).
+			if (spam && !screenForward) promptBlockSenders(senders)
 		}
 
 		setUndoAction(() => {
 			const undoAction = async () => {
-				await setMailsMailboxes.submit({ mails: snapshot })
+				await setMailsMailboxes.submit({
+					mails: snapshot,
+					screen_action: screenForward ? (spam ? 'Accepted' : 'Spam') : null,
+				})
 				reloadThreads()
 			}
 			// Undo flips the junk status back — name the resulting state, like the forward toast does.
@@ -540,6 +559,7 @@ export function useThreadActions(deps: {
 					: __('Threads marked as {0}.', [spam ? __('Not Junk') : __('Junk')])
 			raisePromiseToast(undoAction, __('Undoing...'), restored)
 		})
+
 		const loading = spam ? __('Marking as Junk...') : __('Marking as Not Junk...')
 		// When the account auto-junks the sender, surface that as the single toast for the whole action.
 		const success =
diff --git a/mail/api/account.py b/mail/api/account.py
index d1e932409..36c545497 100644
--- a/mail/api/account.py
+++ b/mail/api/account.py
@@ -172,7 +172,13 @@ def get_user_info() -> dict | None:
 		for s in frappe.get_all(
 			"Account Settings",
 			filters={"name": ["in", account_ids]},
-			fields=["name", "default_outgoing_email", "on_mark_as_junk"],
+			fields=[
+				"name",
+				"default_outgoing_email",
+				"on_mark_as_junk",
+				"enable_screening",
+				"block_remote_images",
+			],
 		)
 	}
 	for acc in data.accounts:
@@ -180,6 +186,8 @@ def get_user_info() -> dict | None:
 		acc["account_settings"] = settings["name"] if settings else None
 		acc["default_outgoing_email"] = settings["default_outgoing_email"] if settings else None
 		acc["on_mark_as_junk"] = settings["on_mark_as_junk"] if settings else "Junk Sender's Mail"
+		acc["enable_screening"] = bool(settings["enable_screening"]) if settings else False
+		acc["block_remote_images"] = bool(settings["block_remote_images"]) if settings else True
 
 	data.user_image = data.user_image or get_avatar_url(user)
 
diff --git a/mail/api/mail.py b/mail/api/mail.py
index 1dcbcf57b..e54639d3d 100644
--- a/mail/api/mail.py
+++ b/mail/api/mail.py
@@ -13,13 +13,11 @@
 
 from mail.api.contacts import create_contacts_if_not_exists
 from mail.api.sieve import (
-	update_sieve_script_for_blocked_emails,
-	update_sieve_script_for_junk_senders,
-	update_sieve_script_for_mailbox,
+	SCREENING_MAILBOX_NAME,
+	build_automation_sieve,
+	pause_automation_sieve_build,
 )
 from mail.api.utils import get_avatar_url
-from mail.client.doctype.blocked_email_address.blocked_email_address import get_blocked_email_addresses
-from mail.client.doctype.junk_email_address.junk_email_address import get_junk_email_addresses
 from mail.client.doctype.mail_message.mail_message import (
 	add_messages_to_mailbox,
 	delete_messages,
@@ -28,6 +26,7 @@
 	fetch_blobs,
 	fetch_thread,
 	fetch_threads,
+	get_messages,
 	move_messages_to_mailbox,
 	remove_messages_from_mailbox,
 	search_messages,
@@ -38,13 +37,25 @@
 )
 from mail.client.doctype.mail_queue.mail_queue import MailQueue
 from mail.client.doctype.mailbox.mailbox import add_mailbox, delete_mailboxes
-from mail.client.doctype.mailbox_settings.mailbox_settings import set_mailbox_settings
-from mail.jmap import get_email_service, get_mailbox_id_by_role, parse_account
-from mail.utils import convert_html_to_text, get_mail_config
+from mail.client.doctype.mailbox_settings.mailbox_settings import (
+	automation_rules_to_settings,
+	set_mailbox_settings,
+)
+from mail.client.doctype.screened_email_address.screened_email_address import (
+	get_screened_email_addresses,
+)
+from mail.jmap import (
+	get_email_service,
+	get_mailbox_id_by_name,
+	get_mailbox_id_by_role,
+	parse_account,
+)
+from mail.utils import convert_html_to_text, get_mail_config, log_error
 from mail.utils.user import get_account_emails, get_session_account, is_jmap_configured
 from mail.utils.validation import has_permission_for_user
 
 AVATAR_CACHE_TTL = 60 * 60 * 24
+SCREENING_FETCH_LIMIT = 500
 
 
 @frappe.whitelist()
@@ -69,7 +80,17 @@ def get_mailboxes(account_id: str) -> list[dict]:
 			"account_id": parse_account(account)[1],
 			"mailbox_id": ["in", [m["id"] for m in mailboxes]],
 		},
-		fields=["mailbox_id", "icon", "color", "disable_push_notification"],
+		fields=[
+			"mailbox_id",
+			"icon",
+			"color",
+			"disable_push_notification",
+			"emails_from",
+			"subject_contains",
+			"match_if",
+			"mark_as_read",
+			"add_star",
+		],
 	)
 
 	settings_map = {
@@ -77,6 +98,19 @@ def get_mailboxes(account_id: str) -> list[dict]:
 			"icon": s.icon,
 			"color": s.color,
 			"disable_push_notification": s.disable_push_notification,
+			# The automation rules backup, surfaced so the UI reads it instead of parsing the sieve.
+			# None when the mailbox has no automation, so the UI shows defaults.
+			"automation_rules": (
+				{
+					"emails_from": s.emails_from or "",
+					"subject_contains": s.subject_contains or "",
+					"match_if": s.match_if or "any",
+					"mark_as_read": bool(s.mark_as_read),
+					"add_star": bool(s.add_star),
+				}
+				if (s.emails_from or s.subject_contains)
+				else None
+			),
 		}
 		for s in mailbox_settings
 	}
@@ -444,6 +478,7 @@ def create_mail(
 
 	if not save_as_draft and doc.status == "Submitted":
 		create_contacts_if_not_exists(account, doc.recipients)
+		auto_accept_recipients(account, doc.recipients)
 
 	return {"id": doc.id, "status": doc.status, "error": doc.error_message, "thread_id": doc.thread_id}
 
@@ -519,6 +554,7 @@ def update_draft_mail(
 
 	if submit and new_doc.status == "Submitted":
 		create_contacts_if_not_exists(account, doc.recipients)
+		auto_accept_recipients(account, doc.recipients)
 
 	return {
 		"id": new_doc.id,
@@ -630,22 +666,40 @@ def remove_mails_from_mailbox(account_id: str, ids: list[str], mailbox_id: str)
 	remove_messages_from_mailbox(account, ids, mailbox_id)
 
 
+def _screen_senders(account: str, ids: list[str], action: str | None) -> None:
+	"""Screen the senders of the given mails with `action` (Spam/Accepted/Reject), in the same request as
+	the mail change — so marking junk/not-junk (and undoing it) updates the sender's rule atomically."""
+
+	if not action:
+		return
+
+	from_emails = [m["from_email"] for m in get_messages(account, ids) if m.get("from_email")]
+	if from_emails:
+		_screen_email_addresses(account, from_emails, action=action)
+
+
 @frappe.whitelist()
-def set_mails_mailboxes(account_id: str, mails: list[dict]) -> None:
-	"""Restores each mail's exact mailbox membership and junk status (used to undo a move)."""
+def set_mails_mailboxes(account_id: str, mails: list[dict], screen_action: str | None = None) -> None:
+	"""Restores each mail's exact mailbox membership and junk status (used to undo a move), optionally
+	re-screening the senders with `screen_action` to reverse a junk/not-junk's screening on undo."""
 
 	account = get_session_account(account_id)
 
 	set_messages_mailboxes(account, mails)
+	_screen_senders(account, [m["id"] for m in mails], screen_action)
 
 
 @frappe.whitelist()
-def set_mails_spam_status(account_id: str, ids: list[str], spam: bool) -> list[str]:
-	"""Sets spam status of the given mails."""
+def set_mails_spam_status(
+	account_id: str, ids: list[str], spam: bool, screen_action: str | None = None
+) -> list[str]:
+	"""Sets spam status of the given mails, optionally screening their senders with `screen_action`
+	(Spam on Junk, Accepted on Not Junk) in the same call."""
 
 	account = get_session_account(account_id)
 
 	set_spam_status(account, ids, spam)
+	_screen_senders(account, ids, screen_action)
 
 	return ids
 
@@ -784,17 +838,20 @@ def create_mailbox(
 
 	account = get_session_account(account_id)
 
-	mailbox_id = add_mailbox(account, name, None, parent)
-
-	set_mailbox_settings(
-		account,
-		mailbox_id,
-		icon=icon,
-		color=color,
-		disable_push_notification=disable_push_notification,
-	)
+	# Create the mailbox and persist its automation rules to Mailbox Settings (the backup the sieve is
+	# generated from) without firing a per-write rebuild, then build the script once from the backups.
+	with pause_automation_sieve_build():
+		mailbox_id = add_mailbox(account, name, None, parent)
+		set_mailbox_settings(
+			account,
+			mailbox_id,
+			icon=icon,
+			color=color,
+			disable_push_notification=disable_push_notification,
+			**automation_rules_to_settings(automation_rules),
+		)
 
-	update_sieve_script_for_mailbox(account, name, automation_rules)
+	build_automation_sieve(account)
 
 
 @frappe.whitelist()
@@ -814,18 +871,23 @@ def update_mailbox(
 
 	account = get_session_account(account_id)
 
-	set_mailbox_settings(
-		account,
-		id,
-		_name=name,
-		role=role,
-		parent=parent,
-		icon=icon,
-		color=color,
-		disable_push_notification=disable_push_notification,
-	)
+	# Persist the automation rules and any rename/move to Mailbox Settings (the backup the sieve is
+	# generated from) without firing a per-write rebuild, then build the script once — after the rename
+	# lands — so the regenerated folder paths are correct.
+	with pause_automation_sieve_build():
+		set_mailbox_settings(
+			account,
+			id,
+			_name=name,
+			role=role,
+			parent=parent,
+			icon=icon,
+			color=color,
+			disable_push_notification=disable_push_notification,
+			**automation_rules_to_settings(automation_rules),
+		)
 
-	update_sieve_script_for_mailbox(account, name, automation_rules, old_name)
+	build_automation_sieve(account)
 
 
 @frappe.whitelist()
@@ -835,153 +897,301 @@ def delete_mailbox(account_id: str, id: str, name: str) -> None:
 	account = get_session_account(account_id)
 
 	delete_mailboxes(account, [id])
-	update_sieve_script_for_mailbox(account, name)
 	frappe.db.delete("Mailbox Settings", {"account_id": parse_account(account)[1], "mailbox_id": id})
+	build_automation_sieve(account)
 
 
 @frappe.whitelist()
-def get_blocked_addresses(account_id: str) -> list[dict]:
-	"""Returns the list of blocked email addresses for the given account."""
+def get_screened_addresses(account_id: str) -> list[dict]:
+	"""Returns the screened email addresses (each with its `action`) for the given account."""
 
 	account = get_session_account(account_id)
 
 	has_permission_for_user(parse_account(account)[0])
-	return get_blocked_email_addresses(account)
+	return get_screened_email_addresses(account)
 
 
 @frappe.whitelist()
-def block_email_address(account_id: str, email: str) -> dict:
-	"""Blocks an email address for the given account."""
+def screen_email_address(account_id: str, email: str, action: str = "Reject") -> None:
+	"""Screens a single email address for the given account with the given action.
 
-	account = get_session_account(account_id)
+	`action` is Reject, Spam, or Accepted. Used by explicit user actions, so it overrides any
+	existing rule for the sender.
+	"""
 
-	has_permission_for_user(parse_account(account)[0])
-	doc = frappe.get_doc(
-		{"doctype": "Blocked Email Address", "account_id": parse_account(account)[1], "email": email}
-	)
-	# Pass the full handle so after_insert can reach JMAP to regenerate the sieve block.
-	doc.flags.account = account
-	doc.insert()
+	_screen_email_addresses(get_session_account(account_id), [email], action)
 
 
 @frappe.whitelist()
-def block_email_addresses(account_id: str, emails: list[str]) -> None:
-	"""Blocks multiple email addresses for the given account in a single request.
+def screen_email_addresses(
+	account_id: str, emails: list[str], action: str = "Reject", override: bool = True
+) -> None:
+	"""Screens multiple email addresses for the given account in a single request.
 
-	Inserts in one batched query via `bulk_insert` (no per-document hooks) instead of looping over
-	`doc.insert()`. Addresses already blocked are skipped, `ignore_duplicates` guards against races,
-	and the sieve script is regenerated once at the end since it is rebuilt from the full list.
+	`action` is Reject (discard incoming mail silently), Spam (file into Junk), or Accepted (let it
+	reach the inbox; used by screening). New addresses are inserted in one batched query via
+	`bulk_insert` (no per-document hooks); the sieve script is regenerated once at the end.
+
+	A sender has at most one screening rule (uniqueness is on the address). `override` controls what
+	happens when a rule already exists: explicit user actions (default `True`) overwrite it, while
+	automated flows like auto-junk pass `override=False` so they never clobber a manual decision.
 	"""
 
-	account = get_session_account(account_id)
+	_screen_email_addresses(get_session_account(account_id), emails, action, override)
+
+
+def _screen_email_addresses(
+	account: str, emails: list[str], action: str = "Reject", override: bool = True
+) -> None:
+	"""Core screening logic on the resolved account handle. Also called internally (the mark-as-junk
+	flow and auto-accept already hold the handle), so it isn't whitelisted."""
+
+	if action not in ("Spam", "Reject", "Accepted"):
+		frappe.throw(_("Invalid screening action: {0}").format(action))
 
 	user, account_id = parse_account(account)
 	has_permission_for_user(user)
 
-	already_blocked = set(get_blocked_email_addresses(account))
+	emails = [email for email in dict.fromkeys(emails) if email]  # de-duplicate, drop empties
+	if not emails:
+		return
+
+	existing = {
+		row.email: row
+		for row in frappe.db.get_all(
+			"Screened Email Address",
+			filters={"account_id": account_id, "email": ["in", emails]},
+			fields=["name", "email", "action"],
+		)
+	}
+
 	docs = []
-	for email in dict.fromkeys(emails):  # de-duplicate while preserving order
-		if not email or email in already_blocked:
+	changed = False
+	for email in emails:
+		row = existing.get(email)
+		if row:
+			if override and row.action != action:
+				frappe.db.set_value(
+					"Screened Email Address", row.name, "action", action, update_modified=False
+				)
+				changed = True
 			continue
+		# bulk_insert bypasses before_insert, so set the shared account_id (the key) explicitly.
 		doc = frappe.get_doc(
 			{
-				"doctype": "Blocked Email Address",
+				"doctype": "Screened Email Address",
 				"account_id": account_id,
 				"email": email,
+				"action": action,
 			}
 		)
 		doc.set_new_name()
 		docs.append(doc)
 
 	if docs:
-		bulk_insert("Blocked Email Address", docs, ignore_duplicates=True)
-		update_sieve_script_for_blocked_emails(account)
+		bulk_insert("Screened Email Address", docs, ignore_duplicates=True)
+		changed = True
 
-	# A hard block supersedes a soft junk rule for the same sender — drop any junk entries so the two
-	# sieve blocks can't both target one address.
-	remove_junk_senders(account, [doc.email for doc in docs])
+	if changed:
+		build_automation_sieve(account)
 
 
-@frappe.whitelist()
-def junk_senders(account_id: str, emails: list[str]) -> None:
-	"""Routes future mail from the given senders into Junk for the account, in a single request.
+def auto_accept_recipients(account: str, recipients: list) -> None:
+	"""When screening is enabled, allowlist the people you email so their replies reach the inbox.
 
-	The soft counterpart to `block_email_addresses`: instead of discarding, the generated sieve block
-	files matching mail into the Junk folder. Already-junked addresses are skipped and the sieve
-	script is regenerated once at the end.
+	Non-overriding, so it never un-rejects a sender you deliberately blocked. Failures are logged and
+	swallowed — auto-accept must never block sending.
 	"""
 
-	account = get_session_account(account_id)
-
-	user, account_id = parse_account(account)
-	has_permission_for_user(user)
+	from mail.api.sieve import is_screening_enabled
 
-	already_junked = set(get_junk_email_addresses(account))
-	docs = []
-	for email in dict.fromkeys(emails):  # de-duplicate while preserving order
-		if not email or email in already_junked:
-			continue
-		doc = frappe.get_doc({"doctype": "Junk Email Address", "account_id": account_id, "email": email})
-		doc.set_new_name()
-		docs.append(doc)
+	try:
+		if not is_screening_enabled(account):
+			return
 
-	if docs:
-		bulk_insert("Junk Email Address", docs, ignore_duplicates=True)
-		update_sieve_script_for_junk_senders(account)
+		emails = list({r.email for r in recipients if getattr(r, "email", None)})
+		if emails:
+			_screen_email_addresses(account, emails, action="Accepted", override=False)
+	except Exception:
+		log_error(
+			_("Screening Auto-Accept Error"),
+			_("Failed to auto-accept recipients for account {0}").format(account),
+		)
 
 
 @frappe.whitelist()
-def unjunk_senders(account_id: str, emails: list[str]) -> None:
-	"""Removes senders from the account's junk list (e.g. when a junk action is undone)."""
+def unscreen_email_addresses(account_id: str, emails: list[str]) -> None:
+	"""Removes screening rules by deleting Screened Email Address records and regenerating the sieve.
+
+	Scoped to the shared account_id (not the per-user handle), so a rule added by any user on a
+	shared account can be removed. `frappe.db.delete` bypasses the doctype's `after_delete` hook, so
+	the screening sieve blocks are rebuilt explicitly here.
+	"""
 
 	account = get_session_account(account_id)
 
 	has_permission_for_user(parse_account(account)[0])
-	remove_junk_senders(account, emails)
-
-
-def remove_junk_senders(account: str, emails: list[str]) -> None:
-	"""Deletes Junk Email Address records and regenerates the junk sieve block."""
 
 	if not emails:
 		return
 
 	account_id = parse_account(account)[1]
 	deleted = frappe.db.get_all(
-		"Junk Email Address", filters={"account_id": account_id, "email": ["in", emails]}, pluck="name"
+		"Screened Email Address",
+		filters={"account_id": account_id, "email": ["in", emails]},
+		pluck="name",
 	)
 	if not deleted:
 		return
 
-	frappe.db.delete("Junk Email Address", {"name": ["in", deleted]})
-	update_sieve_script_for_junk_senders(account)
+	frappe.db.delete("Screened Email Address", {"name": ["in", deleted]})
+	build_automation_sieve(account)
+
+
+# --- Screener (the screening folder view) ---------------------------------------------------------
+
+
+def _screening_message_ids(account: str, from_email: str | None = None) -> list[str]:
+	"""Return ids of Screening-folder messages, optionally only those from a given sender."""
+
+	screening_id = get_mailbox_id_by_name(*parse_account(account), SCREENING_MAILBOX_NAME)
+	if not screening_id:
+		add_mailbox(account, SCREENING_MAILBOX_NAME)
+		return []
+
+	conditions = [{"inMailbox": screening_id}]
+	if from_email:
+		conditions.append({"from": from_email})
+	filter = conditions[0] if len(conditions) == 1 else {"operator": "AND", "conditions": conditions}
+
+	service = get_email_service(*parse_account(account))
+
+	return service.query(filter, limit=service.max_objects_in_get).get("ids", [])
 
 
 @frappe.whitelist()
-def unblock_email_addresses(account_id: str, emails: list[str]) -> None:
-	"""Unblocks email addresses by deleting Blocked Email Address records and regenerating the sieve.
+def get_screening_senders(account_id: str) -> list[dict]:
+	"""Return one row per unique sender in the Screening folder, newest sender first.
 
-	Scoped to the shared account_id (not the per-user handle), so a block added by any user on a
-	shared account can be removed. `frappe.db.delete` bypasses the doctype's `after_delete` hook, so
-	the blocked-emails sieve block is rebuilt explicitly here (mirrors `remove_junk_senders`).
+	The Screener groups by sender rather than by conversation: each row is the latest mail from that
+	sender, with a count of how many of their messages are waiting and how many are unread.
 	"""
 
 	account = get_session_account(account_id)
 
 	has_permission_for_user(parse_account(account)[0])
 
-	if not emails:
-		return
+	screening_id = get_mailbox_id_by_name(*parse_account(account), SCREENING_MAILBOX_NAME)
+	if not screening_id:
+		add_mailbox(account, SCREENING_MAILBOX_NAME)
+		return []
 
-	account_id = parse_account(account)[1]
-	deleted = frappe.db.get_all(
-		"Blocked Email Address", filters={"account_id": account_id, "email": ["in", emails]}, pluck="name"
+	messages, _total = search_messages(
+		account,
+		{"inMailbox": screening_id},
+		position=0,
+		limit=SCREENING_FETCH_LIMIT,
+		sort=[{"property": "receivedAt", "isAscending": False}],
 	)
-	if not deleted:
+
+	senders: dict[str, dict] = {}
+	for message in messages:  # newest first
+		email = (message.get("from_email") or "").lower()
+		if not email:
+			continue
+
+		sender = senders.get(email)
+		if not sender:
+			# The first (newest) message for this sender becomes the summary row.
+			senders[email] = {
+				"from_email": message["from_email"],
+				"from_name": message["from_name"],
+				"subject": message["subject"],
+				"preview": message["preview"],
+				"received_at": message["received_at"],
+				"count": 1,
+				"unread": 0 if message["seen"] else 1,
+			}
+		else:
+			sender["count"] += 1
+			if not message["seen"]:
+				sender["unread"] += 1
+
+	return list(senders.values())
+
+
+@frappe.whitelist()
+def get_screening_sender_mails(account_id: str, from_email: str) -> list[dict]:
+	"""Return all Screening-folder messages from a single sender, oldest to newest (with bodies)."""
+
+	account = get_session_account(account_id)
+
+	has_permission_for_user(parse_account(account)[0])
+
+	ids = _screening_message_ids(account, from_email)
+	if not ids:
+		return []
+
+	# The JMAP `from` filter is a tokenized text match, so it can also return other senders whose From
+	# header shares tokens. Keep only exact-address matches (mirrors how get_screening_senders groups).
+	target = from_email.lower()
+	mails = [serialize_mail(m) for m in get_messages(account, ids)]
+	mails = [m for m in mails if (m.get("from_email") or "").lower() == target]
+	mails.sort(key=lambda m: m["received_at"])
+	return add_user_images_to_emails(account, mails, is_thread=True)
+
+
+@frappe.whitelist()
+def allow_screening_senders(account_id: str, from_emails: list[str]) -> None:
+	"""Allow senders in: accept them (future mail reaches the inbox) and move their screened mail there."""
+
+	account = get_session_account(account_id)
+
+	has_permission_for_user(parse_account(account)[0])
+	if not from_emails:
+		return
+
+	_screen_email_addresses(account, from_emails, action="Accepted")
+
+	inbox_id = get_mailbox_id_by_role(*parse_account(account), "inbox", raise_exception=True)
+	for from_email in from_emails:
+		ids = _screening_message_ids(account, from_email)
+		if ids:
+			move_mails(account_id, ids, inbox_id, clear_junk=True)
+
+
+@frappe.whitelist()
+def move_screening_mails_to_inbox(account_id: str) -> None:
+	"""Move every Screening-folder message to the Inbox (offered when screening is turned off)."""
+
+	account = get_session_account(account_id)
+
+	has_permission_for_user(parse_account(account)[0])
+
+	ids = _screening_message_ids(account)
+	if not ids:
+		return
+
+	inbox_id = get_mailbox_id_by_role(*parse_account(account), "inbox", raise_exception=True)
+	move_mails(account_id, ids, inbox_id, clear_junk=True)
+
+
+@frappe.whitelist()
+def screen_out_senders(account_id: str, from_emails: list[str]) -> None:
+	"""Screen senders out: mark them Spam (future mail to Junk) and move their screened mail to Junk."""
+
+	account = get_session_account(account_id)
+
+	has_permission_for_user(parse_account(account)[0])
+	if not from_emails:
 		return
 
-	frappe.db.delete("Blocked Email Address", {"name": ["in", deleted]})
-	update_sieve_script_for_blocked_emails(account)
+	_screen_email_addresses(account, from_emails, action="Spam")
+
+	for from_email in from_emails:
+		ids = _screening_message_ids(account, from_email)
+		if ids:
+			set_mails_spam_status(account_id, ids, spam=True)
 
 
 @frappe.whitelist(allow_guest=True, methods=["POST"])
diff --git a/mail/api/sieve.py b/mail/api/sieve.py
index 6af8eba23..bfa850e91 100644
--- a/mail/api/sieve.py
+++ b/mail/api/sieve.py
@@ -1,10 +1,13 @@
 import re
+from contextlib import contextmanager
 
 import frappe
 from frappe import _
 
-from mail.client.doctype.blocked_email_address.blocked_email_address import get_blocked_email_addresses
-from mail.client.doctype.junk_email_address.junk_email_address import get_junk_email_addresses
+from mail.client.doctype.mailbox_settings.mailbox_settings import get_mailbox_automation_rules
+from mail.client.doctype.screened_email_address.screened_email_address import (
+	get_screened_email_addresses,
+)
 from mail.client.doctype.sieve_script.sieve_script import SieveScript
 from mail.jmap import (
 	get_mailbox_id_by_name,
@@ -13,8 +16,9 @@
 	get_mailboxes,
 	parse_account,
 )
-from mail.utils.user import get_session_account
+from mail.utils.user import get_account_emails, get_session_account
 
+SCREENING_MAILBOX_NAME = "Screener"
 AUTOMATION_SCRIPT_NAME = "frappe_mail_automation"
 AUTOMATION_SCRIPT_REQUIRE = 'require ["fileinto", "imap4flags"];'
 
@@ -134,30 +138,33 @@ def remove_sieve_block(sieve_script: str, block_name: str) -> str:
 
 
 @frappe.whitelist()
-def create_automation_script(account_id: str, active: bool = False) -> str:
-	"""Create the frappe_mail_automation sieve script for the account."""
+def create_automation_script(account_id: str, active: bool = False) -> None:
+	"""Create (and optionally activate) the frappe_mail_automation sieve script for the account.
 
-	account = get_session_account(account_id)
+	Backs the "Enable Folder Automation" action. Delegates to `build_automation_sieve`, which creates
+	the script if it doesn't exist and regenerates all four sections from their persistent backups
+	(Mailbox Settings + Screened Email Address).
+	"""
 
-	frappe.flags.allow_automation_script_creation = True
-	return SieveScript._add_sieve_script(
-		account=account,
-		name=AUTOMATION_SCRIPT_NAME,
-		content=AUTOMATION_SCRIPT_REQUIRE,
-		active=active,
-	)
+	build_automation_sieve(get_session_account(account_id), activate=active)
 
 
 def get_automation_script_name(account: str) -> str:
-	"""Returns the name of the frappe_mail_automation sieve script for the account, creating it if it doesn't exist."""
+	"""Return the name of the frappe_mail_automation sieve script, creating an empty one if missing.
+
+	Only ensures the script exists (with a bare `require` statement); regenerating the automation
+	blocks is `build_automation_sieve`'s job. Keeping creation free of any rebuild avoids re-entrancy,
+	since the rebuild itself calls this to resolve the script it writes to.
+	"""
 
 	scripts = SieveScript._fetch_sieve_scripts(account, filter={"name": AUTOMATION_SCRIPT_NAME})
 	if scripts and scripts[0]:
 		return scripts[0][0]["name"]
 
-	script_name = create_automation_script(account)
+	frappe.flags.allow_automation_script_creation = True
+	script_id = SieveScript._add_sieve_script(account, AUTOMATION_SCRIPT_NAME, AUTOMATION_SCRIPT_REQUIRE)
 
-	return f"{account}|{script_name}"
+	return f"{account}|{script_id}"
 
 
 def append_sieve_block(script: str, block_name: str, sieve_block: str) -> str:
@@ -166,6 +173,56 @@ def append_sieve_block(script: str, block_name: str, sieve_block: str) -> str:
 	return script.rstrip() + "\n" + f"\n# {block_name}{sieve_block}"
 
 
+def backfill_mailbox_automation_rules() -> None:
+	"""Backfill the Mailbox Settings automation backup from existing frappe_mail_automation scripts.
+
+	Before the Mailbox Settings automation fields existed, folder rules lived only in the sieve script.
+	Run as a background job (JMAP isn't reachable during `bench migrate`) so existing rules are captured
+	into Mailbox Settings before a rebuild — which regenerates the script *from* Mailbox Settings —
+	could drop them. Idempotent: re-running just rewrites the same backup.
+	"""
+
+	from mail.client.doctype.mailbox_settings.mailbox_settings import (
+		automation_rules_to_settings,
+		set_mailbox_settings,
+	)
+	from mail.jmap import get_jmap_connection
+
+	for user in frappe.get_all("User Settings", filters={"username": ["is", "set"]}, pluck="user"):
+		try:
+			account_ids = list(get_jmap_connection(user, ignore_permissions=True).accounts.keys())
+		except Exception:
+			continue
+
+		for account_id in account_ids:
+			account = f"{user}:{account_id}"
+			try:
+				scripts = SieveScript._fetch_sieve_scripts(
+					account, filter={"name": AUTOMATION_SCRIPT_NAME}
+				)
+				if not (scripts and scripts[0]):
+					continue
+
+				script = SieveScript._get_sieve_scripts(account, [scripts[0][0]["id"]], True)
+				content = script[0]["content"] if script else ""
+			except Exception:
+				continue
+
+			for mailbox in get_mailboxes(*parse_account(account)):
+				rules = extract_rules_from_script(content, mailbox["_name"])
+				if not rules or not (rules["emails_from"] or rules["subject_contains"]):
+					continue
+
+				try:
+					set_mailbox_settings(
+						account, mailbox["id"], **automation_rules_to_settings(rules)
+					)
+				except Exception:
+					continue
+
+	frappe.db.commit()
+
+
 def extract_rules_from_script(content: str, mailbox_name: str) -> dict | None:
 	"""Parse and return the automation rules for a mailbox from a Sieve script."""
 
@@ -213,14 +270,6 @@ def extract_rules_from_script(content: str, mailbox_name: str) -> dict | None:
 	return rules
 
 
-def get_child_mailbox_names(account: str, parent_name: str) -> list[str]:
-	"""Return the names of all direct child mailboxes for the given parent."""
-
-	parent_id = get_mailbox_id_by_name(*parse_account(account), parent_name)
-	mailboxes = get_mailboxes(*parse_account(account))
-	return [mailbox["_name"] for mailbox in mailboxes if mailbox.get("parent_id") == parent_id]
-
-
 def get_mailbox_folder_path(account: str, name: str, raise_exception: bool = False) -> str | None:
 	"""Return the full slash-separated folder path for a mailbox."""
 
@@ -249,82 +298,90 @@ def get_mailbox_folder_path(account: str, name: str, raise_exception: bool = Fal
 	return "/".join(reversed(path_parts))
 
 
-def update_sieve_script_for_mailbox(
-	account: str, name: str, automation_rules: dict | None = None, old_name: str | None = None
-) -> None:
-	"""Update the automation Sieve script for a mailbox and its direct children."""
+@contextmanager
+def pause_automation_sieve_build():
+	"""Suppress the automatic `build_automation_sieve` triggered by Mailbox Settings / Screened Email
+	Address document hooks, so a caller doing several writes rebuilds the script once at the end
+	instead of after every write.
 
-	automation_script_name = get_automation_script_name(account)
-	doc = frappe.get_doc("Sieve Script", automation_script_name)
+	Use it around bulk writes, then call `build_automation_sieve` yourself once::
 
-	for child_name in set(get_child_mailbox_names(account, name)):
-		child_block_name = f"Mailbox: {child_name}"
-		child_rules = extract_rules_from_script(doc.content, child_name)
-		doc.content = remove_sieve_block(doc.content, child_block_name)
+	    with pause_automation_sieve_build():
+	            ...several saves...
+	    build_automation_sieve(account)
+	"""
 
-		if child_rules:
-			child_folder_path = get_mailbox_folder_path(account, child_name, raise_exception=True)
-			doc.content = append_sieve_block(
-				doc.content, child_block_name, rule_object_to_sieve(child_rules, child_folder_path)
-			)
+	previous = frappe.flags.get("skip_automation_sieve_build")
+	frappe.flags.skip_automation_sieve_build = True
+	try:
+		yield
+	finally:
+		frappe.flags.skip_automation_sieve_build = previous
 
-	doc.content = remove_sieve_block(doc.content, f"Mailbox: {old_name or name}")
 
-	if automation_rules:
-		folder_path = get_mailbox_folder_path(account, name, raise_exception=True)
-		doc.content = append_sieve_block(
-			doc.content, f"Mailbox: {name}", rule_object_to_sieve(automation_rules, folder_path)
-		)
+def maybe_build_automation_sieve(account: str) -> None:
+	"""Build the automation sieve from a document hook unless a caller paused builds for a bulk write."""
+
+	if frappe.flags.get("skip_automation_sieve_build"):
+		return
+
+	build_automation_sieve(account)
+
+
+def build_automation_sieve(account: str, activate: bool = False) -> None:
+	"""Build the entire frappe_mail_automation sieve script from its sources of truth.
+
+	This is the single entry point for (re)generating the automation script. It:
+	  1. Ensures the frappe_mail_automation script exists, creating an empty one if a third-party
+	     client deleted it.
+	  2. Regenerates all four managed sections, in precedence order — Reject → Mailbox → Spam →
+	     Screening — from their persistent backups: the per-mailbox rules in Mailbox Settings (Mailbox
+	     section) and the Reject/Spam/Screening rules in Screened Email Address plus Account Settings.
+	  3. Activates the script when `activate` is set (the "Enable Folder Automation" action); otherwise
+	     its current active state is preserved.
 
+	Building from the backups rather than mutating the existing script makes it idempotent and recovers
+	the script after a third-party client deletes or mangles it.
+	"""
+
+	doc = frappe.get_doc("Sieve Script", get_automation_script_name(account))
+	doc.content = _build_automation_content(account)
+	if activate:
+		doc.active = True
 	doc.save()
 
 
-def update_sieve_script_for_blocked_emails(account: str) -> None:
-	"""Update sieve script to block emails from blocked email list at the top."""
+def _build_automation_content(account: str) -> str:
+	"""Generate the full frappe_mail_automation script content from the persistent backups."""
 
-	automation_script_name = get_automation_script_name(account)
-	doc = frappe.get_doc("Sieve Script", automation_script_name)
-	content = (doc.content or "").lstrip()
+	content = AUTOMATION_SCRIPT_REQUIRE + "\n"
 
-	block_name = "Blocked Emails"
-	content = remove_sieve_block(content, block_name)
+	# Mailbox section: one block per mailbox that has automation rules in Mailbox Settings.
+	for mailbox in get_mailboxes(*parse_account(account)):
+		rules = get_mailbox_automation_rules(account, mailbox["id"])
+		if not rules:
+			continue
 
-	blocked_emails = get_blocked_email_addresses(account)
-	conditions = [f'address :is "from" "{e.strip()}"' for e in blocked_emails if e.strip()]
+		folder_path = get_mailbox_folder_path(account, mailbox["_name"], raise_exception=True)
+		block = rule_object_to_sieve(rules, folder_path)
+		if block:
+			content = append_sieve_block(content, f"Mailbox: {mailbox['_name']}", block)
 
-	if not conditions:
-		doc.content = content.rstrip() + "\n"
-		doc.save()
-		return
+	# Reject / Spam / Screening sections, layered on top of the mailbox rules.
+	content = _apply_screening_blocks(account, content)
 
-	if len(conditions) == 1:
-		condition_block = f"if {conditions[0]} {{"
-	else:
-		joined = ",\n  ".join(conditions)
-		condition_block = f"if anyof (\n  {joined}\n) {{"
+	return content.rstrip() + "\n"
 
-	block_script = "\n".join(
-		[
-			f"# {block_name}",
-			condition_block,
-			"  discard;",
-			"  stop;",
-			"}",
-			"\n",
-		]
-	)
 
-	require_pattern = r"^(require\s+\[.*?\];\s*)+"
-	match = re.match(require_pattern, content, flags=re.DOTALL)
+@frappe.whitelist()
+def rebuild_automation_script_for_account(account_id: str) -> None:
+	"""Rebuild the frappe_mail_automation script from its backups for the session account.
 
-	if match:
-		insert_pos = match.end()
-		content = content[:insert_pos] + "\n" + block_script + content[insert_pos:]
-	else:
-		content = block_script + content
+	Backs the manual "Rebuild Automation" action, for when the script was deleted or edited by a
+	third-party client.
+	"""
 
-	doc.content = content.rstrip() + "\n"
-	doc.save()
+	build_automation_sieve(get_session_account(account_id))
 
 
 def get_junk_folder_path(account: str) -> str:
@@ -337,56 +394,143 @@ def get_junk_folder_path(account: str) -> str:
 	return get_mailbox_folder_path(account, junk_name, raise_exception=True)
 
 
-def update_sieve_script_for_junk_senders(account: str) -> None:
-	"""Update sieve script to file emails from the junk-sender list into the Junk folder.
+def get_screening_folder_path(account: str) -> str:
+	"""Return the folder path of the account's Screening mailbox, creating it if missing.
 
-	Mirrors `update_sieve_script_for_blocked_emails` but files into Junk instead of discarding. A
-	sender is never in both lists at once (blocking removes the junk entry), so block/junk blocks
-	cannot both fire for the same sender.
+	Screening is not a standard JMAP role, so it is a plain named mailbox looked up by name.
 	"""
 
-	automation_script_name = get_automation_script_name(account)
-	doc = frappe.get_doc("Sieve Script", automation_script_name)
-	content = (doc.content or "").lstrip()
+	from mail.client.doctype.mailbox.mailbox import add_mailbox
+	from mail.jmap.services.core import CoreService
 
-	block_name = "Junk Senders"
-	content = remove_sieve_block(content, block_name)
+	user, account_id = parse_account(account)
 
-	junk_emails = get_junk_email_addresses(account)
-	conditions = [f'address :is "from" "{e.strip()}"' for e in junk_emails if e.strip()]
+	# The mailbox list lives in a per-process TTL cache, so a negative lookup can be stale — another
+	# worker may already have created the Screener. Refresh from the server before deciding to create,
+	# so we never try to recreate an existing mailbox (which JMAP rejects with "already exists").
+	CoreService.invalidate_cache(account_id, key="mailboxes")
+	if not get_mailbox_id_by_name(user, account_id, SCREENING_MAILBOX_NAME):
+		add_mailbox(account, SCREENING_MAILBOX_NAME)
+		CoreService.invalidate_cache(account_id, key="mailboxes")
 
-	if not conditions:
-		doc.content = content.rstrip() + "\n"
-		doc.save()
-		return
+	return get_mailbox_folder_path(account, SCREENING_MAILBOX_NAME, raise_exception=True)
 
-	junk_folder_path = get_junk_folder_path(account)
 
-	if len(conditions) == 1:
-		condition_block = f"if {conditions[0]} {{"
+def is_screening_enabled(account: str) -> bool:
+	"""Whether Hey-style screening is enabled for the account (Account Settings.enable_screening)."""
+
+	return bool(frappe.db.get_value("Account Settings", parse_account(account)[1], "enable_screening"))
+
+
+def build_screening_gate(account: str, accepted_emails: list[str]) -> str:
+	"""Build the screening gate: file mail from senders not on the accepted list into Screening.
+
+	The account's own identity emails are always trusted, so self-addressed and identity mail is
+	never screened. This block is the last in the script — the catch-all fallback after Reject, Spam,
+	and the mailbox automation rules — so trusted and folder-routed mail is handled before it, and only
+	mail from an unrecognised sender that nothing else matched falls into Screening.
+	"""
+
+	screening_folder_path = get_screening_folder_path(account)
+
+	try:
+		own_emails = get_account_emails(account)
+	except Exception:
+		own_emails = []
+
+	trusted = list(dict.fromkeys(e.strip() for e in [*accepted_emails, *own_emails] if e and e.strip()))
+
+	if trusted:
+		joined = ",\n  ".join(f'"{e}"' for e in trusted)
+		condition_block = f'if not address :is "from" [\n  {joined}\n] {{'
 	else:
-		joined = ",\n  ".join(conditions)
-		condition_block = f"if anyof (\n  {joined}\n) {{"
+		# Nothing trusted yet → screen everything (only reached after the Reject/Spam blocks).
+		condition_block = 'if exists "from" {'
 
-	block_script = "\n".join(
+	return "\n".join(
 		[
-			f"# {block_name}",
+			"# Screening",
 			condition_block,
-			f'  fileinto "{junk_folder_path}";',
+			f'  fileinto "{screening_folder_path}";',
 			"  stop;",
 			"}",
 			"\n",
 		]
 	)
 
-	require_pattern = r"^(require\s+\[.*?\];\s*)+"
-	match = re.match(require_pattern, content, flags=re.DOTALL)
 
-	if match:
-		insert_pos = match.end()
-		content = content[:insert_pos] + "\n" + block_script + content[insert_pos:]
+def _build_screening_block(block_name: str, emails: list[str], action_lines: list[str]) -> str:
+	"""Build a labeled sieve block matching the given senders and running `action_lines`.
+
+	Returns an empty string when there are no senders to match.
+	"""
+
+	conditions = [f'address :is "from" "{e.strip()}"' for e in emails if e and e.strip()]
+	if not conditions:
+		return ""
+
+	if len(conditions) == 1:
+		condition_block = f"if {conditions[0]} {{"
 	else:
-		content = block_script + content
+		joined = ",\n  ".join(conditions)
+		condition_block = f"if anyof (\n  {joined}\n) {{"
 
-	doc.content = content.rstrip() + "\n"
-	doc.save()
+	return "\n".join([f"# {block_name}", condition_block, *action_lines, "}", "\n"])
+
+
+def _apply_screening_blocks(account: str, content: str) -> str:
+	"""Layer the Reject/Spam/Screening sieve blocks onto `content` and return the result.
+
+	Rebuilt from the Screened Email Address list (+ Account Settings) in one pass. The blocks are
+	ordered by precedence: Reject (discard) sits at the very top, right after `require`, so it wins
+	outright. The mailbox automation rules come next, so an explicit folder rule can still route mail.
+	Spam (file to Junk) and the Screening gate (`if not <trusted>` → Screening) are fallbacks below the
+	mailbox rules — Spam first, then the catch-all Screening gate at the very bottom. The final order is
+	Reject → Mailbox → Spam → Screening. A sender has at most one screening rule (uniqueness is on the
+	address), so the blocks never conflict.
+	"""
+
+	content = (content or "").lstrip()
+
+	# Remove any existing screening blocks, including the legacy block names from the pre-merge
+	# "Blocked Email Address" / "Junk Email Address" doctypes, so old scripts get cleaned up.
+	for name in ("Rejected Emails", "Spam Senders", "Screening", "Blocked Emails", "Junk Senders"):
+		content = remove_sieve_block(content, name)
+
+	screened = get_screened_email_addresses(account)
+	reject_emails = [s.email for s in screened if s.action == "Reject"]
+	spam_emails = [s.email for s in screened if s.action == "Spam"]
+	accepted_emails = [s.email for s in screened if s.action == "Accepted"]
+
+	# Reject is the most aggressive action and must win outright, so it sits at the very top — right
+	# after the require statement(s), above the mailbox rules.
+	reject_block = _build_screening_block("Rejected Emails", reject_emails, ["  discard;", "  stop;"])
+	if reject_block:
+		require_pattern = r"^(require\s+\[.*?\];\s*)+"
+		match = re.match(require_pattern, content, flags=re.DOTALL)
+		if match:
+			insert_pos = match.end()
+			content = content[:insert_pos] + "\n" + reject_block + content[insert_pos:]
+		else:
+			content = reject_block + content
+
+	# Spam goes below the mailbox rules (so an explicit folder rule can still claim the mail) but above
+	# the Screening gate.
+	if spam_emails:
+		junk_folder_path = get_junk_folder_path(account)
+		spam_block = _build_screening_block(
+			"Spam Senders",
+			spam_emails,
+			# Flag as junk ($junk keyword) as well as filing into Junk, so the mail is marked junk — not
+			# just located there — matching what marking a mail as junk does.
+			['  addflag "$junk";', f'  fileinto "{junk_folder_path}";', "  stop;"],
+		)
+		if spam_block:
+			content = content.rstrip() + "\n\n" + spam_block.rstrip() + "\n"
+
+	# Append the Screening gate last — the catch-all fallback, below every other block.
+	if is_screening_enabled(account):
+		gate = build_screening_gate(account, accepted_emails)
+		content = content.rstrip() + "\n\n" + gate.rstrip() + "\n"
+
+	return content.rstrip() + "\n"
diff --git a/mail/client/doctype/account_settings/account_settings.json b/mail/client/doctype/account_settings/account_settings.json
index cbbab5de1..8abbc33c3 100644
--- a/mail/client/doctype/account_settings/account_settings.json
+++ b/mail/client/doctype/account_settings/account_settings.json
@@ -12,13 +12,17 @@
   "destroy_newsletter_after_submit",
   "incoming_section",
   "on_mark_as_junk",
+  "column_break_fnnk",
+  "enable_screening",
+  "block_remote_images",
   "cache_section",
-  "has_cached_jmap_identities",
-  "has_cached_jmap_mailboxes",
   "column_break_brmt",
   "total_cached_blobs",
   "total_cached_mail_messages",
   "total_cached_contact_cards",
+  "column_break_bxpt",
+  "has_cached_jmap_identities",
+  "has_cached_jmap_mailboxes",
   "sieve_section",
   "last_active_sieve_script_id"
  ],
@@ -80,6 +84,20 @@
    "label": "On Mark As Junk",
    "options": "Junk Sender's Mail\nAsk to Block Sender"
   },
+  {
+   "default": "0",
+   "description": "When enabled, mail from senders not on the Accepted list is filed into the Screening folder instead of the inbox (Hey-style screening). Only senders you accept reach the inbox.",
+   "fieldname": "enable_screening",
+   "fieldtype": "Check",
+   "label": "Enable Screening"
+  },
+  {
+   "default": "1",
+   "description": "When enabled, remote images in mail from senders you haven't accepted are not loaded (this prevents senders from tracking when you open their mail). You can load them per message.",
+   "fieldname": "block_remote_images",
+   "fieldtype": "Check",
+   "label": "Block Remote Images"
+  },
   {
    "depends_on": "eval: !doc.__islocal",
    "fieldname": "cache_section",
@@ -154,12 +172,46 @@
    "no_copy": 1,
    "read_only": 1,
    "search_index": 1
+  },
+  {
+   "fieldname": "column_break_fnnk",
+   "fieldtype": "Column Break"
+  },
+  {
+   "fieldname": "column_break_bxpt",
+   "fieldtype": "Column Break"
   }
  ],
  "grid_page_length": 50,
  "index_web_pages_for_search": 1,
- "links": [],
- "modified": "2026-06-23 10:10:53.961267",
+ "links": [
+  {
+   "group": "Reference",
+   "link_doctype": "Mailbox Settings",
+   "link_fieldname": "account_id"
+  },
+  {
+   "group": "Reference",
+   "link_doctype": "Mail Sync History",
+   "link_fieldname": "account_id"
+  },
+  {
+   "group": "Reference",
+   "link_doctype": "Screened Email Address",
+   "link_fieldname": "account_id"
+  },
+  {
+   "group": "Exchange",
+   "link_doctype": "Mail Exchange",
+   "link_fieldname": "account_id"
+  },
+  {
+   "group": "Exchange",
+   "link_doctype": "Calendar Exchange",
+   "link_fieldname": "account_id"
+  }
+ ],
+ "modified": "2026-06-24 20:45:58.331960",
  "modified_by": "Administrator",
  "module": "Client",
  "name": "Account Settings",
diff --git a/mail/client/doctype/account_settings/account_settings.py b/mail/client/doctype/account_settings/account_settings.py
index a9173a446..4af3e963a 100644
--- a/mail/client/doctype/account_settings/account_settings.py
+++ b/mail/client/doctype/account_settings/account_settings.py
@@ -123,6 +123,20 @@ def validate_default_outgoing_email(self) -> None:
 	def after_insert(self) -> None:
 		create_archive_mailbox(self.account)
 
+	def on_update(self) -> None:
+		# Toggling screening changes the automation sieve's screening gate, so regenerate it. Skipped
+		# during migrate (no JMAP round-trips) and only when the flag actually changed.
+		if frappe.flags.in_migrate:
+			return
+
+		if self.has_value_changed("enable_screening"):
+			from mail.api.sieve import build_automation_sieve
+			from mail.utils.user import get_session_account
+
+			# Account Settings is named by the shared account_id; resolve it to the session user's
+			# account handle for the sieve regeneration.
+			build_automation_sieve(get_session_account(self.name))
+
 	def after_delete(self) -> None:
 		"""Clear all caches related to the account when the settings are deleted."""
 
diff --git a/mail/client/doctype/blocked_email_address/blocked_email_address.py b/mail/client/doctype/blocked_email_address/blocked_email_address.py
deleted file mode 100644
index 35fc5d210..000000000
--- a/mail/client/doctype/blocked_email_address/blocked_email_address.py
+++ /dev/null
@@ -1,84 +0,0 @@
-# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and contributors
-# For license information, please see license.txt
-
-from uuid import uuid7
-
-import frappe
-from frappe.model.document import Document
-
-from mail.jmap import parse_account
-from mail.utils.user import get_account_scoped_permission_query, has_account_scoped_permission
-
-
-class BlockedEmailAddress(Document):
-	"""A blocked sender, shared per JMAP account ID — every user with access to the
-	account sees and manages the same block list."""
-
-	def autoname(self) -> None:
-		self.name = str(uuid7())
-
-	def validate(self) -> None:
-		self.validate_duplicate_email()
-
-	def after_insert(self) -> None:
-		from mail.api.sieve import update_sieve_script_for_blocked_emails
-
-		update_sieve_script_for_blocked_emails(self._full_account())
-
-	def after_delete(self) -> None:
-		from mail.api.sieve import update_sieve_script_for_blocked_emails
-
-		update_sieve_script_for_blocked_emails(self._full_account())
-
-	def _full_account(self) -> str:
-		"""The `user:account_id` handle for the user acting on the shared list.
-
-		The blocked-emails sieve block lives on the account's server-side script, so
-		regenerating it needs a JMAP connection — use the acting user's handle (passed via
-		flags for API inserts, otherwise the session user, who must have access)."""
-
-		return self.flags.get("account") or f"{frappe.session.user}:{self.account_id}"
-
-	def validate_duplicate_email(self) -> None:
-		"""Validates that the same email address is not blocked multiple times for the same account.
-
-		Scoped to `account_id` so a shared account can't have the same address blocked twice.
-		"""
-
-		if frappe.db.exists(
-			"Blocked Email Address",
-			{"account_id": self.account_id, "email": self.email, "name": ["!=", self.name]},
-		):
-			frappe.throw(
-				frappe._("The email address {0} is already blocked for this account.").format(self.email)
-			)
-
-
-def get_blocked_email_addresses(account: str) -> list[str]:
-	"""Returns the blocked email addresses for the given account.
-
-	Keyed on `account_id` so every user with access to a shared account sees the same list.
-	"""
-
-	account_id = parse_account(account)[1]
-	return frappe.db.get_all("Blocked Email Address", filters={"account_id": account_id}, pluck="email")
-
-
-def get_permission_query_condition(user: str | None = None) -> str:
-	return get_account_scoped_permission_query("Blocked Email Address", user=user)
-
-
-def has_permission(doc: Document, ptype: str, user: str | None = None) -> bool:
-	if doc.doctype != "Blocked Email Address":
-		return False
-
-	return has_account_scoped_permission(doc, user=user)
-
-
-def on_doctype_update() -> None:
-	# Block list is shared per account_id, so uniqueness is on (account_id, email).
-	frappe.db.add_unique(
-		"Blocked Email Address",
-		["account_id", "email"],
-		constraint_name="unique_account_id_blocked_email",
-	)
diff --git a/mail/client/doctype/blocked_email_address/blocked_email_address_list.js b/mail/client/doctype/blocked_email_address/blocked_email_address_list.js
deleted file mode 100644
index 1bd2d2503..000000000
--- a/mail/client/doctype/blocked_email_address/blocked_email_address_list.js
+++ /dev/null
@@ -1,4 +0,0 @@
-// Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and contributors
-// For license information, please see license.txt
-
-frappe.listview_settings['Blocked Email Address'] = {}
diff --git a/mail/client/doctype/junk_email_address/__init__.py b/mail/client/doctype/junk_email_address/__init__.py
deleted file mode 100644
index e69de29bb..000000000
diff --git a/mail/client/doctype/junk_email_address/junk_email_address.json b/mail/client/doctype/junk_email_address/junk_email_address.json
deleted file mode 100644
index 0f8fe5905..000000000
--- a/mail/client/doctype/junk_email_address/junk_email_address.json
+++ /dev/null
@@ -1,80 +0,0 @@
-{
- "actions": [],
- "creation": "2026-06-22 11:54:31.220491",
- "doctype": "DocType",
- "engine": "InnoDB",
- "field_order": [
-  "section_break_gl6l",
-  "account_id",
-  "column_break_20of",
-  "email"
- ],
- "fields": [
-  {
-   "fieldname": "section_break_gl6l",
-   "fieldtype": "Section Break"
-  },
-  {
-   "description": "The shared JMAP account ID this junk rule belongs to. The junk list is the same for everyone with access to the account.",
-   "fieldname": "account_id",
-   "fieldtype": "Data",
-   "in_list_view": 1,
-   "in_standard_filter": 1,
-   "label": "Account ID",
-   "no_copy": 1,
-   "reqd": 1,
-   "search_index": 1,
-   "set_only_once": 1
-  },
-  {
-   "fieldname": "column_break_20of",
-   "fieldtype": "Column Break"
-  },
-  {
-   "description": "The email address whose future mail is filed into Junk for the account.",
-   "fieldname": "email",
-   "fieldtype": "Data",
-   "in_list_view": 1,
-   "label": "Email",
-   "no_copy": 1,
-   "options": "Email",
-   "reqd": 1,
-   "search_index": 1,
-   "set_only_once": 1
-  }
- ],
- "grid_page_length": 50,
- "index_web_pages_for_search": 1,
- "links": [],
- "modified": "2026-06-23 00:00:00.000000",
- "modified_by": "Administrator",
- "module": "Client",
- "name": "Junk Email Address",
- "owner": "Administrator",
- "permissions": [
-  {
-   "create": 1,
-   "delete": 1,
-   "email": 1,
-   "export": 1,
-   "print": 1,
-   "read": 1,
-   "report": 1,
-   "role": "System Manager",
-   "share": 1,
-   "write": 1
-  },
-  {
-   "create": 1,
-   "delete": 1,
-   "read": 1,
-   "role": "All",
-   "write": 1
-  }
- ],
- "row_format": "Dynamic",
- "rows_threshold_for_grid_search": 20,
- "sort_field": "creation",
- "sort_order": "DESC",
- "states": []
-}
diff --git a/mail/client/doctype/junk_email_address/junk_email_address.py b/mail/client/doctype/junk_email_address/junk_email_address.py
deleted file mode 100644
index 9e6501a8c..000000000
--- a/mail/client/doctype/junk_email_address/junk_email_address.py
+++ /dev/null
@@ -1,84 +0,0 @@
-# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and contributors
-# For license information, please see license.txt
-
-from uuid import uuid7
-
-import frappe
-from frappe.model.document import Document
-
-from mail.jmap import parse_account
-from mail.utils.user import get_account_scoped_permission_query, has_account_scoped_permission
-
-
-class JunkEmailAddress(Document):
-	"""A junked sender, shared per JMAP account ID — every user with access to the
-	account sees and manages the same junk list."""
-
-	def autoname(self) -> None:
-		self.name = str(uuid7())
-
-	def validate(self) -> None:
-		self.validate_duplicate_email()
-
-	def after_insert(self) -> None:
-		from mail.api.sieve import update_sieve_script_for_junk_senders
-
-		update_sieve_script_for_junk_senders(self._full_account())
-
-	def after_delete(self) -> None:
-		from mail.api.sieve import update_sieve_script_for_junk_senders
-
-		update_sieve_script_for_junk_senders(self._full_account())
-
-	def _full_account(self) -> str:
-		"""The `user:account_id` handle for the user acting on the shared list.
-
-		The junk-senders sieve block lives on the account's server-side script, so
-		regenerating it needs a JMAP connection — use the acting user's handle (passed via
-		flags for API inserts, otherwise the session user, who must have access)."""
-
-		return self.flags.get("account") or f"{frappe.session.user}:{self.account_id}"
-
-	def validate_duplicate_email(self) -> None:
-		"""Validates that the same email address is not junked multiple times for the same account.
-
-		Scoped to `account_id` so a shared account can't have the same address junked twice.
-		"""
-
-		if frappe.db.exists(
-			"Junk Email Address",
-			{"account_id": self.account_id, "email": self.email, "name": ["!=", self.name]},
-		):
-			frappe.throw(
-				frappe._("The email address {0} is already junked for this account.").format(self.email)
-			)
-
-
-def get_junk_email_addresses(account: str) -> list[str]:
-	"""Returns a list of junked email addresses for the given account.
-
-	Keyed on `account_id` so every user with access to a shared account sees the same list.
-	"""
-
-	account_id = parse_account(account)[1]
-	return frappe.db.get_all("Junk Email Address", filters={"account_id": account_id}, pluck="email")
-
-
-def get_permission_query_condition(user: str | None = None) -> str:
-	return get_account_scoped_permission_query("Junk Email Address", user=user)
-
-
-def has_permission(doc: Document, ptype: str, user: str | None = None) -> bool:
-	if doc.doctype != "Junk Email Address":
-		return False
-
-	return has_account_scoped_permission(doc, user=user)
-
-
-def on_doctype_update() -> None:
-	# Junk list is shared per account_id, so uniqueness is on (account_id, email).
-	frappe.db.add_unique(
-		"Junk Email Address",
-		["account_id", "email"],
-		constraint_name="unique_account_id_junk_email",
-	)
diff --git a/mail/client/doctype/junk_email_address/junk_email_address_list.js b/mail/client/doctype/junk_email_address/junk_email_address_list.js
deleted file mode 100644
index 8c3644574..000000000
--- a/mail/client/doctype/junk_email_address/junk_email_address_list.js
+++ /dev/null
@@ -1,4 +0,0 @@
-// Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and contributors
-// For license information, please see license.txt
-
-frappe.listview_settings['Junk Email Address'] = {}
diff --git a/mail/client/doctype/junk_email_address/test_junk_email_address.py b/mail/client/doctype/junk_email_address/test_junk_email_address.py
deleted file mode 100644
index 46a4fbc93..000000000
--- a/mail/client/doctype/junk_email_address/test_junk_email_address.py
+++ /dev/null
@@ -1,20 +0,0 @@
-# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and Contributors
-# See license.txt
-
-# import frappe
-from frappe.tests import IntegrationTestCase
-
-# On IntegrationTestCase, the doctype test records and all
-# link-field test record dependencies are recursively loaded
-# Use these module variables to add/remove to/from that list
-EXTRA_TEST_RECORD_DEPENDENCIES = []  # eg. ["User"]
-IGNORE_TEST_RECORD_DEPENDENCIES = []  # eg. ["User"]
-
-
-class IntegrationTestJunkEmailAddress(IntegrationTestCase):
-	"""
-	Integration tests for JunkEmailAddress.
-	Use this class for testing interactions between multiple components.
-	"""
-
-	pass
diff --git a/mail/client/doctype/mailbox/mailbox.py b/mail/client/doctype/mailbox/mailbox.py
index 2633dc097..249c109ca 100644
--- a/mail/client/doctype/mailbox/mailbox.py
+++ b/mail/client/doctype/mailbox/mailbox.py
@@ -142,7 +142,8 @@ def add_mailbox(
 
 	title = _("Mailbox Creation Error")
 	if response.get("created"):
-		service.invalidate_cache(account, key="mailboxes")
+		# Cache is keyed by the bare account_id, so invalidate with that — not the full handle.
+		service.invalidate_cache(service.account_id, key="mailboxes")
 		return response["created"][creation_id]["id"]
 	elif response.get("notCreated"):
 		frappe.throw(_(response["notCreated"][creation_id]["description"]), title=title)
@@ -203,7 +204,8 @@ def update_mailbox(
 		else:
 			frappe.throw(_(response["description"]), title=title)
 
-	service.invalidate_cache(account, key="mailboxes")
+	# Cache is keyed by the bare account_id, so invalidate with that — not the full handle.
+	service.invalidate_cache(service.account_id, key="mailboxes")
 
 
 @frappe.whitelist()
@@ -224,6 +226,9 @@ def delete_mailboxes(account: str, ids: list[str], remove_emails: bool = True) -
 			title=_("Mailbox Deletion Error"),
 		)
 
+	# Drop the stale list so later lookups (e.g. sieve regeneration) don't see the deleted mailbox.
+	service.invalidate_cache(service.account_id, key="mailboxes")
+
 
 @frappe.whitelist()
 def fetch_mailboxes(account: str, page: int = 1, limit: int = 10) -> list:
diff --git a/mail/client/doctype/mailbox_settings/mailbox_settings.json b/mail/client/doctype/mailbox_settings/mailbox_settings.json
index 236de48ac..86f2e9bf8 100644
--- a/mail/client/doctype/mailbox_settings/mailbox_settings.json
+++ b/mail/client/doctype/mailbox_settings/mailbox_settings.json
@@ -12,7 +12,14 @@
   "icon",
   "color",
   "column_break_mbnv",
-  "disable_push_notification"
+  "disable_push_notification",
+  "automation_section",
+  "emails_from",
+  "subject_contains",
+  "match_if",
+  "column_break_auto",
+  "mark_as_read",
+  "add_star"
  ],
  "fields": [
   {
@@ -75,12 +82,56 @@
    "fieldtype": "Check",
    "label": "Disable Push Notification",
    "search_index": 1
+  },
+  {
+   "description": "Automation rules for this mailbox. Kept as the source of truth so the frappe_mail_automation Sieve script can be regenerated even if it is deleted by a third-party client.",
+   "fieldname": "automation_section",
+   "fieldtype": "Section Break",
+   "label": "Automation"
+  },
+  {
+   "description": "Comma-separated sender addresses (wildcards allowed, e.g. *@example.io). Emails from these addresses are moved to this mailbox.",
+   "fieldname": "emails_from",
+   "fieldtype": "Small Text",
+   "label": "Emails From"
+  },
+  {
+   "description": "Comma-separated keywords. Emails with these keywords in the subject are moved to this mailbox.",
+   "fieldname": "subject_contains",
+   "fieldtype": "Small Text",
+   "label": "Subject Contains"
+  },
+  {
+   "default": "any",
+   "description": "Whether either (any) or both (all) of the conditions above must match. Only relevant when both conditions are set.",
+   "fieldname": "match_if",
+   "fieldtype": "Select",
+   "label": "Match If",
+   "options": "any\nall"
+  },
+  {
+   "fieldname": "column_break_auto",
+   "fieldtype": "Column Break"
+  },
+  {
+   "default": "0",
+   "description": "Automatically mark emails as read when they are moved to this mailbox.",
+   "fieldname": "mark_as_read",
+   "fieldtype": "Check",
+   "label": "Mark as Read"
+  },
+  {
+   "default": "0",
+   "description": "Automatically star emails when they are moved to this mailbox.",
+   "fieldname": "add_star",
+   "fieldtype": "Check",
+   "label": "Add Star"
   }
  ],
  "grid_page_length": 50,
  "index_web_pages_for_search": 1,
  "links": [],
- "modified": "2026-06-23 00:00:00.000000",
+ "modified": "2026-06-25 00:00:00.000000",
  "modified_by": "Administrator",
  "module": "Client",
  "name": "Mailbox Settings",
diff --git a/mail/client/doctype/mailbox_settings/mailbox_settings.py b/mail/client/doctype/mailbox_settings/mailbox_settings.py
index 91436567d..142aa23a9 100644
--- a/mail/client/doctype/mailbox_settings/mailbox_settings.py
+++ b/mail/client/doctype/mailbox_settings/mailbox_settings.py
@@ -10,6 +10,10 @@
 from mail.jmap import parse_account
 from mail.utils.user import get_account_scoped_permission_query, has_account_scoped_permission
 
+# Fields that feed the Mailbox section of the frappe_mail_automation sieve script; a change to any of
+# them regenerates the script.
+AUTOMATION_FIELDS = ("emails_from", "subject_contains", "match_if", "mark_as_read", "add_star")
+
 
 class MailboxSettings(Document):
 	"""Per-mailbox settings, shared per JMAP account ID — every user with access to the
@@ -21,6 +25,20 @@ def autoname(self) -> None:
 	def validate(self) -> None:
 		self.validate_duplicate()
 
+	def on_update(self) -> None:
+		# Regenerate the automation sieve when a folder's automation rules change through the document
+		# lifecycle (e.g. a save from Desk). The high-volume API path writes via db_set — which bypasses
+		# this hook — and rebuilds explicitly once after its structural writes. Skipped during migrate
+		# (no JMAP round-trips) and when a caller paused builds for a bulk write.
+		if frappe.flags.in_migrate or frappe.flags.get("skip_automation_sieve_build"):
+			return
+
+		if any(self.has_value_changed(field) for field in AUTOMATION_FIELDS):
+			from mail.api.sieve import maybe_build_automation_sieve
+			from mail.utils.user import get_session_account
+
+			maybe_build_automation_sieve(get_session_account(self.account_id))
+
 	def validate_duplicate(self) -> None:
 		"""Checks for duplicate Mailbox Settings for the same account and mailbox ID."""
 
@@ -72,6 +90,44 @@ def get_mailbox_settings(
 		)
 
 
+def get_mailbox_automation_rules(account: str, mailbox_id: str) -> dict | None:
+	"""Return the persisted automation rules for a mailbox as a rule dict, or None if it has none.
+
+	This is the backup that the frappe_mail_automation Sieve script is generated from, so the script
+	can be rebuilt even if a third-party client deletes it. A mailbox is considered to have no
+	automation when neither a sender nor a subject condition is set.
+	"""
+
+	settings = get_mailbox_settings(account, mailbox_id, raise_exception=False)
+	if not settings or not (settings.emails_from or settings.subject_contains):
+		return None
+
+	return {
+		"emails_from": settings.emails_from or "",
+		"subject_contains": settings.subject_contains or "",
+		"match_if": settings.match_if or "any",
+		"mark_as_read": bool(settings.mark_as_read),
+		"add_star": bool(settings.add_star),
+	}
+
+
+def automation_rules_to_settings(rules: dict | None) -> dict:
+	"""Flatten a rule dict (or None) into the Mailbox Settings automation fields.
+
+	A falsy `rules` clears the fields, so removing a mailbox's automation in the UI also clears its
+	backup.
+	"""
+
+	rules = rules or {}
+	return {
+		"emails_from": rules.get("emails_from") or "",
+		"subject_contains": rules.get("subject_contains") or "",
+		"match_if": rules.get("match_if") or "any",
+		"mark_as_read": 1 if rules.get("mark_as_read") else 0,
+		"add_star": 1 if rules.get("add_star") else 0,
+	}
+
+
 def set_mailbox_settings(account: str, mailbox_id: str, **kwargs) -> None:
 	"""Sets the Mailbox Settings for a given account and mailbox ID. Creates a new document if it doesn't exist."""
 
diff --git a/mail/client/doctype/blocked_email_address/__init__.py b/mail/client/doctype/screened_email_address/__init__.py
similarity index 100%
rename from mail/client/doctype/blocked_email_address/__init__.py
rename to mail/client/doctype/screened_email_address/__init__.py
diff --git a/mail/client/doctype/blocked_email_address/blocked_email_address.js b/mail/client/doctype/screened_email_address/screened_email_address.js
similarity index 71%
rename from mail/client/doctype/blocked_email_address/blocked_email_address.js
rename to mail/client/doctype/screened_email_address/screened_email_address.js
index f4d84fb97..f599a9176 100644
--- a/mail/client/doctype/blocked_email_address/blocked_email_address.js
+++ b/mail/client/doctype/screened_email_address/screened_email_address.js
@@ -1,4 +1,4 @@
 // Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and contributors
 // For license information, please see license.txt
 
-frappe.ui.form.on('Blocked Email Address', {})
+frappe.ui.form.on('Screened Email Address', {})
diff --git a/mail/client/doctype/blocked_email_address/blocked_email_address.json b/mail/client/doctype/screened_email_address/screened_email_address.json
similarity index 75%
rename from mail/client/doctype/blocked_email_address/blocked_email_address.json
rename to mail/client/doctype/screened_email_address/screened_email_address.json
index dbfad7451..5ed1e5306 100644
--- a/mail/client/doctype/blocked_email_address/blocked_email_address.json
+++ b/mail/client/doctype/screened_email_address/screened_email_address.json
@@ -1,11 +1,12 @@
 {
  "actions": [],
- "creation": "2026-04-21 11:54:31.220491",
+ "creation": "2026-06-22 12:00:00.000000",
  "doctype": "DocType",
  "engine": "InnoDB",
  "field_order": [
   "section_break_gl6l",
   "account_id",
+  "action",
   "column_break_20of",
   "email"
  ],
@@ -41,6 +42,18 @@
    "reqd": 1,
    "search_index": 1,
    "set_only_once": 1
+  },
+  {
+   "default": "Reject",
+   "description": "Accepted lets the sender's mail reach the inbox (used by screening). Spam files incoming mail into the Spam (Junk) folder. Reject discards incoming mail from the sender silently.",
+   "fieldname": "action",
+   "fieldtype": "Select",
+   "in_list_view": 1,
+   "in_standard_filter": 1,
+   "label": "Action",
+   "no_copy": 1,
+   "options": "Spam\nReject\nAccepted",
+   "reqd": 1
   }
  ],
  "grid_page_length": 50,
@@ -49,7 +62,7 @@
  "modified": "2026-06-23 00:00:00.000000",
  "modified_by": "Administrator",
  "module": "Client",
- "name": "Blocked Email Address",
+ "name": "Screened Email Address",
  "owner": "Administrator",
  "permissions": [
   {
diff --git a/mail/client/doctype/screened_email_address/screened_email_address.py b/mail/client/doctype/screened_email_address/screened_email_address.py
new file mode 100644
index 000000000..aa80721a3
--- /dev/null
+++ b/mail/client/doctype/screened_email_address/screened_email_address.py
@@ -0,0 +1,93 @@
+# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and contributors
+# For license information, please see license.txt
+
+from uuid import uuid7
+
+import frappe
+from frappe.model.document import Document
+
+from mail.jmap import parse_account
+from mail.utils.user import (
+	get_account_scoped_permission_query,
+	get_session_account,
+	has_account_scoped_permission,
+)
+
+# Screening actions: what happens to future mail from a screened sender.
+REJECT = "Reject"  # discard the incoming mail silently
+SPAM = "Spam"  # file the incoming mail into the Spam (Junk) folder
+
+
+class ScreenedEmailAddress(Document):
+	def autoname(self) -> None:
+		self.name = str(uuid7())
+
+	def validate(self) -> None:
+		self.validate_duplicate_email()
+
+	def on_update(self) -> None:
+		from mail.api.sieve import maybe_build_automation_sieve
+
+		# Runs on both insert and save. `email` is set_only_once, so on an edit only the action can
+		# change; regenerate on insert (no prior doc) and whenever the action is changed (e.g. switching
+		# Spam <-> Reject in Desk), since that moves the sender between sieve blocks. Skipped when a
+		# caller paused builds for a bulk write (it rebuilds once at the end instead).
+		if self.has_value_changed("action"):
+			maybe_build_automation_sieve(get_session_account(self.account_id))
+
+	def after_delete(self) -> None:
+		from mail.api.sieve import maybe_build_automation_sieve
+
+		maybe_build_automation_sieve(get_session_account(self.account_id))
+
+	def validate_duplicate_email(self) -> None:
+		"""Validates that the same email address is not screened more than once for the same account.
+
+		Scoped to `account_id` (not the per-user `account` handle) so a shared account can't have the
+		same address screened twice by different users. Uniqueness is on the address alone, not the
+		action, so a sender always has exactly one screening rule (Reject or Spam, never both).
+		"""
+
+		if frappe.db.exists(
+			"Screened Email Address",
+			{"account_id": self.account_id, "email": self.email, "name": ["!=", self.name]},
+		):
+			frappe.throw(
+				frappe._("The email address {0} is already screened for this account.").format(self.email)
+			)
+
+
+def get_screened_email_addresses(account: str, action: str | None = None) -> list[dict]:
+	"""Returns the screened email addresses (with their action) for the given account.
+
+	Keyed on `account_id` so every user with access to a shared account sees the same list. Pass
+	`action` to restrict to a single action (e.g. only the Reject rules).
+	"""
+
+	account_id = parse_account(account)[1]
+	filters = {"account_id": account_id}
+	if action:
+		filters["action"] = action
+
+	return frappe.db.get_all("Screened Email Address", filters=filters, fields=["email", "action"])
+
+
+def get_permission_query_condition(user: str | None = None) -> str:
+	return get_account_scoped_permission_query("Screened Email Address", user=user)
+
+
+def has_permission(doc: Document, ptype: str, user: str | None = None) -> bool:
+	if doc.doctype != "Screened Email Address":
+		return False
+
+	return has_account_scoped_permission(doc, user=user)
+
+
+def on_doctype_update() -> None:
+	# Screening list is shared per account_id, so uniqueness is on (account_id, email) — one rule
+	# per address regardless of action.
+	frappe.db.add_unique(
+		"Screened Email Address",
+		["account_id", "email"],
+		constraint_name="unique_account_id_screened_email",
+	)
diff --git a/mail/client/doctype/junk_email_address/junk_email_address.js b/mail/client/doctype/screened_email_address/screened_email_address_list.js
similarity index 68%
rename from mail/client/doctype/junk_email_address/junk_email_address.js
rename to mail/client/doctype/screened_email_address/screened_email_address_list.js
index a4cb13b94..3545f85ff 100644
--- a/mail/client/doctype/junk_email_address/junk_email_address.js
+++ b/mail/client/doctype/screened_email_address/screened_email_address_list.js
@@ -1,4 +1,4 @@
 // Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and contributors
 // For license information, please see license.txt
 
-frappe.ui.form.on('Junk Email Address', {})
+frappe.listview_settings['Screened Email Address'] = {}
diff --git a/mail/client/doctype/blocked_email_address/test_blocked_email_address.py b/mail/client/doctype/screened_email_address/test_screened_email_address.py
similarity index 82%
rename from mail/client/doctype/blocked_email_address/test_blocked_email_address.py
rename to mail/client/doctype/screened_email_address/test_screened_email_address.py
index d9a2a8f27..e69dba551 100644
--- a/mail/client/doctype/blocked_email_address/test_blocked_email_address.py
+++ b/mail/client/doctype/screened_email_address/test_screened_email_address.py
@@ -11,9 +11,9 @@
 IGNORE_TEST_RECORD_DEPENDENCIES = []  # eg. ["User"]
 
 
-class IntegrationTestBlockedEmailAddress(IntegrationTestCase):
+class IntegrationTestScreenedEmailAddress(IntegrationTestCase):
 	"""
-	Integration tests for BlockedEmailAddress.
+	Integration tests for ScreenedEmailAddress.
 	Use this class for testing interactions between multiple components.
 	"""
 
diff --git a/mail/hooks.py b/mail/hooks.py
index 4709b595d..a83821825 100644
--- a/mail/hooks.py
+++ b/mail/hooks.py
@@ -163,9 +163,8 @@
 	"Principal Settings": "mail.server.doctype.principal_settings.principal_settings.get_permission_query_condition",
 	# Client
 	"Account Settings": "mail.client.doctype.account_settings.account_settings.get_permission_query_condition",
-	"Blocked Email Address": "mail.client.doctype.blocked_email_address.blocked_email_address.get_permission_query_condition",
 	"Calendar Exchange": "mail.client.doctype.calendar_exchange.calendar_exchange.get_permission_query_condition",
-	"Junk Email Address": "mail.client.doctype.junk_email_address.junk_email_address.get_permission_query_condition",
+	"Screened Email Address": "mail.client.doctype.screened_email_address.screened_email_address.get_permission_query_condition",
 	"Mail Exchange": "mail.client.doctype.mail_exchange.mail_exchange.get_permission_query_condition",
 	"Mail Queue": "mail.client.doctype.mail_queue.mail_queue.get_permission_query_condition",
 	"Mail Sync History": "mail.client.doctype.mail_sync_history.mail_sync_history.get_permission_query_condition",
@@ -183,15 +182,14 @@
 	# Client
 	"Account Settings": "mail.client.doctype.account_settings.account_settings.has_permission",
 	"Address Book": "mail.client.doctype.address_book.address_book.has_permission",
-	"Blocked Email Address": "mail.client.doctype.blocked_email_address.blocked_email_address.has_permission",
 	"Calendar": "mail.client.doctype.calendar.calendar.has_permission",
 	"Calendar Event": "mail.client.doctype.calendar_event.calendar_event.has_permission",
 	"Calendar Exchange": "mail.client.doctype.calendar_exchange.calendar_exchange.has_permission",
 	"Contact Card": "mail.client.doctype.contact_card.contact_card.has_permission",
 	"Event Notification": "mail.client.doctype.event_notification.event_notification.has_permission",
 	"Identity": "mail.client.doctype.identity.identity.has_permission",
-	"Junk Email Address": "mail.client.doctype.junk_email_address.junk_email_address.has_permission",
 	"Mail Exchange": "mail.client.doctype.mail_exchange.mail_exchange.has_permission",
+	"Screened Email Address": "mail.client.doctype.screened_email_address.screened_email_address.has_permission",
 	"Mail Queue": "mail.client.doctype.mail_queue.mail_queue.has_permission",
 	"Mail Sync History": "mail.client.doctype.mail_sync_history.mail_sync_history.has_permission",
 	"Mailbox": "mail.client.doctype.mailbox.mailbox.has_permission",
@@ -304,7 +302,7 @@
 	# Client
 	"Account Settings",
 	"Calendar Exchange",
-	"Junk Email Address",
+	"Screened Email Address",
 	"Mail Exchange",
 	"Mail Queue",
 	"Mail Signature",
diff --git a/mail/patches.txt b/mail/patches.txt
index d9ca2eb43..3177cd8ee 100644
--- a/mail/patches.txt
+++ b/mail/patches.txt
@@ -25,3 +25,5 @@ mail.patches.backfill_mail_sync_history_account_id
 mail.patches.backfill_mail_queue_account_id
 mail.patches.clear_legacy_user_scoped_stores
 mail.patches.clear_legacy_blob_store_layout
+mail.patches.migrate_to_screened_email_address
+mail.patches.backfill_mailbox_automation_rules
diff --git a/mail/patches/backfill_blocked_email_account_id.py b/mail/patches/backfill_blocked_email_account_id.py
index 75e537546..665c7123c 100644
--- a/mail/patches/backfill_blocked_email_account_id.py
+++ b/mail/patches/backfill_blocked_email_account_id.py
@@ -12,9 +12,12 @@ def execute() -> None:
 	(account_id, email) and fills account_id in, and drops the now-redundant per-handle index.
 	"""
 
-	if not frappe.db.has_column("Blocked Email Address", "account"):
-		# The per-user `account` handle was later dropped (block list shared per account_id);
-		# nothing to backfill on fresh installs.
+	# "Blocked Email Address" has since been merged into "Screened Email Address", and the per-user
+	# `account` handle it read was dropped (the block list is keyed on account_id). Nothing to backfill
+	# once the table or that column is gone (fresh installs, or sites past the migration).
+	if not frappe.db.table_exists("Blocked Email Address") or not frappe.db.has_column(
+		"Blocked Email Address", "account"
+	):
 		return
 
 	rows = frappe.get_all(
diff --git a/mail/patches/backfill_mailbox_automation_rules.py b/mail/patches/backfill_mailbox_automation_rules.py
new file mode 100644
index 000000000..aa522ebbb
--- /dev/null
+++ b/mail/patches/backfill_mailbox_automation_rules.py
@@ -0,0 +1,15 @@
+import frappe
+
+from mail.api.sieve import backfill_mailbox_automation_rules
+
+
+def execute() -> None:
+	"""Capture existing folder automation rules into the Mailbox Settings backup.
+
+	Folder rules used to live only inside the frappe_mail_automation sieve script. Now that Mailbox
+	Settings is the source of truth the script is generated from, copy the existing rules over so the
+	first rebuild doesn't drop them. JMAP isn't reachable during `bench migrate`, so it runs as a
+	background job once migrate is done (same approach as the outgoing-settings backfill).
+	"""
+
+	frappe.enqueue(backfill_mailbox_automation_rules, queue="long", enqueue_after_commit=True)
diff --git a/mail/patches/migrate_to_screened_email_address.py b/mail/patches/migrate_to_screened_email_address.py
new file mode 100644
index 000000000..0c6f30412
--- /dev/null
+++ b/mail/patches/migrate_to_screened_email_address.py
@@ -0,0 +1,72 @@
+import frappe
+from frappe.model.document import bulk_insert
+
+
+def execute() -> None:
+	"""Merge the legacy "Blocked Email Address" and "Junk Email Address" doctypes into the unified
+	"Screened Email Address" doctype, then drop the old doctypes.
+
+	A blocked address becomes a Reject rule (discard) and a junked address becomes a Spam rule (file
+	into Junk). All three doctypes are keyed on the shared `account_id` (the legacy ones were
+	backfilled earlier in this migration), and a sender has at most one rule, so a Reject always
+	supersedes a Spam for the same (account_id, email).
+
+	Inserted via `bulk_insert` (no per-document hooks), so the sieve scripts are not regenerated here:
+	the existing server-side sieve blocks already reflect the same addresses and actions, and the new
+	unified block names supersede the legacy ones the next time a screening change is made.
+	"""
+
+	if not frappe.db.exists("DocType", "Screened Email Address"):
+		return
+
+	seen: set[tuple[str, str]] = set()
+	docs = []
+
+	def add(account_id: str, email: str, action: str, creation) -> None:
+		if not email or not account_id:
+			return
+
+		key = (account_id, email)
+		if key in seen:  # Reject (inserted first) supersedes Spam for the same address.
+			return
+		seen.add(key)
+
+		doc = frappe.get_doc(
+			{
+				"doctype": "Screened Email Address",
+				"account_id": account_id,
+				"email": email,
+				"action": action,
+			}
+		)
+		doc.set_new_name()
+		if creation:
+			doc.creation = creation
+		docs.append(doc)
+
+	# Reject rules first so they win over a Spam rule for the same address.
+	if frappe.db.table_exists("Blocked Email Address"):
+		for row in frappe.get_all(
+			"Blocked Email Address",
+			fields=["account_id", "email", "creation"],
+			order_by="creation asc",
+		):
+			add(row.account_id, row.email, "Reject", row.creation)
+
+	if frappe.db.table_exists("Junk Email Address"):
+		for row in frappe.get_all(
+			"Junk Email Address",
+			fields=["account_id", "email", "creation"],
+			order_by="creation asc",
+		):
+			add(row.account_id, row.email, "Spam", row.creation)
+
+	if docs:
+		bulk_insert("Screened Email Address", docs, ignore_duplicates=True)
+
+	# The data now lives in Screened Email Address; drop the now-redundant legacy doctypes. delete_doc
+	# removes the DocType definition but leaves the table behind, so drop it explicitly too.
+	for doctype in ("Blocked Email Address", "Junk Email Address"):
+		if frappe.db.exists("DocType", doctype):
+			frappe.delete_doc("DocType", doctype, ignore_missing=True, force=True)
+		frappe.db.sql_ddl(f"DROP TABLE IF EXISTS `tab{doctype}`")

From 79014005dc22483d793b12f03570ac30a33823f1 Mon Sep 17 00:00:00 2001
From: s-aga-r <sagarsharma.s312@gmail.com>
Date: Thu, 25 Jun 2026 09:30:42 +0530
Subject: [PATCH 2/2] chore: `linter`

---
 mail/api/sieve.py | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/mail/api/sieve.py b/mail/api/sieve.py
index bfa850e91..364eb2092 100644
--- a/mail/api/sieve.py
+++ b/mail/api/sieve.py
@@ -197,9 +197,7 @@ def backfill_mailbox_automation_rules() -> None:
 		for account_id in account_ids:
 			account = f"{user}:{account_id}"
 			try:
-				scripts = SieveScript._fetch_sieve_scripts(
-					account, filter={"name": AUTOMATION_SCRIPT_NAME}
-				)
+				scripts = SieveScript._fetch_sieve_scripts(account, filter={"name": AUTOMATION_SCRIPT_NAME})
 				if not (scripts and scripts[0]):
 					continue
 
@@ -214,9 +212,7 @@ def backfill_mailbox_automation_rules() -> None:
 					continue
 
 				try:
-					set_mailbox_settings(
-						account, mailbox["id"], **automation_rules_to_settings(rules)
-					)
+					set_mailbox_settings(account, mailbox["id"], **automation_rules_to_settings(rules))
 				except Exception:
 					continue