@sentry/junior-memory 0.76.0

package/dist/index.js

@@ -0,0 +1,1773 @@
+// src/plugin.ts
+import { defineJuniorPlugin } from "@sentry/junior-plugin-api";
+
+// src/agent.ts
+import { z as z2 } from "zod";
+
+// src/types.ts
+import {
+  localRequesterSchema,
+  localSourceSchema,
+  slackRequesterSchema,
+  slackSourceSchema
+} from "@sentry/junior-plugin-api";
+import { z } from "zod";
+var MEMORY_TYPES = [
+  "preference",
+  "identity",
+  "relationship",
+  "knowledge",
+  "context",
+  "event",
+  "task",
+  "observation"
+];
+var MEMORY_SCOPES = ["personal", "conversation"];
+var MEMORY_SUBJECT_TYPES = [
+  "user",
+  "conversation",
+  "general"
+];
+var MEMORY_SOURCE_PLATFORMS = [
+  "slack",
+  "local"
+];
+var MEMORY_EMBEDDING_METRICS = ["cosine"];
+var MEMORY_EMBEDDING_DIMENSIONS = 1536;
+var nonEmptyStringSchema = z.string().min(1);
+var slackMemoryRuntimeContextSchema = z.object({
+  conversationId: nonEmptyStringSchema.optional(),
+  requester: slackRequesterSchema.optional(),
+  source: slackSourceSchema
+}).strict();
+var localMemoryRuntimeContextSchema = z.object({
+  conversationId: nonEmptyStringSchema.optional(),
+  requester: localRequesterSchema.optional(),
+  source: localSourceSchema
+}).strict();
+var memoryRuntimeContextSchema = z.union([
+  slackMemoryRuntimeContextSchema,
+  localMemoryRuntimeContextSchema
+]);
+
+// src/agent.ts
+var memoryTargetSchema = z2.enum(["requester", "conversation"]);
+var memoryKindSchema = z2.enum(["preference", "procedure", "fact"]);
+var memoryRejectReasonSchema = z2.enum([
+  "not_public_shareable",
+  "secret_or_credential",
+  "sensitive_personal",
+  "third_party_personal",
+  "vague_or_not_self_contained",
+  "not_durable",
+  "assistant_or_system_detail",
+  "unsupported_scope"
+]);
+var createMemoryRequestSchema = z2.object({
+  content: z2.string().min(1),
+  expiresAtMs: z2.number().finite().optional(),
+  runtimeContext: memoryRuntimeContextSchema,
+  sourceContext: z2.object({
+    currentUserText: z2.string().min(1).optional()
+  }).strict().optional()
+}).strict();
+var extractSessionRequestSchema = z2.object({
+  existingMemories: z2.array(
+    z2.object({
+      content: z2.string().min(1)
+    }).strict()
+  ).max(10).default([]),
+  runtimeContext: memoryRuntimeContextSchema,
+  transcript: z2.array(
+    z2.discriminatedUnion("type", [
+      z2.object({
+        type: z2.literal("message"),
+        role: z2.enum(["user", "assistant"]),
+        text: z2.string().min(1)
+      }).strict(),
+      z2.object({
+        type: z2.literal("toolResult"),
+        toolName: z2.string().min(1),
+        isError: z2.boolean(),
+        text: z2.string().min(1)
+      }).strict()
+    ])
+  ).min(1)
+}).strict();
+var expiresAtMsSchema = z2.number().finite().nullable().describe(
+  "Expiration timestamp when the fact should expire, otherwise null."
+);
+var memoryReviewDecisionSchema = z2.discriminatedUnion("decision", [
+  z2.object({
+    decision: z2.literal("store"),
+    target: memoryTargetSchema,
+    content: z2.string().min(1),
+    expiresAtMs: z2.number().finite().optional()
+  }).strict(),
+  z2.object({
+    decision: z2.literal("reject"),
+    reason: memoryRejectReasonSchema
+  }).strict()
+]);
+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 fact for shared project, channel, operational, or runbook knowledge."
+    ),
+    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."
+    ),
+    expiresAtMs: expiresAtMsSchema
+  }).strict(),
+  z2.object({
+    decision: z2.literal("reject"),
+    reason: memoryRejectReasonSchema
+  }).strict()
+]);
+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 fact for shared project, channel, operational, or runbook knowledge."
+  ),
+  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."
+  ),
+  expiresAtMs: expiresAtMsSchema
+}).strict();
+var extractMemoriesResponseSchema = z2.object({
+  memories: z2.array(extractedMemorySchema).max(5).describe(
+    "Accepted public/shareable durable memories from the completed run. Return one object per distinct source assertion and classify it with kind."
+  )
+}).strict();
+var MEMORY_REVIEW_SYSTEM = [
+  "You are Junior's memory review agent.",
+  "Review one memory candidate and return one structured review decision.",
+  "Store only public/shareable, self-contained facts that are useful beyond this turn.",
+  "Reject secrets, credentials, private or sensitive personal details, gossip, speculative claims about other people, assistant/system implementation details, vague references, and low-durability chatter.",
+  "Use the runtime context only for authority and scope; do not accept model-provided actor ids, scope ids, aliases, or arbitrary subjects."
+].join("\n");
+var MEMORY_EXTRACTION_SYSTEM = [
+  "You are Junior's passive memory extraction agent. Return only structured memories worth storing.",
+  "Use the completed run transcript as source evidence, including user-authored messages and tool results.",
+  "Assistant text is context for interpreting the run, not independent evidence for new facts.",
+  "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");
+var CANONICAL_CONTENT_RULES = [
+  "- Stored memory text must be a rewritten fact, not copied user wording or a sentence about who said it.",
+  "- 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'.",
+  "- 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."
+];
+function targetForKind(kind) {
+  if (kind === "preference") {
+    return "requester";
+  }
+  return "conversation";
+}
+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 source = runtime.source.platform === "slack" ? `slack:${runtime.source.teamId}:${runtime.source.channelId}` : `local:${runtime.source.conversationId}`;
+  const lines = [
+    `- requester: ${escapeXml(requester)}`,
+    `- source: ${escapeXml(source)}`,
+    `- has_conversation: ${runtime.conversationId ? "true" : "false"}`,
+    `- expires_at: ${request.expiresAtMs === void 0 ? "never" : escapeXml(new Date(request.expiresAtMs).toISOString())}`
+  ];
+  return ["<runtime>", ...lines, "</runtime>"].join("\n");
+}
+function sourceContext(request) {
+  const currentUserText = request.sourceContext?.currentUserText?.trim();
+  if (!currentUserText) {
+    return void 0;
+  }
+  return [
+    "<source-context>",
+    "The current user-authored text is source evidence for explicit memory requests. Use it to recover the concrete fact when the candidate is incomplete, vague, or over-personalized. Store only rewritten, self-contained memory content.",
+    "<current-user-message>",
+    escapeXml(currentUserText),
+    "</current-user-message>",
+    "</source-context>"
+  ].join("\n");
+}
+function existingMemoriesContext(request) {
+  if (request.existingMemories.length === 0) {
+    return "<existing-memories>[]</existing-memories>";
+  }
+  return [
+    "<existing-memories>",
+    "Use these only to skip memories that are already covered or semantically redundant. They are not source evidence for new memories.",
+    escapeXml(JSON.stringify(request.existingMemories)),
+    "</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.",
+    "- 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.",
+    "- fact: stable shared project, channel, operational, or runbook knowledge 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.",
+    "</memory-kinds>"
+  ].join("\n");
+}
+function reviewPrompt(request) {
+  const sections = [
+    "<memory-review-input>",
+    "Review the candidate memory using the runtime-owned context below.",
+    "",
+    runtimeDescription(request),
+    "",
+    sourceContext(request),
+    "",
+    "<candidate>",
+    escapeXml(request.content),
+    "</candidate>",
+    "",
+    "<rules>",
+    "- Return store only when the candidate is public/shareable, durable, and self-contained.",
+    "- First classify the memory kind: preference, procedure, or fact.",
+    "- 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=procedure for reusable task/process/runbook instructions.",
+    "- Use kind=fact for shared project, channel, operational, or runbook knowledge.",
+    "- 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.",
+    "- 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 fact.",
+    "- 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.",
+    "- 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.",
+    "- If unsure, reject.",
+    "</rules>",
+    "</memory-review-input>"
+  ].filter((section) => section !== void 0);
+  return sections.join("\n");
+}
+function runTranscriptContext(request) {
+  return [
+    "<run-transcript>",
+    ...request.transcript.map((entry, index2) => {
+      if (entry.type === "toolResult") {
+        return [
+          `<tool-result index="${index2}" tool="${escapeXml(entry.toolName)}" is_error="${entry.isError ? "true" : "false"}">`,
+          escapeXml(entry.text),
+          "</tool-result>"
+        ].join("\n");
+      }
+      return [
+        `<message index="${index2}" role="${entry.role}">`,
+        escapeXml(entry.text),
+        "</message>"
+      ].join("\n");
+    }),
+    "</run-transcript>"
+  ].join("\n");
+}
+function sessionExtractionPrompt(request) {
+  return [
+    "<memory-extraction-input>",
+    "Extract durable memories from this completed agent run using the runtime-owned context below.",
+    "",
+    runtimeDescription({
+      runtimeContext: request.runtimeContext
+    }),
+    "",
+    existingMemoriesContext(request),
+    "",
+    memoryKindsContext(),
+    "",
+    runTranscriptContext(request),
+    "",
+    "<rules>",
+    "- Return at most five memories.",
+    "- 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.",
+    "- Return one memory per distinct fact.",
+    "- Prefer storing how to achieve a result: stable source-of-truth, query location, workflow, prerequisite, caveat, or reusable decision path that took effort to discover.",
+    "- Store direct answers to user inquiries only when they are stable operational/project knowledge, not values that naturally change over time.",
+    "- Do not store point-in-time analytics, search, issue, metric, incident, availability, or status answers just because a tool produced them.",
+    "- Do not store the fact that the user asked for advice, search, recall, planning, listing, inspection, or removal. Store only stable knowledge discovered in response, such as a reusable method or source-of-truth.",
+    "- 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=fact for shared team, project, channel, runbook, or operational knowledge.",
+    "- 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.",
+    "- 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.",
+    "- Reject third-party personal profile facts, even if they mention a name.",
+    "- If unsure, return no memory for that candidate.",
+    "</rules>",
+    "</memory-extraction-input>"
+  ].join("\n");
+}
+function createMemoryAgent(model) {
+  return {
+    async extractSessionMemories(rawRequest) {
+      const request = extractSessionRequestSchema.parse(rawRequest);
+      const result = await model.completeObject({
+        schema: extractMemoriesResponseSchema,
+        system: MEMORY_EXTRACTION_SYSTEM,
+        prompt: sessionExtractionPrompt(request),
+        maxTokens: 1e3
+      });
+      return extractedMemoriesFromResponse(
+        extractMemoriesResponseSchema.parse(result.object)
+      );
+    },
+    async reviewCreateRequest(rawRequest) {
+      const request = parseCreateMemoryRequest(rawRequest);
+      const result = await model.completeObject({
+        schema: memoryReviewResponseSchema,
+        system: MEMORY_REVIEW_SYSTEM,
+        prompt: reviewPrompt(request),
+        maxTokens: 700
+      });
+      const response = memoryReviewResponseSchema.parse(result.object);
+      return memoryReviewFromResponse(response);
+    }
+  };
+}
+function memoryReviewFromResponse(response) {
+  if (response.decision === "store") {
+    return parseMemoryReview({
+      decision: "store",
+      target: targetForKind(response.kind),
+      content: response.canonicalFact,
+      ...response.expiresAtMs !== null ? { expiresAtMs: response.expiresAtMs } : {}
+    });
+  }
+  return parseMemoryReview({
+    decision: "reject",
+    reason: response.reason
+  });
+}
+function extractedMemoriesFromResponse(response) {
+  const toMemory = (memory) => ({
+    content: memory.canonicalFact,
+    expiresAtMs: memory.expiresAtMs,
+    target: targetForKind(memory.kind)
+  });
+  return response.memories.map(toMemory);
+}
+function parseMemoryReview(result) {
+  return memoryReviewDecisionSchema.parse(result);
+}
+function parseCreateMemoryRequest(request) {
+  return createMemoryRequestSchema.parse(request);
+}
+
+// src/cli/search.ts
+import { InvalidArgumentError, Option } from "commander";
+import { and, desc, eq, gt, ilike, isNull, or } from "drizzle-orm";
+
+// src/db/schema.ts
+import { sql } from "drizzle-orm";
+import {
+  bigint,
+  check,
+  index,
+  integer,
+  pgTable,
+  text,
+  uniqueIndex,
+  vector
+} from "drizzle-orm/pg-core";
+var juniorMemoryMemories = pgTable(
+  "junior_memory_memories",
+  {
+    id: text("id").primaryKey(),
+    scope: text("scope", { enum: MEMORY_SCOPES }).notNull(),
+    scopeKey: text("scope_key").notNull(),
+    type: text("type", { enum: MEMORY_TYPES }).notNull(),
+    subjectType: text("subject_type", { enum: MEMORY_SUBJECT_TYPES }).notNull(),
+    subjectKey: text("subject_key"),
+    content: text("content").notNull(),
+    sourcePlatform: text("source_platform", {
+      enum: MEMORY_SOURCE_PLATFORMS
+    }).notNull(),
+    sourceKey: text("source_key").notNull(),
+    idempotencyKey: text("idempotency_key"),
+    observedAtMs: bigint("observed_at_ms", { mode: "number" }).notNull(),
+    createdAtMs: bigint("created_at_ms", { mode: "number" }).notNull(),
+    expiresAtMs: bigint("expires_at_ms", { mode: "number" }),
+    supersededAtMs: bigint("superseded_at_ms", { mode: "number" }),
+    supersededById: text("superseded_by_id"),
+    archivedAtMs: bigint("archived_at_ms", { mode: "number" }),
+    archiveReason: text("archive_reason")
+  },
+  (table) => [
+    index("junior_memory_memories_visible_idx").on(table.scope, table.scopeKey, table.createdAtMs.desc(), table.id).where(
+      sql`${table.archivedAtMs} IS NULL AND ${table.supersededAtMs} IS NULL AND ${table.supersededById} IS NULL`
+    ),
+    index("junior_memory_memories_expiration_idx").on(table.expiresAtMs).where(
+      sql`${table.archivedAtMs} IS NULL AND ${table.expiresAtMs} IS NOT NULL`
+    ),
+    uniqueIndex("junior_memory_memories_idempotency_idx").on(table.scope, table.scopeKey, table.idempotencyKey).where(
+      sql`${table.idempotencyKey} IS NOT NULL AND ${table.archivedAtMs} IS NULL AND ${table.supersededAtMs} IS NULL AND ${table.supersededById} IS NULL`
+    ),
+    check(
+      "junior_memory_memories_scope_check",
+      sql`${table.scope} IN ('personal', 'conversation')`
+    ),
+    check(
+      "junior_memory_memories_type_check",
+      sql`${table.type} IN (
+        'preference',
+        'identity',
+        'relationship',
+        'knowledge',
+        'context',
+        'event',
+        'task',
+        'observation'
+      )`
+    ),
+    check(
+      "junior_memory_memories_subject_type_check",
+      sql`${table.subjectType} IN ('user', 'conversation', 'general')`
+    ),
+    check(
+      "junior_memory_memories_subject_key_check",
+      sql`(${table.subjectType} = 'general' AND ${table.subjectKey} IS NULL) OR (${table.subjectType} IN ('user', 'conversation') AND ${table.subjectKey} IS NOT NULL AND length(${table.subjectKey}) > 0)`
+    ),
+    check(
+      "junior_memory_memories_source_platform_check",
+      sql`${table.sourcePlatform} IN ('slack', 'local')`
+    )
+  ]
+);
+var juniorMemoryEmbeddings = pgTable(
+  "junior_memory_embeddings",
+  {
+    memoryId: text("memory_id").primaryKey().references(() => juniorMemoryMemories.id, { onDelete: "cascade" }),
+    provider: text("provider").notNull(),
+    model: text("model").notNull(),
+    dimensions: integer("dimensions").notNull(),
+    metric: text("metric", { enum: MEMORY_EMBEDDING_METRICS }).notNull(),
+    contentHash: text("content_hash").notNull(),
+    embedding: vector("embedding", {
+      dimensions: MEMORY_EMBEDDING_DIMENSIONS
+    }).notNull(),
+    createdAtMs: bigint("created_at_ms", { mode: "number" }).notNull()
+  },
+  (table) => [
+    index("junior_memory_embeddings_model_idx").on(
+      table.provider,
+      table.model,
+      table.dimensions,
+      table.metric
+    ),
+    check(
+      "junior_memory_embeddings_metric_check",
+      sql`${table.metric} IN ('cosine')`
+    ),
+    check(
+      "junior_memory_embeddings_dimensions_check",
+      sql`${table.dimensions} = ${sql.raw(String(MEMORY_EMBEDDING_DIMENSIONS))}`
+    )
+  ]
+);
+
+// src/cli/format.ts
+function formatDate(ms) {
+  return ms === null ? "-" : new Date(ms).toISOString();
+}
+function formatMemory(row, args) {
+  const lines = [
+    `id=${row.id}`,
+    `scope=${row.scope}`,
+    `scope_key=${row.scopeKey}`,
+    `subject_type=${row.subjectType}`,
+    ...row.subjectKey ? [`subject_key=${row.subjectKey}`] : [],
+    `type=${row.type}`,
+    `created_at=${formatDate(row.createdAtMs)}`,
+    `observed_at=${formatDate(row.observedAtMs)}`,
+    `expires_at=${formatDate(row.expiresAtMs)}`,
+    `archived_at=${formatDate(row.archivedAtMs)}`
+  ];
+  if (args.showContent) {
+    lines.push(`content=${row.content}`);
+  }
+  return lines.join("\n");
+}
+
+// src/cli/search.ts
+function parseLimit(value) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) {
+    throw new InvalidArgumentError("--limit must be a number");
+  }
+  return Math.min(100, Math.max(1, Math.floor(parsed)));
+}
+async function runSearch(ctx, queryParts, options) {
+  const query = (queryParts ?? []).join(" ").trim();
+  const nowMs = Date.now();
+  const terms = [
+    ...new Set(
+      query.toLowerCase().split(/[^a-z0-9_'-]+/).map((term) => term.trim()).filter((term) => term.length >= 2)
+    )
+  ];
+  const db = ctx.db;
+  const activeExpirationPredicate = or(
+    isNull(juniorMemoryMemories.expiresAtMs),
+    gt(juniorMemoryMemories.expiresAtMs, nowMs)
+  );
+  const predicates = [
+    eq(juniorMemoryMemories.scope, options.scope),
+    eq(juniorMemoryMemories.scopeKey, options.scopeKey),
+    isNull(juniorMemoryMemories.archivedAtMs),
+    isNull(juniorMemoryMemories.supersededAtMs),
+    isNull(juniorMemoryMemories.supersededById)
+  ];
+  if (activeExpirationPredicate) {
+    predicates.push(activeExpirationPredicate);
+  }
+  if (terms.length > 0) {
+    const termPredicate = or(
+      ...terms.map((term) => ilike(juniorMemoryMemories.content, `%${term}%`))
+    );
+    if (termPredicate) {
+      predicates.push(termPredicate);
+    }
+  }
+  const rows = await db.select().from(juniorMemoryMemories).where(and(...predicates)).orderBy(desc(juniorMemoryMemories.createdAtMs)).limit(options.limit);
+  if (rows.length === 0) {
+    await ctx.io.writeOutput("No memories matched.\n");
+    return 0;
+  }
+  await ctx.io.writeOutput(
+    `${rows.map(
+      (row) => formatMemory(row, { showContent: Boolean(options.showContent) })
+    ).join("\n\n")}
+`
+  );
+  return 0;
+}
+function configureMemorySearchCommand(parent, junior) {
+  parent.command("search").description("Search visible memories").argument("[query...]", "Search query").addOption(
+    new Option("--scope <scope>", "Memory scope").choices([...MEMORY_SCOPES]).makeOptionMandatory()
+  ).requiredOption("--scope-key <key>", "Scope key").addOption(
+    new Option("--limit <n>", "Maximum rows").argParser(parseLimit).default(20)
+  ).option("--show-content", "Print raw memory content").action(
+    junior.action(async (ctx, queryParts, options) => {
+      return await runSearch(
+        ctx,
+        queryParts,
+        options
+      );
+    })
+  );
+}
+
+// src/cli/show.ts
+import { eq as eq2 } from "drizzle-orm";
+async function runShow(ctx, id) {
+  const db = ctx.db;
+  const rows = await db.select().from(juniorMemoryMemories).where(eq2(juniorMemoryMemories.id, id)).limit(1);
+  if (!rows[0]) {
+    await ctx.io.writeError(`Memory not found: ${id}
+`);
+    return 1;
+  }
+  await ctx.io.writeOutput(`${formatMemory(rows[0], { showContent: true })}
+`);
+  return 0;
+}
+function configureMemoryShowCommand(parent, junior) {
+  parent.command("show").description("Show one memory").argument("<id>", "Memory id").action(
+    junior.action(async (ctx, id) => {
+      return await runShow(ctx, id);
+    })
+  );
+}
+
+// src/cli/index.ts
+function createMemoryCliCommand() {
+  return {
+    name: "memory",
+    summary: "Inspect Junior memory state",
+    configure(command, junior) {
+      configureMemorySearchCommand(command, junior);
+      configureMemoryShowCommand(command, junior);
+    }
+  };
+}
+
+// src/tools.ts
+import { Type } from "@sinclair/typebox";
+import { Value } from "@sinclair/typebox/value";
+import {
+  getSourceKey,
+  PluginToolInputError
+} from "@sentry/junior-plugin-api";
+
+// src/store.ts
+import { createHash, randomUUID } from "crypto";
+import {
+  and as and2,
+  asc,
+  desc as desc2,
+  eq as eq3,
+  gt as gt2,
+  ilike as ilike2,
+  isNull as isNull2,
+  like,
+  or as or2,
+  sql as sql2
+} from "drizzle-orm";
+import { cosineDistance } from "drizzle-orm/sql/functions";
+import { z as z3 } from "zod";
+
+// src/scope.ts
+function sourceConversationKey(ctx) {
+  if (ctx.source.platform === "local") {
+    return ctx.source.conversationId;
+  }
+  const threadKey = ctx.source.threadTs ?? ctx.source.messageTs;
+  if (!threadKey) {
+    return void 0;
+  }
+  return `slack:${ctx.source.teamId}:${ctx.source.channelId}:${threadKey}`;
+}
+function requesterScopeKey(ctx) {
+  const requester = ctx.requester;
+  if (!requester?.userId) {
+    return void 0;
+  }
+  if (requester.platform === "slack") {
+    return `slack:${requester.teamId}:${requester.userId}`;
+  }
+  return `local:${requester.userId}`;
+}
+function deriveMemoryScope(ctx, scope) {
+  if (scope === "personal") {
+    const scopeKey2 = requesterScopeKey(ctx);
+    if (!scopeKey2) {
+      throw new Error("Personal memory requires requester context.");
+    }
+    return { scope, scopeKey: scopeKey2 };
+  }
+  const scopeKey = sourceConversationKey(ctx);
+  if (!scopeKey) {
+    throw new Error("Conversation memory requires conversation context.");
+  }
+  return { scope, scopeKey };
+}
+function deriveMemorySubject(ctx, scope) {
+  if (scope.scope === "personal") {
+    const subjectKey2 = requesterScopeKey(ctx);
+    if (!subjectKey2) {
+      throw new Error("User-subject memory requires requester context.");
+    }
+    return { subjectType: "user", subjectKey: subjectKey2 };
+  }
+  const subjectKey = sourceConversationKey(ctx);
+  if (!subjectKey) {
+    throw new Error(
+      "Conversation-subject memory requires conversation context."
+    );
+  }
+  return { subjectType: "conversation", subjectKey };
+}
+function deriveVisibleMemoryScopes(ctx) {
+  const scopes = [];
+  try {
+    scopes.push(deriveMemoryScope(ctx, "personal"));
+  } catch {
+  }
+  try {
+    scopes.push(deriveMemoryScope(ctx, "conversation"));
+  } catch {
+  }
+  return scopes;
+}
+
+// src/store.ts
+var DEFAULT_LIST_LIMIT = 50;
+var DEFAULT_SEARCH_LIMIT = 10;
+var VECTOR_SEARCH_OVERFETCH = 4;
+var MAX_MEMORY_CONTENT_CHARS = 4e3;
+var EMBEDDING_METRIC = "cosine";
+var nonEmptyStringSchema2 = z3.string().min(1);
+var memoryContentSchema = z3.string().refine((content) => content.trim().length > 0, {
+  message: "Memory content is required."
+});
+var numberSchema = z3.number().finite();
+var createMemoryInputSchema = z3.object({
+  content: memoryContentSchema,
+  expiresAtMs: numberSchema.optional(),
+  idempotencyKey: nonEmptyStringSchema2
+}).strict();
+var listMemoriesInputSchema = z3.object({
+  limit: numberSchema.optional()
+}).strict();
+var searchMemoriesInputSchema = z3.object({
+  limit: numberSchema.optional(),
+  query: nonEmptyStringSchema2
+}).strict();
+var archiveMemoryInputSchema = z3.object({
+  id: nonEmptyStringSchema2,
+  reason: nonEmptyStringSchema2.optional()
+}).strict();
+var clockSchema = z3.function({ input: [], output: numberSchema }).optional();
+var memoryStoreOptionsSchema = z3.object({
+  now: clockSchema
+}).strict();
+var optionalNumberSchema = z3.preprocess(
+  (value) => value === null ? void 0 : value,
+  z3.coerce.number().optional()
+);
+var optionalStringSchema = z3.preprocess(
+  (value) => value === null ? void 0 : value,
+  z3.string().optional()
+);
+var optionalNonEmptyStringSchema = z3.preprocess(
+  (value) => value === null ? void 0 : value,
+  z3.string().min(1).optional()
+);
+var memoryRowSchema = z3.object({
+  archivedAtMs: optionalNumberSchema,
+  archiveReason: optionalStringSchema,
+  content: memoryContentSchema,
+  createdAtMs: z3.coerce.number(),
+  expiresAtMs: optionalNumberSchema,
+  id: z3.string().min(1),
+  idempotencyKey: optionalStringSchema,
+  observedAtMs: z3.coerce.number(),
+  scope: z3.enum(MEMORY_SCOPES),
+  scopeKey: z3.string().min(1),
+  sourceKey: z3.string().min(1),
+  sourcePlatform: z3.enum(MEMORY_SOURCE_PLATFORMS),
+  subjectKey: optionalNonEmptyStringSchema,
+  subjectType: z3.enum(MEMORY_SUBJECT_TYPES),
+  supersededAtMs: optionalNumberSchema,
+  supersededById: optionalStringSchema,
+  type: z3.enum(MEMORY_TYPES)
+}).strict().superRefine((row, ctx) => {
+  if (row.subjectType === "general") {
+    if (row.subjectKey !== void 0) {
+      ctx.addIssue({
+        code: "custom",
+        message: "General-subject memory rows must not have a subject key.",
+        path: ["subjectKey"]
+      });
+    }
+    return;
+  }
+  if (row.subjectKey === void 0) {
+    ctx.addIssue({
+      code: "custom",
+      message: "User and conversation memory rows require a subject key.",
+      path: ["subjectKey"]
+    });
+  }
+});
+var memoryRecordSchema = z3.object({
+  archivedAtMs: numberSchema.optional(),
+  archiveReason: nonEmptyStringSchema2.optional(),
+  content: memoryContentSchema,
+  createdAtMs: numberSchema,
+  expiresAtMs: numberSchema.optional(),
+  id: nonEmptyStringSchema2,
+  observedAtMs: numberSchema,
+  scope: z3.enum(MEMORY_SCOPES),
+  subjectType: z3.enum(MEMORY_SUBJECT_TYPES),
+  supersededAtMs: numberSchema.optional(),
+  supersededById: nonEmptyStringSchema2.optional(),
+  type: z3.enum(MEMORY_TYPES)
+}).strict();
+var embeddingVectorSchema = z3.array(numberSchema).length(MEMORY_EMBEDDING_DIMENSIONS);
+var embeddingResultSchema = z3.object({
+  dimensions: z3.literal(MEMORY_EMBEDDING_DIMENSIONS),
+  model: nonEmptyStringSchema2,
+  provider: nonEmptyStringSchema2,
+  vectors: z3.array(embeddingVectorSchema)
+}).strict();
+function normalizeContent(content) {
+  return content.replace(/\s+/g, " ").trim();
+}
+function hashEmbeddedContent(content) {
+  return createHash("sha256").update(content, "utf8").digest("hex");
+}
+function boundedLimit(value, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return fallback;
+  }
+  return Math.min(200, Math.max(1, Math.floor(value)));
+}
+function sourceKey(ctx) {
+  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."
+    );
+  }
+  return `slack:${ctx.source.teamId}:${ctx.source.channelId}:${threadKey}`;
+}
+function parseMemoryRow(row) {
+  const parsed = memoryRowSchema.parse(row);
+  return memoryRecordSchema.parse({
+    id: parsed.id,
+    scope: parsed.scope,
+    type: parsed.type,
+    subjectType: parsed.subjectType,
+    content: parsed.content,
+    observedAtMs: parsed.observedAtMs,
+    createdAtMs: parsed.createdAtMs,
+    ...parsed.expiresAtMs !== void 0 ? { expiresAtMs: parsed.expiresAtMs } : {},
+    ...parsed.supersededAtMs !== void 0 ? { supersededAtMs: parsed.supersededAtMs } : {},
+    ...parsed.supersededById ? { supersededById: parsed.supersededById } : {},
+    ...parsed.archivedAtMs !== void 0 ? { archivedAtMs: parsed.archivedAtMs } : {},
+    ...parsed.archiveReason ? { archiveReason: parsed.archiveReason } : {}
+  });
+}
+function visibleScopePredicate(scopes) {
+  if (scopes.length === 0) {
+    return void 0;
+  }
+  return or2(
+    ...scopes.map(
+      (scope) => and2(
+        eq3(juniorMemoryMemories.scope, scope.scope),
+        eq3(juniorMemoryMemories.scopeKey, scope.scopeKey)
+      )
+    )
+  );
+}
+function activeVisiblePredicate(args) {
+  const scopePredicate = visibleScopePredicate(args.scopes);
+  if (!scopePredicate) {
+    return void 0;
+  }
+  return and2(
+    scopePredicate,
+    isNull2(juniorMemoryMemories.archivedAtMs),
+    isNull2(juniorMemoryMemories.supersededAtMs),
+    isNull2(juniorMemoryMemories.supersededById),
+    or2(
+      isNull2(juniorMemoryMemories.expiresAtMs),
+      gt2(juniorMemoryMemories.expiresAtMs, args.nowMs)
+    )
+  );
+}
+async function findByIdempotencyKey(args) {
+  const rows = await args.db.select().from(juniorMemoryMemories).where(
+    and2(
+      eq3(juniorMemoryMemories.scope, args.scope.scope),
+      eq3(juniorMemoryMemories.scopeKey, args.scope.scopeKey),
+      eq3(juniorMemoryMemories.idempotencyKey, args.idempotencyKey),
+      isNull2(juniorMemoryMemories.archivedAtMs),
+      isNull2(juniorMemoryMemories.supersededAtMs),
+      isNull2(juniorMemoryMemories.supersededById)
+    )
+  ).limit(1);
+  return rows[0] ? parseMemoryRow(rows[0]) : void 0;
+}
+function searchScore(memory, terms) {
+  const haystack = memory.content.toLowerCase();
+  return terms.reduce(
+    (score, term) => score + (haystack.includes(term) ? 1 : 0),
+    0
+  );
+}
+function searchTerms(query) {
+  return [
+    ...new Set(
+      query.toLowerCase().split(/[^a-z0-9_'-]+/).map((term) => term.trim()).filter((term) => term.length >= 2)
+    )
+  ];
+}
+async function embedOne(embedder, text2) {
+  const normalized = normalizeContent(text2);
+  if (!normalized) {
+    throw new Error("Embedding text is required.");
+  }
+  const result = embeddingResultSchema.parse(
+    await embedder.embedTexts({ texts: [normalized] })
+  );
+  if (result.vectors.length !== 1) {
+    throw new Error("Embedding provider returned an unexpected vector count.");
+  }
+  return {
+    model: result.model,
+    provider: result.provider,
+    vector: result.vectors[0]
+  };
+}
+async function storeEmbedding(args) {
+  if (!args.embedder) {
+    return;
+  }
+  try {
+    const existing = await args.db.select({ memoryId: juniorMemoryEmbeddings.memoryId }).from(juniorMemoryEmbeddings).where(eq3(juniorMemoryEmbeddings.memoryId, args.memoryId)).limit(1);
+    if (existing[0]) {
+      return;
+    }
+  } catch {
+    return;
+  }
+  let embedding;
+  try {
+    embedding = await embedOne(args.embedder, args.content);
+  } catch {
+    return;
+  }
+  try {
+    await args.db.insert(juniorMemoryEmbeddings).values({
+      contentHash: hashEmbeddedContent(args.content),
+      createdAtMs: args.nowMs,
+      dimensions: MEMORY_EMBEDDING_DIMENSIONS,
+      embedding: embedding.vector,
+      memoryId: args.memoryId,
+      metric: EMBEDDING_METRIC,
+      model: embedding.model,
+      provider: embedding.provider
+    }).onConflictDoNothing();
+  } catch {
+    return;
+  }
+}
+async function listVisibleMemories(args) {
+  const predicate = activeVisiblePredicate(args);
+  if (!predicate) {
+    return [];
+  }
+  const limit = boundedLimit(args.limit, DEFAULT_LIST_LIMIT);
+  const rows = await args.db.select().from(juniorMemoryMemories).where(predicate).orderBy(
+    desc2(juniorMemoryMemories.createdAtMs),
+    asc(juniorMemoryMemories.id)
+  ).limit(limit);
+  return rows.map(parseMemoryRow);
+}
+async function searchVisibleMemories(args) {
+  const terms = searchTerms(args.query);
+  if (terms.length === 0) {
+    return [];
+  }
+  const predicate = activeVisiblePredicate(args);
+  if (!predicate) {
+    return [];
+  }
+  const rows = await args.db.select().from(juniorMemoryMemories).where(
+    and2(
+      predicate,
+      or2(
+        ...terms.map(
+          (term) => ilike2(juniorMemoryMemories.content, `%${term}%`)
+        )
+      )
+    )
+  );
+  return rows.map(parseMemoryRow);
+}
+async function searchVisibleVectorMemories(args) {
+  if (!args.embedder) {
+    return [];
+  }
+  const predicate = activeVisiblePredicate(args);
+  if (!predicate) {
+    return [];
+  }
+  let embedding;
+  try {
+    embedding = await embedOne(args.embedder, args.query);
+  } catch {
+    return [];
+  }
+  const distance = cosineDistance(
+    juniorMemoryEmbeddings.embedding,
+    embedding.vector
+  );
+  const rows = await args.db.select({
+    contentHash: juniorMemoryEmbeddings.contentHash,
+    distance,
+    memory: juniorMemoryMemories
+  }).from(juniorMemoryMemories).innerJoin(
+    juniorMemoryEmbeddings,
+    eq3(juniorMemoryEmbeddings.memoryId, juniorMemoryMemories.id)
+  ).where(
+    and2(
+      predicate,
+      eq3(juniorMemoryEmbeddings.provider, embedding.provider),
+      eq3(juniorMemoryEmbeddings.model, embedding.model),
+      eq3(juniorMemoryEmbeddings.dimensions, MEMORY_EMBEDDING_DIMENSIONS),
+      eq3(juniorMemoryEmbeddings.metric, EMBEDDING_METRIC)
+    )
+  ).orderBy(
+    distance,
+    desc2(juniorMemoryMemories.createdAtMs),
+    asc(juniorMemoryMemories.id)
+  ).limit(args.limit);
+  return rows.flatMap((row) => {
+    const distanceValue = Number(row.distance);
+    if (row.distance === null || !Number.isFinite(distanceValue) || hashEmbeddedContent(row.memory.content) !== row.contentHash) {
+      return [];
+    }
+    return [
+      {
+        memory: parseMemoryRow(row.memory),
+        score: 1 / (1 + Math.max(0, distanceValue))
+      }
+    ];
+  });
+}
+function mergeSearchCandidates(candidates) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    const existing = byId.get(candidate.memory.id);
+    if (existing) {
+      existing.score += candidate.score;
+      continue;
+    }
+    byId.set(candidate.memory.id, {
+      memory: candidate.memory,
+      score: candidate.score
+    });
+  }
+  return [...byId.values()].sort(
+    (left, right) => right.score - left.score || right.memory.createdAtMs - left.memory.createdAtMs || left.memory.id.localeCompare(right.memory.id)
+  ).map((candidate) => candidate.memory);
+}
+function createMemoryStore(db, context, options = {}) {
+  const runtimeContext = memoryRuntimeContextSchema.parse(context);
+  const parsedOptions = memoryStoreOptionsSchema.parse({ now: options.now });
+  const embedder = options.embedder;
+  const getNowMs = parsedOptions.now ?? Date.now;
+  async function createScopedMemory(rawInput, scopeKind) {
+    const input = createMemoryInputSchema.parse(rawInput);
+    const nowMs = getNowMs();
+    const content = normalizeContent(input.content);
+    const scope = deriveMemoryScope(runtimeContext, scopeKind);
+    const subject = deriveMemorySubject(runtimeContext, scope);
+    if (content.length > MAX_MEMORY_CONTENT_CHARS) {
+      throw new Error("Memory content exceeds the maximum length.");
+    }
+    const id = randomUUID();
+    const rows = await db.insert(juniorMemoryMemories).values({
+      content,
+      createdAtMs: nowMs,
+      expiresAtMs: input.expiresAtMs,
+      id,
+      idempotencyKey: input.idempotencyKey,
+      observedAtMs: nowMs,
+      scope: scope.scope,
+      scopeKey: scope.scopeKey,
+      sourceKey: sourceKey(runtimeContext),
+      sourcePlatform: runtimeContext.source.platform,
+      subjectKey: subject.subjectKey,
+      subjectType: subject.subjectType,
+      type: "knowledge"
+    }).onConflictDoNothing({
+      target: [
+        juniorMemoryMemories.scope,
+        juniorMemoryMemories.scopeKey,
+        juniorMemoryMemories.idempotencyKey
+      ],
+      where: sql2`${juniorMemoryMemories.idempotencyKey} IS NOT NULL AND ${juniorMemoryMemories.archivedAtMs} IS NULL AND ${juniorMemoryMemories.supersededAtMs} IS NULL AND ${juniorMemoryMemories.supersededById} IS NULL`
+    }).returning();
+    if (rows[0]) {
+      const memory = parseMemoryRow(rows[0]);
+      await storeEmbedding({
+        content: memory.content,
+        db,
+        embedder,
+        memoryId: memory.id,
+        nowMs
+      });
+      return { created: true, memory };
+    }
+    const idempotent = await findByIdempotencyKey({
+      db,
+      idempotencyKey: input.idempotencyKey,
+      scope
+    });
+    if (!idempotent) {
+      throw new Error("Memory idempotency conflict did not resolve.");
+    }
+    await storeEmbedding({
+      content: idempotent.content,
+      db,
+      embedder,
+      memoryId: idempotent.id,
+      nowMs
+    });
+    return { created: false, memory: idempotent };
+  }
+  return {
+    async createMemory(input) {
+      return await createScopedMemory(input, "personal");
+    },
+    async createConversationMemory(input) {
+      return await createScopedMemory(input, "conversation");
+    },
+    async listMemories(input) {
+      input = listMemoriesInputSchema.parse(input);
+      const nowMs = getNowMs();
+      const scopes = deriveVisibleMemoryScopes(runtimeContext);
+      return await listVisibleMemories({
+        db,
+        limit: input.limit,
+        nowMs,
+        scopes
+      });
+    },
+    async searchMemories(input) {
+      input = searchMemoriesInputSchema.parse(input);
+      const nowMs = getNowMs();
+      const scopes = deriveVisibleMemoryScopes(runtimeContext);
+      const limit = boundedLimit(input.limit, DEFAULT_SEARCH_LIMIT);
+      const vectorCandidates = await searchVisibleVectorMemories({
+        db,
+        embedder,
+        limit: limit * VECTOR_SEARCH_OVERFETCH,
+        nowMs,
+        query: input.query,
+        scopes
+      });
+      const candidates = await searchVisibleMemories({
+        db,
+        nowMs,
+        query: input.query,
+        scopes
+      });
+      const terms = searchTerms(input.query);
+      const lexicalCandidates = candidates.map((memory) => ({ memory, score: searchScore(memory, terms) })).filter((item) => item.score > 0);
+      return mergeSearchCandidates([
+        ...vectorCandidates,
+        ...lexicalCandidates
+      ]).slice(0, limit);
+    },
+    async archiveMemory(input) {
+      input = archiveMemoryInputSchema.parse(input);
+      const nowMs = getNowMs();
+      const scopes = deriveVisibleMemoryScopes(runtimeContext);
+      const predicate = activeVisiblePredicate({ nowMs, scopes });
+      const idPrefix = input.id.trim();
+      if (!idPrefix) {
+        throw new Error("Memory id is required.");
+      }
+      const rows = predicate ? await db.select().from(juniorMemoryMemories).where(
+        and2(
+          predicate,
+          or2(
+            eq3(juniorMemoryMemories.id, idPrefix),
+            like(juniorMemoryMemories.id, `${idPrefix}%`)
+          )
+        )
+      ).orderBy(asc(juniorMemoryMemories.id)).limit(2) : [];
+      if (rows.length === 0) {
+        throw new Error("Memory was not found in the current context.");
+      }
+      if (rows.length > 1) {
+        throw new Error("Memory id prefix is ambiguous.");
+      }
+      const memory = parseMemoryRow(rows[0]);
+      const updated = await db.update(juniorMemoryMemories).set({
+        archivedAtMs: nowMs,
+        archiveReason: input.reason ?? "user_removed"
+      }).where(eq3(juniorMemoryMemories.id, memory.id)).returning();
+      await db.delete(juniorMemoryEmbeddings).where(eq3(juniorMemoryEmbeddings.memoryId, memory.id));
+      return parseMemoryRow(updated[0]);
+    }
+  };
+}
+
+// src/tools.ts
+var MAX_TOOL_CONTENT_CHARS = 4e3;
+var DEFAULT_RESULT_LIMIT = 20;
+var DEFAULT_SEARCH_LIMIT2 = 10;
+var KNOWN_TOOL_INPUT_ERROR_MESSAGES = /* @__PURE__ */ new Set([
+  "Conversation memory requires conversation context.",
+  "Conversation-subject memory requires conversation context.",
+  "Memory content is required.",
+  "Memory content exceeds the maximum length.",
+  "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."
+]);
+function throwToolInputError(message) {
+  throw new PluginToolInputError(message);
+}
+function asToolInputError(error) {
+  if (error instanceof PluginToolInputError) {
+    throw error;
+  }
+  if (error instanceof Error && KNOWN_TOOL_INPUT_ERROR_MESSAGES.has(error.message)) {
+    throw new PluginToolInputError(error.message, { cause: error });
+  }
+  throw error;
+}
+function memoryRuntimeContext(context) {
+  return memoryRuntimeContextSchema.parse({
+    ...context.conversationId ? { conversationId: context.conversationId } : {},
+    ...context.requester ? { requester: context.requester } : {},
+    source: context.source
+  });
+}
+function memoryStore(context) {
+  return createMemoryStore(context.db, memoryRuntimeContext(context), {
+    embedder: context.embedder
+  });
+}
+function boundedLimit2(value, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return fallback;
+  }
+  return Math.min(50, Math.max(1, Math.floor(value)));
+}
+function digitAt(value, index2) {
+  const code = value.charCodeAt(index2);
+  return code >= 48 && code <= 57;
+}
+function readDigits(value, start, length) {
+  for (let index2 = start; index2 < start + length; index2++) {
+    if (!digitAt(value, index2)) {
+      return void 0;
+    }
+  }
+  return Number(value.slice(start, start + length));
+}
+function parseIsoTimestampParts(value) {
+  if (value.length < 20 || value[4] !== "-" || value[7] !== "-" || value[10] !== "T" || value[13] !== ":" || value[16] !== ":") {
+    return void 0;
+  }
+  const year = readDigits(value, 0, 4);
+  const month = readDigits(value, 5, 2);
+  const day = readDigits(value, 8, 2);
+  const hour = readDigits(value, 11, 2);
+  const minute = readDigits(value, 14, 2);
+  const second = readDigits(value, 17, 2);
+  if (year === void 0 || month === void 0 || day === void 0 || hour === void 0 || minute === void 0 || second === void 0) {
+    return void 0;
+  }
+  let zoneStart = 19;
+  if (value[zoneStart] === ".") {
+    zoneStart += 1;
+    const fractionStart = zoneStart;
+    while (zoneStart < value.length && digitAt(value, zoneStart)) {
+      zoneStart += 1;
+    }
+    if (zoneStart === fractionStart) {
+      return void 0;
+    }
+  }
+  if (value[zoneStart] === "Z") {
+    if (zoneStart !== value.length - 1) {
+      return void 0;
+    }
+  } else if (value[zoneStart] === "+" || value[zoneStart] === "-") {
+    if (zoneStart !== value.length - 6 || value[zoneStart + 3] !== ":" || readDigits(value, zoneStart + 1, 2) === void 0 || readDigits(value, zoneStart + 4, 2) === void 0) {
+      return void 0;
+    }
+  } else {
+    return void 0;
+  }
+  return { day, hour, minute, month, second, year };
+}
+function parseExpiresAt(value) {
+  if (!value) {
+    return void 0;
+  }
+  if (value === "never") {
+    return void 0;
+  }
+  const parts = parseIsoTimestampParts(value);
+  const expiresAtMs = Date.parse(value);
+  if (!parts || !Number.isFinite(expiresAtMs)) {
+    throwToolInputError('expires_at must be "never" or a valid ISO timestamp.');
+  }
+  const calendarDate = new Date(
+    Date.UTC(parts.year, parts.month - 1, parts.day)
+  );
+  if (calendarDate.getUTCFullYear() !== parts.year || calendarDate.getUTCMonth() !== parts.month - 1 || calendarDate.getUTCDate() !== parts.day || parts.hour > 23 || parts.minute > 59 || parts.second > 59) {
+    throwToolInputError('expires_at must be "never" or a valid ISO timestamp.');
+  }
+  return expiresAtMs;
+}
+function requireToolCallId(value) {
+  if (!value) {
+    throwToolInputError("Memory creation requires a tool call id.");
+  }
+  return value;
+}
+function requireMemoryContent(value) {
+  if (value.trim().length === 0) {
+    throwToolInputError("Memory content is required.");
+  }
+  return value;
+}
+var createMemoryInputSchema2 = Type.Object(
+  {
+    content: Type.String({
+      minLength: 1,
+      maxLength: MAX_TOOL_CONTENT_CHARS,
+      description: "Self-contained public/shareable memory candidate. Include the subject in natural language when it matters; do not rely on surrounding chat context."
+    }),
+    expires_at: Type.Optional(
+      Type.String({
+        minLength: 1,
+        description: 'Expiration selector. Omit or use "never" when the memory should not expire, or use an exact ISO timestamp such as "2027-06-21T00:00:00Z".'
+      })
+    )
+  },
+  { additionalProperties: false }
+);
+var removeMemoryInputSchema = Type.Object(
+  {
+    id: Type.String({
+      minLength: 1,
+      description: "Memory id or unambiguous short id prefix to remove."
+    })
+  },
+  { additionalProperties: false }
+);
+var listMemoriesInputSchema2 = Type.Object(
+  {
+    limit: Type.Optional(
+      Type.Number({
+        minimum: 1,
+        maximum: 50,
+        description: "Maximum number of visible memories to return."
+      })
+    )
+  },
+  { additionalProperties: false }
+);
+var searchMemoriesInputSchema2 = Type.Object(
+  {
+    query: Type.String({
+      minLength: 1,
+      description: "Search query for visible memory content."
+    }),
+    limit: Type.Optional(
+      Type.Number({
+        minimum: 1,
+        maximum: 50,
+        description: "Maximum number of matching memories to return."
+      })
+    )
+  },
+  { additionalProperties: false }
+);
+function parseToolInput(schema, input) {
+  try {
+    if (!Value.Check(schema, input)) {
+      throw new Error("Input does not match memory tool schema.");
+    }
+    return Value.Parse(schema, input);
+  } catch (error) {
+    throw new PluginToolInputError("Invalid memory tool input.", {
+      cause: error
+    });
+  }
+}
+function sourceIdempotencyKey(context) {
+  const sourceKey2 = getSourceKey(context.source);
+  if (!sourceKey2) {
+    throwToolInputError("Memory creation requires source message context.");
+  }
+  return sourceKey2;
+}
+function createInput(context, input, toolCallId) {
+  return {
+    content: requireMemoryContent(input.content),
+    idempotencyKey: `tool:${sourceIdempotencyKey(context)}:${toolCallId}`,
+    ...input.expiresAtMs !== void 0 ? { expiresAtMs: input.expiresAtMs } : {}
+  };
+}
+function compactMemory(memory) {
+  return {
+    id: memory.id,
+    content: memory.content,
+    createdAtMs: memory.createdAtMs,
+    ...memory.expiresAtMs !== void 0 ? { expiresAtMs: memory.expiresAtMs } : {}
+  };
+}
+function createMemoryCreateTool(context) {
+  return {
+    description: "Explicit memory-write tool. Use only when the latest user message directly asks Junior to remember, store, save, or forget-and-replace a public/shareable fact. Do not use for ordinary statements like 'I prefer X', 'I use Y', or 'X goes before Y' unless the user also asks you to remember/store/save it; passive memory learning handles those after the visible reply. Pass one self-contained natural-language candidate preserving the user's explicit memory intent. Do not ask the user to rephrase ordinary first-person facts, and do not rewrite them into display-name or third-person wording. Do not include secrets, private personal details, medical/legal/financial/sensitive facts, or another person's personal preference, opinion, habit, identity, relationship, workflow, or private life. Runtime context derives actor, scope, source, and subject ids; the memory agent decides the canonical stored content, subject, and target.",
+    executionMode: "sequential",
+    inputSchema: createMemoryInputSchema2,
+    execute: async (input, options) => {
+      const parsedInput = parseToolInput(
+        createMemoryInputSchema2,
+        input
+      );
+      const toolCallId = requireToolCallId(options.toolCallId);
+      const requestedExpiresAtMs = parseExpiresAt(parsedInput.expires_at);
+      const runtimeContext = memoryRuntimeContext(context);
+      const store = memoryStore(context);
+      const review = await (async () => {
+        try {
+          return parseMemoryReview(
+            await context.agent.reviewCreateRequest(
+              parseCreateMemoryRequest({
+                content: requireMemoryContent(parsedInput.content),
+                ...requestedExpiresAtMs !== void 0 ? { expiresAtMs: requestedExpiresAtMs } : {},
+                runtimeContext,
+                ...context.userText?.trim() ? {
+                  sourceContext: {
+                    currentUserText: context.userText.trim()
+                  }
+                } : {}
+              })
+            )
+          );
+        } catch (error) {
+          if (error instanceof PluginToolInputError) {
+            throw error;
+          }
+          const detail = error instanceof Error && error.message.trim() ? `: ${error.message}` : "";
+          throw new PluginToolInputError(
+            `Memory agent review failed${detail}`,
+            { cause: error }
+          );
+        }
+      })();
+      if (review.decision === "reject") {
+        throw new PluginToolInputError(
+          `Memory was not stored: ${review.reason}`
+        );
+      }
+      const memoryInput = createInput(
+        context,
+        {
+          content: review.content,
+          ...review.expiresAtMs !== void 0 ? { expiresAtMs: review.expiresAtMs } : requestedExpiresAtMs !== void 0 ? { expiresAtMs: requestedExpiresAtMs } : {}
+        },
+        toolCallId
+      );
+      const result = await (async () => {
+        try {
+          if (review.target === "conversation") {
+            return await store.createConversationMemory(memoryInput);
+          }
+          return await store.createMemory(memoryInput);
+        } catch (error) {
+          asToolInputError(error);
+        }
+      })();
+      return {
+        ok: true,
+        created: result.created,
+        memory: compactMemory(result.memory)
+      };
+    }
+  };
+}
+function createMemoryRemoveTool(context) {
+  return {
+    description: "Forget one memory visible in the active context. Use only ids or short id prefixes returned by listMemories or searchMemories. Never remove memories by hidden actor, Slack, scope, or subject identifiers.",
+    executionMode: "sequential",
+    inputSchema: removeMemoryInputSchema,
+    execute: async (input) => {
+      const parsedInput = parseToolInput(
+        removeMemoryInputSchema,
+        input
+      );
+      const memory = await (async () => {
+        try {
+          return await memoryStore(context).archiveMemory({
+            id: parsedInput.id,
+            reason: "tool_removed"
+          });
+        } catch (error) {
+          asToolInputError(error);
+        }
+      })();
+      return {
+        ok: true,
+        memory: compactMemory(memory)
+      };
+    }
+  };
+}
+function createMemoryListTool(context) {
+  return {
+    description: "List active memories visible in the current context. Use when the user asks what Junior remembers or when memory ids are needed before removing a memory.",
+    annotations: { readOnlyHint: true, destructiveHint: false },
+    inputSchema: listMemoriesInputSchema2,
+    execute: async (input) => {
+      const parsedInput = parseToolInput(
+        listMemoriesInputSchema2,
+        input
+      );
+      const memories = await memoryStore(context).listMemories({
+        limit: boundedLimit2(parsedInput.limit, DEFAULT_RESULT_LIMIT)
+      });
+      return {
+        ok: true,
+        memories: memories.map(compactMemory)
+      };
+    }
+  };
+}
+function createMemorySearchTool(context) {
+  return {
+    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.",
+    annotations: { readOnlyHint: true, destructiveHint: false },
+    inputSchema: searchMemoriesInputSchema2,
+    execute: async (input) => {
+      const parsedInput = parseToolInput(
+        searchMemoriesInputSchema2,
+        input
+      );
+      const memories = await memoryStore(context).searchMemories({
+        query: parsedInput.query,
+        limit: boundedLimit2(parsedInput.limit, DEFAULT_SEARCH_LIMIT2)
+      });
+      return {
+        ok: true,
+        memories: memories.map(compactMemory)
+      };
+    }
+  };
+}
+
+// src/process-session.ts
+import { createHash as createHash2 } from "crypto";
+import {
+  getSourceKey as getSourceKey2,
+  isPrivateSource
+} from "@sentry/junior-plugin-api";
+import { z as z4 } from "zod";
+var MEMORY_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "createMemory",
+  "listMemories",
+  "removeMemory",
+  "searchMemories"
+]);
+var MEMORY_TASK_STATE_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+var extractedMemoryCacheSchema = z4.array(
+  z4.object({
+    content: z4.string().min(1),
+    expiresAtMs: z4.number().finite().nullable(),
+    target: z4.enum(["requester", "conversation"])
+  }).strict()
+);
+function memoryIdempotencySuffix(memory) {
+  return createHash2("sha256").update(memory.target).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) {
+  return {
+    content: memory.content,
+    idempotencyKey: `session:${sourceKey2}:${sessionId}:${memoryIdempotencySuffix(memory)}`,
+    ...memory.expiresAtMs !== null ? { expiresAtMs: memory.expiresAtMs } : {}
+  };
+}
+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 memories = await extract();
+  if (memories.length > 0) {
+    await context.state.set(cacheKey, memories, MEMORY_TASK_STATE_TTL_MS);
+  }
+  return memories;
+}
+async function processMemorySession(context) {
+  const run = await context.run.load();
+  if (run.transcript.some(
+    (entry) => entry.type === "toolResult" && MEMORY_TOOL_NAMES.has(entry.toolName)
+  )) {
+    return;
+  }
+  if (run.source.platform !== "local" && isPrivateSource(run.source)) {
+    return;
+  }
+  const sourceKey2 = getSourceKey2(run.source);
+  if (!sourceKey2) {
+    return;
+  }
+  const transcript = run.transcript.filter((entry) => entry.text?.trim()).map((entry) => ({ ...entry, text: entry.text.trim() }));
+  const evidenceText = transcript.filter((entry) => entry.type === "toolResult" || entry.role === "user").map((entry) => entry.text).join("\n\n").trim();
+  if (!evidenceText) {
+    return;
+  }
+  const runtimeContext = memoryRuntimeContextSchema.parse({
+    conversationId: run.conversationId,
+    ...run.requester ? { requester: run.requester } : {},
+    source: run.source
+  });
+  const store = createMemoryStore(context.db, runtimeContext, {
+    embedder: context.embedder
+  });
+  const memories = await getTaskMemories(context, async () => {
+    const existingMemories = await store.searchMemories({
+      limit: 10,
+      query: evidenceText
+    });
+    const agent = createMemoryAgent(context.model);
+    return await agent.extractSessionMemories({
+      existingMemories: existingMemories.map((memory) => ({
+        content: memory.content
+      })),
+      transcript,
+      runtimeContext
+    });
+  });
+  if (memories.length === 0) {
+    return;
+  }
+  for (const memory of memories) {
+    const input = passiveInput(run.runId, memory, sourceKey2);
+    if (memory.target === "conversation") {
+      await store.createConversationMemory(input);
+      continue;
+    }
+    if (!run.requester) {
+      continue;
+    }
+    await store.createMemory(input);
+  }
+}
+
+// src/recall.ts
+var DEFAULT_RECALL_LIMIT = 5;
+var MAX_PROMPT_CHARS = 1600;
+var MAX_MEMORY_LINE_CHARS = 320;
+function trimContent(content, maxLength) {
+  const trimmed = content.trim();
+  if (trimmed.length <= maxLength) {
+    return trimmed;
+  }
+  return `${trimmed.slice(0, Math.max(0, maxLength - 3)).trimEnd()}...`;
+}
+function renderMemoryPrompt(memories) {
+  const header = "Relevant memories for this request:";
+  const footer = "Treat these as possibly stale context. Current user instructions and repository evidence take priority.";
+  const lines = [];
+  let totalChars = header.length + footer.length + 2;
+  for (const memory of memories) {
+    const line = `- ${trimContent(memory.content, MAX_MEMORY_LINE_CHARS)}`;
+    if (totalChars + line.length + 1 > MAX_PROMPT_CHARS) {
+      break;
+    }
+    lines.push(line);
+    totalChars += line.length + 1;
+  }
+  if (lines.length === 0) {
+    return void 0;
+  }
+  return `${header}
+${lines.join("\n")}
+
+${footer}`;
+}
+async function createMemoryPromptMessages(context) {
+  if (!context.text.trim()) {
+    return void 0;
+  }
+  const runtimeContext = memoryRuntimeContextSchema.parse({
+    ...context.conversationId ? { conversationId: context.conversationId } : {},
+    ...context.requester ? { requester: context.requester } : {},
+    source: context.source
+  });
+  const memories = await createMemoryStore(
+    context.db,
+    runtimeContext,
+    context.embedder ? { embedder: context.embedder } : {}
+  ).searchMemories({
+    query: context.text,
+    limit: DEFAULT_RECALL_LIMIT
+  });
+  const text2 = renderMemoryPrompt(memories);
+  return text2 ? [{ text: text2 }] : void 0;
+}
+
+// src/plugin.ts
+var MEMORY_MODEL_ENV = "AI_MEMORY_MODEL";
+function memoryModelId(options) {
+  const explicitModelId = options.modelId?.trim();
+  if (explicitModelId) {
+    return explicitModelId;
+  }
+  const envModelId = process.env[MEMORY_MODEL_ENV]?.trim();
+  return envModelId || void 0;
+}
+function memoryToolContext(ctx) {
+  return {
+    agent: ctx.agent,
+    ...ctx.conversationId ? { conversationId: ctx.conversationId } : {},
+    ...ctx.requester ? { requester: ctx.requester } : {},
+    db: ctx.db,
+    ...ctx.embedder ? { embedder: ctx.embedder } : {},
+    source: ctx.source,
+    ...ctx.userText ? { userText: ctx.userText } : {}
+  };
+}
+function createMemoryPlugin(options = {}) {
+  const modelId = memoryModelId(options);
+  return defineJuniorPlugin({
+    manifest: {
+      name: "memory",
+      displayName: "Memory",
+      description: "Long-term Junior memory storage and recall"
+    },
+    model: modelId ? { structuredModelId: modelId } : { structuredModel: "default" },
+    packageName: "@sentry/junior-memory",
+    cli: {
+      commands: [createMemoryCliCommand()]
+    },
+    tasks: {
+      processSession: {
+        async run(ctx) {
+          await processMemorySession(ctx);
+        }
+      }
+    },
+    hooks: {
+      tools(ctx) {
+        const context = memoryToolContext({
+          ...ctx,
+          agent: createMemoryAgent(ctx.model),
+          db: ctx.db,
+          embedder: ctx.embedder
+        });
+        return {
+          createMemory: createMemoryCreateTool(context),
+          removeMemory: createMemoryRemoveTool(context),
+          listMemories: createMemoryListTool(context),
+          searchMemories: createMemorySearchTool(context)
+        };
+      },
+      async userPrompt(ctx) {
+        return await createMemoryPromptMessages({
+          ...ctx.conversationId ? { conversationId: ctx.conversationId } : {},
+          ...ctx.requester ? { requester: ctx.requester } : {},
+          db: ctx.db,
+          embedder: ctx.embedder,
+          source: ctx.source,
+          text: ctx.text
+        });
+      }
+    }
+  });
+}
+var memoryPlugin = createMemoryPlugin();
+export {
+  createMemoryPlugin,
+  createMemoryStore,
+  memoryPlugin
+};
+//# sourceMappingURL=index.js.map