@wirecat/cli-core 0.351.0 → 0.353.0

package/CHANGELOG.md

@@ -7,6 +7,61 @@ shape of this file.
 
 ## Unreleased
 
+## 0.353.0 — 19.10.2026
+
+### Changed — may break callers
+
+- **`ChatsStore.leftChats` also names each chat** in a new `left` list (`id`, `title`, `messages`), the ones holding
+  most messages first; with `clear` it is what was deleted. A test that compares its whole answer, such as max-cli's
+  `src/record.test.ts`, adds `left`.
+
+### Added
+
+- **`store clear --left` shows which chats it deletes**: the refusal without `--allow-dangerous` lists the first 20
+  by id, title and message count, and says how many more; the new `--dry-run` answers every one in `left` and
+  deletes nothing, also under `<PREFIX>_READ_ONLY`; the answer after deleting lists what was deleted. The titles go
+  only to the terminal or the JSON answer — the refusal's message, which a scheduled run's `last.json` keeps, holds
+  only the counts.
+
+### Fixed
+
+- **A re-keyed chat keeps the stricter of its two halves' privacy settings** (security). When `rekeyChat` merges a
+  phone-form chat into its LID twin, the merged chat is hidden from search if either half was, and is personal if the
+  halves sit on different sides (`personal` and `work`, after the account's default). A scope either half pinned
+  stays pinned on the merged chat, so a later change to the account's default cannot loosen it. Before, the old row's
+  `searchable` and `scope` always won, so a chat the owner had hidden became searchable again when a stray
+  phone-form row merged into it; wa reaches this at every `wa serve` start. No released code sets either column, so
+  only a store edited by hand could have been affected.
+- **A chat hidden from search stays out of every search that does not name it** (security). A chat with
+  `searchable = 0` was already left out of `search messages`, `search all`, rankings and statistics, but still came
+  back from `store.messages.search` and `find` (the plain text and sender search, also behind `bot people`, person
+  context and botcheck), `mentioning`, and the meaning half of `conversations search`, `conversations related` and
+  the picture search; the search answers also listed it in their readiness and "embedded only with another model"
+  lists. Each now leaves it out unless the call names the chat, as the Lucene search does. A sender-only `find`
+  therefore no longer counts the hidden chat's messages. No released code sets `searchable = 0`, so only a store
+  edited by hand was affected.
+
+## 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/archive-commands.js

@@ -1,7 +1,7 @@
 import { writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { Readable } from "node:stream";
-import { CliError } from "@wirecat/cli-base";
+import { CliError, singleLine } from "@wirecat/cli-base";
 import { annotate } from "@wirecat/cli-base/commands";
 import { Command } from "commander";
 import { toMarkdown } from "../../render/markdown.js";
@@ -46,29 +46,52 @@ const statusCommand = (messenger) => annotate(new Command("status"), { effects:
     if (rows.length === 0 && context.format === "pretty")
         context.renderer.note("the store holds no messages for this profile yet");
 });
+const LISTED = 20;
+/** Titles are the owner's: these lines go to a person's terminal, never into an error message. */
+const leftLines = (left) => {
+    const shown = left.slice(0, LISTED);
+    const width = shown.reduce((widest, { id }) => Math.max(widest, id.length), 0);
+    return [
+        ...shown.map(({ id, title, messages }) => `  ${id.padEnd(width)}  ${title === null ? "(no title)" : singleLine(title)}  ${messages}`),
+        ...(left.length > shown.length
+            ? [`  and ${left.length - shown.length} more — --dry-run --json lists every one`]
+            : []),
+    ];
+};
 /**
  * Deletes from the store, which is the archive: only what `--left` names, and only with
  * `--allow-dangerous`, since a chat the account left cannot be fetched again. Emptying the whole
- * store is not offered.
+ * store is not offered. The refusal names the chats to a person but keeps them out of its message,
+ * which a scheduled run's `last.json` keeps.
  */
 const clearCommand = (messenger) => annotate(new Command("clear"), { effects: LOCAL_WRITE, mcp: false })
     .description("delete from the store the chats this account has left, with their messages")
     .option("--left", "the chats this account has left — the only thing this clears")
     .option("--allow-dangerous", "yes, delete — it cannot be undone, and a chat you left cannot be fetched again")
+    .option("--dry-run", "list the chats it would delete, and delete nothing")
     .action(async function () {
-    const { left, allowDangerous } = this.opts();
+    const { left, allowDangerous, dryRun } = this.opts();
     if (!left) {
         throw new CliError("validation_error", "say what to clear: --left, the chats this account has left — emptying the whole store is not offered");
     }
     const context = messengerContext(this, messenger);
     const found = await context.withServices((services) => services.archive.left());
+    const pretty = context.format === "pretty";
+    if (dryRun) {
+        renderAnswer(this, context, itemOf(snakeKeys({ cleared: false, dryRun: true, ...found })));
+        return;
+    }
     if (found.chats > 0 && !allowDangerous) {
+        // Not a note: --quiet drops notes, and this list is what the owner confirms.
+        if (pretty)
+            for (const line of ["it would delete these chats — id, title, messages:", ...leftLines(found.left)])
+                context.streams.diagnostic(line);
         throw new CliError("confirmation_required", `this deletes ${found.chats} chat(s) this account has left and their ${found.messages} message(s) ` +
-            "from the store, and it cannot be undone — add --allow-dangerous to go ahead");
+            "from the store, and it cannot be undone — --dry-run lists them; add --allow-dangerous to go ahead");
     }
     const cleared = found.chats > 0 ? await context.withServices((services) => services.archive.left({ clear: true })) : found;
     renderAnswer(this, context, itemOf(snakeKeys({ cleared: cleared.chats > 0, ...cleared })));
-    if (context.format !== "pretty")
+    if (!pretty)
         return;
     if (cleared.chats === 0)
         context.renderer.note("the store holds no chats this account has left");

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/services/archive.d.ts

@@ -1,6 +1,7 @@
 import type { ChatKind, Id, Message } from "../domain/models.js";
 import type { ActionableError } from "../domain/recovery.js";
 import type { Fetching } from "../ports/traits.js";
+import type { LeftChats } from "../store/chats.js";
 import { type AccountKey, type ChatStats, type MessageStore, type Range } from "../store/store.js";
 import { type Estimate } from "./backfill-estimate.js";
 import { batchProgress } from "./batch.js";
@@ -135,10 +136,7 @@ export interface ArchiveService {
     /** The chats this account has left, with their messages; `clear` deletes them. From the store alone. */
     left(options?: {
         clear?: boolean;
-    }): Promise<{
-        chats: number;
-        messages: number;
-    }>;
+    }): Promise<LeftChats>;
 }
 export declare const archiveService: (deps: ServiceDeps) => ArchiveService;
 /** One page of a chat's history, newest first, older than `before` when it is given. */

package/dist/services/embeddings-maintenance.d.ts

@@ -36,7 +36,7 @@ export declare const embeddingTarget: (deps: ServiceDeps, choice?: ModelChoice)
         apart?: boolean;
     }) => Promise<Embedder>;
 };
-export declare const readinessOf: (deps: ServiceDeps, chatId: Id | undefined, key: string) => Promise<ChatReadiness[]>;
+export declare const readinessOf: (deps: ServiceDeps, chatId: Id | undefined, key: string, searchableOnly?: boolean) => Promise<ChatReadiness[]>;
 type EmbeddingTarget = ReturnType<typeof embeddingTarget>;
 /** The server's warm model when there is one, kept open after; otherwise opened here and closed. */
 export declare const withEmbedder: <T>(deps: ServiceDeps, target: EmbeddingTarget, choice: ModelChoice | undefined, { threads }: {

package/dist/services/embeddings-maintenance.js

@@ -57,10 +57,10 @@ export const embeddingTarget = (deps, choice = DEFAULT_TEXT_MODEL) => {
         },
     };
 };
-export const readinessOf = async (deps, chatId, key) => {
+export const readinessOf = async (deps, chatId, key, searchableOnly = false) => {
     const store = await deps.store();
     const account = await deps.account();
-    return (await store.vectors.readiness(account, { ...(chatId === undefined ? {} : { chatId }), model: key })).map(shaped);
+    return (await store.vectors.readiness(account, { ...(chatId === undefined ? {} : { chatId }), model: key, searchableOnly })).map(shaped);
 };
 /** The server's warm model when there is one, kept open after; otherwise opened here and closed. */
 export const withEmbedder = async (deps, target, choice, { threads }, work) => {

package/dist/services/embeddings-search.js

@@ -191,7 +191,7 @@ export const embeddingsSearch = (deps) => {
                     .filter(({ account }) => account.provider === one.provider && account.account === one.account)
                     .map(({ chat }) => chat);
                 const rows = eligibleChats === undefined
-                    ? await store.vectors.readiness(one, { ...scope, model: target.key })
+                    ? await store.vectors.readiness(one, { ...scope, model: target.key, searchableOnly: true })
                     : (await Promise.all(eligibleChats.map((chatId) => store.vectors.readiness(one, { chatId, model: target.key })))).flat();
                 const readiness = searchReadiness(rows.map(shaped), target.installed, words.outside.get(JSON.stringify(one))?.chats ?? new Set());
                 scoped.push({ source: one, readiness });
@@ -261,7 +261,7 @@ export const embeddingsSearch = (deps) => {
                 hits: hits
                     .slice(0, limit)
                     .map(({ summary, chunk, score, stale }) => ({ summary, chunk, score, by: ["meaning"], stale })),
-                readiness: searchReadiness(await readinessOf(deps, undefined, target.key), true, new Set()),
+                readiness: searchReadiness(await readinessOf(deps, undefined, target.key, true), true, new Set()),
             };
         },
     };

package/dist/store/chats.d.ts

@@ -1,11 +1,18 @@
 import type { ChannelTagMatch } from "../domain/channel-tags.js";
 import type { Chat, ChatKind, ChatUpdate, Id, Page } from "../domain/models.js";
 import { type ChatRekey } from "./sqlite/chat-rekey.js";
-import type { ChatMetadata } from "./sqlite/chats.js";
+import type { ChatMetadata, LeftChat } from "./sqlite/chats.js";
 import type { ChatCompleteness } from "./sqlite/completeness.js";
 import type { StoreContext } from "./sqlite/open.js";
 import type { Where } from "./sqlite/query-filter.js";
 import type { AccountKey, ChatActivity, ChatStats, StoredChatFilter } from "./types.js";
+export type { LeftChat };
+/** The chats marked left: how many, the messages they hold, and each one. */
+export interface LeftChats {
+    chats: number;
+    messages: number;
+    left: LeftChat[];
+}
 export interface ChatsStore {
     saveChats(key: AccountKey, chats: ChatUpdate[]): Promise<void>;
     /** Newest first. `query` matches three letters or more of a title; `unread` keeps chats with unread messages. */
@@ -17,23 +24,28 @@ 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.
      */
     rekeyChat(key: AccountKey, from: Id, to: Id): Promise<ChatRekey>;
-    /** The chats marked left and the messages they hold; with `clear`, deletes them and all under them. */
+    /**
+     * The chats marked left and the messages they hold, each named in `left`; with `clear`, deletes them and all under
+     * them — `left` is then what was deleted.
+     */
     leftChats(key: AccountKey, options?: {
         clear?: boolean;
-    }): Promise<{
-        chats: number;
-        messages: number;
-    }>;
+    }): Promise<LeftChats>;
     /** Per chat: whether its history is held up to date, without gaps, back to its start. */
     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. */

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)
@@ -48,14 +52,14 @@ export const chatsStoreOver = (context) => {
         leftChats: async (key, { clear = false } = {}) => {
             const accountKey = findAccountPk(key);
             if (accountKey === undefined)
-                return { chats: 0, messages: 0 };
-            let found = { pks: [], messages: 0 };
+                return { chats: 0, messages: 0, left: [] };
+            let found = { pks: [], chats: [], messages: 0 };
             write(database, () => {
                 found = chatQueries.leftChats(context, accountKey);
                 if (clear)
                     chatQueries.purgeChats(context, found.pks);
             });
-            return { chats: found.pks.length, messages: found.messages };
+            return { chats: found.pks.length, messages: found.messages, left: found.chats };
         },
         chatCompleteness: async (key, chatIds) => {
             const accountKey = findAccountPk(key);

package/dist/store/exports.d.ts

@@ -2,7 +2,7 @@ export type { CounterField, CounterObservations, CounterState } from "../domain/
 export type { RetentionOptions } from "../domain/retention.js";
 export type { AccountAccounts, AccountsStore } from "./accounts.js";
 export type { AccountAttachments, AttachmentsStore } from "./attachments.js";
-export type { ChatsStore } from "./chats.js";
+export type { ChatsStore, LeftChat, LeftChats } from "./chats.js";
 export type { ConversationsStore } from "./conversations.js";
 export type { AccountCounters, CountersStore } from "./counters.js";
 export type { AccountMentions, MentionsStore } from "./mentions.js";

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

@@ -143,6 +143,24 @@ const latest = (a, b) => {
     const [one, other] = [time(a), time(b)];
     return one === null ? other : other === null ? one : Math.max(one, other);
 };
+/**
+ * The owner's word on a chat must not loosen because a stray twin merged in: 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
+ * preparation a personal one does not. A scope either half pinned stays pinned, so a later change to the account's
+ * default cannot loosen the merged chat.
+ */
+const strictest = (context, accountKey, old, twin) => {
+    const account = context.database.prepare("SELECT scope FROM accounts WHERE id = ?").get(accountKey);
+    const effective = (row) => scalar(row.scope) ?? scalar(account?.scope);
+    return {
+        searchable: Math.min(Number(old.searchable), Number(twin.searchable)),
+        scope: scalar(old.scope) === null && scalar(twin.scope) === null
+            ? null
+            : effective(old) === effective(twin)
+                ? effective(old)
+                : "personal",
+    };
+};
 const MESSENGER_FIELDS = [
     "title",
     "unread_count",
@@ -166,6 +184,7 @@ export const rekeyChat = (context, key, accountKey, from, to) => {
     if (twin) {
         if (old.kind !== twin.kind && old.kind !== "unknown" && twin.kind !== "unknown")
             throw new CliError("validation_error", `a ${String(old.kind)} and a ${String(twin.kind)} are not one chat`);
+        const strict = strictest(context, accountKey, old, twin);
         moved = absorb(context, kept, Number(twin.id));
         const fields = MESSENGER_FIELDS.map((field) => `${field} = coalesce(?, ${field})`).join(", ");
         context.database
@@ -173,8 +192,8 @@ export const rekeyChat = (context, key, accountKey, from, to) => {
         // Left only when both were: a complete chat list that named the new id before the re-key marked the old one.
         `UPDATE chats SET ${fields}, kind = CASE WHEN kind = 'unknown' THEN ? ELSE kind END,
            membership_state = CASE WHEN ? IS NULL THEN nullif(membership_state, 'left') ELSE coalesce(nullif(?, 'left'), membership_state) END,
-           last_message_at = ?, updated_at = ? WHERE id = ?`)
-            .run(...MESSENGER_FIELDS.map((field) => scalar(twin[field])), scalar(twin.kind), scalar(twin.membership_state), scalar(twin.membership_state), latest(old.last_message_at, twin.last_message_at), context.now(), kept);
+           searchable = ?, scope = ?, last_message_at = ?, updated_at = ? WHERE id = ?`)
+            .run(...MESSENGER_FIELDS.map((field) => scalar(twin[field])), scalar(twin.kind), scalar(twin.membership_state), scalar(twin.membership_state), strict.searchable, strict.scope, latest(old.last_message_at, twin.last_message_at), context.now(), kept);
     }
     context.database.prepare("UPDATE chats SET external_id = ?, updated_at = ? WHERE id = ?").run(to, context.now(), kept);
     renameText(context, key, accountKey, from, to);

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

@@ -11,11 +11,23 @@ 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;
-/** The chats marked left, and how many messages they hold. */
+/** 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;
+/** A chat marked left: its id, its title, and how many messages it holds. */
+export interface LeftChat {
+    id: Id;
+    title: string | null;
+    messages: number;
+}
+/** The chats marked left, the ones holding the most messages first, and how many messages they hold. */
 export declare const leftChats: ({ orm }: StoreContext, accountKey: number) => {
     pks: number[];
+    chats: LeftChat[];
     messages: number;
 };
 /** These chats and everything under them, children before parents: the foreign keys are enforced. */

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,25 +111,48 @@ 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;
-/** The chats marked left, and how many messages they hold. */
+/**
+ * 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, the ones holding the most messages first, and how many messages they hold. */
 export const leftChats = ({ orm }, accountKey) => {
-    const pks = orm
-        .select({ pk: chats.id })
+    const found = orm
+        .select({ pk: chats.id, id: chats.externalId, title: chats.title })
         .from(chats)
         .where(and(eq(chats.accountId, accountKey), eq(chats.membershipState, "left")))
-        .all()
-        .map(({ pk }) => pk);
-    const count = pks.length === 0
-        ? 0
-        : Number(orm.select({ n: sql `count(*)` }).from(messages).where(inArray(messages.chatId, pks)).get()?.n);
-    return { pks, messages: count };
+        .all();
+    const pks = found.map(({ pk }) => pk);
+    const counts = new Map(pks.length === 0
+        ? []
+        : orm
+            .select({ pk: messages.chatId, n: sql `count(*)` })
+            .from(messages)
+            .where(inArray(messages.chatId, pks))
+            .groupBy(messages.chatId)
+            .all()
+            .map(({ pk, n }) => [pk, Number(n)]));
+    const left = found
+        .map(({ pk, id, title }) => ({ id, title, messages: counts.get(pk) ?? 0 }))
+        .sort((a, b) => b.messages - a.messages || a.id.localeCompare(b.id));
+    return { pks, chats: left, messages: left.reduce((sum, chat) => sum + chat.messages, 0) };
 };
 /** These chats and everything under them, children before parents: the foreign keys are enforced. */
 export const purgeChats = ({ orm }, pks) => {

package/dist/store/sqlite/image-chunks.js

@@ -77,7 +77,7 @@ export const nearestImages = ({ orm }, accountPk, { chatKey, model, since, limit
           JOIN embeddings v ON v.model = ${model} AND v.content_hash = k.content_hash
         WHERE k.chunkable_type = 'image' AND k.position = ${position} AND ch.account_id = ${accountPk}
           AND k.id > ${after}
-          ${chatKey === undefined ? sql `` : sql `AND m.chat_id = ${chatKey}`}
+          ${chatKey === undefined ? sql `AND ch.searchable = 1` : sql `AND m.chat_id = ${chatKey}`}
           ${since === undefined ? sql `` : sql `AND k.occurred_at >= ${since}`}
         ORDER BY k.id LIMIT ${SCAN_PAGE}`);
         for (const row of rows)

package/dist/store/sqlite/person-links.js

@@ -1,7 +1,7 @@
 import { CliError } from "@wirecat/cli-base";
 import { and, eq, inArray, isNull, sql } from "./drizzle/core.js";
 import { resolvePersonLinks } from "./person-resolution.js";
-import { accountIdentities, accounts, identities, identityLinkEvents, identityLinks, messages, persons, } from "./schema.js";
+import { accountIdentities, accounts, chats, identities, identityLinkEvents, identityLinks, messages, persons, } from "./schema.js";
 import { hitsWhere } from "./search.js";
 const identityRow = ({ orm }, { provider, id }) => orm
     .select({ pk: identities.id, personPk: identityLinks.personId })
@@ -159,7 +159,7 @@ export const unlinkIdentity = (context, ref, options) => {
 export const mentioning = (context, accountKey, { id, username }, limit) => {
     const byId = sql `EXISTS (SELECT 1 FROM json_each(${messages.mentions}) WHERE json_each.value = ${id})`;
     const byHandle = username === null ? undefined : sql `instr(lower(${messages.text}), ${`@${username.toLowerCase()}`}) > 0`;
-    const where = and(eq(messages.accountId, accountKey), isNull(messages.deletedAt), byHandle ? sql `(${byId} OR ${byHandle})` : byId);
+    const where = and(eq(messages.accountId, accountKey), eq(chats.searchable, 1), isNull(messages.deletedAt), byHandle ? sql `(${byId} OR ${byHandle})` : byId);
     // instr finds "@ana" inside "@anastasia" too; the word boundary is checked here.
     const handle = username === null ? undefined : new RegExp(`@${escaped(username)}(?![\\p{L}\\p{N}_])`, "iu");
     const page = hitsWhere(context, where, limit);

package/dist/store/sqlite/search.js

@@ -35,7 +35,7 @@ export const matching = (context, { provider, account, accounts: within, senders
     const ids = senders?.length ? [...new Set(senders)] : undefined;
     return and(isNull(messages.deletedAt), trimmed
         ? sql `${messages.id} IN (SELECT rowid FROM messages_fts WHERE messages_fts MATCH ${wordsOf(trimmed)})`
-        : undefined, scopeProvider === undefined ? undefined : eq(accounts.provider, scopeProvider), account ? eq(accounts.externalId, account.account) : undefined, within ? inArray(accounts.externalId, within) : undefined, chatId === undefined ? undefined : eq(chats.externalId, chatId), ids ? and(eq(identities.provider, accounts.provider), inArray(identities.externalId, ids)) : undefined, ids && together ? inArray(messages.chatId, everyoneWrote(context, ids, scopeProvider)) : undefined);
+        : undefined, scopeProvider === undefined ? undefined : eq(accounts.provider, scopeProvider), account ? eq(accounts.externalId, account.account) : undefined, within ? inArray(accounts.externalId, within) : undefined, chatId === undefined ? eq(chats.searchable, 1) : eq(chats.externalId, chatId), ids ? and(eq(identities.provider, accounts.provider), inArray(identities.externalId, ids)) : undefined, ids && together ? inArray(messages.chatId, everyoneWrote(context, ids, scopeProvider)) : undefined);
 };
 /** The chats where every one of `ids` has a message — the outer row's provider when no scope names one. */
 const everyoneWrote = ({ orm }, ids, scopeProvider) => {

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

@@ -86,7 +86,7 @@ export declare const embeddedOnlyElsewhere: ({ orm }: StoreContext, accountPk: n
 /** The messenger's ids of these messages, by pk. */
 export declare const messageIds: ({ orm }: StoreContext, pks: number[]) => Map<number, string>;
 /** Chats of the account whose conversations were ever built, or started to be. */
-export declare const builtChats: ({ orm }: StoreContext, accountPk: number) => {
+export declare const builtChats: ({ orm }: StoreContext, accountPk: number, searchableOnly?: boolean) => {
     chatKey: number;
     id: string;
 }[];

package/dist/store/sqlite/vectors.js

@@ -173,7 +173,7 @@ export const nearestChunks = ({ orm }, accountPk, { chatKey, model, since, limit
           ${projectId === undefined ? sql `` : sql `AND k.project_id=${projectId}`}
           ${before === undefined ? sql `` : sql `AND k.occurred_at < ${before}`}
           ${personId === undefined ? sql `` : sql `AND EXISTS (SELECT 1 FROM conversation_messages pcm JOIN messages pm ON pm.id=pcm.message_id JOIN identity_links pil ON pil.identity_id=pm.sender_identity_id WHERE pcm.conversation_id=c.id AND pil.person_id=${personId})`}
-          ${chatKey === undefined ? sql `` : sql `AND c.chat_id = ${chatKey}`}
+          ${chatKey === undefined ? sql `AND ch.searchable = 1` : sql `AND c.chat_id = ${chatKey}`}
           ${since === undefined ? sql `` : sql `AND k.occurred_at >= ${since}`}
           ${exclude === undefined ? sql `` : sql `AND c.id <> ${exclude}`}
           ${conversations === undefined ? sql `` : sql `AND c.id IN (SELECT value FROM json_each(${JSON.stringify(conversations)}))`}
@@ -215,7 +215,7 @@ export const embeddedOnlyElsewhere = ({ orm }, accountPk, { chatKey, model }) =>
         return [];
     return orm
         .all(sql `SELECT ch.external_id AS id FROM chats ch
-        WHERE ch.account_id = ${accountPk} ${chatKey === undefined ? sql `` : sql `AND ch.id = ${chatKey}`}
+        WHERE ch.account_id = ${accountPk} ${chatKey === undefined ? sql `AND ch.searchable = 1` : sql `AND ch.id = ${chatKey}`}
           AND ${hasVectorOf(sql `IN (${sql.join(others, sql `, `)})`)}
           AND NOT ${hasVectorOf(sql `= ${model}`)}
         ORDER BY ch.external_id`)
@@ -228,8 +228,8 @@ export const messageIds = ({ orm }, pks) => new Map(pks.length === 0
         .all(sql `SELECT id AS pk, external_id AS id FROM messages WHERE id IN (${sql.join(pks.map((pk) => sql `${pk}`), sql `, `)})`)
         .map(({ pk, id }) => [pk, id]));
 /** Chats of the account whose conversations were ever built, or started to be. */
-export const builtChats = ({ orm }, accountPk) => orm.all(sql `SELECT ch.id AS chatKey, ch.external_id AS id FROM conversation_state s JOIN chats ch ON ch.id = s.chat_id
-      WHERE ch.account_id = ${accountPk} ORDER BY ch.external_id`);
+export const builtChats = ({ orm }, accountPk, searchableOnly = false) => orm.all(sql `SELECT ch.id AS chatKey, ch.external_id AS id FROM conversation_state s JOIN chats ch ON ch.id = s.chat_id
+      WHERE ch.account_id = ${accountPk} ${searchableOnly ? sql `AND ch.searchable = 1` : sql ``} ORDER BY ch.external_id`);
 /** Group chats of the account with stored messages and no build ever started, the newest message first. */
 export const unbuiltGroups = ({ orm }, accountPk) => orm
     .all(sql `SELECT ch.external_id AS id FROM chats ch

package/dist/store/vectors.d.ts

@@ -82,11 +82,13 @@ export interface AccountVectors {
     }>;
     /**
      * How fresh each built chat's conversations and `model`'s vectors are — one chat, or every chat whose
-     * conversations were ever built. A chat never built answers `builtAt: null`.
+     * conversations were ever built. A chat never built answers `builtAt: null`. `searchableOnly` leaves out the chats
+     * the owner hid from searches that do not name them.
      */
     readiness(key: AccountKey, options: {
         chatId?: Id;
         model: string;
+        searchableOnly?: boolean;
     }): Promise<StoredReadiness[]>;
     /** Group chats with stored messages whose conversations were never built, the newest message first. */
     unbuiltGroups(key: AccountKey): Promise<Id[]>;

package/dist/store/vectors.js

@@ -176,12 +176,12 @@ export const accountVectorsOver = (context, mail) => {
             }
             return vectors.conversationVectors(context, pk, model);
         },
-        readiness: async (key, { chatId, model }) => {
+        readiness: async (key, { chatId, model, searchableOnly = false }) => {
             const accountPk = findAccountPk(key);
             if (accountPk === undefined)
                 return [];
             const chats = chatId === undefined
-                ? vectors.builtChats(context, accountPk)
+                ? vectors.builtChats(context, accountPk, searchableOnly)
                 : [{ chatKey: chatKeyOf(key, chatId), id: chatId }].flatMap(({ chatKey, id }) => chatKey === undefined ? [] : [{ chatKey, id }]);
             return chats.map(({ chatKey, id }) => {
                 const found = vectors.readiness(context, chatKey, model);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.351.0",
+  "version": "0.353.0",
   "description": "The messenger-neutral half of a messaging CLI: domain model, message locators, rendering, name resolution, the SQLite seam, the command skeleton and shared read commands, the send guard, run records and the message store",
   "license": "Apache-2.0",
   "author": "Viacheslav Ptsarev",

package/parity.json

@@ -4401,6 +4401,7 @@
       "in": "all",
       "options": {
         "--allow-dangerous": "all",
+        "--dry-run": "all",
         "--left": "all"
       }
     },