@wirecat/cli-core 0.549.0 → 0.551.0

package/dist/services/deps.d.ts

@@ -5,6 +5,7 @@ import type { MessengerTraits } from "../ports/traits.js";
 import type { SendGuard } from "../sends/guard.js";
 import type { AccountStore } from "../store/account-store.js";
 import type { AccountKey, MessageStore } from "../store/store.js";
+import type { HistoryLimits } from "./history-limits.js";
 import type { Override } from "./index.js";
 export interface ServiceMessenger extends MessengerTraits {
     /** Replaces shared use cases for this messenger; its commands and MCP tools both get the replacement. */
@@ -39,6 +40,8 @@ export interface ServiceDeps {
     /** `false` keeps no search history: recording was turned off by name. Kept when unset. */
     history?: boolean;
     searchCatchUp?: boolean;
+    /** How far back `messages sync` reads each kind of chat, and which groups it does not read at all. */
+    historyLimits?: HistoryLimits;
     /** This account has picture search on (`pictureSearch`): its images are embedded and searched by their pixels. */
     pictures?: boolean;
     /** Which reranker orders `--discover`'s first hits (`searchReranker`), or `off`; the default when unset. */

package/dist/services/history-limits.d.ts

@@ -22,6 +22,8 @@ export interface HistorySkip {
     members?: number;
     /** For `older_than_window`: the window's start when the push was saved. */
     keptFrom?: string;
+    /** `messages sync` stopped there, so how many messages were left out is not known (`messages` is 0). */
+    unread?: true;
 }
 /** The kind and size of a chat, as the batch names it or the store holds it. */
 export interface ChatShape {

package/dist/services/index.d.ts

@@ -1,10 +1,12 @@
 import { type BotCheckService } from "../botcheck/service.js";
+export { paymentTitle } from "../meetings/index.js";
 export { amountOf, amountsOf, type TaskAmount } from "../search/task-signature.js";
 export { AGENDA_DEFAULTS } from "./agenda.js";
 export { type ChatCoverage, chatCoverage } from "./chat-coverage.js";
 export type { ContextEvidenceItem, ContextEvidencePage, ContextEvidenceReader, ContextEvidenceRequest, ContextEvidenceSender, ContextIndex, ContextReadLimits, ContextReadUsage, ContextRecordReader, ContextSource, ScopedContextEvidenceReader, } from "./context-evidence.js";
 export { contextEvidenceFingerprint, createContextEvidenceReader } from "./context-evidence.js";
 export { excerpt } from "./excerpt.js";
+export { aliasHits, BUILT_IN_PURPOSES, chatSenders, chatTitle, combinedScore, DEFAULT_LIMIT as DEFAULT_LINK_SCAN_LIMIT, DEFAULT_THRESHOLD as DEFAULT_LINK_SCAN_THRESHOLD, emailDomain, type LinkCandidate, type LinkScorer, mailThread, memberChats, memberDialog, PERSON_SCORERS, PERSON_THRESHOLD as PERSON_LINK_SCAN_THRESHOLD, SCAN_BOT, SCORERS, type ScanInput as LinkScanInput, type ScannedProject, type ScannedProposal, type ScanResult as LinkScanResult, type ScorerInput, type Signal as LinkSignal, scanProjectLinks, } from "./link-scorers/index.js";
 export type { MediaArchiveOptions, MediaArchivePorts } from "./media-archive.js";
 export { archiveMedia, checkMediaArchive } from "./media-archive.js";
 export type { MediaArchiveEntry, MediaIdentity } from "./media-archive-manifest.js";
@@ -19,6 +21,7 @@ export { documentPassage, storedMessageNeighbours, storedNeighbours } from "./pr
 export type { EvidenceMention, EvidenceMentions } from "./project-gathering-mentions.js";
 export { findEvidenceMentions } from "./project-gathering-mentions.js";
 export type { ProjectChatFetched, ProjectGatheringBudgets, ProjectGatheringRequest, ProjectLane, ProjectLaneKind, ProjectLinkedChat, ProjectPerson, ProjectSender, ProjectUnitState, } from "./project-gathering-request.js";
+export { DEFAULT_PURPOSES, type MoneyTotal, type ProjectStatus, type ProjectStatusInput, projectStatus, STATUS_CHATS, STATUS_SIGNALS, STATUS_WINDOW, type StatusAttention, type StatusChat, type StatusChatSummary, type StatusContext, type StatusItem, type StatusSignal, } from "./project-status/index.js";
 export { questions } from "./questions.js";
 export { canonicalProjectRef, gatherStoredProject, type LinkedChat, linkedChatsOf, type StoredProjectGathering, type StoredProjectInput, } from "./stored-project-gathering.js";
 import { type AccountService } from "./account.js";
@@ -181,7 +184,7 @@ export { type PackageUpgradeOutcome, type PackageUpgradePorts, type PackageUpgra
 export { type PersonMeetingContext, type PersonMeetingContextItem, type PersonMeetingContextOptions, type PersonMeetingReadStore, personMeetingContext, } from "./person-meeting-context.js";
 export { privatePeopleService } from "./private-people.js";
 export { approveAsTask, type ProposalTaskStore, proposalSource } from "./proposal-tasks.js";
-export { type Decided, type Decision, emptyProposalRegistry, type ProposalFilter, type ProposalKind, type ProposalRegistry, type ProposalRow, parseProposalIds, proposalRegistry, } from "./proposals/index.js";
+export { type Decided, type Decision, emptyProposalRegistry, FACT_SUMMARIES, type ProposalFilter, type ProposalKind, type ProposalRegistry, type ProposalRow, parseProposalIds, proposalRegistry, } from "./proposals/index.js";
 export type { RetentionQuery, RetentionService } from "./retention.js";
 export { retentionService } from "./retention.js";
 export { RESOURCES_SEARCHED, type SearchAllFound, type SearchAllItem, type SearchAllMessenger, type SearchAllRequest, type SearchedResource, searchAll, } from "./search-all.js";

package/dist/services/index.js

@@ -1,9 +1,11 @@
 import { botCheckService } from "../botcheck/service.js";
+export { paymentTitle } from "../meetings/index.js";
 export { amountOf, amountsOf } from "../search/task-signature.js";
 export { AGENDA_DEFAULTS } from "./agenda.js";
 export { chatCoverage } from "./chat-coverage.js";
 export { contextEvidenceFingerprint, createContextEvidenceReader } from "./context-evidence.js";
 export { excerpt } from "./excerpt.js";
+export { aliasHits, BUILT_IN_PURPOSES, chatSenders, chatTitle, combinedScore, DEFAULT_LIMIT as DEFAULT_LINK_SCAN_LIMIT, DEFAULT_THRESHOLD as DEFAULT_LINK_SCAN_THRESHOLD, emailDomain, mailThread, memberChats, memberDialog, PERSON_SCORERS, PERSON_THRESHOLD as PERSON_LINK_SCAN_THRESHOLD, SCAN_BOT, SCORERS, scanProjectLinks, } from "./link-scorers/index.js";
 export { archiveMedia, checkMediaArchive } from "./media-archive.js";
 export { moveMediaArchive } from "./media-archive-move.js";
 export { downloadImageModel, downloadTextModel, } from "./model-downloads.js";
@@ -11,6 +13,7 @@ export { MONEY_DONE, MONEY_REQUEST, MONEY_WORDS, moneyClassesOf, PROMISE } from
 export { gatherProjectEvidence } from "./project-gathering.js";
 export { documentPassage, storedMessageNeighbours, storedNeighbours } from "./project-gathering-around.js";
 export { findEvidenceMentions } from "./project-gathering-mentions.js";
+export { DEFAULT_PURPOSES, projectStatus, STATUS_CHATS, STATUS_SIGNALS, STATUS_WINDOW, } from "./project-status/index.js";
 export { questions } from "./questions.js";
 export { canonicalProjectRef, gatherStoredProject, linkedChatsOf, } from "./stored-project-gathering.js";
 import { accountService } from "./account.js";
@@ -139,7 +142,7 @@ export { upgradePackage, } from "./package-upgrade.js";
 export { personMeetingContext, } from "./person-meeting-context.js";
 export { privatePeopleService } from "./private-people.js";
 export { approveAsTask, proposalSource } from "./proposal-tasks.js";
-export { emptyProposalRegistry, parseProposalIds, proposalRegistry, } from "./proposals/index.js";
+export { emptyProposalRegistry, FACT_SUMMARIES, parseProposalIds, proposalRegistry, } from "./proposals/index.js";
 export { retentionService } from "./retention.js";
 export { RESOURCES_SEARCHED, searchAll, } from "./search-all.js";
 export { RESOURCES_SEARCHED_WITH_MEETINGS, searchAllIncludingMeetings, searchAllWithMeetings, } from "./search-all-meetings.js";

package/dist/services/job-query.d.ts

@@ -1,8 +1,11 @@
 import { type QueryAst } from "@wirecat/cli-base/query";
-/** The job folder is the list's own source: every file is read whole, so it answers each field. */
+/**
+ * The job folder is the list's own source: every file is read whole, so it answers each field. `sql`, not `native`:
+ * `evaluate` takes the whole language, OR included, and the help and the MCP description say so.
+ */
 export declare const JOBS_QUERY: {
     readonly entity: "job";
-    readonly backend: "native";
+    readonly backend: "sql";
     readonly fields: import("@wirecat/cli-base/query").FieldSpec[];
 };
 /** One profile's jobs as `store jobs list` answers them, newest first; the query is checked as each file is read. */

package/dist/services/job-query.js

@@ -1,10 +1,13 @@
 import { evaluate, queryFieldsOf } from "@wirecat/cli-base/query";
 import { job } from "../entities/job.js";
 import { jobItem, listJobs } from "./backfill-jobs.js";
-/** The job folder is the list's own source: every file is read whole, so it answers each field. */
+/**
+ * The job folder is the list's own source: every file is read whole, so it answers each field. `sql`, not `native`:
+ * `evaluate` takes the whole language, OR included, and the help and the MCP description say so.
+ */
 export const JOBS_QUERY = {
     entity: "job",
-    backend: "native",
+    backend: "sql",
     fields: queryFieldsOf(job, {
         native: Object.keys(job.entries),
         examples: { state: "state:failed", started_at: "started_at>=7d", chat: "chat:7", fetched: "fetched>0" },

package/dist/services/link-scorers/alias-hits.d.ts

@@ -0,0 +1,7 @@
+import type { LinkScorer } from "./types.js";
+export declare const aliasWeight: (hits: number) => number;
+/**
+ * Messages in the window that name the project as whole words, grouped by chat: 3–9 of them, or 10 and more. A
+ * text search finds a word inside another, so each hit is checked again by the whole-word rule.
+ */
+export declare const aliasHits: LinkScorer;

package/dist/services/link-scorers/alias-hits.js

@@ -0,0 +1,54 @@
+import { formatReference } from "../../domain/references.js";
+import { chatRef, projectTerms, wholeWords } from "./shared.js";
+const SEARCH_LIMIT = 500;
+export const aliasWeight = (hits) => (hits >= 10 ? 0.55 : hits >= 3 ? 0.35 : 0);
+/**
+ * Messages in the window that name the project as whole words, grouped by chat: 3–9 of them, or 10 and more. A
+ * text search finds a word inside another, so each hit is checked again by the whole-word rule.
+ */
+export const aliasHits = {
+    id: "alias-hits",
+    version: 1,
+    candidates: async ({ store, project, sources, since, signal }) => {
+        if (!project)
+            return [];
+        // The trigram index answers a shorter query with nothing.
+        const terms = projectTerms(project).filter((term) => [...term.trim()].length >= 3);
+        const found = [];
+        for (const key of sources) {
+            const chats = new Map();
+            for (const term of terms) {
+                signal?.throwIfAborted();
+                const pattern = wholeWords(term);
+                const hits = await store.messages.find({ account: key, text: term, limit: SEARCH_LIMIT });
+                for (const hit of hits.items) {
+                    if (hit.timestamp < since || !pattern.test(hit.text.normalize("NFKC").toLowerCase()))
+                        continue;
+                    const messages = chats.get(String(hit.chatId)) ?? new Map();
+                    messages.set(String(hit.id), formatReference({
+                        type: "message",
+                        provider: key.provider,
+                        account: String(key.account),
+                        chat: String(hit.chatId),
+                        message: String(hit.id),
+                    }));
+                    chats.set(String(hit.chatId), messages);
+                }
+            }
+            for (const [chat, messages] of chats) {
+                const weight = aliasWeight(messages.size);
+                if (!weight)
+                    continue;
+                found.push({
+                    from: chatRef(key, chat),
+                    to: project.ref,
+                    kind: "member-of",
+                    weight,
+                    why: `${messages.size} messages since ${since.slice(0, 10)} name the project`,
+                    evidence: [...messages.values()].slice(0, 3),
+                });
+            }
+        }
+        return found;
+    },
+};

package/dist/services/link-scorers/chat-senders.d.ts

@@ -0,0 +1,6 @@
+import type { LinkScorer } from "./types.js";
+/**
+ * A person who wrote 5 or more messages in the window in one of the project's confirmed chats, found by the sender's
+ * identity, never by the name a message shows. In a group of more than 30 people writing there says less.
+ */
+export declare const chatSenders: LinkScorer;

package/dist/services/link-scorers/chat-senders.js

@@ -0,0 +1,56 @@
+import { formatReference, parseReference } from "../../domain/references.js";
+import { contactRef, personRefOf, sameAccount } from "./shared.js";
+const WEIGHT = 0.5;
+const LARGE_GROUP_WEIGHT = 0.2;
+const LARGE_GROUP = 30;
+const MIN_MESSAGES = 5;
+const READ_LIMIT = 2000;
+/**
+ * A person who wrote 5 or more messages in the window in one of the project's confirmed chats, found by the sender's
+ * identity, never by the name a message shows. In a group of more than 30 people writing there says less.
+ */
+export const chatSenders = {
+    id: "chat-senders",
+    version: 1,
+    candidates: async ({ store, project, confirmed, sources, since, owner, signal }) => {
+        if (!project)
+            return [];
+        const found = [];
+        for (const chat of confirmed.chats) {
+            const reference = parseReference(chat);
+            if (reference.type !== "chat")
+                continue;
+            const key = sources.find((source) => sameAccount(source, reference));
+            if (!key)
+                continue;
+            signal?.throwIfAborted();
+            const page = await store.messages.messages(key, reference.chat, { limit: READ_LIMIT, since, outgoing: false });
+            const senders = new Map();
+            for (const message of page.items) {
+                if (message.senderId === null || message.senderIsChat)
+                    continue;
+                const id = String(message.senderId);
+                senders.set(id, { count: (senders.get(id)?.count ?? 0) + 1, last: String(message.id) });
+            }
+            const size = Math.max((await store.roster.members(key, reference.chat)).length, senders.size);
+            const weight = size > LARGE_GROUP ? LARGE_GROUP_WEIGHT : WEIGHT;
+            for (const [id, { count, last }] of senders) {
+                if (count < MIN_MESSAGES)
+                    continue;
+                const person = await personRefOf(store, key.provider, id);
+                if (!person || person === owner)
+                    continue;
+                found.push({
+                    from: person,
+                    to: project.ref,
+                    kind: "member-of",
+                    weight,
+                    why: `${count} messages since ${since.slice(0, 10)} in a project chat (${chat})${size > LARGE_GROUP ? `, a group of ${size}` : ""}`,
+                    evidence: [formatReference({ ...reference, type: "message", message: last })],
+                    identity: contactRef(key.provider, id),
+                });
+            }
+        }
+        return found;
+    },
+};

package/dist/services/link-scorers/chat-title.d.ts

@@ -0,0 +1,6 @@
+import type { LinkScorer } from "./types.js";
+/**
+ * A chat whose title names the project, its key or an alias as whole words. A purpose the owner configured that the
+ * title also names («HRB sales») is proposed with it. Mail threads are the `mail-thread` scorer's.
+ */
+export declare const chatTitle: LinkScorer;

package/dist/services/link-scorers/chat-title.js

@@ -0,0 +1,44 @@
+import { chatRef, namesProject, wholeWords } from "./shared.js";
+const WEIGHT = 0.7;
+/**
+ * A chat whose title names the project, its key or an alias as whole words. A purpose the owner configured that the
+ * title also names («HRB sales») is proposed with it. Mail threads are the `mail-thread` scorer's.
+ */
+export const chatTitle = {
+    id: "chat-title",
+    version: 1,
+    candidates: async ({ store, project, sources, purposes, signal }) => {
+        if (!project)
+            return [];
+        const names = namesProject(project);
+        const purposeOf = purposes
+            .filter((purpose) => purpose !== "work")
+            .map((purpose) => ({ purpose, pattern: wholeWords(purpose) }));
+        const found = [];
+        for (const key of sources) {
+            if (key.provider === "email")
+                continue;
+            signal?.throwIfAborted();
+            const chats = await store.chats.chats(key, {});
+            for (const chat of chats.items) {
+                if (chat.kind === "saved")
+                    continue;
+                const term = names(chat.title);
+                if (!term)
+                    continue;
+                const title = (chat.title ?? "").normalize("NFKC").toLowerCase();
+                const purpose = purposeOf.find(({ pattern }) => pattern.test(title))?.purpose;
+                found.push({
+                    from: chatRef(key, chat.id),
+                    to: project.ref,
+                    kind: "member-of",
+                    weight: WEIGHT,
+                    why: `the chat title names the project${term === project.name ? "" : ` (${term === project.key ? "key" : "alias"})`}`,
+                    evidence: [],
+                    ...(purpose ? { purpose } : {}),
+                });
+            }
+        }
+        return found;
+    },
+};

package/dist/services/link-scorers/email-domain.d.ts

@@ -0,0 +1,6 @@
+import type { LinkScorer } from "./types.js";
+/**
+ * People whose mail addresses share a company domain, related to each other, weakly: a shared domain does not prove
+ * they work together. Needs no project; the rule `relationships scan` ran before scorers existed.
+ */
+export declare const emailDomain: LinkScorer;

package/dist/services/link-scorers/email-domain.js

@@ -0,0 +1,64 @@
+import { contactRef } from "./shared.js";
+const WEIGHT = 0.3;
+const CONTACTS = 500;
+const MOST_PAIRS = 200;
+const FREE = new Set([
+    "gmail.com",
+    "outlook.com",
+    "hotmail.com",
+    "yahoo.com",
+    "icloud.com",
+    "proton.me",
+    "protonmail.com",
+]);
+/**
+ * People whose mail addresses share a company domain, related to each other, weakly: a shared domain does not prove
+ * they work together. Needs no project; the rule `relationships scan` ran before scorers existed.
+ */
+export const emailDomain = {
+    id: "email-domain",
+    version: 1,
+    candidates: async ({ store, sources, owner, signal }) => {
+        const domains = new Map();
+        for (const key of sources) {
+            if (key.provider !== "email")
+                continue;
+            signal?.throwIfAborted();
+            const contacts = await store.people.contacts(key, { order: "name", limit: CONTACTS, offset: 0 });
+            for (const contact of contacts.items) {
+                const address = String(contact.id).toLowerCase();
+                const domain = address.split("@")[1];
+                if (!domain || FREE.has(domain))
+                    continue;
+                const person = await store.people.personOf({ provider: key.provider, id: contact.id });
+                if (!person || `person:${person.uid}` === owner)
+                    continue;
+                const people = domains.get(domain) ?? new Map();
+                if (!people.has(`person:${person.uid}`))
+                    people.set(`person:${person.uid}`, contactRef(key.provider, contact.id));
+                domains.set(domain, people);
+            }
+        }
+        const found = [];
+        for (const [domain, people] of domains) {
+            const sorted = [...people].sort(([a], [b]) => a.localeCompare(b));
+            for (let left = 0; left < sorted.length; left++)
+                for (let right = left + 1; right < sorted.length; right++) {
+                    if (found.length >= MOST_PAIRS)
+                        return found;
+                    const [from, identity] = sorted[left];
+                    const [to] = sorted[right];
+                    found.push({
+                        from,
+                        to,
+                        kind: "related-to",
+                        weight: WEIGHT,
+                        why: `addresses share the domain ${domain}; this does not prove they work together`,
+                        evidence: [],
+                        identity,
+                    });
+                }
+        }
+        return found;
+    },
+};

package/dist/services/link-scorers/index.d.ts

@@ -0,0 +1,9 @@
+export { aliasHits } from "./alias-hits.js";
+export { chatSenders } from "./chat-senders.js";
+export { chatTitle } from "./chat-title.js";
+export { emailDomain } from "./email-domain.js";
+export { mailThread } from "./mail-thread.js";
+export { memberChats } from "./member-chats.js";
+export { memberDialog } from "./member-dialog.js";
+export { BUILT_IN_PURPOSES, combinedScore, DEFAULT_LIMIT, DEFAULT_THRESHOLD, PERSON_SCORERS, PERSON_THRESHOLD, SCAN_BOT, SCORERS, type ScanInput, scanProjectLinks, } from "./scan.js";
+export type { LinkCandidate, LinkScorer, ScannedProject, ScannedProposal, ScanResult, ScorerInput, Signal, } from "./types.js";

package/dist/services/link-scorers/index.js

@@ -0,0 +1,8 @@
+export { aliasHits } from "./alias-hits.js";
+export { chatSenders } from "./chat-senders.js";
+export { chatTitle } from "./chat-title.js";
+export { emailDomain } from "./email-domain.js";
+export { mailThread } from "./mail-thread.js";
+export { memberChats } from "./member-chats.js";
+export { memberDialog } from "./member-dialog.js";
+export { BUILT_IN_PURPOSES, combinedScore, DEFAULT_LIMIT, DEFAULT_THRESHOLD, PERSON_SCORERS, PERSON_THRESHOLD, SCAN_BOT, SCORERS, scanProjectLinks, } from "./scan.js";

package/dist/services/link-scorers/mail-thread.d.ts

@@ -0,0 +1,3 @@
+import type { LinkScorer } from "./types.js";
+/** A mail thread a confirmed member writes in or is written to: strong when its subject names the project. */
+export declare const mailThread: LinkScorer;

package/dist/services/link-scorers/mail-thread.js

@@ -0,0 +1,74 @@
+import { formatReference } from "../../domain/references.js";
+import { identitiesIn, namesProject } from "./shared.js";
+const NAMED = 0.7;
+const MEMBER_ONLY = 0.3;
+const READ_LIMIT = 500;
+/** A mail thread a confirmed member writes in or is written to: strong when its subject names the project. */
+export const mailThread = {
+    id: "mail-thread",
+    version: 1,
+    candidates: async ({ store, project, confirmed, sources, since, owner, signal }) => {
+        if (!project)
+            return [];
+        const names = namesProject(project);
+        const people = confirmed.people.filter((person) => person !== owner);
+        const found = [];
+        for (const key of sources) {
+            if (key.provider !== "email")
+                continue;
+            const account = await store.accounts.storedAccount(key).catch(() => undefined);
+            if (!account)
+                continue;
+            const threads = new Map();
+            for (const { person, id } of await identitiesIn(store, people, "email")) {
+                signal?.throwIfAborted();
+                const emails = await store.mail.emails({
+                    accountId: account.id,
+                    participant: id,
+                    since: Date.parse(since),
+                    limit: READ_LIMIT,
+                });
+                for (const email of emails) {
+                    const held = threads.get(email.emailThreadId) ?? {
+                        members: new Set(),
+                        subject: email.subject,
+                        email: email.externalId,
+                    };
+                    held.members.add(person);
+                    threads.set(email.emailThreadId, held);
+                }
+            }
+            for (const [id, { members, subject, email }] of threads) {
+                const thread = (await store.mail.thread(id))?.thread;
+                if (!thread)
+                    continue;
+                const named = names(thread.subject ?? subject) !== undefined;
+                const chat = formatReference({
+                    type: "chat",
+                    provider: "email",
+                    account: String(key.account),
+                    chat: thread.externalId,
+                });
+                const who = [...members].sort();
+                found.push({
+                    from: chat,
+                    to: project.ref,
+                    kind: "member-of",
+                    weight: named ? NAMED : MEMBER_ONLY,
+                    why: `a thread with ${who.length > 1 ? `${who.length} members` : `a member (${who[0]})`}${named ? "; its subject names the project" : ""}`,
+                    evidence: [
+                        formatReference({
+                            type: "message",
+                            provider: "email",
+                            account: String(key.account),
+                            chat: thread.externalId,
+                            message: email,
+                        }),
+                        ...who,
+                    ].slice(0, 5),
+                });
+            }
+        }
+        return found;
+    },
+};

package/dist/services/link-scorers/member-chats.d.ts

@@ -0,0 +1,3 @@
+import type { LinkScorer } from "./types.js";
+/** A group or channel where two or more of the project's confirmed person members are members. */
+export declare const memberChats: LinkScorer;

package/dist/services/link-scorers/member-chats.js

@@ -0,0 +1,40 @@
+import { chatRef, identitiesIn } from "./shared.js";
+const WEIGHT = 0.5;
+/** A group or channel where two or more of the project's confirmed person members are members. */
+export const memberChats = {
+    id: "member-chats",
+    version: 1,
+    candidates: async ({ store, project, confirmed, sources, owner, signal }) => {
+        if (!project)
+            return [];
+        const people = confirmed.people.filter((person) => person !== owner);
+        const found = [];
+        for (const key of sources) {
+            const members = new Map();
+            for (const { person, id } of await identitiesIn(store, people, key.provider)) {
+                signal?.throwIfAborted();
+                for (const chat of await store.chats.chatsWith(key, id)) {
+                    if (chat.kind !== "group" && chat.kind !== "channel")
+                        continue;
+                    const held = members.get(String(chat.id)) ?? new Set();
+                    held.add(person);
+                    members.set(String(chat.id), held);
+                }
+            }
+            for (const [chat, held] of members) {
+                if (held.size < 2)
+                    continue;
+                const named = [...held].sort();
+                found.push({
+                    from: chatRef(key, chat),
+                    to: project.ref,
+                    kind: "member-of",
+                    weight: WEIGHT,
+                    why: `a group with ${held.size} confirmed members (${named.slice(0, 3).join(", ")}${held.size > 3 ? ", …" : ""})`,
+                    evidence: named.slice(0, 5),
+                });
+            }
+        }
+        return found;
+    },
+};

package/dist/services/link-scorers/member-dialog.d.ts

@@ -0,0 +1,3 @@
+import type { LinkScorer } from "./types.js";
+/** A dialog with a confirmed person member, divided by how many projects that person is a member of. */
+export declare const memberDialog: LinkScorer;

package/dist/services/link-scorers/member-dialog.js

@@ -0,0 +1,34 @@
+import { chatRef, identitiesIn, projectsOf } from "./shared.js";
+const WEIGHT = 0.6;
+/** A dialog with a confirmed person member, divided by how many projects that person is a member of. */
+export const memberDialog = {
+    id: "member-dialog",
+    version: 1,
+    candidates: async ({ store, project, confirmed, sources, owner, signal }) => {
+        if (!project)
+            return [];
+        const people = confirmed.people.filter((person) => person !== owner);
+        const projects = new Map();
+        const found = [];
+        for (const key of sources)
+            for (const { person, id } of await identitiesIn(store, people, key.provider)) {
+                signal?.throwIfAborted();
+                for (const chat of await store.chats.chatsWith(key, id)) {
+                    if (chat.kind !== "dialog")
+                        continue;
+                    if (!projects.has(person))
+                        projects.set(person, Math.max(1, await projectsOf(store, person)));
+                    const shared = projects.get(person) ?? 1;
+                    found.push({
+                        from: chatRef(key, chat.id),
+                        to: project.ref,
+                        kind: "member-of",
+                        weight: WEIGHT / shared,
+                        why: `a dialog with a member (${person})${shared > 1 ? `, who is in ${shared} projects` : ""}`,
+                        evidence: [person],
+                    });
+                }
+            }
+        return found;
+    },
+};

package/dist/services/link-scorers/scan.d.ts

@@ -0,0 +1,41 @@
+import type { MessageStore } from "../../store/store.js";
+import type { AccountKey } from "../../store/types.js";
+import type { LinkScorer, ScanResult } from "./types.js";
+/** A new scorer is one file and one line here. */
+export declare const SCORERS: readonly LinkScorer[];
+/** What a scan with no project runs: person ↔ person rules. */
+export declare const PERSON_SCORERS: readonly LinkScorer[];
+/** The rule bot every scan proposal is written by: only the owner decides its proposals. */
+export declare const SCAN_BOT: {
+    readonly bot: "memo-scan";
+    readonly kind: "rule";
+};
+export declare const BUILT_IN_PURPOSES: readonly ["work", "sales", "support", "other"];
+export declare const DEFAULT_THRESHOLD = 0.5;
+/** A person ↔ person scan keeps the old rule's reach: one weak signal is enough to ask the owner. */
+export declare const PERSON_THRESHOLD = 0.3;
+export declare const DEFAULT_LIMIT = 20;
+export interface ScanInput {
+    /** A project's key, name, alias or `project:<id>`; `null` runs the person ↔ person rules. */
+    project: string | null;
+    sources: AccountKey[];
+    since: string;
+    /** `false` reads only: nothing is written, and each proposal says `dry-run`. */
+    write: boolean;
+    scorers?: readonly LinkScorer[];
+    threshold?: number;
+    /** Most new proposals in one run, 1–50. */
+    limit?: number;
+    /** The host's configured purposes; built-in when left out. */
+    purposes?: readonly string[];
+    signal?: AbortSignal;
+}
+/** 1 − Π(1 − wᵢ), over each scorer's strongest signal for the pair. */
+export declare const combinedScore: (weights: readonly number[]) => number;
+/**
+ * Runs the scorers for one project over the sources named, combines their signals per pair, and proposes what scores
+ * `threshold` or more, highest first, at most `limit` new ones. A pair a link joins, or that was rejected once, is
+ * never proposed; a pending one is updated in place. People are matched by identity only. With `write: false`
+ * nothing is written.
+ */
+export declare const scanProjectLinks: (store: MessageStore, input: ScanInput) => Promise<ScanResult>;