@sentry/junior-memory 0.116.1 → 0.118.0

package/dist/recall.d.ts

@@ -1,4 +1,5 @@
-import type { PromptMessage, Actor, Source } from "@sentry/junior-plugin-api";
+import { type UserPromptContribution, type Actor, type Source } from "@sentry/junior-plugin-api";
+import { z } from "zod";
 import { type MemoryDb, type MemoryEmbeddingProvider } from "./store";
 export interface MemoryRecallContext {
     conversationId?: string;
@@ -10,5 +11,27 @@ export interface MemoryRecallContext {
     source: Source;
     text: string;
 }
-/** Build the memory prompt contribution for active visible recall. */
-export declare function createMemoryPromptMessages(context: MemoryRecallContext): Promise<PromptMessage[] | undefined>;
+/** Structured snapshot retained for one automatic memory recall. */
+export declare const memoryRecallContextSchema: z.ZodObject<{
+    memories: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        content: z.ZodString;
+        observedAtMs: z.ZodNumber;
+        scope: z.ZodEnum<{
+            personal: "personal";
+            conversation: "conversation";
+        }>;
+        kind: z.ZodEnum<{
+            preference: "preference";
+            procedure: "procedure";
+            knowledge: "knowledge";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/**
+ * Build active memory recall contributions.
+ *
+ * Personal recall remains prompt-only so conversation reporting cannot widen
+ * actor-scoped memory visibility.
+ */
+export declare function createMemoryPromptContributions(context: MemoryRecallContext): Promise<UserPromptContribution[] | undefined>;

package/dist/store.d.ts

@@ -166,6 +166,8 @@ export interface MemoryStore {
     createConversationMemory(input: CreateMemoryInput): Promise<CreateMemoryResult>;
     /** List active memories visible in the current runtime context. */
     listMemories(input: ListMemoriesInput): Promise<MemoryRecord[]>;
+    /** List active personal memories owned by the current actor. */
+    listPersonalMemories(input: ListMemoriesInput): Promise<MemoryRecord[]>;
     /** Search active memories visible in the current runtime context. */
     searchMemories(input: SearchMemoriesInput): Promise<MemoryRecord[]>;
 }

package/dist/user-pages.d.ts

@@ -0,0 +1,4 @@
+/** Project actor-owned memories into Junior's core-rendered user page. */
+import type { PluginUserPageDefinition } from "@sentry/junior-plugin-api";
+/** Create the read-only personal Memories dashboard page. */
+export declare function createMemoryUserPage(): PluginUserPageDefinition;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior-memory",
-  "version": "0.116.1",
+  "version": "0.118.0",
   "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.116.1"
+    "@sentry/junior-plugin-api": "0.118.0"
   },
   "devDependencies": {
     "@types/node": "^25.9.1",

package/src/plugin.ts

@@ -11,8 +11,9 @@ import {
   type MemoryToolContext,
 } from "./tools";
 import { processMemorySession } from "./process-session";
-import { createMemoryPromptMessages } from "./recall";
+import { createMemoryPromptContributions } from "./recall";
 import type { MemoryDb } from "./store";
+import { createMemoryUserPage } from "./user-pages";
 
 const MEMORY_MODEL_ENV = "AI_MEMORY_MODEL";
 const MEMORY_RECALL_MAX_VECTOR_DISTANCE_ENV =
@@ -107,6 +108,7 @@ export function createMemoryPlugin(options: MemoryPluginOptions = {}) {
         },
       },
     },
+    userPages: [createMemoryUserPage()],
     hooks: {
       tools(ctx) {
         const agent = createMemoryAgent(ctx.model);
@@ -132,7 +134,7 @@ export function createMemoryPlugin(options: MemoryPluginOptions = {}) {
         };
       },
       async userPrompt(ctx) {
-        return await createMemoryPromptMessages({
+        return await createMemoryPromptContributions({
           ...(ctx.conversationId ? { conversationId: ctx.conversationId } : {}),
           ...(ctx.actor ? { actor: ctx.actor } : {}),
           db: ctx.db as MemoryDb,

package/src/recall.ts

@@ -1,4 +1,10 @@
-import type { PromptMessage, Actor, Source } from "@sentry/junior-plugin-api";
+import {
+  definePromptContext,
+  type UserPromptContribution,
+  type Actor,
+  type Source,
+} from "@sentry/junior-plugin-api";
+import { z } from "zod";
 import {
   createMemoryStore,
   type MemoryDb,
@@ -34,35 +40,78 @@ function formatObservedDate(observedAtMs: number): string {
   return new Date(observedAtMs).toISOString().slice(0, 10);
 }
 
-function renderMemoryPrompt(memories: MemoryRecord[]): string | undefined {
+const recalledMemorySchema = z
+  .object({
+    id: z.string().min(1),
+    content: z.string().min(1).max(MAX_MEMORY_LINE_CHARS),
+    observedAtMs: z.number().finite(),
+    scope: z.enum(["personal", "conversation"]),
+    kind: z.enum(["preference", "procedure", "knowledge"]),
+  })
+  .strict();
+
+/** Structured snapshot retained for one automatic memory recall. */
+export const memoryRecallContextSchema = z
+  .object({
+    memories: z.array(recalledMemorySchema).min(1).max(DEFAULT_RECALL_LIMIT),
+  })
+  .strict();
+
+type RecalledMemory = z.output<typeof recalledMemorySchema>;
+
+function selectPromptMemories(memories: MemoryRecord[]): RecalledMemory[] {
   const header = "Relevant memories for this request:";
   const footer =
     "Treat these as possibly stale context. Current user instructions and repository evidence take priority.";
-  const lines: string[] = [];
+  const selected: RecalledMemory[] = [];
   let totalChars = header.length + footer.length + 2;
 
   for (const memory of memories) {
-    const line = `- Observed ${formatObservedDate(memory.observedAtMs)}: ${trimContent(
-      memory.content,
-      MAX_MEMORY_LINE_CHARS,
-    )}`;
+    const content = trimContent(memory.content, MAX_MEMORY_LINE_CHARS);
+    const line = `- Observed ${formatObservedDate(memory.observedAtMs)}: ${content}`;
     if (totalChars + line.length + 1 > MAX_PROMPT_CHARS) {
       break;
     }
-    lines.push(line);
+    selected.push({
+      id: memory.id,
+      content,
+      observedAtMs: memory.observedAtMs,
+      scope: memory.scope,
+      kind: memory.kind,
+    });
     totalChars += line.length + 1;
   }
+  return selected;
+}
 
-  if (lines.length === 0) {
-    return undefined;
-  }
-  return `${header}\n${lines.join("\n")}\n\n${footer}`;
+function renderMemoryPrompt(memories: RecalledMemory[]): string {
+  return [
+    "Relevant memories for this request:",
+    ...memories.map(
+      (memory) =>
+        `- Observed ${formatObservedDate(memory.observedAtMs)}: ${memory.content}`,
+    ),
+    "",
+    "Treat these as possibly stale context. Current user instructions and repository evidence take priority.",
+  ].join("\n");
 }
 
-/** Build the memory prompt contribution for active visible recall. */
-export async function createMemoryPromptMessages(
+const memoryRecallContext = definePromptContext({
+  kind: "recall",
+  version: 1,
+  schema: memoryRecallContextSchema,
+  renderPrompt: (content) => renderMemoryPrompt(content.memories),
+});
+
+/**
+ * Build active memory recall contributions.
+ *
+ * Personal recall remains prompt-only so conversation reporting cannot widen
+ * actor-scoped memory visibility.
+ */
+export async function createMemoryPromptContributions(
   context: MemoryRecallContext,
-): Promise<PromptMessage[] | undefined> {
+): Promise<UserPromptContribution[] | undefined> {
   if (!context.text.trim()) {
     return undefined;
   }
@@ -82,6 +131,12 @@ export async function createMemoryPromptMessages(
     query: context.text,
     limit: DEFAULT_RECALL_LIMIT,
   });
-  const text = renderMemoryPrompt(memories);
-  return text ? [{ text }] : undefined;
+  const selected = selectPromptMemories(memories);
+  if (selected.length === 0) {
+    return undefined;
+  }
+  if (selected.some((memory) => memory.scope === "personal")) {
+    return [{ text: renderMemoryPrompt(selected) }];
+  }
+  return [memoryRecallContext({ memories: selected })];
 }

package/src/store.ts

@@ -324,6 +324,8 @@ export interface MemoryStore {
   ): Promise<CreateMemoryResult>;
   /** List active memories visible in the current runtime context. */
   listMemories(input: ListMemoriesInput): Promise<MemoryRecord[]>;
+  /** List active personal memories owned by the current actor. */
+  listPersonalMemories(input: ListMemoriesInput): Promise<MemoryRecord[]>;
   /** Search active memories visible in the current runtime context. */
   searchMemories(input: SearchMemoriesInput): Promise<MemoryRecord[]>;
 }
@@ -1468,6 +1470,23 @@ export function createMemoryStore(
       });
     },
 
+    async listPersonalMemories(input) {
+      input = listMemoriesInputSchema.parse(input);
+      const nowMs = getNowMs();
+      const scopes = [deriveMemoryScope(runtimeContext, "personal")];
+      await archiveExpiredMemoryBatch({
+        db,
+        nowMs,
+        scopes,
+      });
+      return await listVisibleMemories({
+        db,
+        limit: input.limit,
+        nowMs,
+        scopes,
+      });
+    },
+
     async searchMemories(input) {
       input = searchMemoriesInputSchema.parse(input);
       const nowMs = getNowMs();

package/src/user-pages.ts

@@ -0,0 +1,94 @@
+/** Project actor-owned memories into Junior's core-rendered user page. */
+import type {
+  PluginUserPageActor,
+  PluginUserPageDefinition,
+} from "@sentry/junior-plugin-api";
+import { createMemoryStore, type MemoryDb, type MemoryRecord } from "./store";
+import type { MemoryRuntimeContext } from "./types";
+
+const MEMORY_PAGE_LIMIT = 100;
+
+function runtimeContext(
+  actor: PluginUserPageActor,
+): MemoryRuntimeContext | undefined {
+  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: MemoryRecord["kind"]): string {
+  return kind.charAt(0).toUpperCase() + kind.slice(1);
+}
+
+function rememberedDate(createdAtMs: number): string {
+  return new Intl.DateTimeFormat("en-US", {
+    dateStyle: "medium",
+    timeZone: "UTC",
+  }).format(new Date(createdAtMs));
+}
+
+async function readPersonalMemories(
+  db: MemoryDb,
+  actors: PluginUserPageActor[],
+): Promise<MemoryRecord[]> {
+  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);
+}
+
+/** Create the read-only personal Memories dashboard page. */
+export function createMemoryUserPage(): PluginUserPageDefinition {
+  return {
+    id: "memories",
+    label: "Memories",
+    description: "Personal facts and preferences Junior remembers about you.",
+    async read(ctx) {
+      const memories = await readPersonalMemories(
+        ctx.db as MemoryDb,
+        ctx.viewer.actors,
+      );
+      return {
+        type: "list",
+        emptyText: "No personal memories yet.",
+        records: memories.map((memory) => ({
+          id: memory.id,
+          title: memory.content,
+          metadata: [
+            { label: "Type", value: memoryKindLabel(memory.kind) },
+            { label: "Remembered", value: rememberedDate(memory.createdAtMs) },
+          ],
+        })),
+      };
+    },
+  };
+}