@anuma/sdk 4.0.0 → 4.0.2

package/dist/expo/index.d.mts

@@ -6083,6 +6083,12 @@ declare function getUnfiledVaultMemoriesOp(ctx: VaultMemoryOperationsContext): P
  * older version (including pre-v37 rows, read as version 0) is then re-extracted
  * by the next sweep, so topic-quality improvements propagate across the existing
  * vault. The worker's `limit` drains that re-extraction across sweeps.
+ *
+ * Bumping this is a WHOLE-VAULT re-extraction: the gate is unconditional across
+ * every stamped row, and `stampTopicsExtractedAtOp` stamps this version on every
+ * healthy row, so a bump sends each user's entire extracted vault back to the
+ * LLM. Never reach for it to repair a subset — see the pre-v42-restore repair in
+ * {@link getMemoriesNeedingTopicExtractionOp}, which targets the damaged rows.
  */
 declare const TOPICS_EXTRACTION_VERSION = 3;
 /**
@@ -6095,9 +6101,10 @@ interface MemoriesNeedingTopicExtraction {
      * Memories to run LLM topic extraction on (decrypted): never-extracted rows
      * with no entity links, plus stamped rows edited since their last pass
      * (`updated_at` > `topics_extracted_at`) or extracted under an older
-     * `topics_extracted_version` than {@link TOPICS_EXTRACTION_VERSION}. Edited /
-     * stale-version rows come first (they get priority under `limit`), each group
-     * newest-created first.
+     * `topics_extracted_version` than {@link TOPICS_EXTRACTION_VERSION}, plus the
+     * pre-v42-restore repair: a stamped row left with neither links nor a `topics`
+     * record, which no no-LLM bucket can reach. Edited / stale-version rows come
+     * first (they get priority under `limit`), each group newest-created first.
      */
     pending: StoredVaultMemory[];
     /**
@@ -6149,6 +6156,11 @@ interface MemoriesNeedingTopicExtraction {
  * between the record and the index and never re-derive them. That's why the
  * ownership filter lives in the partition below rather than in the query: a
  * restored curated memory is exactly the row whose index must be rebuilt.
+ *
+ * NOT purely a read: a curated row with no `topics` record AND no usable link is
+ * a contradiction only a pre-v42 restore produces, and this is the one place
+ * that can see all three facts at once, so it clears the flag there (capped by
+ * `limit`) before returning. See the branch for why that's safe.
  */
 declare function getMemoriesNeedingTopicExtractionOp(ctx: VaultMemoryOperationsContext, options?: {
     limit?: number;

package/dist/expo/index.d.ts

@@ -6083,6 +6083,12 @@ declare function getUnfiledVaultMemoriesOp(ctx: VaultMemoryOperationsContext): P
  * older version (including pre-v37 rows, read as version 0) is then re-extracted
  * by the next sweep, so topic-quality improvements propagate across the existing
  * vault. The worker's `limit` drains that re-extraction across sweeps.
+ *
+ * Bumping this is a WHOLE-VAULT re-extraction: the gate is unconditional across
+ * every stamped row, and `stampTopicsExtractedAtOp` stamps this version on every
+ * healthy row, so a bump sends each user's entire extracted vault back to the
+ * LLM. Never reach for it to repair a subset — see the pre-v42-restore repair in
+ * {@link getMemoriesNeedingTopicExtractionOp}, which targets the damaged rows.
  */
 declare const TOPICS_EXTRACTION_VERSION = 3;
 /**
@@ -6095,9 +6101,10 @@ interface MemoriesNeedingTopicExtraction {
      * Memories to run LLM topic extraction on (decrypted): never-extracted rows
      * with no entity links, plus stamped rows edited since their last pass
      * (`updated_at` > `topics_extracted_at`) or extracted under an older
-     * `topics_extracted_version` than {@link TOPICS_EXTRACTION_VERSION}. Edited /
-     * stale-version rows come first (they get priority under `limit`), each group
-     * newest-created first.
+     * `topics_extracted_version` than {@link TOPICS_EXTRACTION_VERSION}, plus the
+     * pre-v42-restore repair: a stamped row left with neither links nor a `topics`
+     * record, which no no-LLM bucket can reach. Edited / stale-version rows come
+     * first (they get priority under `limit`), each group newest-created first.
      */
     pending: StoredVaultMemory[];
     /**
@@ -6149,6 +6156,11 @@ interface MemoriesNeedingTopicExtraction {
  * between the record and the index and never re-derive them. That's why the
  * ownership filter lives in the partition below rather than in the query: a
  * restored curated memory is exactly the row whose index must be rebuilt.
+ *
+ * NOT purely a read: a curated row with no `topics` record AND no usable link is
+ * a contradiction only a pre-v42 restore produces, and this is the one place
+ * that can see all three facts at once, so it clears the flag there (capped by
+ * `limit`) before returning. See the branch for why that's safe.
  */
 declare function getMemoriesNeedingTopicExtractionOp(ctx: VaultMemoryOperationsContext, options?: {
     limit?: number;

package/dist/expo/index.mjs

@@ -116,7 +116,7 @@ import {
   upsertMessageOp,
   useEncryption,
   vaultMemoryToStored
-} from "./chunk-BOAKGY4R.mjs";
+} from "./chunk-VBO6KSNQ.mjs";
 import {
   PII_PATTERNS,
   PiiRedactor,
@@ -6673,7 +6673,7 @@ async function tryConsolidate(trimmed, ctx, options, prepared) {
     content: m.content,
     similarity: m.similarity
   }));
-  const { consolidateMemory: doConsolidate } = await import("./consolidate-AURTG64H.mjs");
+  const { consolidateMemory: doConsolidate } = await import("./consolidate-KASO7JDS.mjs");
   const decision = await doConsolidate(trimmed, candidates, consolidateOptions);
   if (decision.action === "create") return null;
   if (decision.action === "supersede" && decision.content) {

package/dist/{react/recall-KTJCUAXN.mjs → expo/recall-OCQOA7M3.mjs}

@@ -1,6 +1,6 @@
 import {
   recall
-} from "./chunk-XXCZVG4Z.mjs";
+} from "./chunk-VBO6KSNQ.mjs";
 import "./chunk-ILAWDQDE.mjs";
 import "./chunk-GYKJOWEO.mjs";
 export {

package/dist/react/{chunk-XXCZVG4Z.mjs → chunk-BS7C4CUW.mjs}

@@ -2927,7 +2927,7 @@ async function setMemoryEntitiesOp(ctx, memoryId, entities) {
   if (record.isDeleted || !isOwnedByCtxUser(ctx, record)) return null;
   let stale = false;
   const originalUpdatedAt = record.updatedAt.getTime();
-  await ctx.database.write(async () => {
+  await ctx.database.write(async (writer) => {
     if (record.isDeleted || !isOwnedByCtxUser(ctx, record)) {
       stale = true;
       return;
@@ -2936,30 +2936,23 @@ async function setMemoryEntitiesOp(ctx, memoryId, entities) {
       r._setRaw("topics_user_managed", true);
       r._setRaw("updated_at", originalUpdatedAt);
     });
+    const linked = entities.length > 0 ? await writer.callWriter(
+      () => linkMemoryEntitiesOp(entityCtx, memoryId, entities, { topicsSource: "user" })
+    ) : [];
+    const keep = new Set(linked.map((e) => e.uniqueId));
+    const existing = await entityCtx.memoryEntityCollection.query(Q3.where("memory_id", memoryId)).fetch();
+    const staleLinks = existing.filter((l) => !keep.has(String(l.entityId)));
+    if (staleLinks.length === 0 && entities.length > 0) return;
+    const topicsOp = await prepareMemoryTopicsUpdate(entityCtx, memoryId, linked, entities, "user");
+    await ctx.database.batch(
+      ...staleLinks.map((l) => l.prepareDestroyPermanently()),
+      ...topicsOp ? [topicsOp] : []
+    );
   });
   if (stale) return null;
-  const linked = entities.length > 0 ? await linkMemoryEntitiesOp(entityCtx, memoryId, entities, { topicsSource: "user" }) : [];
-  const keep = new Set(linked.map((e) => e.uniqueId));
-  const existing = await entityCtx.memoryEntityCollection.query(Q3.where("memory_id", memoryId)).fetch();
-  const staleLinks = existing.filter((l) => !keep.has(String(l.entityId)));
-  if (staleLinks.length > 0 || entities.length === 0) {
-    await ctx.database.write(async () => {
-      const topicsOp = await prepareMemoryTopicsUpdate(
-        entityCtx,
-        memoryId,
-        linked,
-        entities,
-        "user"
-      );
-      await ctx.database.batch(
-        ...staleLinks.map((l) => l.prepareDestroyPermanently()),
-        ...topicsOp ? [topicsOp] : []
-      );
-    });
-  }
   return vaultMemoryToStored(record, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner);
 }
-async function clearMemoryTopicsOverrideOp(ctx, memoryId) {
+async function clearMemoryTopicsOverrideOp(ctx, memoryId, options) {
   let record;
   try {
     record = await ctx.vaultMemoryCollection.find(memoryId);
@@ -2968,7 +2961,10 @@ async function clearMemoryTopicsOverrideOp(ctx, memoryId) {
   }
   if (record.isDeleted || !isOwnedByCtxUser(ctx, record)) return false;
   const originalUpdatedAt = record.updatedAt.getTime();
+  let cleared = false;
   await ctx.database.write(async () => {
+    if (options?.unlessTopicsRecorded && parseTopics(record.topics) !== null) return;
+    cleared = true;
     await record.update((r) => {
       r._setRaw("topics_user_managed", false);
       r._setRaw("topics_extracted_version", null);
@@ -2978,7 +2974,7 @@ async function clearMemoryTopicsOverrideOp(ctx, memoryId) {
       r._setRaw("updated_at", originalUpdatedAt);
     });
   });
-  return true;
+  return cleared;
 }
 async function setMemoryVisibilityOp(ctx, id, opts) {
   let record;
@@ -3141,11 +3137,13 @@ async function getMemoriesNeedingTopicExtractionOp(ctx, options) {
     entityCtx,
     rows.map((r) => r.id)
   );
+  const cap = options?.limit !== void 0 && options.limit > 0 ? options.limit : void 0;
   const pendingRaw = [];
   const stampedPendingRaw = [];
   const linkedUnstampedAll = [];
   const topicsToRelinkAll = [];
   const topicsBackfillAll = [];
+  const emptyCurationToClear = [];
   for (const raw of rows) {
     const id = raw.id;
     const topics = parseTopics(raw.topics);
@@ -3155,8 +3153,12 @@ async function getMemoriesNeedingTopicExtractionOp(ctx, options) {
       continue;
     }
     if (raw.topics_user_managed) {
-      if (topics === null && linked !== void 0) topicsBackfillAll.push(id);
-      continue;
+      if (topics !== null || linked !== void 0) {
+        if (topics === null) topicsBackfillAll.push(id);
+        continue;
+      }
+      if (cap !== void 0 && emptyCurationToClear.length >= cap) continue;
+      emptyCurationToClear.push(id);
     }
     const stamp = raw.topics_extracted_at ?? null;
     let isPending = false;
@@ -3172,11 +3174,21 @@ async function getMemoriesNeedingTopicExtractionOp(ctx, options) {
       pendingRaw.push(raw);
       isPending = true;
     }
+    if (!isPending && linked === void 0 && topics === null) {
+      pendingRaw.push(raw);
+      isPending = true;
+    }
     if (!isPending && topics === null && linked !== void 0) {
       topicsBackfillAll.push(id);
     }
   }
-  const cap = options?.limit !== void 0 && options.limit > 0 ? options.limit : void 0;
+  for (const id of emptyCurationToClear) {
+    try {
+      await clearMemoryTopicsOverrideOp(ctx, id, { unlessTopicsRecorded: true });
+    } catch (err) {
+      getLogger().warn("[memory/topics] repair clear failed", err);
+    }
+  }
   const orderedPendingRaw = [...stampedPendingRaw, ...pendingRaw];
   const limitedPendingRaw = cap !== void 0 ? orderedPendingRaw.slice(0, cap) : orderedPendingRaw;
   const pending = await mapInBatches(
@@ -6430,7 +6442,7 @@ function createMemoryVaultSearchTool(vaultCtx, embeddingOptions, cache, searchOp
             legacy.map((r) => ({ id: r.uniqueId, content: r.content, score: r.similarity }))
           );
         }
-        const { recall: recall2 } = await import("./recall-KTJCUAXN.mjs");
+        const { recall: recall2 } = await import("./recall-WXCZHXHZ.mjs");
         let recallDegraded = [];
         const result = await recall2(
           query,

package/dist/react/{consolidate-R6FH7XMV.mjs → consolidate-IFIKT25Z.mjs}

@@ -18,19 +18,21 @@ A "memory" is a self-contained natural-language fact about the user. Multiple me
 Decide one of four actions:
 
 - "create": the new memory describes a distinct fact not covered by any existing memory. Write it as new.
-- "update": the new memory describes the SAME FACET as exactly one existing memory and is COMPATIBLE with it \u2014 it adds detail, fixes an incomplete value, or rephrases the same still-true fact. Return targetId of that existing memory + the consolidated content (richest version of the two).
-- "supersede": the new memory REPLACES a standing fact whose value has CHANGED and is now INCOMPATIBLE with an existing memory \u2014 the old fact was true before but is false now (a state change). Return "targetIds": an array of the ids of EVERY existing candidate that describes the SAME standing attribute now being changed \u2014 retire ALL stale duplicates of the old value, not just one (the candidate list may contain several paraphrases of the same old fact) + content = the NEW fact. The old memories are kept as history, not overwritten or deleted; do not re-state them.
-- "noop": the new memory is already fully captured by an existing memory \u2014 same facet, no new information. Skip the write.
+- "update": the new memory describes the SAME FACET of the SAME SUBJECT as exactly one existing memory, is COMPATIBLE with it, and ADDS INFORMATION \u2014 it adds detail or fills in an incomplete value. Return targetId of that existing memory + the consolidated content (richest version of the two). A pure rewording that adds nothing is NOT an update; it is "noop".
+- "supersede": the new memory REPLACES a standing fact whose value has CHANGED and is now INCOMPATIBLE with an existing memory ABOUT THE SAME SUBJECT \u2014 the old fact was true before but is false now (a state change). Before choosing this, name the subject of the new memory and the subject of each candidate out loud to yourself; if they are different people, the old fact is still TRUE and superseding it would delete a correct memory \u2014 choose "create" instead. Return "targetIds": an array of the ids of EVERY existing candidate that describes the SAME standing attribute now being changed \u2014 retire ALL stale duplicates of the old value, not just one (the candidate list may contain several paraphrases of the same old fact) + content = the NEW fact. The old memories are kept as history, not overwritten or deleted; do not re-state them.
+- "noop": the new memory is already fully captured by an existing memory \u2014 same facet of the same subject, no new information. This INCLUDES a restatement in different words ("has two kids" / "has two children"): if the existing memory already tells you everything the new one does, the answer is noop no matter how differently it is worded. Skip the write.
 
 RULES (carry these strictly):
 
 1. ONE OBSERVATION PER DISTINCT FACET. If the new memory is about "user's aunt's twins" and an existing memory is also about "user's aunt's twins", they are the same facet \u2192 update, never create.
+1a. SAME SUBJECT REQUIRED \u2014 check this FIRST, before you look at the facet. The subject is WHO the fact is about: the user, or a specific person or thing in their life (a relative, their manager, their dog Biscuit). "update", "supersede" and "noop" all require the new memory and the existing one to be about the SAME subject. Two memories can share a facet and still have different subjects, and then they are simply two different facts: "User's daughter is allergic to peanuts" and "User is allergic to peanuts" are both about a peanut allergy, but one is about the DAUGHTER and one is about the USER \u2192 create, keep both. This holds for EVERY attribute, not just the one in this example \u2014 where someone lives, who they work for, what they own, how old they are. A possessive like "user's X" makes X the subject, not the user; strip it and ask "whose fact is this?" before comparing anything. Never retire the user's own value because a fact about somebody else resembles it \u2014 the user's fact is still true, and retiring it destroys it.
 2. MATCH BY FACET, NOT TOPIC. Two memories both mentioning "Zara" is not enough to merge \u2014 only merge if they describe the same property (e.g. both about "user's pending Zara boot exchange"). Two memories about Zara on different topics (e.g. "user shops at Zara" + "user returned a sweater to Zara last week") are separate facets.
 3. NO COMPUTATION. Do not sum counts, decrement quantities, or derive new facts from existing ones. If the new memory says "user spent $200 today" and an existing memory says "user spent $150 yesterday", these are TWO SEPARATE EVENTS \u2014 create.
 4. EVENTS vs STANDING STATE.
    - Distinct EVENTS (episodic \u2014 something that happened on a date) are separate memories, even if the same activity: "user went to gym Monday" vs "user went to gym Friday" \u2192 create; keep both.
-   - A STANDING ATTRIBUTE (an ongoing state: where the user lives/works, relationship status, current role) has ONE current value. When the new memory changes that value ("Lives in Portland" \u2192 "Lives in San Francisco"; "Works at Google" \u2192 "Works at Riverbend"; "Engaged" \u2192 "Broke up"), the old value is no longer true \u2192 supersede (retire the old, record the new). Do NOT create (that leaves a stale contradiction) and do NOT update (that erases the history that the old value was once true).
-5. When in doubt between create and update, choose create \u2014 EXCEPT when the new memory directly contradicts the current value of a standing attribute in an existing memory; then choose supersede. Over-merging loses information; a live contradiction is worse than either.
+   - A STANDING ATTRIBUTE (an ongoing state: where someone lives/works, relationship status, current role) has ONE current value PER SUBJECT. When the new memory changes that value FOR THE SAME SUBJECT ("Lives in Portland" \u2192 "Lives in San Francisco"; "Works at Google" \u2192 "Works at Riverbend"; "Engaged" \u2192 "Broke up"), the old value is no longer true \u2192 supersede (retire the old, record the new). Do NOT create (that leaves a stale contradiction) and do NOT update (that erases the history that the old value was once true). A different subject holding the same attribute is not a value change at all \u2192 create.
+5. When in doubt between create and update, choose create \u2014 EXCEPT when the new memory directly contradicts the current value of a standing attribute in an existing memory ABOUT THE SAME SUBJECT; then choose supersede. Two facts about different subjects never contradict each other, however similarly they read. Over-merging loses information; a live contradiction is worse than either.
+6. When in doubt between update and noop, ask whether the existing memory ALONE already answers everything the new one would. If it does, choose noop \u2014 a write that changes only the wording costs a re-embed and makes an old fact look newly observed.
 
 OUTPUT \u2014 strict JSON, no prose:
 {

package/dist/react/index.cjs

@@ -5238,7 +5238,7 @@ async function setMemoryEntitiesOp(ctx, memoryId, entities) {
   if (record.isDeleted || !isOwnedByCtxUser(ctx, record)) return null;
   let stale = false;
   const originalUpdatedAt = record.updatedAt.getTime();
-  await ctx.database.write(async () => {
+  await ctx.database.write(async (writer) => {
     if (record.isDeleted || !isOwnedByCtxUser(ctx, record)) {
       stale = true;
       return;
@@ -5247,30 +5247,23 @@ async function setMemoryEntitiesOp(ctx, memoryId, entities) {
       r._setRaw("topics_user_managed", true);
       r._setRaw("updated_at", originalUpdatedAt);
     });
+    const linked = entities.length > 0 ? await writer.callWriter(
+      () => linkMemoryEntitiesOp(entityCtx, memoryId, entities, { topicsSource: "user" })
+    ) : [];
+    const keep = new Set(linked.map((e) => e.uniqueId));
+    const existing = await entityCtx.memoryEntityCollection.query(import_watermelondb10.Q.where("memory_id", memoryId)).fetch();
+    const staleLinks = existing.filter((l) => !keep.has(String(l.entityId)));
+    if (staleLinks.length === 0 && entities.length > 0) return;
+    const topicsOp = await prepareMemoryTopicsUpdate(entityCtx, memoryId, linked, entities, "user");
+    await ctx.database.batch(
+      ...staleLinks.map((l) => l.prepareDestroyPermanently()),
+      ...topicsOp ? [topicsOp] : []
+    );
   });
   if (stale) return null;
-  const linked = entities.length > 0 ? await linkMemoryEntitiesOp(entityCtx, memoryId, entities, { topicsSource: "user" }) : [];
-  const keep = new Set(linked.map((e) => e.uniqueId));
-  const existing = await entityCtx.memoryEntityCollection.query(import_watermelondb10.Q.where("memory_id", memoryId)).fetch();
-  const staleLinks = existing.filter((l) => !keep.has(String(l.entityId)));
-  if (staleLinks.length > 0 || entities.length === 0) {
-    await ctx.database.write(async () => {
-      const topicsOp = await prepareMemoryTopicsUpdate(
-        entityCtx,
-        memoryId,
-        linked,
-        entities,
-        "user"
-      );
-      await ctx.database.batch(
-        ...staleLinks.map((l) => l.prepareDestroyPermanently()),
-        ...topicsOp ? [topicsOp] : []
-      );
-    });
-  }
   return vaultMemoryToStored(record, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner);
 }
-async function clearMemoryTopicsOverrideOp(ctx, memoryId) {
+async function clearMemoryTopicsOverrideOp(ctx, memoryId, options) {
   let record;
   try {
     record = await ctx.vaultMemoryCollection.find(memoryId);
@@ -5279,7 +5272,10 @@ async function clearMemoryTopicsOverrideOp(ctx, memoryId) {
   }
   if (record.isDeleted || !isOwnedByCtxUser(ctx, record)) return false;
   const originalUpdatedAt = record.updatedAt.getTime();
+  let cleared = false;
   await ctx.database.write(async () => {
+    if (options?.unlessTopicsRecorded && parseTopics(record.topics) !== null) return;
+    cleared = true;
     await record.update((r) => {
       r._setRaw("topics_user_managed", false);
       r._setRaw("topics_extracted_version", null);
@@ -5289,7 +5285,7 @@ async function clearMemoryTopicsOverrideOp(ctx, memoryId) {
       r._setRaw("updated_at", originalUpdatedAt);
     });
   });
-  return true;
+  return cleared;
 }
 async function setMemoryVisibilityOp(ctx, id, opts) {
   let record;
@@ -5451,11 +5447,13 @@ async function getMemoriesNeedingTopicExtractionOp(ctx, options) {
     entityCtx,
     rows.map((r) => r.id)
   );
+  const cap = options?.limit !== void 0 && options.limit > 0 ? options.limit : void 0;
   const pendingRaw = [];
   const stampedPendingRaw = [];
   const linkedUnstampedAll = [];
   const topicsToRelinkAll = [];
   const topicsBackfillAll = [];
+  const emptyCurationToClear = [];
   for (const raw of rows) {
     const id = raw.id;
     const topics = parseTopics(raw.topics);
@@ -5465,8 +5463,12 @@ async function getMemoriesNeedingTopicExtractionOp(ctx, options) {
       continue;
     }
     if (raw.topics_user_managed) {
-      if (topics === null && linked !== void 0) topicsBackfillAll.push(id);
-      continue;
+      if (topics !== null || linked !== void 0) {
+        if (topics === null) topicsBackfillAll.push(id);
+        continue;
+      }
+      if (cap !== void 0 && emptyCurationToClear.length >= cap) continue;
+      emptyCurationToClear.push(id);
     }
     const stamp = raw.topics_extracted_at ?? null;
     let isPending = false;
@@ -5482,11 +5484,21 @@ async function getMemoriesNeedingTopicExtractionOp(ctx, options) {
       pendingRaw.push(raw);
       isPending = true;
     }
+    if (!isPending && linked === void 0 && topics === null) {
+      pendingRaw.push(raw);
+      isPending = true;
+    }
     if (!isPending && topics === null && linked !== void 0) {
       topicsBackfillAll.push(id);
     }
   }
-  const cap = options?.limit !== void 0 && options.limit > 0 ? options.limit : void 0;
+  for (const id of emptyCurationToClear) {
+    try {
+      await clearMemoryTopicsOverrideOp(ctx, id, { unlessTopicsRecorded: true });
+    } catch (err) {
+      getLogger().warn("[memory/topics] repair clear failed", err);
+    }
+  }
   const orderedPendingRaw = [...stampedPendingRaw, ...pendingRaw];
   const limitedPendingRaw = cap !== void 0 ? orderedPendingRaw.slice(0, cap) : orderedPendingRaw;
   const pending = await mapInBatches(
@@ -8847,19 +8859,21 @@ A "memory" is a self-contained natural-language fact about the user. Multiple me
 Decide one of four actions:
 
 - "create": the new memory describes a distinct fact not covered by any existing memory. Write it as new.
-- "update": the new memory describes the SAME FACET as exactly one existing memory and is COMPATIBLE with it \u2014 it adds detail, fixes an incomplete value, or rephrases the same still-true fact. Return targetId of that existing memory + the consolidated content (richest version of the two).
-- "supersede": the new memory REPLACES a standing fact whose value has CHANGED and is now INCOMPATIBLE with an existing memory \u2014 the old fact was true before but is false now (a state change). Return "targetIds": an array of the ids of EVERY existing candidate that describes the SAME standing attribute now being changed \u2014 retire ALL stale duplicates of the old value, not just one (the candidate list may contain several paraphrases of the same old fact) + content = the NEW fact. The old memories are kept as history, not overwritten or deleted; do not re-state them.
-- "noop": the new memory is already fully captured by an existing memory \u2014 same facet, no new information. Skip the write.
+- "update": the new memory describes the SAME FACET of the SAME SUBJECT as exactly one existing memory, is COMPATIBLE with it, and ADDS INFORMATION \u2014 it adds detail or fills in an incomplete value. Return targetId of that existing memory + the consolidated content (richest version of the two). A pure rewording that adds nothing is NOT an update; it is "noop".
+- "supersede": the new memory REPLACES a standing fact whose value has CHANGED and is now INCOMPATIBLE with an existing memory ABOUT THE SAME SUBJECT \u2014 the old fact was true before but is false now (a state change). Before choosing this, name the subject of the new memory and the subject of each candidate out loud to yourself; if they are different people, the old fact is still TRUE and superseding it would delete a correct memory \u2014 choose "create" instead. Return "targetIds": an array of the ids of EVERY existing candidate that describes the SAME standing attribute now being changed \u2014 retire ALL stale duplicates of the old value, not just one (the candidate list may contain several paraphrases of the same old fact) + content = the NEW fact. The old memories are kept as history, not overwritten or deleted; do not re-state them.
+- "noop": the new memory is already fully captured by an existing memory \u2014 same facet of the same subject, no new information. This INCLUDES a restatement in different words ("has two kids" / "has two children"): if the existing memory already tells you everything the new one does, the answer is noop no matter how differently it is worded. Skip the write.
 
 RULES (carry these strictly):
 
 1. ONE OBSERVATION PER DISTINCT FACET. If the new memory is about "user's aunt's twins" and an existing memory is also about "user's aunt's twins", they are the same facet \u2192 update, never create.
+1a. SAME SUBJECT REQUIRED \u2014 check this FIRST, before you look at the facet. The subject is WHO the fact is about: the user, or a specific person or thing in their life (a relative, their manager, their dog Biscuit). "update", "supersede" and "noop" all require the new memory and the existing one to be about the SAME subject. Two memories can share a facet and still have different subjects, and then they are simply two different facts: "User's daughter is allergic to peanuts" and "User is allergic to peanuts" are both about a peanut allergy, but one is about the DAUGHTER and one is about the USER \u2192 create, keep both. This holds for EVERY attribute, not just the one in this example \u2014 where someone lives, who they work for, what they own, how old they are. A possessive like "user's X" makes X the subject, not the user; strip it and ask "whose fact is this?" before comparing anything. Never retire the user's own value because a fact about somebody else resembles it \u2014 the user's fact is still true, and retiring it destroys it.
 2. MATCH BY FACET, NOT TOPIC. Two memories both mentioning "Zara" is not enough to merge \u2014 only merge if they describe the same property (e.g. both about "user's pending Zara boot exchange"). Two memories about Zara on different topics (e.g. "user shops at Zara" + "user returned a sweater to Zara last week") are separate facets.
 3. NO COMPUTATION. Do not sum counts, decrement quantities, or derive new facts from existing ones. If the new memory says "user spent $200 today" and an existing memory says "user spent $150 yesterday", these are TWO SEPARATE EVENTS \u2014 create.
 4. EVENTS vs STANDING STATE.
    - Distinct EVENTS (episodic \u2014 something that happened on a date) are separate memories, even if the same activity: "user went to gym Monday" vs "user went to gym Friday" \u2192 create; keep both.
-   - A STANDING ATTRIBUTE (an ongoing state: where the user lives/works, relationship status, current role) has ONE current value. When the new memory changes that value ("Lives in Portland" \u2192 "Lives in San Francisco"; "Works at Google" \u2192 "Works at Riverbend"; "Engaged" \u2192 "Broke up"), the old value is no longer true \u2192 supersede (retire the old, record the new). Do NOT create (that leaves a stale contradiction) and do NOT update (that erases the history that the old value was once true).
-5. When in doubt between create and update, choose create \u2014 EXCEPT when the new memory directly contradicts the current value of a standing attribute in an existing memory; then choose supersede. Over-merging loses information; a live contradiction is worse than either.
+   - A STANDING ATTRIBUTE (an ongoing state: where someone lives/works, relationship status, current role) has ONE current value PER SUBJECT. When the new memory changes that value FOR THE SAME SUBJECT ("Lives in Portland" \u2192 "Lives in San Francisco"; "Works at Google" \u2192 "Works at Riverbend"; "Engaged" \u2192 "Broke up"), the old value is no longer true \u2192 supersede (retire the old, record the new). Do NOT create (that leaves a stale contradiction) and do NOT update (that erases the history that the old value was once true). A different subject holding the same attribute is not a value change at all \u2192 create.
+5. When in doubt between create and update, choose create \u2014 EXCEPT when the new memory directly contradicts the current value of a standing attribute in an existing memory ABOUT THE SAME SUBJECT; then choose supersede. Two facts about different subjects never contradict each other, however similarly they read. Over-merging loses information; a live contradiction is worse than either.
+6. When in doubt between update and noop, ask whether the existing memory ALONE already answers everything the new one would. If it does, choose noop \u2014 a write that changes only the wording costs a re-embed and makes an old fact look newly observed.
 
 OUTPUT \u2014 strict JSON, no prose:
 {

package/dist/react/index.d.mts

@@ -7457,8 +7457,18 @@ declare function setMemoryEntitiesOp(ctx: VaultMemoryOperationsContext, memoryId
  * see the schema note. This op's version-invalidation trick is the reason the
  * earlier plan to exclude them from sync was dropped, and it's the last piece
  * that has to move before they can go.
+ *
+ * `options.unlessTopicsRecorded` declines the reset when the row already has a
+ * `topics` record, re-checked INSIDE the serialized writer. Only the repair path
+ * in {@link getMemoriesNeedingTopicExtractionOp} passes it: that path clears the
+ * flag off rows whose curation is provably empty, and a `setMemoryEntitiesOp`
+ * committing in the gap would have written a real record the autotagger must not
+ * be handed. The user-facing reset leaves it off — resetting a memory that HAS
+ * curated topics is the whole point there.
  */
-declare function clearMemoryTopicsOverrideOp(ctx: VaultMemoryOperationsContext, memoryId: string): Promise<boolean>;
+declare function clearMemoryTopicsOverrideOp(ctx: VaultMemoryOperationsContext, memoryId: string, options?: {
+    unlessTopicsRecorded?: boolean;
+}): Promise<boolean>;
 /**
  * Set a memory's People Nearby visibility (and optionally its twin opt-in).
  *
@@ -7500,6 +7510,12 @@ declare function getUnfiledVaultMemoriesOp(ctx: VaultMemoryOperationsContext): P
  * older version (including pre-v37 rows, read as version 0) is then re-extracted
  * by the next sweep, so topic-quality improvements propagate across the existing
  * vault. The worker's `limit` drains that re-extraction across sweeps.
+ *
+ * Bumping this is a WHOLE-VAULT re-extraction: the gate is unconditional across
+ * every stamped row, and `stampTopicsExtractedAtOp` stamps this version on every
+ * healthy row, so a bump sends each user's entire extracted vault back to the
+ * LLM. Never reach for it to repair a subset — see the pre-v42-restore repair in
+ * {@link getMemoriesNeedingTopicExtractionOp}, which targets the damaged rows.
  */
 declare const TOPICS_EXTRACTION_VERSION = 3;
 /**
@@ -7512,9 +7528,10 @@ interface MemoriesNeedingTopicExtraction {
      * Memories to run LLM topic extraction on (decrypted): never-extracted rows
      * with no entity links, plus stamped rows edited since their last pass
      * (`updated_at` > `topics_extracted_at`) or extracted under an older
-     * `topics_extracted_version` than {@link TOPICS_EXTRACTION_VERSION}. Edited /
-     * stale-version rows come first (they get priority under `limit`), each group
-     * newest-created first.
+     * `topics_extracted_version` than {@link TOPICS_EXTRACTION_VERSION}, plus the
+     * pre-v42-restore repair: a stamped row left with neither links nor a `topics`
+     * record, which no no-LLM bucket can reach. Edited / stale-version rows come
+     * first (they get priority under `limit`), each group newest-created first.
      */
     pending: StoredVaultMemory[];
     /**
@@ -7566,6 +7583,11 @@ interface MemoriesNeedingTopicExtraction {
  * between the record and the index and never re-derive them. That's why the
  * ownership filter lives in the partition below rather than in the query: a
  * restored curated memory is exactly the row whose index must be rebuilt.
+ *
+ * NOT purely a read: a curated row with no `topics` record AND no usable link is
+ * a contradiction only a pre-v42 restore produces, and this is the one place
+ * that can see all three facts at once, so it clears the flag there (capped by
+ * `limit`) before returning. See the branch for why that's safe.
  */
 declare function getMemoriesNeedingTopicExtractionOp(ctx: VaultMemoryOperationsContext, options?: {
     limit?: number;

package/dist/react/index.d.ts

@@ -7457,8 +7457,18 @@ declare function setMemoryEntitiesOp(ctx: VaultMemoryOperationsContext, memoryId
  * see the schema note. This op's version-invalidation trick is the reason the
  * earlier plan to exclude them from sync was dropped, and it's the last piece
  * that has to move before they can go.
+ *
+ * `options.unlessTopicsRecorded` declines the reset when the row already has a
+ * `topics` record, re-checked INSIDE the serialized writer. Only the repair path
+ * in {@link getMemoriesNeedingTopicExtractionOp} passes it: that path clears the
+ * flag off rows whose curation is provably empty, and a `setMemoryEntitiesOp`
+ * committing in the gap would have written a real record the autotagger must not
+ * be handed. The user-facing reset leaves it off — resetting a memory that HAS
+ * curated topics is the whole point there.
  */
-declare function clearMemoryTopicsOverrideOp(ctx: VaultMemoryOperationsContext, memoryId: string): Promise<boolean>;
+declare function clearMemoryTopicsOverrideOp(ctx: VaultMemoryOperationsContext, memoryId: string, options?: {
+    unlessTopicsRecorded?: boolean;
+}): Promise<boolean>;
 /**
  * Set a memory's People Nearby visibility (and optionally its twin opt-in).
  *
@@ -7500,6 +7510,12 @@ declare function getUnfiledVaultMemoriesOp(ctx: VaultMemoryOperationsContext): P
  * older version (including pre-v37 rows, read as version 0) is then re-extracted
  * by the next sweep, so topic-quality improvements propagate across the existing
  * vault. The worker's `limit` drains that re-extraction across sweeps.
+ *
+ * Bumping this is a WHOLE-VAULT re-extraction: the gate is unconditional across
+ * every stamped row, and `stampTopicsExtractedAtOp` stamps this version on every
+ * healthy row, so a bump sends each user's entire extracted vault back to the
+ * LLM. Never reach for it to repair a subset — see the pre-v42-restore repair in
+ * {@link getMemoriesNeedingTopicExtractionOp}, which targets the damaged rows.
  */
 declare const TOPICS_EXTRACTION_VERSION = 3;
 /**
@@ -7512,9 +7528,10 @@ interface MemoriesNeedingTopicExtraction {
      * Memories to run LLM topic extraction on (decrypted): never-extracted rows
      * with no entity links, plus stamped rows edited since their last pass
      * (`updated_at` > `topics_extracted_at`) or extracted under an older
-     * `topics_extracted_version` than {@link TOPICS_EXTRACTION_VERSION}. Edited /
-     * stale-version rows come first (they get priority under `limit`), each group
-     * newest-created first.
+     * `topics_extracted_version` than {@link TOPICS_EXTRACTION_VERSION}, plus the
+     * pre-v42-restore repair: a stamped row left with neither links nor a `topics`
+     * record, which no no-LLM bucket can reach. Edited / stale-version rows come
+     * first (they get priority under `limit`), each group newest-created first.
      */
     pending: StoredVaultMemory[];
     /**
@@ -7566,6 +7583,11 @@ interface MemoriesNeedingTopicExtraction {
  * between the record and the index and never re-derive them. That's why the
  * ownership filter lives in the partition below rather than in the query: a
  * restored curated memory is exactly the row whose index must be rebuilt.
+ *
+ * NOT purely a read: a curated row with no `topics` record AND no usable link is
+ * a contradiction only a pre-v42 restore produces, and this is the one place
+ * that can see all three facts at once, so it clears the flag there (capped by
+ * `limit`) before returning. See the branch for why that's safe.
  */
 declare function getMemoriesNeedingTopicExtractionOp(ctx: VaultMemoryOperationsContext, options?: {
     limit?: number;

package/dist/react/index.mjs

@@ -161,7 +161,7 @@ import {
   updateVaultMemoryOp,
   useEncryption,
   vaultMemoryToStored
-} from "./chunk-XXCZVG4Z.mjs";
+} from "./chunk-BS7C4CUW.mjs";
 import {
   PiiRedactor,
   createStreamingDeAnonymizer,
@@ -7490,7 +7490,7 @@ async function tryConsolidate(trimmed, ctx, options, prepared) {
     content: m.content,
     similarity: m.similarity
   }));
-  const { consolidateMemory: doConsolidate } = await import("./consolidate-R6FH7XMV.mjs");
+  const { consolidateMemory: doConsolidate } = await import("./consolidate-IFIKT25Z.mjs");
   const decision = await doConsolidate(trimmed, candidates, consolidateOptions);
   if (decision.action === "create") return null;
   if (decision.action === "supersede" && decision.content) {

package/dist/{expo/recall-O65PGPIQ.mjs → react/recall-WXCZHXHZ.mjs}

@@ -1,6 +1,6 @@
 import {
   recall
-} from "./chunk-BOAKGY4R.mjs";
+} from "./chunk-BS7C4CUW.mjs";
 import "./chunk-ILAWDQDE.mjs";
 import "./chunk-GYKJOWEO.mjs";
 export {