@wirecat/cli-core 0.562.0 → 0.564.0

package/dist/mail/cli/review.js

@@ -8,10 +8,12 @@ import { LOCAL_READ } from "../../cli/effects.js";
 import { listOf, renderAnswer } from "../../cli/envelope.js";
 import { listQuery, nativeField, nativeTerms, queryHelp, typedQuery } from "../../cli/list-query.js";
 import { pointsOf } from "../../cli/messenger/catch-up.js";
-import { catchUpQuery, summaryOf } from "../../cli/messenger/catch-up-answers.js";
+import { catchUpQuery, SUMMARY_UNTRUSTED, summaryOf } from "../../cli/messenger/catch-up-answers.js";
 import { messageItem } from "../../cli/messenger/message-items.js";
 import { checkPoints } from "../../cli/messenger/points.js";
 import { unansweredHours } from "../../cli/messenger/review.js";
+import { MAIL_HIT_UNTRUSTED } from "../../cli/messenger/search-answers.js";
+import { mailOwnText } from "../../conversations/mail-text.js";
 import { parseDuration } from "../../domain/duration.js";
 import { formatReference } from "../../domain/references.js";
 import { AGENDA_DEFAULTS } from "../../services/agenda.js";
@@ -20,6 +22,7 @@ import { readPastMark } from "../marks.js";
 import { hitText } from "../read.js";
 import { OWED_DAYS, REVIEW_THREADS, reviewMail } from "../review.js";
 const DAY = 86_400_000;
+const REVIEW_UNTRUSTED = [...SUMMARY_UNTRUSTED, ...MAIL_HIT_UNTRUSTED];
 /** Where a mail review starts: a time only; one thread is `conversations show`. */
 export const MAIL_REVIEW_QUERY = defineQuery({
     entity: "message",
@@ -29,31 +32,44 @@ export const MAIL_REVIEW_QUERY = defineQuery({
         nativeField({ name: "bulk", type: "kw", operators: ["term"], example: "bulk:false" }),
     ],
 });
-/** The mail review's steps; a host lists them beside its own so its step checks know them. */
-export const MAIL_REVIEW_STEPS = defineSteps([
-    {
-        id: "mail-messages.acknowledge",
-        command: "messages acknowledge",
-        args: [
-            { name: "holder", required: true },
-            { name: "cursor", required: true },
-        ],
-        why: "once these are processed, this moves the holder's mark past them",
-    },
-    {
-        id: "mail-review.next",
-        command: "review",
-        args: [{ name: "query", required: true }],
-        why: "the next review starts where this one ended",
-    },
-    {
-        id: "mail-conversations.show",
-        command: "conversations show",
-        args: [{ name: "conversation", required: true }],
-        why: "only the newest emails of the thread were read here; this reads it whole",
-    },
-]);
-const step = (id) => MAIL_REVIEW_STEPS.find((one) => one.id === id);
+/** The mail review's steps where a host mounted them; a host lists them beside its own so its step checks know them. */
+export const mailReviewSteps = (mount = {}) => {
+    const mailbox = mount.mailbox ? [{ name: mount.mailbox.option, required: true }] : [];
+    return defineSteps([
+        {
+            id: "mail-messages.acknowledge",
+            command: mount.acknowledge ?? "messages acknowledge",
+            args: [{ name: "holder", required: true }, { name: "cursor", required: true }, ...mailbox],
+            why: "once these are processed, this moves the holder's mark past them",
+        },
+        {
+            id: "mail-review.next",
+            command: mount.review ?? "review",
+            args: [{ name: "query", required: true }, ...mailbox],
+            why: "the next review starts where this one ended",
+        },
+        ...(mount.conversation === null
+            ? []
+            : [
+                {
+                    id: "mail-conversations.show",
+                    command: mount.conversation ?? "conversations show",
+                    args: [{ name: "conversation", required: true }, ...mailbox],
+                    why: "only the newest emails of the thread were read here; this reads it whole",
+                },
+            ]),
+    ]);
+};
+/** The steps of a mail CLI, whose profile names the mailbox. */
+export const MAIL_REVIEW_STEPS = mailReviewSteps();
+const stepsFor = (mount, mailbox) => {
+    const definitions = mailReviewSteps(mount);
+    const where = mount?.mailbox ? { [mount.mailbox.option]: mount.mailbox.value(mailbox) } : {};
+    return (id, args) => {
+        const definition = definitions.find((one) => one.id === id);
+        return definition ? [stepOf(definition, { args: { ...args, ...where } })] : [];
+    };
+};
 const waitingHours = (value) => value === true ? AGENDA_DEFAULTS.waiting / 3_600_000 : parseDuration(String(value), "--waiting") / 3_600_000;
 const quoted = (value) => `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
 /** A file name for the mailbox's points: they describe the mailbox, whichever profile reads it. */
@@ -67,20 +83,21 @@ const markText = (marks) => {
     const shown = said.filter(Boolean).join(" · ");
     return shown ? `\n  [${shown}]` : "";
 };
-const reviewAnswer = (found, mailbox, fresh) => {
+const reviewAnswer = (found, mailbox, fresh, step) => {
     const read = found.chats
         .flatMap((chat) => chat.messages.map((message) => ({ ...message, chatTitle: chat.title })))
         .sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp));
     const cut = found.chats.filter((chat) => chat.more);
     const ref = (thread) => formatReference({ type: "chat", ...mailbox, chat: thread });
     const turns = found.unanswered !== undefined || found.waiting !== undefined;
+    const wholeThreads = cut.flatMap((chat) => step("mail-conversations.show", { conversation: ref(chat.id) }));
     const missing = [
         ...(cut.length > 0
             ? [
                 {
                     field: "items",
                     why: `only the newest emails of ${cut.length} thread(s)`,
-                    step: "mail-conversations.show",
+                    ...(wholeThreads.length ? { step: "mail-conversations.show" } : {}),
                 },
             ]
             : []),
@@ -98,13 +115,9 @@ const reviewAnswer = (found, mailbox, fresh) => {
     ];
     const next = [
         ...(!fresh && !turns
-            ? [
-                stepOf(step("mail-review.next"), {
-                    args: { query: `date>${quoted(found.complete ? found.until : found.since)}` },
-                }),
-            ]
+            ? step("mail-review.next", { query: `date>${quoted(found.complete ? found.until : found.since)}` })
             : []),
-        ...cut.map((chat) => stepOf(step("mail-conversations.show"), { args: { conversation: ref(chat.id) } })),
+        ...wholeThreads,
     ];
     return listOf("review", {
         items: read.map((message) => ({
@@ -122,6 +135,7 @@ const reviewAnswer = (found, mailbox, fresh) => {
                     }
                     : {}),
             },
+            untrusted: REVIEW_UNTRUSTED,
         })),
         limit: Math.max(1, read.length),
         has_more: false,
@@ -142,8 +156,10 @@ const holderReview = async (command, mail, holder, query) => {
             : new Map();
         return { read, mailbox, marks };
     });
+    // An agent reads this: earlier mail and signatures stay out of its text; the fingerprint is over the stored body.
+    const emails = read.emails.map((email) => ({ ...email, text: mailOwnText(email.text) }));
     const chats = new Map();
-    for (const email of read.emails) {
+    for (const email of emails) {
         const chat = chats.get(email.chatId) ?? {
             id: email.chatId,
             title: email.chatTitle,
@@ -165,12 +181,10 @@ const holderReview = async (command, mail, holder, query) => {
         partial: false,
         quiet: 0,
     };
-    const answer = reviewAnswer(found, mailbox, true);
+    const step = stepsFor(mail.mount, mailbox);
+    const answer = reviewAnswer(found, mailbox, true, step);
     const skipped = Object.entries(read.skipped).filter(([, count]) => count > 0);
-    answer.next = [
-        stepOf(step("mail-messages.acknowledge"), { args: { holder, cursor: read.cursor } }),
-        ...(answer.next ?? []),
-    ];
+    answer.next = [...step("mail-messages.acknowledge", { holder, cursor: read.cursor }), ...(answer.next ?? [])];
     answer.missing = [
         ...(answer.missing ?? []),
         ...(read.held > 0 ? [{ field: "items", why: `${read.held} partial emails held until they are whole` }] : []),
@@ -183,7 +197,7 @@ const holderReview = async (command, mail, holder, query) => {
         output.renderer.note(read.mark
             ? `${holder}: past ${read.mark.throughId}; acknowledge with --cursor ${read.cursor}${read.more ? "; more after these" : ""}`
             : `${holder} has no mark yet: it starts from now — acknowledge with --cursor ${read.cursor}`);
-        return read.emails.map((hit) => `${hitText(hit)}${markText(marks.get(hit.id))}\n`).join("");
+        return emails.map((hit) => `${hitText(hit)}${markText(marks.get(hit.id))}\n`).join("");
     });
 };
 /**
@@ -209,7 +223,8 @@ export const mailReviewCommand = (mail) => annotate(new Command("review"), {
     .option("--unanswered [duration]", "only threads whose newest email came to you, in To or Cc, with no answer for this long — 4h, 1d; 24h if not given")
     .option("--waiting [duration]", "only threads where you wrote last and nobody answered for this long — 3d; 7d if not given")
     .option("--holder <name>", "read for this holder — an agent or a pipeline — what is stored past its processing mark, by store order; " +
-    "bulk, envelopes, drafts, suspicious senders and partial mail left out; `messages acknowledge` moves the mark")
+    "bulk, envelopes, drafts, suspicious senders and partial mail left out; each text without quoted earlier mail " +
+    "or the signature; `messages acknowledge` moves the mark")
     .option("--new", "what changed since the last `review --new` of this mailbox, a point per thread — for scheduled runs")
     .addHelpText("after", `
 Without a date, --unanswered and --waiting look at threads active in the last ${OWED_DAYS} days.
@@ -254,7 +269,7 @@ an agent over MCP, and each scheduled run.`)
         return { found, mailbox, saved };
     });
     const output = outputFor(this);
-    const answer = reviewAnswer(found, mailbox, saved !== undefined);
+    const answer = reviewAnswer(found, mailbox, saved !== undefined, stepsFor(mail.mount, mailbox));
     if (meta)
         answer.meta = { ...meta, ...answer.meta };
     renderAnswer(this, output, answer, () => {

package/dist/mail/index.d.ts

@@ -1,4 +1,6 @@
+export { mailOwnText } from "../conversations/mail-text.js";
 export { mailAccountKey } from "./account-key.js";
+export { DEFAULT_ATTACHMENT_POLICY, type MailAttachmentPolicy, POLICY_SKIPS } from "./attachments.js";
 export { BULK, bulkBox } from "./bulk.js";
 export { factsOf } from "./facts.js";
 export { MAIL_FINDINGS_KIND, MAIL_FINDINGS_PER_RUN, MAIL_FINDINGS_PER_SENDER, type MailFinding, type MailFindingsInput, mailFindingFingerprint, validateMailFindings, } from "./findings.js";
@@ -27,5 +29,7 @@ export { type MailCriteria, mailCriteriaOf, narrows } from "./server-query.js";
 export { type MailServerAccess, type MailServerRequest, searchMailServer } from "./server-search.js";
 export type { Listed, MailSource, Quick, Searched } from "./source.js";
 export { SEARCH_REFUSED, searchRefused } from "./source.js";
+export { MAIL_STATS_BY, type MailStats, type MailStatsBy, type MailStatsRequest, type MailStatsRow, mailStats, mailStatsItem, } from "./stats.js";
 export { listedOf, type StoredMail } from "./stored.js";
 export { MAX_ATTACHMENT_CHARS, type MailAccount, type MailIndexed, type MailSyncOptions, type MailSyncResult, RETRYABLE_ATTACHMENTS, syncMail, } from "./sync.js";
+export { readEmailWhole, type WholeAttachment } from "./whole.js";

package/dist/mail/index.js

@@ -1,4 +1,6 @@
+export { mailOwnText } from "../conversations/mail-text.js";
 export { mailAccountKey } from "./account-key.js";
+export { DEFAULT_ATTACHMENT_POLICY, POLICY_SKIPS } from "./attachments.js";
 export { BULK, bulkBox } from "./bulk.js";
 export { factsOf } from "./facts.js";
 export { MAIL_FINDINGS_KIND, MAIL_FINDINGS_PER_RUN, MAIL_FINDINGS_PER_SENDER, mailFindingFingerprint, validateMailFindings, } from "./findings.js";
@@ -26,5 +28,7 @@ export { DEMOTE_AT, demotedSenders, SCORE_VERSION, scoreSenders, } from "./sende
 export { mailCriteriaOf, narrows } from "./server-query.js";
 export { searchMailServer } from "./server-search.js";
 export { SEARCH_REFUSED, searchRefused } from "./source.js";
+export { MAIL_STATS_BY, mailStats, mailStatsItem, } from "./stats.js";
 export { listedOf } from "./stored.js";
 export { MAX_ATTACHMENT_CHARS, RETRYABLE_ATTACHMENTS, syncMail, } from "./sync.js";
+export { readEmailWhole } from "./whole.js";

package/dist/mail/partial.d.ts

@@ -1,6 +1,7 @@
 import type { BudgetStop } from "../background/budget.js";
 import type { LoadEngine } from "../readers/types.js";
 import type { MessageStore } from "../store/index.js";
+import { type MailAttachmentPolicy } from "./attachments.js";
 import type { MailSource } from "./source.js";
 /** The `emails.metadata` key of an email stored from its first bytes: `{ bytes }` read of its `size`. */
 export declare const PARTIAL = "partial";
@@ -23,7 +24,7 @@ export interface PartialOutcome {
  * `identify` gives the stored id for the bytes read there. Each failed read is counted, and after `PARTIAL_TRIES`, or
  * at once when the place holds another message, the email is left partial for good.
  */
-export declare const completePartial: ({ store, source, accountId, address, folders, maxBodyChars, maxAttachmentChars, loadEngine, now, take, signal, }: {
+export declare const completePartial: ({ store, source, accountId, address, folders, maxBodyChars, maxAttachmentChars, policy, loadEngine, now, take, signal, }: {
     store: MessageStore;
     source: MailSource;
     accountId: number;
@@ -32,6 +33,7 @@ export declare const completePartial: ({ store, source, accountId, address, fold
     folders: () => Promise<readonly string[]>;
     maxBodyChars: number;
     maxAttachmentChars: number;
+    policy?: MailAttachmentPolicy;
     loadEngine: LoadEngine;
     now: number;
     /** A budgeted run's next request, or why there is none. */

package/dist/mail/partial.js

@@ -15,7 +15,7 @@ export const PARTIAL_TRIES = 3;
  * `identify` gives the stored id for the bytes read there. Each failed read is counted, and after `PARTIAL_TRIES`, or
  * at once when the place holds another message, the email is left partial for good.
  */
-export const completePartial = async ({ store, source, accountId, address, folders, maxBodyChars, maxAttachmentChars, loadEngine, now, take, signal, }) => {
+export const completePartial = async ({ store, source, accountId, address, folders, maxBodyChars, maxAttachmentChars, policy, loadEngine, now, take, signal, }) => {
     const { emails, total, stuck } = await store.mail.partialEmails(accountId, PARTIAL_PER_RUN);
     if (emails.length === 0)
         return { completed: 0, left: 0, stuck };
@@ -89,7 +89,7 @@ export const completePartial = async ({ store, source, accountId, address, folde
             }
             try {
                 const mail = await parseMail(raw, maxBodyChars);
-                const files = await readAttachments(mail, email.externalId, { loadEngine, maxAttachmentChars, at: now, ...(signal ? { signal } : {}) }, attachments);
+                const files = await readAttachments(mail, email.externalId, { loadEngine, maxAttachmentChars, at: now, ...(policy ? { policy } : {}), ...(signal ? { signal } : {}) }, attachments);
                 const { [PARTIAL]: _partial, ...metadata } = email.metadata ?? {};
                 const whole = { ...item, messageId: email.externalId, threadId: email.threadExternalId };
                 await store.mail.saveThread({

package/dist/mail/retry.d.ts

@@ -1,5 +1,6 @@
 import type { LoadEngine } from "../readers/types.js";
 import type { MessageStore } from "../store/index.js";
+import { type MailAttachmentPolicy } from "./attachments.js";
 import type { MailSource } from "./source.js";
 import type { MailAccount, MailSyncOptions, MailSyncResult } from "./sync.js";
 /** Failures a newer install mends: the reader was missing, not the file at fault, so reading again can succeed. */
@@ -9,7 +10,7 @@ export declare const RETRYABLE_ATTACHMENTS: string[];
  * attachment file, so the email comes from the source again. Nothing is listed, so no deletion is proved and no
  * resume point moves; the email keeps its stored mailboxes, flags and rule.
  */
-export declare const retryUnread: ({ store, source, account, since, max, maxBodyChars, maxAttachmentChars, now, loadEngine, index, }: {
+export declare const retryUnread: ({ store, source, account, since, max, maxBodyChars, maxAttachmentChars, policy, now, loadEngine, index, }: {
     store: MessageStore;
     source: MailSource;
     account: MailAccount;
@@ -17,6 +18,7 @@ export declare const retryUnread: ({ store, source, account, since, max, maxBody
     max: number;
     maxBodyChars: number;
     maxAttachmentChars: number;
+    policy?: MailAttachmentPolicy;
     now: () => number;
     loadEngine: LoadEngine;
     index: MailSyncOptions["index"];

package/dist/mail/retry.js

@@ -1,6 +1,6 @@
 import { CliError } from "@wirecat/cli-base";
 import { mailAccountKey } from "./account-key.js";
-import { addressOf, FETCH_CHUNK, readAttachments } from "./attachments.js";
+import { addressOf, FETCH_CHUNK, readAttachments, } from "./attachments.js";
 import { sentAtOf } from "./email-input.js";
 import { mailFolders } from "./folders.js";
 import { mailHeadersOf } from "./headers.js";
@@ -12,7 +12,7 @@ export const RETRYABLE_ATTACHMENTS = ["engine-missing"];
  * attachment file, so the email comes from the source again. Nothing is listed, so no deletion is proved and no
  * resume point moves; the email keeps its stored mailboxes, flags and rule.
  */
-export const retryUnread = async ({ store, source, account, since, max, maxBodyChars, maxAttachmentChars, now, loadEngine, index, }) => {
+export const retryUnread = async ({ store, source, account, since, max, maxBodyChars, maxAttachmentChars, policy, now, loadEngine, index, }) => {
     const startedAt = now();
     const key = mailAccountKey(account.address);
     const find = source.find;
@@ -55,7 +55,7 @@ export const retryUnread = async ({ store, source, account, since, max, maxBodyC
                 continue;
             }
             const before = new Map(stored.attachments.map(({ position, extractionError }) => [position, extractionError]));
-            const files = await readAttachments(mail, item.messageId, { loadEngine, maxAttachmentChars, at: startedAt }, attachments);
+            const files = await readAttachments(mail, item.messageId, { loadEngine, maxAttachmentChars, at: startedAt, ...(policy ? { policy } : {}) }, attachments);
             for (const file of files)
                 if (RETRYABLE_ATTACHMENTS.includes(before.get(file.position) ?? ""))
                     if (file.extraction === "text")

package/dist/mail/stats.d.ts

@@ -0,0 +1,50 @@
+import type { Saved } from "../services/message-resolution.js";
+import type { AccountKey, MessageStore } from "../store/store.js";
+export declare const MAIL_STATS_BY: readonly ["day", "week", "sender"];
+export type MailStatsBy = (typeof MAIL_STATS_BY)[number];
+export interface MailStatsRequest {
+    by: MailStatsBy;
+    /** The query of `search mail`; every stored email when unset. */
+    text?: string;
+    /** Only these mailboxes; every stored one when neither this nor `mailAccount` is given. */
+    accounts?: AccountKey[];
+    /** Only this mailbox, by its address. */
+    mailAccount?: string;
+    exact?: boolean;
+    /** Where calendar days and weeks start; the system timezone when unset, as for search. */
+    timezone?: string;
+    /** Rows kept: the busiest senders, or the latest days and weeks, oldest first. */
+    limit: number;
+}
+export interface MailStatsRow {
+    /** `YYYY-MM-DD` (a week by its Monday), or the sender's address. */
+    key: string;
+    name: string | null;
+    received: number;
+    sent: number;
+}
+export interface MailStats {
+    by: MailStatsBy;
+    received: number;
+    sent: number;
+    rows: MailStatsRow[];
+    hasMore: boolean;
+    timezone: string;
+}
+/**
+ * Stored mail the `search mail` query matches, received and sent, per calendar day, week or sender; counts only.
+ * `--by sender` counts received mail: the sender of sent mail is the owner. Reads the store, records no search.
+ */
+export declare const mailStats: (store: MessageStore, runAs: AccountKey, { by, text, accounts, mailAccount, exact, timezone, limit }: MailStatsRequest, saved?: Saved) => Promise<MailStats>;
+/** The `mail_counts` entity: what a command answers as its `item`. */
+export declare const mailStatsItem: ({ by, received, sent, rows }: MailStats) => {
+    by: "day" | "sender" | "week";
+    received: number;
+    sent: number;
+    rows: {
+        key: string;
+        name: string | null;
+        received: number;
+        sent: number;
+    }[];
+};

package/dist/mail/stats.js

@@ -0,0 +1,60 @@
+import { calendarKey, weekKey } from "../domain/calendar.js";
+import { prepareLucene } from "../services/messages-search.js";
+export const MAIL_STATS_BY = ["day", "week", "sender"];
+/**
+ * Stored mail the `search mail` query matches, received and sent, per calendar day, week or sender; counts only.
+ * `--by sender` counts received mail: the sender of sent mail is the owner. Reads the store, records no search.
+ */
+export const mailStats = async (store, runAs, { by, text, accounts, mailAccount, exact, timezone, limit }, saved = {}) => {
+    const prepared = await prepareLucene(store, runAs, {
+        kind: "mail",
+        limit: 1,
+        ...(text?.trim() ? { text } : {}),
+        ...(accounts === undefined ? {} : { accounts }),
+        ...(mailAccount === undefined ? {} : { mailAccount }),
+        ...(exact ? { exact: true } : {}),
+        ...(timezone === undefined ? {} : { timezone }),
+    }, saved);
+    const mailboxes = prepared.scopeAccounts.filter(({ provider }) => provider === "email");
+    const groups = mailboxes.length
+        ? await store.queries.countQuery({ ...prepared.execution, accounts: mailboxes, corpus: "mail" }, by === "sender" ? "sender_direction" : "time_direction")
+        : [];
+    const received = groups.filter(({ outgoing }) => !outgoing).reduce((sum, { count }) => sum + count, 0);
+    const sent = groups.filter(({ outgoing }) => outgoing).reduce((sum, { count }) => sum + count, 0);
+    let rows;
+    if (by === "sender")
+        rows = groups
+            .filter(({ outgoing }) => !outgoing)
+            .map(({ id, name, count }) => ({ key: id ?? "unknown", name, received: count, sent: 0 }))
+            .sort((a, b) => b.received - a.received || a.key.localeCompare(b.key));
+    else {
+        const day = calendarKey(prepared.timezone, "day");
+        const keyOf = by === "week" ? (at) => weekKey(day(at)) : day;
+        const totals = new Map();
+        for (const { id, outgoing, count } of groups) {
+            const key = keyOf(Number(id));
+            const row = totals.get(key) ?? { key, name: null, received: 0, sent: 0 };
+            if (outgoing)
+                row.sent += count;
+            else
+                row.received += count;
+            totals.set(key, row);
+        }
+        rows = [...totals.values()].sort((a, b) => a.key.localeCompare(b.key));
+    }
+    return {
+        by,
+        received,
+        sent,
+        rows: by === "sender" ? rows.slice(0, limit) : rows.slice(-limit),
+        hasMore: rows.length > limit,
+        timezone: prepared.timezone,
+    };
+};
+/** The `mail_counts` entity: what a command answers as its `item`. */
+export const mailStatsItem = ({ by, received, sent, rows }) => ({
+    by,
+    received,
+    sent,
+    rows: rows.map(({ key, name, received, sent }) => ({ key, name, received, sent })),
+});

package/dist/mail/sync-types.d.ts

@@ -1,6 +1,7 @@
 import type { BudgetStop, RunBudget } from "../background/budget.js";
 import type { LoadEngine } from "../readers/types.js";
 import type { AccountKey, MessageStore } from "../store/index.js";
+import type { MailAttachmentPolicy } from "./attachments.js";
 import type { PartialOutcome } from "./partial.js";
 import type { TagOutcome } from "./rule-tags.js";
 import type { MailRule } from "./rules.js";
@@ -84,6 +85,8 @@ export interface MailSyncOptions {
     max?: number;
     maxBodyChars?: number;
     maxAttachmentChars?: number;
+    /** Whether attachments are read into the index, and up to what size; `DEFAULT_ATTACHMENT_POLICY` when left out. */
+    attachments?: MailAttachmentPolicy;
     now?: () => number;
     /** Domain registration dates already known, for the sender score a rule asks for. */
     ages?: ReadonlyMap<string, DomainAge>;

package/dist/mail/sync.js

@@ -3,7 +3,7 @@ import { CliError } from "@wirecat/cli-base";
 import { importEngine } from "../attachments/extract.js";
 import { isBusy } from "../store/sqlite/transaction.js";
 import { mailAccountKey } from "./account-key.js";
-import { FETCH_CHUNK, MAX_ATTACHMENT_CHARS, readAttachments } from "./attachments.js";
+import { DEFAULT_ATTACHMENT_POLICY, FETCH_CHUNK, MAX_ATTACHMENT_CHARS, readAttachments } from "./attachments.js";
 import { BULK, bulkBox } from "./bulk.js";
 import { parsedEmail } from "./email-input.js";
 import { factsOf } from "./facts.js";
@@ -51,6 +51,7 @@ export const syncMail = async (source, store, options) => {
         folders: () => mailFolders(options.account, source),
         maxBodyChars: options.maxBodyChars ?? MAX_BODY_CHARS,
         maxAttachmentChars: options.maxAttachmentChars ?? MAX_ATTACHMENT_CHARS,
+        policy: options.attachments ?? DEFAULT_ATTACHMENT_POLICY,
         loadEngine: options.loadEngine ?? importEngine,
         now: (options.now ?? Date.now)(),
         ...(options.budget ? { take: () => options.budget?.take() ?? null } : {}),
@@ -169,7 +170,7 @@ const syncRounds = async (source, store, options) => {
             : {}),
     };
 };
-const syncRound = async (source, store, { account, since, max = 200, maxBodyChars = MAX_BODY_CHARS, maxAttachmentChars = MAX_ATTACHMENT_CHARS, now = Date.now, ages, loadEngine = importEngine, retryAttachments = false, rescan = false, saveCoverage = true, resumeFrom = RESUME_FROM, index, signal, }, plan) => {
+const syncRound = async (source, store, { account, since, max = 200, maxBodyChars = MAX_BODY_CHARS, maxAttachmentChars = MAX_ATTACHMENT_CHARS, attachments: policy = DEFAULT_ATTACHMENT_POLICY, now = Date.now, ages, loadEngine = importEngine, retryAttachments = false, rescan = false, saveCoverage = true, resumeFrom = RESUME_FROM, index, signal, }, plan) => {
     if (retryAttachments)
         return retryUnread({
             store,
@@ -179,6 +180,7 @@ const syncRound = async (source, store, { account, since, max = 200, maxBodyChar
             max,
             maxBodyChars,
             maxAttachmentChars,
+            policy,
             now,
             loadEngine,
             index,
@@ -759,7 +761,7 @@ const syncRound = async (source, store, { account, since, max = 200, maxBodyChar
             plan?.unreadable.delete(item.messageId);
             const header = mailHeadersOf(raws[index]);
             // A stop between attachments ends the chunk; what the earlier slices saved stays.
-            const files = await readAttachments(mail, item.messageId, { loadEngine, maxAttachmentChars, at: startedAt, ...(signal ? { signal } : {}) }, attachments).catch(async (error) => {
+            const files = await readAttachments(mail, item.messageId, { loadEngine, maxAttachmentChars, at: startedAt, policy, ...(signal ? { signal } : {}) }, attachments).catch(async (error) => {
                 await stopIfAborted();
                 throw error;
             });

package/dist/mail/whole.d.ts

@@ -0,0 +1,28 @@
+import type { LoadEngine } from "../readers/types.js";
+import type { MessageStore } from "../store/index.js";
+import type { MailSource } from "./source.js";
+export interface WholeAttachment {
+    position: number;
+    name: string;
+    mime: string | null;
+    /** `null` when the email held no content for it. */
+    bytes: Uint8Array | null;
+    status: string;
+}
+/**
+ * Reads one stored email from its source again and every attachment of it, whatever its size: what a person asks for
+ * by name is read even when a sync's policy left it. The new text is saved as a sync saves it, so the search index
+ * takes it; the files are only answered, never written. Gmail's email is found by its id in `folders`; elsewhere it is
+ * read at its newest stored place, trusted only when `identify` gives the stored id for the bytes read there.
+ */
+export declare const readEmailWhole: ({ store, source, address, externalId, folders, maxBodyChars, maxAttachmentChars, loadEngine, now, }: {
+    store: MessageStore;
+    source: MailSource;
+    address: string;
+    externalId: string;
+    folders: () => Promise<readonly string[]>;
+    maxBodyChars?: number;
+    maxAttachmentChars?: number;
+    loadEngine?: LoadEngine;
+    now?: number;
+}) => Promise<WholeAttachment[]>;

package/dist/mail/whole.js

@@ -0,0 +1,70 @@
+import { CliError } from "@wirecat/cli-base";
+import { importEngine } from "../attachments/extract.js";
+import { mailAccountKey } from "./account-key.js";
+import { MAX_ATTACHMENT_CHARS, readAttachments } from "./attachments.js";
+import { parsedEmail } from "./email-input.js";
+import { mailHeadersOf } from "./headers.js";
+import { MAX_BODY_CHARS, parseMail } from "./parse.js";
+import { PARTIAL } from "./partial.js";
+/**
+ * Reads one stored email from its source again and every attachment of it, whatever its size: what a person asks for
+ * by name is read even when a sync's policy left it. The new text is saved as a sync saves it, so the search index
+ * takes it; the files are only answered, never written. Gmail's email is found by its id in `folders`; elsewhere it is
+ * read at its newest stored place, trusted only when `identify` gives the stored id for the bytes read there.
+ */
+export const readEmailWhole = async ({ store, source, address, externalId, folders, maxBodyChars = MAX_BODY_CHARS, maxAttachmentChars = MAX_ATTACHMENT_CHARS, loadEngine = importEngine, now = Date.now(), }) => {
+    const { id: accountId } = await store.accounts.storedAccount(mailAccountKey(address));
+    const stored = await store.mail.emailPlace(accountId, externalId);
+    if (stored === null)
+        throw new CliError("not_found", `${externalId} is not stored for ${address}`);
+    let item;
+    if (source.find)
+        for (const folder of await folders()) {
+            item = (await source.find([externalId], folder)).find(({ messageId }) => messageId === externalId);
+            if (item)
+                break;
+        }
+    else {
+        const place = stored.locations[0];
+        if (place)
+            item = {
+                uid: String(place.uid),
+                folder: place.folder,
+                validity: place.uidvalidity,
+                receivedAt: new Date(stored.receivedAt ?? 0).toISOString(),
+            };
+    }
+    if (item === undefined)
+        throw new CliError("not_found", `the mail server no longer gives ${externalId}`);
+    const [raw] = await source.fetchRaw([item]);
+    if (!(raw instanceof Uint8Array))
+        throw new CliError("provider_unavailable", `${externalId} could not be read from the mail server`);
+    if (!source.find && source.identify?.(raw, item).messageId !== externalId)
+        throw new CliError("not_found", `the mail server holds another email where ${externalId} was`);
+    const mail = await parseMail(raw, maxBodyChars);
+    const log = [];
+    const files = await readAttachments(mail, externalId, { loadEngine, maxAttachmentChars, at: now }, log);
+    const { [PARTIAL]: _partial, ...metadata } = stored.metadata ?? {};
+    const whole = { ...item, messageId: externalId, threadId: stored.threadExternalId };
+    await store.mail.saveThread({
+        accountId,
+        externalId: stored.threadExternalId,
+        now,
+        emails: [
+            {
+                ...parsedEmail(mail, whole, mailHeadersOf(raw), address),
+                receivedAt: stored.receivedAt,
+                size: raw.byteLength,
+                metadata,
+                attachments: files,
+            },
+        ],
+    });
+    return mail.attachments.map((part, position) => ({
+        position,
+        name: part.name,
+        mime: part.mime,
+        bytes: part.bytes,
+        status: log[position]?.status ?? "unavailable",
+    }));
+};

package/dist/meetings/index.d.ts

@@ -32,7 +32,7 @@ export { type MeetingProjectEvidenceAnswer, type MeetingProjectEvidenceItem, mee
 export { MEETING_PROJECT_EVIDENCE_QUERY, type MeetingProjectEvidenceRequest, prepareMeetingProjectEvidence, } from "./project-evidence-query.js";
 export { type MeetingProviderScope, snapshotMeetingScope } from "./provider.js";
 export { type PullOptions, pull, type RunReport } from "./pull.js";
-export { event, eventItem, meetingLink, meetingLinkItem, meetingParticipants, meetingPassage, meetingReview, meetingReviewItem, meetingSpeaker, meetingSpeakerItem, meetingStats, meetingStatsItem, } from "./read-answers.js";
+export { event, eventItem, meetingCounts, meetingCountsItem, meetingLink, meetingLinkItem, meetingParticipants, meetingPassage, meetingReview, meetingReviewItem, meetingSpeaker, meetingSpeakerItem, meetingStats, meetingStatsItem, } from "./read-answers.js";
 export type { MeetingContextReadCapabilities, MeetingReadBudget, MeetingReadCapabilities, MeetingReadScope, TranscriptContextInput, TranscriptContextPage, TranscriptPage, TranscriptReadScope, TranscriptRowPage, } from "./read-store.js";
 export { listed, MeetingError, meetingDetailsAnswer, meetingPeople, meetingSummaryAnswer, meetingTranscriptAnswer, type TranscriptReadOptions, } from "./reads.js";
 export { installRecordingArchiveSchedule, parseRecordingArchiveSchedule, planRecordingArchiveSchedule, type RecordingArchiveSchedule, type RecordingArchiveScheduleInput, type RecordingArchiveScheduler, recordingArchiveScheduleWindow, } from "./recording-schedule.js";
@@ -51,7 +51,7 @@ export { createMeetingSeriesInventoryReader } from "./series-inventory.js";
 export type { MeetingSeriesCandidate, MeetingSeriesInventoryPage, MeetingSeriesInventoryPort, MeetingSeriesInventoryRead, MeetingSeriesInventoryRequest, MeetingSeriesInventoryResult, } from "./series-inventory-types.js";
 export { validateMeetingSeriesInventoryCursor } from "./series-inventory-validation.js";
 export type { MeetingSource, SourceParticipant } from "./source.js";
-export { aggregateMeetingStats, type MeetingSpeakerStats, type MeetingStats, type MeetingStatsInput, type MeetingStatsRow, type MeetingStatsSelection, type MeetingStatsStore, type MeetingWeekStats, } from "./stats.js";
+export { aggregateMeetingCounts, aggregateMeetingStats, MEETING_COUNTS_GROUPINGS, type MeetingCounts, type MeetingCountsGrouping, type MeetingCountsInput, type MeetingCountsMeeting, type MeetingCountsRow, type MeetingSpeakerStats, type MeetingStats, type MeetingStatsInput, type MeetingStatsRow, type MeetingStatsSelection, type MeetingStatsStore, type MeetingWeekStats, NO_SERIES, } from "./stats.js";
 export type { ChatInput, ContractCase, EventCandidateFilter, IdentityInput, MeetingDetails, MeetingFilter, MeetingHitSource, MeetingInput, MeetingSave, MeetingStore, NewRecord, ParticipantInput, SearchHit, TranscriptInput, TranscriptLanguageFill, TranscriptRowInput, } from "./store.js";
 export { meetingTimestamp } from "./timestamp.js";
 export type { MeetingTranscriptReceiptStore, MeetingTranscriptStore, TranscriptAppend, TranscriptAppendReceipt, UnlinkedTranscriptInput, } from "./transcript-store.js";

package/dist/meetings/index.js

@@ -24,7 +24,7 @@ export { meetingProjectEvidence, meetingProjectEvidenceAnswer, } from "./project
 export { MEETING_PROJECT_EVIDENCE_QUERY, prepareMeetingProjectEvidence, } from "./project-evidence-query.js";
 export { snapshotMeetingScope } from "./provider.js";
 export { pull } from "./pull.js";
-export { event, eventItem, meetingLink, meetingLinkItem, meetingParticipants, meetingPassage, meetingReview, meetingReviewItem, meetingSpeaker, meetingSpeakerItem, meetingStats, meetingStatsItem, } from "./read-answers.js";
+export { event, eventItem, meetingCounts, meetingCountsItem, meetingLink, meetingLinkItem, meetingParticipants, meetingPassage, meetingReview, meetingReviewItem, meetingSpeaker, meetingSpeakerItem, meetingStats, meetingStatsItem, } from "./read-answers.js";
 export { listed, MeetingError, meetingDetailsAnswer, meetingPeople, meetingSummaryAnswer, meetingTranscriptAnswer, } from "./reads.js";
 export { installRecordingArchiveSchedule, parseRecordingArchiveSchedule, planRecordingArchiveSchedule, recordingArchiveScheduleWindow, } from "./recording-schedule.js";
 export { parseRecordingSyncCheckpoint, RecordingSyncError, recordingAssetFingerprint, recordingWindows, syncRecordingArchive, } from "./recording-sync.js";
@@ -38,7 +38,7 @@ export { validateMeetingHitSearch } from "./search-validation.js";
 export { validateMeetingSeriesHistory, } from "./series-history.js";
 export { createMeetingSeriesInventoryReader } from "./series-inventory.js";
 export { validateMeetingSeriesInventoryCursor } from "./series-inventory-validation.js";
-export { aggregateMeetingStats, } from "./stats.js";
+export { aggregateMeetingCounts, aggregateMeetingStats, MEETING_COUNTS_GROUPINGS, NO_SERIES, } from "./stats.js";
 export { meetingTimestamp } from "./timestamp.js";
 export { parseTranscriptText, TranscriptTextError } from "./transcript-text.js";
 export { transcribeMeeting, } from "./transcription.js";