@wirecat/cli-core 0.411.0 → 0.413.0

package/dist/services/project-gathering.js

@@ -5,6 +5,7 @@ import { excerpt } from "./excerpt.js";
 import { attachNeighbours, documentMatches, } from "./project-gathering-around.js";
 import { decodeCheckpoint, encodeCheckpoint, projectGatheringRequest, projectUnits, seenKey, } from "./project-gathering-request.js";
 const terminal = new Set(["done", "unavailable", "failed"]);
+const PAGE = 20;
 const CONTEXTS = ["person-only", "sender", "linked-chat", "project"];
 const contextOf = (lane) => lane.kinds.includes("linked-chat")
     ? "linked-chat"
@@ -84,6 +85,12 @@ export const gatherProjectEvidence = async (ports, request) => {
     const oversized = new Map();
     let stopped = null;
     const open = (u) => !terminal.has(u.state) && u.state !== "read-limited";
+    const linkedLanes = new Set(plan.linkedChats.flatMap((c) => (c.lane === null ? [] : [c.lane])));
+    // One even share per linked chat plus one for the word and sender lanes, so one busy chat cannot fill a run; never
+    // below a page, so every chat still gets its whole first page.
+    const linkedLimit = Math.max(PAGE, Math.floor(plan.budgets.maxItems / (linkedLanes.size + 1)));
+    const linkedTaken = new Map();
+    const capped = new Set();
     /** Records another lane finding a reference this run already returned; true when it had. */
     const again = (ref, lane) => {
         const known = byRef.get(ref);
@@ -133,11 +140,13 @@ export const gatherProjectEvidence = async (ports, request) => {
         byRef.set(item.ref, entry);
         items.push(entry);
         usage.items++;
+        if (linkedLanes.has(lane.id))
+            linkedTaken.set(lane.id, (linkedTaken.get(lane.id) ?? 0) + 1);
     };
     // A resumed run starts at its shallowest open unit: below it no unit is due, and an empty round would end the run.
     const shallowest = progress.reduce((low, u) => (open(u) ? Math.min(low, u.pages) : low), Number.POSITIVE_INFINITY);
     for (let round = shallowest; !stopped; round++) {
-        const due = progress.flatMap((u, index) => (open(u) && u.pages <= round ? [index] : []));
+        const due = progress.flatMap((u, index) => open(u) && u.pages <= round && !capped.has(units[index]?.lane.id ?? "") ? [index] : []);
         if (!due.length)
             break;
         for (const index of due) {
@@ -145,6 +154,11 @@ export const gatherProjectEvidence = async (ports, request) => {
             if (!unit || !state)
                 continue;
             signal?.throwIfAborted();
+            const room = linkedLanes.has(unit.lane.id) ? linkedLimit - (linkedTaken.get(unit.lane.id) ?? 0) : PAGE;
+            if (room <= 0) {
+                capped.add(unit.lane.id);
+                continue;
+            }
             stopped =
                 usage.reads >= plan.budgets.maxReads
                     ? "reads"
@@ -187,7 +201,7 @@ export const gatherProjectEvidence = async (ports, request) => {
                 }
             };
             try {
-                let page = await readPage(Math.min(plan.budgets.maxPageBytes, plan.budgets.maxReadBytes - usage.readBytes), 20);
+                let page = await readPage(Math.min(plan.budgets.maxPageBytes, plan.budgets.maxReadBytes - usage.readBytes), Math.min(PAGE, room));
                 // A large record another lane already returned is not read again; its page already moves past it.
                 const big = page.oversized && !again(page.oversized.ref, unit.lane) ? page.oversized : undefined;
                 if (big && big.bytes <= CONTEXT_MAX_READ_BYTES) {
@@ -288,6 +302,8 @@ export const gatherProjectEvidence = async (ports, request) => {
                 : units.every((unit, index) => unit.lane.id !== lane || progress[index]?.state === "unavailable")
                     ? "unavailable"
                     : "in-scope",
+            items: lane === null ? 0 : (linkedTaken.get(lane) ?? 0),
+            capped: lane !== null && capped.has(lane),
         })),
         fetch: fetched.map((f, index) => ({ source: index, ...f })),
         index: indexed,

package/dist/services/search-all.js

@@ -1,6 +1,6 @@
 import { CliError } from "@wirecat/cli-base";
 import { parseLocator } from "../domain/locator.js";
-import { INTERNAL_NOTES, kindOf } from "../domain/providers.js";
+import { INTERNAL_NOTES, kindIn } from "../domain/providers.js";
 import { excerpt } from "./excerpt.js";
 import { MAX_SEARCH_OFFSET, searchStore } from "./messages-archive-search.js";
 import { notesScopeOf, RRF_K, searchNotes } from "./notes-search.js";
@@ -55,7 +55,10 @@ export const searchAll = async (store, account, request, messenger = {}, searchM
         hasMore ||= found.hasMore;
         const read = found.coverage?.accounts ??
             given ??
-            (await store.accounts.accounts()).filter(({ provider }) => kindOf(provider) === kind);
+            (await store.accounts.accounts()).filter(({ provider }) => kindIn(provider) === kind);
+        for (const one of found.skipped ?? [])
+            if (!skipped.some(({ source }) => source === one.source))
+                skipped.push(one);
         accounts.push(...read.map(({ provider, account }) => ({ resource: kind, provider, account })));
         return found.items.map((hit) => {
             const at = parseLocator(hit.locator);

package/dist/store/accounts.d.ts

@@ -1,3 +1,4 @@
+import type { ProviderEntry } from "../domain/providers.js";
 import { type AccountGroups, type Profiles } from "../search/account-list.js";
 import type { StoreContext } from "./sqlite/open.js";
 import type { AccountKey, StoredAccount } from "./types.js";
@@ -29,6 +30,8 @@ export interface AccountsStore extends AccountAccounts {
     profiles(): Promise<Profiles>;
     /** Records which account a profile of `app` is; a no-op when the store already says so. */
     saveProfile(app: string, profile: string, key: AccountKey): Promise<void>;
+    /** Writes a CLI's provider entry for every tool on this store to read; see `registerProvider`. */
+    registerProvider(entry: ProviderEntry): Promise<void>;
 }
 export declare const accountAccountsOver: (context: StoreContext) => AccountAccounts;
 export declare const accountsStoreOver: (context: StoreContext, keyed: AccountAccounts) => AccountsStore;

package/dist/store/accounts.js

@@ -3,6 +3,7 @@ import { keysOver } from "./keys.js";
 import { accountGroupsOf, profilesOf, saveProfile } from "./sqlite/account-groups.js";
 import * as accounts from "./sqlite/accounts.js";
 import { linkOwnIdentities } from "./sqlite/own-identities.js";
+import { registerProvider } from "./sqlite/providers.js";
 import { linkInbox } from "./sqlite/tasks.js";
 import { write } from "./sqlite/transaction.js";
 export const accountAccountsOver = (context) => {
@@ -34,6 +35,7 @@ export const accountsStoreOver = (context, keyed) => {
         accountGroups: async () => accountGroupsOf(database),
         profiles: async () => profilesOf(database),
         saveProfile: async (app, profile, key) => write(database, () => saveProfile(database, app, profile, key, context.now())),
+        registerProvider: async (entry) => registerProvider(database, entry, context.now()),
         saveAccountGroup: async (name, members) => write(database, () => {
             const groups = accountGroupsOf(database);
             if (members === undefined)

package/dist/store/exports.d.ts

@@ -8,6 +8,7 @@ export type { AccountCounters, CountersStore } from "./counters.js";
 export type { AccountMentions, MentionsStore } from "./mentions.js";
 export type { AccountMessages, MessagesStore } from "./messages.js";
 export type { AccountPeople, PeopleStore } from "./people.js";
+export { registerProvider } from "./providers.js";
 export type { QueriesStore } from "./queries.js";
 export type { RosterStore } from "./roster.js";
 export type { SearchIndexStore } from "./search-index.js";

package/dist/store/exports.js

@@ -1,3 +1,4 @@
+export { registerProvider } from "./providers.js";
 export { accountGroupsOf } from "./sqlite/account-groups.js";
 export { attachmentColumns, resetAttachmentWords, } from "./sqlite/attachment-texts.js";
 export { pendingNormalization } from "./sqlite/backfill.js";

package/dist/store/index.d.ts

@@ -3,6 +3,7 @@ export { FACT_STATUSES, FACT_TYPES, MEMORY_KINDS, MEMORY_SCOPES, MEMORY_STATUSES
 export type { TagConsolidationOptions, TagConsolidationPreview, TagConsolidationStore, } from "../domain/tag-consolidation.js";
 export type { TagRedirectIndex, TagRedirectResolution, TagRedirectSnapshot } from "../domain/tag-redirects.js";
 export { createTagRedirectIndex } from "../domain/tag-redirects.js";
+export { note } from "../entities/note.js";
 export type { FindingEvidence, FindingOutcome, MeetingFactFinding, MeetingFinding, MeetingFindingsInput, MeetingFindingsReceipt, MeetingTaskFinding, } from "../meetings/index.js";
 export type { AccountMail, AccountMeetings, AccountStore } from "./account-store.js";
 export type { DocumentTransferOptions, DocumentTransferPreview, DocumentTransferReceipt, } from "./document-transfer/index.js";
@@ -10,6 +11,7 @@ export { applyDocumentTransfer, previewDocumentTransfer } from "./document-trans
 export type { CacheDatabase, CacheStatement, OpenDatabase, SqlValue } from "./driver.js";
 export { PRAGMAS } from "./driver.js";
 export { EVIDENCE_FINDINGS_KIND, type EvidenceFindingsBatch, type EvidenceFindingsDecider, type EvidenceFindingsReceipt, type EvidenceFindingsStore, validateEvidenceFindings, } from "./evidence-findings.js";
+export { ORGANIZATIONS_QUERY, organization, PROJECTS_QUERY, project, REMINDERS_QUERY, reminder, } from "./knowledge-query.js";
 export type { MeetingFindingsBatch, MeetingFindingsStore } from "./meeting-findings.js";
 export { MIGRATIONS, type Migration, migrate } from "./migrations.js";
 export { openCache } from "./open.js";
@@ -41,7 +43,7 @@ export type { AttachmentInput } from "./sqlite/meetings.js";
 export type { Author, MemoriesStore, Memory, MemoryInput } from "./sqlite/memories.js";
 export type { NoteIndexState } from "./sqlite/note-index.js";
 export { type NearestNote, NOTE_FIELDS, type NoteChunkToEmbed, type NoteHit, type NoteQuery, type NoteSearch, } from "./sqlite/note-search.js";
-export type { FileNoteInput, Link, LinkInput, Note, NoteFolder, NotesStore, NoteTag, } from "./sqlite/notes.js";
+export type { FileNoteInput, Link, LinkInput, LinkListFilter, Note, NoteFolder, NotesStore, NoteTag, } from "./sqlite/notes.js";
 export type { PrivateContact, PrivateContactNote } from "./sqlite/private-people.js";
 export type { ProposalInput, ProposedAction, ProposedActionsStore } from "./sqlite/proposed-actions.js";
 export { PROPOSAL_STATUSES } from "./sqlite/proposed-actions.js";

package/dist/store/index.js

@@ -1,8 +1,10 @@
 export { FACT_STATUSES, FACT_TYPES, MEMORY_KINDS, MEMORY_SCOPES, MEMORY_STATUSES, TASK_TYPES, WORK_TASK_TYPES, } from "../domain/knowledge.js";
 export { createTagRedirectIndex } from "../domain/tag-redirects.js";
+export { note } from "../entities/note.js";
 export { applyDocumentTransfer, previewDocumentTransfer } from "./document-transfer/index.js";
 export { PRAGMAS } from "./driver.js";
 export { EVIDENCE_FINDINGS_KIND, validateEvidenceFindings, } from "./evidence-findings.js";
+export { ORGANIZATIONS_QUERY, organization, PROJECTS_QUERY, project, REMINDERS_QUERY, reminder, } from "./knowledge-query.js";
 export { MIGRATIONS, migrate } from "./migrations.js";
 export { openCache } from "./open.js";
 export { storePath } from "./path.js";

package/dist/store/knowledge-query.d.ts

@@ -0,0 +1,6 @@
+import { type QueryRegistry } from "@wirecat/cli-base/query";
+import { organization, project, reminder } from "../entities/knowledge-lists.js";
+export { organization, project, reminder };
+export declare const ORGANIZATIONS_QUERY: QueryRegistry;
+export declare const PROJECTS_QUERY: QueryRegistry;
+export declare const REMINDERS_QUERY: QueryRegistry;

package/dist/store/knowledge-query.js

@@ -0,0 +1,34 @@
+import { queryFieldsOf } from "@wirecat/cli-base/query";
+import { organization, project, reminder } from "../entities/knowledge-lists.js";
+export { organization, project, reminder };
+export const ORGANIZATIONS_QUERY = {
+    entity: "organization",
+    backend: "sql",
+    fields: queryFieldsOf(organization, {
+        native: ["id", "kind", "scope", "created_at"],
+        examples: { id: "id:1", kind: "kind:company", scope: "scope:work", created_at: "created_at>=2026-01-01" },
+    }),
+};
+export const PROJECTS_QUERY = {
+    entity: "project",
+    backend: "sql",
+    fields: queryFieldsOf(project, {
+        native: ["id", "key", "type", "organization_id", "scope", "created_at"],
+        examples: {
+            id: "id:1",
+            key: "key:SMP",
+            type: "type:work",
+            organization_id: "organization_id:1",
+            scope: "scope:work",
+            created_at: "created_at>=2026-01-01",
+        },
+    }),
+};
+export const REMINDERS_QUERY = {
+    entity: "reminder",
+    backend: "sql",
+    fields: queryFieldsOf(reminder, {
+        native: ["id", "state", "due_at", "revision"],
+        examples: { id: "id:1", state: "state:pending", due_at: "due_at>=2026-01-01", revision: "revision>1" },
+    }),
+};

package/dist/store/providers.d.ts

@@ -0,0 +1,7 @@
+import type { ProviderEntry } from "../domain/providers.js";
+import type { MessageStore } from "./store.js";
+/**
+ * A CLI's entry, written into the store on every run so cli-core in every other CLI knows its provider's kind and
+ * aliases. Two entries that disagree on a kind, or an alias another provider already has, are an error.
+ */
+export declare const registerProvider: (store: Pick<MessageStore, "accounts">, entry: ProviderEntry) => Promise<void>;

package/dist/store/providers.js

@@ -0,0 +1,5 @@
+/**
+ * A CLI's entry, written into the store on every run so cli-core in every other CLI knows its provider's kind and
+ * aliases. Two entries that disagree on a kind, or an alias another provider already has, are an error.
+ */
+export const registerProvider = (store, entry) => store.accounts.registerProvider(entry);

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

@@ -1,3 +1,4 @@
+import type { QueryAst } from "@wirecat/cli-base/query";
 import type { AccountKey } from "../types.js";
 import { RELATION_KINDS } from "./link-kinds.js";
 import { type MeetingProjectsStore } from "./meeting-projects.js";
@@ -130,7 +131,7 @@ export interface KnowledgeStore extends VocabularyStore, MeetingProjectsStore {
         id: string;
         removed: true;
     }>;
-    tags(key: KnowledgeScope, target: KnowledgeTarget): Promise<string[]>;
+    tags(key: KnowledgeScope, target: KnowledgeTarget, tag?: string): Promise<string[]>;
     addTags(key: KnowledgeScope, target: KnowledgeTarget, tags: string[]): Promise<string[]>;
     removeTags(key: KnowledgeScope, target: KnowledgeTarget, tags: string[]): Promise<string[]>;
     /**
@@ -163,7 +164,7 @@ export interface KnowledgeStore extends VocabularyStore, MeetingProjectsStore {
         name: string;
         scope?: Organization["scope"];
     }): Promise<Organization>;
-    organizations(): Promise<Organization[]>;
+    organizations(query?: QueryAst): Promise<Organization[]>;
     /** A project; its key is made from the name when none is given. */
     addProject(input: {
         name: string;
@@ -173,7 +174,7 @@ export interface KnowledgeStore extends VocabularyStore, MeetingProjectsStore {
         scope?: Project["scope"];
         description?: string;
     }): Promise<Project>;
-    projects(): Promise<Project[]>;
+    projects(query?: QueryAst): Promise<Project[]>;
     relate(key: KnowledgeScope, input: {
         from: string;
         to: string;
@@ -190,7 +191,7 @@ export interface KnowledgeStore extends VocabularyStore, MeetingProjectsStore {
     }>;
     confirmRelation(key: KnowledgeScope, id: string): Promise<KnowledgeRelation>;
     schedule(key: AccountKey, task: string, dueAt: string, timezone: string): Promise<Reminder>;
-    reminders(key: AccountKey): Promise<Reminder[]>;
+    reminders(key: AccountKey, query?: QueryAst): Promise<Reminder[]>;
     cancelReminder(key: AccountKey, id: string): Promise<Reminder>;
     snoozeReminder(key: AccountKey, id: string, dueAt: string, revision: number): Promise<Reminder>;
     claimReminders(key: AccountKey, options?: {

package/dist/store/sqlite/knowledge.js

@@ -9,6 +9,7 @@ import { ownerPerson } from "./actors.js";
 import { linkKind, RELATION_KINDS } from "./link-kinds.js";
 import { meetingProjectsStoreOver } from "./meeting-projects.js";
 import { insertLink, linkOf } from "./notes.js";
+import { queryFilter } from "./query-filter.js";
 import { addTags as addThingTags, canonicalTagNamed, createTag, labelsOf, removeTags as removeThingTags, setMainTopic, } from "./tags.js";
 import { TASK_KEY_PREFIXES } from "./task-keys.js";
 import { inboxKey, taskAccountOf, taskIdOf, taskRowOf } from "./tasks.js";
@@ -153,10 +154,10 @@ export const knowledgeStoreOver = (context) => {
         ? parseReference(formatReference({ type: "folder", id: target.id, path: target.path ?? null })).path
         : null;
     /** A subfolder's labels: `labelled` links from the folder, anchored at the path, to each tag. */
-    const subfolderLabels = (folder, path) => database
+    const subfolderLabels = (folder, path, tag) => database
         .prepare("SELECT t.name FROM links l JOIN tags t ON t.id = l.to_id WHERE l.from_type = 'account' AND l.from_id = ? " +
-        `AND l.kind = ${linkKind("labelled")} AND l.to_type = 'tag' AND l.anchor = ? ORDER BY t.name`)
-        .all(folder, path)
+        `AND l.kind = ${linkKind("labelled")} AND l.to_type = 'tag' AND l.anchor = ?${tag === undefined ? "" : " AND t.name = ?"} ORDER BY t.name`)
+        .all(folder, path, ...(tag === undefined ? [] : [tag]))
         .map((row) => String(row.name));
     const annotationOf = (row) => {
         const thing = storedThing(row.notable_type, row.notable_id);
@@ -335,12 +336,15 @@ export const knowledgeStoreOver = (context) => {
             database.prepare("DELETE FROM notes WHERE id=?").run(Number(id));
             return { id, removed: true };
         },
-        tags: async (key, target) => {
+        tags: async (key, target, tag) => {
             const { thing, state } = resolve(key, target);
             if (!thing || state !== "available")
                 return [];
             const path = subfolder(target);
-            return path === null ? labelsOf(database, thing).map(({ tag }) => tag) : subfolderLabels(thing.id, path);
+            const name = tag === undefined ? undefined : canonicalTagName(tag);
+            return path === null
+                ? labelsOf(database, thing, name).map(({ tag }) => tag)
+                : subfolderLabels(thing.id, path, name);
         },
         addTags: async (key, target, tags) => {
             const thing = available(key, target);
@@ -418,10 +422,19 @@ export const knowledgeStoreOver = (context) => {
                 .get(oneOf(kind, ORGANIZATION_KINDS, "an organization's kind"), textOf(name, 200), oneOf(scope, SCOPES, "a scope"), at, at);
             return organizationOf(row);
         },
-        organizations: async () => database
-            .prepare("SELECT * FROM organizations WHERE deleted_at IS NULL ORDER BY name, id LIMIT 500")
-            .all()
-            .map(organizationOf),
+        organizations: async (query) => {
+            const where = query &&
+                queryFilter(query, {
+                    id: { type: "kw", sql: "CAST(id AS TEXT)" },
+                    kind: { type: "enum", sql: "kind" },
+                    scope: { type: "enum", sql: "scope" },
+                    created_at: { type: "time", sql: "created_at" },
+                });
+            return database
+                .prepare(`SELECT * FROM organizations WHERE deleted_at IS NULL${where ? ` AND (${where.sql})` : ""} ORDER BY name, id LIMIT 500`)
+                .all(...(where?.params ?? []))
+                .map(organizationOf);
+        },
         addProject: async ({ name, key, type = "other", organization, scope = "personal", description }) => write(database, () => {
             const title = textOf(name, 200);
             const organizationId = organization === undefined
@@ -475,10 +488,21 @@ export const knowledgeStoreOver = (context) => {
                 .get(chosen, title, description === undefined ? null : textOf(description, 2000), oneOf(type, PROJECT_TYPES, "a project's type"), organizationId, oneOf(scope, SCOPES, "a scope"), at, at);
             return projectOf(row);
         }),
-        projects: async () => database
-            .prepare("SELECT * FROM projects WHERE deleted_at IS NULL ORDER BY name, id LIMIT 500")
-            .all()
-            .map(projectOf),
+        projects: async (query) => {
+            const where = query &&
+                queryFilter(query, {
+                    id: { type: "kw", sql: "CAST(id AS TEXT)" },
+                    key: { type: "kw", sql: "key" },
+                    type: { type: "enum", sql: "type" },
+                    organization_id: { type: "kw", sql: "CAST(organization_id AS TEXT)" },
+                    scope: { type: "enum", sql: "scope" },
+                    created_at: { type: "time", sql: "created_at" },
+                });
+            return database
+                .prepare(`SELECT * FROM projects WHERE deleted_at IS NULL${where ? ` AND (${where.sql})` : ""} ORDER BY name, id LIMIT 500`)
+                .all(...(where?.params ?? []))
+                .map(projectOf);
+        },
         relate: async (key, input) => {
             const from = related(key, input.from, true);
             const to = related(key, input.to);
@@ -553,10 +577,19 @@ export const knowledgeStoreOver = (context) => {
                 .get(row, accountId, timestamp, timezone, at, at);
             return reminder(key, String(made?.id));
         },
-        reminders: async (key) => database
-            .prepare("SELECT * FROM reminders WHERE account_id=? ORDER BY due_at, id LIMIT 500")
-            .all(account(key))
-            .map(reminderOf),
+        reminders: async (key, query) => {
+            const where = query &&
+                queryFilter(query, {
+                    id: { type: "kw", sql: "CAST(id AS TEXT)" },
+                    state: { type: "enum", sql: "state" },
+                    due_at: { type: "time", sql: "due_at" },
+                    revision: { type: "num", sql: "revision" },
+                });
+            return database
+                .prepare(`SELECT * FROM reminders WHERE account_id=?${where ? ` AND (${where.sql})` : ""} ORDER BY due_at, id LIMIT 500`)
+                .all(account(key), ...(where?.params ?? []))
+                .map(reminderOf);
+        },
         cancelReminder: async (key, id) => {
             reminder(key, id);
             database

package/dist/store/sqlite/mail-rules.d.ts

@@ -1,3 +1,4 @@
+import type { QueryAst } from "@wirecat/cli-base/query";
 import type { JsonValue } from "../../meetings/index.js";
 import type { CacheDatabase } from "../driver.js";
 type JsonObject = {
@@ -36,7 +37,7 @@ export interface MailRuleCount {
 }
 export interface MailRulesStore {
     /** Oldest first. */
-    list(accountId: number): Promise<MailRule[]>;
+    list(accountId: number, query?: QueryAst): Promise<MailRule[]>;
     /** A rule with the same conditions is replaced, and keeps its id and the emails it decided. */
     upsert(accountId: number, rule: MailRuleInput, now: number): Promise<MailRule>;
     /** Clears the rule from the emails it decided. Answers false when no rule has these conditions. */

package/dist/store/sqlite/mail-rules.js

@@ -1,3 +1,4 @@
+import { queryFilter } from "./query-filter.js";
 import { write } from "./transaction.js";
 const sorted = (value) => Array.isArray(value)
     ? value.map(sorted)
@@ -23,8 +24,17 @@ const ruleOf = (row) => ({
 // SQLite allows 32766 parameters; two are taken by the account and the rule.
 const CHUNK = 30_000;
 export const mailRulesOver = (database) => ({
-    async list(accountId) {
-        return database.prepare("SELECT * FROM mail_rules WHERE account_id = ? ORDER BY id").all(accountId).map(ruleOf);
+    async list(accountId, query) {
+        const where = query &&
+            queryFilter(query, {
+                id: { type: "num", sql: "id" },
+                protected: { type: "bool", sql: "protected" },
+                source: { type: "kw", sql: "source" },
+            });
+        return database
+            .prepare(`SELECT * FROM mail_rules WHERE account_id = ?${where ? ` AND (${where.sql})` : ""} ORDER BY id`)
+            .all(accountId, ...(where?.params ?? []))
+            .map(ruleOf);
     },
     async upsert(accountId, rule, now) {
         const row = database

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

@@ -51,6 +51,16 @@ export interface Link {
     confirmed: boolean;
     createdAt: string;
 }
+export interface LinkListFilter {
+    from?: string;
+    to?: string;
+    unresolved?: boolean;
+    id?: string;
+    kind?: Link["kind"];
+    role?: string;
+    origin?: Link["origin"];
+    confirmed?: boolean;
+}
 export interface LinkInput {
     from: string;
     to?: string;
@@ -123,11 +133,7 @@ export interface NotesStore extends NoteSearch, ImportedDocuments {
         removed: true;
     }>;
     addLink(input: LinkInput): Promise<Link>;
-    links(options?: {
-        from?: string;
-        to?: string;
-        unresolved?: boolean;
-    }): Promise<Link[]>;
+    links(options?: LinkListFilter): Promise<Link[]>;
     removeLink(id: string): Promise<{
         id: string;
         removed: true;

package/dist/store/sqlite/notes.js

@@ -404,10 +404,17 @@ export const notesStoreOver = (context) => {
             const to = pair(options.to);
             if (!from.known || !to.known)
                 return [];
+            const filters = [
+                ...(options.id === undefined ? [] : [{ sql: "CAST(id AS TEXT) = ?", value: options.id }]),
+                ...(options.kind === undefined ? [] : [{ sql: "kind = ?", value: options.kind }]),
+                ...(options.role === undefined ? [] : [{ sql: "role = ?", value: options.role }]),
+                ...(options.origin === undefined ? [] : [{ sql: "source = ?", value: options.origin }]),
+                ...(options.confirmed === undefined ? [] : [{ sql: "confirmed = ?", value: options.confirmed ? 1 : 0 }]),
+            ];
             return database
                 .prepare("SELECT * FROM links WHERE (? IS NULL OR (from_type = ? AND from_id = ?)) AND (? IS NULL OR (to_type = ? AND to_id = ?)) " +
-                "AND (? = 0 OR to_id IS NULL) ORDER BY created_at, id LIMIT 5000")
-                .all(from.type, from.type, from.id, to.type, to.type, to.id, options.unresolved ? 1 : 0)
+                `AND (? = 0 OR to_id IS NULL)${filters.map(({ sql }) => ` AND (${sql})`).join("")} ORDER BY created_at, id LIMIT 5000`)
+                .all(from.type, from.type, from.id, to.type, to.type, to.id, options.unresolved ? 1 : 0, ...filters.map(({ value }) => value))
                 .map((row) => linkOf(database, row));
         },
         removeLink: async (id) => write(database, () => {

package/dist/store/sqlite/open-store.js

@@ -9,6 +9,7 @@ import { backfillNormalized, pendingNormalization } from "./backfill.js";
 import { fillFolded } from "./folded.js";
 import { logPruner } from "./log-pruning.js";
 import { openSqlite } from "./open.js";
+import { loadProviders } from "./providers.js";
 import { assertReadCompatible } from "./read-compatibility.js";
 import { stemsState } from "./stems.js";
 import { fillStems, followDefaultStemmers } from "./stems-fill.js";
@@ -56,6 +57,7 @@ export const openStoreContext = async ({ path, env, now = Date.now, command, rea
                 fillStems(database, { now });
             logPruner(database, now)();
         }
+        loadProviders(database);
         return { ...opened, now, sharedConfig: sharedConfigPath(file, env ?? process.env) };
     }
     catch (error) {

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

@@ -0,0 +1,12 @@
+import { type ProviderEntry } from "../../domain/providers.js";
+import type { CacheDatabase } from "../driver.js";
+export declare const PROVIDERS_SETTING = "providers";
+/** The entries as stored, unchecked: a newer CLI may have written a kind this build does not know. */
+export declare const storedProvidersOf: (database: CacheDatabase) => unknown[];
+/** Called on every open: the module state follows the store the process opened last. */
+export declare const loadProviders: (database: CacheDatabase) => void;
+/**
+ * Writes `entry` over the stored one of its name and loads the result. Every run of every CLI calls it, so it
+ * writes only when the entry changed. Entries this build cannot read stay stored for the CLIs that can.
+ */
+export declare const registerProvider: (database: CacheDatabase, value: ProviderEntry, now: number) => void;

package/dist/store/sqlite/providers.js

@@ -0,0 +1,45 @@
+import { addProvider, providerEntryOf, useStoredProviders } from "../../domain/providers.js";
+import { write } from "./transaction.js";
+export const PROVIDERS_SETTING = "providers";
+/** The entries as stored, unchecked: a newer CLI may have written a kind this build does not know. */
+export const storedProvidersOf = (database) => {
+    const row = database.prepare("SELECT value FROM store_settings WHERE key = ?").get(PROVIDERS_SETTING);
+    if (!row)
+        return [];
+    try {
+        const value = JSON.parse(String(row.value));
+        return Array.isArray(value) ? value : [];
+    }
+    catch {
+        return [];
+    }
+};
+/** Called on every open: the module state follows the store the process opened last. */
+export const loadProviders = (database) => {
+    useStoredProviders(storedProvidersOf(database));
+};
+const nameOf = (stored) => typeof stored === "object" && stored !== null ? stored.name : undefined;
+/**
+ * Writes `entry` over the stored one of its name and loads the result. Every run of every CLI calls it, so it
+ * writes only when the entry changed. Entries this build cannot read stay stored for the CLIs that can.
+ */
+export const registerProvider = (database, value, now) => {
+    const entry = providerEntryOf(value);
+    write(database, () => {
+        const stored = storedProvidersOf(database);
+        const others = stored.filter((one) => nameOf(one) !== entry.name);
+        try {
+            useStoredProviders(others);
+            addProvider(entry);
+        }
+        catch (error) {
+            useStoredProviders(stored);
+            throw error;
+        }
+        if (stored.some((one) => JSON.stringify(one) === JSON.stringify(entry)))
+            return;
+        database
+            .prepare("INSERT OR REPLACE INTO store_settings (key, value, at) VALUES (?, ?, ?)")
+            .run(PROVIDERS_SETTING, JSON.stringify([...others, entry]), now);
+    });
+};

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

@@ -83,7 +83,7 @@ export interface Label {
     origin: "file" | "owner";
 }
 /** A thing's tags by name, with whether only a file states each. */
-export declare const labelsOf: (database: CacheDatabase, thing: Thing) => Label[];
+export declare const labelsOf: (database: CacheDatabase, thing: Thing, tag?: string) => Label[];
 /**
  * Marks one topic as the thing's main one, or clears it with `null`: the topic is tagged on it if it was
  * not, and any other main topic stops being main.

package/dist/store/sqlite/tags.js

@@ -156,9 +156,9 @@ export const removeTags = ({ database }, thing, tags, source) => {
     });
 };
 /** A thing's tags by name, with whether only a file states each. */
-export const labelsOf = (database, thing) => database
-    .prepare("SELECT t.name, g.source FROM taggings g JOIN tags t ON t.id = g.tag_id WHERE g.taggable_type=? AND g.taggable_id=? ORDER BY t.name")
-    .all(thing.type, thing.id)
+export const labelsOf = (database, thing, tag) => database
+    .prepare(`SELECT t.name, g.source FROM taggings g JOIN tags t ON t.id = g.tag_id WHERE g.taggable_type=? AND g.taggable_id=?${tag === undefined ? "" : " AND t.name = ?"} ORDER BY t.name`)
+    .all(thing.type, thing.id, ...(tag === undefined ? [] : [tag]))
     .map((row) => ({ tag: String(row.name), origin: row.source === "file" ? "file" : "owner" }));
 /**
  * Marks one topic as the thing's main one, or clears it with `null`: the topic is tagged on it if it was

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.411.0",
+  "version": "0.413.0",
   "description": "The messenger-neutral half of a messaging CLI: domain model, message locators, rendering, name resolution, the SQLite seam, the command skeleton and shared read commands, the send guard, run records and the message store",
   "license": "Apache-2.0",
   "author": "Viacheslav Ptsarev",
@@ -128,6 +128,10 @@
     "./update": {
       "types": "./dist/update/index.d.ts",
       "default": "./dist/update/index.js"
+    },
+    "./oauth": {
+      "types": "./dist/oauth/index.d.ts",
+      "default": "./dist/oauth/index.js"
     }
   },
   "scripts": {