@wirecat/cli-core 0.545.0 → 0.546.0

package/dist/ports/messenger.d.ts

@@ -401,9 +401,10 @@ export interface HistoryBatch {
 /**
  * Takes one pushed batch. The CLI's own handler resolves `true` once the batch is in the local store and `false` when it
  * could not be written, so a messenger that pushes history once can keep a batch until it is saved; a handler that
- * stores nothing returns nothing.
+ * stores nothing returns nothing. A command's own handler, called through the store, is handed that answer as `saved`,
+ * so what it reports as kept is what reached the store.
  */
-export type HistoryBatchHandler = (batch: HistoryBatch) => void | Promise<boolean>;
+export type HistoryBatchHandler = (batch: HistoryBatch, saved?: Promise<boolean>) => void | Promise<boolean>;
 /** For a messenger that pushes its history to the client instead of answering for it (`Messenger.history: "store"`). */
 export interface PushedHistory {
     /** Chats, people and past messages as the messenger pushes them, until `signal` aborts. */

package/dist/resolve.d.ts

@@ -1,6 +1,8 @@
-import type { Chat, Contact, Id } from "./domain/models.js";
+import type { Chat, Contact, Id, Provider } from "./domain/models.js";
 /** The part of a store that `pickPerson` reads. */
 export interface PeopleLookup {
+    /** Whose identities these are; a `contact:` reference of another provider is refused when it is set. */
+    provider?: Provider;
     get(id: Id): Contact | undefined;
     /** Everyone known, in any order. */
     all(): Contact[];

package/dist/resolve.js

@@ -1,4 +1,5 @@
 import { CliError, singleLine } from "@wirecat/cli-base";
+import { contactReferenceOf } from "./domain/ref-arguments.js";
 /** Shaped like a Telegram or MAX id. Another messenger's ids may be any string, so a miss here is not "not an id". */
 export const isId = (reference) => /^-?\d+$/.test(reference.trim());
 /**
@@ -31,6 +32,13 @@ export const pickChat = (reference, chats) => {
  */
 export const pickPerson = (reference, people) => {
     const trimmed = reference.trim();
+    const contact = contactReferenceOf(trimmed, people.provider);
+    if (contact !== undefined) {
+        const named = people.get(contact);
+        if (named)
+            return named;
+        throw new CliError("not_found", `no person ${contact} in what this account has seen`);
+    }
     const known = people.get(trimmed);
     if (known)
         return known;

package/dist/search/task-signature.d.ts

@@ -7,7 +7,11 @@ export type TaskAmount = {
     value: number;
     currency: string | null;
 };
-/** A bare number is not an amount: `верни 3000 за бензин` has none, so a reminder about it compares as missing. */
+/**
+ * A bare number is not an amount: `верни 3000 за бензин` has none, so a reminder about it compares as missing.
+ * Takes the text as written; it is lower-cased here.
+ */
+export declare const amountsOf: (text: string) => TaskAmount[];
 export declare const amountOf: (text: string) => TaskAmount | null;
 /** The creator's calendar date in the machine's time zone, as a day count: "tomorrow" late at night is local. */
 export declare const dayOf: (ms: number) => number;

package/dist/search/task-signature.js

@@ -10,18 +10,36 @@ const CURRENCY = [
     [/^(\$|usd|долл.*|dollars?)$/u, "USD"],
 ];
 const currencyOf = (word) => word ? (CURRENCY.find(([pattern]) => pattern.test(word))?.[1] ?? null) : null;
-const AMOUNT = /(?<![\p{L}\p{N}])([$€₽])?\s?(\d+(?:[.,]\d+)?)(?:([кk])(?![\p{L}])|\s?(тыс\.?|тысяч\p{L}*))?(?![\p{N}])\s?(₽|руб\p{L}*\.?|р\.|р(?![\p{L}])|rub|eur|евро|€|\$|usd|долл\p{L}*|dollars?|euros?)?(?![\p{L}])/gu;
-/** A bare number is not an amount: `верни 3000 за бензин` has none, so a reminder about it compares as missing. */
-export const amountOf = (text) => {
-    for (const [, before, number = "", short, long, after] of text.matchAll(AMOUNT)) {
-        const multiplier = short ?? long;
-        if (!before && !after && !multiplier)
+const SEPARATORS = String.raw `[ \u00a0\u2009\u202f.,]`;
+/**
+ * Groups of three after a space (also no-break, thin, narrow no-break), a dot or a comma (`50 000`, `1.200`,
+ * `$1,200`) are one number, with an optional one or two digit decimal after (`5 000.50`). A lone `1,5` is a decimal.
+ */
+const NUMBER = String.raw `\d{1,3}(?:${SEPARATORS}\d{3})+(?:[.,]\d{1,2})?|\d+(?:[.,]\d+)?`;
+const AMOUNT = new RegExp(String.raw `(?<![\p{L}\p{N}])([$€₽])?\s?(${NUMBER})(?:([кk])(?![\p{L}])|\s?(тыс\.?|тысяч\p{L}*))?(?![\p{N}])\s?(₽|руб\p{L}*\.?|р\.|р(?![\p{L}])|rub|eur|евро|€|\$|usd|долл\p{L}*|dollars?|euros?)?(?![\p{L}])`, "gu");
+const GROUPED = new RegExp(String.raw `^(\d{1,3}(?:${SEPARATORS}\d{3})+)([.,]\d{1,2})?$`, "u");
+const amountValue = (number, thousands) => {
+    const grouped = GROUPED.exec(number);
+    const plain = grouped
+        ? `${(grouped[1] ?? "").replace(new RegExp(SEPARATORS, "gu"), "")}${(grouped[2] ?? "").replace(",", ".")}`
+        : number.replace(",", ".");
+    return Math.round(Number(plain) * (thousands ? 1000 : 1) * 100) / 100;
+};
+/**
+ * A bare number is not an amount: `верни 3000 за бензин` has none, so a reminder about it compares as missing.
+ * Takes the text as written; it is lower-cased here.
+ */
+export const amountsOf = (text) => {
+    const found = [];
+    for (const [, before, number = "", short, long, after] of text.toLowerCase().matchAll(AMOUNT)) {
+        const thousands = (short ?? long) !== undefined;
+        if (!before && !after && !thousands)
             continue;
-        const value = Math.round(Number(number.replace(",", ".")) * (multiplier ? 1000 : 1));
-        return { value, currency: currencyOf(before ?? after?.replace(/\.$/u, "")) };
+        found.push({ value: amountValue(number, thousands), currency: currencyOf(before ?? after?.replace(/\.$/u, "")) });
     }
-    return null;
+    return found;
 };
+export const amountOf = (text) => amountsOf(text)[0] ?? null;
 const RU_WEEKDAYS = ["воскресен", "понедельник", "вторник", "сред", "четверг", "пятниц", "суббот"];
 const EN_WEEKDAYS = ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];
 const ES_WEEKDAYS = ["domingo", "lunes", "martes", "miercoles", "jueves", "viernes", "sabado"];

package/dist/services/agenda.d.ts

@@ -4,6 +4,11 @@ import { agenda } from "../entities/agenda.js";
 import { type ChatActivity, type TaskDetails } from "../store/store.js";
 import { type ChatCoverage } from "./chat-coverage.js";
 import type { ServiceDeps } from "./deps.js";
+/** How long a chat must be silent before `tasks agenda` lists it, per side. */
+export declare const AGENDA_DEFAULTS: {
+    readonly unanswered: 86400000;
+    readonly waiting: number;
+};
 export interface AgendaOptions {
     /** ms: a task due within this is listed. */
     dueWithin?: number;

package/dist/services/agenda.js

@@ -8,6 +8,8 @@ import { CHAT_KINDS } from "./chats.js";
 import { taskAccount } from "./task-rules.js";
 import { taskTagFilters } from "./task-tag-filters.js";
 const DAY = 86_400_000;
+/** How long a chat must be silent before `tasks agenda` lists it, per side. */
+export const AGENDA_DEFAULTS = { unanswered: DAY, waiting: 7 * DAY };
 const CLAIMS = ["none", "mine", "others", "any"];
 const TASK_FIELDS = new Set(["tag", "category", "claimed"]);
 export const AGENDA_QUERY = {
@@ -35,7 +37,7 @@ export const AGENDA_QUERY = {
     defaults: ["chat_kind:(dialog OR group)", "claimed:(none OR mine)"],
 };
 export const agendaService = (deps, now = Date.now) => ({
-    show: async ({ dueWithin = DAY, waiting = 7 * DAY, unanswered = DAY, within = 30 * DAY, query, holder } = {}) => {
+    show: async ({ dueWithin = DAY, waiting = AGENDA_DEFAULTS.waiting, unanswered = AGENDA_DEFAULTS.unanswered, within = 30 * DAY, query, holder, } = {}) => {
         const [store, account] = [await deps.store(), await deps.account()];
         const at = now();
         const parts = query ? split(query) : { tasks: undefined, chats: undefined };

package/dist/services/index.d.ts

@@ -1,4 +1,6 @@
 import { type BotCheckService } from "../botcheck/service.js";
+export { amountOf, amountsOf, type TaskAmount } from "../search/task-signature.js";
+export { AGENDA_DEFAULTS } from "./agenda.js";
 export { type ChatCoverage, chatCoverage } from "./chat-coverage.js";
 export type { ContextEvidenceItem, ContextEvidencePage, ContextEvidenceReader, ContextEvidenceRequest, ContextEvidenceSender, ContextIndex, ContextReadLimits, ContextReadUsage, ContextRecordReader, ContextSource, ScopedContextEvidenceReader, } from "./context-evidence.js";
 export { contextEvidenceFingerprint, createContextEvidenceReader } from "./context-evidence.js";
@@ -9,6 +11,7 @@ export type { MediaArchiveEntry, MediaIdentity } from "./media-archive-manifest.
 export type { MoveMediaArchiveOptions } from "./media-archive-move.js";
 export { moveMediaArchive } from "./media-archive-move.js";
 export { type DownloadedModel, downloadImageModel, downloadTextModel, type ModelDownloadOptions, } from "./model-downloads.js";
+export { MONEY_DONE, MONEY_REQUEST, MONEY_WORDS, moneyClassesOf, PROMISE } from "./money-words.js";
 export type { ProjectChatFetcher, ProjectChatFetchProgress, ProjectChatFetchRequest, ProjectEvidenceContext, ProjectEvidenceItem, ProjectEvidencePerson, ProjectGathering, ProjectGatheringPorts, ProjectGatheringStop, ProjectIndexCatchUp, } from "./project-gathering.js";
 export { gatherProjectEvidence } from "./project-gathering.js";
 export type { ProjectNeighbour, ProjectNeighbourReader } from "./project-gathering-around.js";
@@ -16,7 +19,8 @@ export { documentPassage, storedMessageNeighbours, storedNeighbours } from "./pr
 export type { EvidenceMention, EvidenceMentions } from "./project-gathering-mentions.js";
 export { findEvidenceMentions } from "./project-gathering-mentions.js";
 export type { ProjectChatFetched, ProjectGatheringBudgets, ProjectGatheringRequest, ProjectLane, ProjectLaneKind, ProjectLinkedChat, ProjectPerson, ProjectSender, ProjectUnitState, } from "./project-gathering-request.js";
-export { canonicalProjectRef, gatherStoredProject, type StoredProjectGathering, type StoredProjectInput, } from "./stored-project-gathering.js";
+export { questions } from "./questions.js";
+export { canonicalProjectRef, gatherStoredProject, type LinkedChat, linkedChatsOf, type StoredProjectGathering, type StoredProjectInput, } from "./stored-project-gathering.js";
 import { type AccountService } from "./account.js";
 import { type AdminService } from "./admin.js";
 import { type AdminStatisticsService } from "./admin-statistics.js";

package/dist/services/index.js

@@ -1,14 +1,18 @@
 import { botCheckService } from "../botcheck/service.js";
+export { amountOf, amountsOf } from "../search/task-signature.js";
+export { AGENDA_DEFAULTS } from "./agenda.js";
 export { chatCoverage } from "./chat-coverage.js";
 export { contextEvidenceFingerprint, createContextEvidenceReader } from "./context-evidence.js";
 export { excerpt } from "./excerpt.js";
 export { archiveMedia, checkMediaArchive } from "./media-archive.js";
 export { moveMediaArchive } from "./media-archive-move.js";
 export { downloadImageModel, downloadTextModel, } from "./model-downloads.js";
+export { MONEY_DONE, MONEY_REQUEST, MONEY_WORDS, moneyClassesOf, PROMISE } from "./money-words.js";
 export { gatherProjectEvidence } from "./project-gathering.js";
 export { documentPassage, storedMessageNeighbours, storedNeighbours } from "./project-gathering-around.js";
 export { findEvidenceMentions } from "./project-gathering-mentions.js";
-export { canonicalProjectRef, gatherStoredProject, } from "./stored-project-gathering.js";
+export { questions } from "./questions.js";
+export { canonicalProjectRef, gatherStoredProject, linkedChatsOf, } from "./stored-project-gathering.js";
 import { accountService } from "./account.js";
 import { adminService } from "./admin.js";
 import { adminStatisticsService } from "./admin-statistics.js";

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

@@ -1,4 +1,5 @@
-import type { Id } from "../domain/models.js";
+import type { Id, Provider } from "../domain/models.js";
+import { type ProfilesOn } from "../domain/ref-arguments.js";
 import type { MessengerTraits } from "../ports/traits.js";
 import type { AccountStore } from "../store/account-store.js";
 import type { AccountKey, MessageStore } from "../store/store.js";
@@ -21,6 +22,8 @@ export declare const storedChatId: (messenger: Saved, reference: string, store:
 export declare const chatIdIn: (messenger: Saved, reference: string, store: AccountStore, { includeLeft }?: {
     includeLeft?: boolean;
 }) => Promise<string>;
+/** The profiles of `app` the store recorded on an account of this provider, for a refusal to name. */
+export declare const profilesOnAccount: (store: Pick<MessageStore, "accounts">, app: string | undefined, provider: Provider) => ProfilesOn;
 /** A chat as `--chat` names it, in whichever of the accounts holds it — one of them, or it is an error. */
 export declare const chatAmong: (messenger: Saved, store: MessageStore, accounts: AccountKey[], reference: string) => Promise<{
     account: AccountKey;

package/dist/services/message-resolution.js

@@ -1,4 +1,5 @@
 import { CliError, singleLine } from "@wirecat/cli-base";
+import { chatReferenceOf, ensureAccount } from "../domain/ref-arguments.js";
 import { isId, pickChat, pickPerson } from "../resolve.js";
 import { codeOf } from "../sends/guarded.js";
 import { nothingStored } from "./deps.js";
@@ -28,10 +29,12 @@ const LEFT_EMPTY = "you left this chat, and the store holds none of its messages
  */
 export const storedChatId = (messenger, reference, store, account, { includeLeft = false } = {}) => {
     const renamed = (id) => store.chats.renamedChatId(account, id);
+    const profilesOn = profilesOnAccount(store, messenger.app?.command, account.provider);
     const among = chatIdAmong(messenger, reference, account, {
         held: () => store.chats.chats(account, {}),
         renamed,
         left: async (id) => leftIn(await store.chats.chats(account, byId(id))),
+        profilesOn,
     });
     if (!includeLeft)
         return among;
@@ -41,6 +44,7 @@ export const storedChatId = (messenger, reference, store, account, { includeLeft
         return chatIdAmong(messenger, reference, account, {
             held: () => store.chats.chats(account, { includeLeft: true }),
             renamed,
+            profilesOn,
         });
     });
 };
@@ -70,14 +74,26 @@ const byId = (id) => ({
     where: { sql: "chats.external_id = ?", params: [id] },
 });
 const leftIn = ({ items }) => items.some((one) => one.membershipState === "left");
+/** The profiles of `app` the store recorded on an account of this provider, for a refusal to name. */
+export const profilesOnAccount = (store, app, provider) => async (account) => {
+    if (app === undefined)
+        return undefined;
+    return Object.entries((await store.accounts.profiles())[app] ?? {})
+        .filter(([, key]) => key.provider === provider && key.account === account)
+        .map(([name]) => name);
+};
 /** `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 chatIdAmong = async (messenger, reference, account, { held, renamed, left, profilesOn, }) => {
     const trimmed = reference.trim();
     if (messenger.savedChatId && ["me", "self", "saved"].includes(trimmed.toLowerCase())) {
         return messenger.savedChatId(account);
     }
-    if (/^-?\d+$/.test(trimmed)) {
-        const id = (await renamed(trimmed)) ?? trimmed;
+    const named = chatReferenceOf(trimmed, account.provider);
+    if (named)
+        await ensureAccount(named, { account: account.account }, profilesOn);
+    if (named || /^-?\d+$/.test(trimmed)) {
+        const typed = named?.chat ?? trimmed;
+        const id = (await renamed(typed)) ?? typed;
         if (await left?.(id))
             throw new CliError("not_found", `you left chat ${id}`);
         return id;

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/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/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;