@wirecat/cli-core 0.550.0 → 0.551.0

package/dist/services/archive.d.ts

@@ -6,6 +6,7 @@ import { type AccountKey, type ChatStats, type MessageStore, type Range } from "
 import { type Estimate } from "./backfill-estimate.js";
 import { batchProgress } from "./batch.js";
 import type { ServiceDeps } from "./deps.js";
+import { type ChatShape } from "./history-limits.js";
 import { type CatchUpOptions, type CatchUpResult } from "./search-catchup.js";
 /** The most messages a provider hands out per history request — Telegram's cap. */
 export declare const PAGE = 100;
@@ -45,6 +46,10 @@ export interface FetchOptions {
         done: number;
         fetched: number;
     }) => void;
+    /** Past the history limits for this chat (`--full-history`). */
+    fullHistory?: boolean;
+    /** The chat's kind and size as the messenger lists it, for a chat the store does not hold yet. */
+    shape?: ChatShape;
 }
 /** A type, not an interface: a job keeps it as a plain record. */
 export type Fetched = {
@@ -62,6 +67,8 @@ export type Fetched = {
     reachedSince?: true;
     reachedLast?: true;
     stopped?: true;
+    /** The history limits stopped this read: a group too large to read, or the window's start reached. */
+    limited?: "group_too_large" | "older_than_window";
 };
 export type FetchedAll = {
     batch?: ReturnType<ReturnType<typeof batchProgress>["result"]>;
@@ -80,7 +87,13 @@ export type FetchedAll = {
         stopped?: true;
         error?: string;
         issue?: ActionableError;
+        limited?: "group_too_large" | "older_than_window";
     }[];
+    /** How many chats the history limits left unread (big groups) or read only to the window's start. */
+    limited?: {
+        groupTooLarge: number;
+        olderThanWindow: number;
+    };
 };
 /** The local store of messages: what it holds, filling it from the messenger, and reading it out. */
 export interface ArchiveService {

package/dist/services/archive.js

@@ -5,6 +5,7 @@ import { typedCommand } from "../runs/scope.js";
 import { fetchedKey, historyStartKey, } from "../store/store.js";
 import { estimateBackfill } from "./backfill-estimate.js";
 import { actionable, batchProgress } from "./batch.js";
+import { historyWindow } from "./history-limits.js";
 import { storedChatId } from "./message-resolution.js";
 import { patiently } from "./patience.js";
 import { catchUpSearch, validateCatchUp } from "./search-catchup.js";
@@ -114,13 +115,28 @@ export const archiveService = (deps) => {
                 throw new CliError("authentication_error", "the connection belongs to another account");
             if (options.stop.aborted)
                 return { chat: null, fetched: 0, complete: false, ranges: [], stopped: true };
-            const result = await fetchInto({
+            const store = await deps.store();
+            const account = { provider: deps.messenger.provider, account: self };
+            const limit = await limitOf(deps, store, account, chat, options);
+            if (limit?.skip) {
+                await recordSkip(store, account, limit.chatId, { reason: "group_too_large", members: limit.skip.members });
+                return { chat: limit.chatId ?? null, fetched: 0, complete: false, ranges: [], limited: "group_too_large" };
+            }
+            const windowed = limit?.keepFrom !== undefined && !(limit.keepFrom <= (options.sinceMs ?? Number.NEGATIVE_INFINITY));
+            const fetched = await fetchInto({
                 history: (window) => history(chat, { ...window, reactions: false }),
-                store: await deps.store(),
-                account: { provider: deps.messenger.provider, account: self },
+                store,
+                account,
                 fetching: deps.messenger.fetching ?? FETCHING,
                 ...options,
+                ...(windowed ? { sinceMs: limit.keepFrom } : {}),
             });
+            const result = windowed && fetched.reachedSince ? { ...fetched, limited: "older_than_window" } : fetched;
+            if (result.limited && limit?.keepFrom !== undefined)
+                await recordSkip(store, account, result.chat ?? limit.chatId, {
+                    reason: "older_than_window",
+                    keptFrom: new Date(limit.keepFrom).toISOString(),
+                });
             return requested && result.chat
                 ? { ...result, prepared: await catchUpSearch(deps, result.chat, requested, options.stop) }
                 : result;
@@ -161,7 +177,17 @@ export const archiveService = (deps) => {
                     continue;
                 }
                 try {
-                    const one = await own.fetch(chat.id, options);
+                    const one = await own.fetch(chat.id, {
+                        ...options,
+                        shape: { kind: chat.kind, participantsCount: chat.participantsCount ?? null },
+                    });
+                    if (one.limited) {
+                        answer.limited ??= { groupTooLarge: 0, olderThanWindow: 0 };
+                        if (one.limited === "group_too_large")
+                            answer.limited.groupTooLarge += 1;
+                        else
+                            answer.limited.olderThanWindow += 1;
+                    }
                     if (one.issue)
                         batch.fail(chat.id, "history", one.issue);
                     else
@@ -172,7 +198,8 @@ export const archiveService = (deps) => {
                         title: chat.title,
                         fetched: one.fetched,
                         // Reaching the window is what --all asked for; older history was not.
-                        complete: one.complete || one.reachedSince === true || one.reachedLast === true,
+                        complete: one.complete || one.reachedSince === true || one.reachedLast === true || one.limited !== undefined,
+                        ...(one.limited ? { limited: one.limited } : {}),
                         ...(one.issue ? { error: one.issue.code, issue: one.issue } : {}),
                         ...(one.stopped ? { stopped: true } : {}),
                     });
@@ -195,6 +222,30 @@ export const archiveService = (deps) => {
         },
     };
 };
+/**
+ * Where the history limits stop this chat's read: not at all for a group above the cap, else at the window's start.
+ * None for a lifted chat or without limits. A chat the store does not hold yet is judged by the shape the list gave.
+ */
+const limitOf = async (deps, store, account, chat, options) => {
+    if (!deps.historyLimits || options.fullHistory)
+        return undefined;
+    const chatId = await storedChatId(deps.messenger, chat, store, account, { includeLeft: true }).catch(() => undefined);
+    const stored = chatId === undefined ? undefined : (await store.chats.historyShapes(account, [chatId])).get(chatId);
+    if (stored?.included)
+        return undefined;
+    const window = historyWindow(stored ?? options.shape, deps.historyLimits, Date.now());
+    return {
+        ...(chatId === undefined ? {} : { chatId }),
+        ...("skip" in window ? { skip: { members: window.members } } : { keepFrom: window.keepFrom }),
+    };
+};
+/** A read the limits stopped, for `store status` and the answers that say not all is there; the count is unknown. */
+const recordSkip = async (store, account, chatId, skip) => {
+    if (!chatId)
+        return;
+    const at = new Date().toISOString();
+    await store.chats.recordHistorySkips(account, new Map([[chatId, { ...skip, messages: 0, oldestAt: at, newestAt: at, unread: true }]]));
+};
 /** The fetch loop, over any history and store: the personal account's service and a bot's command share it. */
 export const abortable = async (read, signal) => {
     signal.throwIfAborted();

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;