@wirecat/cli-core 0.358.0 → 0.360.0

package/CHANGELOG.md

@@ -5,6 +5,36 @@ Notable changes to `@wirecat/cli-core` (`@wirecat/cli-messaging` up to 0.261.0,
 minor version may break callers, and says how under "Changed — may break callers". `pnpm docs:check` checks the
 shape of this file.
 
+## Unreleased
+
+## 0.360.0 — 19.10.2026
+
+### Added
+
+- **Adapter test authors can shorten a connection's close wait and re-key pauses.** The run environment takes
+  `closeWaitMs` (how long a connection's close waits on its saves and passive listens, 5 s by default) and
+  `rekeyPacing` (`{ lockMs, pauseMs }` for chat re-keys, 50 ms and 25 ms by default). Commands, the shared services and
+  the MCP server's tool calls pass them on; a command `serve` runs for a client through its relay keeps the
+  defaults. A test through `run()` no longer pays the real waits. Only code
+  that builds the environment can set them; no flag, variable or MCP call does
+  ([ADAPTERS.md](docs/dev/ADAPTERS.md#running-the-contract-cases)).
+
+## 0.359.0 — 19.10.2026
+
+### Fixed
+
+- **The first `serve` after an upgrade no longer locks other commands out of the store while it re-keys chats.**
+  A pushed batch's `rekeys` were saved one transaction each, back to back, so another command waited for the write
+  lock as long as the re-keys ran: up to 3.4 s for 5,000 re-keys on a synthetic 10,000-chat store. They now go
+  through the new `store.chats.rekeyChats` in passes of one transaction, each holding the lock for about 50 ms with
+  a pause after it. Each re-key keeps its own savepoint, privacy merge and account scope, and a refused one still
+  warns and leaves the others applied. Once the store is about to close (`Saving.closing`, which `connected`
+  aborts) or refuses a whole pass (closed, busy past its timeout), every re-key still queued, in any batch, is given
+  up with one warning: "N chat re-keys not applied yet; the next serve applies them", and one
+  `rekeys_not_applied` event whose new `counts` field (`WarningEvent.counts`) holds N. Before, a messenger that sends
+  each re-key as its own batch (wa) got one `store_not_written` per chat left. `ChatsStore` gains `rekeyChats`, so a
+  hand-written `ChatsStore` must add it.
+
 ## 0.358.0 — 19.10.2026
 
 ### Added

package/dist/cli/context.d.ts

@@ -35,6 +35,13 @@ export interface BaseEnvironment {
     recognizer?: OpenRecognizer;
     /** How long `store restore` and `store reset` wait on another connection's write, 1 s unless a test hands one in. */
     storeLockWaitMs?: number;
+    /** How long a connection's close waits on its saves and passive listens, 5 s unless a test hands one in. */
+    closeWaitMs?: number;
+    /** How long one pass of chat re-keys holds the store's write lock and the pause after it; tests hand in zeros. */
+    rekeyPacing?: {
+        lockMs: number;
+        pauseMs: number;
+    };
     /** Where raw bytes go when stdout is not this process's own — an MCP session relayed by serve. */
     stdout?: NodeJS.WritableStream;
     /** Where a prompt and what is typed at it go, in place of the process's stderr; tests hand one in. */

package/dist/cli/messenger/context.d.ts

@@ -8,7 +8,7 @@ import { type PermissionKey } from "../../sends/permissions.js";
 import { type ServiceMessenger, type Services } from "../../services/index.js";
 import type { OpenRecognizer } from "../../speech/transcribe.js";
 import { type AccountKey, type DeletionScope, type MessageStore } from "../../store/store.js";
-import { type BaseContext } from "../context.js";
+import { type BaseContext, type BaseEnvironment } from "../context.js";
 import { type PermissionKeyOf } from "../permission-keys.js";
 import type { GlobalFlags, ResolveOptions, Settings } from "../settings.js";
 /**
@@ -225,6 +225,8 @@ export interface MessengerContext extends BaseContext {
         name?: string;
     }) => Promise<T>;
 }
+/** The waits a test shortens through its environment; a run without them keeps the defaults. */
+type ConnectionWaits = Pick<BaseEnvironment, "closeWaitMs" | "rekeyPacing">;
 /**
  * A connection as every shared reader sees it: its account remembered, each call a run event, what
  * the reads answer saved to the store. `close` closes the connection and the store it opened. One
@@ -234,7 +236,7 @@ export interface MessengerContext extends BaseContext {
  * does not `watch` is open: what it queued while nothing was connected is delivered once and cannot be fetched again.
  * A connection opened with `listen: true` is left to its `watch` and `feed`, which save the same.
  */
-export declare const connected: (connection: MessengerAdapter, { app, provider, name, deletedWithoutChat, pace, history, savedChatId, }: Pick<Messenger, "app" | "provider" | "name" | "deletedWithoutChat" | "pace" | "history" | "savedChatId">, { settings, env, renderer }: Pick<BaseContext, "settings" | "env" | "renderer">, events: EventSink, store?: LazyStore, { listen: watching }?: Pick<ConnectOptions, "listen">) => {
+export declare const connected: (connection: MessengerAdapter, { app, provider, name, deletedWithoutChat, pace, history, savedChatId, }: Pick<Messenger, "app" | "provider" | "name" | "deletedWithoutChat" | "pace" | "history" | "savedChatId">, { settings, env, renderer }: Pick<BaseContext, "settings" | "env" | "renderer">, events: EventSink, store?: LazyStore, { listen: watching, closeWaitMs, rekeyPacing, }?: Pick<ConnectOptions, "listen"> & ConnectionWaits) => {
     adapter: MessengerAdapter;
     close: () => Promise<void>;
 };
@@ -253,3 +255,4 @@ export declare const connectedFor: (command: Command, messenger: Pick<Messenger,
  */
 export declare const refuseLocalWrite: (context: MessengerContext, command: string, permission: PermissionKey) => void;
 export declare const messengerContext: (command: Command, messenger: Messenger, resolving?: Pick<ResolveOptions, "needsProfile">) => MessengerContext;
+export {};

package/dist/cli/messenger/context.js

@@ -118,7 +118,7 @@ const settled = async (pending, ms) => {
  * never fails the command; one that fails once the connection is `closing` is the close, not news. It still listens
  * while the connection closes, so what arrives then is saved too.
  */
-const listened = ({ run, operation, what }, events, warn) => {
+const listened = ({ run, operation, what }, events, warn, waitMs) => {
     const abort = new AbortController();
     let closing = false;
     const ended = Promise.resolve()
@@ -137,7 +137,7 @@ const listened = ({ run, operation, what }, events, warn) => {
         },
         stop: () => {
             abort.abort();
-            return settled(new Set([ended]), SAVES_WAIT_MS);
+            return settled(new Set([ended]), waitMs);
         },
     };
 };
@@ -171,6 +171,10 @@ const rekeyRecipients = async (app, profile, env, warn, from, to) => {
         warn(`the recipient list still names ${from}: ${error instanceof Error ? error.message : String(error)}`);
     }
 };
+const waitsOf = (command) => {
+    const { closeWaitMs, rekeyPacing } = environmentOf(command);
+    return { ...(closeWaitMs === undefined ? {} : { closeWaitMs }), ...(rekeyPacing ? { rekeyPacing } : {}) };
+};
 /**
  * A connection as every shared reader sees it: its account remembered, each call a run event, what
  * the reads answer saved to the store. `close` closes the connection and the store it opened. One
@@ -180,7 +184,7 @@ const rekeyRecipients = async (app, profile, env, warn, from, to) => {
  * does not `watch` is open: what it queued while nothing was connected is delivered once and cannot be fetched again.
  * A connection opened with `listen: true` is left to its `watch` and `feed`, which save the same.
  */
-export const connected = (connection, { app, provider, name, deletedWithoutChat, pace, history, savedChatId, }, { settings, env, renderer }, events, store = lazyStore(env, app.command), { listen: watching = false } = {}) => {
+export const connected = (connection, { app, provider, name, deletedWithoutChat, pace, history, savedChatId, }, { settings, env, renderer }, events, store = lazyStore(env, app.command), { listen: watching = false, closeWaitMs = SAVES_WAIT_MS, rekeyPacing, } = {}) => {
     const self = connection.self();
     if (self !== null)
         rememberAccount(app, settings.profile, self, env);
@@ -194,6 +198,7 @@ export const connected = (connection, { app, provider, name, deletedWithoutChat,
     const adapter = observed(flooded(connection, memory, { name: name ?? app.command, warn: renderer.warn, pacer }), events);
     const pending = new Set();
     const announcing = new Set();
+    const closing = new AbortController();
     const saving = self === null
         ? adapter
         : stored(adapter, {
@@ -204,13 +209,15 @@ export const connected = (connection, { app, provider, name, deletedWithoutChat,
             events,
             pending,
             announcing,
+            closing: closing.signal,
             ...(deletedWithoutChat ? { deletedWithoutChat } : {}),
+            ...(rekeyPacing ? { rekeyPacing } : {}),
             rekeyed: (from, to) => rekeyRecipients(app, settings.profile, env, renderer.warn, from, to),
             recipientIds: () => (new RecipientList(recipientsPathFor(app, settings.profile, env), app.command).read() ?? []).flatMap((recipient) => [recipient.id, ...(recipient.partnerId ? [recipient.partnerId] : [])]),
             ...(history === "store" ? { namesFromStore: savedChatId ? { savedChatId } : {} } : {}),
         });
     const passives = history === "store" && self !== null && !watching
-        ? passivesOf(saving).map((passive) => listened(passive, events, renderer.warn))
+        ? passivesOf(saving).map((passive) => listened(passive, events, renderer.warn, closeWaitMs))
         : [];
     return {
         adapter: saving,
@@ -229,7 +236,8 @@ export const connected = (connection, { app, provider, name, deletedWithoutChat,
                         events({ event: "warning", code: "store_not_written", operation });
                         renderer.warn(`not saved to the local store: the messenger was still handing on ${what} at exit`);
                     });
-                    await settled(new Set([...pending, ...announcing]), SAVES_WAIT_MS);
+                    await settled(new Set([...pending, ...announcing]), closeWaitMs);
+                    closing.abort();
                     if (pending.size > 0) {
                         events({ event: "warning", code: "store_not_written", operation: "close" });
                         renderer.warn("not saved to the local store: the last messages were still being written at exit");
@@ -262,7 +270,10 @@ export const connectedFor = async (command, messenger, base, options) => {
     }
     return {
         connection,
-        ...connected(connection, messenger, base, options.events, store, options.listen ? { listen: true } : {}),
+        ...connected(connection, messenger, base, options.events, store, {
+            ...waitsOf(command),
+            ...(options.listen ? { listen: true } : {}),
+        }),
     };
 };
 const unrecorded = (command, messenger, profile, offline) => {
@@ -407,7 +418,7 @@ export const messengerContext = (command, messenger, resolving = {}) => {
                             throw new CliError("validation_error", "the read connection has already been released");
                         }
                         base.track(connection);
-                        held = connected(connection, messenger, base, events);
+                        held = connected(connection, messenger, base, events, undefined, waitsOf(command));
                     }
                     return held.adapter;
                 },

package/dist/cli/messenger/stored.d.ts

@@ -21,6 +21,13 @@ export interface Saving {
     };
     /** After a re-key is saved: what outside the store spells the chat id follows it. */
     rekeyed?: (from: Id, to: Id) => void | Promise<void>;
+    /** How long one pass of re-keys may hold the write lock, and the pause after it. */
+    rekeyPacing?: {
+        lockMs: number;
+        pauseMs: number;
+    };
+    /** Aborted just before the store closes: the re-keys still queued are given up, with one warning for them all. */
+    closing?: AbortSignal;
     /**
      * Chat and partner ids this account's recipient list names, told to `storedChats` apart from the stored ones: an
      * entry saved before any chat was stored under its id would otherwise never be re-keyed, and the send guard would
@@ -41,4 +48,4 @@ export interface Saving {
  * would erase what `chats list` stored. Nor are `chat` and `contact`: a card's member list is not
  * known to be whole, and `saveMembers` replaces the list.
  */
-export declare const stored: (messenger: MessengerAdapter, { account, store, warn, events, pending, announcing, deletedWithoutChat, profile, rekeyed, namesFromStore, recipientIds, }: Saving) => MessengerAdapter;
+export declare const stored: (messenger: MessengerAdapter, { account, store, warn, events, pending, announcing, deletedWithoutChat, profile, rekeyed, rekeyPacing, closing, namesFromStore, recipientIds, }: Saving) => MessengerAdapter;

package/dist/cli/messenger/stored.js

@@ -3,6 +3,7 @@ import { capability, throughWrapper } from "../../ports/messenger.js";
 import { isId, pickPerson } from "../../resolve.js";
 import { codeOf } from "../../sends/guarded.js";
 import { chatIdIn } from "../../services/message-resolution.js";
+const REKEY_PACING = { lockMs: 50, pauseMs: 25 };
 /**
  * The adapter, with what each read answers written to the store. **A failed write never fails the
  * read** — the answer is already here, and it is what was asked for.
@@ -11,9 +12,15 @@ import { chatIdIn } from "../../services/message-resolution.js";
  * would erase what `chats list` stored. Nor are `chat` and `contact`: a card's member list is not
  * known to be whole, and `saveMembers` replaces the list.
  */
-export const stored = (messenger, { account, store, warn, events, pending, announcing, deletedWithoutChat, profile, rekeyed, namesFromStore, recipientIds, }) => {
+export const stored = (messenger, { account, store, warn, events, pending, announcing, deletedWithoutChat, profile, rekeyed, rekeyPacing = REKEY_PACING, closing, namesFromStore, recipientIds, }) => {
     let warned = false;
     let recorded = profile === undefined;
+    const notWritten = (operation, error) => {
+        events({ event: "warning", code: "store_not_written", operation });
+        if (!warned)
+            warn(`not saved to the local store: ${error instanceof Error ? error.message : String(error)}`);
+        warned = true;
+    };
     const attempt = async (operation, write) => {
         try {
             const opened = await store();
@@ -28,10 +35,7 @@ export const stored = (messenger, { account, store, warn, events, pending, annou
             }
         }
         catch (error) {
-            events({ event: "warning", code: "store_not_written", operation });
-            if (!warned)
-                warn(`not saved to the local store: ${error instanceof Error ? error.message : String(error)}`);
-            warned = true;
+            notWritten(operation, error);
         }
     };
     const save = (operation, writing) => {
@@ -72,6 +76,54 @@ export const stored = (messenger, { account, store, warn, events, pending, annou
             return undefined;
         }
     };
+    /**
+     * The first serve after an upgrade re-keys every phone-form chat at once. Back-to-back transactions keep the write
+     * lock so busy that another command waits past `busy_timeout`, so the re-keys go in passes with a pause between.
+     */
+    let rekeysQueued = 0;
+    let rekeyRound = 0;
+    const rekeysOnly = new Set();
+    // wa sends each re-key as its own batch, so a closed store would otherwise refuse, and warn for, every chat left.
+    const giveUpRekeys = () => {
+        rekeyRound += 1;
+        const count = rekeysQueued;
+        rekeysQueued = 0;
+        for (const saving of rekeysOnly)
+            pending?.delete(saving);
+        if (count === 0)
+            return;
+        events({ event: "warning", code: "rekeys_not_applied", operation: "history.rekey", counts: { rekeys: count } });
+        warn(`${count} chat re-key${count === 1 ? "" : "s"} not applied yet; the next serve applies them`);
+    };
+    closing?.addEventListener("abort", giveUpRekeys, { once: true });
+    const saveRekeys = async (pairs, round) => {
+        let rest = pairs;
+        while (rest.length > 0 && round === rekeyRound) {
+            let pass;
+            try {
+                pass = await (await store())?.chats.rekeyChats(account, rest, rekeyPacing.lockMs);
+            }
+            catch {
+                // Closed at exit or busy past its timeout, the store would refuse every pass after this one too.
+                if (round === rekeyRound)
+                    giveUpRekeys();
+                return;
+            }
+            if (round !== rekeyRound)
+                return;
+            const taken = pass?.taken ?? rest.length;
+            rekeysQueued -= taken;
+            for (const { from, to } of pass?.applied ?? [])
+                await Promise.resolve()
+                    .then(() => rekeyed?.(from, to))
+                    .catch((error) => notWritten("history.rekey", error));
+            for (const { error } of pass?.refused ?? [])
+                notWritten("history.rekey", error);
+            rest = rest.slice(taken);
+            if (rest.length > 0)
+                await new Promise((resolve) => setTimeout(resolve, rekeyPacing.pauseMs));
+        }
+    };
     const saveBatches = (operation, onBatch) => {
         // In order: a batch's messages may belong to chats only an earlier batch named.
         let previous = Promise.resolve();
@@ -87,18 +139,22 @@ export const stored = (messenger, { account, store, warn, events, pending, annou
                     if (chat.title)
                         titles.set(chat.id, chat.title);
             }
-            // Each re-key apart: one refused leaves the chat split, never the batch's history unsaved.
+            const rekeys = batch.rekeys ?? [];
+            const round = rekeyRound;
+            rekeysQueued += rekeys.length;
+            // A refused re-key leaves its chat split, never the others or the batch's history unsaved.
             const saving = previous.then(async () => {
-                for (const { from, to } of batch.rekeys ?? [])
-                    await attempt("history.rekey", async (opened) => {
-                        await opened.chats.rekeyChat(account, from, to);
-                        await rekeyed?.(from, to);
-                    });
+                await saveRekeys(rekeys, round);
                 await attempt(operation, (opened) => fill(opened, account, batch));
             });
             previous = saving;
             pending?.add(saving);
-            void saving.finally(() => pending?.delete(saving));
+            if (onlyRekeys(batch))
+                rekeysOnly.add(saving);
+            void saving.finally(() => {
+                pending?.delete(saving);
+                rekeysOnly.delete(saving);
+            });
             onBatch(batch);
         };
     };
@@ -436,6 +492,7 @@ const titled = (event, titles) => {
     const title = titles.get(event.chatId);
     return title ? { ...event, chatTitle: title } : event;
 };
+const onlyRekeys = (batch) => Object.entries(batch).every(([part, items]) => (part === "rekeys") === (items?.length ?? 0) > 0);
 /**
  * A pushed batch as the store keeps it. No `markChatsLeft`: a push names some chats, never all of them.
  * No `seenAt`: a pushed snapshot may be older than a deletion this store already holds. A chat's votes and stars go

package/dist/runs/events.d.ts

@@ -34,6 +34,8 @@ export interface WarningEvent {
     operation?: string;
     /** Field paths and types for an answer of an unexpected shape — built without the values. */
     detail?: string;
+    /** How many things the warning is about, per field: `{ rekeys: 199 }`. */
+    counts?: Record<string, number>;
 }
 /** A read answered locally, without asking the messenger, and why. */
 export interface CacheEvent {

package/dist/runs/events.js

@@ -10,7 +10,8 @@ export const providerErrorKey = (value) => typeof value === "string" && /^[A-Za-
  */
 export const renderEvent = (event) => {
     if (event.event === "warning") {
-        return [`${MARK.warning} ${(event.operation ?? "").padEnd(16)} ${event.code}`, event.detail]
+        const counts = Object.entries(event.counts ?? {}).map(([field, count]) => `${count} ${field}`);
+        return [`${MARK.warning} ${(event.operation ?? "").padEnd(16)} ${event.code}`, ...counts, event.detail]
             .filter(Boolean)
             .join("  ");
     }

package/dist/store/chats.d.ts

@@ -1,6 +1,6 @@
 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 ChatRekey, type ChatRekeys } from "./sqlite/chat-rekey.js";
 import type { ChatMetadata, LeftChat } from "./sqlite/chats.js";
 import type { ChatCompleteness } from "./sqlite/completeness.js";
 import type { StoreContext } from "./sqlite/open.js";
@@ -39,6 +39,14 @@ export interface ChatsStore {
      * `to`. Replaying it changes nothing.
      */
     rekeyChat(key: AccountKey, from: Id, to: Id): Promise<ChatRekey>;
+    /**
+     * `rekeyChat` for a run of pairs, in order, in one transaction that ends once it has held the write lock for
+     * `lockMs`: `taken` says how many it got to. A pair refused is in `refused`, and the others still apply.
+     */
+    rekeyChats(key: AccountKey, pairs: readonly {
+        from: Id;
+        to: Id;
+    }[], lockMs: number): Promise<ChatRekeys>;
     /**
      * 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.

package/dist/store/chats.js

@@ -1,6 +1,6 @@
 import { CliError } from "@wirecat/cli-base";
 import { keysOver } from "./keys.js";
-import { rekeyChat } from "./sqlite/chat-rekey.js";
+import { rekeyChat, rekeyChats } from "./sqlite/chat-rekey.js";
 import * as chatQueries from "./sqlite/chats.js";
 import * as completeness from "./sqlite/completeness.js";
 import * as reads from "./sqlite/reads.js";
@@ -49,6 +49,14 @@ export const chatsStoreOver = (context) => {
                 return { outcome: "unchanged", messages: 0, duplicates: 0 };
             return write(database, () => rekeyChat(context, key, accountKey, from, to));
         },
+        rekeyChats: async (key, pairs, lockMs) => {
+            const accountKey = findAccountPk(key);
+            if (accountKey === undefined) {
+                const rekey = { outcome: "unchanged", messages: 0, duplicates: 0 };
+                return { taken: pairs.length, applied: pairs.map((pair) => ({ ...pair, rekey })), refused: [] };
+            }
+            return write(database, () => rekeyChats(context, key, accountKey, pairs, lockMs));
+        },
         leftChats: async (key, { clear = false } = {}) => {
             const accountKey = findAccountPk(key);
             if (accountKey === undefined)

package/dist/store/exports.d.ts

@@ -16,7 +16,7 @@ export { accountGroupsOf } from "./sqlite/account-groups.js";
 export type { AdminStoreRequest, AdminStoreResult } from "./sqlite/admin-statistics.js";
 export { type AttachmentTextEntry, type AttachmentView, attachmentColumns, type FileAttachment, resetAttachmentWords, type TextOrigin, } from "./sqlite/attachment-texts.js";
 export { pendingNormalization } from "./sqlite/backfill.js";
-export type { ChatRekey } from "./sqlite/chat-rekey.js";
+export type { ChatRekey, ChatRekeys } from "./sqlite/chat-rekey.js";
 export { CHAT_COLUMNS, titlePart } from "./sqlite/chats.js";
 export { CHAT_LIST_KEY, type ChatCompleteness, fetchedKey, historyStartKey } from "./sqlite/completeness.js";
 export { CONVERSATION_COLUMNS } from "./sqlite/conversations.js";

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

@@ -8,8 +8,30 @@ export interface ChatRekey {
     /** Messages both chats held under one id; the kept chat's copy stays. */
     duplicates: number;
 }
+export interface ChatRekeys {
+    /** How many of the pairs this pass got to, from the first: the rest wait for another pass. */
+    taken: number;
+    applied: {
+        from: Id;
+        to: Id;
+        rekey: ChatRekey;
+    }[];
+    refused: {
+        from: Id;
+        to: Id;
+        error: unknown;
+    }[];
+}
 /**
  * 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`.
  */
 export declare const rekeyChat: (context: StoreContext, key: AccountKey, accountKey: number, from: Id, to: Id) => ChatRekey;
+/**
+ * Re-keys in order, each in its own savepoint so a refused one leaves the others applied, and stops once `lockMs` has
+ * passed: the caller lets the other processes at the write lock before the next pass. Runs inside `write`.
+ */
+export declare const rekeyChats: (context: StoreContext, key: AccountKey, accountKey: number, pairs: readonly {
+    from: Id;
+    to: Id;
+}[], lockMs: number) => ChatRekeys;

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

@@ -4,6 +4,7 @@ import { purgeChats, stricterPrivacy } from "./chats.js";
 import { pointerPairs } from "./entity-types.js";
 import { tombstone } from "./messages.js";
 import { targetKey } from "./notes.js";
+import { write } from "./transaction.js";
 const chatRow = (context, accountKey, chatId) => context.database.prepare("SELECT * FROM chats WHERE account_id = ? AND external_id = ?").get(accountKey, chatId);
 /**
  * Re-points every `<x>_type = type` pointer from one row to another. A pointer the kept row already has (a unique
@@ -185,3 +186,27 @@ export const rekeyChat = (context, key, accountKey, from, to) => {
     renameText(context, key, accountKey, from, to);
     return { outcome: twin ? "merged" : "renamed", ...moved };
 };
+/**
+ * Re-keys in order, each in its own savepoint so a refused one leaves the others applied, and stops once `lockMs` has
+ * passed: the caller lets the other processes at the write lock before the next pass. Runs inside `write`.
+ */
+export const rekeyChats = (context, key, accountKey, pairs, lockMs) => {
+    const done = { taken: 0, applied: [], refused: [] };
+    const started = performance.now();
+    for (const { from, to } of pairs) {
+        if (done.taken > 0 && performance.now() - started >= lockMs)
+            break;
+        done.taken += 1;
+        try {
+            done.applied.push({
+                from,
+                to,
+                rekey: write(context.database, () => rekeyChat(context, key, accountKey, from, to)),
+            });
+        }
+        catch (error) {
+            done.refused.push({ from, to, error });
+        }
+    }
+    return done;
+};

package/package.json

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