@wirecat/cli-core 0.561.0 → 0.563.0

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";

package/dist/store/index.js

@@ -3,7 +3,7 @@ export { createTagRedirectIndex } from "../domain/tag-redirects.js";
 export { note } from "../entities/note.js";
 export { PAYMENT_DIRECTIONS, PAYMENT_STATES, paymentTitle, validatePayment } from "../meetings/index.js";
 export { CLOSED_STATES, isClosedState, PRIORITY_LABELS, priorityLabel, priorityOf, priorityOption, TASK_STATES, } from "../tasks/index.js";
-export { assertMayDecide, DEFAULT_DECISION_POLICY, mayDecide, } from "./decisions.js";
+export { assertMayDecide, DEFAULT_DECISION_POLICY, isOwnerOnlyKind, mayDecide, } from "./decisions.js";
 export { applyDocumentTransfer, previewDocumentTransfer } from "./document-transfer/index.js";
 export { PRAGMAS } from "./driver.js";
 export { EVIDENCE_FINDINGS_KIND, validateEvidenceFindings, } from "./evidence-findings.js";
@@ -24,7 +24,7 @@ export { EVENT_FIELDS, } from "./sqlite/event-search.js";
 export { IMPORTED_DOCUMENT_QUERY } from "./sqlite/imported-documents.js";
 export { ORGANIZATION_KINDS, PROJECT_TYPES, SCOPES } from "./sqlite/knowledge.js";
 export { NOTE_FIELDS, } from "./sqlite/note-search.js";
-export { PROPOSAL_STATUSES, proposerOfAction, } from "./sqlite/proposed-actions.js";
+export { assertGenericAction, PROPOSAL_STATUSES, proposerOfAction, } from "./sqlite/proposed-actions.js";
 export { fillSearchIndex, resetSearchIndex, searchIndexState, } from "./sqlite/search-index.js";
 export { PROJECT_TASK_FIELDS, TASK_SORTS } from "./sqlite/task-board.js";
 export { certaintyOf } from "./sqlite/task-close.js";

package/dist/store/queries.d.ts

@@ -7,6 +7,7 @@ import type { QueryGroup, QueryGrouping } from "./sqlite/lucene.js";
 import type { StoreContext } from "./sqlite/open.js";
 import { type RankedEvidence, type RankingEvidenceRequest } from "./sqlite/ranking-evidence.js";
 import { type RankedStoreFound, type RankingRequest } from "./sqlite/rankings.js";
+import { type ChatScope, type NewestMessage, type ReplyDelay, type WaitingChat } from "./sqlite/reply-times.js";
 import type { ScoredHit } from "./sqlite/words.js";
 /** A resolved Lucene query run over the store: hits, counts, rankings and the statistics behind them. */
 export interface QueriesStore {
@@ -21,5 +22,8 @@ export interface QueriesStore {
     rankQuery(execution: QueryExecution, request: RankingRequest): Promise<RankedStoreFound>;
     rankingEvidence(execution: QueryExecution, request: RankingEvidenceRequest): Promise<RankedEvidence>;
     adminStatisticsQuery(execution: QueryExecution, request: AdminStoreRequest): Promise<AdminStoreResult>;
+    /** Every reply in one-to-one chats whose reply falls in the scope's period, with how long it took. */
+    replyDelays(scope: ChatScope, who: "me" | "others"): Promise<ReplyDelay[]>;
+    waitingChats(scope: ChatScope, waits: (newest: NewestMessage) => boolean, cap: number): Promise<WaitingChat[]>;
 }
 export declare const queriesStoreOver: (context: StoreContext, stemmerFor: (stemmers: Stemmers) => Stemmer) => QueriesStore;

package/dist/store/queries.js

@@ -4,6 +4,7 @@ import { drainEmailIndex } from "./sqlite/email-index.js";
 import * as lucene from "./sqlite/lucene.js";
 import { rankingEvidence } from "./sqlite/ranking-evidence.js";
 import { rankQuery } from "./sqlite/rankings.js";
+import { replyDelays, waitingChats, } from "./sqlite/reply-times.js";
 export const queriesStoreOver = (context, stemmerFor) => {
     const mailIndexed = (execution) => {
         if (execution.corpus === "mail")
@@ -19,5 +20,7 @@ export const queriesStoreOver = (context, stemmerFor) => {
         rankQuery: async (execution, request) => rankQuery(context, execution, request),
         rankingEvidence: async (execution, request) => rankingEvidence(context, execution, request),
         adminStatisticsQuery: async (execution, request) => adminStatisticsQuery(context, execution, request),
+        replyDelays: async (scope, who) => replyDelays(context, scope, who),
+        waitingChats: async (scope, waits, cap) => waitingChats(context, scope, waits, cap),
     };
 };

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

@@ -38,6 +38,8 @@ export declare const partialEmails: (database: CacheDatabase, accountId: number,
     total: number;
     stuck: number;
 };
+/** One live email's thread and stored places, newest first, in the shape `partialEmails` gives; `null` if not stored. */
+export declare const emailPlace: (database: CacheDatabase, accountId: number, externalId: string) => PartialEmail | null;
 /** Replaces a partial email's `metadata.partial`, as a failed read records itself; a whole email is left alone. */
 export declare const markPartial: (database: CacheDatabase, accountId: number, externalId: string, mark: Metadata) => {
     changes: number;
@@ -48,6 +50,8 @@ export interface PartialMailStore {
         total: number;
         stuck: number;
     }>;
+    /** One live email's thread and stored places, newest first; `null` when it is not stored. */
+    emailPlace(accountId: number, externalId: string): Promise<PartialEmail | null>;
     /** Records a failed read of a partial email in its `metadata.partial`; a whole email is left alone. */
     markPartial(accountId: number, externalId: string, mark: Metadata): Promise<void>;
 }

package/dist/store/sqlite/email-locations.js

@@ -23,6 +23,17 @@ export const folderEmails = (database, accountId, folder, uidvalidity) => databa
     locations: Number(row.locations),
     folders: Number(row.folders),
 }));
+const placed = (row) => ({
+    externalId: String(row.external_id),
+    threadExternalId: String(row.thread),
+    receivedAt: row.at === null ? null : Number(row.at),
+    metadata: fromJson(row.metadata),
+    locations: JSON.parse(String(row.places)).map((place) => ({
+        folder: String(place.folder),
+        uidvalidity: String(place.uidvalidity),
+        uid: Number(place.uid),
+    })),
+});
 export const partialEmails = (database, accountId, limit) => {
     const rows = database
         .prepare(`SELECT e.external_id, t.external_id AS thread, coalesce(e.received_at, e.sent_at) AS at, e.metadata,
@@ -43,19 +54,22 @@ export const partialEmails = (database, accountId, limit) => {
     return {
         total: rows.length ? Number(rows[0]?.total) : 0,
         stuck: Number(stuck?.n ?? 0),
-        emails: rows.map((row) => ({
-            externalId: String(row.external_id),
-            threadExternalId: String(row.thread),
-            receivedAt: row.at === null ? null : Number(row.at),
-            metadata: fromJson(row.metadata),
-            locations: JSON.parse(String(row.places)).map((place) => ({
-                folder: String(place.folder),
-                uidvalidity: String(place.uidvalidity),
-                uid: Number(place.uid),
-            })),
-        })),
+        emails: rows.map(placed),
     };
 };
+/** One live email's thread and stored places, newest first, in the shape `partialEmails` gives; `null` if not stored. */
+export const emailPlace = (database, accountId, externalId) => {
+    const row = database
+        .prepare(`SELECT e.external_id, t.external_id AS thread, coalesce(e.received_at, e.sent_at) AS at, e.metadata,
+         (SELECT json_group_array(json_object('folder', folder, 'uidvalidity', uidvalidity, 'uid', uid))
+            FROM (SELECT b.external_id AS folder, l.uidvalidity, l.uid
+                    FROM email_locations l JOIN mailboxes b ON b.id = l.mailbox_id
+                    WHERE l.email_id = e.id ORDER BY l.rowid DESC)) AS places
+       FROM emails e JOIN email_threads t ON t.id = e.email_thread_id
+       WHERE e.account_id = ? AND e.external_id = ? AND e.deleted_at IS NULL`)
+        .get(accountId, externalId);
+    return row ? placed(row) : null;
+};
 /** Replaces a partial email's `metadata.partial`, as a failed read records itself; a whole email is left alone. */
 export const markPartial = (database, accountId, externalId, mark) => database
     .prepare(`UPDATE emails SET metadata = json_set(metadata, '$.partial', json(?)) WHERE account_id = ? AND external_id = ?
@@ -63,6 +77,7 @@ export const markPartial = (database, accountId, externalId, mark) => database
     .run(JSON.stringify(mark), accountId, externalId);
 export const partialMail = (database) => ({
     partialEmails: async (accountId, limit) => partialEmails(database, accountId, limit),
+    emailPlace: async (accountId, externalId) => emailPlace(database, accountId, externalId),
     markPartial: async (accountId, externalId, mark) => {
         write(database, () => markPartial(database, accountId, externalId, mark));
     },

package/dist/store/sqlite/lucene-fields.d.ts

@@ -82,6 +82,8 @@ type Compiled = {
 type FieldCompiler = (node: ResolvedPredicate, scope: FieldScope) => Compiled;
 /** A leaf as an FTS5 match over a stem index: phrases of stems, or with `~N` their `NEAR`. */
 export declare const stemMatch: (stemmer: Stemmer, node: ResolvedPredicate) => string | undefined;
+/** What `kind:` matches for a chat aliased `c`: private, saved, bot, service, group, channel or unknown. */
+export declare const PEER_KIND = "CASE WHEN json_extract(c.metadata,'$.peerKind') IN ('private','saved','bot','service','group','channel','unknown') THEN json_extract(c.metadata,'$.peerKind') WHEN c.kind='dialog' AND json_extract(c.metadata,'$.isBot')=1 THEN 'bot' WHEN c.kind='dialog' THEN 'private' ELSE c.kind END";
 /** One compiler per field of `QUERY_FIELDS`, by its name: a leaf compiles by a lookup, never a branch. */
 export declare const FIELD_COMPILERS: Readonly<Record<string, FieldCompiler>>;
 export {};

package/dist/store/sqlite/lucene-fields.js

@@ -344,7 +344,9 @@ const messengerOnly = (compile) => (node, scope) => {
     return compile(node, scope);
 };
 const topic = messengerOnly(({ value }) => always(bound("m.thread_external_id = ?", value)));
-const kind = messengerOnly(({ value }) => always(bound("CASE WHEN json_extract(c.metadata,'$.peerKind') IN ('private','saved','bot','service','group','channel','unknown') THEN json_extract(c.metadata,'$.peerKind') WHEN c.kind='dialog' AND json_extract(c.metadata,'$.isBot')=1 THEN 'bot' WHEN c.kind='dialog' THEN 'private' ELSE c.kind END = ?", value.toLowerCase())));
+/** What `kind:` matches for a chat aliased `c`: private, saved, bot, service, group, channel or unknown. */
+export const PEER_KIND = "CASE WHEN json_extract(c.metadata,'$.peerKind') IN ('private','saved','bot','service','group','channel','unknown') THEN json_extract(c.metadata,'$.peerKind') WHEN c.kind='dialog' AND json_extract(c.metadata,'$.isBot')=1 THEN 'bot' WHEN c.kind='dialog' THEN 'private' ELSE c.kind END";
+const kind = messengerOnly(({ value }) => always(bound(`${PEER_KIND} = ?`, value.toLowerCase())));
 const has = ({ value }, { corpus, mail }) => {
     const wanted = value.toLowerCase();
     return always(wanted === "text"

package/dist/store/sqlite/mail-findings.js

@@ -290,7 +290,7 @@ export const mailFindingsStoreOver = (context) => {
                 return invalid("accept only unique IDs shown in this batch");
             if (decision.by === undefined)
                 return invalid("a findings review names who decides: the owner");
-            assertMayDecide({ id, proposedBy: proposals.proposer(id), ownerOnly: true }, decision.by, context.decisions);
+            assertMayDecide({ id, kind: MAIL_FINDINGS_KIND, proposedBy: proposals.proposer(id) }, decision.by, context.decisions);
             const accepted = [...decision.accept].sort();
             if (batch.receipt) {
                 if (JSON.stringify(batch.receipt.accepted) !== JSON.stringify(accepted))

package/dist/store/sqlite/meeting-findings.js

@@ -179,7 +179,7 @@ export const meetingFindingsStoreOver = (context) => {
             const accepted = [...decision.accept].sort();
             if (decision.by === undefined)
                 return invalid("a findings review names who decides: the owner or an agent");
-            assertMayDecide({ id, proposedBy: proposals.proposer(id) }, decision.by, context.decisions);
+            assertMayDecide({ id, kind: MEETING_FINDINGS_KIND, proposedBy: proposals.proposer(id) }, decision.by, context.decisions);
             if (batch.receipt) {
                 if (JSON.stringify(batch.receipt.accepted) !== JSON.stringify(accepted))
                     return invalid("this findings batch was already reviewed with a different decision");

package/dist/store/sqlite/proposed-actions.d.ts

@@ -83,5 +83,7 @@ type ProposalOperations = Omit<{
 /** Who proposed an action, for `mayDecide`. */
 export declare const proposerOfAction: ({ proposedBy, payload }: ProposedAction) => Proposer;
 export declare const proposalOperationsOver: (context: StoreContext) => ProposalOperations;
+/** Refuses a findings batch on a generic action path: approving one as an action would skip its own checks. */
+export declare const assertGenericAction: (kind: string) => void;
 export declare const proposedActionsStoreOver: (context: StoreContext) => ProposedActionsStore;
 export {};

package/dist/store/sqlite/proposed-actions.js

@@ -164,38 +164,45 @@ export const proposalOperationsOver = (context) => {
         },
     };
 };
+/** Stored kinds a generic action path never decides: each has its own review, which checks what the batch cites. */
+const DEDICATED_REVIEW = {
+    [MEETING_FINDINGS_KIND]: { what: "meeting findings", reason: "meeting-findings.dedicated-review" },
+    [EVIDENCE_FINDINGS_KIND]: { what: "evidence findings", reason: "evidence-findings.dedicated-review" },
+    [MAIL_FINDINGS_KIND]: { what: "mail findings", reason: "mail-findings.dedicated-review" },
+};
+/** Refuses a findings batch on a generic action path: approving one as an action would skip its own checks. */
+export const assertGenericAction = (kind) => {
+    const dedicated = DEDICATED_REVIEW[kind];
+    if (dedicated)
+        throw new CliError("validation_error", `review ${dedicated.what} through the dedicated findings command`, {
+            reason: dedicated.reason,
+        });
+};
 export const proposedActionsStoreOver = (context) => {
     const operations = proposalOperationsOver(context);
     const generic = (id) => {
-        const kind = operations.get(id).kind;
-        if (kind === MEETING_FINDINGS_KIND)
-            throw new CliError("validation_error", "review meeting findings through the dedicated findings command", {
-                reason: "meeting-findings.dedicated-review",
-            });
-        if (kind === EVIDENCE_FINDINGS_KIND)
-            throw new CliError("validation_error", "review evidence findings through the dedicated findings command", {
-                reason: "evidence-findings.dedicated-review",
-            });
+        const { kind } = operations.get(id);
+        assertGenericAction(kind);
+        return kind;
     };
     return {
         propose: async (input) => {
-            if (input.kind === MEETING_FINDINGS_KIND)
-                throw new CliError("validation_error", "stage meeting findings through the dedicated findings command");
-            if (input.kind === EVIDENCE_FINDINGS_KIND)
-                throw new CliError("validation_error", "stage evidence findings through the dedicated findings command");
+            const dedicated = DEDICATED_REVIEW[input.kind];
+            if (dedicated)
+                throw new CliError("validation_error", `stage ${dedicated.what} through the dedicated findings command`);
             return operations.propose(input);
         },
         get: async (id) => operations.get(id),
         pending: async (options) => operations.pending(options),
         list: async (options) => operations.list(options),
         approve: async (id, by, result) => {
-            generic(id);
-            assertMayDecide({ id, proposedBy: operations.proposer(id) }, by, context.decisions);
+            const kind = generic(id);
+            assertMayDecide({ id, kind, proposedBy: operations.proposer(id) }, by, context.decisions);
             return operations.approve(id, result, deciderAuthor(by));
         },
         reject: async (id, by, reason) => {
-            generic(id);
-            assertMayDecide({ id, proposedBy: operations.proposer(id) }, by, context.decisions);
+            const kind = generic(id);
+            assertMayDecide({ id, kind, proposedBy: operations.proposer(id) }, by, context.decisions);
             return operations.reject(id, deciderAuthor(by), reason?.trim() ? { reason: reason.trim() } : undefined);
         },
         executed: async (id, result) => {

package/dist/store/sqlite/reply-times.d.ts

@@ -0,0 +1,57 @@
+import type { SqlValue } from "../driver.js";
+import type { AccountKey } from "../types.js";
+import type { StoreContext } from "./open.js";
+/** The chats a reply-time or waiting answer reads; every chat and kind listed must hold. */
+export interface ChatScope {
+    accounts: AccountKey[];
+    chats: {
+        account: AccountKey;
+        chatId: string;
+    }[];
+    kinds: string[];
+    /** Inclusive bounds in ms; absent is open. */
+    since?: number;
+    until?: number;
+}
+export interface ReplyDelay {
+    repliedAt: number;
+    delayMs: number;
+}
+export interface NewestMessage {
+    chatId: number;
+    kind: string;
+    sentAt: number;
+    mine: boolean;
+    text: string;
+    /** The message names the owner by id, or replies to one of the owner's messages. */
+    addressed: boolean;
+    ownerUsername: string | null;
+    /** Muted or archived, and not marked unread: what `inbox` leaves out. */
+    quiet: boolean;
+}
+/**
+ * One row per reply in one-to-one chats. Each chat is read from the start of the run before the first message in the
+ * period, so a reply early in the period is timed from the first message it answers, however old.
+ */
+export declare const replyDelaysQuery: (scope: ChatScope, who: "me" | "others") => {
+    sql: string;
+    params: SqlValue[];
+};
+export declare const replyDelays: (context: StoreContext, scope: ChatScope, who: "me" | "others") => ReplyDelay[];
+/** Each one-to-one chat's and group's newest message, found by index per chat, its time within the scope's bounds. */
+export declare const newestMessagesQuery: (scope: ChatScope, now: number) => {
+    sql: string;
+    params: SqlValue[];
+};
+/** The newest `cap` messages of a chat, newest first: enough to find where the owner last spoke. */
+export declare const TAIL_SQL = "SELECT sent_at, coalesce(outgoing,0) AS mine FROM messages WHERE chat_id=? AND deleted_at IS NULL ORDER BY sent_at DESC LIMIT ?";
+export interface WaitingChat {
+    kind: string;
+    /** When each of the other side's messages after the owner's last one was sent, newest first. */
+    unanswered: number[];
+}
+/**
+ * The chats whose newest message `waits` accepts, with the other side's messages since the owner last spoke, read
+ * back no further than `cap` messages per chat.
+ */
+export declare const waitingChats: (context: StoreContext, scope: ChatScope, waits: (newest: NewestMessage) => boolean, cap: number) => WaitingChat[];