@wirecat/cli-core 0.562.0 → 0.563.0

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;

package/dist/services/reply-stats.js

@@ -0,0 +1,137 @@
+import { CliError } from "@wirecat/cli-base";
+import { parseLucene, timezoneOf } from "@wirecat/cli-base/query";
+import { delayStats } from "../domain/admin-statistics.js";
+import { calendarKey } from "../domain/calendar.js";
+import { rankingQuestion } from "../domain/rankings-options.js";
+import { MESSAGE_PARSING } from "../search/lucene/types.js";
+import { prepareLucene } from "./messages-search.js";
+const FIELDS = ["date", "chat", "kind"];
+/** Per waiting chat, how far back its unanswered messages are counted. */
+export const WAITING_TAIL = 100;
+/** Only AND-ed `date:`, `chat:` and `kind:` terms: each becomes an index bound, so no query reads every message. */
+const plainOnly = (text, command) => {
+    if (text === undefined)
+        return;
+    const refuse = () => {
+        throw new CliError("validation_error", `${command} reads date:, chat: and kind: terms, AND-ed — not words, other fields, OR or NOT`, { reason: "query.unsupported-field" });
+    };
+    const visit = (node) => {
+        if (node.kind === "boolean")
+            for (const clause of node.clauses) {
+                if (clause.occur !== "must")
+                    refuse();
+                visit(clause.node);
+            }
+        else if (!FIELDS.includes(node.field) || !["term", "phrase", "range"].includes(node.operator))
+            refuse();
+    };
+    visit(parseLucene(text, { ...MESSAGE_PARSING, defaultField: "text" }).root);
+};
+const scopeOf = (root, accounts) => {
+    const scope = { accounts, chats: [], kinds: [] };
+    const visit = (node) => {
+        if (node.kind === "boolean") {
+            for (const clause of node.clauses)
+                visit(clause.node);
+            return;
+        }
+        const { chat, date } = node.resolution ?? {};
+        if (chat)
+            scope.chats.push(chat);
+        else if (node.field === "kind")
+            scope.kinds.push(node.value.toLowerCase());
+        else if (date) {
+            if (date.lower !== undefined) {
+                const lower = date.lower + (date.lower_inclusive ? 0 : 1);
+                scope.since = Math.max(scope.since ?? lower, lower);
+            }
+            if (date.upper !== undefined) {
+                const upper = date.upper - (date.upper_inclusive ? 0 : 1);
+                scope.until = Math.min(scope.until ?? upper, upper);
+            }
+        }
+    };
+    visit(root);
+    return scope;
+};
+const figuresOf = (delays) => {
+    const { medianMilliseconds, p90Milliseconds } = delayStats(delays);
+    return {
+        replies: delays.length,
+        medianMs: medianMilliseconds,
+        p90Ms: p90Milliseconds,
+        meanMs: delays.length ? Math.round(delays.reduce((sum, one) => sum + one, 0) / delays.length) : null,
+    };
+};
+const MINUTE = 60_000;
+/** 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 const waitsOnOwner = (newest) => {
+    if (newest.mine)
+        return false;
+    if (newest.kind === "private")
+        return !newest.quiet && rankingQuestion(newest.text);
+    return (newest.addressed ||
+        (newest.ownerUsername !== null &&
+            new RegExp(`(^|[^\\w@])@${newest.ownerUsername.replace(/[^\w]/g, "\\$&")}(?!\\w)`, "i").test(newest.text)));
+};
+export const replyStatsService = (deps) => {
+    const prepared = async (query, command) => {
+        plainOnly(query.text, command);
+        const store = await deps.store();
+        const found = await prepareLucene(store, await deps.account(), {
+            ...(query.text === undefined ? {} : { text: query.text }),
+            ...(query.source === undefined ? {} : { source: query.source }),
+            timezone: timezoneOf(query.timezone),
+            limit: 1,
+        }, deps.messenger);
+        return { store, timezone: found.timezone, scope: scopeOf(found.execution.root, found.scopeAccounts) };
+    };
+    return {
+        responses: async ({ who, by, ...query }) => {
+            const { store, timezone, scope } = await prepared(query, "stats messages responses");
+            const delays = scope.accounts.length ? await store.queries.replyDelays(scope, who) : [];
+            const buckets = { under5m: 0, under1h: 0, under1d: 0, over1d: 0 };
+            for (const { delayMs } of delays) {
+                if (delayMs < 5 * MINUTE)
+                    buckets.under5m++;
+                else if (delayMs < 60 * MINUTE)
+                    buckets.under1h++;
+                else if (delayMs < 24 * 60 * MINUTE)
+                    buckets.under1d++;
+                else
+                    buckets.over1d++;
+            }
+            const days = new Map();
+            if (by === "day") {
+                const keyOf = calendarKey(timezone, "day");
+                for (const { repliedAt, delayMs } of delays) {
+                    const key = keyOf(repliedAt);
+                    const list = days.get(key) ?? [];
+                    list.push(delayMs);
+                    days.set(key, list);
+                }
+            }
+            return {
+                who,
+                by,
+                ...figuresOf(delays.map(({ delayMs }) => delayMs)),
+                buckets,
+                rows: [...days].sort(([a], [b]) => a.localeCompare(b)).map(([key, list]) => ({ key, ...figuresOf(list) })),
+            };
+        },
+        waiting: async (query) => {
+            const { store, scope } = await prepared(query, "stats messages waiting");
+            const chats = scope.accounts.length ? await store.queries.waitingChats(scope, waitsOnOwner, WAITING_TAIL) : [];
+            const firsts = chats.flatMap(({ unanswered }) => unanswered.at(-1) ?? []);
+            return {
+                chats: chats.length,
+                messages: chats.reduce((sum, { unanswered }) => sum + unanswered.length, 0),
+                oldestAt: firsts.length ? new Date(firsts.reduce((low, one) => Math.min(low, one))).toISOString() : null,
+                byKind: {
+                    private: chats.filter(({ kind }) => kind === "private").length,
+                    group: chats.filter(({ kind }) => kind === "group").length,
+                },
+            };
+        },
+    };
+};

package/dist/store/decisions.d.ts

@@ -21,6 +21,12 @@ export type Decider = "owner" | {
     model?: string;
     reason: string;
 };
+export interface DecidedRow {
+    id: string;
+    proposedBy: Proposer;
+    ownerOnly?: boolean;
+    kind?: string;
+}
 export interface DecisionPolicy {
     /** The host's `agent_decisions`: off unless the owner sets it to `true`; off keeps every decision with the owner. */
     agentDecisions: boolean;
@@ -34,17 +40,18 @@ export interface Refusal {
     reason: string;
     message: string;
 }
+/**
+ * Stored proposal kinds only the owner decides, whatever `agent_decisions` says. Read from the row's kind, so a path
+ * that sees the row as something else — a generic action, a host's own kind — still refuses an agent.
+ */
+export declare const isOwnerOnlyKind: (kind: string | undefined) => boolean;
 /**
  * The one check every decide path runs before it confirms or rejects a proposal. `null` means allowed. Every Claude
  * Code session is the bot `claude-code`, so comparing bot names keeps one session from deciding another's proposal.
  */
 export declare const mayDecide: (
-/** `ownerOnly`: what only the owner may say, such as that a payment was made. */
-row: {
-    id: string;
-    proposedBy: Proposer;
-    ownerOnly?: boolean;
-}, by: Decider, policy?: DecisionPolicy) => Refusal | null;
+/** `ownerOnly`: what only the owner may say, such as that a payment was made; `kind`: the stored kind. */
+row: DecidedRow, by: Decider, policy?: DecisionPolicy) => Refusal | null;
 /** One bot whatever its letter case or spacing: `Claude-Code` is `claude-code`. */
 export declare const botKey: (name: string) => string;
 /**
@@ -59,11 +66,7 @@ export declare const assertMayWithdraw: (row: {
     bot: string;
 }) => void;
 /** `mayDecide` for a store method: throws the refusal instead of returning it. */
-export declare const assertMayDecide: (row: {
-    id: string;
-    proposedBy: Proposer;
-    ownerOnly?: boolean;
-}, by: Decider, policy?: DecisionPolicy) => void;
+export declare const assertMayDecide: (row: DecidedRow, by: Decider, policy?: DecisionPolicy) => void;
 /** The author a decision is recorded under. */
 export declare const deciderAuthor: (by: Decider) => "owner" | {
     bot: string;

package/dist/store/decisions.js

@@ -1,11 +1,18 @@
 import { CliError } from "@wirecat/cli-base";
+import { MEETING_FINDINGS_KIND } from "../meetings/index.js";
+import { MAIL_FINDINGS_KIND } from "./mail-findings.js";
 export const DEFAULT_DECISION_POLICY = { agentDecisions: false, ruleProposalsOwnerOnly: true };
+/**
+ * Stored proposal kinds only the owner decides, whatever `agent_decisions` says. Read from the row's kind, so a path
+ * that sees the row as something else — a generic action, a host's own kind — still refuses an agent.
+ */
+export const isOwnerOnlyKind = (kind) => kind === MAIL_FINDINGS_KIND || kind === MEETING_FINDINGS_KIND;
 /**
  * The one check every decide path runs before it confirms or rejects a proposal. `null` means allowed. Every Claude
  * Code session is the bot `claude-code`, so comparing bot names keeps one session from deciding another's proposal.
  */
 export const mayDecide = (
-/** `ownerOnly`: what only the owner may say, such as that a payment was made. */
+/** `ownerOnly`: what only the owner may say, such as that a payment was made; `kind`: the stored kind. */
 row, by, policy = DEFAULT_DECISION_POLICY) => {
     if (by === "owner")
         return null;
@@ -15,7 +22,7 @@ row, by, policy = DEFAULT_DECISION_POLICY) => {
         reason,
         message,
     });
-    if (row.ownerOnly)
+    if (row.ownerOnly || isOwnerOnlyKind(row.kind))
         return refuse("permission_error", "proposal.owner-only", `only the owner decides ${row.id}`);
     if (!policy.agentDecisions)
         return refuse("permission_error", "proposals.agent-decisions-off", "agent decisions are turned off; the owner decides");

package/dist/store/index.d.ts

@@ -9,7 +9,7 @@ export type { FindingEvidence, FindingOutcome, MeetingFactFinding, MeetingFindin
 export { PAYMENT_DIRECTIONS, PAYMENT_STATES, type Payment, paymentTitle, validatePayment } from "../meetings/index.js";
 export { CLOSED_STATES, isClosedState, PRIORITY_LABELS, type PriorityLabel, priorityLabel, priorityOf, priorityOption, TASK_STATES, type TaskState, } from "../tasks/index.js";
 export type { AccountMail, AccountMeetings, AccountStore } from "./account-store.js";
-export { assertMayDecide, DEFAULT_DECISION_POLICY, type Decider, type DecisionPolicy, mayDecide, type Proposer, type Refusal, } from "./decisions.js";
+export { assertMayDecide, DEFAULT_DECISION_POLICY, type Decider, type DecisionPolicy, isOwnerOnlyKind, mayDecide, type Proposer, type Refusal, } from "./decisions.js";
 export type { DocumentTransferOptions, DocumentTransferPreview, DocumentTransferReceipt, } from "./document-transfer/index.js";
 export { applyDocumentTransfer, previewDocumentTransfer } from "./document-transfer/index.js";
 export type { CacheDatabase, CacheStatement, OpenDatabase, SqlValue } from "./driver.js";
@@ -54,7 +54,7 @@ export type { NoteIndexState } from "./sqlite/note-index.js";
 export { type NearestNote, NOTE_FIELDS, type NoteChunkToEmbed, type NoteHit, type NoteQuery, type NoteSearch, } from "./sqlite/note-search.js";
 export type { FileNoteInput, Link, LinkInput, LinkListFilter, Note, NoteFolder, NotesStore, NoteTag, } from "./sqlite/notes.js";
 export type { PrivateContact, PrivateContactNote } from "./sqlite/private-people.js";
-export { PROPOSAL_STATUSES, type ProposalInput, type ProposedAction, type ProposedActionsStore, proposerOfAction, } from "./sqlite/proposed-actions.js";
+export { assertGenericAction, PROPOSAL_STATUSES, type ProposalInput, type ProposedAction, type ProposedActionsStore, proposerOfAction, } from "./sqlite/proposed-actions.js";
 export type { RecordKey, RecordOutcome, RecordStore, RecordsWritten, SourceRecord, } from "./sqlite/records.js";
 export type { LinkDecision, RelationUpdate } from "./sqlite/relation-proposals.js";
 export { fillSearchIndex, resetSearchIndex, type SearchIndexFill, type SearchIndexState, searchIndexState, } from "./sqlite/search-index.js";
@@ -72,6 +72,6 @@ export type { TaskRelation, TaskRelationKind, TaskRelationsStore } from "./sqlit
 export { TASK_RELATION_KINDS } from "./sqlite/task-relations.js";
 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 type { BoardCounts, BoardOptions, EditedTask, MovedSubtask, 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 TaskAnalysisMark, type TaskAnalysisMarkWrite, type TaskTagTarget, type TextOrigin, type VectorsStore, } from "./store.js";