@sentry/junior-memory 0.118.0 → 0.120.0

package/dist/index.js

@@ -13,7 +13,6 @@ import {
   desc,
   eq,
   gt,
-  ilike,
   inArray,
   isNull,
   isNotNull,
@@ -106,6 +105,9 @@ var juniorMemoryMemories = pgTable(
     index("junior_memory_memories_expiration_idx").on(table.expiresAtMs).where(
       sql`${table.archivedAtMs} IS NULL AND ${table.expiresAtMs} IS NOT NULL`
     ),
+    index("junior_memory_memories_search_idx").using("gin", sql`to_tsvector('english', ${table.content})`).where(
+      sql`${table.archivedAtMs} IS NULL AND ${table.supersededAtMs} IS NULL AND ${table.supersededById} IS NULL`
+    ),
     uniqueIndex("junior_memory_memories_idempotency_idx").on(table.scope, table.scopeKey, table.idempotencyKey).where(
       sql`${table.idempotencyKey} IS NOT NULL AND ${table.archivedAtMs} IS NULL AND ${table.supersededAtMs} IS NULL AND ${table.supersededById} IS NULL`
     ),
@@ -167,6 +169,63 @@ var juniorMemoryEmbeddings = pgTable(
   ]
 );
 
+// src/ranking.ts
+var RECIPROCAL_RANK_FUSION_K = 60;
+var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
+function reciprocalRank(rank) {
+  return 1 / (RECIPROCAL_RANK_FUSION_K + rank);
+}
+function matchScore(match) {
+  return (match.vector ? reciprocalRank(match.vector.rank) : 0) + (match.lexical ? reciprocalRank(match.lexical.rank) : 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) {
+    return 3;
+  }
+  if (ageMs <= 30 * ONE_DAY_MS) {
+    return 2;
+  }
+  if (ageMs <= 90 * ONE_DAY_MS) {
+    return 1;
+  }
+  return 0;
+}
+function rankMemoryMatches(matches, options) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const match of matches) {
+    const existing = byId.get(match.memory.id);
+    if (!existing) {
+      byId.set(match.memory.id, match);
+      continue;
+    }
+    byId.set(match.memory.id, {
+      ...existing,
+      exactIdentifier: existing.exactIdentifier || match.exactIdentifier,
+      ...match.lexical ? { lexical: match.lexical } : {},
+      ...match.vector ? { vector: match.vector } : {}
+    });
+  }
+  return [...byId.values()].sort((left, right) => {
+    const identifierDelta = Number(right.exactIdentifier) - Number(left.exactIdentifier);
+    if (identifierDelta !== 0) {
+      return identifierDelta;
+    }
+    const scoreDelta = matchScore(right) - matchScore(left);
+    if (scoreDelta !== 0) {
+      return scoreDelta;
+    }
+    const channelDelta = Number(currentChannel(right, options.channelPrefix)) - Number(currentChannel(left, options.channelPrefix));
+    if (channelDelta !== 0) {
+      return channelDelta;
+    }
+    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
 import { isPrivateSource } from "@sentry/junior-plugin-api";
 function sourceConversationKey(ctx) {
@@ -239,15 +298,11 @@ function deriveVisibleMemoryScopes(ctx) {
 var DEFAULT_LIST_LIMIT = 50;
 var DEFAULT_SEARCH_LIMIT = 10;
 var DEFAULT_EXPIRED_ARCHIVE_LIMIT = 100;
-var HIGH_CONFIDENCE_DUPLICATE_DISTANCE = 0.015;
 var PREFERENCE_ADJUDICATION_CANDIDATE_LIMIT = 10;
 var PREFERENCE_ADJUDICATION_VECTOR_LIMIT = 5;
 var VECTOR_SEARCH_OVERFETCH = 4;
 var MAX_MEMORY_CONTENT_CHARS = 4e3;
 var EMBEDDING_METRIC = "cosine";
-var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
-var RELEVANCE_NEAR_TIE_DELTA = 0.01;
-var SOURCE_CHANNEL_BOOST = 0.05;
 var nonEmptyStringSchema2 = z2.string().min(1);
 var memoryContentSchema = z2.string().refine((content) => content.trim().length > 0, {
   message: "Memory content is required."
@@ -553,20 +608,26 @@ async function archiveExpiredMemoryBatch(args) {
   });
   return { archivedCount: archivedIds.length };
 }
-function searchScore(memory, terms) {
-  const haystack = memory.content.toLowerCase();
-  return terms.reduce(
-    (score, term) => score + (haystack.includes(term) ? 1 : 0),
-    0
-  );
-}
-function searchTerms(query) {
+function structuredQueryIdentifiers(query) {
+  const matches = query.toLowerCase().match(
+    /(?:[a-z0-9][a-z0-9._-]*\/)+[a-z0-9][a-z0-9._-]*|[a-z0-9]+(?:[._][a-z0-9]+)+|[a-z0-9]+(?:-[a-z0-9]+){2,}/g
+  ) ?? [];
   return [
-    ...new Set(
-      query.toLowerCase().split(/[^a-z0-9_'-]+/).map((term) => term.trim()).filter((term) => term.length >= 2)
-    )
+    ...new Set(matches.map((identifier) => identifier.replace(/\.+$/, "")))
   ];
 }
+function denseRanks(values, key) {
+  let previous;
+  let rank = 0;
+  return values.map((value, index2) => {
+    const current = key(value);
+    if (index2 === 0 || current !== previous) {
+      rank = index2 + 1;
+      previous = current;
+    }
+    return rank;
+  });
+}
 async function embedOne(embedder, text2) {
   const normalized = normalizeContent(text2);
   if (!normalized) {
@@ -657,38 +718,6 @@ async function findExactDuplicateMemory(args) {
   ).limit(1);
   return rows[0] ? parseMemoryRow(rows[0]) : void 0;
 }
-async function findVectorDuplicateMemory(args) {
-  const distance = cosineDistance(
-    juniorMemoryEmbeddings.embedding,
-    args.embedding.vector
-  );
-  const rows = await args.db.select({
-    contentHash: juniorMemoryEmbeddings.contentHash,
-    distance,
-    memory: juniorMemoryMemories
-  }).from(juniorMemoryMemories).innerJoin(
-    juniorMemoryEmbeddings,
-    eq(juniorMemoryEmbeddings.memoryId, juniorMemoryMemories.id)
-  ).where(
-    and(
-      activeScopedSubjectPredicate(args),
-      eq(juniorMemoryEmbeddings.provider, args.embedding.provider),
-      eq(juniorMemoryEmbeddings.model, args.embedding.model),
-      eq(juniorMemoryEmbeddings.dimensions, MEMORY_EMBEDDING_DIMENSIONS),
-      eq(juniorMemoryEmbeddings.metric, EMBEDDING_METRIC),
-      lte(distance, HIGH_CONFIDENCE_DUPLICATE_DISTANCE)
-    )
-  ).orderBy(
-    distance,
-    desc(juniorMemoryMemories.createdAtMs),
-    asc(juniorMemoryMemories.id)
-  ).limit(1);
-  const row = rows[0];
-  if (!row || hashEmbeddedContent(row.memory.content) !== row.contentHash) {
-    return void 0;
-  }
-  return parseMemoryRow(row.memory);
-}
 async function rememberDuplicateIdempotency(args) {
   if (args.idempotencyKey === void 0) {
     return;
@@ -823,29 +852,55 @@ async function listVisibleMemories(args) {
   ).limit(limit);
   return rows.map(parseMemoryRow);
 }
-async function searchVisibleMemories(args) {
-  const terms = searchTerms(args.query);
-  if (terms.length === 0) {
-    return [];
-  }
+async function searchVisibleLexicalMemories(args) {
   const predicate = activeVisiblePredicate(args);
   if (!predicate) {
     return [];
   }
-  const rows = await args.db.select().from(juniorMemoryMemories).where(
-    and(
-      predicate,
-      or(
-        ...terms.map(
-          (term) => ilike(juniorMemoryMemories.content, `%${term}%`)
-        )
-      )
+  const queryVector = sql2`to_tsvector('english', ${args.query})`;
+  const tsquery = sql2`(
+    SELECT COALESCE(
+      string_agg(quote_literal(term), ' | ')::tsquery,
+      ''::tsquery
     )
+    FROM unnest(tsvector_to_array(${queryVector})) AS query_terms(term)
+  )`;
+  const textsearch = sql2`to_tsvector('english', ${juniorMemoryMemories.content})`;
+  const textRank = sql2`ts_rank_cd(${textsearch}, ${tsquery})`;
+  const identifiers = structuredQueryIdentifiers(args.query);
+  const contentTokens = sql2`regexp_split_to_array(lower(${juniorMemoryMemories.content}), '[^a-z0-9._/-]+')`;
+  const identifierArray = identifiers.length > 0 ? sql2`ARRAY[${sql2.join(
+    identifiers.map((identifier) => sql2`${identifier}`),
+    sql2`, `
+  )}]::text[]` : void 0;
+  const exactIdentifierMatch = identifierArray !== void 0 ? sql2`EXISTS (
+          SELECT 1
+          FROM unnest(${contentTokens}) AS content_token(value)
+          CROSS JOIN unnest(${identifierArray}) AS query_identifier(value)
+          WHERE strpos(
+            '/' || regexp_replace(content_token.value, '\\.+$', '') || '/',
+            '/' || query_identifier.value || '/'
+          ) > 0
+        )` : sql2`false`;
+  const rows = await args.db.select({
+    exactIdentifierMatch,
+    memory: juniorMemoryMemories,
+    textRank
+  }).from(juniorMemoryMemories).where(and(predicate, sql2`${textsearch} @@ ${tsquery}`)).orderBy(
+    ...identifiers.length > 0 ? [desc(exactIdentifierMatch)] : [],
+    desc(textRank),
+    desc(juniorMemoryMemories.observedAtMs),
+    asc(juniorMemoryMemories.id)
+  ).limit(args.limit);
+  const ranks = denseRanks(
+    rows,
+    (row) => `${row.exactIdentifierMatch}:${Number(row.textRank)}`
   );
-  return rows.map((row) => ({
-    memory: parseMemoryRow(row),
-    score: 0,
-    sourceKey: row.sourceKey
+  return rows.map((row, index2) => ({
+    exactIdentifier: row.exactIdentifierMatch,
+    lexical: { rank: ranks[index2] },
+    memory: parseMemoryRow(row.memory),
+    sourceKey: row.memory.sourceKey
   }));
 }
 async function searchVisibleVectorMemories(args) {
@@ -886,7 +941,8 @@ async function searchVisibleVectorMemories(args) {
     desc(juniorMemoryMemories.createdAtMs),
     asc(juniorMemoryMemories.id)
   ).limit(args.limit);
-  return rows.flatMap((row) => {
+  const ranks = denseRanks(rows, (row) => Number(row.distance));
+  return rows.flatMap((row, index2) => {
     const distanceValue = Number(row.distance);
     if (row.distance === null || !Number.isFinite(distanceValue) || hashEmbeddedContent(row.memory.content) !== row.contentHash) {
       return [];
@@ -896,58 +952,16 @@ async function searchVisibleVectorMemories(args) {
     }
     return [
       {
+        exactIdentifier: false,
         memory: parseMemoryRow(row.memory),
-        score: 1 / (1 + Math.max(0, distanceValue)),
-        sourceKey: row.memory.sourceKey
+        sourceKey: row.memory.sourceKey,
+        vector: {
+          rank: ranks[index2]
+        }
       }
     ];
   });
 }
-function sourceBoost(candidate, currentChannelPrefix) {
-  if (!currentChannelPrefix) {
-    return 0;
-  }
-  return candidate.sourceKey.startsWith(currentChannelPrefix) ? SOURCE_CHANNEL_BOOST : 0;
-}
-function observedAgeBoost(memory, nowMs) {
-  const ageMs = Math.max(0, nowMs - memory.observedAtMs);
-  if (ageMs <= 7 * ONE_DAY_MS) {
-    return 0.15;
-  }
-  if (ageMs <= 30 * ONE_DAY_MS) {
-    return 0.1;
-  }
-  if (ageMs <= 90 * ONE_DAY_MS) {
-    return 0.05;
-  }
-  return 0;
-}
-function mergeSearchCandidates(candidates, nowMs, currentChannelKey) {
-  const byId = /* @__PURE__ */ new Map();
-  for (const candidate of candidates) {
-    const existing = byId.get(candidate.memory.id);
-    if (existing) {
-      existing.score += candidate.score;
-      continue;
-    }
-    byId.set(candidate.memory.id, {
-      memory: candidate.memory,
-      score: candidate.score,
-      sourceKey: candidate.sourceKey
-    });
-  }
-  return [...byId.values()].sort((left, right) => {
-    const scoreDelta = right.score - left.score;
-    if (Math.abs(scoreDelta) > RELEVANCE_NEAR_TIE_DELTA) {
-      return scoreDelta;
-    }
-    const sourceDelta = sourceBoost(right, currentChannelKey) - sourceBoost(left, currentChannelKey);
-    if (sourceDelta !== 0) {
-      return sourceDelta;
-    }
-    return observedAgeBoost(right.memory, nowMs) - observedAgeBoost(left.memory, nowMs) || right.memory.observedAtMs - left.memory.observedAtMs || left.memory.id.localeCompare(right.memory.id);
-  }).map((candidate) => candidate.memory);
-}
 function createMemoryStore(db, context, options = {}) {
   const runtimeContext2 = memoryRuntimeContextSchema.parse(context);
   const parsedOptions = memoryStoreOptionsSchema.parse({ now: options.now });
@@ -1044,24 +1058,6 @@ function createMemoryStore(db, context, options = {}) {
         candidateEmbedding = void 0;
       }
     }
-    const vectorDuplicate = candidateEmbedding ? await findVectorDuplicateMemory({
-      db,
-      embedding: candidateEmbedding,
-      kind: input.kind,
-      nowMs,
-      scope,
-      subject
-    }) : void 0;
-    if (vectorDuplicate) {
-      return await reuseDuplicateMemory({
-        content,
-        duplicate: vectorDuplicate,
-        idempotencyKey: input.idempotencyKey,
-        nowMs,
-        scope,
-        subject
-      });
-    }
     let supersededIds = [];
     if (scopeKind === "personal" && input.kind === "preference" && supersessionDecider && (input.expiresAtMs === void 0 || input.expiresAtMs > nowMs)) {
       const preferenceCandidates = await listPreferenceAdjudicationCandidates({
@@ -1169,6 +1165,41 @@ function createMemoryStore(db, context, options = {}) {
     });
     return { created: false, memory: idempotent };
   }
+  async function retrieveVisibleMemories(rawInput, vectorMaxDistance) {
+    const input = searchMemoriesInputSchema.parse(rawInput);
+    const nowMs = getNowMs();
+    const scopes = deriveVisibleMemoryScopes(runtimeContext2);
+    await archiveExpiredMemoryBatch({
+      db,
+      nowMs,
+      scopes
+    });
+    const limit = boundedLimit(input.limit, DEFAULT_SEARCH_LIMIT);
+    const candidateLimit = limit * VECTOR_SEARCH_OVERFETCH;
+    const [vectorMatches, lexicalMatches] = await Promise.all([
+      searchVisibleVectorMemories({
+        db,
+        embedder,
+        limit: candidateLimit,
+        ...vectorMaxDistance !== void 0 ? { maxDistance: vectorMaxDistance } : {},
+        nowMs,
+        query: input.query,
+        scopes
+      }),
+      searchVisibleLexicalMemories({
+        db,
+        limit: candidateLimit,
+        nowMs,
+        query: input.query,
+        scopes
+      })
+    ]);
+    const channelPrefix = sourceChannelPrefix(runtimeContext2);
+    return rankMemoryMatches([...vectorMatches, ...lexicalMatches], {
+      nowMs,
+      ...channelPrefix ? { channelPrefix } : {}
+    }).slice(0, limit).map(({ memory }) => memory);
+  }
   return {
     async archiveExpiredMemories(input) {
       return await archiveExpiredVisibleMemories(input, getNowMs());
@@ -1211,41 +1242,11 @@ function createMemoryStore(db, context, options = {}) {
         scopes
       });
     },
+    async recallMemories(input) {
+      return await retrieveVisibleMemories(input, maxVectorDistance);
+    },
     async searchMemories(input) {
-      input = searchMemoriesInputSchema.parse(input);
-      const nowMs = getNowMs();
-      const scopes = deriveVisibleMemoryScopes(runtimeContext2);
-      await archiveExpiredMemoryBatch({
-        db,
-        nowMs,
-        scopes
-      });
-      const limit = boundedLimit(input.limit, DEFAULT_SEARCH_LIMIT);
-      const vectorCandidates = await searchVisibleVectorMemories({
-        db,
-        embedder,
-        limit: limit * VECTOR_SEARCH_OVERFETCH,
-        ...maxVectorDistance !== void 0 ? { maxDistance: maxVectorDistance } : {},
-        nowMs,
-        query: input.query,
-        scopes
-      });
-      const candidates = await searchVisibleMemories({
-        db,
-        nowMs,
-        query: input.query,
-        scopes
-      });
-      const terms = searchTerms(input.query);
-      const lexicalCandidates = candidates.map((candidate) => ({
-        ...candidate,
-        score: searchScore(candidate.memory, terms)
-      })).filter((item) => item.score > 0);
-      return mergeSearchCandidates(
-        [...vectorCandidates, ...lexicalCandidates],
-        nowMs,
-        sourceChannelPrefix(runtimeContext2)
-      ).slice(0, limit);
+      return await retrieveVisibleMemories(input, void 0);
     },
     async archiveMemory(input) {
       input = archiveMemoryInputSchema.parse(input);
@@ -1294,6 +1295,19 @@ var memoryRejectReasonSchema = z3.enum([
   "assistant_or_system_detail",
   "unsupported_scope"
 ]);
+var memoryRecallCandidateSchema = z3.object({
+  content: z3.string().min(1),
+  id: z3.string().min(1)
+}).strict();
+var memoryRecallInputSchema = z3.object({
+  candidates: z3.array(memoryRecallCandidateSchema).min(1).max(20),
+  userRequest: z3.string().min(1)
+}).strict();
+var memoryRecallDecisionSchema = z3.object({
+  relevantIds: z3.array(z3.string().min(1)).max(20).describe(
+    "Candidate ids whose memories directly help with the current request, ordered by relevance."
+  )
+}).strict();
 var createMemoryRequestSchema = z3.object({
   content: z3.string().min(1),
   expiresAtMs: z3.number().finite().optional(),
@@ -1399,6 +1413,13 @@ var MEMORY_EXTRACTION_SYSTEM = [
   "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."
 ].join("\n");
+var MEMORY_RECALL_SYSTEM = [
+  "You are Junior's memory recall relevance agent.",
+  "Select only memories that would directly help answer the user's current request.",
+  "Reject memories that merely share a company, product family, repository vocabulary, programming language, or general engineering context.",
+  "Prefer specific matches on the exact repository, workflow, command, test, CI setup, project, or user preference being asked about.",
+  "An empty relevantIds array is correct when no candidate is directly helpful."
+].join("\n");
 var MEMORY_PREFERENCE_ADJUDICATION_SYSTEM = [
   "You are Junior's memory preference adjudication agent.",
   "Classify how one new actor preference relates to existing active actor preferences.",
@@ -1598,6 +1619,21 @@ function sessionExtractionPrompt(request) {
     "</memory-extraction-input>"
   ].join("\n");
 }
+function recallRelevancePrompt(request) {
+  return [
+    "<memory-recall-input>",
+    "<user-request>",
+    escapeXml(request.userRequest),
+    "</user-request>",
+    "",
+    "<candidate-memories>",
+    escapeXml(JSON.stringify(request.candidates)),
+    "</candidate-memories>",
+    "",
+    "Return only ids from candidate-memories. Preserve the most relevant candidates first.",
+    "</memory-recall-input>"
+  ].join("\n");
+}
 function preferenceAdjudicationPrompt(request) {
   return [
     "<memory-preference-adjudication-input>",
@@ -1630,6 +1666,20 @@ function preferenceAdjudicationPrompt(request) {
 }
 function createMemoryAgent(model) {
   return {
+    async selectRelevantMemories(rawRequest) {
+      const request = memoryRecallInputSchema.parse(rawRequest);
+      const result = await model.completeObject({
+        schema: memoryRecallDecisionSchema,
+        system: MEMORY_RECALL_SYSTEM,
+        prompt: recallRelevancePrompt(request),
+        maxTokens: 400
+      });
+      const decision = memoryRecallDecisionSchema.parse(result.object);
+      const candidateIds = new Set(request.candidates.map(({ id }) => id));
+      return [...new Set(decision.relevantIds)].filter(
+        (id) => candidateIds.has(id)
+      );
+    },
     async adjudicateSupersession(rawRequest) {
       const request = memorySupersessionInputSchema.parse(rawRequest);
       const result = await model.completeObject({
@@ -1698,9 +1748,317 @@ function parseCreateMemoryRequest(request) {
   return createMemoryRequestSchema.parse(request);
 }
 
+// src/api.ts
+import { z as z6 } 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, lt, or as or2, sql as sql3 } from "drizzle-orm";
+import { z as z4 } from "zod";
+var nonEmptyStringSchema3 = z4.string().min(1);
+var personalMemoryCursorSchema = z4.object({
+  createdAtMs: z4.number().finite(),
+  id: nonEmptyStringSchema3
+}).strict();
+var personalMemoryPageInputSchema = z4.object({
+  cursor: personalMemoryCursorSchema.optional(),
+  limit: z4.number().int().min(1).max(50),
+  query: z4.string().max(200).optional()
+}).strict();
+var PersonalMemoryNotFoundError = class extends Error {
+  constructor() {
+    super("Memory was not found for the authenticated viewer.");
+    this.name = "PersonalMemoryNotFoundError";
+  }
+};
+function personalScopes(runtimeContexts) {
+  return [
+    ...new Map(
+      runtimeContexts.map((context) => {
+        const scope = deriveMemoryScope(context, "personal");
+        return [`${scope.scope}:${scope.scopeKey}`, scope];
+      })
+    ).values()
+  ];
+}
+function searchTerms(query) {
+  return [
+    ...new Set(
+      query.toLowerCase().split(/[^a-z0-9_'-]+/).map((term) => term.trim()).filter((term) => term.length >= 2)
+    )
+  ];
+}
+function createPersonalMemoryCollection(db, runtimeContexts, options = {}) {
+  const scopes = personalScopes(runtimeContexts);
+  const getNowMs = () => options.now?.() ?? Date.now();
+  return {
+    async archive(id) {
+      const memoryId = nonEmptyStringSchema3.parse(id);
+      const nowMs = getNowMs();
+      const predicate = activeVisiblePredicate({ nowMs, scopes });
+      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 });
+      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 parseMemoryRow(rows[0]);
+    },
+    async list(input) {
+      input = personalMemoryPageInputSchema.parse(input);
+      const nowMs = getNowMs();
+      await archiveExpiredMemoryBatch({ db, nowMs, scopes });
+      const active = activeVisiblePredicate({ nowMs, scopes });
+      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 rows = await db.select().from(juniorMemoryMemories).where(and2(active, cursor, search)).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(parseMemoryRow);
+      const last = memories.at(-1);
+      return {
+        memories,
+        ...hasNextPage && last ? {
+          nextCursor: {
+            createdAtMs: last.createdAtMs,
+            id: last.id
+          }
+        } : {}
+      };
+    }
+  };
+}
+
+// src/personal.ts
+var cursorSchema = z5.object({
+  createdAtMs: z5.number().finite(),
+  id: z5.string().min(1),
+  query: z5.string().max(200).optional(),
+  version: z5.literal(1)
+}).strict();
+var InvalidMemoryCursorError = class extends Error {
+  constructor() {
+    super("Memory cursor is invalid.");
+    this.name = "InvalidMemoryCursorError";
+  }
+};
+function runtimeContext(actor) {
+  if (actor.platform === "slack") {
+    return {
+      actor,
+      source: {
+        platform: "slack",
+        type: "priv",
+        teamId: actor.teamId,
+        channelId: "DDASHBOARD"
+      }
+    };
+  }
+  return {
+    actor,
+    source: {
+      platform: "local",
+      type: "priv",
+      conversationId: "local:dashboard:memories"
+    }
+  };
+}
+function decodeCursor(value, query) {
+  if (!value) return void 0;
+  try {
+    const parsed = cursorSchema.parse(
+      JSON.parse(Buffer.from(value, "base64url").toString("utf8"))
+    );
+    if (parsed.query !== query) {
+      throw new InvalidMemoryCursorError();
+    }
+    return { createdAtMs: parsed.createdAtMs, id: parsed.id };
+  } catch {
+    throw new InvalidMemoryCursorError();
+  }
+}
+function encodeCursor(cursor, query) {
+  return Buffer.from(
+    JSON.stringify({ ...cursor, ...query ? { query } : {}, version: 1 }),
+    "utf8"
+  ).toString("base64url");
+}
+function createViewerMemories(db, actors) {
+  const collection = createPersonalMemoryCollection(
+    db,
+    actors.map(runtimeContext)
+  );
+  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 page = await collection.list({
+        cursor: decodeCursor(input.cursor, query),
+        limit: input.limit,
+        ...query ? { query } : {}
+      });
+      return {
+        memories: page.memories,
+        ...page.nextCursor ? { nextCursor: encodeCursor(page.nextCursor, query) } : {}
+      };
+    }
+  };
+}
+
+// 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()
+}).strict();
+var memoryListResponseSchema = z6.object({
+  memories: z6.array(memoryApiSchema),
+  nextCursor: z6.string().min(1).optional()
+}).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()
+}).strict();
+function json(body, status = 200) {
+  return Response.json(body, {
+    headers: { "cache-control": "no-store" },
+    status
+  });
+}
+function apiMemory(memory) {
+  return {
+    content: memory.content,
+    createdAt: new Date(memory.createdAtMs).toISOString(),
+    ...memory.expiresAtMs !== void 0 ? { expiresAt: new Date(memory.expiresAtMs).toISOString() } : {},
+    id: memory.id,
+    kind: memory.kind,
+    observedAt: new Date(memory.observedAtMs).toISOString()
+  };
+}
+function viewerEmail(context) {
+  const parsed = pluginApiRouteRequestContextSchema.safeParse(context);
+  if (!parsed.success || parsed.data.auth.user.emailVerified !== true) {
+    return void 0;
+  }
+  return parsed.data.auth.user.email?.trim().toLowerCase() || void 0;
+}
+function createMemoryApi(options) {
+  return {
+    async fetch(request, context) {
+      const email = viewerEmail(context);
+      if (!email) {
+        return json({ error: "Authentication required." }, 401);
+      }
+      const url = new URL(request.url);
+      const memoryPath = /^\/memories\/([^/]+)$/.exec(url.pathname);
+      const isCollection = url.pathname === "/memories";
+      if (!isCollection && !memoryPath) {
+        return json({ error: "Not found." }, 404);
+      }
+      const actors = await options.actors(email);
+      const memories = createViewerMemories(options.db, actors);
+      try {
+        if (isCollection && (request.method === "GET" || request.method === "HEAD")) {
+          const query = memoryListQuerySchema.parse({
+            cursor: url.searchParams.get("cursor") ?? void 0,
+            limit: url.searchParams.get("limit") ?? void 0,
+            q: url.searchParams.get("q") ?? void 0
+          });
+          const page = await memories.list({
+            cursor: query.cursor,
+            limit: query.limit,
+            ...query.q ? { query: query.q } : {}
+          });
+          const body = memoryListResponseSchema.parse({
+            memories: page.memories.map(apiMemory),
+            ...page.nextCursor ? { nextCursor: page.nextCursor } : {}
+          });
+          return request.method === "HEAD" ? new Response(null, {
+            headers: { "cache-control": "no-store" },
+            status: 200
+          }) : json(body);
+        }
+        if (memoryPath && (request.method === "GET" || request.method === "HEAD")) {
+          const memory = memoryApiSchema.parse(
+            apiMemory(await memories.get(decodeURIComponent(memoryPath[1])))
+          );
+          return request.method === "HEAD" ? new Response(null, {
+            headers: { "cache-control": "no-store" },
+            status: 200
+          }) : json(memory);
+        }
+        if (memoryPath && request.method === "DELETE") {
+          await memories.archive(decodeURIComponent(memoryPath[1]));
+          return new Response(null, {
+            headers: { "cache-control": "no-store" },
+            status: 204
+          });
+        }
+      } catch (error) {
+        if (error instanceof z6.ZodError || error instanceof InvalidMemoryCursorError) {
+          return json({ error: "Invalid memory request." }, 400);
+        }
+        if (error instanceof PersonalMemoryNotFoundError) {
+          return json({ error: error.message }, 404);
+        }
+        throw error;
+      }
+      return json({ error: "Method not allowed." }, 405);
+    }
+  };
+}
+
 // src/cli/search.ts
 import { InvalidArgumentError, Option } from "commander";
-import { and as and2, desc as desc2, eq as eq2, gt as gt2, ilike as ilike2, isNull as isNull2, or as or2 } from "drizzle-orm";
+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";
 
 // src/cli/format.ts
 function formatDate(ms) {
@@ -1742,13 +2100,13 @@ async function runSearch(ctx, queryParts, options) {
     )
   ];
   const db = ctx.db;
-  const activeExpirationPredicate = or2(
+  const activeExpirationPredicate = or3(
     isNull2(juniorMemoryMemories.expiresAtMs),
-    gt2(juniorMemoryMemories.expiresAtMs, nowMs)
+    gt3(juniorMemoryMemories.expiresAtMs, nowMs)
   );
   const predicates = [
-    eq2(juniorMemoryMemories.scope, options.scope),
-    eq2(juniorMemoryMemories.scopeKey, options.scopeKey),
+    eq3(juniorMemoryMemories.scope, options.scope),
+    eq3(juniorMemoryMemories.scopeKey, options.scopeKey),
     isNull2(juniorMemoryMemories.archivedAtMs),
     isNull2(juniorMemoryMemories.supersededAtMs),
     isNull2(juniorMemoryMemories.supersededById)
@@ -1757,14 +2115,14 @@ async function runSearch(ctx, queryParts, options) {
     predicates.push(activeExpirationPredicate);
   }
   if (terms.length > 0) {
-    const termPredicate = or2(
+    const termPredicate = or3(
       ...terms.map((term) => ilike2(juniorMemoryMemories.content, `%${term}%`))
     );
     if (termPredicate) {
       predicates.push(termPredicate);
     }
   }
-  const rows = await db.select().from(juniorMemoryMemories).where(and2(...predicates)).orderBy(desc2(juniorMemoryMemories.createdAtMs)).limit(options.limit);
+  const rows = await db.select().from(juniorMemoryMemories).where(and3(...predicates)).orderBy(desc3(juniorMemoryMemories.createdAtMs)).limit(options.limit);
   if (rows.length === 0) {
     await ctx.io.writeOutput("No memories matched.\n");
     return 0;
@@ -1794,10 +2152,10 @@ function configureMemorySearchCommand(parent, junior) {
 }
 
 // src/cli/show.ts
-import { eq as eq3 } from "drizzle-orm";
+import { eq as eq4 } from "drizzle-orm";
 async function runShow(ctx, id) {
   const db = ctx.db;
-  const rows = await db.select().from(juniorMemoryMemories).where(eq3(juniorMemoryMemories.id, id)).limit(1);
+  const rows = await db.select().from(juniorMemoryMemories).where(eq4(juniorMemoryMemories.id, id)).limit(1);
   if (!rows[0]) {
     await ctx.io.writeError(`Memory not found: ${id}
 `);
@@ -1836,7 +2194,7 @@ import {
   PluginToolInputError,
   pluginToolResultSchema
 } from "@sentry/junior-plugin-api";
-import { z as z4 } from "zod";
+import { z as z7 } from "zod";
 var MAX_TOOL_CONTENT_CHARS = 4e3;
 var DEFAULT_RESULT_LIMIT = 20;
 var DEFAULT_SEARCH_LIMIT2 = 10;
@@ -1963,23 +2321,23 @@ function requireMemoryContent(value) {
   }
   return value;
 }
-var createMemoryInputSchema2 = z4.object({
-  content: z4.string().min(1).max(MAX_TOOL_CONTENT_CHARS).describe(
+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."
   ),
-  expires_at: z4.string().min(1).describe(
+  expires_at: z7.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 = z4.object({
-  id: z4.string().min(1).describe("Memory id or unambiguous short id prefix to remove.")
+var removeMemoryInputSchema = z7.object({
+  id: z7.string().min(1).describe("Memory id or unambiguous short id prefix to remove.")
 }).strict();
-var listMemoriesInputSchema2 = z4.object({
-  limit: z4.number().min(1).max(50).describe("Maximum number of visible memories to return.").optional()
+var listMemoriesInputSchema2 = z7.object({
+  limit: z7.number().min(1).max(50).describe("Maximum number of visible memories to return.").optional()
 }).strict();
-var searchMemoriesInputSchema2 = z4.object({
-  query: z4.string().min(1).describe("Search query for visible memory content."),
-  limit: z4.number().min(1).max(50).describe("Maximum number of matching memories to return.").optional()
+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()
 }).strict();
 var memoryToolProjectionSchema = Type.Object(
   {
@@ -1991,44 +2349,44 @@ var memoryToolProjectionSchema = Type.Object(
   },
   { additionalProperties: false }
 );
-var memoryProjectionOutputSchema = z4.object({
-  id: z4.string(),
-  content: z4.string(),
-  createdAtMs: z4.number(),
-  observedAtMs: z4.number(),
-  expiresAtMs: z4.number().optional()
+var memoryProjectionOutputSchema = z7.object({
+  id: z7.string(),
+  content: z7.string(),
+  createdAtMs: z7.number(),
+  observedAtMs: z7.number(),
+  expiresAtMs: z7.number().optional()
 });
-var memoryCreateDataOutputSchema = z4.object({
-  created: z4.boolean(),
+var memoryCreateDataOutputSchema = z7.object({
+  created: z7.boolean(),
   memory: memoryProjectionOutputSchema
 });
-var memorySingleDataOutputSchema = z4.object({
+var memorySingleDataOutputSchema = z7.object({
   memory: memoryProjectionOutputSchema
 });
-var memoryManyDataOutputSchema = z4.object({
-  memories: z4.array(memoryProjectionOutputSchema)
+var memoryManyDataOutputSchema = z7.object({
+  memories: z7.array(memoryProjectionOutputSchema)
 });
 var memoryCreateOutputSchema = pluginToolResultSchema.extend({
-  ok: z4.literal(true),
-  status: z4.literal("success"),
-  target: z4.string(),
+  ok: z7.literal(true),
+  status: z7.literal("success"),
+  target: z7.string(),
   data: memoryCreateDataOutputSchema,
-  created: z4.boolean(),
+  created: z7.boolean(),
   memory: memoryProjectionOutputSchema
 });
 var memorySingleOutputSchema = pluginToolResultSchema.extend({
-  ok: z4.literal(true),
-  status: z4.literal("success"),
-  target: z4.string(),
+  ok: z7.literal(true),
+  status: z7.literal("success"),
+  target: z7.string(),
   data: memorySingleDataOutputSchema,
   memory: memoryProjectionOutputSchema
 });
 var memoryManyOutputSchema = pluginToolResultSchema.extend({
-  ok: z4.literal(true),
-  status: z4.literal("success"),
-  target: z4.string(),
+  ok: z7.literal(true),
+  status: z7.literal("success"),
+  target: z7.string(),
   data: memoryManyDataOutputSchema,
-  memories: z4.array(memoryProjectionOutputSchema)
+  memories: z7.array(memoryProjectionOutputSchema)
 });
 function parseMemoryToolInput(schema, input) {
   const result = schema.safeParse(input);
@@ -2219,7 +2577,7 @@ import {
   getSourceKey as getSourceKey2,
   isPrivateSource as isPrivateSource2
 } from "@sentry/junior-plugin-api";
-import { z as z5 } from "zod";
+import { z as z8 } from "zod";
 var MEMORY_TOOL_NAMES = /* @__PURE__ */ new Set([
   "createMemory",
   "listMemories",
@@ -2227,12 +2585,12 @@ var MEMORY_TOOL_NAMES = /* @__PURE__ */ new Set([
   "searchMemories"
 ]);
 var MEMORY_TASK_STATE_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
-var extractedMemoryCacheSchema = z5.array(
-  z5.object({
-    content: z5.string().min(1),
-    expiresAtMs: z5.number().finite().nullable(),
-    kind: z5.enum(MEMORY_KINDS),
-    evidenceMessageIndices: z5.array(z5.number().int().nonnegative()).min(1).max(10)
+var extractedMemoryCacheSchema = z8.array(
+  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)
 );
 function isRunActorInstruction(entry) {
@@ -2371,8 +2729,9 @@ async function processMemorySession(context) {
 import {
   definePromptContext
 } from "@sentry/junior-plugin-api";
-import { z as z6 } from "zod";
+import { z as z9 } from "zod";
 var DEFAULT_RECALL_LIMIT = 5;
+var RECALL_CANDIDATE_LIMIT = 20;
 var MAX_PROMPT_CHARS = 4e3;
 var MAX_MEMORY_LINE_CHARS = 600;
 function trimContent(content, maxLength) {
@@ -2385,15 +2744,15 @@ function trimContent(content, maxLength) {
 function formatObservedDate(observedAtMs) {
   return new Date(observedAtMs).toISOString().slice(0, 10);
 }
-var recalledMemorySchema = z6.object({
-  id: z6.string().min(1),
-  content: z6.string().min(1).max(MAX_MEMORY_LINE_CHARS),
-  observedAtMs: z6.number().finite(),
-  scope: z6.enum(["personal", "conversation"]),
-  kind: z6.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(),
+  scope: z9.enum(["personal", "conversation"]),
+  kind: z9.enum(["preference", "procedure", "knowledge"])
 }).strict();
-var memoryRecallContextSchema = z6.object({
-  memories: z6.array(recalledMemorySchema).min(1).max(DEFAULT_RECALL_LIMIT)
+var memoryRecallContextSchema = z9.object({
+  memories: z9.array(recalledMemorySchema).min(1).max(DEFAULT_RECALL_LIMIT)
 }).strict();
 function selectPromptMemories(memories) {
   const header = "Relevant memories for this request:";
@@ -2442,14 +2801,31 @@ async function createMemoryPromptContributions(context) {
     ...context.actor ? { actor: context.actor } : {},
     source: context.source
   });
-  const memories = await createMemoryStore(context.db, runtimeContext2, {
+  const candidates = await createMemoryStore(context.db, runtimeContext2, {
     ...context.embedder ? { embedder: context.embedder } : {},
     ...context.maxVectorDistance !== void 0 ? { maxVectorDistance: context.maxVectorDistance } : {}
-  }).searchMemories({
+  }).recallMemories({
     query: context.text,
-    limit: DEFAULT_RECALL_LIMIT
+    limit: RECALL_CANDIDATE_LIMIT
   });
-  const selected = selectPromptMemories(memories);
+  if (candidates.length === 0) {
+    return void 0;
+  }
+  let relevantIds;
+  try {
+    relevantIds = await context.agent.selectRelevantMemories({
+      candidates: candidates.map(({ content, id }) => ({ content, id })),
+      userRequest: context.text
+    });
+  } catch {
+    context.log.warn("memory_recall_selection_failed");
+    return void 0;
+  }
+  const candidatesById = new Map(
+    candidates.map((memory) => [memory.id, memory])
+  );
+  const relevant = relevantIds.map((id) => candidatesById.get(id)).filter((memory) => memory !== void 0).slice(0, DEFAULT_RECALL_LIMIT);
+  const selected = selectPromptMemories(relevant);
   if (selected.length === 0) {
     return void 0;
   }
@@ -2460,28 +2836,6 @@ async function createMemoryPromptContributions(context) {
 }
 
 // src/user-pages.ts
-var MEMORY_PAGE_LIMIT = 100;
-function runtimeContext(actor) {
-  if (actor.platform === "slack") {
-    return {
-      actor,
-      source: {
-        platform: "slack",
-        type: "priv",
-        teamId: actor.teamId,
-        channelId: "DDASHBOARD"
-      }
-    };
-  }
-  return {
-    actor,
-    source: {
-      platform: "local",
-      type: "priv",
-      conversationId: "local:dashboard:memories"
-    }
-  };
-}
 function memoryKindLabel(kind) {
   return kind.charAt(0).toUpperCase() + kind.slice(1);
 }
@@ -2491,35 +2845,35 @@ function rememberedDate(createdAtMs) {
     timeZone: "UTC"
   }).format(new Date(createdAtMs));
 }
-async function readPersonalMemories(db, actors) {
-  const memories = await Promise.all(
-    actors.flatMap((actor) => {
-      const context = runtimeContext(actor);
-      return context ? [
-        createMemoryStore(db, context).listPersonalMemories({
-          limit: MEMORY_PAGE_LIMIT
-        })
-      ] : [];
-    })
-  );
-  return [
-    ...new Map(memories.flat().map((memory) => [memory.id, memory])).values()
-  ].sort((left, right) => right.createdAtMs - left.createdAtMs).slice(0, MEMORY_PAGE_LIMIT);
-}
 function createMemoryUserPage() {
   return {
     id: "memories",
     label: "Memories",
     description: "Personal facts and preferences Junior remembers about you.",
-    async read(ctx) {
-      const memories = await readPersonalMemories(
+    async read(ctx, input) {
+      const page = await createViewerMemories(
         ctx.db,
         ctx.viewer.actors
-      );
+      ).list({
+        cursor: input.cursor,
+        limit: input.limit,
+        ...input.query ? { query: input.query } : {}
+      });
       return {
         type: "list",
-        emptyText: "No personal memories yet.",
-        records: memories.map((memory) => ({
+        emptyText: input.query ? "No memories matched your search." : "No personal memories yet.",
+        ...page.nextCursor ? { nextCursor: page.nextCursor } : {},
+        searchPlaceholder: "Search memories",
+        records: page.memories.map((memory) => ({
+          actions: [
+            {
+              confirmation: "Forget this memory?",
+              href: `/api/plugins/memory/memories/${encodeURIComponent(memory.id)}`,
+              label: "Forget",
+              method: "DELETE",
+              tone: "danger"
+            }
+          ],
           id: memory.id,
           title: memory.content,
           metadata: [
@@ -2574,7 +2928,7 @@ function memoryCreateToolContext(ctx) {
     supersessionDecider: ctx.supersessionDecider
   };
 }
-function createMemoryPlugin(options = {}) {
+function memoryPlugin(options = {}) {
   const modelId = memoryModelId(options);
   return defineJuniorPlugin({
     manifest: {
@@ -2596,6 +2950,12 @@ function createMemoryPlugin(options = {}) {
     },
     userPages: [createMemoryUserPage()],
     hooks: {
+      apiRoutes(ctx) {
+        return createMemoryApi({
+          actors: ctx.viewer.actors,
+          db: ctx.db
+        });
+      },
       tools(ctx) {
         const agent = createMemoryAgent(ctx.model);
         const context = memoryToolContext({
@@ -2621,10 +2981,12 @@ function createMemoryPlugin(options = {}) {
       },
       async userPrompt(ctx) {
         return await createMemoryPromptContributions({
+          agent: createMemoryAgent(ctx.model),
           ...ctx.conversationId ? { conversationId: ctx.conversationId } : {},
           ...ctx.actor ? { actor: ctx.actor } : {},
           db: ctx.db,
           embedder: ctx.embedder,
+          log: ctx.log,
           maxVectorDistance: recallMaxVectorDistance(options),
           source: ctx.source,
           text: ctx.text
@@ -2633,11 +2995,11 @@ function createMemoryPlugin(options = {}) {
     }
   });
 }
-var memoryPlugin = createMemoryPlugin();
 export {
   MEMORY_KINDS,
-  createMemoryPlugin,
   createMemoryStore,
+  memoryApiSchema,
+  memoryListResponseSchema,
   memoryPlugin
 };
 //# sourceMappingURL=index.js.map