@batalabs/virlow-mcp-core 3.83.0 → 3.84.0

package/dist/cjs/memory-graph.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NEIGHBOUR_BOOST = exports.DIRECT_BOOST = exports.SINGLE_VALUED = exports.ONE_SUBJECT_PER_OBJECT = exports.ONE_OBJECT_PER_SUBJECT = void 0;
+exports.ROLES = exports.ENTITY_KINDS = exports.NEIGHBOUR_BOOST = exports.DIRECT_BOOST = exports.SINGLE_VALUED = exports.ONE_SUBJECT_PER_OBJECT = exports.ONE_OBJECT_PER_SUBJECT = void 0;
+exports.keyOf = keyOf;
+exports.findEntity = findEntity;
+exports.aliasMap = aliasMap;
 exports.entityKey = entityKey;
 exports.normalizePredicate = normalizePredicate;
 exports.heldAt = heldAt;
@@ -13,7 +16,45 @@ exports.supersededBy = supersededBy;
 exports.graphHealth = graphHealth;
 exports.renameEntityInMeta = renameEntityInMeta;
 exports.unlinkEntityFromMeta = unlinkEntityFromMeta;
+exports.normalizeKind = normalizeKind;
 exports.entityKinds = entityKinds;
+exports.storedKind = storedKind;
+exports.untypedEntities = untypedEntities;
+exports.suggestKind = suggestKind;
+/** The key an entity is filed under in `graph`: its own key, or, when the
+ *  registry names it as an alias, the key of the entity it is an alias of. */
+function keyOf(graph, name) {
+    const key = entityKey(name);
+    return graph.aliases?.get(key) ?? key;
+}
+/** The entity a name refers to, through aliases. */
+function findEntity(graph, name) {
+    return graph.entities.get(keyOf(graph, name));
+}
+/**
+ * Alias keys from registry entries. One level only: an alias names the entry
+ * it sits on, never a chain. When two entries claim one alias, the first by
+ * key wins, so every client resolves it the same way. An alias that is the
+ * entry's own key is ignored.
+ */
+function aliasMap(described) {
+    const aliases = new Map();
+    for (const key of [...described.keys()].sort()) {
+        for (const alias of described.get(key).aliases ?? []) {
+            const aliasKey = entityKey(alias);
+            if (!aliasKey || aliasKey === key || aliases.has(aliasKey))
+                continue;
+            // An entry that is itself an alias of something else does not gain
+            // aliases of its own: that would be a chain.
+            aliases.set(aliasKey, key);
+        }
+    }
+    for (const [aliasKey, target] of [...aliases]) {
+        if (aliases.has(target))
+            aliases.delete(aliasKey);
+    }
+    return aliases;
+}
 /** The matching key for a name: case, spacing and a leading article do not
  *  make a different entity. */
 function entityKey(name) {
@@ -87,12 +128,19 @@ function memoryHeldAt(memory, at) {
     const start = memory.meta.validFrom ?? relationStarts[0] ?? memory.meta.created;
     return heldAt(start, memory.meta.validTo, at);
 }
-function buildGraph(memories) {
+/**
+ * Entities and edges from memories. With `described` (the entity registry,
+ * by entity key), names the registry lists as aliases fold into the entity
+ * they are aliases of, and the registry's display name, kind and note ride
+ * along. The memories themselves are never rewritten for this.
+ */
+function buildGraph(memories, described = new Map()) {
     const entities = new Map();
     const spellings = new Map();
     const edges = [];
+    const aliases = aliasMap(described);
     const touch = (name, memoryId) => {
-        const key = entityKey(name);
+        const key = keyOf({ aliases }, name);
         let entity = entities.get(key);
         if (!entity) {
             entity = { key, name: name.trim(), memoryIds: new Set(), mentionIds: new Set(), edges: [] };
@@ -114,22 +162,29 @@ function buildGraph(memories) {
             touch(relation.s, memory.id).edges.push(edge);
             // The object is an entity only if something else names it as one;
             // "async standups" as the object of prefers stays a literal.
-            const objectKey = entityKey(relation.o);
+            const objectKey = keyOf({ aliases }, relation.o);
             if (entities.has(objectKey) || isEntityLike(relation.o)) {
                 touch(relation.o, memory.id).edges.push(edge);
             }
         }
     }
     for (const [key, counts] of spellings) {
-        const [best] = [...counts.entries()].sort((a, b) => b[1] - a[1]);
-        if (best)
+        // The registry's spelling first; then the canonical name's own most
+        // common spelling, so "Dana" as an alias never renames Dana Whitfield;
+        // then whatever is most common.
+        const given = described.get(key)?.name?.trim();
+        const own = [...counts.entries()].filter(([n]) => entityKey(n) === key);
+        const [best] = (own.length > 0 ? own : [...counts.entries()]).sort((a, b) => b[1] - a[1]);
+        if (given)
+            entities.get(key).name = given;
+        else if (best)
             entities.get(key).name = best[0];
     }
     // A memory that names a known entity in its words belongs to it too,
     // without anyone writing the link: "Deploy Atlas on Fridays" is about
     // Atlas once any memory names Atlas as an entity. Computed, never
     // written back, so it costs nothing and a rename is never stale.
-    const graph = { entities, edges };
+    const graph = { entities, edges, aliases, described };
     for (const memory of all) {
         for (const entity of entitiesMentioned(graph, `${memory.label} ${memory.text}`)) {
             if (entity.memoryIds.has(memory.id))
@@ -155,17 +210,25 @@ function entitiesMentioned(graph, text) {
         .replace(/[^a-z0-9.\s]/g, ' ')
         .replace(/\.(?![a-z0-9])|(?<![a-z0-9])\./g, ' ')
         .replace(/\s+/g, ' ')} `;
-    const found = [];
-    const byLength = [...graph.entities.values()].sort((a, b) => b.key.length - a.key.length);
+    const found = new Set();
+    // Every name an entity goes by: its key, and the aliases the registry
+    // gives it.
+    const needles = [...graph.entities.values()].map((e) => [e.key, e]);
+    for (const [alias, target] of graph.aliases ?? []) {
+        const entity = graph.entities.get(target);
+        if (entity)
+            needles.push([alias, entity]);
+    }
+    needles.sort((a, b) => b[0].length - a[0].length);
     let remaining = haystack;
-    for (const entity of byLength) {
-        const needle = ` ${entity.key} `;
-        if (entity.key.length < 2 || !remaining.includes(needle))
+    for (const [key, entity] of needles) {
+        const needle = ` ${key} `;
+        if (key.length < 2 || !remaining.includes(needle))
             continue;
-        found.push(entity);
+        found.add(entity);
         remaining = remaining.split(needle).join(' ');
     }
-    return found;
+    return [...found];
 }
 /** Entities one relation away from any of `from`. */
 function neighbours(graph, from) {
@@ -174,7 +237,7 @@ function neighbours(graph, from) {
     for (const entity of from) {
         for (const edge of entity.edges) {
             for (const end of [edge.s, edge.o]) {
-                const key = entityKey(end);
+                const key = keyOf(graph, end);
                 const other = graph.entities.get(key);
                 if (other && !seen.has(key)) {
                     seen.add(key);
@@ -222,8 +285,8 @@ function rankMemories(graph, query, scored, opts) {
  */
 function supersededBy(graph, relation, at) {
     const p = normalizePredicate(relation.p);
-    const s = entityKey(relation.s);
-    const o = entityKey(relation.o);
+    const s = keyOf(graph, relation.s);
+    const o = keyOf(graph, relation.o);
     const bySubject = exports.ONE_OBJECT_PER_SUBJECT.has(p);
     const byObject = exports.ONE_SUBJECT_PER_OBJECT.has(p);
     if (!bySubject && !byObject)
@@ -231,8 +294,8 @@ function supersededBy(graph, relation, at) {
     return graph.edges.filter((edge) => {
         if (edge.p !== p || !heldAt(edge.from, edge.to, at))
             return false;
-        const es = entityKey(edge.s);
-        const eo = entityKey(edge.o);
+        const es = keyOf(graph, edge.s);
+        const eo = keyOf(graph, edge.o);
         if (es === s && eo === o)
             return false;
         return bySubject ? es === s : eo === o;
@@ -240,8 +303,8 @@ function supersededBy(graph, relation, at) {
 }
 /**
  * Housekeeping findings for a tidy pass: memories linked to nothing, names
- * that look like one entity spelled two ways, and single-valued predicates
- * holding two values at once.
+ * that look like one entity spelled two ways, single-valued predicates
+ * holding two values at once, and names with no kind.
  */
 function graphHealth(graph, memories, at = Date.now()) {
     // Linked by nothing, and naming nothing the graph knows: a memory that
@@ -272,10 +335,14 @@ function graphHealth(graph, memories, at = Date.now()) {
             continue;
         const bySubject = exports.ONE_OBJECT_PER_SUBJECT.has(edge.p);
         const anchor = bySubject ? edge.s : edge.o;
-        const key = `${entityKey(anchor)}|${edge.p}`;
+        const key = `${keyOf(graph, anchor)}|${edge.p}`;
         if (!current.has(key))
-            current.set(key, { anchor, predicate: edge.p, values: new Set() });
-        current.get(key).values.add(bySubject ? edge.o : edge.s);
+            current.set(key, { anchor, predicate: edge.p, values: new Map() });
+        const value = bySubject ? edge.o : edge.s;
+        // Keyed through aliases, so "Acme" and its alias "Acme Inc" are one value.
+        const values = current.get(key).values;
+        if (!values.has(keyOf(graph, value)))
+            values.set(keyOf(graph, value), value);
     }
     for (const [key, { anchor, predicate, values }] of current) {
         if (values.size < 2)
@@ -283,10 +350,12 @@ function graphHealth(graph, memories, at = Date.now()) {
         contradictions.push({
             subject: graph.entities.get(key.split('|')[0])?.name ?? anchor,
             predicate,
-            objects: [...values],
+            objects: [...values.values()],
         });
     }
-    return { unlinked, possibleDuplicates, contradictions };
+    // Names nothing types yet, for the untyped review.
+    const untyped = untypedEntities(graph).map((e) => e.name);
+    return { unlinked, possibleDuplicates, contradictions, untyped };
 }
 /**
  * A memory's links with one name swapped for another: how "Dana" becomes
@@ -337,14 +406,70 @@ function uniqueNames(names) {
             byKey.set(entityKey(n), n);
     return [...byKey.values()];
 }
+/**
+ * What an entity is. `organization` was spelled `organisation` before the
+ * registry existed; readers accept both (see normalizeKind) and writers use
+ * this spelling. `other` is the fallback when nothing says.
+ */
+exports.ENTITY_KINDS = [
+    'person',
+    'organization',
+    'project',
+    'tool',
+    'place',
+    'event',
+    'topic',
+    'product',
+    'media',
+    'pet',
+    'group',
+    'goal',
+    'other',
+];
+const KIND_SET = new Set(exports.ENTITY_KINDS);
+/** Other words a person or a model uses for a kind. */
+const KIND_SYNONYMS = {
+    organisation: 'organization',
+    org: 'organization',
+    company: 'organization',
+    people: 'person',
+    human: 'person',
+    location: 'place',
+    habit: 'goal',
+    book: 'media',
+    document: 'media',
+    documents: 'media',
+    brand: 'product',
+    animal: 'pet',
+    software: 'tool',
+};
+/** A kind as stored or typed, as one of ENTITY_KINDS; undefined when it is
+ *  not one. Case and a plural "s" do not matter; `organisation` reads as
+ *  `organization`. */
+function normalizeKind(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const v = value.trim().toLowerCase();
+    if (KIND_SET.has(v))
+        return v;
+    if (KIND_SYNONYMS[v])
+        return KIND_SYNONYMS[v];
+    const singular = v.endsWith('s') ? v.slice(0, -1) : v;
+    if (KIND_SET.has(singular))
+        return singular;
+    return KIND_SYNONYMS[singular];
+}
 /**
  * What each end of a predicate usually is. "Dana works_at Acme" says Dana
- * is a person and Acme an organisation; "Atlas uses Postgres" says Atlas is
+ * is a person and Acme an organization; "Atlas uses Postgres" says Atlas is
  * a project and Postgres a tool. Unknown predicates say nothing.
  */
-const ROLES = {
-    works_at: ['person', 'organisation'],
-    employed_by: ['person', 'organisation'],
+exports.ROLES = {
+    works_at: ['person', 'organization'],
+    works_for: ['person', 'organization'],
+    employed_by: ['person', 'organization'],
+    founded: ['person', 'organization'],
+    ceo_of: ['person', 'organization'],
     works_on: ['person', 'project'],
     contributes_to: ['person', 'project'],
     leads: ['person', 'project'],
@@ -352,9 +477,18 @@ const ROLES = {
     owns: ['person', null],
     reports_to: ['person', 'person'],
     knows: ['person', 'person'],
+    friend_of: ['person', 'person'],
+    married_to: ['person', 'person'],
+    partner_of: ['person', 'person'],
+    sibling_of: ['person', 'person'],
+    parent_of: ['person', 'person'],
+    child_of: ['person', 'person'],
     lives_in: ['person', 'place'],
+    born_in: ['person', 'place'],
+    visited: ['person', 'place'],
     based_in: [null, 'place'],
     located_in: [null, 'place'],
+    headquartered_in: ['organization', 'place'],
     prefers: ['person', null],
     role: ['person', null],
     title: ['person', null],
@@ -367,20 +501,70 @@ const ROLES = {
     deployed_on: ['project', 'tool'],
     depends_on: ['project', 'tool'],
     part_of: [null, 'project'],
+    // Events
+    attends: ['person', 'event'],
+    attended: ['person', 'event'],
+    attending: ['person', 'event'],
+    spoke_at: ['person', 'event'],
+    organizes: ['person', 'event'],
+    organized: ['person', 'event'],
+    held_in: ['event', 'place'],
+    held_at: ['event', 'place'],
+    // Topics
+    about: [null, 'topic'],
+    interested_in: ['person', 'topic'],
+    studies: ['person', 'topic'],
+    studied: ['person', 'topic'],
+    learning: ['person', 'topic'],
+    expert_in: ['person', 'topic'],
+    // Products
+    bought: ['person', 'product'],
+    uses_product: ['person', 'product'],
+    owns_product: ['person', 'product'],
+    // Documents and media
+    reading: ['person', 'media'],
+    read: ['person', 'media'],
+    reads: ['person', 'media'],
+    wrote: ['person', 'media'],
+    authored: ['person', 'media'],
+    written_by: ['media', 'person'],
+    watched: ['person', 'media'],
+    listens_to: ['person', 'media'],
+    // Pets
+    owns_pet: ['person', 'pet'],
+    has_pet: ['person', 'pet'],
+    // Groups
+    member_of: ['person', 'group'],
+    belongs_to: ['person', 'group'],
+    // Goals and habits
+    goal: ['person', 'goal'],
+    has_goal: ['person', 'goal'],
+    working_toward: ['person', 'goal'],
+    working_towards: ['person', 'goal'],
+    practices: ['person', 'goal'],
 };
 /** Ties go to the kind a person most likely means. */
-const KIND_ORDER = ['person', 'project', 'organisation', 'place', 'tool'];
-/**
- * A best guess at what each entity is, from the roles it plays in its
- * relations; "other" when nothing says. A guess for filtering and colour,
- * never written back.
- */
-function entityKinds(graph) {
+const KIND_ORDER = [
+    'person',
+    'project',
+    'organization',
+    'place',
+    'tool',
+    'event',
+    'topic',
+    'group',
+    'product',
+    'media',
+    'pet',
+    'goal',
+];
+/** Kinds voted for each entity by the roles it plays in its relations. */
+function roleVotes(graph) {
     const votes = new Map();
     const vote = (name, kind) => {
         if (!kind)
             return;
-        const key = entityKey(name);
+        const key = keyOf(graph, name);
         if (!graph.entities.has(key))
             return;
         const tally = votes.get(key) ?? new Map();
@@ -388,19 +572,142 @@ function entityKinds(graph) {
         votes.set(key, tally);
     };
     for (const edge of graph.edges) {
-        const [s, o] = ROLES[edge.p] ?? [null, null];
+        const [s, o] = exports.ROLES[edge.p] ?? [null, null];
         vote(edge.s, s);
         vote(edge.o, o);
     }
+    return votes;
+}
+function bestVote(tally) {
+    return [...tally.entries()].sort((a, b) => b[1] - a[1] || KIND_ORDER.indexOf(a[0]) - KIND_ORDER.indexOf(b[0]))[0][0];
+}
+/**
+ * What each entity is. A kind stored in the entity registry (set by the
+ * person or by an AI with describe_entity or add_memory) wins; otherwise a
+ * best guess from the roles the entity plays in its relations; "other" when
+ * nothing says. The guess is never written back.
+ */
+function entityKinds(graph) {
+    const votes = roleVotes(graph);
     const kinds = new Map();
     for (const key of graph.entities.keys()) {
-        const tally = votes.get(key);
-        if (!tally) {
-            kinds.set(key, 'other');
+        const stored = graph.described?.get(key)?.kind;
+        if (stored) {
+            kinds.set(key, stored);
             continue;
         }
-        const best = [...tally.entries()].sort((a, b) => b[1] - a[1] || KIND_ORDER.indexOf(a[0]) - KIND_ORDER.indexOf(b[0]))[0];
-        kinds.set(key, best[0]);
+        const tally = votes.get(key);
+        kinds.set(key, tally ? bestVote(tally) : 'other');
     }
     return kinds;
 }
+/** The kind the registry stores for an entity, if any. */
+function storedKind(graph, name) {
+    return graph.described?.get(keyOf(graph, name))?.kind;
+}
+/**
+ * Entities nothing types: no kind in the registry and no relation role to
+ * guess one from. These are what a review asks the person (or an AI) to
+ * sort out. Most known first.
+ */
+function untypedEntities(graph) {
+    const kinds = entityKinds(graph);
+    return [...graph.entities.values()]
+        .filter((e) => kinds.get(e.key) === 'other' && !graph.described?.get(e.key)?.kind)
+        .sort((a, b) => b.memoryIds.size - a.memoryIds.size || a.name.localeCompare(b.name));
+}
+/** Company suffixes that make a name an organization and nothing else. */
+const ORG_SUFFIX = /(?:^|[\s,])(inc\.?|incorporated|llc|l\.l\.c\.|ltd\.?|limited|gmbh|corp\.?|corporation|plc|llp|s\.a\.|ag|& co\.?)$/i;
+/**
+ * A suggested kind for an untyped entity, from signals on this device only
+ * (memory content is end-to-end encrypted, so no server can suggest
+ * anything). Only signals that point one way:
+ * - relation roles (ROLES), when the entity plays one;
+ * - how typed entities are used: if every typed subject (or object) of a
+ *   predicate is one kind, an untyped one in the same place is that kind
+ *   too ("Dana mentors Sam", with Dana a person, makes Lee in "Lee mentors
+ *   Kim" a person), with at least two typed examples;
+ * - the name: a company suffix (Inc, LLC, Ltd, GmbH...) is an organization,
+ *   and a single name that is the first name of exactly one typed person
+ *   ("Dana" beside the person "Dana Whitfield") is a person.
+ * Null when nothing points one way; a wrong guess costs more than none.
+ */
+function suggestKind(graph, name) {
+    const key = keyOf(graph, name);
+    const entity = graph.entities.get(key);
+    if (!entity)
+        return null;
+    const kinds = entityKinds(graph);
+    const tally = roleVotes(graph).get(key);
+    if (tally) {
+        const kind = bestVote(tally);
+        const edge = entity.edges.find((e) => {
+            const [s, o] = exports.ROLES[e.p] ?? [null, null];
+            return (keyOf(graph, e.s) === key && s === kind) || (keyOf(graph, e.o) === key && o === kind);
+        });
+        const n = tally.get(kind);
+        return {
+            kind,
+            reason: `${edge ? edge.p.replace(/_/g, ' ') : 'its relations'}${n > 1 ? ` in ${n} relations` : ''}`,
+        };
+    }
+    if (ORG_SUFFIX.test(entity.name.trim())) {
+        return { kind: 'organization', reason: 'company name' };
+    }
+    // Learned roles: how typed entities are used with the same predicates.
+    const typed = (n) => {
+        const k = keyOf(graph, n);
+        return graph.described?.get(k)?.kind;
+    };
+    const learned = new Map();
+    for (const edge of graph.edges) {
+        for (const [side, end] of [
+            ['s', edge.s],
+            ['o', edge.o],
+        ]) {
+            const kind = typed(end);
+            if (!kind || kind === 'other')
+                continue;
+            const slot = `${edge.p}|${side}`;
+            const m = learned.get(slot) ?? new Map();
+            m.set(kind, (m.get(kind) ?? 0) + 1);
+            learned.set(slot, m);
+        }
+    }
+    const agree = new Map();
+    let conflicted = false;
+    for (const edge of entity.edges) {
+        for (const [side, end] of [
+            ['s', edge.s],
+            ['o', edge.o],
+        ]) {
+            if (keyOf(graph, end) !== key)
+                continue;
+            const m = learned.get(`${edge.p}|${side}`);
+            if (!m)
+                continue;
+            if (m.size !== 1) {
+                conflicted = true;
+                continue;
+            }
+            const [[kind, count]] = [...m.entries()];
+            if (count < 2)
+                continue;
+            if (!agree.has(kind))
+                agree.set(kind, edge.p.replace(/_/g, ' '));
+        }
+    }
+    if (agree.size === 1 && !conflicted) {
+        const [[kind, predicate]] = [...agree.entries()];
+        return { kind, reason: `used like other ${kind === 'person' ? 'people' : `${kind}s`} with "${predicate}"` };
+    }
+    // A first name beside exactly one typed person who has it.
+    if (!entity.key.includes(' ')) {
+        const people = [...graph.entities.values()].filter((e) => e.key !== key && e.key.startsWith(`${entity.key} `) && kinds.get(e.key) === 'person');
+        const others = [...graph.entities.values()].filter((e) => e.key !== key && e.key.startsWith(`${entity.key} `) && kinds.get(e.key) !== 'person');
+        if (people.length === 1 && others.length === 0) {
+            return { kind: 'person', reason: `first name of ${people[0].name}` };
+        }
+    }
+    return null;
+}

package/dist/cjs/notes.js

@@ -5,6 +5,7 @@ const virlow_crypto_1 = require("@batalabs/virlow-crypto");
 const exposure_js_1 = require("./exposure.js");
 const attrs_js_1 = require("./attrs.js");
 const attrs_extract_js_1 = require("./attrs-extract.js");
+const entity_registry_js_1 = require("./entity-registry.js");
 const vault_js_1 = require("./vault.js");
 /** Hard ceiling on how many notes searchNotes() will decrypt+scan in a
  * single call. Keeps a single search bounded even for very large accounts;
@@ -248,7 +249,7 @@ class NotesService {
         // surface in list/search results. readNote() still allows fetching one
         // by exact id — that's a deliberate, explicit request.
         const exposure = await this.exposure();
-        const notHidden = notes.filter((row) => row.hidden !== true);
+        const notHidden = notes.filter((row) => row.hidden !== true && !isSystemNote(row));
         // Folders the user has not opened to AI tools are filtered here rather
         // than at the API, so the count of what was withheld can be reported.
         const visible = notHidden.filter((row) => exposure.allows(row.folderId));
@@ -298,7 +299,7 @@ class NotesService {
             deleted: false,
         });
         const exposure = await this.exposure();
-        const notHidden = notes.filter((row) => row.hidden !== true);
+        const notHidden = notes.filter((row) => row.hidden !== true && !isSystemNote(row));
         const visible = notHidden.filter((row) => exposure.allows(row.folderId));
         const withheld = {
             inClosedFolders: notHidden.length - visible.length,
@@ -383,6 +384,9 @@ class NotesService {
             // sent encrypted under a key the vault has since revoked.
             const startEpoch = this.epoch;
             const existingRow = await this.api.getNote(id);
+            if (isSystemNote(existingRow)) {
+                throw new Error('That note is the entity registry. Change entities with describe_entity.');
+            }
             const exposure = await this.exposure();
             this.requireExposed(exposure, existingRow.folderId, id);
             const current = await this.decryptRow(key, existingRow);
@@ -661,7 +665,7 @@ class NotesService {
             const { notes, pagination } = await this.api.listNotes({ page, limit: SEARCH_PAGE_LIMIT, deleted: false });
             total = pagination.total;
             for (const row of notes) {
-                if (row.hidden === true)
+                if (row.hidden === true || isSystemNote(row))
                     continue;
                 if (!exposure.allows(row.folderId))
                     continue;
@@ -849,7 +853,7 @@ class NotesService {
         for (;;) {
             const { notes, pagination } = await this.api.listNotes({ page, limit: SEARCH_PAGE_LIMIT, deleted: false });
             for (const row of notes) {
-                if (row.hidden === true)
+                if (row.hidden === true || isSystemNote(row))
                     continue;
                 // Archived notes are out of the way by the user's own choice, so an
                 // archived note is not a backlink source and not a mention target.
@@ -982,3 +986,8 @@ class NotesService {
     }
 }
 exports.NotesService = NotesService;
+/** A note the app keeps for itself, never listed or searched as a note:
+ *  the entity registry (see entity-registry.ts). */
+function isSystemNote(row) {
+    return row.type === entity_registry_js_1.ENTITY_REGISTRY_NOTE_TYPE;
+}