@sentry/junior-memory 0.106.0 → 0.107.1

package/dist/index.js

@@ -3,8 +3,41 @@ import { defineJuniorPlugin } from "@sentry/junior-plugin-api";
 
 // src/agent.ts
 import { actorSchema } from "@sentry/junior-plugin-api";
+import { z as z3 } from "zod";
+
+// src/store.ts
+import { createHash, randomUUID } from "crypto";
+import {
+  and,
+  asc,
+  desc,
+  eq,
+  gt,
+  ilike,
+  inArray,
+  isNull,
+  isNotNull,
+  like,
+  lte,
+  or,
+  sql as sql2
+} from "drizzle-orm";
+import { cosineDistance } from "drizzle-orm/sql/functions";
 import { z as z2 } from "zod";
 
+// src/db/schema.ts
+import { sql } from "drizzle-orm";
+import {
+  bigint,
+  check,
+  index,
+  integer,
+  pgTable,
+  text,
+  uniqueIndex,
+  vector
+} from "drizzle-orm/pg-core";
+
 // src/types.ts
 import {
   localActorSchema,
@@ -42,1606 +75,1021 @@ var memoryRuntimeContextSchema = z.union([
   localMemoryRuntimeContextSchema
 ]);
 
-// src/agent.ts
-var memoryKindSchema = z2.enum(MEMORY_KINDS);
-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 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),
-        provenance: transcriptProvenanceSchema.optional(),
-        isRunActor: z2.boolean().optional()
-      }).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 supersessionRequestSchema = z2.object({
-  candidate: z2.object({
-    content: z2.string().min(1),
-    kind: z2.literal("preference")
-  }).strict(),
-  existingMemories: z2.array(
-    z2.object({
-      content: z2.string().min(1),
-      id: z2.string().min(1)
-    }).strict()
-  ).min(1).max(10),
-  runtimeContext: memoryRuntimeContextSchema
-}).strict();
-var expiresAtMsSchema = z2.number().finite().nullable().describe(
-  "Expiration timestamp when the fact should expire, otherwise null."
+// src/db/schema.ts
+var juniorMemoryMemories = pgTable(
+  "junior_memory_memories",
+  {
+    id: text("id").primaryKey(),
+    scope: text("scope", { enum: MEMORY_SCOPES }).notNull(),
+    scopeKey: text("scope_key").notNull(),
+    kind: text("type", { enum: MEMORY_KINDS }).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_kind_check",
+      sql`${table.kind} IN (
+        'preference',
+        'procedure',
+        'knowledge'
+      )`
+    ),
+    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 memoryReviewDecisionSchema = z2.discriminatedUnion("decision", [
-  z2.object({
-    decision: z2.literal("store"),
-    kind: memoryKindSchema,
-    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 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."
+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
     ),
-    canonicalFact: z2.string().min(1).describe(
-      "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."
+    check(
+      "junior_memory_embeddings_metric_check",
+      sql`${table.metric} IN ('cosine')`
     ),
-    expiresAtMs: expiresAtMsSchema
-  }).strict(),
-  z2.object({
-    decision: z2.literal("reject"),
-    reason: memoryRejectReasonSchema
-  }).strict()
-]);
-var extractedMemorySchema = z2.object({
-  kind: memoryKindSchema.describe(
-    "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 actor names, actor/user labels, source labels, or first- or second-person wording."
-  ),
-  expiresAtMs: expiresAtMsSchema,
-  evidenceMessageIndices: evidenceMessageIndicesSchema
-}).strict();
-var extractedMemoryResultSchema = z2.object({
-  content: z2.string().min(1),
-  expiresAtMs: expiresAtMsSchema,
-  kind: memoryKindSchema,
-  evidenceMessageIndices: evidenceMessageIndicesSchema
-}).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 supersessionDecisionResponseSchema = z2.discriminatedUnion("decision", [
-  z2.object({
-    decision: z2.literal("supersedes_old"),
-    supersededIds: z2.array(z2.string().min(1)).min(1).max(10)
-  }).strict(),
-  z2.object({
-    decision: z2.enum(["distinct", "uncertain"])
-  }).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 MEMORY_SUPERSESSION_SYSTEM = [
-  "You are Junior's memory supersession agent.",
-  "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");
-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 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 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 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 = [
-    `- 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())}`
-  ];
-  return ["<runtime>", ...lines, "</runtime>"].join("\n");
-}
-function sourceContext(request) {
-  const currentUserText = request.sourceContext?.currentUserText?.trim();
-  if (!currentUserText) {
+    check(
+      "junior_memory_embeddings_dimensions_check",
+      sql`${table.dimensions} = ${sql.raw(String(MEMORY_EMBEDDING_DIMENSIONS))}`
+    )
+  ]
+);
+
+// src/scope.ts
+import { isPrivateSource } from "@sentry/junior-plugin-api";
+function sourceConversationKey(ctx) {
+  if (ctx.source.platform === "local") {
+    return ctx.source.conversationId;
+  }
+  if (!isPrivateSource(ctx.source)) {
+    return `slack:${ctx.source.teamId}`;
+  }
+  const threadKey = ctx.source.threadTs ?? ctx.source.messageTs;
+  if (!threadKey) {
     return 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");
+  return `slack:${ctx.source.teamId}:${ctx.source.channelId}:${threadKey}`;
 }
-function existingMemoriesContext(request) {
-  if (request.existingMemories.length === 0) {
-    return "<existing-memories>[]</existing-memories>";
+function actorScopeKey(ctx) {
+  const actor = ctx.actor;
+  if (!actor?.userId) {
+    return void 0;
   }
-  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");
+  if (actor.platform === "slack") {
+    return `slack:${actor.teamId}:${actor.userId}`;
+  }
+  return `local:${actor.userId}`;
 }
-function allowedExtractionKinds(actorCount) {
-  return actorCount === 1 ? new Set(MEMORY_KINDS) : /* @__PURE__ */ new Set(["procedure", "knowledge"]);
+function deriveMemoryScope(ctx, scope) {
+  if (scope === "personal") {
+    const scopeKey2 = actorScopeKey(ctx);
+    if (!scopeKey2) {
+      throw new Error("Personal memory requires actor context.");
+    }
+    return { scope, scopeKey: scopeKey2 };
+  }
+  const scopeKey = sourceConversationKey(ctx);
+  if (!scopeKey) {
+    throw new Error("Conversation memory requires conversation context.");
+  }
+  return { scope, scopeKey };
 }
-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."
+function deriveMemorySubject(ctx, scope) {
+  if (scope.scope === "personal") {
+    const subjectKey2 = actorScopeKey(ctx);
+    if (!subjectKey2) {
+      throw new Error("User-subject memory requires actor context.");
+    }
+    return { subjectType: "user", subjectKey: subjectKey2 };
+  }
+  const subjectKey = sourceConversationKey(ctx);
+  if (!subjectKey) {
+    throw new Error(
+      "Conversation-subject memory requires conversation context."
     );
   }
-  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 actor preference. Direct answers to user inquiries qualify only when they are durable beyond this run. Stored as conversation memory.",
-    "</memory-kinds>"
-  );
-  return lines.join("\n");
+  return { subjectType: "conversation", subjectKey };
 }
-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 knowledge.",
-    "- 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 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 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.",
-    "- If unsure, reject.",
-    "</rules>",
-    "</memory-review-input>"
-  ].filter((section) => section !== void 0);
-  return sections.join("\n");
+function deriveVisibleMemoryScopes(ctx) {
+  const scopes = [];
+  try {
+    scopes.push(deriveMemoryScope(ctx, "personal"));
+  } catch {
+  }
+  try {
+    scopes.push(deriveMemoryScope(ctx, "conversation"));
+  } catch {
+  }
+  return scopes;
 }
-function transcriptActorLabel(actor) {
-  if (!actor) {
-    return "none";
+
+// src/store.ts
+var DEFAULT_LIST_LIMIT = 50;
+var DEFAULT_SEARCH_LIMIT = 10;
+var DEFAULT_EXPIRED_ARCHIVE_LIMIT = 100;
+var HIGH_CONFIDENCE_DUPLICATE_DISTANCE = 0.015;
+var PREFERENCE_ADJUDICATION_CANDIDATE_LIMIT = 10;
+var PREFERENCE_ADJUDICATION_VECTOR_LIMIT = 5;
+var VECTOR_SEARCH_OVERFETCH = 4;
+var MAX_MEMORY_CONTENT_CHARS = 4e3;
+var EMBEDDING_METRIC = "cosine";
+var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
+var RELEVANCE_NEAR_TIE_DELTA = 0.01;
+var SOURCE_CHANNEL_BOOST = 0.05;
+var nonEmptyStringSchema2 = z2.string().min(1);
+var memoryContentSchema = z2.string().refine((content) => content.trim().length > 0, {
+  message: "Memory content is required."
+});
+var numberSchema = z2.number().finite();
+var createMemoryInputSchema = z2.object({
+  content: memoryContentSchema,
+  expiresAtMs: numberSchema.optional(),
+  idempotencyKey: nonEmptyStringSchema2,
+  kind: z2.enum(MEMORY_KINDS)
+}).strict();
+var listMemoriesInputSchema = z2.object({
+  limit: numberSchema.optional()
+}).strict();
+var searchMemoriesInputSchema = z2.object({
+  limit: numberSchema.optional(),
+  query: nonEmptyStringSchema2
+}).strict();
+var archiveMemoryInputSchema = z2.object({
+  id: nonEmptyStringSchema2,
+  reason: nonEmptyStringSchema2.optional()
+}).strict();
+var archiveExpiredMemoriesInputSchema = z2.object({
+  limit: numberSchema.optional()
+}).strict();
+var clockSchema = z2.function({ input: [], output: numberSchema }).optional();
+var memoryStoreOptionsSchema = z2.object({
+  now: clockSchema
+}).strict();
+var optionalNumberSchema = z2.preprocess(
+  (value) => value === null ? void 0 : value,
+  z2.coerce.number().optional()
+);
+var optionalStringSchema = z2.preprocess(
+  (value) => value === null ? void 0 : value,
+  z2.string().optional()
+);
+var optionalNonEmptyStringSchema = z2.preprocess(
+  (value) => value === null ? void 0 : value,
+  z2.string().min(1).optional()
+);
+var memoryRowSchema = z2.object({
+  archivedAtMs: optionalNumberSchema,
+  archiveReason: optionalStringSchema,
+  content: memoryContentSchema,
+  createdAtMs: z2.coerce.number(),
+  expiresAtMs: optionalNumberSchema,
+  id: z2.string().min(1),
+  idempotencyKey: optionalStringSchema,
+  observedAtMs: z2.coerce.number(),
+  scope: z2.enum(MEMORY_SCOPES),
+  scopeKey: z2.string().min(1),
+  sourceKey: z2.string().min(1),
+  sourcePlatform: z2.enum(MEMORY_SOURCE_PLATFORMS),
+  subjectKey: optionalNonEmptyStringSchema,
+  subjectType: z2.enum(MEMORY_SUBJECT_TYPES),
+  supersededAtMs: optionalNumberSchema,
+  supersededById: optionalStringSchema,
+  kind: z2.enum(MEMORY_KINDS)
+}).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 (actor.platform === "system") {
-    return `system:${actor.name}`;
+  if (row.subjectKey === void 0) {
+    ctx.addIssue({
+      code: "custom",
+      message: "User and conversation memory rows require a subject key.",
+      path: ["subjectKey"]
+    });
   }
-  return actor.platform === "slack" ? `slack:${actor.teamId}:${actor.userId}` : `local:${actor.userId}`;
+});
+var memoryRecordSchema = z2.object({
+  archivedAtMs: numberSchema.optional(),
+  archiveReason: nonEmptyStringSchema2.optional(),
+  content: memoryContentSchema,
+  createdAtMs: numberSchema,
+  expiresAtMs: numberSchema.optional(),
+  id: nonEmptyStringSchema2,
+  observedAtMs: numberSchema,
+  scope: z2.enum(MEMORY_SCOPES),
+  subjectType: z2.enum(MEMORY_SUBJECT_TYPES),
+  supersededAtMs: numberSchema.optional(),
+  supersededById: nonEmptyStringSchema2.optional(),
+  kind: z2.enum(MEMORY_KINDS)
+}).strict();
+var embeddingVectorSchema = z2.array(numberSchema).length(MEMORY_EMBEDDING_DIMENSIONS);
+var embeddingResultSchema = z2.object({
+  dimensions: z2.literal(MEMORY_EMBEDDING_DIMENSIONS),
+  model: nonEmptyStringSchema2,
+  provider: nonEmptyStringSchema2,
+  vectors: z2.array(embeddingVectorSchema)
+}).strict();
+var memorySupersessionCandidateSchema = z2.object({
+  content: z2.string().min(1),
+  id: z2.string().min(1)
+}).strict();
+var memorySupersessionCandidatesSchema = z2.array(memorySupersessionCandidateSchema).min(1).max(PREFERENCE_ADJUDICATION_CANDIDATE_LIMIT);
+var supersededIdsSchema = z2.array(z2.string().min(1)).min(1).max(PREFERENCE_ADJUDICATION_CANDIDATE_LIMIT);
+var memorySupersessionInputSchema = z2.object({
+  candidate: z2.object({
+    content: z2.string().min(1),
+    kind: z2.literal("preference")
+  }).strict(),
+  existingMemories: memorySupersessionCandidatesSchema,
+  runtimeContext: memoryRuntimeContextSchema
+}).strict();
+var memorySupersessionDecisionSchema = z2.discriminatedUnion(
+  "decision",
+  [
+    z2.object({
+      decision: z2.literal("duplicate"),
+      duplicateId: z2.string().min(1)
+    }).strict(),
+    z2.object({
+      decision: z2.literal("supersedes_old"),
+      supersededIds: supersededIdsSchema
+    }).strict(),
+    z2.object({
+      decision: z2.enum(["distinct", "uncertain"])
+    }).strict()
+  ]
+);
+function normalizeContent(content) {
+  return content.replace(/\s+/g, " ").trim();
 }
-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");
-      }
-      const authority = entry.provenance?.authority ?? "context";
-      const isRunActor = entry.isRunActor === true;
-      const actor = transcriptActorLabel(entry.provenance?.actor);
-      return [
-        `<message index="${index2}" role="${entry.role}" authority="${authority}" is_run_actor="${isRunActor ? "true" : "false"}" actor="${escapeXml(actor)}">`,
-        escapeXml(entry.text),
-        "</message>"
-      ].join("\n");
-    }),
-    "</run-transcript>"
-  ].join("\n");
+function hashEmbeddedContent(content) {
+  return createHash("sha256").update(content, "utf8").digest("hex");
 }
-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.",
-    "",
-    runtimeDescription({
-      runtimeContext: request.runtimeContext
-    }),
-    "",
-    existingMemoriesContext(request),
-    "",
-    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.",
-    "- 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=knowledge for shared team, project, channel, runbook, or operational facts.",
-    ...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.",
-    "- 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 idempotencyAliasId(args) {
+  return `alias:${createHash("sha256").update(args.scope.scope).update("\0").update(args.scope.scopeKey).update("\0").update(args.idempotencyKey).update("\0").update(args.targetId).digest("hex")}`;
 }
-function supersessionPrompt(request) {
-  return [
-    "<memory-supersession-input>",
-    "Decide whether the candidate preference clearly replaces one or more existing active preferences.",
-    "",
-    runtimeDescription({
-      runtimeContext: request.runtimeContext
-    }),
-    "",
-    "<candidate>",
-    escapeXml(JSON.stringify(request.candidate)),
-    "</candidate>",
-    "",
-    "<existing-memories>",
-    escapeXml(JSON.stringify(request.existingMemories)),
-    "</existing-memories>",
-    "",
-    "<rules>",
-    "- Return supersedes_old only when the candidate and old memory describe the same mutable preference slot and the candidate is the newer value.",
-    "- Examples of same mutable slot: preferred programming language, preferred review style, preferred notification cadence, preferred tool for a task.",
-    "- Do not supersede when the candidate is just more specific, an additional preference, a different task/context, or the same value phrased differently.",
-    "- Do not supersede memories from different topics even if they are both preferences.",
-    "- Only return ids that appear in existing-memories.",
-    "- If unsure, return uncertain.",
-    "</rules>",
-    "</memory-supersession-input>"
-  ].join("\n");
+function boundedLimit(value, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return fallback;
+  }
+  return Math.min(200, Math.max(1, Math.floor(value)));
 }
-function createMemoryAgent(model) {
-  return {
-    async adjudicateSupersession(rawRequest) {
-      const request = supersessionRequestSchema.parse(
-        rawRequest
-      );
-      const result = await model.completeObject({
-        schema: supersessionDecisionResponseSchema,
-        system: MEMORY_SUPERSESSION_SYSTEM,
-        prompt: supersessionPrompt(request),
-        maxTokens: 400
-      });
-      return supersessionDecisionResponseSchema.parse(
-        result.object
-      );
-    },
-    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 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 memoryReviewFromResponse(response) {
-  if (response.decision === "store") {
-    return parseMemoryReview({
-      decision: "store",
-      kind: response.kind,
-      content: response.canonicalFact,
-      ...response.expiresAtMs !== null ? { expiresAtMs: response.expiresAtMs } : {}
-    });
+function sourceChannelPrefix(ctx) {
+  if (ctx.source.platform !== "slack") {
+    return void 0;
   }
-  return parseMemoryReview({
-    decision: "reject",
-    reason: response.reason
+  return `slack:${ctx.source.teamId}:${ctx.source.channelId}:`;
+}
+function parseMemoryRow(row) {
+  const parsed = memoryRowSchema.parse(row);
+  return memoryRecordSchema.parse({
+    id: parsed.id,
+    scope: parsed.scope,
+    kind: parsed.kind,
+    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 extractedMemoriesFromResponse(response) {
-  const toMemory = (memory) => parseExtractedMemory({
-    content: memory.canonicalFact,
-    expiresAtMs: memory.expiresAtMs,
-    kind: memory.kind,
-    evidenceMessageIndices: memory.evidenceMessageIndices
+function visibleScopePredicate(scopes) {
+  if (scopes.length === 0) {
+    return void 0;
+  }
+  return or(
+    ...scopes.map(
+      (scope) => and(
+        eq(juniorMemoryMemories.scope, scope.scope),
+        eq(juniorMemoryMemories.scopeKey, scope.scopeKey)
+      )
+    )
+  );
+}
+function activeVisiblePredicate(args) {
+  const scopePredicate = visibleScopePredicate(args.scopes);
+  if (!scopePredicate) {
+    return void 0;
+  }
+  return and(
+    scopePredicate,
+    isNull(juniorMemoryMemories.archivedAtMs),
+    isNull(juniorMemoryMemories.supersededAtMs),
+    isNull(juniorMemoryMemories.supersededById),
+    or(
+      isNull(juniorMemoryMemories.expiresAtMs),
+      gt(juniorMemoryMemories.expiresAtMs, args.nowMs)
+    )
+  );
+}
+async function findByIdempotencyKey(args) {
+  const activeRows = await args.db.select().from(juniorMemoryMemories).where(
+    and(
+      eq(juniorMemoryMemories.scope, args.scope.scope),
+      eq(juniorMemoryMemories.scopeKey, args.scope.scopeKey),
+      eq(juniorMemoryMemories.idempotencyKey, args.idempotencyKey),
+      isNull(juniorMemoryMemories.archivedAtMs),
+      isNull(juniorMemoryMemories.supersededAtMs),
+      isNull(juniorMemoryMemories.supersededById),
+      or(
+        isNull(juniorMemoryMemories.expiresAtMs),
+        gt(juniorMemoryMemories.expiresAtMs, args.nowMs)
+      )
+    )
+  ).limit(1);
+  if (activeRows[0]) {
+    return parseMemoryRow(activeRows[0]);
+  }
+  const aliasRows = await args.db.select({ supersededById: juniorMemoryMemories.supersededById }).from(juniorMemoryMemories).where(
+    and(
+      eq(juniorMemoryMemories.scope, args.scope.scope),
+      eq(juniorMemoryMemories.scopeKey, args.scope.scopeKey),
+      eq(juniorMemoryMemories.idempotencyKey, args.idempotencyKey),
+      isNull(juniorMemoryMemories.archivedAtMs),
+      isNotNull(juniorMemoryMemories.supersededAtMs),
+      isNotNull(juniorMemoryMemories.supersededById),
+      or(
+        isNull(juniorMemoryMemories.expiresAtMs),
+        gt(juniorMemoryMemories.expiresAtMs, args.nowMs)
+      )
+    )
+  ).orderBy(
+    desc(juniorMemoryMemories.createdAtMs),
+    asc(juniorMemoryMemories.id)
+  );
+  for (const alias of aliasRows) {
+    if (!alias.supersededById) {
+      continue;
+    }
+    const rows = await args.db.select().from(juniorMemoryMemories).where(
+      and(
+        eq(juniorMemoryMemories.id, alias.supersededById),
+        eq(juniorMemoryMemories.scope, args.scope.scope),
+        eq(juniorMemoryMemories.scopeKey, args.scope.scopeKey),
+        isNull(juniorMemoryMemories.archivedAtMs),
+        isNull(juniorMemoryMemories.supersededAtMs),
+        isNull(juniorMemoryMemories.supersededById),
+        or(
+          isNull(juniorMemoryMemories.expiresAtMs),
+          gt(juniorMemoryMemories.expiresAtMs, args.nowMs)
+        )
+      )
+    ).limit(1);
+    if (rows[0]) {
+      return parseMemoryRow(rows[0]);
+    }
+  }
+  return void 0;
+}
+async function archiveExpiredMemoryBatch(args) {
+  const scopePredicate = visibleScopePredicate(args.scopes);
+  if (!scopePredicate) {
+    return { archivedCount: 0 };
+  }
+  const predicates = [
+    scopePredicate,
+    isNull(juniorMemoryMemories.archivedAtMs),
+    isNull(juniorMemoryMemories.supersededAtMs),
+    isNull(juniorMemoryMemories.supersededById),
+    lte(juniorMemoryMemories.expiresAtMs, args.nowMs)
+  ];
+  if (args.idempotencyKey !== void 0) {
+    predicates.push(
+      eq(juniorMemoryMemories.idempotencyKey, args.idempotencyKey)
+    );
+  }
+  const archivedIds = await args.db.transaction(async (tx) => {
+    const expired = await tx.select({ id: juniorMemoryMemories.id }).from(juniorMemoryMemories).where(and(...predicates)).orderBy(
+      asc(juniorMemoryMemories.expiresAtMs),
+      asc(juniorMemoryMemories.id)
+    ).limit(boundedLimit(args.limit, DEFAULT_EXPIRED_ARCHIVE_LIMIT));
+    const ids = expired.map((row) => row.id);
+    if (ids.length === 0) {
+      return [];
+    }
+    const archived = await tx.update(juniorMemoryMemories).set({
+      archivedAtMs: args.nowMs,
+      archiveReason: "expired"
+    }).where(and(inArray(juniorMemoryMemories.id, ids), ...predicates)).returning({ id: juniorMemoryMemories.id });
+    const idsToClean = archived.map((row) => row.id);
+    if (idsToClean.length > 0) {
+      await tx.delete(juniorMemoryEmbeddings).where(inArray(juniorMemoryEmbeddings.memoryId, idsToClean));
+    }
+    return idsToClean;
   });
-  return response.memories.map(toMemory);
+  return { archivedCount: archivedIds.length };
 }
-function parseExtractedMemory(memory) {
-  return extractedMemoryResultSchema.parse(memory);
+function searchScore(memory, terms) {
+  const haystack = memory.content.toLowerCase();
+  return terms.reduce(
+    (score, term) => score + (haystack.includes(term) ? 1 : 0),
+    0
+  );
 }
-function parseMemoryReview(result) {
-  return memoryReviewDecisionSchema.parse(result);
+function searchTerms(query) {
+  return [
+    ...new Set(
+      query.toLowerCase().split(/[^a-z0-9_'-]+/).map((term) => term.trim()).filter((term) => term.length >= 2)
+    )
+  ];
 }
-function parseCreateMemoryRequest(request) {
-  return createMemoryRequestSchema.parse(request);
+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]
+  };
 }
-
-// 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(),
-    kind: text("type", { enum: MEMORY_KINDS }).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_kind_check",
-      sql`${table.kind} IN (
-        'preference',
-        'procedure',
-        'knowledge'
-      )`
-    ),
-    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}`] : [],
-    `kind=${row.kind}`,
-    `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");
+async function storeEmbedding(args) {
+  if (!args.embedder && !args.embedding) {
+    return;
   }
-  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);
+  try {
+    const existing = await args.db.select({ memoryId: juniorMemoryEmbeddings.memoryId }).from(juniorMemoryEmbeddings).where(eq(juniorMemoryEmbeddings.memoryId, args.memoryId)).limit(1);
+    if (existing[0]) {
+      return;
+    }
+  } catch {
+    return;
   }
-  if (terms.length > 0) {
-    const termPredicate = or(
-      ...terms.map((term) => ilike(juniorMemoryMemories.content, `%${term}%`))
-    );
-    if (termPredicate) {
-      predicates.push(termPredicate);
+  let embedding;
+  if (args.embedding) {
+    embedding = args.embedding;
+  } else {
+    const embedder = args.embedder;
+    if (!embedder) {
+      return;
+    }
+    try {
+      embedding = await embedOne(embedder, args.content);
+    } catch {
+      return;
     }
   }
-  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;
+  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;
   }
-  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
-      );
-    })
+function activeScopedSubjectPredicate(args) {
+  const predicate = and(
+    eq(juniorMemoryMemories.scope, args.scope.scope),
+    eq(juniorMemoryMemories.scopeKey, args.scope.scopeKey),
+    eq(juniorMemoryMemories.kind, args.kind),
+    eq(juniorMemoryMemories.subjectType, args.subject.subjectType),
+    args.subject.subjectKey === void 0 ? isNull(juniorMemoryMemories.subjectKey) : eq(juniorMemoryMemories.subjectKey, args.subject.subjectKey),
+    isNull(juniorMemoryMemories.archivedAtMs),
+    isNull(juniorMemoryMemories.supersededAtMs),
+    isNull(juniorMemoryMemories.supersededById),
+    or(
+      isNull(juniorMemoryMemories.expiresAtMs),
+      gt(juniorMemoryMemories.expiresAtMs, args.nowMs)
+    )
   );
-}
-
-// 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;
+  if (!predicate) {
+    throw new Error("Memory duplicate predicate is empty.");
   }
-  await ctx.io.writeOutput(`${formatMemory(rows[0], { showContent: true })}
-`);
-  return 0;
+  return predicate;
 }
-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);
-    })
+async function findExactDuplicateMemory(args) {
+  const rows = await args.db.select().from(juniorMemoryMemories).where(
+    and(
+      activeScopedSubjectPredicate(args),
+      eq(juniorMemoryMemories.content, args.content)
+    )
+  ).orderBy(
+    desc(juniorMemoryMemories.createdAtMs),
+    asc(juniorMemoryMemories.id)
+  ).limit(1);
+  return rows[0] ? parseMemoryRow(rows[0]) : void 0;
+}
+async function findVectorDuplicateMemory(args) {
+  const distance = cosineDistance(
+    juniorMemoryEmbeddings.embedding,
+    args.embedding.vector
   );
+  const rows = await args.db.select({
+    contentHash: juniorMemoryEmbeddings.contentHash,
+    distance,
+    memory: juniorMemoryMemories
+  }).from(juniorMemoryMemories).innerJoin(
+    juniorMemoryEmbeddings,
+    eq(juniorMemoryEmbeddings.memoryId, juniorMemoryMemories.id)
+  ).where(
+    and(
+      activeScopedSubjectPredicate(args),
+      eq(juniorMemoryEmbeddings.provider, args.embedding.provider),
+      eq(juniorMemoryEmbeddings.model, args.embedding.model),
+      eq(juniorMemoryEmbeddings.dimensions, MEMORY_EMBEDDING_DIMENSIONS),
+      eq(juniorMemoryEmbeddings.metric, EMBEDDING_METRIC),
+      lte(distance, HIGH_CONFIDENCE_DUPLICATE_DISTANCE)
+    )
+  ).orderBy(
+    distance,
+    desc(juniorMemoryMemories.createdAtMs),
+    asc(juniorMemoryMemories.id)
+  ).limit(1);
+  const row = rows[0];
+  if (!row || hashEmbeddedContent(row.memory.content) !== row.contentHash) {
+    return void 0;
+  }
+  return parseMemoryRow(row.memory);
 }
-
-// src/cli/index.ts
-function createMemoryCliCommand() {
-  return {
-    name: "memory",
-    summary: "Inspect Junior memory state",
-    configure(command, junior) {
-      configureMemorySearchCommand(command, junior);
-      configureMemoryShowCommand(command, junior);
+async function rememberDuplicateIdempotency(args) {
+  if (args.idempotencyKey === void 0) {
+    return;
+  }
+  await args.db.insert(juniorMemoryMemories).values({
+    content: args.content,
+    createdAtMs: args.nowMs,
+    expiresAtMs: args.duplicate.expiresAtMs,
+    id: idempotencyAliasId({
+      idempotencyKey: args.idempotencyKey,
+      scope: args.scope,
+      targetId: args.duplicate.id
+    }),
+    idempotencyKey: args.idempotencyKey,
+    observedAtMs: args.nowMs,
+    scope: args.scope.scope,
+    scopeKey: args.scope.scopeKey,
+    sourceKey: sourceKey(args.runtimeContext),
+    sourcePlatform: args.runtimeContext.source.platform,
+    subjectKey: args.subject.subjectKey,
+    subjectType: args.subject.subjectType,
+    supersededAtMs: args.nowMs,
+    supersededById: args.duplicate.id,
+    kind: args.duplicate.kind
+  }).onConflictDoNothing();
+}
+async function listPreferenceAdjudicationCandidates(args) {
+  const vectorCandidates = args.embedding ? await listVectorPreferenceAdjudicationCandidates({
+    db: args.db,
+    embedding: args.embedding,
+    nowMs: args.nowMs,
+    scope: args.scope,
+    subject: args.subject
+  }) : [];
+  const recentCandidates = (await args.db.select().from(juniorMemoryMemories).where(
+    activeScopedSubjectPredicate({
+      ...args,
+      kind: "preference"
+    })
+  ).orderBy(
+    desc(juniorMemoryMemories.createdAtMs),
+    asc(juniorMemoryMemories.id)
+  ).limit(PREFERENCE_ADJUDICATION_CANDIDATE_LIMIT)).map(parseMemoryRow);
+  return [
+    ...new Map(
+      [...vectorCandidates, ...recentCandidates].map((memory) => [
+        memory.id,
+        memory
+      ])
+    ).values()
+  ].slice(0, PREFERENCE_ADJUDICATION_CANDIDATE_LIMIT);
+}
+async function listVectorPreferenceAdjudicationCandidates(args) {
+  const distance = cosineDistance(
+    juniorMemoryEmbeddings.embedding,
+    args.embedding.vector
+  );
+  const rows = await args.db.select({
+    contentHash: juniorMemoryEmbeddings.contentHash,
+    distance,
+    memory: juniorMemoryMemories
+  }).from(juniorMemoryMemories).innerJoin(
+    juniorMemoryEmbeddings,
+    eq(juniorMemoryEmbeddings.memoryId, juniorMemoryMemories.id)
+  ).where(
+    and(
+      activeScopedSubjectPredicate({ ...args, kind: "preference" }),
+      eq(juniorMemoryEmbeddings.provider, args.embedding.provider),
+      eq(juniorMemoryEmbeddings.model, args.embedding.model),
+      eq(juniorMemoryEmbeddings.dimensions, MEMORY_EMBEDDING_DIMENSIONS),
+      eq(juniorMemoryEmbeddings.metric, EMBEDDING_METRIC)
+    )
+  ).orderBy(
+    distance,
+    desc(juniorMemoryMemories.createdAtMs),
+    asc(juniorMemoryMemories.id)
+  ).limit(PREFERENCE_ADJUDICATION_VECTOR_LIMIT);
+  return rows.flatMap((row) => {
+    if (hashEmbeddedContent(row.memory.content) !== row.contentHash) {
+      return [];
     }
-  };
+    return [parseMemoryRow(row.memory)];
+  });
 }
-
-// src/tools.ts
-import { Type } from "@sinclair/typebox";
-import { Value } from "@sinclair/typebox/value";
-import {
-  definePluginTool,
-  getSourceKey,
-  PluginToolInputError,
-  pluginToolResultSchema
-} from "@sentry/junior-plugin-api";
-import { z as z4 } from "zod";
-
-// 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,
-  inArray,
-  isNull as isNull2,
-  isNotNull,
-  like,
-  lte,
-  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
-import { isPrivateSource } from "@sentry/junior-plugin-api";
-function sourceConversationKey(ctx) {
-  if (ctx.source.platform === "local") {
-    return ctx.source.conversationId;
-  }
-  if (!isPrivateSource(ctx.source)) {
-    return `slack:${ctx.source.teamId}`;
-  }
-  const threadKey = ctx.source.threadTs ?? ctx.source.messageTs;
-  if (!threadKey) {
-    return void 0;
+async function adjudicatePreferenceCandidate(args) {
+  const [firstCandidate, ...remainingCandidates] = args.candidates;
+  if (!firstCandidate) {
+    return { decision: "create" };
+  }
+  const existingMemories = [
+    { content: firstCandidate.content, id: firstCandidate.id },
+    ...remainingCandidates.map((memory) => ({
+      content: memory.content,
+      id: memory.id
+    }))
+  ];
+  const candidateIds = new Set(args.candidates.map((memory) => memory.id));
+  try {
+    const decision = await args.decider.adjudicateSupersession({
+      candidate: {
+        content: args.content,
+        kind: "preference"
+      },
+      existingMemories,
+      runtimeContext: args.runtimeContext
+    });
+    if (decision.decision === "duplicate") {
+      const memory = args.candidates.find(
+        (candidate) => candidate.id === decision.duplicateId
+      );
+      return memory ? { decision: "duplicate", memory } : { decision: "create" };
+    }
+    if (decision.decision === "supersedes_old") {
+      const ids = decision.supersededIds.filter((id) => candidateIds.has(id));
+      const [firstId, ...remainingIds] = ids;
+      return firstId ? { decision: "supersede", ids: [firstId, ...remainingIds] } : { decision: "create" };
+    }
+    return { decision: "create" };
+  } catch {
+    return { decision: "create" };
   }
-  return `slack:${ctx.source.teamId}:${ctx.source.channelId}:${threadKey}`;
 }
-function actorScopeKey(ctx) {
-  const actor = ctx.actor;
-  if (!actor?.userId) {
-    return void 0;
-  }
-  if (actor.platform === "slack") {
-    return `slack:${actor.teamId}:${actor.userId}`;
+async function listVisibleMemories(args) {
+  const predicate = activeVisiblePredicate(args);
+  if (!predicate) {
+    return [];
   }
-  return `local:${actor.userId}`;
+  const limit = boundedLimit(args.limit, DEFAULT_LIST_LIMIT);
+  const rows = await args.db.select().from(juniorMemoryMemories).where(predicate).orderBy(
+    desc(juniorMemoryMemories.createdAtMs),
+    asc(juniorMemoryMemories.id)
+  ).limit(limit);
+  return rows.map(parseMemoryRow);
 }
-function deriveMemoryScope(ctx, scope) {
-  if (scope === "personal") {
-    const scopeKey2 = actorScopeKey(ctx);
-    if (!scopeKey2) {
-      throw new Error("Personal memory requires actor context.");
-    }
-    return { scope, scopeKey: scopeKey2 };
+async function searchVisibleMemories(args) {
+  const terms = searchTerms(args.query);
+  if (terms.length === 0) {
+    return [];
   }
-  const scopeKey = sourceConversationKey(ctx);
-  if (!scopeKey) {
-    throw new Error("Conversation memory requires conversation context.");
+  const predicate = activeVisiblePredicate(args);
+  if (!predicate) {
+    return [];
   }
-  return { scope, scopeKey };
+  const rows = await args.db.select().from(juniorMemoryMemories).where(
+    and(
+      predicate,
+      or(
+        ...terms.map(
+          (term) => ilike(juniorMemoryMemories.content, `%${term}%`)
+        )
+      )
+    )
+  );
+  return rows.map((row) => ({
+    memory: parseMemoryRow(row),
+    score: 0,
+    sourceKey: row.sourceKey
+  }));
 }
-function deriveMemorySubject(ctx, scope) {
-  if (scope.scope === "personal") {
-    const subjectKey2 = actorScopeKey(ctx);
-    if (!subjectKey2) {
-      throw new Error("User-subject memory requires actor context.");
-    }
-    return { subjectType: "user", subjectKey: subjectKey2 };
+async function searchVisibleVectorMemories(args) {
+  if (!args.embedder) {
+    return [];
   }
-  const subjectKey = sourceConversationKey(ctx);
-  if (!subjectKey) {
-    throw new Error(
-      "Conversation-subject memory requires conversation context."
-    );
+  const predicate = activeVisiblePredicate(args);
+  if (!predicate) {
+    return [];
   }
-  return { subjectType: "conversation", subjectKey };
-}
-function deriveVisibleMemoryScopes(ctx) {
-  const scopes = [];
+  let embedding;
   try {
-    scopes.push(deriveMemoryScope(ctx, "personal"));
+    embedding = await embedOne(args.embedder, args.query);
   } catch {
+    return [];
   }
-  try {
-    scopes.push(deriveMemoryScope(ctx, "conversation"));
-  } catch {
+  const distance = cosineDistance(
+    juniorMemoryEmbeddings.embedding,
+    embedding.vector
+  );
+  const rows = await args.db.select({
+    contentHash: juniorMemoryEmbeddings.contentHash,
+    distance,
+    memory: juniorMemoryMemories
+  }).from(juniorMemoryMemories).innerJoin(
+    juniorMemoryEmbeddings,
+    eq(juniorMemoryEmbeddings.memoryId, juniorMemoryMemories.id)
+  ).where(
+    and(
+      predicate,
+      eq(juniorMemoryEmbeddings.provider, embedding.provider),
+      eq(juniorMemoryEmbeddings.model, embedding.model),
+      eq(juniorMemoryEmbeddings.dimensions, MEMORY_EMBEDDING_DIMENSIONS),
+      eq(juniorMemoryEmbeddings.metric, EMBEDDING_METRIC)
+    )
+  ).orderBy(
+    distance,
+    desc(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 [];
+    }
+    if (args.maxDistance !== void 0 && distanceValue > args.maxDistance) {
+      return [];
+    }
+    return [
+      {
+        memory: parseMemoryRow(row.memory),
+        score: 1 / (1 + Math.max(0, distanceValue)),
+        sourceKey: row.memory.sourceKey
+      }
+    ];
+  });
+}
+function sourceBoost(candidate, currentChannelPrefix) {
+  if (!currentChannelPrefix) {
+    return 0;
   }
-  return scopes;
+  return candidate.sourceKey.startsWith(currentChannelPrefix) ? SOURCE_CHANNEL_BOOST : 0;
 }
-
-// src/store.ts
-var DEFAULT_LIST_LIMIT = 50;
-var DEFAULT_SEARCH_LIMIT = 10;
-var DEFAULT_EXPIRED_ARCHIVE_LIMIT = 100;
-var HIGH_CONFIDENCE_DUPLICATE_DISTANCE = 0.015;
-var SUPERSESSION_CANDIDATE_LIMIT = 10;
-var VECTOR_SEARCH_OVERFETCH = 4;
-var MAX_MEMORY_CONTENT_CHARS = 4e3;
-var EMBEDDING_METRIC = "cosine";
-var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
-var RELEVANCE_NEAR_TIE_DELTA = 0.01;
-var SOURCE_CHANNEL_BOOST = 0.05;
-var SUPERSESSION_STOP_TERMS = /* @__PURE__ */ new Set([
-  "and",
-  "for",
-  "prefer",
-  "prefers",
-  "preference",
-  "the",
-  "use",
-  "uses",
-  "with"
-]);
-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,
-  kind: z3.enum(MEMORY_KINDS)
-}).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 archiveExpiredMemoriesInputSchema = z3.object({
-  limit: numberSchema.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,
-  kind: z3.enum(MEMORY_KINDS)
-}).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(),
-  kind: z3.enum(MEMORY_KINDS)
-}).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 idempotencyAliasId(args) {
-  return `alias:${createHash("sha256").update(args.scope.scope).update("\0").update(args.scope.scopeKey).update("\0").update(args.idempotencyKey).update("\0").update(args.targetId).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 sourceChannelPrefix(ctx) {
-  if (ctx.source.platform !== "slack") {
-    return void 0;
+function observedAgeBoost(memory, nowMs) {
+  const ageMs = Math.max(0, nowMs - memory.observedAtMs);
+  if (ageMs <= 7 * ONE_DAY_MS) {
+    return 0.15;
   }
-  return `slack:${ctx.source.teamId}:${ctx.source.channelId}:`;
-}
-function parseMemoryRow(row) {
-  const parsed = memoryRowSchema.parse(row);
-  return memoryRecordSchema.parse({
-    id: parsed.id,
-    scope: parsed.scope,
-    kind: parsed.kind,
-    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;
+  if (ageMs <= 30 * ONE_DAY_MS) {
+    return 0.1;
   }
-  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;
+  if (ageMs <= 90 * ONE_DAY_MS) {
+    return 0.05;
   }
-  return and2(
-    scopePredicate,
-    isNull2(juniorMemoryMemories.archivedAtMs),
-    isNull2(juniorMemoryMemories.supersededAtMs),
-    isNull2(juniorMemoryMemories.supersededById),
-    or2(
-      isNull2(juniorMemoryMemories.expiresAtMs),
-      gt2(juniorMemoryMemories.expiresAtMs, args.nowMs)
-    )
-  );
+  return 0;
 }
-async function findByIdempotencyKey(args) {
-  const activeRows = 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),
-      or2(
-        isNull2(juniorMemoryMemories.expiresAtMs),
-        gt2(juniorMemoryMemories.expiresAtMs, args.nowMs)
-      )
-    )
-  ).limit(1);
-  if (activeRows[0]) {
-    return parseMemoryRow(activeRows[0]);
-  }
-  const aliasRows = await args.db.select({ supersededById: juniorMemoryMemories.supersededById }).from(juniorMemoryMemories).where(
-    and2(
-      eq3(juniorMemoryMemories.scope, args.scope.scope),
-      eq3(juniorMemoryMemories.scopeKey, args.scope.scopeKey),
-      eq3(juniorMemoryMemories.idempotencyKey, args.idempotencyKey),
-      isNull2(juniorMemoryMemories.archivedAtMs),
-      isNotNull(juniorMemoryMemories.supersededAtMs),
-      isNotNull(juniorMemoryMemories.supersededById),
-      or2(
-        isNull2(juniorMemoryMemories.expiresAtMs),
-        gt2(juniorMemoryMemories.expiresAtMs, args.nowMs)
-      )
-    )
-  ).orderBy(
-    desc2(juniorMemoryMemories.createdAtMs),
-    asc(juniorMemoryMemories.id)
-  );
-  for (const alias of aliasRows) {
-    if (!alias.supersededById) {
+function mergeSearchCandidates(candidates, nowMs, currentChannelKey) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    const existing = byId.get(candidate.memory.id);
+    if (existing) {
+      existing.score += candidate.score;
       continue;
     }
-    const rows = await args.db.select().from(juniorMemoryMemories).where(
-      and2(
-        eq3(juniorMemoryMemories.id, alias.supersededById),
-        eq3(juniorMemoryMemories.scope, args.scope.scope),
-        eq3(juniorMemoryMemories.scopeKey, args.scope.scopeKey),
-        isNull2(juniorMemoryMemories.archivedAtMs),
-        isNull2(juniorMemoryMemories.supersededAtMs),
-        isNull2(juniorMemoryMemories.supersededById),
-        or2(
-          isNull2(juniorMemoryMemories.expiresAtMs),
-          gt2(juniorMemoryMemories.expiresAtMs, args.nowMs)
-        )
-      )
-    ).limit(1);
-    if (rows[0]) {
-      return parseMemoryRow(rows[0]);
-    }
-  }
-  return void 0;
-}
-async function archiveExpiredMemoryBatch(args) {
-  const scopePredicate = visibleScopePredicate(args.scopes);
-  if (!scopePredicate) {
-    return { archivedCount: 0 };
-  }
-  const predicates = [
-    scopePredicate,
-    isNull2(juniorMemoryMemories.archivedAtMs),
-    isNull2(juniorMemoryMemories.supersededAtMs),
-    isNull2(juniorMemoryMemories.supersededById),
-    lte(juniorMemoryMemories.expiresAtMs, args.nowMs)
-  ];
-  if (args.idempotencyKey !== void 0) {
-    predicates.push(
-      eq3(juniorMemoryMemories.idempotencyKey, args.idempotencyKey)
-    );
+    byId.set(candidate.memory.id, {
+      memory: candidate.memory,
+      score: candidate.score,
+      sourceKey: candidate.sourceKey
+    });
   }
-  const archivedIds = await args.db.transaction(async (tx) => {
-    const expired = await tx.select({ id: juniorMemoryMemories.id }).from(juniorMemoryMemories).where(and2(...predicates)).orderBy(
-      asc(juniorMemoryMemories.expiresAtMs),
-      asc(juniorMemoryMemories.id)
-    ).limit(boundedLimit(args.limit, DEFAULT_EXPIRED_ARCHIVE_LIMIT));
-    const ids = expired.map((row) => row.id);
-    if (ids.length === 0) {
-      return [];
+  return [...byId.values()].sort((left, right) => {
+    const scoreDelta = right.score - left.score;
+    if (Math.abs(scoreDelta) > RELEVANCE_NEAR_TIE_DELTA) {
+      return scoreDelta;
     }
-    const archived = await tx.update(juniorMemoryMemories).set({
-      archivedAtMs: args.nowMs,
-      archiveReason: "expired"
-    }).where(and2(inArray(juniorMemoryMemories.id, ids), ...predicates)).returning({ id: juniorMemoryMemories.id });
-    const idsToClean = archived.map((row) => row.id);
-    if (idsToClean.length > 0) {
-      await tx.delete(juniorMemoryEmbeddings).where(inArray(juniorMemoryEmbeddings.memoryId, idsToClean));
+    const sourceDelta = sourceBoost(right, currentChannelKey) - sourceBoost(left, currentChannelKey);
+    if (sourceDelta !== 0) {
+      return sourceDelta;
     }
-    return idsToClean;
-  });
-  return { archivedCount: archivedIds.length };
-}
-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)
-    )
-  ];
+    return observedAgeBoost(right.memory, nowMs) - observedAgeBoost(left.memory, nowMs) || right.memory.observedAtMs - left.memory.observedAtMs || left.memory.id.localeCompare(right.memory.id);
+  }).map((candidate) => candidate.memory);
 }
-async function embedOne(embedder, text2) {
-  const normalized = normalizeContent(text2);
-  if (!normalized) {
-    throw new Error("Embedding text is required.");
+function createMemoryStore(db, context, options = {}) {
+  const runtimeContext = memoryRuntimeContextSchema.parse(context);
+  const parsedOptions = memoryStoreOptionsSchema.parse({ now: options.now });
+  const embedder = options.embedder;
+  const maxVectorDistance = options.maxVectorDistance;
+  const supersessionDecider = options.supersessionDecider;
+  const getNowMs = parsedOptions.now ?? Date.now;
+  async function archiveExpiredVisibleMemories(input, nowMs) {
+    input = archiveExpiredMemoriesInputSchema.parse(input ?? {});
+    return await archiveExpiredMemoryBatch({
+      db,
+      limit: input.limit,
+      nowMs,
+      scopes: deriveVisibleMemoryScopes(runtimeContext)
+    });
   }
-  const result = embeddingResultSchema.parse(
-    await embedder.embedTexts({ texts: [normalized] })
-  );
-  if (result.vectors.length !== 1) {
-    throw new Error("Embedding provider returned an unexpected vector count.");
+  async function reuseDuplicateMemory(args) {
+    await rememberDuplicateIdempotency({
+      ...args,
+      db,
+      runtimeContext
+    });
+    await storeEmbedding({
+      content: args.duplicate.content,
+      db,
+      embedder,
+      memoryId: args.duplicate.id,
+      nowMs: args.nowMs
+    });
+    return { created: false, memory: args.duplicate };
   }
-  return {
-    model: result.model,
-    provider: result.provider,
-    vector: result.vectors[0]
-  };
-}
-async function storeEmbedding(args) {
-  if (!args.embedder && !args.embedding) {
-    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;
+  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.");
     }
-  } catch {
-    return;
-  }
-  let embedding;
-  if (args.embedding) {
-    embedding = args.embedding;
-  } else {
-    const embedder = args.embedder;
-    if (!embedder) {
-      return;
+    await archiveExpiredMemoryBatch({
+      db,
+      nowMs,
+      scopes: [scope]
+    });
+    await archiveExpiredMemoryBatch({
+      db,
+      idempotencyKey: input.idempotencyKey,
+      limit: 1,
+      nowMs,
+      scopes: [scope]
+    });
+    if (input.idempotencyKey !== void 0) {
+      const idempotent2 = await findByIdempotencyKey({
+        db,
+        idempotencyKey: input.idempotencyKey,
+        nowMs,
+        scope
+      });
+      if (idempotent2) {
+        await storeEmbedding({
+          content: idempotent2.content,
+          db,
+          embedder,
+          memoryId: idempotent2.id,
+          nowMs
+        });
+        return { created: false, memory: idempotent2 };
+      }
     }
-    try {
-      embedding = await embedOne(embedder, args.content);
-    } catch {
-      return;
+    const exactDuplicate = await findExactDuplicateMemory({
+      content,
+      db,
+      kind: input.kind,
+      nowMs,
+      scope,
+      subject
+    });
+    if (exactDuplicate) {
+      return await reuseDuplicateMemory({
+        content,
+        duplicate: exactDuplicate,
+        idempotencyKey: input.idempotencyKey,
+        nowMs,
+        scope,
+        subject
+      });
     }
-  }
-  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;
-  }
-}
-function activeScopedSubjectPredicate(args) {
-  const predicate = and2(
-    eq3(juniorMemoryMemories.scope, args.scope.scope),
-    eq3(juniorMemoryMemories.scopeKey, args.scope.scopeKey),
-    eq3(juniorMemoryMemories.kind, args.kind),
-    eq3(juniorMemoryMemories.subjectType, args.subject.subjectType),
-    args.subject.subjectKey === void 0 ? isNull2(juniorMemoryMemories.subjectKey) : eq3(juniorMemoryMemories.subjectKey, args.subject.subjectKey),
-    isNull2(juniorMemoryMemories.archivedAtMs),
-    isNull2(juniorMemoryMemories.supersededAtMs),
-    isNull2(juniorMemoryMemories.supersededById),
-    or2(
-      isNull2(juniorMemoryMemories.expiresAtMs),
-      gt2(juniorMemoryMemories.expiresAtMs, args.nowMs)
-    )
-  );
-  if (!predicate) {
-    throw new Error("Memory duplicate predicate is empty.");
-  }
-  return predicate;
-}
-async function findExactDuplicateMemory(args) {
-  const rows = await args.db.select().from(juniorMemoryMemories).where(
-    and2(
-      activeScopedSubjectPredicate(args),
-      eq3(juniorMemoryMemories.content, args.content)
-    )
-  ).orderBy(
-    desc2(juniorMemoryMemories.createdAtMs),
-    asc(juniorMemoryMemories.id)
-  ).limit(1);
-  return rows[0] ? parseMemoryRow(rows[0]) : void 0;
-}
-async function findVectorDuplicateMemory(args) {
-  const distance = cosineDistance(
-    juniorMemoryEmbeddings.embedding,
-    args.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(
-      activeScopedSubjectPredicate(args),
-      eq3(juniorMemoryEmbeddings.provider, args.embedding.provider),
-      eq3(juniorMemoryEmbeddings.model, args.embedding.model),
-      eq3(juniorMemoryEmbeddings.dimensions, MEMORY_EMBEDDING_DIMENSIONS),
-      eq3(juniorMemoryEmbeddings.metric, EMBEDDING_METRIC),
-      lte(distance, HIGH_CONFIDENCE_DUPLICATE_DISTANCE)
-    )
-  ).orderBy(
-    distance,
-    desc2(juniorMemoryMemories.createdAtMs),
-    asc(juniorMemoryMemories.id)
-  ).limit(1);
-  const row = rows[0];
-  if (!row || hashEmbeddedContent(row.memory.content) !== row.contentHash) {
-    return void 0;
-  }
-  return parseMemoryRow(row.memory);
-}
-async function rememberDuplicateIdempotency(args) {
-  if (args.idempotencyKey === void 0) {
-    return;
-  }
-  await args.db.insert(juniorMemoryMemories).values({
-    content: args.content,
-    createdAtMs: args.nowMs,
-    expiresAtMs: args.duplicate.expiresAtMs,
-    id: idempotencyAliasId({
-      idempotencyKey: args.idempotencyKey,
-      scope: args.scope,
-      targetId: args.duplicate.id
-    }),
-    idempotencyKey: args.idempotencyKey,
-    observedAtMs: args.nowMs,
-    scope: args.scope.scope,
-    scopeKey: args.scope.scopeKey,
-    sourceKey: sourceKey(args.runtimeContext),
-    sourcePlatform: args.runtimeContext.source.platform,
-    subjectKey: args.subject.subjectKey,
-    subjectType: args.subject.subjectType,
-    supersededAtMs: args.nowMs,
-    supersededById: args.duplicate.id,
-    kind: args.duplicate.kind
-  }).onConflictDoNothing();
-}
-async function listSupersessionCandidates(args) {
-  const predicate = activeScopedSubjectPredicate(args);
-  const terms = searchTerms(args.content).filter(
-    (term) => !SUPERSESSION_STOP_TERMS.has(term)
-  );
-  const lexicalRows = terms.length > 0 ? await args.db.select().from(juniorMemoryMemories).where(
-    and2(
-      predicate,
-      or2(
-        ...terms.map(
-          (term) => ilike2(juniorMemoryMemories.content, `%${term}%`)
-        )
-      )
-    )
-  ) : [];
-  const lexicalCandidates = lexicalRows.map(parseMemoryRow).map((memory) => ({
-    memory,
-    score: searchScore(memory, terms)
-  })).filter((candidate) => candidate.score > 1).sort(
-    (left, right) => right.score - left.score || right.memory.createdAtMs - left.memory.createdAtMs || left.memory.id.localeCompare(right.memory.id)
-  ).map((candidate) => candidate.memory);
-  const vectorCandidates = args.embedding ? await listVectorSupersessionCandidates({
-    db: args.db,
-    embedding: args.embedding,
-    kind: args.kind,
-    nowMs: args.nowMs,
-    scope: args.scope,
-    subject: args.subject
-  }) : [];
-  const byId = /* @__PURE__ */ new Map();
-  for (const memory of [...lexicalCandidates, ...vectorCandidates]) {
-    if (byId.size >= SUPERSESSION_CANDIDATE_LIMIT) {
-      break;
+    let candidateEmbedding;
+    if (embedder) {
+      try {
+        candidateEmbedding = await embedOne(embedder, content);
+      } catch {
+        candidateEmbedding = void 0;
+      }
     }
-    byId.set(memory.id, memory);
-  }
-  return [...byId.values()];
-}
-async function listVectorSupersessionCandidates(args) {
-  const distance = cosineDistance(
-    juniorMemoryEmbeddings.embedding,
-    args.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(
-      activeScopedSubjectPredicate(args),
-      eq3(juniorMemoryEmbeddings.provider, args.embedding.provider),
-      eq3(juniorMemoryEmbeddings.model, args.embedding.model),
-      eq3(juniorMemoryEmbeddings.dimensions, MEMORY_EMBEDDING_DIMENSIONS),
-      eq3(juniorMemoryEmbeddings.metric, EMBEDDING_METRIC)
-    )
-  ).orderBy(
-    distance,
-    desc2(juniorMemoryMemories.createdAtMs),
-    asc(juniorMemoryMemories.id)
-  ).limit(SUPERSESSION_CANDIDATE_LIMIT);
-  return rows.flatMap((row) => {
-    if (hashEmbeddedContent(row.memory.content) !== row.contentHash) {
-      return [];
+    const vectorDuplicate = candidateEmbedding ? await findVectorDuplicateMemory({
+      db,
+      embedding: candidateEmbedding,
+      kind: input.kind,
+      nowMs,
+      scope,
+      subject
+    }) : void 0;
+    if (vectorDuplicate) {
+      return await reuseDuplicateMemory({
+        content,
+        duplicate: vectorDuplicate,
+        idempotencyKey: input.idempotencyKey,
+        nowMs,
+        scope,
+        subject
+      });
     }
-    return [parseMemoryRow(row.memory)];
-  });
-}
-async function decideSupersededIds(args) {
-  if (args.kind !== "preference" || !args.decider || args.candidates.length === 0) {
-    return [];
-  }
-  const existingMemories = args.candidates.map((memory) => ({
-    content: memory.content,
-    id: memory.id
-  }));
-  const candidateIds = new Set(args.candidates.map((memory) => memory.id));
-  try {
-    const decision = await args.decider.adjudicateSupersession({
-      candidate: {
-        content: args.content,
-        kind: "preference"
-      },
-      existingMemories,
-      runtimeContext: args.runtimeContext
-    });
-    if (decision.decision !== "supersedes_old") {
-      return [];
-    }
-    return decision.supersededIds.filter((id) => candidateIds.has(id));
-  } 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((row) => ({
-    memory: parseMemoryRow(row),
-    score: 0,
-    sourceKey: row.sourceKey
-  }));
-}
-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 [];
-    }
-    if (args.maxDistance !== void 0 && distanceValue > args.maxDistance) {
-      return [];
-    }
-    return [
-      {
-        memory: parseMemoryRow(row.memory),
-        score: 1 / (1 + Math.max(0, distanceValue)),
-        sourceKey: row.memory.sourceKey
-      }
-    ];
-  });
-}
-function sourceBoost(candidate, currentChannelPrefix) {
-  if (!currentChannelPrefix) {
-    return 0;
-  }
-  return candidate.sourceKey.startsWith(currentChannelPrefix) ? SOURCE_CHANNEL_BOOST : 0;
-}
-function observedAgeBoost(memory, nowMs) {
-  const ageMs = Math.max(0, nowMs - memory.observedAtMs);
-  if (ageMs <= 7 * ONE_DAY_MS) {
-    return 0.15;
-  }
-  if (ageMs <= 30 * ONE_DAY_MS) {
-    return 0.1;
-  }
-  if (ageMs <= 90 * ONE_DAY_MS) {
-    return 0.05;
-  }
-  return 0;
-}
-function mergeSearchCandidates(candidates, nowMs, currentChannelKey) {
-  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,
-      sourceKey: candidate.sourceKey
-    });
-  }
-  return [...byId.values()].sort((left, right) => {
-    const scoreDelta = right.score - left.score;
-    if (Math.abs(scoreDelta) > RELEVANCE_NEAR_TIE_DELTA) {
-      return scoreDelta;
-    }
-    const sourceDelta = sourceBoost(right, currentChannelKey) - sourceBoost(left, currentChannelKey);
-    if (sourceDelta !== 0) {
-      return sourceDelta;
-    }
-    return observedAgeBoost(right.memory, nowMs) - observedAgeBoost(left.memory, nowMs) || right.memory.observedAtMs - left.memory.observedAtMs || 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 maxVectorDistance = options.maxVectorDistance;
-  const supersessionDecider = options.supersessionDecider;
-  const getNowMs = parsedOptions.now ?? Date.now;
-  async function archiveExpiredVisibleMemories(input, nowMs) {
-    input = archiveExpiredMemoriesInputSchema.parse(input ?? {});
-    return await archiveExpiredMemoryBatch({
-      db,
-      limit: input.limit,
-      nowMs,
-      scopes: deriveVisibleMemoryScopes(runtimeContext)
-    });
-  }
-  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.");
-    }
-    await archiveExpiredMemoryBatch({
-      db,
-      nowMs,
-      scopes: [scope]
-    });
-    await archiveExpiredMemoryBatch({
-      db,
-      idempotencyKey: input.idempotencyKey,
-      limit: 1,
-      nowMs,
-      scopes: [scope]
-    });
-    if (input.idempotencyKey !== void 0) {
-      const idempotent2 = await findByIdempotencyKey({
-        db,
-        idempotencyKey: input.idempotencyKey,
-        nowMs,
-        scope
-      });
-      if (idempotent2) {
-        await storeEmbedding({
-          content: idempotent2.content,
-          db,
-          embedder,
-          memoryId: idempotent2.id,
-          nowMs
-        });
-        return { created: false, memory: idempotent2 };
-      }
-    }
-    const exactDuplicate = await findExactDuplicateMemory({
-      content,
-      db,
-      kind: input.kind,
-      nowMs,
-      scope,
-      subject
-    });
-    if (exactDuplicate) {
-      await rememberDuplicateIdempotency({
-        content,
-        db,
-        duplicate: exactDuplicate,
-        idempotencyKey: input.idempotencyKey,
-        nowMs,
-        runtimeContext,
-        scope,
-        subject
-      });
-      await storeEmbedding({
-        content: exactDuplicate.content,
-        db,
-        embedder,
-        memoryId: exactDuplicate.id,
-        nowMs
-      });
-      return { created: false, memory: exactDuplicate };
-    }
-    let candidateEmbedding;
-    if (embedder) {
-      try {
-        candidateEmbedding = await embedOne(embedder, content);
-      } catch {
-        candidateEmbedding = void 0;
-      }
-    }
-    const vectorDuplicate = candidateEmbedding ? await findVectorDuplicateMemory({
-      db,
-      embedding: candidateEmbedding,
-      kind: input.kind,
-      nowMs,
-      scope,
-      subject
-    }) : void 0;
-    if (vectorDuplicate) {
-      await rememberDuplicateIdempotency({
-        content,
-        db,
-        duplicate: vectorDuplicate,
-        idempotencyKey: input.idempotencyKey,
-        nowMs,
-        runtimeContext,
-        scope,
-        subject
-      });
-      await storeEmbedding({
-        content: vectorDuplicate.content,
-        db,
-        embedder,
-        memoryId: vectorDuplicate.id,
-        nowMs
-      });
-      return { created: false, memory: vectorDuplicate };
-    }
-    let supersededIds = [];
-    if (scopeKind === "personal" && input.kind === "preference" && supersessionDecider && (input.expiresAtMs === void 0 || input.expiresAtMs > nowMs)) {
-      const supersessionCandidates = await listSupersessionCandidates({
-        content,
-        db,
-        ...candidateEmbedding ? { embedding: candidateEmbedding } : {},
-        kind: input.kind,
-        nowMs,
-        scope,
-        subject
-      });
-      supersededIds = await decideSupersededIds({
-        candidates: supersessionCandidates,
-        content,
-        decider: supersessionDecider,
-        kind: input.kind,
-        runtimeContext
-      });
+    let supersededIds = [];
+    if (scopeKind === "personal" && input.kind === "preference" && supersessionDecider && (input.expiresAtMs === void 0 || input.expiresAtMs > nowMs)) {
+      const preferenceCandidates = await listPreferenceAdjudicationCandidates({
+        db,
+        ...candidateEmbedding ? { embedding: candidateEmbedding } : {},
+        nowMs,
+        scope,
+        subject
+      });
+      const adjudication = await adjudicatePreferenceCandidate({
+        candidates: preferenceCandidates,
+        content,
+        decider: supersessionDecider,
+        runtimeContext
+      });
+      if (adjudication.decision === "duplicate") {
+        return await reuseDuplicateMemory({
+          content,
+          duplicate: adjudication.memory,
+          idempotencyKey: input.idempotencyKey,
+          nowMs,
+          scope,
+          subject
+        });
+      }
+      if (adjudication.decision === "supersede") {
+        supersededIds = adjudication.ids;
+      }
     }
     const id = randomUUID();
     const rows = await db.transaction(async (tx) => {
@@ -1675,7 +1123,7 @@ function createMemoryStore(db, context, options = {}) {
         supersededAtMs: nowMs,
         supersededById: insertedMemory.id
       }).where(
-        and2(
+        and(
           inArray(juniorMemoryMemories.id, supersededIds),
           activeScopedSubjectPredicate({
             kind: input.kind,
@@ -1703,122 +1151,676 @@ function createMemoryStore(db, context, options = {}) {
       });
       return { created: true, memory };
     }
-    const idempotent = await findByIdempotencyKey({
-      db,
-      idempotencyKey: input.idempotencyKey,
-      nowMs,
-      scope
+    const idempotent = await findByIdempotencyKey({
+      db,
+      idempotencyKey: input.idempotencyKey,
+      nowMs,
+      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 archiveExpiredMemories(input) {
+      return await archiveExpiredVisibleMemories(input, getNowMs());
+    },
+    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);
+      await archiveExpiredMemoryBatch({
+        db,
+        nowMs,
+        scopes
+      });
+      return await listVisibleMemories({
+        db,
+        limit: input.limit,
+        nowMs,
+        scopes
+      });
+    },
+    async searchMemories(input) {
+      input = searchMemoriesInputSchema.parse(input);
+      const nowMs = getNowMs();
+      const scopes = deriveVisibleMemoryScopes(runtimeContext);
+      await archiveExpiredMemoryBatch({
+        db,
+        nowMs,
+        scopes
+      });
+      const limit = boundedLimit(input.limit, DEFAULT_SEARCH_LIMIT);
+      const vectorCandidates = await searchVisibleVectorMemories({
+        db,
+        embedder,
+        limit: limit * VECTOR_SEARCH_OVERFETCH,
+        ...maxVectorDistance !== void 0 ? { maxDistance: maxVectorDistance } : {},
+        nowMs,
+        query: input.query,
+        scopes
+      });
+      const candidates = await searchVisibleMemories({
+        db,
+        nowMs,
+        query: input.query,
+        scopes
+      });
+      const terms = searchTerms(input.query);
+      const lexicalCandidates = candidates.map((candidate) => ({
+        ...candidate,
+        score: searchScore(candidate.memory, terms)
+      })).filter((item) => item.score > 0);
+      return mergeSearchCandidates(
+        [...vectorCandidates, ...lexicalCandidates],
+        nowMs,
+        sourceChannelPrefix(runtimeContext)
+      ).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(
+        and(
+          predicate,
+          or(
+            eq(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(eq(juniorMemoryMemories.id, memory.id)).returning();
+      await db.delete(juniorMemoryEmbeddings).where(eq(juniorMemoryEmbeddings.memoryId, memory.id));
+      return parseMemoryRow(updated[0]);
+    }
+  };
+}
+
+// src/agent.ts
+var memoryKindSchema = z3.enum(MEMORY_KINDS);
+var memoryRejectReasonSchema = z3.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 = z3.object({
+  content: z3.string().min(1),
+  expiresAtMs: z3.number().finite().optional(),
+  runtimeContext: memoryRuntimeContextSchema,
+  sourceContext: z3.object({
+    currentUserText: z3.string().min(1).optional()
+  }).strict().optional()
+}).strict();
+var transcriptProvenanceSchema = z3.object({
+  authority: z3.enum(["instruction", "context"]),
+  actor: actorSchema.optional()
+}).strict();
+var evidenceMessageIndicesSchema = z3.array(z3.number().int().nonnegative()).min(1).max(10).describe("Indices from <run-transcript> that directly support this memory.");
+var extractSessionRequestSchema = z3.object({
+  existingMemories: z3.array(
+    z3.object({
+      content: z3.string().min(1)
+    }).strict()
+  ).max(10).default([]),
+  actors: z3.array(actorSchema),
+  runtimeContext: memoryRuntimeContextSchema,
+  transcript: z3.array(
+    z3.discriminatedUnion("type", [
+      z3.object({
+        type: z3.literal("message"),
+        role: z3.enum(["user", "assistant"]),
+        text: z3.string().min(1),
+        provenance: transcriptProvenanceSchema.optional(),
+        isRunActor: z3.boolean().optional()
+      }).strict(),
+      z3.object({
+        type: z3.literal("toolResult"),
+        toolName: z3.string().min(1),
+        isError: z3.boolean(),
+        text: z3.string().min(1)
+      }).strict()
+    ])
+  ).min(1)
+}).strict();
+var expiresAtMsSchema = z3.number().finite().nullable().describe(
+  "Expiration timestamp when the fact should expire, otherwise null."
+);
+var memoryReviewDecisionSchema = z3.discriminatedUnion("decision", [
+  z3.object({
+    decision: z3.literal("store"),
+    kind: memoryKindSchema,
+    content: z3.string().min(1),
+    expiresAtMs: z3.number().finite().optional()
+  }).strict(),
+  z3.object({
+    decision: z3.literal("reject"),
+    reason: memoryRejectReasonSchema
+  }).strict()
+]);
+var memoryReviewResponseSchema = z3.discriminatedUnion("decision", [
+  z3.object({
+    decision: z3.literal("store"),
+    kind: memoryKindSchema.describe(
+      "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: z3.string().min(1).describe(
+      "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(),
+  z3.object({
+    decision: z3.literal("reject"),
+    reason: memoryRejectReasonSchema
+  }).strict()
+]);
+var extractedMemorySchema = z3.object({
+  kind: memoryKindSchema.describe(
+    "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: z3.string().min(1).describe(
+    "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,
+  evidenceMessageIndices: evidenceMessageIndicesSchema
+}).strict();
+var extractedMemoryResultSchema = z3.object({
+  content: z3.string().min(1),
+  expiresAtMs: expiresAtMsSchema,
+  kind: memoryKindSchema,
+  evidenceMessageIndices: evidenceMessageIndicesSchema
+}).strict();
+var extractMemoriesResponseSchema = z3.object({
+  memories: z3.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 MEMORY_PREFERENCE_ADJUDICATION_SYSTEM = [
+  "You are Junior's memory preference adjudication agent.",
+  "Classify how one new actor preference relates to existing active actor preferences.",
+  "Return duplicate when the same durable preference is merely phrased differently.",
+  "Return supersedes_old only for an obvious changed value in the same mutable preference slot.",
+  "Return distinct for additive preferences or different topics, and uncertain when the relationship is unclear."
+].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 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 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 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 = [
+    `- 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())}`
+  ];
+  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 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 actor preference. Direct answers to user inquiries qualify only when they are durable beyond this run. Stored as conversation memory.",
+    "</memory-kinds>"
+  );
+  return lines.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 knowledge.",
+    "- 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 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 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.",
+    "- If unsure, reject.",
+    "</rules>",
+    "</memory-review-input>"
+  ].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>",
+    ...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");
+      }
+      const authority = entry.provenance?.authority ?? "context";
+      const isRunActor = entry.isRunActor === true;
+      const actor = transcriptActorLabel(entry.provenance?.actor);
+      return [
+        `<message index="${index2}" role="${entry.role}" authority="${authority}" is_run_actor="${isRunActor ? "true" : "false"}" actor="${escapeXml(actor)}">`,
+        escapeXml(entry.text),
+        "</message>"
+      ].join("\n");
+    }),
+    "</run-transcript>"
+  ].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.",
+    "",
+    runtimeDescription({
+      runtimeContext: request.runtimeContext
+    }),
+    "",
+    existingMemoriesContext(request),
+    "",
+    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.",
+    "- 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=knowledge for shared team, project, channel, runbook, or operational facts.",
+    ...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.",
+    "- 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 preferenceAdjudicationPrompt(request) {
+  return [
+    "<memory-preference-adjudication-input>",
+    "Classify the candidate preference against the related active preferences.",
+    "",
+    runtimeDescription({
+      runtimeContext: request.runtimeContext
+    }),
+    "",
+    "<candidate>",
+    escapeXml(JSON.stringify(request.candidate)),
+    "</candidate>",
+    "",
+    "<existing-memories>",
+    escapeXml(JSON.stringify(request.existingMemories)),
+    "</existing-memories>",
+    "",
+    "<rules>",
+    "- Return duplicate when the candidate and one existing memory express the same durable preference or value with different wording.",
+    "- Return supersedes_old only when the candidate and old memory describe the same mutable preference slot and the candidate is the newer value.",
+    "- Examples of same mutable slot: preferred programming language, preferred review style, preferred notification cadence, preferred tool for a task.",
+    "- Return distinct when the candidate is an additional preference or belongs to a different task or topic.",
+    "- Return uncertain when broader or narrower wording makes equivalence or replacement unclear.",
+    "- Do not supersede memories from different topics even if they are both preferences.",
+    "- duplicateId and supersededIds may contain only ids from existing-memories.",
+    "- If unsure, return uncertain.",
+    "</rules>",
+    "</memory-preference-adjudication-input>"
+  ].join("\n");
+}
+function createMemoryAgent(model) {
+  return {
+    async adjudicateSupersession(rawRequest) {
+      const request = memorySupersessionInputSchema.parse(rawRequest);
+      const result = await model.completeObject({
+        schema: memorySupersessionDecisionSchema,
+        system: MEMORY_PREFERENCE_ADJUDICATION_SYSTEM,
+        prompt: preferenceAdjudicationPrompt(request),
+        maxTokens: 400
+      });
+      return memorySupersessionDecisionSchema.parse(result.object);
+    },
+    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",
+      kind: response.kind,
+      content: response.canonicalFact,
+      ...response.expiresAtMs !== null ? { expiresAtMs: response.expiresAtMs } : {}
     });
-    if (!idempotent) {
-      throw new Error("Memory idempotency conflict did not resolve.");
+  }
+  return parseMemoryReview({
+    decision: "reject",
+    reason: response.reason
+  });
+}
+function extractedMemoriesFromResponse(response) {
+  const toMemory = (memory) => parseExtractedMemory({
+    content: memory.canonicalFact,
+    expiresAtMs: memory.expiresAtMs,
+    kind: memory.kind,
+    evidenceMessageIndices: memory.evidenceMessageIndices
+  });
+  return response.memories.map(toMemory);
+}
+function parseExtractedMemory(memory) {
+  return extractedMemoryResultSchema.parse(memory);
+}
+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 as and2, desc as desc2, eq as eq2, gt as gt2, ilike as ilike2, isNull as isNull2, or as or2 } from "drizzle-orm";
+
+// 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}`] : [],
+    `kind=${row.kind}`,
+    `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 = or2(
+    isNull2(juniorMemoryMemories.expiresAtMs),
+    gt2(juniorMemoryMemories.expiresAtMs, nowMs)
+  );
+  const predicates = [
+    eq2(juniorMemoryMemories.scope, options.scope),
+    eq2(juniorMemoryMemories.scopeKey, options.scopeKey),
+    isNull2(juniorMemoryMemories.archivedAtMs),
+    isNull2(juniorMemoryMemories.supersededAtMs),
+    isNull2(juniorMemoryMemories.supersededById)
+  ];
+  if (activeExpirationPredicate) {
+    predicates.push(activeExpirationPredicate);
+  }
+  if (terms.length > 0) {
+    const termPredicate = or2(
+      ...terms.map((term) => ilike2(juniorMemoryMemories.content, `%${term}%`))
+    );
+    if (termPredicate) {
+      predicates.push(termPredicate);
     }
-    await storeEmbedding({
-      content: idempotent.content,
-      db,
-      embedder,
-      memoryId: idempotent.id,
-      nowMs
-    });
-    return { created: false, memory: idempotent };
   }
+  const rows = await db.select().from(juniorMemoryMemories).where(and2(...predicates)).orderBy(desc2(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 eq3 } from "drizzle-orm";
+async function runShow(ctx, id) {
+  const db = ctx.db;
+  const rows = await db.select().from(juniorMemoryMemories).where(eq3(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 {
-    async archiveExpiredMemories(input) {
-      return await archiveExpiredVisibleMemories(input, getNowMs());
-    },
-    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);
-      await archiveExpiredMemoryBatch({
-        db,
-        nowMs,
-        scopes
-      });
-      return await listVisibleMemories({
-        db,
-        limit: input.limit,
-        nowMs,
-        scopes
-      });
-    },
-    async searchMemories(input) {
-      input = searchMemoriesInputSchema.parse(input);
-      const nowMs = getNowMs();
-      const scopes = deriveVisibleMemoryScopes(runtimeContext);
-      await archiveExpiredMemoryBatch({
-        db,
-        nowMs,
-        scopes
-      });
-      const limit = boundedLimit(input.limit, DEFAULT_SEARCH_LIMIT);
-      const vectorCandidates = await searchVisibleVectorMemories({
-        db,
-        embedder,
-        limit: limit * VECTOR_SEARCH_OVERFETCH,
-        ...maxVectorDistance !== void 0 ? { maxDistance: maxVectorDistance } : {},
-        nowMs,
-        query: input.query,
-        scopes
-      });
-      const candidates = await searchVisibleMemories({
-        db,
-        nowMs,
-        query: input.query,
-        scopes
-      });
-      const terms = searchTerms(input.query);
-      const lexicalCandidates = candidates.map((candidate) => ({
-        ...candidate,
-        score: searchScore(candidate.memory, terms)
-      })).filter((item) => item.score > 0);
-      return mergeSearchCandidates(
-        [...vectorCandidates, ...lexicalCandidates],
-        nowMs,
-        sourceChannelPrefix(runtimeContext)
-      ).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]);
+    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 {
+  definePluginTool,
+  getSourceKey,
+  PluginToolInputError,
+  pluginToolResultSchema
+} from "@sentry/junior-plugin-api";
+import { z as z4 } from "zod";
 var MAX_TOOL_CONTENT_CHARS = 4e3;
 var DEFAULT_RESULT_LIMIT = 20;
 var DEFAULT_SEARCH_LIMIT2 = 10;