@sentry/junior-memory 0.118.0 → 0.120.0

package/dist/personal-store.d.ts

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { type MemoryDb, type MemoryRecord } from "./store";
+import type { MemoryRuntimeContext } from "./types";
+declare const personalMemoryCursorSchema: z.ZodObject<{
+    createdAtMs: z.ZodNumber;
+    id: z.ZodString;
+}, z.core.$strict>;
+declare const personalMemoryPageInputSchema: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodObject<{
+        createdAtMs: z.ZodNumber;
+        id: z.ZodString;
+    }, z.core.$strict>>;
+    limit: z.ZodNumber;
+    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[];
+    nextCursor?: PersonalMemoryCursor;
+}
+/** Expected failure when a viewer does not own the requested memory. */
+export declare class PersonalMemoryNotFoundError extends Error {
+    constructor();
+}
+/** Viewer-scoped personal memory operations shared by dashboard and REST. */
+export interface PersonalMemoryCollection {
+    /** Archive one exact personal memory owned by a linked actor. */
+    archive(id: string): Promise<MemoryRecord>;
+    /** Read one exact personal memory owned by a linked actor. */
+    get(id: string): Promise<MemoryRecord>;
+    /** List one stable page across every linked personal scope. */
+    list(input: PersonalMemoryPageInput): Promise<PersonalMemoryPage>;
+}
+/** Build storage operations for every personal scope linked to one viewer. */
+export declare function createPersonalMemoryCollection(db: MemoryDb, runtimeContexts: MemoryRuntimeContext[], options?: {
+    now?: () => number;
+}): PersonalMemoryCollection;
+export {};

package/dist/personal.d.ts

@@ -0,0 +1,21 @@
+import type { PluginUserPageActor } from "@sentry/junior-plugin-api";
+import type { MemoryDb, MemoryRecord } from "./store";
+export interface ViewerMemoryPage {
+    memories: MemoryRecord[];
+    nextCursor?: string;
+}
+export interface ViewerMemoryPageInput {
+    cursor?: string;
+    limit: number;
+    query?: string;
+}
+export declare class InvalidMemoryCursorError extends Error {
+    constructor();
+}
+export { PersonalMemoryNotFoundError } from "./personal-store";
+/** Build personal-memory operations authorized by a viewer's linked actors. */
+export declare function createViewerMemories(db: MemoryDb, actors: PluginUserPageActor[]): {
+    archive(id: string): Promise<MemoryRecord>;
+    get(id: string): Promise<MemoryRecord>;
+    list(input: ViewerMemoryPageInput): Promise<ViewerMemoryPage>;
+};

package/dist/plugin.d.ts

@@ -3,6 +3,5 @@ export interface MemoryPluginOptions {
     /** Maximum cosine distance for vector recall candidates. Defaults to MEMORY_RECALL_MAX_VECTOR_DISTANCE env or 0.45. */
     recallMaxVectorDistance?: number;
 }
-/** Create Junior's long-term memory plugin registration. */
-export declare function createMemoryPlugin(options?: MemoryPluginOptions): import("@sentry/junior-plugin-api").PluginRegistration;
-export declare const memoryPlugin: import("@sentry/junior-plugin-api").PluginRegistration;
+/** Register Junior's long-term memory plugin. */
+export declare function memoryPlugin(options?: MemoryPluginOptions): import("@sentry/junior-plugin-api").PluginRegistration;

package/dist/ranking.d.ts

@@ -0,0 +1,20 @@
+import type { MemoryRecord } from "./store";
+export interface MemoryMatch {
+    exactIdentifier: boolean;
+    lexical?: {
+        rank: number;
+    };
+    memory: MemoryRecord;
+    sourceKey: string;
+    vector?: {
+        rank: number;
+    };
+}
+/**
+ * Keep exact structured-identifier matches in the strongest relevance tier,
+ * then fuse lexical and vector ranks without comparing provider raw scores.
+ */
+export declare function rankMemoryMatches(matches: MemoryMatch[], options: {
+    channelPrefix?: string;
+    nowMs: number;
+}): MemoryMatch[];

package/dist/recall.d.ts

@@ -1,10 +1,13 @@
-import { type UserPromptContribution, type Actor, type Source } from "@sentry/junior-plugin-api";
+import { type UserPromptContribution, type Actor, type PluginLogger, type Source } from "@sentry/junior-plugin-api";
 import { z } from "zod";
+import type { MemoryAgent } from "./agent";
 import { type MemoryDb, type MemoryEmbeddingProvider } from "./store";
 export interface MemoryRecallContext {
+    agent: Pick<MemoryAgent, "selectRelevantMemories">;
     conversationId?: string;
     db: MemoryDb;
     embedder?: MemoryEmbeddingProvider;
+    log: PluginLogger;
     /** Maximum cosine distance for vector recall. Passed through to the memory store. */
     maxVectorDistance?: number;
     actor?: Actor;

package/dist/store.d.ts

@@ -1,8 +1,10 @@
+import { type SQL } from "drizzle-orm";
 import type { PgDatabase } from "drizzle-orm/pg-core";
 import type { PgQueryResultHKT } from "drizzle-orm/pg-core/session";
 import { z } from "zod";
 import * as memorySqlSchema from "./db/schema";
 import { type MemoryRuntimeContext } from "./types";
+import { type ResolvedMemoryScope } from "./scope";
 export type MemoryDb = PgDatabase<PgQueryResultHKT, typeof memorySqlSchema>;
 declare const createMemoryInputSchema: z.ZodObject<{
     content: z.ZodString;
@@ -168,9 +170,32 @@ export interface MemoryStore {
     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.
+     */
+    recallMemories(input: SearchMemoriesInput): Promise<MemoryRecord[]>;
     /** 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. */
+export declare function activeVisiblePredicate(args: {
+    nowMs: number;
+    scopes: ResolvedMemoryScope[];
+}): SQL | undefined;
+/**
+ * Archive a bounded batch of expired active rows and remove their derived vectors.
+ */
+export declare function archiveExpiredMemoryBatch(args: {
+    db: MemoryDb;
+    idempotencyKey?: string;
+    limit?: number;
+    nowMs: number;
+    scopes: ResolvedMemoryScope[];
+}): Promise<ArchiveExpiredMemoriesResult>;
 /** Create a context-bound SQL-backed store for explicit memory operations. */
 export declare function createMemoryStore(db: MemoryDb, context: MemoryRuntimeContext, options?: MemoryStoreOptions): MemoryStore;
 export {};

package/dist/user-pages.d.ts

@@ -1,4 +1,4 @@
-/** Project actor-owned memories into Junior's core-rendered user page. */
+/** Project viewer-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. */
+/** Create the interactive personal Memories dashboard page. */
 export declare function createMemoryUserPage(): PluginUserPageDefinition;

package/migrations/0005_short_jamie_braddock.sql

@@ -0,0 +1 @@
+CREATE INDEX "junior_memory_memories_search_idx" ON "junior_memory_memories" USING gin (to_tsvector('english', "content")) WHERE "junior_memory_memories"."archived_at_ms" IS NULL AND "junior_memory_memories"."superseded_at_ms" IS NULL AND "junior_memory_memories"."superseded_by_id" IS NULL;

package/migrations/meta/0005_snapshot.json

@@ -0,0 +1,364 @@
+{
+  "id": "6948ea3f-2e44-49ce-aa94-8a993ce61cec",
+  "prevId": "e915b537-996a-488c-a828-7cf4da06be44",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "public.junior_memory_embeddings": {
+      "name": "junior_memory_embeddings",
+      "schema": "",
+      "columns": {
+        "memory_id": {
+          "name": "memory_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "provider": {
+          "name": "provider",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "model": {
+          "name": "model",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "dimensions": {
+          "name": "dimensions",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "metric": {
+          "name": "metric",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "content_hash": {
+          "name": "content_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "embedding": {
+          "name": "embedding",
+          "type": "vector(1536)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at_ms": {
+          "name": "created_at_ms",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "junior_memory_embeddings_model_idx": {
+          "name": "junior_memory_embeddings_model_idx",
+          "columns": [
+            {
+              "expression": "provider",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "model",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "dimensions",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "metric",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "junior_memory_embeddings_memory_id_junior_memory_memories_id_fk": {
+          "name": "junior_memory_embeddings_memory_id_junior_memory_memories_id_fk",
+          "tableFrom": "junior_memory_embeddings",
+          "tableTo": "junior_memory_memories",
+          "columnsFrom": ["memory_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "junior_memory_embeddings_metric_check": {
+          "name": "junior_memory_embeddings_metric_check",
+          "value": "\"junior_memory_embeddings\".\"metric\" IN ('cosine')"
+        },
+        "junior_memory_embeddings_dimensions_check": {
+          "name": "junior_memory_embeddings_dimensions_check",
+          "value": "\"junior_memory_embeddings\".\"dimensions\" = 1536"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.junior_memory_memories": {
+      "name": "junior_memory_memories",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "scope": {
+          "name": "scope",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "scope_key": {
+          "name": "scope_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "subject_type": {
+          "name": "subject_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "subject_key": {
+          "name": "subject_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "content": {
+          "name": "content",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "source_platform": {
+          "name": "source_platform",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "source_key": {
+          "name": "source_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "idempotency_key": {
+          "name": "idempotency_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "observed_at_ms": {
+          "name": "observed_at_ms",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at_ms": {
+          "name": "created_at_ms",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "expires_at_ms": {
+          "name": "expires_at_ms",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "superseded_at_ms": {
+          "name": "superseded_at_ms",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "superseded_by_id": {
+          "name": "superseded_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "archived_at_ms": {
+          "name": "archived_at_ms",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "archive_reason": {
+          "name": "archive_reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "junior_memory_memories_visible_idx": {
+          "name": "junior_memory_memories_visible_idx",
+          "columns": [
+            {
+              "expression": "scope",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "scope_key",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at_ms",
+              "isExpression": false,
+              "asc": false,
+              "nulls": "last"
+            },
+            {
+              "expression": "id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"junior_memory_memories\".\"archived_at_ms\" IS NULL AND \"junior_memory_memories\".\"superseded_at_ms\" IS NULL AND \"junior_memory_memories\".\"superseded_by_id\" IS NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "junior_memory_memories_expiration_idx": {
+          "name": "junior_memory_memories_expiration_idx",
+          "columns": [
+            {
+              "expression": "expires_at_ms",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"junior_memory_memories\".\"archived_at_ms\" IS NULL AND \"junior_memory_memories\".\"expires_at_ms\" IS NOT NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "junior_memory_memories_search_idx": {
+          "name": "junior_memory_memories_search_idx",
+          "columns": [
+            {
+              "expression": "to_tsvector('english', \"content\")",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"junior_memory_memories\".\"archived_at_ms\" IS NULL AND \"junior_memory_memories\".\"superseded_at_ms\" IS NULL AND \"junior_memory_memories\".\"superseded_by_id\" IS NULL",
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        },
+        "junior_memory_memories_idempotency_idx": {
+          "name": "junior_memory_memories_idempotency_idx",
+          "columns": [
+            {
+              "expression": "scope",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "scope_key",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "idempotency_key",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "\"junior_memory_memories\".\"idempotency_key\" IS NOT NULL AND \"junior_memory_memories\".\"archived_at_ms\" IS NULL AND \"junior_memory_memories\".\"superseded_at_ms\" IS NULL AND \"junior_memory_memories\".\"superseded_by_id\" IS NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "junior_memory_memories_scope_check": {
+          "name": "junior_memory_memories_scope_check",
+          "value": "\"junior_memory_memories\".\"scope\" IN ('personal', 'conversation')"
+        },
+        "junior_memory_memories_kind_check": {
+          "name": "junior_memory_memories_kind_check",
+          "value": "\"junior_memory_memories\".\"type\" IN (\n        'preference',\n        'procedure',\n        'knowledge'\n      )"
+        },
+        "junior_memory_memories_subject_type_check": {
+          "name": "junior_memory_memories_subject_type_check",
+          "value": "\"junior_memory_memories\".\"subject_type\" IN ('user', 'conversation', 'general')"
+        },
+        "junior_memory_memories_subject_key_check": {
+          "name": "junior_memory_memories_subject_key_check",
+          "value": "(\"junior_memory_memories\".\"subject_type\" = 'general' AND \"junior_memory_memories\".\"subject_key\" IS NULL) OR (\"junior_memory_memories\".\"subject_type\" IN ('user', 'conversation') AND \"junior_memory_memories\".\"subject_key\" IS NOT NULL AND length(\"junior_memory_memories\".\"subject_key\") > 0)"
+        },
+        "junior_memory_memories_source_platform_check": {
+          "name": "junior_memory_memories_source_platform_check",
+          "value": "\"junior_memory_memories\".\"source_platform\" IN ('slack', 'local')"
+        }
+      },
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {},
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}

package/migrations/meta/_journal.json

@@ -36,6 +36,13 @@
       "when": 1782676852768,
       "tag": "0004_gigantic_celestials",
       "breakpoints": true
+    },
+    {
+      "idx": 5,
+      "version": "7",
+      "when": 1785293874649,
+      "tag": "0005_short_jamie_braddock",
+      "breakpoints": true
     }
   ]
 }

package/package.json

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

package/src/agent.ts

@@ -23,6 +23,28 @@ const memoryRejectReasonSchema = z.enum([
   "assistant_or_system_detail",
   "unsupported_scope",
 ]);
+const memoryRecallCandidateSchema = z
+  .object({
+    content: z.string().min(1),
+    id: z.string().min(1),
+  })
+  .strict();
+const memoryRecallInputSchema = z
+  .object({
+    candidates: z.array(memoryRecallCandidateSchema).min(1).max(20),
+    userRequest: z.string().min(1),
+  })
+  .strict();
+const memoryRecallDecisionSchema = z
+  .object({
+    relevantIds: z
+      .array(z.string().min(1))
+      .max(20)
+      .describe(
+        "Candidate ids whose memories directly help with the current request, ordered by relevance.",
+      ),
+  })
+  .strict();
 const createMemoryRequestSchema = z
   .object({
     content: z.string().min(1),
@@ -169,6 +191,7 @@ type MemoryReviewResponse = z.output<typeof memoryReviewResponseSchema>;
 type ExtractMemoriesResponse = z.output<typeof extractMemoriesResponseSchema>;
 
 export type MemoryReview = z.output<typeof memoryReviewDecisionSchema>;
+export type MemoryRecallInput = z.output<typeof memoryRecallInputSchema>;
 
 export type CreateMemoryRequest = z.output<typeof createMemoryRequestSchema>;
 export type ExtractSessionRequest = z.output<
@@ -177,6 +200,10 @@ export type ExtractSessionRequest = z.output<
 export type ExtractedMemory = z.output<typeof extractedMemoryResultSchema>;
 
 export interface MemoryAgent {
+  /** Select candidate memories that directly help with the current request. */
+  selectRelevantMemories(
+    request: MemoryRecallInput,
+  ): Promise<string[]> | string[];
   /** Classify a new preference against related active preferences. */
   adjudicateSupersession(
     request: MemorySupersessionInput,
@@ -203,6 +230,13 @@ const MEMORY_EXTRACTION_SYSTEM = [
   "Reject secrets, credentials, private or sensitive personal details, gossip, speculative claims about other people, assistant/system implementation details, vague references, and low-durability chatter.",
   "If no public, durable, self-contained memory remains after rewriting, return an empty memories array.",
 ].join("\n");
+const MEMORY_RECALL_SYSTEM = [
+  "You are Junior's memory recall relevance agent.",
+  "Select only memories that would directly help answer the user's current request.",
+  "Reject memories that merely share a company, product family, repository vocabulary, programming language, or general engineering context.",
+  "Prefer specific matches on the exact repository, workflow, command, test, CI setup, project, or user preference being asked about.",
+  "An empty relevantIds array is correct when no candidate is directly helpful.",
+].join("\n");
 const MEMORY_PREFERENCE_ADJUDICATION_SYSTEM = [
   "You are Junior's memory preference adjudication agent.",
   "Classify how one new actor preference relates to existing active actor preferences.",
@@ -444,6 +478,22 @@ function sessionExtractionPrompt(request: ExtractSessionRequest): string {
   ].join("\n");
 }
 
+function recallRelevancePrompt(request: MemoryRecallInput): string {
+  return [
+    "<memory-recall-input>",
+    "<user-request>",
+    escapeXml(request.userRequest),
+    "</user-request>",
+    "",
+    "<candidate-memories>",
+    escapeXml(JSON.stringify(request.candidates)),
+    "</candidate-memories>",
+    "",
+    "Return only ids from candidate-memories. Preserve the most relevant candidates first.",
+    "</memory-recall-input>",
+  ].join("\n");
+}
+
 function preferenceAdjudicationPrompt(
   request: MemorySupersessionInput,
 ): string {
@@ -477,9 +527,23 @@ function preferenceAdjudicationPrompt(
   ].join("\n");
 }
 
-/** Create the memory-owned agent that reviews and extracts memory candidates. */
+/** Create the memory-owned agent that reviews, extracts, and recalls memories. */
 export function createMemoryAgent(model: PluginModel): MemoryAgent {
   return {
+    async selectRelevantMemories(rawRequest) {
+      const request = memoryRecallInputSchema.parse(rawRequest);
+      const result = await model.completeObject({
+        schema: memoryRecallDecisionSchema,
+        system: MEMORY_RECALL_SYSTEM,
+        prompt: recallRelevancePrompt(request),
+        maxTokens: 400,
+      });
+      const decision = memoryRecallDecisionSchema.parse(result.object);
+      const candidateIds = new Set(request.candidates.map(({ id }) => id));
+      return [...new Set(decision.relevantIds)].filter((id) =>
+        candidateIds.has(id),
+      );
+    },
     async adjudicateSupersession(rawRequest) {
       const request = memorySupersessionInputSchema.parse(rawRequest);
       const result = await model.completeObject({