@wirecat/cli-core 0.562.0 → 0.564.0

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/retention.js

@@ -1,14 +1,9 @@
 import { createHash } from "node:crypto";
 import { CliError } from "@wirecat/cli-base";
-import { calendarKey } from "../../domain/calendar.js";
+import { calendarKey, weekKey } from "../../domain/calendar.js";
 import { RETENTION_TOLERANCE, retentionCohorts, validateRetentionOptions, } from "../../domain/retention.js";
 import { chatCompleteness } from "./completeness.js";
 const iso = (at) => new Date(at).toISOString();
-const week = (day) => {
-    const date = new Date(`${day}T00:00:00Z`);
-    date.setUTCDate(date.getUTCDate() - ((date.getUTCDay() + 6) % 7));
-    return date.toISOString().slice(0, 10);
-};
 export const retentionQuery = (context, accountPk, chatPk, chatId, options, evidence) => {
     validateRetentionOptions(options);
     if (options.cutoff > context.now())
@@ -33,7 +28,7 @@ export const retentionQuery = (context, accountPk, chatPk, chatId, options, evid
     const activityStatement = database.prepare(`SELECT min(sent_at) AS at FROM messages WHERE chat_id=? AND sender_identity_id=? AND deleted_at IS NULL AND sent_at >= ? AND sent_at < ?`);
     const stays = raw.map((row) => {
         const joinedAt = Number(row.joined_at), pk = Number(row.pk), end = joinedAt + options.within;
-        const day = dayOf(joinedAt), cohort = options.by === "week" ? week(day) : day;
+        const day = dayOf(joinedAt), cohort = options.by === "week" ? weekKey(day) : day;
         const absence = departureStatement.get(chatPk, Math.max(joinedAt, Number(row.first_seen_at)), options.cutoff, pk);
         const upper = absence ? Number(absence.observed_at) : null;
         const positive = lastPositiveStatement.get(pk, upper ?? options.cutoff + 1);

package/dist/store/sqlite/task-board.js

@@ -37,6 +37,7 @@ export const PROJECT_TASK_FIELDS = [
         relation: "the due date as a board groups it: overdue (open work due before today), today, upcoming (the next 7 days " +
             "after today), later, or none",
     }),
+    field("created", "time", "created:>=30d", { relation: "when it was opened" }),
     field("closed", "time", "closed:>=14d", { relation: "when it was done or dismissed" }),
     field("ready", "bool", "ready:true", { relation: "open work whose blocked-by tasks are all done" }),
     field("text", "txt", "text:invoice", { relation: "words of the title and description; a bare word means this" }),
@@ -183,6 +184,7 @@ export const projectTaskColumns = (now, zone) => ({
     agent: { where: agentWhere },
     parent: { where: parentWhere },
     due: { type: "time", sql: "t.due_at" },
+    created: { type: "time", sql: "t.created_at" },
     closed: { type: "time", sql: "t.closed_at" },
     overdue: { where: (node) => truth(node, dueGroups(now, zone).overdue) },
     when: {

package/dist/store/sqlite/task-stats.d.ts

@@ -0,0 +1,32 @@
+import type { StoreContext } from "./open.js";
+import type { Where } from "./query-filter.js";
+/** One account's tasks (its inbox), or the owner's project tasks across every project. */
+export type TaskStatScope = {
+    account: string;
+} | {
+    board: true;
+};
+export interface TaskStatRow {
+    group: string | null;
+    sourceKind: string | null;
+    projectId: number;
+    state: string;
+    createdAt: number;
+    closedAt: number | null;
+}
+export type TaskStatNames = "chat" | "meeting" | "project";
+export interface TaskStats {
+    /** One narrow row per live task in the scope that `where` keeps, oldest first. */
+    statRows(scope: TaskStatScope, where: Where | undefined): Promise<TaskStatRow[]>;
+    /** Titles by id, read once: chats by external id within `account`, meetings and projects by their store id. */
+    statNames(kind: TaskStatNames, ids: readonly string[], account?: string): Promise<Map<string, string>>;
+}
+/** Every statement `stats tasks show` runs, for the query-plan test. */
+export declare const TASK_STATS_SQL: {
+    readonly rows: (board: boolean, filter: string) => string;
+    readonly chat: string;
+    readonly meeting: "SELECT CAST(id AS TEXT) AS id, title AS name FROM meetings WHERE id IN (SELECT value FROM json_each(?))";
+    readonly project: "SELECT CAST(id AS TEXT) AS id, name FROM projects WHERE id IN (SELECT value FROM json_each(?))";
+};
+/** `inbox` finds an account's inbox project without making one. */
+export declare const taskStatsOver: ({ database }: StoreContext, inbox: (account: string) => number | undefined) => TaskStats;

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

@@ -0,0 +1,45 @@
+import { BOARD_SCOPE } from "./task-board.js";
+const ACCOUNT_SCOPE = "t.package_id IS NOT NULL AND t.deleted_at IS NULL AND t.project_id = ?";
+/** Every statement `stats tasks show` runs, for the query-plan test. */
+export const TASK_STATS_SQL = {
+    rows: (board, filter) => "SELECT t.source_group, t.source_kind, t.project_id, t.status, t.created_at, t.closed_at FROM tasks t " +
+        `WHERE ${board ? BOARD_SCOPE : ACCOUNT_SCOPE}${filter} ORDER BY t.created_at, t.id`,
+    chat: "SELECT c.external_id AS id, c.title AS name FROM chats c JOIN accounts a ON a.id = c.account_id " +
+        "WHERE a.provider = ? AND a.external_id = ? AND c.external_id IN (SELECT value FROM json_each(?))",
+    meeting: "SELECT CAST(id AS TEXT) AS id, title AS name FROM meetings WHERE id IN (SELECT value FROM json_each(?))",
+    project: "SELECT CAST(id AS TEXT) AS id, name FROM projects WHERE id IN (SELECT value FROM json_each(?))",
+};
+/** `inbox` finds an account's inbox project without making one. */
+export const taskStatsOver = ({ database }, inbox) => ({
+    statRows: async (scope, where) => {
+        const filter = where === undefined ? "" : ` AND (${where.sql})`;
+        const board = !("account" in scope);
+        const project = board ? undefined : inbox(scope.account);
+        if (!board && project === undefined)
+            return [];
+        return database
+            .prepare(TASK_STATS_SQL.rows(board, filter))
+            .all(...(project === undefined ? [] : [project]), ...(where?.params ?? []))
+            .map((row) => ({
+            group: row.source_group == null ? null : String(row.source_group),
+            sourceKind: row.source_kind == null ? null : String(row.source_kind),
+            projectId: Number(row.project_id),
+            state: String(row.status),
+            createdAt: Number(row.created_at),
+            closedAt: row.closed_at == null ? null : Number(row.closed_at),
+        }));
+    },
+    statNames: async (kind, ids, account) => {
+        if (ids.length === 0)
+            return new Map();
+        let params = [JSON.stringify(ids.map(Number))];
+        if (kind === "chat") {
+            if (account === undefined)
+                return new Map();
+            const at = account.indexOf(":");
+            params = [account.slice(0, at), account.slice(at + 1), JSON.stringify(ids)];
+        }
+        const rows = database.prepare(TASK_STATS_SQL[kind]).all(...params);
+        return new Map(rows.filter((row) => row.name != null).map((row) => [String(row.id), String(row.name)]));
+    },
+});

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

@@ -6,11 +6,12 @@ import { type TaskSimilarity } from "./task-candidates.js";
 import { type CloseSuggestion } from "./task-close.js";
 import { type TaskCloseStore } from "./task-close-store.js";
 import { type TaskPairs } from "./task-pairs.js";
+import { type TaskStats } from "./task-stats.js";
 import { type WorkTasks } from "./work-tasks.js";
 export { inboxKey, linkInbox, taskAccountOf } from "./task-keys.js";
 export { taskIdOf, taskRowOf } from "./things.js";
 /** `TaskStore` for `src/tasks/`, plus a way from its task ids to the store's rows. */
-export interface StoreTaskStore extends Omit<Required<TaskStore>, "reviewDuplicates">, WorkTasks, TaskSimilarity, TaskPairs, TaskCloseStore {
+export interface StoreTaskStore extends Omit<Required<TaskStore>, "reviewDuplicates">, WorkTasks, TaskSimilarity, TaskPairs, TaskStats, TaskCloseStore {
     /** The default list (or one an older build saved here) with the shared config file's `task_categories` edits. */
     categories(): Promise<readonly TaskCategory[]>;
     /** The shared config file whose `task_categories` edits the list. */

package/dist/store/sqlite/tasks.js

@@ -11,6 +11,7 @@ import { CLEAR_SUGGESTION, closeSuggestionOf, SUGGESTION_COLUMNS } from "./task-
 import { taskCloseOver } from "./task-close-store.js";
 import { inboxKey, typedKey } from "./task-keys.js";
 import { taskPairsOver } from "./task-pairs.js";
+import { taskStatsOver } from "./task-stats.js";
 import { taskRowOf, thingOf } from "./things.js";
 import { read, write } from "./transaction.js";
 import { recordTaskEvent, workTasksOver } from "./work-tasks.js";
@@ -91,6 +92,7 @@ export const taskStoreOver = (context) => {
         ...workTasksOver(context),
         ...similarity,
         ...taskPairsOver(context, similarity),
+        ...taskStatsOver(context, (account) => inbox(account, false)),
         ...taskCloseOver(context),
         rowOf: (id) => taskRowOf(database, id),
         categories: async () => listOf(),

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.564.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

@@ -160,7 +160,7 @@
     "--by": {
       "value": "<grouping>",
       "meaning": "what to count by",
-      "note": "each command names its own groupings — stats messages show chat, sender, day or hour, and searches create the same for stats messages show --saved; stats chats show day or week, as a series beside its totals — so it differs on purpose (Help text rule 4)"
+      "note": "each command names its own groupings — stats messages show chat, sender, day or hour, and searches create the same for stats messages show --saved; stats chats show day or week, as a series beside its totals; stats tasks show chat, meeting or project — so it differs on purpose (Help text rule 4)"
     },
     "--calls": {
       "value": "<who>",
@@ -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,15 +4623,28 @@
         "--timezone": "all"
       }
     },
+    "stats messages waiting": {
+      "in": "all",
+      "options": {
+        "--source": "all",
+        "--timezone": "all"
+      }
+    },
     "stats tasks": {
       "in": "all"
     },
     "stats tasks show": {
       "in": "all",
       "options": {
+        "--by": {
+          "in": "all"
+        },
         "--chat": {
           "in": "all"
         },
+        "--timezone": {
+          "in": "all"
+        },
         "--type": {
           "in": "all"
         }
@@ -4652,6 +4682,12 @@
         "--encrypt": "all"
       }
     },
+    "store chats": {
+      "in": "all"
+    },
+    "store chats status": {
+      "in": "all"
+    },
     "store check": {
       "in": "all"
     },