@wirecat/cli-core 0.561.0 → 0.563.0

package/dist/mail/cli/review.js

@@ -29,31 +29,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 +80,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 +112,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) => ({
@@ -165,12 +175,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` }] : []),
@@ -254,7 +262,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,5 @@
 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";
@@ -29,3 +30,4 @@ export type { Listed, MailSource, Quick, Searched } from "./source.js";
 export { SEARCH_REFUSED, searchRefused } from "./source.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,5 @@
 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";
@@ -28,3 +29,4 @@ export { searchMailServer } from "./server-search.js";
 export { SEARCH_REFUSED, searchRefused } from "./source.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/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,69 @@
+import { CliError } from "@wirecat/cli-base";
+import { mailAccountKey } from "./account-key.js";
+import { readAttachments } from "./attachments.js";
+import { parsedEmail } from "./email-input.js";
+import { mailHeadersOf } from "./headers.js";
+import { 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, maxAttachmentChars, loadEngine, 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/services/index.d.ts

@@ -49,6 +49,7 @@ import { type PeopleService } from "./people.js";
 import { type PicturesService } from "./pictures.js";
 import { privatePeopleService } from "./private-people.js";
 import { type RankingsService } from "./rankings.js";
+import { type ReplyStatsService } from "./reply-stats.js";
 import { type RetentionService } from "./retention.js";
 import { type SearchesService } from "./searches.js";
 import { type TagsService } from "./tags.js";
@@ -119,6 +120,7 @@ export interface Services {
     counters: CountersService;
     retention: RetentionService;
     rankings: RankingsService;
+    replyStats: ReplyStatsService;
     topics: TopicsService;
     messages: MessagesService;
     chats: ChatsService;

package/dist/services/index.js

@@ -40,6 +40,7 @@ import { peopleService } from "./people.js";
 import { picturesService, withPictures } from "./pictures.js";
 import { privatePeopleService } from "./private-people.js";
 import { rankingsService } from "./rankings.js";
+import { replyStatsService } from "./reply-stats.js";
 import { retentionService } from "./retention.js";
 import { searchesService } from "./searches.js";
 import { tagsService } from "./tags.js";
@@ -89,6 +90,7 @@ export const servicesFor = (deps) => {
         counters: countersService(deps),
         retention: retentionService(deps),
         rankings: rankingsService(deps),
+        replyStats: replyStatsService(deps),
         topics: topicsService(deps),
         messages: withPictures(messagesService(deps), pictures),
         chats: chatsService(deps),

package/dist/services/proposal-tasks.js

@@ -1,8 +1,6 @@
 import { CliError } from "@wirecat/cli-base";
-import { MEETING_FINDINGS_KIND } from "../meetings/index.js";
 import { assertMayDecide } from "../store/decisions.js";
-import { EVIDENCE_FINDINGS_KIND } from "../store/evidence-findings.js";
-import { proposerOfAction } from "../store/index.js";
+import { assertGenericAction, proposerOfAction } from "../store/index.js";
 import { createTaskService } from "../tasks/index.js";
 import { taskAccount } from "./task-rules.js";
 /** The source a proposal's task keeps: found again on a retry, so one proposal never makes two tasks. */
@@ -13,19 +11,12 @@ export const proposalSource = (id) => `proposed-action:${id}`;
  */
 export const approveAsTask = async (store, id, by) => {
     const proposal = await store.proposedActions.get(id);
-    if (proposal.kind === MEETING_FINDINGS_KIND)
-        throw new CliError("validation_error", "review meeting findings through the dedicated findings command", {
-            reason: "meeting-findings.dedicated-review",
-        });
-    if (proposal.kind === EVIDENCE_FINDINGS_KIND)
-        throw new CliError("validation_error", "review evidence findings through the dedicated findings command", {
-            reason: "evidence-findings.dedicated-review",
-        });
+    assertGenericAction(proposal.kind);
     if (proposal.status !== "proposed")
         throw new CliError("validation_error", `a ${proposal.status} action cannot be approved`, {
             reason: "proposal.wrong-state",
         });
-    assertMayDecide({ id: proposal.id, proposedBy: proposerOfAction(proposal) }, by, store.decisionPolicy);
+    assertMayDecide({ id: proposal.id, kind: proposal.kind, proposedBy: proposerOfAction(proposal) }, by, store.decisionPolicy);
     if (proposal.account === null)
         throw new CliError("validation_error", "a proposal names the account that would act; this one names none");
     const { task } = await createTaskService({ store: store.tasks }).add({

package/dist/services/proposals/kinds/action.js

@@ -1,5 +1,5 @@
 import { MEETING_FINDINGS_KIND } from "../../../meetings/index.js";
-import { proposerOfAction } from "../../../store/index.js";
+import { EVIDENCE_FINDINGS_KIND, isOwnerOnlyKind, MAIL_FINDINGS_KIND, proposerOfAction, } from "../../../store/index.js";
 import { approveAsTask } from "../../proposal-tasks.js";
 import { actionStatus, kept, projectOf, pushed, storedStatus } from "./shared.js";
 const rowOf = (action) => ({
@@ -17,6 +17,7 @@ const rowOf = (action) => ({
     signals: null,
     parts: null,
     createdAt: action.createdAt,
+    ...(isOwnerOnlyKind(action.kind) ? { ownerOnly: true } : {}),
 });
 /**
  * Every stored proposal no other kind claims: a reply, a ban, a task to create. Confirming makes it the owner's task
@@ -27,7 +28,7 @@ export const actionKind = (store, claimed) => ({
     list: async (filter) => {
         const status = storedStatus(filter);
         const actions = await store.proposedActions.list({
-            except: [...claimed(), MEETING_FINDINGS_KIND],
+            except: [...claimed(), MEETING_FINDINGS_KIND, EVIDENCE_FINDINGS_KIND, MAIL_FINDINGS_KIND],
             ...(status === undefined ? {} : { status }),
             ...pushed(filter),
         });

package/dist/services/proposals/registry.js

@@ -10,6 +10,7 @@ import { memoryKind } from "./kinds/memory.js";
 import { relationshipKind } from "./kinds/relationship.js";
 import { relationshipUpdateKind } from "./kinds/relationship-update.js";
 const PREFIX = /^([a-z][a-z_]*):/;
+const marked = (kind, row) => kind.ownerOnly ? { ...row, ownerOnly: true } : row;
 const refusalOf = (id, error) => {
     if (!(error instanceof CliError))
         throw error;
@@ -51,12 +52,15 @@ export const emptyProposalRegistry = (store) => {
                 throw new CliError("validation_error", "a proposal list takes a nonnegative offset");
             const asked = filter.kinds === undefined ? kinds : kinds.filter((kind) => filter.kinds?.includes(kind.kind));
             const wide = { ...filter, offset: 0, limit: filter.offset + filter.limit + 1 };
-            const rows = (await Promise.all(asked.map((kind) => kind.list(wide)))).flat();
+            const rows = (await Promise.all(asked.map(async (kind) => (await kind.list(wide)).map((row) => marked(kind, row))))).flat();
             rows.sort((a, b) => b.createdAt.localeCompare(a.createdAt) || b.id.localeCompare(a.id));
             const page = rows.slice(filter.offset, filter.offset + filter.limit + 1);
             return { items: page.slice(0, filter.limit), hasMore: page.length > filter.limit };
         },
-        get: async (id) => (await kindOf(id)).get(id),
+        get: async (id) => {
+            const kind = await kindOf(id);
+            return marked(kind, await kind.get(id));
+        },
         decide: async (ids, decision) => {
             const parts = new Map();
             const whole = new Set();
@@ -89,7 +93,7 @@ export const emptyProposalRegistry = (store) => {
                         refuseIds(id, `a ${kind.kind} proposal has no parts; name ${id} alone`);
                         continue;
                     }
-                    const row = await kind.get(id);
+                    const row = marked(kind, await kind.get(id));
                     if (row.status !== "proposed") {
                         refused.push({
                             id,
@@ -99,7 +103,7 @@ export const emptyProposalRegistry = (store) => {
                         });
                         continue;
                     }
-                    const refusal = mayDecide(kind.ownerOnly ? { ...row, ownerOnly: true } : row, decision.by, policy);
+                    const refusal = mayDecide(row, decision.by, policy);
                     if (refusal) {
                         refused.push(refusal);
                         continue;

package/dist/services/proposals/types.d.ts

@@ -28,6 +28,8 @@ export interface ProposalRow {
         outcome: "accepted" | "rejected" | null;
     }[] | null;
     createdAt: string;
+    /** Only the owner decides it: its kind says so, whichever path decides it. */
+    ownerOnly?: boolean;
 }
 export interface ProposalFilter {
     project?: string;

package/dist/services/reply-stats.d.ts

@@ -0,0 +1,48 @@
+import type { NewestMessage } from "../store/store.js";
+import type { ServiceDeps } from "./deps.js";
+export type ReplyWho = "me" | "others";
+export interface ReplyFigures {
+    replies: number;
+    medianMs: number | null;
+    p90Ms: number | null;
+    meanMs: number | null;
+}
+export interface ReplyTimes extends ReplyFigures {
+    who: ReplyWho;
+    by: "day" | "total";
+    buckets: {
+        under5m: number;
+        under1h: number;
+        under1d: number;
+        over1d: number;
+    };
+    rows: (ReplyFigures & {
+        key: string;
+    })[];
+}
+export interface Waiting {
+    chats: number;
+    messages: number;
+    oldestAt: string | null;
+    byKind: {
+        private: number;
+        group: number;
+    };
+}
+export interface ReplyQuery {
+    text?: string;
+    source?: string;
+    timezone?: string;
+}
+export interface ReplyStatsService {
+    responses(query: ReplyQuery & {
+        who: ReplyWho;
+        by: "day" | "total";
+    }): Promise<ReplyTimes>;
+    waiting(query: ReplyQuery): Promise<Waiting>;
+}
+/** Per waiting chat, how far back its unanswered messages are counted. */
+export declare const WAITING_TAIL = 100;
+/** Asks the owner something: a question in a one-to-one chat; in a group, a mention by id or `@handle`, or a reply. */
+export declare const waitsOnOwner: (newest: NewestMessage) => boolean;
+export declare const replyStatsService: (deps: ServiceDeps) => ReplyStatsService;