@wirecat/cli-core 0.365.0 → 0.366.0

package/CHANGELOG.md

@@ -7,6 +7,17 @@ shape of this file.
 
 ## Unreleased
 
+## 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/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/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/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.366.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",