@sentry/junior-memory 0.134.0 → 0.136.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior-memory",
-  "version": "0.134.0",
+  "version": "0.136.0",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -27,7 +27,7 @@
     "commander": "^14.0.3",
     "drizzle-orm": "^0.45.2",
     "zod": "^4.4.3",
-    "@sentry/junior-plugin-api": "0.134.0"
+    "@sentry/junior-plugin-api": "0.136.0"
   },
   "devDependencies": {
     "@types/node": "^25.9.1",

package/src/api.ts

@@ -27,6 +27,8 @@ export const memoryApiSchema = z
     id: z.string().min(1),
     kind: z.enum(["preference", "procedure", "knowledge"]),
     observedAt: z.iso.datetime(),
+    origin: z.enum(["automatic", "explicit", "other"]),
+    sourcePlatform: z.enum(["local", "slack"]),
     visibility: z.enum(["private", "public"]),
   })
   .strict();
@@ -118,6 +120,8 @@ function apiMemory(
     id: memory.id,
     kind: memory.kind,
     observedAt: new Date(memory.observedAtMs).toISOString(),
+    origin: memory.origin,
+    sourcePlatform: memory.sourcePlatform,
     visibility: memory.visibility,
   };
 }

package/src/ranking.ts

@@ -83,10 +83,15 @@ export function rankMemoryMatches(
       byId.set(match.memory.id, match);
       continue;
     }
+    // Keep the first rank per modality. Shared legs are fused before personal
+    // probes, so a smaller personal top-k cannot overwrite a shared dense rank
+    // with an inflated top rank for the same memory.
     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) => {
@@ -94,6 +99,15 @@ export function rankMemoryMatches(
     if (scoreDelta !== 0) {
       return scoreDelta;
     }
+    // Prefer actor preferences over workspace knowledge when RRF ties. Shared
+    // lexical legs often assign the same top rank to recent conversation noise
+    // and a personal-scope probe hit for the same common token.
+    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));

package/src/store.ts

@@ -1066,30 +1066,17 @@ async function searchVisibleLexicalMemories(args: {
 /** Search active visible records with pgvector cosine distance. */
 async function searchVisibleVectorMemories(args: {
   db: MemoryDb;
-  embedder: MemoryEmbeddingProvider | undefined;
+  embedding: MemoryEmbedding;
   limit: number;
   maxDistance?: number;
   nowMs: number;
-  query: string;
   scopes: ResolvedMemoryScope[];
 }): Promise<MemoryMatch[]> {
-  if (!args.embedder) {
-    return [];
-  }
   const predicate = activeVisiblePredicate(args);
   if (!predicate) {
     return [];
   }
-  const query = normalizeRetrievalQuery(args.query);
-  if (!query) {
-    return [];
-  }
-  let embedding: Awaited<ReturnType<typeof embedOne>>;
-  try {
-    embedding = await embedOne(args.embedder, query);
-  } catch {
-    return [];
-  }
+  const embedding = args.embedding;
   const distance = cosineDistance(
     juniorMemoryEmbeddings.embedding,
     embedding.vector,
@@ -1409,6 +1396,11 @@ export function createMemoryStore(
    * vectors already hit: that drops exact/token memories and serializes the
    * miss path. Each leg is a hard-capped top-k probe so Postgres work stays
    * bounded even on broad queries.
+   *
+   * Automatic recall also runs personal-scope-only probes. Workspace
+   * conversation memories sharing common tokens (for example "time") can fill
+   * the shared lexical recency window before ranking, which buries older actor
+   * preferences that explicit search still finds.
    */
   async function retrieveVisibleMemories(
     rawInput: SearchMemoriesInput,
@@ -1428,30 +1420,66 @@ export function createMemoryStore(
         ? SEARCH_RETRIEVAL_OVERFETCH
         : RECALL_RETRIEVAL_OVERFETCH;
     const candidateLimit = retrievalLegLimit(limit, overfetch);
+    const personalScopes = scopes.filter((scope) => scope.scope === "personal");
+    // Automatic recall only: keep a personal-scope probe so workspace noise
+    // cannot monopolize the shared lexical recency window.
+    const probePersonal =
+      vectorMaxDistance !== undefined && personalScopes.length > 0;
+    const query = normalizeRetrievalQuery(input.query);
+    let queryEmbedding: MemoryEmbedding | undefined;
+    if (embedder && query) {
+      try {
+        queryEmbedding = await embedOne(embedder, query);
+      } catch {
+        queryEmbedding = undefined;
+      }
+    }
+    const emptyMatches = Promise.resolve([] as MemoryMatch[]);
+    const lexicalArgs = {
+      db,
+      limit: candidateLimit,
+      nowMs,
+      query: input.query,
+    };
     // Always run both legs in parallel. Conditional lexical skip is unsafe:
     // one in-threshold vector distractor can hide a stronger lexical hit.
-    const [vectorMatches, lexicalMatches] = await Promise.all([
-      searchVisibleVectorMemories({
-        db,
-        embedder,
-        limit: candidateLimit,
-        ...(vectorMaxDistance !== undefined
-          ? { maxDistance: vectorMaxDistance }
-          : {}),
-        nowMs,
-        query: input.query,
-        scopes,
-      }),
+    // Embed once up front; vector probes only run when that embedding exists.
+    const matches = await Promise.all([
+      queryEmbedding
+        ? searchVisibleVectorMemories({
+            db,
+            embedding: queryEmbedding,
+            limit: candidateLimit,
+            ...(vectorMaxDistance !== undefined
+              ? { maxDistance: vectorMaxDistance }
+              : {}),
+            nowMs,
+            scopes,
+          })
+        : emptyMatches,
       searchVisibleLexicalMemories({
-        db,
-        limit: candidateLimit,
-        nowMs,
-        query: input.query,
+        ...lexicalArgs,
         scopes,
       }),
+      queryEmbedding && probePersonal
+        ? searchVisibleVectorMemories({
+            db,
+            embedding: queryEmbedding,
+            limit: candidateLimit,
+            maxDistance: vectorMaxDistance,
+            nowMs,
+            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 === undefined