@sentry/junior-memory 0.124.0 → 0.124.2

package/dist/api.d.ts

@@ -1,8 +1,9 @@
 /**
- * Authenticated REST resources for personal memories.
+ * Authenticated REST resources for viewer-visible memories.
  *
  * HTTP identity is one verified viewer. Linked platform actors are resolved
- * behind the route boundary and used only to authorize personal scopes.
+ * behind the route boundary and used only to authorize personal and public
+ * workspace scopes.
  */
 import { z } from "zod";
 import { type PluginRouteApp, type PluginUserPageActor } from "@sentry/junior-plugin-api";
@@ -18,6 +19,10 @@ export declare const memoryApiSchema: z.ZodObject<{
         knowledge: "knowledge";
     }>;
     observedAt: z.ZodISODateTime;
+    visibility: z.ZodEnum<{
+        public: "public";
+        private: "private";
+    }>;
 }, z.core.$strict>;
 export declare const memoryListResponseSchema: z.ZodObject<{
     memories: z.ZodArray<z.ZodObject<{
@@ -31,15 +36,40 @@ export declare const memoryListResponseSchema: z.ZodObject<{
             knowledge: "knowledge";
         }>;
         observedAt: z.ZodISODateTime;
+        visibility: z.ZodEnum<{
+            public: "public";
+            private: "private";
+        }>;
     }, z.core.$strict>>;
     nextCursor: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
+export declare const memoryDashboardResponseSchema: z.ZodObject<{
+    days: z.ZodArray<z.ZodObject<{
+        date: z.ZodISODate;
+        personal: z.ZodNumber;
+        public: z.ZodNumber;
+    }, z.core.$strict>>;
+    generatedAt: z.ZodISODateTime;
+    stats: z.ZodObject<{
+        active: z.ZodNumber;
+        automatic: z.ZodNumber;
+        createdThirtyDays: z.ZodNumber;
+        embedded: z.ZodNumber;
+        explicit: z.ZodNumber;
+        knowledge: z.ZodNumber;
+        personal: z.ZodNumber;
+        preference: z.ZodNumber;
+        procedure: z.ZodNumber;
+        public: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
 export type MemoryApi = z.output<typeof memoryApiSchema>;
+export type MemoryDashboardResponse = z.output<typeof memoryDashboardResponseSchema>;
 export type MemoryListResponse = z.output<typeof memoryListResponseSchema>;
 interface MemoryApiOptions {
     actors(email: string): Promise<PluginUserPageActor[]>;
     db: MemoryDb;
 }
-/** Create the authenticated personal-memory REST app. */
+/** Create the authenticated viewer-memory REST app. */
 export declare function createMemoryApi(options: MemoryApiOptions): PluginRouteApp;
 export {};

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { memoryPlugin } from "./plugin";
-export { memoryApiSchema, memoryListResponseSchema, type MemoryApi, type MemoryListResponse, } from "./api";
+export { memoryApiSchema, memoryDashboardResponseSchema, memoryListResponseSchema, type MemoryApi, type MemoryDashboardResponse, type MemoryListResponse, } from "./api";
 export type { MemoryPluginOptions } from "./plugin";
 export { createMemoryStore } from "./store";
 export type { ArchiveMemoryInput, CreateMemoryInput, CreateMemoryResult, ListMemoriesInput, MemoryDb, MemoryEmbeddingProvider, MemoryRecord, MemoryStore, MemoryStoreOptions, SearchMemoriesInput, } from "./store";

package/dist/index.js

@@ -496,12 +496,12 @@ function visibleScopePredicate(scopes) {
   );
 }
 function activeVisiblePredicate(args) {
-  const scopePredicate = visibleScopePredicate(args.scopes);
-  if (!scopePredicate) {
+  const scopePredicate2 = visibleScopePredicate(args.scopes);
+  if (!scopePredicate2) {
     return void 0;
   }
   return and(
-    scopePredicate,
+    scopePredicate2,
     isNull(juniorMemoryMemories.archivedAtMs),
     isNull(juniorMemoryMemories.supersededAtMs),
     isNull(juniorMemoryMemories.supersededById),
@@ -571,12 +571,12 @@ async function findByIdempotencyKey(args) {
   return void 0;
 }
 async function archiveExpiredMemoryBatch(args) {
-  const scopePredicate = visibleScopePredicate(args.scopes);
-  if (!scopePredicate) {
+  const scopePredicate2 = visibleScopePredicate(args.scopes);
+  if (!scopePredicate2) {
     return { archivedCount: 0 };
   }
   const predicates = [
-    scopePredicate,
+    scopePredicate2,
     isNull(juniorMemoryMemories.archivedAtMs),
     isNull(juniorMemoryMemories.supersededAtMs),
     isNull(juniorMemoryMemories.supersededById),
@@ -1762,18 +1762,26 @@ import {
 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 { 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";
 import { z as z4 } from "zod";
 var nonEmptyStringSchema3 = z4.string().min(1);
+var memoryVisibilitySchema = z4.enum(["private", "public"]);
 var personalMemoryCursorSchema = z4.object({
   createdAtMs: z4.number().finite(),
   id: nonEmptyStringSchema3
 }).strict();
 var personalMemoryPageInputSchema = z4.object({
   cursor: personalMemoryCursorSchema.optional(),
+  kind: z4.enum(MEMORY_KINDS).optional(),
   limit: z4.number().int().min(1).max(50),
-  query: z4.string().max(200).optional()
+  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 {
   constructor() {
     super("Memory was not found for the authenticated viewer.");
@@ -1790,6 +1798,39 @@ function personalScopes(runtimeContexts) {
     ).values()
   ];
 }
+function publicWorkspaceScopes(runtimeContexts) {
+  return [
+    ...new Map(
+      runtimeContexts.flatMap((context) => {
+        if (context.source.platform !== "slack" || !context.actor) {
+          return [];
+        }
+        if (context.actor.platform !== "slack") {
+          return [];
+        }
+        const scope = {
+          scope: "conversation",
+          scopeKey: `slack:${context.actor.teamId}`
+        };
+        return [[`${scope.scope}:${scope.scopeKey}`, scope]];
+      })
+    ).values()
+  ];
+}
+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 utcDate(ms) {
+  return new Date(ms).toISOString().slice(0, 10);
+}
 function searchTerms(query) {
   return [
     ...new Set(
@@ -1797,14 +1838,55 @@ function searchTerms(query) {
     )
   ];
 }
+function memoryOrigin(idempotencyKey) {
+  if (idempotencyKey?.startsWith("session:")) return "automatic";
+  if (idempotencyKey?.startsWith("tool:")) return "explicit";
+  return "other";
+}
+function memoryVisibility(scope) {
+  return scope === "personal" ? "private" : "public";
+}
+function personalMemoryRecord(row) {
+  const memory = parseMemoryRow(row);
+  return {
+    ...memory,
+    origin: memoryOrigin(row.idempotencyKey),
+    sourcePlatform: row.sourcePlatform,
+    visibility: memoryVisibility(memory.scope)
+  };
+}
+function emptyStats() {
+  return {
+    active: 0,
+    automatic: 0,
+    createdThirtyDays: 0,
+    embedded: 0,
+    explicit: 0,
+    knowledge: 0,
+    personal: 0,
+    preference: 0,
+    procedure: 0,
+    public: 0
+  };
+}
 function createPersonalMemoryCollection(db, runtimeContexts, options = {}) {
-  const scopes = personalScopes(runtimeContexts);
+  const privateScopes = personalScopes(runtimeContexts);
+  const publicScopes = publicWorkspaceScopes(runtimeContexts);
+  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 });
+      const predicate = activeVisiblePredicate({
+        nowMs,
+        scopes: privateScopes
+      });
       if (!predicate) {
         throw new PersonalMemoryNotFoundError();
       }
@@ -1821,7 +1903,7 @@ function createPersonalMemoryCollection(db, runtimeContexts, options = {}) {
     async get(id) {
       const memoryId = nonEmptyStringSchema3.parse(id);
       const nowMs = getNowMs();
-      const predicate = activeVisiblePredicate({ nowMs, scopes });
+      const predicate = activeVisiblePredicate({ nowMs, scopes: allScopes });
       if (!predicate) {
         throw new PersonalMemoryNotFoundError();
       }
@@ -1829,11 +1911,12 @@ function createPersonalMemoryCollection(db, runtimeContexts, options = {}) {
       if (!rows[0]) {
         throw new PersonalMemoryNotFoundError();
       }
-      return parseMemoryRow(rows[0]);
+      return personalMemoryRecord(rows[0]);
     },
     async list(input) {
       input = personalMemoryPageInputSchema.parse(input);
       const nowMs = getNowMs();
+      const scopes = scopesForVisibility(input.visibility);
       await archiveExpiredMemoryBatch({ db, nowMs, scopes });
       const active = activeVisiblePredicate({ nowMs, scopes });
       if (!active) {
@@ -1852,12 +1935,14 @@ function createPersonalMemoryCollection(db, runtimeContexts, options = {}) {
           (term) => ilike(juniorMemoryMemories.content, `%${term}%`)
         )
       );
-      const rows = await db.select().from(juniorMemoryMemories).where(and2(active, cursor, search)).orderBy(
+      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(parseMemoryRow);
+      const memories = rows.slice(0, input.limit).map(personalMemoryRecord);
       const last = memories.at(-1);
       return {
         memories,
@@ -1868,6 +1953,97 @@ function createPersonalMemoryCollection(db, runtimeContexts, options = {}) {
           }
         } : {}
       };
+    },
+    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
+        };
+      });
     }
   };
 }
@@ -1876,8 +2052,11 @@ function createPersonalMemoryCollection(db, runtimeContexts, options = {}) {
 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)
+  version: z5.literal(1),
+  visibility: z5.enum(["private", "public"]).optional()
 }).strict();
 var InvalidMemoryCursorError = class extends Error {
   constructor() {
@@ -1906,13 +2085,13 @@ function runtimeContext(actor) {
     }
   };
 }
-function decodeCursor(value, query) {
+function decodeCursor(value, input) {
   if (!value) return void 0;
   try {
     const parsed = cursorSchema.parse(
       JSON.parse(Buffer.from(value, "base64url").toString("utf8"))
     );
-    if (parsed.query !== query) {
+    if (parsed.query !== input.query || parsed.kind !== input.kind || parsed.origin !== input.origin || parsed.visibility !== input.visibility) {
       throw new InvalidMemoryCursorError();
     }
     return { createdAtMs: parsed.createdAtMs, id: parsed.id };
@@ -1920,9 +2099,16 @@ function decodeCursor(value, query) {
     throw new InvalidMemoryCursorError();
   }
 }
-function encodeCursor(cursor, query) {
+function encodeCursor(cursor, input) {
   return Buffer.from(
-    JSON.stringify({ ...cursor, ...query ? { query } : {}, version: 1 }),
+    JSON.stringify({
+      ...cursor,
+      ...input.query ? { query: input.query } : {},
+      ...input.kind ? { kind: input.kind } : {},
+      ...input.origin ? { origin: input.origin } : {},
+      ...input.visibility ? { visibility: input.visibility } : {},
+      version: 1
+    }),
     "utf8"
   ).toString("base64url");
 }
@@ -1940,15 +2126,27 @@ function createViewerMemories(db, actors) {
     },
     async list(input) {
       const query = input.query?.trim() || void 0;
+      const filters = {
+        ...input.kind ? { kind: input.kind } : {},
+        ...input.origin ? { origin: input.origin } : {},
+        ...query ? { query } : {},
+        ...input.visibility ? { visibility: input.visibility } : {}
+      };
       const page = await collection.list({
-        cursor: decodeCursor(input.cursor, query),
-        limit: input.limit,
-        ...query ? { query } : {}
+        cursor: decodeCursor(input.cursor, filters),
+        ...filters,
+        limit: input.limit
       });
       return {
         memories: page.memories,
-        ...page.nextCursor ? { nextCursor: encodeCursor(page.nextCursor, query) } : {}
+        ...page.nextCursor ? { nextCursor: encodeCursor(page.nextCursor, filters) } : {}
       };
+    },
+    async stats() {
+      return await collection.stats();
+    },
+    async timeline(input) {
+      return await collection.timeline(input);
     }
   };
 }
@@ -1960,12 +2158,34 @@ var memoryApiSchema = z6.object({
   expiresAt: z6.iso.datetime().optional(),
   id: z6.string().min(1),
   kind: z6.enum(["preference", "procedure", "knowledge"]),
-  observedAt: z6.iso.datetime()
+  observedAt: z6.iso.datetime(),
+  visibility: z6.enum(["private", "public"])
 }).strict();
 var memoryListResponseSchema = z6.object({
   memories: z6.array(memoryApiSchema),
   nextCursor: z6.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)
+}).strict();
+var memoryDashboardResponseSchema = z6.object({
+  days: z6.array(memoryDashboardDaySchema).length(90),
+  generatedAt: z6.iso.datetime(),
+  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)
+  }).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),
@@ -1984,7 +2204,8 @@ function apiMemory(memory) {
     ...memory.expiresAtMs !== void 0 ? { expiresAt: new Date(memory.expiresAtMs).toISOString() } : {},
     id: memory.id,
     kind: memory.kind,
-    observedAt: new Date(memory.observedAtMs).toISOString()
+    observedAt: new Date(memory.observedAtMs).toISOString(),
+    visibility: memory.visibility
   };
 }
 function viewerEmail(context) {
@@ -2004,12 +2225,28 @@ function createMemoryApi(options) {
       const url = new URL(request.url);
       const memoryPath = /^\/memories\/([^/]+)$/.exec(url.pathname);
       const isCollection = url.pathname === "/memories";
-      if (!isCollection && !memoryPath) {
+      const isDashboard = url.pathname === "/dashboard";
+      if (!isCollection && !isDashboard && !memoryPath) {
         return json({ error: "Not found." }, 404);
       }
       const actors = await options.actors(email);
       const memories = createViewerMemories(options.db, actors);
       try {
+        if (isDashboard && (request.method === "GET" || request.method === "HEAD")) {
+          const [stats, days] = await Promise.all([
+            memories.stats(),
+            memories.timeline({ days: 90 })
+          ]);
+          const body = memoryDashboardResponseSchema.parse({
+            days,
+            generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            stats
+          });
+          return request.method === "HEAD" ? new Response(null, {
+            headers: { "cache-control": "no-store" },
+            status: 200
+          }) : json(body);
+        }
         if (isCollection && (request.method === "GET" || request.method === "HEAD")) {
           const query = memoryListQuerySchema.parse({
             cursor: url.searchParams.get("cursor") ?? void 0,
@@ -2925,7 +3162,7 @@ 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";
-var DAY_MS = 24 * 60 * 60 * 1e3;
+var DAY_MS2 = 24 * 60 * 60 * 1e3;
 var WINDOWS = [7, 30, 90];
 var memoryDaySchema = z11.object({
   conversation: z11.number().int().nonnegative(),
@@ -2945,8 +3182,8 @@ function startOfUtcDay(value) {
 }
 async function aggregateMemoryDays(args) {
   const end = startOfUtcDay(args.nowMs);
-  const start = startOfUtcDay(args.nowMs - (WINDOWS.at(-1) - 1) * DAY_MS);
-  const endExclusiveMs = end.getTime() + DAY_MS;
+  const start = startOfUtcDay(args.nowMs - (WINDOWS.at(-1) - 1) * DAY_MS2);
+  const endExclusiveMs = end.getTime() + DAY_MS2;
   const table = juniorMemoryMemories;
   const result = await args.db.execute(sql4`
     WITH days AS (
@@ -3010,7 +3247,7 @@ async function buildMemoryOperationalReport(args) {
       conversation: sql4`count(*) filter (where ${active} and ${juniorMemoryMemories.scope} = 'conversation')`.mapWith(
         Number
       ),
-      createdThirtyDays: sql4`count(*) filter (where ${juniorMemoryMemories.createdAtMs} >= ${args.nowMs - 30 * DAY_MS})`.mapWith(
+      createdThirtyDays: sql4`count(*) filter (where ${juniorMemoryMemories.createdAtMs} >= ${args.nowMs - 30 * DAY_MS2})`.mapWith(
         Number
       ),
       embedded: sql4`count(${juniorMemoryEmbeddings.memoryId}) filter (where ${active})`.mapWith(
@@ -3080,36 +3317,59 @@ async function buildMemoryOperationalReport(args) {
 }
 
 // src/user-pages.ts
-function memoryKindLabel(kind) {
-  return kind.charAt(0).toUpperCase() + kind.slice(1);
+function titleCase(value) {
+  return value.charAt(0).toUpperCase() + value.slice(1);
 }
 function rememberedDate(createdAtMs) {
   return new Intl.DateTimeFormat("en-US", {
     dateStyle: "medium",
+    timeStyle: "short",
     timeZone: "UTC"
   }).format(new Date(createdAtMs));
 }
+function originLabel(origin) {
+  if (origin === "automatic") return "Automatic";
+  if (origin === "explicit") return "Explicit";
+  return "Other";
+}
+function visibilityLabel(visibility) {
+  return visibility === "public" ? "Public" : "Private";
+}
+function pageFilter(filter) {
+  if (filter === "private") return { visibility: "private" };
+  if (filter === "public") return { visibility: "public" };
+  return {};
+}
+function pageEmptyText(input) {
+  if (input.query) return "No memories matched your search.";
+  if (input.filter === "private") return "No private memories yet.";
+  if (input.filter === "public") return "No public memories yet.";
+  return "No memories yet.";
+}
 function createMemoryUserPage() {
   return {
     id: "memories",
     label: "Memories",
-    description: "Personal facts and preferences Junior remembers about you.",
+    navigation: "primary",
+    description: "Personal and public memories Junior can use across conversations.",
     async read(ctx, input) {
-      const page = await createViewerMemories(
+      const memories = createViewerMemories(
         ctx.db,
         ctx.viewer.actors
-      ).list({
+      );
+      const page = await memories.list({
         cursor: input.cursor,
+        ...pageFilter(input.filter),
         limit: input.limit,
         ...input.query ? { query: input.query } : {}
       });
       return {
         type: "list",
-        emptyText: input.query ? "No memories matched your search." : "No personal memories yet.",
+        emptyText: pageEmptyText(input),
         ...page.nextCursor ? { nextCursor: page.nextCursor } : {},
         searchPlaceholder: "Search memories",
         records: page.memories.map((memory) => ({
-          actions: [
+          actions: memory.visibility === "private" ? [
             {
               confirmation: "Forget this memory?",
               href: `/api/plugins/memory/memories/${encodeURIComponent(memory.id)}`,
@@ -3117,12 +3377,23 @@ function createMemoryUserPage() {
               method: "DELETE",
               tone: "danger"
             }
-          ],
+          ] : [],
           id: memory.id,
           title: memory.content,
           metadata: [
-            { label: "Type", value: memoryKindLabel(memory.kind) },
-            { label: "Remembered", value: rememberedDate(memory.createdAtMs) }
+            { label: "Type", value: titleCase(memory.kind) },
+            { label: "Learned", value: originLabel(memory.origin) },
+            { label: "Source", value: titleCase(memory.sourcePlatform) },
+            {
+              label: "Visibility",
+              value: visibilityLabel(memory.visibility)
+            },
+            { label: "Remembered", value: rememberedDate(memory.createdAtMs) },
+            { label: "Observed", value: rememberedDate(memory.observedAtMs) },
+            {
+              label: "Expires",
+              value: memory.expiresAtMs ? rememberedDate(memory.expiresAtMs) : "Never"
+            }
           ]
         }))
       };
@@ -3250,6 +3521,7 @@ export {
   MEMORY_KINDS,
   createMemoryStore,
   memoryApiSchema,
+  memoryDashboardResponseSchema,
   memoryListResponseSchema,
   memoryPlugin
 };