@sentry/junior-memory 0.90.0 → 0.92.0

package/dist/agent.d.ts

@@ -1,4 +1,4 @@
-import type { PluginModel } from "@sentry/junior-plugin-api";
+import { type PluginModel } from "@sentry/junior-plugin-api";
 import { z } from "zod";
 import type { MemorySupersessionDecision, MemorySupersessionInput } from "./store";
 declare const createMemoryRequestSchema: z.ZodObject<{
@@ -6,7 +6,7 @@ declare const createMemoryRequestSchema: z.ZodObject<{
     expiresAtMs: z.ZodOptional<z.ZodNumber>;
     runtimeContext: z.ZodUnion<readonly [z.ZodObject<{
         conversationId: z.ZodOptional<z.ZodString>;
-        requester: z.ZodOptional<z.ZodObject<{
+        actor: z.ZodOptional<z.ZodObject<{
             platform: z.ZodLiteral<"slack">;
             teamId: z.ZodString;
             email: z.ZodOptional<z.ZodString>;
@@ -27,7 +27,7 @@ declare const createMemoryRequestSchema: z.ZodObject<{
         }, z.core.$strict>;
     }, z.core.$strict>, z.ZodObject<{
         conversationId: z.ZodOptional<z.ZodString>;
-        requester: z.ZodOptional<z.ZodObject<{
+        actor: z.ZodOptional<z.ZodObject<{
             platform: z.ZodLiteral<"local">;
             email: z.ZodOptional<z.ZodString>;
             fullName: z.ZodOptional<z.ZodString>;
@@ -48,9 +48,26 @@ declare const extractSessionRequestSchema: z.ZodObject<{
     existingMemories: z.ZodDefault<z.ZodArray<z.ZodObject<{
         content: z.ZodString;
     }, z.core.$strict>>>;
+    actors: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        platform: z.ZodLiteral<"slack">;
+        teamId: z.ZodString;
+        email: z.ZodOptional<z.ZodString>;
+        fullName: z.ZodOptional<z.ZodString>;
+        userId: z.ZodString;
+        userName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        platform: z.ZodLiteral<"local">;
+        email: z.ZodOptional<z.ZodString>;
+        fullName: z.ZodOptional<z.ZodString>;
+        userId: z.ZodString;
+        userName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        platform: z.ZodLiteral<"system">;
+        name: z.ZodString;
+    }, z.core.$strict>], "platform">>;
     runtimeContext: z.ZodUnion<readonly [z.ZodObject<{
         conversationId: z.ZodOptional<z.ZodString>;
-        requester: z.ZodOptional<z.ZodObject<{
+        actor: z.ZodOptional<z.ZodObject<{
             platform: z.ZodLiteral<"slack">;
             teamId: z.ZodString;
             email: z.ZodOptional<z.ZodString>;
@@ -71,7 +88,7 @@ declare const extractSessionRequestSchema: z.ZodObject<{
         }, z.core.$strict>;
     }, z.core.$strict>, z.ZodObject<{
         conversationId: z.ZodOptional<z.ZodString>;
-        requester: z.ZodOptional<z.ZodObject<{
+        actor: z.ZodOptional<z.ZodObject<{
             platform: z.ZodLiteral<"local">;
             email: z.ZodOptional<z.ZodString>;
             fullName: z.ZodOptional<z.ZodString>;
@@ -91,6 +108,30 @@ declare const extractSessionRequestSchema: z.ZodObject<{
             assistant: "assistant";
         }>;
         text: z.ZodString;
+        provenance: z.ZodOptional<z.ZodObject<{
+            authority: z.ZodEnum<{
+                instruction: "instruction";
+                context: "context";
+            }>;
+            actor: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                platform: z.ZodLiteral<"slack">;
+                teamId: z.ZodString;
+                email: z.ZodOptional<z.ZodString>;
+                fullName: z.ZodOptional<z.ZodString>;
+                userId: z.ZodString;
+                userName: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                platform: z.ZodLiteral<"local">;
+                email: z.ZodOptional<z.ZodString>;
+                fullName: z.ZodOptional<z.ZodString>;
+                userId: z.ZodString;
+                userName: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                platform: z.ZodLiteral<"system">;
+                name: z.ZodString;
+            }, z.core.$strict>], "platform">>;
+        }, z.core.$strict>>;
+        isRunActor: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"toolResult">;
         toolName: z.ZodString;
@@ -128,6 +169,7 @@ declare const extractedMemoryResultSchema: z.ZodObject<{
         procedure: "procedure";
         knowledge: "knowledge";
     }>;
+    evidenceMessageIndices: z.ZodArray<z.ZodNumber>;
 }, z.core.$strict>;
 export type MemoryReview = z.output<typeof memoryReviewDecisionSchema>;
 export type CreateMemoryRequest = z.output<typeof createMemoryRequestSchema>;

package/dist/index.js

@@ -2,13 +2,14 @@
 import { defineJuniorPlugin } from "@sentry/junior-plugin-api";
 
 // src/agent.ts
+import { actorSchema } from "@sentry/junior-plugin-api";
 import { z as z2 } from "zod";
 
 // src/types.ts
 import {
-  localRequesterSchema,
+  localActorSchema,
   localSourceSchema,
-  slackRequesterSchema,
+  slackActorSchema,
   slackSourceSchema
 } from "@sentry/junior-plugin-api";
 import { z } from "zod";
@@ -28,12 +29,12 @@ var MEMORY_EMBEDDING_DIMENSIONS = 1536;
 var nonEmptyStringSchema = z.string().min(1);
 var slackMemoryRuntimeContextSchema = z.object({
   conversationId: nonEmptyStringSchema.optional(),
-  requester: slackRequesterSchema.optional(),
+  actor: slackActorSchema.optional(),
   source: slackSourceSchema
 }).strict();
 var localMemoryRuntimeContextSchema = z.object({
   conversationId: nonEmptyStringSchema.optional(),
-  requester: localRequesterSchema.optional(),
+  actor: localActorSchema.optional(),
   source: localSourceSchema
 }).strict();
 var memoryRuntimeContextSchema = z.union([
@@ -61,19 +62,27 @@ var createMemoryRequestSchema = z2.object({
     currentUserText: z2.string().min(1).optional()
   }).strict().optional()
 }).strict();
+var transcriptProvenanceSchema = z2.object({
+  authority: z2.enum(["instruction", "context"]),
+  actor: actorSchema.optional()
+}).strict();
+var evidenceMessageIndicesSchema = z2.array(z2.number().int().nonnegative()).min(1).max(10).describe("Indices from <run-transcript> that directly support this memory.");
 var extractSessionRequestSchema = z2.object({
   existingMemories: z2.array(
     z2.object({
       content: z2.string().min(1)
     }).strict()
   ).max(10).default([]),
+  actors: z2.array(actorSchema),
   runtimeContext: memoryRuntimeContextSchema,
   transcript: z2.array(
     z2.discriminatedUnion("type", [
       z2.object({
         type: z2.literal("message"),
         role: z2.enum(["user", "assistant"]),
-        text: z2.string().min(1)
+        text: z2.string().min(1),
+        provenance: transcriptProvenanceSchema.optional(),
+        isRunActor: z2.boolean().optional()
       }).strict(),
       z2.object({
         type: z2.literal("toolResult"),
@@ -116,10 +125,10 @@ var memoryReviewResponseSchema = z2.discriminatedUnion("decision", [
   z2.object({
     decision: z2.literal("store"),
     kind: memoryKindSchema.describe(
-      "Use preference only for requester-owned personal preferences, opinions, habits, or workflows. Use procedure for reusable task or process instructions. Use knowledge for shared project, channel, operational, or runbook facts."
+      "Use preference only for actor-owned personal preferences, opinions, habits, or workflows. Use procedure for reusable task or process instructions. Use knowledge for shared project, channel, operational, or runbook facts."
     ),
     canonicalFact: z2.string().min(1).describe(
-      "Stored memory text. It must be self-contained and must not include requester names, requester/user labels, source labels, or first- or second-person wording."
+      "Stored memory text. It must be self-contained and must not include actor names, actor/user labels, source labels, or first- or second-person wording."
     ),
     expiresAtMs: expiresAtMsSchema
   }).strict(),
@@ -130,17 +139,19 @@ var memoryReviewResponseSchema = z2.discriminatedUnion("decision", [
 ]);
 var extractedMemorySchema = z2.object({
   kind: memoryKindSchema.describe(
-    "Use preference only for requester-owned personal preferences, opinions, habits, or workflows. Use procedure for reusable task or process instructions. Use knowledge for shared project, channel, operational, or runbook facts."
+    "Use preference only for actor-owned personal preferences, opinions, habits, or workflows. Use procedure for reusable task or process instructions. Use knowledge for shared project, channel, operational, or runbook facts."
   ),
   canonicalFact: z2.string().min(1).describe(
-    "Stored memory text as one self-contained fact. It must not include requester names, requester/user labels, source labels, or first- or second-person wording."
+    "Stored memory text as one self-contained fact. It must not include actor names, actor/user labels, source labels, or first- or second-person wording."
   ),
-  expiresAtMs: expiresAtMsSchema
+  expiresAtMs: expiresAtMsSchema,
+  evidenceMessageIndices: evidenceMessageIndicesSchema
 }).strict();
 var extractedMemoryResultSchema = z2.object({
   content: z2.string().min(1),
   expiresAtMs: expiresAtMsSchema,
-  kind: memoryKindSchema
+  kind: memoryKindSchema,
+  evidenceMessageIndices: evidenceMessageIndicesSchema
 }).strict();
 var extractMemoriesResponseSchema = z2.object({
   memories: z2.array(extractedMemorySchema).max(5).describe(
@@ -172,7 +183,7 @@ var MEMORY_EXTRACTION_SYSTEM = [
 ].join("\n");
 var MEMORY_SUPERSESSION_SYSTEM = [
   "You are Junior's memory supersession agent.",
-  "Decide whether a new requester preference clearly replaces existing active requester preferences.",
+  "Decide whether a new actor preference clearly replaces existing active actor preferences.",
   "Return supersedes_old only for obvious changed preferences about the same mutable slot.",
   "If the facts are additive, different topics, duplicate, broader/narrower without direct replacement, or uncertain, do not supersede."
 ].join("\n");
@@ -181,19 +192,19 @@ var CANONICAL_CONTENT_RULES = [
   "- Store the minimum useful assertion supported by source evidence; do not add adjacent steps, caveats, or generalized advice.",
   "- Do not return both concise and expanded variants of the same source assertion; keep the shortest self-contained canonical memory.",
   "- Put ownership in structured fields, not prose.",
-  "- For requester memories, omit the subject and write a stable fact such as 'Prefers X', 'Uses Y', or 'Thinks Z'.",
+  "- For actor memories, omit the subject and write a stable fact such as 'Prefers X', 'Uses Y', or 'Thinks Z'.",
   "- Drop perspective/provenance markers while preserving useful context.",
-  "- Remove requester names, display names, requester/user labels, first- or second-person wording, thread labels, channel labels, and source labels."
+  "- Remove actor names, display names, actor/user labels, first- or second-person wording, thread labels, channel labels, and source labels."
 ];
 function escapeXml(value) {
   return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 }
 function runtimeDescription(request) {
   const runtime = request.runtimeContext;
-  const requester = runtime.requester?.platform === "slack" ? `slack:${runtime.requester.teamId}:${runtime.requester.userId}` : runtime.requester?.platform === "local" ? `local:${runtime.requester.userId}` : "none";
+  const actor = runtime.actor?.platform === "slack" ? `slack:${runtime.actor.teamId}:${runtime.actor.userId}` : runtime.actor?.platform === "local" ? `local:${runtime.actor.userId}` : "none";
   const source = runtime.source.platform === "slack" ? `slack:${runtime.source.teamId}:${runtime.source.channelId}` : `local:${runtime.source.conversationId}`;
   const lines = [
-    `- requester: ${escapeXml(requester)}`,
+    `- actor: ${escapeXml(actor)}`,
     `- source: ${escapeXml(source)}`,
     `- has_conversation: ${runtime.conversationId ? "true" : "false"}`,
     `- expires_at: ${request.expiresAtMs === void 0 ? "never" : escapeXml(new Date(request.expiresAtMs).toISOString())}`
@@ -225,14 +236,22 @@ function existingMemoriesContext(request) {
     "</existing-memories>"
   ].join("\n");
 }
-function memoryKindsContext() {
-  return [
-    "<memory-kinds>",
-    "- preference: a durable first-person personal preference, opinion, habit, or workflow owned by the current requester. Stored as requester memory.",
+function allowedExtractionKinds(actorCount) {
+  return actorCount === 1 ? new Set(MEMORY_KINDS) : /* @__PURE__ */ new Set(["procedure", "knowledge"]);
+}
+function memoryKindsContext(allowedKinds) {
+  const lines = ["<memory-kinds>"];
+  if (allowedKinds.has("preference")) {
+    lines.push(
+      "- preference: a durable first-person personal preference, opinion, habit, or workflow owned by the current actor. Stored as actor memory."
+    );
+  }
+  lines.push(
     "- procedure: reusable instructions for how a task, lookup, investigation, process, triage flow, or runbook should be done. Store the method, source-of-truth, prerequisite, or decision path when it took effort to discover. Stored as conversation memory.",
-    "- knowledge: stable shared project, channel, operational, or runbook fact that is not a personal requester preference. Direct answers to user inquiries qualify only when they are durable beyond this run. Stored as conversation memory.",
+    "- knowledge: stable shared project, channel, operational, or runbook fact that is not a personal actor preference. Direct answers to user inquiries qualify only when they are durable beyond this run. Stored as conversation memory.",
     "</memory-kinds>"
-  ].join("\n");
+  );
+  return lines.join("\n");
 }
 function reviewPrompt(request) {
   const sections = [
@@ -250,17 +269,17 @@ function reviewPrompt(request) {
     "<rules>",
     "- Return store only when the candidate is public/shareable, durable, and self-contained.",
     "- First classify the memory kind: preference, procedure, or knowledge.",
-    "- Use kind=preference only for first-person facts authored by the current requester about their own preference, opinion, habit, identity, or workflow.",
-    "- Reject named third-person personal facts such as another person's preference, opinion, habit, identity, relationship, or workflow. Do not assume a named person is the current requester.",
+    "- Use kind=preference only for first-person facts authored by the current actor about their own preference, opinion, habit, identity, or workflow.",
+    "- Reject named third-person personal facts such as another person's preference, opinion, habit, identity, relationship, or workflow. Do not assume a named person is the current actor.",
     "- Use kind=procedure for reusable task/process/runbook instructions.",
     "- Use kind=knowledge for shared project, channel, operational, or runbook facts.",
     "- When current-user-message contains an explicit memory request with a concrete fact or procedure, extract from current-user-message even if the candidate is vague, incomplete, or phrased as an instruction.",
-    "- A candidate may be badly phrased by an outer assistant or extraction pass. When current-user-message contains the requester's own first-person memory fact, treat that as requester-authored source evidence and canonicalize the fact instead of rejecting for third-person wording.",
+    "- A candidate may be badly phrased by an outer assistant or extraction pass. When current-user-message contains the actor's own first-person memory fact, treat that as actor-authored source evidence and canonicalize the fact instead of rejecting for third-person wording.",
     "- When candidate wording personalizes a shared task, process, runbook, project, channel, or operational fact, use current-user-message to recover the shared fact and classify it as procedure or knowledge.",
     "- Explicit procedure requests are valid when the source text contains both task context and action. Canonicalize them as shared procedure facts instead of rejecting them as vague.",
     "- Store content as person-less, source-less canonical knowledge. Ownership and source live in structured metadata, not prose.",
-    "- For requester memories, omit the subject and write the content as a stable fact such as 'Prefers X', 'Uses Y', or 'Thinks Z'.",
-    "- Remove requester names, display names, requester/user labels, first- or second-person wording, thread labels, channel labels, and source labels from stored content.",
+    "- For actor memories, omit the subject and write the content as a stable fact such as 'Prefers X', 'Uses Y', or 'Thinks Z'.",
+    "- Remove actor names, display names, actor/user labels, first- or second-person wording, thread labels, channel labels, and source labels from stored content.",
     "- Reject third-party personal profile facts, even if they mention a name.",
     "- Reject vague content such as 'remember this' unless the candidate or current-user-message contains the concrete fact.",
     "- Preserve the requested expiration when one exists; otherwise set expiresAtMs to null.",
@@ -270,6 +289,15 @@ function reviewPrompt(request) {
   ].filter((section) => section !== void 0);
   return sections.join("\n");
 }
+function transcriptActorLabel(actor) {
+  if (!actor) {
+    return "none";
+  }
+  if (actor.platform === "system") {
+    return `system:${actor.name}`;
+  }
+  return actor.platform === "slack" ? `slack:${actor.teamId}:${actor.userId}` : `local:${actor.userId}`;
+}
 function runTranscriptContext(request) {
   return [
     "<run-transcript>",
@@ -281,8 +309,11 @@ function runTranscriptContext(request) {
           "</tool-result>"
         ].join("\n");
       }
+      const authority = entry.provenance?.authority ?? "context";
+      const isRunActor = entry.isRunActor === true;
+      const actor = transcriptActorLabel(entry.provenance?.actor);
       return [
-        `<message index="${index2}" role="${entry.role}">`,
+        `<message index="${index2}" role="${entry.role}" authority="${authority}" is_run_actor="${isRunActor ? "true" : "false"}" actor="${escapeXml(actor)}">`,
         escapeXml(entry.text),
         "</message>"
       ].join("\n");
@@ -291,6 +322,8 @@ function runTranscriptContext(request) {
   ].join("\n");
 }
 function sessionExtractionPrompt(request) {
+  const allowedKinds = allowedExtractionKinds(request.actors.length);
+  const allowsPreference = allowedKinds.has("preference");
   return [
     "<memory-extraction-input>",
     "Extract durable memories from this completed agent run using the runtime-owned context below.",
@@ -301,12 +334,19 @@ function sessionExtractionPrompt(request) {
     "",
     existingMemoriesContext(request),
     "",
-    memoryKindsContext(),
+    memoryKindsContext(allowedKinds),
     "",
     runTranscriptContext(request),
     "",
     "<rules>",
     "- Return at most five memories.",
+    "- Every returned memory must cite one or more evidenceMessageIndices from <run-transcript>.",
+    "- Cite only indices that directly support the stored fact; do not cite assistant messages as independent evidence.",
+    "- Each transcript message exposes authority (instruction or context), is_run_actor, and an actor id. Use these to classify evidence.",
+    ...allowsPreference ? [
+      "- For a preference, cite only messages with authority=instruction and is_run_actor=true; a preference must be the run actor's own first-person fact."
+    ] : [],
+    "- For a procedure or knowledge memory, cite run-actor instruction messages, public context messages, or successful tool results.",
     "- Use user messages and successful tool results as source evidence for storable facts.",
     "- Use failed tool results only when the failure reveals durable process knowledge, not transient errors.",
     "- Use assistant messages only as context; do not store the assistant's claims unless supported by user messages or tool results.",
@@ -318,9 +358,18 @@ function sessionExtractionPrompt(request) {
     "- A user question asking how, what, where, or whether to do something is not source evidence for the answer. Store the answer only when supported by a user-authored factual statement or a tool result.",
     "- Set kind=procedure for reusable task/process/runbook instructions.",
     "- Set kind=knowledge for shared team, project, channel, runbook, or operational facts.",
-    "- Set kind=preference only for clear durable first-person facts authored by the current requester about their own preference, opinion, habit, identity, or workflow.",
-    "- Reject named third-person personal facts such as another person's preference, opinion, habit, identity, relationship, or workflow. Do not assume a named person is the current requester.",
-    "- User-authored task instructions are procedures, not preferences, unless they explicitly describe the requester's personal preference or habit.",
+    ...allowsPreference ? [
+      "- Set kind=preference only for clear durable first-person facts authored by the current actor about their own preference, opinion, habit, identity, or workflow.",
+      "- A single task request or ask-for-help is never a durable preference, even when phrased as an ongoing action for this run (for example 'help me capture takeaways as we go'). Do not convert a one-off ask into a 'Prefers ...' memory.",
+      "- A durable preference requires explicitly stated, generalizable first-person phrasing such as 'I prefer ...', 'I always ...', or 'I never ...' that describes how the actor wants things done in general, not just for the current task."
+    ] : [
+      "- This completed run has multiple run actors. Return only conversation-scoped procedure or knowledge memories.",
+      "- Do not return personal preferences, opinions, habits, identity facts, or workflow preferences from any actor in this run.",
+      "- Do not convert a personal first-person statement into shared knowledge or procedure. Statements like 'I prefer ...', 'I use ...', 'I always ...', or 'I never ...' are not memory evidence in this run.",
+      "- Shared team, channel, repository, or operational norms are eligible only when the source states them as collective practice or durable operational fact, not as one individual's preference."
+    ],
+    "- Reject named third-person personal facts such as another person's preference, opinion, habit, identity, relationship, or workflow. Do not assume a named person is the current actor.",
+    "- User-authored task instructions are procedures, not preferences, unless they explicitly describe the actor's personal preference or habit.",
     "- Procedural statements such as 'for X, do Y', 'when X, do Y', and 'to accomplish X, do Y' belong in procedures.",
     ...CANONICAL_CONTENT_RULES,
     "- Skip a candidate when existing-memories already cover the same durable fact.",
@@ -417,7 +466,8 @@ function extractedMemoriesFromResponse(response) {
   const toMemory = (memory) => parseExtractedMemory({
     content: memory.canonicalFact,
     expiresAtMs: memory.expiresAtMs,
-    kind: memory.kind
+    kind: memory.kind,
+    evidenceMessageIndices: memory.evidenceMessageIndices
   });
   return response.memories.map(toMemory);
 }
@@ -709,21 +759,21 @@ function sourceConversationKey(ctx) {
   }
   return `slack:${ctx.source.teamId}:${ctx.source.channelId}:${threadKey}`;
 }
-function requesterScopeKey(ctx) {
-  const requester = ctx.requester;
-  if (!requester?.userId) {
+function actorScopeKey(ctx) {
+  const actor = ctx.actor;
+  if (!actor?.userId) {
     return void 0;
   }
-  if (requester.platform === "slack") {
-    return `slack:${requester.teamId}:${requester.userId}`;
+  if (actor.platform === "slack") {
+    return `slack:${actor.teamId}:${actor.userId}`;
   }
-  return `local:${requester.userId}`;
+  return `local:${actor.userId}`;
 }
 function deriveMemoryScope(ctx, scope) {
   if (scope === "personal") {
-    const scopeKey2 = requesterScopeKey(ctx);
+    const scopeKey2 = actorScopeKey(ctx);
     if (!scopeKey2) {
-      throw new Error("Personal memory requires requester context.");
+      throw new Error("Personal memory requires actor context.");
     }
     return { scope, scopeKey: scopeKey2 };
   }
@@ -735,9 +785,9 @@ function deriveMemoryScope(ctx, scope) {
 }
 function deriveMemorySubject(ctx, scope) {
   if (scope.scope === "personal") {
-    const subjectKey2 = requesterScopeKey(ctx);
+    const subjectKey2 = actorScopeKey(ctx);
     if (!subjectKey2) {
-      throw new Error("User-subject memory requires requester context.");
+      throw new Error("User-subject memory requires actor context.");
     }
     return { subjectType: "user", subjectKey: subjectKey2 };
   }
@@ -1780,8 +1830,8 @@ var KNOWN_TOOL_INPUT_ERROR_MESSAGES = /* @__PURE__ */ new Set([
   "Memory id is required.",
   "Memory was not found in the current context.",
   "Memory id prefix is ambiguous.",
-  "Personal memory requires requester context.",
-  "User-subject memory requires requester context."
+  "Personal memory requires actor context.",
+  "User-subject memory requires actor context."
 ]);
 function throwToolInputError(message) {
   throw new PluginToolInputError(message);
@@ -1798,7 +1848,7 @@ function asToolInputError(error) {
 function memoryRuntimeContext(context) {
   return memoryRuntimeContextSchema.parse({
     ...context.conversationId ? { conversationId: context.conversationId } : {},
-    ...context.requester ? { requester: context.requester } : {},
+    ...context.actor ? { actor: context.actor } : {},
     source: context.source
   });
 }
@@ -1988,7 +2038,7 @@ function createInput(context, input, toolCallId) {
 }
 function targetForKind(kind) {
   if (kind === "preference") {
-    return "requester";
+    return "actor";
   }
   return "conversation";
 }
@@ -2125,7 +2175,7 @@ function createMemoryListTool(context) {
 }
 function createMemorySearchTool(context) {
   return definePluginTool({
-    description: "Search active memories visible in the current context. Use when the model needs targeted memory recall. The tool searches only the current requester and active conversation scopes.",
+    description: "Search active memories visible in the current context. Use when the model needs targeted memory recall. The tool searches only the current actor and active conversation scopes.",
     annotations: { readOnlyHint: true, destructiveHint: false },
     inputSchema: searchMemoriesInputSchema2,
     outputSchema: memoryManyOutputSchema,
@@ -2163,22 +2213,61 @@ var extractedMemoryCacheSchema = z5.array(
   z5.object({
     content: z5.string().min(1),
     expiresAtMs: z5.number().finite().nullable(),
-    kind: z5.enum(MEMORY_KINDS)
+    kind: z5.enum(MEMORY_KINDS),
+    evidenceMessageIndices: z5.array(z5.number().int().nonnegative()).min(1).max(10)
   }).strict().transform(parseExtractedMemory)
 );
-function targetForKind2(kind) {
-  if (kind === "preference") {
-    return "requester";
+function isRunActorInstruction(entry) {
+  return entry.type === "message" && entry.role === "user" && entry.provenance?.authority === "instruction" && entry.isRunActor === true;
+}
+function isConversationEvidence(entry) {
+  if (entry.type === "toolResult") {
+    return entry.isError === false && Boolean(entry.text?.trim());
   }
-  return "conversation";
+  if (entry.type === "message" && entry.role === "user" && entry.provenance?.authority === "instruction" && entry.isRunActor === false) {
+    return Boolean(entry.provenance.actor);
+  }
+  return entry.type === "message" && entry.role === "user" && entry.provenance?.authority === "context";
 }
-function memoryIdempotencySuffix(memory) {
-  return createHash2("sha256").update(targetForKind2(memory.kind)).update("\0").update(memory.kind).update("\0").update(memory.content).update("\0").update(memory.expiresAtMs === null ? "never" : String(memory.expiresAtMs)).digest("hex").slice(0, 32);
+function citedEntries(indices, transcript) {
+  const seen = /* @__PURE__ */ new Set();
+  const entries = [];
+  for (const index2 of indices) {
+    if (seen.has(index2)) {
+      continue;
+    }
+    seen.add(index2);
+    const entry = transcript[index2];
+    if (!entry) {
+      return { valid: false, entries: [] };
+    }
+    entries.push(entry);
+  }
+  return { valid: entries.length > 0, entries };
 }
-function passiveInput(sessionId, memory, sourceKey2) {
+function routeExtractedMemory(memory, transcript, run) {
+  const cited = citedEntries(memory.evidenceMessageIndices, transcript);
+  if (!cited.valid) {
+    return "drop";
+  }
+  if (memory.kind === "preference") {
+    const exactlyOneRunActor = Boolean(run.actor) && run.actors.length === 1;
+    if (!exactlyOneRunActor) {
+      return "drop";
+    }
+    return cited.entries.every(isRunActorInstruction) ? "personal" : "drop";
+  }
+  return cited.entries.every(
+    (entry) => isRunActorInstruction(entry) || isConversationEvidence(entry)
+  ) ? "conversation" : "drop";
+}
+function memoryIdempotencySuffix(memory, target) {
+  return createHash2("sha256").update(target).update("\0").update(memory.kind).update("\0").update(memory.content).update("\0").update(memory.expiresAtMs === null ? "never" : String(memory.expiresAtMs)).digest("hex").slice(0, 32);
+}
+function passiveInput(sessionId, memory, sourceKey2, target) {
   return {
     content: memory.content,
-    idempotencyKey: `session:${sourceKey2}:${sessionId}:${memoryIdempotencySuffix(memory)}`,
+    idempotencyKey: `session:${sourceKey2}:${sessionId}:${memoryIdempotencySuffix(memory, target)}`,
     kind: memory.kind,
     ...memory.expiresAtMs !== null ? { expiresAtMs: memory.expiresAtMs } : {}
   };
@@ -2187,7 +2276,11 @@ async function getTaskMemories(context, extract) {
   const cacheKey = `memory-extraction:${context.id}`;
   const cached = await context.state.get(cacheKey);
   if (cached !== void 0) {
-    return extractedMemoryCacheSchema.parse(cached);
+    const parsed = extractedMemoryCacheSchema.safeParse(cached);
+    if (parsed.success) {
+      return parsed.data;
+    }
+    await context.state.delete(cacheKey);
   }
   const memories = await extract();
   if (memories.length > 0) {
@@ -2216,7 +2309,7 @@ async function processMemorySession(context) {
   }
   const runtimeContext = memoryRuntimeContextSchema.parse({
     conversationId: run.conversationId,
-    ...run.requester ? { requester: run.requester } : {},
+    ...run.actor ? { actor: run.actor } : {},
     source: run.source
   });
   const agent = createMemoryAgent(context.model);
@@ -2234,6 +2327,7 @@ async function processMemorySession(context) {
       existingMemories: existingMemories.map((memory) => ({
         content: memory.content
       })),
+      actors: run.actors,
       transcript,
       runtimeContext
     });
@@ -2242,12 +2336,13 @@ async function processMemorySession(context) {
     return;
   }
   for (const memory of memories) {
-    const input = passiveInput(run.runId, memory, sourceKey2);
-    if (targetForKind2(memory.kind) === "conversation") {
-      await store.createConversationMemory(input);
+    const target = routeExtractedMemory(memory, transcript, run);
+    if (target === "drop") {
       continue;
     }
-    if (!run.requester) {
+    const input = passiveInput(run.runId, memory, sourceKey2, target);
+    if (target === "conversation") {
+      await store.createConversationMemory(input);
       continue;
     }
     await store.createMemory(input);
@@ -2298,17 +2393,13 @@ async function createMemoryPromptMessages(context) {
   }
   const runtimeContext = memoryRuntimeContextSchema.parse({
     ...context.conversationId ? { conversationId: context.conversationId } : {},
-    ...context.requester ? { requester: context.requester } : {},
+    ...context.actor ? { actor: context.actor } : {},
     source: context.source
   });
-  const memories = await createMemoryStore(
-    context.db,
-    runtimeContext,
-    {
-      ...context.embedder ? { embedder: context.embedder } : {},
-      ...context.maxVectorDistance !== void 0 ? { maxVectorDistance: context.maxVectorDistance } : {}
-    }
-  ).searchMemories({
+  const memories = await createMemoryStore(context.db, runtimeContext, {
+    ...context.embedder ? { embedder: context.embedder } : {},
+    ...context.maxVectorDistance !== void 0 ? { maxVectorDistance: context.maxVectorDistance } : {}
+  }).searchMemories({
     query: context.text,
     limit: DEFAULT_RECALL_LIMIT
   });
@@ -2345,7 +2436,7 @@ function memoryToolContext(ctx) {
   return {
     agent: ctx.agent,
     ...ctx.conversationId ? { conversationId: ctx.conversationId } : {},
-    ...ctx.requester ? { requester: ctx.requester } : {},
+    ...ctx.actor ? { actor: ctx.actor } : {},
     db: ctx.db,
     ...ctx.embedder ? { embedder: ctx.embedder } : {},
     source: ctx.source,
@@ -2405,7 +2496,7 @@ function createMemoryPlugin(options = {}) {
       async userPrompt(ctx) {
         return await createMemoryPromptMessages({
           ...ctx.conversationId ? { conversationId: ctx.conversationId } : {},
-          ...ctx.requester ? { requester: ctx.requester } : {},
+          ...ctx.actor ? { actor: ctx.actor } : {},
           db: ctx.db,
           embedder: ctx.embedder,
           maxVectorDistance: recallMaxVectorDistance(options),