@withbuddi/buddi 0.1.0-pre.42 → 0.1.0-pre.44

package/node_modules/@buddi/tool-email/dist/pages/queries.js

@@ -23,7 +23,7 @@ import { QueryRefusal } from '@buddi/core/plugin';
 import { POLL_EVERY_SECONDS, TRIAGE_AGENT_ID } from '../sources/inbox-poll.js';
 import { idleLive } from '../sources/idle.js';
 import { booleanFilter, buildSearch, narrows, toSearchRow, validateFilters, windowNote, } from '../search.js';
-import { lastSyncByAccount, listAccounts } from '../config.js';
+import { lastSyncedByAccount, listAccounts } from '../config.js';
 import { ACCOUNT_KIND } from '../credentials.js';
 import { attentionReasons, findThread, listThreadRows, threadMessages } from '../threads.js';
 import { attentionLine, reasonOf, viewOf } from '../needs-you.js';
@@ -34,6 +34,7 @@ import { loadWatcherSettings, DEFAULT_WATCHER_SETTINGS } from '../watchers.js';
 import { draftStatusLine, isoOf, policyLine, relative } from './format.js';
 import { describeUndo, movedSince, plural, recentActions, undoRefusal, verbOf } from '../mailbox/actions.js';
 import { learnedRules } from '../policies/auto.js';
+import { ACTION_COLUMNS, SEEN, toAction } from '../mailbox/actions.js';
 /** How many conversations the list shows before the owner narrows it. */
 export const THREAD_LIST_LIMIT = 30;
 /** How many messages of a conversation the page draws. The newest ones. */
@@ -80,6 +81,11 @@ export function attachmentRows(messageId, raw) {
             line: `${filename} — ${detail}`,
             artifactId: a.artifactId ?? null,
             held: a.artifactId ? 'in your files' : 'not fetched',
+            // The `message` component's own words for the same file (host API 1.30).
+            name: filename,
+            size: Number.isFinite(size) ? size : 0,
+            mime: a.mime ?? 'application/octet-stream',
+            contentId: typeof a.contentId === 'string' && a.contentId !== '' ? a.contentId : null,
         };
     });
 }
@@ -109,8 +115,14 @@ export function formatBytes(bytes) {
 export const MAX_BODY_BYTES = 512 * 1024;
 /** The sentence a cut body ends with. Said once, so a test can name it. */
 export const TRUNCATED_NOTE = '… this message is too long to show in full; the rest is in your mailbox.';
-export function truncateBody(text) {
-    if (Buffer.byteLength(text, 'utf8') <= MAX_BODY_BYTES)
+/**
+ * How much of the plain text rides along when there is an HTML body too: the
+ * text is then only the fallback, and the answer must stay under the
+ * engine's megabyte with both in it.
+ */
+export const TEXT_WITH_HTML_BYTES = 64 * 1024;
+export function truncateBody(text, max = MAX_BODY_BYTES) {
+    if (Buffer.byteLength(text, 'utf8') <= max)
         return text;
     /*
      * Cut on a character boundary: slicing bytes can land in the middle of a
@@ -118,12 +130,12 @@ export function truncateBody(text) {
      * end of every long message. Decoding the slice leaves that partial
      * character as U+FFFD, which is exactly what is trimmed off here.
      */
-    const bytes = Buffer.from(text, 'utf8').subarray(0, MAX_BODY_BYTES);
+    const bytes = Buffer.from(text, 'utf8').subarray(0, max);
     const whole = new TextDecoder('utf-8').decode(bytes).replace(/\uFFFD+$/, '');
     return `${whole}\n\n${TRUNCATED_NOTE}`;
 }
 /** A draft as the editor and the draft list read it. Never a patch: all of it. */
-function draftRow(draft, now) {
+function draftRow(draft, now, fromAddress) {
     const live = LIVE_DRAFT_STATUSES.includes(draft.status) && draft.sentActionId === null;
     // Dispatched, never confirmed: the one state where nothing may be done to it
     // until somebody has looked in the mailbox.
@@ -153,6 +165,17 @@ function draftRow(draft, now) {
         notLiveLine: `This draft is ${draft.status} and cannot be edited or sent. It is kept so you can read what was proposed.`,
         unresolvedLine: unresolvedLine(draft.sendError),
         sendError: draft.sendError,
+        /*
+         * The reply as the reading pane shows it before anyone edits it: drawn
+         * the way a message is (host API 1.30), from the mailbox it will leave.
+         */
+        preview: {
+            from: { name: 'Your reply', address: fromAddress ?? draft.to[0] ?? 'you' },
+            to: draft.to.map((address) => ({ address })),
+            cc: draft.cc.map((address) => ({ address })),
+            at: draft.updatedAt,
+            text: draft.bodyText,
+        },
     };
 }
 /** What a dispatch that never came back says, with the server's own words. */
@@ -199,6 +222,7 @@ export function threadsQuery() {
             const { rows } = await ctx.buddi.db.query(`select distinct thread_id from email.drafts
           where thread_id = any($1::uuid[]) and status = any($2::text[])`, [threads.map((t) => t.id), [...LIVE_DRAFT_STATUSES]]);
             const withDraft = new Set(rows.map((r) => String(r.thread_id)));
+            const reading = await listReading(ctx.buddi.db, threads.map((t) => t.id));
             /*
              * Who the conversation is *with*: the first participant who is not one
              * of the owner's own addresses. The owner is on every thread, so the
@@ -206,34 +230,159 @@ export function threadsQuery() {
              */
             const own = new Set(accounts.flatMap((account) => [account.address, ...account.aliases]).map((address) => address.toLowerCase()));
             return {
-                threads: threads.map((thread) => ({
-                    id: thread.id,
-                    subject: thread.subject === '' ? '(no subject)' : thread.subject,
-                    sender: thread.participants.find((address) => !own.has(address.toLowerCase())) ??
+                threads: threads.map((thread) => {
+                    const sender = thread.participants.find((address) => !own.has(address.toLowerCase())) ??
                         thread.participants[0] ??
-                        '(nobody)',
-                    participants: thread.participants.join(', '),
-                    state: thread.state,
-                    /*
-                     * The state as the owner reads it (`needs-you.ts`): "Waiting on you"
-                     * only when the one rule says so. A notification and a message
-                     * nobody expects an answer to carry no pill at all — a word on every
-                     * row is how forty "Waiting on you" pills came to mean nothing.
-                     */
-                    attention: viewOf(reasons.get(thread.id) ?? reasonOf(null, thread.state)),
-                    pill: listPillOf(viewOf(reasons.get(thread.id) ?? reasonOf(null, thread.state))),
-                    // The "draft" pill sits *beside* the state, never in place of it: a
-                    // conversation that is waiting on the owner and has a reply written
-                    // for it is two facts, and the old page showed both.
-                    draftPill: withDraft.has(thread.id) ? 'draft' : '',
-                    when: relative(thread.lastAt, now),
-                    messageCount: thread.messageCount,
-                })),
+                        '(nobody)';
+                    const read = reading.get(thread.id);
+                    return {
+                        id: thread.id,
+                        subject: thread.subject === '' ? '(no subject)' : thread.subject,
+                        sender,
+                        /*
+                         * The person, not the address: the display name on their latest
+                         * message when they gave one (host API 1.30's reading pane), the
+                         * address otherwise.
+                         */
+                        senderName: read?.senderName && read.senderAddress?.toLowerCase() === sender.toLowerCase() ? read.senderName : sender,
+                        // What the conversation last said, on one line; the owner's own words say so.
+                        preview: read ? (read.lastOut ? `You: ${read.snippet}` : read.snippet) : '',
+                        unread: read?.unread ?? false,
+                        // Mail Triage's word for the latest message, as a chip: "Bill", "Receipt".
+                        tag: read?.category && read.category !== 'other' ? tagLabel(read.category) : '',
+                        participants: thread.participants.join(', '),
+                        state: thread.state,
+                        /*
+                         * The state as the owner reads it (`needs-you.ts`): "Waiting on you"
+                         * only when the one rule says so. A notification and a message
+                         * nobody expects an answer to carry no pill at all — a word on every
+                         * row is how forty "Waiting on you" pills came to mean nothing.
+                         */
+                        attention: viewOf(reasons.get(thread.id) ?? reasonOf(null, thread.state)),
+                        pill: listPillOf(viewOf(reasons.get(thread.id) ?? reasonOf(null, thread.state))),
+                        // The "draft" pill sits *beside* the state, never in place of it: a
+                        // conversation that is waiting on the owner and has a reply written
+                        // for it is two facts, and the old page showed both.
+                        draftPill: withDraft.has(thread.id) ? 'draft' : '',
+                        when: relative(thread.lastAt, now),
+                        messageCount: thread.messageCount,
+                    };
+                }),
                 ...hits,
             };
         },
     };
 }
+/** Triage's categories as a chip says them. Anything else reads as itself, capitalised. */
+const TAG_WORDS = {
+    'reply-needed': 'Reply needed',
+    'payment-failed': 'Payment failed',
+    'bank-notice': 'Bank',
+    'service-notice': 'Service',
+    promo: 'Promotion',
+};
+export function tagLabel(category) {
+    const known = TAG_WORDS[category];
+    if (known)
+        return known;
+    const words = category.replace(/-/g, ' ').trim();
+    return words === '' ? '' : words[0].toUpperCase() + words.slice(1);
+}
+/**
+ * What the list draws beside each conversation, in one read: how its last
+ * message opens, the name on the latest message they sent, whether anything
+ * they sent is still unread on the server (no `\Seen`, as the flag sync last
+ * saw it), and Mail Triage's latest category.
+ */
+async function listReading(db, ids) {
+    const out = new Map();
+    if (ids.length === 0)
+        return out;
+    const { rows } = await db.query(`select t.id,
+            lm.snippet, lm.direction as last_direction,
+            li.from_name, li.from_addr,
+            exists (select 1 from email.messages u
+                     where u.thread_id = t.id and u.direction = 'in'
+                       and not (coalesce(u.flags, '[]'::jsonb) ? $2)) as unread,
+            (select tr.category from email.triage tr
+              where tr.message_id = li.id
+              order by tr.decided_at desc, tr.processing_version desc limit 1) as category
+       from email.threads t
+       left join email.messages lm on lm.id = t.last_message_id
+       left join lateral (
+         select m.id, m.from_name, m.from_addr from email.messages m
+          where m.thread_id = t.id and m.direction = 'in'
+          order by coalesce(m.internal_date, m.fetched_at) desc, m.id desc limit 1
+       ) li on true
+      where t.id = any($1::uuid[])`, [ids, SEEN]);
+    for (const row of rows) {
+        out.set(String(row.id), {
+            snippet: String(row.snippet ?? ''),
+            lastOut: row.last_direction === 'out',
+            senderName: typeof row.from_name === 'string' && row.from_name.trim() !== '' ? row.from_name.trim() : null,
+            senderAddress: typeof row.from_addr === 'string' ? row.from_addr : null,
+            unread: row.unread === true,
+            category: typeof row.category === 'string' ? row.category : null,
+        });
+    }
+    return out;
+}
+/** One address as the `message` component reads it. */
+function addressRow(address, name) {
+    return name ? { address, name } : { address };
+}
+/**
+ * The parts of a conversation's reading pane that are buddi's rather than the
+ * mail's: Mail Triage's verdict on the latest message they sent, and what
+ * buddi changed in the mailbox about this conversation, newest first, with
+ * Undo where it still applies (the same rows and words as Recent changes).
+ */
+async function threadLayer(db, threadId, accountAddress, now) {
+    const verdict = await db.query(`select tr.category, tr.urgency, tr.summary, tr.action_needed, tr.decided_at
+       from email.triage tr
+       join lateral (
+         select m.id from email.messages m
+          where m.thread_id = $1::uuid and m.direction = 'in'
+          order by coalesce(m.internal_date, m.fetched_at) desc, m.id desc limit 1
+       ) li on li.id = tr.message_id
+      order by tr.decided_at desc, tr.processing_version desc limit 1`, [threadId]);
+    const v = verdict.rows[0];
+    const triage = v
+        ? {
+            category: String(v.category),
+            tag: tagLabel(String(v.category)),
+            urgency: String(v.urgency),
+            // "Bill · normal — The October invoice from Studio North, €1,240. To do: pay by 14 Oct."
+            line: [
+                `${tagLabel(String(v.category))} · ${v.urgency === 'urgent' ? 'urgent' : v.urgency === 'low' ? 'low' : 'this week'}`,
+                '—',
+                String(v.summary ?? '').trim(),
+                v.action_needed ? `To do: ${String(v.action_needed).trim()}` : '',
+            ]
+                .filter((part) => part !== '')
+                .join(' '),
+            when: relative(isoOf(v.decided_at), now),
+        }
+        : null;
+    const { rows } = await db.query(`select ${ACTION_COLUMNS_SQL} from email.mailbox_actions a
+      where a.message_ids && (select coalesce(array_agg(m.id), '{}') from email.messages m where m.thread_id = $1::uuid)
+      order by a.created_at desc, a.seq desc limit $2`, [threadId, THREAD_CHANGES]);
+    const changes = [];
+    for (const c of rows.map(toAction)) {
+        const undoable = undoRefusal(c) === null;
+        const moved = undoable ? await movedSince(db, c) : 0;
+        const who = c.origin === 'policy' ? `by ${c.actor}` : c.origin === 'owner' ? 'by you' : c.actor === TRIAGE_AGENT_ID ? 'by Mail Triage' : `by @${c.actor}`;
+        changes.push({
+            id: c.id,
+            // The words Recent changes uses: "Mark as read · by Mail Triage · yesterday".
+            line: [verbOf(c.kind, c.destination), who, relative(c.createdAt, now), c.note ?? ''].filter((p) => p !== '').join(' · '),
+            state: changeState(c),
+            undoable,
+            undoLine: describeUndo(c, accountAddress, moved),
+        });
+    }
+    return { triage, changes };
+}
 /**
  * The list's pill for a conversation: the views that are worth a word.
  * A notification and "they wrote" are the inbox's ordinary weather and say
@@ -302,6 +451,26 @@ async function searchHits(ctx, input, ids) {
         ...(built.windowed && built.windowFrom ? { window: windowNote(built.windowFrom) } : {}),
     };
 }
+/** How many of buddi's changes a reading pane lists for one conversation. */
+export const THREAD_CHANGES = 3;
+const ACTION_COLUMNS_SQL = ACTION_COLUMNS.split(',').map((c) => `a.${c.trim()}`).join(', ');
+/** The display name, the server's own arrival time and the read mark of each message, by id. */
+async function messageExtras(db, ids) {
+    const out = new Map();
+    if (ids.length === 0)
+        return out;
+    const { rows } = await db.query(`select id, from_name, coalesce(internal_date, fetched_at) as at, direction,
+            coalesce(flags, '[]'::jsonb) ? $2 as seen
+       from email.messages where id = any($1::uuid[])`, [ids, SEEN]);
+    for (const row of rows) {
+        out.set(String(row.id), {
+            fromName: typeof row.from_name === 'string' && row.from_name.trim() !== '' ? row.from_name.trim() : null,
+            at: isoOf(row.at),
+            unread: row.direction === 'in' && row.seen !== true,
+        });
+    }
+    return out;
+}
 /**
  * One conversation: its messages' snippets, then the drafts under them.
  *
@@ -327,8 +496,23 @@ export function threadQuery() {
             const live = drafts.filter((d) => LIVE_DRAFT_STATUSES.includes(d.status));
             const older = drafts.filter((d) => !LIVE_DRAFT_STATUSES.includes(d.status));
             const latest = messages[messages.length - 1] ?? null;
+            const accounts = await listAccounts(ctx.buddi.db, { enabledOnly: false });
+            const account = accounts.find((a) => a.id === thread.accountId);
+            const layer = await threadLayer(ctx.buddi.db, thread.id, account?.address ?? 'your mailbox', now);
+            const extra = await messageExtras(ctx.buddi.db, messages.map((m) => m.id));
+            const view = viewOf(reason);
             return {
                 id: thread.id,
+                /*
+                 * buddi's layer above the thread (host API 1.30's reading pane): the
+                 * verdict, what was changed and Undo, and "Needs a reply" with Done.
+                 */
+                hasTriage: layer.triage !== null,
+                triage: layer.triage,
+                triageLine: layer.triage ? String(layer.triage.line) : '',
+                changes: layer.changes,
+                hasChanges: layer.changes.length > 0,
+                needsReply: view === 'needs-you',
                 subject: thread.subject === '' ? '(no subject)' : thread.subject,
                 state: thread.state,
                 attention: viewOf(reason),
@@ -337,32 +521,41 @@ export function threadQuery() {
                 participants: thread.participants.join(', '),
                 lastAt: thread.lastAt,
                 messageCount: thread.messageCount,
-                messages: messages.map((message) => ({
-                    id: message.id,
-                    from: message.from,
-                    snippet: message.snippet,
-                    who: message.direction === 'out' ? 'you wrote' : 'they wrote',
-                    when: relative(message.date, now),
-                    // Where it is now when that is not the inbox: archived, in Trash,
-                    // in a label, or no longer in the inbox (moved in another app).
-                    place: message.place,
-                    // One line, because a repeated component draws text and formats
-                    // nothing: who wrote it, when, where it is now, and what it opens with.
-                    summary: [
-                        message.from,
-                        message.direction === 'out' ? 'you wrote' : 'they wrote',
-                        relative(message.date, now),
-                        message.place,
-                    ]
-                        .filter((part) => part !== '')
-                        .join(' · ') + (message.snippet ? ` — ${message.snippet}` : ''),
-                })),
+                messages: messages.map((message, index) => {
+                    const more = extra.get(message.id);
+                    return {
+                        id: message.id,
+                        // The header the reading pane draws before the body arrives (`message`).
+                        from: addressRow(message.from, more?.fromName),
+                        to: message.to.map((address) => addressRow(address)),
+                        at: more?.at ?? message.date,
+                        // Every message but the newest is one line until it is opened, unless the owner has not read it.
+                        folded: index < messages.length - 1 && !(more?.unread ?? false),
+                        fromAddress: message.from,
+                        snippet: message.snippet,
+                        who: message.direction === 'out' ? 'you wrote' : 'they wrote',
+                        when: relative(message.date, now),
+                        // Where it is now when that is not the inbox: archived, in Trash,
+                        // in a label, or no longer in the inbox (moved in another app).
+                        place: message.place,
+                        // One line, because a repeated component draws text and formats
+                        // nothing: who wrote it, when, where it is now, and what it opens with.
+                        summary: [
+                            message.from,
+                            message.direction === 'out' ? 'you wrote' : 'they wrote',
+                            relative(message.date, now),
+                            message.place,
+                        ]
+                            .filter((part) => part !== '')
+                            .join(' · ') + (message.snippet ? ` — ${message.snippet}` : ''),
+                    };
+                }),
                 latestMessageId: latest?.id ?? null,
                 hasMessages: messages.length > 0,
                 hasDraft: live.length > 0,
                 // Every live draft: the page draws an editor per row, so each row is
                 // the whole envelope rather than a line about one.
-                drafts: live.map((draft) => draftRow(draft, now)),
+                drafts: live.map((draft) => draftRow(draft, now, account?.address)),
                 hasOlder: older.length > 0,
                 older: older.map((draft) => ({
                     id: draft.id,
@@ -401,8 +594,9 @@ export function messageQuery() {
         params: byId,
         async produce(params, ctx) {
             const { id } = params;
-            const { rows } = await ctx.buddi.db.query(`select m.id, m.from_addr, m.to_addrs, m.cc, m.subject, m.date, m.direction,
-                m.body_text, m.body_purged_at, m.attachments
+            const { rows } = await ctx.buddi.db.query(`select m.id, m.from_addr, m.from_name, m.to_addrs, m.cc, m.subject, m.date, m.direction,
+                m.body_text, m.body_html, m.body_purged_at, m.attachments, m.snippet,
+                coalesce(m.internal_date, m.fetched_at) as at
            from email.messages m
            join email.accounts a on a.id = m.account_id
           where m.id = $1::uuid`, [id]);
@@ -411,20 +605,35 @@ export function messageQuery() {
                 throw new QueryRefusal('No message here has that id.');
             const messageId = String(row.id);
             const purged = row.body_purged_at !== null;
-            const body = purged
-                ? 'The body of this message has been purged under your retention setting. Its headers are kept.'
-                : truncateBody(String(row.body_text ?? ''));
+            const purgedNote = 'The body of this message has been purged under your retention setting. Its headers are kept.';
+            const html = !purged && typeof row.body_html === 'string' && row.body_html !== '' ? row.body_html : null;
+            const text = purged ? '' : truncateBody(String(row.body_text ?? ''), html ? TEXT_WITH_HTML_BYTES : MAX_BODY_BYTES);
+            const toList = Array.isArray(row.to_addrs) ? row.to_addrs : [];
+            const ccList = Array.isArray(row.cc) ? row.cc : [];
             return {
                 id: messageId,
-                from: row.from_addr,
-                to: (Array.isArray(row.to_addrs) ? row.to_addrs : []).join(', '),
-                cc: (Array.isArray(row.cc) ? row.cc : []).join(', '),
+                /*
+                 * The `message` component's shape (host API 1.30): who, to whom,
+                 * when (the server's arrival time, as the thread orders by), the
+                 * stored HTML — sanitised at ingest, and again by the dashboard — and
+                 * the text it falls back to. Never anything fetched now.
+                 */
+                from: addressRow(String(row.from_addr), typeof row.from_name === 'string' ? row.from_name : null),
+                to: toList.map((address) => addressRow(address)),
+                cc: ccList.map((address) => addressRow(address)),
+                at: isoOf(row.at) ?? isoOf(row.date),
+                html,
+                text: purged ? null : text,
+                snippet: row.snippet ?? '',
+                note: purged ? purgedNote : null,
+                toText: toList.join(', '),
+                ccText: ccList.join(', '),
                 subject: row.subject ?? '',
                 date: isoOf(row.date),
                 who: row.direction === 'out' ? 'you wrote' : 'they wrote',
-                // Null once retention has purged it: the headers stay, the body does
-                // not, and the page says so rather than drawing an empty message.
-                bodyText: body,
+                // The body rides once, as `text` (null once retention purged it, with
+                // `note` saying so): a second copy would put a long message over the
+                // gateway's megabyte per answer.
                 purged,
                 attachments: attachmentRows(messageId, row.attachments),
             };
@@ -483,10 +692,18 @@ export function accountsQuery() {
         async produce(_params, ctx) {
             const now = ctx.buddi.clock.now();
             const accounts = await listAccounts(ctx.buddi.db, { enabledOnly: false });
-            const synced = await lastSyncByAccount(ctx.buddi.db);
+            // When each mailbox last *finished* a poll: "connected, synced 3 min
+            // ago" is true of a quiet mailbox too, where "when mail last landed"
+            // read "no mail has arrived yet" on the day it was connected.
+            const synced = await lastSyncedByAccount(ctx.buddi.db);
             const waiting = await triageWaitingByAccount(ctx.buddi.db);
             const needed = await passwordsNeeded(accounts, ctx);
+            const { rows: storedRows } = await ctx.buddi.db.query(`select a.id from email.accounts a where exists (select 1 from email.messages m where m.account_id = a.id)`);
+            const stored = new Set(storedRows.map((row) => String(row.id)));
             return {
+                // A connected mailbox with nothing stored yet: the Mail page's "Read
+                // the last 7 days" lands here, and the note it lands on reads this.
+                anyFresh: accounts.some((account) => account.enabled && !stored.has(account.id)),
                 /*
                  * Whether new mail has anybody to triage it. `needs-agent` is what
                  * the page's offer line is drawn against: a mailbox, and no agent
@@ -522,9 +739,11 @@ export function accountsQuery() {
                         : idleLive(account.id)
                             ? 'Instant'
                             : `Checking every ${Math.round(POLL_EVERY_SECONDS / 60)} min`,
-                    lastSync: synced.get(account.id)
-                        ? relative(synced.get(account.id) ?? null, now)
-                        : 'no mail has arrived yet',
+                    lastSync: !account.enabled
+                        ? '—'
+                        : synced.get(account.id)
+                            ? relative(synced.get(account.id).toISOString(), now)
+                            : 'not yet',
                     /*
                      * Facts about a mailbox, not one sentence to be parsed: whether
                      * buddi is reading it, and whether it is a mailbox `.env` used to
@@ -534,9 +753,13 @@ export function accountsQuery() {
                      * carry the tone.
                      */
                     state: [
-                        account.enabled
-                            ? { value: 'on', tone: 'neutral' }
-                            : { value: 'off', tone: 'warning' },
+                        // Connected once a poll has finished with the password it has;
+                        // until the first one, "connecting".
+                        !account.enabled
+                            ? { value: 'off', tone: 'warning' }
+                            : synced.get(account.id) && !needed.has(account.id)
+                                ? { value: 'connected', tone: 'neutral' }
+                                : { value: needed.has(account.id) ? 'on' : 'connecting', tone: 'neutral' },
                         // A mailbox `.env` used to name that could not be adopted is a
                         // password nobody can read here: Set password brings it back.
                         ...(account.addedVia === 'env' ? [{ value: 'password needed', tone: 'neutral' }] : []),
@@ -548,6 +771,78 @@ export function accountsQuery() {
         },
     };
 }
+/**
+ * The Mail page's own read: which mailboxes are connected, and which of them
+ * are fresh — connected, a first poll finished, and nothing stored yet. A
+ * fresh mailbox gets a first state instead of an empty list ("Connected to
+ * you@example.com. Reading new mail from now on; 412 older messages left
+ * alone."), because "No conversations here" on the day you connect reads as a
+ * fault. Until that first poll has finished nothing is known about what was
+ * left alone, so the page says "Connecting to you@example.com…" instead.
+ */
+export function mailStatusQuery() {
+    return {
+        name: 'mail_status',
+        params: noParams,
+        async produce(_params, ctx) {
+            const accounts = await listAccounts(ctx.buddi.db, { enabledOnly: true });
+            // The conversation list reads every mailbox, a disabled one's retained
+            // conversations included; whether there is mail to list asks the same.
+            const everyId = (await listAccounts(ctx.buddi.db, { enabledOnly: false })).map((account) => account.id);
+            const { rows } = await ctx.buddi.db.query(`select a.id,
+                exists (select 1 from email.messages m where m.account_id = a.id) as stored,
+                (a.last_synced_at is not null
+                  or exists (select 1 from email.folders f
+                              where f.account_id = a.id and f.first_contact_at is not null)) as polled,
+                (select f.left_alone from email.folders f
+                  where f.account_id = a.id and f.kind = 'inbox' order by f.first_contact_at nulls last limit 1) as left_alone
+           from email.accounts a where a.enabled`);
+            const facts = new Map(rows.map((row) => [String(row.id), row]));
+            const empty = accounts.filter((account) => facts.get(account.id)?.stored !== true);
+            const fresh = empty.filter((account) => facts.get(account.id)?.polled === true);
+            const connecting = empty.filter((account) => facts.get(account.id)?.polled !== true);
+            const mail = everyId.length === 0
+                ? { rows: [] }
+                : await ctx.buddi.db.query(`select exists (select 1 from email.messages where account_id = any($1::uuid[])) as has_mail`, [everyId]);
+            const hasMail = mail.rows[0]?.has_mail === true;
+            return {
+                connected: accounts.length
+                    ? `Connected: ${accounts.map((account) => account.address).join(' · ')}`
+                    : '',
+                hasAccounts: accounts.length > 0,
+                anyFresh: fresh.length > 0,
+                anyConnecting: connecting.length > 0,
+                connecting: connecting.length > 0 ? connectingLine(connecting.map((account) => account.address)) : '',
+                hasMail,
+                // The list is drawn when there is mail to list, or nothing connected
+                // at all (its empty sentence is then the honest one).
+                showList: hasMail || accounts.length === 0,
+                fresh: fresh.map((account) => ({
+                    id: account.id,
+                    address: account.address,
+                    line: freshLine(account.address, facts.get(account.id)?.left_alone),
+                })),
+            };
+        },
+    };
+}
+/** What the page says while a mailbox's first poll has not finished. */
+export function connectingLine(addresses) {
+    const list = addresses.length <= 1
+        ? (addresses[0] ?? '')
+        : `${addresses.slice(0, -1).join(', ')} and ${addresses[addresses.length - 1]}`;
+    return `Connecting to ${list}…`;
+}
+/** The first-state sentence for one fresh mailbox. */
+export function freshLine(address, leftAlone) {
+    const older = leftAlone === null || leftAlone === undefined ? null : Number(leftAlone);
+    const head = `Connected to ${address}. Reading new mail from now on`;
+    if (older === null || !Number.isFinite(older))
+        return `${head}; older messages left alone.`;
+    if (older === 0)
+        return `${head}.`;
+    return `${head}; ${older.toLocaleString('en-US')} older ${older === 1 ? 'message' : 'messages'} left alone.`;
+}
 /**
  * How many of this plugin's rules wait on Settings → Proposals. Zero on an
  * installation whose core has no proposals table yet.
@@ -846,6 +1141,7 @@ export function emailPageQueries() {
         draftQuery(),
         messageQuery(),
         accountsQuery(),
+        mailStatusQuery(),
         policiesQuery(),
         ruleThreadsQuery(),
         watcherSettingsQuery(),