@wirecat/cli-core 0.562.0 → 0.564.0

package/dist/store/chats.d.ts

@@ -3,7 +3,7 @@ import type { Chat, ChatKind, ChatUpdate, Id, Page } from "../domain/models.js";
 import type { HistorySkip } from "../services/history-limits.js";
 import { type ChatRekey, type ChatRekeys } from "./sqlite/chat-rekey.js";
 import type { ChatMetadata, LeftChat } from "./sqlite/chats.js";
-import type { ChatCompleteness } from "./sqlite/completeness.js";
+import type { ChatCompleteness, ChatCoverage } from "./sqlite/completeness.js";
 import type { ChatHistoryShape, StoredHistorySkip } from "./sqlite/history-skips.js";
 import type { StoreContext } from "./sqlite/open.js";
 import type { Where } from "./sqlite/query-filter.js";
@@ -59,6 +59,8 @@ export interface ChatsStore {
     }): Promise<LeftChats>;
     /** Per chat: whether its history is held up to date, without gaps, back to its start. */
     chatCompleteness(key: AccountKey, chatIds: Id[]): Promise<ChatCompleteness[]>;
+    /** Over every searchable chat: how many are held in full, in part, or never fetched, and the oldest message held. */
+    chatCoverage(key: AccountKey): Promise<ChatCoverage>;
     /** Per chat that has messages: how many, the oldest and newest, and when the last one was stored. */
     chatStats(key: AccountKey, chatId?: Id): Promise<ChatStats[]>;
     /**

package/dist/store/chats.js

@@ -78,6 +78,12 @@ export const chatsStoreOver = (context) => {
             const accountKey = findAccountPk(key);
             return accountKey === undefined ? [] : completeness.chatCompleteness(context, accountKey, chatIds);
         },
+        chatCoverage: async (key) => {
+            const accountKey = findAccountPk(key);
+            return accountKey === undefined
+                ? { chats: 0, fetched: 0, partial: 0, never: 0, oldestMessageAt: null }
+                : completeness.chatCoverage(context, accountKey);
+        },
         chatStats: async (key, chatId) => {
             const accountKey = findAccountPk(key);
             return accountKey === undefined ? [] : reads.chatStats(context, accountKey, chatId);

package/dist/store/decisions.d.ts

@@ -1,3 +1,5 @@
+/** An agent's suggested close of a task: kept on the task, not in `proposed_actions`. */
+export declare const TASK_CLOSE_KIND = "task_close";
 /**
  * Who proposed something waiting for the owner. `unknown` is a suggestion that names no author, such as an
  * unconfirmed link written without provenance: only the owner decides it. `verified: false` is a bot named only by
@@ -21,6 +23,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 +42,18 @@ export interface Refusal {
     reason: string;
     message: string;
 }
+/**
+ * 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 +68,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,20 @@
 import { CliError } from "@wirecat/cli-base";
+import { MEETING_FINDINGS_KIND } from "../meetings/index.js";
+import { MAIL_FINDINGS_KIND } from "./mail-findings.js";
+/** An agent's suggested close of a task: kept on the task, not in `proposed_actions`. */
+export const TASK_CLOSE_KIND = "task_close";
 export const DEFAULT_DECISION_POLICY = { agentDecisions: false, ruleProposalsOwnerOnly: true };
+/**
+ * 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 || kind === TASK_CLOSE_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 +24,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/exports.d.ts

@@ -20,7 +20,7 @@ export { pendingNormalization } from "./sqlite/backfill.js";
 export type { ChatRekey, ChatRekeys } from "./sqlite/chat-rekey.js";
 export { CHAT_COLUMNS, TRACKED_CHAT_COLUMNS, titlePart } from "./sqlite/chats.js";
 export { storeClients } from "./sqlite/clients.js";
-export { CHAT_LIST_KEY, type ChatCompleteness, fetchedKey, historyStartKey } from "./sqlite/completeness.js";
+export { CHAT_LIST_KEY, type ChatCompleteness, type ChatCoverage, fetchedKey, historyStartKey, } from "./sqlite/completeness.js";
 export { CONVERSATION_COLUMNS } from "./sqlite/conversations.js";
 export type { CounterTarget } from "./sqlite/counters.js";
 export { type EmailMarks, MAIL_AGENDA_COLUMNS, type MarkedEmail, type NewestEmail, type ThreadActivity, } from "./sqlite/email-activity.js";

package/dist/store/exports.js

@@ -4,7 +4,7 @@ export { attachmentColumns, resetAttachmentWords, } from "./sqlite/attachment-te
 export { pendingNormalization } from "./sqlite/backfill.js";
 export { CHAT_COLUMNS, TRACKED_CHAT_COLUMNS, titlePart } from "./sqlite/chats.js";
 export { storeClients } from "./sqlite/clients.js";
-export { CHAT_LIST_KEY, fetchedKey, historyStartKey } from "./sqlite/completeness.js";
+export { CHAT_LIST_KEY, fetchedKey, historyStartKey, } from "./sqlite/completeness.js";
 export { CONVERSATION_COLUMNS } from "./sqlite/conversations.js";
 export { MAIL_AGENDA_COLUMNS, } from "./sqlite/email-activity.js";
 export { messageOfEmail, threadConversation } from "./sqlite/emails.js";

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";
@@ -62,7 +62,7 @@ export type { SyncStateSave } from "./sqlite/sync.js";
 export type { TagCreationOptions, TagCreationReview } from "./sqlite/tag-creation.js";
 export type { TagKind, TagRow } from "./sqlite/tags.js";
 export type { TaskSort } from "./sqlite/task-board.js";
-export { PROJECT_TASK_FIELDS, TASK_SORTS } from "./sqlite/task-board.js";
+export { PROJECT_TASK_FIELDS, TASK_SORTS, withoutField } from "./sqlite/task-board.js";
 export type { SimilarSubject, SimilarTask, TaskDraft } from "./sqlite/task-candidates.js";
 export { type AgentCloseSettings, type CloseSuggestion, certaintyOf } from "./sqlite/task-close.js";
 export type { NamedAuthor, TaskComment } from "./sqlite/task-comments.js";
@@ -70,8 +70,9 @@ export type { TaskPair, TaskPairDecision, TaskPairSide } from "./sqlite/task-pai
 export { TASK_PAIR_DECISIONS } from "./sqlite/task-pairs.js";
 export type { TaskRelation, TaskRelationKind, TaskRelationsStore } from "./sqlite/task-relations.js";
 export { TASK_RELATION_KINDS } from "./sqlite/task-relations.js";
+export type { TaskStatRow, TaskStatScope } from "./sqlite/task-stats.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,9 +24,9 @@ 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 { PROJECT_TASK_FIELDS, TASK_SORTS, withoutField } from "./sqlite/task-board.js";
 export { certaintyOf } from "./sqlite/task-close.js";
 export { TASK_PAIR_DECISIONS } from "./sqlite/task-pairs.js";
 export { TASK_RELATION_KINDS } from "./sqlite/task-relations.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/completeness.d.ts

@@ -23,3 +23,20 @@ export interface ChatCompleteness {
  * A start mark that a later fetch reached past was wrong, so it stops counting.
  */
 export declare const chatCompleteness: ({ database }: StoreContext, accountKey: number, chatIds: Id[]) => ChatCompleteness[];
+export interface ChatCoverage {
+    chats: number;
+    /** Held back to the first message, up to date, without gaps: `complete` above. */
+    fetched: number;
+    partial: number;
+    /** No fetch ever recorded and no message held. */
+    never: number;
+    oldestMessageAt: string | null;
+}
+export declare const COVERAGE_SQL = "SELECT c.last_message_at AS newest, c.message_count AS messages,\n     (SELECT m.sent_at FROM messages m WHERE m.chat_id = c.id AND m.deleted_at IS NULL\n       ORDER BY m.sent_at DESC LIMIT 1) AS held,\n     (SELECT m.sent_at FROM messages m WHERE m.chat_id = c.id AND m.deleted_at IS NULL\n       ORDER BY m.sent_at ASC LIMIT 1) AS oldest,\n     (SELECT count(*) FROM sync_ranges r WHERE r.chat_id = c.id) AS stretches,\n     EXISTS (SELECT 1 FROM sync_cursors s WHERE s.account_id = c.account_id AND s.key = 'history_start:' || c.external_id\n       AND NOT EXISTS (SELECT 1 FROM sync_ranges r WHERE r.chat_id = c.id AND r.from_key < CAST(s.value AS INTEGER)))\n       AS start,\n     EXISTS (SELECT 1 FROM sync_cursors s WHERE s.account_id = c.account_id\n       AND s.key IN ('history_start:' || c.external_id, 'fetched:' || c.external_id)) AS recorded\n   FROM chats c WHERE c.account_id = ? AND c.searchable = 1";
+/**
+ * `chatCompleteness` over every searchable chat of the account in one statement. A chat whose history was pushed
+ * into the store (WhatsApp) has messages and no fetch record, so it counts as partial, not never. The newest and
+ * oldest held are read with ORDER BY … LIMIT 1, so each stops at the first live row of `messages_by_time` rather than
+ * relying on the planner's min/max shortcut, which the deleted_at filter may defeat.
+ */
+export declare const chatCoverage: ({ database }: StoreContext, accountKey: number) => ChatCoverage;

package/dist/store/sqlite/completeness.js

@@ -24,18 +24,54 @@ export const chatCompleteness = ({ database }, accountKey, chatIds) => {
        FROM chats c WHERE c.account_id = ? AND c.external_id IN (SELECT value FROM json_each(?))`)
         .all(accountKey, JSON.stringify(chatIds))
         .map((row) => {
-        const stretches = Number(row.stretches);
-        const reachesStart = Number(row.start) === 1;
-        const upToDate = row.newest === null ? null : row.held !== null && Number(row.held) >= Number(row.newest);
-        const gaps = stretches > 1;
-        const fetched = stretches > 0 || reachesStart;
-        return {
-            chatId: String(row.chat),
-            state: !fetched ? "unknown" : upToDate !== false && !gaps && reachesStart ? "complete" : "partial",
-            upToDate,
-            gaps,
-            reachesStart,
-            fetchedAt: toIso(row.fetched),
-        };
+        const facts = factsOf(row);
+        return { chatId: String(row.chat), ...facts, fetchedAt: toIso(row.fetched) };
     });
 };
+const factsOf = (row) => {
+    const stretches = Number(row.stretches);
+    const reachesStart = Number(row.start) === 1;
+    const upToDate = row.newest === null ? null : row.held !== null && Number(row.held) >= Number(row.newest);
+    const gaps = stretches > 1;
+    const fetched = stretches > 0 || reachesStart;
+    const state = !fetched
+        ? "unknown"
+        : upToDate !== false && !gaps && reachesStart
+            ? "complete"
+            : "partial";
+    return { state, upToDate, gaps, reachesStart };
+};
+export const COVERAGE_SQL = `SELECT c.last_message_at AS newest, c.message_count AS messages,
+     (SELECT m.sent_at FROM messages m WHERE m.chat_id = c.id AND m.deleted_at IS NULL
+       ORDER BY m.sent_at DESC LIMIT 1) AS held,
+     (SELECT m.sent_at FROM messages m WHERE m.chat_id = c.id AND m.deleted_at IS NULL
+       ORDER BY m.sent_at ASC LIMIT 1) AS oldest,
+     (SELECT count(*) FROM sync_ranges r WHERE r.chat_id = c.id) AS stretches,
+     EXISTS (SELECT 1 FROM sync_cursors s WHERE s.account_id = c.account_id AND s.key = 'history_start:' || c.external_id
+       AND NOT EXISTS (SELECT 1 FROM sync_ranges r WHERE r.chat_id = c.id AND r.from_key < CAST(s.value AS INTEGER)))
+       AS start,
+     EXISTS (SELECT 1 FROM sync_cursors s WHERE s.account_id = c.account_id
+       AND s.key IN ('history_start:' || c.external_id, 'fetched:' || c.external_id)) AS recorded
+   FROM chats c WHERE c.account_id = ? AND c.searchable = 1`;
+/**
+ * `chatCompleteness` over every searchable chat of the account in one statement. A chat whose history was pushed
+ * into the store (WhatsApp) has messages and no fetch record, so it counts as partial, not never. The newest and
+ * oldest held are read with ORDER BY … LIMIT 1, so each stops at the first live row of `messages_by_time` rather than
+ * relying on the planner's min/max shortcut, which the deleted_at filter may defeat.
+ */
+export const chatCoverage = ({ database }, accountKey) => {
+    const rows = database.prepare(COVERAGE_SQL).all(accountKey);
+    const coverage = { chats: rows.length, fetched: 0, partial: 0, never: 0, oldestMessageAt: null };
+    let oldest = null;
+    for (const row of rows) {
+        if (row.oldest !== null && (oldest === null || Number(row.oldest) < oldest))
+            oldest = Number(row.oldest);
+        if (factsOf(row).state === "complete")
+            coverage.fetched += 1;
+        else if (Number(row.stretches) === 0 && Number(row.recorded) === 0 && Number(row.messages) === 0)
+            coverage.never += 1;
+        else
+            coverage.partial += 1;
+    }
+    return { ...coverage, oldestMessageAt: toIso(oldest) };
+};

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,9 +344,13 @@ 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();
+    if (wanted === "transcript")
+        return always(bound(mail ? "0" : "EXISTS (SELECT 1 FROM message_transcripts t WHERE t.message_id = m.id)"));
     return always(wanted === "text"
         ? bound("length(trim(coalesce(m.text,''))) > 0")
         : wanted === "link"

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

@@ -0,0 +1,15 @@
+/** `_direction`: the same groups, each split by `outgoing`, for counts of received and sent mail. */
+export type QueryGrouping = "chat" | "sender" | "time" | "sender_direction" | "time_direction";
+export interface QueryGroup {
+    provider?: string;
+    account?: string;
+    id: string | null;
+    name: string | null;
+    outgoing?: boolean;
+    count: number;
+}
+/** How `countQuery` groups the matches: the GROUP BY key and the columns each group reads. */
+export declare const GROUPS: Record<QueryGrouping, {
+    key: string;
+    select: string;
+}>;

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

@@ -0,0 +1,21 @@
+/** How `countQuery` groups the matches: the GROUP BY key and the columns each group reads. */
+export const GROUPS = {
+    chat: {
+        key: "m.chat_id",
+        select: "ac.provider AS provider, ac.external_id AS account, c.external_id AS id, c.title AS name",
+    },
+    sender: {
+        key: "coalesce(m.sender_identity_id, -m.account_id)",
+        select: "ac.provider AS provider, ac.external_id AS account, i.external_id AS id, i.name AS name, max(m.outgoing) AS outgoing",
+    },
+    // Quarter hours, so a calendar day or hour in any zone (+05:30, +05:45) is a whole number of buckets.
+    time: { key: "m.sent_at / 900000", select: "CAST(min(m.sent_at / 900000) * 900000 AS TEXT) AS id, NULL AS name" },
+    sender_direction: {
+        key: "coalesce(m.sender_identity_id, -m.account_id), coalesce(m.outgoing, 0)",
+        select: "ac.provider AS provider, ac.external_id AS account, i.external_id AS id, i.name AS name, coalesce(m.outgoing, 0) AS outgoing",
+    },
+    time_direction: {
+        key: "m.sent_at / 900000, coalesce(m.outgoing, 0)",
+        select: "CAST(min(m.sent_at / 900000) * 900000 AS TEXT) AS id, NULL AS name, coalesce(m.outgoing, 0) AS outgoing",
+    },
+};

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

@@ -1,18 +1,11 @@
 import type { Page } from "../../domain/models.js";
 import type { QueryExecution } from "../../search/lucene/resolved.js";
 import { type SqlValue } from "../driver.js";
+import { type QueryGroup, type QueryGrouping } from "./lucene-groups.js";
 import type { StoreContext } from "./open.js";
 import type { ScoredHit } from "./words.js";
 export { type Corpus, prefixOf } from "./lucene-fields.js";
-export type QueryGrouping = "chat" | "sender" | "time";
-export interface QueryGroup {
-    provider?: string;
-    account?: string;
-    id: string | null;
-    name: string | null;
-    outgoing?: boolean;
-    count: number;
-}
+export type { QueryGroup, QueryGrouping } from "./lucene-groups.js";
 export declare const matchQuery: (context: StoreContext, execution: QueryExecution) => Promise<Page<ScoredHit>>;
 /** Every match counted once, grouped; the work and candidate budgets of a search still apply. */
 export declare const countQuery: (context: StoreContext, execution: QueryExecution, by: QueryGrouping) => Promise<QueryGroup[]>;

package/dist/store/sqlite/lucene.js

@@ -6,6 +6,7 @@ import { TIME_LIMIT_FUNCTION, TimeLimitReached } from "../driver.js";
 import { emailHitsByPk } from "./emails.js";
 import { placeHits } from "./hit-places.js";
 import { combine, FIELD_COMPILERS, ftsMatch, SPEECH, } from "./lucene-fields.js";
+import { GROUPS } from "./lucene-groups.js";
 import { hitsByPk } from "./search.js";
 import { read } from "./transaction.js";
 import { transcriptItems, transcriptTerms } from "./transcript-query.js";
@@ -32,18 +33,6 @@ const MAIL = {
     item: "email",
     thread: "email_thread",
 };
-const GROUPS = {
-    chat: {
-        key: "m.chat_id",
-        select: "ac.provider AS provider, ac.external_id AS account, c.external_id AS id, c.title AS name",
-    },
-    sender: {
-        key: "coalesce(m.sender_identity_id, -m.account_id)",
-        select: "ac.provider AS provider, ac.external_id AS account, i.external_id AS id, i.name AS name, max(m.outgoing) AS outgoing",
-    },
-    // Quarter hours, so a calendar day or hour in any zone (+05:30, +05:45) is a whole number of buckets.
-    time: { key: "m.sent_at / 900000", select: "CAST(min(m.sent_at / 900000) * 900000 AS TEXT) AS id, NULL AS name" },
-};
 export const matchQuery = (context, execution) => runQuery(context, execution);
 /** Every match counted once, grouped; the work and candidate budgets of a search still apply. */
 export const countQuery = (context, execution, by) => runQuery(context, execution, by);

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/meeting-stats.d.ts

@@ -1,5 +1,7 @@
 import { type MeetingStatsStore } from "../../meetings/index.js";
 import type { StoreContext } from "./open.js";
+/** One row per selected meeting through `meetings_by_time`; a current transcript is neither deleted nor superseded. */
+export declare const meetingCountsSql: (where: string) => string;
 /**
  * One transcript per meeting — its earliest current one — so a local transcript beside the provider's does not count
  * the talk twice. Words are counted from spaces in SQL, so no transcript text leaves the database.

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

@@ -1,10 +1,17 @@
 import { CliError } from "@wirecat/cli-base";
-import { aggregateMeetingStats } from "../../meetings/index.js";
+import { aggregateMeetingCounts, aggregateMeetingStats, } from "../../meetings/index.js";
 import { checkMeetingCancelled } from "./meeting-operation.js";
 import { positiveReadInteger } from "./meeting-reads.js";
 import { meetingSelectionSql } from "./meeting-selection.js";
 import { read } from "./transaction.js";
 const MOST_ROWS = 500_000;
+/** One row per selected meeting through `meetings_by_time`; a current transcript is neither deleted nor superseded. */
+export const meetingCountsSql = (where) => `SELECT m.started_at, coalesce(m.duration_ms, m.ended_at - m.started_at) AS duration_ms,
+     EXISTS (SELECT 1 FROM meeting_transcripts t WHERE t.meeting_id = m.id AND t.deleted_at IS NULL
+       AND t.superseded_at IS NULL) AS transcribed,
+     s.external_id AS series_key, CASE WHEN s.id IS NULL THEN NULL ELSE coalesce(s.title, m.title) END AS series_title
+   FROM meetings m LEFT JOIN meeting_series s ON s.id = m.meeting_series_id
+   WHERE ${where} ORDER BY m.started_at DESC`;
 /**
  * One transcript per meeting — its earliest current one — so a local transcript beside the provider's does not count
  * the talk twice. Words are counted from spaces in SQL, so no transcript text leaves the database.
@@ -52,4 +59,23 @@ export const meetingStatsOver = ({ database }) => ({
             })), input.timeZone);
         });
     },
+    async meetingCounts(input) {
+        checkMeetingCancelled(input.signal);
+        positiveReadInteger(input.accountId, "accountId");
+        return read(database, () => {
+            const { clauses, params } = meetingSelectionSql(input);
+            const meetings = database
+                .prepare(meetingCountsSql(clauses.join(" AND ")))
+                .all(...params)
+                .map((row) => ({
+                startedAt: row.started_at === null ? null : Number(row.started_at),
+                durationMs: row.duration_ms === null ? null : Number(row.duration_ms),
+                transcribed: Number(row.transcribed) === 1,
+                seriesKey: row.series_key === null ? null : String(row.series_key),
+                seriesTitle: row.series_title === null ? null : String(row.series_title),
+            }));
+            checkMeetingCancelled(input.signal);
+            return aggregateMeetingCounts(meetings, input.by, input.timeZone, input.limit);
+        });
+    },
 });

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 {};