@wirecat/cli-core 0.563.0 → 0.564.0

package/dist/services/messages-discovery.d.ts

@@ -70,11 +70,7 @@ within?: () => Promise<number[] | undefined>) => Promise<{
 export declare const RANK_WITHIN_MESSAGES = 100000;
 /** What a hit not found by the query's words must match: as a search request's text or AST. */
 type Scope = Pick<SearchQuery, "text" | "ast">;
-/**
- * The query discovery searches. A question's own "?" would parse as a one-character wildcard and send it to strict
- * search (BUG-395); the colon of a time or ratio ("22:00", "1:1") would parse as a field and fail the whole search,
- * and escaped it is syntax again, so it splits the numbers (BUG-450). A quoted timestamp keeps its colons (BUG-458).
- */
+/** The query discovery searches: a question's text cleaned as `questionText` says. */
 export declare const discoveryRequest: (asked: SearchQuery) => SearchQuery;
 export declare const searchDiscovery: (store: MessageStore, account: AccountKey, asked: SearchQuery, messenger?: Partial<Pick<MessengerTraits, "savedChatId" | "app" | "history" | "provider">>, meaning?: MeaningLane, rerank?: RerankLane) => Promise<SearchFound>;
 /** The nearest messages the question's filters allow, as hits, nearest first. */

package/dist/services/messages-discovery.js

@@ -4,7 +4,7 @@ import { parseLocator } from "../domain/locator.js";
 import { fieldsOfQuery, meaningWords } from "../search/lucene/meaning-parts.js";
 import { validateFields } from "../search/lucene/registry.js";
 import { exhausted, MESSAGE_PARSING, outOfTime, QUERY_LIMITS } from "../search/lucene/types.js";
-import { planQuestion, words } from "../search/question-plan.js";
+import { anyOfTerms, lookupTerms, planQuestion, questionText, words } from "../search/question-plan.js";
 import { searchCombined } from "./messages-combined.js";
 import { prepareLucene, searchLucene } from "./messages-search.js";
 /** How many of the messages nearest in meaning join the fusion: the benchmark's pool (performance/search/evidence-pipeline). */
@@ -49,19 +49,8 @@ const EVERY_MESSAGE = {
     upper_inclusive: true,
 };
 const scopeOf = (root) => root === undefined ? {} : { ast: { version: 1, language: "lucene-v1", root } };
-/**
- * The query discovery searches. A question's own "?" would parse as a one-character wildcard and send it to strict
- * search (BUG-395); the colon of a time or ratio ("22:00", "1:1") would parse as a field and fail the whole search,
- * and escaped it is syntax again, so it splits the numbers (BUG-450). A quoted timestamp keeps its colons (BUG-458).
- */
-export const discoveryRequest = (asked) => asked.ast !== undefined || asked.exact || !asked.text
-    ? asked
-    : {
-        ...asked,
-        text: asked.text
-            .replace(/(?<=\p{L})\?(?=\s|$)/gu, "")
-            .replace(/"(?:[^"\\]|\\.)*"|(?<=\d):(?=\d)/gu, (found) => (found === ":" ? " " : found)),
-    };
+/** The query discovery searches: a question's text cleaned as `questionText` says. */
+export const discoveryRequest = (asked) => asked.ast !== undefined || asked.exact || !asked.text ? asked : { ...asked, text: questionText(asked.text) };
 export const searchDiscovery = async (store, account, asked, messenger = {}, meaning, rerank) => {
     const request = discoveryRequest(asked);
     const original = await prepareLucene(store, account, request, messenger);
@@ -82,9 +71,7 @@ export const searchDiscovery = async (store, account, asked, messenger = {}, mea
     const question = root === undefined ? text : meaningWords(root);
     if (!question)
         return searchLucene(store, account, request, messenger);
-    const terms = root === undefined
-        ? [...new Set(plan.terms.concat(plan.aliases.flatMap((alias) => words(alias.split(" -> ")[1] ?? ""))))]
-        : [...new Set(words(question))];
+    const terms = root === undefined ? lookupTerms(plan) : [...new Set(words(question))];
     if (!terms.length)
         return searchLucene(store, account, request, messenger);
     if (terms.length > 64)
@@ -125,7 +112,7 @@ export const searchDiscovery = async (store, account, asked, messenger = {}, mea
         truncated ||= found.hasMore || found.query.combined.truncated;
     }
     check();
-    const relaxed = root === undefined ? `(${terms.join(" OR ")})${plan.scope ? ` ${plan.scope}` : ""}` : text;
+    const relaxed = root === undefined ? anyOfTerms(terms, plan.scope) : text;
     const partialRequest = { ...request, text: relaxed, ast: undefined, limit: 300, context: 0, thread: undefined };
     const partial = await searchLucene(store, account, partialRequest, messenger);
     add(partial.items);

package/dist/services/messages-meaning.js

@@ -16,9 +16,19 @@ export const meaningLane = (deps) => async (question, accounts, shared, within)
     const store = await deps.store();
     const ready = [];
     const without = [];
-    for (const one of accounts)
-        ((await store.vectors.hasMessageVectors(one, target.key)) ? ready : without).push(one);
-    if (ready.length === 0)
+    // Mail keeps its vectors by thread, not by message: its accounts are read through the mail store.
+    const mail = new Map();
+    const stored = await store.accounts.storedAccounts();
+    for (const one of accounts) {
+        const id = one.provider === "email"
+            ? stored.find(({ provider, account }) => provider === one.provider && account === one.account)?.id
+            : undefined;
+        if (id !== undefined)
+            mail.set(one, Number(id));
+        else
+            ((await store.vectors.hasMessageVectors(one, target.key)) ? ready : without).push(one);
+    }
+    if (ready.length === 0 && mail.size === 0)
         return skipped("no message has a vector yet", "conversations.rebuild");
     const words = plainWords(question);
     try {
@@ -38,12 +48,24 @@ export const meaningLane = (deps) => async (question, accounts, shared, within)
                     for (const { chatId, messageId, score } of near)
                         ranked.push({ ...one, chatId, id: messageId, score });
                 }
+                for (const [one, accountId] of mail) {
+                    const near = await store.mail.nearest(target.key, query, {
+                        accountId,
+                        limit: MEANING_DEPTH,
+                    });
+                    if (near.length === 0)
+                        without.push(one);
+                    for (const { threadExternalId, externalId, score } of near)
+                        ranked.push({ ...one, chatId: threadExternalId, id: externalId, score });
+                }
             };
             if (shared && !deps.embedders)
                 await lookUp(await shared.get(target.key, () => target.open()));
             else
                 await withEmbedder(deps, target, DEFAULT_TEXT_MODEL, {}, lookUp);
         }
+        if (ranked.length === 0 && without.length === accounts.length)
+            return skipped("no message has a vector yet", "conversations.rebuild");
         return {
             model: target.id,
             ranked: ranked.sort((a, b) => b.score - a.score).slice(0, MEANING_DEPTH),

package/dist/services/messages.js

@@ -40,7 +40,7 @@ export const messagesService = (deps) => {
             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 serverThenStore = async (store, account, query, lanes = true) => {
         const server = await searchServer(deps, query);
         const only = query.backend === "server" && server
             ? [...server.sources.keys()].map((key) => {
@@ -48,12 +48,13 @@ export const messagesService = (deps) => {
                 return { ...account, chatId, id };
             })
             : undefined;
-        const found = await searchStore(store, account, only ? { ...query, only } : query, deps.messenger, query.discover && query.kind !== "mail" ? meaningLane(deps) : undefined, query.discover && query.kind !== "mail" ? rerankLane(deps) : undefined);
+        const found = await searchStore(store, account, only ? { ...query, only } : query, deps.messenger, lanes && query.discover && query.kind !== "mail" ? meaningLane(deps) : undefined, lanes && query.discover && query.kind !== "mail" ? rerankLane(deps) : undefined);
         return { found, server };
     };
     const unifiedMessages = (store, account) => async (query) => {
         await topUp(store);
-        const { found, server } = await serverThenStore(store, account, query);
+        // `search all` adds meaning itself, and a reranker's load would cost it seconds on every question.
+        const { found, server } = await serverThenStore(store, account, query, false);
         return withServer(found, account, server);
     };
     /**

package/dist/services/notes-search.d.ts

@@ -105,6 +105,8 @@ export interface FoundNote {
     }[];
     /** Which halves of the search found it. */
     found_by: ("title" | "words" | "meaning")[];
+    /** The cosine of the nearest chunk, when meaning found it: comparable with other records under the same model. */
+    meaning_score?: number;
 }
 export interface LinkedRecord {
     /** `person:…`, `note:…`, `entity:…`, or `null` while the name written in the notes matches nobody yet. */
@@ -147,6 +149,8 @@ export interface NotesQuery {
     withInternal?: boolean;
     source?: Note["source"];
     exact?: boolean;
+    /** A question typed as a sentence finds what holds some of its words, as `search messages --discover` does. */
+    discover?: boolean;
     timezone?: string;
     env?: NodeJS.ProcessEnv;
     /** The tool's command, named in the hint when the model is missing. */
@@ -182,7 +186,7 @@ export declare const RANK_WITHIN = 2000;
  * each hit says which half found it, and the answer lists what the notes found link to. Every field of the query and
  * of `filter` holds for every hit, found by words or by meaning; a query of fields alone is not searched by meaning.
  */
-export declare const searchNotes: (store: MessageStore, query: string, { limit, offset, tag, filter: expression, folderIds, withInternal, source: given, exact, timezone, env, command, embedders, pictures: withPictures, pictureLimit, pictureEmbedder, }?: NotesQuery) => Promise<NotesFound>;
+export declare const searchNotes: (store: MessageStore, query: string, { limit, offset, tag, filter: expression, folderIds, withInternal, source: given, exact, discover, timezone, env, command, embedders, pictures: withPictures, pictureLimit, pictureEmbedder, }?: NotesQuery) => Promise<NotesFound>;
 /** What `notes:internal` and `notes:<folder id>` ask of the store: one query, so a page of it is one page. */
 export declare const notesScopeOf: (accounts: readonly AccountKey[]) => Pick<NotesQuery, "folderIds" | "withInternal" | "source">;
 export interface NotesFoundOf extends NotesFound {

package/dist/services/notes-search.js

@@ -10,6 +10,7 @@ import { fieldsOfQuery as fieldsOf, meaningWords } from "../search/lucene/meanin
 import { validateFields } from "../search/lucene/registry.js";
 import { hasStems } from "../search/lucene/resolved.js";
 import { isQueryLimit, SEARCH_QUERY } from "../search/lucene/types.js";
+import { questionLookup, questionText } from "../search/question-plan.js";
 import { createStemmer, DEFAULT_STEMMERS } from "../search/stem.js";
 import { TOTAL_CAP, totalOf } from "../search/total.js";
 import { openPictureEmbedderFor } from "./document-pictures.js";
@@ -324,20 +325,22 @@ const notesTotal = async (store, text, { exact, scope, shown, hasMore, }, others
  * each hit says which half found it, and the answer lists what the notes found link to. Every field of the query and
  * of `filter` holds for every hit, found by words or by meaning; a query of fields alone is not searched by meaning.
  */
-export const searchNotes = async (store, query, { limit = 20, offset = 0, tag, filter: expression, folderIds, withInternal, source: given, exact = false, timezone, env, command, embedders, pictures: withPictures = false, pictureLimit = 5, pictureEmbedder, } = {}) => {
+export const searchNotes = async (store, query, { limit = 20, offset = 0, tag, filter: expression, folderIds, withInternal, source: given, exact = false, discover = false, timezone, env, command, embedders, pictures: withPictures = false, pictureLimit = 5, pictureEmbedder, } = {}) => {
     const typed = noteSourceOfQuery(query);
     const source = given ?? typed.source;
     const rest = typed.source !== undefined && typed.source === source ? typed.rest : query;
     const label = tag === undefined ? undefined : normalizeTag(tag);
     const filter = [expression ? `(${expression})` : "", label === undefined ? "" : `tag:${label}`].filter(Boolean).join(" AND ") ||
         undefined;
-    const parsed = query.trim() ? parsedQuery(query, exact) : undefined;
+    const lookup = discover && !exact ? questionLookup(query) : undefined;
+    const parsed = query.trim() ? parsedQuery(lookup === undefined ? query : questionText(query), exact) : undefined;
     const words = parsed === undefined ? "" : meaningWords(parsed);
     const narrowing = allOf([
         ...(parsed === undefined ? [] : [fieldsOfQuery(parsed)].filter((node) => node !== undefined)),
         ...(filter === undefined ? [] : [parsedQuery(filter)]),
     ]);
-    const text = [query.trim() ? `(${query})` : "", filter ?? ""].filter(Boolean).join(" AND ");
+    const asked = lookup ?? query;
+    const text = [asked.trim() ? `(${asked})` : "", filter ?? ""].filter(Boolean).join(" AND ");
     const window = offset + limit;
     const scope = {
         ...(folderIds === undefined ? {} : { folderIds }),
@@ -347,6 +350,7 @@ export const searchNotes = async (store, query, { limit = 20, offset = 0, tag, f
     };
     let meaningSkipped;
     let meaning;
+    const cosines = new Map();
     /** Every note found by meaning; `meaningComplete` is false when the nearest overall were cut at the depth. */
     let meaningRefs;
     let meaningComplete = true;
@@ -375,8 +379,10 @@ export const searchNotes = async (store, query, { limit = 20, offset = 0, tag, f
                 nearest = ranked.slice(0, depth);
             }
             const allowed = await matching(store, nearest.map(({ ref }) => ref), narrowing, scope);
-            meaning = nearest.flatMap(({ ref }) => {
+            meaning = nearest.flatMap(({ ref, score }) => {
                 const found = allowed.get(ref);
+                if (found)
+                    cosines.set(ref, score);
                 return found ? [{ ref, ...found }] : [];
             });
             meaningRefs ??= new Set(meaning.map(({ ref }) => ref));
@@ -410,9 +416,13 @@ export const searchNotes = async (store, query, { limit = 20, offset = 0, tag, f
         if (tierRefs.has(ref))
             return;
         const held = ranked.get(ref) ?? { note, at, score: 0, foundBy: [] };
-        held.score += 1 / (RRF_K + rank + 1);
         held.foundBy.push(by);
         ranked.set(ref, held);
+        // A question's any-word list holds nearly every note meaning finds; a second vote there buried notes found by
+        // words alone (recall@10 0.55 against 1.00, cli-testing knowledge-graph-memory, MEMO-36).
+        if (by === "meaning" && lookup !== undefined && held.foundBy.includes("words"))
+            return;
+        held.score += 1 / (RRF_K + rank + 1);
     });
     add(matched.items, "words");
     if (meaning !== undefined)
@@ -446,6 +456,7 @@ export const searchNotes = async (store, query, { limit = 20, offset = 0, tag, f
             excerpt: firstLine(note.text, words),
             links,
             found_by: foundBy,
+            ...(cosines.has(ref) ? { meaning_score: cosines.get(ref) } : {}),
         });
         for (const link of new Map(links.map((link) => [link.to ?? `?${link.target_text}`, link])).values()) {
             const key = link.to ?? `?${link.target_text}`;

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

@@ -1,5 +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.
+ * Proposal ids from the command line, before any reference parsing: `17070-17079,fact:500-502,17080/f1,close:Q-15`
+ * becomes each id once, in the order given. A task key after a prefix is one id, never a range.
  */
 export declare const parseProposalIds: (text: readonly string[]) => string[];

package/dist/services/proposals/ids.js

@@ -18,6 +18,8 @@ const one = (token) => {
     const part = /^([1-9]\d*)\/([A-Za-z0-9_-]{1,64})$/.exec(token);
     if (part)
         return [token];
+    if (/^[a-z][a-z_]*:[A-Za-z][A-Za-z0-9]*-[1-9]\d*$/.test(token))
+        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;
@@ -27,11 +29,11 @@ const one = (token) => {
     }
     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`);
+    return refuse(`not a proposal id: ${token}; use 17070, 17070-17079, fact:512, close:Q-15 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.
+ * Proposal ids from the command line, before any reference parsing: `17070-17079,fact:500-502,17080/f1,close:Q-15`
+ * becomes each id once, in the order given. A task key after a prefix is one id, never a range.
  */
 export const parseProposalIds = (text) => {
     const ids = [...new Set(text.flatMap((arg) => arg.split(",")).flatMap((token) => one(token.trim())))];

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

@@ -5,6 +5,6 @@ import type { ProposalKind } from "../types.js";
 export declare const FACT_SUMMARIES: Record<string, (finding: Finding) => string>;
 /**
  * An agent's batch of cited facts and tasks from stored messages, mail and documents. Confirming accepts the parts
- * named, or every finding not rejected before; the rest are rejected. Meeting findings stay with their meeting.
+ * named, or every finding not rejected before; the rest are rejected. Meeting findings have their own kind.
  */
 export declare const findingsKind: (store: Pick<MessageStore, "evidenceFindings" | "proposedActions">) => ProposalKind;

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

@@ -35,7 +35,7 @@ const rowOf = (batch, createdAt) => {
 };
 /**
  * An agent's batch of cited facts and tasks from stored messages, mail and documents. Confirming accepts the parts
- * named, or every finding not rejected before; the rest are rejected. Meeting findings stay with their meeting.
+ * named, or every finding not rejected before; the rest are rejected. Meeting findings have their own kind.
  */
 export const findingsKind = (store) => {
     // The batch view carries no staging time; its stored proposal does.

package/dist/services/proposals/kinds/meeting-findings.d.ts

@@ -0,0 +1,7 @@
+import { type MessageStore } from "../../../store/index.js";
+import type { ProposalKind } from "../types.js";
+/**
+ * A meeting's cited findings, staged by `meetings actions add`: the same review as `meetings actions confirm`, with
+ * the batch's current fingerprint. Only the owner decides it.
+ */
+export declare const meetingFindingsKind: (store: Pick<MessageStore, "meetingFindings" | "proposedActions">) => ProposalKind;

package/dist/services/proposals/kinds/meeting-findings.js

@@ -0,0 +1,73 @@
+import { CliError } from "@wirecat/cli-base";
+import { MEETING_FINDINGS_KIND } from "../../../meetings/index.js";
+import { proposerOfAction, } from "../../../store/index.js";
+import { FACT_SUMMARIES } from "./findings.js";
+import { kept } from "./shared.js";
+const rowOf = (action, batch) => {
+    const findings = batch.input.findings;
+    const projects = [...new Set(findings.map((one) => ("project" in one ? one.project : undefined)))];
+    const outcome = (id) => batch.receipt?.items.find((item) => item.id === id)?.status ?? null;
+    const references = [...new Set(findings.flatMap((finding) => finding.evidence.map((one) => one.reference)))];
+    return {
+        id: action.id,
+        kind: "meeting_findings",
+        status: batch.status === "proposed" ? "proposed" : batch.receipt?.accepted.length ? "confirmed" : "rejected",
+        project: projects.length === 1 && typeof projects[0] === "string" ? projects[0] : null,
+        subject: references[0] ?? `meeting_findings:${action.id}`,
+        object: null,
+        summary: `${findings.length} finding${findings.length === 1 ? "" : "s"}`,
+        proposedBy: proposerOfAction(action),
+        reason: action.reason,
+        evidence: references.slice(0, 5),
+        score: null,
+        signals: null,
+        parts: findings.map((finding) => ({
+            id: finding.id,
+            kind: finding.kind,
+            summary: FACT_SUMMARIES[finding.kind]?.(finding) ?? finding.kind,
+            outcome: outcome(finding.id),
+        })),
+        createdAt: action.createdAt,
+    };
+};
+/**
+ * A meeting's cited findings, staged by `meetings actions add`: the same review as `meetings actions confirm`, with
+ * the batch's current fingerprint. Only the owner decides it.
+ */
+export const meetingFindingsKind = (store) => {
+    const batchOf = async (action) => {
+        if (action.account === null)
+            throw new CliError("not_found", `meeting findings ${action.id} name no account`);
+        return { account: action.account, batch: await store.meetingFindings.get(action.account, action.id) };
+    };
+    return {
+        kind: "meeting_findings",
+        stored: [MEETING_FINDINGS_KIND],
+        parts: true,
+        ownerOnly: true,
+        list: async (filter) => {
+            const actions = await store.proposedActions.list({
+                kinds: [MEETING_FINDINGS_KIND],
+                ...((filter.status ?? "proposed") === "proposed" ? { status: "proposed" } : {}),
+                ...(filter.by === undefined ? {} : { proposedBy: filter.by }),
+                limit: Math.min(filter.offset + filter.limit, 500),
+            });
+            const rows = await Promise.all(actions.map(async (action) => rowOf(action, (await batchOf(action)).batch)));
+            return kept(rows, { ...filter, limit: filter.offset + filter.limit });
+        },
+        get: async (id) => {
+            const action = await store.proposedActions.get(id);
+            return rowOf(action, (await batchOf(action)).batch);
+        },
+        decide: async (id, { confirm, by, parts }) => {
+            const { account, batch } = await batchOf(await store.proposedActions.get(id));
+            const turnedDown = new Set(batch.previous.filter((one) => one.status === "rejected").map((one) => one.id));
+            const accept = !confirm
+                ? []
+                : (parts ?? batch.input.findings.map((finding) => finding.id).filter((one) => !turnedDown.has(one)));
+            const reviewed = await store.meetingFindings.review(account, id, { fingerprint: batch.fingerprint, accept, by });
+            const made = (reviewed.receipt?.items ?? []).flatMap((item) => item.status === "accepted" && item.reference && !item.reused ? [item.reference] : []);
+            return { id, kind: "meeting_findings", status: accept.length ? "confirmed" : "rejected", made };
+        },
+    };
+};

package/dist/services/proposals/kinds/task-close.d.ts

@@ -0,0 +1,7 @@
+import type { MessageStore } from "../../../store/index.js";
+import type { ProposalKind } from "../types.js";
+/**
+ * An agent's close of an open task, waiting on the owner (`close_suggested_*`). Confirming closes it as suggested;
+ * rejecting clears the suggestion, as `tasks reject` does. Its id is `close:<task key>`; only the owner decides it.
+ */
+export declare const taskCloseKind: (store: Pick<MessageStore, "tasks">) => ProposalKind;

package/dist/services/proposals/kinds/task-close.js

@@ -0,0 +1,76 @@
+import { CliError } from "@wirecat/cli-base";
+import { deciderAuthor, TASK_CLOSE_KIND } from "../../../store/decisions.js";
+import { createTaskService } from "../../../tasks/index.js";
+import { kept } from "./shared.js";
+const rowOf = (task) => {
+    const suggestion = task.closeSuggestion;
+    if (suggestion === null)
+        return undefined;
+    return {
+        id: `close:${task.key}`,
+        kind: TASK_CLOSE_KIND,
+        status: "proposed",
+        project: task.project,
+        subject: task.ref,
+        object: null,
+        summary: `close as ${suggestion.as}: ${task.title}`,
+        proposedBy: { type: "bot", id: suggestion.by, name: suggestion.by, kind: "agent" },
+        reason: suggestion.reason,
+        evidence: task.source === null ? [] : [task.source],
+        score: suggestion.certainty,
+        signals: null,
+        parts: null,
+        createdAt: suggestion.at,
+    };
+};
+/**
+ * An agent's close of an open task, waiting on the owner (`close_suggested_*`). Confirming closes it as suggested;
+ * rejecting clears the suggestion, as `tasks reject` does. Its id is `close:<task key>`; only the owner decides it.
+ */
+export const taskCloseKind = (store) => {
+    const taskOf = async (id) => {
+        const key = id.slice("close:".length);
+        const task = await store.tasks.details(key).catch(() => undefined);
+        const row = task && rowOf(task);
+        if (!task || !row)
+            throw new CliError("not_found", `no close waits on task ${key}`);
+        return { task, row };
+    };
+    return {
+        kind: TASK_CLOSE_KIND,
+        prefix: "close",
+        ownerOnly: true,
+        list: async (filter) => {
+            if ((filter.status ?? "proposed") !== "proposed" && filter.status !== "all")
+                return [];
+            const tasks = await store.tasks.find({
+                status: "open",
+                where: { sql: "t.close_suggested_as IS NOT NULL", params: [] },
+                limit: filter.offset + filter.limit,
+            });
+            return kept(tasks.flatMap((task) => rowOf(task) ?? []), { ...filter, limit: filter.offset + filter.limit });
+        },
+        get: async (id) => (await taskOf(id)).row,
+        decide: async (id, { confirm, by, reason }) => {
+            const { task } = await taskOf(id);
+            const suggestion = task.closeSuggestion;
+            if (!confirm || suggestion === null) {
+                await store.tasks.suggestClose(task.id, null, "owner");
+                return { id, kind: TASK_CLOSE_KIND, status: "rejected", made: [] };
+            }
+            // A project task has no row in the message task service; a message task closes there, keeping the
+            // suggestion's reason as `tasks close` does.
+            if ((await store.tasks.get(task.id)) === undefined)
+                await store.tasks.edit(task.id, { status: suggestion.as, ...(reason === undefined ? {} : { reason }) }, deciderAuthor(by));
+            else {
+                const why = reason ?? suggestion.reason ?? undefined;
+                await createTaskService({ store: store.tasks }).close(task.id, {
+                    as: suggestion.as,
+                    by: "owner",
+                    ...(why === undefined ? {} : { reason: why }),
+                });
+            }
+            return { id, kind: TASK_CLOSE_KIND, status: "confirmed", made: [task.ref] };
+        },
+    };
+};

package/dist/services/proposals/registry.js

@@ -6,9 +6,11 @@ import { invoiceKind, paymentKind } from "./kinds/finance.js";
 import { findingsKind } from "./kinds/findings.js";
 import { keyDocumentKind } from "./kinds/key-document.js";
 import { mailFindingsKind } from "./kinds/mail-findings.js";
+import { meetingFindingsKind } from "./kinds/meeting-findings.js";
 import { memoryKind } from "./kinds/memory.js";
 import { relationshipKind } from "./kinds/relationship.js";
 import { relationshipUpdateKind } from "./kinds/relationship-update.js";
+import { taskCloseKind } from "./kinds/task-close.js";
 const PREFIX = /^([a-z][a-z_]*):/;
 const marked = (kind, row) => kind.ownerOnly ? { ...row, ownerOnly: true } : row;
 const refusalOf = (id, error) => {
@@ -133,6 +135,8 @@ export const proposalRegistry = (store) => {
         memoryKind(store),
         findingsKind(store),
         mailFindingsKind(store),
+        meetingFindingsKind(store),
+        taskCloseKind(store),
     ])
         registry.register(kind);
     registry.register(actionKind(store, registry.claimed));

package/dist/services/search-all.d.ts

@@ -79,6 +79,11 @@ export interface SearchAllFound {
         by: "words" | "words and meaning";
         meaningSkipped?: MeaningSkipped;
     };
+    /** How the mail was searched, when it was; never by meaning with `exact`. */
+    mail?: {
+        by: "words" | "words and meaning";
+        meaningSkipped?: MeaningSkipped;
+    };
     /** The messenger's server step for messages, as `search messages` reports it. */
     server?: ServerSearched;
     /** What the store held of the chats the messages were searched in; absent when messages were not searched. */