@sentry/junior-memory 0.180.0 → 0.181.1

package/src/events.ts

@@ -3,12 +3,23 @@ import { z } from "zod";
 import { MEMORY_KINDS, MEMORY_SCOPES } from "./types";
 import type { MemoryRecord } from "./store";
 
+const capturedMemoryFields = {
+  content: z.string().min(1),
+  id: z.string().min(1),
+  kind: z.enum(MEMORY_KINDS),
+  observedAtMs: z.number().finite(),
+};
+
+const legacyCapturedMemorySchema = z
+  .object({
+    ...capturedMemoryFields,
+    scope: z.enum(["personal", "conversation"]),
+  })
+  .strict();
+
 const capturedMemorySchema = z
   .object({
-    content: z.string().min(1),
-    id: z.string().min(1),
-    kind: z.enum(MEMORY_KINDS),
-    observedAtMs: z.number().finite(),
+    ...capturedMemoryFields,
     scope: z.enum(MEMORY_SCOPES),
   })
   .strict();
@@ -28,9 +39,20 @@ const recalledMemoriesSchema = z
   })
   .strict();
 
-function renderCapturedMemories(
-  event: z.output<typeof capturedMemoriesSchema>,
+function currentScope(
+  scope: "personal" | "conversation" | "private" | "public",
 ) {
+  if (scope === "personal") return "private";
+  if (scope === "conversation") return "public";
+  return scope;
+}
+
+function renderCapturedMemories(event: {
+  memories: Array<
+    | z.output<typeof legacyCapturedMemorySchema>
+    | z.output<typeof capturedMemorySchema>
+  >;
+}) {
   const count = event.memories.length;
   if (count === 0) return undefined;
   return {
@@ -38,7 +60,7 @@ function renderCapturedMemories(
     title: `${count} ${count === 1 ? "memory" : "memories"} captured`,
     details: event.memories.map((memory) => ({
       title: memory.content,
-      metadata: [memory.kind, memory.scope],
+      metadata: [memory.kind, currentScope(memory.scope)],
     })),
   };
 }
@@ -49,7 +71,7 @@ export const memoriesCapturedEventV1 = defineConversationEvent({
   version: 1,
   schema: z
     .object({
-      memories: z.array(capturedMemorySchema).min(1).max(100),
+      memories: z.array(legacyCapturedMemorySchema).min(1).max(100),
     })
     .strict(),
   renderEvent: renderCapturedMemories,

package/src/operational-report.ts

@@ -12,9 +12,9 @@ const WINDOWS = [7, 30, 90] as const;
 
 const memoryDaySchema = z
   .object({
-    conversation: z.number().int().nonnegative(),
     date: z.string().date(),
-    personal: z.number().int().nonnegative(),
+    private: z.number().int().nonnegative(),
+    public: z.number().int().nonnegative(),
   })
   .strict();
 
@@ -55,11 +55,11 @@ async function aggregateMemoryDays(args: { db: MemoryDb; nowMs: number }) {
           to_timestamp(${table.createdAtMs} / 1000.0) AT TIME ZONE 'UTC'
         ) AS day,
         count(*) FILTER (
-          WHERE ${table.scope} = 'personal'
-        )::integer AS personal,
+          WHERE ${table.scope} = 'private'
+        )::integer AS private,
         count(*) FILTER (
-          WHERE ${table.scope} = 'conversation'
-        )::integer AS conversation
+          WHERE ${table.scope} = 'public'
+        )::integer AS public
       FROM ${table}
       WHERE ${table.createdAtMs} >= ${start.getTime()}
         AND ${table.createdAtMs} < ${endExclusiveMs}
@@ -70,8 +70,8 @@ async function aggregateMemoryDays(args: { db: MemoryDb; nowMs: number }) {
     )
     SELECT
       to_char(days.day, 'YYYY-MM-DD') AS date,
-      coalesce(daily.personal, 0)::integer AS personal,
-      coalesce(daily.conversation, 0)::integer AS conversation
+      coalesce(daily.private, 0)::integer AS private,
+      coalesce(daily.public, 0)::integer AS public
     FROM days
     LEFT JOIN daily ON daily.day = days.day
     ORDER BY days.day
@@ -119,8 +119,8 @@ export async function buildMemoryOperationalReport(args: {
     args.db
       .select({
         active: sql<number>`count(*) filter (where ${active})`.mapWith(Number),
-        conversation:
-          sql<number>`count(*) filter (where ${active} and ${juniorMemoryMemories.scope} = 'conversation')`.mapWith(
+        public:
+          sql<number>`count(*) filter (where ${active} and ${juniorMemoryMemories.scope} = 'public')`.mapWith(
             Number,
           ),
         createdThirtyDays:
@@ -131,8 +131,8 @@ export async function buildMemoryOperationalReport(args: {
           sql<number>`count(${juniorMemoryEmbeddings.memoryId}) filter (where ${active})`.mapWith(
             Number,
           ),
-        personal:
-          sql<number>`count(*) filter (where ${active} and ${juniorMemoryMemories.scope} = 'personal')`.mapWith(
+        private:
+          sql<number>`count(*) filter (where ${active} and ${juniorMemoryMemories.scope} = 'private')`.mapWith(
             Number,
           ),
       })
@@ -171,12 +171,12 @@ export async function buildMemoryOperationalReport(args: {
         value: formatCount(counts?.createdThirtyDays ?? 0),
       },
       {
-        label: "personal",
-        value: formatCount(counts?.personal ?? 0),
+        label: "private",
+        value: formatCount(counts?.private ?? 0),
       },
       {
-        label: "conversation",
-        value: formatCount(counts?.conversation ?? 0),
+        label: "public",
+        value: formatCount(counts?.public ?? 0),
       },
       {
         label: "embedding coverage",
@@ -208,15 +208,15 @@ export async function buildMemoryOperationalReport(args: {
           id: day.date,
           label: day.date,
           values: {
-            conversation: day.conversation,
-            personal: day.personal,
+            private: day.private,
+            public: day.public,
           },
         })),
         description: "Memories stored per day by scope",
         id: "memories-created",
         series: [
-          { key: "personal", label: "Personal" },
-          { key: "conversation", label: "Conversation" },
+          { key: "private", label: "Private" },
+          { key: "public", label: "Public" },
         ],
         timeRangeDays: [...WINDOWS],
         title: "Memories created",

package/src/plugin.ts

@@ -46,17 +46,23 @@ function memoryToolContext(ctx: {
   conversationId?: string;
   db: MemoryToolContext["db"];
   embedder?: MemoryToolContext["embedder"];
+  locationId?: string;
   actor?: MemoryToolContext["actor"];
   source: MemoryToolContext["source"];
+  users: MemoryToolContext["users"];
   userText?: string;
 }): MemoryToolContext {
   return {
     agent: ctx.agent,
-    ...(ctx.conversationId ? { conversationId: ctx.conversationId } : undefined),
+    ...(ctx.conversationId
+      ? { conversationId: ctx.conversationId }
+      : undefined),
     ...(ctx.actor ? { actor: ctx.actor } : undefined),
     db: ctx.db,
     ...(ctx.embedder ? { embedder: ctx.embedder } : undefined),
+    ...(ctx.locationId ? { locationId: ctx.locationId } : undefined),
     source: ctx.source,
+    users: ctx.users,
     ...(ctx.userText ? { userText: ctx.userText } : undefined),
   };
 }
@@ -66,9 +72,11 @@ function memoryCreateToolContext(ctx: {
   conversationId?: string;
   db: MemoryCreateToolContext["db"];
   embedder?: MemoryCreateToolContext["embedder"];
+  locationId?: string;
   actor?: MemoryCreateToolContext["actor"];
   source: MemoryCreateToolContext["source"];
   supersessionDecider: MemoryCreateToolContext["supersessionDecider"];
+  users: MemoryCreateToolContext["users"];
   userText?: string;
 }): MemoryCreateToolContext {
   return {
@@ -162,9 +170,13 @@ export function memoryPlugin(options: MemoryPluginOptions = {}) {
                 db: ctx.db as MemoryDb,
                 embedder: ctx.embedder,
                 events: ctx.events,
+                ...(ctx.locationId
+                  ? { locationId: ctx.locationId }
+                  : undefined),
                 log: ctx.log,
                 source: ctx.source,
                 text: ctx.text,
+                users: ctx.users,
               });
             },
           }

package/src/process-session.ts

@@ -4,7 +4,6 @@ import {
   type PluginRunContext,
   type PluginRunTranscriptEntry,
   type PluginTaskContext,
-  type Source,
 } from "@sentry/junior-plugin-api";
 import { z } from "zod";
 import {
@@ -54,23 +53,8 @@ const extractedMemoryCacheSchema = z.union([
     .transform((memories) => ({ memories })),
 ]);
 
-/** Where a passively extracted memory may be stored, or dropped when unproven. */
-type MemoryRouteTarget = "drop" | "personal" | "conversation";
-
-/**
- * V1 passive learning opts in by Source branch, then public vs private.
- * Public API is the same as public Slack: shared conversation evidence may
- * learn. Private sources stay out. Local remains available for QA.
- */
-function allowsPassiveMemoryExtraction(source: Source): boolean {
-  switch (source.platform) {
-    case "local":
-      return true;
-    case "web":
-    case "slack":
-      return source.visibility === "public";
-  }
-}
+/** Subject for a passively extracted memory, or drop when unproven. */
+type MemorySubjectTarget = "drop" | "user" | "conversation";
 
 function recordCapturedMemory(
   captured: ReturnType<typeof capturedMemory>[],
@@ -151,8 +135,8 @@ function citedEntries(
 function routeExtractedMemory(
   memory: ExtractedMemory,
   transcript: PluginRunTranscriptEntry[],
-  run: Pick<PluginRunContext, "actor" | "actors">,
-): MemoryRouteTarget {
+  run: Pick<PluginRunContext, "actor" | "actors" | "actorUserId">,
+): MemorySubjectTarget {
   const cited = citedEntries(memory.evidenceMessageIndices, transcript);
   if (!cited.valid) {
     return "drop";
@@ -160,6 +144,7 @@ function routeExtractedMemory(
   if (memory.kind === "preference") {
     // Only a run attributed to exactly one human run actor may store a preference.
     const exactlyOneHumanRunActor =
+      run.actorUserId !== undefined &&
       run.actor !== undefined &&
       run.actor.platform !== "system" &&
       run.actors.length === 1 &&
@@ -167,8 +152,8 @@ function routeExtractedMemory(
     if (!exactlyOneHumanRunActor) {
       return "drop";
     }
-    // Never downgrade an unproven first-person preference to conversation scope.
-    return cited.entries.every(isRunActorInstruction) ? "personal" : "drop";
+    // Never downgrade an unproven first-person preference to conversation subject.
+    return cited.entries.every(isRunActorInstruction) ? "user" : "drop";
   }
   return cited.entries.every(
     (entry) => isRunActorInstruction(entry) || isConversationEvidence(entry),
@@ -179,7 +164,7 @@ function routeExtractedMemory(
 
 function memoryIdempotencySuffix(
   memory: ExtractedMemory,
-  target: MemoryRouteTarget,
+  target: MemorySubjectTarget,
 ): string {
   return createHash("sha256")
     .update(target)
@@ -197,13 +182,15 @@ function passiveInput(
   sessionId: string,
   memory: ExtractedMemory,
   sourceKey: string,
-  target: MemoryRouteTarget,
+  target: MemorySubjectTarget,
 ): CreateMemoryInput {
   return {
     content: memory.content,
     idempotencyKey: `session:${sourceKey}:${sessionId}:${memoryIdempotencySuffix(memory, target)}`,
     kind: memory.kind,
-    ...(memory.expiresAtMs !== null ? { expiresAtMs: memory.expiresAtMs } : undefined),
+    ...(memory.expiresAtMs !== null
+      ? { expiresAtMs: memory.expiresAtMs }
+      : undefined),
   };
 }
 
@@ -228,15 +215,17 @@ async function getTaskExtraction(
 /**
  * Extract and store memories from a completed session plugin task.
  *
- * Memory owns post-session extraction and consumes only the bounded plugin task
- * projection. Explicit memory tools and private non-local sources remain hard
- * boundaries so background retries cannot reinterpret user-directed mutations
- * or private conversations.
+ * Memory owns learning after a run and reads only the plugin run data.
+ * Explicit memory tools stay separate so retries do not reinterpret user
+ * requests.
  */
 export async function processMemorySession(
   context: PluginTaskContext,
 ): Promise<void> {
   const run = await context.run.load();
+  if (run.source.platform === "local") {
+    return;
+  }
   // Memory tool turns already own memory management or recall; do not reinterpret
   // recalled memory output as fresh passive-learning evidence.
   if (
@@ -247,13 +236,8 @@ export async function processMemorySession(
   ) {
     return;
   }
-  // V1 passive learning is a Source-branch policy: local QA always, public
-  // Slack/API by visibility, private sources never.
-  if (!allowsPassiveMemoryExtraction(run.source)) {
-    return;
-  }
   const sourceKey = getSourceKey(run.source);
-  if (!sourceKey) {
+  if (!sourceKey || (run.source.visibility === "private" && !run.actorUserId)) {
     return;
   }
   const transcript = run.transcript
@@ -270,8 +254,10 @@ export async function processMemorySession(
 
   const runtimeContext = memoryRuntimeContextSchema.parse({
     conversationId: run.conversationId,
+    ...(run.locationId ? { locationId: run.locationId } : undefined),
     ...(run.actor ? { actor: run.actor } : undefined),
     source: run.source,
+    ...(run.actorUserId ? { userId: run.actorUserId } : undefined),
   });
   const agent = createMemoryAgent(context.model);
   const store = createMemoryStore(context.db as MemoryDb, runtimeContext, {

package/src/ranking.ts

@@ -9,7 +9,6 @@ export interface MemoryMatch {
     rank: number;
   };
   memory: MemoryRecord;
-  sourceKey: string;
   vector?: {
     rank: number;
   };
@@ -33,13 +32,6 @@ function matchScore(
   );
 }
 
-function currentChannel(
-  match: Pick<MemoryMatch, "sourceKey">,
-  channelPrefix: string | undefined,
-): boolean {
-  return channelPrefix ? match.sourceKey.startsWith(channelPrefix) : false;
-}
-
 function observedAgeRank(memory: MemoryRecord, nowMs: number): number {
   const ageMs = Math.max(0, nowMs - memory.observedAtMs);
   if (ageMs <= 7 * ONE_DAY_MS) {
@@ -64,7 +56,6 @@ function positiveWeight(value: number | undefined, fallback: number): number {
 export function rankMemoryMatches(
   matches: MemoryMatch[],
   options: {
-    channelPrefix?: string;
     /** Optional RRF weight for the lexical leg. Defaults to 1. */
     lexicalWeight?: number;
     nowMs: number;
@@ -83,9 +74,8 @@ 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.
+    // Keep the first rank from each search. The shared searches run first, so
+    // the smaller private searches cannot replace their ranks.
     byId.set(match.memory.id, {
       ...existing,
       ...(!existing.lexical && match.lexical
@@ -99,20 +89,13 @@ 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));
-    if (channelDelta !== 0) {
-      return channelDelta;
+    // Prefer private memory when RRF ties. Public and private searches can give
+    // the same rank to common words.
+    const privateDelta =
+      Number(right.memory.scope === "private") -
+      Number(left.memory.scope === "private");
+    if (privateDelta !== 0) {
+      return privateDelta;
     }
     return (
       observedAgeRank(right.memory, options.nowMs) -

package/src/recall.ts

@@ -2,9 +2,11 @@ import {
   definePromptContext,
   type UserPromptContribution,
   type Actor,
+  type Identity,
   type PluginConversationEvents,
   type PluginLogger,
   type Source,
+  type User,
 } from "@sentry/junior-plugin-api";
 import { z } from "zod";
 import type { MemoryAgent, MemoryRecallResult } from "./agent";
@@ -28,9 +30,13 @@ export interface MemoryRecallContext {
   embedder?: MemoryEmbeddingProvider;
   events?: PluginConversationEvents;
   log: PluginLogger;
+  locationId?: string;
   actor?: Actor;
   source: Source;
   text: string;
+  users: {
+    resolveActor(): Promise<{ identity: Identity; user?: User } | undefined>;
+  };
 }
 
 function trimContent(content: string, maxLength: number): string {
@@ -50,6 +56,7 @@ const recalledMemorySchema = z
     id: z.string().min(1),
     content: z.string().min(1).max(MAX_MEMORY_LINE_CHARS),
     observedAtMs: z.number().finite(),
+    // Stored version 1 uses the old scope labels. Prompt rendering ignores them.
     scope: z.enum(["personal", "conversation"]),
     kind: z.enum(["preference", "procedure", "knowledge"]),
   })
@@ -82,7 +89,7 @@ function selectPromptMemories(memories: MemoryRecord[]): RecalledMemory[] {
       id: memory.id,
       content,
       observedAtMs: memory.observedAtMs,
-      scope: memory.scope,
+      scope: memory.scope === "private" ? "personal" : "conversation",
       kind: memory.kind,
     });
     totalChars += line.length + 1;
@@ -138,12 +145,15 @@ export async function createMemoryPromptContributions(
   if (!context.text.trim()) {
     return undefined;
   }
+  const actorUser = (await context.users.resolveActor())?.user;
   const runtimeContext = memoryRuntimeContextSchema.parse({
     ...(context.conversationId
       ? { conversationId: context.conversationId }
       : undefined),
     ...(context.actor ? { actor: context.actor } : undefined),
+    ...(context.locationId ? { locationId: context.locationId } : undefined),
     source: context.source,
+    ...(actorUser ? { userId: actorUser.id } : undefined),
   });
   let embeddingCostUsd: number | undefined;
   const sourceEmbedder = context.embedder;