@wirecat/cli-core 0.563.0 → 0.564.0

package/dist/services/search-all.js

@@ -7,7 +7,7 @@ import { INTERNAL_NOTES, kindIn } from "../domain/providers.js";
 import { runEmbedders } from "../embeddings/embed.js";
 import { DEFAULT_TEXT_MODEL } from "../embeddings/models.js";
 import { MESSAGE_PARSING } from "../search/lucene/types.js";
-import { planQuestion } from "../search/question-plan.js";
+import { planQuestion, questionLookup } from "../search/question-plan.js";
 import { calendarAccounts, searchEvents } from "./events-search.js";
 import { excerpt } from "./excerpt.js";
 import { MAX_SEARCH_OFFSET, searchStore } from "./messages-archive-search.js";
@@ -52,11 +52,17 @@ export const searchAll = async (store, account, request, messenger = {}, searchM
     let hasMore = false;
     let notes;
     let events;
-    let messagesBy;
+    const by = {};
     let server;
+    // Every word of a sentence is rarely in one record: a question finds what holds some of them, as `--discover` does.
+    const discover = !request.exact && questionLookup(request.text) !== undefined;
+    /** Each hit found by meaning, by its cosine: one model for every source, so these compare across them. */
+    const cosines = new Map();
     let coverage;
     const messagesOf = async (kind) => {
         const given = request.scope?.[kind];
+        // The server still gets the question as typed: a query that is not a sentence still finds what it holds.
+        const discovers = discover && (kind === "mail" || request.backend !== "server");
         const query = {
             text: request.text,
             kind,
@@ -71,6 +77,7 @@ export const searchAll = async (store, account, request, messenger = {}, searchM
                 : {}),
             limit: window,
             ...(request.exact ? { exact: true } : {}),
+            ...(discovers ? { discover: true } : {}),
             ...(request.timezone === undefined ? {} : { timezone: request.timezone }),
             ...(request.signal === undefined ? {} : { signal: request.signal }),
         };
@@ -109,7 +116,7 @@ export const searchAll = async (store, account, request, messenger = {}, searchM
         };
         const byWords = found.items.map((hit) => itemOf(hit, ["words"]));
         // Server hits are only those the server returned; the local vectors would add others.
-        if (kind === "mail" || !meaning || request.exact || request.backend === "server")
+        if (!meaning || request.exact || (kind === "messages" && request.backend === "server"))
             return byWords;
         const filters = filtersBeside(request.text);
         const lane = filters === undefined
@@ -121,10 +128,10 @@ export const searchAll = async (store, account, request, messenger = {}, searchM
             }
             : await meaning(request.text, read, embedders);
         if ("skipped" in lane) {
-            messagesBy = { by: "words", meaningSkipped: lane.skipped };
+            by[kind] = { by: "words", meaningSkipped: lane.skipped };
             return byWords;
         }
-        messagesBy = { by: "words and meaning", ...(lane.partly ? { meaningSkipped: lane.partly } : {}) };
+        by[kind] = { by: "words and meaning", ...(lane.partly ? { meaningSkipped: lane.partly } : {}) };
         const near = await nearEligible(store, account, query, messenger, lane.ranked, filters ? { text: filters } : {});
         // One list per resource, as notes give theirs, so messages get no second vote against mail.
         const fused = new Map();
@@ -132,9 +139,13 @@ export const searchAll = async (store, account, request, messenger = {}, searchM
             fused.set(item.ref, { item, score: 1 / (RRF_K + rank + 1) });
         });
         near.forEach((hit, rank) => {
+            cosines.set(hit.locator, hit.cosine);
             const held = fused.get(hit.locator);
             if (held)
                 held.item.foundBy = ["words", "meaning"];
+            // As in notes: a question's any-word list already holds what meaning finds, and a second vote buries the rest.
+            if (held && discovers)
+                return;
             fused.set(hit.locator, {
                 item: held?.item ?? itemOf(hit, ["meaning"]),
                 score: (held?.score ?? 0) + 1 / (RRF_K + rank + 1),
@@ -155,6 +166,7 @@ export const searchAll = async (store, account, request, messenger = {}, searchM
                         embedders,
                         ...(chosen === undefined ? {} : notesScopeOf(chosen)),
                         ...(request.exact ? { exact: true } : {}),
+                        ...(discover ? { discover: true } : {}),
                         ...(request.timezone === undefined ? {} : { timezone: request.timezone }),
                         ...(request.env === undefined ? {} : { env: request.env }),
                     });
@@ -163,6 +175,9 @@ export const searchAll = async (store, account, request, messenger = {}, searchM
                         by: found.by,
                         ...(found.meaning_skipped === undefined ? {} : { meaningSkipped: found.meaning_skipped }),
                     };
+                    for (const hit of found.hits)
+                        if (hit.meaning_score !== undefined)
+                            cosines.set(hit.ref, hit.meaning_score);
                     lists.push(found.hits.map((hit) => ({
                         kind: hit.kind ?? "note",
                         ref: hit.ref,
@@ -192,6 +207,7 @@ export const searchAll = async (store, account, request, messenger = {}, searchM
                         ...(command === undefined ? {} : { command }),
                         ...(request.env === undefined ? {} : { env: request.env }),
                         ...(request.exact ? { exact: true } : {}),
+                        ...(discover ? { discover: true } : {}),
                         ...(request.timezone === undefined ? {} : { timezone: request.timezone }),
                         ...(request.signal === undefined ? {} : { signal: request.signal }),
                     });
@@ -200,6 +216,9 @@ export const searchAll = async (store, account, request, messenger = {}, searchM
                         by: found.by,
                         ...(found.meaning_skipped === undefined ? {} : { meaningSkipped: found.meaning_skipped }),
                     };
+                    for (const hit of found.hits)
+                        if (hit.meaning_score !== undefined)
+                            cosines.set(hit.ref, hit.meaning_score);
                     lists.push(found.hits.map((hit) => ({
                         kind: "event",
                         ref: hit.ref,
@@ -227,14 +246,7 @@ export const searchAll = async (store, account, request, messenger = {}, searchM
     finally {
         await embedders.close();
     }
-    const ranked = new Map();
-    for (const list of lists)
-        list.forEach((item, rank) => {
-            const held = ranked.get(item.ref) ?? { item, score: 0 };
-            held.score += 1 / (RRF_K + rank + 1);
-            ranked.set(item.ref, held);
-        });
-    const ordered = [...ranked.values()].sort((a, b) => b.score - a.score).map(({ item }) => item);
+    const ordered = oneList(lists, cosines);
     const more = hasMore || ordered.length > window;
     return {
         query: request.text,
@@ -246,8 +258,29 @@ export const searchAll = async (store, account, request, messenger = {}, searchM
         skipped,
         ...(notes === undefined ? {} : { notes }),
         ...(events === undefined ? {} : { events }),
-        ...(messagesBy === undefined ? {} : { messages: messagesBy }),
+        ...(by.messages === undefined ? {} : { messages: by.messages }),
+        ...(by.mail === undefined ? {} : { mail: by.mail }),
         ...(server === undefined ? {} : { server }),
         ...(coverage === undefined ? {} : { coverage }),
     };
 };
+/**
+ * Every source's hits as one list: by the rank each has in its own source, then by cosine. Rank alone gave every
+ * source's hit at one rank the same score, so the sources took turns and the order among them was the order they were
+ * read in (MEMO-37). One model scores every source, so cosine compares across them; a hit meaning did not find comes
+ * after those it did at the same rank. Each source's own order is kept, so recall at any depth past the number of
+ * sources does not change.
+ */
+const oneList = (lists, cosines) => {
+    const place = new Map();
+    for (const list of lists)
+        list.forEach((item, rank) => {
+            const held = place.get(item.ref);
+            if (!held || rank < held.rank)
+                place.set(item.ref, { item, rank });
+        });
+    const cosine = (ref) => cosines.get(ref) ?? Number.NEGATIVE_INFINITY;
+    return [...place.values()]
+        .sort((a, b) => a.rank - b.rank || cosine(b.item.ref) - cosine(a.item.ref))
+        .map(({ item }) => item);
+};

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

@@ -0,0 +1,41 @@
+import { type QueryAst } from "@wirecat/cli-base/query";
+import type { AccountKey, MessageStore } from "../store/store.js";
+import { type ColumnMap } from "../store/store.js";
+import { type TaskKind } from "../tasks/index.js";
+export declare const TASK_STATS_BY: readonly ["chat", "meeting", "project"];
+export type TaskStatsBy = (typeof TASK_STATS_BY)[number];
+/** The query field that sets the period; `closed` counts read the same range on the close time. */
+export declare const PERIOD_FIELD = "created";
+export interface TaskStatsRequest {
+    by?: TaskStatsBy;
+    query?: QueryAst;
+    timezone?: string;
+    /** A stored chat id: only that chat's tasks. */
+    group?: string;
+    kind?: TaskKind;
+}
+export interface TaskStatsGroup {
+    /** The stored chat id, `meeting:<account>/<meeting>`, or the project's store id. */
+    group: string;
+    name: string | null;
+    open: number;
+    created: number;
+    closed: number;
+    oldestOpenAt?: Date;
+    medianCloseMs?: number;
+    meanOpenAgeMs?: number;
+}
+export interface TaskStats {
+    by: TaskStatsBy;
+    open: number;
+    created: number;
+    closed: number;
+    medianCloseMs?: number;
+    meanOpenAgeMs?: number;
+    rows: TaskStatsGroup[];
+}
+/**
+ * `stats tasks show`: `open` is open now, `created` the tasks opened in the period, `closed` those closed in it; the
+ * other terms of the query narrow all three. `columns` reads the task query's fields on the row `t`.
+ */
+export declare const taskStatsOf: (store: MessageStore, account: AccountKey, { by, query, timezone, group, kind }: TaskStatsRequest, columns: ColumnMap, now?: number) => Promise<TaskStats>;

package/dist/services/task-stats.js

@@ -0,0 +1,126 @@
+import { CliError } from "@wirecat/cli-base";
+import { walkQuery } from "@wirecat/cli-base/query";
+import { parseMeetingReference } from "../meetings/index.js";
+import { withoutField } from "../store/index.js";
+import { queryFilter } from "../store/store.js";
+import { isClosedState } from "../tasks/index.js";
+import { taskAccount } from "./task-rules.js";
+export const TASK_STATS_BY = ["chat", "meeting", "project"];
+/** The query field that sets the period; `closed` counts read the same range on the close time. */
+export const PERIOD_FIELD = "created";
+/** Only as a required term at the top: inside OR or NOT it would no longer say which tasks the period covers. */
+const refuseNestedPeriod = (node, top = true) => {
+    if (node.kind === "predicate")
+        return;
+    const optional = node.clauses.some(({ occur }) => occur === "should");
+    for (const { occur, node: inner } of node.clauses) {
+        if (!walkQuery(inner).some(({ field }) => field === PERIOD_FIELD))
+            continue;
+        if (!top || optional || occur !== "must")
+            throw new CliError("validation_error", `${PERIOD_FIELD}: sets the period of stats tasks show: give it as a required term, not inside OR or NOT`);
+        refuseNestedPeriod(inner, top);
+    }
+};
+const renamed = (node, from, to) => node.kind === "predicate"
+    ? node.field === from
+        ? { ...node, field: to }
+        : node
+    : { ...node, clauses: node.clauses.map((clause) => ({ ...clause, node: renamed(clause.node, from, to) })) };
+const median = (values) => {
+    const sorted = [...values].sort((a, b) => a - b);
+    const middle = Math.floor(sorted.length / 2);
+    const upper = sorted[middle] ?? 0;
+    return sorted.length % 2 === 1 ? upper : ((sorted[middle - 1] ?? 0) + upper) / 2;
+};
+const mean = (values) => Math.round(values.reduce((sum, one) => sum + one, 0) / values.length);
+const spread = (open, closeMs, now) => ({
+    ...(closeMs.length > 0 ? { medianCloseMs: median(closeMs) } : {}),
+    ...(open.length > 0 ? { meanOpenAgeMs: mean(open.map(({ createdAt }) => now - createdAt)) } : {}),
+});
+const and = (parts) => parts.length === 0
+    ? undefined
+    : { sql: parts.map(({ sql }) => `(${sql})`).join(" AND "), params: parts.flatMap(({ params }) => params) };
+/**
+ * `stats tasks show`: `open` is open now, `created` the tasks opened in the period, `closed` those closed in it; the
+ * other terms of the query narrow all three. `columns` reads the task query's fields on the row `t`.
+ */
+export const taskStatsOf = async (store, account, { by = "chat", query, timezone, group, kind }, columns, now = Date.now()) => {
+    if (query)
+        refuseNestedPeriod(query.root);
+    const time = (sql) => ({ type: "time", sql });
+    const read = { ...columns, [PERIOD_FIELD]: time("t.created_at"), closed: time("t.closed_at") };
+    const fixed = [
+        ...(group === undefined ? [] : [{ sql: "t.source_group = ?", params: [group] }]),
+        ...(kind === undefined ? [] : [{ sql: "t.type = ?", params: [kind] }]),
+        ...(by === "meeting" ? [{ sql: "t.source_kind = 'meeting'", params: [] }] : []),
+    ];
+    const options = { command: "stats tasks show", now, ...(timezone === undefined ? {} : { zone: timezone }) };
+    const where = (ast, more = []) => and([...fixed, ...more, ...(ast ? [queryFilter(ast, read, options)] : [])]);
+    const scope = by === "project" ? { board: true } : { account: taskAccount(account) };
+    const all = await store.tasks.statRows(scope, where(withoutField(query, PERIOD_FIELD)));
+    const created = await store.tasks.statRows(scope, where(query));
+    const closed = await store.tasks.statRows(scope, where(query && { ...query, root: renamed(query.root, PERIOD_FIELD, "closed") }, [
+        { sql: "t.closed_at IS NOT NULL", params: [] },
+    ]));
+    const keyOf = (row) => (by === "project" ? String(row.projectId) : (row.group ?? ""));
+    const groups = new Map();
+    const slot = (row) => {
+        const key = keyOf(row);
+        const found = groups.get(key) ?? { open: [], created: 0, closeMs: [] };
+        groups.set(key, found);
+        return found;
+    };
+    for (const row of all)
+        if (!isClosedState(row.state))
+            slot(row).open.push(row);
+    for (const row of created)
+        slot(row).created++;
+    for (const row of closed)
+        slot(row).closeMs.push((row.closedAt ?? row.createdAt) - row.createdAt);
+    const kept = [...groups].filter(([, one]) => one.open.length + one.created + one.closeMs.length > 0);
+    const ids = kept.map(([key]) => key);
+    const names = by === "chat"
+        ? await store.tasks.statNames("chat", ids, taskAccount(account))
+        : by === "project"
+            ? await store.tasks.statNames("project", ids)
+            : await meetingNames(store, ids);
+    const rows = kept.map(([key, one]) => ({
+        group: key,
+        name: names.get(key) ?? null,
+        open: one.open.length,
+        created: one.created,
+        closed: one.closeMs.length,
+        ...(one.open[0] ? { oldestOpenAt: new Date(one.open[0].createdAt) } : {}),
+        ...spread(one.open, one.closeMs, now),
+    }));
+    const open = kept.flatMap(([, one]) => one.open);
+    const closeMs = kept.flatMap(([, one]) => one.closeMs);
+    return {
+        by,
+        open: open.length,
+        created: created.length,
+        closed: closeMs.length,
+        ...spread(open, closeMs, now),
+        rows,
+    };
+};
+const meetingIdOf = (group) => {
+    try {
+        return String(parseMeetingReference(group).meetingId);
+    }
+    catch {
+        return undefined;
+    }
+};
+/** A meeting task's group is `meeting:<account>/<meeting>`; its title is the meeting's, by the meeting's store id. */
+const meetingNames = async (store, groups) => {
+    const meetingOf = new Map(groups.flatMap((group) => {
+        const id = meetingIdOf(group);
+        return id === undefined ? [] : [[group, id]];
+    }));
+    const titles = await store.tasks.statNames("meeting", [...new Set(meetingOf.values())]);
+    return new Map([...meetingOf].flatMap(([group, id]) => {
+        const title = titles.get(id);
+        return title === undefined ? [] : [[group, title]];
+    }));
+};

package/dist/services/tasks.d.ts

@@ -3,9 +3,10 @@ import type * as v from "valibot";
 import { task as taskEntity } from "../entities/task.js";
 import { type CloseSuggestion, type SimilarTask, type TaskDraft, type TaskPair, type TaskPairSide, type TaskRelation } from "../store/index.js";
 import type { AccountKey, Author, MessageStore, TaskDetails, ThingLink } from "../store/store.js";
-import { type ClosedState, type GroupStats, TASK_KINDS, TASK_STATES, type Task, type TaskKind, type TaskOrigin } from "../tasks/index.js";
+import { type ClosedState, TASK_KINDS, TASK_STATES, type Task, type TaskKind, type TaskOrigin } from "../tasks/index.js";
 import type { ServiceDeps } from "./deps.js";
 import { type TaskCategory, type UnlistedCategory } from "./task-categories.js";
+import { type TaskStats, type TaskStatsRequest } from "./task-stats.js";
 export { TASK_KINDS, TASK_STATES };
 /** Source previews are read on demand; task records never retain source text. */
 export interface TaskView extends Task {
@@ -26,6 +27,18 @@ export declare const TASK_QUERY: {
     readonly backend: "sql";
     readonly fields: import("@wirecat/cli-base/query").FieldSpec[];
 };
+/** `stats tasks show`: the task query's fields, with the period as `created` in place of the two time fields. */
+export declare const TASK_STATS_QUERY: {
+    readonly entity: "task";
+    readonly backend: "sql";
+    readonly fields: readonly [...import("@wirecat/cli-base/query").FieldSpec[], {
+        readonly name: "created";
+        readonly type: "time";
+        readonly operators: readonly import("@wirecat/cli-base/query").Operator[];
+        readonly example: "created>=30d";
+        readonly relation: "the period: created counts the tasks opened in it, closed the tasks done or dismissed in it; open is open now";
+    }];
+};
 /** Which pairs `tasks duplicates list` lists: those waiting for the reviewing agent, or those it left to the owner. */
 export declare const PAIR_DECISIONS: readonly ["review", "unsure"];
 export type PairDecision = (typeof PAIR_DECISIONS)[number];
@@ -163,10 +176,10 @@ export interface TasksService {
     close(id: string, options: CloseRequest): Promise<ClosedTask>;
     /** The owner refuses an agent's close: the task stays open and the suggestion goes. */
     reject(id: string, by: TaskOrigin): Promise<TaskCard>;
-    stats(filter?: {
+    /** `chat` narrows to one chat, by name or id; see `taskStatsOf` for what each count means. */
+    stats(request?: Omit<TaskStatsRequest, "group"> & {
         chat?: string;
-        type?: TaskKind;
-    }): Promise<GroupStats[]>;
+    }): Promise<TaskStats>;
     /** Title, description, due date and next check; `null` clears one. */
     plan(id: string, plan: TaskPlan, by: TaskOrigin): Promise<TaskCard>;
     /**

package/dist/services/tasks.js

@@ -1,5 +1,5 @@
 import { CliError, isCliError, singleLine } from "@wirecat/cli-base";
-import { queryFieldsOf, walkQuery } from "@wirecat/cli-base/query";
+import { OPERATORS_BY_TYPE, queryFieldsOf, walkQuery } from "@wirecat/cli-base/query";
 import { isLocator, parseLocator } from "../domain/locator.js";
 import { formatReference } from "../domain/references.js";
 import { task as taskEntity } from "../entities/task.js";
@@ -9,6 +9,7 @@ import { createTaskService, isClosedState, TASK_KINDS, TASK_STATES, } from "../t
 import { storedChatId } from "./message-resolution.js";
 import { categorize, taskCategoryOf } from "./task-categories.js";
 import { taskAccount } from "./task-rules.js";
+import { PERIOD_FIELD, taskStatsOf } from "./task-stats.js";
 import { taskTagFilters } from "./task-tag-filters.js";
 export { TASK_KINDS, TASK_STATES };
 export const TASK_QUERY = {
@@ -41,6 +42,21 @@ export const TASK_QUERY = {
         },
     }),
 };
+/** `stats tasks show`: the task query's fields, with the period as `created` in place of the two time fields. */
+export const TASK_STATS_QUERY = {
+    entity: "task",
+    backend: "sql",
+    fields: [
+        ...TASK_QUERY.fields.filter(({ name }) => name !== "created_at" && name !== "closed_at"),
+        {
+            name: PERIOD_FIELD,
+            type: "time",
+            operators: OPERATORS_BY_TYPE.time,
+            example: `${PERIOD_FIELD}>=30d`,
+            relation: "the period: created counts the tasks opened in it, closed the tasks done or dismissed in it; open is open now",
+        },
+    ],
+};
 /** Which pairs `tasks duplicates list` lists: those waiting for the reviewing agent, or those it left to the owner. */
 export const PAIR_DECISIONS = ["review", "unsure"];
 export const TASK_PAIR_QUERY = {
@@ -143,6 +159,14 @@ export const tasksService = (deps, categories) => {
     const inStore = async (work) => work(await deps.store(), await deps.account());
     const service = (store) => createTaskService({ store: store.tasks });
     const groupOf = async (store, account, chat) => chat === undefined ? undefined : storedChatId(deps.messenger, chat, store, account, { includeLeft: true });
+    /** The task query's columns, with each `chat:` name in the query resolved to its stored chat id once. */
+    const queryColumns = async (store, account, query) => {
+        const groups = new Map();
+        for (const node of query ? walkQuery(query.root) : [])
+            if (node.field === "chat" && node.operator !== "wildcard" && !groups.has(node.value))
+                groups.set(node.value, await storedChatId(deps.messenger, node.value, store, account, { includeLeft: true }));
+        return taskColumns(groups, await taskTagFilters(store, query));
+    };
     const refuseBare = (target) => {
         throw new CliError("validation_error", `no task ${singleLine(target)} — write task:${singleLine(target)} for a task`);
     };
@@ -204,12 +228,9 @@ export const tasksService = (deps, categories) => {
         : 0;
     return {
         list: ({ query, limit, offset, previews }) => inStore(async (store, account) => {
-            const groups = new Map();
-            for (const node of query ? walkQuery(query.root) : [])
-                if (node.field === "chat" && node.operator !== "wildcard" && !groups.has(node.value))
-                    groups.set(node.value, await storedChatId(deps.messenger, node.value, store, account, { includeLeft: true }));
-            const tags = await taskTagFilters(store, query);
-            const where = query ? queryFilter(query, taskColumns(groups, tags), { command: "tasks list" }) : undefined;
+            const where = query
+                ? queryFilter(query, await queryColumns(store, account, query), { command: "tasks list" })
+                : undefined;
             const rows = await store.tasks.query(taskAccount(account), where, { limit: limit + 1, offset });
             const shown = rows.slice(0, limit);
             return {
@@ -484,13 +505,9 @@ export const tasksService = (deps, categories) => {
             await owned(store, account, subject);
             return store.tasks.similar({ task: subject }, options);
         }),
-        stats: (filter = {}) => inStore(async (store, account) => {
-            const group = await groupOf(store, account, filter.chat);
-            const rows = await service(store).stats({
-                account: taskAccount(account),
-                ...(filter.type === undefined ? {} : { kind: filter.type }),
-            });
-            return group === undefined ? rows : rows.filter((one) => one.group === group);
+        stats: ({ chat, ...request } = {}) => inStore(async (store, account) => {
+            const group = await groupOf(store, account, chat);
+            return taskStatsOf(store, account, { ...request, ...(group === undefined ? {} : { group }) }, await queryColumns(store, account, request.query));
         }),
     };
 };

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
@@ -41,8 +43,8 @@ export interface Refusal {
     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.
+ * 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;
 /**

package/dist/store/decisions.js

@@ -1,12 +1,14 @@
 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 };
 /**
- * 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.
+ * 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;
+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.

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

@@ -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,6 +70,7 @@ 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, EditedTask, MovedSubtask, NewWorkTask, RevisionCheck, TaskAssignment, TaskDetails, TaskEvent, TaskFields, TaskMove, TaskMoved, TaskRole, TaskType, WorkTaskType, } from "./sqlite/work-tasks.js";

package/dist/store/index.js

@@ -26,7 +26,7 @@ export { ORGANIZATION_KINDS, PROJECT_TYPES, SCOPES } from "./sqlite/knowledge.js
 export { NOTE_FIELDS, } from "./sqlite/note-search.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/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;