@sentry/junior-memory 0.134.0 → 0.136.0

package/README.md

@@ -71,6 +71,10 @@ exported types, tools, and tests are authoritative.
   and slightly prefers lexical ranks so exact tokens survive soft semantic
   neighbors. Vector recall also applies the cosine distance cutoff in SQL, and
   embeddings use an HNSW cosine index (`vector_cosine_ops`).
+- Automatic recall also runs personal-scope-only vector and lexical probes so
+  older actor preferences are not buried when newer workspace conversation
+  memories fill the shared lexical recency window with common tokens. On RRF
+  score ties, personal-scope matches rank ahead of conversation matches.
 - Automatic recall retrieves a bounded candidate window, then uses the
   memory-owned relevance model to admit at most five directly useful memories.
   An empty result contributes no filler prompt text.

package/dist/api.d.ts

@@ -18,6 +18,15 @@ export declare const memoryApiSchema: z.ZodObject<{
         knowledge: "knowledge";
     }>;
     observedAt: z.ZodISODateTime;
+    origin: z.ZodEnum<{
+        automatic: "automatic";
+        explicit: "explicit";
+        other: "other";
+    }>;
+    sourcePlatform: z.ZodEnum<{
+        slack: "slack";
+        local: "local";
+    }>;
     visibility: z.ZodEnum<{
         public: "public";
         private: "private";
@@ -35,6 +44,15 @@ export declare const memoryListResponseSchema: z.ZodObject<{
             knowledge: "knowledge";
         }>;
         observedAt: z.ZodISODateTime;
+        origin: z.ZodEnum<{
+            automatic: "automatic";
+            explicit: "explicit";
+            other: "other";
+        }>;
+        sourcePlatform: z.ZodEnum<{
+            slack: "slack";
+            local: "local";
+        }>;
         visibility: z.ZodEnum<{
             public: "public";
             private: "private";

package/dist/index.js

@@ -224,8 +224,8 @@ function rankMemoryMatches(matches, options) {
     }
     byId.set(match.memory.id, {
       ...existing,
-      ...match.lexical ? { lexical: match.lexical } : {},
-      ...match.vector ? { vector: match.vector } : {}
+      ...!existing.lexical && match.lexical ? { lexical: match.lexical } : {},
+      ...!existing.vector && match.vector ? { vector: match.vector } : {}
     });
   }
   return [...byId.values()].sort((left, right) => {
@@ -233,6 +233,10 @@ function rankMemoryMatches(matches, options) {
     if (scoreDelta !== 0) {
       return scoreDelta;
     }
+    const personalDelta = Number(right.memory.scope === "personal") - Number(left.memory.scope === "personal");
+    if (personalDelta !== 0) {
+      return personalDelta;
+    }
     const channelDelta = Number(currentChannel(right, options.channelPrefix)) - Number(currentChannel(left, options.channelPrefix));
     if (channelDelta !== 0) {
       return channelDelta;
@@ -981,23 +985,11 @@ async function searchVisibleLexicalMemories(args) {
   }));
 }
 async function searchVisibleVectorMemories(args) {
-  if (!args.embedder) {
-    return [];
-  }
   const predicate = activeVisiblePredicate(args);
   if (!predicate) {
     return [];
   }
-  const query = normalizeRetrievalQuery(args.query);
-  if (!query) {
-    return [];
-  }
-  let embedding;
-  try {
-    embedding = await embedOne(args.embedder, query);
-  } catch {
-    return [];
-  }
+  const embedding = args.embedding;
   const distance = cosineDistance(
     juniorMemoryEmbeddings.embedding,
     embedding.vector
@@ -1259,26 +1251,52 @@ function createMemoryStore(db, context, options = {}) {
     const limit = boundedLimit(input.limit, DEFAULT_SEARCH_LIMIT);
     const overfetch = vectorMaxDistance === void 0 ? SEARCH_RETRIEVAL_OVERFETCH : RECALL_RETRIEVAL_OVERFETCH;
     const candidateLimit = retrievalLegLimit(limit, overfetch);
-    const [vectorMatches, lexicalMatches] = await Promise.all([
-      searchVisibleVectorMemories({
+    const personalScopes = scopes.filter((scope) => scope.scope === "personal");
+    const probePersonal = vectorMaxDistance !== void 0 && personalScopes.length > 0;
+    const query = normalizeRetrievalQuery(input.query);
+    let queryEmbedding;
+    if (embedder && query) {
+      try {
+        queryEmbedding = await embedOne(embedder, query);
+      } catch {
+        queryEmbedding = void 0;
+      }
+    }
+    const emptyMatches = Promise.resolve([]);
+    const lexicalArgs = {
+      db,
+      limit: candidateLimit,
+      nowMs,
+      query: input.query
+    };
+    const matches = await Promise.all([
+      queryEmbedding ? searchVisibleVectorMemories({
         db,
-        embedder,
+        embedding: queryEmbedding,
         limit: candidateLimit,
         ...vectorMaxDistance !== void 0 ? { maxDistance: vectorMaxDistance } : {},
         nowMs,
-        query: input.query,
         scopes
-      }),
+      }) : emptyMatches,
       searchVisibleLexicalMemories({
+        ...lexicalArgs,
+        scopes
+      }),
+      queryEmbedding && probePersonal ? searchVisibleVectorMemories({
         db,
+        embedding: queryEmbedding,
         limit: candidateLimit,
+        maxDistance: vectorMaxDistance,
         nowMs,
-        query: input.query,
-        scopes
-      })
+        scopes: personalScopes
+      }) : emptyMatches,
+      probePersonal ? searchVisibleLexicalMemories({
+        ...lexicalArgs,
+        scopes: personalScopes
+      }) : emptyMatches
     ]);
     const channelPrefix = sourceChannelPrefix(runtimeContext);
-    return rankMemoryMatches([...vectorMatches, ...lexicalMatches], {
+    return rankMemoryMatches(matches.flat(), {
       nowMs,
       // Slight lexical preference protects exact ids/names/timezones on ties.
       ...vectorMaxDistance === void 0 ? {} : { lexicalWeight: 1, vectorWeight: 0.85 },
@@ -2195,6 +2213,8 @@ var memoryApiSchema = z6.object({
   id: z6.string().min(1),
   kind: z6.enum(["preference", "procedure", "knowledge"]),
   observedAt: z6.iso.datetime(),
+  origin: z6.enum(["automatic", "explicit", "other"]),
+  sourcePlatform: z6.enum(["local", "slack"]),
   visibility: z6.enum(["private", "public"])
 }).strict();
 var memoryListResponseSchema = z6.object({
@@ -2248,6 +2268,8 @@ function apiMemory(memory) {
     id: memory.id,
     kind: memory.kind,
     observedAt: new Date(memory.observedAtMs).toISOString(),
+    origin: memory.origin,
+    sourcePlatform: memory.sourcePlatform,
     visibility: memory.visibility
   };
 }