@sentry/junior-memory 0.179.0 → 0.181.0

package/README.md

@@ -1,6 +1,6 @@
 # @sentry/junior-memory
 
-The memory plugin stores durable, actor-scoped facts, recalls relevant facts
+The memory plugin stores durable facts, recalls relevant facts
 into prompts, and learns candidates from completed sessions. SQL schemas,
 exported types, tools, and tests are authoritative.
 
@@ -13,27 +13,29 @@ exported types, tools, and tests are authoritative.
   learning.
 - The `memory` CLI namespace provides explicit administrative search and
   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. 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
+- The dashboard exposes a searchable, paginated **Memories** user page. It
+  includes public memory and private memory owned by the authenticated user.
+  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 authorized memories through
   `GET /api/plugins/memory/memories`, read one through
-  `GET /api/plugins/memory/memories/:id`, and archive one through
-  `DELETE /api/plugins/memory/memories/:id`. Personal bearer tokens remain
-  read-only, so mutations require a dashboard browser session.
+  `GET /api/plugins/memory/memories/:id`, and forget an authorized private
+  memory through `DELETE /api/plugins/memory/memories/:id`. Public memory is
+  read-only in the dashboard and REST API.
 
 ## Scope And Visibility
 
-- Memory scope is derived from the active actor and source, never from
-  model-supplied ownership fields.
-- Dashboard and REST requests authorize one verified viewer, then derive access
-  from every linked provider identity so no arbitrary identity is treated as
-  the canonical user.
-- Private conversations and local sources remain private by default.
-- Recall filters candidates by actor, source, visibility, status, and relevance
-  before content reaches the model.
+- The Source sets memory visibility. Model output cannot set it.
+- Public memory is visible everywhere.
+- Private memory belongs to one User. Every Identity linked to that User can
+  access it.
+- Junior records the optional Location where it learned a memory. Location is
+  a record of where Junior learned it. It does not grant access.
+- The subject says what a memory is about. It does not set access. A user
+  preference can be public or private based on its Source.
+- Recall filters candidates by visibility, status, and relevance before content
+  reaches the model.
 - Administrative reads require explicit selectors and safe output defaults.
 - Memory content, embeddings, source excerpts, and review prompts must not be
   logged or traced.
@@ -71,13 +73,12 @@ exported types, tools, and tests are authoritative.
   and slightly prefers lexical ranks so exact tokens survive soft semantic
   neighbors. Vector recall also applies the cosine distance cutoff in SQL, and
   embeddings use an HNSW cosine index (`vector_cosine_ops`).
-- Automatic recall also runs personal-scope-only vector and lexical probes so
-  older actor preferences are not buried when newer workspace conversation
-  memories fill the shared lexical recency window with common tokens. On RRF
-  score ties, personal-scope matches rank ahead of conversation matches.
+- Automatic recall also searches private memory by itself. This keeps newer
+  public memory with common words from hiding older private memory. On equal
+  RRF scores, private memory ranks first.
 - Automatic recall retrieves a bounded 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.
+  memory relevance model and prompt limit to select useful memories. An empty
+  result adds no 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

package/dist/agent.d.ts

@@ -13,6 +13,7 @@ declare const createMemoryRequestSchema: z.ZodObject<{
     expiresAtMs: z.ZodOptional<z.ZodNumber>;
     runtimeContext: z.ZodObject<{
         conversationId: z.ZodOptional<z.ZodString>;
+        locationId: z.ZodOptional<z.ZodString>;
         actor: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
             platform: z.ZodLiteral<"slack">;
             teamId: z.ZodString;
@@ -58,6 +59,7 @@ declare const createMemoryRequestSchema: z.ZodObject<{
             }>;
             conversationId: z.ZodString;
         }, z.core.$strict>], "platform">;
+        userId: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>;
     sourceContext: z.ZodOptional<z.ZodObject<{
         currentUserText: z.ZodOptional<z.ZodString>;
@@ -92,6 +94,7 @@ declare const extractSessionRequestSchema: z.ZodObject<{
     }, z.core.$strict>], "platform">>;
     runtimeContext: z.ZodObject<{
         conversationId: z.ZodOptional<z.ZodString>;
+        locationId: z.ZodOptional<z.ZodString>;
         actor: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
             platform: z.ZodLiteral<"slack">;
             teamId: z.ZodString;
@@ -137,6 +140,7 @@ declare const extractSessionRequestSchema: z.ZodObject<{
             }>;
             conversationId: z.ZodString;
         }, z.core.$strict>], "platform">;
+        userId: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>;
     transcript: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"message">;

package/dist/api.d.ts

@@ -1,8 +1,7 @@
 /**
- * Authenticated REST resources for viewer-visible memories.
+ * Authenticated REST access to memory.
  *
- * HTTP identity is one verified user whose linked identities authorize
- * personal and public workspace scopes.
+ * The signed-in User can read public memory and private memory that they own.
  */
 import { z } from "zod";
 import { type PluginConversationEventStats, type PluginRouteApp, type User } from "@sentry/junior-plugin-api";
@@ -102,6 +101,6 @@ interface MemoryApiOptions {
         resolve(email: string): Promise<User | undefined>;
     };
 }
-/** Create the authenticated viewer-memory REST app. */
+/** Create the authenticated memory REST app. */
 export declare function createMemoryApi(options: MemoryApiOptions): PluginRouteApp;
 export {};

package/dist/db/schema.d.ts

@@ -24,14 +24,14 @@ export declare const juniorMemoryMemories: import("drizzle-orm/pg-core").PgTable
             tableName: "junior_memory_memories";
             dataType: "string";
             columnType: "PgText";
-            data: "personal" | "conversation";
+            data: "public" | "private";
             driverParam: string;
             notNull: true;
             hasDefault: false;
             isPrimaryKey: false;
             isAutoincrement: false;
             hasRuntimeDefault: false;
-            enumValues: ["personal", "conversation"];
+            enumValues: ["private", "public"];
             baseColumn: never;
             identity: undefined;
             generated: undefined;
@@ -176,6 +176,23 @@ export declare const juniorMemoryMemories: import("drizzle-orm/pg-core").PgTable
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        locationId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "location_id";
+            tableName: "junior_memory_memories";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
         idempotencyKey: import("drizzle-orm/pg-core").PgColumn<{
             name: "idempotency_key";
             tableName: "junior_memory_memories";

package/dist/events.d.ts

@@ -2,21 +2,21 @@ import type { MemoryRecord } from "./store";
 /** Previous stored memory-capture event shape retained for transcript rendering. */
 export declare const memoriesCapturedEventV1: import("@sentry/junior-plugin-api").DefinedConversationEvent<{
     memories: {
+        scope: "conversation" | "personal";
         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: {
+        scope: "public" | "private";
         content: string;
         id: string;
         kind: "preference" | "procedure" | "knowledge";
         observedAtMs: number;
-        scope: "personal" | "conversation";
     }[];
     costUsd?: number | undefined;
 }>;
@@ -31,5 +31,5 @@ export declare function capturedMemory(memory: MemoryRecord): {
     id: string;
     kind: "preference" | "procedure" | "knowledge";
     observedAtMs: number;
-    scope: "personal" | "conversation";
+    scope: "public" | "private";
 };