@squirrelnotes.app/mcp 2.1.1-test.341 → 2.1.1-test.342

package/README.md

@@ -72,7 +72,7 @@ MCP does not (R-038).
 
 | Tool | Description |
 |------|-------------|
-| `search_memory` | Finds memories by the words in their text, entity and tags: BM25 over the decrypted set, times a recency decay per category (half-life 30 days for `project_state`, a year for preferences and mental models, two years for entity facts), with the app's trigram matching. The decrypted list is reused for up to 60 s, and re-read after any write from this process. Reads every page of `GET /public/memory` and searches the decrypted set on your machine; it never asks the server for one memory, so the server cannot tell which ones were consulted. Leaves out superseded and invalidated memories unless asked. A record that fails to decrypt or verify is skipped and counted (`unverifiable`), never shown. |
+| `search_memory` | Finds memories by the words in their text, entity and tags: BM25 over the decrypted set, times a recency decay per category (half-life 30 days for `project_state`, a year for preferences and mental models, two years for entity facts), with the app's trigram matching. Common English words and contraction fragments (a built-in list of 144: "what", "does", "he", "is", the "s" of "what's"…) are dropped from the query unless it has nothing else. The response names its `ranking` (`lexical` here; `hybrid` with the embeddings package; `none` for a listing) and `total` (matches before `limit`). Each hit has `score`, which orders that response only, and two scores that compare across searches: `lexicalScore` (0–1, the share of the query's content words the memory holds, a prefix counting half) and `semanticScore` (cosine similarity; always `null` in this package). As a guide (ADR-0444, synthetic data): a hit below `lexicalScore` 0.67, and below `semanticScore` 0.45 with embeddings, is rarely the answer (about 1 in 20); at `lexicalScore` ≥ 0.67 (two thirds of the words, as delivered, rounded to two places) about 9 in 10 are, at `semanticScore` ≥ 0.45 about half. `query` is optional when `category` or `entity` is given: the matching memories are then listed, newest first, `limit` at a time; pass `nextCursor` back as `cursor` for the next page (`null` on the last, and always `null` for a search). A memory edited during a walk can be missed, so compare the count against `total` or start again. With neither a query nor a filter, the call is refused. The decrypted list is reused for up to 60 s, and re-read after any write from this process. Reads every page of `GET /public/memory` and searches the decrypted set on your machine; it never asks the server for one memory, so the server cannot tell which ones were consulted. Leaves out superseded and invalidated memories unless asked. A record that fails to decrypt or verify is skipped and counted (`unverifiable`), never shown. |
 | `remember_memory` | Saves one memory (`text`, `category`, `entity`, optional `tags`, `sourceNoteId`). It is never pinned: only you pin, in the app. Returns near-duplicates so the agent can supersede instead of adding a copy. |
 | `supersede_memory` | Replaces an active memory: the old one is kept, marked superseded and linked to the new one. Guarded by the memory's revision, so a concurrent change is refused (409), not overwritten. Both records are written unpinned, even if the old one was pinned. |
 | `invalidate_memory` | Marks an active memory as wrong. The text is kept; the memory is written unpinned. |
@@ -128,8 +128,10 @@ opt in, change `args` to `["-y", "@squirrelnotes.app/mcp-embeddings"]` and add
 - The model runs in the MCP process on your machine. Memory text is not sent
   anywhere to be embedded. Search results still go to your agent.
 - Vectors are kept only in an AES-256-GCM file in your OS cache directory,
-  mode `0600`. They are never sent, logged or returned.
-- Tools, inputs and output keys are identical. If the model is refused or
+  mode `0600`. They are never sent, logged or returned; each hit carries only its
+  similarity, one rounded number, as `semanticScore`.
+- Tools, inputs and output keys are identical (`ranking` says `hybrid` when
+  meaning was used). If the model is refused or
   cannot load, search is this package's lexical search.
 
 This package has no ML dependency: `onnxruntime-node` is installed only by the

package/dist/stdio-handler.js

@@ -22613,8 +22613,15 @@ function intersectSets(a, b) {
 function searchableText(p) {
   return normalizeText([p.text, p.entity, ...p.tags].join(" "));
 }
+function hasSearchableText(query) {
+  return normalizeText(query).length > 0;
+}
 function queryTerms(query) {
-  return [...new Set(normalizeText(query).split(" ").filter(Boolean))];
+  const tokens = normalizeText(query).split(" ").filter(Boolean);
+  const isStop = (w, i) => STOPWORDS.has(w) || NT_STEMS.has(w) && tokens[i + 1] === "t";
+  const content = [...new Set(tokens.filter((w, i) => !isStop(w, i)))];
+  const words = [...new Set(tokens)];
+  return content.length > 0 ? content : words;
 }
 function recencyWeight(category, lastValidatedAt, now2) {
   const at = Date.parse(lastValidatedAt);
@@ -22700,7 +22707,7 @@ function termCoverage(text, p) {
   }
   return total / terms.length;
 }
-var DECAY_HALF_LIFE_DAYS, BM25_K1, BM25_B, PREFIX_WEIGHT, DAY_MS;
+var DECAY_HALF_LIFE_DAYS, BM25_K1, BM25_B, PREFIX_WEIGHT, DAY_MS, STOPWORDS, NT_STEMS;
 var init_memory_search = __esm({
   "src/memory-search.ts"() {
     "use strict";
@@ -22714,6 +22721,158 @@ var init_memory_search = __esm({
     BM25_B = 0.75;
     PREFIX_WEIGHT = 0.5;
     DAY_MS = 864e5;
+    STOPWORDS = /* @__PURE__ */ new Set([
+      "a",
+      "about",
+      "above",
+      "after",
+      "again",
+      "all",
+      "am",
+      "an",
+      "and",
+      "any",
+      "are",
+      "as",
+      "at",
+      "be",
+      "because",
+      "been",
+      "before",
+      "being",
+      "below",
+      "between",
+      "both",
+      "but",
+      "by",
+      "can",
+      "could",
+      "did",
+      "do",
+      "does",
+      "doing",
+      "during",
+      "each",
+      "few",
+      "for",
+      "from",
+      "further",
+      "had",
+      "has",
+      "have",
+      "having",
+      "he",
+      "her",
+      "here",
+      "hers",
+      "herself",
+      "him",
+      "himself",
+      "his",
+      "how",
+      "i",
+      "if",
+      "in",
+      "into",
+      "is",
+      "it",
+      "its",
+      "itself",
+      "just",
+      "me",
+      "more",
+      "most",
+      "my",
+      "myself",
+      "no",
+      "nor",
+      "not",
+      "of",
+      "off",
+      "on",
+      "once",
+      "only",
+      "or",
+      "other",
+      "our",
+      "ours",
+      "ourselves",
+      "out",
+      "over",
+      "own",
+      "same",
+      "she",
+      "should",
+      "so",
+      "some",
+      "such",
+      "than",
+      "that",
+      "the",
+      "their",
+      "theirs",
+      "them",
+      "themselves",
+      "then",
+      "there",
+      "these",
+      "they",
+      "this",
+      "those",
+      "through",
+      "to",
+      "too",
+      "under",
+      "until",
+      "up",
+      "very",
+      "was",
+      "we",
+      "were",
+      "what",
+      "when",
+      "where",
+      "which",
+      "while",
+      "who",
+      "whom",
+      "whose",
+      "why",
+      "will",
+      "with",
+      "would",
+      "you",
+      "your",
+      "yours",
+      "yourself",
+      "yourselves",
+      // What contractions leave once normalizeText turns the apostrophe into a
+      // space ("what's" → "what s", "doesn't" → "doesn t"). A one-letter term
+      // would prefix-match every word starting with that letter. "don", "won" and
+      // "haven" are also words or names, so they are not here: queryTerms drops
+      // them only before a "t" (NT_STEMS).
+      "s",
+      "t",
+      "d",
+      "ll",
+      "m",
+      "re",
+      "ve",
+      "aren",
+      "couldn",
+      "didn",
+      "doesn",
+      "hadn",
+      "hasn",
+      "isn",
+      "mustn",
+      "needn",
+      "shouldn",
+      "wasn",
+      "weren",
+      "wouldn"
+    ]);
+    NT_STEMS = /* @__PURE__ */ new Set(["don", "won", "haven"]);
   }
 });
 
@@ -22730,6 +22889,9 @@ function blendRanks(lexical, dense) {
   for (const [id, s] of scores) scores.set(id, s / max);
   return scores;
 }
+function aboveFloor(similarities, minSimilarity) {
+  return similarities.filter((m) => m.similarity >= minSimilarity);
+}
 var RRF_K;
 var init_memory_rank = __esm({
   "src/memory-rank.ts"() {
@@ -22785,24 +22947,66 @@ async function listAllMemories(client, key) {
   return { memories, unverifiable };
 }
 async function rankForSearch(query, all, eligible, semantic, key, now2) {
+  const byId = new Map(eligible.map((m) => [m.id, m]));
+  const hit = (id, score, similarity2) => ({
+    id,
+    score,
+    lexicalScore: termCoverage(query, byId.get(id).payload),
+    semanticScore: similarity2 ? similarity2.get(id) ?? null : null
+  });
   const lexical = scoreMemories(query, eligible, now2);
-  if (!semantic) return { ranked: lexical, fused: false };
-  const matches = await semantic.rank(
+  const lexicalOnly = () => ({ ranked: lexical.map((x) => hit(x.id, x.score, null)), fused: false });
+  if (!semantic) return lexicalOnly();
+  const scored = await semantic.score(
     query,
     all.map((m) => ({ id: m.id, revision: m.revision, text: memoryEmbeddingText(m.payload) })),
     new Set(eligible.map((m) => m.id)),
     key
   );
-  if (!matches) return { ranked: lexical, fused: false };
-  const byId = new Map(eligible.map((m) => [m.id, m]));
+  if (!scored) return lexicalOnly();
+  const similarity = new Map(scored.similarities.map((m) => [m.id, m.similarity]));
   const decay = (id) => {
     const p = byId.get(id).payload;
     return recencyWeight(p.category, p.lastValidatedAt, now2);
   };
-  const dense = matches.map(({ id, similarity }) => ({ id, weighed: similarity * decay(id) })).sort((a, b) => b.weighed - a.weighed || (a.id < b.id ? -1 : 1)).map((x) => x.id);
-  const ranked = [...blendRanks(lexical.map((x) => x.id), dense)].map(([id, score]) => ({ id, score, updatedAt: byId.get(id).payload.updatedAt })).sort((a, b) => b.score - a.score || b.updatedAt.localeCompare(a.updatedAt) || (a.id < b.id ? -1 : 1)).map(({ id, score }) => ({ id, score }));
+  const dense = aboveFloor(scored.similarities, scored.minSimilarity).map(({ id, similarity: sim }) => ({ id, weighed: sim * decay(id) })).sort((a, b) => b.weighed - a.weighed || (a.id < b.id ? -1 : 1)).map((x) => x.id);
+  const ranked = [...blendRanks(lexical.map((x) => x.id), dense)].map(([id, score]) => ({ id, score, updatedAt: byId.get(id).payload.updatedAt })).sort((a, b) => b.score - a.score || b.updatedAt.localeCompare(a.updatedAt) || (a.id < b.id ? -1 : 1)).map(({ id, score }) => hit(id, score, similarity));
   return { ranked, fused: true };
 }
+function listByRecency(eligible) {
+  return [...eligible].sort(compareRecency);
+}
+function compareRecency(a, b) {
+  return b.payload.updatedAt.localeCompare(a.payload.updatedAt) || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+}
+function encodeListCursor(m) {
+  const position = { u: m.payload.updatedAt, i: m.id };
+  return Buffer.from(JSON.stringify(position)).toString("base64url");
+}
+function decodeListCursor(cursor) {
+  try {
+    const parsed = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+    if (typeof parsed !== "object" || parsed === null) return null;
+    const { u, i } = parsed;
+    return typeof u === "string" && typeof i === "string" && u.length <= 64 && i.length <= 64 ? { u, i } : null;
+  } catch {
+    return null;
+  }
+}
+function listPage(eligible, after, limit) {
+  const ordered = listByRecency(eligible);
+  const start = after === null ? ordered : ordered.filter((m) => compareRecency(m, { id: after.i, payload: { updatedAt: after.u } }) > 0);
+  const page = start.slice(0, limit);
+  const last = page[page.length - 1];
+  return { page, nextCursor: start.length > limit && last ? encodeListCursor(last) : null };
+}
+function hitScores(h) {
+  return {
+    score: round(h.score, 2),
+    lexicalScore: round(h.lexicalScore, 2),
+    semanticScore: h.semanticScore === null ? null : round(h.semanticScore, 3)
+  };
+}
 function view(m, score) {
   const p = m.payload;
   return {
@@ -22823,7 +23027,7 @@ function view(m, score) {
     reviewedAt: p.reviewedAt,
     flaggedAt: p.flaggedAt ?? null,
     updatedAt: p.updatedAt,
-    ...score !== void 0 ? { score: Math.round(score * 100) / 100 } : {}
+    ...typeof score === "number" ? { score: round(score, 2) } : score ?? {}
   };
 }
 function chunkNote(title, markdown, category) {
@@ -23060,33 +23264,45 @@ function registerMemoryTools(server, context, options = {}) {
   };
   server.tool(
     "search_memory",
-    `Search the user's long-term memories (short facts and preferences saved by agents or the user). Ranks active memories by their relevance to the query: matching words in the text, entity and tags, and, when the user has installed local embeddings, similar meaning. Word matching uses ASCII letters and digits only (as in the app's search): other letters, such as accented or non-Latin ones, are ignored by it, so without local embeddings a query or memory written only in them cannot be found. ${NEEDS_REVIEW_HELP} Superseded and invalidated memories are left out unless asked for.`,
+    SEARCH_MEMORY_DESCRIPTION,
     {
-      query: external_exports.string().min(1).max(500).describe("Words to look for"),
+      query: external_exports.string().max(500).optional().describe("Words to look for. Optional when category or entity is given: then the matching memories are listed, newest first"),
       category: external_exports.enum(MEMORY_CATEGORIES).optional().describe("Only this category"),
       entity: external_exports.string().max(MAX_ENTITY).optional().describe("Only memories about this entity (case-insensitive)"),
       includeSuperseded: external_exports.boolean().default(false),
       includeInvalidated: external_exports.boolean().default(false),
-      limit: external_exports.number().int().min(1).max(20).default(5)
+      limit: external_exports.number().int().min(1).max(20).default(5),
+      cursor: external_exports.string().max(200).optional().describe("A listing only (no query): the nextCursor of the previous page, to get the next one")
     },
-    async ({ query, category, entity, includeSuperseded, includeInvalidated, limit }) => {
+    async ({ query, category, entity, includeSuperseded, includeInvalidated, limit, cursor }) => {
+      const wantEntity = entity?.trim().toLowerCase() || void 0;
+      const wantQuery = query?.trim() ? query : void 0;
+      if (wantQuery === void 0 && !category && !wantEntity) return refuse("search_memory", NO_QUERY_OR_FILTER);
+      if (cursor !== void 0 && wantQuery !== void 0) return refuse("search_memory", CURSOR_WITH_QUERY);
+      const after = cursor === void 0 ? null : decodeListCursor(cursor);
+      if (cursor !== void 0 && after === null) return refuse("search_memory", BAD_CURSOR);
       try {
         const ctx = await unlock();
         const { client, key } = ctx;
         const { memories, unverifiable } = await loadAll(client, key);
-        const wantEntity = entity?.trim().toLowerCase();
         const eligible = memories.filter(
           ({ payload: p }) => p.state === "active" || p.state === "superseded" && includeSuperseded || p.state === "invalidated" && includeInvalidated
         ).filter(({ payload: p }) => !category || p.category === category).filter(({ payload: p }) => !wantEntity || p.entity.trim().toLowerCase() === wantEntity);
+        if (wantQuery === void 0) {
+          const { page, nextCursor } = listPage(eligible, after, limit);
+          const results2 = page.map((m) => view(m, NO_SCORES));
+          mcpLog(`memory: search_memory listed=${eligible.length} results=${results2.length} unverifiable=${unverifiable}`);
+          const ranking2 = "none";
+          return ok({ ranking: ranking2, results: results2, total: eligible.length, nextCursor, searched: memories.length, unverifiable });
+        }
         const byId = new Map(eligible.map((m) => [m.id, m]));
-        const { ranked, fused } = await rankForSearch(query, memories, eligible, options.semantic ?? null, key, Date.now());
-        const results = ranked.slice(0, limit).map((x) => view(byId.get(x.id), x.score));
+        const { ranked, fused } = await rankForSearch(wantQuery, memories, eligible, options.semantic ?? null, key, Date.now());
+        const results = ranked.slice(0, limit).map((x) => view(byId.get(x.id), hitScores(x)));
+        const ranking = fused ? "hybrid" : "lexical";
         mcpLog(`memory: search_memory searched=${memories.length} results=${results.length} unverifiable=${unverifiable}`);
-        if (queryTerms(query).length === 0) {
-          const note = fused ? MEANING_ONLY_NOTE : NO_SEARCHABLE_TERMS;
-          return ok({ results, searched: memories.length, unverifiable, note });
-        }
-        return ok({ results, searched: memories.length, unverifiable });
+        const body = { ranking, results, total: ranked.length, nextCursor: null, searched: memories.length, unverifiable };
+        if (!hasSearchableText(wantQuery)) return ok({ ...body, note: fused ? MEANING_ONLY_NOTE : NO_SEARCHABLE_TERMS });
+        return ok(body);
       } catch (err) {
         return fail("search_memory", err);
       }
@@ -23317,7 +23533,7 @@ async function supersedeLanded(client, key, newId, oldId) {
     return false;
   }
 }
-var MEMORY_CATEGORIES, MEMORY_STATES, VIAS, MAX_TEXT, MAX_ENTITY, MAX_REASON, MAX_TAGS, MAX_TAG, MAX_CLIENT_NAME, uuidArg, MAX_IMPORT, CREATED_REVISION, MAX_ENCRYPTED_PAYLOAD_LENGTH, NoteVerificationError, MemoryTooLongError, isStr, isStrOrNull, oneOf, NEAR_DUPLICATE_SCORE, NEAR_DUPLICATE_LIMIT, STORAGE_MESSAGES, KeyContextError, isRetryable, USER_DATA_TEXT, NEEDS_REVIEW_TEXT, PROFILE_TOKEN_BUDGET, CHARS_PER_TOKEN, PROFILE_URI, NO_SEARCHABLE_TERMS, MEANING_ONLY_NOTE, NO_PINNED_MESSAGE, MEMORY_INSTRUCTIONS, NEEDS_REVIEW_HELP, now, MEMORY_CACHE_TTL_MS;
+var MEMORY_CATEGORIES, MEMORY_STATES, VIAS, MAX_TEXT, MAX_ENTITY, MAX_REASON, MAX_TAGS, MAX_TAG, MAX_CLIENT_NAME, uuidArg, MAX_IMPORT, CREATED_REVISION, MAX_ENCRYPTED_PAYLOAD_LENGTH, NoteVerificationError, MemoryTooLongError, isStr, isStrOrNull, oneOf, NEAR_DUPLICATE_SCORE, NEAR_DUPLICATE_LIMIT, round, NO_SCORES, STORAGE_MESSAGES, KeyContextError, isRetryable, USER_DATA_TEXT, NEEDS_REVIEW_TEXT, PROFILE_TOKEN_BUDGET, CHARS_PER_TOKEN, PROFILE_URI, NO_SEARCHABLE_TERMS, MEANING_ONLY_NOTE, CURSOR_WITH_QUERY, BAD_CURSOR, NO_QUERY_OR_FILTER, NO_PINNED_MESSAGE, MEMORY_INSTRUCTIONS, NEEDS_REVIEW_HELP, SEARCH_MEMORY_DESCRIPTION, now, MEMORY_CACHE_TTL_MS;
 var init_memory = __esm({
   "src/memory.ts"() {
     "use strict";
@@ -23357,6 +23573,8 @@ var init_memory = __esm({
     oneOf = (xs, x) => isStr(x) && xs.includes(x);
     NEAR_DUPLICATE_SCORE = 0.6;
     NEAR_DUPLICATE_LIMIT = 3;
+    round = (x, places) => Math.round(x * 10 ** places) / 10 ** places;
+    NO_SCORES = { score: null, lexicalScore: null, semanticScore: null };
     STORAGE_MESSAGES = ["Memory limit reached", "Memory storage limit reached"];
     KeyContextError = class extends Error {
       constructor(reason) {
@@ -23374,9 +23592,13 @@ var init_memory = __esm({
     PROFILE_URI = "memory://profile";
     NO_SEARCHABLE_TERMS = "The query has no searchable characters: memory search matches ASCII letters and digits only, so accented or non-Latin text cannot be searched.";
     MEANING_ONLY_NOTE = "The query has no ASCII letters or digits, which word matching ignores: these results were found only by meaning, through local embeddings.";
+    CURSOR_WITH_QUERY = "A cursor pages a listing (a category or entity with no query); a search does not page. Leave out the cursor, or the query.";
+    BAD_CURSOR = "That cursor is not one search_memory returned. Use the nextCursor of the previous page, or leave it out to start again.";
+    NO_QUERY_OR_FILTER = "Nothing to search for: give a query, or a category or entity to list the memories that match it.";
     NO_PINNED_MESSAGE = "No pinned memories yet. Only the user pins memories, in the Squirrel Notes app (Memory); agents cannot pin. Pinned memories appear here. Use search_memory to look for anything else.";
     MEMORY_INSTRUCTIONS = "Squirrel Notes keeps the user's encrypted notes and long-term memories. At the start of a session, call get_memory_profile (or read the resource memory://profile) to load the memories the user has pinned as always relevant (only the user pins, in the app). Use search_memory before asking the user something they may already have told you, and remember_memory, supersede_memory and invalidate_memory to keep memories current. " + NEEDS_REVIEW_TEXT;
     NEEDS_REVIEW_HELP = "`needsReview: true` means the memory was written by an agent and the user has not confirmed it yet; it is still in effect. " + USER_DATA_TEXT;
+    SEARCH_MEMORY_DESCRIPTION = `Search the user's long-term memories (short facts and preferences saved by agents or the user). Ranks active memories by their relevance to the query: matching words in the text, entity and tags, and, when the user has installed local embeddings, similar meaning. Common English words (stopwords such as "what", "does", "he", "is") are ignored by word matching unless the query has nothing else. Word matching uses ASCII letters and digits only (as in the app's search): other letters, such as accented or non-Latin ones, are ignored by it, so without local embeddings a query or memory written only in them cannot be found. The response says which ranking ran: "hybrid" (words and meaning), "lexical" (words only) or "none" (a listing). Each hit has \`score\`, which orders this response only and cannot be compared across searches, and two scores that can: \`lexicalScore\` (0\u20131, the share of the query's words, stopwords aside, that the memory contains; a query word that only begins a memory word counts half) and \`semanticScore\` (the cosine similarity of meaning, null unless the ranking is hybrid). As a guide, measured on a synthetic test set: a hit with semanticScore below 0.45 and lexicalScore below 0.67 is rarely the answer (about 1 in 20); at semanticScore 0.45 or more about half are, and at lexicalScore 0.67 or more (two thirds of the query's words, as delivered) about 9 in 10 are. semanticScore is a cosine, from -1 to 1 (in practice about -0.1 to 0.9). Without a query, a category or entity filter lists the matching memories, newest first, \`limit\` (at most 20) at a time: pass the response's \`nextCursor\` as \`cursor\` for the next page (null on the last). \`total\` is how many match in all; a memory edited during a walk may be missed, so compare against \`total\` or start again. ${NEEDS_REVIEW_HELP} Superseded and invalidated memories are left out unless asked for.`;
     now = () => (/* @__PURE__ */ new Date()).toISOString();
     MEMORY_CACHE_TTL_MS = 6e4;
   }
@@ -24610,6 +24832,7 @@ var memory_semantic_exports = {};
 __export(memory_semantic_exports, {
   RRF_K: () => RRF_K,
   SemanticMemoryIndex: () => SemanticMemoryIndex,
+  aboveFloor: () => aboveFloor,
   blendRanks: () => blendRanks,
   memoryEmbeddingText: () => memoryEmbeddingText
 });
@@ -24648,15 +24871,18 @@ var init_memory_semantic = __esm({
       batchSize;
       settled;
       /**
-       * The `candidates` whose cosine similarity to `query` reaches the model's
-       * minimum, with that similarity, best first; or null, meaning "rank
-       * lexically". The caller weighs them (recency, ADR-0444) before fusing.
+       * Every candidate that has a vector, with its cosine similarity to `query`,
+       * best first, and the model's minimum alongside, from one embedding of the
+       * query; or null, meaning "rank lexically". search_memory fuses those at or
+       * above the minimum (`aboveFloor`), weighed by recency, and reports each
+       * hit's similarity as `semanticScore` (ADR-0444, amended). A candidate not
+       * embedded within the time budget is absent.
        *
        * `all` is every memory the list returned: it decides which vectors are kept
        * on file. `candidates` is the subset search_memory has already filtered
        * (state, category, entity).
        */
-      async rank(query, all, candidates2, dek) {
+      async score(query, all, candidates2, dek) {
         const epoch = this.epoch;
         const state = await this.settledState();
         if (state.kind !== "ready") return null;
@@ -24669,12 +24895,11 @@ var init_memory_semantic = __esm({
           const scored = [];
           for (const id of candidates2) {
             const e = vectors.get(id);
-            if (!e) continue;
-            const similarity = dot(q, e.vector);
-            if (similarity >= embedder.minSimilarity) scored.push({ id, similarity });
+            if (e) scored.push({ id, similarity: dot(q, e.vector) });
           }
           await this.writeChain;
-          return scored.sort((a, b) => b.similarity - a.similarity || (a.id < b.id ? -1 : 1));
+          scored.sort((a, b) => b.similarity - a.similarity || (a.id < b.id ? -1 : 1));
+          return { similarities: scored, minSimilarity: embedder.minSimilarity };
         } catch {
           this.state = { kind: "off" };
           this.options.log("memory: semantic search failed in the embedding runtime; using lexical search for the rest of this session");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squirrelnotes.app/mcp",
-  "version": "2.1.1-test.341",
+  "version": "2.1.1-test.342",
   "description": "MCP stdio CLI for Squirrel Notes — bridges AI agents to the encrypted note-taking API",
   "type": "module",
   "repository": {