@sentry/junior-memory 0.124.1 → 0.125.0

package/README.md

@@ -15,7 +15,9 @@ exported types, tools, and tests are authoritative.
   inspection.
 - The dashboard exposes a searchable, paginated **Memories** user page for
   personal memories owned by actors linked to the signed-in viewer. Its
-  **Forget** action archives the selected memory.
+  **Forget** action archives the selected memory. The overview charts global
+  passive-extraction cost from the durable `memory/memories_captured` events;
+  the System plugin report uses the same event-cost feed.
 - Authenticated REST clients can list and search personal memories through
   `GET /api/plugins/memory/memories`, read one through
   `GET /api/plugins/memory/memories/:id`, and archive one through
@@ -55,6 +57,10 @@ exported types, tools, and tests are authoritative.
   learning.
 - Passive extraction creates only durable, reusable facts—not transient tasks,
   conversation summaries, secrets, or speculative interpretation.
+- Every completed passive extraction emits the namespaced
+  `memory/memories_captured` conversation event with its best-effort model cost.
+  Empty extraction outcomes remain durable for reporting but do not produce a
+  transcript row.
 - Candidate review resolves duplicates and supersession before activation.
 - Search combines independently ranked vector and PostgreSQL full-text matches
   with reciprocal rank fusion; provider-specific raw scores are never added
@@ -62,6 +68,10 @@ exported types, tools, and tests are authoritative.
 - Automatic recall retrieves a broad candidate window, then uses the
   memory-owned relevance model to admit at most five directly useful memories.
   An empty result contributes no filler prompt text.
+- Every completed automatic recall attempt emits an invisible, namespaced
+  `memory/memories_recalled` conversation event with the admitted memory IDs
+  and best-effort embedding and relevance-model cost, including retrievals that
+  find no candidates and decisions that admit no memories.
 - Automatic recall degrades to no prompt contribution when relevance selection
   fails. Review, extraction, and write failures still fail their owning
   hook/task without corrupting existing memory state.

package/dist/agent.d.ts

@@ -183,12 +183,22 @@ export type MemoryRecallInput = z.output<typeof memoryRecallInputSchema>;
 export type CreateMemoryRequest = z.output<typeof createMemoryRequestSchema>;
 export type ExtractSessionRequest = z.output<typeof extractSessionRequestSchema>;
 export type ExtractedMemory = z.output<typeof extractedMemoryResultSchema>;
+/** Memories proposed by passive extraction and the model cost of that pass. */
+export type MemoryExtractionResult = {
+    costUsd?: number;
+    memories: ExtractedMemory[];
+};
+/** Memories admitted by automatic recall and the model cost of that decision. */
+export type MemoryRecallResult = {
+    costUsd?: number;
+    relevantIds: string[];
+};
 export interface MemoryAgent {
     /** Select candidate memories that directly help with the current request. */
-    selectRelevantMemories(request: MemoryRecallInput): Promise<string[]> | string[];
+    selectRelevantMemories(request: MemoryRecallInput): Promise<MemoryRecallResult> | MemoryRecallResult;
     /** Classify a new preference against related active preferences. */
     adjudicateSupersession(request: MemorySupersessionInput): Promise<MemorySupersessionDecision> | MemorySupersessionDecision;
-    extractSessionMemories(request: ExtractSessionRequest): Promise<ExtractedMemory[]> | ExtractedMemory[];
+    extractSessionMemories(request: ExtractSessionRequest): Promise<MemoryExtractionResult> | MemoryExtractionResult;
     reviewCreateRequest(request: CreateMemoryRequest): Promise<MemoryReview> | MemoryReview;
 }
 /** Create the memory-owned agent that reviews, extracts, and recalls memories. */

package/dist/api.d.ts

@@ -1,11 +1,12 @@
 /**
- * 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";
+import { type PluginConversationEventStats, type PluginRouteApp, type PluginUserPageActor } from "@sentry/junior-plugin-api";
 import type { MemoryDb } from "./store";
 export declare const memoryApiSchema: z.ZodObject<{
     content: z.ZodString;
@@ -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,23 @@ 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;
-        knowledge: z.ZodNumber;
-        preference: z.ZodNumber;
-        procedure: z.ZodNumber;
+        personal: z.ZodNumber;
+        public: z.ZodNumber;
+    }, z.core.$strict>>;
+    extractionDays: z.ZodArray<z.ZodObject<{
+        costUsd: z.ZodNumber;
+        date: z.ZodISODate;
+        events: z.ZodNumber;
     }, z.core.$strict>>;
     generatedAt: z.ZodISODateTime;
     stats: z.ZodObject<{
@@ -49,8 +62,10 @@ export declare const memoryDashboardResponseSchema: z.ZodObject<{
         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>;
@@ -59,7 +74,8 @@ export type MemoryListResponse = z.output<typeof memoryListResponseSchema>;
 interface MemoryApiOptions {
     actors(email: string): Promise<PluginUserPageActor[]>;
     db: MemoryDb;
+    eventStats: PluginConversationEventStats;
 }
-/** Create the authenticated personal-memory REST app. */
+/** Create the authenticated viewer-memory REST app. */
 export declare function createMemoryApi(options: MemoryApiOptions): PluginRouteApp;
 export {};

package/dist/events.d.ts

@@ -1,5 +1,15 @@
 import type { MemoryRecord } from "./store";
-/** Durable transcript event emitted after background memory capture. */
+/** Previous stored memory-capture event shape retained for transcript rendering. */
+export declare const memoriesCapturedEventV1: import("@sentry/junior-plugin-api").DefinedConversationEvent<{
+    memories: {
+        content: string;
+        id: string;
+        kind: "preference" | "procedure" | "knowledge";
+        observedAtMs: number;
+        scope: "personal" | "conversation";
+    }[];
+}>;
+/** Durable outcome emitted after every completed passive memory extraction. */
 export declare const memoriesCapturedEvent: import("@sentry/junior-plugin-api").DefinedConversationEvent<{
     memories: {
         content: string;
@@ -8,6 +18,12 @@ export declare const memoriesCapturedEvent: import("@sentry/junior-plugin-api").
         observedAtMs: number;
         scope: "personal" | "conversation";
     }[];
+    costUsd?: number | undefined;
+}>;
+/** Durable outcome emitted after one completed automatic recall attempt. */
+export declare const memoriesRecalledEvent: import("@sentry/junior-plugin-api").DefinedConversationEvent<{
+    memories: string[];
+    costUsd?: number | undefined;
 }>;
 /** Select the stable, safe memory fields retained in conversation history. */
 export declare function capturedMemory(memory: MemoryRecord): {