@sentry/junior-memory 0.180.0 → 0.181.1

package/dist/process-session.d.ts

@@ -2,9 +2,8 @@ import { type PluginTaskContext } from "@sentry/junior-plugin-api";
 /**
  * Extract and store memories from a completed session plugin task.
  *
- * Memory owns post-session extraction and consumes only the bounded plugin task
- * projection. Explicit memory tools and private non-local sources remain hard
- * boundaries so background retries cannot reinterpret user-directed mutations
- * or private conversations.
+ * Memory owns learning after a run and reads only the plugin run data.
+ * Explicit memory tools stay separate so retries do not reinterpret user
+ * requests.
  */
 export declare function processMemorySession(context: PluginTaskContext): Promise<void>;

package/dist/ranking.d.ts

@@ -4,14 +4,12 @@ export interface MemoryMatch {
         rank: number;
     };
     memory: MemoryRecord;
-    sourceKey: string;
     vector?: {
         rank: number;
     };
 }
 /** Fuse lexical and vector ranks without comparing provider raw scores. */
 export declare function rankMemoryMatches(matches: MemoryMatch[], options: {
-    channelPrefix?: string;
     /** Optional RRF weight for the lexical leg. Defaults to 1. */
     lexicalWeight?: number;
     nowMs: number;

package/dist/recall.d.ts

@@ -1,4 +1,4 @@
-import { type UserPromptContribution, type Actor, type PluginConversationEvents, type PluginLogger, type Source } from "@sentry/junior-plugin-api";
+import { type UserPromptContribution, type Actor, type Identity, type PluginConversationEvents, type PluginLogger, type Source, type User } from "@sentry/junior-plugin-api";
 import { z } from "zod";
 import type { MemoryAgent } from "./agent";
 import { type MemoryDb, type MemoryEmbeddingProvider } from "./store";
@@ -9,9 +9,16 @@ export interface MemoryRecallContext {
     embedder?: MemoryEmbeddingProvider;
     events?: PluginConversationEvents;
     log: PluginLogger;
+    locationId?: string;
     actor?: Actor;
     source: Source;
     text: string;
+    users: {
+        resolveActor(): Promise<{
+            identity: Identity;
+            user?: User;
+        } | undefined>;
+    };
 }
 /** Structured snapshot retained for one automatic memory recall. */
 export declare const memoryRecallContextSchema: z.ZodObject<{
@@ -20,8 +27,8 @@ export declare const memoryRecallContextSchema: z.ZodObject<{
         content: z.ZodString;
         observedAtMs: z.ZodNumber;
         scope: z.ZodEnum<{
-            personal: "personal";
             conversation: "conversation";
+            personal: "personal";
         }>;
         kind: z.ZodEnum<{
             preference: "preference";

package/dist/scope.d.ts

@@ -1,23 +1,19 @@
-import { type Identity } from "@sentry/junior-plugin-api";
 import type { MemoryRuntimeContext, MemoryScope, MemorySubjectType } from "./types";
-/** Runtime-derived visibility scope used for memory authorization checks. */
+/** Stored memory access rule. */
 export interface ResolvedMemoryScope {
     scope: MemoryScope;
     scopeKey: string;
 }
-/** Runtime-derived subject classification stored for filtering and rendering. */
+/** What a stored memory is about. */
 export interface ResolvedMemorySubject {
-    subjectKey?: string;
-    subjectType: MemorySubjectType;
+    subjectKey: string;
+    subjectType: Extract<MemorySubjectType, "user" | "conversation">;
 }
-/** Derive viewer-visible memory scopes from canonical provider identities. */
-export declare function deriveViewerMemoryScopes(identities: Identity[]): {
-    privateScopes: ResolvedMemoryScope[];
-    publicScopes: ResolvedMemoryScope[];
-};
-/** Derive the authority-bearing key for a requested memory scope. */
-export declare function deriveMemoryScope(ctx: MemoryRuntimeContext, scope: MemoryScope): ResolvedMemoryScope;
-/** Derive the memory subject from the already-authorized write scope. */
-export declare function deriveMemorySubject(ctx: MemoryRuntimeContext, scope: ResolvedMemoryScope): ResolvedMemorySubject;
-/** Return every visible scope for memory retrieval in the current context. */
+/** Public memories are visible everywhere. */
+export declare const publicMemoryScope: ResolvedMemoryScope;
+/** Set memory access from the Source. */
+export declare function deriveMemoryScope(ctx: MemoryRuntimeContext): ResolvedMemoryScope;
+/** Set what a memory is about. Access is set separately. */
+export declare function deriveMemorySubject(ctx: MemoryRuntimeContext, subjectType: Extract<MemorySubjectType, "user" | "conversation">): ResolvedMemorySubject;
+/** Return the memory scopes that the current User can access. */
 export declare function deriveVisibleMemoryScopes(ctx: MemoryRuntimeContext): ResolvedMemoryScope[];

package/dist/store.d.ts

@@ -39,8 +39,8 @@ declare const memoryRecordSchema: z.ZodObject<{
     id: z.ZodString;
     observedAtMs: z.ZodNumber;
     scope: z.ZodEnum<{
-        personal: "personal";
-        conversation: "conversation";
+        public: "public";
+        private: "private";
     }>;
     subjectType: z.ZodEnum<{
         user: "user";
@@ -67,6 +67,7 @@ export declare const memorySupersessionInputSchema: z.ZodObject<{
     }, z.core.$strict>>;
     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;
@@ -112,6 +113,7 @@ export declare const memorySupersessionInputSchema: z.ZodObject<{
             }>;
             conversationId: z.ZodString;
         }, z.core.$strict>], "platform">;
+        userId: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>;
 }, z.core.$strict>;
 /**
@@ -177,14 +179,12 @@ export interface MemoryStore {
     archiveExpiredMemories(input?: ArchiveExpiredMemoriesInput): Promise<ArchiveExpiredMemoriesResult>;
     /** Archive a visible memory in the current runtime context. */
     archiveMemory(input: ArchiveMemoryInput): Promise<MemoryRecord>;
-    /** Store a personal memory for the current actor. */
+    /** Store a memory about the current User. The Source sets access. */
     createMemory(input: CreateMemoryInput): Promise<CreateMemoryResult>;
-    /** Store a conversation memory for the current source conversation. */
+    /** Store a memory about the current Conversation. The Source sets access. */
     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[]>;
     /**
      * Retrieve a broad relevance-ranked candidate window for automatic recall.
      * Prompt admission remains owned by the recall boundary.
@@ -193,7 +193,6 @@ export interface MemoryStore {
     /** Search active memories visible in the current runtime context. */
     searchMemories(input: SearchMemoriesInput): Promise<MemoryRecord[]>;
 }
-/** Parse one SQL row into the public memory record projection. */
 /** Parse one SQL row into the public memory projection. */
 export declare function parseMemoryRow(row: unknown): MemoryRecord;
 /** Build the active-row predicate for already-authorized memory scopes. */

package/dist/tools.d.ts

@@ -1,4 +1,4 @@
-import { type Source, type Actor } from "@sentry/junior-plugin-api";
+import { type Source, type Actor, type Identity, type User } from "@sentry/junior-plugin-api";
 import { type MemoryEmbeddingProvider, type MemoryDb, type MemorySupersessionDecider } from "./store";
 import { type MemoryAgent } from "./agent";
 export type MemoryReviewer = Pick<MemoryAgent, "reviewCreateRequest">;
@@ -8,8 +8,15 @@ export interface MemoryToolContext {
     conversationId?: string;
     db: MemoryDb;
     embedder?: MemoryEmbeddingProvider;
+    locationId?: string;
     actor?: Actor;
     source: Source;
+    users: {
+        resolveActor(): Promise<{
+            identity: Identity;
+            user?: User;
+        } | undefined>;
+    };
     userText?: string;
 }
 export interface MemoryCreateToolContext extends MemoryToolContext {

package/dist/types.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 export declare const MEMORY_KINDS: readonly ["preference", "procedure", "knowledge"];
-export declare const MEMORY_SCOPES: readonly ["personal", "conversation"];
+export declare const MEMORY_SCOPES: readonly ["private", "public"];
 export declare const MEMORY_SUBJECT_TYPES: readonly ["user", "conversation", "general"];
 export declare const MEMORY_SOURCE_PLATFORMS: readonly ["slack", "local", "web"];
 export declare const MEMORY_EMBEDDING_METRICS: readonly ["cosine"];
@@ -10,9 +10,10 @@ export type MemoryScope = (typeof MEMORY_SCOPES)[number];
 export type MemorySubjectType = (typeof MEMORY_SUBJECT_TYPES)[number];
 export type MemorySourcePlatform = (typeof MEMORY_SOURCE_PLATFORMS)[number];
 export type MemoryEmbeddingMetric = (typeof MEMORY_EMBEDDING_METRICS)[number];
-/** Runtime-owned memory invocation fields used for scope and source authority. */
+/** Host data used to set memory access, subject, and source. */
 export declare const memoryRuntimeContextSchema: 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,5 +59,6 @@ export declare const memoryRuntimeContextSchema: z.ZodObject<{
         }>;
         conversationId: z.ZodString;
     }, z.core.$strict>], "platform">;
+    userId: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export type MemoryRuntimeContext = z.output<typeof memoryRuntimeContextSchema>;

package/dist/user-pages.d.ts

@@ -1,4 +1,4 @@
-/** Project viewer-visible memories into Junior's core-rendered user page. */
+/** Render memory in Junior's User page format. */
 import type { PluginUserPageDefinition } from "@sentry/junior-plugin-api";
 /** Create the interactive Memories dashboard page. */
 export declare function createMemoryUserPage(): PluginUserPageDefinition;

package/dist/viewer.d.ts

@@ -0,0 +1,85 @@
+import { z } from "zod";
+import { type MemoryDb, type MemoryRecord } from "./store";
+import { type MemorySourcePlatform } from "./types";
+declare const memoryVisibilitySchema: z.ZodEnum<{
+    public: "public";
+    private: "private";
+}>;
+declare const pageInputSchema: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodString>;
+    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>;
+    visibility: z.ZodOptional<z.ZodEnum<{
+        public: "public";
+        private: "private";
+    }>>;
+}, z.core.$strict>;
+/** Access label returned by dashboard and REST memory views. */
+export type MemoryVisibility = z.output<typeof memoryVisibilitySchema>;
+/** Memory fields returned to an authenticated User. */
+export type MemoryView = MemoryRecord & {
+    origin: "automatic" | "explicit" | "other";
+    sourcePlatform: MemorySourcePlatform;
+    visibility: MemoryVisibility;
+};
+interface MemoryPage {
+    memories: MemoryView[];
+    nextCursor?: string;
+}
+type MemoryPageInput = z.output<typeof pageInputSchema>;
+/** Expected error for a malformed or mismatched page cursor. */
+export declare class InvalidMemoryCursorError extends Error {
+    constructor();
+}
+/** Expected error when the current User cannot access a memory. */
+export declare class MemoryNotFoundError extends Error {
+    constructor();
+}
+/** Archive one active private memory owned by the authenticated User. */
+export declare function archiveMemory(db: MemoryDb, userId: string, id: string): Promise<{
+    content: string;
+    createdAtMs: number;
+    id: string;
+    observedAtMs: number;
+    scope: "public" | "private";
+    subjectType: "user" | "conversation" | "general";
+    kind: "preference" | "procedure" | "knowledge";
+    archivedAtMs?: number | undefined;
+    archiveReason?: string | undefined;
+    expiresAtMs?: number | undefined;
+    supersededAtMs?: number | undefined;
+    supersededById?: string | undefined;
+}>;
+/** Read one active memory visible to the authenticated User. */
+export declare function getMemory(db: MemoryDb, userId: string, id: string): Promise<MemoryView>;
+/** List one stable page of active memory visible to the authenticated User. */
+export declare function listMemories(db: MemoryDb, userId: string, input: MemoryPageInput): Promise<MemoryPage>;
+/** Summarize active memory visible to the authenticated User. */
+export declare function getMemoryStats(db: MemoryDb, userId: string): Promise<{
+    active: number;
+    automatic: number;
+    createdThirtyDays: number;
+    embedded: number;
+    explicit: number;
+    knowledge: number;
+    private: number;
+    preference: number;
+    procedure: number;
+    public: number;
+}>;
+/** Read daily memory creation totals visible to the authenticated User in UTC. */
+export declare function getMemoryTimeline(db: MemoryDb, userId: string, days: number): Promise<{
+    date: string;
+    private: number;
+    public: number;
+}[]>;
+export {};

package/migrations/0009_faithful_whizzer.sql

@@ -0,0 +1,114 @@
+ALTER TABLE "junior_memory_memories" DROP CONSTRAINT "junior_memory_memories_scope_check";--> statement-breakpoint
+ALTER TABLE "junior_memory_memories" ADD COLUMN "location_id" text;--> statement-breakpoint
+CREATE TEMP TABLE junior_memory_legacy_owners (
+  id text PRIMARY KEY,
+  user_id text NOT NULL
+) ON COMMIT DROP;--> statement-breakpoint
+DO $$
+BEGIN
+  IF to_regclass('junior_identities') IS NOT NULL THEN
+    EXECUTE $migration$
+      INSERT INTO junior_memory_legacy_owners (id, user_id)
+      SELECT memory.id, owner.user_id
+      FROM junior_memory_memories AS memory
+      INNER JOIN LATERAL (
+        SELECT identity.user_id
+        FROM junior_identities AS identity
+        WHERE identity.user_id IS NOT NULL
+          AND (
+            (
+              memory.scope_key LIKE 'slack:%'
+              AND identity.provider = 'slack'
+              AND identity.provider_tenant_id = split_part(memory.scope_key, ':', 2)
+              AND identity.provider_subject_id = split_part(memory.scope_key, ':', 3)
+            )
+            OR (
+              memory.scope_key LIKE 'local:%'
+              AND identity.provider = 'local'
+              AND identity.provider_subject_id = substring(memory.scope_key FROM 7)
+            )
+            OR (
+              memory.scope_key LIKE 'junior:%'
+              AND identity.provider = 'junior'
+              AND identity.provider_subject_id = substring(memory.scope_key FROM 8)
+            )
+          )
+        ORDER BY identity.id
+        LIMIT 1
+      ) AS owner ON memory.scope = 'personal'
+    $migration$;
+  END IF;
+END
+$$;--> statement-breakpoint
+CREATE TEMP TABLE junior_memory_scope_targets ON COMMIT DROP AS
+SELECT
+  memory.id,
+  CASE
+    WHEN memory.scope = 'conversation'
+      AND memory.source_platform = 'slack'
+      AND memory.scope_key = 'slack:' || split_part(memory.source_key, ':', 2)
+      THEN 'public'
+    ELSE 'private'
+  END AS target_scope,
+  CASE
+    WHEN memory.scope = 'conversation'
+      AND memory.source_platform = 'slack'
+      AND memory.scope_key = 'slack:' || split_part(memory.source_key, ':', 2)
+      THEN 'public'
+    WHEN memory.scope = 'personal' AND owner.user_id IS NOT NULL
+      THEN owner.user_id
+    ELSE 'legacy-unowned:' || memory.id
+  END AS target_scope_key,
+  (
+    memory.scope <> 'personal' AND NOT (
+      memory.scope = 'conversation'
+        AND memory.source_platform = 'slack'
+        AND memory.scope_key = 'slack:' || split_part(memory.source_key, ':', 2)
+    )
+  ) OR (memory.scope = 'personal' AND owner.user_id IS NULL) AS archive_unowned
+FROM junior_memory_memories AS memory
+LEFT JOIN junior_memory_legacy_owners AS owner ON owner.id = memory.id;--> statement-breakpoint
+WITH duplicate_targets AS (
+  SELECT
+    memory.id,
+    row_number() OVER (
+      PARTITION BY target.target_scope, target.target_scope_key, memory.idempotency_key
+      ORDER BY memory.id
+    ) AS duplicate_rank
+  FROM junior_memory_memories AS memory
+  INNER JOIN junior_memory_scope_targets AS target ON target.id = memory.id
+  WHERE memory.idempotency_key IS NOT NULL
+    AND memory.archived_at_ms IS NULL
+    AND memory.superseded_at_ms IS NULL
+    AND memory.superseded_by_id IS NULL
+    AND NOT target.archive_unowned
+)
+UPDATE junior_memory_memories AS memory
+SET idempotency_key = 'legacy-scope:' || memory.id
+FROM duplicate_targets
+WHERE memory.id = duplicate_targets.id
+  AND duplicate_targets.duplicate_rank > 1;--> statement-breakpoint
+UPDATE junior_memory_memories AS memory
+SET
+  scope = target.target_scope,
+  scope_key = target.target_scope_key,
+  subject_key = CASE
+    WHEN memory.subject_type = 'user' AND target.target_scope = 'private'
+      THEN target.target_scope_key
+    ELSE memory.subject_key
+  END,
+  archived_at_ms = CASE
+    WHEN target.archive_unowned
+      THEN coalesce(memory.archived_at_ms, floor(extract(epoch FROM clock_timestamp()) * 1000)::bigint)
+    ELSE memory.archived_at_ms
+  END,
+  archive_reason = CASE
+    WHEN target.archive_unowned
+      THEN coalesce(memory.archive_reason, 'legacy_unowned_scope')
+    ELSE memory.archive_reason
+  END
+FROM junior_memory_scope_targets AS target
+WHERE memory.id = target.id;--> statement-breakpoint
+DROP TABLE junior_memory_scope_targets;--> statement-breakpoint
+DROP TABLE junior_memory_legacy_owners;--> statement-breakpoint
+ALTER TABLE "junior_memory_memories" ADD CONSTRAINT "junior_memory_memories_scope_check" CHECK ("junior_memory_memories"."scope" IN ('private', 'public'));

package/migrations/0010_memories_captured_scope_labels.sql

@@ -0,0 +1,50 @@
+-- Rewrite pre-rename memories_captured v2 scope labels in conversation history.
+-- personal -> private, conversation -> public. Leaves v1 rows alone.
+-- No-op when core events are absent.
+DO $$
+BEGIN
+  IF to_regclass('public.junior_conversation_events') IS NULL THEN
+    RETURN;
+  END IF;
+
+  UPDATE junior_conversation_events AS event
+  SET payload = jsonb_set(
+    event.payload,
+    '{content,memories}',
+    (
+      SELECT coalesce(
+        jsonb_agg(
+          CASE
+            WHEN jsonb_typeof(memory.value) = 'object'
+              AND memory.value->>'scope' = 'personal'
+              THEN jsonb_set(memory.value, '{scope}', '"private"'::jsonb)
+            WHEN jsonb_typeof(memory.value) = 'object'
+              AND memory.value->>'scope' = 'conversation'
+              THEN jsonb_set(memory.value, '{scope}', '"public"'::jsonb)
+            ELSE memory.value
+          END
+          ORDER BY memory.ordinality
+        ),
+        '[]'::jsonb
+      )
+      FROM jsonb_array_elements(
+        CASE
+          WHEN jsonb_typeof(event.payload->'content'->'memories') = 'array'
+            THEN event.payload->'content'->'memories'
+          ELSE '[]'::jsonb
+        END
+      ) WITH ORDINALITY AS memory(value, ordinality)
+    )
+  )
+  WHERE event.type = 'structured_event'
+    AND event.payload->>'namespace' = 'memory'
+    AND event.payload->>'name' = 'memories_captured'
+    AND (event.payload->>'version') = '2'
+    AND jsonb_typeof(event.payload->'content'->'memories') = 'array'
+    AND EXISTS (
+      SELECT 1
+      FROM jsonb_array_elements(event.payload->'content'->'memories') AS memory(value)
+      WHERE memory.value->>'scope' IN ('personal', 'conversation')
+    );
+END
+$$;