@wirecat/cli-core 0.544.0 → 0.546.0

package/dist/services/messages.js

@@ -3,6 +3,7 @@ import { validateFormattedText, visibleFormattedText } from "../domain/formattin
 import { formatLocator } from "../domain/locator.js";
 import { fileLinks, messageLinkTarget, validatePermalink } from "../domain/message-link.js";
 import { pinDurationsText } from "../domain/pin-duration.js";
+import { ensureAccount } from "../domain/ref-arguments.js";
 import { threadIdOf } from "../domain/thread.js";
 import { capability } from "../ports/messenger.js";
 import { codeOf, guardedWrite, sentIds } from "../sends/guarded.js";
@@ -31,6 +32,14 @@ const filesOf = ({ attachments }) => {
 export const messagesService = (deps) => {
     const { guard } = deps;
     const inStore = async (read) => read(await deps.store(), await deps.account());
+    /** A message named by a reference is read only in the account the reference names; the store is not opened to say so. */
+    const ownTarget = async (target, account) => {
+        if (account.provider !== deps.messenger.provider)
+            throw new CliError("validation_error", "that locator belongs to another account; select its profile first");
+        if (target.account === undefined)
+            return;
+        await ensureAccount({ text: target.text, account: target.account }, { account: account.account, ...(deps.profile === undefined ? {} : { profile: deps.profile }) });
+    };
     const serverThenStore = async (store, account, query) => {
         const server = await searchServer(deps, query);
         const only = query.backend === "server" && server
@@ -151,11 +160,8 @@ export const messagesService = (deps) => {
         },
         around: async (reference, message, window) => {
             const target = messageLinkTarget(reference, message, deps.messenger.provider);
-            if (target.account !== undefined) {
-                const account = await deps.account();
-                if (account.provider !== deps.messenger.provider || target.account !== account.account)
-                    throw new CliError("validation_error", "that locator belongs to another account; select its profile first");
-            }
+            if (target.account !== undefined)
+                await ownTarget(target, await deps.account());
             if (fromStore(deps)) {
                 return inStore(async (store, account) => store.messages.around(account, await readChatId(deps, target.chat, store, account), target.message, window));
             }
@@ -163,9 +169,7 @@ export const messagesService = (deps) => {
         },
         thread: (reference, message, options) => inStore(async (store, account) => {
             const target = messageLinkTarget(reference, message, deps.messenger.provider);
-            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");
+            await ownTarget(target, account);
             return readThreadContext(store, account, await storedChatId(deps.messenger, target.chat, store, account, { includeLeft: true }), target.message, options);
         }),
         comments: async (chat, typedPost, window) => {
@@ -184,9 +188,7 @@ export const messagesService = (deps) => {
         link: async (reference, message) => {
             const target = messageLinkTarget(reference, message, deps.messenger.provider);
             const account = await deps.account();
-            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");
+            await ownTarget(target, account);
             if (fromStore(deps)) {
                 const store = await deps.store();
                 const chat = await readChatId(deps, target.chat, store, account);
@@ -227,8 +229,8 @@ export const messagesService = (deps) => {
         },
         download: async (reference, message) => {
             const target = messageLinkTarget(reference, message, deps.messenger.provider);
-            if (target.account !== undefined && target.account !== (await deps.account()).account)
-                throw new CliError("validation_error", "that locator belongs to another account; select its profile first");
+            if (target.account !== undefined)
+                await ownTarget(target, await deps.account());
             const connection = await deps.connection();
             const download = capability(connection, "download", "download attachments");
             return download((await connection.resolve(target.chat)).id, target.message);

package/dist/services/money-words.d.ts

@@ -0,0 +1,3 @@
+export { MONEY_DONE, MONEY_REQUEST, MONEY_WORDS, PROMISE } from "../domain/money-words.js";
+/** The money classes the text's words belong to; none for a text with no money verb. */
+export declare const moneyClassesOf: (text: string) => string[];

package/dist/services/money-words.js

@@ -0,0 +1,5 @@
+import { MONEY_WORDS } from "../domain/money-words.js";
+import { listsHit } from "./task-categories.js";
+export { MONEY_DONE, MONEY_REQUEST, MONEY_WORDS, PROMISE } from "../domain/money-words.js";
+/** The money classes the text's words belong to; none for a text with no money verb. */
+export const moneyClassesOf = (text) => listsHit(text, MONEY_WORDS);

package/dist/services/questions.d.ts

@@ -9,9 +9,14 @@ export declare const unanswered: (messages: Message[], { answerers, before }: {
     answerers: ReadonlySet<Id>;
     before: number;
 }) => Message[];
-/** Every question from others, as `unanswered` reads them, with the message that answered it, if one did. */
-export declare const questions: (messages: Message[], { answerers }: {
+/**
+ * Every question from others, as `unanswered` reads them, with the message that answered it, if one did.
+ * With `asker: "owner"` it is the owner's own questions instead, and anyone but the owner answers: by replying to
+ * it, or by speaking next. `answerers` is not read then.
+ */
+export declare const questions: (messages: Message[], { answerers, asker }: {
     answerers: ReadonlySet<Id>;
+    asker?: "others" | "owner";
 }) => {
     question: Message;
     answer?: Message;

package/dist/services/questions.js

@@ -9,12 +9,21 @@ const LINKS = /https?:\/\/\S+/g;
 export const unanswered = (messages, { answerers, before }) => questions(messages, { answerers })
     .filter(({ question, answer }) => answer === undefined && Date.parse(question.timestamp) < before)
     .map(({ question }) => question);
-/** Every question from others, as `unanswered` reads them, with the message that answered it, if one did. */
-export const questions = (messages, { answerers }) => {
-    const answers = (message) => message.outgoing === true || (message.senderId !== null && answerers.has(message.senderId));
+/**
+ * Every question from others, as `unanswered` reads them, with the message that answered it, if one did.
+ * With `asker: "owner"` it is the owner's own questions instead, and anyone but the owner answers: by replying to
+ * it, or by speaking next. `answerers` is not read then.
+ */
+export const questions = (messages, { answerers, asker = "others" }) => {
+    const fromOwner = (message) => message.outgoing === true;
+    const answers = asker === "owner"
+        ? (message) => !fromOwner(message)
+        : (message) => fromOwner(message) || (message.senderId !== null && answerers.has(message.senderId));
     const byId = new Map(messages.map((message) => [message.id, message]));
     // Telegram names only the id a reply answers; the message itself is found in the window, or not at all.
     const repliesToAnswerer = (message) => {
+        if (asker === "owner")
+            return false;
         const to = message.replyTo?.id ?? message.replyToId;
         const quoted = to === undefined ? undefined : byId.get(to);
         if (quoted)
@@ -22,7 +31,7 @@ export const questions = (messages, { answerers }) => {
         return (message.replyTo !== null && (message.replyTo.outgoing === true || answerers.has(message.replyTo.senderId ?? "")));
     };
     return messages.flatMap((message, index) => {
-        if (answers(message))
+        if (asker === "owner" ? !fromOwner(message) : answers(message))
             return [];
         const transcript = "transcript" in message && typeof message.transcript === "string" ? message.transcript : "";
         if (![message.text, transcript].join("\n").replace(LINKS, "").includes("?") && !repliesToAnswerer(message))

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

@@ -34,6 +34,15 @@ export interface StoredProjectInput {
 }
 /** `project:<id>`, or the one project a key, name or alias names; several or none is refused, never guessed. */
 export declare const canonicalProjectRef: (store: MessageStore, reference: string) => Promise<string>;
+export interface LinkedChat {
+    provider: string;
+    account: string;
+    chat: string;
+    /** The link's free role (`source report`, `what worked`), if the owner set one. */
+    role: string | null;
+}
+/** Only links the owner confirmed: a suggested one would put a whole chat into the evidence on a guess. */
+export declare const linkedChatsOf: (store: MessageStore, project: string | null) => Promise<LinkedChat[]>;
 export type StoredProjectGathering = Awaited<ReturnType<typeof gatherProjectEvidence>> & {
     projectRef: string | null;
     unreadSources: {

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

@@ -118,7 +118,7 @@ const memberLanesOf = async (store, project, given, room) => {
     return { lanes, left };
 };
 /** Only links the owner confirmed: a suggested one would put a whole chat into the evidence on a guess. */
-const linkedChatsOf = async (store, project) => {
+export const linkedChatsOf = async (store, project) => {
     if (!project)
         return [];
     const chats = [];
@@ -129,9 +129,14 @@ const linkedChatsOf = async (store, project) => {
             continue;
         const reference = parseReference(relation.from);
         if (reference.type === "chat")
-            chats.push(reference);
+            chats.push({
+                provider: reference.provider,
+                account: reference.account,
+                chat: reference.chat,
+                role: relation.role,
+            });
     }
-    return chats.map(({ provider, account, chat }) => ({ provider, account, chat }));
+    return chats;
 };
 /**
  * `projects evidence` over a whole store: the project's names, key and aliases, the given words and contacts, its
@@ -158,7 +163,7 @@ export const gatherStoredProject = async (store, input) => {
     const members = await memberLanesOf(store, project.ref, new Set(contacts.flatMap((one) => one.reference ?? [])), room);
     const people = [...contacts, ...members.lanes];
     const linked = await linkedChatsOf(store, project.ref);
-    const linkedChats = linked.slice(0, LINKED_CHATS);
+    const linkedChats = linked.slice(0, LINKED_CHATS).map(({ provider, account, chat }) => ({ provider, account, chat }));
     const budgets = {
         ...(input.maxReads === undefined ? {} : { maxReads: input.maxReads }),
         ...(input.limit === undefined ? {} : { maxItems: input.limit }),

package/dist/services/task-categories.d.ts

@@ -2,6 +2,8 @@ import { type TaskCategory } from "../domain/task-categories.js";
 export { DEFAULT_TASK_CATEGORIES, FALLBACK_CATEGORY, parseTaskCategory, type TaskCategory, type UnlistedCategory, unlistedNote, withTaskCategory, } from "../domain/task-categories.js";
 /** A category the list holds, or a refusal that names the list. */
 export declare const taskCategoryOf: (categories?: readonly TaskCategory[], flag?: string) => (typed: string) => string;
+/** The names of every list the text hits, so a message can be a request and a promise at once. */
+export declare const listsHit: (text: string, categories: readonly TaskCategory[]) => string[];
 /**
  * The category with the most distinct trigger stems in the text; none is `other`, a tie goes to the earlier one.
  * A word hits by its English stem first, so a cognate (`hospital`) counts once, not twice.

package/dist/services/task-categories.js

@@ -38,15 +38,12 @@ const triggerStems = (categories) => {
     stemsByList.set(categories, built);
     return built;
 };
-/**
- * The category with the most distinct trigger stems in the text; none is `other`, a tie goes to the earlier one.
- * A word hits by its English stem first, so a cognate (`hospital`) counts once, not twice.
- */
-export const categorize = (text, categories = DEFAULT_TASK_CATEGORIES) => {
+/** For each list the text hits, the number of distinct trigger stems it hit, in list order. */
+const hitsByList = (text, categories) => {
     const stem = stemmersOf();
     const english = stem.english.stemTokens(text);
     const spanish = readsSpanish(text) ? stem.spanish.stemTokens(text) : [];
-    let best = { name: FALLBACK_CATEGORY, hits: 0 };
+    const counted = [];
     for (const triggers of triggerStems(categories)) {
         const hit = new Set();
         english.forEach((word, at) => {
@@ -56,8 +53,22 @@ export const categorize = (text, categories = DEFAULT_TASK_CATEGORIES) => {
             else if (other !== undefined && triggers.spanish.has(other))
                 hit.add(other);
         });
-        if (hit.size > best.hits)
-            best = { name: triggers.name, hits: hit.size };
+        counted.push({ name: triggers.name, hits: hit.size });
     }
+    return counted;
+};
+/** The names of every list the text hits, so a message can be a request and a promise at once. */
+export const listsHit = (text, categories) => hitsByList(text, categories)
+    .filter(({ hits }) => hits > 0)
+    .map(({ name }) => name);
+/**
+ * The category with the most distinct trigger stems in the text; none is `other`, a tie goes to the earlier one.
+ * A word hits by its English stem first, so a cognate (`hospital`) counts once, not twice.
+ */
+export const categorize = (text, categories = DEFAULT_TASK_CATEGORIES) => {
+    let best = { name: FALLBACK_CATEGORY, hits: 0 };
+    for (const counted of hitsByList(text, categories))
+        if (counted.hits > best.hits)
+            best = counted;
     return best.name;
 };

package/dist/store/chats.d.ts

@@ -1,8 +1,10 @@
 import type { ChannelTagMatch } from "../domain/channel-tags.js";
 import type { Chat, ChatKind, ChatUpdate, Id, Page } from "../domain/models.js";
+import type { HistorySkip } from "../services/history-limits.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 { ChatHistoryShape, StoredHistorySkip } from "./sqlite/history-skips.js";
 import type { StoreContext } from "./sqlite/open.js";
 import type { Where } from "./sqlite/query-filter.js";
 import type { AccountKey, ChatActivity, ChatStats, StoredChatFilter } from "./types.js";
@@ -64,6 +66,14 @@ export interface ChatsStore {
      * `chatId` itself. Only for finding the chat: the old id and its history are never shown or searched.
      */
     renamedChatId(key: AccountKey, chatId: Id): Promise<Id | undefined>;
+    /** Per stored chat: its kind, how many people, and whether the owner lifted its history limits. */
+    historyShapes(key: AccountKey, chatIds: Id[]): Promise<Map<Id, ChatHistoryShape>>;
+    /** Adds what the history limits left out of pushed history, per chat. */
+    recordHistorySkips(key: AccountKey, skips: Map<Id, HistorySkip>): Promise<void>;
+    /** Lifts the history limits for one chat, or puts them back; `false` when the store does not know the chat. */
+    setHistoryIncluded(key: AccountKey, chatId: Id, included: boolean): Promise<boolean>;
+    /** Every chat whose pushed history the limits left out, most messages first. */
+    historySkips(key: AccountKey): Promise<StoredHistorySkip[]>;
     /** A stored chat's kind, with or without messages; `undefined` when the store does not know the chat. */
     chatKind(key: AccountKey, chatId: Id): Promise<ChatKind | undefined>;
     /** A stored chat's title, with or without messages; `null` when it has none or the store does not know the chat. */

package/dist/store/chats.js

@@ -3,6 +3,7 @@ import { keysOver } from "./keys.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 history from "./sqlite/history-skips.js";
 import * as reads from "./sqlite/reads.js";
 import { write } from "./sqlite/transaction.js";
 export const chatsStoreOver = (context) => {
@@ -85,6 +86,30 @@ export const chatsStoreOver = (context) => {
             const accountKey = findAccountPk(key);
             return accountKey === undefined ? undefined : chatQueries.renamedChatId(context, accountKey, chatId);
         },
+        historyShapes: async (key, chatIds) => {
+            const accountKey = findAccountPk(key);
+            return accountKey === undefined ? new Map() : history.historyShapes(context, accountKey, chatIds);
+        },
+        recordHistorySkips: async (key, skips) => {
+            const accountKey = findAccountPk(key);
+            if (accountKey === undefined || skips.size === 0)
+                return;
+            write(database, () => history.recordHistorySkips(context, accountKey, skips));
+        },
+        setHistoryIncluded: async (key, chatId, included) => {
+            const accountKey = findAccountPk(key);
+            if (accountKey === undefined)
+                return false;
+            let done = false;
+            write(database, () => {
+                done = history.setHistoryIncluded(context, accountKey, chatId, included);
+            });
+            return done;
+        },
+        historySkips: async (key) => {
+            const accountKey = findAccountPk(key);
+            return accountKey === undefined ? [] : history.historySkips(context, accountKey);
+        },
         chatKind: async (key, chatId) => {
             const accountKey = findAccountPk(key);
             if (accountKey === undefined)

package/dist/store/sqlite/chats.js

@@ -1,6 +1,7 @@
 import { CliError } from "@wirecat/cli-base";
 import { and, eq, inArray, or, sql } from "./drizzle/core.js";
 import { folded } from "./folded.js";
+import { withoutHistory } from "./history-skips.js";
 import { identityPk } from "./identities.js";
 import { bound } from "./query-filter.js";
 import { chatEventPeople, chatEvents, chatMembers, chats, chunks, fetchLeases, identities, involvements, memberCounts, memberObservationMembers, memberObservations, memberStays, messageReactions, messageRevisions, messages, messageTranscripts, pollVotes, syncRanges, } from "./schema.js";
@@ -395,7 +396,7 @@ const toChat = (row, at, parentId) => ({
         scope: row.scope,
         parentChatId: parentId ?? null,
         membershipState: row.membershipState,
-        providerMetadata: parsed(row.metadata),
+        providerMetadata: withoutHistory(parsed(row.metadata)),
     }),
     ...muteOf(row, at),
     ...present({ archived: flag(row.archived), markedUnread: flag(row.markedUnread) }),

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

@@ -1,5 +1,5 @@
 import { linkKind } from "./link-kinds.js";
-import { canonicalThingReference, referenceOfThing, stateOfThing, storedThing, thingOf } from "./things.js";
+import { referenceOfThing, stateOfThing, storedThing, thingOf } from "./things.js";
 const EXCERPT_CHARS = 280;
 const excerptOf = (text) => {
     if (text == null)
@@ -59,7 +59,7 @@ export const evidenceSourcesOf = (database, from) => database
     .map((link) => sourceOf(database, storedThing(link.to_type, link.to_id)));
 const thingNamed = (database, reference) => {
     try {
-        return thingOf(database, canonicalThingReference(reference));
+        return thingOf(database, reference);
     }
     catch {
         return undefined;

package/dist/store/sqlite/history-skips.d.ts

@@ -0,0 +1,24 @@
+import type { Id } from "../../domain/models.js";
+import type { ChatShape, HistorySkip } from "../../services/history-limits.js";
+import type { StoreContext } from "./open.js";
+/**
+ * The history limits' record of a chat, kept in the chat row's `metadata` under this key so no store version is
+ * needed; `Chat.providerMetadata` leaves it out.
+ */
+export declare const HISTORY_KEY = "$history";
+export interface ChatHistoryShape extends ChatShape {
+    included: boolean;
+}
+export interface StoredHistorySkip extends HistorySkip {
+    chatId: Id;
+    title: string | null;
+}
+export declare const historyShapes: (context: StoreContext, accountKey: number, chatIds: Id[]) => Map<Id, ChatHistoryShape>;
+/** Adds what one push left out to what the chat's record already holds. A chat the store lacks is left as it is. */
+export declare const recordHistorySkips: (context: StoreContext, accountKey: number, skips: Map<Id, HistorySkip>) => void;
+/** Lifts the limits for one chat from now on, or puts them back. Answers `false` for a chat the store lacks. */
+export declare const setHistoryIncluded: (context: StoreContext, accountKey: number, chatId: Id, included: boolean) => boolean;
+/** Every chat of the account whose pushed history the limits left out, most messages first. */
+export declare const historySkips: ({ database }: StoreContext, accountKey: number) => StoredHistorySkip[];
+/** `metadata` as the messenger gave it: the history record is the store's own. */
+export declare const withoutHistory: <T extends Record<string, unknown> | undefined>(metadata: T) => T;

package/dist/store/sqlite/history-skips.js

@@ -0,0 +1,95 @@
+/**
+ * The history limits' record of a chat, kept in the chat row's `metadata` under this key so no store version is
+ * needed; `Chat.providerMetadata` leaves it out.
+ */
+export const HISTORY_KEY = "$history";
+const objectOf = (text) => {
+    if (typeof text !== "string")
+        return {};
+    try {
+        const value = JSON.parse(text);
+        return value !== null && typeof value === "object" && !Array.isArray(value)
+            ? value
+            : {};
+    }
+    catch {
+        return {};
+    }
+};
+const recordOf = (metadata) => {
+    const value = objectOf(metadata)[HISTORY_KEY];
+    return value !== null && typeof value === "object" ? value : {};
+};
+const rowOf = ({ database }, accountKey, chatId) => database
+    .prepare("SELECT id, kind, participants_count, metadata FROM chats WHERE account_id = ? AND external_id = ?")
+    .get(accountKey, chatId);
+const update = (context, id, metadata, change) => {
+    const all = objectOf(metadata);
+    const next = change(recordOf(metadata));
+    if (next.skipped === undefined && !next.included)
+        delete all[HISTORY_KEY];
+    else
+        all[HISTORY_KEY] = next;
+    const text = Object.keys(all).length === 0 ? null : JSON.stringify(all);
+    context.database.prepare("UPDATE chats SET metadata = ?, updated_at = ? WHERE id = ?").run(text, context.now(), id);
+};
+export const historyShapes = (context, accountKey, chatIds) => {
+    const shapes = new Map();
+    for (const chatId of new Set(chatIds)) {
+        const row = rowOf(context, accountKey, chatId);
+        if (!row)
+            continue;
+        shapes.set(chatId, {
+            kind: String(row.kind),
+            participantsCount: row.participants_count == null ? null : Number(row.participants_count),
+            included: recordOf(row.metadata).included === true,
+        });
+    }
+    return shapes;
+};
+/** Adds what one push left out to what the chat's record already holds. A chat the store lacks is left as it is. */
+export const recordHistorySkips = (context, accountKey, skips) => {
+    for (const [chatId, skip] of skips) {
+        const row = rowOf(context, accountKey, chatId);
+        if (!row)
+            continue;
+        update(context, Number(row.id), row.metadata, (held) => {
+            const before = held.skipped;
+            const skipped = before
+                ? {
+                    ...skip,
+                    messages: before.messages + skip.messages,
+                    oldestAt: before.oldestAt < skip.oldestAt ? before.oldestAt : skip.oldestAt,
+                    newestAt: before.newestAt > skip.newestAt ? before.newestAt : skip.newestAt,
+                }
+                : skip;
+            return { ...held, skipped };
+        });
+    }
+};
+/** Lifts the limits for one chat from now on, or puts them back. Answers `false` for a chat the store lacks. */
+export const setHistoryIncluded = (context, accountKey, chatId, included) => {
+    const row = rowOf(context, accountKey, chatId);
+    if (!row)
+        return false;
+    update(context, Number(row.id), row.metadata, (held) => ({ ...held, included }));
+    return true;
+};
+/** Every chat of the account whose pushed history the limits left out, most messages first. */
+export const historySkips = ({ database }, accountKey) => database
+    .prepare(`SELECT external_id, title, metadata FROM chats WHERE account_id = ? AND metadata LIKE '%"${HISTORY_KEY}"%'`)
+    .all(accountKey)
+    .flatMap((row) => {
+    const { skipped } = recordOf(row.metadata);
+    return skipped
+        ? [{ chatId: String(row.external_id), title: row.title == null ? null : String(row.title), ...skipped }]
+        : [];
+})
+    .sort((a, b) => b.messages - a.messages);
+/** `metadata` as the messenger gave it: the history record is the store's own. */
+export const withoutHistory = (metadata) => {
+    if (metadata === undefined || !(HISTORY_KEY in metadata))
+        return metadata;
+    const { [HISTORY_KEY]: _, ...rest } = metadata;
+    return rest;
+};

package/dist/store/sqlite/identities.js

@@ -205,7 +205,7 @@ export const people = ({ orm, database }, provider, { account, accounts: native
         }
     }
     const byId = new Map(everyone.map((person) => [person.id, person]));
-    return { get: (id) => byId.get(id), all: () => everyone };
+    return { provider, get: (id) => byId.get(id), all: () => everyone };
 };
 const contactsWhere = (accountKey, key, { query, notes }) => {
     if (query !== undefined && query.trim().length < 3) {

package/dist/store/sqlite/knowledge.js

@@ -127,7 +127,7 @@ export const knowledgeStoreOver = (context) => {
         if (thing.type === "meeting")
             return { type: "meeting", id: String(thing.id) };
         const reference = referenceOfThing(database, thing);
-        if (reference === undefined || reference.startsWith("meeting:"))
+        if (reference === undefined)
             return undefined;
         const parsed = parseReference(reference);
         if (parsed.type === "message")
@@ -136,7 +136,12 @@ export const knowledgeStoreOver = (context) => {
             return { type: "chat", id: parsed.chat };
         if (parsed.type === "folder")
             return { type: "folder", id: parsed.id, path: parsed.path };
-        if (parsed.type === "entity" || parsed.type === "memory" || parsed.type === "fact" || parsed.type === "bot")
+        if (parsed.type === "entity" ||
+            parsed.type === "memory" ||
+            parsed.type === "fact" ||
+            parsed.type === "bot" ||
+            parsed.type === "event" ||
+            parsed.type === "meeting")
             return undefined;
         return { type: parsed.type, id: parsed.id };
     };

package/dist/store/sqlite/notes.js

@@ -14,7 +14,7 @@ import { LINK_KINDS, LINK_ORIGINS, linkKind } from "./link-kinds.js";
 import { reviewLink } from "./link-reviews.js";
 import { holdingText } from "./note-index.js";
 import { addTags, ensureTag, labelsOf } from "./tags.js";
-import { canonicalThingReference, referenceOfThing, storedThing, thingOf } from "./things.js";
+import { referenceOfThing, storedThing, thingOf } from "./things.js";
 import { write } from "./transaction.js";
 export const NOTE_FORMATS = ["obsidian", "markdown"];
 export { LINK_ORIGINS } from "./link-kinds.js";
@@ -94,7 +94,7 @@ export const linkOf = (database, row) => {
 };
 /** The row a reference names, refused when the store holds none. */
 export const requiredThing = (database, reference, what = "the target") => {
-    const thing = thingOf(database, canonicalThingReference(reference));
+    const thing = thingOf(database, reference);
     if (!thing)
         throw new CliError("not_found", `${what} ${reference} is not in the local store`);
     return thing;
@@ -522,7 +522,7 @@ export const notesStoreOver = (context) => {
             const { limit, offset } = bounded(options.limit, options.offset);
             if (options.source !== undefined)
                 oneOf(options.source, ["file", "internal"], "a note's source");
-            const about = options.about === undefined ? undefined : thingOf(database, canonicalThingReference(options.about));
+            const about = options.about === undefined ? undefined : thingOf(database, options.about);
             if (options.about !== undefined && !about)
                 return { items: [], hasMore: false };
             const folder = options.folderId === undefined ? null : Number(folderRow(options.folderId).id);
@@ -597,7 +597,7 @@ export const notesStoreOver = (context) => {
             const pair = (reference) => {
                 if (reference === undefined)
                     return { known: true, type: null, id: null };
-                const thing = thingOf(database, canonicalThingReference(reference));
+                const thing = thingOf(database, reference);
                 return thing ? { known: true, type: thing.type, id: thing.id } : { known: false, type: null, id: null };
             };
             const from = pair(options.from);

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

@@ -24,4 +24,3 @@ export declare const stateOfThing: (database: CacheDatabase, thing: Thing | unde
 export declare const taskRowOf: (database: CacheDatabase, id: string) => number | undefined;
 /** The package's id for a task row: the reverse of `taskRowOf`. */
 export declare const taskIdOf: (database: CacheDatabase, rowId: number) => string | undefined;
-export declare const canonicalThingReference: (reference: string) => string;

package/dist/store/sqlite/things.js

@@ -1,7 +1,7 @@
 import { formatLocator } from "../../domain/locator.js";
 import { filesAccountSql } from "../../domain/providers.js";
-import { canonicalReference, formatReference, parseReference } from "../../domain/references.js";
-import { canonicalMeetingReference, formatMeetingReference, parseMeetingReference } from "../../meetings/index.js";
+import { formatReference, parseReference } from "../../domain/references.js";
+import { formatMeetingReference } from "../../meetings/index.js";
 import { ENTITY_TABLES, isEntityType } from "./entity-types.js";
 /** A pointer as a row holds it. An unknown type is not refused on read: `store check` reports it. */
 export const storedThing = (type, id) => ({ type: String(type), id: Number(id) });
@@ -16,6 +16,7 @@ const REFERABLE = {
     memory: { tombstone: true },
     fact: { tombstone: true },
     bot: { tombstone: false },
+    event: { tombstone: true },
     message: { tombstone: true },
     email: { tombstone: true },
     email_thread: { tombstone: true },
@@ -30,30 +31,11 @@ const storeId = (text) => (/^[1-9]\d{0,15}$/.test(text) ? Number(text) : undefin
  * `messages.db` (a ULID, an `entity:`) is simply not found: it is never guessed at.
  */
 export const thingOf = (database, reference) => {
-    if (typeof reference === "string" && reference.trim().startsWith("meeting:")) {
-        const parsed = parseMeetingReference(reference);
-        const meeting = database
-            .prepare("SELECT id FROM meetings WHERE id=? AND account_id=? AND deleted_at IS NULL")
-            .get(parsed.meetingId, parsed.accountId);
-        if (!meeting)
-            return undefined;
-        if (parsed.transcriptId === undefined)
-            return { type: "meeting", id: parsed.meetingId };
-        const transcript = database
-            .prepare("SELECT id FROM meeting_transcripts WHERE id=? AND meeting_id=? AND deleted_at IS NULL")
-            .get(parsed.transcriptId, parsed.meetingId);
-        if (!transcript)
-            return undefined;
-        if (parsed.cuePosition === undefined)
-            return { type: "meeting_transcript", id: parsed.transcriptId };
-        const row = database
-            .prepare("SELECT id FROM meeting_transcript_rows WHERE meeting_transcript_id=? AND position=?")
-            .get(parsed.transcriptId, parsed.cuePosition);
-        return row ? { type: "meeting_transcript_row", id: Number(row.id) } : undefined;
-    }
     const parsed = typeof reference === "string" ? parseReference(reference) : reference;
     const found = (type, row) => row ? { type, id: Number(row.id) } : undefined;
     switch (parsed.type) {
+        case "meeting":
+            return meetingThingOf(database, parsed);
         case "message":
             return ((parsed.provider === "email" ? emailOf(database, parsed.account, parsed.chat, parsed.message) : undefined) ??
                 found("message", database
@@ -90,6 +72,26 @@ export const thingOf = (database, reference) => {
         }
     }
 };
+const meetingThingOf = (database, parsed) => {
+    const meeting = database
+        .prepare("SELECT id FROM meetings WHERE id=? AND account_id=? AND deleted_at IS NULL")
+        .get(parsed.meetingId, parsed.accountId);
+    if (!meeting)
+        return undefined;
+    if (parsed.transcriptId === undefined)
+        return { type: "meeting", id: parsed.meetingId };
+    const transcript = database
+        .prepare("SELECT id FROM meeting_transcripts WHERE id=? AND meeting_id=? AND deleted_at IS NULL")
+        .get(parsed.transcriptId, parsed.meetingId);
+    if (!transcript)
+        return undefined;
+    if (parsed.cuePosition === undefined)
+        return { type: "meeting_transcript", id: parsed.transcriptId };
+    const row = database
+        .prepare("SELECT id FROM meeting_transcript_rows WHERE meeting_transcript_id=? AND position=?")
+        .get(parsed.transcriptId, parsed.cuePosition);
+    return row ? { type: "meeting_transcript_row", id: Number(row.id) } : undefined;
+};
 /** Mail that memo saved before it wrote the mail tables is still messages, so the caller falls back to them. */
 export const emailOf = (database, account, thread, email) => {
     const row = database
@@ -237,4 +239,3 @@ export const taskIdOf = (database, rowId) => {
     const row = database.prepare("SELECT key, package_id AS id FROM tasks WHERE id = ?").get(rowId);
     return row ? String(row.id ?? row.key) : undefined;
 };
-export const canonicalThingReference = (reference) => reference.trim().startsWith("meeting:") ? canonicalMeetingReference(reference) : canonicalReference(reference);

package/dist/store/store.d.ts

@@ -106,6 +106,7 @@ export interface MessageStore {
     forAccount(key: AccountKey): AccountStore;
     close(): Promise<void>;
 }
+export type { ChatHistoryShape, StoredHistorySkip } from "./sqlite/history-skips.js";
 export { BACKFILL_ON_OPEN, type StoreOptions } from "./sqlite/open-store.js";
 export { fileFacts, readStoreTables, type TableKind } from "./sqlite/store-tables.js";
 export declare const openStore: (options?: StoreOptions) => Promise<MessageStore>;

package/package.json

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