@anuma/sdk 2.0.1 → 2.2.0

package/dist/expo/index.cjs

@@ -3904,14 +3904,19 @@ async function upsertEntitiesOp(ctx, entities) {
     return out;
   });
 }
-async function linkMemoryEntitiesOp(ctx, memoryId, entityInputs) {
+async function linkMemoryEntitiesOp(ctx, memoryId, entityInputs, options) {
   if (entityInputs.length === 0) return [];
   const normalized = entityInputs.map((e) => typeof e === "string" ? { name: e } : e);
   const byName = await upsertEntitiesOp(ctx, normalized);
   const entities = Array.from(byName.values());
   if (entities.length === 0) return [];
   const userId = ctx.userId;
+  let skipped = false;
   await ctx.database.write(async () => {
+    if (options?.unlessTopicsUserManaged && await autoLinkBlocked(ctx, memoryId)) {
+      skipped = true;
+      return;
+    }
     const existingLinks = await ctx.memoryEntityCollection.query(import_watermelondb8.Q.where("memory_id", memoryId)).fetch();
     const existingEntityIds = new Set(existingLinks.map((l) => String(l.entityId)));
     const toCreate = entities.filter((e) => !existingEntityIds.has(e.uniqueId));
@@ -3925,7 +3930,46 @@ async function linkMemoryEntitiesOp(ctx, memoryId, entityInputs) {
     );
     await ctx.database.batch(...prepared);
   });
-  return entities;
+  return skipped ? [] : entities;
+}
+async function autoLinkBlocked(ctx, memoryId) {
+  try {
+    const rows = await ctx.database.get("memory_vault").query(import_watermelondb8.Q.where("id", memoryId)).fetch();
+    const row = rows[0];
+    return !row || !!row.isDeleted || !!row.topicsUserManaged;
+  } catch {
+    return true;
+  }
+}
+async function replaceMemoryEntitiesGuardedOp(ctx, memoryId, entityInputs) {
+  const normalized = entityInputs.map((e) => typeof e === "string" ? { name: e } : e);
+  const byName = await upsertEntitiesOp(ctx, normalized);
+  const entities = Array.from(byName.values());
+  const userId = ctx.userId;
+  let skipped = false;
+  await ctx.database.write(async () => {
+    if (await autoLinkBlocked(ctx, memoryId)) {
+      skipped = true;
+      return;
+    }
+    const existingLinks = await ctx.memoryEntityCollection.query(import_watermelondb8.Q.where("memory_id", memoryId)).fetch();
+    const keep = new Set(entities.map((e) => e.uniqueId));
+    const existingEntityIds = new Set(existingLinks.map((l) => String(l.entityId)));
+    const toCreate = entities.filter((e) => !existingEntityIds.has(e.uniqueId));
+    const toDestroy = existingLinks.filter((l) => !keep.has(String(l.entityId)));
+    if (toCreate.length === 0 && toDestroy.length === 0) return;
+    await ctx.database.batch(
+      ...toCreate.map(
+        (e) => ctx.memoryEntityCollection.prepareCreate((record) => {
+          record._setRaw("memory_id", memoryId);
+          record._setRaw("entity_id", e.uniqueId);
+          if (userId !== void 0) record._setRaw("user_id", userId);
+        })
+      ),
+      ...toDestroy.map((l) => l.prepareDestroyPermanently())
+    );
+  });
+  return skipped ? null : entities;
 }
 async function unlinkMemoryEntitiesOp(ctx, memoryIds) {
   if (memoryIds.length === 0) return;
@@ -4061,6 +4105,7 @@ function vaultMemoryToStoredRaw(memory) {
     eventTimeEnd: memory.eventTimeEnd ?? null,
     eventTimeKind: memory.eventTimeKind ?? null,
     topicsUserManaged: memory.topicsUserManaged ?? false,
+    topicsExtractedAt: memory.topicsExtractedAt ?? null,
     createdAt: memory.createdAt,
     updatedAt: memory.updatedAt,
     isDeleted: memory.isDeleted
@@ -4244,6 +4289,7 @@ function vaultMemoryRawToStoredRaw(raw) {
     eventTimeKind: raw.event_time_kind ?? null,
     // SQLite stores booleans as 0/1, LokiJS as true/false — coerce both.
     topicsUserManaged: raw.topics_user_managed === true || raw.topics_user_managed === 1,
+    topicsExtractedAt: raw.topics_extracted_at ?? null,
     createdAt: new Date(raw.created_at),
     updatedAt: new Date(raw.updated_at),
     isDeleted: raw.is_deleted === true || raw.is_deleted === 1
@@ -4386,6 +4432,87 @@ async function getUnfiledVaultMemoriesOp(ctx) {
     (record) => vaultMemoryToStored(record, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner)
   );
 }
+async function getMemoriesNeedingTopicExtractionOp(ctx, options) {
+  const entityCtx = ctx.entityCtx;
+  if (!entityCtx) {
+    throw new Error("getMemoriesNeedingTopicExtractionOp requires ctx.entityCtx");
+  }
+  const conditions = [
+    // Boolean optional column: null (legacy) and false both mean auto-managed.
+    // Q.notEq(true) is a NULL trap on SQLite (NULL <> TRUE is NULL) — enumerate.
+    import_watermelondb9.Q.or(import_watermelondb9.Q.where("topics_user_managed", null), import_watermelondb9.Q.where("topics_user_managed", false)),
+    ...baseVaultConditions(ctx),
+    import_watermelondb9.Q.sortBy("created_at", import_watermelondb9.Q.desc)
+  ];
+  const rows = await ctx.vaultMemoryCollection.query(...conditions).unsafeFetchRaw();
+  const stampedPending = [];
+  const unstamped = [];
+  for (const raw of rows) {
+    const stamp = raw.topics_extracted_at ?? null;
+    if (stamp !== null) {
+      if (raw.updated_at > stamp) stampedPending.push(raw);
+    } else {
+      unstamped.push(raw);
+    }
+  }
+  const linkedIds = /* @__PURE__ */ new Set();
+  const CHUNK = 500;
+  for (let i = 0; i < unstamped.length; i += CHUNK) {
+    const ids = unstamped.slice(i, i + CHUNK).map((r) => r.id);
+    const links = await entityCtx.memoryEntityCollection.query(import_watermelondb9.Q.where("memory_id", import_watermelondb9.Q.oneOf(ids))).unsafeFetchRaw();
+    for (const link of links) linkedIds.add(String(link.memory_id));
+  }
+  const linkedUnstampedAll = [];
+  const pendingRaw = [...stampedPending];
+  for (const raw of unstamped) {
+    if (linkedIds.has(raw.id)) {
+      linkedUnstampedAll.push(raw.id);
+    } else {
+      pendingRaw.push(raw);
+    }
+  }
+  const cap = options?.limit !== void 0 && options.limit > 0 ? options.limit : void 0;
+  const limitedPendingRaw = cap !== void 0 ? pendingRaw.slice(0, cap) : pendingRaw;
+  const linkedUnstamped = cap !== void 0 ? linkedUnstampedAll.slice(0, cap) : linkedUnstampedAll;
+  const pending = await mapInBatches(
+    limitedPendingRaw,
+    (raw) => vaultMemoryRawToStored(raw, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner)
+  );
+  return { pending, linkedUnstamped };
+}
+async function stampTopicsExtractedAtOp(ctx, memoryIds, extractedAt) {
+  if (memoryIds.length === 0) return [];
+  const uniqueIds = Array.from(new Set(memoryIds));
+  const CHUNK = 500;
+  const stamped = [];
+  for (let i = 0; i < uniqueIds.length; i += CHUNK) {
+    const chunkIds = uniqueIds.slice(i, i + CHUNK);
+    await ctx.database.write(async () => {
+      const prepared = [];
+      for (const id of chunkIds) {
+        let record;
+        try {
+          record = await ctx.vaultMemoryCollection.find(id);
+        } catch {
+          continue;
+        }
+        if (record.isDeleted || !isOwnedByCtxUser(ctx, record) || record.topicsUserManaged) {
+          continue;
+        }
+        const originalUpdatedAt = record.updatedAt.getTime();
+        prepared.push(
+          record.prepareUpdate((r) => {
+            r._setRaw("topics_extracted_at", extractedAt);
+            r._setRaw("updated_at", originalUpdatedAt);
+          })
+        );
+        stamped.push(id);
+      }
+      if (prepared.length > 0) await ctx.database.batch(...prepared);
+    });
+  }
+  return stamped;
+}
 async function deleteAllVaultMemoriesForUserOp(ctx, userId) {
   if (ctx.userId !== void 0 && ctx.userId !== userId) return 0;
   const records = await ctx.vaultMemoryCollection.query(import_watermelondb9.Q.where("user_id", userId), import_watermelondb9.Q.where("is_deleted", false)).fetch();
@@ -6658,6 +6785,7 @@ __export(index_exports, {
   StoredVaultFolderModel: () => VaultFolder,
   StoredVaultMemoryModel: () => VaultMemory,
   StreamExpiredError: () => StreamExpiredError,
+  TOPIC_EXTRACTION_BATCH_SIZE: () => TOPIC_EXTRACTION_BATCH_SIZE,
   WalletPoller: () => WalletPoller,
   addConversationMemoriesOp: () => addConversationMemoriesOp,
   buildNotionAuthUrl: () => buildNotionAuthUrl,
@@ -6709,7 +6837,9 @@ __export(index_exports, {
   embedMessage: () => embedMessage,
   ensureDefaultFoldersOp: () => ensureDefaultFoldersOp,
   exchangeNotionCode: () => exchangeNotionCode,
+  extractAndLinkEntitiesForMemoriesOp: () => extractAndLinkEntitiesForMemoriesOp,
   extractAndRetain: () => extractAndRetain,
+  extractEntitiesForMemories: () => extractEntitiesForMemories,
   extractFacts: () => extractFacts,
   generateConversationId: () => generateConversationId,
   generateEmbedding: () => generateEmbedding,
@@ -6723,6 +6853,7 @@ __export(index_exports, {
   getConversationsByProjectLazyOp: () => getConversationsByProjectLazyOp,
   getConversationsLazyOp: () => getConversationsLazyOp,
   getLogger: () => getLogger,
+  getMemoriesNeedingTopicExtractionOp: () => getMemoriesNeedingTopicExtractionOp,
   getServerTools: () => getServerTools,
   getUnfiledVaultMemoriesOp: () => getUnfiledVaultMemoriesOp,
   getVaultFolderMemoryCountOp: () => getVaultFolderMemoryCountOp,
@@ -6749,6 +6880,7 @@ __export(index_exports, {
   searchVaultMemories: () => searchVaultMemories,
   setLogger: () => setLogger,
   shouldChunkMessage: () => shouldChunkMessage,
+  stampTopicsExtractedAtOp: () => stampTopicsExtractedAtOp,
   streamCancelPath: () => streamCancelPath,
   streamReplayPath: () => streamReplayPath,
   updateVaultFolderContextOp: () => updateVaultFolderContextOp,
@@ -12212,6 +12344,9 @@ __decorateClass([
 __decorateClass([
   (0, import_decorators3.field)("topics_user_managed")
 ], VaultMemory.prototype, "topicsUserManaged", 2);
+__decorateClass([
+  (0, import_decorators3.field)("topics_extracted_at")
+], VaultMemory.prototype, "topicsExtractedAt", 2);
 __decorateClass([
   import_decorators3.readonly,
   (0, import_decorators3.date)("created_at")
@@ -12783,7 +12918,7 @@ async function isMemoryTopicsUserManaged(ctx, memoryId) {
     return true;
   }
 }
-var DEFAULT_MODEL3 = "gpt-oss/gpt-oss-120b";
+var DEFAULT_EXTRACTION_MODEL = "gpt-oss/gpt-oss-120b";
 var DEFAULT_MIN_CONFIDENCE = 0.7;
 var MAX_CONTENT_LENGTH = 200;
 var MIN_CONTENT_LENGTH = 3;
@@ -12796,6 +12931,16 @@ var FACT_TYPES = [
   "constraint",
   "other"
 ];
+var ENTITY_KIND_GUIDELINES = `Choose the MOST SPECIFIC kind:
+    - person: a named individual ("Sara", "Dr. Lee")
+    - organization: a company, team, school, or group ("Google", "the Warriors", "Stanford")
+    - place: a geographic location or venue ("San Francisco", "Blue Bottle on Valencia")
+    - event: a dated or nameable occurrence ("Chicago Marathon", "the Japan trip", "their wedding")
+    - product: a named app, tool, brand, device, book, film, or other media title ("Linear", "iPhone", "Dune", "Ableton")
+    - thing: a concrete physical object that isn't a branded product ("road bike", "sourdough starter")
+    - concept: a topic, skill, field, language, or idea ("machine learning", "Spanish", "async communication")
+    - other: a named entity that genuinely fits none of the above \u2014 use sparingly
+  Prefer organization / product / event / place over the generic "thing"; fall back to "thing" or "other" only when no specific kind fits.`;
 var SYSTEM_PROMPT3 = `You extract durable user facts from conversations for a personal memory system.
 
 A "durable fact" is something the user shared about themselves that should still be true in future conversations. Examples that ARE durable:
@@ -12824,16 +12969,7 @@ For each durable fact, output:
 - type: one of identity | preference | relationship | plan | ongoing_context | constraint | other
 - confidence: 0.0-1.0; how sure you are this is durable AND true. Only include facts >= 0.7.
 - sourceMessageIds: which message IDs from the conversation contained the evidence
-- entities: named entities mentioned, each as an object { "name": string, "kind": one of "person" | "organization" | "place" | "event" | "product" | "thing" | "concept" | "other" }. Optional \u2014 include only NAMED entities, skip generic/common nouns. Choose the MOST SPECIFIC kind:
-    - person: a named individual ("Sara", "Dr. Lee")
-    - organization: a company, team, school, or group ("Google", "the Warriors", "Stanford")
-    - place: a geographic location or venue ("San Francisco", "Blue Bottle on Valencia")
-    - event: a dated or nameable occurrence ("Chicago Marathon", "the Japan trip", "their wedding")
-    - product: a named app, tool, brand, device, book, film, or other media title ("Linear", "iPhone", "Dune", "Ableton")
-    - thing: a concrete physical object that isn't a branded product ("road bike", "sourdough starter")
-    - concept: a topic, skill, field, language, or idea ("machine learning", "Spanish", "async communication")
-    - other: a named entity that genuinely fits none of the above \u2014 use sparingly
-  Prefer organization / product / event / place over the generic "thing"; fall back to "thing" or "other" only when no specific kind fits. Examples:
+- entities: named entities mentioned, each as an object { "name": string, "kind": one of "person" | "organization" | "place" | "event" | "product" | "thing" | "concept" | "other" }. Optional \u2014 include only NAMED entities, skip generic/common nouns. ${ENTITY_KIND_GUIDELINES} Examples:
     - "started a new job at Hollowpoint Labs and I'm learning Haskell for it" \u2192 entities: [{ "name": "Hollowpoint Labs", "kind": "organization" }, { "name": "Haskell", "kind": "concept" }]
     - "running the Berlin Half in May and I track workouts in Whoop" \u2192 entities: [{ "name": "Berlin Half", "kind": "event" }, { "name": "Whoop", "kind": "product" }]
 - eventTime: when the event in this fact occurs/occurred. Resolve relative phrases ("yesterday", "next week") against the current date given in the user message. Output one of:
@@ -12859,7 +12995,7 @@ async function extractFacts(messages, options) {
     ...options.apiKey !== void 0 && { apiKey: options.apiKey },
     ...options.getToken !== void 0 && { getToken: options.getToken },
     ...options.baseUrl !== void 0 && { baseUrl: options.baseUrl },
-    model: options.model ?? DEFAULT_MODEL3,
+    model: options.model ?? DEFAULT_EXTRACTION_MODEL,
     systemPrompt: SYSTEM_PROMPT3,
     userMessage: `Today's date is ${today}. Resolve any relative dates ("yesterday", "next week") against it.
 
@@ -12953,7 +13089,9 @@ async function extractAndRetain(messages, retainCtx, options) {
       if (options.entityCtx && candidate.entities.length > 0) {
         try {
           if (!await isMemoryTopicsUserManaged(options.entityCtx, result.memoryId)) {
-            await linkMemoryEntitiesOp(options.entityCtx, result.memoryId, candidate.entities);
+            await linkMemoryEntitiesOp(options.entityCtx, result.memoryId, candidate.entities, {
+              unlessTopicsUserManaged: true
+            });
           }
         } catch (err) {
           log.warn("[memory/extract] linkMemoryEntitiesOp failed", err);
@@ -13358,7 +13496,7 @@ init_logger();
 init_portalLlm();
 init_recall();
 var DEFAULT_BASE_URL2 = BASE_URL;
-var DEFAULT_MODEL4 = "anthropic/claude-sonnet-4-6";
+var DEFAULT_MODEL3 = "anthropic/claude-sonnet-4-6";
 var DEFAULT_MAX_TOKENS = 4096;
 var REQUEST_TIMEOUT_MS = 6e4;
 var DEFAULT_SYSTEM_PROMPT = `You are a personal assistant with access to the user's memory. Answer the user's question using the supplied memories as evidence.
@@ -13390,7 +13528,7 @@ async function reflect(query, ctx, options) {
   const evidence = recalled.memories.map((m, i) => `[${i + 1}] (id: ${m.id}, kind: ${m.kind})
 ${m.content}`).join("\n\n");
   const baseUrl = options.baseUrl ?? DEFAULT_BASE_URL2;
-  const model = options.llmModel ?? DEFAULT_MODEL4;
+  const model = options.llmModel ?? DEFAULT_MODEL3;
   const wantsStructured = !!options.responseSchema;
   const sendResponseFormat = wantsStructured && supportsResponseFormat(model, "json_schema");
   const basePrompt = options.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
@@ -13500,6 +13638,168 @@ function parseAnswer(body, base, parseSchema) {
   };
 }
 
+// src/lib/memory/topicExtract.ts
+init_operations2();
+init_operations3();
+init_logger();
+init_redactor();
+init_portalLlm();
+var TOPIC_EXTRACTION_BATCH_SIZE = 10;
+var MAX_CHARS_PER_MEMORY = 300;
+var MAX_VOCABULARY_NAMES = 100;
+var SYSTEM_PROMPT4 = `You assign topics to saved memories for a personal memory system.
+
+Each memory is a short statement about the user. For each memory, list the NAMED entities it mentions \u2014 these become the memory's topics, used to connect related memories in a knowledge graph.
+
+Include only NAMED entities, skip generic/common nouns. ${ENTITY_KIND_GUIDELINES}
+
+Output strict JSON: {"memories": [{"id": string, "entities": [{"name": string, "kind": string}]}]}
+- exactly one element per input memory, echoing its id verbatim
+- "entities" may be empty when a memory mentions no named entities \u2014 most short memories have 0-3
+No prose.`;
+async function extractEntitiesForMemories(memories, options) {
+  const out = /* @__PURE__ */ new Map();
+  if (memories.length === 0) return out;
+  const redactor = resolvePiiRedactor(options.piiRedaction);
+  const vocabulary = (options.existingEntityNames ?? []).filter((n) => n.trim().length > 0).slice(0, MAX_VOCABULARY_NAMES).map((n) => redactor ? redactor.redactText(n).text : n);
+  const vocabularyNote = vocabulary.length > 0 ? `The user's existing topics: ${vocabulary.join(", ")}.
+When a memory refers to one of these, reuse the EXACT existing name (same spelling and casing) instead of a variant.
+
+` : "";
+  for (let i = 0; i < memories.length; i += TOPIC_EXTRACTION_BATCH_SIZE) {
+    const batch = memories.slice(i, i + TOPIC_EXTRACTION_BATCH_SIZE);
+    const listing = batch.map((m) => {
+      const content = m.content.slice(0, MAX_CHARS_PER_MEMORY);
+      return `[${m.id}] ${redactor ? redactor.redactText(content).text : content}`;
+    }).join("\n");
+    const parsed = await callPortalJsonCompletion({
+      ...options.apiKey !== void 0 && { apiKey: options.apiKey },
+      ...options.getToken !== void 0 && { getToken: options.getToken },
+      ...options.baseUrl !== void 0 && { baseUrl: options.baseUrl },
+      model: options.model ?? DEFAULT_EXTRACTION_MODEL,
+      systemPrompt: SYSTEM_PROMPT4,
+      userMessage: `${vocabularyNote}Memories:
+${listing}
+
+List each memory's named entities.`,
+      tag: "memory/topics",
+      ...options.fetchFn && { fetchFn: options.fetchFn },
+      ...options.maxAttempts !== void 0 && { maxAttempts: options.maxAttempts },
+      ...options.timeoutMs !== void 0 && { timeoutMs: options.timeoutMs },
+      ...options.totalTimeoutMs !== void 0 && { totalTimeoutMs: options.totalTimeoutMs },
+      ...options.backoffMs && { backoffMs: options.backoffMs }
+    });
+    if (parsed === null) {
+      getLogger().warn(
+        `[memory/topics] batch of ${batch.length} failed after retries \u2014 will retry next sweep`
+      );
+      continue;
+    }
+    const validIds = new Set(batch.map((m) => m.id));
+    const byId = parseTopicResponse(parsed, validIds);
+    if (byId === null) {
+      getLogger().warn(
+        `[memory/topics] batch of ${batch.length} returned an unrecognized shape \u2014 will retry next sweep`
+      );
+      continue;
+    }
+    for (const m of batch) {
+      const entities = byId.get(m.id);
+      if (entities === void 0) {
+        continue;
+      }
+      out.set(m.id, redactor ? restoreEntities(entities, redactor) : entities);
+    }
+  }
+  return out;
+}
+function restoreEntities(entities, redactor) {
+  return entities.map((e) => ({ kind: e.kind, restored: redactor.restoreForStorage(e.name) })).filter((e) => !e.restored.unresolved).map(
+    (e) => e.kind !== void 0 ? { name: e.restored.text, kind: e.kind } : { name: e.restored.text }
+  );
+}
+function parseTopicResponse(parsed, validIds) {
+  if (typeof parsed !== "object" || parsed === null) return null;
+  const list = parsed.memories;
+  if (!Array.isArray(list)) return null;
+  const out = /* @__PURE__ */ new Map();
+  for (const raw of list) {
+    if (typeof raw !== "object" || raw === null) continue;
+    const obj = raw;
+    if (typeof obj.id !== "string" || !validIds.has(obj.id) || out.has(obj.id)) continue;
+    const entities = Array.isArray(obj.entities) ? parseEntities(obj.entities) : [];
+    out.set(obj.id, entities);
+  }
+  return out;
+}
+async function extractAndLinkEntitiesForMemoriesOp(ctx, memoryIds, options) {
+  const entityCtx = ctx.entityCtx;
+  if (!entityCtx) {
+    throw new Error("extractAndLinkEntitiesForMemoriesOp requires ctx.entityCtx");
+  }
+  const log = getLogger();
+  const extractedAt = options.now ?? Date.now();
+  const skippedIds = [];
+  const inputs = [];
+  for (const id of memoryIds) {
+    let record;
+    try {
+      record = await ctx.vaultMemoryCollection.find(id);
+    } catch {
+      skippedIds.push(id);
+      continue;
+    }
+    if (record.isDeleted || ctx.userId !== void 0 && record.userId !== ctx.userId || record.topicsUserManaged) {
+      skippedIds.push(id);
+      continue;
+    }
+    try {
+      const stored = await vaultMemoryToStored(
+        record,
+        ctx.walletAddress,
+        ctx.signMessage,
+        ctx.embeddedWalletSigner
+      );
+      inputs.push({ id, content: stored.content });
+    } catch (err) {
+      log.warn("[memory/topics] failed to load memory for extraction", err);
+      skippedIds.push(id);
+    }
+  }
+  const entitiesByMemory = await extractEntitiesForMemories(inputs, options);
+  const toStamp = [];
+  for (const input of inputs) {
+    const entities = entitiesByMemory.get(input.id);
+    if (entities === void 0) {
+      skippedIds.push(input.id);
+      continue;
+    }
+    try {
+      const linked = await replaceMemoryEntitiesGuardedOp(entityCtx, input.id, entities);
+      if (linked === null) {
+        skippedIds.push(input.id);
+        entitiesByMemory.delete(input.id);
+        continue;
+      }
+    } catch (err) {
+      log.warn("[memory/topics] replaceMemoryEntitiesGuardedOp failed", err);
+      skippedIds.push(input.id);
+      entitiesByMemory.delete(input.id);
+      continue;
+    }
+    toStamp.push(input.id);
+  }
+  const stampedIds = await stampTopicsExtractedAtOp(ctx, toStamp, extractedAt);
+  const stampedSet = new Set(stampedIds);
+  for (const id of toStamp) {
+    if (!stampedSet.has(id)) {
+      skippedIds.push(id);
+      entitiesByMemory.delete(id);
+    }
+  }
+  return { entitiesByMemory, stampedIds, skippedIds };
+}
+
 // src/lib/memoryEngine/index.ts
 init_chunking();
 init_embeddings();
@@ -16024,7 +16324,7 @@ __decorateClass([
 ], VaultFolder.prototype, "context", 2);
 
 // src/lib/db/schema.ts
-var SDK_SCHEMA_VERSION = 35;
+var SDK_SCHEMA_VERSION = 36;
 var sdkSchema = (0, import_watermelondb19.appSchema)({
   version: SDK_SCHEMA_VERSION,
   tables: [
@@ -16145,7 +16445,11 @@ var sdkSchema = (0, import_watermelondb19.appSchema)({
         // When true, the user has manually set this memory's topics (entity
         // links). Auto-extraction then leaves its links alone — the user owns
         // them. Null/false = topics are auto-derived (default).
-        { name: "topics_user_managed", type: "boolean", isOptional: true }
+        { name: "topics_user_managed", type: "boolean", isOptional: true },
+        // Unix ms of the last LLM topic-extraction pass over this memory's
+        // content. Null = never extracted standalone (legacy rows with entity
+        // links are grandfathered — see getMemoriesNeedingTopicExtractionOp).
+        { name: "topics_extracted_at", type: "number", isOptional: true }
       ]
     }),
     // Entity table — canonical names extracted from auto-extraction (W5).
@@ -16743,6 +17047,19 @@ var sdkMigrations = (0, import_migrations2.schemaMigrations)({
           ]
         })
       ]
+    },
+    // v35 -> v36: topics_extracted_at watermark on memory_vault. Existing rows
+    // keep it NULL — rows that already have entity links are grandfathered as
+    // extracted (no mass re-extraction on upgrade), rows without links are the
+    // backfill target. See getMemoriesNeedingTopicExtractionOp.
+    {
+      toVersion: 36,
+      steps: [
+        (0, import_migrations2.addColumns)({
+          table: "memory_vault",
+          columns: [{ name: "topics_extracted_at", type: "number", isOptional: true }]
+        })
+      ]
     }
   ]
 });
@@ -18105,6 +18422,7 @@ function createNotionTools(getAccessToken, requestNotionAccess) {
   StoredVaultFolderModel,
   StoredVaultMemoryModel,
   StreamExpiredError,
+  TOPIC_EXTRACTION_BATCH_SIZE,
   WalletPoller,
   addConversationMemoriesOp,
   buildNotionAuthUrl,
@@ -18156,7 +18474,9 @@ function createNotionTools(getAccessToken, requestNotionAccess) {
   embedMessage,
   ensureDefaultFoldersOp,
   exchangeNotionCode,
+  extractAndLinkEntitiesForMemoriesOp,
   extractAndRetain,
+  extractEntitiesForMemories,
   extractFacts,
   generateConversationId,
   generateEmbedding,
@@ -18170,6 +18490,7 @@ function createNotionTools(getAccessToken, requestNotionAccess) {
   getConversationsByProjectLazyOp,
   getConversationsLazyOp,
   getLogger,
+  getMemoriesNeedingTopicExtractionOp,
   getServerTools,
   getUnfiledVaultMemoriesOp,
   getVaultFolderMemoryCountOp,
@@ -18196,6 +18517,7 @@ function createNotionTools(getAccessToken, requestNotionAccess) {
   searchVaultMemories,
   setLogger,
   shouldChunkMessage,
+  stampTopicsExtractedAtOp,
   streamCancelPath,
   streamReplayPath,
   updateVaultFolderContextOp,