@sentry/junior-memory 0.147.0 → 0.148.0

package/src/process-session.ts

@@ -1,10 +1,10 @@
 import { createHash } from "node:crypto";
 import {
   getSourceKey,
-  isPrivateSource,
   type PluginRunContext,
   type PluginRunTranscriptEntry,
   type PluginTaskContext,
+  type Source,
 } from "@sentry/junior-plugin-api";
 import { z } from "zod";
 import {
@@ -57,6 +57,21 @@ const extractedMemoryCacheSchema = z.union([
 /** Where a passively extracted memory may be stored, or dropped when unproven. */
 type MemoryRouteTarget = "drop" | "personal" | "conversation";
 
+/**
+ * V1 passive learning opts in by Source branch, then public vs private.
+ * Public API is the same as public Slack: shared conversation evidence may
+ * learn. Private sources stay out. Local remains available for QA.
+ */
+function allowsPassiveMemoryExtraction(source: Source): boolean {
+  switch (source.platform) {
+    case "local":
+      return true;
+    case "web":
+    case "slack":
+      return source.visibility === "public";
+  }
+}
+
 function recordCapturedMemory(
   captured: ReturnType<typeof capturedMemory>[],
   result: CreateMemoryResult,
@@ -232,8 +247,9 @@ export async function processMemorySession(
   ) {
     return;
   }
-  // V1 passive learning only stores public channel facts outside local QA.
-  if (run.source.platform !== "local" && isPrivateSource(run.source)) {
+  // V1 passive learning is a Source-branch policy: local QA always, public
+  // Slack/API by visibility, private sources never.
+  if (!allowsPassiveMemoryExtraction(run.source)) {
     return;
   }
   const sourceKey = getSourceKey(run.source);

package/src/scope.ts

@@ -1,4 +1,4 @@
-import { isPrivateSource, type Identity } from "@sentry/junior-plugin-api";
+import { type Actor, type Identity, type Source } from "@sentry/junior-plugin-api";
 import type {
   MemoryRuntimeContext,
   MemoryScope,
@@ -25,29 +25,40 @@ function uniqueScopes(scopes: ResolvedMemoryScope[]): ResolvedMemoryScope[] {
   ];
 }
 
+/** Personal scope key for one verified provider identity, when one exists. */
+function personalScopeFromIdentity(
+  identity: Identity,
+): ResolvedMemoryScope | undefined {
+  if (identity.provider === "local") {
+    return {
+      scope: "personal",
+      scopeKey: `local:${identity.providerSubjectId}`,
+    };
+  }
+  // Dashboard/web actors persist as junior identities keyed by verified email.
+  if (identity.provider === "junior") {
+    return {
+      scope: "personal",
+      scopeKey: `junior:${identity.providerSubjectId}`,
+    };
+  }
+  if (identity.provider === "slack" && identity.providerTenantId) {
+    return {
+      scope: "personal",
+      scopeKey: `slack:${identity.providerTenantId}:${identity.providerSubjectId}`,
+    };
+  }
+  return undefined;
+}
+
 /** Derive viewer-visible memory scopes from canonical provider identities. */
 export function deriveViewerMemoryScopes(identities: Identity[]): {
   privateScopes: ResolvedMemoryScope[];
   publicScopes: ResolvedMemoryScope[];
 } {
   const privateScopes = identities.flatMap((identity) => {
-    if (identity.provider === "local") {
-      return [
-        {
-          scope: "personal" as const,
-          scopeKey: `local:${identity.providerSubjectId}`,
-        },
-      ];
-    }
-    if (identity.provider === "slack" && identity.providerTenantId) {
-      return [
-        {
-          scope: "personal" as const,
-          scopeKey: `slack:${identity.providerTenantId}:${identity.providerSubjectId}`,
-        },
-      ];
-    }
-    return [];
+    const scope = personalScopeFromIdentity(identity);
+    return scope ? [scope] : [];
   });
   const publicScopes = identities.flatMap((identity) =>
     identity.provider === "slack" && identity.providerTenantId
@@ -65,29 +76,43 @@ export function deriveViewerMemoryScopes(identities: Identity[]): {
   };
 }
 
-function sourceConversationKey(ctx: MemoryRuntimeContext): string | undefined {
-  if (ctx.source.platform === "local") {
-    return ctx.source.conversationId;
-  }
-  if (!isPrivateSource(ctx.source)) {
-    return `slack:${ctx.source.teamId}`;
-  }
-  const threadKey = ctx.source.threadTs ?? ctx.source.messageTs;
-  if (!threadKey) {
-    return undefined;
+/** Conversation-scoped key for the Source branch we actually have. */
+function sourceConversationKey(source: Source): string | undefined {
+  switch (source.platform) {
+    case "web":
+    case "local":
+      return source.conversationId;
+    case "slack": {
+      if (source.visibility === "public") {
+        return `slack:${source.teamId}`;
+      }
+      const threadKey = source.threadTs ?? source.messageTs;
+      if (!threadKey) {
+        return undefined;
+      }
+      return `slack:${source.teamId}:${source.channelId}:${threadKey}`;
+    }
   }
-  return `slack:${ctx.source.teamId}:${ctx.source.channelId}:${threadKey}`;
 }
 
-function actorScopeKey(ctx: MemoryRuntimeContext): string | undefined {
-  const actor = ctx.actor;
-  if (!actor || actor.platform === "system") {
+/** Personal scope key for the Actor branch we actually have. */
+function actorScopeKey(actor: Actor | undefined): string | undefined {
+  if (!actor) {
     return undefined;
   }
-  if (actor.platform === "slack") {
-    return `slack:${actor.teamId}:${actor.userId}`;
+  switch (actor.platform) {
+    case "system":
+      return undefined;
+    case "slack":
+      return `slack:${actor.teamId}:${actor.userId}`;
+    case "local":
+      return `local:${actor.userId}`;
+    case "web": {
+      // Match junior identity personal scopes used by the dashboard viewer.
+      const email = actor.email?.trim().toLowerCase();
+      return email ? `junior:${email}` : undefined;
+    }
   }
-  return `local:${actor.userId}`;
 }
 
 /** Derive the authority-bearing key for a requested memory scope. */
@@ -96,14 +121,14 @@ export function deriveMemoryScope(
   scope: MemoryScope,
 ): ResolvedMemoryScope {
   if (scope === "personal") {
-    const scopeKey = actorScopeKey(ctx);
+    const scopeKey = actorScopeKey(ctx.actor);
     if (!scopeKey) {
       throw new Error("Personal memory requires actor context.");
     }
     return { scope, scopeKey };
   }
 
-  const scopeKey = sourceConversationKey(ctx);
+  const scopeKey = sourceConversationKey(ctx.source);
   if (!scopeKey) {
     throw new Error("Conversation memory requires conversation context.");
   }
@@ -116,14 +141,14 @@ export function deriveMemorySubject(
   scope: ResolvedMemoryScope,
 ): ResolvedMemorySubject {
   if (scope.scope === "personal") {
-    const subjectKey = actorScopeKey(ctx);
+    const subjectKey = actorScopeKey(ctx.actor);
     if (!subjectKey) {
       throw new Error("User-subject memory requires actor context.");
     }
     return { subjectType: "user", subjectKey };
   }
 
-  const subjectKey = sourceConversationKey(ctx);
+  const subjectKey = sourceConversationKey(ctx.source);
   if (!subjectKey) {
     throw new Error(
       "Conversation-subject memory requires conversation context.",

package/src/store.ts

@@ -37,6 +37,7 @@ import {
   memoryRuntimeContextSchema,
   type MemoryRuntimeContext,
   type MemoryScope,
+  type MemorySourcePlatform,
 } from "./types";
 import {
   deriveMemoryScope,
@@ -383,26 +384,47 @@ function boundedLimit(value: number | undefined, fallback: number): number {
   return Math.min(200, Math.max(1, Math.floor(value)));
 }
 
+/** Map runtime Source platform onto the durable memory source platform. */
+function memorySourcePlatform(
+  source: MemoryRuntimeContext["source"],
+): MemorySourcePlatform {
+  switch (source.platform) {
+    case "slack":
+      return "slack";
+    case "local":
+      return "local";
+    case "web":
+      return "web";
+  }
+}
+
 /** Build the durable source attribution key from runtime-owned source fields. */
 function sourceKey(ctx: MemoryRuntimeContext): string {
-  if (ctx.source.platform === "local") {
-    return ctx.source.conversationId;
-  }
-  const threadKey = ctx.source.threadTs ?? ctx.source.messageTs;
-  if (!threadKey) {
-    throw new Error(
-      "Memory source requires a Slack message or thread timestamp.",
-    );
+  switch (ctx.source.platform) {
+    case "web":
+    case "local":
+      return ctx.source.conversationId;
+    case "slack": {
+      const threadKey = ctx.source.threadTs ?? ctx.source.messageTs;
+      if (!threadKey) {
+        throw new Error(
+          "Memory source requires a Slack message or thread timestamp.",
+        );
+      }
+      return `slack:${ctx.source.teamId}:${ctx.source.channelId}:${threadKey}`;
+    }
   }
-  return `slack:${ctx.source.teamId}:${ctx.source.channelId}:${threadKey}`;
 }
 
 function sourceChannelPrefix(ctx: MemoryRuntimeContext): string | undefined {
-  if (ctx.source.platform !== "slack") {
-    return undefined;
+  switch (ctx.source.platform) {
+    case "slack":
+      // TODO(v0.82.0): Replace Slack source-key prefix matching with typed source proximity metadata.
+      return `slack:${ctx.source.teamId}:${ctx.source.channelId}:`;
+    case "web":
+    case "local":
+      return undefined;
   }
-  // TODO(v0.82.0): Replace Slack source-key prefix matching with typed source proximity metadata.
-  return `slack:${ctx.source.teamId}:${ctx.source.channelId}:`;
 }
 
 /** Parse one SQL row into the public memory record projection. */
@@ -788,7 +810,7 @@ async function rememberDuplicateIdempotency(args: {
       scope: args.scope.scope,
       scopeKey: args.scope.scopeKey,
       sourceKey: sourceKey(args.runtimeContext),
-      sourcePlatform: args.runtimeContext.source.platform,
+      sourcePlatform: memorySourcePlatform(args.runtimeContext.source),
       subjectKey: args.subject.subjectKey,
       subjectType: args.subject.subjectType,
       supersededAtMs: args.nowMs,
@@ -1305,7 +1327,7 @@ export function createMemoryStore(
           scope: scope.scope,
           scopeKey: scope.scopeKey,
           sourceKey: sourceKey(runtimeContext),
-          sourcePlatform: runtimeContext.source.platform,
+          sourcePlatform: memorySourcePlatform(runtimeContext.source),
           subjectKey: subject.subjectKey,
           subjectType: subject.subjectType,
           kind: input.kind,

package/src/types.ts

@@ -1,8 +1,4 @@
-import {
-  actorSchema,
-  platformSchema,
-  sourceSchema,
-} from "@sentry/junior-plugin-api";
+import { actorSchema, sourceSchema } from "@sentry/junior-plugin-api";
 import { z } from "zod";
 
 export const MEMORY_KINDS = ["preference", "procedure", "knowledge"] as const;
@@ -13,10 +9,8 @@ export const MEMORY_SUBJECT_TYPES = [
   "conversation",
   "general",
 ] as const;
-export const MEMORY_SOURCE_PLATFORMS = [
-  "slack",
-  "local",
-] as const satisfies readonly z.output<typeof platformSchema>[];
+// Durable attribution follows Source platform, including dashboard/web roots.
+export const MEMORY_SOURCE_PLATFORMS = ["slack", "local", "web"] as const;
 export const MEMORY_EMBEDDING_METRICS = ["cosine"] as const;
 export const MEMORY_EMBEDDING_DIMENSIONS = 1536;