@wirecat/cli-core 0.367.0 → 0.368.0

package/CHANGELOG.md

@@ -7,6 +7,18 @@ shape of this file.
 
 ## Unreleased
 
+## 0.368.0 — 20.10.2026
+
+### Fixed
+
+- **Reads of a left chat's kept history find it by any id; live operations refuse it by any id.** `store export`
+  (also `--output-dir` with named chats), `store status`, `messages thread`, a search's `--chat` and `chat:` in one
+  account, `metadata get`, members, stats, events, tags, tasks, conversations, embeddings, pictures and attachments
+  now find a chat the account left by its name or id, the current one or one it was re-keyed from, as `chats show`
+  and `messages list` already did. Before, a left chat named by a non-numeric id was refused. `chats track` and
+  `store gaps plan` refuse a left chat with "you left chat <id>", also by a numeric id, which used to pass as typed.
+  A numeric id the store does not hold still passes as typed.
+
 ## 0.367.0 — 20.10.2026
 
 ### Added

package/dist/cli/messenger/tasks-command.js

@@ -370,7 +370,7 @@ export const tasksCommand = (messenger) => {
         const passes = await context.withStore(async (store, account) => {
             const ids = [];
             for (const chat of chats)
-                ids.push(await storedChatId(messenger, chat, store, account));
+                ids.push(await storedChatId(messenger, chat, store, account, { includeLeft: true }));
             return applyTaskRulesToChats(store, account, ids, { ...(last === undefined ? {} : { last }), yes });
         }, { name: "tasks scan" });
         renderAnswer(this, context, listOf("tasks scan", { items: passes.map(snakeKeys), limit: passes.length, has_more: false }), () => `${passes.map((pass) => applyText(pass, yes, tool)).join("\n")}\n`);

package/dist/services/archive.js

@@ -29,13 +29,13 @@ export const archiveService = (deps) => {
     const found = async (chat) => {
         const store = await deps.store();
         const account = await deps.account();
-        return { store, account, chatId: await storedChatId(deps.messenger, chat, store, account) };
+        return { store, account, chatId: await storedChatId(deps.messenger, chat, store, account, { includeLeft: true }) };
     };
     return {
         status: async (chat) => {
             const store = await deps.store();
             const account = await deps.account();
-            const only = chat === undefined ? undefined : await storedChatId(deps.messenger, chat, store, account);
+            const only = chat === undefined ? undefined : await storedChatId(deps.messenger, chat, store, account, { includeLeft: true });
             const stats = await store.chats.chatStats(account, only);
             return Promise.all(stats.map(async (one) => ({ ...one, held: await store.sync.ranges(account, one.chatId) })));
         },
@@ -54,7 +54,7 @@ export const archiveService = (deps) => {
             const store = await deps.store();
             const account = await deps.account();
             if (chats !== undefined && chats.length > 0) {
-                const named = await Promise.all(chats.map((chat) => storedChatId(deps.messenger, chat, store, account)));
+                const named = await Promise.all(chats.map((chat) => storedChatId(deps.messenger, chat, store, account, { includeLeft: true })));
                 const titles = new Map((await store.chats.chatStats(account)).map((one) => [one.chatId, one.title]));
                 return { account, chats: [...new Set(named)].map((id) => ({ id, title: titles.get(id) ?? null })) };
             }

package/dist/services/attachments.js

@@ -147,7 +147,7 @@ const messageOf = async (deps, store, chat, message) => {
     }
     if (message === undefined)
         throw new CliError("validation_error", "which message? give its id after the chat");
-    return { chatId: await chatIdIn(deps.messenger, chat, store), messageId: message.trim() };
+    return { chatId: await chatIdIn(deps.messenger, chat, store, { includeLeft: true }), messageId: message.trim() };
 };
 export const attachmentsService = (deps) => ({
     extract: async ({ chat, message: onlyMessage, paths, fromDir, cursor, scanLimit: requestedScanLimit, limit: requestedLimit, download, onItem, signal, load = importEngine, ocr, concurrency = 1, } = {}) => {
@@ -167,7 +167,7 @@ export const attachmentsService = (deps) => ({
         deps.guard.check({ chatId: null, key: "attachments.extract" }, { reserve: false });
         const store = await accountStore(deps);
         const { account } = store;
-        const chatId = chat === undefined ? undefined : await chatIdIn(deps.messenger, chat, store);
+        const chatId = chat === undefined ? undefined : await chatIdIn(deps.messenger, chat, store, { includeLeft: true });
         const directory = fromDir === undefined
             ? undefined
             : await directoryPaths(store, chatId, fromDir, deps.messenger.app, deps.env ?? process.env);
@@ -346,7 +346,7 @@ export const attachmentsService = (deps) => ({
         if (query)
             for (const node of walkQuery(query.root))
                 if (node.field === "chat" && node.operator !== "wildcard" && !chats.has(node.value))
-                    chats.set(node.value, await chatIdIn(deps.messenger, node.value, store));
+                    chats.set(node.value, await chatIdIn(deps.messenger, node.value, store, { includeLeft: true }));
         const where = query ? queryFilter(query, attachmentColumns(chats), { command: "attachments list" }) : undefined;
         const views = await store.attachments.attachments({ ...(where ? { where } : {}), offset, limit: limit + 1 });
         return { items: views.slice(0, limit).map((view) => itemOf(account, view)), has_more: views.length > limit };

package/dist/services/chat-documents.js

@@ -5,7 +5,7 @@ import { chatIdIn } from "./message-resolution.js";
 export const chatDocumentsService = (deps) => ({
     list: async (chat, { limit, offset }) => {
         const store = await accountStore(deps);
-        const chatId = await chatIdIn(deps.messenger, chat, store);
+        const chatId = await chatIdIn(deps.messenger, chat, store, { includeLeft: true });
         const items = (await store.messages.documentLinkMessages(chatId)).flatMap((message) => googleDocumentLinks(message.text).map(({ url, documentId }) => {
             const stored = documentId === null ? undefined : message.documents.find((one) => one.fileId === documentId);
             return {

package/dist/services/chats.js

@@ -24,7 +24,7 @@ export const CHAT_KINDS = ["dialog", "group", "channel", "saved"];
 export const STORED_EVENTS = 1000;
 /** For a messenger whose history is pushed: the events `serve` kept, never asking the messenger. */
 const storedEvents = async (store, deps, chat, since) => {
-    const chatId = await chatIdIn(deps.messenger, chat, store);
+    const chatId = await chatIdIn(deps.messenger, chat, store, { includeLeft: true });
     const found = await store.roster.chatEvents(chatId, {
         since: new Date(since).toISOString(),
         limit: STORED_EVENTS + 1,
@@ -94,7 +94,7 @@ export const chatsService = (deps) => ({
                 return capability(connection, "members", "list a group's members")(chat, window);
         }
         const store = await accountStore(deps);
-        const chatId = await chatIdIn(deps.messenger, chat, store);
+        const chatId = await chatIdIn(deps.messenger, chat, store, { includeLeft: true });
         const everyone = await store.roster.members(chatId);
         const end = window.limit === undefined ? everyone.length : window.offset + window.limit;
         return { chatId, items: everyone.slice(window.offset, end), hasMore: everyone.length > end };
@@ -116,7 +116,7 @@ export const chatsService = (deps) => ({
     },
     stats: async (chat, { since, by, timezone }) => {
         const store = await accountStore(deps);
-        const chatId = await chatIdIn(deps.messenger, chat, store);
+        const chatId = await chatIdIn(deps.messenger, chat, store, { includeLeft: true });
         const [completeness] = await store.chats.chatCompleteness([chatId]);
         if (!completeness)
             throw new CliError("not_found", `no stored chat ${chatId}`);
@@ -213,7 +213,7 @@ export const chatsService = (deps) => ({
     tracked: async () => (await accountStore(deps)).roster.trackedChats(),
     memberHistory: async (chat, { since }) => {
         const store = await accountStore(deps);
-        const chatId = await chatIdIn(deps.messenger, chat, store);
+        const chatId = await chatIdIn(deps.messenger, chat, store, { includeLeft: true });
         const [stays, revisions] = await Promise.all([
             store.roster.memberStays(chatId),
             store.roster.profileRevisions(chatId),
@@ -222,7 +222,7 @@ export const chatsService = (deps) => ({
     },
     trackedChat: async (chat) => {
         const store = await accountStore(deps);
-        const chatId = await chatIdIn(deps.messenger, chat, store);
+        const chatId = await chatIdIn(deps.messenger, chat, store, { includeLeft: true });
         const entry = (await store.roster.trackedChats()).find((one) => one.chatId === chatId);
         const since = new Date(Date.now() - TRACKED_DAYS * 86_400_000).toISOString().slice(0, 10);
         return {

package/dist/services/conversations.js

@@ -37,7 +37,7 @@ export const BATCH_SIZE = { default: 50, min: 10, max: 200 };
 export const conversationsService = (deps) => {
     const found = async (chat) => {
         const store = await accountStore(deps);
-        return { store, chatId: await chatIdIn(deps.messenger, chat, store) };
+        return { store, chatId: await chatIdIn(deps.messenger, chat, store, { includeLeft: true }) };
     };
     const notBuilt = (chatId) => new CliError("not_found", `chat ${chatId} has no conversations yet — \`${typedCommand(deps.messenger.app.command, `conversations build --chat ${chatId}`)}\``);
     return {

package/dist/services/embeddings-maintenance.js

@@ -80,7 +80,7 @@ export const embeddingsMaintenance = (deps) => {
     const found = async (chat) => {
         const store = await deps.store();
         const account = await deps.account();
-        const chatId = await storedChatId(deps.messenger, chat, store, account);
+        const chatId = await storedChatId(deps.messenger, chat, store, account, { includeLeft: true });
         if (!(await store.conversations.conversationState(account, chatId))?.builtAt)
             throw notBuiltError(deps, chatId);
         return { store, account, chatId };
@@ -198,7 +198,7 @@ export const embeddingsMaintenance = (deps) => {
             const store = await deps.store();
             const account = await deps.account();
             const target = embeddingTarget(deps, choice);
-            const chatId = chat === undefined ? undefined : await storedChatId(deps.messenger, chat, store, account);
+            const chatId = chat === undefined ? undefined : await storedChatId(deps.messenger, chat, store, account, { includeLeft: true });
             const chats = await readinessOf(deps, chatId, target.key);
             if (chatId !== undefined)
                 return { model: target.id, chats };
@@ -211,7 +211,7 @@ export const embeddingsMaintenance = (deps) => {
             const target = embeddingTarget(deps, choice);
             if (embed && !build && !target.installed)
                 throw notDownloaded(deps, target.id);
-            const chatId = chat === undefined ? undefined : await storedChatId(deps.messenger, chat, store, account);
+            const chatId = chat === undefined ? undefined : await storedChatId(deps.messenger, chat, store, account, { includeLeft: true });
             const scan = async () => ({
                 chats: (await readinessOf(deps, chatId, target.key)).sort(byOldestBuild),
                 unbuilt: chatId === undefined ? await store.vectors.unbuiltGroups(account) : [],
@@ -278,7 +278,7 @@ export const embeddingsMaintenance = (deps) => {
         clear: async (chat, choice) => {
             const store = await deps.store();
             const account = await deps.account();
-            const chatId = await storedChatId(deps.messenger, chat, store, account);
+            const chatId = await storedChatId(deps.messenger, chat, store, account, { includeLeft: true });
             const cleared = await store.vectors.clearVectors(account, chatId, choice === undefined ? undefined : embeddingTarget(deps, choice).key);
             return { chat: chatId, cleared };
         },

package/dist/services/embeddings-search.js

@@ -235,7 +235,7 @@ export const embeddingsSearch = (deps) => {
             const store = await deps.store();
             const account = await deps.account();
             const target = embeddingTarget(deps, choice);
-            const chatId = await storedChatId(deps.messenger, chat, store, account);
+            const chatId = await storedChatId(deps.messenger, chat, store, account, { includeLeft: true });
             const [source] = await store.conversations.conversationsOfMessages(account, [{ chatId, messageId: message }]);
             if (!source) {
                 if (!(await store.conversations.conversationState(account, chatId))?.builtAt)

package/dist/services/evidence-read.js

@@ -7,7 +7,7 @@ export const readEvidencePacket = async (store, account, { chat, limit, before }
         throw new CliError("validation_error", "evidence message limit must be an integer from 1 to 100");
     if (before !== undefined && !before.trim())
         throw new CliError("validation_error", "evidence before id must not be empty");
-    const chatId = await storedChatId(messenger, chat, store, account);
+    const chatId = await storedChatId(messenger, chat, store, account, { includeLeft: true });
     const page = await store.messages.messages(account, chatId, { limit, ...(before === undefined ? {} : { before }) });
     const items = page.items.toReversed();
     const packet = prepareEvidencePacket({

package/dist/services/message-resolution.d.ts

@@ -10,8 +10,13 @@ export type Saved = Partial<Pick<MessengerTraits, "savedChatId" | "app">>;
  * in store mode the store is the only source, so an empty answer would pass for "nothing was said".
  */
 export declare const readChatId: (deps: ServiceDeps, reference: string, store: MessageStore, account: AccountKey) => Promise<string>;
-/** A chat as typed, found among the stored chats the way an adapter finds it among its own. */
-export declare const storedChatId: (messenger: Saved, reference: string, store: MessageStore, account: AccountKey) => Promise<string>;
+/**
+ * A chat as typed, found among the stored chats the way an adapter finds it among its own; `includeLeft` tries the
+ * left ones last, for a read of their kept history.
+ */
+export declare const storedChatId: (messenger: Saved, reference: string, store: MessageStore, account: AccountKey, { includeLeft }?: {
+    includeLeft?: boolean;
+}) => Promise<string>;
 /** `storedChatId`, among the chats of the account the store is bound to; `includeLeft` tries the left ones last. */
 export declare const chatIdIn: (messenger: Saved, reference: string, store: AccountStore, { includeLeft }?: {
     includeLeft?: boolean;

package/dist/services/message-resolution.js

@@ -22,24 +22,37 @@ export const readChatId = async (deps, reference, store, account) => {
     return chatId;
 };
 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, {
-    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, {
-        held: () => store.chats.chats(account, { includeLeft: true }),
-        renamed: (id) => store.chats.renamedChatId(account, id),
+/**
+ * A chat as typed, found among the stored chats the way an adapter finds it among its own; `includeLeft` tries the
+ * left ones last, for a read of their kept history.
+ */
+export const storedChatId = (messenger, reference, store, account, { includeLeft = false } = {}) => {
+    const renamed = (id) => store.chats.renamedChatId(account, id);
+    const among = chatIdAmong(messenger, reference, account, {
+        held: () => store.chats.chats(account, {}),
+        renamed,
+        left: async (id) => leftIn(await store.chats.chats(account, byId(id))),
     });
-});
+    if (!includeLeft)
+        return among;
+    return among.catch((error) => {
+        if (codeOf(error) !== "not_found")
+            throw error;
+        return chatIdAmong(messenger, reference, account, {
+            held: () => store.chats.chats(account, { includeLeft: true }),
+            renamed,
+        });
+    });
+};
+const keptChatId = (messenger, reference, store, account) => storedChatId(messenger, reference, store, account, { includeLeft: true });
 /** `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 renamed = (id) => store.chats.renamedChatId(id);
-    const among = chatIdAmong(messenger, reference, store.account, { held: () => store.chats.chats({}), renamed });
+    const among = chatIdAmong(messenger, reference, store.account, {
+        held: () => store.chats.chats({}),
+        renamed,
+        left: async (id) => leftIn(await store.chats.chats(byId(id))),
+    });
     if (!includeLeft)
         return among;
     return among.catch((error) => {
@@ -51,13 +64,24 @@ export const chatIdIn = (messenger, reference, store, { includeLeft = false } =
         });
     });
 };
-const chatIdAmong = async (messenger, reference, account, { held, renamed }) => {
+const byId = (id) => ({
+    includeLeft: true,
+    limit: 1,
+    where: { sql: "chats.external_id = ?", params: [id] },
+});
+const leftIn = ({ items }) => items.some((one) => one.membershipState === "left");
+/** `left` is given where a left chat is refused; it lets a numeric id the store does not hold through as typed. */
+const chatIdAmong = async (messenger, reference, account, { held, renamed, left, }) => {
     const trimmed = reference.trim();
     if (messenger.savedChatId && ["me", "self", "saved"].includes(trimmed.toLowerCase())) {
         return messenger.savedChatId(account);
     }
-    if (/^-?\d+$/.test(trimmed))
-        return (await renamed(trimmed)) ?? trimmed;
+    if (/^-?\d+$/.test(trimmed)) {
+        const id = (await renamed(trimmed)) ?? trimmed;
+        if (await left?.(id))
+            throw new CliError("not_found", `you left chat ${id}`);
+        return id;
+    }
     const chats = (await held()).items;
     const exact = chats.find((one) => one.id === trimmed);
     if (exact)
@@ -90,7 +114,7 @@ const missing = (error) => {
 export const chatAmong = async (messenger, store, accounts, reference) => {
     const [only] = accounts;
     if (accounts.length === 1 && only)
-        return { account: only, chatId: await storedChatId(messenger, reference, store, only) };
+        return { account: only, chatId: await storedChatId(messenger, reference, store, only, { includeLeft: true }) };
     const found = (await Promise.all(accounts.map(async (account) => {
         const held = (await store.chats.chats(account, {})).items;
         const chatId = await storedChatId(messenger, reference, store, account).catch(missing);

package/dist/services/messages.js

@@ -158,7 +158,7 @@ export const messagesService = (deps) => {
             if (account.provider !== deps.messenger.provider ||
                 (target.account !== undefined && target.account !== account.account))
                 throw new CliError("validation_error", "that locator belongs to another account; select its profile first");
-            return readThreadContext(store, account, await storedChatId(deps.messenger, target.chat, store, account), target.message, options);
+            return readThreadContext(store, account, await storedChatId(deps.messenger, target.chat, store, account, { includeLeft: true }), target.message, options);
         }),
         comments: async (chat, typedPost, window) => {
             const post = typedPost.trim();

package/dist/services/metadata.js

@@ -3,10 +3,10 @@ import { CHANNEL_TAG_RULES_VERSION, classifyChannel } from "../domain/channel-ta
 import { capability } from "../ports/messenger.js";
 import { storedChatId } from "./message-resolution.js";
 export const metadataService = (deps) => {
-    const held = async (reference) => {
+    const held = async (reference, { includeLeft = false } = {}) => {
         const store = await deps.store();
         const account = await deps.account();
-        const chatId = await storedChatId(deps.messenger, reference, store, account);
+        const chatId = await storedChatId(deps.messenger, reference, store, account, { includeLeft });
         return { store, account, chatId };
     };
     const refresh = async (reference) => {
@@ -44,7 +44,7 @@ export const metadataService = (deps) => {
             return missing;
         },
         get: async (reference) => {
-            const { store, account, chatId } = await held(reference);
+            const { store, account, chatId } = await held(reference, { includeLeft: true });
             return { chatId, metadata: (await store.chats.chatMetadata(account, chatId)) ?? null };
         },
         refresh,

package/dist/services/people.js

@@ -80,7 +80,7 @@ export const peopleService = (deps) => {
             const store = await deps.store();
             const account = await deps.account();
             if (!fetch) {
-                const ids = await Promise.all(chats.map((chat) => storedChatId(deps.messenger, chat, store, account)));
+                const ids = await Promise.all(chats.map((chat) => storedChatId(deps.messenger, chat, store, account, { includeLeft: true })));
                 return personMessages(store, account, person, {
                     chats: ids,
                     ...(limit ? { limit } : {}),

package/dist/services/pictures.js

@@ -80,7 +80,7 @@ export const picturesService = (deps) => {
                 throw new CliError("validation_error", PICTURES_OFF);
             const store = await deps.store();
             const account = await deps.account();
-            const chatId = chat === undefined ? undefined : await storedChatId(deps.messenger, chat, store, account);
+            const chatId = chat === undefined ? undefined : await storedChatId(deps.messenger, chat, store, account, { includeLeft: true });
             const use = await embedder();
             const result = { model: model.key, embedded: 0, skipped: 0, failed: 0, more: false };
             const pending = [];
@@ -177,7 +177,7 @@ export const picturesService = (deps) => {
                 return {};
             const store = await deps.store();
             const account = await deps.account();
-            const chatId = chat === undefined ? undefined : await storedChatId(deps.messenger, chat, store, account);
+            const chatId = chat === undefined ? undefined : await storedChatId(deps.messenger, chat, store, account, { includeLeft: true });
             let vector;
             try {
                 const use = await embedder();

package/dist/services/retention.js

@@ -26,7 +26,7 @@ export const retentionService = (deps) => ({
             limit: query.limit ?? 20,
         };
         const store = await deps.store(), account = await deps.account();
-        const chatId = await storedChatId(deps.messenger, chat, store, account);
+        const chatId = await storedChatId(deps.messenger, chat, store, account, { includeLeft: true });
         const result = await store.roster.retention(account, chatId, options);
         return {
             ...result,

package/dist/services/tags.js

@@ -71,7 +71,7 @@ const targetOf = async (deps, store, account, { chat, contact, message, task })
     }
     if (chat === undefined)
         throw new CliError("validation_error", ONE_TARGET);
-    const chatId = await storedChatId(deps.messenger, chat, store, account);
+    const chatId = await storedChatId(deps.messenger, chat, store, account, { includeLeft: true });
     return message === undefined ? { type: "chat", chatId } : { type: "message", chatId, messageId: message.trim() };
 };
 const viewOf = (account, target) => target.type === "message"

package/dist/services/tasks.js

@@ -149,7 +149,7 @@ export const tasksService = (deps, categories) => {
     const categoryOf = async (store, name) => taskCategoryOf(await listOf(store))(name);
     const inStore = async (work) => work(await deps.store(), await deps.account());
     const service = (store) => createTaskService({ store: store.tasks });
-    const groupOf = async (store, account, chat) => chat === undefined ? undefined : storedChatId(deps.messenger, chat, store, account);
+    const groupOf = async (store, account, chat) => chat === undefined ? undefined : storedChatId(deps.messenger, chat, store, account, { includeLeft: true });
     const refuseBare = (target) => {
         throw new CliError("validation_error", `no task ${singleLine(target)} — write task:${singleLine(target)} for a task`);
     };
@@ -212,7 +212,7 @@ export const tasksService = (deps, categories) => {
             const groups = new Map();
             for (const node of query ? walkQuery(query.root) : [])
                 if (node.field === "chat" && node.operator !== "wildcard" && !groups.has(node.value))
-                    groups.set(node.value, await storedChatId(deps.messenger, node.value, store, account));
+                    groups.set(node.value, await storedChatId(deps.messenger, node.value, store, account, { includeLeft: true }));
             const where = query ? queryFilter(query, taskColumns(groups), { command: "tasks list" }) : undefined;
             const rows = await store.tasks.query(taskAccount(account), where, { limit: limit + 1, offset });
             const shown = rows.slice(0, limit);
@@ -443,7 +443,7 @@ export const tasksService = (deps, categories) => {
                     type: "chat",
                     provider: account.provider,
                     account: account.account,
-                    chat: await storedChatId(deps.messenger, chat, store, account),
+                    chat: await storedChatId(deps.messenger, chat, store, account, { includeLeft: true }),
                 })));
                 const origin = by === "owner" ? "owner" : "suggested";
                 for (const target of [...written, ...chatRefs]) {

package/package.json

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