@wirecat/cli-core 0.554.0 → 0.556.0

package/dist/mail/review.js

@@ -0,0 +1,118 @@
+import { CliError } from "@wirecat/cli-base";
+import { senderIsMe } from "../domain/models.js";
+import { mailTurn } from "./owed.js";
+/** Every thread is a local read; this many keep one answer readable, and the rest wait in `skipped`. */
+export const REVIEW_THREADS = 50;
+const REVIEW_PER_THREAD = 50;
+/** Without a date, `--unanswered` and `--waiting` look as far back as `tasks agenda` does. */
+export const OWED_DAYS = 30;
+// A thread is picked by its own time, which is the Date header where sync stored one; mail delivered up to a day
+// after its date is still found.
+const DATED_SLACK = 86_400_000;
+const HOUR = 3_600_000;
+/** Mail sent to many, a list's, or recorded by an envelope rule without its text. */
+export const isBulk = (email) => email.bulk || email.list || email.envelope;
+const absent = (error) => {
+    if (error instanceof CliError && error.code === "not_found")
+        return undefined;
+    throw error;
+};
+/**
+ * How far sync proved the mailbox: everything that arrived before `until` is stored. Review cuts there, so mail a
+ * running sync has not stored yet cannot slip behind a saved point.
+ */
+const syncedThrough = async (store, mailbox) => {
+    const saved = await store.sync.syncState(mailbox, "mail_coverage");
+    if (!saved)
+        return { until: undefined, complete: false };
+    try {
+        const { until, state } = JSON.parse(saved.value);
+        const at = typeof until === "string" ? Date.parse(until) : Number.NaN;
+        return { until: Number.isNaN(at) ? undefined : at, complete: state === "window" && !Number.isNaN(at) };
+    }
+    catch {
+        return { until: undefined, complete: false };
+    }
+};
+const wanted = (thread, { noBulk, unansweredAfterHours, waitingAfterHours }, now) => {
+    const newest = thread.newest;
+    if (unansweredAfterHours !== undefined || waitingAfterHours !== undefined) {
+        const turn = mailTurn(newest);
+        const age = newest === null ? 0 : now - newest.at;
+        const owed = turn === "owed" && unansweredAfterHours !== undefined && age >= unansweredAfterHours * HOUR;
+        const waiting = turn === "waiting" && waitingAfterHours !== undefined && age >= waitingAfterHours * HOUR;
+        if (!owed && !waiting)
+            return "no";
+    }
+    return noBulk && newest !== null && !newest.outgoing && isBulk(newest) ? "quiet" : "read";
+};
+/** The emails after the other side last wrote: what is owed, or what waits for an answer. */
+const turnTail = (messages, owner, ownerWrote) => {
+    const start = messages.findLastIndex((one) => senderIsMe(one, owner) !== ownerWrote);
+    return messages.slice(start + 1);
+};
+/**
+ * **Every email, both sides, in each thread that changed since a point** — `review` over the store's mail, in
+ * messenger review's shape: a thread is a chat, an email a message. Reads the store alone, so it costs the mail
+ * server nothing; it opens no task (the owner reviews mail tasks first). Cut where sync proved the mailbox
+ * (`syncedThrough`), so the next review starting at `until` misses nothing sync had stored by then.
+ */
+export const reviewMail = async (store, mailbox, options) => {
+    const { since, points } = options;
+    const now = options.now ?? Date.now();
+    const account = await store.accounts.storedAccount(mailbox).catch(absent);
+    const synced = account ? await syncedThrough(store, mailbox) : { until: undefined, complete: false };
+    const cut = Math.min(now, synced.until ?? now);
+    const startOf = (thread) => points?.get(thread) ?? since;
+    const activity = account ? await store.mail.threadActivity(account.id, since - DATED_SLACK) : [];
+    const changed = activity.filter((thread) => Math.max(thread.lastEmailAt, thread.newest?.at ?? 0) > startOf(thread.threadId));
+    const picked = changed.map((thread) => ({ thread, as: wanted(thread, options, now) }));
+    const shown = picked.filter(({ as }) => as === "read").map(({ thread }) => thread);
+    const read = shown.slice(0, REVIEW_THREADS);
+    const skipped = shown.slice(REVIEW_THREADS).map(({ threadId, subject, lastEmailAt }) => ({
+        id: threadId,
+        title: subject,
+        lastMessageAt: new Date(lastEmailAt).toISOString(),
+    }));
+    const turns = options.unansweredAfterHours !== undefined || options.waitingAfterHours !== undefined;
+    const chats = [];
+    const checked = {};
+    for (const thread of read) {
+        const hits = await store.mail.threadHits(account?.id ?? 0, thread.threadId, {
+            after: startOf(thread.threadId),
+            until: cut,
+        });
+        const tail = turns ? turnTail(hits, mailbox.account, thread.newest?.outgoing === true) : hits;
+        const marks = await store.mail.emailMarks(account?.id ?? 0, tail.map((hit) => hit.id));
+        const messages = tail.map((hit) => {
+            const mark = marks.get(hit.id);
+            return mark ? { ...hit, marks: mark } : hit;
+        });
+        const more = messages.length > REVIEW_PER_THREAD;
+        if (messages.length > 0)
+            chats.push({
+                id: thread.threadId,
+                title: thread.subject,
+                kind: "dialog",
+                messages: more ? messages.slice(-REVIEW_PER_THREAD) : messages,
+                more,
+            });
+        if (!more)
+            checked[thread.threadId] = new Date(cut).toISOString();
+    }
+    const earliest = changed.reduce((low, thread) => Math.min(low, startOf(thread.threadId)), Number.POSITIVE_INFINITY);
+    return {
+        since: new Date(points === undefined || changed.length === 0 ? since : earliest).toISOString(),
+        until: new Date(cut).toISOString(),
+        complete: synced.complete && skipped.length === 0 && chats.every((one) => !one.more),
+        chats,
+        skipped,
+        partial: false,
+        quiet: picked.filter(({ as }) => as === "quiet").length,
+        ...(options.unansweredAfterHours === undefined
+            ? {}
+            : { unanswered: { olderThanHours: options.unansweredAfterHours } }),
+        ...(options.waitingAfterHours === undefined ? {} : { waiting: { olderThanHours: options.waitingAfterHours } }),
+        ...(points === undefined ? {} : { checked }),
+    };
+};

package/dist/sends/permissions.js

@@ -276,6 +276,7 @@ const NAMED_WRITE_KEYS = [
     "mentions.reject",
     "tags.add",
     "tags.remove",
+    "tasks.acknowledge",
     "tasks.add",
     "tasks.claim",
     "tasks.close",

package/dist/services/agenda-mail.d.ts

@@ -0,0 +1,15 @@
+import { type MailTurn } from "../mail/owed.js";
+import { type AccountKey, type ChatActivity, type MessageStore, queryFilter } from "../store/store.js";
+import type { ChatCoverage } from "./chat-coverage.js";
+export interface TurnActivity extends ChatActivity {
+    turn: MailTurn;
+}
+/**
+ * `tasks agenda` over an email account: each thread with mail in the window, its newest email deciding whose turn it
+ * is (`mailTurn`). `storedAt` is when sync last proved the mailbox, so a quiet day with no mail is not `stale`.
+ */
+export declare const mailActivity: (store: MessageStore, account: AccountKey, since: number, chats: Parameters<typeof queryFilter>[0] | undefined) => Promise<{
+    chats: TurnActivity[];
+    storedAt: string | null;
+    coverage: (ids: string[]) => ChatCoverage[];
+}>;

package/dist/services/agenda-mail.js

@@ -0,0 +1,66 @@
+import { CliError } from "@wirecat/cli-base";
+import { mailTurn } from "../mail/owed.js";
+import { MAIL_AGENDA_COLUMNS, queryFilter, } from "../store/store.js";
+const absent = (error) => {
+    if (error instanceof CliError && error.code === "not_found")
+        return undefined;
+    throw error;
+};
+/**
+ * `tasks agenda` over an email account: each thread with mail in the window, its newest email deciding whose turn it
+ * is (`mailTurn`). `storedAt` is when sync last proved the mailbox, so a quiet day with no mail is not `stale`.
+ */
+export const mailActivity = async (store, account, since, chats) => {
+    const stored = await store.accounts.storedAccount(account).catch(absent);
+    if (!stored)
+        return { chats: [], storedAt: null, coverage: () => [] };
+    const where = chats
+        ? queryFilter(chats, MAIL_AGENDA_COLUMNS, { command: "tasks agenda" })
+        : undefined;
+    const threads = await store.mail.threadActivity(stored.id, since, where);
+    const synced = await store.sync.syncState(account, "mail_coverage");
+    const window = (() => {
+        try {
+            return JSON.parse(synced?.value ?? "{}");
+        }
+        catch {
+            return {};
+        }
+    })();
+    const byId = new Map(threads.map((thread) => [thread.threadId, thread]));
+    return {
+        chats: threads.map((thread) => ({
+            chatId: thread.threadId,
+            title: thread.subject,
+            kind: "dialog",
+            lastMessageAt: new Date(thread.newest?.at ?? thread.lastEmailAt).toISOString(),
+            lastMessageId: thread.newest?.externalId ?? null,
+            lastFromOwner: thread.newest ? thread.newest.outgoing : null,
+            turn: mailTurn(thread.newest),
+        })),
+        storedAt: synced?.at ?? null,
+        coverage: (ids) => ids.map((chatId) => {
+            const thread = byId.get(chatId);
+            const newest = thread?.newest?.at ?? thread?.lastEmailAt;
+            const until = window.until === undefined ? Number.NaN : Date.parse(window.until);
+            return {
+                chatId,
+                title: thread?.subject ?? null,
+                completeness: {
+                    chatId,
+                    // Sync holds a window of the mailbox, never a thread's whole history.
+                    state: synced ? "partial" : "unknown",
+                    upToDate: window.state === "window" && newest !== undefined && !Number.isNaN(until) ? newest <= until : null,
+                    gaps: false,
+                    reachesStart: false,
+                    fetchedAt: synced?.at ?? null,
+                },
+                held: {
+                    messages: thread?.emails ?? 0,
+                    oldestAt: null,
+                    newestAt: newest === undefined ? null : new Date(newest).toISOString(),
+                },
+            };
+        }),
+    };
+};

package/dist/services/agenda.d.ts

@@ -79,6 +79,10 @@ export interface Agenda {
 export interface AgendaService {
     show(options?: AgendaOptions): Promise<Agenda>;
 }
+/**
+ * An email account's chats are its threads, and whose turn one is follows `mailTurn` (`../mail/owed.ts`), not merely
+ * who wrote last: mail sent to many is never owed.
+ */
 export declare const agendaService: (deps: ServiceDeps, now?: () => number) => AgendaService;
 export type AgendaItem = v.InferOutput<typeof agenda>;
 /** The agenda in entity keys, as `--json` and MCP answer it; chats become `chat:` references. */

package/dist/services/agenda.js

@@ -3,6 +3,7 @@ import { formatLocator, isLocator, parseLocator } from "../domain/locator.js";
 import { formatReference } from "../domain/references.js";
 import { agenda } from "../entities/agenda.js";
 import { AGENDA_COLUMNS, inboxKey, queryFilter, } from "../store/store.js";
+import { mailActivity } from "./agenda-mail.js";
 import { chatCoverage } from "./chat-coverage.js";
 import { CHAT_KINDS } from "./chats.js";
 import { taskAccount } from "./task-rules.js";
@@ -36,6 +37,10 @@ export const AGENDA_QUERY = {
     }),
     defaults: ["chat_kind:(dialog OR group)", "claimed:(none OR mine)"],
 };
+/**
+ * An email account's chats are its threads, and whose turn one is follows `mailTurn` (`../mail/owed.ts`), not merely
+ * who wrote last: mail sent to many is never owed.
+ */
 export const agendaService = (deps, now = Date.now) => ({
     show: async ({ dueWithin = DAY, waiting = AGENDA_DEFAULTS.waiting, unanswered = AGENDA_DEFAULTS.unanswered, within = 30 * DAY, query, holder, } = {}) => {
         const [store, account] = [await deps.store(), await deps.account()];
@@ -91,9 +96,12 @@ export const agendaService = (deps, now = Date.now) => ({
             createdAt: task.createdAt,
             assignees,
         }));
-        const where = parts.chats ? queryFilter(parts.chats, AGENDA_COLUMNS, { command: "tasks agenda" }) : undefined;
-        const activity = await store.chats.chatActivity(account, at - within, where);
+        const mail = account.provider === "email" ? await mailActivity(store, account, at - within, parts.chats) : undefined;
+        const activity = mail ??
+            (await store.chats.chatActivity(account, at - within, parts.chats ? queryFilter(parts.chats, AGENDA_COLUMNS, { command: "tasks agenda" }) : undefined));
+        const turnOf = (chat) => "turn" in chat ? chat.turn : chat.lastFromOwner === null ? null : chat.lastFromOwner ? "waiting" : "owed";
         const chats = activity.chats.map(({ lastMessageId, ...chat }) => ({
+            turn: turnOf({ lastMessageId, ...chat }),
             ...chat,
             lastMessage: lastMessageId === null
                 ? null
@@ -107,12 +115,14 @@ export const agendaService = (deps, now = Date.now) => ({
         }));
         const silentFor = (chat) => at - Date.parse(chat.lastMessageAt);
         const shown = {
-            owed: chats.filter((chat) => chat.lastFromOwner === false && silentFor(chat) >= unanswered),
-            waiting: chats.filter((chat) => chat.lastFromOwner === true && silentFor(chat) >= waiting),
-            unsynced: chats.filter((chat) => chat.lastMessage === null),
+            owed: chats.filter((chat) => chat.turn === "owed" && silentFor(chat) >= unanswered),
+            waiting: chats.filter((chat) => chat.turn === "waiting" && silentFor(chat) >= waiting),
+            // A thread with no stored email but drafts is not behind: mail sync stores every email it lists.
+            unsynced: mail ? [] : chats.filter((chat) => chat.lastMessage === null),
         };
-        const covered = new Map((await chatCoverage(store, account, Object.values(shown).flatMap((list) => list.map(({ chatId }) => chatId)))).map((one) => [one.chatId, one]));
-        const withCoverage = (list) => list.map((chat) => ({ ...chat, coverage: covered.get(chat.chatId) }));
+        const ids = Object.values(shown).flatMap((list) => list.map(({ chatId }) => chatId));
+        const covered = new Map((mail ? mail.coverage(ids) : await chatCoverage(store, account, ids)).map((one) => [one.chatId, one]));
+        const withCoverage = (list) => list.map(({ turn: _, ...chat }) => ({ ...chat, coverage: covered.get(chat.chatId) }));
         const inList = new Set((await store.tasks.categories()).map(({ name }) => name));
         const unlisted = new Map();
         for (const { category } of open)

package/dist/services/task-analysis.d.ts

@@ -0,0 +1,58 @@
+import type { ChatKind, Id, Message } from "../domain/models.js";
+import type { AccountKey, MessageStore, TaskAnalysisMark } from "../store/index.js";
+/** How many messages one read gives an agent: a page it can judge in one go. */
+export declare const ANALYSIS_PAGE = 100;
+export declare const ANALYSIS_PAGE_MAX = 1000;
+/** Where a chat never read for tasks starts, unless the caller names a time: older history is not new work. */
+export declare const defaultStart: (now: Date) => string;
+export interface ChatAnalysis {
+    chatId: Id;
+    title: string | null;
+    kind: ChatKind;
+    newestAt: string | null;
+    mark: TaskAnalysisMark | null;
+    /** Stored messages after the mark, or since the default start when the chat was never read for tasks. */
+    waiting: number;
+    /** Stored inside the read stretch after it was read: `--since <from>` reads the stretch again. */
+    late: number;
+}
+/**
+ * Every chat whose messages can hold the owner's tasks — not a channel or Saved Messages (owner, 2026-10-17) — with
+ * how far it was read for tasks and how much waits, newest chat first.
+ */
+export declare const taskAnalysisList: (store: MessageStore, account: AccountKey, now?: Date) => Promise<ChatAnalysis[]>;
+export interface UnanalysedPage {
+    mark: TaskAnalysisMark | null;
+    /** Where this read started: the mark, `since`, or the default start. */
+    from: string;
+    messages: Message[];
+    more: boolean;
+    late: number;
+}
+/**
+ * The stored messages of a chat not yet read for tasks, oldest first, from its mark; `since` reads from that time
+ * instead, to read a stretch again. Reading moves nothing: `acknowledgeTaskAnalysis` does, once the reader is done.
+ */
+export declare const unanalysedMessages: (store: MessageStore, account: AccountKey, chatId: Id, { limit, since, now }?: {
+    limit?: number;
+    since?: string;
+    now?: Date;
+}) => Promise<UnanalysedPage>;
+/**
+ * Records that the chat was read for tasks through `messageId`, from `since` when that read started there. The mark
+ * never moves back. A read that covered the whole stretch again also clears what arrived late inside it.
+ */
+export declare const acknowledgeTaskAnalysis: (store: MessageStore, account: AccountKey, chatId: Id, messageId: Id, { since, by, now }: {
+    since?: string;
+    by: string;
+    now?: Date;
+}) => Promise<{
+    mark: TaskAnalysisMark;
+    moved: boolean;
+}>;
+/**
+ * A read again of history the chat's task point already passed only updates and closes tasks (owner, 2026-11-03):
+ * a new task from such a message needs `--open-new`. A message that already has a task, or one after the point, is
+ * let through.
+ */
+export declare const refuseAlreadyRead: (store: MessageStore, account: AccountKey, source: string) => Promise<void>;

package/dist/services/task-analysis.js

@@ -0,0 +1,125 @@
+import { CliError } from "@wirecat/cli-base";
+import { isLocator, parseLocator } from "../domain/locator.js";
+import { FIRST_PASS_DAYS, RULES_IN, taskAccount } from "./task-rules.js";
+/** How many messages one read gives an agent: a page it can judge in one go. */
+export const ANALYSIS_PAGE = 100;
+export const ANALYSIS_PAGE_MAX = 1000;
+/** Where a chat never read for tasks starts, unless the caller names a time: older history is not new work. */
+export const defaultStart = (now) => new Date(now.getTime() - FIRST_PASS_DAYS * 86_400_000).toISOString();
+const after = (iso) => new Date(Date.parse(iso) + 1).toISOString();
+/** Messages saved or edited after the mark was last checked, sent inside the stretch it had read. */
+const lateOf = async (store, account, mark) => {
+    const { messages } = await store.messages.changes(account, mark.chatId, mark.checkedAt);
+    return messages.filter((one) => one.timestamp >= mark.from && one.timestamp <= mark.checkedThrough);
+};
+/**
+ * Every chat whose messages can hold the owner's tasks — not a channel or Saved Messages (owner, 2026-10-17) — with
+ * how far it was read for tasks and how much waits, newest chat first.
+ */
+export const taskAnalysisList = async (store, account, now = new Date()) => {
+    const marks = new Map((await store.sync.taskAnalysisMarks(account)).map((mark) => [mark.chatId, mark]));
+    const start = defaultStart(now);
+    const chats = [];
+    for (const chat of await store.chats.chatStats(account)) {
+        if (RULES_IN[chat.kind] === "none")
+            continue;
+        const mark = marks.get(chat.chatId) ?? null;
+        chats.push({
+            chatId: chat.chatId,
+            title: chat.title,
+            kind: chat.kind,
+            newestAt: chat.newestAt,
+            mark,
+            waiting: await store.messages.countMessages(account, chat.chatId, { since: mark ? after(mark.through) : start }),
+            late: mark ? (await lateOf(store, account, mark)).length : 0,
+        });
+    }
+    return chats.sort((a, b) => (b.newestAt ?? "").localeCompare(a.newestAt ?? ""));
+};
+/**
+ * The stored messages of a chat not yet read for tasks, oldest first, from its mark; `since` reads from that time
+ * instead, to read a stretch again. Reading moves nothing: `acknowledgeTaskAnalysis` does, once the reader is done.
+ */
+export const unanalysedMessages = async (store, account, chatId, { limit = ANALYSIS_PAGE, since, now = new Date() } = {}) => {
+    const mark = (await store.sync.taskAnalysisMark(account, chatId)) ?? null;
+    const from = since ?? mark?.through ?? defaultStart(now);
+    const byTime = { time: Date.parse(from) - (since === undefined && mark ? 0 : 1) };
+    const read = (start) => store.messages.messages(account, chatId, { limit, after: start });
+    let page;
+    if (since === undefined && mark) {
+        try {
+            page = await read({ id: mark.throughId });
+        }
+        catch (error) {
+            if (!(error instanceof CliError && error.code === "not_found"))
+                throw error;
+            page = await read(byTime);
+        }
+    }
+    else
+        page = await read(byTime);
+    return {
+        mark,
+        from,
+        messages: page.items,
+        more: page.hasMore,
+        late: mark ? (await lateOf(store, account, mark)).length : 0,
+    };
+};
+/**
+ * Records that the chat was read for tasks through `messageId`, from `since` when that read started there. The mark
+ * never moves back. A read that covered the whole stretch again also clears what arrived late inside it.
+ */
+export const acknowledgeTaskAnalysis = async (store, account, chatId, messageId, { since, by, now = new Date() }) => {
+    const message = await store.messages.message(account, messageId, { chatId });
+    if (!message)
+        throw new CliError("not_found", `message ${messageId} is not in the local copy of chat ${chatId}`);
+    const mark = await store.sync.taskAnalysisMark(account, chatId);
+    const start = since ?? mark?.from ?? defaultStart(now);
+    if (message.timestamp < start)
+        throw new CliError("validation_error", `message ${messageId} was sent before the read started (${start})`);
+    if (mark && message.timestamp < mark.from)
+        throw new CliError("validation_error", `message ${messageId} ends before the stretch already read (${mark.from}): read on to it, then acknowledge`);
+    const ahead = !mark || message.timestamp > mark.through || (since !== undefined && message.timestamp >= mark.through);
+    if (mark && !ahead && start >= mark.from)
+        return { mark, moved: false };
+    const reread = mark !== undefined && since !== undefined && since <= mark.from && ahead;
+    const checked = !mark || reread || (since === undefined && (await lateOf(store, account, mark)).length === 0);
+    const through = mark && !ahead ? mark : { through: message.timestamp, throughId: message.id };
+    const next = {
+        chatId,
+        from: mark && mark.from < start ? mark.from : start,
+        through: through.through,
+        throughId: through.throughId,
+        by,
+        checked,
+        checkedThrough: checked || !mark ? through.through : mark.checkedThrough,
+    };
+    await store.sync.setTaskAnalysisMark(account, next);
+    const saved = await store.sync.taskAnalysisMark(account, chatId);
+    if (!saved)
+        throw new Error(`the task analysis mark of chat ${chatId} was not saved`);
+    return { mark: saved, moved: true };
+};
+/**
+ * A read again of history the chat's task point already passed only updates and closes tasks (owner, 2026-11-03):
+ * a new task from such a message needs `--open-new`. A message that already has a task, or one after the point, is
+ * let through.
+ */
+export const refuseAlreadyRead = async (store, account, source) => {
+    if (!isLocator(source))
+        return;
+    const { provider, account: owner, chat, message } = parseLocator(source);
+    if (provider !== account.provider || owner !== account.account)
+        return;
+    const mark = await store.sync.taskAnalysisMark(account, chat);
+    if (!mark)
+        return;
+    const stored = await store.messages.message(account, message, { chatId: chat });
+    if (!stored || stored.timestamp > mark.through)
+        return;
+    if ((await store.tasks.findBySource(taskAccount(account), source)).length > 0)
+        return;
+    throw new CliError("validation_error", `${source} was already read for tasks (the point is at ${mark.through}): a read again only updates and closes ` +
+        "tasks; add --open-new to open a task from it anyway", { reason: "task.already-read" });
+};

package/dist/store/exports.d.ts

@@ -23,6 +23,7 @@ export { storeClients } from "./sqlite/clients.js";
 export { CHAT_LIST_KEY, type ChatCompleteness, fetchedKey, historyStartKey } from "./sqlite/completeness.js";
 export { CONVERSATION_COLUMNS } from "./sqlite/conversations.js";
 export type { CounterTarget } from "./sqlite/counters.js";
+export { type EmailMarks, MAIL_AGENDA_COLUMNS, type MarkedEmail, type NewestEmail, type ThreadActivity, } from "./sqlite/email-activity.js";
 export { messageOfEmail, threadConversation } from "./sqlite/emails.js";
 export { orphanPointers } from "./sqlite/entity-types.js";
 export { involvementStoreOver } from "./sqlite/involvements.js";
@@ -60,5 +61,5 @@ export type { MatchPlace, ScoredHit } from "./sqlite/words.js";
 export type { TaskDetails } from "./sqlite/work-tasks.js";
 export type { SyncStore } from "./sync.js";
 export type { TagsStore } from "./tags.js";
-export type { AccountKey, AccountMessageFilter, AgentAnswer, BatchMessage, ChatActivity, ChatStats, ConversationBuild, ConversationHit, ConversationSummary, DeletionScope, Delta, IdentityRef, IngestedVia, LinkBatch, LinkedIdentity, LinkOptions, MessageFilter, PersonFacts, PersonRecord, PictureInput, Range, SenderChatStats, StoredAccount, StoredChatFilter, StoredHit, StoredLink, StoredReadiness, } from "./types.js";
+export type { AccountKey, AccountMessageFilter, AgentAnswer, BatchMessage, ChatActivity, ChatStats, ConversationBuild, ConversationHit, ConversationSummary, DeletionScope, Delta, IdentityRef, IngestedVia, LinkBatch, LinkedIdentity, LinkOptions, MessageFilter, PersonFacts, PersonRecord, PictureInput, Range, SenderChatStats, StoredAccount, StoredChatFilter, StoredHit, StoredLink, StoredReadiness, TaskAnalysisMark, TaskAnalysisMarkWrite, } from "./types.js";
 export type { AccountVectors, VectorsStore } from "./vectors.js";

package/dist/store/exports.js

@@ -6,6 +6,7 @@ export { CHAT_COLUMNS, TRACKED_CHAT_COLUMNS, titlePart } from "./sqlite/chats.js
 export { storeClients } from "./sqlite/clients.js";
 export { CHAT_LIST_KEY, fetchedKey, historyStartKey } from "./sqlite/completeness.js";
 export { CONVERSATION_COLUMNS } from "./sqlite/conversations.js";
+export { MAIL_AGENDA_COLUMNS, } from "./sqlite/email-activity.js";
 export { messageOfEmail, threadConversation } from "./sqlite/emails.js";
 export { orphanPointers } from "./sqlite/entity-types.js";
 export { involvementStoreOver } from "./sqlite/involvements.js";

package/dist/store/index.d.ts

@@ -71,4 +71,4 @@ export type { StoreTaskStore } from "./sqlite/tasks.js";
 export type { TagPreflight, VocabularyAlias, VocabularyAliasReceipt, VocabularyAudit, VocabularyAuditOptions, VocabularyCatalog, VocabularyEntry, VocabularyKind, VocabularyOptions, VocabularyResolution, VocabularyStore, VocabularyTarget, } from "./sqlite/vocabulary.js";
 export type { BoardCounts, BoardOptions, NewWorkTask, RevisionCheck, TaskAssignment, TaskDetails, TaskEvent, TaskFields, TaskMove, TaskMoved, TaskRole, TaskType, WorkTaskType, } from "./sqlite/work-tasks.js";
 export { TASK_EVENT_KINDS, TASK_ROLES } from "./sqlite/work-tasks.js";
-export { type AccountAccounts, type AccountAttachments, type AccountCounters, type AccountKey, type AccountMentions, type AccountMessageFilter, type AccountMessages, type AccountPeople, type AccountsStore, type AccountVectors, type AttachmentsStore, type AttachmentTextEntry, type AttachmentView, type ChatStats, type ChatsStore, type ConversationsStore, type CountersStore, type DeletionScope, type Delta, type FileAttachment, type IdentityRef, type IngestedVia, type LinkedIdentity, type LinkOptions, MENTION_QUERY, MENTION_STATUSES, type MentionsStore, type MessageFilter, type MessageStore, type MessagesStore, OTHER_SOURCES, openStore, type PeopleStore, type PersonFacts, type PersonRecord, type QueriesStore, type Range, type RankedEvidence, type RankedStoreFound, type RankedStoreRow, type RankingEvidenceItem, type RankingEvidenceRequest, type RankingRequest, type RosterStore, type SearchCommand, type SearchesStore, type SearchIndexStore, type SearchRecord, type StoredAccount, type StoredChatFilter, type StoredHit, type StoredSearch, type StoredTag, type StoreOptions, type SyncStore, type TagFilter, type TagsStore, type TagTarget, type TaskTagTarget, type TextOrigin, type VectorsStore, } from "./store.js";
+export { type AccountAccounts, type AccountAttachments, type AccountCounters, type AccountKey, type AccountMentions, type AccountMessageFilter, type AccountMessages, type AccountPeople, type AccountsStore, type AccountVectors, type AttachmentsStore, type AttachmentTextEntry, type AttachmentView, type ChatStats, type ChatsStore, type ConversationsStore, type CountersStore, type DeletionScope, type Delta, type FileAttachment, type IdentityRef, type IngestedVia, type LinkedIdentity, type LinkOptions, MENTION_QUERY, MENTION_STATUSES, type MentionsStore, type MessageFilter, type MessageStore, type MessagesStore, OTHER_SOURCES, openStore, type PeopleStore, type PersonFacts, type PersonRecord, type QueriesStore, type Range, type RankedEvidence, type RankedStoreFound, type RankedStoreRow, type RankingEvidenceItem, type RankingEvidenceRequest, type RankingRequest, type RosterStore, type SearchCommand, type SearchesStore, type SearchIndexStore, type SearchRecord, type StoredAccount, type StoredChatFilter, type StoredHit, type StoredSearch, type StoredTag, type StoreOptions, type SyncStore, type TagFilter, type TagsStore, type TagTarget, type TaskAnalysisMark, type TaskAnalysisMarkWrite, type TaskTagTarget, type TextOrigin, type VectorsStore, } from "./store.js";

package/dist/store/sqlite/email-activity.d.ts

@@ -0,0 +1,93 @@
+import type { CacheDatabase } from "../driver.js";
+import type { Where } from "./query-filter.js";
+/** What decides whose turn a thread is, read from its newest email that is not a draft; never its text. */
+export interface NewestEmail {
+    externalId: string;
+    /** ms: when it was received, or sent when that is unknown. */
+    at: number;
+    outgoing: boolean;
+    /** The mailbox's own address is in To or Cc. */
+    addressed: boolean;
+    /** Filed in the mailbox of mail sent to many. */
+    bulk: boolean;
+    /** Carries a List-Id. */
+    list: boolean;
+    /** Recorded by an envelope rule, without its text. */
+    envelope: boolean;
+    /** Its sender's mail looks like spam, a scam or a robot (the sender score). */
+    demoted: boolean;
+}
+/** One thread with mail after a time: `tasks agenda` and `review` read this, never the emails' text. */
+export interface ThreadActivity {
+    /** The thread's external id: what a `chat:email/…` reference names. */
+    threadId: string;
+    subject: string | null;
+    /** ms. */
+    lastEmailAt: number;
+    emails: number;
+    /** `null` when every email of the thread is a draft. */
+    newest: NewestEmail | null;
+}
+/** What a reader sorts mail by, per email: never its text. */
+export interface EmailMarks {
+    /** Filed in the mailbox of mail sent to many. */
+    bulk: boolean;
+    listId: string | null;
+    /** The mail rule that decided how it is stored, by its id in `rules list`. */
+    ruleId: number | null;
+}
+/** One email as a processing mark sees it, by its store id; never its text. */
+export interface MarkedEmail {
+    id: number;
+    externalId: string;
+    thread: string;
+    /** ms: received, or sent when that is unknown. */
+    at: number | null;
+    /** ms: when the store saved it first, and last changed it. */
+    storedAt: number;
+    changedAt: number;
+    /** Sent to many: the bulk mailbox or a List-Id. */
+    bulk: boolean;
+    envelope: boolean;
+    /** Stored from its first bytes, not whole yet. */
+    partial: boolean;
+    draft: boolean;
+}
+export interface MailActivityStore {
+    /**
+     * The account's live emails stored after `afterId`, oldest first, at most `limit`, and those of `ids`: what a
+     * processing mark reads next. The id is the store's insert order, so mail stored late is never behind the mark.
+     */
+    emailsAfter(accountId: number, afterId: number, limit: number, ids?: readonly number[]): Promise<MarkedEmail[]>;
+    /** The account's newest store id; 0 with no mail. */
+    newestEmailId(accountId: number): Promise<number>;
+    /** Every `sync_cursors` value of the account whose key starts with `prefix`. */
+    statesLike(accountId: number, prefix: string): Promise<{
+        key: string;
+        value: string;
+        at: number;
+    }[]>;
+    /** Each live email's marks, by its Message-ID; one the store does not hold is left out. */
+    emailMarks(accountId: number, externalIds: readonly string[]): Promise<Map<string, EmailMarks>>;
+    /**
+     * Each live thread of the account whose newest email is after `since` (ms), newest first, with the facts of that
+     * email. `where` is a `tasks agenda` query compiled over `MAIL_AGENDA_COLUMNS`.
+     */
+    threadActivity(accountId: number, since: number, where?: Where): Promise<ThreadActivity[]>;
+}
+/** `tasks agenda` fields over `threadActivity`'s threads: an email thread counts as a dialog. */
+export declare const MAIL_AGENDA_COLUMNS: {
+    readonly chat_kind: {
+        readonly type: "enum";
+        readonly sql: "'dialog'";
+    };
+};
+export declare const threadActivity: (database: CacheDatabase, accountId: number, since: number, where?: Where) => ThreadActivity[];
+/** A thread's live emails, oldest first; `window` keeps those received in (after, until], in ms. */
+export declare const threadEmailIds: (database: CacheDatabase, accountId: number, thread: string, { after, until }?: {
+    after?: number;
+    until?: number;
+}) => number[];
+export declare const emailMarks: (database: CacheDatabase, accountId: number, externalIds: readonly string[]) => Map<string, EmailMarks>;
+export declare const emailsAfter: (database: CacheDatabase, accountId: number, afterId: number, limit: number, ids?: readonly number[]) => MarkedEmail[];
+export declare const mailActivity: (database: CacheDatabase) => MailActivityStore;