@wirecat/cli-core 0.491.0 → 0.493.0

package/CHANGELOG.md

@@ -5,6 +5,64 @@ Notable changes to `@wirecat/cli-core` (`@wirecat/cli-messaging` up to 0.261.0,
 minor version may break callers, and says how under "Changed — may break callers". `pnpm docs:check` checks the
 shape of this file.
 
+## Unreleased
+
+## 0.493.0 — 31.10.2026
+
+### Added
+
+- **`chatCoverage(store, account, chatIds)` says what the store holds of each chat.** Per chat, in the order asked:
+  `completeness` (`complete`, `partial` or `unknown`, up to date, gaps, start reached, last fetch) and `held` (messages,
+  oldest, newest), never text. It reads only the chats named, so a store of thousands of chats costs what the ids cost.
+  `coverageGaps` also takes a list of these rows and answers `missing` (`field: "history"`) and `next`: for the first
+  incomplete chat, `messages sync <chat> --since-time <start of the window>` when the answer has a window, then
+  `messages sync <chat>`. The step `messages.sync` takes `since_time`.
+- **`messages list --offline` says when the store holds only part of the chat.** A chat that is `partial` or was never
+  fetched gives `meta.complete: false`, exit code 0, `missing` and `next`, as an offline read of 262 of 777 messages
+  must not pass for the whole chat. Online reads are unchanged.
+- **`tasks agenda` says how much of each listed chat the store holds.** Each row of `owed`, `waiting` and `unsynced` has
+  `completeness` and `held`; a chat held only in part is marked `[partial]` or `[never fetched]` in the text, with one
+  line above the lists. The answer then has `meta.complete: false`, `missing` and `next` (bounded sync over the
+  `--within` window, then the whole chat).
+- **`search all` names the chat to sync** when the store holds the chats its messages were searched in only in part:
+  `missing` (`field: "coverage"`) and `next`, from the same coverage `search messages` reports. `SearchAllFound` gains
+  `coverage`.
+
+### Changed — may break callers
+
+- **`tasks agenda --json` rows gain `completeness` and `held`**, and the answer may carry `meta.complete: false` with
+  `missing` and `next`; a caller that stops on anything but `meta.complete: true` now sees a store that holds chats in
+  part as incomplete. `tasks agenda` is declared `partial`, so the exit code stays 0. `AgendaChat` gains `coverage`
+  and `Agenda` gains `since`.
+- **`search messages`, `search mail` and `search all` answer `meta.complete: false` when a chat searched is partial or
+  never fetched**, where they kept `true` and put the gap only in `missing` and `next`. Exit code stays 0 (the commands
+  are declared `partial`). A caller that read `meta.complete` as "no source failed" must read `missing` for the reason.
+- **`messages list --offline --json` may carry `meta.complete: false`, `missing` and `next`** for a chat held in part.
+  `messages list` is declared `partial`: the exit code stays 0.
+
+## 0.492.0 — 31.10.2026
+
+### Added
+
+- **`search messages --discover` shows follow-ups: later messages that may cancel or change a hit.** Each of the
+  first five hits gets up to two later messages, from any chat the search reads and passing its filters, that
+  share a word of three letters or more whose stem at most three messages of the store hold; latest first, a
+  message already shown above is not repeated. `items[].follow_ups` in `--json` and MCP (`ref`, `chat_title`,
+  `timestamp`, `sender_name`, `text`, all untrusted), `later, shares a rare word` lines in the terminal, and the
+  SDK's `query.discovery.followUps` counts them. The counts come from the stem index through a temporary `fts5vocab`
+  table, so the store does not change; while the stems are being built there are no follow-ups. On a benchmark
+  split written by an agent that never saw the method, cancelled decisions in the first three went from 7 to 11
+  of 15 and no answer was lost
+  ([evidence pipeline](https://github.com/WireCatLabs/cli-testing/tree/main/performance/search/evidence-pipeline)).
+
+### Fixed
+
+- **`search messages --discover` no longer fails on a question with a time or a ratio.** "Do we meet until 22:00?"
+  or "a 1:1 with Anna" read the colon as a field filter and ended the whole search with `query.invalid-syntax`.
+  In a question, a colon between two digits now splits the numbers, as a space would. Explicit query syntax is
+  unchanged. A question with a bare number still runs as strict search until cli-core takes cli-base 0.66.1, where a
+  number counts as a word of the question.
+
 ## 0.491.0 — 31.10.2026
 
 ### Fixed

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

@@ -75,6 +75,13 @@ export declare const conversationShown: (account: AccountKey, { summary, message
             sender_name: string | null;
             text: string;
         }[] | undefined;
+        follow_ups?: {
+            ref: string;
+            chat_title: string | null;
+            timestamp: string;
+            sender_name: string | null;
+            text: string;
+        }[] | undefined;
         outgoing: boolean | null;
         attachments: {
             message?: string | undefined;

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

@@ -52,6 +52,13 @@ export declare const threadAnswer: ({ items, ...thread }: ThreadContext, reader:
             sender_name: string | null;
             text: string;
         }[] | undefined;
+        follow_ups?: {
+            ref: string;
+            chat_title: string | null;
+            timestamp: string;
+            sender_name: string | null;
+            text: string;
+        }[] | undefined;
         outgoing: boolean | null;
         attachments: {
             message?: string | undefined;

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

@@ -56,6 +56,13 @@ export declare const writtenAnswer: ({ operationId, sendId, message, messages, s
             sender_name: string | null;
             text: string;
         }[] | undefined;
+        follow_ups?: {
+            ref: string;
+            chat_title: string | null;
+            timestamp: string;
+            sender_name: string | null;
+            text: string;
+        }[] | undefined;
         outgoing: boolean | null;
         attachments: {
             message?: string | undefined;
@@ -268,6 +275,13 @@ export declare const writtenAnswer: ({ operationId, sendId, message, messages, s
             sender_name: string | null;
             text: string;
         }[] | undefined;
+        follow_ups?: {
+            ref: string;
+            chat_title: string | null;
+            timestamp: string;
+            sender_name: string | null;
+            text: string;
+        }[] | undefined;
         outgoing: boolean | null;
         attachments: {
             message?: string | undefined;

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

@@ -5,7 +5,9 @@ import { isLocator, parseLocator } from "../../domain/locator.js";
 import { SAVE_HELP } from "../../meetings/index.js";
 import { renderMessages } from "../../render/messages.js";
 import { renderThreadLinks } from "../../render/thread-context.js";
+import { chatCoverage } from "../../services/chat-coverage.js";
 import { readMail } from "../../services/mail-search.js";
+import { storedChatId } from "../../services/message-resolution.js";
 import { modelWith, spoken } from "../../speech/hearing.js";
 import { REMOTE_READ } from "../effects.js";
 import { itemOf, listOf, renderAnswer } from "../envelope.js";
@@ -30,6 +32,7 @@ import { pinCommand, starCommands, unpinCommand } from "./messages-pin-command.j
 import { pressCommand } from "./messages-press-command.js";
 import { scheduledCommand } from "./messages-scheduled-command.js";
 import { sendCommand } from "./messages-send-command.js";
+import { coverageGaps } from "./search-answers.js";
 import { threadOptions, threadRequest } from "./thread-options.js";
 import { transcribeSubcommand } from "./transcribe-command.js";
 /** `messages`: reading, and sending through the guard. A CLI may add its own subcommands. */
@@ -40,6 +43,7 @@ export const messagesCommand = (messenger) => {
     const list = annotate(messages.command("list"), {
         examples: [`${messenger.app.command} personal messages list "Book club" --limit 20`],
         effects: REMOTE_READ,
+        partial: true,
     })
         .description("a chat's messages, oldest to newest")
         .addHelpText("after", SAVE_HELP)
@@ -68,6 +72,12 @@ export const messagesCommand = (messenger) => {
         const next = page.hasMore
             ? cursorOf(window, { first: page.items[0]?.id, last: page.items.at(-1)?.id })
             : undefined;
+        // Offline, the store is the whole answer: say how much of the chat it holds. Online the messenger is read.
+        const gaps = context.settings.offline
+            ? coverageGaps(await context.withStore(async (store, account) => chatCoverage(store, account, [
+                await storedChatId(messenger, chat, store, account, { includeLeft: true }),
+            ])))
+            : { next: [], missing: [] };
         renderAnswer(this, context, listOf("messages list", {
             items: messageItems(heardItems(page.items, hearing), reader),
             limit,
@@ -75,7 +85,9 @@ export const messagesCommand = (messenger) => {
             paging: "cursor",
             ...(next === undefined ? {} : { cursor: next }),
             args: { chat, ...(query.length > 0 ? { query: query.join(" ") } : {}) },
-            missing: hearingMissing(hearing, transcribe === true),
+            next: gaps.next,
+            missing: [...hearingMissing(hearing, transcribe === true), ...gaps.missing],
+            ...(gaps.missing.length > 0 ? { meta: { complete: false } } : {}),
         }), () => renderMessages(spokenItems(page.items, hearing), viewOf(context, messenger)));
     });
     annotate(list, { output: { entity: "message" }, query: history });

package/dist/cli/messenger/messages-search-command.js

@@ -174,7 +174,10 @@ const searchAction = (messenger) => async function (given) {
             const place = hit.matchedIn && hit.matchedIn !== "text" && "excerpt" in hit
                 ? `\n  found in the ${PLACES[hit.matchedIn]}: ${String(hit.excerpt)}`
                 : "";
-            return `${spans ? `${at.provider} · ${title}` : title}  ${hit.locator}\n${renderMessages(hit.thread?.items ?? hit.context ?? [hit], options)}${place}${links ? `\n${links}` : ""}`;
+            const later = (hit.followUps ?? [])
+                .map((one) => `\n  later, shares a rare word · ${one.chatTitle ?? one.chatId}  ${one.locator}\n${renderMessages([one], options)}`)
+                .join("");
+            return `${spans ? `${at.provider} · ${title}` : title}  ${hit.locator}\n${renderMessages(hit.thread?.items ?? hit.context ?? [hit], options)}${place}${later}${links ? `\n${links}` : ""}`;
         })
             .join("\n\n");
         const elsewhere = [...new Set(hits.map(({ at }) => at.provider))].filter((one) => one !== messenger.provider);

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

@@ -1,6 +1,7 @@
 import type { Missing, NextStep } from "@wirecat/cli-base/standards";
 import type { InferOutput } from "valibot";
 import type { ENTITIES } from "../../entities/index.js";
+import type { ChatCoverage } from "../../services/chat-coverage.js";
 import type { FoundMessage, SearchFound } from "../../services/messages.js";
 import type { MeaningSkipped } from "../../services/messages-discovery.js";
 import type { FoundNote, NotesFoundOf } from "../../services/notes-search.js";
@@ -16,8 +17,11 @@ export type HitItem = InferOutput<(typeof ENTITIES)["hit"]>;
 /** The page a `--page` asks for, as the offset the search services take. */
 export declare const offsetOf: (page: number | undefined, limit: number) => number | undefined;
 export declare const messageHitItem: (hit: FoundMessage, query?: string) => MessageHitItem;
-/** What the archive lacked for this answer, and the step that would fill it. */
-export declare const coverageGaps: (found: Pick<SearchFound, "coverage" | "refreshed">, shown: number) => {
+/**
+ * What the archive lacked for this answer, and the step that would fill it. From a search's coverage, or from the
+ * chats an answer is about (`since` is the start of the window it was asked for).
+ */
+export declare const coverageGaps: (found: Pick<SearchFound, "coverage" | "refreshed"> | ChatCoverage[], shown?: number, since?: string) => {
     next: NextStep[];
     missing: Missing[];
 };

package/dist/cli/messenger/search-answers.js

@@ -12,7 +12,16 @@ const defined = (value) => Object.fromEntries(Object.entries(value).filter(([, o
 /** The page a `--page` asks for, as the offset the search services take. */
 export const offsetOf = (page, limit) => page === undefined || page <= 1 ? undefined : (page - 1) * limit;
 /** Who wrote it and what, the chat's title, the mail's headers: others write them; the owner's own messages too. */
-const MESSAGE_HIT_UNTRUSTED = ["chat_title", "sender_name", "excerpt", "context.sender_name", "context.text"];
+const MESSAGE_HIT_UNTRUSTED = [
+    "chat_title",
+    "sender_name",
+    "excerpt",
+    "context.sender_name",
+    "context.text",
+    "follow_ups.chat_title",
+    "follow_ups.sender_name",
+    "follow_ups.text",
+];
 const MAIL_HIT_UNTRUSTED = [
     "email.subject",
     "email.from.name",
@@ -67,20 +76,61 @@ export const messageHitItem = (hit, query = "") => {
             sender_name: one.senderName,
             text: one.text,
         })),
+        follow_ups: hit.followUps?.map((one) => ({
+            ref: one.locator,
+            chat_title: one.chatTitle ?? null,
+            timestamp: one.timestamp,
+            sender_name: one.senderName,
+            text: one.text,
+        })),
         untrusted: hit.email ? [...MESSAGE_HIT_UNTRUSTED, ...MAIL_HIT_UNTRUSTED] : MESSAGE_HIT_UNTRUSTED,
     });
 };
 const accountName = ({ provider, account }) => `${provider}:${account}`;
 /** A source left out is an issue by its code; the sentence saying why goes to a person as a note, never here. */
-const metaOf = (accounts, skipped = []) => ({
+const metaOf = (accounts, skipped = [], heldInPart = false) => ({
     accounts: accounts.map(accountName),
-    complete: skipped.length === 0,
+    complete: skipped.length === 0 && !heldInPart,
     ...(skipped.length
         ? { issues: skipped.map(({ source, resource, code }) => ({ code, source: source ?? resource ?? "" })) }
         : {}),
 });
-/** What the archive lacked for this answer, and the step that would fill it. */
-export const coverageGaps = (found, shown) => {
+const day = (at) => at?.slice(0, 10) ?? "no date";
+/**
+ * The steps for chats the store holds only in part. Bounded first, when the answer's window is known, then the whole
+ * chat; both name the first chat only, because a download is the owner's call. Counts and dates only, never text.
+ */
+const chatGaps = (rows, since) => {
+    const open = rows.filter(({ completeness }) => completeness.state !== "complete");
+    const [first] = open;
+    if (!first)
+        return { next: [], missing: [] };
+    const held = first.completeness.state === "unknown" ? "never fetched" : `held from ${day(first.held.oldestAt)} only`;
+    const steps = (args, why) => ({
+        ...nextStep("messages.sync", { args: { chat: first.chatId, ...args } }),
+        why,
+    });
+    return {
+        next: [
+            ...(since === undefined ? [] : [steps({ since_time: since }, `${held}; this reads back to ${day(since)}`)]),
+            steps({}, "reads the chat back to its first message; a big group can take minutes"),
+        ],
+        missing: [
+            {
+                field: "history",
+                why: `${open.length} of ${rows.length} chats hold only part of their history; the first is ${held}`,
+                step: "messages.sync",
+            },
+        ],
+    };
+};
+/**
+ * What the archive lacked for this answer, and the step that would fill it. From a search's coverage, or from the
+ * chats an answer is about (`since` is the start of the window it was asked for).
+ */
+export const coverageGaps = (found, shown = 0, since) => {
+    if (Array.isArray(found))
+        return chatGaps(found, since);
     const coverage = found.coverage;
     const stale = found.refreshed?.complete === false;
     if (!coverage?.next && !stale)
@@ -187,7 +237,7 @@ export const messagesAnswer = (command, found, { limit, page, again }, query = "
         page: page ?? 1,
         ...(again ? { args: again } : {}),
         ...gapsOf(found),
-        meta: metaOf(accounts, found.skipped),
+        meta: metaOf(accounts, found.skipped, coverageGaps(found).missing.length > 0),
     });
 };
 /**
@@ -256,6 +306,7 @@ export const allAnswer = (command, found, { limit, page, again }, exact = false)
     const scan = found.meetings?.complete === false ? found.meetings : undefined;
     const notes = meaningGap(found.notes?.meaningSkipped, exact);
     const messages = messageMeaningGap(found.messages?.meaningSkipped, "found_by");
+    const archive = coverageGaps({ coverage: found.coverage }, found.items.length);
     return listOf(command, {
         items: found.items.map(allHitItem),
         limit,
@@ -274,6 +325,7 @@ export const allAnswer = (command, found, { limit, page, again }, exact = false)
                 : []),
             ...notes.next,
             ...messages.next.filter((step) => !notes.next.some((asked) => JSON.stringify(asked) === JSON.stringify(step))),
+            ...archive.next,
         ],
         missing: [
             ...(scan
@@ -287,7 +339,8 @@ export const allAnswer = (command, found, { limit, page, again }, exact = false)
                 : []),
             ...notes.missing,
             ...messages.missing,
+            ...archive.missing,
         ],
-        meta: metaOf(found.accounts, found.skipped),
+        meta: metaOf(found.accounts, found.skipped, archive.missing.length > 0),
     });
 };

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

@@ -15,6 +15,7 @@ import { itemOf, listOf, renderAnswer, snakeKeys } from "../envelope.js";
 import { listQuery, pagedList, pageOf, queryTerms, typedQuery, withQuery } from "../list-query.js";
 import { positiveCount } from "../paging.js";
 import { messengerContext, refuseLocalWrite } from "./context.js";
+import { coverageGaps } from "./search-answers.js";
 import { refuseJsonl, taskStatsAnswer } from "./stats-answers.js";
 const line = ({ id, key, state, kind, group, createdAt, message, note }) => [
     key ?? id.slice(0, 8),
@@ -50,10 +51,16 @@ const applyText = (pass, yes, tool) => yes
         ...pass.tasks.map((task) => `  ${task.kind.padEnd(8)} ${(task.category ?? "—").padEnd(13)} ${task.source}`),
         ...(pass.tasks.length > 0 ? [`  ${tool} tasks scan ${pass.chat} --yes opens them`] : []),
     ].join("\n");
+const agendaChats = (agenda) => [...agenda.unsynced, ...agenda.owed, ...agenda.waiting];
+const agendaGaps = (agenda) => coverageGaps(agendaChats(agenda).map(({ coverage }) => coverage), 0, agenda.since);
+const STATE_MARK = { complete: "", partial: "  [partial]", unknown: "  [never fetched]" };
 const agendaText = (agenda) => {
     const chat = (one) => `  ${when(one.lastMessageAt)}  ${one.title ?? one.chatId}  ${one.lastMessage ?? one.chatId}` +
-        (one.openTasks.length > 0 ? `  (${one.openTasks.length} open)` : "");
+        (one.openTasks.length > 0 ? `  (${one.openTasks.length} open)` : "") +
+        STATE_MARK[one.coverage.completeness.state];
+    const [history] = agendaGaps(agenda).missing;
     return [
+        ...(history ? [`${history.why}: sync before trusting what is listed`] : []),
         ...(agenda.stale
             ? [`the store saved nothing since ${when(agenda.storedAt)}: sync before trusting quiet chats`]
             : []),
@@ -356,7 +363,11 @@ export const tasksCommand = (messenger) => {
         const unmerged = await context.withServices((services) => services.tasks.unmerge(dup, writerOf(this)));
         renderAnswer(this, context, itemOf(snakeKeys(unmerged)), () => `${card(unmerged.task)}\n`);
     });
-    withQuery(annotate(tasks.command("agenda"), { effects: LOCAL_READ, examples: [`${tool} personal tasks agenda`] })
+    withQuery(annotate(tasks.command("agenda"), {
+        effects: LOCAL_READ,
+        partial: true,
+        examples: [`${tool} personal tasks agenda`],
+    })
         .summary("what needs a look today: tasks due, chats you owe or wait on, what you are owed")
         .description("what needs a look today, from the local store and without message text: tasks overdue, due or to check, " +
         "chats where you owe an answer, chats where you wait for one, open tasks someone else does"), AGENDA_QUERY)
@@ -377,7 +388,8 @@ export const tasksCommand = (messenger) => {
             ...(query ? { query } : {}),
             holder: holderOf(this),
         }));
-        renderAnswer(this, context, itemOf(agendaItem(agenda)), () => `${agendaText(agenda)}\n`);
+        const { next, missing } = agendaGaps(agenda);
+        renderAnswer(this, context, itemOf(agendaItem(agenda), { next, missing, ...(missing.length > 0 ? { meta: { complete: false } } : {}) }), () => `${agendaText(agenda)}\n`);
     });
     annotate(tasks.command("categories"), {
         output: { entity: "task_categories" },

package/dist/cli/steps.js

@@ -14,6 +14,7 @@ export const STEPS = defineSteps([
         args: [
             { name: "chat", required: false },
             { name: "all", required: false },
+            { name: "since_time", required: false },
             { name: "background", required: false },
         ],
         why: "the local copy is missing messages; syncing brings them in",

package/dist/entities/agenda.d.ts

@@ -42,6 +42,20 @@ export declare const agenda: v.StrictObjectSchema<{
         readonly last_from_owner: v.NullableSchema<v.BooleanSchema<undefined>, undefined>;
         /** Open tasks whose source is in this chat. */
         readonly open_tasks: v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+        /** `unknown` means nothing ever fetched the chat's history; `partial` that the store holds only part of it. */
+        readonly completeness: v.StrictObjectSchema<{
+            readonly state: v.PicklistSchema<["complete", "partial", "unknown"], undefined>;
+            readonly up_to_date: v.NullableSchema<v.BooleanSchema<undefined>, undefined>;
+            readonly gaps: v.BooleanSchema<undefined>;
+            readonly reaches_start: v.BooleanSchema<undefined>;
+            readonly fetched_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+        }, undefined>;
+        /** What the store holds of the chat: the count and the span, never the text. */
+        readonly held: v.StrictObjectSchema<{
+            readonly messages: v.NumberSchema<undefined>;
+            readonly oldest_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+            readonly newest_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+        }, undefined>;
     }, undefined>, undefined>;
     /** The owner wrote last, and nobody answered. */
     readonly waiting: v.ArraySchema<v.StrictObjectSchema<{
@@ -55,6 +69,20 @@ export declare const agenda: v.StrictObjectSchema<{
         readonly last_from_owner: v.NullableSchema<v.BooleanSchema<undefined>, undefined>;
         /** Open tasks whose source is in this chat. */
         readonly open_tasks: v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+        /** `unknown` means nothing ever fetched the chat's history; `partial` that the store holds only part of it. */
+        readonly completeness: v.StrictObjectSchema<{
+            readonly state: v.PicklistSchema<["complete", "partial", "unknown"], undefined>;
+            readonly up_to_date: v.NullableSchema<v.BooleanSchema<undefined>, undefined>;
+            readonly gaps: v.BooleanSchema<undefined>;
+            readonly reaches_start: v.BooleanSchema<undefined>;
+            readonly fetched_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+        }, undefined>;
+        /** What the store holds of the chat: the count and the span, never the text. */
+        readonly held: v.StrictObjectSchema<{
+            readonly messages: v.NumberSchema<undefined>;
+            readonly oldest_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+            readonly newest_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+        }, undefined>;
     }, undefined>, undefined>;
     /** The chat list says these moved and their newest message is not stored: read them first. */
     readonly unsynced: v.ArraySchema<v.StrictObjectSchema<{
@@ -68,6 +96,20 @@ export declare const agenda: v.StrictObjectSchema<{
         readonly last_from_owner: v.NullableSchema<v.BooleanSchema<undefined>, undefined>;
         /** Open tasks whose source is in this chat. */
         readonly open_tasks: v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+        /** `unknown` means nothing ever fetched the chat's history; `partial` that the store holds only part of it. */
+        readonly completeness: v.StrictObjectSchema<{
+            readonly state: v.PicklistSchema<["complete", "partial", "unknown"], undefined>;
+            readonly up_to_date: v.NullableSchema<v.BooleanSchema<undefined>, undefined>;
+            readonly gaps: v.BooleanSchema<undefined>;
+            readonly reaches_start: v.BooleanSchema<undefined>;
+            readonly fetched_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+        }, undefined>;
+        /** What the store holds of the chat: the count and the span, never the text. */
+        readonly held: v.StrictObjectSchema<{
+            readonly messages: v.NumberSchema<undefined>;
+            readonly oldest_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+            readonly newest_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+        }, undefined>;
     }, undefined>, undefined>;
     /** Open tasks someone else does: what they owe the owner, oldest first. */
     readonly assigned: v.ArraySchema<v.StrictObjectSchema<{

package/dist/entities/agenda.js

@@ -13,6 +13,16 @@ const agendaChat = v.strictObject({
     last_from_owner: v.nullable(v.boolean()),
     /** Open tasks whose source is in this chat. */
     open_tasks: v.array(id),
+    /** `unknown` means nothing ever fetched the chat's history; `partial` that the store holds only part of it. */
+    completeness: v.strictObject({
+        state: v.picklist(["complete", "partial", "unknown"]),
+        up_to_date: v.nullable(v.boolean()),
+        gaps: v.boolean(),
+        reaches_start: v.boolean(),
+        fetched_at: v.nullable(time),
+    }),
+    /** What the store holds of the chat: the count and the span, never the text. */
+    held: v.strictObject({ messages: v.number(), oldest_at: v.nullable(time), newest_at: v.nullable(time) }),
 });
 /** What needs a look today, from the store alone and without one message's text. */
 export const agenda = v.strictObject({

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

@@ -51,6 +51,13 @@ export declare const conversationDetails: v.UnionSchema<[v.StrictObjectSchema<{
             readonly sender_name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly text: v.StringSchema<undefined>;
         }, undefined>, undefined>, undefined>;
+        readonly follow_ups: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+            readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+            readonly chat_title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly timestamp: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+            readonly sender_name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly text: v.StringSchema<undefined>;
+        }, undefined>, undefined>, undefined>;
         readonly outgoing: v.NullableSchema<v.BooleanSchema<undefined>, undefined>;
         readonly attachments: v.ArraySchema<v.StrictObjectSchema<{
             readonly message: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
@@ -261,6 +268,13 @@ export declare const conversationDetails: v.UnionSchema<[v.StrictObjectSchema<{
         readonly sender_name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly text: v.StringSchema<undefined>;
     }, undefined>, undefined>, undefined>;
+    readonly follow_ups: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+        readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+        readonly chat_title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly timestamp: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+        readonly sender_name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly text: v.StringSchema<undefined>;
+    }, undefined>, undefined>, undefined>;
     readonly outgoing: v.NullableSchema<v.BooleanSchema<undefined>, undefined>;
     readonly attachments: v.ArraySchema<v.StrictObjectSchema<{
         readonly message: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;

package/dist/entities/evidence.d.ts

@@ -42,6 +42,13 @@ export declare const contribution: v.StrictObjectSchema<{
             readonly sender_name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly text: v.StringSchema<undefined>;
         }, undefined>, undefined>, undefined>;
+        readonly follow_ups: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+            readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+            readonly chat_title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly timestamp: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+            readonly sender_name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly text: v.StringSchema<undefined>;
+        }, undefined>, undefined>, undefined>;
         readonly outgoing: v.NullableSchema<v.BooleanSchema<undefined>, undefined>;
         readonly attachments: v.ArraySchema<v.StrictObjectSchema<{
             readonly message: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
@@ -252,6 +259,13 @@ export declare const contribution: v.StrictObjectSchema<{
                 readonly sender_name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
                 readonly text: v.StringSchema<undefined>;
             }, undefined>, undefined>, undefined>;
+            readonly follow_ups: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+                readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+                readonly chat_title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                readonly timestamp: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+                readonly sender_name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                readonly text: v.StringSchema<undefined>;
+            }, undefined>, undefined>, undefined>;
             readonly outgoing: v.NullableSchema<v.BooleanSchema<undefined>, undefined>;
             readonly attachments: v.ArraySchema<v.StrictObjectSchema<{
                 readonly message: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
@@ -500,6 +514,13 @@ export declare const contribution: v.StrictObjectSchema<{
             readonly sender_name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly text: v.StringSchema<undefined>;
         }, undefined>, undefined>, undefined>;
+        readonly follow_ups: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+            readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+            readonly chat_title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly timestamp: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+            readonly sender_name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly text: v.StringSchema<undefined>;
+        }, undefined>, undefined>, undefined>;
         readonly outgoing: v.NullableSchema<v.BooleanSchema<undefined>, undefined>;
         readonly attachments: v.ArraySchema<v.StrictObjectSchema<{
             readonly message: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
@@ -710,6 +731,13 @@ export declare const contribution: v.StrictObjectSchema<{
                 readonly sender_name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
                 readonly text: v.StringSchema<undefined>;
             }, undefined>, undefined>, undefined>;
+            readonly follow_ups: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+                readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+                readonly chat_title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                readonly timestamp: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+                readonly sender_name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                readonly text: v.StringSchema<undefined>;
+            }, undefined>, undefined>, undefined>;
             readonly outgoing: v.NullableSchema<v.BooleanSchema<undefined>, undefined>;
             readonly attachments: v.ArraySchema<v.StrictObjectSchema<{
                 readonly message: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
@@ -994,6 +1022,13 @@ export declare const evidence: v.UnionSchema<[v.StrictObjectSchema<{
             readonly sender_name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly text: v.StringSchema<undefined>;
         }, undefined>, undefined>, undefined>;
+        readonly follow_ups: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+            readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+            readonly chat_title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly timestamp: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+            readonly sender_name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly text: v.StringSchema<undefined>;
+        }, undefined>, undefined>, undefined>;
         readonly outgoing: v.NullableSchema<v.BooleanSchema<undefined>, undefined>;
         readonly attachments: v.ArraySchema<v.StrictObjectSchema<{
             readonly message: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
@@ -1204,6 +1239,13 @@ export declare const evidence: v.UnionSchema<[v.StrictObjectSchema<{
                 readonly sender_name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
                 readonly text: v.StringSchema<undefined>;
             }, undefined>, undefined>, undefined>;
+            readonly follow_ups: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+                readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+                readonly chat_title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                readonly timestamp: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+                readonly sender_name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                readonly text: v.StringSchema<undefined>;
+            }, undefined>, undefined>, undefined>;
             readonly outgoing: v.NullableSchema<v.BooleanSchema<undefined>, undefined>;
             readonly attachments: v.ArraySchema<v.StrictObjectSchema<{
                 readonly message: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
@@ -1452,6 +1494,13 @@ export declare const evidence: v.UnionSchema<[v.StrictObjectSchema<{
             readonly sender_name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly text: v.StringSchema<undefined>;
         }, undefined>, undefined>, undefined>;
+        readonly follow_ups: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+            readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+            readonly chat_title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly timestamp: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+            readonly sender_name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly text: v.StringSchema<undefined>;
+        }, undefined>, undefined>, undefined>;
         readonly outgoing: v.NullableSchema<v.BooleanSchema<undefined>, undefined>;
         readonly attachments: v.ArraySchema<v.StrictObjectSchema<{
             readonly message: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
@@ -1662,6 +1711,13 @@ export declare const evidence: v.UnionSchema<[v.StrictObjectSchema<{
                 readonly sender_name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
                 readonly text: v.StringSchema<undefined>;
             }, undefined>, undefined>, undefined>;
+            readonly follow_ups: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+                readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+                readonly chat_title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                readonly timestamp: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+                readonly sender_name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                readonly text: v.StringSchema<undefined>;
+            }, undefined>, undefined>, undefined>;
             readonly outgoing: v.NullableSchema<v.BooleanSchema<undefined>, undefined>;
             readonly attachments: v.ArraySchema<v.StrictObjectSchema<{
                 readonly message: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;