@sentry/junior-memory 0.180.0 → 0.181.1

package/dist/index.js

@@ -25,6 +25,7 @@ import {
 } from "drizzle-orm";
 import { cosineDistance } from "drizzle-orm/sql/functions";
 import { z as z2 } from "zod";
+import { getSourceKey } from "@sentry/junior-plugin-api";
 
 // src/db/schema.ts
 import { sql } from "drizzle-orm";
@@ -44,7 +45,7 @@ import {
 import { actorSchema, sourceSchema } from "@sentry/junior-plugin-api";
 import { z } from "zod";
 var MEMORY_KINDS = ["preference", "procedure", "knowledge"];
-var MEMORY_SCOPES = ["personal", "conversation"];
+var MEMORY_SCOPES = ["private", "public"];
 var MEMORY_SUBJECT_TYPES = [
   "user",
   "conversation",
@@ -56,8 +57,11 @@ var MEMORY_EMBEDDING_DIMENSIONS = 1536;
 var nonEmptyStringSchema = z.string().min(1);
 var memoryRuntimeContextSchema = z.object({
   conversationId: nonEmptyStringSchema.optional(),
+  locationId: nonEmptyStringSchema.optional(),
   actor: actorSchema.optional(),
-  source: sourceSchema
+  source: sourceSchema,
+  /** User linked to the active Actor. */
+  userId: nonEmptyStringSchema.optional()
 }).strict();
 
 // src/db/schema.ts
@@ -83,6 +87,8 @@ var juniorMemoryMemories = pgTable(
       enum: MEMORY_SOURCE_PLATFORMS
     }).notNull(),
     sourceKey: text("source_key").notNull(),
+    /** Location where Junior learned the memory, when known. */
+    locationId: text("location_id"),
     idempotencyKey: text("idempotency_key"),
     observedAtMs: bigint("observed_at_ms", { mode: "number" }).notNull(),
     createdAtMs: bigint("created_at_ms", { mode: "number" }).notNull(),
@@ -107,7 +113,7 @@ var juniorMemoryMemories = pgTable(
     ),
     check(
       "junior_memory_memories_scope_check",
-      sql`${table.scope} IN ('personal', 'conversation')`
+      sql`${table.scope} IN ('private', 'public')`
     ),
     check(
       "junior_memory_memories_kind_check",
@@ -176,9 +182,6 @@ function reciprocalRank(rank, weight) {
 function matchScore(match, weights) {
   return (match.vector ? reciprocalRank(match.vector.rank, weights.vectorWeight) : 0) + (match.lexical ? reciprocalRank(match.lexical.rank, weights.lexicalWeight) : 0);
 }
-function currentChannel(match, channelPrefix) {
-  return channelPrefix ? match.sourceKey.startsWith(channelPrefix) : false;
-}
 function observedAgeRank(memory, nowMs) {
   const ageMs = Math.max(0, nowMs - memory.observedAtMs);
   if (ageMs <= 7 * ONE_DAY_MS) {
@@ -218,140 +221,55 @@ 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;
+    const privateDelta = Number(right.memory.scope === "private") - Number(left.memory.scope === "private");
+    if (privateDelta !== 0) {
+      return privateDelta;
     }
     return observedAgeRank(right.memory, options.nowMs) - observedAgeRank(left.memory, options.nowMs) || right.memory.observedAtMs - left.memory.observedAtMs || left.memory.id.localeCompare(right.memory.id);
   });
 }
 
 // src/scope.ts
-function uniqueScopes(scopes) {
-  return [
-    ...new Map(
-      scopes.map((scope) => [`${scope.scope}:${scope.scopeKey}`, scope])
-    ).values()
-  ];
-}
-function personalScopeFromIdentity(identity) {
-  if (identity.provider === "local") {
-    return {
-      scope: "personal",
-      scopeKey: `local:${identity.providerSubjectId}`
-    };
-  }
-  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 void 0;
-}
-function deriveViewerMemoryScopes(identities) {
-  const privateScopes = identities.flatMap((identity) => {
-    const scope = personalScopeFromIdentity(identity);
-    return scope ? [scope] : [];
-  });
-  const publicScopes = identities.flatMap(
-    (identity) => identity.provider === "slack" && identity.providerTenantId ? [
-      {
-        scope: "conversation",
-        scopeKey: `slack:${identity.providerTenantId}`
-      }
-    ] : []
-  );
-  return {
-    privateScopes: uniqueScopes(privateScopes),
-    publicScopes: uniqueScopes(publicScopes)
-  };
-}
-function sourceConversationKey(source) {
-  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 void 0;
-      }
-      return `slack:${source.teamId}:${source.channelId}:${threadKey}`;
-    }
-  }
-}
-function actorScopeKey(actor) {
-  if (!actor) {
-    return void 0;
-  }
-  switch (actor.platform) {
-    case "system":
-      return void 0;
-    case "slack":
-      return `slack:${actor.teamId}:${actor.userId}`;
-    case "local":
-      return `local:${actor.userId}`;
-    case "web": {
-      const email = actor.email?.trim().toLowerCase();
-      return email ? `junior:${email}` : void 0;
-    }
-  }
+var PUBLIC_SCOPE_KEY = "public";
+var publicMemoryScope = {
+  scope: "public",
+  scopeKey: PUBLIC_SCOPE_KEY
+};
+function privateMemoryScope(userId) {
+  return { scope: "private", scopeKey: userId };
 }
-function deriveMemoryScope(ctx, scope) {
-  if (scope === "personal") {
-    const scopeKey2 = actorScopeKey(ctx.actor);
-    if (!scopeKey2) {
-      throw new Error("Personal memory requires actor context.");
-    }
-    return { scope, scopeKey: scopeKey2 };
+function deriveMemoryScope(ctx) {
+  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);
 }
-function deriveMemorySubject(ctx, scope) {
-  if (scope.scope === "personal") {
-    const subjectKey2 = actorScopeKey(ctx.actor);
-    if (!subjectKey2) {
-      throw new Error("User-subject memory requires actor context.");
+function deriveMemorySubject(ctx, subjectType) {
+  if (subjectType === "user") {
+    if (!ctx.userId) {
+      throw new Error("User memory requires a User.");
     }
-    return { subjectType: "user", subjectKey: subjectKey2 };
+    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
+  };
 }
 function deriveVisibleMemoryScopes(ctx) {
-  const scopes = [];
-  try {
-    scopes.push(deriveMemoryScope(ctx, "personal"));
-  } catch {
-  }
-  try {
-    scopes.push(deriveMemoryScope(ctx, "conversation"));
-  } catch {
+  if (!ctx.userId) {
+    return [publicMemoryScope];
   }
-  return scopes;
+  return [publicMemoryScope, privateMemoryScope(ctx.userId)];
 }
 
 // src/store.ts
@@ -418,6 +336,7 @@ var memoryRowSchema = z2.object({
   expiresAtMs: optionalNumberSchema,
   id: z2.string().min(1),
   idempotencyKey: optionalStringSchema,
+  locationId: optionalNonEmptyStringSchema,
   observedAtMs: z2.coerce.number(),
   searchVector: z2.string().optional(),
   scope: z2.enum(MEMORY_SCOPES),
@@ -515,40 +434,12 @@ function boundedLimit(value, fallback) {
   }
   return Math.min(200, Math.max(1, Math.floor(value)));
 }
-function memorySourcePlatform(source) {
-  switch (source.platform) {
-    case "slack":
-      return "slack";
-    case "local":
-      return "local";
-    case "web":
-      return "web";
-  }
-}
 function sourceKey(ctx) {
-  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}`;
-    }
-  }
-}
-function sourceChannelPrefix(ctx) {
-  switch (ctx.source.platform) {
-    case "slack":
-      return `slack:${ctx.source.teamId}:${ctx.source.channelId}:`;
-    case "web":
-    case "local":
-      return void 0;
+  const key = getSourceKey(ctx.source);
+  if (!key) {
+    throw new Error("Memory Source has no stable key.");
   }
+  return key;
 }
 function parseMemoryRow(row) {
   const parsed = memoryRowSchema.parse(row);
@@ -581,12 +472,12 @@ function visibleScopePredicate(scopes) {
   );
 }
 function activeVisiblePredicate(args) {
-  const scopePredicate2 = visibleScopePredicate(args.scopes);
-  if (!scopePredicate2) {
+  const scopePredicate = visibleScopePredicate(args.scopes);
+  if (!scopePredicate) {
     return void 0;
   }
   return and(
-    scopePredicate2,
+    scopePredicate,
     isNull(juniorMemoryMemories.archivedAtMs),
     isNull(juniorMemoryMemories.supersededAtMs),
     isNull(juniorMemoryMemories.supersededById),
@@ -656,12 +547,12 @@ async function findByIdempotencyKey(args) {
   return void 0;
 }
 async function archiveExpiredMemoryBatch(args) {
-  const scopePredicate2 = visibleScopePredicate(args.scopes);
-  if (!scopePredicate2) {
+  const scopePredicate = visibleScopePredicate(args.scopes);
+  if (!scopePredicate) {
     return { archivedCount: 0 };
   }
   const predicates = [
-    scopePredicate2,
+    scopePredicate,
     isNull(juniorMemoryMemories.archivedAtMs),
     isNull(juniorMemoryMemories.supersededAtMs),
     isNull(juniorMemoryMemories.supersededById),
@@ -769,7 +660,7 @@ function activeScopedSubjectPredicate(args) {
     eq(juniorMemoryMemories.scopeKey, args.scope.scopeKey),
     eq(juniorMemoryMemories.kind, args.kind),
     eq(juniorMemoryMemories.subjectType, args.subject.subjectType),
-    args.subject.subjectKey === void 0 ? isNull(juniorMemoryMemories.subjectKey) : eq(juniorMemoryMemories.subjectKey, args.subject.subjectKey),
+    eq(juniorMemoryMemories.subjectKey, args.subject.subjectKey),
     isNull(juniorMemoryMemories.archivedAtMs),
     isNull(juniorMemoryMemories.supersededAtMs),
     isNull(juniorMemoryMemories.supersededById),
@@ -809,11 +700,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,
@@ -998,8 +890,7 @@ async function searchVisibleLexicalMemories(args) {
   const ranks = denseRanks(rows, (row) => Number(row.textRank));
   return rows.map((row, index2) => ({
     lexical: { rank: ranks[index2] },
-    memory: parseMemoryRow(row.memory),
-    sourceKey: row.memory.sourceKey
+    memory: parseMemoryRow(row.memory)
   }));
 }
 async function searchVisibleVectorMemories(args) {
@@ -1043,7 +934,6 @@ async function searchVisibleVectorMemories(args) {
     return [
       {
         memory: parseMemoryRow(row.memory),
-        sourceKey: row.memory.sourceKey,
         vector: {
           rank: ranks[index2]
         }
@@ -1081,12 +971,12 @@ function createMemoryStore(db, context, options = {}) {
     });
     return { created: false, memory: args.duplicate };
   }
-  async function createScopedMemory(rawInput, scopeKind) {
+  async function createScopedMemory(rawInput, subjectType) {
     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.");
     }
@@ -1147,7 +1037,7 @@ function createMemoryStore(db, context, options = {}) {
       }
     }
     let supersededIds = [];
-    if (scopeKind === "personal" && input.kind === "preference" && supersessionDecider && (input.expiresAtMs === void 0 || input.expiresAtMs > nowMs)) {
+    if (subjectType === "user" && input.kind === "preference" && supersessionDecider && (input.expiresAtMs === void 0 || input.expiresAtMs > nowMs)) {
       const preferenceCandidates = await listPreferenceAdjudicationCandidates({
         db,
         ...candidateEmbedding ? { embedding: candidateEmbedding } : void 0,
@@ -1183,11 +1073,12 @@ function createMemoryStore(db, context, options = {}) {
         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
@@ -1269,8 +1160,8 @@ 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 personalScopes = scopes.filter((scope) => scope.scope === "personal");
-    const probePersonal = vectorMaxDistance !== void 0 && personalScopes.length > 0;
+    const privateScopes = scopes.filter((scope) => scope.scope === "private");
+    const probePrivate = vectorMaxDistance !== void 0 && privateScopes.length > 0;
     const query = normalizeRetrievalQuery(input.query);
     let queryEmbedding;
     if (embedder && query) {
@@ -1300,25 +1191,23 @@ function createMemoryStore(db, context, options = {}) {
         ...lexicalArgs,
         scopes
       }),
-      queryEmbedding && probePersonal ? searchVisibleVectorMemories({
+      queryEmbedding && probePrivate ? searchVisibleVectorMemories({
         db,
         embedding: queryEmbedding,
         limit: candidateLimit,
         maxDistance: vectorMaxDistance,
         nowMs,
-        scopes: personalScopes
+        scopes: privateScopes
       }) : emptyMatches,
-      probePersonal ? searchVisibleLexicalMemories({
+      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 === void 0 ? void 0 : { lexicalWeight: 1, vectorWeight: 0.85 },
-      ...channelPrefix ? { channelPrefix } : void 0
+      ...vectorMaxDistance === void 0 ? void 0 : { lexicalWeight: 1, vectorWeight: 0.85 }
     }).slice(0, limit).map(({ memory }) => memory);
   }
   return {
@@ -1326,7 +1215,7 @@ function createMemoryStore(db, context, options = {}) {
       return await archiveExpiredVisibleMemories(input, getNowMs());
     },
     async createMemory(input) {
-      return await createScopedMemory(input, "personal");
+      return await createScopedMemory(input, "user");
     },
     async createConversationMemory(input) {
       return await createScopedMemory(input, "conversation");
@@ -1347,22 +1236,6 @@ function createMemoryStore(db, context, options = {}) {
         scopes
       });
     },
-    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);
     },
@@ -1372,7 +1245,9 @@ function createMemoryStore(db, context, options = {}) {
     async archiveMemory(input) {
       input = archiveMemoryInputSchema.parse(input);
       const nowMs = getNowMs();
-      const scopes = deriveVisibleMemoryScopes(runtimeContext);
+      const scopes = deriveVisibleMemoryScopes(runtimeContext).filter(
+        (scope) => scope.scope === "private"
+      );
       const predicate = activeVisiblePredicate({ nowMs, scopes });
       const idPrefix = input.id.trim();
       if (!idPrefix) {
@@ -1517,13 +1392,13 @@ var extractedMemoryResultSchema = z3.object({
 }).strict();
 var extractMemoriesResponseSchema = z3.object({
   memories: z3.array(extractedMemorySchema).max(5).describe(
-    "Accepted public/shareable durable memories from the completed run. Return one object per distinct source assertion and classify it with kind."
+    "Accepted durable memories from the completed run. Return one object per distinct source assertion and classify it with kind."
   )
 }).strict();
 var MEMORY_REVIEW_SYSTEM = [
   "You are Junior's memory review agent.",
   "Review one memory candidate and return one structured review decision.",
-  "Store only public/shareable, self-contained facts that are useful beyond this turn.",
+  "Store only self-contained facts that are useful beyond this turn and safe for the current Source.",
   "Reject secrets, credentials, private or sensitive personal details, gossip, speculative claims about other people, assistant/system implementation details, vague references, and low-durability chatter.",
   "Use the runtime context only for authority and scope; do not accept model-provided actor ids, scope ids, aliases, or arbitrary subjects."
 ].join("\n");
@@ -1532,7 +1407,7 @@ var MEMORY_EXTRACTION_SYSTEM = [
   "Use the completed run transcript as source evidence, including user-authored messages and tool results.",
   "Assistant text is context for interpreting the run, not independent evidence for new facts.",
   "Reject secrets, credentials, private or sensitive personal details, gossip, speculative claims about other people, assistant/system implementation details, vague references, and low-durability chatter.",
-  "If no public, durable, self-contained memory remains after rewriting, return an empty memories array."
+  "If no durable, self-contained memory remains after rewriting, return an empty memories array."
 ].join("\n");
 var MEMORY_RECALL_SYSTEM = [
   "You are Junior's memory recall relevance agent.",
@@ -1650,7 +1525,7 @@ function reviewPrompt(request) {
     "</candidate>",
     "",
     "<rules>",
-    "- Return store only when the candidate is public/shareable, durable, and self-contained.",
+    "- Return store only when the candidate is durable, self-contained, and safe for the current Source.",
     "- First classify the memory kind: preference, procedure, or knowledge.",
     "- Use kind=preference only for first-person facts authored by the current actor about their own preference, opinion, habit, identity, or workflow.",
     "- Reject named third-person personal facts such as another person's preference, opinion, habit, identity, relationship, or workflow. Do not assume a named person is the current actor.",
@@ -1889,49 +1764,85 @@ function parseCreateMemoryRequest(request) {
 }
 
 // src/api.ts
-import { z as z6 } from "zod";
+import { z as z5 } from "zod";
 import {
   pluginApiRouteRequestContextSchema
 } from "@sentry/junior-plugin-api";
 
-// src/personal.ts
-import { z as z5 } from "zod";
-
-// src/personal-store.ts
-import { and as and2, asc as asc2, desc as desc2, eq as eq2, gt as gt2, ilike, like as like2, lt, or as or2, sql as sql3 } from "drizzle-orm";
+// src/viewer.ts
+import {
+  and as and2,
+  asc as asc2,
+  desc as desc2,
+  eq as eq2,
+  gt as gt2,
+  ilike,
+  isNull as isNull2,
+  like as like2,
+  lt,
+  or as or2,
+  sql as sql3
+} from "drizzle-orm";
 import { z as z4 } from "zod";
+var DAY_MS = 24 * 60 * 60 * 1e3;
 var nonEmptyStringSchema3 = z4.string().min(1);
 var memoryVisibilitySchema = z4.enum(["private", "public"]);
-var personalMemoryCursorSchema = z4.object({
+var cursorSchema = z4.object({
   createdAtMs: z4.number().finite(),
-  id: nonEmptyStringSchema3
+  id: nonEmptyStringSchema3,
+  kind: z4.enum(MEMORY_KINDS).optional(),
+  origin: z4.enum(["automatic", "explicit"]).optional(),
+  query: z4.string().max(200).optional(),
+  version: z4.literal(1),
+  visibility: memoryVisibilitySchema.optional()
 }).strict();
-var personalMemoryPageInputSchema = z4.object({
-  cursor: personalMemoryCursorSchema.optional(),
+var pageInputSchema = z4.object({
+  cursor: z4.string().min(1).max(1e3).optional(),
   kind: z4.enum(MEMORY_KINDS).optional(),
   limit: z4.number().int().min(1).max(50),
   origin: z4.enum(["automatic", "explicit"]).optional(),
   query: z4.string().max(200).optional(),
   visibility: memoryVisibilitySchema.optional()
 }).strict();
-var personalMemoryTimelineInputSchema = z4.object({
-  days: z4.number().int().min(1).max(365)
-}).strict();
-var DAY_MS = 24 * 60 * 60 * 1e3;
-var PersonalMemoryNotFoundError = class extends Error {
+var timelineDaysSchema = z4.number().int().min(1).max(365);
+var InvalidMemoryCursorError = class extends Error {
+  constructor() {
+    super("Memory cursor is invalid.");
+    this.name = "InvalidMemoryCursorError";
+  }
+};
+var MemoryNotFoundError = class extends Error {
   constructor() {
-    super("Memory was not found for the authenticated viewer.");
-    this.name = "PersonalMemoryNotFoundError";
+    super("Memory was not found for this user.");
+    this.name = "MemoryNotFoundError";
   }
 };
-function scopePredicate(scopes) {
-  if (scopes.length === 0) return void 0;
-  return or2(
-    ...scopes.map(
-      (scope) => and2(
-        eq2(juniorMemoryMemories.scope, scope.scope),
-        eq2(juniorMemoryMemories.scopeKey, scope.scopeKey)
-      )
+function publicScopePredicate() {
+  return and2(
+    eq2(juniorMemoryMemories.scope, publicMemoryScope.scope),
+    eq2(juniorMemoryMemories.scopeKey, publicMemoryScope.scopeKey)
+  );
+}
+function privateScopePredicate(userId) {
+  return and2(
+    eq2(juniorMemoryMemories.scope, "private"),
+    eq2(juniorMemoryMemories.scopeKey, userId)
+  );
+}
+function visibleScopePredicate2(userId, visibility) {
+  if (visibility === "public") return publicScopePredicate();
+  if (visibility === "private") return privateScopePredicate(userId);
+  return or2(publicScopePredicate(), privateScopePredicate(userId));
+}
+function activeMemoryPredicate(userId, nowMs, visibility) {
+  return and2(
+    visibleScopePredicate2(userId, visibility),
+    isNull2(juniorMemoryMemories.archivedAtMs),
+    isNull2(juniorMemoryMemories.supersededAtMs),
+    isNull2(juniorMemoryMemories.supersededById),
+    or2(
+      isNull2(juniorMemoryMemories.expiresAtMs),
+      gt2(juniorMemoryMemories.expiresAtMs, nowMs)
     )
   );
 }
@@ -1950,233 +1861,30 @@ function memoryOrigin(idempotencyKey) {
   if (idempotencyKey?.startsWith("tool:")) return "explicit";
   return "other";
 }
-function memoryVisibility(scope) {
-  return scope === "personal" ? "private" : "public";
-}
-function personalMemoryRecord(row) {
+function toMemoryView(row) {
   const memory = parseMemoryRow(row);
   return {
     ...memory,
     origin: memoryOrigin(row.idempotencyKey),
     sourcePlatform: row.sourcePlatform,
-    visibility: memoryVisibility(memory.scope)
+    visibility: memory.scope
   };
 }
-function emptyStats() {
+function cursorFilters(input) {
   return {
-    active: 0,
-    automatic: 0,
-    createdThirtyDays: 0,
-    embedded: 0,
-    explicit: 0,
-    knowledge: 0,
-    personal: 0,
-    preference: 0,
-    procedure: 0,
-    public: 0
-  };
-}
-function createPersonalMemoryCollection(db, scopes, options = {}) {
-  const { privateScopes, publicScopes } = scopes;
-  const allScopes = [...privateScopes, ...publicScopes];
-  const getNowMs = () => options.now?.() ?? Date.now();
-  function scopesForVisibility(visibility) {
-    if (visibility === "private") return privateScopes;
-    if (visibility === "public") return publicScopes;
-    return allScopes;
-  }
-  return {
-    async archive(id) {
-      const memoryId = nonEmptyStringSchema3.parse(id);
-      const nowMs = getNowMs();
-      const predicate = activeVisiblePredicate({
-        nowMs,
-        scopes: privateScopes
-      });
-      if (!predicate) {
-        throw new PersonalMemoryNotFoundError();
-      }
-      const updated = await db.update(juniorMemoryMemories).set({
-        archivedAtMs: nowMs,
-        archiveReason: "user_removed"
-      }).where(and2(predicate, eq2(juniorMemoryMemories.id, memoryId))).returning();
-      if (!updated[0]) {
-        throw new PersonalMemoryNotFoundError();
-      }
-      await db.delete(juniorMemoryEmbeddings).where(eq2(juniorMemoryEmbeddings.memoryId, memoryId));
-      return parseMemoryRow(updated[0]);
-    },
-    async get(id) {
-      const memoryId = nonEmptyStringSchema3.parse(id);
-      const nowMs = getNowMs();
-      const predicate = activeVisiblePredicate({ nowMs, scopes: allScopes });
-      if (!predicate) {
-        throw new PersonalMemoryNotFoundError();
-      }
-      const rows = await db.select().from(juniorMemoryMemories).where(and2(predicate, eq2(juniorMemoryMemories.id, memoryId))).limit(1);
-      if (!rows[0]) {
-        throw new PersonalMemoryNotFoundError();
-      }
-      return personalMemoryRecord(rows[0]);
-    },
-    async list(input) {
-      input = personalMemoryPageInputSchema.parse(input);
-      const nowMs = getNowMs();
-      const scopes2 = scopesForVisibility(input.visibility);
-      await archiveExpiredMemoryBatch({ db, nowMs, scopes: scopes2 });
-      const active = activeVisiblePredicate({ nowMs, scopes: scopes2 });
-      if (!active) {
-        return { memories: [] };
-      }
-      const cursor = input.cursor ? or2(
-        lt(juniorMemoryMemories.createdAtMs, input.cursor.createdAtMs),
-        and2(
-          eq2(juniorMemoryMemories.createdAtMs, input.cursor.createdAtMs),
-          gt2(juniorMemoryMemories.id, input.cursor.id)
-        )
-      ) : void 0;
-      const terms = input.query ? searchTerms(input.query) : [];
-      const search = input.query === void 0 ? void 0 : terms.length === 0 ? sql3`false` : or2(
-        ...terms.map(
-          (term) => ilike(juniorMemoryMemories.content, `%${term}%`)
-        )
-      );
-      const kind = input.kind ? eq2(juniorMemoryMemories.kind, input.kind) : void 0;
-      const origin = input.origin === "automatic" ? like2(juniorMemoryMemories.idempotencyKey, "session:%") : input.origin === "explicit" ? like2(juniorMemoryMemories.idempotencyKey, "tool:%") : void 0;
-      const rows = await db.select().from(juniorMemoryMemories).where(and2(active, cursor, search, kind, origin)).orderBy(
-        desc2(juniorMemoryMemories.createdAtMs),
-        asc2(juniorMemoryMemories.id)
-      ).limit(input.limit + 1);
-      const hasNextPage = rows.length > input.limit;
-      const memories = rows.slice(0, input.limit).map(personalMemoryRecord);
-      const last = memories.at(-1);
-      return {
-        memories,
-        ...hasNextPage && last ? {
-          nextCursor: {
-            createdAtMs: last.createdAtMs,
-            id: last.id
-          }
-        } : void 0
-      };
-    },
-    async stats() {
-      const nowMs = getNowMs();
-      await archiveExpiredMemoryBatch({ db, nowMs, scopes: allScopes });
-      const active = activeVisiblePredicate({ nowMs, scopes: allScopes });
-      if (!active) {
-        return emptyStats();
-      }
-      const [counts] = await db.select({
-        active: sql3`count(*)`.mapWith(Number),
-        automatic: sql3`count(*) filter (where ${juniorMemoryMemories.idempotencyKey} like 'session:%')`.mapWith(
-          Number
-        ),
-        createdThirtyDays: sql3`count(*) filter (where ${juniorMemoryMemories.createdAtMs} >= ${nowMs - 30 * 24 * 60 * 60 * 1e3})`.mapWith(
-          Number
-        ),
-        embedded: sql3`count(${juniorMemoryEmbeddings.memoryId})`.mapWith(
-          Number
-        ),
-        explicit: sql3`count(*) filter (where ${juniorMemoryMemories.idempotencyKey} like 'tool:%')`.mapWith(
-          Number
-        ),
-        knowledge: sql3`count(*) filter (where ${juniorMemoryMemories.kind} = 'knowledge')`.mapWith(
-          Number
-        ),
-        personal: sql3`count(*) filter (where ${juniorMemoryMemories.scope} = 'personal')`.mapWith(
-          Number
-        ),
-        preference: sql3`count(*) filter (where ${juniorMemoryMemories.kind} = 'preference')`.mapWith(
-          Number
-        ),
-        procedure: sql3`count(*) filter (where ${juniorMemoryMemories.kind} = 'procedure')`.mapWith(
-          Number
-        ),
-        public: sql3`count(*) filter (where ${juniorMemoryMemories.scope} = 'conversation')`.mapWith(
-          Number
-        )
-      }).from(juniorMemoryMemories).leftJoin(
-        juniorMemoryEmbeddings,
-        eq2(juniorMemoryEmbeddings.memoryId, juniorMemoryMemories.id)
-      ).where(active);
-      return {
-        active: counts?.active ?? 0,
-        automatic: counts?.automatic ?? 0,
-        createdThirtyDays: counts?.createdThirtyDays ?? 0,
-        embedded: counts?.embedded ?? 0,
-        explicit: counts?.explicit ?? 0,
-        knowledge: counts?.knowledge ?? 0,
-        personal: counts?.personal ?? 0,
-        preference: counts?.preference ?? 0,
-        procedure: counts?.procedure ?? 0,
-        public: counts?.public ?? 0
-      };
-    },
-    async timeline(input) {
-      input = personalMemoryTimelineInputSchema.parse(input);
-      const todayMs = Date.parse(`${utcDate(getNowMs())}T00:00:00.000Z`);
-      const startMs = todayMs - (input.days - 1) * DAY_MS;
-      const ownership = scopePredicate(allScopes);
-      if (!ownership) {
-        return Array.from({ length: input.days }, (_, index2) => ({
-          date: utcDate(startMs + index2 * DAY_MS),
-          personal: 0,
-          public: 0
-        }));
-      }
-      const rows = await db.select({
-        date: sql3`to_char(to_timestamp(${juniorMemoryMemories.createdAtMs} / 1000.0) AT TIME ZONE 'UTC', 'YYYY-MM-DD')`.as(
-          "date"
-        ),
-        personal: sql3`count(*) filter (where ${juniorMemoryMemories.scope} = 'personal')`.mapWith(
-          Number
-        ),
-        public: sql3`count(*) filter (where ${juniorMemoryMemories.scope} = 'conversation')`.mapWith(
-          Number
-        )
-      }).from(juniorMemoryMemories).where(
-        and2(ownership, gt2(juniorMemoryMemories.createdAtMs, startMs - 1))
-      ).groupBy(
-        sql3`to_char(to_timestamp(${juniorMemoryMemories.createdAtMs} / 1000.0) AT TIME ZONE 'UTC', 'YYYY-MM-DD')`
-      );
-      const byDate = new Map(rows.map((row) => [row.date, row]));
-      return Array.from({ length: input.days }, (_, index2) => {
-        const date = utcDate(startMs + index2 * DAY_MS);
-        const row = byDate.get(date);
-        return {
-          date,
-          personal: row?.personal ?? 0,
-          public: row?.public ?? 0
-        };
-      });
-    }
+    kind: input.kind,
+    origin: input.origin,
+    query: input.query?.trim() || void 0,
+    visibility: input.visibility
   };
 }
-
-// src/personal.ts
-var cursorSchema = z5.object({
-  createdAtMs: z5.number().finite(),
-  id: z5.string().min(1),
-  kind: z5.enum(["preference", "procedure", "knowledge"]).optional(),
-  origin: z5.enum(["automatic", "explicit"]).optional(),
-  query: z5.string().max(200).optional(),
-  version: z5.literal(1),
-  visibility: z5.enum(["private", "public"]).optional()
-}).strict();
-var InvalidMemoryCursorError = class extends Error {
-  constructor() {
-    super("Memory cursor is invalid.");
-    this.name = "InvalidMemoryCursorError";
-  }
-};
-function decodeCursor(value, input) {
+function decodeCursor(value, filters) {
   if (!value) return void 0;
   try {
     const parsed = cursorSchema.parse(
       JSON.parse(Buffer.from(value, "base64url").toString("utf8"))
     );
-    if (parsed.query !== input.query || parsed.kind !== input.kind || parsed.origin !== input.origin || parsed.visibility !== input.visibility) {
+    if (parsed.query !== filters.query || parsed.kind !== filters.kind || parsed.origin !== filters.origin || parsed.visibility !== filters.visibility) {
       throw new InvalidMemoryCursorError();
     }
     return { createdAtMs: parsed.createdAtMs, id: parsed.id };
@@ -2184,106 +1892,190 @@ function decodeCursor(value, input) {
     throw new InvalidMemoryCursorError();
   }
 }
-function encodeCursor(cursor, input) {
+function encodeCursor(createdBefore, filters) {
   return Buffer.from(
-    JSON.stringify({
-      ...cursor,
-      ...input.query ? { query: input.query } : void 0,
-      ...input.kind ? { kind: input.kind } : void 0,
-      ...input.origin ? { origin: input.origin } : void 0,
-      ...input.visibility ? { visibility: input.visibility } : void 0,
-      version: 1
-    }),
+    JSON.stringify({ ...createdBefore, ...filters, version: 1 }),
     "utf8"
   ).toString("base64url");
 }
-function createViewerMemories(db, user) {
-  const collection = createPersonalMemoryCollection(
-    db,
-    deriveViewerMemoryScopes(user.identities)
+async function archiveMemory(db, userId, id) {
+  const memoryId = nonEmptyStringSchema3.parse(id);
+  const nowMs = Date.now();
+  const updated = await db.update(juniorMemoryMemories).set({
+    archivedAtMs: nowMs,
+    archiveReason: "user_removed"
+  }).where(
+    and2(
+      activeMemoryPredicate(userId, nowMs, "private"),
+      eq2(juniorMemoryMemories.id, memoryId)
+    )
+  ).returning();
+  if (!updated[0]) throw new MemoryNotFoundError();
+  await db.delete(juniorMemoryEmbeddings).where(eq2(juniorMemoryEmbeddings.memoryId, memoryId));
+  return parseMemoryRow(updated[0]);
+}
+async function getMemory(db, userId, id) {
+  const memoryId = nonEmptyStringSchema3.parse(id);
+  const nowMs = Date.now();
+  const rows = await db.select().from(juniorMemoryMemories).where(
+    and2(
+      activeMemoryPredicate(userId, nowMs),
+      eq2(juniorMemoryMemories.id, memoryId)
+    )
+  ).limit(1);
+  if (!rows[0]) throw new MemoryNotFoundError();
+  return toMemoryView(rows[0]);
+}
+async function listMemories(db, userId, input) {
+  input = pageInputSchema.parse(input);
+  const filters = cursorFilters(input);
+  const cursor = decodeCursor(input.cursor, filters);
+  const active = activeMemoryPredicate(userId, Date.now(), input.visibility);
+  const createdBefore = cursor ? or2(
+    lt(juniorMemoryMemories.createdAtMs, cursor.createdAtMs),
+    and2(
+      eq2(juniorMemoryMemories.createdAtMs, cursor.createdAtMs),
+      gt2(juniorMemoryMemories.id, cursor.id)
+    )
+  ) : void 0;
+  const terms = input.query ? searchTerms(input.query) : [];
+  const search = input.query === void 0 ? void 0 : terms.length === 0 ? sql3`false` : or2(
+    ...terms.map(
+      (term) => ilike(juniorMemoryMemories.content, `%${term}%`)
+    )
   );
-  return {
-    async archive(id) {
-      return await collection.archive(id);
-    },
-    async get(id) {
-      return await collection.get(id);
-    },
-    async list(input) {
-      const query = input.query?.trim() || void 0;
-      const filters = {
-        ...input.kind ? { kind: input.kind } : void 0,
-        ...input.origin ? { origin: input.origin } : void 0,
-        ...query ? { query } : void 0,
-        ...input.visibility ? { visibility: input.visibility } : void 0
-      };
-      const page = await collection.list({
-        cursor: decodeCursor(input.cursor, filters),
-        ...filters,
-        limit: input.limit
-      });
-      return {
-        memories: page.memories,
-        ...page.nextCursor ? { nextCursor: encodeCursor(page.nextCursor, filters) } : void 0
-      };
-    },
-    async stats() {
-      return await collection.stats();
-    },
-    async timeline(input) {
-      return await collection.timeline(input);
-    }
-  };
+  const kind = input.kind ? eq2(juniorMemoryMemories.kind, input.kind) : void 0;
+  const origin = input.origin === "automatic" ? like2(juniorMemoryMemories.idempotencyKey, "session:%") : input.origin === "explicit" ? like2(juniorMemoryMemories.idempotencyKey, "tool:%") : void 0;
+  const rows = await db.select().from(juniorMemoryMemories).where(and2(active, createdBefore, search, kind, origin)).orderBy(
+    desc2(juniorMemoryMemories.createdAtMs),
+    asc2(juniorMemoryMemories.id)
+  ).limit(input.limit + 1);
+  const memories = rows.slice(0, input.limit).map(toMemoryView);
+  const last = memories.at(-1);
+  if (rows.length <= input.limit || !last) return { memories };
+  const next = { createdAtMs: last.createdAtMs, id: last.id };
+  return { memories, nextCursor: encodeCursor(next, filters) };
+}
+async function getMemoryStats(db, userId) {
+  const nowMs = Date.now();
+  const [counts] = await db.select({
+    active: sql3`count(*)`.mapWith(Number),
+    automatic: sql3`count(*) filter (where ${juniorMemoryMemories.idempotencyKey} like 'session:%')`.mapWith(
+      Number
+    ),
+    createdThirtyDays: sql3`count(*) filter (where ${juniorMemoryMemories.createdAtMs} >= ${nowMs - 30 * DAY_MS})`.mapWith(
+      Number
+    ),
+    embedded: sql3`count(${juniorMemoryEmbeddings.memoryId})`.mapWith(
+      Number
+    ),
+    explicit: sql3`count(*) filter (where ${juniorMemoryMemories.idempotencyKey} like 'tool:%')`.mapWith(
+      Number
+    ),
+    knowledge: sql3`count(*) filter (where ${juniorMemoryMemories.kind} = 'knowledge')`.mapWith(
+      Number
+    ),
+    private: sql3`count(*) filter (where ${juniorMemoryMemories.scope} = 'private')`.mapWith(
+      Number
+    ),
+    preference: sql3`count(*) filter (where ${juniorMemoryMemories.kind} = 'preference')`.mapWith(
+      Number
+    ),
+    procedure: sql3`count(*) filter (where ${juniorMemoryMemories.kind} = 'procedure')`.mapWith(
+      Number
+    ),
+    public: sql3`count(*) filter (where ${juniorMemoryMemories.scope} = 'public')`.mapWith(
+      Number
+    )
+  }).from(juniorMemoryMemories).leftJoin(
+    juniorMemoryEmbeddings,
+    eq2(juniorMemoryEmbeddings.memoryId, juniorMemoryMemories.id)
+  ).where(activeMemoryPredicate(userId, nowMs));
+  if (!counts) throw new Error("Memory stats query returned no row.");
+  return counts;
+}
+async function getMemoryTimeline(db, userId, days) {
+  days = timelineDaysSchema.parse(days);
+  const todayMs = Date.parse(`${utcDate(Date.now())}T00:00:00.000Z`);
+  const startMs = todayMs - (days - 1) * DAY_MS;
+  const rows = await db.select({
+    date: sql3`to_char(to_timestamp(${juniorMemoryMemories.createdAtMs} / 1000.0) AT TIME ZONE 'UTC', 'YYYY-MM-DD')`.as(
+      "date"
+    ),
+    private: sql3`count(*) filter (where ${juniorMemoryMemories.scope} = 'private')`.mapWith(
+      Number
+    ),
+    public: sql3`count(*) filter (where ${juniorMemoryMemories.scope} = 'public')`.mapWith(
+      Number
+    )
+  }).from(juniorMemoryMemories).where(
+    and2(
+      visibleScopePredicate2(userId),
+      gt2(juniorMemoryMemories.createdAtMs, startMs - 1)
+    )
+  ).groupBy(
+    sql3`to_char(to_timestamp(${juniorMemoryMemories.createdAtMs} / 1000.0) AT TIME ZONE 'UTC', 'YYYY-MM-DD')`
+  );
+  const byDate = new Map(rows.map((row) => [row.date, row]));
+  return Array.from({ length: days }, (_, index2) => {
+    const date = utcDate(startMs + index2 * DAY_MS);
+    const row = byDate.get(date);
+    return {
+      date,
+      private: row?.private ?? 0,
+      public: row?.public ?? 0
+    };
+  });
 }
 
 // src/api.ts
-var memoryApiSchema = z6.object({
-  content: z6.string().min(1),
-  createdAt: z6.iso.datetime(),
-  expiresAt: z6.iso.datetime().optional(),
-  id: z6.string().min(1),
-  kind: z6.enum(["preference", "procedure", "knowledge"]),
-  observedAt: z6.iso.datetime(),
-  origin: z6.enum(["automatic", "explicit", "other"]),
-  sourcePlatform: z6.enum(MEMORY_SOURCE_PLATFORMS),
-  visibility: z6.enum(["private", "public"])
+var memoryApiSchema = z5.object({
+  content: z5.string().min(1),
+  createdAt: z5.iso.datetime(),
+  expiresAt: z5.iso.datetime().optional(),
+  id: z5.string().min(1),
+  kind: z5.enum(["preference", "procedure", "knowledge"]),
+  observedAt: z5.iso.datetime(),
+  origin: z5.enum(["automatic", "explicit", "other"]),
+  sourcePlatform: z5.enum(MEMORY_SOURCE_PLATFORMS),
+  visibility: z5.enum(["private", "public"])
 }).strict();
-var memoryListResponseSchema = z6.object({
-  memories: z6.array(memoryApiSchema),
-  nextCursor: z6.string().min(1).optional()
+var memoryListResponseSchema = z5.object({
+  memories: z5.array(memoryApiSchema),
+  nextCursor: z5.string().min(1).optional()
 }).strict();
-var memoryDashboardDaySchema = z6.object({
-  date: z6.iso.date(),
-  personal: z6.number().int().min(0),
-  public: z6.number().int().min(0)
+var memoryDashboardDaySchema = z5.object({
+  date: z5.iso.date(),
+  personal: z5.number().int().min(0),
+  public: z5.number().int().min(0)
 }).strict();
-var memoryCostDaySchema = z6.object({
-  costUsd: z6.number().finite().nonnegative(),
-  date: z6.iso.date(),
-  events: z6.number().int().min(0)
+var memoryCostDaySchema = z5.object({
+  costUsd: z5.number().finite().nonnegative(),
+  date: z5.iso.date(),
+  events: z5.number().int().min(0)
 }).strict();
-var memoryDashboardResponseSchema = z6.object({
-  days: z6.array(memoryDashboardDaySchema).length(90),
-  extractionDays: z6.array(memoryCostDaySchema).length(90),
-  generatedAt: z6.iso.datetime(),
-  recallDays: z6.array(memoryCostDaySchema).length(90),
-  stats: z6.object({
-    active: z6.number().int().min(0),
-    automatic: z6.number().int().min(0),
-    createdThirtyDays: z6.number().int().min(0),
-    embedded: z6.number().int().min(0),
-    explicit: z6.number().int().min(0),
-    knowledge: z6.number().int().min(0),
-    personal: z6.number().int().min(0),
-    preference: z6.number().int().min(0),
-    procedure: z6.number().int().min(0),
-    public: z6.number().int().min(0)
+var memoryDashboardResponseSchema = z5.object({
+  days: z5.array(memoryDashboardDaySchema).length(90),
+  extractionDays: z5.array(memoryCostDaySchema).length(90),
+  generatedAt: z5.iso.datetime(),
+  recallDays: z5.array(memoryCostDaySchema).length(90),
+  stats: z5.object({
+    active: z5.number().int().min(0),
+    automatic: z5.number().int().min(0),
+    createdThirtyDays: z5.number().int().min(0),
+    embedded: z5.number().int().min(0),
+    explicit: z5.number().int().min(0),
+    knowledge: z5.number().int().min(0),
+    personal: z5.number().int().min(0),
+    preference: z5.number().int().min(0),
+    procedure: z5.number().int().min(0),
+    public: z5.number().int().min(0)
   }).strict()
 }).strict();
-var memoryListQuerySchema = z6.object({
-  cursor: z6.string().min(1).max(1e3).optional(),
-  limit: z6.coerce.number().int().min(1).max(50).default(25),
-  q: z6.string().trim().max(200).optional()
+var memoryListQuerySchema = z5.object({
+  cursor: z5.string().min(1).max(1e3).optional(),
+  limit: z5.coerce.number().int().min(1).max(50).default(25),
+  q: z5.string().trim().max(200).optional()
 }).strict();
 function json(body, status = 200) {
   return Response.json(body, {
@@ -2329,14 +2121,14 @@ function createMemoryApi(options) {
       if (!isRead && !(memoryPath && request.method === "DELETE")) {
         return json({ error: "Method not allowed." }, 405);
       }
-      const user = await options.users.resolve(email);
-      if (!user) return json({ error: "Authentication required." }, 401);
-      const memories = createViewerMemories(options.db, user);
+      const viewer = await options.users.resolve(email);
+      if (!viewer) return json({ error: "Authentication required." }, 401);
+      const userId = viewer.id;
       try {
         if (isDashboard && isRead) {
           const [stats, days, extractionDays, recallDays] = await Promise.all([
-            memories.stats(),
-            memories.timeline({ days: 90 }),
+            getMemoryStats(options.db, userId),
+            getMemoryTimeline(options.db, userId, 90),
             options.eventStats.costsByDay({
               days: 90,
               eventName: "memories_captured"
@@ -2346,12 +2138,16 @@ function createMemoryApi(options) {
               eventName: "memories_recalled"
             })
           ]);
+          const { private: personal, ...dashboardStats } = stats;
           const body = memoryDashboardResponseSchema.parse({
-            days,
+            days: days.map(({ private: personal2, ...day }) => ({
+              ...day,
+              personal: personal2
+            })),
             extractionDays,
             generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
             recallDays,
-            stats
+            stats: { ...dashboardStats, personal }
           });
           return request.method === "HEAD" ? new Response(null, {
             headers: { "cache-control": "no-store" },
@@ -2364,7 +2160,7 @@ function createMemoryApi(options) {
             limit: url.searchParams.get("limit") ?? void 0,
             q: url.searchParams.get("q") ?? void 0
           });
-          const page = await memories.list({
+          const page = await listMemories(options.db, userId, {
             cursor: query.cursor,
             limit: query.limit,
             ...query.q ? { query: query.q } : void 0
@@ -2379,26 +2175,30 @@ function createMemoryApi(options) {
           }) : json(body);
         }
         if (memoryPath && isRead) {
-          const memory = memoryApiSchema.parse(
-            apiMemory(await memories.get(decodeURIComponent(memoryPath[1])))
+          const memory = await getMemory(
+            options.db,
+            userId,
+            decodeURIComponent(memoryPath[1])
           );
+          const body = memoryApiSchema.parse(apiMemory(memory));
           return request.method === "HEAD" ? new Response(null, {
             headers: { "cache-control": "no-store" },
             status: 200
-          }) : json(memory);
+          }) : json(body);
         }
         if (memoryPath && request.method === "DELETE") {
-          await memories.archive(decodeURIComponent(memoryPath[1]));
+          const id = decodeURIComponent(memoryPath[1]);
+          await archiveMemory(options.db, userId, id);
           return new Response(null, {
             headers: { "cache-control": "no-store" },
             status: 204
           });
         }
       } catch (error) {
-        if (error instanceof z6.ZodError || error instanceof InvalidMemoryCursorError) {
+        if (error instanceof z5.ZodError || error instanceof InvalidMemoryCursorError) {
           return json({ error: "Invalid memory request." }, 400);
         }
-        if (error instanceof PersonalMemoryNotFoundError) {
+        if (error instanceof MemoryNotFoundError) {
           return json({ error: error.message }, 404);
         }
         throw error;
@@ -2410,7 +2210,7 @@ function createMemoryApi(options) {
 
 // src/cli/search.ts
 import { InvalidArgumentError, Option } from "commander";
-import { and as and3, desc as desc3, eq as eq3, gt as gt3, ilike as ilike2, isNull as isNull2, or as or3 } from "drizzle-orm";
+import { and as and3, desc as desc3, eq as eq3, gt as gt3, ilike as ilike2, isNull as isNull3, or as or3 } from "drizzle-orm";
 
 // src/cli/format.ts
 function formatDate(ms) {
@@ -2453,15 +2253,15 @@ async function runSearch(ctx, queryParts, options) {
   ];
   const db = ctx.db;
   const activeExpirationPredicate = or3(
-    isNull2(juniorMemoryMemories.expiresAtMs),
+    isNull3(juniorMemoryMemories.expiresAtMs),
     gt3(juniorMemoryMemories.expiresAtMs, nowMs)
   );
   const predicates = [
     eq3(juniorMemoryMemories.scope, options.scope),
     eq3(juniorMemoryMemories.scopeKey, options.scopeKey),
-    isNull2(juniorMemoryMemories.archivedAtMs),
-    isNull2(juniorMemoryMemories.supersededAtMs),
-    isNull2(juniorMemoryMemories.supersededById)
+    isNull3(juniorMemoryMemories.archivedAtMs),
+    isNull3(juniorMemoryMemories.supersededAtMs),
+    isNull3(juniorMemoryMemories.supersededById)
   ];
   if (activeExpirationPredicate) {
     predicates.push(activeExpirationPredicate);
@@ -2542,11 +2342,11 @@ import { Type } from "@sinclair/typebox";
 import { Value } from "@sinclair/typebox/value";
 import {
   definePluginTool,
-  getSourceKey,
+  getSourceKey as getSourceKey2,
   PluginToolInputError,
   pluginToolOutputSchema
 } from "@sentry/junior-plugin-api";
-import { z as z7 } from "zod";
+import { z as z6 } from "zod";
 var MAX_TOOL_CONTENT_CHARS = 4e3;
 var DEFAULT_RESULT_LIMIT = 20;
 var DEFAULT_SEARCH_LIMIT2 = 10;
@@ -2558,8 +2358,8 @@ var KNOWN_TOOL_INPUT_ERROR_MESSAGES = /* @__PURE__ */ 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."
 ]);
 function throwToolInputError(message) {
   throw new PluginToolInputError(message);
@@ -2573,15 +2373,18 @@ function asToolInputError(error) {
   }
   throw error;
 }
-function memoryRuntimeContext(context) {
+async function memoryRuntimeContext(context) {
+  const actorUser = (await context.users.resolveActor())?.user;
   return memoryRuntimeContextSchema.parse({
     ...context.conversationId ? { conversationId: context.conversationId } : void 0,
     ...context.actor ? { actor: context.actor } : void 0,
-    source: context.source
+    ...context.locationId ? { locationId: context.locationId } : void 0,
+    source: context.source,
+    ...actorUser ? { userId: actorUser.id } : void 0
   });
 }
-function memoryStore(context, options = {}) {
-  return createMemoryStore(context.db, memoryRuntimeContext(context), {
+function memoryStore(context, runtimeContext, options = {}) {
+  return createMemoryStore(context.db, runtimeContext, {
     embedder: context.embedder,
     ...options.supersessionDecider ? { supersessionDecider: options.supersessionDecider } : void 0
   });
@@ -2673,23 +2476,23 @@ function requireMemoryContent(value) {
   }
   return value;
 }
-var createMemoryInputSchema2 = z7.object({
-  content: z7.string().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."
+var createMemoryInputSchema2 = z6.object({
+  content: z6.string().min(1).max(MAX_TOOL_CONTENT_CHARS).describe(
+    "Self-contained memory candidate. Include the subject in natural language when it matters; do not rely on surrounding chat context."
   ),
-  expires_at: z7.string().min(1).describe(
+  expires_at: z6.string().min(1).describe(
     'Expiration selector. Omit or use "never" when the memory should not expire, or use an exact ISO timestamp such as "2027-06-21T00:00:00Z".'
   ).optional()
 }).strict();
-var removeMemoryInputSchema = z7.object({
-  id: z7.string().min(1).describe("Memory id or unambiguous short id prefix to remove.")
+var removeMemoryInputSchema = z6.object({
+  id: z6.string().min(1).describe("Memory id or unambiguous short id prefix to remove.")
 }).strict();
-var listMemoriesInputSchema2 = z7.object({
-  limit: z7.number().min(1).max(50).describe("Maximum number of visible memories to return.").optional()
+var listMemoriesInputSchema2 = z6.object({
+  limit: z6.number().min(1).max(50).describe("Maximum number of visible memories to return.").optional()
 }).strict();
-var searchMemoriesInputSchema2 = z7.object({
-  query: z7.string().min(1).describe("Search query for visible memory content."),
-  limit: z7.number().min(1).max(50).describe("Maximum number of matching memories to return.").optional()
+var searchMemoriesInputSchema2 = z6.object({
+  query: z6.string().min(1).describe("Search query for visible memory content."),
+  limit: z6.number().min(1).max(50).describe("Maximum number of matching memories to return.").optional()
 }).strict();
 var memoryToolProjectionSchema = Type.Object(
   {
@@ -2701,25 +2504,25 @@ var memoryToolProjectionSchema = Type.Object(
   },
   { additionalProperties: false }
 );
-var memoryProjectionOutputSchema = z7.object({
-  id: z7.string(),
-  content: z7.string(),
-  createdAtMs: z7.number(),
-  observedAtMs: z7.number(),
-  expiresAtMs: z7.number().optional()
+var memoryProjectionOutputSchema = z6.object({
+  id: z6.string(),
+  content: z6.string(),
+  createdAtMs: z6.number(),
+  observedAtMs: z6.number(),
+  expiresAtMs: z6.number().optional()
 });
 var memoryCreateOutputSchema = pluginToolOutputSchema.extend({
-  target: z7.string(),
-  created: z7.boolean(),
+  target: z6.string(),
+  created: z6.boolean(),
   memory: memoryProjectionOutputSchema
 });
 var memorySingleOutputSchema = pluginToolOutputSchema.extend({
-  target: z7.string(),
+  target: z6.string(),
   memory: memoryProjectionOutputSchema
 });
 var memoryManyOutputSchema = pluginToolOutputSchema.extend({
-  target: z7.string(),
-  memories: z7.array(memoryProjectionOutputSchema)
+  target: z6.string(),
+  memories: z6.array(memoryProjectionOutputSchema)
 });
 function parseMemoryToolInput(schema, input) {
   const result = schema.safeParse(input);
@@ -2731,7 +2534,7 @@ function parseMemoryToolInput(schema, input) {
   return result.data;
 }
 function sourceIdempotencyKey(context) {
-  const sourceKey2 = getSourceKey(context.source);
+  const sourceKey2 = getSourceKey2(context.source);
   if (!sourceKey2) {
     throwToolInputError("Memory creation requires source message context.");
   }
@@ -2775,7 +2578,7 @@ function createMemoryCreateTool(context) {
       openWorldHint: false,
       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.",
+    description: "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: createMemoryInputSchema2,
     outputSchema: memoryCreateOutputSchema,
@@ -2783,8 +2586,8 @@ function createMemoryCreateTool(context) {
       const parsedInput = parseMemoryToolInput(createMemoryInputSchema2, 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 () => {
@@ -2853,15 +2656,16 @@ function createMemoryRemoveTool(context) {
       openWorldHint: false,
       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.",
+    description: "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"
           });
@@ -2888,7 +2692,8 @@ function createMemoryListTool(context) {
     outputSchema: memoryManyOutputSchema,
     execute: async (input) => {
       const parsedInput = parseMemoryToolInput(listMemoriesInputSchema2, input);
-      const memories = await memoryStore(context).listMemories({
+      const runtimeContext = await memoryRuntimeContext(context);
+      const memories = await memoryStore(context, runtimeContext).listMemories({
         limit: boundedLimit2(parsedInput.limit, DEFAULT_RESULT_LIMIT)
       });
       return memoryToolResult("listMemories", {
@@ -2899,7 +2704,7 @@ function createMemoryListTool(context) {
 }
 function createMemorySearchTool(context) {
   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.",
+    description: "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,
@@ -2913,7 +2718,11 @@ function createMemorySearchTool(context) {
         searchMemoriesInputSchema2,
         input
       );
-      const memories = await memoryStore(context).searchMemories({
+      const runtimeContext = await memoryRuntimeContext(context);
+      const memories = await memoryStore(
+        context,
+        runtimeContext
+      ).searchMemories({
         query: parsedInput.query,
         limit: boundedLimit2(parsedInput.limit, DEFAULT_SEARCH_LIMIT2)
       });
@@ -2927,29 +2736,41 @@ function createMemorySearchTool(context) {
 // src/process-session.ts
 import { createHash as createHash2 } from "crypto";
 import {
-  getSourceKey as getSourceKey2
+  getSourceKey as getSourceKey3
 } from "@sentry/junior-plugin-api";
-import { z as z9 } from "zod";
+import { z as z8 } from "zod";
 
 // src/events.ts
 import { defineConversationEvent } from "@sentry/junior-plugin-api";
-import { z as z8 } from "zod";
-var capturedMemorySchema = z8.object({
-  content: z8.string().min(1),
-  id: z8.string().min(1),
-  kind: z8.enum(MEMORY_KINDS),
-  observedAtMs: z8.number().finite(),
-  scope: z8.enum(MEMORY_SCOPES)
+import { z as z7 } from "zod";
+var capturedMemoryFields = {
+  content: z7.string().min(1),
+  id: z7.string().min(1),
+  kind: z7.enum(MEMORY_KINDS),
+  observedAtMs: z7.number().finite()
+};
+var legacyCapturedMemorySchema = z7.object({
+  ...capturedMemoryFields,
+  scope: z7.enum(["personal", "conversation"])
+}).strict();
+var capturedMemorySchema = z7.object({
+  ...capturedMemoryFields,
+  scope: z7.enum(MEMORY_SCOPES)
 }).strict();
-var capturedMemoriesSchema = z8.object({
-  memories: z8.array(capturedMemorySchema).max(100),
-  costUsd: z8.number().finite().nonnegative().optional()
+var capturedMemoriesSchema = z7.object({
+  memories: z7.array(capturedMemorySchema).max(100),
+  costUsd: z7.number().finite().nonnegative().optional()
 }).strict();
-var recalledMemoriesSchema = z8.object({
+var recalledMemoriesSchema = z7.object({
   // Matches the automatic-recall candidate window; admission packs by char budget.
-  memories: z8.array(z8.string().min(1)).max(20),
-  costUsd: z8.number().finite().nonnegative().optional()
+  memories: z7.array(z7.string().min(1)).max(20),
+  costUsd: z7.number().finite().nonnegative().optional()
 }).strict();
+function currentScope(scope) {
+  if (scope === "personal") return "private";
+  if (scope === "conversation") return "public";
+  return scope;
+}
 function renderCapturedMemories(event) {
   const count = event.memories.length;
   if (count === 0) return void 0;
@@ -2958,15 +2779,15 @@ function renderCapturedMemories(event) {
     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)]
     }))
   };
 }
 var memoriesCapturedEventV1 = defineConversationEvent({
   name: "memories_captured",
   version: 1,
-  schema: z8.object({
-    memories: z8.array(capturedMemorySchema).min(1).max(100)
+  schema: z7.object({
+    memories: z7.array(legacyCapturedMemorySchema).min(1).max(100)
   }).strict(),
   renderEvent: renderCapturedMemories
 });
@@ -3002,28 +2823,19 @@ var MEMORY_TOOL_NAMES = /* @__PURE__ */ new Set([
   "searchMemories"
 ]);
 var MEMORY_TASK_STATE_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
-var extractedMemorySchema2 = z9.object({
-  content: z9.string().min(1),
-  expiresAtMs: z9.number().finite().nullable(),
-  kind: z9.enum(MEMORY_KINDS),
-  evidenceMessageIndices: z9.array(z9.number().int().nonnegative()).min(1).max(10)
+var extractedMemorySchema2 = z8.object({
+  content: z8.string().min(1),
+  expiresAtMs: z8.number().finite().nullable(),
+  kind: z8.enum(MEMORY_KINDS),
+  evidenceMessageIndices: z8.array(z8.number().int().nonnegative()).min(1).max(10)
 }).strict().transform(parseExtractedMemory);
-var extractedMemoryCacheSchema = z9.union([
-  z9.object({
-    costUsd: z9.number().finite().nonnegative().optional(),
-    memories: z9.array(extractedMemorySchema2).max(5)
+var extractedMemoryCacheSchema = z8.union([
+  z8.object({
+    costUsd: z8.number().finite().nonnegative().optional(),
+    memories: z8.array(extractedMemorySchema2).max(5)
   }).strict(),
-  z9.array(extractedMemorySchema2).max(5).transform((memories) => ({ memories }))
+  z8.array(extractedMemorySchema2).max(5).transform((memories) => ({ memories }))
 ]);
-function allowsPassiveMemoryExtraction(source) {
-  switch (source.platform) {
-    case "local":
-      return true;
-    case "web":
-    case "slack":
-      return source.visibility === "public";
-  }
-}
 function recordCapturedMemory(captured, result) {
   const supersededIds = new Set(result.supersededIds ?? []);
   for (let index2 = captured.length - 1; index2 >= 0; index2 -= 1) {
@@ -3069,11 +2881,11 @@ function routeExtractedMemory(memory, transcript, run) {
     return "drop";
   }
   if (memory.kind === "preference") {
-    const exactlyOneHumanRunActor = run.actor !== void 0 && run.actor.platform !== "system" && run.actors.length === 1 && run.actors[0]?.platform !== "system";
+    const exactlyOneHumanRunActor = run.actorUserId !== void 0 && run.actor !== void 0 && run.actor.platform !== "system" && run.actors.length === 1 && run.actors[0]?.platform !== "system";
     if (!exactlyOneHumanRunActor) {
       return "drop";
     }
-    return cited.entries.every(isRunActorInstruction) ? "personal" : "drop";
+    return cited.entries.every(isRunActorInstruction) ? "user" : "drop";
   }
   return cited.entries.every(
     (entry) => isRunActorInstruction(entry) || isConversationEvidence(entry)
@@ -3106,16 +2918,16 @@ async function getTaskExtraction(context, extract) {
 }
 async function processMemorySession(context) {
   const run = await context.run.load();
+  if (run.source.platform === "local") {
+    return;
+  }
   if (run.transcript.some(
     (entry) => entry.type === "toolResult" && MEMORY_TOOL_NAMES.has(entry.toolName)
   )) {
     return;
   }
-  if (!allowsPassiveMemoryExtraction(run.source)) {
-    return;
-  }
-  const sourceKey2 = getSourceKey2(run.source);
-  if (!sourceKey2) {
+  const sourceKey2 = getSourceKey3(run.source);
+  if (!sourceKey2 || run.source.visibility === "private" && !run.actorUserId) {
     return;
   }
   const transcript = run.transcript.filter((entry) => entry.text?.trim()).map((entry) => ({ ...entry, text: entry.text.trim() }));
@@ -3125,8 +2937,10 @@ async function processMemorySession(context) {
   }
   const runtimeContext = memoryRuntimeContextSchema.parse({
     conversationId: run.conversationId,
+    ...run.locationId ? { locationId: run.locationId } : void 0,
     ...run.actor ? { actor: run.actor } : void 0,
-    source: run.source
+    source: run.source,
+    ...run.actorUserId ? { userId: run.actorUserId } : void 0
   });
   const agent = createMemoryAgent(context.model);
   const store = createMemoryStore(context.db, runtimeContext, {
@@ -3175,7 +2989,7 @@ async function processMemorySession(context) {
 import {
   definePromptContext
 } from "@sentry/junior-plugin-api";
-import { z as z10 } from "zod";
+import { z as z9 } from "zod";
 var RECALL_CANDIDATE_LIMIT = 20;
 var MAX_PROMPT_CHARS = 4e3;
 var MAX_MEMORY_LINE_CHARS = 600;
@@ -3189,16 +3003,17 @@ function trimContent(content, maxLength) {
 function formatObservedDate(observedAtMs) {
   return new Date(observedAtMs).toISOString().slice(0, 10);
 }
-var recalledMemorySchema = z10.object({
-  id: z10.string().min(1),
-  content: z10.string().min(1).max(MAX_MEMORY_LINE_CHARS),
-  observedAtMs: z10.number().finite(),
-  scope: z10.enum(["personal", "conversation"]),
-  kind: z10.enum(["preference", "procedure", "knowledge"])
+var recalledMemorySchema = z9.object({
+  id: z9.string().min(1),
+  content: z9.string().min(1).max(MAX_MEMORY_LINE_CHARS),
+  observedAtMs: z9.number().finite(),
+  // Stored version 1 uses the old scope labels. Prompt rendering ignores them.
+  scope: z9.enum(["personal", "conversation"]),
+  kind: z9.enum(["preference", "procedure", "knowledge"])
 }).strict();
-var memoryRecallContextSchema = z10.object({
+var memoryRecallContextSchema = z9.object({
   // Count is a safety rail only. Admission packs by MAX_PROMPT_CHARS.
-  memories: z10.array(recalledMemorySchema).min(1).max(RECALL_CANDIDATE_LIMIT)
+  memories: z9.array(recalledMemorySchema).min(1).max(RECALL_CANDIDATE_LIMIT)
 }).strict();
 function selectPromptMemories(memories) {
   const header = "Relevant memories for this request:";
@@ -3215,7 +3030,7 @@ function selectPromptMemories(memories) {
       id: memory.id,
       content,
       observedAtMs: memory.observedAtMs,
-      scope: memory.scope,
+      scope: memory.scope === "private" ? "personal" : "conversation",
       kind: memory.kind
     });
     totalChars += line.length + 1;
@@ -3255,10 +3070,13 @@ async function createMemoryPromptContributions(context) {
   if (!context.text.trim()) {
     return void 0;
   }
+  const actorUser = (await context.users.resolveActor())?.user;
   const runtimeContext = memoryRuntimeContextSchema.parse({
     ...context.conversationId ? { conversationId: context.conversationId } : void 0,
     ...context.actor ? { actor: context.actor } : void 0,
-    source: context.source
+    ...context.locationId ? { locationId: context.locationId } : void 0,
+    source: context.source,
+    ...actorUser ? { userId: actorUser.id } : void 0
   });
   let embeddingCostUsd;
   const sourceEmbedder = context.embedder;
@@ -3311,14 +3129,14 @@ async function createMemoryPromptContributions(context) {
 }
 
 // src/operational-report.ts
-import { and as and4, eq as eq5, gt as gt4, isNull as isNull3, or as or4, sql as sql4 } from "drizzle-orm";
-import { z as z11 } from "zod";
+import { and as and4, eq as eq5, gt as gt4, isNull as isNull4, or as or4, sql as sql4 } from "drizzle-orm";
+import { z as z10 } from "zod";
 var DAY_MS2 = 24 * 60 * 60 * 1e3;
 var WINDOWS = [7, 30, 90];
-var memoryDaySchema = z11.object({
-  conversation: z11.number().int().nonnegative(),
-  date: z11.string().date(),
-  personal: z11.number().int().nonnegative()
+var memoryDaySchema = z10.object({
+  date: z10.string().date(),
+  private: z10.number().int().nonnegative(),
+  public: z10.number().int().nonnegative()
 }).strict();
 function queryRows(result) {
   if (typeof result !== "object" || result === null || !("rows" in result) || !Array.isArray(result.rows)) {
@@ -3350,11 +3168,11 @@ async function aggregateMemoryDays(args) {
           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}
@@ -3365,13 +3183,13 @@ async function aggregateMemoryDays(args) {
     )
     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
   `);
-  return z11.array(memoryDaySchema).parse(queryRows(result));
+  return z10.array(memoryDaySchema).parse(queryRows(result));
 }
 function formatCount(value) {
   return new Intl.NumberFormat("en-US").format(value);
@@ -3393,18 +3211,18 @@ function formatUsd(value) {
 }
 async function buildMemoryOperationalReport(args) {
   const active = and4(
-    isNull3(juniorMemoryMemories.archivedAtMs),
-    isNull3(juniorMemoryMemories.supersededAtMs),
-    isNull3(juniorMemoryMemories.supersededById),
+    isNull4(juniorMemoryMemories.archivedAtMs),
+    isNull4(juniorMemoryMemories.supersededAtMs),
+    isNull4(juniorMemoryMemories.supersededById),
     or4(
-      isNull3(juniorMemoryMemories.expiresAtMs),
+      isNull4(juniorMemoryMemories.expiresAtMs),
       gt4(juniorMemoryMemories.expiresAtMs, args.nowMs)
     )
   );
   const [[counts], memoryDays] = await Promise.all([
     args.db.select({
       active: sql4`count(*) filter (where ${active})`.mapWith(Number),
-      conversation: sql4`count(*) filter (where ${active} and ${juniorMemoryMemories.scope} = 'conversation')`.mapWith(
+      public: sql4`count(*) filter (where ${active} and ${juniorMemoryMemories.scope} = 'public')`.mapWith(
         Number
       ),
       createdThirtyDays: sql4`count(*) filter (where ${juniorMemoryMemories.createdAtMs} >= ${args.nowMs - 30 * DAY_MS2})`.mapWith(
@@ -3413,7 +3231,7 @@ async function buildMemoryOperationalReport(args) {
       embedded: sql4`count(${juniorMemoryEmbeddings.memoryId}) filter (where ${active})`.mapWith(
         Number
       ),
-      personal: sql4`count(*) filter (where ${active} and ${juniorMemoryMemories.scope} = 'personal')`.mapWith(
+      private: sql4`count(*) filter (where ${active} and ${juniorMemoryMemories.scope} = 'private')`.mapWith(
         Number
       )
     }).from(juniorMemoryMemories).leftJoin(
@@ -3448,12 +3266,12 @@ 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",
@@ -3480,15 +3298,15 @@ 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",
@@ -3535,8 +3353,7 @@ function createMemoryUserPage() {
     navigation: "primary",
     description: "Personal and public memories Junior can use across conversations.",
     async read(ctx, input) {
-      const memories = createViewerMemories(ctx.db, ctx.viewer);
-      const page = await memories.list({
+      const page = await listMemories(ctx.db, ctx.viewer.id, {
         cursor: input.cursor,
         ...pageFilter(input.filter),
         limit: input.limit,
@@ -3597,7 +3414,9 @@ function memoryToolContext(ctx) {
     ...ctx.actor ? { actor: ctx.actor } : void 0,
     db: ctx.db,
     ...ctx.embedder ? { embedder: ctx.embedder } : void 0,
+    ...ctx.locationId ? { locationId: ctx.locationId } : void 0,
     source: ctx.source,
+    users: ctx.users,
     ...ctx.userText ? { userText: ctx.userText } : void 0
   };
 }
@@ -3684,9 +3503,11 @@ function memoryPlugin(options = {}) {
             db: ctx.db,
             embedder: ctx.embedder,
             events: ctx.events,
+            ...ctx.locationId ? { locationId: ctx.locationId } : void 0,
             log: ctx.log,
             source: ctx.source,
-            text: ctx.text
+            text: ctx.text,
+            users: ctx.users
           });
         }
       } : void 0