@wirecat/cli-core 0.351.0 → 0.352.0

package/CHANGELOG.md

@@ -7,6 +7,27 @@ shape of this file.
 
 ## Unreleased
 
+## 0.352.0 — 19.10.2026
+
+### Changed — may break callers
+
+- **A saved chat keeps its membership when the update leaves it out**: `saveChats`, `Delta.chats` and
+  `HistoryBatch.chats` no longer take a "left" mark off a chat that comes without `membershipState`. So a late
+  community notice for a group the owner left no longer marks it rejoined. A value sets the membership; `null`
+  (newly allowed on `ChatUpdate`) clears it. A page of the adapter's `chats`, complete or not, still rejoins the
+  chats it names, through `markChatsLeft` (now also takes the mark off the chats its complete list names) or the new
+  `rejoinChats`; other states such as "archived" are kept. A client that saves its own chat list must call
+  `rejoinChats(key, ids)` for a list that is not complete, or a chat the owner rejoined stays hidden from stored
+  reads until the next complete one. **max-cli must do this in the bump that takes this version**: in
+  `rememberChats` (`src/record.ts`), `else await db.chats.rejoinChats(key, ids)`; without it a chat rejoined while
+  the session list is cut stays "left", is hidden from `max chats list`, and `archive clear --left` deletes it.
+  A caller that learns of a rejoin any other way sends `membershipState: null`.
+
+### Added
+
+- **`ChatsStore.rejoinChats(key, ids)`** takes the "left" mark off the chats a messenger's chat list names, from any
+  page of it, and says how many.
+
 ## 0.351.0 — 19.10.2026
 
 ### Added

package/dist/cli/messenger/stored.js

@@ -186,8 +186,11 @@ export const stored = (messenger, { account, store, warn, events, pending, annou
                     const complete = window.offset === 0 && !page.hasMore && page.items.length > 0;
                     await save("chats.list", async (opened) => {
                         await opened.chats.saveChats(account, page.items);
+                        const ids = page.items.map((chat) => chat.id);
                         if (complete)
-                            await opened.chats.markChatsLeft(account, page.items.map((chat) => chat.id));
+                            await opened.chats.markChatsLeft(account, ids);
+                        else
+                            await opened.chats.rejoinChats(account, ids);
                     });
                     return page;
                 },

package/dist/domain/models.d.ts

@@ -47,11 +47,13 @@ export interface Chat {
     providerMetadata?: ProviderMetadata;
 }
 /**
- * A chat as an adapter saves it. A `title`, `unreadCount`, `lastMessageAt` or `participantsCount` left out keeps the
- * stored value; `null` stores none. So a push that knows only some of them, such as a notice that a group left its
- * community, leaves the rest out.
+ * A chat as an adapter saves it. A `title`, `unreadCount`, `lastMessageAt`, `participantsCount` or `membershipState`
+ * left out keeps the stored value; `null` stores none. So a push that knows only some of them, such as a notice that
+ * a group left its community, leaves the rest out.
  */
-export type ChatUpdate = Omit<Chat, KeptFields> & Partial<Pick<Chat, KeptFields>>;
+export type ChatUpdate = Omit<Chat, KeptFields | "membershipState"> & Partial<Pick<Chat, KeptFields>> & {
+    membershipState?: MembershipState | null;
+};
 type KeptFields = "title" | "unreadCount" | "lastMessageAt" | "participantsCount";
 /** A group's switches; `null` where the messenger does not say, or has no such switch. */
 export interface GroupSettings {

package/dist/store/chats.d.ts

@@ -17,11 +17,16 @@ export interface ChatsStore {
     /** The chats a person is in, newest first — as far as the saved member lists go. */
     chatsWith(key: AccountKey, memberId: Id): Promise<Chat[]>;
     /**
-     * Given every chat the account is in, marks the rest `left` and says how many it marked. Only
-     * ever from a complete list: a page or a cut list says nothing about the chats it leaves out.
+     * Given every chat the account is in, marks the rest `left`, takes the mark off those it names, and says how many
+     * it marked. Only ever from a complete list: a page or a cut list says nothing about the chats it leaves out.
      * Remembers when, so a search can say the store knows the account's whole chat list.
      */
     markChatsLeft(key: AccountKey, present: Id[]): Promise<number>;
+    /**
+     * Takes the `left` mark off the chats a messenger's own chat list names, from any page of it: the list holds only
+     * chats the account is in. Other states are kept. Says how many it took the mark off.
+     */
+    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.

package/dist/store/chats.js

@@ -39,6 +39,10 @@ export const chatsStoreOver = (context) => {
             });
             return marked;
         },
+        rejoinChats: async (key, present) => {
+            const accountKey = findAccountPk(key);
+            return accountKey === undefined ? 0 : write(database, () => chatQueries.rejoin(context, accountKey, present));
+        },
         rekeyChat: async (key, from, to) => {
             const accountKey = findAccountPk(key);
             if (accountKey === undefined)

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

@@ -11,8 +11,13 @@ export declare const upsertChat: (context: StoreContext, accountKey: number, cha
 /** Replaces who is in the chat, whole. */
 export declare const writeMembers: (context: StoreContext, key: AccountKey, accountKey: number, chatId: Id, memberIds: Id[]) => void;
 export declare const members: ({ orm }: StoreContext, chatKey: number) => Member[];
-/** Marks this account's chats that `present` does not name; only ever given a complete list. */
-export declare const markLeft: ({ orm }: StoreContext, accountKey: number, present: Id[]) => number;
+/** Takes the left mark off the chats `present` names; any other state is kept. Answers how many. */
+export declare const rejoin: ({ orm }: StoreContext, accountKey: number, present: Id[]) => number;
+/**
+ * Marks this account's chats that `present` does not name, and rejoins those it names. Only ever given a complete
+ * list. Answers how many it marked.
+ */
+export declare const markLeft: (context: StoreContext, accountKey: number, present: Id[]) => number;
 /** The chats marked left, and how many messages they hold. */
 export declare const leftChats: ({ orm }: StoreContext, accountKey: number) => {
     pks: number[];

package/dist/store/sqlite/chats.js

@@ -65,9 +65,7 @@ export const upsertChat = (context, accountKey, chat) => {
             ...(chat.lastMessageAt === undefined ? {} : { lastMessageAt: sql `excluded.last_message_at` }),
             ...(chat.participantsCount === undefined ? {} : { participantsCount: sql `excluded.participants_count` }),
             metadata: sql `excluded.metadata`,
-            // A chat the list names again has been rejoined; any other state it had is kept.
-            membershipState: sql `CASE WHEN excluded.membership_state IS NOT NULL THEN excluded.membership_state
-          WHEN ${chats.membershipState} = 'left' THEN NULL ELSE ${chats.membershipState} END`,
+            ...(chat.membershipState === undefined ? {} : { membershipState: sql `excluded.membership_state` }),
             updatedAt: sql `excluded.updated_at`,
         },
     })
@@ -113,13 +111,27 @@ export const members = ({ orm }, chatKey) => orm
     .all();
 const byRecency = [sql `${chats.lastMessageAt} DESC NULLS LAST`, chats.id];
 const notLeft = sql `${chats.membershipState} IS NOT 'left'`;
-/** Marks this account's chats that `present` does not name; only ever given a complete list. */
-export const markLeft = ({ orm }, accountKey, present) => orm
+const named = (present) => sql `${chats.externalId} IN (SELECT value FROM json_each(${JSON.stringify(present)}))`;
+/** Takes the left mark off the chats `present` names; any other state is kept. Answers how many. */
+export const rejoin = ({ orm }, accountKey, present) => orm
     .update(chats)
-    .set({ membershipState: "left" })
-    .where(and(eq(chats.accountId, accountKey), notLeft, sql `${chats.externalId} NOT IN (SELECT value FROM json_each(${JSON.stringify(present)}))`))
+    .set({ membershipState: null })
+    .where(and(eq(chats.accountId, accountKey), eq(chats.membershipState, "left"), named(present)))
     .returning({ pk: chats.id })
     .all().length;
+/**
+ * Marks this account's chats that `present` does not name, and rejoins those it names. Only ever given a complete
+ * list. Answers how many it marked.
+ */
+export const markLeft = (context, accountKey, present) => {
+    rejoin(context, accountKey, present);
+    return context.orm
+        .update(chats)
+        .set({ membershipState: "left" })
+        .where(and(eq(chats.accountId, accountKey), notLeft, sql `NOT (${named(present)})`))
+        .returning({ pk: chats.id })
+        .all().length;
+};
 /** The chats marked left, and how many messages they hold. */
 export const leftChats = ({ orm }, accountKey) => {
     const pks = orm

package/package.json

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