@sentry/junior-memory 0.180.0 → 0.181.1

package/src/scope.ts

@@ -1,176 +1,75 @@
-import { type Actor, type Identity, type Source } from "@sentry/junior-plugin-api";
 import type {
   MemoryRuntimeContext,
   MemoryScope,
   MemorySubjectType,
 } from "./types";
 
-/** Runtime-derived visibility scope used for memory authorization checks. */
+const PUBLIC_SCOPE_KEY = "public";
+
+/** Stored memory access rule. */
 export interface ResolvedMemoryScope {
   scope: MemoryScope;
   scopeKey: string;
 }
 
-/** Runtime-derived subject classification stored for filtering and rendering. */
+/** What a stored memory is about. */
 export interface ResolvedMemorySubject {
-  subjectKey?: string;
-  subjectType: MemorySubjectType;
-}
-
-function uniqueScopes(scopes: ResolvedMemoryScope[]): ResolvedMemoryScope[] {
-  return [
-    ...new Map(
-      scopes.map((scope) => [`${scope.scope}:${scope.scopeKey}`, scope]),
-    ).values(),
-  ];
-}
-
-/** Personal scope key for one verified provider identity, when one exists. */
-function personalScopeFromIdentity(
-  identity: Identity,
-): ResolvedMemoryScope | undefined {
-  if (identity.provider === "local") {
-    return {
-      scope: "personal",
-      scopeKey: `local:${identity.providerSubjectId}`,
-    };
-  }
-  // Dashboard/web actors persist as junior identities keyed by verified email.
-  if (identity.provider === "junior") {
-    return {
-      scope: "personal",
-      scopeKey: `junior:${identity.providerSubjectId}`,
-    };
-  }
-  if (identity.provider === "slack" && identity.providerTenantId) {
-    return {
-      scope: "personal",
-      scopeKey: `slack:${identity.providerTenantId}:${identity.providerSubjectId}`,
-    };
-  }
-  return undefined;
-}
-
-/** Derive viewer-visible memory scopes from canonical provider identities. */
-export function deriveViewerMemoryScopes(identities: Identity[]): {
-  privateScopes: ResolvedMemoryScope[];
-  publicScopes: ResolvedMemoryScope[];
-} {
-  const privateScopes = identities.flatMap((identity) => {
-    const scope = personalScopeFromIdentity(identity);
-    return scope ? [scope] : [];
-  });
-  const publicScopes = identities.flatMap((identity) =>
-    identity.provider === "slack" && identity.providerTenantId
-      ? [
-          {
-            scope: "conversation" as const,
-            scopeKey: `slack:${identity.providerTenantId}`,
-          },
-        ]
-      : [],
-  );
-  return {
-    privateScopes: uniqueScopes(privateScopes),
-    publicScopes: uniqueScopes(publicScopes),
-  };
+  subjectKey: string;
+  subjectType: Extract<MemorySubjectType, "user" | "conversation">;
 }
 
-/** Conversation-scoped key for the Source branch we actually have. */
-function sourceConversationKey(source: Source): string | undefined {
-  switch (source.platform) {
-    case "web":
-    case "local":
-      return source.conversationId;
-    case "slack": {
-      if (source.visibility === "public") {
-        return `slack:${source.teamId}`;
-      }
-      const threadKey = source.threadTs ?? source.messageTs;
-      if (!threadKey) {
-        return undefined;
-      }
-      return `slack:${source.teamId}:${source.channelId}:${threadKey}`;
-    }
-  }
-}
+/** Public memories are visible everywhere. */
+export const publicMemoryScope: ResolvedMemoryScope = {
+  scope: "public",
+  scopeKey: PUBLIC_SCOPE_KEY,
+};
 
-/** Personal scope key for the Actor branch we actually have. */
-function actorScopeKey(actor: Actor | undefined): string | undefined {
-  if (!actor) {
-    return undefined;
-  }
-  switch (actor.platform) {
-    case "system":
-      return undefined;
-    case "slack":
-      return `slack:${actor.teamId}:${actor.userId}`;
-    case "local":
-      return `local:${actor.userId}`;
-    case "web": {
-      // Match junior identity personal scopes used by the dashboard viewer.
-      const email = actor.email?.trim().toLowerCase();
-      return email ? `junior:${email}` : undefined;
-    }
-  }
+function privateMemoryScope(userId: string): ResolvedMemoryScope {
+  return { scope: "private", scopeKey: userId };
 }
 
-/** Derive the authority-bearing key for a requested memory scope. */
+/** Set memory access from the Source. */
 export function deriveMemoryScope(
   ctx: MemoryRuntimeContext,
-  scope: MemoryScope,
 ): ResolvedMemoryScope {
-  if (scope === "personal") {
-    const scopeKey = actorScopeKey(ctx.actor);
-    if (!scopeKey) {
-      throw new Error("Personal memory requires actor context.");
-    }
-    return { scope, scopeKey };
+  if (ctx.source.visibility === "public") {
+    return publicMemoryScope;
   }
-
-  const scopeKey = sourceConversationKey(ctx.source);
-  if (!scopeKey) {
-    throw new Error("Conversation memory requires conversation context.");
+  if (!ctx.userId) {
+    throw new Error("Private memory requires a User.");
   }
-  return { scope, scopeKey };
+  return privateMemoryScope(ctx.userId);
 }
 
-/** Derive the memory subject from the already-authorized write scope. */
+/** Set what a memory is about. Access is set separately. */
 export function deriveMemorySubject(
   ctx: MemoryRuntimeContext,
-  scope: ResolvedMemoryScope,
+  subjectType: Extract<MemorySubjectType, "user" | "conversation">,
 ): ResolvedMemorySubject {
-  if (scope.scope === "personal") {
-    const subjectKey = actorScopeKey(ctx.actor);
-    if (!subjectKey) {
-      throw new Error("User-subject memory requires actor context.");
+  if (subjectType === "user") {
+    if (!ctx.userId) {
+      throw new Error("User memory requires a User.");
     }
-    return { subjectType: "user", subjectKey };
+    return { subjectType, subjectKey: ctx.userId };
   }
-
-  const subjectKey = sourceConversationKey(ctx.source);
+  const subjectKey = ctx.conversationId;
   if (!subjectKey) {
     throw new Error(
       "Conversation-subject memory requires conversation context.",
     );
   }
-  return { subjectType: "conversation", subjectKey };
+  return {
+    subjectType,
+    subjectKey,
+  };
 }
 
-/** Return every visible scope for memory retrieval in the current context. */
+/** Return the memory scopes that the current User can access. */
 export function deriveVisibleMemoryScopes(
   ctx: MemoryRuntimeContext,
 ): ResolvedMemoryScope[] {
-  const scopes: ResolvedMemoryScope[] = [];
-  try {
-    scopes.push(deriveMemoryScope(ctx, "personal"));
-  } catch {
-    // Personal memory is optional when a runtime surface has no actor.
-  }
-  try {
-    scopes.push(deriveMemoryScope(ctx, "conversation"));
-  } catch {
-    // Conversation memory is optional for synthetic invocations.
+  if (!ctx.userId) {
+    return [publicMemoryScope];
   }
-  return scopes;
+  return [publicMemoryScope, privateMemoryScope(ctx.userId)];
 }

package/src/store.ts

@@ -25,6 +25,7 @@ import { cosineDistance } from "drizzle-orm/sql/functions";
 import type { PgDatabase } from "drizzle-orm/pg-core";
 import type { PgQueryResultHKT } from "drizzle-orm/pg-core/session";
 import { z } from "zod";
+import { getSourceKey } from "@sentry/junior-plugin-api";
 import * as memorySqlSchema from "./db/schema";
 import { juniorMemoryEmbeddings, juniorMemoryMemories } from "./db/schema";
 import { rankMemoryMatches, type MemoryMatch } from "./ranking";
@@ -36,8 +37,6 @@ import {
   MEMORY_KINDS,
   memoryRuntimeContextSchema,
   type MemoryRuntimeContext,
-  type MemoryScope,
-  type MemorySourcePlatform,
 } from "./types";
 import {
   deriveMemoryScope,
@@ -150,6 +149,7 @@ const memoryRowSchema = z
     expiresAtMs: optionalNumberSchema,
     id: z.string().min(1),
     idempotencyKey: optionalStringSchema,
+    locationId: optionalNonEmptyStringSchema,
     observedAtMs: z.coerce.number(),
     searchVector: z.string().optional(),
     scope: z.enum(MEMORY_SCOPES),
@@ -334,16 +334,14 @@ export interface MemoryStore {
   ): Promise<ArchiveExpiredMemoriesResult>;
   /** Archive a visible memory in the current runtime context. */
   archiveMemory(input: ArchiveMemoryInput): Promise<MemoryRecord>;
-  /** Store a personal memory for the current actor. */
+  /** Store a memory about the current User. The Source sets access. */
   createMemory(input: CreateMemoryInput): Promise<CreateMemoryResult>;
-  /** Store a conversation memory for the current source conversation. */
+  /** Store a memory about the current Conversation. The Source sets access. */
   createConversationMemory(
     input: CreateMemoryInput,
   ): Promise<CreateMemoryResult>;
   /** List active memories visible in the current runtime context. */
   listMemories(input: ListMemoriesInput): Promise<MemoryRecord[]>;
-  /** List active personal memories owned by the current actor. */
-  listPersonalMemories(input: ListMemoriesInput): Promise<MemoryRecord[]>;
   /**
    * Retrieve a broad relevance-ranked candidate window for automatic recall.
    * Prompt admission remains owned by the recall boundary.
@@ -384,50 +382,15 @@ function boundedLimit(value: number | undefined, fallback: number): number {
   return Math.min(200, Math.max(1, Math.floor(value)));
 }
 
-/** Map runtime Source platform onto the durable memory source platform. */
-function memorySourcePlatform(
-  source: MemoryRuntimeContext["source"],
-): MemorySourcePlatform {
-  switch (source.platform) {
-    case "slack":
-      return "slack";
-    case "local":
-      return "local";
-    case "web":
-      return "web";
-  }
-}
-
-/** Build the durable source attribution key from runtime-owned source fields. */
+/** Build the stored key for the Source. */
 function sourceKey(ctx: MemoryRuntimeContext): string {
-  switch (ctx.source.platform) {
-    case "web":
-    case "local":
-      return ctx.source.conversationId;
-    case "slack": {
-      const threadKey = ctx.source.threadTs ?? ctx.source.messageTs;
-      if (!threadKey) {
-        throw new Error(
-          "Memory source requires a Slack message or thread timestamp.",
-        );
-      }
-      return `slack:${ctx.source.teamId}:${ctx.source.channelId}:${threadKey}`;
-    }
+  const key = getSourceKey(ctx.source);
+  if (!key) {
+    throw new Error("Memory Source has no stable key.");
   }
+  return key;
 }
 
-function sourceChannelPrefix(ctx: MemoryRuntimeContext): string | undefined {
-  switch (ctx.source.platform) {
-    case "slack":
-      // TODO(v0.82.0): Replace Slack source-key prefix matching with typed source proximity metadata.
-      return `slack:${ctx.source.teamId}:${ctx.source.channelId}:`;
-    case "web":
-    case "local":
-      return undefined;
-  }
-}
-
-/** Parse one SQL row into the public memory record projection. */
 /** Parse one SQL row into the public memory projection. */
 export function parseMemoryRow(row: unknown): MemoryRecord {
   const parsed = memoryRowSchema.parse(row);
@@ -739,9 +702,7 @@ function activeScopedSubjectPredicate(args: {
     eq(juniorMemoryMemories.scopeKey, args.scope.scopeKey),
     eq(juniorMemoryMemories.kind, args.kind),
     eq(juniorMemoryMemories.subjectType, args.subject.subjectType),
-    args.subject.subjectKey === undefined
-      ? isNull(juniorMemoryMemories.subjectKey)
-      : eq(juniorMemoryMemories.subjectKey, args.subject.subjectKey),
+    eq(juniorMemoryMemories.subjectKey, args.subject.subjectKey),
     isNull(juniorMemoryMemories.archivedAtMs),
     isNull(juniorMemoryMemories.supersededAtMs),
     isNull(juniorMemoryMemories.supersededById),
@@ -806,11 +767,12 @@ async function rememberDuplicateIdempotency(args: {
         targetId: args.duplicate.id,
       }),
       idempotencyKey: args.idempotencyKey,
+      locationId: args.runtimeContext.locationId,
       observedAtMs: args.nowMs,
       scope: args.scope.scope,
       scopeKey: args.scope.scopeKey,
       sourceKey: sourceKey(args.runtimeContext),
-      sourcePlatform: memorySourcePlatform(args.runtimeContext.source),
+      sourcePlatform: args.runtimeContext.source.platform,
       subjectKey: args.subject.subjectKey,
       subjectType: args.subject.subjectType,
       supersededAtMs: args.nowMs,
@@ -1081,7 +1043,6 @@ async function searchVisibleLexicalMemories(args: {
   return rows.map((row, index) => ({
     lexical: { rank: ranks[index] },
     memory: parseMemoryRow(row.memory),
-    sourceKey: row.memory.sourceKey,
   }));
 }
 
@@ -1148,7 +1109,6 @@ async function searchVisibleVectorMemories(args: {
     return [
       {
         memory: parseMemoryRow(row.memory),
-        sourceKey: row.memory.sourceKey,
         vector: {
           rank: ranks[index],
         },
@@ -1208,13 +1168,13 @@ export function createMemoryStore(
   /** Persist a memory under the plugin-derived scope and subject. */
   async function createScopedMemory(
     rawInput: CreateMemoryInput,
-    scopeKind: MemoryScope,
+    subjectType: ResolvedMemorySubject["subjectType"],
   ): Promise<CreateMemoryResult> {
     const input = createMemoryInputSchema.parse(rawInput);
     const nowMs = getNowMs();
     const content = normalizeContent(input.content);
-    const scope = deriveMemoryScope(runtimeContext, scopeKind);
-    const subject = deriveMemorySubject(runtimeContext, scope);
+    const scope = deriveMemoryScope(runtimeContext);
+    const subject = deriveMemorySubject(runtimeContext, subjectType);
     if (content.length > MAX_MEMORY_CONTENT_CHARS) {
       throw new Error("Memory content exceeds the maximum length.");
     }
@@ -1280,7 +1240,7 @@ export function createMemoryStore(
     }
     let supersededIds: string[] = [];
     if (
-      scopeKind === "personal" &&
+      subjectType === "user" &&
       input.kind === "preference" &&
       supersessionDecider &&
       (input.expiresAtMs === undefined || input.expiresAtMs > nowMs)
@@ -1323,11 +1283,12 @@ export function createMemoryStore(
           expiresAtMs: input.expiresAtMs,
           id,
           idempotencyKey: input.idempotencyKey,
+          locationId: runtimeContext.locationId,
           observedAtMs: nowMs,
           scope: scope.scope,
           scopeKey: scope.scopeKey,
           sourceKey: sourceKey(runtimeContext),
-          sourcePlatform: memorySourcePlatform(runtimeContext.source),
+          sourcePlatform: runtimeContext.source.platform,
           subjectKey: subject.subjectKey,
           subjectType: subject.subjectType,
           kind: input.kind,
@@ -1419,10 +1380,8 @@ export function createMemoryStore(
    * 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.
+   * Automatic recall also searches private memory by itself. This keeps newer
+   * public memory with common words from hiding older private memory.
    */
   async function retrieveVisibleMemories(
     rawInput: SearchMemoriesInput,
@@ -1442,11 +1401,11 @@ 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 privateScopes = scopes.filter((scope) => scope.scope === "private");
+    // Search private memory by itself during recall so public results cannot
+    // fill both search windows.
+    const probePrivate =
+      vectorMaxDistance !== undefined && privateScopes.length > 0;
     const query = normalizeRetrievalQuery(input.query);
     let queryEmbedding: MemoryEmbedding | undefined;
     if (embedder && query) {
@@ -1483,31 +1442,29 @@ export function createMemoryStore(
         ...lexicalArgs,
         scopes,
       }),
-      queryEmbedding && probePersonal
+      queryEmbedding && probePrivate
         ? searchVisibleVectorMemories({
             db,
             embedding: queryEmbedding,
             limit: candidateLimit,
             maxDistance: vectorMaxDistance,
             nowMs,
-            scopes: personalScopes,
+            scopes: privateScopes,
           })
         : emptyMatches,
-      probePersonal
+      probePrivate
         ? searchVisibleLexicalMemories({
             ...lexicalArgs,
-            scopes: personalScopes,
+            scopes: privateScopes,
           })
         : emptyMatches,
     ]);
-    const channelPrefix = sourceChannelPrefix(runtimeContext);
     return rankMemoryMatches(matches.flat(), {
       nowMs,
       // Slight lexical preference protects exact ids/names/timezones on ties.
       ...(vectorMaxDistance === undefined
         ? undefined
         : { lexicalWeight: 1, vectorWeight: 0.85 }),
-      ...(channelPrefix ? { channelPrefix } : undefined),
     })
       .slice(0, limit)
       .map(({ memory }) => memory);
@@ -1519,7 +1476,7 @@ export function createMemoryStore(
     },
 
     async createMemory(input) {
-      return await createScopedMemory(input, "personal");
+      return await createScopedMemory(input, "user");
     },
 
     async createConversationMemory(input) {
@@ -1543,23 +1500,6 @@ export function createMemoryStore(
       });
     },
 
-    async listPersonalMemories(input) {
-      input = listMemoriesInputSchema.parse(input);
-      const nowMs = getNowMs();
-      const scopes = [deriveMemoryScope(runtimeContext, "personal")];
-      await archiveExpiredMemoryBatch({
-        db,
-        nowMs,
-        scopes,
-      });
-      return await listVisibleMemories({
-        db,
-        limit: input.limit,
-        nowMs,
-        scopes,
-      });
-    },
-
     async recallMemories(input) {
       return await retrieveVisibleMemories(input, RECALL_MAX_VECTOR_DISTANCE);
     },
@@ -1571,7 +1511,10 @@ export function createMemoryStore(
     async archiveMemory(input) {
       input = archiveMemoryInputSchema.parse(input);
       const nowMs = getNowMs();
-      const scopes = deriveVisibleMemoryScopes(runtimeContext);
+      // Public memory is shared and has no single user owner.
+      const scopes = deriveVisibleMemoryScopes(runtimeContext).filter(
+        (scope) => scope.scope === "private",
+      );
       const predicate = activeVisiblePredicate({ nowMs, scopes });
       const idPrefix = input.id.trim();
       if (!idPrefix) {

package/src/tools.ts

@@ -7,6 +7,8 @@ import {
   type PluginToolOutput,
   type Source,
   type Actor,
+  type Identity,
+  type User,
   pluginToolOutputSchema,
 } from "@sentry/junior-plugin-api";
 import { z } from "zod";
@@ -43,8 +45,8 @@ const KNOWN_TOOL_INPUT_ERROR_MESSAGES = new Set([
   "Memory id is required.",
   "Memory was not found in the current context.",
   "Memory id prefix is ambiguous.",
-  "Personal memory requires actor context.",
-  "User-subject memory requires actor context.",
+  "Private memory requires a User.",
+  "User memory requires a User.",
 ]);
 
 /** Runtime-owned context used to bind memory tools to visible scopes. */
@@ -53,8 +55,12 @@ export interface MemoryToolContext {
   conversationId?: string;
   db: MemoryDb;
   embedder?: MemoryEmbeddingProvider;
+  locationId?: string;
   actor?: Actor;
   source: Source;
+  users: {
+    resolveActor(): Promise<{ identity: Identity; user?: User } | undefined>;
+  };
   userText?: string;
 }
 
@@ -79,23 +85,27 @@ function asToolInputError(error: unknown): never {
   throw error;
 }
 
-function memoryRuntimeContext(
+async function memoryRuntimeContext(
   context: MemoryToolContext,
-): MemoryRuntimeContext {
+): Promise<MemoryRuntimeContext> {
+  const actorUser = (await context.users.resolveActor())?.user;
   return 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),
   });
 }
 
 function memoryStore(
   context: MemoryToolContext,
+  runtimeContext: MemoryRuntimeContext,
   options: { supersessionDecider?: MemorySupersessionDecider } = {},
 ) {
-  return createMemoryStore(context.db, memoryRuntimeContext(context), {
+  return createMemoryStore(context.db, runtimeContext, {
     embedder: context.embedder,
     ...(options.supersessionDecider
       ? { supersessionDecider: options.supersessionDecider }
@@ -237,7 +247,7 @@ const createMemoryInputSchema = z
       .min(1)
       .max(MAX_TOOL_CONTENT_CHARS)
       .describe(
-        "Self-contained public/shareable memory candidate. Include the subject in natural language when it matters; do not rely on surrounding chat context.",
+        "Self-contained memory candidate. Include the subject in natural language when it matters; do not rely on surrounding chat context.",
       ),
     expires_at: z
       .string()
@@ -400,7 +410,7 @@ export function createMemoryCreateTool(context: MemoryCreateToolContext) {
       readOnlyHint: false,
     },
     description:
-      "Explicit memory-write tool. Use only when the latest user message directly asks Junior to remember, store, save, or forget-and-replace a public/shareable fact. Do not use for ordinary statements like 'I prefer X', 'I use Y', or 'X goes before Y' unless the user also asks you to remember/store/save it; passive memory learning handles those after the visible reply. Pass one self-contained natural-language candidate preserving the user's explicit memory intent. Do not ask the user to rephrase ordinary first-person facts, and do not rewrite them into display-name or third-person wording. Do not include secrets, private personal details, medical/legal/financial/sensitive facts, or another person's personal preference, opinion, habit, identity, relationship, workflow, or private life. Runtime context derives actor, scope, source, and subject ids; the memory agent decides canonical stored content and memory kind, then the plugin derives storage target from kind.",
+      "Explicit memory-write tool. Use only when the latest user message directly asks Junior to remember, store, save, or forget-and-replace a fact. Do not use for ordinary statements like 'I prefer X', 'I use Y', or 'X goes before Y' unless the user also asks you to remember/store/save it; passive memory learning handles those after the visible reply. Pass one self-contained natural-language candidate preserving the user's explicit memory intent. Do not ask the user to rephrase ordinary first-person facts, and do not rewrite them into display-name or third-person wording. Do not include secrets, private personal details, medical/legal/financial/sensitive facts, or another person's personal preference, opinion, habit, identity, relationship, workflow, or private life. Junior sets access, Location, Source, and subject. The memory agent rewrites the content and sets the memory kind.",
     executionMode: "sequential",
     inputSchema: createMemoryInputSchema,
     outputSchema: memoryCreateOutputSchema,
@@ -408,8 +418,8 @@ export function createMemoryCreateTool(context: MemoryCreateToolContext) {
       const parsedInput = parseMemoryToolInput(createMemoryInputSchema, input);
       const toolCallId = requireToolCallId(options.toolCallId);
       const requestedExpiresAtMs = parseExpiresAt(parsedInput.expires_at);
-      const runtimeContext = memoryRuntimeContext(context);
-      const store = memoryStore(context, {
+      const runtimeContext = await memoryRuntimeContext(context);
+      const store = memoryStore(context, runtimeContext, {
         supersessionDecider: context.supersessionDecider,
       });
       const review = await (async () => {
@@ -492,15 +502,16 @@ export function createMemoryRemoveTool(context: MemoryToolContext) {
       readOnlyHint: false,
     },
     description:
-      "Forget one memory visible in the active context. Use only ids or short id prefixes returned by listMemories or searchMemories. Never remove memories by hidden actor, Slack, scope, or subject identifiers.",
+      "Forget one private memory owned by the current User. Public memories are read-only. Use only ids or short id prefixes returned by listMemories or searchMemories. Never remove memories by hidden Actor, provider, scope, or subject ids.",
     executionMode: "sequential",
     inputSchema: removeMemoryInputSchema,
     outputSchema: memorySingleOutputSchema,
     execute: async (input) => {
       const parsedInput = parseMemoryToolInput(removeMemoryInputSchema, input);
+      const runtimeContext = await memoryRuntimeContext(context);
       const memory = await (async () => {
         try {
-          return await memoryStore(context).archiveMemory({
+          return await memoryStore(context, runtimeContext).archiveMemory({
             id: parsedInput.id,
             reason: "tool_removed",
           });
@@ -530,7 +541,8 @@ export function createMemoryListTool(context: MemoryToolContext) {
     outputSchema: memoryManyOutputSchema,
     execute: async (input) => {
       const parsedInput = parseMemoryToolInput(listMemoriesInputSchema, input);
-      const memories = await memoryStore(context).listMemories({
+      const runtimeContext = await memoryRuntimeContext(context);
+      const memories = await memoryStore(context, runtimeContext).listMemories({
         limit: boundedLimit(parsedInput.limit, DEFAULT_RESULT_LIMIT),
       });
       return memoryToolResult("listMemories", {
@@ -544,7 +556,7 @@ export function createMemoryListTool(context: MemoryToolContext) {
 export function createMemorySearchTool(context: MemoryToolContext) {
   return definePluginTool({
     description:
-      "Search active memories visible in the current context. Use when the model needs targeted memory recall. The tool searches only the current actor and active conversation scopes.",
+      "Search active memories visible in the current context. Use when the model needs targeted memory recall. Public memories are visible everywhere. Private memories belong to the current User.",
     annotations: {
       destructiveHint: false,
       idempotentHint: true,
@@ -558,7 +570,11 @@ export function createMemorySearchTool(context: MemoryToolContext) {
         searchMemoriesInputSchema,
         input,
       );
-      const memories = await memoryStore(context).searchMemories({
+      const runtimeContext = await memoryRuntimeContext(context);
+      const memories = await memoryStore(
+        context,
+        runtimeContext,
+      ).searchMemories({
         query: parsedInput.query,
         limit: boundedLimit(parsedInput.limit, DEFAULT_SEARCH_LIMIT),
       });

package/src/types.ts

@@ -3,7 +3,7 @@ import { z } from "zod";
 
 export const MEMORY_KINDS = ["preference", "procedure", "knowledge"] as const;
 
-export const MEMORY_SCOPES = ["personal", "conversation"] as const;
+export const MEMORY_SCOPES = ["private", "public"] as const;
 export const MEMORY_SUBJECT_TYPES = [
   "user",
   "conversation",
@@ -22,12 +22,15 @@ export type MemoryEmbeddingMetric = (typeof MEMORY_EMBEDDING_METRICS)[number];
 
 const nonEmptyStringSchema = z.string().min(1);
 
-/** Runtime-owned memory invocation fields used for scope and source authority. */
+/** Host data used to set memory access, subject, and source. */
 export const memoryRuntimeContextSchema = z
   .object({
     conversationId: nonEmptyStringSchema.optional(),
+    locationId: nonEmptyStringSchema.optional(),
     actor: actorSchema.optional(),
     source: sourceSchema,
+    /** User linked to the active Actor. */
+    userId: nonEmptyStringSchema.optional(),
   })
   .strict();