@wirecat/cli-core 0.365.0 → 0.367.0

package/CHANGELOG.md

@@ -7,6 +7,38 @@ shape of this file.
 
 ## Unreleased
 
+## 0.367.0 — 20.10.2026
+
+### Added
+
+- **A document hit in project gathering carries the paragraphs around it.** `around` holds, in document order, up
+  to `around.before` and `around.after` paragraphs next to the first one naming a searched word, plus that one
+  marked `found`. The bytes count as `usage.aroundBytes`, as a message's neighbours do.
+
+### Fixed
+
+- **An evidence findings review accepts the findings whose own evidence is unchanged.** Before, one changed text
+  anywhere in a batch refused accepting any of it, so the agent had to stage the whole batch again. Now only the
+  accepted findings' project, assignee and cited texts are rechecked; the rest can be rejected in the same review.
+  Batches keep one hash per checked record for this; a batch staged earlier is still checked as a whole.
+
+- **Project gathering moves past large documents instead of stalling.** A page of evidence now holds the records
+  that fit its byte budget together, rather than failing when they do not. A record larger than the page is read
+  alone, up to 256 KiB. One larger still is listed in the new `oversized` result field by reference and skipped,
+  so a resume no longer retries the same page and charges its budget each time. The context reader's page gains
+  the same optional `oversized`. Meeting preparation reports such a record as `read-limited` and continues past it.
+
+## 0.366.0 — 20.10.2026
+
+### Added
+
+- **A chat's history in the store (store version 25).** `chat_revisions` keeps one row per change to a chat's id,
+  title, membership, scope, search visibility or parent, with the old and new value, the time and the store write
+  that made it (`chats`, `delta`, `left`, `rejoin`, `rekey`, `merge`, `send`, `details`; NULL for an older build or SQL
+  by hand). A trigger writes it in the changing transaction, only for a real change. A read by the id a chat was
+  re-keyed from, `messages list <old id> --offline` included, now finds the chat it became, per account
+  (`store.chats.renamedChatId`). The history is never indexed for search; a purged chat's history goes with it.
+
 ## 0.365.0 — 19.10.2026
 
 ### Fixed

package/dist/context/evidence-response.js

@@ -34,6 +34,14 @@ export const validateContextEvidencePage = (page, request) => {
             fail();
         if (page.next)
             contextEvidenceRequest({ ...request, cursor: page.next });
+        const big = page.oversized;
+        if (big !== undefined &&
+            (!big ||
+                page.items.length ||
+                typeof big.ref !== "string" ||
+                !Number.isSafeInteger(big.bytes) ||
+                big.bytes <= maxReadBytes))
+            fail();
         let actual = 0;
         for (const item of page.items) {
             if (!item ||

package/dist/context/evidence.d.ts

@@ -1,3 +1,4 @@
+export declare const CONTEXT_MAX_READ_BYTES = 262144;
 export declare const CONTEXT_SOURCE_KINDS: readonly ["message", "mail", "document", "meeting"];
 export interface ContextSource {
     kind: (typeof CONTEXT_SOURCE_KINDS)[number];
@@ -40,6 +41,11 @@ export interface ContextEvidencePage {
         scope: string;
     } | null;
     readBytes: number;
+    /** The next record alone is larger than maxReadBytes: it was not read, and next moves past it. */
+    oversized?: {
+        ref: string;
+        bytes: number;
+    };
     coverage: {
         available: boolean;
         index: "ready" | "pending" | "missing" | "unknown";
@@ -65,6 +71,11 @@ export interface ContextIndex {
 }
 /** Changes whenever the cited text, its title or its revision does; a staged finding citing an older one is stale. */
 export declare const contextEvidenceFingerprint: (item: Pick<ContextEvidenceItem, "ref" | "title" | "text" | "revision">) => string;
+/** How many rows, in reading order, fit the allowance together; none when the first alone is larger. */
+export declare const fittingRows: (sizes: readonly number[], limit: number, maxReadBytes: number) => {
+    count: number;
+    bytes: number;
+};
 /** One stored message, email or document as the context reader returns it, by its reference. */
 export interface ContextRecordReader {
     read(ref: string): Promise<Pick<ContextEvidenceItem, "ref" | "title" | "text" | "revision"> | null>;

package/dist/context/evidence.js

@@ -1,10 +1,22 @@
 import { createHash } from "node:crypto";
 import { CliError } from "@wirecat/cli-base";
+export const CONTEXT_MAX_READ_BYTES = 262144;
 export const CONTEXT_SOURCE_KINDS = ["message", "mail", "document", "meeting"];
 /** Changes whenever the cited text, its title or its revision does; a staged finding citing an older one is stale. */
 export const contextEvidenceFingerprint = (item) => createHash("sha256")
     .update(JSON.stringify(["context-evidence-v1", item.ref, item.title, item.text, item.revision]))
     .digest("hex");
+/** How many rows, in reading order, fit the allowance together; none when the first alone is larger. */
+export const fittingRows = (sizes, limit, maxReadBytes) => {
+    let count = 0, bytes = 0;
+    for (const size of sizes.slice(0, limit)) {
+        if (!(bytes + size <= maxReadBytes))
+            break;
+        bytes += size;
+        count++;
+    }
+    return { count, bytes };
+};
 export const contextCursorScope = (request) => createHash("sha256")
     .update(JSON.stringify([
     "context-evidence-v1",
@@ -56,7 +68,7 @@ export const contextEvidenceRequest = (input) => {
     if (!words.length || words.length > 16)
         throw new CliError("validation_error", "query needs 1–16 literal words");
     const limit = integer(input.limit ?? 10, "limit", 1, 20);
-    const maxReadBytes = integer(input.maxReadBytes ?? 65536, "maxReadBytes", 1, 262144);
+    const maxReadBytes = integer(input.maxReadBytes ?? 65536, "maxReadBytes", 1, CONTEXT_MAX_READ_BYTES);
     if (input.cursor !== undefined && (!input.cursor || typeof input.cursor !== "object"))
         throw new CliError("validation_error", "cursor needs at, id and scope");
     if (input.cursor)

package/dist/services/meeting-communications-preparation.js

@@ -41,6 +41,10 @@ export const readPreparationCommunications = async (plan, signal) => {
                 coverage.state = "unavailable";
                 coverage.issue = "not_found";
             }
+            else if (page.oversized) {
+                coverage.state = "read-limited";
+                coverage.issue = "validation_error";
+            }
             else if (page.coverage.index !== "ready")
                 coverage.issue = "configuration_error";
             const refs = new Set();

package/dist/services/message-resolution.js

@@ -23,35 +23,48 @@ export const readChatId = async (deps, reference, store, account) => {
 };
 const LEFT_EMPTY = "you left this chat, and the store holds none of its messages";
 /** A chat as typed, found among the stored chats the way an adapter finds it among its own. */
-export const storedChatId = async (messenger, reference, store, account) => chatIdAmong(messenger, reference, account, () => store.chats.chats(account, {}));
+export const storedChatId = async (messenger, reference, store, account) => chatIdAmong(messenger, reference, account, {
+    held: () => store.chats.chats(account, {}),
+    renamed: (id) => store.chats.renamedChatId(account, id),
+});
 /** `storedChatId`, then among the chats the account left: their history is kept, so a read of it still finds them. */
 const keptChatId = (messenger, reference, store, account) => storedChatId(messenger, reference, store, account).catch((error) => {
     if (codeOf(error) !== "not_found")
         throw error;
-    return chatIdAmong(messenger, reference, account, () => store.chats.chats(account, { includeLeft: true }));
+    return chatIdAmong(messenger, reference, account, {
+        held: () => store.chats.chats(account, { includeLeft: true }),
+        renamed: (id) => store.chats.renamedChatId(account, id),
+    });
 });
 /** `storedChatId`, among the chats of the account the store is bound to; `includeLeft` tries the left ones last. */
 export const chatIdIn = (messenger, reference, store, { includeLeft = false } = {}) => {
-    const among = chatIdAmong(messenger, reference, store.account, () => store.chats.chats({}));
+    const renamed = (id) => store.chats.renamedChatId(id);
+    const among = chatIdAmong(messenger, reference, store.account, { held: () => store.chats.chats({}), renamed });
     if (!includeLeft)
         return among;
     return among.catch((error) => {
         if (codeOf(error) !== "not_found")
             throw error;
-        return chatIdAmong(messenger, reference, store.account, () => store.chats.chats({ includeLeft: true }));
+        return chatIdAmong(messenger, reference, store.account, {
+            held: () => store.chats.chats({ includeLeft: true }),
+            renamed,
+        });
     });
 };
-const chatIdAmong = async (messenger, reference, account, held) => {
+const chatIdAmong = async (messenger, reference, account, { held, renamed }) => {
     const trimmed = reference.trim();
     if (messenger.savedChatId && ["me", "self", "saved"].includes(trimmed.toLowerCase())) {
         return messenger.savedChatId(account);
     }
     if (/^-?\d+$/.test(trimmed))
-        return trimmed;
+        return (await renamed(trimmed)) ?? trimmed;
     const chats = (await held()).items;
     const exact = chats.find((one) => one.id === trimmed);
     if (exact)
         return exact.id;
+    const moved = await renamed(trimmed);
+    if (moved !== undefined && chats.some((one) => one.id === moved))
+        return moved;
     if (trimmed.startsWith("@")) {
         const username = trimmed.slice(1).toLowerCase();
         const found = chats.find((one) => String(one.providerMetadata?.username ?? "").toLowerCase() === username);

package/dist/services/project-gathering-around.d.ts

@@ -20,6 +20,14 @@ export interface ProjectNeighbourReader {
     }[]>;
 }
 export declare const storedMessageNeighbours: (messages: Pick<MessagesStore, "around">) => ProjectNeighbourReader;
+/** The paragraphs around the first one that names the query, in document order; the hit's own is marked found. */
+export declare const documentPassage: (text: string, query: string, window: {
+    before: number;
+    after: number;
+}) => {
+    text: string;
+    found: boolean;
+}[];
 /**
  * Neighbours are context for reading a hit, not matches: they never join `items`, and their text counts against
  * the run's read bytes.

package/dist/services/project-gathering-around.js

@@ -1,5 +1,6 @@
 import { CliError } from "@wirecat/cli-base";
 import { formatLocator, parseLocator } from "../domain/locator.js";
+import { fold } from "../store/normalize.js";
 import { excerpt } from "./excerpt.js";
 export const storedMessageNeighbours = (messages) => ({
     async around(ref, window) {
@@ -17,6 +18,23 @@ export const storedMessageNeighbours = (messages) => ({
         }));
     },
 });
+const wordsOf = (text) => (text.match(/[\p{L}\p{N}\p{M}]+/gu) ?? []).map(fold);
+/** The paragraphs around the first one that names the query, in document order; the hit's own is marked found. */
+export const documentPassage = (text, query, window) => {
+    const paragraphs = text
+        .split(/\n\s*\n/)
+        .map((part) => part.replace(/\s+/g, " ").trim())
+        .filter(Boolean);
+    const words = new Set(wordsOf(query));
+    const hit = paragraphs.findIndex((part) => wordsOf(part).some((word) => words.has(word)));
+    if (hit < 0 || paragraphs.length < 2)
+        return [];
+    const from = Math.max(0, hit - window.before);
+    return paragraphs.slice(from, hit + window.after + 1).map((part, index) => ({
+        text: excerpt(part, query, 200, { literal: true }),
+        found: from + index === hit,
+    }));
+};
 /**
  * Neighbours are context for reading a hit, not matches: they never join `items`, and their text counts against
  * the run's read bytes.

package/dist/services/project-gathering.d.ts

@@ -79,6 +79,12 @@ export declare const gatherProjectEvidence: (ports: ProjectGatheringPorts, reque
         issue: string | null;
     }[];
     items: ProjectEvidenceItem[];
+    oversized: {
+        ref: string;
+        lanes: string[];
+        source: number;
+        bytes: number;
+    }[];
     matchedAgain: {
         ref: string;
         lanes: string[];

package/dist/services/project-gathering.js

@@ -1,8 +1,8 @@
 import { CliError } from "@wirecat/cli-base";
-import { contextEvidenceFingerprint } from "../context/evidence.js";
+import { CONTEXT_MAX_READ_BYTES, contextEvidenceFingerprint } from "../context/evidence.js";
 import { createContextEvidenceReader } from "./context-evidence.js";
 import { excerpt } from "./excerpt.js";
-import { attachNeighbours } from "./project-gathering-around.js";
+import { attachNeighbours, documentPassage, } from "./project-gathering-around.js";
 import { decodeCheckpoint, encodeCheckpoint, projectGatheringRequest, projectUnits, seenKey, } from "./project-gathering-request.js";
 const terminal = new Set(["done", "unavailable", "failed"]);
 export const gatherProjectEvidence = async (ports, request) => {
@@ -72,6 +72,7 @@ export const gatherProjectEvidence = async (ports, request) => {
     const items = [];
     const byRef = new Map();
     const matchedAgain = new Map();
+    const oversized = new Map();
     let stopped = null;
     const open = (u) => !terminal.has(u.state) && u.state !== "read-limited";
     const take = (item, lane, kind, source) => {
@@ -101,6 +102,18 @@ export const gatherProjectEvidence = async (ports, request) => {
             lanes: [lane.id],
             context: lane.kinds.every((k) => k === "person") ? "person-only" : "project",
         };
+        if (kind === "document" && plan.around.before + plan.around.after) {
+            entry.around = [];
+            for (const part of documentPassage(item.text, lane.query, plan.around)) {
+                const bytes = Buffer.byteLength(part.text);
+                if (bytes > plan.budgets.maxReadBytes - usage.readBytes - usage.aroundBytes) {
+                    entry.aroundIssue = "read-bytes";
+                    break;
+                }
+                usage.aroundBytes += bytes;
+                entry.around.push({ ref: item.ref, at: item.at, sender: null, ...part });
+            }
+        }
         byRef.set(item.ref, entry);
         items.push(entry);
         usage.items++;
@@ -126,24 +139,49 @@ export const gatherProjectEvidence = async (ports, request) => {
                                 : null;
             if (stopped)
                 break;
-            const allowance = Math.min(plan.budgets.maxPageBytes, plan.budgets.maxReadBytes - usage.readBytes);
-            const reader = createContextEvidenceReader(ports.evidence, [unit.source], {
-                maxReads: 1,
-                maxTotalReadBytes: allowance,
-            });
-            usage.reads++;
-            try {
-                const page = await reader.read({
-                    source: unit.source,
-                    query: unit.lane.query,
-                    after: unit.chunk.after,
-                    before: unit.chunk.before,
-                    limit: 20,
-                    maxReadBytes: allowance,
-                    ...(state.cursor ? { cursor: state.cursor } : {}),
-                    signal,
+            const readPage = async (allowance, limit) => {
+                const reader = createContextEvidenceReader(ports.evidence, [unit.source], {
+                    maxReads: 1,
+                    maxTotalReadBytes: allowance,
                 });
-                usage.readBytes += page.readBytes;
+                usage.reads++;
+                try {
+                    const page = await reader.read({
+                        source: unit.source,
+                        query: unit.lane.query,
+                        after: unit.chunk.after,
+                        before: unit.chunk.before,
+                        limit,
+                        maxReadBytes: allowance,
+                        ...(state.cursor ? { cursor: state.cursor } : {}),
+                        signal,
+                    });
+                    usage.readBytes += page.readBytes;
+                    return page;
+                }
+                catch (error) {
+                    usage.readBytes += reader.usage().chargedBytes;
+                    throw error;
+                }
+            };
+            try {
+                let page = await readPage(Math.min(plan.budgets.maxPageBytes, plan.budgets.maxReadBytes - usage.readBytes), 20);
+                const big = page.oversized;
+                if (big && big.bytes <= CONTEXT_MAX_READ_BYTES) {
+                    if (big.bytes > plan.budgets.maxReadBytes - usage.readBytes || usage.reads >= plan.budgets.maxReads) {
+                        state.state = "read-limited";
+                        state.code = "validation_error";
+                        continue;
+                    }
+                    page = await readPage(big.bytes, 1);
+                }
+                else if (big) {
+                    const known = oversized.get(big.ref);
+                    if (!known)
+                        oversized.set(big.ref, { ref: big.ref, lanes: [unit.lane.id], source: unit.sourceIndex, bytes: big.bytes });
+                    else if (!known.lanes.includes(unit.lane.id))
+                        known.lanes.push(unit.lane.id);
+                }
                 state.pages++;
                 state.code = page.coverage.index === "ready" ? null : `index-${page.coverage.index}`;
                 for (const item of page.items)
@@ -161,7 +199,6 @@ export const gatherProjectEvidence = async (ports, request) => {
             }
             catch (error) {
                 signal?.throwIfAborted();
-                usage.readBytes += reader.usage().chargedBytes;
                 if (!(error instanceof CliError))
                     throw error;
                 if (error.code === "validation_error" && error.details?.reason === "context.read-budget")
@@ -225,6 +262,7 @@ export const gatherProjectEvidence = async (ports, request) => {
             issue: progress[index]?.code ?? null,
         })),
         items,
+        oversized: [...oversized.values()],
         matchedAgain: [...matchedAgain].map(([ref, lanes]) => ({ ref, lanes: [...lanes] })),
         usage: { ...usage, elapsedMs: now() - started },
         totals,

package/dist/store/chats.d.ts

@@ -36,7 +36,8 @@ export interface ChatsStore {
     rejoinChats(key: AccountKey, present: Id[]): Promise<number>;
     /**
      * The chat the messenger now names `to` instead of `from`: renamed, or merged into the chat already stored as
-     * `to`. Replaying it changes nothing.
+     * `to`, with `from` recorded in `chat_revisions` (`renamedChatId`), also when only `to` is stored. Replaying it
+     * changes nothing.
      */
     rekeyChat(key: AccountKey, from: Id, to: Id): Promise<ChatRekey>;
     /**
@@ -58,6 +59,11 @@ export interface ChatsStore {
     chatCompleteness(key: AccountKey, chatIds: Id[]): Promise<ChatCompleteness[]>;
     /** Per chat that has messages: how many, the oldest and newest, and when the last one was stored. */
     chatStats(key: AccountKey, chatId?: Id): Promise<ChatStats[]>;
+    /**
+     * The id a chat re-keyed from `chatId` has now, from `chat_revisions`; `undefined` while a chat is stored under
+     * `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>;
     /** 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>;
     /** Per chat that spoke since `since` (ms): its newest message and who sent it when stored, never the text. */

package/dist/store/chats.js

@@ -11,8 +11,10 @@ export const chatsStoreOver = (context) => {
     return {
         saveChats: async (key, list) => write(database, () => {
             const accountKey = accountPk(key);
-            for (const chat of list)
-                chatQueries.upsertChat(context, accountKey, chat);
+            chatQueries.revisedBy(context, "chats", () => {
+                for (const chat of list)
+                    chatQueries.upsertChat(context, accountKey, chat);
+            });
         }),
         chats: async (key, window) => {
             const accountKey = findAccountPk(key);
@@ -34,14 +36,16 @@ export const chatsStoreOver = (context) => {
                 return 0;
             let marked = 0;
             write(database, () => {
-                marked = chatQueries.markLeft(context, accountKey, present);
+                marked = chatQueries.revisedBy(context, "left", () => chatQueries.markLeft(context, accountKey, present));
                 writeState(accountKey, completeness.CHAT_LIST_KEY, String(present.length));
             });
             return marked;
         },
         rejoinChats: async (key, present) => {
             const accountKey = findAccountPk(key);
-            return accountKey === undefined ? 0 : write(database, () => chatQueries.rejoin(context, accountKey, present));
+            return accountKey === undefined
+                ? 0
+                : write(database, () => chatQueries.revisedBy(context, "rejoin", () => chatQueries.rejoin(context, accountKey, present)));
         },
         rekeyChat: async (key, from, to) => {
             const accountKey = findAccountPk(key);
@@ -77,6 +81,10 @@ export const chatsStoreOver = (context) => {
             const accountKey = findAccountPk(key);
             return accountKey === undefined ? [] : reads.chatStats(context, accountKey, chatId);
         },
+        renamedChatId: async (key, chatId) => {
+            const accountKey = findAccountPk(key);
+            return accountKey === undefined ? undefined : chatQueries.renamedChatId(context, accountKey, chatId);
+        },
         chatKind: async (key, chatId) => {
             const accountKey = findAccountPk(key);
             if (accountKey === undefined)
@@ -93,7 +101,7 @@ export const chatsStoreOver = (context) => {
                 : reads.chatActivity(context, accountKey, since, where);
         },
         chatMetadata: async (key, chatId) => chatQueries.metadata(context, key, chatId),
-        saveChatMetadata: async (key, entry) => chatQueries.saveMetadata(context, key, entry),
+        saveChatMetadata: async (key, entry) => write(database, () => chatQueries.saveMetadata(context, key, entry)),
         replaceAutoTags: async (key, chatId, algorithm, matches) => write(database, () => chatQueries.replaceAutoTags(context, key, chatId, algorithm, matches)),
         rankingDiscussionChats: async (account, chatId) => {
             const rows = database

package/dist/store/sqlite/chat-rekey.d.ts

@@ -24,7 +24,8 @@ export interface ChatRekeys {
 }
 /**
  * A chat the messenger now names by another id: renamed in place, or merged into the row already stored under the
- * new id's twin. Replaying it, or naming a chat the store does not hold, changes nothing. Runs inside `write`.
+ * new id's twin, each change recorded in `chat_revisions`. Replaying it changes nothing; naming a chat the store does
+ * not hold records only the old id, when the new one is stored. Runs inside `write`.
  */
 export declare const rekeyChat: (context: StoreContext, key: AccountKey, accountKey: number, from: Id, to: Id) => ChatRekey;
 /**

package/dist/store/sqlite/chat-rekey.js

@@ -1,6 +1,6 @@
 import { CliError } from "@wirecat/cli-base";
 import { formatLocator } from "../../domain/locator.js";
-import { purgeChats, stricterPrivacy } from "./chats.js";
+import { purgeChats, revisedBy, stricterPrivacy } from "./chats.js";
 import { pointerPairs } from "./entity-types.js";
 import { tombstone } from "./messages.js";
 import { targetKey } from "./notes.js";
@@ -113,6 +113,7 @@ const absorb = (context, kept, gone) => {
     foldOpenStays(context, kept, gone);
     for (const table of [
         "poll_votes",
+        "chat_revisions",
         "chat_events",
         "message_transcripts",
         "chat_members",
@@ -157,15 +158,33 @@ const MESSENGER_FIELDS = [
     "description",
     "details_fetched_at",
 ];
+/**
+ * The re-key of a chat stored only under its new id changes no row, so the trigger records nothing; the old id is
+ * written by hand, once, so a read by it still finds the chat.
+ */
+const recordOldId = ({ database, now }, accountKey, chat, from, to) => {
+    database
+        .prepare(`INSERT INTO chat_revisions (chat_id, account_id, field, old_value, new_value, source, created_at)
+        SELECT ?, ?, 'external_id', ?, ?, 'rekey', ? WHERE NOT EXISTS (SELECT 1 FROM chat_revisions
+          WHERE chat_id = ? AND field = 'external_id' AND old_value = ?)`)
+        .run(chat, accountKey, from, to, now(), chat, from);
+};
 /**
  * A chat the messenger now names by another id: renamed in place, or merged into the row already stored under the
- * new id's twin. Replaying it, or naming a chat the store does not hold, changes nothing. Runs inside `write`.
+ * new id's twin, each change recorded in `chat_revisions`. Replaying it changes nothing; naming a chat the store does
+ * not hold records only the old id, when the new one is stored. Runs inside `write`.
  */
 export const rekeyChat = (context, key, accountKey, from, to) => {
     const old = from === to ? undefined : chatRow(context, accountKey, from);
-    if (!old)
+    const twin = from === to ? undefined : chatRow(context, accountKey, to);
+    if (!old) {
+        if (twin)
+            recordOldId(context, accountKey, Number(twin.id), from, to);
         return { outcome: "unchanged", messages: 0, duplicates: 0 };
-    const twin = chatRow(context, accountKey, to);
+    }
+    return revisedBy(context, twin ? "merge" : "rekey", () => moveChat(context, key, accountKey, old, twin, from, to));
+};
+const moveChat = (context, key, accountKey, old, twin, from, to) => {
     const kept = Number(old.id);
     let moved = { messages: 0, duplicates: 0 };
     if (twin) {

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

@@ -7,6 +7,19 @@ export declare const chatOf: ({ orm }: StoreContext, accountKey: number, chatKey
 export declare const findChatPk: ({ orm }: StoreContext, accountKey: number, chatId: Id) => number | undefined;
 /** A chat known only from its messages, until the chat list names it. */
 export declare const chatPkFor: (context: StoreContext, accountKey: number, chatId: Id) => number;
+/** The store write a `chat_revisions` row names; a writer that sets none is recorded as NULL. */
+export type ChatRevisionSource = "chats" | "delta" | "left" | "rejoin" | "rekey" | "merge" | "send" | "details";
+/**
+ * Runs `body` with `source` as what the `chat_revisions` trigger records, inside the caller's transaction. The row is
+ * gone again before the commit, so an older build's write in a later transaction records no source rather than this
+ * one; a nested call puts the outer source back.
+ */
+export declare const revisedBy: <T>({ database, now }: StoreContext, source: ChatRevisionSource, body: () => T) => T;
+/**
+ * The id the chat once stored as `chatId` has now, from its newest re-key in this account; `undefined` while a chat is
+ * stored under `chatId` itself, or none ever was.
+ */
+export declare const renamedChatId: ({ database }: StoreContext, accountKey: number, chatId: Id) => Id | undefined;
 interface ChatPrivacy {
     searchable: number;
     scope: string | null;

package/dist/store/sqlite/chats.js

@@ -29,6 +29,38 @@ export const chatPkFor = (context, accountKey, chatId) => findChatPk(context, ac
     })
         .returning({ pk: chats.id })
         .get()?.pk);
+/**
+ * Runs `body` with `source` as what the `chat_revisions` trigger records, inside the caller's transaction. The row is
+ * gone again before the commit, so an older build's write in a later transaction records no source rather than this
+ * one; a nested call puts the outer source back.
+ */
+export const revisedBy = ({ database, now }, source, body) => {
+    const outer = database.prepare("SELECT source, at FROM chat_revision_source WHERE id = 1").get();
+    const set = database.prepare("INSERT OR REPLACE INTO chat_revision_source (id, source, at) VALUES (1, ?, ?)");
+    set.run(source, now());
+    try {
+        return body();
+    }
+    finally {
+        if (outer)
+            set.run(String(outer.source), Number(outer.at));
+        else
+            database.prepare("DELETE FROM chat_revision_source").run();
+    }
+};
+/**
+ * The id the chat once stored as `chatId` has now, from its newest re-key in this account; `undefined` while a chat is
+ * stored under `chatId` itself, or none ever was.
+ */
+export const renamedChatId = ({ database }, accountKey, chatId) => {
+    const row = database
+        .prepare(`SELECT c.external_id AS id FROM chat_revisions r JOIN chats c ON c.id = r.chat_id
+        WHERE r.account_id = ? AND r.field = 'external_id' AND r.old_value = ? AND c.account_id = r.account_id
+          AND NOT EXISTS (SELECT 1 FROM chats WHERE account_id = ? AND external_id = ?)
+        ORDER BY r.created_at DESC, r.id DESC LIMIT 1`)
+        .get(accountKey, chatId, accountKey, chatId);
+    return row ? String(row.id) : undefined;
+};
 /**
  * The owner's word on a chat must not loosen because another row joins it: hidden wins, and when the two chats sit
  * on different sides of the owner's life, the personal side wins, since a work chat reaches work views and meeting
@@ -70,11 +102,11 @@ export const answeredChatPk = (context, accountKey, chatId, typed) => {
     if (found !== undefined) {
         const strict = stricterPrivacy(context, accountKey, found, like);
         if (strict.searchable !== found.searchable || strict.scope !== found.scope)
-            orm
+            revisedBy(context, "send", () => orm
                 .update(chats)
                 .set({ ...strict, updatedAt: now() })
                 .where(eq(chats.id, found.pk))
-                .run();
+                .run());
         return found.pk;
     }
     return Number(orm
@@ -185,7 +217,7 @@ export const rejoin = ({ orm }, accountKey, present) => orm
  * list. Answers how many it marked.
  */
 export const markLeft = (context, accountKey, present) => {
-    rejoin(context, accountKey, present);
+    revisedBy(context, "rejoin", () => rejoin(context, accountKey, present));
     return context.orm
         .update(chats)
         .set({ membershipState: "left" })
@@ -352,9 +384,9 @@ export const metadata = (context, key, chatId) => {
         : undefined;
 };
 export const saveMetadata = (context, key, entry) => {
-    context.database
+    revisedBy(context, "details", () => context.database
         .prepare("UPDATE chats SET title=?, username=?, description=?, details_fetched_at=?, updated_at=? WHERE id=?")
-        .run(entry.title, entry.username, entry.description, context.now(), context.now(), metadataChatPk(context, key, entry.chatId));
+        .run(entry.title, entry.username, entry.description, context.now(), context.now(), metadataChatPk(context, key, entry.chatId)));
     return metadata(context, key, entry.chatId);
 };
 /** Called inside the store's transaction: claims and effective search tags change together. */

package/dist/store/sqlite/context-evidence.js

@@ -1,5 +1,4 @@
-import { CliError } from "@wirecat/cli-base";
-import { contextCursorScope, contextEvidenceRequest, } from "../../context/evidence.js";
+import { contextCursorScope, contextEvidenceRequest, fittingRows, } from "../../context/evidence.js";
 import { formatLocator, parseLocator } from "../../domain/locator.js";
 import { NORMALIZER_VERSION, normalize } from "../normalize.js";
 import { contextDocumentTime, contextDocumentTimeKind, contextDocumentUrl } from "./context-document-source.js";
@@ -122,38 +121,48 @@ export const contextEvidenceOver = ({ database }) => ({
             if (cursor)
                 params.push(cursor.at, cursor.at, cursor.id);
             params.push(limit + 1);
-            const probe = database
-                .prepare(`SELECT coalesce(sum(
+            const sized = database
+                .prepare(`SELECT id,at,provider,account,chat,external_id,
         length(CAST(coalesce(title,'') AS BLOB))+length(CAST(coalesce(body,'') AS BLOB))+
         length(CAST(coalesce(url,'') AS BLOB))+length(CAST(provider AS BLOB))+
         length(CAST(account AS BLOB))+length(CAST(external_id AS BLOB))+
-        length(CAST(coalesce(chat,'') AS BLOB))+length(CAST(time_kind AS BLOB))),0) AS bytes FROM (${selection})`)
-                .get(...params);
-            const readBytes = Number(probe?.bytes);
-            if (!Number.isSafeInteger(readBytes) || readBytes < 0 || readBytes > maxReadBytes)
-                throw new CliError("validation_error", "context evidence exceeds maxReadBytes before hydration", {
-                    reason: "context.read-budget",
+        length(CAST(coalesce(chat,'') AS BLOB))+length(CAST(time_kind AS BLOB)) AS bytes FROM (${selection})`)
+                .all(...params);
+            const refOf = (row) => source.kind === "document"
+                ? `document:${row.id}`
+                : formatLocator({
+                    provider: String(row.provider),
+                    account: String(row.account),
+                    chat: String(row.chat),
+                    message: String(row.external_id),
                 });
+            const past = (row) => ({ at: Number(row.at), id: Number(row.id), scope });
+            const fit = fittingRows(sized.map((row) => Number(row.bytes)), limit, maxReadBytes);
+            const first = sized[0];
+            if (!fit.count && first) {
+                coverage.hasMore = sized.length > 1;
+                return {
+                    source,
+                    items: [],
+                    readBytes: 0,
+                    coverage,
+                    next: coverage.hasMore ? past(first) : null,
+                    oversized: { ref: refOf(first), bytes: Number(first.bytes) },
+                };
+            }
             signal?.throwIfAborted();
-            const rows = database.prepare(selection).all(...params);
+            params[params.length - 1] = fit.count;
+            const selected = fit.count ? database.prepare(selection).all(...params) : [];
             signal?.throwIfAborted();
-            coverage.hasMore = rows.length > limit;
-            const selected = rows.slice(0, limit);
+            coverage.hasMore = sized.length > selected.length;
             const last = selected.at(-1);
             return {
                 source,
-                readBytes,
+                readBytes: fit.bytes,
                 coverage,
-                next: coverage.hasMore && last ? { at: Number(last.at), id: Number(last.id), scope } : null,
+                next: coverage.hasMore && last ? past(last) : null,
                 items: selected.map((row) => ({
-                    ref: source.kind === "document"
-                        ? `document:${row.id}`
-                        : formatLocator({
-                            provider: String(row.provider),
-                            account: String(row.account),
-                            chat: String(row.chat),
-                            message: String(row.external_id),
-                        }),
+                    ref: refOf(row),
                     provider: String(row.provider),
                     account: String(row.account),
                     title: row.title == null ? null : String(row.title),

package/dist/store/sqlite/context-meeting-source.js

@@ -1,5 +1,4 @@
-import { CliError } from "@wirecat/cli-base";
-import { contextCursorScope } from "../../context/evidence.js";
+import { contextCursorScope, fittingRows, } from "../../context/evidence.js";
 import { normalize } from "../normalize.js";
 import { read } from "./transaction.js";
 /** Transcript cues keep their retained revision reference; a meeting title alone is not a transcript match. */
@@ -57,29 +56,40 @@ export const readMeetingContextEvidence = (database, request) => {
         if (cursor)
             params.push(cursor.at, cursor.at, cursor.id);
         params.push(limit + 1);
-        const probe = database
-            .prepare(`SELECT coalesce(sum(length(CAST(coalesce(title,'') AS BLOB))+
+        const sized = database
+            .prepare(`SELECT id,at,ref,length(CAST(coalesce(title,'') AS BLOB))+
         length(CAST(text AS BLOB))+length(CAST(provider AS BLOB))+
-        length(CAST(account AS BLOB))+length(CAST(ref AS BLOB))+length('meeting-start')),0) AS bytes FROM (${selection})`)
-            .get(...params);
-        const readBytes = Number(probe?.bytes);
-        if (!Number.isSafeInteger(readBytes) || readBytes < 0 || readBytes > maxReadBytes)
-            throw new CliError("validation_error", "meeting context evidence exceeds maxReadBytes before hydration", {
-                reason: "context.read-budget",
-            });
+        length(CAST(account AS BLOB))+length(CAST(ref AS BLOB))+length('meeting-start') AS bytes FROM (${selection})`)
+            .all(...params);
+        const past = (row) => ({
+            at: Number(row.at),
+            id: Number(row.id),
+            scope: contextCursorScope(request),
+        });
+        const fit = fittingRows(sized.map((row) => Number(row.bytes)), limit, maxReadBytes);
+        const first = sized[0];
+        if (!fit.count && first) {
+            coverage.hasMore = sized.length > 1;
+            return {
+                source,
+                items: [],
+                readBytes: 0,
+                coverage,
+                next: coverage.hasMore ? past(first) : null,
+                oversized: { ref: String(first.ref), bytes: Number(first.bytes) },
+            };
+        }
         signal?.throwIfAborted();
-        const rows = database.prepare(selection).all(...params);
+        params[params.length - 1] = fit.count;
+        const selected = fit.count ? database.prepare(selection).all(...params) : [];
         signal?.throwIfAborted();
-        coverage.hasMore = rows.length > limit;
-        const selected = rows.slice(0, limit);
+        coverage.hasMore = sized.length > selected.length;
         const last = selected.at(-1);
         return {
             source,
-            readBytes,
+            readBytes: fit.bytes,
             coverage,
-            next: coverage.hasMore && last
-                ? { at: Number(last.at), id: Number(last.id), scope: contextCursorScope(request) }
-                : null,
+            next: coverage.hasMore && last ? past(last) : null,
             items: selected.map((row) => ({
                 ref: String(row.ref),
                 provider: String(row.provider),

package/dist/store/sqlite/evidence-findings.js

@@ -54,9 +54,9 @@ export const evidenceFindingsStoreOver = (context) => {
             receipt: proposal.result,
         };
     };
-    const snapshot = (input) => {
+    const cite = () => {
         let readBytes = 0;
-        return core.snapshot(input, (evidence, _finding, _project, seen) => {
+        return (evidence, _finding, _project, seen) => {
             if (seen.has(evidence.reference)) {
                 if (seen.get(evidence.reference) !== evidence.fingerprint)
                     return stale();
@@ -72,8 +72,9 @@ export const evidenceFindingsStoreOver = (context) => {
             if (fingerprint !== evidence.fingerprint)
                 return stale();
             seen.set(evidence.reference, fingerprint);
-        });
+        };
     };
+    const snapshot = (input) => core.snapshot(input, cite());
     const decider = (by) => {
         if (by === undefined || by === "owner")
             return { author: "owner", decision: { by: "owner" } };
@@ -109,6 +110,7 @@ export const evidenceFindingsStoreOver = (context) => {
                     return view(proposal);
                 }
                 const snapshotHash = snapshot(input);
+                const snapshotParts = core.snapshotParts(input, cite());
                 const fingerprints = input.findings.map(findingFingerprint);
                 if (new Set(fingerprints).size !== fingerprints.length)
                     return invalid("the batch contains duplicate findings");
@@ -116,7 +118,7 @@ export const evidenceFindingsStoreOver = (context) => {
                     kind: EVIDENCE_FINDINGS_KIND,
                     by,
                     target: [...projects][0],
-                    payload: { ...input, inputHash, snapshotHash, agentModel: by.model ?? null },
+                    payload: { ...input, inputHash, snapshotHash, snapshotParts, agentModel: by.model ?? null },
                 }));
             });
         },
@@ -152,9 +154,21 @@ export const evidenceFindingsStoreOver = (context) => {
                 return batch;
             }
             const input = proposal.payload;
-            // Rejecting creates nothing, so a batch whose evidence changed can still be closed.
-            if (accepted.length && snapshot(batch.input) !== input.snapshotHash)
-                return stale();
+            // Rejecting creates nothing, so a batch whose evidence changed can still be closed. Accepting needs only the
+            // accepted findings' own project, assignee and evidence unchanged; a batch staged before parts were kept needs all.
+            if (accepted.length) {
+                const parts = input.snapshotParts;
+                if (!parts) {
+                    if (snapshot(batch.input) !== input.snapshotHash)
+                        return stale();
+                }
+                else {
+                    const chosen = { ...batch.input, findings: batch.input.findings.filter((f) => accepted.includes(f.id)) };
+                    const now = core.snapshotParts(chosen, cite());
+                    if (Object.entries(now).some(([key, hash]) => parts[key] !== hash))
+                        return stale();
+                }
+            }
             if (proposal.proposedBy.type !== "bot" || !proposal.proposedBy.name)
                 return invalid("a findings author must be an agent");
             const agent = {

package/dist/store/sqlite/findings-core.d.ts

@@ -12,6 +12,7 @@ export declare const findingsAgent: (agent: FindingsAgent) => FindingsAgent;
  */
 export declare const findingsCoreOver: (context: StoreContext, kind: string) => {
     snapshot: (input: FindingsInput, cite: (evidence: FindingEvidence, finding: Finding, projectId: string, seen: Map<string, unknown>) => void) => string;
+    snapshotParts: (input: FindingsInput, cite: (evidence: FindingEvidence, finding: Finding, projectId: string, seen: Map<string, unknown>) => void) => Record<string, string>;
     previous: (account: number | null, fingerprint: string) => FindingOutcome | undefined;
     outcomes: (account: number | null, input: FindingsInput, accepted: string[], agent: FindingsAgent) => FindingOutcome[];
 };

package/dist/store/sqlite/findings-core.js

@@ -27,7 +27,7 @@ export const findingsCoreOver = (context, kind) => {
     const { database } = context;
     const facts = factOperationsOver(context);
     const tasks = workTaskOperationsOver(context);
-    const snapshot = (input, cite) => {
+    const cited = (input, cite) => {
         const seen = new Map();
         for (const finding of input.findings) {
             const project = requiredThing(database, finding.project, "the project");
@@ -51,8 +51,11 @@ export const findingsCoreOver = (context, kind) => {
             for (const evidence of finding.evidence)
                 cite(evidence, finding, String(project.id), seen);
         }
-        return findingHash([...seen].sort(([a], [b]) => a.localeCompare(b)));
+        return seen;
     };
+    const snapshot = (...args) => findingHash([...cited(...args)].sort(([a], [b]) => a.localeCompare(b)));
+    /** The same snapshot, one hash per project, person and cited reference, so part of a batch can be checked alone. */
+    const snapshotParts = (...args) => Object.fromEntries([...cited(...args)].map(([key, value]) => [key, findingHash(value)]));
     const previous = (account, fingerprint) => {
         const row = database
             .prepare("SELECT substr(j.value,1,4096) AS item FROM proposed_actions p,json_each(p.result,'$.items') j WHERE p.account_id IS ? AND p.kind=? AND p.status='approved' AND json_extract(j.value,'$.fingerprint')=? ORDER BY p.id LIMIT 1")
@@ -104,5 +107,5 @@ export const findingsCoreOver = (context, kind) => {
             reused: false,
         };
     });
-    return { snapshot, previous, outcomes };
+    return { snapshot, snapshotParts, previous, outcomes };
 };

package/dist/store/sqlite/manifest.js

@@ -29,6 +29,8 @@ export const MANIFEST = [
     { name: "20261018024850_version-23-chat-events", version: 23, minCompatible: 1 },
     { name: "20261018061512_version-24-message-stars", version: 24, minCompatible: 1 },
     { name: "20261018063952_version-24-message-stars-index", version: 24, minCompatible: 1 },
+    { name: "20261019115025_version-25-chat-revisions", version: 25, minCompatible: 1 },
+    { name: "20261019115027_version-25-chat-revisions-triggers", version: 25, minCompatible: 1 },
 ];
 export const generatedMigrations = (manifest = MANIFEST, generated = GENERATED) => {
     const migrations = [];

package/dist/store/sqlite/migrations.generated.js

@@ -538,5 +538,21 @@ export const GENERATED = [
         "statements": [
             "CREATE INDEX `messages_starred_by_time` ON `messages` (`chat_id`,\"sent_at\" desc) WHERE starred = 1;"
         ]
+    },
+    {
+        "name": "20261019115025_version-25-chat-revisions",
+        "statements": [
+            "CREATE TABLE `chat_revision_source` (\n\t`id` integer PRIMARY KEY,\n\t`source` text NOT NULL,\n\t`at` integer NOT NULL\n);",
+            "CREATE TABLE `chat_revisions` (\n\t`id` integer PRIMARY KEY,\n\t`chat_id` integer NOT NULL,\n\t`account_id` integer NOT NULL,\n\t`field` text NOT NULL,\n\t`old_value` text,\n\t`new_value` text,\n\t`source` text,\n\t`created_at` integer NOT NULL\n);",
+            "CREATE INDEX `chat_revisions_by_chat_id_created_at` ON `chat_revisions` (`chat_id`,`created_at`);",
+            "CREATE INDEX `chat_revisions_by_account_id_old_value` ON `chat_revisions` (`account_id`,`old_value`) WHERE field = 'external_id';"
+        ]
+    },
+    {
+        "name": "20261019115027_version-25-chat-revisions-triggers",
+        "statements": [
+            "CREATE TRIGGER chat_revisions_au AFTER UPDATE OF external_id, title, membership_state, scope, searchable, parent_chat_id ON chats BEGIN\n  INSERT INTO chat_revisions (chat_id, account_id, field, old_value, new_value, source, created_at)\n  SELECT new.id, new.account_id, f.field, f.old_value, f.new_value, s.source,\n    coalesce(s.at, CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER))\n  FROM (\n    SELECT 'external_id' AS field, old.external_id AS old_value, new.external_id AS new_value\n    UNION ALL SELECT 'title', old.title, new.title\n    UNION ALL SELECT 'membership_state', old.membership_state, new.membership_state\n    UNION ALL SELECT 'scope', old.scope, new.scope\n    UNION ALL SELECT 'searchable', old.searchable, new.searchable\n    UNION ALL SELECT 'parent_chat_id', old.parent_chat_id, new.parent_chat_id\n  ) f\n  LEFT JOIN chat_revision_source s ON s.id = 1\n  WHERE f.old_value IS NOT f.new_value;\nEND;",
+            "CREATE TRIGGER chat_revisions_ad AFTER DELETE ON chats BEGIN\n  DELETE FROM chat_revisions WHERE chat_id = old.id;\nEND;"
+        ]
     }
 ];

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

@@ -4092,6 +4092,201 @@ export declare const pollVotes: import("drizzle-orm/sqlite-core").SQLiteTableWit
     };
     dialect: 'sqlite';
 }>;
+/**
+ * One row per field a chat changed, written by a trigger on `chats` in the changing statement's transaction. No foreign
+ * keys: an older build purges chats without knowing this table, and a trigger drops a purged chat's rows instead.
+ */
+export declare const chatRevisions: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "chat_revisions";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "chat_revisions";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        chatId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "chat_revisions";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        accountId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "chat_revisions";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        field: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "chat_revisions";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        oldValue: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "chat_revisions";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        newValue: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "chat_revisions";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        source: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "chat_revisions";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "chat_revisions";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+    };
+    dialect: 'sqlite';
+}>;
+/** The source and time the `chat_revisions` trigger records, set by the store inside its write and gone by commit. */
+export declare const chatRevisionSource: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "chat_revision_source";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "chat_revision_source";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        source: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "chat_revision_source";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        at: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "chat_revision_source";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+    };
+    dialect: 'sqlite';
+}>;
 /** Changes to who is in a chat, and to its title, for a messenger whose history is pushed to the store. */
 export declare const chatEvents: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
     name: "chat_events";

package/dist/store/sqlite/schema.js

@@ -457,6 +457,31 @@ export const pollVotes = sqliteTable("poll_votes", {
     unique().on(table.chatId, table.messageExternalId, table.identityId),
     index("poll_votes_by_identity_id").on(table.identityId),
 ]);
+/**
+ * One row per field a chat changed, written by a trigger on `chats` in the changing statement's transaction. No foreign
+ * keys: an older build purges chats without knowing this table, and a trigger drops a purged chat's rows instead.
+ */
+export const chatRevisions = sqliteTable("chat_revisions", {
+    id: integer("id").primaryKey(),
+    chatId: integer("chat_id").notNull(),
+    accountId: integer("account_id").notNull(),
+    field: text("field").notNull(),
+    oldValue: text("old_value"),
+    newValue: text("new_value"),
+    source: text("source"),
+    createdAt: integer("created_at").notNull(),
+}, (table) => [
+    index("chat_revisions_by_chat_id_created_at").on(table.chatId, table.createdAt),
+    index("chat_revisions_by_account_id_old_value")
+        .on(table.accountId, table.oldValue)
+        .where(sql `field = 'external_id'`),
+]);
+/** The source and time the `chat_revisions` trigger records, set by the store inside its write and gone by commit. */
+export const chatRevisionSource = sqliteTable("chat_revision_source", {
+    id: integer("id").primaryKey(),
+    source: text("source").notNull(),
+    at: integer("at").notNull(),
+});
 /** Changes to who is in a chat, and to its title, for a messenger whose history is pushed to the store. */
 export const chatEvents = sqliteTable("chat_events", {
     id: integer("id").primaryKey(),

package/dist/store/sync.js

@@ -20,8 +20,10 @@ export const syncStoreOver = (context) => {
         },
         applyDelta: async (key, { chats = [], people = [], members = new Map(), state = {} }) => write(database, () => {
             const accountKey = accountPk(key);
-            for (const chat of chats)
-                chatQueries.upsertChat(context, accountKey, chat);
+            chatQueries.revisedBy(context, "delta", () => {
+                for (const chat of chats)
+                    chatQueries.upsertChat(context, accountKey, chat);
+            });
             for (const person of people)
                 identityPk(accountKey, key.provider, person.id, person.name, person);
             for (const [chatId, ids] of members)

package/package.json

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