@wirecat/cli-core 0.554.0 → 0.556.0

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

@@ -0,0 +1,109 @@
+import { int, str } from "./events.js";
+/** `tasks agenda` fields over `threadActivity`'s threads: an email thread counts as a dialog. */
+export const MAIL_AGENDA_COLUMNS = { chat_kind: { type: "enum", sql: "'dialog'" } };
+// The thread's own time is the Date header where sync stored one, so a thread is picked by it; the newest email is
+// picked by when it arrived, which is what an answer follows.
+const ACTIVITY = `
+  SELECT t.external_id AS thread, t.subject, t.last_email_at, t.emails_count,
+    e.external_id, coalesce(e.received_at, e.sent_at) AS at,
+    coalesce(e.outgoing, lower(e.from_address) = lower(a.external_id)) AS outgoing,
+    EXISTS (SELECT 1 FROM email_recipients r WHERE r.email_id = e.id AND r.role IN ('to', 'cc')
+      AND lower(r.address) = lower(a.external_id)) AS addressed,
+    EXISTS (SELECT 1 FROM email_mailboxes m JOIN mailboxes b ON b.id = m.mailbox_id
+      WHERE m.email_id = e.id AND b.kind = 'bulk') AS bulk,
+    coalesce(json_extract(e.headers, '$."list-id"'), json_extract(e.metadata, '$.listId')) IS NOT NULL AS list,
+    EXISTS (SELECT 1 FROM email_mailboxes m JOIN mailboxes b ON b.id = m.mailbox_id
+      WHERE m.email_id = e.id AND b.kind = 'envelope') AS envelope,
+    EXISTS (SELECT 1 FROM account_identities ai WHERE ai.account_id = t.account_id
+      AND ai.identity_id = e.from_identity_id AND ai.mail_demoted = 1) AS demoted
+  FROM email_threads t JOIN accounts a ON a.id = t.account_id
+  LEFT JOIN emails e ON e.id = (SELECT f.id FROM emails f WHERE f.email_thread_id = t.id AND f.deleted_at IS NULL
+    AND coalesce(f.draft, 0) = 0 ORDER BY coalesce(f.received_at, f.sent_at) DESC, f.id DESC LIMIT 1)
+  WHERE t.account_id = ? AND t.deleted_at IS NULL AND t.last_email_at > ?`;
+export const threadActivity = (database, accountId, since, where) => database
+    .prepare(`${ACTIVITY}${where ? ` AND (${where.sql})` : ""} ORDER BY t.last_email_at DESC, t.id DESC`)
+    .all(accountId, since, ...(where?.params ?? []))
+    .map((row) => ({
+    threadId: String(row.thread),
+    subject: str(row.subject),
+    lastEmailAt: Number(row.last_email_at),
+    emails: Number(row.emails_count),
+    newest: row.external_id == null
+        ? null
+        : {
+            externalId: String(row.external_id),
+            at: int(row.at) ?? Number(row.last_email_at),
+            outgoing: Boolean(row.outgoing),
+            addressed: Boolean(row.addressed),
+            bulk: Boolean(row.bulk),
+            list: Boolean(row.list),
+            envelope: Boolean(row.envelope),
+            demoted: Boolean(row.demoted),
+        },
+}));
+/** A thread's live emails, oldest first; `window` keeps those received in (after, until], in ms. */
+export const threadEmailIds = (database, accountId, thread, { after, until } = {}) => database
+    .prepare(`SELECT e.id FROM emails e JOIN email_threads t ON t.id = e.email_thread_id
+        WHERE t.account_id = ? AND t.external_id = ? AND e.deleted_at IS NULL
+          AND coalesce(e.received_at, e.sent_at, 0) > coalesce(?, -1)
+          AND coalesce(e.received_at, e.sent_at, 0) <= coalesce(?, 9e15)
+        ORDER BY coalesce(e.sent_at, e.received_at), e.id`)
+    .all(accountId, thread, after ?? null, until ?? null)
+    .map(({ id }) => Number(id));
+const MARKS = `
+  SELECT e.mail_rule_id, coalesce(json_extract(e.headers, '$."list-id"'), json_extract(e.metadata, '$.listId')) AS list_id,
+    EXISTS (SELECT 1 FROM email_mailboxes m JOIN mailboxes b ON b.id = m.mailbox_id
+      WHERE m.email_id = e.id AND b.kind = 'bulk') AS bulk
+  FROM emails e WHERE e.account_id = ? AND e.external_id = ? AND e.deleted_at IS NULL`;
+export const emailMarks = (database, accountId, externalIds) => {
+    const one = database.prepare(MARKS);
+    const marks = new Map();
+    for (const id of externalIds) {
+        const row = one.get(accountId, id);
+        if (row)
+            marks.set(id, { bulk: Boolean(row.bulk), listId: str(row.list_id), ruleId: int(row.mail_rule_id) });
+    }
+    return marks;
+};
+const MARKED = `
+  SELECT e.id, e.external_id, t.external_id AS thread, coalesce(e.received_at, e.sent_at) AS at, e.created_at,
+    e.updated_at, coalesce(e.draft, 0) AS draft, json_extract(e.metadata, '$.partial') IS NOT NULL AS partial,
+    coalesce(json_extract(e.headers, '$."list-id"'), json_extract(e.metadata, '$.listId')) IS NOT NULL
+      OR EXISTS (SELECT 1 FROM email_mailboxes m JOIN mailboxes b ON b.id = m.mailbox_id
+        WHERE m.email_id = e.id AND b.kind = 'bulk') AS bulk,
+    EXISTS (SELECT 1 FROM email_mailboxes m JOIN mailboxes b ON b.id = m.mailbox_id
+      WHERE m.email_id = e.id AND b.kind = 'envelope') AS envelope
+  FROM emails e JOIN email_threads t ON t.id = e.email_thread_id`;
+const markedOf = (row) => ({
+    id: Number(row.id),
+    externalId: String(row.external_id),
+    thread: String(row.thread),
+    at: int(row.at),
+    storedAt: Number(row.created_at),
+    changedAt: Number(row.updated_at),
+    bulk: Boolean(row.bulk),
+    envelope: Boolean(row.envelope),
+    partial: Boolean(row.partial),
+    draft: Boolean(row.draft),
+});
+export const emailsAfter = (database, accountId, afterId, limit, ids = []) => {
+    const next = database
+        .prepare(`${MARKED} WHERE e.id > ? AND e.account_id = ? AND e.deleted_at IS NULL ORDER BY e.id LIMIT ?`)
+        .all(afterId, accountId, limit);
+    const one = database.prepare(`${MARKED} WHERE e.id = ? AND e.account_id = ? AND e.deleted_at IS NULL`);
+    const named = ids.flatMap((id) => {
+        const row = one.get(id, accountId);
+        return row ? [row] : [];
+    });
+    return [...named, ...next].map(markedOf);
+};
+export const mailActivity = (database) => ({
+    emailsAfter: async (accountId, afterId, limit, ids) => emailsAfter(database, accountId, afterId, limit, ids),
+    newestEmailId: async (accountId) => Number(database.prepare("SELECT max(id) AS id FROM emails WHERE account_id = ?").get(accountId)?.id ?? 0),
+    statesLike: async (accountId, prefix) => database
+        .prepare("SELECT key, value, updated_at FROM sync_cursors WHERE account_id = ? AND substr(key, 1, ?) = ?")
+        .all(accountId, prefix.length, prefix)
+        .map((row) => ({ key: String(row.key), value: String(row.value), at: Number(row.updated_at) })),
+    emailMarks: async (accountId, externalIds) => emailMarks(database, accountId, externalIds),
+    threadActivity: async (accountId, since, where) => threadActivity(database, accountId, since, where),
+});

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

@@ -3,6 +3,7 @@ import type { Attachment, Metadata } from "../../meetings/index.js";
 import type { Stemmer, Stemmers } from "../../search/stem.js";
 import type { CacheDatabase } from "../driver.js";
 import type { ConversationSummary, StoredHit } from "../types.js";
+import { type MailActivityStore } from "./email-activity.js";
 import { type EmailLocationInput, type FolderEmail, type PartialMailStore } from "./email-locations.js";
 import { type MailRulesStore } from "./mail-rules.js";
 import { type AttachmentInput } from "./meetings.js";
@@ -205,7 +206,7 @@ export interface SenderScore {
     demoted?: boolean;
 }
 /** Mail in tables of its own: threads, emails, recipients and mailboxes, keyed by account and Message-ID. */
-export interface MailStore extends PartialMailStore {
+export interface MailStore extends PartialMailStore, MailActivityStore {
     saveThread(input: ThreadSave): Promise<ThreadDetails>;
     /** Several threads and sync state in one transaction: a slice of mail commits with its resume point, or not at all. */
     saveThreads(inputs: ThreadSave[], states?: SyncStateSave[]): Promise<ThreadDetails[]>;
@@ -268,8 +269,13 @@ export interface MailStore extends PartialMailStore {
     }[]>;
     /** Live emails of one account by Message-ID, each placed in its thread; an unknown one is left out. */
     inThreads(accountId: number, externalIds: string[]): Promise<EmailInThread[]>;
-    /** A thread's live emails, oldest first, as search hits: whole text, people, labels and locator. */
-    threadHits(accountId: number, threadExternalId: string): Promise<StoredHit[]>;
+    /** Emails by store id, as search hits in the order given; one the store does not hold is left out. */
+    emailHits(ids: readonly number[]): Promise<StoredHit[]>;
+    /** A thread's live emails, oldest first, as search hits; `window` keeps those received in (after, until], in ms. */
+    threadHits(accountId: number, thread: string, window?: {
+        after?: number;
+        until?: number;
+    }): Promise<StoredHit[]>;
     /** The emails of one account nearest in meaning to `query`, each by its best chunk, best first. */
     nearest(model: string, query: Float32Array, options: {
         accountId: number;

package/dist/store/sqlite/emails.js

@@ -1,6 +1,7 @@
 import { formatLocator } from "../../domain/locator.js";
 import { formatReference } from "../../domain/references.js";
 import { fold, normalize } from "../normalize.js";
+import { mailActivity, threadEmailIds } from "./email-activity.js";
 import { chunkAttachments, drainEmailIndex, dropAttachmentChunks, MAIL_PIECES, queueThreads, threadPieces, titleOf, } from "./email-index.js";
 import { backfillSentAt, folderEmails, forgetLocations, locate, partialMail, setLocations, storedWhole, } from "./email-locations.js";
 import { markEmailsDeleted, markEmailsRestored, recountEmailThread as recount, setEmailFlags } from "./email-state.js";
@@ -472,6 +473,7 @@ export const mailStoreOver = ({ database, orm, now }, stemmerFor = stemmerCache(
         }));
     },
     ...partialMail(database),
+    ...mailActivity(database),
     async emailFacts(filter = {}) {
         const [where, params] = emailWhere(filter);
         return database
@@ -631,14 +633,9 @@ export const mailStoreOver = ({ database, orm, now }, stemmerFor = stemmerCache(
             return place ? [{ ...place, score }] : [];
         });
     },
-    async threadHits(accountId, threadExternalId) {
-        const ids = database
-            .prepare(`SELECT e.id FROM emails e JOIN email_threads t ON t.id = e.email_thread_id
-          WHERE t.account_id = ? AND t.external_id = ? AND e.deleted_at IS NULL
-          ORDER BY coalesce(e.sent_at, e.received_at), e.id`)
-            .all(accountId, threadExternalId)
-            .map(({ id }) => Number(id));
-        return emailHitsByPk(database, ids);
+    emailHits: async (ids) => emailHitsByPk(database, [...ids]),
+    async threadHits(accountId, thread, window) {
+        return emailHitsByPk(database, threadEmailIds(database, accountId, thread, window));
     },
     async inThreads(accountId, externalIds) {
         const id = database.prepare("SELECT id FROM emails WHERE account_id = ? AND external_id = ? AND deleted_at IS NULL");

package/dist/store/sqlite/task-analysis-marks.d.ts

@@ -0,0 +1,7 @@
+import type { Id } from "../../domain/models.js";
+import type { CacheDatabase } from "../driver.js";
+import type { AccountKey, TaskAnalysisMark, TaskAnalysisMarkWrite } from "../types.js";
+export declare const taskAnalysisMarks: (database: CacheDatabase, account: AccountKey) => TaskAnalysisMark[];
+export declare const taskAnalysisMark: (database: CacheDatabase, account: AccountKey, chatId: Id) => TaskAnalysisMark | undefined;
+/** `checked`: the whole stretch through `checkedThrough` was read just now, by this store's clock. */
+export declare const setTaskAnalysisMark: (database: CacheDatabase, account: AccountKey, { chatId, checked, ...saved }: TaskAnalysisMarkWrite, now: number) => void;

package/dist/store/sqlite/task-analysis-marks.js

@@ -0,0 +1,27 @@
+// In store_settings beside task_rules_until, so backup and restore carry it and it needs no migration.
+const prefixOf = ({ provider, account }) => `task_analysis:${provider}:${account}:`;
+const markOf = (prefix, row) => ({
+    chatId: String(row.key).slice(prefix.length),
+    ...JSON.parse(String(row.value)),
+    at: new Date(Number(row.at)).toISOString(),
+});
+export const taskAnalysisMarks = (database, account) => {
+    const prefix = prefixOf(account);
+    return database
+        .prepare("SELECT key, value, at FROM store_settings WHERE substr(key, 1, ?) = ? ORDER BY at DESC")
+        .all(prefix.length, prefix)
+        .map((row) => markOf(prefix, row));
+};
+export const taskAnalysisMark = (database, account, chatId) => {
+    const prefix = prefixOf(account);
+    const row = database.prepare("SELECT key, value, at FROM store_settings WHERE key = ?").get(prefix + chatId);
+    return row ? markOf(prefix, row) : undefined;
+};
+/** `checked`: the whole stretch through `checkedThrough` was read just now, by this store's clock. */
+export const setTaskAnalysisMark = (database, account, { chatId, checked, ...saved }, now) => {
+    const checkedAt = checked ? new Date(now).toISOString() : taskAnalysisMark(database, account, chatId)?.checkedAt;
+    database
+        .prepare("INSERT INTO store_settings (key, value, at) VALUES (?, ?, ?) " +
+        "ON CONFLICT (key) DO UPDATE SET value = excluded.value, at = excluded.at")
+        .run(prefixOf(account) + chatId, JSON.stringify({ ...saved, checkedAt: checkedAt ?? new Date(now).toISOString() }), now);
+};

package/dist/store/sync.d.ts

@@ -1,6 +1,6 @@
 import type { Id } from "../domain/models.js";
 import type { StoreContext } from "./sqlite/open.js";
-import type { AccountKey, Delta, Range } from "./types.js";
+import type { AccountKey, Delta, Range, TaskAnalysisMark, TaskAnalysisMarkWrite } from "./types.js";
 export interface SyncStore {
     /** What a sync remembered under `name` for this account, and when; a caller encodes a number itself. */
     syncState(key: AccountKey, name: string): Promise<{
@@ -31,5 +31,9 @@ export interface SyncStore {
     /** Where the account's last task-rule pass stopped: the newest store time it read. */
     taskRulesStop(key: AccountKey): Promise<string | null>;
     setTaskRulesStop(key: AccountKey, until: string): Promise<void>;
+    /** Every chat of the account read for tasks, the latest moved first. */
+    taskAnalysisMarks(key: AccountKey): Promise<TaskAnalysisMark[]>;
+    taskAnalysisMark(key: AccountKey, chatId: Id): Promise<TaskAnalysisMark | undefined>;
+    setTaskAnalysisMark(key: AccountKey, mark: TaskAnalysisMarkWrite): Promise<void>;
 }
 export declare const syncStoreOver: (context: StoreContext) => SyncStore;

package/dist/store/sync.js

@@ -2,6 +2,7 @@ import { keysOver } from "./keys.js";
 import * as chatQueries from "./sqlite/chats.js";
 import * as ranges from "./sqlite/ranges.js";
 import * as sync from "./sqlite/sync.js";
+import { setTaskAnalysisMark, taskAnalysisMark, taskAnalysisMarks } from "./sqlite/task-analysis-marks.js";
 import { setTaskRulesStop, taskRulesStop } from "./sqlite/task-rule-stops.js";
 import { write } from "./sqlite/transaction.js";
 export const syncStoreOver = (context) => {
@@ -56,5 +57,8 @@ export const syncStoreOver = (context) => {
         },
         taskRulesStop: async (key) => taskRulesStop(database, key),
         setTaskRulesStop: async (key, until) => setTaskRulesStop(database, key, until, context.now()),
+        taskAnalysisMarks: async (key) => taskAnalysisMarks(database, key),
+        taskAnalysisMark: async (key, chatId) => taskAnalysisMark(database, key, chatId),
+        setTaskAnalysisMark: async (key, mark) => setTaskAnalysisMark(database, key, mark, context.now()),
     };
 };

package/dist/store/types.d.ts

@@ -251,3 +251,28 @@ export interface Range {
     from: number;
     to: number;
 }
+/**
+ * How far a chat's messages were read for tasks: every stored message sent from `from` through `through`, the one
+ * with id `throughId` last. Its own point, so reading a chat, marking it read or another reader's `--new` never
+ * moves it.
+ */
+export interface TaskAnalysisMark {
+    chatId: Id;
+    from: string;
+    through: string;
+    throughId: Id;
+    /** Who moved it last: an agent's name or the owner. */
+    by: string;
+    /**
+     * At `checkedAt` every stored message sent from `from` through `checkedThrough` had been read; one saved or edited
+     * later inside that stretch (history fetched afterwards) was not.
+     */
+    checkedAt: string;
+    checkedThrough: string;
+    /** When it last moved. */
+    at: string;
+}
+/** `checked` stamps `checkedAt` with the store's clock; otherwise the mark keeps its earlier one. */
+export type TaskAnalysisMarkWrite = Omit<TaskAnalysisMark, "at" | "checkedAt"> & {
+    checked: boolean;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.554.0",
+  "version": "0.556.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

@@ -735,6 +735,9 @@
       "value": "<on|off>",
       "meaning": "only the owner may change the name and photo"
     },
+    "--open-new": {
+      "meaning": "open a task from a message the chat's task point already passed; without it a read again only updates and closes tasks"
+    },
     "--operation-id": {
       "value": "<id>",
       "meaning": "identify a send or creation attempt; message/poll retries reuse it, while an unknown topic creation must never be repeated"
@@ -2763,6 +2766,12 @@
     "config": {
       "in": "all"
     },
+    "config repair": {
+      "in": "all",
+      "options": {
+        "--dry-run": "all"
+      }
+    },
     "config set": {
       "in": "all",
       "options": {
@@ -4816,6 +4825,12 @@
     "tasks": {
       "in": "all"
     },
+    "tasks acknowledge": {
+      "in": "all",
+      "options": {
+        "--since-time": "all"
+      }
+    },
     "tasks add": {
       "in": "all",
       "options": {
@@ -4825,6 +4840,7 @@
         "--due": "all",
         "--into": "all",
         "--new": "all",
+        "--open-new": "all",
         "--remind-time": "all",
         "--title": "all",
         "--type": {
@@ -4931,6 +4947,13 @@
         "--holder": "all"
       }
     },
+    "tasks review": {
+      "in": "all",
+      "options": {
+        "--limit": "all",
+        "--since-time": "all"
+      }
+    },
     "tasks scan": {
       "in": "all",
       "options": {
@@ -4940,6 +4963,12 @@
     "tasks show": {
       "in": "all"
     },
+    "tasks status": {
+      "in": "all",
+      "options": {
+        "--limit": "all"
+      }
+    },
     "tasks unmerge": {
       "in": "all"
     },

package/skills/follow-ups/SKILL.md

@@ -38,6 +38,26 @@ no message text — read all of it:
 
 Anything not on the agenda waits for its own date. Do not open it.
 
+**Every chat keeps its own point of reading for tasks.** `review --new`, `inbox`, the owner reading on the phone
+and other agents all move their own points, so a message they showed is not yet read for tasks. Work from the
+task point instead:
+
+```sh
+{{command}} tasks status --json                        # per chat: read for tasks through when, how many wait, how many came late
+{{command}} tasks review "<chat>" --json               # the messages after the point, oldest first, and the chat's open tasks
+{{command}} tasks acknowledge "<chat>" <message id>    # after its tasks are opened, updated or closed: the next review starts after it
+```
+
+For each chat with `waiting` above 0: `tasks review`, then open new tasks, update or close the listed `open_tasks`
+the new messages settle, then run the `next` step the answer gives (`tasks acknowledge`). Acknowledge only what you
+finished; a page with `has_more: true` is followed by the next one. A chat with `late` above 0 got older history
+after it was read: `tasks review "<chat>" --since-time <mark.from>` reads the stretch again (up to 1000 messages),
+and acknowledging that read clears it. A read again only updates and closes tasks: `tasks add` refuses a message the
+point already passed (`task.already-read`) unless it is given `--open-new`, which you pass only when the owner asked
+for tasks from that history. When that answer has `has_more: true` it gives no acknowledge step: the stretch
+is too long to read again in one page, so tell the owner and move on. A chat whose history is not stored yet is fetched by `messages sync` first; `tasks review` reads
+only the store.
+
 **History is not work.** A first sync opens no tasks from old messages (`task_first_pass_per_chat`, 0 by
 default) and says how many it held. Do not read old chats looking for tasks. Ask the owner which chats to build,
 then for each: `{{command}} tasks scan "<chat>" --json` lists what would open, and `--yes` opens it. Dig deeper
@@ -103,7 +123,7 @@ stop. The owner sends what they choose.
 
 `{{command}} schedule agent follow-ups claude "<prompt>" --at 08:30` runs this every morning. Then you run
 with the CLI's read-only variable set (`MAX_READ_ONLY=1` for max). The task work above still runs: `tasks scan --yes`,
-`add`, `plan`, `link`, `merge`, `unmerge`, `duplicates reject`, `duplicates defer`, `claim`, `release` and `close`
+`acknowledge`, `add`, `plan`, `link`, `merge`, `unmerge`, `duplicates reject`, `duplicates defer`, `claim`, `release` and `close`
 — but every `tasks close` then waits on the owner as a suggestion, whatever your certainty, and `--as-owner` is
 refused. Everything else that writes is refused, so do not try: every send, reaction and edit; changes to schedules,
 settings, the recipient list or auto-replies; tags, contact notes and aliases, saved searches, `tasks reject`. What you print is the report the owner opens; its first line shows in the desktop
@@ -115,7 +135,7 @@ A recipe is a set of flags, not a new command:
 
 | Recipe | Command |
 |---|---|
-| Morning sweep | `review --new --json`, then `tasks agenda --json` |
+| Morning sweep | `review --new --json`, then `tasks agenda --json`, then `tasks status --json` and a `tasks review` per waiting chat |
 | Weekly quiet-chat pass | `tasks agenda --waiting 3d --within 90d --json` |
 | Groups too, not only people | `tasks agenda "chat_kind:(dialog OR group OR channel)" --json` |
 | Before a call with someone | `tasks list 'chat:"<chat>" state:open' --json`, then `tasks show` each |