@novacraft-engineering/mailbox 0.4.28 → 0.4.30

package/lib/inbox-filters.test.ts

@@ -0,0 +1,54 @@
+import assert from 'node:assert/strict'
+import { DatabaseSync } from 'node:sqlite'
+import { DEFAULT_INBOX_FILTERS, inboxFiltersSql, matchesInboxFilters, normalizeInboxFilters, type InboxFilter } from './inbox-filters.ts'
+
+assert.deepEqual(normalizeInboxFilters(undefined), DEFAULT_INBOX_FILTERS, 'untouched settings get the defaults')
+assert.deepEqual(normalizeInboxFilters([]), [], 'an emptied list stays empty')
+assert.deepEqual(
+  normalizeInboxFilters([
+    { kind: 'senderDomain', value: ' @Example.COM ' },
+    { kind: 'senderDomain', value: 'example.com' },
+    { kind: 'bogus', value: 'x' },
+    { kind: 'subjectPrefix', value: '   ' },
+  ]),
+  [{ kind: 'senderDomain', value: 'example.com' }],
+  'sender values are lowercased, duplicates and junk dropped',
+)
+
+const threads = [
+  { id: 'dmarc', senders: ['DMARC <dmarcreport@microsoft.com>'], subject: '[Preview] Report Domain: example.com', snippet: 'This is a DMARC report' },
+  { id: 'dmarc-joined', senders: ['dmarcreport@microsoft.com', 'Ada <ada@example.org>'], subject: 'Re: report', snippet: 'Thanks' },
+  { id: 'newsletter', senders: ['news@mail.example.net'], subject: 'Weekly: what shipped', snippet: '\n  Unsubscribe any time' },
+  { id: 'person', senders: ['Ada <ada@example.org>'], subject: 'Lunch 50% off?', snippet: 'Hi' },
+]
+
+const db = new DatabaseSync(':memory:')
+db.exec('CREATE TABLE mail_threads (thread_id TEXT, senders TEXT, subject TEXT, snippet TEXT)')
+const insert = db.prepare('INSERT INTO mail_threads VALUES (?, ?, ?, ?)')
+for (const thread of threads) insert.run(thread.id, JSON.stringify(thread.senders), thread.subject, thread.snippet)
+
+const viaSql = (filters: InboxFilter[]) => {
+  const clause = inboxFiltersSql(filters)
+  if (!clause) return []
+  return db.prepare(`SELECT thread_id FROM mail_threads t WHERE ${clause.sql} ORDER BY thread_id`).all(...clause.args).map(row => String(row.thread_id))
+}
+const viaJs = (filters: InboxFilter[]) =>
+  threads.filter(thread => matchesInboxFilters(filters, { senders: thread.senders, subject: thread.subject, text: thread.snippet })).map(thread => thread.id).sort()
+
+const cases: Array<[InboxFilter[], string[]]> = [
+  [DEFAULT_INBOX_FILTERS, ['dmarc']],
+  [[{ kind: 'senderDomain', value: 'example.net' }], ['newsletter']],
+  [[{ kind: 'senderDomain', value: 'microsoft.com' }], ['dmarc']],
+  [[{ kind: 'subjectPrefix', value: 'weekly:' }], ['newsletter']],
+  [[{ kind: 'subjectContains', value: '50%' }], ['person']],
+  [[{ kind: 'subjectContains', value: '0%' }], ['person']],
+  [[{ kind: 'messagePrefix', value: 'unsubscribe' }], ['newsletter']],
+  [[{ kind: 'senderPrefix', value: 'dmarcreport' }, { kind: 'senderPrefix', value: 'ada' }], ['dmarc', 'dmarc-joined', 'person']],
+]
+for (const [filters, expected] of cases) {
+  assert.deepEqual(viaSql(filters), expected, `sql ${JSON.stringify(filters)}`)
+  assert.deepEqual(viaJs(filters), expected, `js ${JSON.stringify(filters)}`)
+}
+assert.equal(inboxFiltersSql([]), null)
+
+console.log('inbox-filters: ok')

package/lib/inbox-filters.ts

@@ -0,0 +1,111 @@
+export type InboxFilterKind = 'senderPrefix' | 'senderDomain' | 'subjectPrefix' | 'subjectContains' | 'messagePrefix'
+export type InboxFilter = { kind: InboxFilterKind; value: string }
+
+export const INBOX_FILTER_KINDS: Array<{ kind: InboxFilterKind; label: string; placeholder: string }> = [
+  { kind: 'senderPrefix', label: 'Sender starts with', placeholder: 'dmarcreport' },
+  { kind: 'senderDomain', label: 'Sender domain', placeholder: 'example.com' },
+  { kind: 'subjectPrefix', label: 'Subject starts with', placeholder: 'Report Domain:' },
+  { kind: 'subjectContains', label: 'Subject contains', placeholder: 'newsletter' },
+  { kind: 'messagePrefix', label: 'Message starts with', placeholder: 'This is an automated' },
+]
+
+export const DEFAULT_INBOX_FILTERS: InboxFilter[] = [{ kind: 'senderPrefix', value: 'dmarcreport' }]
+
+const MAX_FILTERS = 40
+const MAX_VALUE = 200
+const SENDER_KINDS = new Set<InboxFilterKind>(['senderPrefix', 'senderDomain'])
+
+/** A person who never touched the list gets the defaults; one who emptied it gets none. */
+export function normalizeInboxFilters(raw: unknown): InboxFilter[] {
+  if (!Array.isArray(raw)) return DEFAULT_INBOX_FILTERS
+  const seen = new Set<string>()
+  const filters: InboxFilter[] = []
+  for (const entry of raw) {
+    const kind = (entry as InboxFilter)?.kind
+    if (!INBOX_FILTER_KINDS.some(option => option.kind === kind)) continue
+    let value = String((entry as InboxFilter).value ?? '').replace(/\s+/g, ' ').trim().slice(0, MAX_VALUE)
+    if (SENDER_KINDS.has(kind)) value = value.toLowerCase().replace(/^@/, '')
+    const key = `${kind}:${value.toLowerCase()}`
+    if (!value || seen.has(key)) continue
+    seen.add(key)
+    filters.push({ kind, value })
+    if (filters.length === MAX_FILTERS) break
+  }
+  return filters
+}
+
+const likeEscape = (value: string) => value.replace(/[\\%_]/g, match => `\\${match}`)
+
+function senderAddress(raw: string): string {
+  const angled = raw.match(/<([^>]*)>?/)
+  return (angled ? angled[1] : raw).trim().toLowerCase()
+}
+
+const ADDRESS_SQL = "lower(trim(rtrim(CASE WHEN instr(value, '<') > 0 THEN substr(value, instr(value, '<') + 1) ELSE value END, '> ')))"
+const SNIPPET_SQL = "ltrim(coalesce(t.snippet, ''), ' ' || char(9, 10, 13))"
+
+/**
+ * The rules as one SQL condition over a mail_threads row aliased `t`. Sender rules hold only
+ * when every sender in the conversation matches, so a person replying into a filtered
+ * thread brings it back; subject and message rules read the latest message.
+ */
+export function inboxFiltersSql(filters: InboxFilter[]): { sql: string; args: string[] } | null {
+  if (!filters.length) return null
+  const senderRules: string[] = []
+  const senderArgs: string[] = []
+  const rules: string[] = []
+  const args: string[] = []
+  for (const filter of filters) {
+    const value = likeEscape(filter.value)
+    if (filter.kind === 'senderPrefix') {
+      senderRules.push(`${ADDRESS_SQL} LIKE ? ESCAPE '\\'`)
+      senderArgs.push(`${value.toLowerCase()}%`)
+    } else if (filter.kind === 'senderDomain') {
+      senderRules.push(`(${ADDRESS_SQL} LIKE ? ESCAPE '\\' OR ${ADDRESS_SQL} LIKE ? ESCAPE '\\')`)
+      senderArgs.push(`%@${value.toLowerCase()}`, `%.${value.toLowerCase()}`)
+    } else if (filter.kind === 'subjectPrefix') {
+      rules.push(`coalesce(t.subject, '') LIKE ? ESCAPE '\\'`)
+      args.push(`${value}%`)
+    } else if (filter.kind === 'subjectContains') {
+      rules.push(`coalesce(t.subject, '') LIKE ? ESCAPE '\\'`)
+      args.push(`%${value}%`)
+    } else {
+      rules.push(`${SNIPPET_SQL} LIKE ? ESCAPE '\\'`)
+      args.push(`${value}%`)
+    }
+  }
+  const parts = [...rules]
+  if (senderRules.length) {
+    parts.unshift(
+      `(json_array_length(coalesce(t.senders, '[]')) > 0 AND NOT EXISTS (SELECT 1 FROM json_each(coalesce(t.senders, '[]')) WHERE NOT (${senderRules.join(' OR ')})))`,
+    )
+  }
+  return { sql: `(${parts.join(' OR ')})`, args: [...senderArgs, ...args] }
+}
+
+/** The same rules for one message, for the paths that never reach SQL — a push, say. */
+export function matchesInboxFilters(
+  filters: InboxFilter[],
+  message: { senders: string[]; subject: string | null | undefined; text: string | null | undefined },
+): boolean {
+  const addresses = message.senders.filter(Boolean).map(senderAddress)
+  const subject = (message.subject ?? '').toLowerCase()
+  const text = (message.text ?? '').trimStart().toLowerCase()
+  const senderMatches = (address: string) =>
+    filters.some(filter => {
+      if (filter.kind === 'senderPrefix') return address.startsWith(filter.value.toLowerCase())
+      if (filter.kind === 'senderDomain') {
+        const domain = filter.value.toLowerCase()
+        return address.endsWith(`@${domain}`) || address.endsWith(`.${domain}`)
+      }
+      return false
+    })
+  if (filters.some(filter => SENDER_KINDS.has(filter.kind)) && addresses.length && addresses.every(senderMatches)) return true
+  return filters.some(filter => {
+    const value = filter.value.toLowerCase()
+    if (filter.kind === 'subjectPrefix') return subject.startsWith(value)
+    if (filter.kind === 'subjectContains') return subject.includes(value)
+    if (filter.kind === 'messagePrefix') return text.startsWith(value)
+    return false
+  })
+}

package/lib/mailbox.ts

@@ -13,6 +13,10 @@ import { hashPassword } from './password'
 import { duration, type ParsedQuery } from '@/app/mail/search'
 import { turso, tursoBatch, tursoQuery } from './turso'
 import { subjectKey, threadIdFor, THREAD_GAP_MS } from './threads'
+import { inboxFiltersSql, normalizeInboxFilters, type InboxFilter } from './inbox-filters'
+import { judgeMessage, senderDomainOf, type Risk, type RiskJudgement, type RiskSignals, type SenderStanding } from './risk'
+
+export { judgeMessage, senderDomainOf, type Risk, type RiskJudgement, type RiskSignals, type SenderStanding }
 
 export type InboundAttachment = { filename: string; contentType?: string; size?: number; shareId?: string }
 
@@ -386,6 +390,7 @@ export function ensureMailSchema(): Promise<void> {
       await sqlRaw("ALTER TABLE mail_inbox ADD COLUMN spam INTEGER NOT NULL DEFAULT 0").catch(() => {})
       await sqlRaw("CREATE INDEX IF NOT EXISTS mail_inbox_spam_idx ON mail_inbox (lower(owner), spam, received_at DESC)").catch(() => {})
       await sqlRaw("ALTER TABLE mail_inbox ADD COLUMN risk_reasons TEXT").catch(() => {})
+      await sqlRaw('ALTER TABLE mail_sender_reputation ADD COLUMN trusted INTEGER NOT NULL DEFAULT 0').catch(() => {})
       // The row in the list follows its newest message, so the conversation carries it too.
       await sqlRaw("ALTER TABLE mail_threads ADD COLUMN addressed TEXT").catch(() => {})
       // Worst verdict in the conversation, so a warning cannot hide behind a later reply.
@@ -454,30 +459,47 @@ export function ensureMailSchema(): Promise<void> {
 
 // ── Inbox ──────────────────────────────────────────────────────
 
-export type SenderStanding = {
-  received: number
-  trashed: number
-  markedSpam: number
-  replied: number
-  firstSeen: string | null
+
+const domainMatch = (domain: string) => {
+  const host = domain.toLowerCase()
+  return {
+    sql: "(lower(from_addr) LIKE ? OR lower(from_addr) LIKE ? OR lower(from_addr) LIKE ? OR lower(from_addr) LIKE ?)",
+    args: [`%@${host}`, `%@${host}>`, `%.${host}`, `%.${host}>`],
+  }
+}
+
+// The counters began long after the history they sit beside, so years of imported mail would
+// read as a stranger's first message. The stored mail itself says when a domain first wrote.
+async function earliestFrom(domain: string): Promise<string | null> {
+  const match = domainMatch(domain)
+  const rows = await tagged(db(), `SELECT MIN(received_at) AS first FROM mail_inbox WHERE ${match.sql}`, match.args)
+  return rows[0]?.first == null ? null : String(rows[0].first)
 }
 
 /** What this mailbox has done with this sender's domain before. */
-export async function senderStanding(owner: string | null, domain: string): Promise<SenderStanding> {
-  const empty = { received: 0, trashed: 0, markedSpam: 0, replied: 0, firstSeen: null }
+export async function senderStanding(
+  owner: string | null,
+  domain: string,
+  earliestCache?: Map<string, string | null>,
+): Promise<SenderStanding> {
+  const empty = { received: 0, trashed: 0, markedSpam: 0, replied: 0, trusted: false, firstSeen: null }
   if (!owner || !domain) return empty
   await ensureMailSchema()
   const rows = await db()`
-    SELECT received, trashed, marked_spam, replied, first_seen FROM mail_sender_reputation
+    SELECT received, trashed, marked_spam, replied, trusted, first_seen FROM mail_sender_reputation
     WHERE owner = ${owner.toLowerCase()} AND domain = ${domain.toLowerCase()}`
   const row = rows[0]
-  if (!row) return empty
+  const key = domain.toLowerCase()
+  const earliest = earliestCache?.has(key) ? earliestCache.get(key)! : await earliestFrom(key)
+  earliestCache?.set(key, earliest)
+  const counted = row?.first_seen == null ? null : String(row.first_seen)
   return {
-    received: Number(row.received ?? 0),
-    trashed: Number(row.trashed ?? 0),
-    markedSpam: Number(row.marked_spam ?? 0),
-    replied: Number(row.replied ?? 0),
-    firstSeen: row.first_seen == null ? null : String(row.first_seen),
+    received: Number(row?.received ?? 0),
+    trashed: Number(row?.trashed ?? 0),
+    markedSpam: Number(row?.marked_spam ?? 0),
+    replied: Number(row?.replied ?? 0),
+    trusted: Boolean(Number(row?.trusted ?? 0)),
+    firstSeen: [counted, earliest].filter((value): value is string => Boolean(value)).sort()[0] ?? null,
   }
 }
 
@@ -504,189 +526,6 @@ export async function noteSender(
       last_seen = ${now}`
 }
 
-/** What the scanners and the sender's own domain said. */
-export type Risk = 'clean' | 'suspicious' | 'spam' | 'virus'
-
-export type RiskSignals = {
-  spam?: string | null
-  virus?: string | null
-  spf?: string | null
-  dkim?: string | null
-  dmarc?: string | null
-  /** The message itself, for the tells authentication cannot see. */
-  from?: string | null
-  replyTo?: string[] | null
-  subject?: string | null
-  text?: string | null
-}
-
-/** Defaults only. Each is overridable per deployment, so a list can change without a
- *  release — metroperil can drop a word its own trade uses every day. */
-const FREE_MAIL_DEFAULT = new Set([
-  'gmail.com', 'googlemail.com', 'yahoo.com', 'ymail.com', 'hotmail.com', 'outlook.com',
-  'live.com', 'aol.com', 'protonmail.com', 'proton.me', 'mail.com', 'gmx.com', 'yandex.com',
-  'icloud.com', 'zoho.com', 'inbox.lv', 'consultant.com', 'qq.com', '163.com',
-])
-
-const THROWAWAY_TLDS_DEFAULT = new Set([
-  'xyz', 'top', 'buzz', 'click', 'link', 'work', 'gq', 'cf', 'ml', 'tk', 'ga',
-  'loan', 'men', 'date', 'racing', 'win', 'stream', 'download', 'review', 'country', 'kim',
-])
-
-/** The shape of an advance-fee approach. Counted, never single-word: one alone is innocent. */
-// Only wording that is odd in ordinary business correspondence belongs here. A single
-// generic term is not evidence of anything: an insurance broker writes "beneficiary" and
-// "bank draft" all day, a logistics firm writes "consignment", and every sales team sends
-// a "business proposal". Add them per deployment through MAIL_SCAM_PHRASES if a mailbox
-// genuinely never sees them.
-const SCAM_PHRASES_DEFAULT = [
-  'next of kin', 'sole beneficiary', 'late client', 'deceased client',
-  'inheritance', 'died without', 'without a will', 'unclaimed inheritance',
-  'winning notification', 'lottery winner', 'western union', 'atm card',
-  'transfer to your account immediately', 'strictly confidential and urgent',
-]
-
-/** The registrable domain behind an address, for reputation to be keyed on. */
-export const senderDomainOf = (address: string): string => registrable(domainOf(address))
-
-const domainOf = (address: string): string => {
-  const angled = address.match(/<([^>]+)>/)
-  const bare = (angled ? angled[1] : address).trim().toLowerCase()
-  return bare.split('@').pop() ?? ''
-}
-
-/** example.co.uk and example.com both reduce to the name somebody actually registered. */
-const registrable = (host: string): string => {
-  const parts = host.split('.').filter(Boolean)
-  if (parts.length <= 2) return parts.join('.')
-  const twoLevel = /^(co|com|org|net|gov|ac|edu|ltd|plc)\.[a-z]{2}$/.test(parts.slice(-2).join('.'))
-  return parts.slice(twoLevel ? -3 : -2).join('.')
-}
-
-const failed = (verdict: string | null | undefined): boolean =>
-  typeof verdict === 'string' && /^(fail|softfail|permerror)$/i.test(verdict.trim())
-
-const listFrom = (raw: string | undefined, fallback: Iterable<string>): Set<string> => {
-  const parsed = (raw ?? '').split(',').map(entry => entry.trim().toLowerCase()).filter(Boolean)
-  return parsed.length ? new Set(parsed) : new Set(fallback)
-}
-
-// Read per call, so a deployment can change any of them without a release.
-const freeProviders = () => listFrom(process.env.MAIL_FREE_PROVIDERS, FREE_MAIL_DEFAULT)
-const throwawayTlds = () => listFrom(process.env.MAIL_THROWAWAY_TLDS, THROWAWAY_TLDS_DEFAULT)
-
-// Bulk senders put their own bounce domain in From and the real correspondent in Reply-To.
-// That is how the campaign gets replies, not an attempt to redirect them somewhere unexpected.
-const BULK_SENDERS_DEFAULT = new Set([
-  'mailchimpapp.com', 'mcsv.net', 'rsgsv.net', 'mailchimp.com',
-  'sendgrid.net', 'sendgrid.com', 'sparkpostmail.com', 'amazonses.com',
-  'mailgun.org', 'mandrillapp.com', 'postmarkapp.com', 'sendinblue.com',
-  'brevo.com', 'constantcontact.com', 'cmail19.com', 'createsend.com',
-  'hubspotemail.net', 'mailerlite.com', 'klaviyomail.com', 'salesforce.com',
-])
-const bulkSenders = () => listFrom(process.env.MAIL_BULK_SENDERS, BULK_SENDERS_DEFAULT)
-const scamPhrases = () => [...listFrom(process.env.MAIL_SCAM_PHRASES, SCAM_PHRASES_DEFAULT)]
-
-/** Weight at which a message stops being labelled and is held out of the inbox instead. */
-const quarantineAt = () => Number(process.env.MAIL_SPAM_THRESHOLD ?? 6)
-
-/** Below this nothing is said at all. One small oddity is not a case. */
-const flagAt = () => Number(process.env.MAIL_SUSPICION_THRESHOLD ?? 3)
-
-export type RiskJudgement = { risk: Risk; reasons: string[]; score: number; quarantine: boolean }
-
-/**
- * What this mailbox knows, then what is true of the message. The standing a sender has
- * built here leads: somebody you have written back to is not spam because their subject
- * shouts, and somebody whose mail you have binned repeatedly does not get the benefit of
- * the doubt again. The fixed rules only decide the cases with no history to go on, and
- * every one of their lists can be changed per deployment without a release.
- */
-export function judgeMessage(signals: RiskSignals, standing: SenderStanding): RiskJudgement {
-  const reasons: string[] = []
-  let score = 0
-  // A finding is "telling" when it is hard to trip by accident. Failing an authentication
-  // check or shouting in the subject line is neither: ordinary mail does both. Holding a
-  // message back takes at least one finding of the first kind, however the weights add up.
-  let telling = 0
-  const add = (weight: number, why: string, isTelling = false) => {
-    score += weight
-    if (isTelling) telling += 1
-    reasons.push(why)
-  }
-
-  if (/^fail$/i.test((signals.virus ?? '').trim())) {
-    return { risk: 'virus', reasons: ['A virus scan failed on this message'], score: 100, quarantine: true }
-  }
-
-  // Trust is earned by being written back to, never by volume alone: a sender whose mail
-  // arrives forty times and is binned every time has not earned anything.
-  const trusted = standing.replied > 0 && standing.markedSpam === 0
-  if (standing.markedSpam > 0) {
-    add(4 + Math.min(standing.markedSpam, 4),
-      `You marked ${standing.markedSpam} earlier message${standing.markedSpam === 1 ? '' : 's'} from this sender as spam`, true)
-  } else if (standing.trashed >= 3 && standing.replied === 0) {
-    add(3, `You have deleted ${standing.trashed} messages from this sender without ever replying`, true)
-  }
-
-  if (/^fail$/i.test((signals.spam ?? '').trim())) add(4, 'The provider\u2019s spam filter flagged this message', true)
-
-  const authenticated = /^pass$/i.test((signals.dmarc ?? '').trim())
-  // Heavy, but not enough on its own to hide a message: mail forwarded through a list
-  // breaks alignment and fails DMARC while being perfectly legitimate. It warns loudly;
-  // it takes a second finding to put a message out of sight.
-  if (failed(signals.dmarc)) add(4, 'The sending domain says this message is not from them (DMARC failed)')
-  else if (!authenticated) {
-    if (failed(signals.spf)) add(2, 'The sending server is not authorised by that domain (SPF failed)')
-    if (failed(signals.dkim)) add(2, 'The signature does not match the sending domain (DKIM failed)')
-  }
-
-  const fromDomain = registrable(domainOf(signals.from ?? ''))
-  const replyDomains = (signals.replyTo ?? [])
-    .map(entry => registrable(domainOf(entry)))
-    .filter(entry => entry && entry !== fromDomain)
-  const free = freeProviders()
-  const freeReply = replyDomains.find(entry => free.has(entry))
-  const bulk = bulkSenders().has(fromDomain)
-  if (bulk) {
-    // Nothing to say: a campaign's replies are meant to land somewhere other than the
-    // sending platform, and treating that as misdirection buries ordinary bulk mail.
-  } else if (freeReply && fromDomain && !free.has(fromDomain)) {
-    add(4, `Replies to this message go to ${freeReply}, not to ${fromDomain}`, true)
-  } else if (replyDomains.length) {
-    add(1, `Replies go to ${replyDomains[0]} rather than ${fromDomain || 'the sender'}`)
-  }
-
-  const tld = fromDomain.split('.').pop() ?? ''
-  if (throwawayTlds().has(tld)) add(2, `The sender\u2019s domain ends in .${tld}, which is cheap to register and often disposable`, true)
-  if (/^\d{4,}$/.test(fromDomain.split('.')[0] ?? '')) add(2, 'The sender\u2019s domain name is just a string of digits', true)
-
-  const subject = (signals.subject ?? '').trim()
-  const letters = subject.replace(/[^A-Za-z]/g, '')
-  if (letters.length >= 12 && letters === letters.toUpperCase()) add(1, 'The subject is written entirely in capitals')
-
-  const body = (signals.text ?? '').toLowerCase()
-  const hits = scamPhrases().filter(phrase => body.includes(phrase))
-  if (hits.length >= 2) add(3, `The wording follows a known advance-fee approach (${hits.slice(0, 3).join(', ')})`, true)
-  else if (hits.length === 1) add(1, `Wording associated with advance-fee mail (${hits[0]})`)
-
-  // Never heard from before is not suspicious by itself — everyone writes once for the
-  // first time — but it is what turns a couple of small oddities into a pattern.
-  if (!trusted && standing.received <= 1 && score > 0) add(1, 'This is the first message from this sender')
-
-  // Someone this mailbox corresponds with is forgiven the small stuff; only findings heavy
-  // enough to stand on their own still count against them.
-  const limit = quarantineAt()
-  if (trusted && score < limit) return { risk: 'clean', reasons: [], score: 0, quarantine: false }
-
-  // One small oddity is not a case to answer. A subject in capitals from somebody writing
-  // for the first time is a stranger in a hurry, not a scam, and saying otherwise every
-  // time teaches the reader to ignore the warning.
-  if (score < flagAt()) return { risk: 'clean', reasons: [], score, quarantine: false }
-
-  const quarantine = score >= limit && telling > 0
-  return { risk: quarantine ? 'spam' : 'suspicious', reasons, score, quarantine }
-}
 
 
 /** How the mailbox came to hold a message, from that mailbox's own point of view. */
@@ -1183,13 +1022,23 @@ async function rethreadAfterChange(id: string, previousOwner?: string | null, pr
   }
 }
 
-export type ThreadFolder = 'inbox' | 'archive' | 'trash' | 'starred' | 'snoozed' | 'spam'
+export type ThreadFolder = 'inbox' | 'archive' | 'trash' | 'starred' | 'snoozed' | 'spam' | 'filtered'
 
 /** The newest conversations in a folder: one row each, already summarised. */
 export type ThreadPage = { rows: ThreadRow[]; nextCursor: string | null }
 
-export async function listThreads(ownerRaw: string | null, folder: ThreadFolder, limit: number, cursorRaw?: string | null): Promise<ThreadPage> {
-  await ensureMailSchema()
+export async function listThreads(
+  ownerRaw: string | null,
+  folder: ThreadFolder,
+  limit: number,
+  cursorRaw?: string | null,
+  filters: InboxFilter[] = [],
+): Promise<ThreadPage> {
+  await ensureMailSchema()
+  const filterSql = folder === 'inbox' || folder === 'filtered' ? inboxFiltersSql(filters) : null
+  if (folder === 'filtered' && !filterSql) return { rows: [], nextCursor: null }
+  const filterClause = filterSql ? (folder === 'filtered' ? filterSql.sql : `NOT ${filterSql.sql}`) : ''
+  const filterArgs = filterSql?.args ?? []
   const owner = ownerRaw === null ? null : ownerRaw.toLowerCase()
   const nowIso = new Date().toISOString()
   const predicate =
@@ -1201,7 +1050,7 @@ export async function listThreads(ownerRaw: string | null, folder: ThreadFolder,
     : 'inbox_count > 0 AND (snoozed_until IS NULL OR snoozed_until <= ?)'
   // Both snooze predicates carry one bound timestamp; the others carry none, and the
   // cursor's arguments have to follow whatever the predicate used.
-  const folderArgs = folder === 'snoozed' || folder === 'inbox' ? [nowIso] : []
+  const folderArgs = folder === 'snoozed' || folder === 'inbox' || folder === 'filtered' ? [nowIso] : []
   const cursor = decodeCursor(cursorRaw)
   const cursorClause = cursor ? '(latest_at < ? OR (latest_at = ? AND thread_id < ?))' : ''
   const cursorArgs = cursor ? [cursor.receivedAt, cursor.receivedAt, cursor.id] : []
@@ -1209,25 +1058,28 @@ export async function listThreads(ownerRaw: string | null, folder: ThreadFolder,
   // conversation back together. SQLite fills a bare column from whichever row matched the
   // MAX in the same select, which is how subject, snippet and senders come from the latest
   // message rather than an arbitrary one.
+  const outer = [filterClause, cursorClause].filter(Boolean).join(' AND ')
   const rows = owner === null
     ? await tagged(db(), `
-        SELECT thread_id, subject, MIN(first_at) AS first_at, MAX(latest_at) AS latest_at, latest_id,
-          SUM(count) AS count, SUM(unread_count) AS unread_count, SUM(starred_count) AS starred_count,
-          SUM(inbox_count) AS inbox_count, SUM(archived_count) AS archived_count,
-          SUM(trashed_count) AS trashed_count, SUM(spam_count) AS spam_count, SUM(attach_count) AS attach_count,
-          senders, snippet, labels, snoozed_until, addressed, risk
-        FROM mail_threads
-        GROUP BY thread_id
-        HAVING ${predicate}${cursorClause ? ` AND ${cursorClause}` : ''}
+        SELECT * FROM (
+          SELECT thread_id, subject, MIN(first_at) AS first_at, MAX(latest_at) AS latest_at, latest_id,
+            SUM(count) AS count, SUM(unread_count) AS unread_count, SUM(starred_count) AS starred_count,
+            SUM(inbox_count) AS inbox_count, SUM(archived_count) AS archived_count,
+            SUM(trashed_count) AS trashed_count, SUM(spam_count) AS spam_count, SUM(attach_count) AS attach_count,
+            senders, snippet, labels, snoozed_until, addressed, risk
+          FROM mail_threads
+          GROUP BY thread_id
+          HAVING ${predicate}
+        ) t${outer ? ` WHERE ${outer}` : ''}
         ORDER BY latest_at DESC, thread_id DESC LIMIT ?`,
-        [...folderArgs, ...cursorArgs, limit])
+        [...folderArgs, ...filterArgs, ...cursorArgs, limit])
     : await tagged(db(), `
         SELECT thread_id, subject, first_at, latest_at, latest_id, count, unread_count, starred_count,
           inbox_count, archived_count, trashed_count, spam_count, attach_count, senders, snippet, labels, snoozed_until, addressed, risk
-        FROM mail_threads WHERE owner = ? AND ${predicate}
-          ${cursorClause ? `AND ${cursorClause}` : ''}
+        FROM mail_threads t WHERE owner = ? AND ${predicate}
+          ${outer ? `AND ${outer}` : ''}
         ORDER BY latest_at DESC, thread_id DESC LIMIT ?`,
-        [owner, ...folderArgs, ...cursorArgs, limit])
+        [owner, ...folderArgs, ...filterArgs, ...cursorArgs, limit])
   const last = rows[rows.length - 1]
   const nextCursor = rows.length === limit && last ? encodeCursor(String(last.latest_at), String(last.thread_id)) : null
   const mapped = rows.map(row => ({
@@ -1254,6 +1106,27 @@ export async function listThreads(ownerRaw: string | null, folder: ThreadFolder,
   return { rows: mapped, nextCursor }
 }
 
+/** Inbox conversations the rules hold out, and how many of those have unread mail. */
+export async function countFilteredThreads(ownerRaw: string | null, filters: InboxFilter[]): Promise<{ total: number; unread: number }> {
+  const filterSql = inboxFiltersSql(filters)
+  if (!filterSql) return { total: 0, unread: 0 }
+  await ensureMailSchema()
+  const nowIso = new Date().toISOString()
+  const inbox = 'inbox_count > 0 AND (snoozed_until IS NULL OR snoozed_until <= ?)'
+  const rows = ownerRaw === null
+    ? await tagged(db(), `
+        SELECT COUNT(*) AS total, SUM(CASE WHEN unread_count > 0 THEN 1 ELSE 0 END) AS unread FROM (
+          SELECT thread_id, SUM(unread_count) AS unread_count, SUM(inbox_count) AS inbox_count, snoozed_until, senders, subject, snippet, MAX(latest_at)
+          FROM mail_threads GROUP BY thread_id HAVING ${inbox}
+        ) t WHERE ${filterSql.sql}`,
+        [nowIso, ...filterSql.args])
+    : await tagged(db(), `
+        SELECT COUNT(*) AS total, SUM(CASE WHEN unread_count > 0 THEN 1 ELSE 0 END) AS unread
+        FROM mail_threads t WHERE owner = ? AND ${inbox} AND ${filterSql.sql}`,
+        [ownerRaw.toLowerCase(), nowIso, ...filterSql.args])
+  return { total: Number(rows[0]?.total ?? 0), unread: Number(rows[0]?.unread ?? 0) }
+}
+
 /**
  * Backfill, phase one: give every message a thread id, oldest first so the thirty-day
  * rule holds for history. Summaries are left for the second phase, so each thread is
@@ -1337,7 +1210,7 @@ export async function appendInbound(
  * labels and owner are the reader's, not the repair's, and a row that already has a body
  * is left exactly as it is.
  */
-export async function rejudgeStored(options: { before?: string; limit?: number } = {}): Promise<{
+export async function rejudgeStored(options: { before?: string; limit?: number; flaggedOnly?: boolean } = {}): Promise<{
   scanned: number
   changed: number
   quarantined: number
@@ -1351,7 +1224,7 @@ export async function rejudgeStored(options: { before?: string; limit?: number }
     SELECT id, owner, from_addr, reply_to, subject, body_text, headers, received_at,
            read, starred, archived, trashed, risk, spam
     FROM mail_inbox
-    WHERE received_at < ${before}
+    WHERE received_at < ${before} AND (${options.flaggedOnly ? 1 : 0} = 0 OR coalesce(risk, 'clean') != 'clean')
     ORDER BY received_at DESC
     LIMIT ${limit}`
 
@@ -1360,6 +1233,7 @@ export async function rejudgeStored(options: { before?: string; limit?: number }
   result.cursor = String(rows[rows.length - 1].received_at ?? '')
 
   const standings = new Map<string, SenderStanding>()
+  const earliest = new Map<string, string | null>()
   const touchedOwners = new Set<string>()
   for (const row of rows) {
     const owner = String(row.owner ?? '')
@@ -1367,7 +1241,7 @@ export async function rejudgeStored(options: { before?: string; limit?: number }
     const key = `${owner.toLowerCase()}\u0000${senderDomain}`
     let standing = standings.get(key)
     if (!standing) {
-      standing = await senderStanding(owner, senderDomain)
+      standing = await senderStanding(owner, senderDomain, earliest)
       standings.set(key, standing)
     }
 
@@ -1384,6 +1258,7 @@ export async function rejudgeStored(options: { before?: string; limit?: number }
       replyTo: parseJson<string[]>(row.reply_to, []),
       subject: String(row.subject ?? ''),
       text: row.body_text == null ? null : String(row.body_text),
+      receivedAt: String(row.received_at ?? ''),
     }, standing)
 
     // A message the reader has already read, starred, filed or binned stays exactly where
@@ -1718,6 +1593,30 @@ export async function setInboundSpam(id: string, spam: boolean): Promise<void> {
   await rethreadAfterChange(id)
 }
 
+/** Trusts the sender of one message for its mailbox, and lifts the warnings already on their mail there. */
+export async function trustSenderOf(id: string): Promise<string[]> {
+  await ensureMailSchema()
+  const sql = db()
+  const rows = await sql`SELECT owner, from_addr FROM mail_inbox WHERE id = ${id}`
+  const owner = rows[0]?.owner == null ? '' : String(rows[0].owner).toLowerCase()
+  const domain = senderDomainOf(String(rows[0]?.from_addr ?? ''))
+  if (!owner || !domain) return []
+  const now = nowIso()
+  await sql`
+    INSERT INTO mail_sender_reputation (owner, domain, trusted, first_seen, last_seen)
+    VALUES (${owner}, ${domain}, 1, ${now}, ${now})
+    ON CONFLICT (owner, domain) DO UPDATE SET trusted = 1, marked_spam = 0`
+  const match = domainMatch(domain)
+  const flagged = await tagged(sql, `SELECT id FROM mail_inbox WHERE lower(owner) = ? AND risk = 'suspicious' AND ${match.sql}`, [owner, ...match.args])
+  const ids = flagged.map(row => String(row.id))
+  for (const flaggedId of ids) {
+    await sql`UPDATE mail_inbox SET risk = 'clean', risk_reasons = '[]' WHERE id = ${flaggedId}`
+    await rethreadAfterChange(flaggedId)
+  }
+  await invalidateCounts(owner)
+  return ids
+}
+
 export async function setInboundFlags(id: string, flags: InboundFlags): Promise<void> {
   const sql = db()
   if (flags.read !== undefined) await sql`UPDATE mail_inbox SET read = ${flags.read} WHERE id = ${id}`
@@ -1906,6 +1805,10 @@ export async function getSettings(owner: string): Promise<Record<string, unknown
   return parseJson<Record<string, unknown>>(rows[0]?.data, {})
 }
 
+export async function inboxFiltersFor(login: string): Promise<InboxFilter[]> {
+  return normalizeInboxFilters((await getSettings(login)).inboxFilters)
+}
+
 export async function setSettings(owner: string, data: Record<string, unknown>): Promise<void> {
   await ensureMailSchema()
   const sql = db()