@wirecat/cli-core 0.554.0 → 0.556.0

package/dist/cli/messenger/catch-up-answers.d.ts

@@ -1,5 +1,5 @@
 import type { Meta } from "@wirecat/cli-base/standards";
-import type { ChatKind, Inbox, Review } from "../../domain/models.js";
+import type { ChatKind, Inbox, Message, Review } from "../../domain/models.js";
 import { type Hearing } from "../../speech/hearing.js";
 import type { AccountKey } from "../../store/store.js";
 import { type QueryWords } from "../list-query.js";
@@ -14,6 +14,54 @@ export declare const catchUpQuery: (words: QueryWords, registry: typeof INBOX_QU
     kinds?: ChatKind[];
     meta?: Partial<Meta>;
 };
+type Read = Message & {
+    chatTitle?: string | null;
+};
+/** One message of a catch-up answer: the fields `inbox` and `review` show, for every messenger and for mail. */
+export declare const summaryOf: (message: Read, reader: AccountKey) => {
+    ref: string;
+    chat_id: string;
+    chat_title: string | null | undefined;
+    timestamp: string;
+    sender_name: string | null;
+    sender_is_me: boolean;
+    outgoing: boolean | null;
+    text: string;
+    transcript?: string | undefined;
+    attachments: {
+        message?: string | undefined;
+        kind: string;
+        position?: number | undefined;
+        url?: string | undefined;
+        name?: string | undefined;
+        title?: string | undefined;
+        mime?: string | undefined;
+        size?: number | undefined;
+        width?: number | undefined;
+        height?: number | undefined;
+        duration?: number | undefined;
+        text?: string | undefined;
+        extraction?: {
+            origin: string;
+            extractor: string;
+            chars: number;
+            error?: string | undefined;
+        } | undefined;
+        local_path?: string | undefined;
+        contact?: {
+            name: string;
+            first_name?: string | undefined;
+            last_name?: string | undefined;
+            phone?: string | undefined;
+            user_id?: string | undefined;
+        } | undefined;
+        buttons?: {
+            kind: "app" | "callback" | "chat" | "clipboard" | "contact" | "link" | "location" | "message" | "other";
+            text: string;
+            url?: string | undefined;
+        }[][] | undefined;
+    }[];
+};
 export declare const inboxAnswer: (inbox: Inbox, hearing: Hearing | undefined, reader: AccountKey, transcribe: boolean, meta?: Partial<Meta>) => import("../envelope.js").ListBody<{
     ref: string;
     chat_id: string;
@@ -113,3 +161,4 @@ export declare const reviewAnswer: (found: Review, hearing: Hearing | undefined,
         }[][] | undefined;
     }[];
 }>;
+export {};

package/dist/cli/messenger/catch-up-answers.js

@@ -33,7 +33,8 @@ export const catchUpQuery = (words, registry, command) => {
         ...(meta === undefined ? {} : { meta }),
     };
 };
-const summaryOf = (message, reader) => {
+/** One message of a catch-up answer: the fields `inbox` and `review` show, for every messenger and for mail. */
+export const summaryOf = (message, reader) => {
     const { ref, chat_id, chat_title, timestamp, sender_name, sender_is_me, outgoing, text, transcript, attachments } = messageItem(message, reader);
     return {
         ref,

package/dist/cli/messenger/catch-up.d.ts

@@ -1,3 +1,7 @@
 import type { Command } from "commander";
-/** Whose `--new` points a run moves: an agent's are its own, so the owner's `inbox --new` still shows everything. */
-export declare const pointsOf: <N extends "inbox" | "review">(command: Command, name: N) => N | `mcp-${N}`;
+import type { AppIdentity } from "../../ports/app.js";
+/**
+ * Whose `--new` points a run moves. A scheduled run (`<PREFIX>_SCHEDULED`) keeps one per schedule, an agent over MCP
+ * one of its own, and the owner the plain one: no reader moves another's point past what it never showed.
+ */
+export declare const pointsOf: (command: Command, name: string, app: Pick<AppIdentity, "envPrefix">) => string;

package/dist/cli/messenger/catch-up.js

@@ -1,3 +1,12 @@
 import { environmentOf } from "../context.js";
-/** Whose `--new` points a run moves: an agent's are its own, so the owner's `inbox --new` still shows everything. */
-export const pointsOf = (command, name) => environmentOf(command).agent ? `mcp-${name}` : name;
+/**
+ * Whose `--new` points a run moves. A scheduled run (`<PREFIX>_SCHEDULED`) keeps one per schedule, an agent over MCP
+ * one of its own, and the owner the plain one: no reader moves another's point past what it never showed.
+ */
+export const pointsOf = (command, name, app) => {
+    const { agent, env } = environmentOf(command);
+    const scheduled = (env ?? process.env)[`${app.envPrefix}_SCHEDULED`]?.trim();
+    if (scheduled)
+        return `schedule-${scheduled.replace(/[^a-z0-9-]/gi, "_")}-${name}`;
+    return agent ? `mcp-${name}` : name;
+};

package/dist/cli/messenger/conversation-answers.d.ts

@@ -248,6 +248,9 @@ export declare const conversationShown: (account: AccountKey, { summary, message
                 signals: string[];
                 demoted?: true | undefined;
             } | undefined;
+            bulk?: boolean | undefined;
+            list_id?: string | null | undefined;
+            rule_id?: number | null | undefined;
         } | undefined;
         provider_metadata?: {
             [x: string]: unknown;

package/dist/cli/messenger/inbox.js

@@ -53,7 +53,7 @@ export const inboxCommand = (messenger) => annotate(new Command("inbox"), {
         throw new CliError("validation_error", "--new keeps its own point — not with a date in the query");
     const saved = fresh && since === undefined
         ? checkPoints(app, {
-            command: pointsOf(this, "inbox"),
+            command: pointsOf(this, "inbox", app),
             profile: settings.profile,
             env,
             firstLookMs: FIRST_LOOK_MS,

package/dist/cli/messenger/message-answers.d.ts

@@ -225,6 +225,9 @@ export declare const threadAnswer: ({ items, ...thread }: ThreadContext, reader:
                 signals: string[];
                 demoted?: true | undefined;
             } | undefined;
+            bulk?: boolean | undefined;
+            list_id?: string | null | undefined;
+            rule_id?: number | null | undefined;
         } | undefined;
         provider_metadata?: {
             [x: string]: unknown;

package/dist/cli/messenger/message-writes.d.ts

@@ -229,6 +229,9 @@ export declare const writtenAnswer: ({ operationId, sendId, message, messages, s
                 signals: string[];
                 demoted?: true | undefined;
             } | undefined;
+            bulk?: boolean | undefined;
+            list_id?: string | null | undefined;
+            rule_id?: number | null | undefined;
         } | undefined;
         provider_metadata?: {
             [x: string]: unknown;
@@ -448,6 +451,9 @@ export declare const writtenAnswer: ({ operationId, sendId, message, messages, s
                 signals: string[];
                 demoted?: true | undefined;
             } | undefined;
+            bulk?: boolean | undefined;
+            list_id?: string | null | undefined;
+            rule_id?: number | null | undefined;
         } | undefined;
         provider_metadata?: {
             [x: string]: unknown;

package/dist/cli/messenger/points.d.ts

@@ -5,16 +5,21 @@ export interface CheckPoints {
     first: number;
     /** ms, per chat: where its next check starts. */
     chats: ReadonlyMap<Id, number>;
-    /** Moves the chats checked; the rest keep their point. */
-    save(checked: Record<Id, string>): void;
+    /**
+     * Moves the chats checked; the rest keep their point. With `through`, everything up to it was read: the start for
+     * a chat never checked moves there, and the points it passes are dropped, so the file stays small.
+     */
+    save(checked: Record<Id, string>, options?: {
+        through?: string;
+    }): void;
 }
 /**
  * Where `<command> --new` stopped, per chat and profile, beside the remembered account. `inbox` and
  * `review` keep a file each: sharing one, an `inbox` run would move `review` past what it never showed.
- * The MCP tools keep their own too, so an agent's run never moves the owner's `--new`.
+ * Each reader keeps its own too (`pointsOf`), so an agent's or a schedule's run never moves the owner's `--new`.
  */
 export declare const checkPoints: (app: AppIdentity, { command, profile, env, firstLookMs, }: {
-    command: "inbox" | "review" | "mcp-inbox" | "mcp-review";
+    command: string;
     profile: string;
     env: NodeJS.ProcessEnv;
     firstLookMs: number;

package/dist/cli/messenger/points.js

@@ -4,7 +4,7 @@ import { resolvePaths, writeSecurely } from "@wirecat/cli-base";
 /**
  * Where `<command> --new` stopped, per chat and profile, beside the remembered account. `inbox` and
  * `review` keep a file each: sharing one, an `inbox` run would move `review` past what it never showed.
- * The MCP tools keep their own too, so an agent's run never moves the owner's `--new`.
+ * Each reader keeps its own too (`pointsOf`), so an agent's or a schedule's run never moves the owner's `--new`.
  */
 export const checkPoints = (app, { command, profile, env, firstLookMs, }) => {
     const file = join(resolvePaths({ appName: app.appName, prefix: app.envPrefix, env }).state, command, `${profile}.json`);
@@ -13,10 +13,16 @@ export const checkPoints = (app, { command, profile, env, firstLookMs, }) => {
     return {
         first: Date.parse(first),
         chats: new Map(Object.entries(saved.chats ?? {}).map(([chat, at]) => [chat, Date.parse(at)])),
-        save: (checked) => {
-            if (Object.keys(checked).length === 0)
+        save: (checked, { through } = {}) => {
+            if (Object.keys(checked).length === 0 && through === undefined)
                 return;
-            const kept = { lastCheckAt: first, chats: { ...saved.chats, ...checked } };
+            const chats = { ...saved.chats, ...checked };
+            const kept = through === undefined
+                ? { lastCheckAt: first, chats }
+                : {
+                    lastCheckAt: through,
+                    chats: Object.fromEntries(Object.entries(chats).filter(([, at]) => Date.parse(at) > Date.parse(through))),
+                };
             writeSecurely(file, `${JSON.stringify(kept)}\n`, 0o600);
         },
     };

package/dist/cli/messenger/review.js

@@ -52,7 +52,7 @@ export const reviewCommand = (messenger) => annotate(new Command("review"), {
     }
     const saved = options.new
         ? checkPoints(messenger.app, {
-            command: pointsOf(this, "review"),
+            command: pointsOf(this, "review", messenger.app),
             profile: settings.profile,
             env,
             firstLookMs: REVIEW_DAYS * 86_400_000,

package/dist/cli/messenger/store-maintenance-command.d.ts

@@ -3,9 +3,9 @@ import type { CacheDatabase } from "../../store/driver.js";
 import type { Messenger } from "./context.js";
 /** `doctor`'s short summary of the store. Must answer for a broken file, so an error is a field. */
 export declare const storeSummary: (env: NodeJS.ProcessEnv) => Promise<{
+    error?: undefined;
     path: string;
     exists: boolean;
-    error?: undefined;
 } | {
     path: string;
     exists: boolean;

package/dist/cli/messenger/tasks-analysis-command.d.ts

@@ -0,0 +1,8 @@
+import type { Command } from "commander";
+import { type Messenger } from "./context.js";
+/**
+ * Each chat's own point of reading for tasks (`../../services/task-analysis.ts`): how far it was read, what waits, and
+ * the step that moves it. Apart from `inbox --new`, `review --new` and the messenger's read state, which other
+ * readers move.
+ */
+export declare const analysisCommands: (tasks: Command, messenger: Messenger) => void;

package/dist/cli/messenger/tasks-analysis-command.js

@@ -0,0 +1,184 @@
+import { annotate } from "@wirecat/cli-base/commands";
+import { formatLocator } from "../../domain/locator.js";
+import { storedChatId } from "../../services/message-resolution.js";
+import { momentOf } from "../../services/moment.js";
+import { ANALYSIS_PAGE, ANALYSIS_PAGE_MAX, acknowledgeTaskAnalysis, taskAnalysisList, unanalysedMessages, } from "../../services/task-analysis.js";
+import { TASK_QUERY } from "../../services/tasks.js";
+import { actorOf } from "../author.js";
+import { destroysNothing, LOCAL_READ, LOCAL_WRITE } from "../effects.js";
+import { itemOf, renderAnswer } from "../envelope.js";
+import { listQuery, pagedList, pageOf, typedQuery } from "../list-query.js";
+import { positiveCount } from "../paging.js";
+import { nextStep } from "../steps.js";
+import { messengerContext, refuseLocalWrite } from "./context.js";
+const when = (at) => (at === null ? "—" : at.slice(0, 16).replace("T", " "));
+const sinceOf = (typed) => typed === undefined ? undefined : new Date(momentOf(typed, "--since-time")).toISOString();
+const markItem = (mark) => ({
+    chat: mark.chatId,
+    from: mark.from,
+    through: mark.through,
+    through_id: mark.throughId,
+    by: mark.by,
+    checked_at: mark.checkedAt,
+    checked_through: mark.checkedThrough,
+    at: mark.at,
+});
+const analysisItem = (chat) => ({
+    chat: chat.chatId,
+    title: chat.title,
+    kind: chat.kind,
+    newest_at: chat.newestAt,
+    mark: chat.mark === null ? null : markItem(chat.mark),
+    waiting: chat.waiting,
+    late: chat.late,
+    untrusted: ["title"],
+});
+/**
+ * Each chat's own point of reading for tasks (`../../services/task-analysis.ts`): how far it was read, what waits, and
+ * the step that moves it. Apart from `inbox --new`, `review --new` and the messenger's read state, which other
+ * readers move.
+ */
+export const analysisCommands = (tasks, messenger) => {
+    const tool = messenger.app.command;
+    annotate(tasks.command("status"), {
+        output: { entity: "task_analysis" },
+        effects: LOCAL_READ,
+        examples: [`${tool} personal tasks status`],
+    })
+        .summary("how far each chat was read for tasks, and how much waits")
+        .description("every chat that can hold your tasks — not a channel or Saved Messages — with the point its messages were read " +
+        "for tasks through, who read them, how many stored messages wait after it, and how many arrived late inside " +
+        "the stretch already read (history fetched afterwards). Its own point: reading a chat, marking it read, " +
+        "inbox --new and review --new never move it; tasks acknowledge does. Reads only the local store")
+        .option("--limit <n>", "how many chats", positiveCount("--limit"))
+        .action(async function () {
+        const context = messengerContext(this, messenger);
+        const { limit, offset } = pageOf(context.settings);
+        const chats = await context.withStore((store, account) => taskAnalysisList(store, account), {
+            name: "tasks status",
+        });
+        const shown = chats.slice(offset, offset + limit);
+        renderAnswer(this, context, pagedList("tasks status", context.settings, {
+            items: shown.map(analysisItem),
+            has_more: chats.length > offset + limit,
+        }), () => shown.length === 0
+            ? ""
+            : `${shown
+                .map((one) => `${(one.title ?? one.chatId).slice(0, 30).padEnd(30)}  read through ${when(one.mark?.through ?? null)}` +
+                `  ${one.waiting} waiting${one.late > 0 ? `, ${one.late} late` : ""}`)
+                .join("\n")}\n`);
+    });
+    annotate(tasks.command("review"), {
+        output: { entity: "task_review" },
+        effects: LOCAL_READ,
+        examples: [`${tool} personal tasks review <chat>`, `${tool} personal tasks review <chat> --since-time 30d`],
+    })
+        .summary("a chat's stored messages not yet read for tasks, with its open tasks")
+        .description("the stored messages after the chat's task point, oldest first, and the chat's open tasks, so one read can open " +
+        "new tasks and update or close the old ones. A chat never read starts 14 days back. Moves nothing: when done, " +
+        "tasks acknowledge <chat> <through> records it. Reads only the local store; messages sync or backfill fetch " +
+        "what it lacks")
+        .argument("<chat>", messenger.chatArgument)
+        .option("--limit <n>", `how many messages (default ${ANALYSIS_PAGE}, ${ANALYSIS_PAGE_MAX} with --since-time; at most ${ANALYSIS_PAGE_MAX})`, positiveCount("--limit"))
+        .option("--since-time <time>", "read again from this ISO 8601 time, or 30d ago, whatever the point says; what the point already passed only " +
+        "updates and closes tasks, unless tasks add is given --open-new")
+        .action(async function (chat) {
+        const context = messengerContext(this, messenger);
+        const { sinceTime, ...options } = this.opts();
+        const since = sinceOf(sinceTime);
+        // A read again clears late messages only when one acknowledge covers the whole stretch, so it takes one page.
+        const limit = options.limit ?? (since === undefined ? ANALYSIS_PAGE : ANALYSIS_PAGE_MAX);
+        const { id, page, sourceOf } = await context.withStore(async (store, account) => {
+            const id = await storedChatId(messenger, chat, store, account, { includeLeft: true });
+            return {
+                id,
+                page: await unanalysedMessages(store, account, id, {
+                    limit: Math.min(limit, ANALYSIS_PAGE_MAX),
+                    ...(since === undefined ? {} : { since }),
+                }),
+                sourceOf: (message) => formatLocator({ ...account, chat: id, message }),
+            };
+        }, { name: "tasks review" });
+        const open = await context.withServices((services) => services.tasks.list({
+            query: listQuery(typedQuery([`chat:${JSON.stringify(id)}`, "state:open"]), TASK_QUERY, "tasks review"),
+            limit: 100,
+            offset: 0,
+        }));
+        const last = page.messages.at(-1);
+        renderAnswer(this, context, itemOf({
+            chat: id,
+            from: page.from,
+            mark: page.mark === null ? null : markItem(page.mark),
+            late: page.late,
+            has_more: page.more,
+            through: last ? sourceOf(last.id) : null,
+            messages: page.messages.map((one) => ({
+                ref: sourceOf(one.id),
+                at: one.timestamp,
+                sender: one.senderName,
+                outgoing: one.outgoing === true,
+                reply_to: one.replyTo?.id ?? one.replyToId ?? null,
+                text: one.text,
+            })),
+            open_tasks: open.items.map(({ key = null, kind, title, source_message }) => ({
+                key,
+                kind,
+                title,
+                source: source_message,
+            })),
+            untrusted: ["messages.text", "messages.sender"],
+        }, {
+            next: last && !(since !== undefined && page.more)
+                ? [
+                    nextStep("tasks.acknowledge", {
+                        args: { chat: id, message: last.id, since_time: since },
+                        values: { shown: page.messages.length },
+                    }),
+                ]
+                : [],
+        }), () => [
+            `from ${when(page.from)}: ${page.messages.length} message(s)${page.more ? ", more after them" : ""}` +
+                (page.late > 0
+                    ? `; ${page.late} arrived late inside the stretch read: --since-time ${page.mark?.from} reads it again`
+                    : ""),
+            ...page.messages.map((one) => `  ${when(one.timestamp)}  ${one.outgoing ? "you" : (one.senderName ?? "?")}: ${one.text.replace(/\s+/g, " ").slice(0, 100)}`),
+            `open tasks (${open.items.length})`,
+            ...open.items.map((task) => `  ${task.key}  ${task.kind}  ${task.title ?? ""}`),
+            ...(since !== undefined && page.more
+                ? [
+                    `this read again does not reach the point in one page: acknowledging it moves nothing and late ` +
+                        "messages stay until a later version pages a read again (tell the owner)",
+                ]
+                : last
+                    ? [`done reading: ${tool} tasks acknowledge ${id} ${last.id}`]
+                    : []),
+            "",
+        ].join("\n"));
+    });
+    destroysNothing(annotate(tasks.command("acknowledge"), {
+        output: { entity: "task_analysis_mark" },
+        effects: LOCAL_WRITE,
+        examples: [`${tool} personal tasks acknowledge <chat> <message>`],
+    }))
+        .summary("record that a chat was read for tasks through a message")
+        .description("moves the chat's task point to this message once its tasks are opened, updated or closed; it never moves " +
+        "back. With --since-time, the read started there: a read again from the start of the stretch clears what " +
+        "arrived late inside it")
+        .argument("<chat>", messenger.chatArgument)
+        .argument("<message>", "the id of the last message read, as tasks review shows it")
+        .option("--since-time <time>", "where the read started, when tasks review was given --since-time")
+        .action(async function (chat, message) {
+        const context = messengerContext(this, messenger);
+        refuseLocalWrite(context, messenger.app.command, "tasks.acknowledge");
+        const { sinceTime } = this.opts();
+        const since = sinceOf(sinceTime);
+        const by = actorOf(this);
+        const { mark, moved } = await context.withStore(async (store, account) => {
+            const id = await storedChatId(messenger, chat, store, account, { includeLeft: true });
+            return acknowledgeTaskAnalysis(store, account, id, message, { by, ...(since === undefined ? {} : { since }) });
+        }, { name: "tasks acknowledge" });
+        renderAnswer(this, context, itemOf({ ...markItem(mark), moved }), () => moved
+            ? `read for tasks from ${when(mark.from)} through ${when(mark.through)}\n`
+            : `already read through ${when(mark.through)}; the point stays\n`);
+    });
+};

package/dist/cli/messenger/tasks-command.js

@@ -5,6 +5,7 @@ import { readOnlyLockOf, readOnlyRefusal } from "../../ports/app.js";
 import { AGENDA_QUERY, agendaItem } from "../../services/agenda.js";
 import { storedChatId } from "../../services/message-resolution.js";
 import { aheadOf, momentOf } from "../../services/moment.js";
+import { refuseAlreadyRead } from "../../services/task-analysis.js";
 import { unlistedNote } from "../../services/task-categories.js";
 import { ARRIVAL_WINDOW, applyTaskRulesToChats } from "../../services/task-rules.js";
 import { CLAIM_LEASE_MS, closedStateOf, TASK_PAIR_QUERY, TASK_QUERY, taskLinkKindOf, taskTypeOf, } from "../../services/tasks.js";
@@ -18,6 +19,7 @@ import { positiveCount } from "../paging.js";
 import { messengerContext, refuseLocalWrite } from "./context.js";
 import { coverageGaps } from "./search-answers.js";
 import { refuseJsonl, taskStatsAnswer } from "./stats-answers.js";
+import { analysisCommands } from "./tasks-analysis-command.js";
 const line = ({ id, key, state, kind, group, createdAt, message, note }) => [
     key ?? id.slice(0, 8),
     state.padEnd(9),
@@ -175,11 +177,17 @@ export const tasksCommand = (messenger) => {
         .requiredOption("--type <type>", "the task's type: question, request, mention or promise", taskTypeOf)
         .requiredOption("--category <name>", categoryHelp)
         .option("--into <id>", "when tasks add listed tasks that may be the same job: link the message to this one instead of opening a task")
-        .option("--new", "when tasks add listed tasks that may be the same job: open the task anyway"), "send Alex the API token").action(async function (message) {
+        .option("--new", "when tasks add listed tasks that may be the same job: open the task anyway")
+        .option("--open-new", "open a task from a message the chat's task point already passed (a read again with tasks review " +
+        "--since-time); without it such a read only updates and closes tasks"), "send Alex the API token").action(async function (message) {
         const context = messengerContext(this, messenger);
         refuseLocalWrite(context, messenger.app.command, "tasks.add");
         const options = this.opts();
-        const { into, new: anyway, ...rest } = options;
+        const { into, new: anyway, openNew, ...rest } = options;
+        if (!openNew)
+            await context.withStore((store, account) => refuseAlreadyRead(store, account, message), {
+                name: "tasks add",
+            });
         const plan = planFrom(rest);
         const { task, created, attached, review, followUpOf, card: planned, } = await context.withServices((services) => services.tasks.add(message, options.type, writerOf(this), plan, {
             ...(into === undefined ? {} : { attach: into }),
@@ -440,6 +448,7 @@ export const tasksCommand = (messenger) => {
         }, { name: "tasks scan" });
         renderAnswer(this, context, listOf("tasks scan", { items: passes.map(snakeKeys), limit: passes.length, has_more: false }), () => `${passes.map((pass) => applyText(pass, yes, tool)).join("\n")}\n`);
     });
+    analysisCommands(tasks, messenger);
     destroysNothing(annotate(tasks.command("claim"), {
         output: { entity: "task_card" },
         effects: LOCAL_WRITE,

package/dist/cli/steps.js

@@ -209,6 +209,16 @@ export const STEPS = defineSteps([
         args: [],
         why: "serve still runs an older version; a restart runs the one installed now",
     },
+    {
+        id: "tasks.acknowledge",
+        command: "tasks acknowledge",
+        args: [
+            { name: "chat", required: true },
+            { name: "message", required: true },
+            { name: "since_time", required: false },
+        ],
+        why: "once the tasks these {shown} messages hold are opened, updated or closed, so the next review starts after them",
+    },
     {
         id: "search.meetings",
         command: "*",

package/dist/domain/models.d.ts

@@ -519,6 +519,10 @@ export interface Review {
     unanswered?: {
         olderThanHours: number;
     };
+    /** `--waiting` (mail): only threads where the owner wrote last and nobody answered for this many hours. */
+    waiting?: {
+        olderThanHours: number;
+    };
     /** With saved points: each chat read whole, and the time its next check starts from. */
     checked?: Record<Id, string>;
     /** Tasks the review opened and closed in the store, by the rules; absent when the store was not open. */

package/dist/entities/contact-context.d.ts

@@ -346,6 +346,9 @@ export declare const contactMessages: v.StrictObjectSchema<{
                     readonly signals: v.ArraySchema<v.StringSchema<undefined>, undefined>;
                     readonly demoted: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
                 }, undefined>, undefined>;
+                readonly bulk: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+                readonly list_id: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+                readonly rule_id: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
                 readonly reply_to: v.ArraySchema<v.StrictObjectSchema<{
                     readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
                     readonly address: v.StringSchema<undefined>;
@@ -1118,6 +1121,9 @@ export declare const contactContext: v.UnionSchema<[v.StrictObjectSchema<{
                     readonly signals: v.ArraySchema<v.StringSchema<undefined>, undefined>;
                     readonly demoted: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
                 }, undefined>, undefined>;
+                readonly bulk: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+                readonly list_id: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+                readonly rule_id: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
                 readonly reply_to: v.ArraySchema<v.StrictObjectSchema<{
                     readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
                     readonly address: v.StringSchema<undefined>;

package/dist/entities/conversation-results.d.ts

@@ -224,6 +224,9 @@ export declare const conversationDetails: v.UnionSchema<[v.StrictObjectSchema<{
                 readonly signals: v.ArraySchema<v.StringSchema<undefined>, undefined>;
                 readonly demoted: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
             }, undefined>, undefined>;
+            readonly bulk: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+            readonly list_id: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+            readonly rule_id: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
         }, undefined>, undefined>;
         readonly provider_metadata: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>;
     }, undefined>, undefined>;
@@ -441,6 +444,9 @@ export declare const conversationDetails: v.UnionSchema<[v.StrictObjectSchema<{
             readonly signals: v.ArraySchema<v.StringSchema<undefined>, undefined>;
             readonly demoted: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
         }, undefined>, undefined>;
+        readonly bulk: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+        readonly list_id: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+        readonly rule_id: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
     }, undefined>, undefined>;
     readonly provider_metadata: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>;
 }, undefined>], undefined>;

package/dist/entities/evidence.d.ts

@@ -215,6 +215,9 @@ export declare const contribution: v.StrictObjectSchema<{
                 readonly signals: v.ArraySchema<v.StringSchema<undefined>, undefined>;
                 readonly demoted: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
             }, undefined>, undefined>;
+            readonly bulk: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+            readonly list_id: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+            readonly rule_id: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
         }, undefined>, undefined>;
         readonly provider_metadata: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>;
     }, undefined>, "entries" | "~run" | "~standard" | "~types"> & {
@@ -432,6 +435,9 @@ export declare const contribution: v.StrictObjectSchema<{
                     readonly signals: v.ArraySchema<v.StringSchema<undefined>, undefined>;
                     readonly demoted: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
                 }, undefined>, undefined>;
+                readonly bulk: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+                readonly list_id: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+                readonly rule_id: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
             }, undefined>, undefined>;
             readonly provider_metadata: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>;
         }, "chat_title" | "ref" | "sender_name" | "text" | "timestamp">;
@@ -687,6 +693,9 @@ export declare const contribution: v.StrictObjectSchema<{
                 readonly signals: v.ArraySchema<v.StringSchema<undefined>, undefined>;
                 readonly demoted: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
             }, undefined>, undefined>;
+            readonly bulk: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+            readonly list_id: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+            readonly rule_id: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
         }, undefined>, undefined>;
         readonly provider_metadata: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>;
     }, undefined>, "entries" | "~run" | "~standard" | "~types"> & {
@@ -904,6 +913,9 @@ export declare const contribution: v.StrictObjectSchema<{
                     readonly signals: v.ArraySchema<v.StringSchema<undefined>, undefined>;
                     readonly demoted: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
                 }, undefined>, undefined>;
+                readonly bulk: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+                readonly list_id: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+                readonly rule_id: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
             }, undefined>, undefined>;
             readonly provider_metadata: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>;
         }, "chat_title" | "ref" | "sender_name" | "text" | "timestamp">;
@@ -1195,6 +1207,9 @@ export declare const evidence: v.UnionSchema<[v.StrictObjectSchema<{
                 readonly signals: v.ArraySchema<v.StringSchema<undefined>, undefined>;
                 readonly demoted: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
             }, undefined>, undefined>;
+            readonly bulk: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+            readonly list_id: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+            readonly rule_id: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
         }, undefined>, undefined>;
         readonly provider_metadata: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>;
     }, undefined>, "entries" | "~run" | "~standard" | "~types"> & {
@@ -1412,6 +1427,9 @@ export declare const evidence: v.UnionSchema<[v.StrictObjectSchema<{
                     readonly signals: v.ArraySchema<v.StringSchema<undefined>, undefined>;
                     readonly demoted: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
                 }, undefined>, undefined>;
+                readonly bulk: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+                readonly list_id: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+                readonly rule_id: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
             }, undefined>, undefined>;
             readonly provider_metadata: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>;
         }, "chat_title" | "ref" | "sender_name" | "text" | "timestamp">;
@@ -1667,6 +1685,9 @@ export declare const evidence: v.UnionSchema<[v.StrictObjectSchema<{
                 readonly signals: v.ArraySchema<v.StringSchema<undefined>, undefined>;
                 readonly demoted: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
             }, undefined>, undefined>;
+            readonly bulk: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+            readonly list_id: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+            readonly rule_id: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
         }, undefined>, undefined>;
         readonly provider_metadata: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>;
     }, undefined>, "entries" | "~run" | "~standard" | "~types"> & {
@@ -1884,6 +1905,9 @@ export declare const evidence: v.UnionSchema<[v.StrictObjectSchema<{
                     readonly signals: v.ArraySchema<v.StringSchema<undefined>, undefined>;
                     readonly demoted: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
                 }, undefined>, undefined>;
+                readonly bulk: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+                readonly list_id: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+                readonly rule_id: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
             }, undefined>, undefined>;
             readonly provider_metadata: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>;
         }, "chat_title" | "ref" | "sender_name" | "text" | "timestamp">;