@wirecat/cli-core 0.499.0 → 0.501.0

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

@@ -118,6 +118,11 @@ export declare const coverageOf: (store: MessageStore, { scopeAccounts, selected
     coverage: SearchCoverage;
 }>;
 export declare const searchLucene: (store: MessageStore, account: AccountKey, request: SearchQuery, messenger?: Partial<Pick<MessengerTraits, "savedChatId" | "app" | "history" | "provider">>) => Promise<SearchFound>;
+/**
+ * How many messages the query matches, mail included, each counted no further than `cap + 1`; `undefined` when only
+ * the search itself could tell.
+ */
+export declare const countLucene: (store: MessageStore, account: AccountKey, request: SearchQuery, messenger: Partial<Pick<MessengerTraits, "savedChatId" | "app">>, cap: number) => Promise<number | undefined>;
 export type StatsGrouping = "chat" | "sender" | "day" | "hour";
 export interface StatsRow {
     key: string;

package/dist/services/messages-search.js

@@ -366,6 +366,28 @@ export const searchLucene = async (store, account, request, messenger = {}) => {
             : {}),
     };
 };
+/**
+ * How many messages the query matches, mail included, each counted no further than `cap + 1`; `undefined` when only
+ * the search itself could tell.
+ */
+export const countLucene = async (store, account, request, messenger, cap) => {
+    const prepared = await prepareLucene(store, account, request, messenger);
+    if (!prepared.scopeAccounts.length)
+        return 0;
+    const count = (execution) => store.queries.countMatches(execution, cap);
+    const mailAccounts = prepared.scopeAccounts.filter(({ provider }) => provider === MAIL);
+    const messages = await count(prepared.execution);
+    let mail = 0;
+    if (mailAccounts.length)
+        try {
+            mail = await count({ ...prepared.execution, accounts: mailAccounts, corpus: "mail" });
+        }
+        catch (error) {
+            if (!(request.kind !== "mail" && error instanceof CliError && error.code === "validation_error"))
+                throw error;
+        }
+    return messages === undefined || mail === undefined ? undefined : messages + mail;
+};
 /** The garbled spellings voice-note hits were found through, one entry per query word. */
 const correctionsOf = (items) => {
     const found = new Map();

package/dist/services/messages.d.ts

@@ -3,6 +3,7 @@ import { type MessageLink } from "../domain/message-link.js";
 import type { Deletion, Discussion, Id, Message, Page, Provider, WindowedMessage } from "../domain/models.js";
 import { type After, type Download, type Sent } from "../ports/messenger.js";
 import type { SkippedSource } from "../search/account-list.js";
+import type { SearchTotal } from "../search/total.js";
 import { type Operated } from "../sends/guarded.js";
 import type { PermissionKey } from "../sends/permissions.js";
 import type { AccountKey, ChatCompleteness, MatchPlace, StoredHit } from "../store/store.js";
@@ -104,6 +105,8 @@ export type FoundMessage = StoredHit & {
 export interface SearchFound extends Page<FoundMessage> {
     /** Where the next page starts, as `offset`; absent on the last page. */
     nextOffset?: number;
+    /** How many messages match, every page together, as Elasticsearch's `hits.total`; set by the archive search. */
+    total?: SearchTotal;
     refreshed?: SearchRefreshed;
     server?: ServerSearched;
     query?: QueryMetadata;

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

@@ -6,6 +6,7 @@ import type { AppIdentity } from "../ports/app.js";
 import { type SkippedSource } from "../search/account-list.js";
 import { type ResolvedNode } from "../search/lucene/resolved.js";
 import { type Stemmer } from "../search/stem.js";
+import { type SearchTotal } from "../search/total.js";
 import type { Link, NearestNote, Note, NoteHit } from "../store/index.js";
 import type { AccountKey, MessageStore } from "../store/store.js";
 export interface NotesSearchRequest {
@@ -71,7 +72,8 @@ export declare const embedMail: (store: MessageStore, options?: NotesEmbedOption
     command?: string;
 }) => Promise<NotesEmbedded>;
 /** Notes nearest in meaning to the query, best first; only notes already embedded can be found. */
-export declare const nearestNotes: (store: MessageStore, query: string, { model: choice, limit, folderIds, withInternal, source, env, threads, command, embedders, }: Omit<NotesEmbedOptions, "maxChunks"> & {
+export declare const nearestNotes: (store: MessageStore, query: string, options: NearestOptions) => Promise<NearestNote[]>;
+type NearestOptions = Omit<NotesEmbedOptions, "maxChunks"> & {
     limit: number;
     folderIds?: string[];
     withInternal?: boolean;
@@ -79,7 +81,7 @@ export declare const nearestNotes: (store: MessageStore, query: string, { model:
     command?: string;
     /** The search's own, when another part of it loads the same model. */
     embedders?: Pick<WarmEmbedders, "get">;
-}) => Promise<NearestNote[]>;
+};
 export interface FoundNote {
     kind?: "document" | "note";
     provider?: string;
@@ -120,6 +122,8 @@ export interface NotesFound {
     /** Why meaning was not searched, when it was not. */
     meaning_skipped?: string;
     hits: FoundNote[];
+    /** How many notes match the query, every page together, as Elasticsearch's `hits.total`. */
+    total?: SearchTotal;
     has_more: boolean;
     next_offset?: number;
     /** What the notes found link to, most linked first. */
@@ -173,6 +177,13 @@ export declare const noteSourceOfQuery: (query: string) => {
 export declare const fieldsOfQuery: (root: QueryNode) => QueryNode | undefined;
 /** The words and phrases the query asks for, for the meaning half to embed; none it excludes, no field. */
 export declare const meaningWords: (root: QueryNode) => string;
+/**
+ * The most notes a filter may hold for meaning to rank all of them, each by its best chunk. Above it, meaning ranks
+ * the nearest notes overall and keeps those inside the filter, so a narrow filter over a large store loses some. On
+ * the owner's store (1,454 documents, 23,308 chunks) scoring all of them took ~0.5 s against ~0.17 s for the
+ * nearest 50 overall, and the cost grows with chunks, so 2,000 notes keeps it under a second at that density.
+ */
+export declare const RANK_WITHIN = 2000;
 /**
  * `search notes`: words and stems, and meaning when the local model is there, merged by reciprocal rank;
  * each hit says which half found it, and the answer lists what the notes found link to. Every field of the query and
@@ -199,3 +210,4 @@ export declare const searchNotesOf: (store: MessageStore, account: AccountKey, t
     accounts?: string;
     app?: AppIdentity;
 }) => Promise<NotesFoundOf>;
+export {};

package/dist/services/notes-search.js

@@ -1,4 +1,4 @@
-import { CliError } from "@wirecat/cli-base";
+import { CliError, isCliError } from "@wirecat/cli-base";
 import { dateRange, parseLucene, timezoneOf } from "@wirecat/cli-base/query";
 import { INTERNAL_NOTES } from "../domain/providers.js";
 import { normalizeTag } from "../domain/tags.js";
@@ -10,6 +10,7 @@ import { validateFields } from "../search/lucene/registry.js";
 import { hasStems } from "../search/lucene/resolved.js";
 import { SEARCH_QUERY } from "../search/lucene/types.js";
 import { createStemmer, DEFAULT_STEMMERS } from "../search/stem.js";
+import { TOTAL_CAP, totalOf } from "../search/total.js";
 import { openPictureEmbedderFor } from "./document-pictures.js";
 import { documentSource } from "./document-source.js";
 import { plainQueryWords, titleQuery, titleTiers } from "./notes-title-tier.js";
@@ -122,7 +123,17 @@ export const embedEvents = (store, options = {}) => embedChunks(store, store.cal
 /** Embeds mail's chunks as notes' are embedded: same model and key, so search by meaning reads both. */
 export const embedMail = (store, options = {}) => embedChunks(store, store.mail, options);
 /** Notes nearest in meaning to the query, best first; only notes already embedded can be found. */
-export const nearestNotes = async (store, query, { model: choice, limit, folderIds, withInternal, source, env, threads, command, embedders, }) => {
+export const nearestNotes = async (store, query, options) => {
+    const { key, vector, floor } = await queryVector(store, query, options);
+    const nearest = await store.notes.nearest(key, vector, {
+        limit: options.limit,
+        ...(options.folderIds ? { folderIds: options.folderIds } : {}),
+        ...(options.withInternal ? { withInternal: true } : {}),
+        ...(options.source ? { source: options.source } : {}),
+    });
+    return nearest.filter(({ score }) => score > floor);
+};
+const queryVector = async (store, query, { model: choice, folderIds, withInternal, source, env, threads, command, embedders }) => {
     if (!query.trim())
         throw new CliError("validation_error", "say what to find in the notes");
     const { model, directory, key } = localModel(choice, env, command);
@@ -134,14 +145,12 @@ export const nearestNotes = async (store, query, { model: choice, limit, folderI
     if (!(await store.notes.embedded(key, scope)))
         throw new CliError("not_found", `nothing searched here has vectors of ${model.id} yet, so only words were matched`);
     const [vector] = await withLocal(model, directory, threads, (embedder) => embedder.embed([query], "query"), embedders);
-    const floor = meaningFloor(key);
-    const nearest = await store.notes.nearest(key, vector, {
-        limit,
-        ...(folderIds ? { folderIds } : {}),
-        ...(withInternal ? { withInternal: true } : {}),
-        ...(source ? { source } : {}),
-    });
-    return nearest.filter(({ score }) => score > floor);
+    return { key, vector: vector, floor: meaningFloor(key) };
+};
+/** Every note of `refs` nearer in meaning than the model's floor, best first. */
+const nearestAmong = async (store, query, refs, options) => {
+    const { key, vector, floor } = await queryVector(store, query, options);
+    return (await store.notes.scoreNotes(key, vector, refs)).filter(({ score }) => score > floor);
 };
 const MAX_LINE = 200;
 const MAX_NOTES_OFFSET = 1000;
@@ -289,6 +298,62 @@ const matching = async (store, refs, root, scope) => {
     });
     return new Map(found.items.map(({ ref, note, at }) => [ref, { note, at }]));
 };
+/**
+ * The most notes a filter may hold for meaning to rank all of them, each by its best chunk. Above it, meaning ranks
+ * the nearest notes overall and keeps those inside the filter, so a narrow filter over a large store loses some. On
+ * the owner's store (1,454 documents, 23,308 chunks) scoring all of them took ~0.5 s against ~0.17 s for the
+ * nearest 50 overall, and the cost grows with chunks, so 2,000 notes keeps it under a second at that density.
+ */
+export const RANK_WITHIN = 2000;
+/** The notes of a filter, newest first, when there are at most `RANK_WITHIN`; `undefined` when more, or too costly. */
+const filterRefs = async (store, narrowing, scope) => {
+    const resolved = await resolvedQuery(store, narrowing, scope.timezone);
+    try {
+        const found = await store.notes.matchingRefs({
+            root: resolved.root,
+            limit: RANK_WITHIN,
+            ...(scope.folderIds ? { folderIds: scope.folderIds } : {}),
+            ...(scope.withInternal ? { withInternal: true } : {}),
+            ...(scope.source ? { source: scope.source } : {}),
+            ...(resolved.stemmer ? { stemmer: resolved.stemmer } : {}),
+        });
+        return found.hasMore ? undefined : found.refs;
+    }
+    catch (error) {
+        if (tooLarge(error))
+            return undefined;
+        throw error;
+    }
+};
+const tooLarge = (error) => isCliError(error) && error.details.reason === "query.too-large";
+/**
+ * The notes the words find, with those found by meaning: every note the search would list, paged to the end. Never
+ * below what the page already showed; a count the store refuses as too costly is that lower bound.
+ */
+const notesTotal = async (store, text, { exact, scope, shown, hasMore, }, others, othersComplete) => {
+    let words;
+    try {
+        const { root, stemmer } = await storeQuery(store, text, {
+            exact,
+            ...(scope.timezone ? { timezone: scope.timezone } : {}),
+        });
+        words = await store.notes.matchingRefs({
+            root,
+            limit: TOTAL_CAP,
+            ...(scope.folderIds ? { folderIds: scope.folderIds } : {}),
+            ...(scope.withInternal ? { withInternal: true } : {}),
+            ...(scope.source ? { source: scope.source } : {}),
+            ...(stemmer ? { stemmer } : {}),
+        });
+    }
+    catch (error) {
+        if (tooLarge(error))
+            return totalOf(undefined, shown, hasMore);
+        throw error;
+    }
+    const count = new Set([...words.refs, ...others]).size + (words.hasMore ? 1 : 0);
+    return totalOf(count, shown, hasMore, othersComplete);
+};
 /**
  * `search notes`: words and stems, and meaning when the local model is there, merged by reciprocal rank;
  * each hit says which half found it, and the answer lists what the notes found link to. Every field of the query and
@@ -317,24 +382,39 @@ export const searchNotes = async (store, query, { limit = 20, offset = 0, tag, f
     };
     let meaningSkipped;
     let meaning;
+    /** Every note found by meaning; `meaningComplete` is false when the nearest overall were cut at the depth. */
+    let meaningRefs;
+    let meaningComplete = true;
     if (exact)
         meaningSkipped = "--exact searches words as written";
     else if (words) {
+        const lane = {
+            command,
+            ...(env === undefined ? {} : { env }),
+            ...(embedders === undefined ? {} : { embedders }),
+            ...(folderIds === undefined ? {} : { folderIds }),
+            ...(withInternal ? { withInternal: true } : {}),
+            ...(source === undefined ? {} : { source }),
+        };
+        const depth = Math.max(window, CANDIDATES);
         try {
-            const nearest = await nearestNotes(store, words, {
-                limit: Math.max(window, CANDIDATES),
-                command,
-                ...(env === undefined ? {} : { env }),
-                ...(embedders === undefined ? {} : { embedders }),
-                ...(folderIds === undefined ? {} : { folderIds }),
-                ...(withInternal ? { withInternal: true } : {}),
-                ...(source === undefined ? {} : { source }),
-            });
+            const within = narrowing === undefined ? undefined : await filterRefs(store, narrowing, scope);
+            let nearest;
+            if (within === undefined) {
+                nearest = await nearestNotes(store, words, { ...lane, limit: depth });
+                meaningComplete = nearest.length < depth;
+            }
+            else {
+                const ranked = within.length ? await nearestAmong(store, words, within, lane) : [];
+                meaningRefs = new Set(ranked.map(({ ref }) => ref));
+                nearest = ranked.slice(0, depth);
+            }
             const allowed = await matching(store, nearest.map(({ ref }) => ref), narrowing, scope);
             meaning = nearest.flatMap(({ ref }) => {
                 const found = allowed.get(ref);
                 return found ? [{ ref, ...found }] : [];
             });
+            meaningRefs ??= new Set(meaning.map(({ ref }) => ref));
         }
         catch (error) {
             if (!(error instanceof CliError && error.code === "not_found"))
@@ -378,6 +458,7 @@ export const searchNotes = async (store, query, { limit = 20, offset = 0, tag, f
     ];
     const page = slice ? ordered : ordered.slice(offset, window);
     const hasMore = slice ? matched.hasMore : ordered.length > window || matched.hasMore || titled.hasMore;
+    const total = await notesTotal(store, text, { exact, scope, shown: offset + page.length, hasMore }, [...tier.map(({ ref }) => ref), ...(meaningRefs ?? [])], meaningComplete);
     const hits = [];
     const counts = new Map();
     const accounts = await store.accounts.storedAccounts();
@@ -441,6 +522,7 @@ export const searchNotes = async (store, query, { limit = 20, offset = 0, tag, f
         by: meaning === undefined ? "words" : "words and meaning",
         ...(meaningSkipped === undefined ? {} : { meaning_skipped: meaningSkipped }),
         hits,
+        total,
         has_more: hasMore,
         ...(hasMore && window <= MAX_NOTES_OFFSET ? { next_offset: window } : {}),
         linked: [...counts.values()].sort((a, b) => b.notes - a.notes || (a.name ?? a.ref ?? "").localeCompare(b.name ?? b.ref ?? "")),

package/dist/store/index.d.ts

@@ -31,6 +31,7 @@ export { CATALOG_QUERY } from "./sqlite/catalog.js";
 export type { ChatMetadata } from "./sqlite/chats.js";
 export type { Email, EmailAddress, EmailAttachment, EmailFacts, EmailFilter, EmailInput, EmailInThread, EmailLocationInput, EmailRecipient, EmailRef, EmailThread, EmailVectorHit, FolderEmail, Mailbox, MailboxInput, MailFilter, MailStore, SenderScore, ThreadDetails, ThreadSave, } from "./sqlite/emails.js";
 export { EVENT_FIELDS, type EventChunkToEmbed, type EventHit, type EventQuery, type EventSearch, type NearestEvent, } from "./sqlite/event-search.js";
+export type { EvidenceSource } from "./sqlite/evidence-sources.js";
 export type { Fact, FactInput, FactsStore } from "./sqlite/facts.js";
 export type { FileListQuery, FilesStore, StoredFile } from "./sqlite/files.js";
 export { IMPORTED_DOCUMENT_QUERY, type ImportedDocuments } from "./sqlite/imported-documents.js";

package/dist/store/project-transfer/request.d.ts

@@ -6,7 +6,7 @@ export declare const projectAnnotationRequest: (request: ProjectAnnotationTarget
             ref: string;
             type: "decision" | "fact" | "promise" | "question" | "statement";
             statement: string;
-            status: "accepted" | "proposed" | "reversed" | "superseded";
+            status: "accepted" | "proposed" | "rejected" | "reversed" | "superseded";
             subject: string | null;
             occurred_at: number | null;
             supersedes: string | null;

package/dist/store/project-transfer/schema.d.ts

@@ -25,7 +25,7 @@ export declare const projectAnnotationsSchema: v.StrictObjectSchema<{
         readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, number, undefined>]>;
         readonly type: v.PicklistSchema<readonly ["fact", "statement", "question", "decision", "promise"], undefined>;
         readonly statement: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, number, undefined>]>;
-        readonly status: v.PicklistSchema<readonly ["proposed", "accepted", "superseded", "reversed"], undefined>;
+        readonly status: v.PicklistSchema<readonly ["proposed", "accepted", "superseded", "reversed", "rejected"], undefined>;
         readonly subject: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
         readonly occurred_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.SafeIntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
         readonly supersedes: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
@@ -40,7 +40,7 @@ export declare const projectAnnotationsSchema: v.StrictObjectSchema<{
         ref: string;
         type: "decision" | "fact" | "promise" | "question" | "statement";
         statement: string;
-        status: "accepted" | "proposed" | "reversed" | "superseded";
+        status: "accepted" | "proposed" | "rejected" | "reversed" | "superseded";
         subject: string | null;
         occurred_at: number | null;
         supersedes: string | null;

package/dist/store/project-transfer/snapshot-model.d.ts

@@ -6,7 +6,7 @@ export declare const projectAnnotationSnapshotSchema: v.StrictObjectSchema<{
         readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, number, undefined>]>;
         readonly type: v.PicklistSchema<readonly ["fact", "statement", "question", "decision", "promise"], undefined>;
         readonly statement: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, number, undefined>]>;
-        readonly status: v.PicklistSchema<readonly ["proposed", "accepted", "superseded", "reversed"], undefined>;
+        readonly status: v.PicklistSchema<readonly ["proposed", "accepted", "superseded", "reversed", "rejected"], undefined>;
         readonly subject: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
         readonly occurred_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.SafeIntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
         readonly supersedes: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
@@ -21,7 +21,7 @@ export declare const projectAnnotationSnapshotSchema: v.StrictObjectSchema<{
         ref: string;
         type: "decision" | "fact" | "promise" | "question" | "statement";
         statement: string;
-        status: "accepted" | "proposed" | "reversed" | "superseded";
+        status: "accepted" | "proposed" | "rejected" | "reversed" | "superseded";
         subject: string | null;
         occurred_at: number | null;
         supersedes: string | null;

package/dist/store/queries.d.ts

@@ -13,6 +13,8 @@ export interface QueriesStore {
     matchQuery(execution: QueryExecution): Promise<Page<ScoredHit>>;
     /** The same matches as `matchQuery`, each counted once, grouped by chat, sender or quarter hour. */
     countQuery(execution: QueryExecution, by: QueryGrouping): Promise<QueryGroup[]>;
+    /** How many messages match, counted no further than `cap + 1`; `undefined` when only a full search could tell. */
+    countMatches(execution: QueryExecution, cap: number): Promise<number | undefined>;
     conversationEligibility(execution: QueryExecution): Promise<ConversationEligibility>;
     rankQuery(execution: QueryExecution, request: RankingRequest): Promise<RankedStoreFound>;
     rankingEvidence(execution: QueryExecution, request: RankingEvidenceRequest): Promise<RankedEvidence>;

package/dist/store/queries.js

@@ -13,6 +13,7 @@ export const queriesStoreOver = (context, stemmerFor) => {
     return {
         matchQuery: async (execution) => lucene.matchQuery(context, mailIndexed(execution)),
         countQuery: async (execution, by) => lucene.countQuery(context, mailIndexed(execution), by),
+        countMatches: async (execution, cap) => lucene.countMatches(context, mailIndexed(execution), cap),
         conversationEligibility: async (execution) => conversationEligibility(context, execution),
         rankQuery: async (execution, request) => rankQuery(context, execution, request),
         rankingEvidence: async (execution, request) => rankingEvidence(context, execution, request),

package/dist/store/sqlite/evidence-sources.d.ts

@@ -0,0 +1,23 @@
+import type { CacheDatabase } from "../driver.js";
+/** One reference a memory or fact rests on, read back whole enough to judge it without opening it. */
+export interface EvidenceSource {
+    /** `null` when the row is gone from the store and its reference with it. */
+    ref: string | null;
+    kind: string;
+    title: string | null;
+    sender: string | null;
+    at: string | null;
+    excerpt: string | null;
+    /** The provider the source came through: `telegram`, `email`, `notes`, `zoom`… */
+    tool: string | null;
+    /** Deleted at its source since it was cited, or no longer in the store. */
+    missing: boolean;
+}
+/**
+ * Every `evidence` link from a memory or fact, in the order they were written, including one whose target was
+ * deleted since: `evidenceOf` drops those, so a reader would never learn the record lost a source.
+ */
+export declare const evidenceSourcesOf: (database: CacheDatabase, from: {
+    type: string;
+    id: number;
+}) => EvidenceSource[];

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

@@ -0,0 +1,59 @@
+import { linkKind } from "./link-kinds.js";
+import { referenceOfThing, stateOfThing, storedThing } from "./things.js";
+const EXCERPT_CHARS = 280;
+const excerptOf = (text) => {
+    if (text == null)
+        return null;
+    const flat = String(text).replace(/\s+/g, " ").trim();
+    if (!flat)
+        return null;
+    return flat.length > EXCERPT_CHARS ? `${flat.slice(0, EXCERPT_CHARS - 1)}…` : flat;
+};
+const iso = (value) => (value == null ? null : new Date(Number(value)).toISOString());
+const textOf = (value) => (value == null || String(value).trim() === "" ? null : String(value));
+const READS = {
+    message: "SELECT c.title, coalesce(m.sender_name, i.name) AS sender, m.sent_at AS at, m.text AS body, a.provider AS tool " +
+        "FROM messages m JOIN chats c ON c.id = m.chat_id JOIN accounts a ON a.id = c.account_id " +
+        "LEFT JOIN identities i ON i.id = m.sender_identity_id WHERE m.id = ?",
+    email: "SELECT e.subject AS title, coalesce(e.from_name, e.from_address) AS sender, e.sent_at AS at, " +
+        "coalesce(e.body_text, e.snippet) AS body, 'email' AS tool FROM emails e WHERE e.id = ?",
+    note: "SELECT title, NULL AS sender, updated_at AS at, body, 'notes' AS tool FROM notes WHERE id = ?",
+    document: "SELECT d.title, NULL AS sender, coalesce(d.external_updated_at, d.updated_at) AS at, d.body, a.provider AS tool " +
+        "FROM documents d JOIN accounts a ON a.id = d.account_id WHERE d.id = ?",
+    meeting: "SELECT m.title, NULL AS sender, m.started_at AS at, m.description AS body, a.provider AS tool " +
+        "FROM meetings m JOIN accounts a ON a.id = m.account_id WHERE m.id = ?",
+    meeting_transcript: "SELECT m.title, NULL AS sender, m.started_at AS at, NULL AS body, a.provider AS tool FROM meeting_transcripts t " +
+        "JOIN meetings m ON m.id = t.meeting_id JOIN accounts a ON a.id = m.account_id WHERE t.id = ?",
+    meeting_transcript_row: "SELECT m.title, r.speaker_name AS sender, m.started_at + coalesce(r.start_ms, 0) AS at, r.text AS body, " +
+        "a.provider AS tool FROM meeting_transcript_rows r JOIN meeting_transcripts t ON t.id = r.meeting_transcript_id " +
+        "JOIN meetings m ON m.id = t.meeting_id JOIN accounts a ON a.id = m.account_id WHERE r.id = ?",
+};
+const KIND = {
+    meeting_transcript: "meeting",
+    meeting_transcript_row: "meeting",
+};
+/**
+ * Every `evidence` link from a memory or fact, in the order they were written, including one whose target was
+ * deleted since: `evidenceOf` drops those, so a reader would never learn the record lost a source.
+ */
+export const evidenceSourcesOf = (database, from) => database
+    .prepare(`SELECT to_type, to_id FROM links WHERE from_type = ? AND from_id = ? AND kind = ${linkKind("evidence")} ` +
+    "AND to_id IS NOT NULL ORDER BY id")
+    .all(from.type, from.id)
+    .map((link) => {
+    const thing = storedThing(link.to_type, link.to_id);
+    const state = stateOfThing(database, thing);
+    const read = READS[thing.type];
+    const row = read === undefined || state === "unavailable" ? undefined : database.prepare(read).get(thing.id);
+    const gone = state !== "available";
+    return {
+        ref: referenceOfThing(database, thing) ?? null,
+        kind: KIND[thing.type] ?? thing.type,
+        title: textOf(row?.title),
+        sender: textOf(row?.sender),
+        at: iso(row?.at),
+        excerpt: gone ? null : excerptOf(row?.body),
+        tool: textOf(row?.tool),
+        missing: gone,
+    };
+});

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

@@ -1,5 +1,6 @@
 import { type FACT_STATUSES, FACT_TYPES, MEMORY_SCOPES } from "../../domain/knowledge.js";
 import type { Actor } from "./actors.js";
+import { type EvidenceSource } from "./evidence-sources.js";
 import { type Author } from "./memories.js";
 import type { StoreContext } from "./open.js";
 /** What happened, as its evidence shows; its evidence is `links` of kind `evidence`. */
@@ -12,6 +13,8 @@ export interface Fact {
     status: (typeof FACT_STATUSES)[number];
     project: string | null;
     subject: string | null;
+    subjectName: string | null;
+    subjectIsOwner: boolean;
     occurredAt: string | null;
     supersedes: string | null;
     /** `name` is a bot's handle; `null` for a person. */
@@ -61,6 +64,19 @@ export interface FactsStore {
     accept(reference: string): Promise<Fact>;
     /** An accepted decision no longer holds and nothing replaced it. */
     reverse(reference: string): Promise<Fact>;
+    /** The owner turns down a proposed fact; it stays, marked `rejected`. */
+    reject(reference: string): Promise<Fact>;
+    /**
+     * Erases the fact: its row, its links, its tags, and the memory it was migrated from, which still held its text.
+     * A decision that replaced it no longer names it. A backup made before keeps it.
+     */
+    remove(reference: string): Promise<{
+        ref: string;
+        removed: true;
+        links: number;
+    }>;
+    /** Each reference it rests on, read back; one deleted since is `missing`. */
+    sources(reference: string): Promise<EvidenceSource[]>;
 }
 type FactOperations = {
     [K in keyof FactsStore]: FactsStore[K] extends (...args: infer A) => Promise<infer R> ? (...args: A) => R : never;

package/dist/store/sqlite/facts.js

@@ -1,10 +1,10 @@
 import { CliError } from "@wirecat/cli-base";
 import { FACT_TYPES, MEMORY_SCOPES } from "../../domain/knowledge.js";
 import { calendarMoment } from "../../domain/moment.js";
+import { evidenceSourcesOf } from "./evidence-sources.js";
 import { linkKind } from "./link-kinds.js";
-import { authorActor, authorOf, evidenceOf, linkEvidence } from "./memories.js";
+import { authorActor, authorOf, dropLinksOf, erase, evidenceOf, linkEvidence, subjectOf, } from "./memories.js";
 import { requiredThing } from "./notes.js";
-import { referenceOfThing, storedThing } from "./things.js";
 import { write } from "./transaction.js";
 const NAMED = "SELECT f.*, b.name AS author_name FROM facts f LEFT JOIN bots b ON f.author_type = 'bot' AND b.id = f.author_id";
 const iso = (value) => new Date(Number(value)).toISOString();
@@ -22,9 +22,7 @@ export const factOperationsOver = (context) => {
         statement: String(row.statement),
         status: row.status,
         project: row.project_id == null ? null : `project:${row.project_id}`,
-        subject: row.subject_type == null
-            ? null
-            : (referenceOfThing(database, storedThing(row.subject_type, row.subject_id)) ?? null),
+        ...subjectOf(database, row),
         occurredAt: row.occurred_at == null ? null : iso(row.occurred_at),
         supersedes: row.supersedes_id == null ? null : `fact:${row.supersedes_id}`,
         author: authorOf(row),
@@ -125,8 +123,41 @@ export const factOperationsOver = (context) => {
             database.prepare("UPDATE facts SET status = 'reversed', updated_at = ? WHERE id = ?").run(now(), Number(row.id));
             return factOf(rowOf(reference));
         },
+        reject: (reference) => {
+            const row = rowOf(reference);
+            if (row.status !== "proposed")
+                throw new CliError("validation_error", `only a proposed fact can be rejected; this one is ${String(row.status)}`);
+            database.prepare("UPDATE facts SET status = 'rejected', updated_at = ? WHERE id = ?").run(now(), Number(row.id));
+            return factOf(rowOf(reference));
+        },
+        remove: (reference) => {
+            const row = rowOf(reference);
+            const id = Number(row.id);
+            const twin = row.source === "memory" && row.metadata != null ? migratedFrom(String(row.metadata)) : undefined;
+            const links = erase(database, () => {
+                database.prepare("UPDATE facts SET supersedes_id = NULL WHERE supersedes_id = ?").run(id);
+                const count = dropLinksOf(database, { type: "fact", id });
+                database.prepare("DELETE FROM links WHERE from_type = 'fact' AND from_id = ?").run(id);
+                database.prepare("DELETE FROM taggings WHERE taggable_type = 'fact' AND taggable_id = ?").run(id);
+                database.prepare("DELETE FROM facts WHERE id = ?").run(id);
+                if (twin !== undefined)
+                    database.prepare("DELETE FROM memories WHERE id = ? AND deleted_at IS NOT NULL").run(twin);
+                return count;
+            });
+            return { ref: `fact:${id}`, removed: true, links };
+        },
+        sources: (reference) => evidenceSourcesOf(database, { type: "fact", id: Number(rowOf(reference).id) }),
     };
 };
+const migratedFrom = (metadata) => {
+    try {
+        const { memory } = JSON.parse(metadata);
+        return Number.isInteger(memory) ? Number(memory) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
 export const factsStoreOver = (context) => {
     const operations = factOperationsOver(context);
     return {
@@ -135,5 +166,8 @@ export const factsStoreOver = (context) => {
         list: async (options) => operations.list(options),
         accept: async (reference) => operations.accept(reference),
         reverse: async (reference) => operations.reverse(reference),
+        reject: async (reference) => operations.reject(reference),
+        remove: async (reference) => operations.remove(reference),
+        sources: async (reference) => operations.sources(reference),
     };
 };

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

@@ -18,6 +18,11 @@ export declare const matchQuery: (context: StoreContext, execution: QueryExecuti
 export declare const countQuery: (context: StoreContext, execution: QueryExecution, by: QueryGrouping) => Promise<QueryGroup[]>;
 /** All matching message keys, without materializing message bodies or imposing a hit-page limit. */
 export declare const queryMessagePks: (context: StoreContext, execution: QueryExecution) => Promise<number[]>;
+/**
+ * How many messages match, counting no further than `cap + 1`: one SQL count, unranked. `undefined` when a leaf is
+ * checked row by row (a preset, a pattern), where a count would cost as much as the search itself.
+ */
+export declare const countMatches: (context: StoreContext, execution: QueryExecution, cap: number) => number | undefined;
 interface QuerySelection {
     sql: string;
     params: SqlValue[];

package/dist/store/sqlite/lucene.js

@@ -48,6 +48,23 @@ export const matchQuery = (context, execution) => runQuery(context, execution);
 export const countQuery = (context, execution, by) => runQuery(context, execution, by);
 /** All matching message keys, without materializing message bodies or imposing a hit-page limit. */
 export const queryMessagePks = (context, execution) => runQuery(context, execution, "pks");
+/**
+ * How many messages match, counting no further than `cap + 1`: one SQL count, unranked. `undefined` when a leaf is
+ * checked row by row (a preset, a pattern), where a count would cost as much as the search itself.
+ */
+export const countMatches = (context, execution, cap) => {
+    const { database, check, where, from, withRanking, ranked, leaves } = compileQuery(context, {
+        ...execution,
+        newest: true,
+    });
+    if (leaves.some(({ test }) => test))
+        return undefined;
+    const row = database
+        .prepare(`SELECT count(*) AS n FROM (${withRanking}SELECT m.id ${from} WHERE ${where.sql} LIMIT ?)`)
+        .get(...ranked.params, ...where.params, cap + 1);
+    check();
+    return Number(row?.n ?? 0);
+};
 const compileQuery = (context, execution, boundedAttachments = false) => {
     const { database } = context;
     const corpus = execution.corpus === "mail" ? MAIL : MESSAGES;