@wirecat/cli-memo 0.131.21 → 0.131.22

package/dist/bundle/{chunk-J55Z6EJ3.js → chunk-ZKWE5MCA.js}

@@ -21681,7 +21681,7 @@ var peopleService = /* @__PURE__ */ __name((deps) => {
       ...!includeNotes || local.notes.length === 0 ? {} : { notes: local.notes }
     };
   }, "localCard");
-  const referenceOf = /* @__PURE__ */ __name(async (reference) => {
+  const referenceOf2 = /* @__PURE__ */ __name(async (reference) => {
     const held = await storeIfOpen(deps);
     if (!held)
       return reference;
@@ -21696,7 +21696,7 @@ var peopleService = /* @__PURE__ */ __name((deps) => {
   }, "online");
   const change = /* @__PURE__ */ __name(async (action2, person, act2) => {
     const connection = await online(`contacts ${action2.slice("contact-".length)}`);
-    const [personId] = await capability(connection, "people", "find people")([await referenceOf(person)]);
+    const [personId] = await capability(connection, "people", "find people")([await referenceOf2(person)]);
     const operationId = newOperationId();
     const done2 = await guardedWrite(deps.guard, { operationId, chatId: null, kind: "account", action: action2 }, () => act2(connection, personId));
     return { operationId, personId, done: done2 };
@@ -21720,7 +21720,7 @@ var peopleService = /* @__PURE__ */ __name((deps) => {
         const found = pickPerson(person, await store.people.people(account.provider, { account: account.account }));
         return localCard({ ...found, chats: await sharedChats(store, account, found.id) }, notes);
       }
-      const card = await capability(await deps.connection(), "contact", "show a person")(await referenceOf(person));
+      const card = await capability(await deps.connection(), "contact", "show a person")(await referenceOf2(person));
       if (card.chats.length > 0)
         return localCard(card, notes);
       const held = await storeIfOpen(deps);
@@ -23473,6 +23473,393 @@ var excerpt = /* @__PURE__ */ __name((text2, query, size4 = 240, options = {}) =
 }, "excerpt");
 var withExcerpt = /* @__PURE__ */ __name(({ matchedText, ...hit }, query) => ({ ...hit, excerpt: excerpt(matchedText ?? hit.text, query) }), "withExcerpt");
 
+// node_modules/.pnpm/@wirecat+cli-core@0.560.0_@wirecat+cli-base@0.75.0_commander@15.0.0_esbuild@0.28.2_type_5702f943a9224d209a94753f662cf36c/node_modules/@wirecat/cli-core/dist/services/link-scorers/shared.js
+var escaped = /* @__PURE__ */ __name((text2) => text2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "escaped");
+var folded = /* @__PURE__ */ __name((text2) => text2.normalize("NFKC").toLowerCase().replace(/\s+/gu, " "), "folded");
+var wholeWords = /* @__PURE__ */ __name((term) => new RegExp(`(?<![\\p{L}\\p{N}\\p{M}_])${escaped(normalizeVocabularyName(term))}(?![\\p{L}\\p{N}\\p{M}_])`, "u"), "wholeWords");
+var projectTerms = /* @__PURE__ */ __name((project2) => {
+  const terms = /* @__PURE__ */ new Map();
+  for (const term of [project2.name, project2.key, ...project2.aliases])
+    if (term?.trim())
+      terms.set(normalizeVocabularyName(term), term);
+  return [...terms.values()];
+}, "projectTerms");
+var namesProject = /* @__PURE__ */ __name((project2) => {
+  const patterns = projectTerms(project2).map((term) => ({ term, pattern: wholeWords(term) }));
+  return (text2) => {
+    if (!text2)
+      return void 0;
+    const value = folded(text2);
+    return patterns.find(({ pattern }) => pattern.test(value))?.term;
+  };
+}, "namesProject");
+var chatRef2 = /* @__PURE__ */ __name((key, chat) => formatReference({ type: "chat", provider: key.provider, account: String(key.account), chat: String(chat) }), "chatRef");
+var contactRef2 = /* @__PURE__ */ __name((provider, id2) => formatReference({ type: "contact", provider, id: String(id2) }), "contactRef");
+var sameAccount = /* @__PURE__ */ __name((a, b) => a.provider === b.provider && String(a.account) === b.account, "sameAccount");
+var personRefOf = /* @__PURE__ */ __name(async (store, provider, id2) => {
+  const person = await store.people.personOf({ provider, id: id2 });
+  return person ? `person:${person.uid}` : void 0;
+}, "personRefOf");
+var projectsOf = /* @__PURE__ */ __name(async (store, person) => new Set((await store.knowledge.relations(null, person)).filter((one2) => one2.confirmed && one2.kind === "member-of" && one2.from === person && one2.to.startsWith("project:")).map((one2) => one2.to)).size, "projectsOf");
+var identitiesIn = /* @__PURE__ */ __name(async (store, people, provider) => {
+  const found = [];
+  for (const person of people) {
+    const record2 = await store.people.personByUid(person.slice("person:".length));
+    for (const identity of record2?.identities ?? [])
+      if (identity.provider === provider)
+        found.push({ person, id: String(identity.id) });
+  }
+  return found;
+}, "identitiesIn");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.560.0_@wirecat+cli-base@0.75.0_commander@15.0.0_esbuild@0.28.2_type_5702f943a9224d209a94753f662cf36c/node_modules/@wirecat/cli-core/dist/services/link-scorers/alias-hits.js
+var SEARCH_LIMIT = 500;
+var aliasWeight = /* @__PURE__ */ __name((hits) => hits >= 10 ? 0.55 : hits >= 3 ? 0.35 : 0, "aliasWeight");
+var aliasHits = {
+  id: "alias-hits",
+  version: 1,
+  candidates: /* @__PURE__ */ __name(async ({ store, project: project2, sources, since, signal }) => {
+    if (!project2)
+      return [];
+    const terms = projectTerms(project2).filter((term) => [...term.trim()].length >= 3);
+    const found = [];
+    for (const key of sources) {
+      const chats = /* @__PURE__ */ 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)) ?? /* @__PURE__ */ 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: chatRef2(key, chat),
+          to: project2.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;
+  }, "candidates")
+};
+
+// node_modules/.pnpm/@wirecat+cli-core@0.560.0_@wirecat+cli-base@0.75.0_commander@15.0.0_esbuild@0.28.2_type_5702f943a9224d209a94753f662cf36c/node_modules/@wirecat/cli-core/dist/services/link-scorers/chat-senders.js
+var WEIGHT = 0.5;
+var LARGE_GROUP_WEIGHT = 0.2;
+var LARGE_GROUP = 30;
+var MIN_MESSAGES = 5;
+var READ_LIMIT = 2e3;
+var chatSenders = {
+  id: "chat-senders",
+  version: 1,
+  candidates: /* @__PURE__ */ __name(async ({ store, project: project2, confirmed, sources, since, owner, signal }) => {
+    if (!project2)
+      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 = /* @__PURE__ */ new Map();
+      for (const message of page.items) {
+        if (message.senderId === null || message.senderIsChat)
+          continue;
+        const id2 = String(message.senderId);
+        senders.set(id2, { count: (senders.get(id2)?.count ?? 0) + 1, last: String(message.id) });
+      }
+      const size4 = Math.max((await store.roster.members(key, reference.chat)).length, senders.size);
+      const weight = size4 > LARGE_GROUP ? LARGE_GROUP_WEIGHT : WEIGHT;
+      for (const [id2, { count: count4, last }] of senders) {
+        if (count4 < MIN_MESSAGES)
+          continue;
+        const person = await personRefOf(store, key.provider, id2);
+        if (!person || person === owner)
+          continue;
+        found.push({
+          from: person,
+          to: project2.ref,
+          kind: "member-of",
+          weight,
+          why: `${count4} messages since ${since.slice(0, 10)} in a project chat (${chat})${size4 > LARGE_GROUP ? `, a group of ${size4}` : ""}`,
+          evidence: [formatReference({ ...reference, type: "message", message: last })],
+          identity: contactRef2(key.provider, id2)
+        });
+      }
+    }
+    return found;
+  }, "candidates")
+};
+
+// node_modules/.pnpm/@wirecat+cli-core@0.560.0_@wirecat+cli-base@0.75.0_commander@15.0.0_esbuild@0.28.2_type_5702f943a9224d209a94753f662cf36c/node_modules/@wirecat/cli-core/dist/services/link-scorers/chat-title.js
+var WEIGHT2 = 0.7;
+var chatTitle = {
+  id: "chat-title",
+  version: 1,
+  candidates: /* @__PURE__ */ __name(async ({ store, project: project2, sources, purposes, signal }) => {
+    if (!project2)
+      return [];
+    const names2 = namesProject(project2);
+    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 = names2(chat.title);
+        if (!term)
+          continue;
+        const title = (chat.title ?? "").normalize("NFKC").toLowerCase();
+        const purpose = purposeOf.find(({ pattern }) => pattern.test(title))?.purpose;
+        found.push({
+          from: chatRef2(key, chat.id),
+          to: project2.ref,
+          kind: "member-of",
+          weight: WEIGHT2,
+          why: `the chat title names the project${term === project2.name ? "" : ` (${term === project2.key ? "key" : "alias"})`}`,
+          evidence: [],
+          ...purpose ? { purpose } : {}
+        });
+      }
+    }
+    return found;
+  }, "candidates")
+};
+
+// node_modules/.pnpm/@wirecat+cli-core@0.560.0_@wirecat+cli-base@0.75.0_commander@15.0.0_esbuild@0.28.2_type_5702f943a9224d209a94753f662cf36c/node_modules/@wirecat/cli-core/dist/services/link-scorers/email-domain.js
+var WEIGHT3 = 0.3;
+var CONTACTS = 500;
+var MOST_PAIRS = 200;
+var FREE = /* @__PURE__ */ new Set([
+  "gmail.com",
+  "outlook.com",
+  "hotmail.com",
+  "yahoo.com",
+  "icloud.com",
+  "proton.me",
+  "protonmail.com"
+]);
+var emailDomain = {
+  id: "email-domain",
+  version: 1,
+  candidates: /* @__PURE__ */ __name(async ({ store, sources, owner, signal }) => {
+    const domains = /* @__PURE__ */ 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) ?? /* @__PURE__ */ new Map();
+        if (!people.has(`person:${person.uid}`))
+          people.set(`person:${person.uid}`, contactRef2(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: WEIGHT3,
+            why: `addresses share the domain ${domain}; this does not prove they work together`,
+            evidence: [],
+            identity
+          });
+        }
+    }
+    return found;
+  }, "candidates")
+};
+
+// node_modules/.pnpm/@wirecat+cli-core@0.560.0_@wirecat+cli-base@0.75.0_commander@15.0.0_esbuild@0.28.2_type_5702f943a9224d209a94753f662cf36c/node_modules/@wirecat/cli-core/dist/services/link-scorers/mail-thread.js
+var NAMED = 0.7;
+var MEMBER_ONLY = 0.3;
+var READ_LIMIT2 = 500;
+var mailThread = {
+  id: "mail-thread",
+  version: 1,
+  candidates: /* @__PURE__ */ __name(async ({ store, project: project2, confirmed, sources, since, owner, signal }) => {
+    if (!project2)
+      return [];
+    const names2 = namesProject(project2);
+    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(() => void 0);
+      if (!account)
+        continue;
+      const threads = /* @__PURE__ */ new Map();
+      for (const { person, id: id2 } of await identitiesIn(store, people, "email")) {
+        signal?.throwIfAborted();
+        const emails = await store.mail.emails({
+          accountId: account.id,
+          participant: id2,
+          since: Date.parse(since),
+          limit: READ_LIMIT2
+        });
+        for (const email of emails) {
+          const held = threads.get(email.emailThreadId) ?? {
+            members: /* @__PURE__ */ new Set(),
+            subject: email.subject,
+            email: email.externalId
+          };
+          held.members.add(person);
+          threads.set(email.emailThreadId, held);
+        }
+      }
+      for (const [id2, { members, subject, email }] of threads) {
+        const thread = (await store.mail.thread(id2))?.thread;
+        if (!thread)
+          continue;
+        const named2 = names2(thread.subject ?? subject) !== void 0;
+        const chat = formatReference({
+          type: "chat",
+          provider: "email",
+          account: String(key.account),
+          chat: thread.externalId
+        });
+        const who2 = [...members].sort();
+        found.push({
+          from: chat,
+          to: project2.ref,
+          kind: "member-of",
+          weight: named2 ? NAMED : MEMBER_ONLY,
+          why: `a thread with ${who2.length > 1 ? `${who2.length} members` : `a member (${who2[0]})`}${named2 ? "; its subject names the project" : ""}`,
+          evidence: [
+            formatReference({
+              type: "message",
+              provider: "email",
+              account: String(key.account),
+              chat: thread.externalId,
+              message: email
+            }),
+            ...who2
+          ].slice(0, 5)
+        });
+      }
+    }
+    return found;
+  }, "candidates")
+};
+
+// node_modules/.pnpm/@wirecat+cli-core@0.560.0_@wirecat+cli-base@0.75.0_commander@15.0.0_esbuild@0.28.2_type_5702f943a9224d209a94753f662cf36c/node_modules/@wirecat/cli-core/dist/services/link-scorers/member-chats.js
+var WEIGHT4 = 0.5;
+var memberChats = {
+  id: "member-chats",
+  version: 1,
+  candidates: /* @__PURE__ */ __name(async ({ store, project: project2, confirmed, sources, owner, signal }) => {
+    if (!project2)
+      return [];
+    const people = confirmed.people.filter((person) => person !== owner);
+    const found = [];
+    for (const key of sources) {
+      const members = /* @__PURE__ */ new Map();
+      for (const { person, id: id2 } of await identitiesIn(store, people, key.provider)) {
+        signal?.throwIfAborted();
+        for (const chat of await store.chats.chatsWith(key, id2)) {
+          if (chat.kind !== "group" && chat.kind !== "channel")
+            continue;
+          const held = members.get(String(chat.id)) ?? /* @__PURE__ */ new Set();
+          held.add(person);
+          members.set(String(chat.id), held);
+        }
+      }
+      for (const [chat, held] of members) {
+        if (held.size < 2)
+          continue;
+        const named2 = [...held].sort();
+        found.push({
+          from: chatRef2(key, chat),
+          to: project2.ref,
+          kind: "member-of",
+          weight: WEIGHT4,
+          why: `a group with ${held.size} confirmed members (${named2.slice(0, 3).join(", ")}${held.size > 3 ? ", \u2026" : ""})`,
+          evidence: named2.slice(0, 5)
+        });
+      }
+    }
+    return found;
+  }, "candidates")
+};
+
+// node_modules/.pnpm/@wirecat+cli-core@0.560.0_@wirecat+cli-base@0.75.0_commander@15.0.0_esbuild@0.28.2_type_5702f943a9224d209a94753f662cf36c/node_modules/@wirecat/cli-core/dist/services/link-scorers/member-dialog.js
+var WEIGHT5 = 0.6;
+var memberDialog = {
+  id: "member-dialog",
+  version: 1,
+  candidates: /* @__PURE__ */ __name(async ({ store, project: project2, confirmed, sources, owner, signal }) => {
+    if (!project2)
+      return [];
+    const people = confirmed.people.filter((person) => person !== owner);
+    const projects = /* @__PURE__ */ new Map();
+    const found = [];
+    for (const key of sources)
+      for (const { person, id: id2 } of await identitiesIn(store, people, key.provider)) {
+        signal?.throwIfAborted();
+        for (const chat of await store.chats.chatsWith(key, id2)) {
+          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: chatRef2(key, chat.id),
+            to: project2.ref,
+            kind: "member-of",
+            weight: WEIGHT5 / shared,
+            why: `a dialog with a member (${person})${shared > 1 ? `, who is in ${shared} projects` : ""}`,
+            evidence: [person]
+          });
+        }
+      }
+    return found;
+  }, "candidates")
+};
+
 // node_modules/.pnpm/@wirecat+cli-core@0.560.0_@wirecat+cli-base@0.75.0_commander@15.0.0_esbuild@0.28.2_type_5702f943a9224d209a94753f662cf36c/node_modules/@wirecat/cli-core/dist/services/project-gathering-around.js
 var storedMessageNeighbours = /* @__PURE__ */ __name((messages) => ({
   async around(ref, window3) {
@@ -24694,6 +25081,214 @@ var purposeHintOf = /* @__PURE__ */ __name((linked, rows, of) => {
   return { chat: top.ref, relationship: link4.relationship, items, of };
 }, "purposeHintOf");
 
+// node_modules/.pnpm/@wirecat+cli-core@0.560.0_@wirecat+cli-base@0.75.0_commander@15.0.0_esbuild@0.28.2_type_5702f943a9224d209a94753f662cf36c/node_modules/@wirecat/cli-core/dist/services/link-scorers/scan.js
+var SCORERS = [chatTitle, aliasHits, memberChats, memberDialog, chatSenders, mailThread];
+var PERSON_SCORERS = [emailDomain];
+var SCAN_BOT = { bot: "memo-scan", kind: "rule" };
+var DEFAULT_THRESHOLD = 0.5;
+var PERSON_THRESHOLD = 0.3;
+var DEFAULT_LIMIT = 20;
+var projectOf3 = /* @__PURE__ */ __name(async (store, reference) => {
+  const ref = await canonicalProjectRef(store, reference);
+  const entry = (await store.knowledge.vocabulary({ kind: "project" })).entries.find((one2) => one2.id === ref.slice(8));
+  if (!entry)
+    throw new CliError("not_found", `no project ${reference}`);
+  return { ref, name: entry.name, key: entry.key, aliases: entry.aliases.map((alias) => alias.name) };
+}, "projectOf");
+var confirmedOf = /* @__PURE__ */ __name(async (store, project2) => {
+  if (!project2)
+    return { chats: [], people: [] };
+  const members = (await store.knowledge.relations(null, project2.ref)).filter((one2) => one2.confirmed && one2.kind === "member-of" && one2.to === project2.ref);
+  return {
+    chats: [...new Set(members.map((one2) => one2.from).filter((ref) => ref.startsWith("chat:")))].sort(),
+    people: [...new Set(members.map((one2) => one2.from).filter((ref) => ref.startsWith("person:")))].sort()
+  };
+}, "confirmedOf");
+var checkedSources = /* @__PURE__ */ __name(async (store, sources) => {
+  const stored = await store.accounts.accounts();
+  const choices = stored.map((one2) => `${one2.provider}:${one2.account}`);
+  if (!Array.isArray(sources) || sources.length === 0)
+    throw new CliError("validation_error", "a scan names the accounts it reads; none is picked for you", {
+      param: "source",
+      choices
+    });
+  for (const source of sources)
+    if (!stored.some((one2) => one2.provider === source.provider && String(one2.account) === String(source.account)))
+      throw new CliError("not_found", `the store holds no account ${source.provider}:${source.account}`, {
+        param: "source",
+        choices
+      });
+  return sources;
+}, "checkedSources");
+var pairKey = /* @__PURE__ */ __name(({ from, to, kind }) => `${from}\0${to}\0${kind}`, "pairKey");
+var combinedScore = /* @__PURE__ */ __name((weights) => Math.round((1 - weights.reduce((left, weight) => left * (1 - weight), 1)) * 1e3) / 1e3, "combinedScore");
+var scanProjectLinks = /* @__PURE__ */ __name(async (store, input) => {
+  const limit = input.limit ?? DEFAULT_LIMIT;
+  if (!Number.isSafeInteger(limit) || limit < 1 || limit > 50)
+    throw new CliError("validation_error", "a scan proposes 1\u201350 links a run", { param: "limit" });
+  const threshold = input.threshold ?? (input.project === null ? PERSON_THRESHOLD : DEFAULT_THRESHOLD);
+  if (typeof threshold !== "number" || !(threshold > 0 && threshold <= 1))
+    throw new CliError("validation_error", "a scan's threshold is more than 0 and at most 1", { param: "threshold" });
+  const since = Date.parse(input.since);
+  if (Number.isNaN(since))
+    throw new CliError("validation_error", "a scan's window starts at an ISO 8601 time", { param: "since" });
+  const sources = await checkedSources(store, input.sources);
+  const project2 = input.project === null ? null : await projectOf3(store, input.project);
+  const owner = await store.people.owner();
+  const scorerInput = {
+    store,
+    project: project2,
+    confirmed: await confirmedOf(store, project2),
+    sources,
+    since: new Date(since).toISOString(),
+    purposes: input.purposes ?? BUILT_IN_PURPOSES,
+    owner: owner ? `person:${owner.uid}` : null,
+    ...input.signal ? { signal: input.signal } : {}
+  };
+  const scorers = input.scorers ?? (project2 ? SCORERS : PERSON_SCORERS);
+  const skipped = {
+    confirmed: 0,
+    rejected: 0,
+    belowThreshold: 0,
+    overLimit: 0,
+    nameOnly: 0,
+    unresolved: 0
+  };
+  const pairs = /* @__PURE__ */ new Map();
+  const nameOnly = /* @__PURE__ */ new Set();
+  for (const scorer of scorers) {
+    input.signal?.throwIfAborted();
+    for (const candidate of await scorer.candidates(scorerInput)) {
+      const key = pairKey(candidate);
+      const verdict = await admissible(store, scorerInput, candidate);
+      if (verdict === "owner")
+        continue;
+      if (verdict === "name-only") {
+        if (!nameOnly.has(key))
+          skipped.nameOnly++;
+        nameOnly.add(key);
+        continue;
+      }
+      if (verdict !== "ok") {
+        skipped.unresolved++;
+        continue;
+      }
+      const weight = Math.min(1, Math.max(0, candidate.weight));
+      const held = pairs.get(key) ?? { candidate, signals: /* @__PURE__ */ new Map() };
+      const scorerId = `${scorer.id}@${scorer.version}`;
+      const before2 = held.signals.get(scorerId);
+      if (!before2 || before2.weight < weight)
+        held.signals.set(scorerId, {
+          scorer: scorerId,
+          weight,
+          why: candidate.why.slice(0, 500),
+          ...candidate.purpose && scorerInput.purposes.includes(candidate.purpose) ? { purpose: candidate.purpose } : {}
+        });
+      held.candidate = {
+        ...held.candidate,
+        evidence: [.../* @__PURE__ */ new Set([...held.candidate.evidence, ...candidate.evidence])]
+      };
+      pairs.set(key, held);
+    }
+  }
+  const scored = [...pairs.values()].map(({ candidate, signals: signals2 }) => {
+    const list3 = [...signals2.values()].sort((a, b) => b.weight - a.weight || a.scorer.localeCompare(b.scorer));
+    const purpose = list3.find((one2) => one2.purpose)?.purpose;
+    return {
+      candidate,
+      purpose,
+      signals: list3.map(({ scorer, weight, why }) => ({ scorer, weight, why })),
+      score: combinedScore(list3.map((one2) => one2.weight))
+    };
+  }).sort((a, b) => b.score - a.score || a.candidate.from.localeCompare(b.candidate.from));
+  const proposals = [];
+  let fresh = 0;
+  for (const { candidate, purpose, signals: signals2, score } of scored) {
+    const state = await store.knowledge.relationState(null, candidate);
+    if (!state) {
+      skipped.unresolved++;
+      continue;
+    }
+    if (state.linked) {
+      skipped.confirmed++;
+      continue;
+    }
+    if (state.rejected || await rejectedReversed(store, candidate)) {
+      skipped.rejected++;
+      continue;
+    }
+    if (score < threshold) {
+      skipped.belowThreshold++;
+      continue;
+    }
+    if (!state.pending && fresh >= limit) {
+      skipped.overLimit++;
+      continue;
+    }
+    if (!state.pending)
+      fresh++;
+    const { identity: _identity, purpose: _purpose, weight: _weight, why: _why, ...pair } = candidate;
+    const evidence = candidate.evidence.slice(0, 5);
+    const proposal = {
+      ...pair,
+      weight: score,
+      why: signals2.map((one2) => one2.why).join("; "),
+      evidence,
+      ...purpose ? { purpose } : {},
+      score,
+      signals: signals2
+    };
+    if (!input.write) {
+      proposals.push({ ...proposal, id: state.pending?.id ?? null, state: "dry-run" });
+      continue;
+    }
+    const written = await store.knowledge.proposeRelation(null, {
+      from: pair.from,
+      to: pair.to,
+      kind: pair.kind,
+      evidence,
+      reason: proposal.why.slice(0, 2e3),
+      score,
+      signals: signals2,
+      ...purpose ? { purpose } : {}
+    }, SCAN_BOT);
+    proposals.push({
+      ...proposal,
+      id: written.id,
+      state: !state.pending ? "new" : JSON.stringify(written.payload) === JSON.stringify(state.pending.payload) ? "unchanged" : "updated"
+    });
+  }
+  return { project: project2?.ref ?? null, proposals, skipped };
+}, "scanProjectLinks");
+var admissible = /* @__PURE__ */ __name(async (store, input, candidate) => {
+  if (candidate.from === candidate.to || !Number.isFinite(candidate.weight))
+    return "unresolved";
+  if (input.project && candidate.to !== input.project.ref && !candidate.to.startsWith("person:"))
+    return "unresolved";
+  if (candidate.from === input.owner || candidate.to === input.owner)
+    return "owner";
+  if (candidate.from.startsWith("person:")) {
+    const identity = candidate.identity === void 0 ? void 0 : referenceOf(candidate.identity);
+    if (identity?.type !== "contact")
+      return "name-only";
+    const person = await store.people.personOf({ provider: identity.provider, id: identity.id });
+    return person !== void 0 && `person:${person.uid}` === candidate.from ? "ok" : "name-only";
+  }
+  if (candidate.from.startsWith("chat:")) {
+    const chat = referenceOf(candidate.from);
+    return chat?.type === "chat" && input.sources.some((source) => sameAccount(source, chat)) ? "ok" : "unresolved";
+  }
+  return "unresolved";
+}, "admissible");
+var referenceOf = /* @__PURE__ */ __name((text2) => {
+  try {
+    return parseReference(text2);
+  } catch {
+    return void 0;
+  }
+}, "referenceOf");
+var rejectedReversed = /* @__PURE__ */ __name(async (store, candidate) => candidate.kind === "related-to" && candidate.to.startsWith("person:") && ((await store.knowledge.relationState(null, { from: candidate.to, to: candidate.from, kind: candidate.kind }))?.rejected ?? false), "rejectedReversed");
+
 // node_modules/.pnpm/@wirecat+cli-core@0.560.0_@wirecat+cli-base@0.75.0_commander@15.0.0_esbuild@0.28.2_type_5702f943a9224d209a94753f662cf36c/node_modules/@wirecat/cli-core/dist/services/media-archive.js
 import { setTimeout as sleep3 } from "node:timers/promises";
 
@@ -26283,13 +26878,13 @@ var replyNext = {
 };
 
 // node_modules/.pnpm/@wirecat+cli-core@0.560.0_@wirecat+cli-base@0.75.0_commander@15.0.0_esbuild@0.28.2_type_5702f943a9224d209a94753f662cf36c/node_modules/@wirecat/cli-core/dist/services/project-status/signals/topics.js
-var escaped = /* @__PURE__ */ __name((text2) => text2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "escaped");
-var wholeWord = /* @__PURE__ */ __name((word) => new RegExp(`(?<![\\p{L}\\p{N}])${escaped(word)}(?![\\p{L}\\p{N}])`, "u"), "wholeWord");
+var escaped2 = /* @__PURE__ */ __name((text2) => text2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "escaped");
+var wholeWord = /* @__PURE__ */ __name((word) => new RegExp(`(?<![\\p{L}\\p{N}])${escaped2(word)}(?![\\p{L}\\p{N}])`, "u"), "wholeWord");
 var matcherOf = /* @__PURE__ */ __name((query) => {
   const words3 = normalize(query).split(" ").filter(Boolean).map(wholeWord);
   return (text2) => {
-    const folded = normalize(text2);
-    return words3.length > 0 && words3.every((word) => word.test(folded));
+    const folded2 = normalize(text2);
+    return words3.length > 0 && words3.every((word) => word.test(folded2));
   };
 }, "matcherOf");
 var topics = {
@@ -28064,8 +28659,8 @@ var refusedPlace = /* @__PURE__ */ __name((path, app, env, platform = process.pl
       ancestor = parent;
     }
   }
-  const folded = platform === "darwin" || platform === "win32";
-  const fold2 = /* @__PURE__ */ __name((text2) => folded ? text2.toLowerCase() : text2, "fold");
+  const folded2 = platform === "darwin" || platform === "win32";
+  const fold2 = /* @__PURE__ */ __name((text2) => folded2 ? text2.toLowerCase() : text2, "fold");
   const parts = new Set([...CREDENTIAL_PARTS].map(fold2));
   const runs = CREDENTIAL_RUNS.map((run) => run.map(fold2));
   const named2 = /* @__PURE__ */ __name((candidate) => {
@@ -38499,6 +39094,7 @@ export {
   documentPassage,
   storedNeighbours,
   gatherStoredProject,
+  scanProjectLinks,
   validateMediaSince,
   checkMediaArchive,
   archiveMedia,

package/dist/bundle/{entry-DO6ZBFIS.js → entry-L42C5CHF.js}

@@ -3,7 +3,7 @@ const require = __bundleRequire(import.meta.url);
 import {
   openBrowser,
   startCli
-} from "./chunk-ZCKU6WMX.js";
+} from "./chunk-7W3RCCRR.js";
 import "./chunk-NELE7AIX.js";
 import "./chunk-OUF6RCRZ.js";
 import "./chunk-2NJUPIAO.js";