@wirecat/cli-core 0.545.0 → 0.547.0

package/dist/services/documents/knowledge.d.ts

@@ -1,5 +1,5 @@
 import type { QueryAst } from "@wirecat/cli-base/query";
-import type { Author, Fact, Link, LinkInput, LinkListFilter, Memory, MemoryInput, MessageStore, Note } from "../../store/index.js";
+import type { Author, Decider, Fact, Link, LinkInput, LinkListFilter, Memory, MemoryInput, MessageStore, Note } from "../../store/index.js";
 export interface DocumentKnowledge {
     documents(principal: string, query: QueryAst | undefined, page: {
         limit: number;
@@ -14,7 +14,7 @@ export interface DocumentKnowledge {
     }): Promise<string[]>;
     links(principal: string, ref: string, filter?: Omit<LinkListFilter, "from" | "to">): Promise<Link[]>;
     addLink(principal: string, ref: string, input: Omit<LinkInput, "from" | "origin">): Promise<Link>;
-    removeLink(principal: string, ref: string, id: string): Promise<unknown>;
+    removeLink(principal: string, ref: string, id: string, by: Decider): Promise<unknown>;
     notes(principal: string, ref: string, options?: {
         search?: string;
         limit?: number;
@@ -28,7 +28,7 @@ export interface DocumentKnowledge {
     editNote(principal: string, ref: string, noteRef: string, text: string, revision: number): Promise<Note>;
     removeNote(principal: string, ref: string, noteRef: string): Promise<unknown>;
     addMemory(principal: string, ref: string, input: Pick<MemoryInput, "body" | "kind" | "scope" | "status" | "supersedes"> & {
-        author?: MemoryInput["author"];
+        author: MemoryInput["author"];
     }): Promise<Memory>;
     memories(principal: string, ref: string, options?: {
         scope?: Memory["scope"];
@@ -36,7 +36,9 @@ export interface DocumentKnowledge {
         status?: Memory["status"];
         limit?: number;
     }): Promise<Memory[]>;
-    memory(principal: string, ref: string, memoryRef: string, action?: "show" | "confirm" | "stale"): Promise<Memory>;
+    memory(principal: string, ref: string, memoryRef: string, action?: "show"): Promise<Memory>;
+    /** `by` decides: the owner, or an agent for the owner that did not propose it. */
+    memory(principal: string, ref: string, memoryRef: string, action: "confirm" | "stale", by: Decider): Promise<Memory>;
     searchMemories(principal: string, ref: string, query: string, scope?: Memory["scope"]): Promise<{
         items: Memory[];
         limit_reached: boolean;
@@ -45,7 +47,7 @@ export interface DocumentKnowledge {
         statement: string;
         type: Fact["type"];
         scope?: Memory["scope"];
-        by?: Author;
+        by: Author;
         supersedes?: string;
         occurredAt?: string;
     }): Promise<Fact>;
@@ -54,6 +56,8 @@ export interface DocumentKnowledge {
         status?: Fact["status"];
         limit?: number;
     }): Promise<Fact[]>;
-    fact(principal: string, ref: string, factRef: string, action?: "show" | "confirm" | "reverse"): Promise<Fact>;
+    fact(principal: string, ref: string, factRef: string, action?: "show"): Promise<Fact>;
+    /** `by` decides: the owner, or an agent for the owner that did not propose it; only the owner reverses. */
+    fact(principal: string, ref: string, factRef: string, action: "confirm" | "reverse", by: Decider): Promise<Fact>;
 }
 export declare const documentKnowledge: (store: Pick<MessageStore, "notes" | "facts" | "memories" | "knowledge">, folder: (principal: string) => Promise<string | undefined>) => DocumentKnowledge;

package/dist/services/documents/knowledge.js

@@ -1,4 +1,18 @@
 import { CliError } from "@wirecat/cli-base";
+const writer = (by) => {
+    if (by === undefined)
+        throw new CliError("validation_error", "name who writes it: the owner or an agent; there is no default", {
+            reason: "proposal.decider-required",
+        });
+    return by;
+};
+const decider = (by) => {
+    if (by === undefined)
+        throw new CliError("validation_error", "a confirm names who decides: the owner or an agent with a reason", {
+            reason: "proposal.decider-required",
+        });
+    return by;
+};
 export const documentKnowledge = (store, folder) => {
     const document = async (principal, ref) => {
         const note = await store.notes.resolveNote(ref);
@@ -62,13 +76,13 @@ export const documentKnowledge = (store, folder) => {
         },
         addLink: async (principal, ref, input) => {
             await document(principal, ref);
-            return store.notes.addLink({ ...input, from: ref, origin: "owner" });
+            return store.notes.addLink({ ...input, from: ref, origin: input.by === "owner" ? "owner" : "suggested" });
         },
-        removeLink: async (principal, ref, id) => {
+        removeLink: async (principal, ref, id, by) => {
             const links = await port.links(principal, ref);
             if (!links.some((link) => link.id === id && link.origin === "owner"))
                 throw new CliError("not_found", "owner link is not attached to this document");
-            return store.notes.removeLink(id);
+            return store.notes.removeLink(id, by);
         },
         notes: async (principal, ref, options) => {
             await document(principal, ref);
@@ -91,18 +105,18 @@ export const documentKnowledge = (store, folder) => {
             await document(principal, ref);
             if (input.supersedes)
                 await memoryFor(principal, ref, input.supersedes);
-            return store.memories.add({ ...input, subject: ref, evidence: [ref], author: input.author ?? "owner" });
+            return store.memories.add({ ...input, subject: ref, evidence: [ref], author: writer(input.author) });
         },
         memories: async (principal, ref, options) => {
             await document(principal, ref);
             return store.memories.list({ ...options, subject: ref });
         },
-        memory: async (principal, ref, memoryRef, action = "show") => {
+        memory: async (principal, ref, memoryRef, action = "show", by) => {
             const memory = await memoryFor(principal, ref, memoryRef);
             if (action === "confirm")
-                return store.memories.confirm(memory.ref);
+                return store.memories.confirm(memory.ref, decider(by));
             if (action === "stale")
-                return store.memories.markStale(memory.ref);
+                return store.memories.markStale(memory.ref, decider(by));
             return memory;
         },
         searchMemories: async (principal, ref, query, scope) => {
@@ -117,7 +131,7 @@ export const documentKnowledge = (store, folder) => {
             return store.facts.add({
                 type,
                 statement,
-                by: by ?? "owner",
+                by: writer(by),
                 ...(supersedes === undefined ? {} : { supersedes }),
                 ...(occurredAt === undefined ? {} : { occurredAt }),
                 subject: ref,
@@ -129,12 +143,12 @@ export const documentKnowledge = (store, folder) => {
             await document(principal, ref);
             return store.facts.list({ ...options, subject: ref });
         },
-        fact: async (principal, ref, factRef, action = "show") => {
+        fact: async (principal, ref, factRef, action = "show", by) => {
             const fact = await factFor(principal, ref, factRef);
             if (action === "confirm")
-                return store.facts.accept(fact.ref);
+                return store.facts.accept(fact.ref, decider(by));
             if (action === "reverse")
-                return store.facts.reverse(fact.ref);
+                return store.facts.reverse(fact.ref, decider(by));
             return fact;
         },
     };

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";
@@ -177,6 +181,7 @@ export { type PackageUpgradeOutcome, type PackageUpgradePorts, type PackageUpgra
 export { type PersonMeetingContext, type PersonMeetingContextItem, type PersonMeetingContextOptions, type PersonMeetingReadStore, personMeetingContext, } from "./person-meeting-context.js";
 export { privatePeopleService } from "./private-people.js";
 export { approveAsTask, type ProposalTaskStore, proposalSource } from "./proposal-tasks.js";
+export { type Decided, type Decision, emptyProposalRegistry, type ProposalFilter, type ProposalKind, type ProposalRegistry, type ProposalRow, parseProposalIds, proposalRegistry, } from "./proposals/index.js";
 export type { RetentionQuery, RetentionService } from "./retention.js";
 export { retentionService } from "./retention.js";
 export { RESOURCES_SEARCHED, type SearchAllFound, type SearchAllItem, type SearchAllMessenger, type SearchAllRequest, type SearchedResource, searchAll, } from "./search-all.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";
@@ -135,6 +139,7 @@ export { upgradePackage, } from "./package-upgrade.js";
 export { personMeetingContext, } from "./person-meeting-context.js";
 export { privatePeopleService } from "./private-people.js";
 export { approveAsTask, proposalSource } from "./proposal-tasks.js";
+export { emptyProposalRegistry, parseProposalIds, proposalRegistry, } from "./proposals/index.js";
 export { retentionService } from "./retention.js";
 export { RESOURCES_SEARCHED, searchAll, } from "./search-all.js";
 export { RESOURCES_SEARCHED_WITH_MEETINGS, searchAllIncludingMeetings, searchAllWithMeetings, } from "./search-all-meetings.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.d.ts

@@ -24,6 +24,8 @@ export interface ListWindow {
     beforeTime?: number;
     /** Read forward from this message or moment, parsed by the caller in its own words (`afterOf`). */
     after?: After;
+    /** The window's last moment, epoch milliseconds, inclusive: a forward read stops here. */
+    until?: number;
     /** Only the messages the owner starred (true) or did not (false); the store answers it, never the messenger. */
     starred?: boolean;
     /** Only this forum topic. */

package/dist/services/messages.js

@@ -3,13 +3,14 @@ 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";
 import { sendAsCheck } from "../sends/send-as.js";
 import { newOperationId, newSendId } from "../sends/send-id.js";
 import { uploadSize } from "../sends/upload.js";
-import { crossAccount, fromStore, PUSHED } from "./deps.js";
+import { crossAccount, fromStore } from "./deps.js";
 import { readChatId, storedChatId } from "./message-resolution.js";
 import { accountOf, keyOf, searchStore, statsStore, topUp } from "./messages-archive-search.js";
 import { meaningLane } from "./messages-meaning.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
@@ -75,8 +84,8 @@ export const messagesService = (deps) => {
         await guardedWrite(guard, { operationId, chatId, kind: "pin", key: pinned ? "messages.pin" : "messages.unpin", messageId: message, notify }, () => act(chatId, message, { notify, ...(duration === undefined ? {} : { duration }) }));
         return { operationId, chatId, messageId: message, pinned };
     };
-    const topicPage = async (chat, threadId, { limit, before, beforeTime, after }) => {
-        if (beforeTime !== undefined || after !== undefined)
+    const topicPage = async (chat, threadId, { limit, before, beforeTime, after, until }) => {
+        if (beforeTime !== undefined || after !== undefined || until !== undefined)
             throw new CliError("validation_error", "a topic is read back from its newest message, or from --before-id");
         if (threadId === "1")
             throw new CliError("validation_error", "the General topic's messages carry no topic id — read the whole chat without --topic");
@@ -86,11 +95,11 @@ export const messagesService = (deps) => {
         }
         return capability(await deps.connection(), "topicHistory", "read one forum topic")(chat, threadId, window);
     };
-    const listPage = async (chat, { limit, before, beforeTime, after, threadId: typedThread, starred }) => {
+    const listPage = async (chat, { limit, before, beforeTime, after, until, threadId: typedThread, starred }) => {
         if (starred !== undefined) {
             if (!fromStore(deps))
                 throw new CliError("validation_error", "starred: reads the local store; not while reading from the messenger");
-            if (typedThread !== undefined || beforeTime !== undefined || after !== undefined)
+            if (typedThread !== undefined || beforeTime !== undefined || after !== undefined || until !== undefined)
                 throw new CliError("validation_error", "starred: pages back through the whole chat; give only id< with it");
             return inStore(async (store, account) => store.messages.messages(account, await readChatId(deps, chat, store, account), {
                 limit,
@@ -100,28 +109,30 @@ export const messagesService = (deps) => {
         }
         const threadId = threadIdOf(typedThread);
         if (threadId !== undefined)
-            return topicPage(chat, threadId, { limit, before, beforeTime, after });
-        if (beforeTime !== undefined) {
-            if (deps.offline)
-                throw new CliError("validation_error", "reading back from a time asks the messenger; not with --offline");
-            if (fromStore(deps))
-                throw new CliError("validation_error", `${PUSHED}, which pages back from a message only`);
-            const connection = await deps.connection();
-            return capability(connection, "historyBefore", "read back from a time")(chat, { limit, time: beforeTime });
+            return topicPage(chat, threadId, { limit, before, beforeTime, after, until });
+        if (fromStore(deps)) {
+            const window = after
+                ? { limit, after, ...(until === undefined ? {} : { until }) }
+                : {
+                    limit,
+                    ...(before === undefined ? {} : { before }),
+                    // historyBefore reads strictly before its moment; the store's end is inclusive.
+                    ...(beforeTime === undefined ? {} : { until: beforeTime - 1 }),
+                };
+            return inStore(async (store, account) => store.messages.messages(account, await readChatId(deps, chat, store, account), window));
         }
+        const connection = await deps.connection();
+        if (beforeTime !== undefined)
+            return capability(connection, "historyBefore", "read back from a time")(chat, { limit, time: beforeTime });
         if (after !== undefined) {
-            if (deps.offline)
-                throw new CliError("validation_error", "reading forward asks the messenger; the store pages only backwards");
-            if (fromStore(deps))
-                throw new CliError("validation_error", `${PUSHED}, which pages only backwards`);
-            const connection = await deps.connection();
-            return capability(connection, "historyAfter", "read forward from a message")(chat, { limit, after });
+            const page = await capability(connection, "historyAfter", "read forward from a message")(chat, { limit, after });
+            if (until === undefined)
+                return page;
+            const items = page.items.filter((one) => Date.parse(one.timestamp) <= until);
+            return { items, hasMore: page.hasMore && items.length === page.items.length };
         }
         const window = { limit, ...(before === undefined ? {} : { before }) };
-        if (fromStore(deps)) {
-            return inStore(async (store, account) => store.messages.messages(account, await readChatId(deps, chat, store, account), window));
-        }
-        return capability(await deps.connection(), "history", "read a chat's history")(chat, window);
+        return capability(connection, "history", "read a chat's history")(chat, window);
     };
     return {
         // A provider caps its pages (Telegram at 100), so a larger --limit reads on from the last page's edge.
@@ -151,11 +162,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 +171,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 +190,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 +231,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/proposal-tasks.d.ts

@@ -1,13 +1,14 @@
+import { type Decider } from "../store/decisions.js";
 import type { MessageStore, ProposedAction } from "../store/store.js";
 import { type Task } from "../tasks/index.js";
-export type ProposalTaskStore = Pick<MessageStore, "proposedActions" | "tasks">;
+export type ProposalTaskStore = Pick<MessageStore, "proposedActions" | "tasks" | "decisionPolicy">;
 /** The source a proposal's task keeps: found again on a retry, so one proposal never makes two tasks. */
 export declare const proposalSource: (id: string) => string;
 /**
  * Approving a proposal makes it the owner's task in the account that would act; nothing is carried out.
  * The task comes first, so an approval that failed half-way finds the same task when it is run again.
  */
-export declare const approveAsTask: (store: ProposalTaskStore, id: string) => Promise<{
+export declare const approveAsTask: (store: ProposalTaskStore, id: string, by: Decider) => Promise<{
     proposal: ProposedAction;
     task: Task;
 }>;

package/dist/services/proposal-tasks.js

@@ -1,6 +1,8 @@
 import { CliError } from "@wirecat/cli-base";
 import { MEETING_FINDINGS_KIND } from "../meetings/index.js";
+import { assertMayDecide } from "../store/decisions.js";
 import { EVIDENCE_FINDINGS_KIND } from "../store/evidence-findings.js";
+import { proposerOfAction } from "../store/index.js";
 import { createTaskService } from "../tasks/index.js";
 import { taskAccount } from "./task-rules.js";
 /** The source a proposal's task keeps: found again on a retry, so one proposal never makes two tasks. */
@@ -9,7 +11,7 @@ export const proposalSource = (id) => `proposed-action:${id}`;
  * Approving a proposal makes it the owner's task in the account that would act; nothing is carried out.
  * The task comes first, so an approval that failed half-way finds the same task when it is run again.
  */
-export const approveAsTask = async (store, id) => {
+export const approveAsTask = async (store, id, by) => {
     const proposal = await store.proposedActions.get(id);
     if (proposal.kind === MEETING_FINDINGS_KIND)
         throw new CliError("validation_error", "review meeting findings through the dedicated findings command", {
@@ -23,6 +25,7 @@ export const approveAsTask = async (store, id) => {
         throw new CliError("validation_error", `a ${proposal.status} action cannot be approved`, {
             reason: "proposal.wrong-state",
         });
+    assertMayDecide({ id: proposal.id, proposedBy: proposerOfAction(proposal) }, by, store.decisionPolicy);
     if (proposal.account === null)
         throw new CliError("validation_error", "a proposal names the account that would act; this one names none");
     const { task } = await createTaskService({ store: store.tasks }).add({
@@ -33,5 +36,5 @@ export const approveAsTask = async (store, id) => {
         kind: "request",
         origin: "agent",
     });
-    return { proposal: await store.proposedActions.approve(proposal.id, { task: task.id }), task };
+    return { proposal: await store.proposedActions.approve(proposal.id, by, { task: task.id }), task };
 };

package/dist/services/proposals/ids.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Proposal ids from the command line, before any reference parsing: `17070-17079,fact:500-502,17080/f1` becomes
+ * each id once, in the order given.
+ */
+export declare const parseProposalIds: (text: readonly string[]) => string[];

package/dist/services/proposals/ids.js

@@ -0,0 +1,43 @@
+import { CliError } from "@wirecat/cli-base";
+const MAX_IDS = 500;
+const refuse = (message) => {
+    throw new CliError("validation_error", message, { reason: "proposal.ids" });
+};
+const range = (prefix, from, to) => {
+    const [start, end] = [Number(from), Number(to)];
+    if (start > end)
+        return refuse(`a range runs upwards: ${from}-${to}`);
+    if (end - start + 1 > MAX_IDS)
+        return refuse(`a range takes at most ${MAX_IDS} ids`);
+    return Array.from({ length: end - start + 1 }, (_, n) => `${prefix}${start + n}`);
+};
+const one = (token) => {
+    const bare = /^([1-9]\d*)(?:-([1-9]\d*))?$/.exec(token);
+    if (bare?.[1])
+        return bare[2] ? range("", bare[1], bare[2]) : [bare[1]];
+    const part = /^([1-9]\d*)\/([A-Za-z0-9_-]{1,64})$/.exec(token);
+    if (part)
+        return [token];
+    const prefixed = /^([a-z][a-z_]*):([1-9]\d*)(?:-(?:([a-z][a-z_]*):)?([1-9]\d*))?$/.exec(token);
+    if (prefixed?.[1] && prefixed[2]) {
+        const [, prefix, from, other, to] = prefixed;
+        if (other !== undefined && other !== prefix)
+            return refuse(`a range stays inside one prefix: ${token}`);
+        return to ? range(`${prefix}:`, from, to) : [`${prefix}:${from}`];
+    }
+    if (/^[1-9]\d*-[a-z]/.test(token))
+        return refuse(`a range stays inside one prefix: ${token}`);
+    return refuse(`not a proposal id: ${token}; use 17070, 17070-17079, fact:512 or 17080/f2`);
+};
+/**
+ * Proposal ids from the command line, before any reference parsing: `17070-17079,fact:500-502,17080/f1` becomes
+ * each id once, in the order given.
+ */
+export const parseProposalIds = (text) => {
+    const ids = [...new Set(text.flatMap((arg) => arg.split(",")).flatMap((token) => one(token.trim())))];
+    if (ids.length === 0)
+        return refuse("name at least one proposal id");
+    if (ids.length > MAX_IDS)
+        return refuse(`decide at most ${MAX_IDS} proposals at once`);
+    return ids;
+};

package/dist/services/proposals/index.d.ts

@@ -0,0 +1,3 @@
+export { parseProposalIds } from "./ids.js";
+export { emptyProposalRegistry, proposalRegistry } from "./registry.js";
+export type { Decided, Decision, ProposalFilter, ProposalKind, ProposalRegistry, ProposalRow } from "./types.js";

package/dist/services/proposals/index.js

@@ -0,0 +1,2 @@
+export { parseProposalIds } from "./ids.js";
+export { emptyProposalRegistry, proposalRegistry } from "./registry.js";

package/dist/services/proposals/kinds/action.d.ts

@@ -0,0 +1,7 @@
+import { type MessageStore } from "../../../store/index.js";
+import type { ProposalKind } from "../types.js";
+/**
+ * Every stored proposal no other kind claims: a reply, a ban, a task to create. Confirming makes it the owner's task
+ * in the account that would act; nothing is carried out. Meeting findings are reviewed with their meeting.
+ */
+export declare const actionKind: (store: Pick<MessageStore, "proposedActions" | "tasks" | "decisionPolicy">, claimed: () => readonly string[]) => ProposalKind;

package/dist/services/proposals/kinds/action.js

@@ -0,0 +1,45 @@
+import { MEETING_FINDINGS_KIND } from "../../../meetings/index.js";
+import { proposerOfAction } from "../../../store/index.js";
+import { approveAsTask } from "../../proposal-tasks.js";
+import { actionStatus, kept, projectOf, pushed, storedStatus } from "./shared.js";
+const rowOf = (action) => ({
+    id: action.id,
+    kind: "action",
+    status: actionStatus(action.status),
+    project: projectOf(action.target),
+    subject: action.target ?? `action:${action.id}`,
+    object: null,
+    summary: action.kind,
+    proposedBy: proposerOfAction(action),
+    reason: action.reason,
+    evidence: [],
+    score: null,
+    signals: null,
+    parts: null,
+    createdAt: action.createdAt,
+});
+/**
+ * Every stored proposal no other kind claims: a reply, a ban, a task to create. Confirming makes it the owner's task
+ * in the account that would act; nothing is carried out. Meeting findings are reviewed with their meeting.
+ */
+export const actionKind = (store, claimed) => ({
+    kind: "action",
+    list: async (filter) => {
+        const status = storedStatus(filter);
+        const actions = await store.proposedActions.list({
+            except: [...claimed(), MEETING_FINDINGS_KIND],
+            ...(status === undefined ? {} : { status }),
+            ...pushed(filter),
+        });
+        return kept(actions.map(rowOf), filter);
+    },
+    get: async (id) => rowOf(await store.proposedActions.get(id)),
+    decide: async (id, { confirm, by, reason }) => {
+        if (!confirm) {
+            await store.proposedActions.reject(id, by, reason);
+            return { id, kind: "action", status: "rejected", made: [] };
+        }
+        const { task } = await approveAsTask(store, id, by);
+        return { id, kind: "action", status: "confirmed", made: [`task:${task.key ?? task.id}`] };
+    },
+});

package/dist/services/proposals/kinds/fact.d.ts

@@ -0,0 +1,4 @@
+import type { MessageStore } from "../../../store/index.js";
+import type { ProposalKind } from "../types.js";
+/** Facts keep their own table and lifecycle; an agent's waits as `proposed`. */
+export declare const factKind: (store: Pick<MessageStore, "facts">) => ProposalKind;