@sentry/junior-memory 0.124.0 → 0.124.1

package/dist/personal-store.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { type MemoryDb, type MemoryRecord } from "./store";
-import type { MemoryRuntimeContext } from "./types";
+import { type MemoryRuntimeContext } from "./types";
 declare const personalMemoryCursorSchema: z.ZodObject<{
     createdAtMs: z.ZodNumber;
     id: z.ZodString;
@@ -10,15 +10,47 @@ declare const personalMemoryPageInputSchema: z.ZodObject<{
         createdAtMs: z.ZodNumber;
         id: z.ZodString;
     }, z.core.$strict>>;
+    kind: z.ZodOptional<z.ZodEnum<{
+        preference: "preference";
+        procedure: "procedure";
+        knowledge: "knowledge";
+    }>>;
     limit: z.ZodNumber;
+    origin: z.ZodOptional<z.ZodEnum<{
+        automatic: "automatic";
+        explicit: "explicit";
+    }>>;
     query: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export type PersonalMemoryCursor = z.output<typeof personalMemoryCursorSchema>;
 export type PersonalMemoryPageInput = z.output<typeof personalMemoryPageInputSchema>;
 export interface PersonalMemoryPage {
-    memories: MemoryRecord[];
+    memories: PersonalMemoryRecord[];
     nextCursor?: PersonalMemoryCursor;
 }
+/** Safe provenance attached to one viewer-owned personal memory. */
+export type PersonalMemoryRecord = MemoryRecord & {
+    origin: "automatic" | "explicit" | "other";
+    sourcePlatform: "local" | "slack";
+};
+/** Viewer-scoped active memory totals used by the dashboard. */
+export interface PersonalMemoryStats {
+    active: number;
+    automatic: number;
+    createdThirtyDays: number;
+    embedded: number;
+    explicit: number;
+    knowledge: number;
+    preference: number;
+    procedure: number;
+}
+/** Viewer-scoped memory creation totals for one UTC calendar day. */
+export interface PersonalMemoryDay {
+    date: string;
+    knowledge: number;
+    preference: number;
+    procedure: number;
+}
 /** Expected failure when a viewer does not own the requested memory. */
 export declare class PersonalMemoryNotFoundError extends Error {
     constructor();
@@ -31,6 +63,12 @@ export interface PersonalMemoryCollection {
     get(id: string): Promise<MemoryRecord>;
     /** List one stable page across every linked personal scope. */
     list(input: PersonalMemoryPageInput): Promise<PersonalMemoryPage>;
+    /** Summarize active memories across every linked personal scope. */
+    stats(): Promise<PersonalMemoryStats>;
+    /** Read memory creation history across every linked personal scope. */
+    timeline(input: {
+        days: number;
+    }): Promise<PersonalMemoryDay[]>;
 }
 /** Build storage operations for every personal scope linked to one viewer. */
 export declare function createPersonalMemoryCollection(db: MemoryDb, runtimeContexts: MemoryRuntimeContext[], options?: {

package/dist/personal.d.ts

@@ -1,12 +1,16 @@
 import type { PluginUserPageActor } from "@sentry/junior-plugin-api";
+import { type PersonalMemoryRecord } from "./personal-store";
 import type { MemoryDb, MemoryRecord } from "./store";
+import type { MemoryKind } from "./types";
 export interface ViewerMemoryPage {
-    memories: MemoryRecord[];
+    memories: PersonalMemoryRecord[];
     nextCursor?: string;
 }
 export interface ViewerMemoryPageInput {
     cursor?: string;
+    kind?: MemoryKind;
     limit: number;
+    origin?: "automatic" | "explicit";
     query?: string;
 }
 export declare class InvalidMemoryCursorError extends Error {
@@ -18,4 +22,8 @@ export declare function createViewerMemories(db: MemoryDb, actors: PluginUserPag
     archive(id: string): Promise<MemoryRecord>;
     get(id: string): Promise<MemoryRecord>;
     list(input: ViewerMemoryPageInput): Promise<ViewerMemoryPage>;
+    stats(): Promise<import("./personal-store").PersonalMemoryStats>;
+    timeline(input: {
+        days: number;
+    }): Promise<import("./personal-store").PersonalMemoryDay[]>;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior-memory",
-  "version": "0.124.0",
+  "version": "0.124.1",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -27,7 +27,7 @@
     "commander": "^14.0.3",
     "drizzle-orm": "^0.45.2",
     "zod": "^4.4.3",
-    "@sentry/junior-plugin-api": "0.124.0"
+    "@sentry/junior-plugin-api": "0.124.1"
   },
   "devDependencies": {
     "@types/node": "^25.9.1",

package/src/api.ts

@@ -36,7 +36,38 @@ export const memoryListResponseSchema = z
   })
   .strict();
 
+const memoryDashboardDaySchema = z
+  .object({
+    date: z.iso.date(),
+    knowledge: z.number().int().min(0),
+    preference: z.number().int().min(0),
+    procedure: z.number().int().min(0),
+  })
+  .strict();
+
+export const memoryDashboardResponseSchema = z
+  .object({
+    days: z.array(memoryDashboardDaySchema).length(90),
+    generatedAt: z.iso.datetime(),
+    stats: z
+      .object({
+        active: z.number().int().min(0),
+        automatic: z.number().int().min(0),
+        createdThirtyDays: z.number().int().min(0),
+        embedded: z.number().int().min(0),
+        explicit: z.number().int().min(0),
+        knowledge: z.number().int().min(0),
+        preference: z.number().int().min(0),
+        procedure: z.number().int().min(0),
+      })
+      .strict(),
+  })
+  .strict();
+
 export type MemoryApi = z.output<typeof memoryApiSchema>;
+export type MemoryDashboardResponse = z.output<
+  typeof memoryDashboardResponseSchema
+>;
 export type MemoryListResponse = z.output<typeof memoryListResponseSchema>;
 
 const memoryListQuerySchema = z
@@ -94,13 +125,35 @@ export function createMemoryApi(options: MemoryApiOptions): PluginRouteApp {
       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: 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")

package/src/index.ts

@@ -1,8 +1,10 @@
 export { memoryPlugin } from "./plugin";
 export {
   memoryApiSchema,
+  memoryDashboardResponseSchema,
   memoryListResponseSchema,
   type MemoryApi,
+  type MemoryDashboardResponse,
   type MemoryListResponse,
 } from "./api";
 export type { MemoryPluginOptions } from "./plugin";

package/src/personal-store.ts

@@ -4,7 +4,7 @@
  * A viewer may resolve to several runtime actors. This store combines their
  * personal scopes without treating one actor as the canonical identity.
  */
-import { and, asc, desc, eq, gt, ilike, lt, or, sql } from "drizzle-orm";
+import { and, asc, desc, eq, gt, ilike, like, lt, or, sql } from "drizzle-orm";
 import { z } from "zod";
 import { juniorMemoryEmbeddings, juniorMemoryMemories } from "./db/schema";
 import { deriveMemoryScope, type ResolvedMemoryScope } from "./scope";
@@ -15,7 +15,7 @@ import {
   type MemoryDb,
   type MemoryRecord,
 } from "./store";
-import type { MemoryRuntimeContext } from "./types";
+import { MEMORY_KINDS, type MemoryRuntimeContext } from "./types";
 
 const nonEmptyStringSchema = z.string().min(1);
 const personalMemoryCursorSchema = z
@@ -27,10 +27,18 @@ const personalMemoryCursorSchema = z
 const personalMemoryPageInputSchema = z
   .object({
     cursor: personalMemoryCursorSchema.optional(),
+    kind: z.enum(MEMORY_KINDS).optional(),
     limit: z.number().int().min(1).max(50),
+    origin: z.enum(["automatic", "explicit"]).optional(),
     query: z.string().max(200).optional(),
   })
   .strict();
+const personalMemoryTimelineInputSchema = z
+  .object({
+    days: z.number().int().min(1).max(365),
+  })
+  .strict();
+const DAY_MS = 24 * 60 * 60 * 1_000;
 
 export type PersonalMemoryCursor = z.output<typeof personalMemoryCursorSchema>;
 
@@ -39,10 +47,36 @@ export type PersonalMemoryPageInput = z.output<
 >;
 
 export interface PersonalMemoryPage {
-  memories: MemoryRecord[];
+  memories: PersonalMemoryRecord[];
   nextCursor?: PersonalMemoryCursor;
 }
 
+/** Safe provenance attached to one viewer-owned personal memory. */
+export type PersonalMemoryRecord = MemoryRecord & {
+  origin: "automatic" | "explicit" | "other";
+  sourcePlatform: "local" | "slack";
+};
+
+/** Viewer-scoped active memory totals used by the dashboard. */
+export interface PersonalMemoryStats {
+  active: number;
+  automatic: number;
+  createdThirtyDays: number;
+  embedded: number;
+  explicit: number;
+  knowledge: number;
+  preference: number;
+  procedure: number;
+}
+
+/** Viewer-scoped memory creation totals for one UTC calendar day. */
+export interface PersonalMemoryDay {
+  date: string;
+  knowledge: number;
+  preference: number;
+  procedure: number;
+}
+
 /** Expected failure when a viewer does not own the requested memory. */
 export class PersonalMemoryNotFoundError extends Error {
   constructor() {
@@ -59,6 +93,10 @@ export interface PersonalMemoryCollection {
   get(id: string): Promise<MemoryRecord>;
   /** List one stable page across every linked personal scope. */
   list(input: PersonalMemoryPageInput): Promise<PersonalMemoryPage>;
+  /** Summarize active memories across every linked personal scope. */
+  stats(): Promise<PersonalMemoryStats>;
+  /** Read memory creation history across every linked personal scope. */
+  timeline(input: { days: number }): Promise<PersonalMemoryDay[]>;
 }
 
 function personalScopes(
@@ -74,6 +112,22 @@ function personalScopes(
   ];
 }
 
+function personalScopePredicate(scopes: ResolvedMemoryScope[]) {
+  if (scopes.length === 0) return undefined;
+  return or(
+    ...scopes.map((scope) =>
+      and(
+        eq(juniorMemoryMemories.scope, scope.scope),
+        eq(juniorMemoryMemories.scopeKey, scope.scopeKey),
+      ),
+    ),
+  );
+}
+
+function utcDate(ms: number): string {
+  return new Date(ms).toISOString().slice(0, 10);
+}
+
 function searchTerms(query: string): string[] {
   return [
     ...new Set(
@@ -86,6 +140,24 @@ function searchTerms(query: string): string[] {
   ];
 }
 
+function memoryOrigin(
+  idempotencyKey: string | null,
+): PersonalMemoryRecord["origin"] {
+  if (idempotencyKey?.startsWith("session:")) return "automatic";
+  if (idempotencyKey?.startsWith("tool:")) return "explicit";
+  return "other";
+}
+
+function personalMemoryRecord(
+  row: typeof juniorMemoryMemories.$inferSelect,
+): PersonalMemoryRecord {
+  return {
+    ...parseMemoryRow(row),
+    origin: memoryOrigin(row.idempotencyKey),
+    sourcePlatform: row.sourcePlatform,
+  };
+}
+
 /** Build storage operations for every personal scope linked to one viewer. */
 export function createPersonalMemoryCollection(
   db: MemoryDb,
@@ -167,17 +239,26 @@ export function createPersonalMemoryCollection(
                   ilike(juniorMemoryMemories.content, `%${term}%`),
                 ),
               );
+      const kind = input.kind
+        ? eq(juniorMemoryMemories.kind, input.kind)
+        : undefined;
+      const origin =
+        input.origin === "automatic"
+          ? like(juniorMemoryMemories.idempotencyKey, "session:%")
+          : input.origin === "explicit"
+            ? like(juniorMemoryMemories.idempotencyKey, "tool:%")
+            : undefined;
       const rows = await db
         .select()
         .from(juniorMemoryMemories)
-        .where(and(active, cursor, search))
+        .where(and(active, cursor, search, kind, origin))
         .orderBy(
           desc(juniorMemoryMemories.createdAtMs),
           asc(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,
@@ -191,5 +272,122 @@ export function createPersonalMemoryCollection(
           : {}),
       };
     },
+
+    async stats() {
+      const nowMs = getNowMs();
+      await archiveExpiredMemoryBatch({ db, nowMs, scopes });
+      const active = activeVisiblePredicate({ nowMs, scopes });
+      if (!active) {
+        return {
+          active: 0,
+          automatic: 0,
+          createdThirtyDays: 0,
+          embedded: 0,
+          explicit: 0,
+          knowledge: 0,
+          preference: 0,
+          procedure: 0,
+        };
+      }
+      const [counts] = await db
+        .select({
+          active: sql<number>`count(*)`.mapWith(Number),
+          automatic:
+            sql<number>`count(*) filter (where ${juniorMemoryMemories.idempotencyKey} like 'session:%')`.mapWith(
+              Number,
+            ),
+          createdThirtyDays:
+            sql<number>`count(*) filter (where ${juniorMemoryMemories.createdAtMs} >= ${nowMs - 30 * 24 * 60 * 60 * 1_000})`.mapWith(
+              Number,
+            ),
+          embedded:
+            sql<number>`count(${juniorMemoryEmbeddings.memoryId})`.mapWith(
+              Number,
+            ),
+          explicit:
+            sql<number>`count(*) filter (where ${juniorMemoryMemories.idempotencyKey} like 'tool:%')`.mapWith(
+              Number,
+            ),
+          knowledge:
+            sql<number>`count(*) filter (where ${juniorMemoryMemories.kind} = 'knowledge')`.mapWith(
+              Number,
+            ),
+          preference:
+            sql<number>`count(*) filter (where ${juniorMemoryMemories.kind} = 'preference')`.mapWith(
+              Number,
+            ),
+          procedure:
+            sql<number>`count(*) filter (where ${juniorMemoryMemories.kind} = 'procedure')`.mapWith(
+              Number,
+            ),
+        })
+        .from(juniorMemoryMemories)
+        .leftJoin(
+          juniorMemoryEmbeddings,
+          eq(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,
+        preference: counts?.preference ?? 0,
+        procedure: counts?.procedure ?? 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 = personalScopePredicate(scopes);
+      if (!ownership) {
+        return Array.from({ length: input.days }, (_, index) => ({
+          date: utcDate(startMs + index * DAY_MS),
+          knowledge: 0,
+          preference: 0,
+          procedure: 0,
+        }));
+      }
+      const rows = await db
+        .select({
+          date: sql<string>`to_char(to_timestamp(${juniorMemoryMemories.createdAtMs} / 1000.0) AT TIME ZONE 'UTC', 'YYYY-MM-DD')`.as(
+            "date",
+          ),
+          knowledge:
+            sql<number>`count(*) filter (where ${juniorMemoryMemories.kind} = 'knowledge')`.mapWith(
+              Number,
+            ),
+          preference:
+            sql<number>`count(*) filter (where ${juniorMemoryMemories.kind} = 'preference')`.mapWith(
+              Number,
+            ),
+          procedure:
+            sql<number>`count(*) filter (where ${juniorMemoryMemories.kind} = 'procedure')`.mapWith(
+              Number,
+            ),
+        })
+        .from(juniorMemoryMemories)
+        .where(
+          and(ownership, gt(juniorMemoryMemories.createdAtMs, startMs - 1)),
+        )
+        .groupBy(
+          sql`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 }, (_, index) => {
+        const date = utcDate(startMs + index * DAY_MS);
+        const row = byDate.get(date);
+        return {
+          date,
+          knowledge: row?.knowledge ?? 0,
+          preference: row?.preference ?? 0,
+          procedure: row?.procedure ?? 0,
+        };
+      });
+    },
   };
 }

package/src/personal.ts

@@ -6,27 +6,34 @@
  */
 import { z } from "zod";
 import type { PluginUserPageActor } from "@sentry/junior-plugin-api";
-import { createPersonalMemoryCollection } from "./personal-store";
+import {
+  createPersonalMemoryCollection,
+  type PersonalMemoryRecord,
+} from "./personal-store";
 import type { MemoryDb, MemoryRecord } from "./store";
-import type { MemoryRuntimeContext } from "./types";
+import type { MemoryKind, MemoryRuntimeContext } from "./types";
 
 const cursorSchema = z
   .object({
     createdAtMs: z.number().finite(),
     id: z.string().min(1),
+    kind: z.enum(["preference", "procedure", "knowledge"]).optional(),
+    origin: z.enum(["automatic", "explicit"]).optional(),
     query: z.string().max(200).optional(),
     version: z.literal(1),
   })
   .strict();
 
 export interface ViewerMemoryPage {
-  memories: MemoryRecord[];
+  memories: PersonalMemoryRecord[];
   nextCursor?: string;
 }
 
 export interface ViewerMemoryPageInput {
   cursor?: string;
+  kind?: MemoryKind;
   limit: number;
+  origin?: "automatic" | "explicit";
   query?: string;
 }
 
@@ -61,13 +68,20 @@ function runtimeContext(actor: PluginUserPageActor): MemoryRuntimeContext {
   };
 }
 
-function decodeCursor(value: string | undefined, query: string | undefined) {
+function decodeCursor(
+  value: string | undefined,
+  input: Pick<ViewerMemoryPageInput, "kind" | "origin" | "query">,
+) {
   if (!value) return undefined;
   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
+    ) {
       throw new InvalidMemoryCursorError();
     }
     return { createdAtMs: parsed.createdAtMs, id: parsed.id };
@@ -78,10 +92,16 @@ function decodeCursor(value: string | undefined, query: string | undefined) {
 
 function encodeCursor(
   cursor: { createdAtMs: number; id: string },
-  query: string | undefined,
+  input: Pick<ViewerMemoryPageInput, "kind" | "origin" | "query">,
 ): string {
   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 } : {}),
+      version: 1,
+    }),
     "utf8",
   ).toString("base64url");
 }
@@ -104,17 +124,28 @@ export function createViewerMemories(
     },
     async list(input: ViewerMemoryPageInput): Promise<ViewerMemoryPage> {
       const query = input.query?.trim() || undefined;
+      const filters = {
+        ...(input.kind ? { kind: input.kind } : {}),
+        ...(input.origin ? { origin: input.origin } : {}),
+        ...(query ? { query } : {}),
+      };
       const page = await collection.list({
-        cursor: decodeCursor(input.cursor, query),
+        cursor: decodeCursor(input.cursor, filters),
+        ...filters,
         limit: input.limit,
-        ...(query ? { query } : {}),
       });
       return {
         memories: page.memories,
         ...(page.nextCursor
-          ? { nextCursor: encodeCursor(page.nextCursor, query) }
+          ? { nextCursor: encodeCursor(page.nextCursor, filters) }
           : {}),
       };
     },
+    async stats() {
+      return await collection.stats();
+    },
+    async timeline(input: { days: number }) {
+      return await collection.timeline(input);
+    },
   };
 }

package/src/user-pages.ts

@@ -1,39 +1,66 @@
 /** Project viewer-owned memories into Junior's core-rendered user page. */
 import type { PluginUserPageDefinition } from "@sentry/junior-plugin-api";
 import { createViewerMemories } from "./personal";
-import type { MemoryDb, MemoryRecord } from "./store";
+import type { PersonalMemoryRecord } from "./personal-store";
+import type { MemoryDb } from "./store";
 
-function memoryKindLabel(kind: MemoryRecord["kind"]): string {
-  return kind.charAt(0).toUpperCase() + kind.slice(1);
+function titleCase(value: string): string {
+  return value.charAt(0).toUpperCase() + value.slice(1);
 }
 
 function rememberedDate(createdAtMs: number): string {
   return new Intl.DateTimeFormat("en-US", {
     dateStyle: "medium",
+    timeStyle: "short",
     timeZone: "UTC",
   }).format(new Date(createdAtMs));
 }
 
+function originLabel(origin: PersonalMemoryRecord["origin"]): string {
+  if (origin === "automatic") return "Automatic";
+  if (origin === "explicit") return "Explicit";
+  return "Other";
+}
+
+function pageFilter(filter: string | undefined): {
+  kind?: "preference";
+  origin?: "automatic" | "explicit";
+} {
+  if (filter === "preferences") return { kind: "preference" };
+  if (filter === "automatic") return { origin: "automatic" };
+  if (filter === "explicit") return { origin: "explicit" };
+  return {};
+}
+
+function pageEmptyText(input: { filter?: string; query?: string }): string {
+  if (input.query) return "No memories matched your search.";
+  if (input.filter === "preferences") return "No preferences yet.";
+  if (input.filter === "automatic") return "No learned memories yet.";
+  if (input.filter === "explicit") return "No saved memories yet.";
+  return "No personal memories yet.";
+}
+
 /** Create the interactive personal Memories dashboard page. */
 export function createMemoryUserPage(): PluginUserPageDefinition {
   return {
     id: "memories",
     label: "Memories",
+    navigation: "primary",
     description: "Personal facts and preferences Junior remembers about you.",
     async read(ctx, input) {
-      const page = await createViewerMemories(
+      const memories = createViewerMemories(
         ctx.db as MemoryDb,
         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) => ({
@@ -49,8 +76,18 @@ export function createMemoryUserPage(): PluginUserPageDefinition {
           id: memory.id,
           title: memory.content,
           metadata: [
-            { label: "Type", value: memoryKindLabel(memory.kind) },
+            { label: "Type", value: titleCase(memory.kind) },
+            { label: "Learned", value: originLabel(memory.origin) },
+            { label: "Source", value: titleCase(memory.sourcePlatform) },
+            { label: "Visibility", value: "Only you" },
             { label: "Remembered", value: rememberedDate(memory.createdAtMs) },
+            { label: "Observed", value: rememberedDate(memory.observedAtMs) },
+            {
+              label: "Expires",
+              value: memory.expiresAtMs
+                ? rememberedDate(memory.expiresAtMs)
+                : "Never",
+            },
           ],
         })),
       };