@wirecat/cli-core 0.544.0 → 0.545.0

package/CHANGELOG.md

@@ -7,6 +7,18 @@ shape of this file.
 
 ## Unreleased
 
+## 0.545.0 — 02.11.2026
+
+### Added
+
+- **History limits for pushed history, per profile.** A messenger whose history is pushed (`history: "store"`,
+  WhatsApp) saves one-to-one chats back `history_dialog_days` (1095 by default), groups of more than two people back
+  `history_group_days` (365) and nothing of a group above `history_group_members_max` people (50); at most 1095 days.
+  The chat row stays, so the chat is still listed. Live messages, `messages sync` and what the store already holds are
+  never dropped. `messages sync <chat> --full-history` fetches a chat and keeps its pushed history in full from then on
+  (`history_included` in the answer). `ChatsStore` gains `historySkips`, `historyShapes`, `recordHistorySkips` and
+  `setHistoryIncluded`; `Saving` takes `historyLimits`.
+
 ## 0.544.0 — 02.11.2026
 
 ### Added

package/dist/cli/messenger/archive-commands.js

@@ -12,11 +12,12 @@ import { kindsOf } from "../../services/inbox.js";
 import { dateWindow } from "../../services/moment.js";
 import { destroysNothing, LOCAL_READ, LOCAL_WRITE } from "../effects.js";
 import { itemOf, listOf, renderAnswer, snakeKeys } from "../envelope.js";
-import { commandAt } from "../steps.js";
+import { commandAt, lineOf } from "../steps.js";
 import { jobsCommand } from "./backfill-command.js";
 import { messengerContext } from "./context.js";
 import { admitPassword, linesOf, openFolder, runFileFor, saveManifest, sealRun, writeChanges } from "./export-folder.js";
 import { gapsCommand } from "./gaps-command.js";
+import { historyLimitGaps } from "./history-gaps.js";
 import { messageItems } from "./message-items.js";
 import { ENCRYPT_OPTION, passwordOf } from "./password.js";
 import { storeMaintenanceCommands } from "./store-maintenance-command.js";
@@ -71,9 +72,26 @@ const statusCommand = (messenger) => annotate(new Command("status"), { output: {
     .action(async function (chat) {
     const context = messengerContext(this, messenger);
     const rows = await context.withServices((services) => services.archive.status(chat));
-    renderAnswer(this, context, listOf("store status", { items: rows.map(snakeKeys), limit: Math.max(1, rows.length), has_more: false }));
+    const skips = await context
+        .withStore((store, account) => store.chats.historySkips(account))
+        .then((all) => chat === undefined ? all : all.filter((skip) => rows.some((row) => row.chatId === skip.chatId)))
+        .catch(() => []);
+    const limited = historyLimitGaps(skips);
+    renderAnswer(this, context, listOf("store status", {
+        items: rows.map(snakeKeys),
+        limit: Math.max(1, rows.length),
+        has_more: false,
+        next: limited.next,
+        missing: limited.missing,
+    }));
     if (rows.length === 0 && context.format === "pretty")
         context.renderer.note("the store holds no messages for this profile yet");
+    if (skips.length > 0 && context.format === "pretty")
+        context.renderer.note(`history limits left out pushed history of ${skips.length} chats — \`${lineOf(this, "messages sync <chat> --full-history")}\` fetches one and keeps it in full:\n` +
+            skips
+                .slice(0, 20)
+                .map((skip) => `  ${skip.title ?? skip.chatId}  ${skip.messages} messages  ${skip.reason}`)
+                .join("\n"));
 });
 const LISTED = 20;
 /** Titles are the owner's: these lines go to a person's terminal, never into an error message. */

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

@@ -58,14 +58,17 @@ export const syncCommand = (messenger) => {
         .option("--catch-up-chunks <n>", "at most this many local vector chunks", wholeNumber)
         .option("--catch-up-messages <n>", "skip a graph rebuild larger than this many messages", wholeNumber)
         .option("--catch-up-time <duration>", "local preparation time budget, 30s by default")
+        .option("--full-history", "keep this chat's pushed history in full from now on, past the history limits (history_* settings)")
         .option("--background", "run as a job that outlives this command; `store jobs show` follows it")
         .option("--dry-run", "only estimate how many messages, requests and minutes a full fetch would still take — from the store, no request")
         .action(async function (chat) {
-        const { all, pause, sinceTime: since, last, background, dryRun: estimate, catchUp, catchUpChunks, catchUpMessages, catchUpTime, ...sizes } = this.opts();
+        const { all, pause, sinceTime: since, last, background, dryRun: estimate, catchUp, catchUpChunks, catchUpMessages, catchUpTime, fullHistory: include, ...sizes } = this.opts();
         if ((chat === undefined) === (all !== true))
             throw new CliError("validation_error", "name a chat, or --all for every chat");
         if (all && estimate)
             throw new CliError("validation_error", "--dry-run prices one chat; not with --all");
+        if (include && chat === undefined)
+            throw new CliError("validation_error", "--full-history keeps one chat: name it");
         if (all && messenger.history === "store") {
             throw new CliError("validation_error", `--all walks the messenger's chat list, and ${messenger.name ?? messenger.app.command} pushes its chats ` +
                 `instead — keep \`${lineOf(this, "serve")}\` running${messenger.historyOnDemand ? ", or name one chat" : ""}`);
@@ -164,6 +167,10 @@ export const syncCommand = (messenger) => {
             const result = await context.withServices((services) => chat === undefined ? services.archive.fetchAll(options) : services.archive.fetch(chat, options));
             if (jobId)
                 finishJob(messenger.app, jobs, jobId, { finishedAt: new Date().toISOString(), result });
+            const synced = "chat" in result ? result.chat : null;
+            const included = include && synced
+                ? await context.withStore((store, account) => store.chats.setHistoryIncluded(account, synced, true))
+                : undefined;
             const tasks = await taskRulesAfterSync(context);
             const prepared = "prepared" in result ? result.prepared : undefined;
             const unprepared = prepared && !prepared.complete && "chat" in result && result.chat !== null;
@@ -171,7 +178,11 @@ export const syncCommand = (messenger) => {
             const review = await context.withServices((services) => services.mentions.newCount(point.after));
             const toReview = review.count;
             const shown = `${toReview}${review.more ? "+" : ""}`;
-            renderAnswer(this, context, itemOf(snakeKeys(tasks && tasks.added + tasks.closed + (tasks.held ?? 0) > 0 ? { ...result, tasks } : result), {
+            renderAnswer(this, context, itemOf(snakeKeys({
+                ...result,
+                ...(tasks && tasks.added + tasks.closed + (tasks.held ?? 0) > 0 ? { tasks } : {}),
+                ...(included === undefined ? {} : { historyIncluded: included }),
+            }), {
                 next: [
                     ...(unprepared
                         ? [

package/dist/cli/messenger/context.js

@@ -231,6 +231,9 @@ export const connected = (connection, { app, provider, name, deletedWithoutChat,
             recipientIds: () => (new RecipientList(recipientsPathFor(app, settings.profile, env), app.command).read() ?? []).flatMap((recipient) => [recipient.id, ...(recipient.partnerId ? [recipient.partnerId] : [])]),
             ...(history === "store" ? { namesFromStore: savedChatId ? { savedChatId } : {} } : {}),
             ...(unreadCounts === "store" ? { countsUnread: true } : {}),
+            ...(history === "store" && settings.historyLimits
+                ? { historyLimits: settings.historyLimits, command: `${app.command} ${settings.profile}` }
+                : {}),
         });
     const passives = history === "store" && self !== null && !watching
         ? passivesOf(saving).map((passive) => listened(passive, events, renderer.warn, closeWaitMs))

package/dist/cli/messenger/history-gaps.d.ts

@@ -0,0 +1,12 @@
+import type { Missing, NextStep } from "@wirecat/cli-base/standards";
+import type { AccountKey, MessageStore, StoredHistorySkip } from "../../store/store.js";
+/**
+ * What the history limits (`history_*` settings) left out of pushed history, as `missing` and `next`: an answer read
+ * from the store must not pass for every message the messenger has.
+ */
+export declare const historyLimitGaps: (skips: StoredHistorySkip[]) => {
+    next: NextStep[];
+    missing: Missing[];
+};
+/** What the limits left out in every account an answer read, most messages first. */
+export declare const historySkipsOf: (store: Pick<MessageStore, "chats">, accounts: readonly AccountKey[]) => Promise<StoredHistorySkip[]>;

package/dist/cli/messenger/history-gaps.js

@@ -0,0 +1,41 @@
+import { nextStep } from "../steps.js";
+const SHOWN = 5;
+const reasonOf = (skip) => skip.reason === "group_too_large"
+    ? `a group of ${skip.members ?? "many"} people, not saved`
+    : `only from ${skip.keptFrom?.slice(0, 10) ?? "the window's start"}`;
+const nameOf = (skip) => skip.title ?? skip.chatId;
+/**
+ * What the history limits (`history_*` settings) left out of pushed history, as `missing` and `next`: an answer read
+ * from the store must not pass for every message the messenger has.
+ */
+export const historyLimitGaps = (skips) => {
+    const [first] = skips;
+    if (!first)
+        return { next: [], missing: [] };
+    const messages = skips.reduce((sum, skip) => sum + skip.messages, 0);
+    const listed = skips
+        .slice(0, SHOWN)
+        .map((skip) => `${nameOf(skip)} (${skip.messages}, ${reasonOf(skip)})`)
+        .join("; ");
+    const more = skips.length > SHOWN ? `; and ${skips.length - SHOWN} more — \`store status\` lists them` : "";
+    return {
+        next: [
+            {
+                ...nextStep("messages.sync", { args: { chat: first.chatId, full_history: true } }),
+                why: "fetches this chat's history and keeps it in full from now on, past the history limits",
+            },
+        ],
+        missing: [
+            {
+                field: "history_limits",
+                why: `the history limits (history_* settings) left ${messages} pushed messages of ${skips.length} chats out of ` +
+                    `the store: ${listed}${more}`,
+                step: "messages.sync",
+            },
+        ],
+    };
+};
+/** What the limits left out in every account an answer read, most messages first. */
+export const historySkipsOf = async (store, accounts) => (await Promise.all(accounts.map((account) => store.chats.historySkips(account))))
+    .flat()
+    .sort((a, b) => b.messages - a.messages);

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

@@ -18,6 +18,7 @@ import { messengerContext } from "./context.js";
 import { linksCommand } from "./conversations-command.js";
 import { downloadSubcommand } from "./download-command.js";
 import { heardItems, hearForCommand, hearingMissing, MODEL_OPTION, spokenItems, TRANSCRIBE_OPTION, } from "./hearing-command.js";
+import { historyLimitGaps } from "./history-gaps.js";
 import { cursorOf, historyQuery, historyWindow } from "./history-query.js";
 import { hideNever } from "./lacks.js";
 import { threadAnswer } from "./message-answers.js";
@@ -74,9 +75,12 @@ export const messagesCommand = (messenger) => {
             : 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 }),
-            ])))
+            ? await context.withStore(async (store, account) => {
+                const chatId = await storedChatId(messenger, chat, store, account, { includeLeft: true });
+                const held = coverageGaps(await chatCoverage(store, account, [chatId]));
+                const limited = historyLimitGaps((await store.chats.historySkips(account)).filter((skip) => skip.chatId === chatId));
+                return { next: [...limited.next, ...held.next], missing: [...limited.missing, ...held.missing] };
+            })
             : { next: [], missing: [] };
         renderAnswer(this, context, listOf("messages list", {
             items: messageItems(heardItems(page.items, hearing), reader),

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

@@ -12,6 +12,7 @@ import { renderAnswer } from "../envelope.js";
 import { positiveCount } from "../paging.js";
 import { archiveSummary } from "./archive-summary.js";
 import { messengerContext } from "./context.js";
+import { historySkipsOf } from "./history-gaps.js";
 import { meaningNote, messagesAnswer, offsetOf, shownOf } from "./search-answers.js";
 import { backendOptions, backendRequest, noteServer } from "./search-backend-options.js";
 import { syncOptions, syncRequest, syncsFirst } from "./search-sync-options.js";
@@ -207,7 +208,10 @@ const searchAction = (messenger) => async function (given) {
         ...(newest ? { newest: true } : {}),
         ...(timezone === undefined ? {} : { timezone }),
     };
-    renderAnswer(this, context, messagesAnswer("search messages", found, { limit, page: page ?? 1, again }, given.join(" ")), view);
+    const skips = await context
+        .withStore((store) => historySkipsOf(store, found.coverage?.accounts ?? found.accounts ?? []))
+        .catch(() => []);
+    renderAnswer(this, context, messagesAnswer("search messages", found, { limit, page: page ?? 1, again }, given.join(" "), skips), view);
 };
 const withOffset = (page, limit) => {
     const offset = offsetOf(page, limit);

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

@@ -8,6 +8,7 @@ import type { MeaningSkipped } from "../../services/messages-discovery.js";
 import type { FoundNote, NotesFoundOf } from "../../services/notes-search.js";
 import type { SearchAllItem } from "../../services/search-all.js";
 import type { MeetingSearchItem, SearchAllIncludingMeetingsFound } from "../../services/search-all-meetings.js";
+import type { StoredHistorySkip } from "../../store/store.js";
 import { type ListBody } from "../envelope.js";
 /** What a source tool's `search all` reads: never mail, which is memo's (docs/dev/TOOL-BOUNDARIES.md). */
 export declare const SOURCE_SEARCHED: readonly ["messages", "notes", "events", "meetings"];
@@ -42,10 +43,10 @@ export interface Paging {
 /** "showing 20 of 144", for the human view under a page of hits; `+` when the total is a lower bound. */
 export declare const shownOf: (shown: number, offset: number, total: SearchTotal | undefined) => string | undefined;
 /** `search messages` and `search mail`, CLI and MCP alike. */
-export declare const messagesAnswer: (command: string, found: SearchFound, { limit, page, again }: Paging, query?: string) => ListBody<MessageHitItem>;
+export declare const messagesAnswer: (command: string, found: SearchFound, { limit, page, again }: Paging, query?: string, skips?: StoredHistorySkip[]) => ListBody<MessageHitItem>;
 export declare const noteHitItem: (hit: FoundNote) => NoteHitItem;
 export declare const allHitItem: (item: SearchAllItem | MeetingSearchItem) => HitItem;
 /** `search notes`, CLI and MCP alike. */
 export declare const notesAnswer: (command: string, found: NotesFoundOf, { limit, page, again }: Paging, exact?: boolean) => ListBody<NoteHitItem>;
 /** `search all`, CLI and MCP alike. A bounded meeting scan that could not tell whether more match says so. */
-export declare const allAnswer: (command: string, found: SearchAllIncludingMeetingsFound, { limit, page, again }: Paging, exact?: boolean) => ListBody<HitItem>;
+export declare const allAnswer: (command: string, found: SearchAllIncludingMeetingsFound, { limit, page, again }: Paging, exact?: boolean, skips?: StoredHistorySkip[]) => ListBody<HitItem>;

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

@@ -7,6 +7,7 @@ import { MAX_SEARCH_OFFSET } from "../../services/messages-archive-search.js";
 import { listOf } from "../envelope.js";
 import { nextStep } from "../steps.js";
 import { archiveSummary } from "./archive-summary.js";
+import { historyLimitGaps } from "./history-gaps.js";
 /** What a source tool's `search all` reads: never mail, which is memo's (docs/dev/TOOL-BOUNDARIES.md). */
 export const SOURCE_SEARCHED = ["messages", "notes", "events", "meetings"];
 const nonEmpty = (list) => (list.length > 0 ? list : undefined);
@@ -249,8 +250,10 @@ export const shownOf = (shown, offset, total) => total === undefined || shown ==
     ? undefined
     : `showing ${offset + 1}–${offset + shown} of ${total.value}${total.relation === "gte" ? "+" : ""}`;
 /** `search messages` and `search mail`, CLI and MCP alike. */
-export const messagesAnswer = (command, found, { limit, page, again }, query = "") => {
+export const messagesAnswer = (command, found, { limit, page, again }, query = "", skips = []) => {
     const accounts = found.coverage?.accounts ?? found.accounts ?? [];
+    const gaps = gapsOf(found);
+    const limited = historyLimitGaps(skips);
     return listOf(command, {
         items: [...found.items.map((hit) => messageHitItem(hit, query)), ...pictureItems(found)],
         limit,
@@ -258,8 +261,9 @@ export const messagesAnswer = (command, found, { limit, page, again }, query = "
         page: page ?? 1,
         ...(found.total ? { total: found.total } : {}),
         ...(again ? { args: again } : {}),
-        ...gapsOf(found),
-        meta: metaOf(accounts, found.skipped, coverageGaps(found).missing.length > 0),
+        next: [...gaps.next, ...limited.next],
+        missing: [...gaps.missing, ...limited.missing],
+        meta: metaOf(accounts, found.skipped, coverageGaps(found).missing.length > 0 || skips.length > 0),
     });
 };
 /**
@@ -327,7 +331,8 @@ export const notesAnswer = (command, found, { limit, page, again }, exact = fals
     meta: metaOf(found.accounts, found.skipped),
 });
 /** `search all`, CLI and MCP alike. A bounded meeting scan that could not tell whether more match says so. */
-export const allAnswer = (command, found, { limit, page, again }, exact = false) => {
+export const allAnswer = (command, found, { limit, page, again }, exact = false, skips = []) => {
+    const limited = historyLimitGaps(skips);
     const scan = found.meetings?.complete === false ? found.meetings : undefined;
     const notes = meaningGap(found.notes?.meaningSkipped, exact);
     const messages = messageMeaningGap(found.messages?.meaningSkipped, "found_by");
@@ -351,6 +356,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,
+            ...limited.next,
         ],
         missing: [
             ...(scan
@@ -365,7 +371,8 @@ export const allAnswer = (command, found, { limit, page, again }, exact = false)
             ...notes.missing,
             ...messages.missing,
             ...archive.missing,
+            ...limited.missing,
         ],
-        meta: metaOf(found.accounts, found.skipped, archive.missing.length > 0),
+        meta: metaOf(found.accounts, found.skipped, archive.missing.length > 0 || skips.length > 0),
     });
 };

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

@@ -10,6 +10,7 @@ import { runsSearchCommand } from "../runs/search-command.js";
 import { commandAt } from "../steps.js";
 import { messengerContext } from "./context.js";
 import { conversationsSearchCommand } from "./conversations-command.js";
+import { historySkipsOf } from "./history-gaps.js";
 import { messagesSearchCommand } from "./messages-search-command.js";
 import { allAnswer, meaningNote, notesAnswer, offsetOf, SOURCE_SEARCHED, shownOf, } from "./search-answers.js";
 import { backendOptions, backendRequest, noteServer } from "./search-backend-options.js";
@@ -92,7 +93,8 @@ const allCommand = (messenger) => {
             ...(exact ? { exact: true } : {}),
             ...(timezone === undefined ? {} : { timezone }),
         };
-        renderAnswer(this, context, allAnswer("search all", found, { limit, page: page ?? 1, again }), () => {
+        const skips = await context.withStore((store) => historySkipsOf(store, found.accounts)).catch(() => []);
+        renderAnswer(this, context, allAnswer("search all", found, { limit, page: page ?? 1, again }, false, skips), () => {
             if (found.items.length === 0)
                 context.renderer.note(found.server && !found.server.skipped
                     ? "nothing found in the local store or on the messenger's server"

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

@@ -2,6 +2,7 @@ import type { Id } from "../../domain/models.js";
 import { type MessengerAdapter } from "../../ports/messenger.js";
 import type { MessengerTraits } from "../../ports/traits.js";
 import type { EventSink, Warn } from "../../runs/events.js";
+import { type HistoryLimits } from "../../services/history-limits.js";
 import type { AccountKey, DeletionScope, MessageStore } from "../../store/store.js";
 export interface Saving {
     account: AccountKey;
@@ -41,6 +42,10 @@ export interface Saving {
     namesFromStore?: Pick<MessengerTraits, "savedChatId">;
     /** `MessengerTraits.unreadCounts: "store"`: a message `watch` or `listen` saves raises its chat's unread count. */
     countsUnread?: boolean;
+    /** Pushed history (`feed`, `listenHistory`) outside these is not saved, and each chat records what it left out. */
+    historyLimits?: HistoryLimits;
+    /** The app command and profile, for the warning that names the command listing what the limits left out. */
+    command?: string;
 }
 /**
  * The adapter, with what each read answers written to the store. **A failed write never fails the
@@ -50,4 +55,4 @@ export interface Saving {
  * would erase what `chats list` stored. Nor are `chat` and `contact`: a card's member list is not
  * known to be whole, and `saveMembers` replaces the list.
  */
-export declare const stored: (messenger: MessengerAdapter, { account, store, warn, events, pending, announcing, deletedWithoutChat, profile, rekeyed, rekeyPacing, closing, namesFromStore, recipientIds, countsUnread, }: Saving) => MessengerAdapter;
+export declare const stored: (messenger: MessengerAdapter, { account, store, warn, events, pending, announcing, deletedWithoutChat, profile, rekeyed, rekeyPacing, closing, namesFromStore, recipientIds, countsUnread, historyLimits, command, }: Saving) => MessengerAdapter;

package/dist/cli/messenger/stored.js

@@ -2,6 +2,7 @@ import { CliError } from "@wirecat/cli-base";
 import { capability, throughWrapper, } from "../../ports/messenger.js";
 import { foldName, isId, pickPerson } from "../../resolve.js";
 import { codeOf } from "../../sends/guarded.js";
+import { limitBatch } from "../../services/history-limits.js";
 import { chatIdIn } from "../../services/message-resolution.js";
 const REKEY_PACING = { lockMs: 50, pauseMs: 25 };
 /**
@@ -12,8 +13,37 @@ const REKEY_PACING = { lockMs: 50, pauseMs: 25 };
  * would erase what `chats list` stored. Nor are `chat` and `contact`: a card's member list is not
  * known to be whole, and `saveMembers` replaces the list.
  */
-export const stored = (messenger, { account, store, warn, events, pending, announcing, deletedWithoutChat, profile, rekeyed, rekeyPacing = REKEY_PACING, closing, namesFromStore, recipientIds, countsUnread = false, }) => {
+export const stored = (messenger, { account, store, warn, events, pending, announcing, deletedWithoutChat, profile, rekeyed, rekeyPacing = REKEY_PACING, closing, namesFromStore, recipientIds, countsUnread = false, historyLimits, command = "cli", }) => {
     let warned = false;
+    let limitedNoted = false;
+    const limited = async (opened, batch) => {
+        if (!historyLimits || !batch.messages?.length)
+            return { batch, skipped: new Map() };
+        const shapes = await opened.chats.historyShapes(account, [...new Set(batch.messages.map((one) => one.chatId))]);
+        return limitBatch(batch, (chatId) => shapes.get(chatId), (chatId) => shapes.get(chatId)?.included === true, historyLimits);
+    };
+    const noteLimited = (skipped) => {
+        if (skipped.size === 0)
+            return;
+        const counts = {
+            chats: skipped.size,
+            messages: 0,
+            group_too_large: 0,
+            older_than_window: 0,
+        };
+        for (const skip of skipped.values()) {
+            counts.messages = (counts.messages ?? 0) + skip.messages;
+            counts[skip.reason] = (counts[skip.reason] ?? 0) + 1;
+        }
+        const warning = { event: "warning", code: "history_limited", operation: "history.save", counts };
+        events(warning);
+        if (limitedNoted)
+            return;
+        limitedNoted = true;
+        warn(`history limits left out ${counts.messages} pushed messages of ${skipped.size} chats (big groups, older ` +
+            `than the window) — \`${command} store status\` lists them; \`${command} messages sync <chat> --full-history\` ` +
+            "fetches one and keeps it in full", warning);
+    };
     let recorded = profile === undefined;
     const notWritten = (operation, error) => {
         const warning = { event: "warning", code: "store_not_written", operation };
@@ -155,7 +185,13 @@ export const stored = (messenger, { account, store, warn, events, pending, annou
             // A refused re-key leaves its chat split, never the others or the batch's history unsaved.
             const saving = previous.then(async () => {
                 await saveRekeys(rekeys, round);
-                return attempt(operation, (opened) => fill(opened, account, batch));
+                return attempt(operation, async (opened) => {
+                    const { batch: kept, skipped } = await limited(opened, batch);
+                    await fill(opened, account, kept);
+                    if (skipped.size > 0)
+                        await opened.chats.recordHistorySkips(account, skipped);
+                    noteLimited(skipped);
+                });
             });
             previous = saving;
             pending?.add(saving);

package/dist/cli/settings.d.ts

@@ -4,6 +4,7 @@ import { type AISettings } from "../analysis/settings.js";
 import { type AppIdentity } from "../ports/app.js";
 import type { RecordInput } from "../runs/run-context.js";
 import { type Level, type PermissionKey } from "../sends/permissions.js";
+import { type HistoryLimits } from "../services/history-limits.js";
 import { type ConfigIssue } from "./config-issues.js";
 import type { CommandPermissions } from "./permission-keys.js";
 export declare const plain: (rule: string) => (issue: v.BaseIssue<unknown>) => string;
@@ -94,6 +95,8 @@ export interface Settings extends AISettings {
     color: boolean | undefined;
     senderColors: boolean;
     searchCatchUp?: boolean;
+    /** How much pushed history the store keeps, by chat kind; a messenger that answers history on request ignores it. */
+    historyLimits?: HistoryLimits;
     /** Search and `images embed` read the pictures themselves, with a model on this machine. Off until set. */
     pictureSearch?: boolean;
     /** The reranker that orders `search messages --discover`'s first hits once it is downloaded, or `off`. */
@@ -300,6 +303,9 @@ export declare const settingsFor: <T extends object = Record<never, never>>(app:
             transcribe_with: v.OptionalSchema<v.PicklistSchema<["auto", "messenger", "local"], (issue: v.BaseIssue<unknown>) => string>, undefined>;
             speech_model: v.OptionalSchema<v.StringSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
             search_catch_up: v.OptionalSchema<v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
+            history_dialog_days: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<(issue: v.BaseIssue<unknown>) => string>, v.IntegerAction<number, (issue: v.BaseIssue<unknown>) => string>, v.MinValueAction<number, 1, (issue: v.BaseIssue<unknown>) => string>, v.MaxValueAction<number, 1095, (issue: v.BaseIssue<unknown>) => string>]>, undefined>;
+            history_group_days: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<(issue: v.BaseIssue<unknown>) => string>, v.IntegerAction<number, (issue: v.BaseIssue<unknown>) => string>, v.MinValueAction<number, 1, (issue: v.BaseIssue<unknown>) => string>, v.MaxValueAction<number, 1095, (issue: v.BaseIssue<unknown>) => string>]>, undefined>;
+            history_group_members_max: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<(issue: v.BaseIssue<unknown>) => string>, v.IntegerAction<number, (issue: v.BaseIssue<unknown>) => string>, v.MinValueAction<number, 1, (issue: v.BaseIssue<unknown>) => string>]>, undefined>;
             picture_search: v.OptionalSchema<v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
             search_reranker: v.OptionalSchema<v.PicklistSchema<[...string[], "off"], (issue: v.BaseIssue<unknown>) => string>, undefined>;
             update_check: v.OptionalSchema<v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
@@ -376,6 +382,9 @@ export declare const settingsFor: <T extends object = Record<never, never>>(app:
             transcribe_with: v.OptionalSchema<v.PicklistSchema<["auto", "messenger", "local"], (issue: v.BaseIssue<unknown>) => string>, undefined>;
             speech_model: v.OptionalSchema<v.StringSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
             search_catch_up: v.OptionalSchema<v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
+            history_dialog_days: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<(issue: v.BaseIssue<unknown>) => string>, v.IntegerAction<number, (issue: v.BaseIssue<unknown>) => string>, v.MinValueAction<number, 1, (issue: v.BaseIssue<unknown>) => string>, v.MaxValueAction<number, 1095, (issue: v.BaseIssue<unknown>) => string>]>, undefined>;
+            history_group_days: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<(issue: v.BaseIssue<unknown>) => string>, v.IntegerAction<number, (issue: v.BaseIssue<unknown>) => string>, v.MinValueAction<number, 1, (issue: v.BaseIssue<unknown>) => string>, v.MaxValueAction<number, 1095, (issue: v.BaseIssue<unknown>) => string>]>, undefined>;
+            history_group_members_max: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<(issue: v.BaseIssue<unknown>) => string>, v.IntegerAction<number, (issue: v.BaseIssue<unknown>) => string>, v.MinValueAction<number, 1, (issue: v.BaseIssue<unknown>) => string>]>, undefined>;
             picture_search: v.OptionalSchema<v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
             search_reranker: v.OptionalSchema<v.PicklistSchema<[...string[], "off"], (issue: v.BaseIssue<unknown>) => string>, undefined>;
         }, (issue: v.StrictObjectIssue) => string>, "has to be an object of profiles, by name">, {}>;

package/dist/cli/settings.js

@@ -7,6 +7,7 @@ import { DEFAULT_RERANK_MODEL, RERANK_MODELS } from "../embeddings/models.js";
 import { envName, readOnlyLockOf } from "../ports/app.js";
 import { KEEP_SUCCESSFUL_RUNS_FOR_DAYS, RUNS_SIZE_LIMIT_MB } from "../runs/run.js";
 import { assertOverridesTighten, CEILING_KEY, COMMAND_PATH_KEY, LEVELS, layerPermissions, permissionOverrides, RESOURCE_KEY, RESOURCES, } from "../sends/permissions.js";
+import { DEFAULT_HISTORY_LIMITS, HISTORY_MAX_DAYS } from "../services/history-limits.js";
 import { storePath } from "../store/path.js";
 import { sharedConfigPath } from "../store/shared-config.js";
 import { checkConfigText, issueMessage, readConfigFile, readConfigText, savedPermissionKeys, schemaIssues, settingPathOf, withoutPath, } from "./config-issues.js";
@@ -34,6 +35,8 @@ export const count = v.pipe(v.number(wholeNumber), v.integer(wholeNumber), v.min
 const zeroOrMore = plain("has to be a whole number, 0 or more");
 const countOrZero = v.pipe(v.number(zeroOrMore), v.integer(zeroOrMore), v.minValue(0, zeroOrMore));
 export const flag = v.boolean(plain("has to be true or false"));
+const historyDaysMessage = plain(`has to be a whole number of days, 1 to ${HISTORY_MAX_DAYS}`);
+const historyDays = v.pipe(v.number(historyDaysMessage), v.integer(historyDaysMessage), v.minValue(1, historyDaysMessage), v.maxValue(HISTORY_MAX_DAYS, historyDaysMessage));
 /** `record_input`: true, false, or "failed" — the words typed kept only in a run that failed. */
 export const recordInputSetting = v.union([v.boolean(), v.literal("failed")], plain('has to be true, false or "failed"'));
 const wholeOrZero = (text, name) => {
@@ -71,6 +74,9 @@ const SHARED_PROFILE_ENTRIES = {
     transcribe_with: v.optional(v.picklist(["auto", "messenger", "local"], plain("has to be auto, messenger or local"))),
     speech_model: v.optional(v.string(plain("has to be a model id from `models list`, in quotes"))),
     search_catch_up: v.optional(flag),
+    history_dialog_days: v.optional(historyDays),
+    history_group_days: v.optional(historyDays),
+    history_group_members_max: v.optional(count),
     picture_search: v.optional(flag),
     search_reranker: v.optional(v.picklist([...RERANK_MODELS.map((model) => model.id), "off"], plain(`has to be off or a reranker id: ${RERANK_MODELS.map((model) => model.id).join(", ")}`))),
     ...AI_ENTRIES,
@@ -91,6 +97,9 @@ export const MESSENGER_ONLY_SETTINGS = [
     "sends_per_hour",
     "transcribe_with",
     "search_catch_up",
+    "history_dialog_days",
+    "history_group_days",
+    "history_group_members_max",
     "read_other_bots",
 ];
 /** One program, one version: whether to look for a newer one is not a per-profile matter. */
@@ -255,6 +264,9 @@ export const settingsFor = (app, extension = {}) => {
         const color = fromLayers("color", undefined);
         const senderColors = fromLayers("sender_colors", false);
         const searchCatchUp = fromLayers("search_catch_up", false);
+        const historyDialogDays = fromLayers("history_dialog_days", DEFAULT_HISTORY_LIMITS.dialogDays);
+        const historyGroupDays = fromLayers("history_group_days", DEFAULT_HISTORY_LIMITS.groupDays);
+        const historyGroupMembersMax = fromLayers("history_group_members_max", DEFAULT_HISTORY_LIMITS.groupMembersMax);
         const pictureSearch = fromLayers("picture_search", false);
         const searchReranker = fromLayers("search_reranker", DEFAULT_RERANK_MODEL);
         const recordInput = fromLayers("record_input", true);
@@ -306,6 +318,11 @@ export const settingsFor = (app, extension = {}) => {
             color: color.value,
             senderColors: senderColors.value,
             searchCatchUp: searchCatchUp.value,
+            historyLimits: {
+                dialogDays: historyDialogDays.value,
+                groupDays: historyGroupDays.value,
+                groupMembersMax: historyGroupMembersMax.value,
+            },
             pictureSearch: pictureSearch.value,
             searchReranker: searchReranker.value,
             limit: limit.value,
@@ -343,6 +360,9 @@ export const settingsFor = (app, extension = {}) => {
                 color: color.from,
                 senderColors: senderColors.from,
                 searchCatchUp: searchCatchUp.from,
+                historyDialogDays: historyDialogDays.from,
+                historyGroupDays: historyGroupDays.from,
+                historyGroupMembersMax: historyGroupMembersMax.from,
                 pictureSearch: pictureSearch.from,
                 searchReranker: searchReranker.from,
                 record: record.from,

package/dist/cli/shared-command-exports.d.ts

@@ -82,6 +82,9 @@ export declare const appDoctorCommand: (app: import("./entry.js").AppIdentity, c
             transcribe_with: import("valibot").OptionalSchema<import("valibot").PicklistSchema<["auto", "messenger", "local"], (issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             speech_model: import("valibot").OptionalSchema<import("valibot").StringSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             search_catch_up: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
+            history_dialog_days: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MaxValueAction<number, 1095, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
+            history_group_days: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MaxValueAction<number, 1095, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
+            history_group_members_max: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
             picture_search: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             search_reranker: import("valibot").OptionalSchema<import("valibot").PicklistSchema<[...string[], "off"], (issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             update_check: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
@@ -158,6 +161,9 @@ export declare const appDoctorCommand: (app: import("./entry.js").AppIdentity, c
             transcribe_with: import("valibot").OptionalSchema<import("valibot").PicklistSchema<["auto", "messenger", "local"], (issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             speech_model: import("valibot").OptionalSchema<import("valibot").StringSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             search_catch_up: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
+            history_dialog_days: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MaxValueAction<number, 1095, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
+            history_group_days: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MaxValueAction<number, 1095, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
+            history_group_members_max: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
             picture_search: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             search_reranker: import("valibot").OptionalSchema<import("valibot").PicklistSchema<[...string[], "off"], (issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
         }, (issue: import("valibot").StrictObjectIssue) => string>, "has to be an object of profiles, by name">, {}>;
@@ -256,6 +262,9 @@ export declare const appMcpCommand: (app: import("./entry.js").AppIdentity, conf
             transcribe_with: import("valibot").OptionalSchema<import("valibot").PicklistSchema<["auto", "messenger", "local"], (issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             speech_model: import("valibot").OptionalSchema<import("valibot").StringSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             search_catch_up: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
+            history_dialog_days: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MaxValueAction<number, 1095, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
+            history_group_days: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MaxValueAction<number, 1095, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
+            history_group_members_max: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
             picture_search: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             search_reranker: import("valibot").OptionalSchema<import("valibot").PicklistSchema<[...string[], "off"], (issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             update_check: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
@@ -332,6 +341,9 @@ export declare const appMcpCommand: (app: import("./entry.js").AppIdentity, conf
             transcribe_with: import("valibot").OptionalSchema<import("valibot").PicklistSchema<["auto", "messenger", "local"], (issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             speech_model: import("valibot").OptionalSchema<import("valibot").StringSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             search_catch_up: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
+            history_dialog_days: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MaxValueAction<number, 1095, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
+            history_group_days: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MaxValueAction<number, 1095, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
+            history_group_members_max: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
             picture_search: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             search_reranker: import("valibot").OptionalSchema<import("valibot").PicklistSchema<[...string[], "off"], (issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
         }, (issue: import("valibot").StrictObjectIssue) => string>, "has to be an object of profiles, by name">, {}>;
@@ -437,6 +449,9 @@ export declare const configCommand: (app: import("./entry.js").AppIdentity, conf
             transcribe_with: import("valibot").OptionalSchema<import("valibot").PicklistSchema<["auto", "messenger", "local"], (issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             speech_model: import("valibot").OptionalSchema<import("valibot").StringSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             search_catch_up: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
+            history_dialog_days: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MaxValueAction<number, 1095, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
+            history_group_days: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MaxValueAction<number, 1095, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
+            history_group_members_max: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
             picture_search: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             search_reranker: import("valibot").OptionalSchema<import("valibot").PicklistSchema<[...string[], "off"], (issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             update_check: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
@@ -513,6 +528,9 @@ export declare const configCommand: (app: import("./entry.js").AppIdentity, conf
             transcribe_with: import("valibot").OptionalSchema<import("valibot").PicklistSchema<["auto", "messenger", "local"], (issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             speech_model: import("valibot").OptionalSchema<import("valibot").StringSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             search_catch_up: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
+            history_dialog_days: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MaxValueAction<number, 1095, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
+            history_group_days: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MaxValueAction<number, 1095, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
+            history_group_members_max: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
             picture_search: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             search_reranker: import("valibot").OptionalSchema<import("valibot").PicklistSchema<[...string[], "off"], (issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
         }, (issue: import("valibot").StrictObjectIssue) => string>, "has to be an object of profiles, by name">, {}>;
@@ -646,6 +664,9 @@ export declare const completeCommand: (messenger: import("./index.js").Messenger
             transcribe_with: import("valibot").OptionalSchema<import("valibot").PicklistSchema<["auto", "messenger", "local"], (issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             speech_model: import("valibot").OptionalSchema<import("valibot").StringSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             search_catch_up: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
+            history_dialog_days: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MaxValueAction<number, 1095, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
+            history_group_days: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MaxValueAction<number, 1095, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
+            history_group_members_max: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
             picture_search: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             search_reranker: import("valibot").OptionalSchema<import("valibot").PicklistSchema<[...string[], "off"], (issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             update_check: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
@@ -722,6 +743,9 @@ export declare const completeCommand: (messenger: import("./index.js").Messenger
             transcribe_with: import("valibot").OptionalSchema<import("valibot").PicklistSchema<["auto", "messenger", "local"], (issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             speech_model: import("valibot").OptionalSchema<import("valibot").StringSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             search_catch_up: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
+            history_dialog_days: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MaxValueAction<number, 1095, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
+            history_group_days: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MaxValueAction<number, 1095, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
+            history_group_members_max: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
             picture_search: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             search_reranker: import("valibot").OptionalSchema<import("valibot").PicklistSchema<[...string[], "off"], (issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
         }, (issue: import("valibot").StrictObjectIssue) => string>, "has to be an object of profiles, by name">, {}>;

package/dist/cli/steps.js

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

package/dist/entities/index.d.ts

@@ -1106,6 +1106,7 @@ export declare const ENTITIES: {
             readonly held: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
             readonly held_chats: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
         }, undefined>, undefined>;
+        readonly history_included: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
     }, undefined>, v.StrictObjectSchema<{
         readonly batch: v.OptionalSchema<v.StrictObjectSchema<{
             readonly attempted: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;

package/dist/entities/message-transfer.d.ts

@@ -209,6 +209,8 @@ export declare const messageSyncChat: v.StrictObjectSchema<{
         readonly held: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
         readonly held_chats: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
     }, undefined>, undefined>;
+    /** `--full-history`: the chat's pushed history is now kept in full; `false` when the store does not know the chat. */
+    readonly history_included: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
 }, undefined>;
 export declare const messageSyncAll: v.StrictObjectSchema<{
     readonly batch: v.OptionalSchema<v.StrictObjectSchema<{
@@ -333,6 +335,8 @@ export declare const messageSync: v.UnionSchema<[v.StrictObjectSchema<{
         readonly held: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
         readonly held_chats: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
     }, undefined>, undefined>;
+    /** `--full-history`: the chat's pushed history is now kept in full; `false` when the store does not know the chat. */
+    readonly history_included: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
 }, undefined>, v.StrictObjectSchema<{
     readonly batch: v.OptionalSchema<v.StrictObjectSchema<{
         readonly attempted: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;

package/dist/entities/message-transfer.js

@@ -60,6 +60,8 @@ export const messageSyncChat = v.strictObject({
     reached_last: v.optional(v.literal(true)),
     stopped: v.optional(v.literal(true)),
     tasks,
+    /** `--full-history`: the chat's pushed history is now kept in full; `false` when the store does not know the chat. */
+    history_included: v.optional(v.boolean()),
 });
 export const messageSyncAll = v.strictObject({
     batch: v.optional(batchResult),

package/dist/services/history-limits.d.ts

@@ -0,0 +1,45 @@
+import type { Id } from "../domain/models.js";
+import type { HistoryBatch } from "../ports/messenger.js";
+/** How much pushed history the store keeps of each kind of chat. */
+export interface HistoryLimits {
+    /** One-to-one chats: days back from now. */
+    dialogDays: number;
+    /** Groups of more than two people: days back from now. */
+    groupDays: number;
+    /** Above this many people a group's pushed history is not kept at all. */
+    groupMembersMax: number;
+}
+export declare const HISTORY_MAX_DAYS = 1095;
+export declare const DEFAULT_HISTORY_LIMITS: HistoryLimits;
+export type HistorySkipReason = "group_too_large" | "older_than_window";
+/** What the limits left out of one chat, summed over every push. */
+export interface HistorySkip {
+    reason: HistorySkipReason;
+    messages: number;
+    oldestAt: string;
+    newestAt: string;
+    /** For `group_too_large`: how many people the group had. */
+    members?: number;
+    /** For `older_than_window`: the window's start when the push was saved. */
+    keptFrom?: string;
+}
+/** The kind and size of a chat, as the batch names it or the store holds it. */
+export interface ChatShape {
+    kind: string;
+    participantsCount: number | null;
+}
+/** Whether this chat's pushed history is kept, and from when. A chat the owner lifted keeps everything. */
+export declare const historyWindow: (shape: ChatShape | undefined, limits: HistoryLimits, now: number) => {
+    keepFrom: number;
+} | {
+    skip: "group_too_large";
+    members: number;
+};
+/**
+ * The batch without the messages its chats' limits leave out, and what was left out per chat. Chat rows, people and
+ * re-keys always stay: a skipped chat is still listed, so its history can be fetched by hand.
+ */
+export declare const limitBatch: (batch: HistoryBatch, shapes: (chatId: Id) => ChatShape | undefined, included: (chatId: Id) => boolean, limits: HistoryLimits, now?: number) => {
+    batch: HistoryBatch;
+    skipped: Map<Id, HistorySkip>;
+};

package/dist/services/history-limits.js

@@ -0,0 +1,50 @@
+export const HISTORY_MAX_DAYS = 1095;
+export const DEFAULT_HISTORY_LIMITS = { dialogDays: 1095, groupDays: 365, groupMembersMax: 50 };
+const DAY_MS = 24 * 60 * 60 * 1000;
+/** Whether this chat's pushed history is kept, and from when. A chat the owner lifted keeps everything. */
+export const historyWindow = (shape, limits, now) => {
+    const group = shape !== undefined && shape.kind !== "dialog" && shape.kind !== "saved";
+    if (group && (shape.participantsCount ?? 0) > limits.groupMembersMax)
+        return { skip: "group_too_large", members: shape.participantsCount ?? 0 };
+    const days = group ? limits.groupDays : limits.dialogDays;
+    return { keepFrom: now - Math.min(days, HISTORY_MAX_DAYS) * DAY_MS };
+};
+/**
+ * The batch without the messages its chats' limits leave out, and what was left out per chat. Chat rows, people and
+ * re-keys always stay: a skipped chat is still listed, so its history can be fetched by hand.
+ */
+export const limitBatch = (batch, shapes, included, limits, now = Date.now()) => {
+    const skipped = new Map();
+    if (!batch.messages?.length)
+        return { batch, skipped };
+    const named = new Map((batch.chats ?? []).map((chat) => [chat.id, chat]));
+    const windows = new Map();
+    const windowOf = (chatId) => {
+        if (!windows.has(chatId)) {
+            const chat = named.get(chatId);
+            const shape = chat ? { kind: chat.kind, participantsCount: chat.participantsCount ?? null } : shapes(chatId);
+            windows.set(chatId, included(chatId) ? undefined : historyWindow(shape, limits, now));
+        }
+        return windows.get(chatId);
+    };
+    const messages = batch.messages.filter((message) => {
+        const window = windowOf(message.chatId);
+        if (window === undefined)
+            return true;
+        const at = Date.parse(message.timestamp);
+        if ("keepFrom" in window && !(at < window.keepFrom))
+            return true;
+        const reason = "skip" in window ? window.skip : "older_than_window";
+        const held = skipped.get(message.chatId);
+        const iso = new Date(at).toISOString();
+        skipped.set(message.chatId, {
+            reason,
+            messages: (held?.messages ?? 0) + 1,
+            oldestAt: held && held.oldestAt < iso ? held.oldestAt : iso,
+            newestAt: held && held.newestAt > iso ? held.newestAt : iso,
+            ...("skip" in window ? { members: window.members } : { keptFrom: new Date(window.keepFrom).toISOString() }),
+        });
+        return false;
+    });
+    return { batch: { ...batch, messages }, skipped };
+};

package/dist/store/chats.d.ts

@@ -1,8 +1,10 @@
 import type { ChannelTagMatch } from "../domain/channel-tags.js";
 import type { Chat, ChatKind, ChatUpdate, Id, Page } from "../domain/models.js";
+import type { HistorySkip } from "../services/history-limits.js";
 import { type ChatRekey, type ChatRekeys } from "./sqlite/chat-rekey.js";
 import type { ChatMetadata, LeftChat } from "./sqlite/chats.js";
 import type { ChatCompleteness } from "./sqlite/completeness.js";
+import type { ChatHistoryShape, StoredHistorySkip } from "./sqlite/history-skips.js";
 import type { StoreContext } from "./sqlite/open.js";
 import type { Where } from "./sqlite/query-filter.js";
 import type { AccountKey, ChatActivity, ChatStats, StoredChatFilter } from "./types.js";
@@ -64,6 +66,14 @@ export interface ChatsStore {
      * `chatId` itself. Only for finding the chat: the old id and its history are never shown or searched.
      */
     renamedChatId(key: AccountKey, chatId: Id): Promise<Id | undefined>;
+    /** Per stored chat: its kind, how many people, and whether the owner lifted its history limits. */
+    historyShapes(key: AccountKey, chatIds: Id[]): Promise<Map<Id, ChatHistoryShape>>;
+    /** Adds what the history limits left out of pushed history, per chat. */
+    recordHistorySkips(key: AccountKey, skips: Map<Id, HistorySkip>): Promise<void>;
+    /** Lifts the history limits for one chat, or puts them back; `false` when the store does not know the chat. */
+    setHistoryIncluded(key: AccountKey, chatId: Id, included: boolean): Promise<boolean>;
+    /** Every chat whose pushed history the limits left out, most messages first. */
+    historySkips(key: AccountKey): Promise<StoredHistorySkip[]>;
     /** A stored chat's kind, with or without messages; `undefined` when the store does not know the chat. */
     chatKind(key: AccountKey, chatId: Id): Promise<ChatKind | undefined>;
     /** A stored chat's title, with or without messages; `null` when it has none or the store does not know the chat. */

package/dist/store/chats.js

@@ -3,6 +3,7 @@ import { keysOver } from "./keys.js";
 import { rekeyChat, rekeyChats } from "./sqlite/chat-rekey.js";
 import * as chatQueries from "./sqlite/chats.js";
 import * as completeness from "./sqlite/completeness.js";
+import * as history from "./sqlite/history-skips.js";
 import * as reads from "./sqlite/reads.js";
 import { write } from "./sqlite/transaction.js";
 export const chatsStoreOver = (context) => {
@@ -85,6 +86,30 @@ export const chatsStoreOver = (context) => {
             const accountKey = findAccountPk(key);
             return accountKey === undefined ? undefined : chatQueries.renamedChatId(context, accountKey, chatId);
         },
+        historyShapes: async (key, chatIds) => {
+            const accountKey = findAccountPk(key);
+            return accountKey === undefined ? new Map() : history.historyShapes(context, accountKey, chatIds);
+        },
+        recordHistorySkips: async (key, skips) => {
+            const accountKey = findAccountPk(key);
+            if (accountKey === undefined || skips.size === 0)
+                return;
+            write(database, () => history.recordHistorySkips(context, accountKey, skips));
+        },
+        setHistoryIncluded: async (key, chatId, included) => {
+            const accountKey = findAccountPk(key);
+            if (accountKey === undefined)
+                return false;
+            let done = false;
+            write(database, () => {
+                done = history.setHistoryIncluded(context, accountKey, chatId, included);
+            });
+            return done;
+        },
+        historySkips: async (key) => {
+            const accountKey = findAccountPk(key);
+            return accountKey === undefined ? [] : history.historySkips(context, accountKey);
+        },
         chatKind: async (key, chatId) => {
             const accountKey = findAccountPk(key);
             if (accountKey === undefined)

package/dist/store/sqlite/chats.js

@@ -1,6 +1,7 @@
 import { CliError } from "@wirecat/cli-base";
 import { and, eq, inArray, or, sql } from "./drizzle/core.js";
 import { folded } from "./folded.js";
+import { withoutHistory } from "./history-skips.js";
 import { identityPk } from "./identities.js";
 import { bound } from "./query-filter.js";
 import { chatEventPeople, chatEvents, chatMembers, chats, chunks, fetchLeases, identities, involvements, memberCounts, memberObservationMembers, memberObservations, memberStays, messageReactions, messageRevisions, messages, messageTranscripts, pollVotes, syncRanges, } from "./schema.js";
@@ -395,7 +396,7 @@ const toChat = (row, at, parentId) => ({
         scope: row.scope,
         parentChatId: parentId ?? null,
         membershipState: row.membershipState,
-        providerMetadata: parsed(row.metadata),
+        providerMetadata: withoutHistory(parsed(row.metadata)),
     }),
     ...muteOf(row, at),
     ...present({ archived: flag(row.archived), markedUnread: flag(row.markedUnread) }),

package/dist/store/sqlite/history-skips.d.ts

@@ -0,0 +1,24 @@
+import type { Id } from "../../domain/models.js";
+import type { ChatShape, HistorySkip } from "../../services/history-limits.js";
+import type { StoreContext } from "./open.js";
+/**
+ * The history limits' record of a chat, kept in the chat row's `metadata` under this key so no store version is
+ * needed; `Chat.providerMetadata` leaves it out.
+ */
+export declare const HISTORY_KEY = "$history";
+export interface ChatHistoryShape extends ChatShape {
+    included: boolean;
+}
+export interface StoredHistorySkip extends HistorySkip {
+    chatId: Id;
+    title: string | null;
+}
+export declare const historyShapes: (context: StoreContext, accountKey: number, chatIds: Id[]) => Map<Id, ChatHistoryShape>;
+/** Adds what one push left out to what the chat's record already holds. A chat the store lacks is left as it is. */
+export declare const recordHistorySkips: (context: StoreContext, accountKey: number, skips: Map<Id, HistorySkip>) => void;
+/** Lifts the limits for one chat from now on, or puts them back. Answers `false` for a chat the store lacks. */
+export declare const setHistoryIncluded: (context: StoreContext, accountKey: number, chatId: Id, included: boolean) => boolean;
+/** Every chat of the account whose pushed history the limits left out, most messages first. */
+export declare const historySkips: ({ database }: StoreContext, accountKey: number) => StoredHistorySkip[];
+/** `metadata` as the messenger gave it: the history record is the store's own. */
+export declare const withoutHistory: <T extends Record<string, unknown> | undefined>(metadata: T) => T;

package/dist/store/sqlite/history-skips.js

@@ -0,0 +1,95 @@
+/**
+ * The history limits' record of a chat, kept in the chat row's `metadata` under this key so no store version is
+ * needed; `Chat.providerMetadata` leaves it out.
+ */
+export const HISTORY_KEY = "$history";
+const objectOf = (text) => {
+    if (typeof text !== "string")
+        return {};
+    try {
+        const value = JSON.parse(text);
+        return value !== null && typeof value === "object" && !Array.isArray(value)
+            ? value
+            : {};
+    }
+    catch {
+        return {};
+    }
+};
+const recordOf = (metadata) => {
+    const value = objectOf(metadata)[HISTORY_KEY];
+    return value !== null && typeof value === "object" ? value : {};
+};
+const rowOf = ({ database }, accountKey, chatId) => database
+    .prepare("SELECT id, kind, participants_count, metadata FROM chats WHERE account_id = ? AND external_id = ?")
+    .get(accountKey, chatId);
+const update = (context, id, metadata, change) => {
+    const all = objectOf(metadata);
+    const next = change(recordOf(metadata));
+    if (next.skipped === undefined && !next.included)
+        delete all[HISTORY_KEY];
+    else
+        all[HISTORY_KEY] = next;
+    const text = Object.keys(all).length === 0 ? null : JSON.stringify(all);
+    context.database.prepare("UPDATE chats SET metadata = ?, updated_at = ? WHERE id = ?").run(text, context.now(), id);
+};
+export const historyShapes = (context, accountKey, chatIds) => {
+    const shapes = new Map();
+    for (const chatId of new Set(chatIds)) {
+        const row = rowOf(context, accountKey, chatId);
+        if (!row)
+            continue;
+        shapes.set(chatId, {
+            kind: String(row.kind),
+            participantsCount: row.participants_count == null ? null : Number(row.participants_count),
+            included: recordOf(row.metadata).included === true,
+        });
+    }
+    return shapes;
+};
+/** Adds what one push left out to what the chat's record already holds. A chat the store lacks is left as it is. */
+export const recordHistorySkips = (context, accountKey, skips) => {
+    for (const [chatId, skip] of skips) {
+        const row = rowOf(context, accountKey, chatId);
+        if (!row)
+            continue;
+        update(context, Number(row.id), row.metadata, (held) => {
+            const before = held.skipped;
+            const skipped = before
+                ? {
+                    ...skip,
+                    messages: before.messages + skip.messages,
+                    oldestAt: before.oldestAt < skip.oldestAt ? before.oldestAt : skip.oldestAt,
+                    newestAt: before.newestAt > skip.newestAt ? before.newestAt : skip.newestAt,
+                }
+                : skip;
+            return { ...held, skipped };
+        });
+    }
+};
+/** Lifts the limits for one chat from now on, or puts them back. Answers `false` for a chat the store lacks. */
+export const setHistoryIncluded = (context, accountKey, chatId, included) => {
+    const row = rowOf(context, accountKey, chatId);
+    if (!row)
+        return false;
+    update(context, Number(row.id), row.metadata, (held) => ({ ...held, included }));
+    return true;
+};
+/** Every chat of the account whose pushed history the limits left out, most messages first. */
+export const historySkips = ({ database }, accountKey) => database
+    .prepare(`SELECT external_id, title, metadata FROM chats WHERE account_id = ? AND metadata LIKE '%"${HISTORY_KEY}"%'`)
+    .all(accountKey)
+    .flatMap((row) => {
+    const { skipped } = recordOf(row.metadata);
+    return skipped
+        ? [{ chatId: String(row.external_id), title: row.title == null ? null : String(row.title), ...skipped }]
+        : [];
+})
+    .sort((a, b) => b.messages - a.messages);
+/** `metadata` as the messenger gave it: the history record is the store's own. */
+export const withoutHistory = (metadata) => {
+    if (metadata === undefined || !(HISTORY_KEY in metadata))
+        return metadata;
+    const { [HISTORY_KEY]: _, ...rest } = metadata;
+    return rest;
+};

package/dist/store/store.d.ts

@@ -106,6 +106,7 @@ export interface MessageStore {
     forAccount(key: AccountKey): AccountStore;
     close(): Promise<void>;
 }
+export type { ChatHistoryShape, StoredHistorySkip } from "./sqlite/history-skips.js";
 export { BACKFILL_ON_OPEN, type StoreOptions } from "./sqlite/open-store.js";
 export { fileFacts, readStoreTables, type TableKind } from "./sqlite/store-tables.js";
 export declare const openStore: (options?: StoreOptions) => Promise<MessageStore>;

package/package.json

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

@@ -438,6 +438,9 @@
     "--full": {
       "meaning": "found messages with their whole text and every provider field"
     },
+    "--full-history": {
+      "meaning": "keep this chat's pushed history in full from now on, past the history limits"
+    },
     "--hidden": {
       "value": "<on|off>",
       "meaning": "on hides a forum's General topic from the topic list, off shows it"
@@ -3509,6 +3512,7 @@
         "--catch-up-messages": "all",
         "--catch-up-time": "all",
         "--dry-run": "all",
+        "--full-history": "all",
         "--last": "all",
         "--limit": "all",
         "--no-catch-up": "all",