@wirecat/cli-core 0.543.0 → 0.545.0

package/CHANGELOG.md

@@ -5,6 +5,42 @@ 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.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
+
+- **The first run of a new version refreshes the agent instructions an older version installed**: each `SKILL.md`
+  copy whose `skill status` is `stale` (Claude Code's, `~/.agents/skills`, and Hermes's own copy) is rewritten once,
+  with one line on stderr — `Updated the tg instructions for Claude Code and other agents to 0.112.0`. A missing copy
+  stays missing, an `unversioned` one (no released `skill install` wrote it) and a symlink are left as they are, and a
+  failure is one note, never a failed command. The version tried is kept in `<state>/skill-refresh.json`. Off in a
+  moved run, under vitest, during `skill`, and with `<PREFIX>_NO_SKILL_REFRESH=1`; `--quiet` keeps the line out.
+
+### Changed — may break callers
+
+- **An agent's own shell may tighten a permission but never loosen it.** `config set|unset permissions…` run where
+  `AI_AGENT`, `CLAUDECODE`, `OPENCLAW_SHELL=exec` or another agent marker is set is now treated like an MCP agent's
+  call: `mcp.authority` and `bot.api` stay owner-only, and a level may only go down (`readonly` → `deny`, never
+  `readonly` → `allow`). Unsetting a permission, replacing `permissions` whole, or `--defaults`/`--personal`/`--bot`
+  accept only `deny`. Before, Hermes or OpenClaw could undo the read-only the desktop app set, from any chat message
+  that talked it into running `config set`. The owner changes them in a terminal outside the agent; the desktop app
+  already runs the tools without these variables. Not a sandbox: an agent with a general shell can still edit the
+  file itself, so keep its own command approvals on.
+
 ## 0.543.0 — 02.11.2026
 
 ### Added

package/dist/cli/config-command.js

@@ -2,7 +2,8 @@ import { CliError, pathsAreOverridden } from "@wirecat/cli-base";
 import { annotate } from "@wirecat/cli-base/commands";
 import { Command, Option } from "commander";
 import { envName } from "../ports/app.js";
-import { AUTHORITY_KEY, BOT_API_KEY } from "../sends/permissions.js";
+import { agentOf } from "../runs/run-context.js";
+import { AUTHORITY_KEY, BOT_API_KEY, LEVELS, levelFor } from "../sends/permissions.js";
 import { baseContext, environmentOf } from "./context.js";
 import { grantsAuthority, LOCAL_READ, LOCAL_WRITE } from "./effects.js";
 import { itemOf, renderAnswer } from "./envelope.js";
@@ -115,8 +116,13 @@ export const configCommand = (app, config, { permissionKey = config.permissions,
                 // The defaults are every other profile's settings too, and the top of the file is everyone's.
                 throw new CliError("permission_error", `this process is locked to profile ${settings.profile} (${lock}) — ${root ? setting : "--defaults"} changes other profiles`);
             }
-            if (environmentOf(this).agent)
+            // An agent's own shell counts too: Hermes and OpenClaw run the tool there for anyone their chat accepts (SEC-116).
+            if (environmentOf(this).agent || agentOf(env)) {
                 refuseGuardedKey(setting, action === "set" ? String(given) : undefined, ownerOnly);
+                refuseLoosening(settings.permissions, setting, action === "set" ? String(given) : undefined, {
+                    wide: Boolean(everyone || root || personal || bot),
+                });
+            }
             if (action === "set")
                 refuseUnknownKey(this, setting, String(given), permissionKey);
             const saved = config.changeSetting(settings.configPath, {
@@ -185,6 +191,30 @@ const refuseGuardedKey = (setting, value, ownerOnly) => {
         return;
     throw new CliError("permission_error", `an agent cannot change permissions.${guarded} — the owner sets it in a terminal`, { permission: guarded });
 };
+/**
+ * An agent may tighten a permission, never loosen one: a message in a chat the agent reads must not be able to talk it
+ * into lifting the owner's `readonly`. Removing a key, replacing `permissions` whole, or changing what several profiles
+ * get can loosen in ways this profile's levels cannot show, so there an agent may only set `deny`.
+ */
+const refuseLoosening = (levels, setting, value, { wide }) => {
+    if (setting !== "permissions" && !setting.startsWith("permissions."))
+        return;
+    const key = setting.slice("permissions.".length);
+    const refuse = (why) => {
+        throw new CliError("permission_error", `an agent cannot loosen permissions: ${why} — the owner does it in a terminal`, {
+            permission: key || "permissions",
+        });
+    };
+    if (value === "deny" && setting !== "permissions")
+        return;
+    if (value === undefined)
+        refuse(`unsetting ${setting} can lift a limit`);
+    if (setting === "permissions" || wide)
+        refuse(`only deny may be set for ${setting} with --defaults, --personal, --bot or the whole object`);
+    const now = levelFor(levels, key).level;
+    if (LEVELS.indexOf(value) > LEVELS.indexOf(now))
+        refuse(`${setting} is ${now}, ${value} is looser`);
+};
 /** The keys of a `permissions` object given whole; anything else is left to the schema to refuse. */
 const objectKeys = (value) => {
     try {

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

@@ -31,6 +31,8 @@ import { commandWords, isProfileName, liftProfile, sampleCommand, takesProfile,
 import { absolutePaths, relayTarget } from "./relay-route.js";
 import { NoProfileHere, namedProfile, settingsFor, } from "./settings.js";
 import { assertSharedContracts } from "./shared-contracts.js";
+import { skillSourceOf } from "./skill-command.js";
+import { refreshSkills, skipsSkillRefresh } from "./skill-refresh.js";
 import { commandAt, failureSteps, lineOf, withLines } from "./steps.js";
 // An MCP server builds the tree on every tool call; the contracts of one definition's tree do not change between builds.
 const contractsChecked = new WeakSet();
@@ -470,6 +472,9 @@ const runOnce = async (argv, definition, options) => {
     try {
         await control.race(() => program.parseAsync(rest, { from: "user" }));
         const code = exit.code ?? (process.exitCode === undefined ? 0 : Number(process.exitCode));
+        const refreshed = code === 0 ? refreshFor(definition, program, rest, options) : undefined;
+        if (refreshed && !rest.includes("--quiet"))
+            streams.diagnostic(refreshed);
         const hint = code === 0 && rest[0] !== "commands" && rest[0] !== "help" && !rest.includes("--quiet")
             ? hintFor(definition, rest, options)
             : undefined;
@@ -555,6 +560,23 @@ const failingNoticeFor = (app, env, program) => {
         return undefined;
     }
 };
+const NO_REFRESH_COMMANDS = ["skill", "complete", "commands", "help"];
+/** Not while `skill` runs: right after an update, `skill status` must report the copies as they are. */
+const refreshFor = ({ app }, program, argv, options) => {
+    const env = options.env ?? process.env;
+    try {
+        if (NO_REFRESH_COMMANDS.includes(argv[0] ?? "") || skipsSkillRefresh(app, env))
+            return undefined;
+        const skill = skillSourceOf(program, app.appName);
+        if (!skill)
+            return undefined;
+        const state = resolvePaths({ appName: app.appName, prefix: app.envPrefix, env }).state;
+        return refreshSkills({ app, skill, env, markerPath: join(state, "skill-refresh.json") });
+    }
+    catch {
+        return undefined;
+    }
+};
 /** The update notice's state file, so both daily lines share one file per CLI. */
 const hintFor = ({ app, configuration }, argv, options) => {
     const env = options.env ?? process.env;

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">, {}>;