@wirecat/cli-core 0.562.0 → 0.563.0

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[];

package/dist/store/sqlite/reply-times.js

@@ -0,0 +1,113 @@
+import { PEER_KIND } from "./lucene-fields.js";
+import { read } from "./transaction.js";
+const FAR = Number.MAX_SAFE_INTEGER;
+const chatsIn = (scope, kinds) => {
+    const params = [...scope.accounts.flatMap(({ provider, account }) => [provider, account]), ...kinds];
+    const parts = [
+        `(${scope.accounts.map(() => "(ac.provider=? AND ac.external_id=?)").join(" OR ") || "0"})`,
+        `${PEER_KIND} IN (${kinds.map(() => "?").join(",")})`,
+    ];
+    for (const { account, chatId } of scope.chats) {
+        parts.push("ac.provider=? AND ac.external_id=? AND c.external_id=?");
+        params.push(account.provider, account.account, chatId);
+    }
+    for (const kind of scope.kinds) {
+        parts.push(`${PEER_KIND}=?`);
+        params.push(kind);
+    }
+    // As in search: a chat named is read even when it is not searchable.
+    if (scope.chats.length === 0)
+        parts.push("c.searchable=1");
+    return { sql: parts.join(" AND "), params };
+};
+/**
+ * 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 const replyDelaysQuery = (scope, who) => {
+    const since = scope.since ?? -FAR;
+    const until = scope.until ?? FAR;
+    const chats = chatsIn(scope, ["private"]);
+    return {
+        sql: `WITH scoped AS MATERIALIZED (
+  SELECT c.id AS chat_id, coalesce((
+    SELECT p.sent_at FROM messages p WHERE p.chat_id=c.id AND p.sent_at<? AND p.deleted_at IS NULL
+      AND coalesce(p.outgoing,0)<>(SELECT coalesce(l.outgoing,0) FROM messages l
+        WHERE l.chat_id=c.id AND l.sent_at<? AND l.deleted_at IS NULL ORDER BY l.sent_at DESC LIMIT 1)
+    ORDER BY p.sent_at DESC LIMIT 1), ?) AS since
+  FROM chats c JOIN accounts ac ON ac.id=c.account_id WHERE ${chats.sql}
+), sides AS (
+  SELECT m.chat_id, m.id, m.sent_at, coalesce(m.outgoing,0) AS mine,
+    lag(coalesce(m.outgoing,0)) OVER (PARTITION BY m.chat_id ORDER BY m.sent_at, m.id) AS before
+  FROM scoped s JOIN messages m ON m.chat_id=s.chat_id AND m.sent_at>=s.since AND m.sent_at<=?
+  WHERE m.deleted_at IS NULL
+), runs AS (
+  SELECT sent_at, mine, lag(sent_at) OVER (PARTITION BY chat_id ORDER BY sent_at, id) AS asked_at
+  FROM sides WHERE before IS NULL OR before<>mine
+)
+SELECT sent_at AS replied_at, sent_at-asked_at AS delay_ms FROM runs
+WHERE asked_at IS NOT NULL AND mine=? AND sent_at>=? AND sent_at<=?`,
+        params: [since, since, -FAR, ...chats.params, until, who === "me" ? 1 : 0, since, until],
+    };
+};
+export const replyDelays = (context, scope, who) => {
+    const { sql, params } = replyDelaysQuery(scope, who);
+    return read(context.database, () => context.database
+        .prepare(sql)
+        .all(...params)
+        .map((row) => ({ repliedAt: Number(row.replied_at), delayMs: Number(row.delay_ms) })));
+};
+/** Each one-to-one chat's and group's newest message, found by index per chat, its time within the scope's bounds. */
+export const newestMessagesQuery = (scope, now) => {
+    const chats = chatsIn(scope, ["private", "group"]);
+    return {
+        sql: `SELECT c.id AS chat_id, ${PEER_KIND} AS kind, m.sent_at, coalesce(m.outgoing,0) AS mine, m.text,
+  (EXISTS (SELECT 1 FROM json_each(CASE WHEN json_valid(m.mentions) THEN m.mentions ELSE '[]' END) WHERE value=ac.external_id)
+    OR coalesce(json_extract(CASE WHEN json_valid(m.reply_to) THEN m.reply_to ELSE '{}' END,'$.outgoing'),0)=1
+    OR EXISTS (SELECT 1 FROM messages q WHERE q.chat_id=c.id AND q.external_id=m.reply_to_external_id AND q.outgoing=1)
+  ) AS addressed,
+  (SELECT i.username FROM identities i WHERE i.provider=ac.provider AND i.external_id=ac.external_id) AS owner_username,
+  ((coalesce(c.muted,0)=1 AND (c.muted_until IS NULL OR c.muted_until>?)) OR coalesce(c.archived,0)=1)
+    AND coalesce(c.marked_unread,0)=0 AS quiet
+FROM chats c JOIN accounts ac ON ac.id=c.account_id
+JOIN messages m ON m.id=(SELECT n.id FROM messages n WHERE n.chat_id=c.id AND n.deleted_at IS NULL ORDER BY n.sent_at DESC LIMIT 1)
+WHERE ${chats.sql} AND m.sent_at>=? AND m.sent_at<=?`,
+        params: [now, ...chats.params, scope.since ?? -FAR, scope.until ?? FAR],
+    };
+};
+/** The newest `cap` messages of a chat, newest first: enough to find where the owner last spoke. */
+export 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 ?";
+/**
+ * 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 const waitingChats = (context, scope, waits, cap) => {
+    const { sql, params } = newestMessagesQuery(scope, context.now());
+    const { database } = context;
+    return read(database, () => {
+        const tail = database.prepare(TAIL_SQL);
+        return database
+            .prepare(sql)
+            .all(...params)
+            .map((row) => ({
+            chatId: Number(row.chat_id),
+            kind: String(row.kind),
+            sentAt: Number(row.sent_at),
+            mine: Number(row.mine) === 1,
+            text: String(row.text),
+            addressed: Number(row.addressed) === 1,
+            ownerUsername: row.owner_username === null ? null : String(row.owner_username),
+            quiet: Number(row.quiet) === 1,
+        }))
+            .filter(waits)
+            .map(({ chatId, kind }) => {
+            const unanswered = [];
+            for (const row of tail.all(chatId, cap)) {
+                if (Number(row.mine) === 1)
+                    break;
+                unanswered.push(Number(row.sent_at));
+            }
+            return { kind, unanswered };
+        });
+    });
+};

package/dist/store/sqlite/work-tasks.d.ts

@@ -33,7 +33,8 @@ export interface TaskFields {
     category?: string;
     /**
      * Another owner project, by key or `project:<id>`: the task takes the next key there; its old key still finds it.
-     * A subtask moves only with `parent: null` in the same edit.
+     * Its subtasks, all the way down, move with it and keep their parents. A subtask moves only with `parent: null` in
+     * the same edit.
      */
     project?: string;
     /** A project task's kind, bug, feature or chore. */
@@ -91,6 +92,15 @@ export interface TaskDetails {
     createdAt: string;
     updatedAt: string;
 }
+/** A subtask that moved to another project with its parent: its key before and after. */
+export interface MovedSubtask {
+    from: string;
+    to: string;
+}
+/** What `edit` answers: the task, and the subtasks a move to another project took with it. */
+export interface EditedTask extends TaskDetails {
+    movedSubtasks?: MovedSubtask[];
+}
 export interface RevisionCheck {
     /** The revision the caller read; a write on any other is refused (`task.stale`). */
     revision?: number;
@@ -167,7 +177,7 @@ export interface TaskEvent {
 /** Tasks beyond the package's four message kinds, and the fields the package does not know, on any task. */
 export interface WorkTasks extends TaskRelationsStore {
     create(input: NewWorkTask, by: Author): Promise<TaskDetails>;
-    edit(id: string, fields: TaskFields, by: Author, check?: RevisionCheck): Promise<TaskDetails>;
+    edit(id: string, fields: TaskFields, by: Author, check?: RevisionCheck): Promise<EditedTask>;
     assign(id: string, assignment: TaskAssignment, by: Author, check?: RevisionCheck): Promise<TaskDetails>;
     unassign(id: string, assignment: TaskAssignment, by: Author, check?: RevisionCheck): Promise<TaskDetails>;
     /**

package/dist/store/sqlite/work-tasks.js

@@ -172,7 +172,7 @@ export const workTaskOperationsOver = (context) => {
     /** The task takes the target's next number and key; the source's counter never goes back, so its old key stays unique. */
     const moveToProject = (task, before, target, actor, at, detach) => {
         if (target === Number(before.project_id))
-            return;
+            return [];
         if (!onBoard(task))
             throw new CliError("validation_error", "only a project task moves to another project");
         const targetRow = database.prepare("SELECT key FROM projects WHERE id = ?").get(target);
@@ -182,25 +182,32 @@ export const workTaskOperationsOver = (context) => {
             const parent = taskIdOf(database, Number(before.parent_id));
             throw new CliError("validation_error", `${String(before.key)} is a subtask of ${parent}; detach it in the same write (parent none) to move it alone`, { reason: "task.is-subtask", parent });
         }
-        const children = database
-            .prepare("SELECT key FROM tasks WHERE parent_id = ? AND deleted_at IS NULL ORDER BY id")
-            .all(task)
-            .map((row) => String(row.key));
-        if (children.length)
-            throw new CliError("validation_error", `${String(before.key)} has subtasks (${children.join(", ")}); move or detach them first`, { reason: "task.has-subtasks", subtasks: children });
-        const counted = database
-            .prepare("UPDATE projects SET tasks_count = tasks_count + 1, updated_at = ? WHERE id = ? RETURNING key, tasks_count")
-            .get(at, target);
-        const number = Number(counted.tasks_count);
-        const key = `${String(counted.key)}-${number}`;
-        database
-            .prepare("UPDATE tasks SET project_id = ?, number = ?, key = ?, parent_id = NULL, updated_at = ? WHERE id = ?")
-            .run(target, number, key, at, task);
-        recordTaskEvent(database, task, actor, "project", {
-            project: [`project:${before.project_id}`, `project:${target}`],
-            key: [String(before.key), key],
-            ...(before.parent_id == null ? {} : { parent: [`task:${taskIdOf(database, Number(before.parent_id))}`, null] }),
-        }, at);
+        const renumber = (row, parent) => {
+            const counted = database
+                .prepare("UPDATE projects SET tasks_count = tasks_count + 1, updated_at = ? WHERE id = ? RETURNING key, tasks_count")
+                .get(at, target);
+            const number = Number(counted.tasks_count);
+            const key = `${String(counted.key)}-${number}`;
+            database
+                .prepare("UPDATE tasks SET project_id = ?, number = ?, key = ?, parent_id = ?, updated_at = ? WHERE id = ?")
+                .run(target, number, key, parent, at, Number(row.id));
+            recordTaskEvent(database, Number(row.id), actor, "project", {
+                project: [`project:${row.project_id}`, `project:${target}`],
+                key: [String(row.key), key],
+                ...(row.parent_id === parent ? {} : { parent: [`task:${taskIdOf(database, Number(row.parent_id))}`, null] }),
+            }, at);
+            return key;
+        };
+        renumber(before, null);
+        const moved = [];
+        const childrenOf = database.prepare("SELECT * FROM tasks WHERE parent_id = ? AND deleted_at IS NULL ORDER BY id");
+        for (const queue = [task]; queue.length > 0;) {
+            for (const child of childrenOf.all(queue.shift())) {
+                moved.push({ from: String(child.key), to: renumber(child, child.parent_id) });
+                queue.push(Number(child.id));
+            }
+        }
+        return moved;
     };
     const edit = (task, fields, actor, created = false) => {
         const before = rowById(task);
@@ -283,16 +290,18 @@ export const workTaskOperationsOver = (context) => {
             change("type", fields.type, "type");
             bump = true;
         }
-        if (fields.project !== undefined)
-            moveToProject(task, before, projectOf(fields.project), actor, at, fields.parent === null);
+        const moved = fields.project === undefined
+            ? []
+            : moveToProject(task, before, projectOf(fields.project), actor, at, fields.parent === null);
         if (set.length === 0) {
             if (bump)
                 database.prepare("UPDATE tasks SET revision = revision + 1 WHERE id = ?").run(task);
-            return;
+            return moved;
         }
         if (bump)
             set.push("revision = revision + 1");
         database.prepare(`UPDATE tasks SET ${set.join(", ")}, updated_at = ? WHERE id = ?`).run(...values, at, task);
+        return moved;
     };
     /** The column's tasks in board order, the moving one left out; no priority reads as 0, the bottom of low. */
     const columnOf = (task, status) => database
@@ -390,11 +399,11 @@ export const workTaskOperationsOver = (context) => {
         },
         edit: async (id, fields, by, check = {}) => {
             const task = required(id);
-            write(database, () => {
+            const moved = write(database, () => {
                 checkRevision(rowById(task), check.revision);
-                edit(task, fields, authorActor(context, by).actor);
+                return edit(task, fields, authorActor(context, by).actor);
             });
-            return details(task);
+            return moved.length > 0 ? { ...details(task), movedSubtasks: moved } : details(task);
         },
         /** `edit` inside the caller's write, so a decision that edits a task rolls back with it. */
         editNow: (id, fields, by) => {

package/dist/store/store.d.ts

@@ -123,6 +123,7 @@ export interface MessageStore {
 }
 export type { ChatHistoryShape, StoredHistorySkip } from "./sqlite/history-skips.js";
 export { BACKFILL_ON_OPEN, type StoreOptions } from "./sqlite/open-store.js";
+export type { ChatScope, NewestMessage, ReplyDelay, WaitingChat } from "./sqlite/reply-times.js";
 export { fileFacts, readStoreTables, type TableKind } from "./sqlite/store-tables.js";
 export declare const openStore: (options?: StoreOptions) => Promise<MessageStore>;
 export * from "./exports.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.562.0",
+  "version": "0.563.0",
   "description": "The messenger-neutral half of a messaging CLI: domain model, message locators, rendering, name resolution, the SQLite seam, the command skeleton and shared read commands, the send guard, run records and the message store",
   "license": "Apache-2.0",
   "author": "Viacheslav Ptsarev",

package/parity.json

@@ -1127,6 +1127,11 @@
       "value": "<json>",
       "meaning": "the complete ranking component weights; replaces preset weights when --score is given"
     },
+    "--who": {
+      "value": "<side>",
+      "default": "me",
+      "meaning": "whose replies are timed: the owner's (me) or the other side's (others)"
+    },
     "--with-notes": {
       "meaning": "include your private notes, subject to contacts.notes.list permission"
     },
@@ -2766,6 +2771,9 @@
     "config": {
       "in": "all"
     },
+    "config migrate": {
+      "in": "all"
+    },
     "config repair": {
       "in": "all",
       "options": {
@@ -4528,6 +4536,15 @@
         "--selection": "all"
       }
     },
+    "stats messages responses": {
+      "in": "all",
+      "options": {
+        "--by": "all",
+        "--source": "all",
+        "--timezone": "all",
+        "--who": "all"
+      }
+    },
     "stats messages show": {
       "in": "all",
       "options": {
@@ -4606,6 +4623,13 @@
         "--timezone": "all"
       }
     },
+    "stats messages waiting": {
+      "in": "all",
+      "options": {
+        "--source": "all",
+        "--timezone": "all"
+      }
+    },
     "stats tasks": {
       "in": "all"
     },