@wirecat/cli-core 0.366.0 → 0.368.0

package/CHANGELOG.md

@@ -7,6 +7,39 @@ 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
+
+- **A document hit in project gathering carries the paragraphs around it.** `around` holds, in document order, up
+  to `around.before` and `around.after` paragraphs next to the first one naming a searched word, plus that one
+  marked `found`. The bytes count as `usage.aroundBytes`, as a message's neighbours do.
+
+### Fixed
+
+- **An evidence findings review accepts the findings whose own evidence is unchanged.** Before, one changed text
+  anywhere in a batch refused accepting any of it, so the agent had to stage the whole batch again. Now only the
+  accepted findings' project, assignee and cited texts are rechecked; the rest can be rejected in the same review.
+  Batches keep one hash per checked record for this; a batch staged earlier is still checked as a whole.
+
+- **Project gathering moves past large documents instead of stalling.** A page of evidence now holds the records
+  that fit its byte budget together, rather than failing when they do not. A record larger than the page is read
+  alone, up to 256 KiB. One larger still is listed in the new `oversized` result field by reference and skipped,
+  so a resume no longer retries the same page and charges its budget each time. The context reader's page gains
+  the same optional `oversized`. Meeting preparation reports such a record as `read-limited` and continues past it.
+
 ## 0.366.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/context/evidence-response.js

@@ -34,6 +34,14 @@ export const validateContextEvidencePage = (page, request) => {
             fail();
         if (page.next)
             contextEvidenceRequest({ ...request, cursor: page.next });
+        const big = page.oversized;
+        if (big !== undefined &&
+            (!big ||
+                page.items.length ||
+                typeof big.ref !== "string" ||
+                !Number.isSafeInteger(big.bytes) ||
+                big.bytes <= maxReadBytes))
+            fail();
         let actual = 0;
         for (const item of page.items) {
             if (!item ||

package/dist/context/evidence.d.ts

@@ -1,3 +1,4 @@
+export declare const CONTEXT_MAX_READ_BYTES = 262144;
 export declare const CONTEXT_SOURCE_KINDS: readonly ["message", "mail", "document", "meeting"];
 export interface ContextSource {
     kind: (typeof CONTEXT_SOURCE_KINDS)[number];
@@ -40,6 +41,11 @@ export interface ContextEvidencePage {
         scope: string;
     } | null;
     readBytes: number;
+    /** The next record alone is larger than maxReadBytes: it was not read, and next moves past it. */
+    oversized?: {
+        ref: string;
+        bytes: number;
+    };
     coverage: {
         available: boolean;
         index: "ready" | "pending" | "missing" | "unknown";
@@ -65,6 +71,11 @@ export interface ContextIndex {
 }
 /** Changes whenever the cited text, its title or its revision does; a staged finding citing an older one is stale. */
 export declare const contextEvidenceFingerprint: (item: Pick<ContextEvidenceItem, "ref" | "title" | "text" | "revision">) => string;
+/** How many rows, in reading order, fit the allowance together; none when the first alone is larger. */
+export declare const fittingRows: (sizes: readonly number[], limit: number, maxReadBytes: number) => {
+    count: number;
+    bytes: number;
+};
 /** One stored message, email or document as the context reader returns it, by its reference. */
 export interface ContextRecordReader {
     read(ref: string): Promise<Pick<ContextEvidenceItem, "ref" | "title" | "text" | "revision"> | null>;

package/dist/context/evidence.js

@@ -1,10 +1,22 @@
 import { createHash } from "node:crypto";
 import { CliError } from "@wirecat/cli-base";
+export const CONTEXT_MAX_READ_BYTES = 262144;
 export const CONTEXT_SOURCE_KINDS = ["message", "mail", "document", "meeting"];
 /** Changes whenever the cited text, its title or its revision does; a staged finding citing an older one is stale. */
 export const contextEvidenceFingerprint = (item) => createHash("sha256")
     .update(JSON.stringify(["context-evidence-v1", item.ref, item.title, item.text, item.revision]))
     .digest("hex");
+/** How many rows, in reading order, fit the allowance together; none when the first alone is larger. */
+export const fittingRows = (sizes, limit, maxReadBytes) => {
+    let count = 0, bytes = 0;
+    for (const size of sizes.slice(0, limit)) {
+        if (!(bytes + size <= maxReadBytes))
+            break;
+        bytes += size;
+        count++;
+    }
+    return { count, bytes };
+};
 export const contextCursorScope = (request) => createHash("sha256")
     .update(JSON.stringify([
     "context-evidence-v1",
@@ -56,7 +68,7 @@ export const contextEvidenceRequest = (input) => {
     if (!words.length || words.length > 16)
         throw new CliError("validation_error", "query needs 1–16 literal words");
     const limit = integer(input.limit ?? 10, "limit", 1, 20);
-    const maxReadBytes = integer(input.maxReadBytes ?? 65536, "maxReadBytes", 1, 262144);
+    const maxReadBytes = integer(input.maxReadBytes ?? 65536, "maxReadBytes", 1, CONTEXT_MAX_READ_BYTES);
     if (input.cursor !== undefined && (!input.cursor || typeof input.cursor !== "object"))
         throw new CliError("validation_error", "cursor needs at, id and scope");
     if (input.cursor)

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/meeting-communications-preparation.js

@@ -41,6 +41,10 @@ export const readPreparationCommunications = async (plan, signal) => {
                 coverage.state = "unavailable";
                 coverage.issue = "not_found";
             }
+            else if (page.oversized) {
+                coverage.state = "read-limited";
+                coverage.issue = "validation_error";
+            }
             else if (page.coverage.index !== "ready")
                 coverage.issue = "configuration_error";
             const refs = new Set();

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/project-gathering-around.d.ts

@@ -20,6 +20,14 @@ export interface ProjectNeighbourReader {
     }[]>;
 }
 export declare const storedMessageNeighbours: (messages: Pick<MessagesStore, "around">) => ProjectNeighbourReader;
+/** The paragraphs around the first one that names the query, in document order; the hit's own is marked found. */
+export declare const documentPassage: (text: string, query: string, window: {
+    before: number;
+    after: number;
+}) => {
+    text: string;
+    found: boolean;
+}[];
 /**
  * Neighbours are context for reading a hit, not matches: they never join `items`, and their text counts against
  * the run's read bytes.

package/dist/services/project-gathering-around.js

@@ -1,5 +1,6 @@
 import { CliError } from "@wirecat/cli-base";
 import { formatLocator, parseLocator } from "../domain/locator.js";
+import { fold } from "../store/normalize.js";
 import { excerpt } from "./excerpt.js";
 export const storedMessageNeighbours = (messages) => ({
     async around(ref, window) {
@@ -17,6 +18,23 @@ export const storedMessageNeighbours = (messages) => ({
         }));
     },
 });
+const wordsOf = (text) => (text.match(/[\p{L}\p{N}\p{M}]+/gu) ?? []).map(fold);
+/** The paragraphs around the first one that names the query, in document order; the hit's own is marked found. */
+export const documentPassage = (text, query, window) => {
+    const paragraphs = text
+        .split(/\n\s*\n/)
+        .map((part) => part.replace(/\s+/g, " ").trim())
+        .filter(Boolean);
+    const words = new Set(wordsOf(query));
+    const hit = paragraphs.findIndex((part) => wordsOf(part).some((word) => words.has(word)));
+    if (hit < 0 || paragraphs.length < 2)
+        return [];
+    const from = Math.max(0, hit - window.before);
+    return paragraphs.slice(from, hit + window.after + 1).map((part, index) => ({
+        text: excerpt(part, query, 200, { literal: true }),
+        found: from + index === hit,
+    }));
+};
 /**
  * Neighbours are context for reading a hit, not matches: they never join `items`, and their text counts against
  * the run's read bytes.

package/dist/services/project-gathering.d.ts

@@ -79,6 +79,12 @@ export declare const gatherProjectEvidence: (ports: ProjectGatheringPorts, reque
         issue: string | null;
     }[];
     items: ProjectEvidenceItem[];
+    oversized: {
+        ref: string;
+        lanes: string[];
+        source: number;
+        bytes: number;
+    }[];
     matchedAgain: {
         ref: string;
         lanes: string[];

package/dist/services/project-gathering.js

@@ -1,8 +1,8 @@
 import { CliError } from "@wirecat/cli-base";
-import { contextEvidenceFingerprint } from "../context/evidence.js";
+import { CONTEXT_MAX_READ_BYTES, contextEvidenceFingerprint } from "../context/evidence.js";
 import { createContextEvidenceReader } from "./context-evidence.js";
 import { excerpt } from "./excerpt.js";
-import { attachNeighbours } from "./project-gathering-around.js";
+import { attachNeighbours, documentPassage, } from "./project-gathering-around.js";
 import { decodeCheckpoint, encodeCheckpoint, projectGatheringRequest, projectUnits, seenKey, } from "./project-gathering-request.js";
 const terminal = new Set(["done", "unavailable", "failed"]);
 export const gatherProjectEvidence = async (ports, request) => {
@@ -72,6 +72,7 @@ export const gatherProjectEvidence = async (ports, request) => {
     const items = [];
     const byRef = new Map();
     const matchedAgain = new Map();
+    const oversized = new Map();
     let stopped = null;
     const open = (u) => !terminal.has(u.state) && u.state !== "read-limited";
     const take = (item, lane, kind, source) => {
@@ -101,6 +102,18 @@ export const gatherProjectEvidence = async (ports, request) => {
             lanes: [lane.id],
             context: lane.kinds.every((k) => k === "person") ? "person-only" : "project",
         };
+        if (kind === "document" && plan.around.before + plan.around.after) {
+            entry.around = [];
+            for (const part of documentPassage(item.text, lane.query, plan.around)) {
+                const bytes = Buffer.byteLength(part.text);
+                if (bytes > plan.budgets.maxReadBytes - usage.readBytes - usage.aroundBytes) {
+                    entry.aroundIssue = "read-bytes";
+                    break;
+                }
+                usage.aroundBytes += bytes;
+                entry.around.push({ ref: item.ref, at: item.at, sender: null, ...part });
+            }
+        }
         byRef.set(item.ref, entry);
         items.push(entry);
         usage.items++;
@@ -126,24 +139,49 @@ export const gatherProjectEvidence = async (ports, request) => {
                                 : null;
             if (stopped)
                 break;
-            const allowance = Math.min(plan.budgets.maxPageBytes, plan.budgets.maxReadBytes - usage.readBytes);
-            const reader = createContextEvidenceReader(ports.evidence, [unit.source], {
-                maxReads: 1,
-                maxTotalReadBytes: allowance,
-            });
-            usage.reads++;
-            try {
-                const page = await reader.read({
-                    source: unit.source,
-                    query: unit.lane.query,
-                    after: unit.chunk.after,
-                    before: unit.chunk.before,
-                    limit: 20,
-                    maxReadBytes: allowance,
-                    ...(state.cursor ? { cursor: state.cursor } : {}),
-                    signal,
+            const readPage = async (allowance, limit) => {
+                const reader = createContextEvidenceReader(ports.evidence, [unit.source], {
+                    maxReads: 1,
+                    maxTotalReadBytes: allowance,
                 });
-                usage.readBytes += page.readBytes;
+                usage.reads++;
+                try {
+                    const page = await reader.read({
+                        source: unit.source,
+                        query: unit.lane.query,
+                        after: unit.chunk.after,
+                        before: unit.chunk.before,
+                        limit,
+                        maxReadBytes: allowance,
+                        ...(state.cursor ? { cursor: state.cursor } : {}),
+                        signal,
+                    });
+                    usage.readBytes += page.readBytes;
+                    return page;
+                }
+                catch (error) {
+                    usage.readBytes += reader.usage().chargedBytes;
+                    throw error;
+                }
+            };
+            try {
+                let page = await readPage(Math.min(plan.budgets.maxPageBytes, plan.budgets.maxReadBytes - usage.readBytes), 20);
+                const big = page.oversized;
+                if (big && big.bytes <= CONTEXT_MAX_READ_BYTES) {
+                    if (big.bytes > plan.budgets.maxReadBytes - usage.readBytes || usage.reads >= plan.budgets.maxReads) {
+                        state.state = "read-limited";
+                        state.code = "validation_error";
+                        continue;
+                    }
+                    page = await readPage(big.bytes, 1);
+                }
+                else if (big) {
+                    const known = oversized.get(big.ref);
+                    if (!known)
+                        oversized.set(big.ref, { ref: big.ref, lanes: [unit.lane.id], source: unit.sourceIndex, bytes: big.bytes });
+                    else if (!known.lanes.includes(unit.lane.id))
+                        known.lanes.push(unit.lane.id);
+                }
                 state.pages++;
                 state.code = page.coverage.index === "ready" ? null : `index-${page.coverage.index}`;
                 for (const item of page.items)
@@ -161,7 +199,6 @@ export const gatherProjectEvidence = async (ports, request) => {
             }
             catch (error) {
                 signal?.throwIfAborted();
-                usage.readBytes += reader.usage().chargedBytes;
                 if (!(error instanceof CliError))
                     throw error;
                 if (error.code === "validation_error" && error.details?.reason === "context.read-budget")
@@ -225,6 +262,7 @@ export const gatherProjectEvidence = async (ports, request) => {
             issue: progress[index]?.code ?? null,
         })),
         items,
+        oversized: [...oversized.values()],
         matchedAgain: [...matchedAgain].map(([ref, lanes]) => ({ ref, lanes: [...lanes] })),
         usage: { ...usage, elapsedMs: now() - started },
         totals,

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/dist/store/sqlite/context-evidence.js

@@ -1,5 +1,4 @@
-import { CliError } from "@wirecat/cli-base";
-import { contextCursorScope, contextEvidenceRequest, } from "../../context/evidence.js";
+import { contextCursorScope, contextEvidenceRequest, fittingRows, } from "../../context/evidence.js";
 import { formatLocator, parseLocator } from "../../domain/locator.js";
 import { NORMALIZER_VERSION, normalize } from "../normalize.js";
 import { contextDocumentTime, contextDocumentTimeKind, contextDocumentUrl } from "./context-document-source.js";
@@ -122,38 +121,48 @@ export const contextEvidenceOver = ({ database }) => ({
             if (cursor)
                 params.push(cursor.at, cursor.at, cursor.id);
             params.push(limit + 1);
-            const probe = database
-                .prepare(`SELECT coalesce(sum(
+            const sized = database
+                .prepare(`SELECT id,at,provider,account,chat,external_id,
         length(CAST(coalesce(title,'') AS BLOB))+length(CAST(coalesce(body,'') AS BLOB))+
         length(CAST(coalesce(url,'') AS BLOB))+length(CAST(provider AS BLOB))+
         length(CAST(account AS BLOB))+length(CAST(external_id AS BLOB))+
-        length(CAST(coalesce(chat,'') AS BLOB))+length(CAST(time_kind AS BLOB))),0) AS bytes FROM (${selection})`)
-                .get(...params);
-            const readBytes = Number(probe?.bytes);
-            if (!Number.isSafeInteger(readBytes) || readBytes < 0 || readBytes > maxReadBytes)
-                throw new CliError("validation_error", "context evidence exceeds maxReadBytes before hydration", {
-                    reason: "context.read-budget",
+        length(CAST(coalesce(chat,'') AS BLOB))+length(CAST(time_kind AS BLOB)) AS bytes FROM (${selection})`)
+                .all(...params);
+            const refOf = (row) => source.kind === "document"
+                ? `document:${row.id}`
+                : formatLocator({
+                    provider: String(row.provider),
+                    account: String(row.account),
+                    chat: String(row.chat),
+                    message: String(row.external_id),
                 });
+            const past = (row) => ({ at: Number(row.at), id: Number(row.id), scope });
+            const fit = fittingRows(sized.map((row) => Number(row.bytes)), limit, maxReadBytes);
+            const first = sized[0];
+            if (!fit.count && first) {
+                coverage.hasMore = sized.length > 1;
+                return {
+                    source,
+                    items: [],
+                    readBytes: 0,
+                    coverage,
+                    next: coverage.hasMore ? past(first) : null,
+                    oversized: { ref: refOf(first), bytes: Number(first.bytes) },
+                };
+            }
             signal?.throwIfAborted();
-            const rows = database.prepare(selection).all(...params);
+            params[params.length - 1] = fit.count;
+            const selected = fit.count ? database.prepare(selection).all(...params) : [];
             signal?.throwIfAborted();
-            coverage.hasMore = rows.length > limit;
-            const selected = rows.slice(0, limit);
+            coverage.hasMore = sized.length > selected.length;
             const last = selected.at(-1);
             return {
                 source,
-                readBytes,
+                readBytes: fit.bytes,
                 coverage,
-                next: coverage.hasMore && last ? { at: Number(last.at), id: Number(last.id), scope } : null,
+                next: coverage.hasMore && last ? past(last) : null,
                 items: selected.map((row) => ({
-                    ref: source.kind === "document"
-                        ? `document:${row.id}`
-                        : formatLocator({
-                            provider: String(row.provider),
-                            account: String(row.account),
-                            chat: String(row.chat),
-                            message: String(row.external_id),
-                        }),
+                    ref: refOf(row),
                     provider: String(row.provider),
                     account: String(row.account),
                     title: row.title == null ? null : String(row.title),

package/dist/store/sqlite/context-meeting-source.js

@@ -1,5 +1,4 @@
-import { CliError } from "@wirecat/cli-base";
-import { contextCursorScope } from "../../context/evidence.js";
+import { contextCursorScope, fittingRows, } from "../../context/evidence.js";
 import { normalize } from "../normalize.js";
 import { read } from "./transaction.js";
 /** Transcript cues keep their retained revision reference; a meeting title alone is not a transcript match. */
@@ -57,29 +56,40 @@ export const readMeetingContextEvidence = (database, request) => {
         if (cursor)
             params.push(cursor.at, cursor.at, cursor.id);
         params.push(limit + 1);
-        const probe = database
-            .prepare(`SELECT coalesce(sum(length(CAST(coalesce(title,'') AS BLOB))+
+        const sized = database
+            .prepare(`SELECT id,at,ref,length(CAST(coalesce(title,'') AS BLOB))+
         length(CAST(text AS BLOB))+length(CAST(provider AS BLOB))+
-        length(CAST(account AS BLOB))+length(CAST(ref AS BLOB))+length('meeting-start')),0) AS bytes FROM (${selection})`)
-            .get(...params);
-        const readBytes = Number(probe?.bytes);
-        if (!Number.isSafeInteger(readBytes) || readBytes < 0 || readBytes > maxReadBytes)
-            throw new CliError("validation_error", "meeting context evidence exceeds maxReadBytes before hydration", {
-                reason: "context.read-budget",
-            });
+        length(CAST(account AS BLOB))+length(CAST(ref AS BLOB))+length('meeting-start') AS bytes FROM (${selection})`)
+            .all(...params);
+        const past = (row) => ({
+            at: Number(row.at),
+            id: Number(row.id),
+            scope: contextCursorScope(request),
+        });
+        const fit = fittingRows(sized.map((row) => Number(row.bytes)), limit, maxReadBytes);
+        const first = sized[0];
+        if (!fit.count && first) {
+            coverage.hasMore = sized.length > 1;
+            return {
+                source,
+                items: [],
+                readBytes: 0,
+                coverage,
+                next: coverage.hasMore ? past(first) : null,
+                oversized: { ref: String(first.ref), bytes: Number(first.bytes) },
+            };
+        }
         signal?.throwIfAborted();
-        const rows = database.prepare(selection).all(...params);
+        params[params.length - 1] = fit.count;
+        const selected = fit.count ? database.prepare(selection).all(...params) : [];
         signal?.throwIfAborted();
-        coverage.hasMore = rows.length > limit;
-        const selected = rows.slice(0, limit);
+        coverage.hasMore = sized.length > selected.length;
         const last = selected.at(-1);
         return {
             source,
-            readBytes,
+            readBytes: fit.bytes,
             coverage,
-            next: coverage.hasMore && last
-                ? { at: Number(last.at), id: Number(last.id), scope: contextCursorScope(request) }
-                : null,
+            next: coverage.hasMore && last ? past(last) : null,
             items: selected.map((row) => ({
                 ref: String(row.ref),
                 provider: String(row.provider),

package/dist/store/sqlite/evidence-findings.js

@@ -54,9 +54,9 @@ export const evidenceFindingsStoreOver = (context) => {
             receipt: proposal.result,
         };
     };
-    const snapshot = (input) => {
+    const cite = () => {
         let readBytes = 0;
-        return core.snapshot(input, (evidence, _finding, _project, seen) => {
+        return (evidence, _finding, _project, seen) => {
             if (seen.has(evidence.reference)) {
                 if (seen.get(evidence.reference) !== evidence.fingerprint)
                     return stale();
@@ -72,8 +72,9 @@ export const evidenceFindingsStoreOver = (context) => {
             if (fingerprint !== evidence.fingerprint)
                 return stale();
             seen.set(evidence.reference, fingerprint);
-        });
+        };
     };
+    const snapshot = (input) => core.snapshot(input, cite());
     const decider = (by) => {
         if (by === undefined || by === "owner")
             return { author: "owner", decision: { by: "owner" } };
@@ -109,6 +110,7 @@ export const evidenceFindingsStoreOver = (context) => {
                     return view(proposal);
                 }
                 const snapshotHash = snapshot(input);
+                const snapshotParts = core.snapshotParts(input, cite());
                 const fingerprints = input.findings.map(findingFingerprint);
                 if (new Set(fingerprints).size !== fingerprints.length)
                     return invalid("the batch contains duplicate findings");
@@ -116,7 +118,7 @@ export const evidenceFindingsStoreOver = (context) => {
                     kind: EVIDENCE_FINDINGS_KIND,
                     by,
                     target: [...projects][0],
-                    payload: { ...input, inputHash, snapshotHash, agentModel: by.model ?? null },
+                    payload: { ...input, inputHash, snapshotHash, snapshotParts, agentModel: by.model ?? null },
                 }));
             });
         },
@@ -152,9 +154,21 @@ export const evidenceFindingsStoreOver = (context) => {
                 return batch;
             }
             const input = proposal.payload;
-            // Rejecting creates nothing, so a batch whose evidence changed can still be closed.
-            if (accepted.length && snapshot(batch.input) !== input.snapshotHash)
-                return stale();
+            // Rejecting creates nothing, so a batch whose evidence changed can still be closed. Accepting needs only the
+            // accepted findings' own project, assignee and evidence unchanged; a batch staged before parts were kept needs all.
+            if (accepted.length) {
+                const parts = input.snapshotParts;
+                if (!parts) {
+                    if (snapshot(batch.input) !== input.snapshotHash)
+                        return stale();
+                }
+                else {
+                    const chosen = { ...batch.input, findings: batch.input.findings.filter((f) => accepted.includes(f.id)) };
+                    const now = core.snapshotParts(chosen, cite());
+                    if (Object.entries(now).some(([key, hash]) => parts[key] !== hash))
+                        return stale();
+                }
+            }
             if (proposal.proposedBy.type !== "bot" || !proposal.proposedBy.name)
                 return invalid("a findings author must be an agent");
             const agent = {

package/dist/store/sqlite/findings-core.d.ts

@@ -12,6 +12,7 @@ export declare const findingsAgent: (agent: FindingsAgent) => FindingsAgent;
  */
 export declare const findingsCoreOver: (context: StoreContext, kind: string) => {
     snapshot: (input: FindingsInput, cite: (evidence: FindingEvidence, finding: Finding, projectId: string, seen: Map<string, unknown>) => void) => string;
+    snapshotParts: (input: FindingsInput, cite: (evidence: FindingEvidence, finding: Finding, projectId: string, seen: Map<string, unknown>) => void) => Record<string, string>;
     previous: (account: number | null, fingerprint: string) => FindingOutcome | undefined;
     outcomes: (account: number | null, input: FindingsInput, accepted: string[], agent: FindingsAgent) => FindingOutcome[];
 };

package/dist/store/sqlite/findings-core.js

@@ -27,7 +27,7 @@ export const findingsCoreOver = (context, kind) => {
     const { database } = context;
     const facts = factOperationsOver(context);
     const tasks = workTaskOperationsOver(context);
-    const snapshot = (input, cite) => {
+    const cited = (input, cite) => {
         const seen = new Map();
         for (const finding of input.findings) {
             const project = requiredThing(database, finding.project, "the project");
@@ -51,8 +51,11 @@ export const findingsCoreOver = (context, kind) => {
             for (const evidence of finding.evidence)
                 cite(evidence, finding, String(project.id), seen);
         }
-        return findingHash([...seen].sort(([a], [b]) => a.localeCompare(b)));
+        return seen;
     };
+    const snapshot = (...args) => findingHash([...cited(...args)].sort(([a], [b]) => a.localeCompare(b)));
+    /** The same snapshot, one hash per project, person and cited reference, so part of a batch can be checked alone. */
+    const snapshotParts = (...args) => Object.fromEntries([...cited(...args)].map(([key, value]) => [key, findingHash(value)]));
     const previous = (account, fingerprint) => {
         const row = database
             .prepare("SELECT substr(j.value,1,4096) AS item FROM proposed_actions p,json_each(p.result,'$.items') j WHERE p.account_id IS ? AND p.kind=? AND p.status='approved' AND json_extract(j.value,'$.fingerprint')=? ORDER BY p.id LIMIT 1")
@@ -104,5 +107,5 @@ export const findingsCoreOver = (context, kind) => {
             reused: false,
         };
     });
-    return { snapshot, previous, outcomes };
+    return { snapshot, snapshotParts, previous, outcomes };
 };

package/package.json

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