@anuma/sdk 6.39.3 → 6.41.0

package/dist/expo/index.mjs

@@ -9333,6 +9333,62 @@ async function clearConversationMemoriesOp(ctx, conversationId) {
   });
 }
 
+// src/lib/db/entities/types.ts
+var ENTITY_KINDS = [
+  "person",
+  "organization",
+  "place",
+  "event",
+  "product",
+  "thing",
+  "concept",
+  "other"
+];
+function normalizeEntityName(name) {
+  return name.trim().toLowerCase();
+}
+var TOPIC_SALIENCE_WEIGHTS = { primary: 1, secondary: 0.6, mention: 0.3 };
+function topicWeight(topic) {
+  return topic.source === "user" ? 1 : topic.weight ?? 1;
+}
+function primaryTopic(topics) {
+  let best = null;
+  for (const topic of topics ?? []) {
+    if (best === null || topicWeight(topic) > topicWeight(best)) best = topic;
+  }
+  return best;
+}
+function parseTopicWeight(value) {
+  return typeof value === "number" && value > 0 && value <= 1 ? value : void 0;
+}
+function serializeTopics(topics) {
+  return JSON.stringify(topics);
+}
+function parseTopics(value) {
+  if (typeof value !== "string" || value.length === 0) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch {
+    return null;
+  }
+  if (!Array.isArray(parsed)) return null;
+  const out = [];
+  for (const raw of parsed) {
+    if (typeof raw !== "object" || raw === null) continue;
+    const { name, kind, source, weight } = raw;
+    if (typeof name !== "string" || name.trim().length === 0) continue;
+    const parsedWeight = parseTopicWeight(weight);
+    out.push({
+      name,
+      ...typeof kind === "string" && kind.length > 0 ? { kind } : {},
+      source: source === "user" ? "user" : "auto",
+      ...parsedWeight !== void 0 ? { weight: parsedWeight } : {}
+    });
+  }
+  return out;
+}
+
 // src/lib/db/manager.ts
 import { Database } from "@nozbe/watermelondb";
 
@@ -10689,48 +10745,6 @@ import { Q as Q5 } from "@nozbe/watermelondb";
 
 // src/lib/db/entities/operations.ts
 import { Q as Q4 } from "@nozbe/watermelondb";
-
-// src/lib/db/entities/types.ts
-var ENTITY_KINDS = [
-  "person",
-  "organization",
-  "place",
-  "event",
-  "product",
-  "thing",
-  "concept",
-  "other"
-];
-function normalizeEntityName(name) {
-  return name.trim().toLowerCase();
-}
-function serializeTopics(topics) {
-  return JSON.stringify(topics);
-}
-function parseTopics(value) {
-  if (typeof value !== "string" || value.length === 0) return null;
-  let parsed;
-  try {
-    parsed = JSON.parse(value);
-  } catch {
-    return null;
-  }
-  if (!Array.isArray(parsed)) return null;
-  const out = [];
-  for (const raw of parsed) {
-    if (typeof raw !== "object" || raw === null) continue;
-    const { name, kind, source } = raw;
-    if (typeof name !== "string" || name.trim().length === 0) continue;
-    out.push({
-      name,
-      ...typeof kind === "string" && kind.length > 0 ? { kind } : {},
-      source: source === "user" ? "user" : "auto"
-    });
-  }
-  return out;
-}
-
-// src/lib/db/entities/operations.ts
 function entityToStored(e) {
   return {
     uniqueId: e.id,
@@ -10811,21 +10825,47 @@ function displayNamesOf(entities) {
 }
 function topicsEqual(stored2, computed) {
   if (stored2 === null || stored2.length !== computed.length) return false;
-  const key = (t) => JSON.stringify([t.name, t.kind ?? null, t.source]);
+  const key = (t) => JSON.stringify([t.name, t.kind ?? null, t.source, t.weight ?? null]);
   const storedKeys = stored2.map(key).sort();
   const computedKeys = computed.map(key).sort();
   return storedKeys.every((k, i) => k === computedKeys[i]);
 }
-function resolveTopicsWrite(row, linked, displayNames, source) {
+function resolveTopicsWrite(row, linked, inputs, source, mode) {
   if (row === null || source === null) return null;
-  const topics = topicsForEntities(linked, displayNames, source);
-  if (topicsEqual(parseTopics(row.topics), topics)) return null;
+  const stored2 = parseTopics(row.topics);
+  const carried = mode === "merge" ? stored2 : null;
+  const weights = source === "auto" ? weightsOf(carried, inputs) : null;
+  const displayNames = displayNamesOf([...inputs, ...carried ?? []]);
+  const topics = topicsForEntities(linked, displayNames, source, weights);
+  if (topicsEqual(stored2, topics)) return null;
   return { row, topics };
 }
-function topicsForEntities(entities, displayNames, source) {
+function weightsOf(stored2, inputs) {
+  const out = /* @__PURE__ */ new Map();
+  for (const topic of stored2 ?? []) out.set(normalizeEntityName(topic.name), topic.weight);
+  for (const input of inputs) {
+    const weight = parseTopicWeight(input.weight);
+    if (weight === void 0) continue;
+    const name = normalizeEntityName(input.name);
+    if (!out.has(name)) {
+      out.set(name, weight);
+      continue;
+    }
+    const current = out.get(name);
+    if (current !== void 0 && weight > current) out.set(name, weight);
+  }
+  return out;
+}
+function topicsForEntities(entities, displayNames, source, weights) {
   return entities.map((e) => {
     const name = displayNames.get(e.canonicalName) ?? e.canonicalName;
-    return { name, ...e.kind ? { kind: e.kind } : {}, source };
+    const weight = weights?.get(e.canonicalName);
+    return {
+      name,
+      ...e.kind ? { kind: e.kind } : {},
+      source,
+      ...weight !== void 0 ? { weight } : {}
+    };
   });
 }
 function toEntityObjects(entityInputs) {
@@ -10833,7 +10873,7 @@ function toEntityObjects(entityInputs) {
 }
 async function resolveMemoryTopicsWrite(ctx, memoryId, linked, inputs, source) {
   const row = await findVaultRowInWrite(ctx, memoryId);
-  return resolveTopicsWrite(row, linked, displayNamesOf(toEntityObjects(inputs)), source);
+  return resolveTopicsWrite(row, linked, toEntityObjects(inputs), source, "replace");
 }
 function prepareMemoryTopicsUpdate(write) {
   return prepareTopicsUpdate(write.row, write.topics, Date.now());
@@ -10871,8 +10911,9 @@ async function linkMemoryEntitiesOp(ctx, memoryId, entityInputs, options) {
     const topicsWrite = resolveTopicsWrite(
       vaultRow,
       [...carriedOver, ...entities],
-      displayNamesOf(normalized),
-      options?.topicsSource ?? "auto"
+      normalized,
+      options?.topicsSource ?? "auto",
+      "merge"
     );
     if (entityOps.length === 0 && kindBackfills.length === 0 && toCreate.length === 0 && topicsWrite === null) {
       return;
@@ -10938,8 +10979,9 @@ async function replaceMemoryEntities(ctx, memoryId, entityInputs, options) {
     const topicsWrite = resolveTopicsWrite(
       vaultRow,
       entities,
-      displayNamesOf(normalized),
-      options.topicsSource
+      normalized,
+      options.topicsSource,
+      "replace"
     );
     if (entityOps.length === 0 && kindBackfills.length === 0 && toCreate.length === 0 && toDestroy.length === 0 && topicsWrite === null) {
       return;
@@ -15739,9 +15781,9 @@ 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. ${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" }]
+- entities: named entities mentioned, each as an object { "name": string, "kind": one of "person" | "organization" | "place" | "event" | "product" | "thing" | "concept" | "other", "salience": one of "primary" | "secondary" | "mention" }. Optional \u2014 include only NAMED entities, skip generic/common nouns. ${ENTITY_KIND_GUIDELINES} Salience is how central the entity is to the fact: "primary" = the fact is ABOUT it (usually exactly one per fact), "secondary" = a meaningful part of it, "mention" = named in passing. Examples:
+    - "started a new job at Hollowpoint Labs and I'm learning Haskell for it" \u2192 entities: [{ "name": "Hollowpoint Labs", "kind": "organization", "salience": "primary" }, { "name": "Haskell", "kind": "concept", "salience": "secondary" }]
+    - "running the Berlin Half in May and I track workouts in Whoop" \u2192 entities: [{ "name": "Berlin Half", "kind": "event", "salience": "primary" }, { "name": "Whoop", "kind": "product", "salience": "mention" }]
 - 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:
     - { "kind": "point", "start": "YYYY-MM-DD" }     for a single date ("met Sara on March 14, 2026")
     - { "kind": "range", "start": "YYYY-MM-DD", "end": "YYYY-MM-DD" }  for a span ("Japan trip May 4\u201315, 2026")
@@ -15822,9 +15864,10 @@ function restoreCandidates(candidates, redactor, ownNames) {
       candidate: {
         ...c,
         content: content.text,
-        entities: c.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 }
-        )
+        entities: c.entities.flatMap((e) => {
+          const restored = redactor.restoreForStorage(e.name);
+          return restored.unresolved ? [] : [{ ...e, name: restored.text }];
+        })
       },
       unresolved: content.unresolved
     };
@@ -16053,7 +16096,12 @@ function parseEntities(raw) {
     const name = typeof obj.name === "string" ? obj.name.trim() : "";
     if (name.length === 0 || isGenericEntityName(name)) continue;
     const kind = typeof obj.kind === "string" && ENTITY_KINDS.includes(obj.kind) ? obj.kind : void 0;
-    out.push(kind !== void 0 ? { name, kind } : { name });
+    const weight = typeof obj.salience === "string" && Object.keys(TOPIC_SALIENCE_WEIGHTS).includes(obj.salience) ? TOPIC_SALIENCE_WEIGHTS[obj.salience] : void 0;
+    out.push({
+      name,
+      ...kind !== void 0 ? { kind } : {},
+      ...weight !== void 0 ? { weight } : {}
+    });
   }
   return out;
 }
@@ -18012,7 +18060,13 @@ Include only NAMED entities, skip generic/common nouns. A topic must identify a
 - Prefer 0 entities over a weak one. A memory whose only candidate is a generic noun has NO entities.
 ${ENTITY_KIND_GUIDELINES}
 
-Each memory below is written as "<id>: <text>". Output strict JSON: {"memories": [{"id": string, "entities": [{"name": string, "kind": string}]}]}
+Give each entity a "salience" \u2014 how central it is to the memory:
+- "primary": the memory is ABOUT it. A memory with entities usually has exactly one primary; never more than two.
+- "secondary": a meaningful part of the memory, but not its subject.
+- "mention": named in passing; the memory would say much the same without it.
+Example: "Ran the Chicago Marathon with my sister Ana in 3:41" \u2192 Chicago Marathon primary, Ana secondary.
+
+Each memory below is written as "<id>: <text>". Output strict JSON: {"memories": [{"id": string, "entities": [{"name": string, "kind": string, "salience": "primary" | "secondary" | "mention"}]}]}
 - exactly one element per input memory; copy its id EXACTLY as written (the token before the first ": "), with no brackets, quotes, or extra characters
 - "entities" may be empty when a memory mentions no named entities \u2014 most short memories have 0-3
 No prose.`;
@@ -18083,9 +18137,10 @@ List each memory's named 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 }
-  );
+  return entities.flatMap((e) => {
+    const restored = redactor.restoreForStorage(e.name);
+    return restored.unresolved ? [] : [{ ...e, name: restored.text }];
+  });
 }
 function parseTopicResponse(parsed, validIds) {
   if (typeof parsed !== "object" || parsed === null) return null;
@@ -18246,6 +18301,14 @@ function createLocalMemoryStore(options) {
       getLogger().warn("[memory/store] Failed to embed memory:", err);
     });
   };
+  const maintenance = {
+    createDecaySweeper: (sweeperOptions) => createDecaySweeper({ ...sweeperOptions, vaultCtx }),
+    getTopicBacklog: (backlogOptions) => getMemoriesNeedingTopicExtractionOp(vaultCtx, backlogOptions),
+    extractTopics: (memoryIds, extractOptions) => extractAndLinkEntitiesForMemoriesOp(vaultCtx, memoryIds, extractOptions),
+    stampTopicsExtracted: (memoryIds, extractedAt, version) => stampTopicsExtractedAtOp(vaultCtx, memoryIds, extractedAt, version),
+    relinkTopics: (memoryIds) => relinkMemoryTopicsOp(vaultCtx, memoryIds),
+    backfillTopics: (memoryIds) => backfillMemoryTopicsOp(vaultCtx, memoryIds)
+  };
   return {
     masksEmbeddingInput: options.embeddingOptions.maskInput !== void 0,
     list: (listOptions) => getAllVaultMemoriesOp(vaultCtx, listOptions),
@@ -18259,21 +18322,22 @@ function createLocalMemoryStore(options) {
     memoriesByTopics: (names) => getMemoriesByEntityNamesOp(entityCtx, names),
     topicsByMemories: (memoryIds) => getEntitiesByMemoryIdsOp(entityCtx, memoryIds),
     listTopics: async () => {
-      const links = await entityCtx.memoryEntityCollection.query(...linksOwnedBy).fetch();
+      const links = await entityCtx.memoryEntityCollection.query(...linksOwnedBy).unsafeFetchRaw();
       const members = /* @__PURE__ */ new Map();
       for (const link of links) {
-        const entityId = String(link.entityId);
+        const entityId = String(link.entity_id);
         const set = members.get(entityId) ?? /* @__PURE__ */ new Set();
-        set.add(String(link.memoryId));
+        set.add(String(link.memory_id));
         members.set(entityId, set);
       }
-      const entities = userId === void 0 ? await entityCtx.entityCollection.query().fetch() : members.size ? await entityCtx.entityCollection.query(Q8.where("id", Q8.oneOf([...members.keys()]))).fetch() : [];
+      const entities = userId === void 0 ? await entityCtx.entityCollection.query().unsafeFetchRaw() : members.size ? await entityCtx.entityCollection.query(Q8.where("id", Q8.oneOf([...members.keys()]))).unsafeFetchRaw() : [];
       const byName = /* @__PURE__ */ new Map();
       for (const entity of entities) {
-        const count2 = members.get(entity.id)?.size ?? 0;
-        const existing = byName.get(entity.canonicalName);
-        byName.set(entity.canonicalName, {
-          name: entity.canonicalName,
+        const name = String(entity.canonical_name);
+        const count2 = members.get(String(entity.id))?.size ?? 0;
+        const existing = byName.get(name);
+        byName.set(name, {
+          name,
           kind: existing?.kind ?? entity.kind ?? null,
           memoryCount: (existing?.memoryCount ?? 0) + count2
         });
@@ -18364,14 +18428,8 @@ function createLocalMemoryStore(options) {
       }
       return () => subscriptions.forEach((s) => s.unsubscribe());
     },
-    maintenance: {
-      createDecaySweeper: (sweeperOptions) => createDecaySweeper({ ...sweeperOptions, vaultCtx }),
-      getTopicBacklog: (backlogOptions) => getMemoriesNeedingTopicExtractionOp(vaultCtx, backlogOptions),
-      extractTopics: (memoryIds, extractOptions) => extractAndLinkEntitiesForMemoriesOp(vaultCtx, memoryIds, extractOptions),
-      stampTopicsExtracted: (memoryIds, extractedAt, version) => stampTopicsExtractedAtOp(vaultCtx, memoryIds, extractedAt, version),
-      relinkTopics: (memoryIds) => relinkMemoryTopicsOp(vaultCtx, memoryIds),
-      backfillTopics: (memoryIds) => backfillMemoryTopicsOp(vaultCtx, memoryIds)
-    }
+    maintenance,
+    topicMaintenance: maintenance
   };
 }
 
@@ -19155,7 +19213,7 @@ function createRemoteMemoryPipeline(options) {
         const memory = {
           ...snapshot.memory,
           content: patch.content,
-          updated_at: patch.preserveUpdatedAt ? snapshot.memory.updated_at : Date.now()
+          updated_at: patch.preserveUpdatedAt ? snapshot.memory.updated_at : Math.max(Date.now(), (snapshot.memory.topics_extracted_at ?? 0) + 1)
         };
         if (patch.scope !== void 0) memory.scope = patch.scope;
         if (patch.embedding === void 0 && patch.content !== snapshot.memory.content) {
@@ -19288,6 +19346,7 @@ function projection({ memory }) {
   };
 }
 function relevant(change, options) {
+  if (change === "metadata") return false;
   return options.includeDeleted ? change === "membership" : change !== "embedding" || !!options.embeddings;
 }
 function safely(onChange) {
@@ -19368,17 +19427,32 @@ function topicInputs(topics, source) {
   return topics.flatMap((topic) => {
     const name = (typeof topic === "string" ? topic : topic.name).trim();
     const kind = typeof topic === "string" ? void 0 : topic.kind;
-    return name ? [{ name, ...kind && { kind }, source }] : [];
+    const weight = typeof topic === "string" || source === "user" ? void 0 : parseTopicWeight(topic.weight);
+    return name ? [{ name, ...kind && { kind }, source, ...weight && { weight } }] : [];
   });
 }
 function mergeTopics(existing, added) {
   const byName = /* @__PURE__ */ new Map();
   for (const topic of [...existing, ...added]) {
     const key = normalizeEntityName(topic.name);
-    if (!byName.has(key)) byName.set(key, topic);
+    const kept = byName.get(key);
+    if (!kept) byName.set(key, topic);
+    else if (kept.weight !== void 0 && topic.weight !== void 0 && topic.weight > kept.weight)
+      byName.set(key, { ...kept, weight: topic.weight });
   }
   return [...byName.values()];
 }
+function sameTopics(stored2, next) {
+  const key = (t) => JSON.stringify([t.name, t.kind ?? null, t.source, t.weight ?? null]);
+  if (stored2 === null || stored2.length !== next.length) return false;
+  const keys = new Set(stored2.map(key));
+  return next.every((t) => keys.has(key(t)));
+}
+function extractionDue(memory) {
+  const stamp = memory.topics_extracted_at;
+  if (stamp === void 0 || stamp === null) return "fresh";
+  return memory.updated_at > stamp || (memory.topics_extracted_version ?? 0) < TOPICS_EXTRACTION_VERSION ? "stale" : null;
+}
 function canonicalTopics(row) {
   return new Set((parseTopics(row.topics) ?? []).map((topic) => normalizeEntityName(topic.name)));
 }
@@ -19391,7 +19465,12 @@ function createRemoteMemoryStore(options) {
   const seen = /* @__PURE__ */ new Map();
   let timer;
   const notify = (change, records = []) => {
-    if (timer) for (const record2 of records) seen.set(record2.memory.memory_id, record2);
+    if (timer)
+      for (const record2 of records) {
+        const previous = seen.get(record2.memory.memory_id);
+        if ((previous?.version ?? 0) + 1 === record2.version)
+          seen.set(record2.memory.memory_id, record2);
+      }
     for (const subscriber of [...subscribers])
       if (relevant(change, subscriber.options)) safely(subscriber.onChange);
   };
@@ -19452,15 +19531,72 @@ function createRemoteMemoryStore(options) {
     const record2 = await persistence.get(id);
     return record2 && !record2.memory.is_deleted ? record2 : null;
   };
-  const mutate = async (id, change, edit) => serialized(id, async () => {
+  const mutateLocked = async (id, change, edit) => {
     const record2 = await live(id);
     if (!record2) return null;
     const next = edit(structuredClone(record2.memory));
     if (!next) return null;
     const saved = await persistence.put(next, record2);
-    notify(change, [saved]);
+    notify(typeof change === "function" ? change(record2.memory) : change, [saved]);
     return saved;
-  });
+  };
+  const mutate = (id, change, edit) => serialized(id, () => mutateLocked(id, change, edit));
+  const serializedAll = (ids, task) => [...new Set(ids)].sort().reduceRight((inner, id) => () => serialized(id, inner), task)();
+  const mutateMany = async (ids, change, edit) => {
+    const saved = /* @__PURE__ */ new Map();
+    const failed = /* @__PURE__ */ new Map();
+    for (const slice of chunks([...new Set(ids)], MAX_BATCH)) {
+      await serializedAll(slice, async () => {
+        const writes = [];
+        let read;
+        try {
+          read = await readEveryState(slice);
+        } catch (error) {
+          for (const id of slice) failed.set(id, error);
+          return;
+        }
+        const { records, unreadable } = read;
+        for (const id of slice) {
+          const record2 = records.get(id);
+          if (unreadable.has(id)) failed.set(id, new Error(`Memory ${id} could not be decrypted`));
+          else if (!record2) failed.set(id, new Error(`Memory ${id} was not found`));
+          else if (!record2.memory.is_deleted) {
+            const memory = edit(structuredClone(record2.memory));
+            if (memory) writes.push({ before: record2, memory });
+          }
+        }
+        if (writes.length === 0) return;
+        try {
+          const written = await persistence.putMany(
+            writes.map(({ before, memory }) => ({ memory, expectedVersion: before }))
+          );
+          const byChange = /* @__PURE__ */ new Map();
+          written.forEach((record2, i) => {
+            saved.set(record2.memory.memory_id, record2);
+            const kind = change(writes[i].before.memory);
+            byChange.set(kind, [...byChange.get(kind) ?? [], record2]);
+          });
+          for (const [kind, changed] of byChange) notify(kind, changed);
+        } catch (error) {
+          const perRow = error instanceof RemoteMemoryError && (error.code === "version_conflict" || error.status === 429);
+          for (const { before } of writes) {
+            const id = before.memory.memory_id;
+            if (!perRow) {
+              failed.set(id, error);
+              continue;
+            }
+            try {
+              const record2 = await mutateLocked(id, change, edit);
+              if (record2) saved.set(id, record2);
+            } catch (rowError) {
+              failed.set(id, rowError);
+            }
+          }
+        }
+      });
+    }
+    return { saved, failed };
+  };
   const embedInBackground = ({ memory: { memory_id: id, content } }) => {
     generateEmbedding(content, embeddingOptions).then(
       (vector) => serialized(id, async () => {
@@ -19516,11 +19652,10 @@ function createRemoteMemoryStore(options) {
     return records.map((record2) => stored(record2.memory));
   };
   const asStored = (record2) => record2 ? stored(record2.memory) : null;
-  const withKnownKinds = async (topics) => {
+  const knownKinds = async (topics) => {
     const unkinded = [
       ...new Set(topics.filter((t) => !t.kind).map((t) => normalizeEntityName(t.name)))
     ];
-    if (unkinded.length === 0) return topics;
     const kinds = /* @__PURE__ */ new Map();
     for (const names of chunks(unkinded, MAX_QUERY_TOPICS)) {
       for (const { memory } of await pages(metadata, {
@@ -19535,10 +19670,136 @@ function createRemoteMemoryStore(options) {
         }
       }
     }
-    return topics.map((topic) => {
+    return (topic) => {
       const kind = topic.kind ?? kinds.get(normalizeEntityName(topic.name));
       return kind ? { ...topic, kind } : topic;
-    });
+    };
+  };
+  const withKnownKinds = async (topics) => topics.map(await knownKinds(topics));
+  const readEveryState = async (ids) => {
+    const records = /* @__PURE__ */ new Map();
+    const unreadable = /* @__PURE__ */ new Set();
+    for (const memory_ids of chunks(ids, MAX_QUERY_IDS)) {
+      let cursor2;
+      do {
+        const page = await persistence.query({
+          memory_ids,
+          include_deleted: true,
+          include_archived: true,
+          include_quarantined: true,
+          include_superseded: true,
+          limit: 200,
+          ...cursor2 && { cursor: cursor2 }
+        });
+        warnFailed(page.failed);
+        for (const record2 of page.items) records.set(record2.memory.memory_id, record2);
+        for (const failure of page.failed) unreadable.add(failure.memory_id);
+        cursor2 = page.next_cursor;
+      } while (cursor2);
+    }
+    return { records, unreadable };
+  };
+  const topicMaintenance = {
+    getTopicBacklog: async (backlogOptions = {}) => {
+      const stale = [];
+      const fresh = [];
+      for (const { memory } of await pages(metadata, { order: "created" })) {
+        if (memory.topics_user_managed) continue;
+        const due = extractionDue(memory);
+        if (due === "stale") stale.push(memory.memory_id);
+        else if (due === "fresh") fresh.push(memory.memory_id);
+      }
+      const limit = backlogOptions.limit !== void 0 && backlogOptions.limit > 0 ? backlogOptions.limit : Infinity;
+      return {
+        pending: [...stale, ...fresh].slice(0, limit).map((uniqueId) => ({ uniqueId })),
+        linkedUnstamped: [],
+        topicsToRelink: [],
+        topicsBackfill: []
+      };
+    },
+    extractTopics: async (memoryIds, extractOptions) => {
+      const extractedAt = extractOptions.now ?? Date.now();
+      const skippedIds = [];
+      const skippedReasons = /* @__PURE__ */ new Map();
+      const skip = (id, reason) => {
+        if (skippedReasons.has(id)) return;
+        skippedIds.push(id);
+        skippedReasons.set(id, reason);
+      };
+      const ids = [...new Set(memoryIds)];
+      const { records, unreadable } = await readEveryState(ids);
+      const inputs = [];
+      for (const id of ids) {
+        const memory = records.get(id)?.memory;
+        if (unreadable.has(id)) skip(id, "unreadable");
+        else if (!memory) skip(id, "not-found");
+        else if (memory.is_deleted || memory.topics_user_managed) skip(id, "excluded");
+        else inputs.push({ id, content: memory.content });
+      }
+      const entitiesByMemory = await extractEntitiesForMemories(inputs, extractOptions);
+      const answered = /* @__PURE__ */ new Map();
+      for (const input of inputs) {
+        const entities = entitiesByMemory.get(input.id);
+        if (entities === void 0) skip(input.id, "llm-unanswered");
+        else
+          answered.set(input.id, { content: input.content, topics: topicInputs(entities, "auto") });
+      }
+      const stampedIds = [];
+      const fail = (id, reason) => {
+        skip(id, reason);
+        entitiesByMemory.delete(id);
+      };
+      try {
+        const kinded = await knownKinds([...answered.values()].flatMap((a) => a.topics));
+        const topics = new Map(
+          [...answered].map(([id, a]) => [id, mergeTopics([], a.topics.map(kinded))])
+        );
+        const unchanged = (memory) => sameTopics(parseTopics(memory.topics), topics.get(memory.memory_id));
+        const { saved, failed } = await mutateMany(
+          [...answered.keys()],
+          (before) => sameTopics(parseTopics(before.topics) ?? [], topics.get(before.memory_id)) ? "metadata" : "edit",
+          (memory) => {
+            if (memory.topics_user_managed || memory.content !== answered.get(memory.memory_id).content)
+              return null;
+            return {
+              ...memory,
+              ...!unchanged(memory) && {
+                topics: serializeTopics(topics.get(memory.memory_id)),
+                topics_updated_at: Date.now()
+              },
+              topics_extracted_at: Math.max(extractedAt, memory.updated_at),
+              topics_extracted_version: TOPICS_EXTRACTION_VERSION
+            };
+          }
+        );
+        for (const id of answered.keys()) {
+          if (saved.has(id)) stampedIds.push(id);
+          else fail(id, failed.has(id) ? "link-failed" : "link-declined");
+        }
+        if (failed.size)
+          getLogger().warn(
+            "[memory/remote-store] Failed to write extracted topics:",
+            failed.values().next().value
+          );
+      } catch (error) {
+        getLogger().warn("[memory/remote-store] Failed to write extracted topics:", error);
+        for (const id of answered.keys()) fail(id, "link-failed");
+      }
+      return { entitiesByMemory, stampedIds, skippedIds, skippedReasons };
+    },
+    stampTopicsExtracted: async (memoryIds, extractedAt, version = TOPICS_EXTRACTION_VERSION) => {
+      const ids = [...new Set(memoryIds)];
+      const { saved, failed } = await mutateMany(
+        ids,
+        () => "metadata",
+        (memory) => memory.topics_user_managed ? null : { ...memory, topics_extracted_at: extractedAt, topics_extracted_version: version }
+      );
+      if (failed.size)
+        getLogger().warn("[memory/remote-store] Failed to stamp topics:", [...failed.values()]);
+      return ids.filter((id) => saved.has(id));
+    },
+    relinkTopics: () => Promise.resolve([]),
+    backfillTopics: () => Promise.resolve([])
   };
   const everyState = {
     include_deleted: true,
@@ -19617,6 +19878,7 @@ function createRemoteMemoryStore(options) {
   };
   return {
     masksEmbeddingInput: embeddingOptions.maskInput !== void 0,
+    topicMaintenance,
     list: async (listOptions = {}) => (await listRows(decrypted, listOptions, listFilters(listOptions), maxOf(listOptions))).map(
       (r) => stored(r.memory)
     ),
@@ -19701,7 +19963,7 @@ function createRemoteMemoryStore(options) {
         const kind = patch.kind !== void 0 ? patch.kind : memory.kind;
         assertValidKindLevel(kind, level);
         memory.content = patch.content;
-        memory.updated_at = Date.now();
+        memory.updated_at = Math.max(Date.now(), (memory.topics_extracted_at ?? 0) + 1);
         if (patch.level !== void 0) {
           memory.level = level;
           memory.scope = scopeForLevel(level);
@@ -26093,6 +26355,7 @@ export {
   TOOL_RESULT_ORIGIN,
   TOPICS_EXTRACTION_VERSION,
   TOPIC_EXTRACTION_BATCH_SIZE,
+  TOPIC_SALIENCE_WEIGHTS,
   TREND_RECENT_WINDOW_DAYS,
   TREND_STALE_WINDOW_DAYS,
   VAULT_SIZE_HOP_CAP,
@@ -26217,6 +26480,7 @@ export {
   onKeyAvailable,
   parseMedia,
   preEmbedVaultMemories,
+  primaryTopic,
   quantizeEmbedding,
   queueManager,
   rankProfileCandidates,
@@ -26250,6 +26514,7 @@ export {
   summarizeObservationTrends,
   supersedeVaultMemoryOp,
   synthesizeProfile,
+  topicWeight,
   traverseGraphLane,
   ttlForType,
   updateVaultFolderContextOp,

package/dist/memory/context.d.mts

@@ -157,6 +157,8 @@ interface StoredTopic {
     name: string;
     kind?: string;
     source: TopicSource;
+    /** How central the topic is to the memory, in (0, 1]; read it with {@link topicWeight}. */
+    weight?: number;
 }
 
 interface EntityOperationsContext {