@anuma/sdk 6.41.0 → 6.42.1

package/dist/expo/index.cjs

@@ -20196,6 +20196,8 @@ var queryFields = [
   "memory_ids",
   "topics",
   "updated_after",
+  "topics_due",
+  "topics_extracted",
   "order",
   "cursor",
   "limit",
@@ -21083,11 +21085,6 @@ function sameTopics(stored2, next) {
   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)));
 }
@@ -21336,17 +21333,16 @@ function createRemoteMemoryStore(options) {
   };
   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;
+      const due = (extracted2, max) => pages(
+        metadata,
+        { order: "created", topics_due: TOPICS_EXTRACTION_VERSION, topics_extracted: extracted2 },
+        max
+      );
+      const stale = await due(true, limit);
+      const fresh = stale.length < limit ? await due(false, limit - stale.length) : [];
       return {
-        pending: [...stale, ...fresh].slice(0, limit).map((uniqueId) => ({ uniqueId })),
+        pending: [...stale, ...fresh].map(({ memory }) => ({ uniqueId: memory.memory_id })),
         linkedUnstamped: [],
         topicsToRelink: [],
         topicsBackfill: []
@@ -21843,12 +21839,19 @@ var FACET_STRUCTURED_RESPONSE_HINT = {
   interests: `, "interests": <the same interests as an array of at most ${NEARBY_MAX_INTERESTS} strings of at most ${NEARBY_MAX_INTEREST_CODEPOINTS} characters each, e.g. ["trail running", "film photography"], or []>`
 };
 async function synthesizeProfile(ctx, options = {}) {
-  if (!ctx.vaultCtx) {
-    throw new Error("synthesizeProfile requires ctx.vaultCtx (vault-backed facts).");
+  const { store } = options;
+  const vaultCtx = ctx.vaultCtx;
+  if (!store && !vaultCtx) {
+    throw new Error(
+      "synthesizeProfile requires options.store or ctx.vaultCtx (vault-backed facts)."
+    );
   }
-  if (!ctx.vaultCache) {
-    throw new Error("synthesizeProfile requires ctx.vaultCache (semantic fact recall).");
+  if (!store && !ctx.vaultCache) {
+    throw new Error(
+      "synthesizeProfile requires options.store or ctx.vaultCache (semantic fact recall)."
+    );
   }
+  const recallCtx = store ? { embeddingOptions: ctx.embeddingOptions, factSource: store.factSource } : ctx;
   const facets = options.facets ?? DEFAULT_PROFILE_FACETS;
   const scopes = options.scopes ?? DEFAULT_SCOPES;
   const config = {
@@ -21859,11 +21862,8 @@ async function synthesizeProfile(ctx, options = {}) {
     reviewedMemoryIdsSignature: reviewedMemoryIdsSignature(options.reviewedMemoryIds)
   };
   const previous = options.previous && options.previous.version === PROFILE_DOC_VERSION && configMatches(options.previous.config, config) ? options.previous : void 0;
-  const memories = await getAllVaultMemoriesOp(ctx.vaultCtx, {
-    scopes,
-    includeDeleted: true,
-    includeSuperseded: true
-  });
+  const listOptions = { scopes, includeDeleted: true, includeSuperseded: true };
+  const [memories, projections] = store ? await Promise.all([store.list(listOptions), store.listProjections(listOptions)]) : [await getAllVaultMemoriesOp(vaultCtx, listOptions), []];
   const watermark = computeVaultWatermark(memories);
   const observationTrends = summarizeObservationTrends(
     memories.filter((m) => !m.isDeleted && m.supersededBy === null).map((m) => ({
@@ -21873,11 +21873,14 @@ async function synthesizeProfile(ctx, options = {}) {
     }))
   );
   const presentIds = new Set(memories.map((m) => m.uniqueId));
+  const unreadableMemoryIds = projections.map((p) => p.uniqueId).filter((id) => !presentIds.has(id)).sort();
+  const previousUnreadable = new Set(previous?.unreadableMemoryIds ?? []);
+  const sameUnreadable = unreadableMemoryIds.length === previousUnreadable.size && unreadableMemoryIds.every((id) => previousUnreadable.has(id));
   const hasStaleSections = previous?.sections.some((s) => s.stale);
   const citesMissingFact = previous?.sections.some(
     (s) => s.sourceMemoryIds.some((id) => !presentIds.has(id))
   );
-  if (previous && previous.vaultWatermark === watermark && !hasStaleSections && !citesMissingFact) {
+  if (previous && previous.vaultWatermark === watermark && !hasStaleSections && !citesMissingFact && sameUnreadable) {
     const sameOrder = previous.sections.length === facets.length && facets.every((f, i) => previous.sections[i]?.key === f.key);
     if (sameOrder) {
       if (trendsEqual(previous.observationTrends, observationTrends)) return previous;
@@ -21890,12 +21893,13 @@ async function synthesizeProfile(ctx, options = {}) {
     };
   }
   const staleKeys = await computeStaleFacetKeys(
-    ctx,
+    recallCtx,
     memories,
     facets,
     previous,
     watermark,
-    options.reviewedMemoryIds
+    options.reviewedMemoryIds,
+    previousUnreadable
   );
   const memoriesById = new Map(memories.map((memory) => [memory.uniqueId, memory]));
   const fallbackPriors = /* @__PURE__ */ new Map();
@@ -21915,7 +21919,7 @@ async function synthesizeProfile(ctx, options = {}) {
       if (prior && !staleKeys.has(facet.key)) {
         return prior;
       }
-      return synthesizeFacet(facet, ctx, options, fallbackPriors.get(facet.key));
+      return synthesizeFacet(facet, recallCtx, options, fallbackPriors.get(facet.key));
     })
   );
   const sections = settled.map((r, i) => {
@@ -21930,12 +21934,18 @@ async function synthesizeProfile(ctx, options = {}) {
     );
     return fallbackSection(facet, fallbackPriors.get(facet.key));
   });
+  if (!sameUnreadable && unreadableMemoryIds.length > 0) {
+    getLogger().warn("[memory/synthesizeProfile] some memories could not be read", {
+      unreadable: unreadableMemoryIds.length
+    });
+  }
   return {
     version: PROFILE_DOC_VERSION,
     sections,
     vaultWatermark: watermark,
     config,
     observationTrends,
+    ...unreadableMemoryIds.length > 0 && { unreadableMemoryIds },
     generatedAt: Date.now()
   };
 }
@@ -21969,11 +21979,13 @@ function computeVaultWatermark(memories) {
   }
   return max;
 }
-async function computeStaleFacetKeys(ctx, memories, facets, previous, watermark, reviewedMemoryIds) {
+async function computeStaleFacetKeys(ctx, memories, facets, previous, watermark, reviewedMemoryIds, previouslyUnreadable) {
   const allKeys = new Set(facets.map((f) => f.key));
   if (previous && watermark < previous.vaultWatermark) return allKeys;
   if (!previous) return allKeys;
-  const changed = memories.filter((m) => changeTime(m) > previous.vaultWatermark);
+  const changed = memories.filter(
+    (m) => changeTime(m) > previous.vaultWatermark || previouslyUnreadable.has(m.uniqueId)
+  );
   const changedIds = new Set(changed.map((m) => m.uniqueId));
   const presentIds = new Set(memories.map((m) => m.uniqueId));
   const stale = /* @__PURE__ */ new Set();
@@ -22047,7 +22059,12 @@ async function attributeFacts(ctx, candidates, facets) {
   for (const fv of factVectors) {
     let matchedAny = false;
     for (let i = 0; i < facets.length; i++) {
-      if (cosineSimilarity(fv, queryVectors[i]) >= NEW_FACT_ATTRIBUTION_MIN_SCORE) {
+      const query = queryVectors[i];
+      const similarity = cosineSimilarity(
+        fv,
+        fv.length < query.length ? query.slice(0, fv.length) : query
+      );
+      if (similarity >= NEW_FACT_ATTRIBUTION_MIN_SCORE) {
         keys.add(facets[i].key);
         matchedAny = true;
       }

package/dist/expo/index.d.mts

@@ -9590,6 +9590,8 @@ interface RemoteMemoryQueryOptions extends RemoteMemoryReadFilters {
     memory_ids?: string[];
     topics?: string[];
     updated_after?: number;
+    topics_due?: number;
+    topics_extracted?: boolean;
     order?: "created" | "updated" | "archived" | "changed";
     cursor?: string;
     limit?: number;
@@ -9821,6 +9823,12 @@ interface ProfileDoc {
      * without another LLM pass. Recomputed every synthesis (not delta-cached).
      */
     observationTrends: Record<ObservationTrend, number>;
+    /**
+     * Sorted ids the store listed but could not decrypt at synthesis time.
+     * Absent when every memory was readable. A later call regenerates only when
+     * this set changes, and attributes a memory once it becomes readable.
+     */
+    unreadableMemoryIds?: string[];
     /** Unix ms this doc was produced. */
     generatedAt: number;
 }
@@ -9874,6 +9882,12 @@ interface SynthesizeProfileOptions extends PortalLlmAuth {
      * never accidentally disable the gate by finding it empty.
      */
     reviewedMemoryIds?: readonly string[];
+    /**
+     * Read facts and recall through this store instead of `ctx.vaultCtx` and
+     * `ctx.vaultCache`, so a remote store works. Only `ctx.embeddingOptions` is
+     * then read from `ctx`.
+     */
+    store?: Pick<MemoryStore, "list" | "listProjections" | "factSource">;
 }
 /**
  * Synthesize a shareable {@link ProfileDoc} from the user's vault, on-device.

package/dist/expo/index.d.ts

@@ -9590,6 +9590,8 @@ interface RemoteMemoryQueryOptions extends RemoteMemoryReadFilters {
     memory_ids?: string[];
     topics?: string[];
     updated_after?: number;
+    topics_due?: number;
+    topics_extracted?: boolean;
     order?: "created" | "updated" | "archived" | "changed";
     cursor?: string;
     limit?: number;
@@ -9821,6 +9823,12 @@ interface ProfileDoc {
      * without another LLM pass. Recomputed every synthesis (not delta-cached).
      */
     observationTrends: Record<ObservationTrend, number>;
+    /**
+     * Sorted ids the store listed but could not decrypt at synthesis time.
+     * Absent when every memory was readable. A later call regenerates only when
+     * this set changes, and attributes a memory once it becomes readable.
+     */
+    unreadableMemoryIds?: string[];
     /** Unix ms this doc was produced. */
     generatedAt: number;
 }
@@ -9874,6 +9882,12 @@ interface SynthesizeProfileOptions extends PortalLlmAuth {
      * never accidentally disable the gate by finding it empty.
      */
     reviewedMemoryIds?: readonly string[];
+    /**
+     * Read facts and recall through this store instead of `ctx.vaultCtx` and
+     * `ctx.vaultCache`, so a remote store works. Only `ctx.embeddingOptions` is
+     * then read from `ctx`.
+     */
+    store?: Pick<MemoryStore, "list" | "listProjections" | "factSource">;
 }
 /**
  * Synthesize a shareable {@link ProfileDoc} from the user's vault, on-device.

package/dist/expo/index.mjs

@@ -18563,6 +18563,8 @@ var queryFields = [
   "memory_ids",
   "topics",
   "updated_after",
+  "topics_due",
+  "topics_extracted",
   "order",
   "cursor",
   "limit",
@@ -19448,11 +19450,6 @@ function sameTopics(stored2, next) {
   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)));
 }
@@ -19701,17 +19698,16 @@ function createRemoteMemoryStore(options) {
   };
   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;
+      const due = (extracted2, max) => pages(
+        metadata,
+        { order: "created", topics_due: TOPICS_EXTRACTION_VERSION, topics_extracted: extracted2 },
+        max
+      );
+      const stale = await due(true, limit);
+      const fresh = stale.length < limit ? await due(false, limit - stale.length) : [];
       return {
-        pending: [...stale, ...fresh].slice(0, limit).map((uniqueId) => ({ uniqueId })),
+        pending: [...stale, ...fresh].map(({ memory }) => ({ uniqueId: memory.memory_id })),
         linkedUnstamped: [],
         topicsToRelink: [],
         topicsBackfill: []
@@ -20206,12 +20202,19 @@ var FACET_STRUCTURED_RESPONSE_HINT = {
   interests: `, "interests": <the same interests as an array of at most ${NEARBY_MAX_INTERESTS} strings of at most ${NEARBY_MAX_INTEREST_CODEPOINTS} characters each, e.g. ["trail running", "film photography"], or []>`
 };
 async function synthesizeProfile(ctx, options = {}) {
-  if (!ctx.vaultCtx) {
-    throw new Error("synthesizeProfile requires ctx.vaultCtx (vault-backed facts).");
+  const { store } = options;
+  const vaultCtx = ctx.vaultCtx;
+  if (!store && !vaultCtx) {
+    throw new Error(
+      "synthesizeProfile requires options.store or ctx.vaultCtx (vault-backed facts)."
+    );
   }
-  if (!ctx.vaultCache) {
-    throw new Error("synthesizeProfile requires ctx.vaultCache (semantic fact recall).");
+  if (!store && !ctx.vaultCache) {
+    throw new Error(
+      "synthesizeProfile requires options.store or ctx.vaultCache (semantic fact recall)."
+    );
   }
+  const recallCtx = store ? { embeddingOptions: ctx.embeddingOptions, factSource: store.factSource } : ctx;
   const facets = options.facets ?? DEFAULT_PROFILE_FACETS;
   const scopes = options.scopes ?? DEFAULT_SCOPES;
   const config = {
@@ -20222,11 +20225,8 @@ async function synthesizeProfile(ctx, options = {}) {
     reviewedMemoryIdsSignature: reviewedMemoryIdsSignature(options.reviewedMemoryIds)
   };
   const previous = options.previous && options.previous.version === PROFILE_DOC_VERSION && configMatches(options.previous.config, config) ? options.previous : void 0;
-  const memories = await getAllVaultMemoriesOp(ctx.vaultCtx, {
-    scopes,
-    includeDeleted: true,
-    includeSuperseded: true
-  });
+  const listOptions = { scopes, includeDeleted: true, includeSuperseded: true };
+  const [memories, projections] = store ? await Promise.all([store.list(listOptions), store.listProjections(listOptions)]) : [await getAllVaultMemoriesOp(vaultCtx, listOptions), []];
   const watermark = computeVaultWatermark(memories);
   const observationTrends = summarizeObservationTrends(
     memories.filter((m) => !m.isDeleted && m.supersededBy === null).map((m) => ({
@@ -20236,11 +20236,14 @@ async function synthesizeProfile(ctx, options = {}) {
     }))
   );
   const presentIds = new Set(memories.map((m) => m.uniqueId));
+  const unreadableMemoryIds = projections.map((p) => p.uniqueId).filter((id) => !presentIds.has(id)).sort();
+  const previousUnreadable = new Set(previous?.unreadableMemoryIds ?? []);
+  const sameUnreadable = unreadableMemoryIds.length === previousUnreadable.size && unreadableMemoryIds.every((id) => previousUnreadable.has(id));
   const hasStaleSections = previous?.sections.some((s) => s.stale);
   const citesMissingFact = previous?.sections.some(
     (s) => s.sourceMemoryIds.some((id) => !presentIds.has(id))
   );
-  if (previous && previous.vaultWatermark === watermark && !hasStaleSections && !citesMissingFact) {
+  if (previous && previous.vaultWatermark === watermark && !hasStaleSections && !citesMissingFact && sameUnreadable) {
     const sameOrder = previous.sections.length === facets.length && facets.every((f, i) => previous.sections[i]?.key === f.key);
     if (sameOrder) {
       if (trendsEqual(previous.observationTrends, observationTrends)) return previous;
@@ -20253,12 +20256,13 @@ async function synthesizeProfile(ctx, options = {}) {
     };
   }
   const staleKeys = await computeStaleFacetKeys(
-    ctx,
+    recallCtx,
     memories,
     facets,
     previous,
     watermark,
-    options.reviewedMemoryIds
+    options.reviewedMemoryIds,
+    previousUnreadable
   );
   const memoriesById = new Map(memories.map((memory) => [memory.uniqueId, memory]));
   const fallbackPriors = /* @__PURE__ */ new Map();
@@ -20278,7 +20282,7 @@ async function synthesizeProfile(ctx, options = {}) {
       if (prior && !staleKeys.has(facet.key)) {
         return prior;
       }
-      return synthesizeFacet(facet, ctx, options, fallbackPriors.get(facet.key));
+      return synthesizeFacet(facet, recallCtx, options, fallbackPriors.get(facet.key));
     })
   );
   const sections = settled.map((r, i) => {
@@ -20293,12 +20297,18 @@ async function synthesizeProfile(ctx, options = {}) {
     );
     return fallbackSection(facet, fallbackPriors.get(facet.key));
   });
+  if (!sameUnreadable && unreadableMemoryIds.length > 0) {
+    getLogger().warn("[memory/synthesizeProfile] some memories could not be read", {
+      unreadable: unreadableMemoryIds.length
+    });
+  }
   return {
     version: PROFILE_DOC_VERSION,
     sections,
     vaultWatermark: watermark,
     config,
     observationTrends,
+    ...unreadableMemoryIds.length > 0 && { unreadableMemoryIds },
     generatedAt: Date.now()
   };
 }
@@ -20332,11 +20342,13 @@ function computeVaultWatermark(memories) {
   }
   return max;
 }
-async function computeStaleFacetKeys(ctx, memories, facets, previous, watermark, reviewedMemoryIds) {
+async function computeStaleFacetKeys(ctx, memories, facets, previous, watermark, reviewedMemoryIds, previouslyUnreadable) {
   const allKeys = new Set(facets.map((f) => f.key));
   if (previous && watermark < previous.vaultWatermark) return allKeys;
   if (!previous) return allKeys;
-  const changed = memories.filter((m) => changeTime(m) > previous.vaultWatermark);
+  const changed = memories.filter(
+    (m) => changeTime(m) > previous.vaultWatermark || previouslyUnreadable.has(m.uniqueId)
+  );
   const changedIds = new Set(changed.map((m) => m.uniqueId));
   const presentIds = new Set(memories.map((m) => m.uniqueId));
   const stale = /* @__PURE__ */ new Set();
@@ -20410,7 +20422,12 @@ async function attributeFacts(ctx, candidates, facets) {
   for (const fv of factVectors) {
     let matchedAny = false;
     for (let i = 0; i < facets.length; i++) {
-      if (cosineSimilarity(fv, queryVectors[i]) >= NEW_FACT_ATTRIBUTION_MIN_SCORE) {
+      const query = queryVectors[i];
+      const similarity = cosineSimilarity(
+        fv,
+        fv.length < query.length ? query.slice(0, fv.length) : query
+      );
+      if (similarity >= NEW_FACT_ATTRIBUTION_MIN_SCORE) {
         keys.add(facets[i].key);
         matchedAny = true;
       }

package/dist/react/index.cjs

@@ -23569,6 +23569,8 @@ var queryFields = [
   "memory_ids",
   "topics",
   "updated_after",
+  "topics_due",
+  "topics_extracted",
   "order",
   "cursor",
   "limit",
@@ -24456,11 +24458,6 @@ function sameTopics(stored2, next) {
   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)));
 }
@@ -24709,17 +24706,16 @@ function createRemoteMemoryStore(options) {
   };
   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;
+      const due = (extracted2, max) => pages(
+        metadata,
+        { order: "created", topics_due: TOPICS_EXTRACTION_VERSION, topics_extracted: extracted2 },
+        max
+      );
+      const stale = await due(true, limit);
+      const fresh = stale.length < limit ? await due(false, limit - stale.length) : [];
       return {
-        pending: [...stale, ...fresh].slice(0, limit).map((uniqueId) => ({ uniqueId })),
+        pending: [...stale, ...fresh].map(({ memory }) => ({ uniqueId: memory.memory_id })),
         linkedUnstamped: [],
         topicsToRelink: [],
         topicsBackfill: []
@@ -25216,12 +25212,19 @@ var FACET_STRUCTURED_RESPONSE_HINT = {
   interests: `, "interests": <the same interests as an array of at most ${NEARBY_MAX_INTERESTS} strings of at most ${NEARBY_MAX_INTEREST_CODEPOINTS} characters each, e.g. ["trail running", "film photography"], or []>`
 };
 async function synthesizeProfile(ctx, options = {}) {
-  if (!ctx.vaultCtx) {
-    throw new Error("synthesizeProfile requires ctx.vaultCtx (vault-backed facts).");
+  const { store } = options;
+  const vaultCtx = ctx.vaultCtx;
+  if (!store && !vaultCtx) {
+    throw new Error(
+      "synthesizeProfile requires options.store or ctx.vaultCtx (vault-backed facts)."
+    );
   }
-  if (!ctx.vaultCache) {
-    throw new Error("synthesizeProfile requires ctx.vaultCache (semantic fact recall).");
+  if (!store && !ctx.vaultCache) {
+    throw new Error(
+      "synthesizeProfile requires options.store or ctx.vaultCache (semantic fact recall)."
+    );
   }
+  const recallCtx = store ? { embeddingOptions: ctx.embeddingOptions, factSource: store.factSource } : ctx;
   const facets = options.facets ?? DEFAULT_PROFILE_FACETS;
   const scopes = options.scopes ?? DEFAULT_SCOPES;
   const config = {
@@ -25232,11 +25235,8 @@ async function synthesizeProfile(ctx, options = {}) {
     reviewedMemoryIdsSignature: reviewedMemoryIdsSignature(options.reviewedMemoryIds)
   };
   const previous = options.previous && options.previous.version === PROFILE_DOC_VERSION && configMatches(options.previous.config, config) ? options.previous : void 0;
-  const memories = await getAllVaultMemoriesOp(ctx.vaultCtx, {
-    scopes,
-    includeDeleted: true,
-    includeSuperseded: true
-  });
+  const listOptions = { scopes, includeDeleted: true, includeSuperseded: true };
+  const [memories, projections] = store ? await Promise.all([store.list(listOptions), store.listProjections(listOptions)]) : [await getAllVaultMemoriesOp(vaultCtx, listOptions), []];
   const watermark = computeVaultWatermark(memories);
   const observationTrends = summarizeObservationTrends(
     memories.filter((m) => !m.isDeleted && m.supersededBy === null).map((m) => ({
@@ -25246,11 +25246,14 @@ async function synthesizeProfile(ctx, options = {}) {
     }))
   );
   const presentIds = new Set(memories.map((m) => m.uniqueId));
+  const unreadableMemoryIds = projections.map((p) => p.uniqueId).filter((id) => !presentIds.has(id)).sort();
+  const previousUnreadable = new Set(previous?.unreadableMemoryIds ?? []);
+  const sameUnreadable = unreadableMemoryIds.length === previousUnreadable.size && unreadableMemoryIds.every((id) => previousUnreadable.has(id));
   const hasStaleSections = previous?.sections.some((s) => s.stale);
   const citesMissingFact = previous?.sections.some(
     (s) => s.sourceMemoryIds.some((id) => !presentIds.has(id))
   );
-  if (previous && previous.vaultWatermark === watermark && !hasStaleSections && !citesMissingFact) {
+  if (previous && previous.vaultWatermark === watermark && !hasStaleSections && !citesMissingFact && sameUnreadable) {
     const sameOrder = previous.sections.length === facets.length && facets.every((f, i) => previous.sections[i]?.key === f.key);
     if (sameOrder) {
       if (trendsEqual(previous.observationTrends, observationTrends)) return previous;
@@ -25263,12 +25266,13 @@ async function synthesizeProfile(ctx, options = {}) {
     };
   }
   const staleKeys = await computeStaleFacetKeys(
-    ctx,
+    recallCtx,
     memories,
     facets,
     previous,
     watermark,
-    options.reviewedMemoryIds
+    options.reviewedMemoryIds,
+    previousUnreadable
   );
   const memoriesById = new Map(memories.map((memory) => [memory.uniqueId, memory]));
   const fallbackPriors = /* @__PURE__ */ new Map();
@@ -25288,7 +25292,7 @@ async function synthesizeProfile(ctx, options = {}) {
       if (prior && !staleKeys.has(facet.key)) {
         return prior;
       }
-      return synthesizeFacet(facet, ctx, options, fallbackPriors.get(facet.key));
+      return synthesizeFacet(facet, recallCtx, options, fallbackPriors.get(facet.key));
     })
   );
   const sections = settled.map((r, i) => {
@@ -25303,12 +25307,18 @@ async function synthesizeProfile(ctx, options = {}) {
     );
     return fallbackSection(facet, fallbackPriors.get(facet.key));
   });
+  if (!sameUnreadable && unreadableMemoryIds.length > 0) {
+    getLogger().warn("[memory/synthesizeProfile] some memories could not be read", {
+      unreadable: unreadableMemoryIds.length
+    });
+  }
   return {
     version: PROFILE_DOC_VERSION,
     sections,
     vaultWatermark: watermark,
     config,
     observationTrends,
+    ...unreadableMemoryIds.length > 0 && { unreadableMemoryIds },
     generatedAt: Date.now()
   };
 }
@@ -25342,11 +25352,13 @@ function computeVaultWatermark(memories) {
   }
   return max;
 }
-async function computeStaleFacetKeys(ctx, memories, facets, previous, watermark, reviewedMemoryIds) {
+async function computeStaleFacetKeys(ctx, memories, facets, previous, watermark, reviewedMemoryIds, previouslyUnreadable) {
   const allKeys = new Set(facets.map((f) => f.key));
   if (previous && watermark < previous.vaultWatermark) return allKeys;
   if (!previous) return allKeys;
-  const changed = memories.filter((m) => changeTime(m) > previous.vaultWatermark);
+  const changed = memories.filter(
+    (m) => changeTime(m) > previous.vaultWatermark || previouslyUnreadable.has(m.uniqueId)
+  );
   const changedIds = new Set(changed.map((m) => m.uniqueId));
   const presentIds = new Set(memories.map((m) => m.uniqueId));
   const stale = /* @__PURE__ */ new Set();
@@ -25420,7 +25432,12 @@ async function attributeFacts(ctx, candidates, facets) {
   for (const fv of factVectors) {
     let matchedAny = false;
     for (let i = 0; i < facets.length; i++) {
-      if (cosineSimilarity(fv, queryVectors[i]) >= NEW_FACT_ATTRIBUTION_MIN_SCORE) {
+      const query = queryVectors[i];
+      const similarity = cosineSimilarity(
+        fv,
+        fv.length < query.length ? query.slice(0, fv.length) : query
+      );
+      if (similarity >= NEW_FACT_ATTRIBUTION_MIN_SCORE) {
         keys.add(facets[i].key);
         matchedAny = true;
       }

package/dist/react/index.d.mts

@@ -11826,6 +11826,8 @@ interface RemoteMemoryQueryOptions extends RemoteMemoryReadFilters {
     memory_ids?: string[];
     topics?: string[];
     updated_after?: number;
+    topics_due?: number;
+    topics_extracted?: boolean;
     order?: "created" | "updated" | "archived" | "changed";
     cursor?: string;
     limit?: number;
@@ -12057,6 +12059,12 @@ interface ProfileDoc {
      * without another LLM pass. Recomputed every synthesis (not delta-cached).
      */
     observationTrends: Record<ObservationTrend, number>;
+    /**
+     * Sorted ids the store listed but could not decrypt at synthesis time.
+     * Absent when every memory was readable. A later call regenerates only when
+     * this set changes, and attributes a memory once it becomes readable.
+     */
+    unreadableMemoryIds?: string[];
     /** Unix ms this doc was produced. */
     generatedAt: number;
 }
@@ -12110,6 +12118,12 @@ interface SynthesizeProfileOptions extends PortalLlmAuth {
      * never accidentally disable the gate by finding it empty.
      */
     reviewedMemoryIds?: readonly string[];
+    /**
+     * Read facts and recall through this store instead of `ctx.vaultCtx` and
+     * `ctx.vaultCache`, so a remote store works. Only `ctx.embeddingOptions` is
+     * then read from `ctx`.
+     */
+    store?: Pick<MemoryStore, "list" | "listProjections" | "factSource">;
 }
 /**
  * Synthesize a shareable {@link ProfileDoc} from the user's vault, on-device.

package/dist/react/index.d.ts

@@ -11826,6 +11826,8 @@ interface RemoteMemoryQueryOptions extends RemoteMemoryReadFilters {
     memory_ids?: string[];
     topics?: string[];
     updated_after?: number;
+    topics_due?: number;
+    topics_extracted?: boolean;
     order?: "created" | "updated" | "archived" | "changed";
     cursor?: string;
     limit?: number;
@@ -12057,6 +12059,12 @@ interface ProfileDoc {
      * without another LLM pass. Recomputed every synthesis (not delta-cached).
      */
     observationTrends: Record<ObservationTrend, number>;
+    /**
+     * Sorted ids the store listed but could not decrypt at synthesis time.
+     * Absent when every memory was readable. A later call regenerates only when
+     * this set changes, and attributes a memory once it becomes readable.
+     */
+    unreadableMemoryIds?: string[];
     /** Unix ms this doc was produced. */
     generatedAt: number;
 }
@@ -12110,6 +12118,12 @@ interface SynthesizeProfileOptions extends PortalLlmAuth {
      * never accidentally disable the gate by finding it empty.
      */
     reviewedMemoryIds?: readonly string[];
+    /**
+     * Read facts and recall through this store instead of `ctx.vaultCtx` and
+     * `ctx.vaultCache`, so a remote store works. Only `ctx.embeddingOptions` is
+     * then read from `ctx`.
+     */
+    store?: Pick<MemoryStore, "list" | "listProjections" | "factSource">;
 }
 /**
  * Synthesize a shareable {@link ProfileDoc} from the user's vault, on-device.

package/dist/react/index.mjs

@@ -21665,6 +21665,8 @@ var queryFields = [
   "memory_ids",
   "topics",
   "updated_after",
+  "topics_due",
+  "topics_extracted",
   "order",
   "cursor",
   "limit",
@@ -22550,11 +22552,6 @@ function sameTopics(stored2, next) {
   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)));
 }
@@ -22803,17 +22800,16 @@ function createRemoteMemoryStore(options) {
   };
   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;
+      const due = (extracted2, max) => pages(
+        metadata,
+        { order: "created", topics_due: TOPICS_EXTRACTION_VERSION, topics_extracted: extracted2 },
+        max
+      );
+      const stale = await due(true, limit);
+      const fresh = stale.length < limit ? await due(false, limit - stale.length) : [];
       return {
-        pending: [...stale, ...fresh].slice(0, limit).map((uniqueId) => ({ uniqueId })),
+        pending: [...stale, ...fresh].map(({ memory }) => ({ uniqueId: memory.memory_id })),
         linkedUnstamped: [],
         topicsToRelink: [],
         topicsBackfill: []
@@ -23308,12 +23304,19 @@ var FACET_STRUCTURED_RESPONSE_HINT = {
   interests: `, "interests": <the same interests as an array of at most ${NEARBY_MAX_INTERESTS} strings of at most ${NEARBY_MAX_INTEREST_CODEPOINTS} characters each, e.g. ["trail running", "film photography"], or []>`
 };
 async function synthesizeProfile(ctx, options = {}) {
-  if (!ctx.vaultCtx) {
-    throw new Error("synthesizeProfile requires ctx.vaultCtx (vault-backed facts).");
+  const { store } = options;
+  const vaultCtx = ctx.vaultCtx;
+  if (!store && !vaultCtx) {
+    throw new Error(
+      "synthesizeProfile requires options.store or ctx.vaultCtx (vault-backed facts)."
+    );
   }
-  if (!ctx.vaultCache) {
-    throw new Error("synthesizeProfile requires ctx.vaultCache (semantic fact recall).");
+  if (!store && !ctx.vaultCache) {
+    throw new Error(
+      "synthesizeProfile requires options.store or ctx.vaultCache (semantic fact recall)."
+    );
   }
+  const recallCtx = store ? { embeddingOptions: ctx.embeddingOptions, factSource: store.factSource } : ctx;
   const facets = options.facets ?? DEFAULT_PROFILE_FACETS;
   const scopes = options.scopes ?? DEFAULT_SCOPES;
   const config = {
@@ -23324,11 +23327,8 @@ async function synthesizeProfile(ctx, options = {}) {
     reviewedMemoryIdsSignature: reviewedMemoryIdsSignature(options.reviewedMemoryIds)
   };
   const previous = options.previous && options.previous.version === PROFILE_DOC_VERSION && configMatches(options.previous.config, config) ? options.previous : void 0;
-  const memories = await getAllVaultMemoriesOp(ctx.vaultCtx, {
-    scopes,
-    includeDeleted: true,
-    includeSuperseded: true
-  });
+  const listOptions = { scopes, includeDeleted: true, includeSuperseded: true };
+  const [memories, projections] = store ? await Promise.all([store.list(listOptions), store.listProjections(listOptions)]) : [await getAllVaultMemoriesOp(vaultCtx, listOptions), []];
   const watermark = computeVaultWatermark(memories);
   const observationTrends = summarizeObservationTrends(
     memories.filter((m) => !m.isDeleted && m.supersededBy === null).map((m) => ({
@@ -23338,11 +23338,14 @@ async function synthesizeProfile(ctx, options = {}) {
     }))
   );
   const presentIds = new Set(memories.map((m) => m.uniqueId));
+  const unreadableMemoryIds = projections.map((p) => p.uniqueId).filter((id) => !presentIds.has(id)).sort();
+  const previousUnreadable = new Set(previous?.unreadableMemoryIds ?? []);
+  const sameUnreadable = unreadableMemoryIds.length === previousUnreadable.size && unreadableMemoryIds.every((id) => previousUnreadable.has(id));
   const hasStaleSections = previous?.sections.some((s) => s.stale);
   const citesMissingFact = previous?.sections.some(
     (s) => s.sourceMemoryIds.some((id) => !presentIds.has(id))
   );
-  if (previous && previous.vaultWatermark === watermark && !hasStaleSections && !citesMissingFact) {
+  if (previous && previous.vaultWatermark === watermark && !hasStaleSections && !citesMissingFact && sameUnreadable) {
     const sameOrder = previous.sections.length === facets.length && facets.every((f, i) => previous.sections[i]?.key === f.key);
     if (sameOrder) {
       if (trendsEqual(previous.observationTrends, observationTrends)) return previous;
@@ -23355,12 +23358,13 @@ async function synthesizeProfile(ctx, options = {}) {
     };
   }
   const staleKeys = await computeStaleFacetKeys(
-    ctx,
+    recallCtx,
     memories,
     facets,
     previous,
     watermark,
-    options.reviewedMemoryIds
+    options.reviewedMemoryIds,
+    previousUnreadable
   );
   const memoriesById = new Map(memories.map((memory) => [memory.uniqueId, memory]));
   const fallbackPriors = /* @__PURE__ */ new Map();
@@ -23380,7 +23384,7 @@ async function synthesizeProfile(ctx, options = {}) {
       if (prior && !staleKeys.has(facet.key)) {
         return prior;
       }
-      return synthesizeFacet(facet, ctx, options, fallbackPriors.get(facet.key));
+      return synthesizeFacet(facet, recallCtx, options, fallbackPriors.get(facet.key));
     })
   );
   const sections = settled.map((r, i) => {
@@ -23395,12 +23399,18 @@ async function synthesizeProfile(ctx, options = {}) {
     );
     return fallbackSection(facet, fallbackPriors.get(facet.key));
   });
+  if (!sameUnreadable && unreadableMemoryIds.length > 0) {
+    getLogger().warn("[memory/synthesizeProfile] some memories could not be read", {
+      unreadable: unreadableMemoryIds.length
+    });
+  }
   return {
     version: PROFILE_DOC_VERSION,
     sections,
     vaultWatermark: watermark,
     config,
     observationTrends,
+    ...unreadableMemoryIds.length > 0 && { unreadableMemoryIds },
     generatedAt: Date.now()
   };
 }
@@ -23434,11 +23444,13 @@ function computeVaultWatermark(memories) {
   }
   return max;
 }
-async function computeStaleFacetKeys(ctx, memories, facets, previous, watermark, reviewedMemoryIds) {
+async function computeStaleFacetKeys(ctx, memories, facets, previous, watermark, reviewedMemoryIds, previouslyUnreadable) {
   const allKeys = new Set(facets.map((f) => f.key));
   if (previous && watermark < previous.vaultWatermark) return allKeys;
   if (!previous) return allKeys;
-  const changed = memories.filter((m) => changeTime(m) > previous.vaultWatermark);
+  const changed = memories.filter(
+    (m) => changeTime(m) > previous.vaultWatermark || previouslyUnreadable.has(m.uniqueId)
+  );
   const changedIds = new Set(changed.map((m) => m.uniqueId));
   const presentIds = new Set(memories.map((m) => m.uniqueId));
   const stale = /* @__PURE__ */ new Set();
@@ -23512,7 +23524,12 @@ async function attributeFacts(ctx, candidates, facets) {
   for (const fv of factVectors) {
     let matchedAny = false;
     for (let i = 0; i < facets.length; i++) {
-      if (cosineSimilarity(fv, queryVectors[i]) >= NEW_FACT_ATTRIBUTION_MIN_SCORE) {
+      const query = queryVectors[i];
+      const similarity = cosineSimilarity(
+        fv,
+        fv.length < query.length ? query.slice(0, fv.length) : query
+      );
+      if (similarity >= NEW_FACT_ATTRIBUTION_MIN_SCORE) {
         keys.add(facets[i].key);
         matchedAny = true;
       }

package/dist/server/index.cjs

@@ -35411,12 +35411,19 @@ var FACET_STRUCTURED_RESPONSE_HINT = {
   interests: `, "interests": <the same interests as an array of at most ${NEARBY_MAX_INTERESTS} strings of at most ${NEARBY_MAX_INTEREST_CODEPOINTS} characters each, e.g. ["trail running", "film photography"], or []>`
 };
 async function synthesizeProfile(ctx, options = {}) {
-  if (!ctx.vaultCtx) {
-    throw new Error("synthesizeProfile requires ctx.vaultCtx (vault-backed facts).");
+  const { store } = options;
+  const vaultCtx = ctx.vaultCtx;
+  if (!store && !vaultCtx) {
+    throw new Error(
+      "synthesizeProfile requires options.store or ctx.vaultCtx (vault-backed facts)."
+    );
   }
-  if (!ctx.vaultCache) {
-    throw new Error("synthesizeProfile requires ctx.vaultCache (semantic fact recall).");
+  if (!store && !ctx.vaultCache) {
+    throw new Error(
+      "synthesizeProfile requires options.store or ctx.vaultCache (semantic fact recall)."
+    );
   }
+  const recallCtx = store ? { embeddingOptions: ctx.embeddingOptions, factSource: store.factSource } : ctx;
   const facets = options.facets ?? DEFAULT_PROFILE_FACETS;
   const scopes = options.scopes ?? DEFAULT_SCOPES;
   const config = {
@@ -35427,11 +35434,8 @@ async function synthesizeProfile(ctx, options = {}) {
     reviewedMemoryIdsSignature: reviewedMemoryIdsSignature(options.reviewedMemoryIds)
   };
   const previous = options.previous && options.previous.version === PROFILE_DOC_VERSION && configMatches(options.previous.config, config) ? options.previous : void 0;
-  const memories = await getAllVaultMemoriesOp(ctx.vaultCtx, {
-    scopes,
-    includeDeleted: true,
-    includeSuperseded: true
-  });
+  const listOptions = { scopes, includeDeleted: true, includeSuperseded: true };
+  const [memories, projections] = store ? await Promise.all([store.list(listOptions), store.listProjections(listOptions)]) : [await getAllVaultMemoriesOp(vaultCtx, listOptions), []];
   const watermark = computeVaultWatermark(memories);
   const observationTrends = summarizeObservationTrends(
     memories.filter((m) => !m.isDeleted && m.supersededBy === null).map((m) => ({
@@ -35441,11 +35445,14 @@ async function synthesizeProfile(ctx, options = {}) {
     }))
   );
   const presentIds = new Set(memories.map((m) => m.uniqueId));
+  const unreadableMemoryIds = projections.map((p) => p.uniqueId).filter((id) => !presentIds.has(id)).sort();
+  const previousUnreadable = new Set(previous?.unreadableMemoryIds ?? []);
+  const sameUnreadable = unreadableMemoryIds.length === previousUnreadable.size && unreadableMemoryIds.every((id) => previousUnreadable.has(id));
   const hasStaleSections = previous?.sections.some((s) => s.stale);
   const citesMissingFact = previous?.sections.some(
     (s) => s.sourceMemoryIds.some((id) => !presentIds.has(id))
   );
-  if (previous && previous.vaultWatermark === watermark && !hasStaleSections && !citesMissingFact) {
+  if (previous && previous.vaultWatermark === watermark && !hasStaleSections && !citesMissingFact && sameUnreadable) {
     const sameOrder = previous.sections.length === facets.length && facets.every((f, i) => previous.sections[i]?.key === f.key);
     if (sameOrder) {
       if (trendsEqual(previous.observationTrends, observationTrends)) return previous;
@@ -35458,12 +35465,13 @@ async function synthesizeProfile(ctx, options = {}) {
     };
   }
   const staleKeys = await computeStaleFacetKeys(
-    ctx,
+    recallCtx,
     memories,
     facets,
     previous,
     watermark,
-    options.reviewedMemoryIds
+    options.reviewedMemoryIds,
+    previousUnreadable
   );
   const memoriesById = new Map(memories.map((memory) => [memory.uniqueId, memory]));
   const fallbackPriors = /* @__PURE__ */ new Map();
@@ -35483,7 +35491,7 @@ async function synthesizeProfile(ctx, options = {}) {
       if (prior && !staleKeys.has(facet.key)) {
         return prior;
       }
-      return synthesizeFacet(facet, ctx, options, fallbackPriors.get(facet.key));
+      return synthesizeFacet(facet, recallCtx, options, fallbackPriors.get(facet.key));
     })
   );
   const sections = settled.map((r, i) => {
@@ -35498,12 +35506,18 @@ async function synthesizeProfile(ctx, options = {}) {
     );
     return fallbackSection(facet, fallbackPriors.get(facet.key));
   });
+  if (!sameUnreadable && unreadableMemoryIds.length > 0) {
+    getLogger().warn("[memory/synthesizeProfile] some memories could not be read", {
+      unreadable: unreadableMemoryIds.length
+    });
+  }
   return {
     version: PROFILE_DOC_VERSION,
     sections,
     vaultWatermark: watermark,
     config,
     observationTrends,
+    ...unreadableMemoryIds.length > 0 && { unreadableMemoryIds },
     generatedAt: Date.now()
   };
 }
@@ -35537,11 +35551,13 @@ function computeVaultWatermark(memories) {
   }
   return max;
 }
-async function computeStaleFacetKeys(ctx, memories, facets, previous, watermark, reviewedMemoryIds) {
+async function computeStaleFacetKeys(ctx, memories, facets, previous, watermark, reviewedMemoryIds, previouslyUnreadable) {
   const allKeys = new Set(facets.map((f) => f.key));
   if (previous && watermark < previous.vaultWatermark) return allKeys;
   if (!previous) return allKeys;
-  const changed = memories.filter((m) => changeTime(m) > previous.vaultWatermark);
+  const changed = memories.filter(
+    (m) => changeTime(m) > previous.vaultWatermark || previouslyUnreadable.has(m.uniqueId)
+  );
   const changedIds = new Set(changed.map((m) => m.uniqueId));
   const presentIds = new Set(memories.map((m) => m.uniqueId));
   const stale = /* @__PURE__ */ new Set();
@@ -35615,7 +35631,12 @@ async function attributeFacts(ctx, candidates, facets) {
   for (const fv of factVectors) {
     let matchedAny = false;
     for (let i = 0; i < facets.length; i++) {
-      if (cosineSimilarity(fv, queryVectors[i]) >= NEW_FACT_ATTRIBUTION_MIN_SCORE) {
+      const query = queryVectors[i];
+      const similarity = cosineSimilarity(
+        fv,
+        fv.length < query.length ? query.slice(0, fv.length) : query
+      );
+      if (similarity >= NEW_FACT_ATTRIBUTION_MIN_SCORE) {
         keys.add(facets[i].key);
         matchedAny = true;
       }

package/dist/server/index.d.mts

@@ -9766,6 +9766,12 @@ interface ProfileDoc {
      * without another LLM pass. Recomputed every synthesis (not delta-cached).
      */
     observationTrends: Record<ObservationTrend, number>;
+    /**
+     * Sorted ids the store listed but could not decrypt at synthesis time.
+     * Absent when every memory was readable. A later call regenerates only when
+     * this set changes, and attributes a memory once it becomes readable.
+     */
+    unreadableMemoryIds?: string[];
     /** Unix ms this doc was produced. */
     generatedAt: number;
 }
@@ -9819,6 +9825,12 @@ interface SynthesizeProfileOptions extends PortalLlmAuth {
      * never accidentally disable the gate by finding it empty.
      */
     reviewedMemoryIds?: readonly string[];
+    /**
+     * Read facts and recall through this store instead of `ctx.vaultCtx` and
+     * `ctx.vaultCache`, so a remote store works. Only `ctx.embeddingOptions` is
+     * then read from `ctx`.
+     */
+    store?: Pick<MemoryStore, "list" | "listProjections" | "factSource">;
 }
 /**
  * Synthesize a shareable {@link ProfileDoc} from the user's vault, on-device.

package/dist/server/index.d.ts

@@ -9766,6 +9766,12 @@ interface ProfileDoc {
      * without another LLM pass. Recomputed every synthesis (not delta-cached).
      */
     observationTrends: Record<ObservationTrend, number>;
+    /**
+     * Sorted ids the store listed but could not decrypt at synthesis time.
+     * Absent when every memory was readable. A later call regenerates only when
+     * this set changes, and attributes a memory once it becomes readable.
+     */
+    unreadableMemoryIds?: string[];
     /** Unix ms this doc was produced. */
     generatedAt: number;
 }
@@ -9819,6 +9825,12 @@ interface SynthesizeProfileOptions extends PortalLlmAuth {
      * never accidentally disable the gate by finding it empty.
      */
     reviewedMemoryIds?: readonly string[];
+    /**
+     * Read facts and recall through this store instead of `ctx.vaultCtx` and
+     * `ctx.vaultCache`, so a remote store works. Only `ctx.embeddingOptions` is
+     * then read from `ctx`.
+     */
+    store?: Pick<MemoryStore, "list" | "listProjections" | "factSource">;
 }
 /**
  * Synthesize a shareable {@link ProfileDoc} from the user's vault, on-device.

package/dist/server/index.mjs

@@ -33686,12 +33686,19 @@ var FACET_STRUCTURED_RESPONSE_HINT = {
   interests: `, "interests": <the same interests as an array of at most ${NEARBY_MAX_INTERESTS} strings of at most ${NEARBY_MAX_INTEREST_CODEPOINTS} characters each, e.g. ["trail running", "film photography"], or []>`
 };
 async function synthesizeProfile(ctx, options = {}) {
-  if (!ctx.vaultCtx) {
-    throw new Error("synthesizeProfile requires ctx.vaultCtx (vault-backed facts).");
+  const { store } = options;
+  const vaultCtx = ctx.vaultCtx;
+  if (!store && !vaultCtx) {
+    throw new Error(
+      "synthesizeProfile requires options.store or ctx.vaultCtx (vault-backed facts)."
+    );
   }
-  if (!ctx.vaultCache) {
-    throw new Error("synthesizeProfile requires ctx.vaultCache (semantic fact recall).");
+  if (!store && !ctx.vaultCache) {
+    throw new Error(
+      "synthesizeProfile requires options.store or ctx.vaultCache (semantic fact recall)."
+    );
   }
+  const recallCtx = store ? { embeddingOptions: ctx.embeddingOptions, factSource: store.factSource } : ctx;
   const facets = options.facets ?? DEFAULT_PROFILE_FACETS;
   const scopes = options.scopes ?? DEFAULT_SCOPES;
   const config = {
@@ -33702,11 +33709,8 @@ async function synthesizeProfile(ctx, options = {}) {
     reviewedMemoryIdsSignature: reviewedMemoryIdsSignature(options.reviewedMemoryIds)
   };
   const previous = options.previous && options.previous.version === PROFILE_DOC_VERSION && configMatches(options.previous.config, config) ? options.previous : void 0;
-  const memories = await getAllVaultMemoriesOp(ctx.vaultCtx, {
-    scopes,
-    includeDeleted: true,
-    includeSuperseded: true
-  });
+  const listOptions = { scopes, includeDeleted: true, includeSuperseded: true };
+  const [memories, projections] = store ? await Promise.all([store.list(listOptions), store.listProjections(listOptions)]) : [await getAllVaultMemoriesOp(vaultCtx, listOptions), []];
   const watermark = computeVaultWatermark(memories);
   const observationTrends = summarizeObservationTrends(
     memories.filter((m) => !m.isDeleted && m.supersededBy === null).map((m) => ({
@@ -33716,11 +33720,14 @@ async function synthesizeProfile(ctx, options = {}) {
     }))
   );
   const presentIds = new Set(memories.map((m) => m.uniqueId));
+  const unreadableMemoryIds = projections.map((p) => p.uniqueId).filter((id) => !presentIds.has(id)).sort();
+  const previousUnreadable = new Set(previous?.unreadableMemoryIds ?? []);
+  const sameUnreadable = unreadableMemoryIds.length === previousUnreadable.size && unreadableMemoryIds.every((id) => previousUnreadable.has(id));
   const hasStaleSections = previous?.sections.some((s) => s.stale);
   const citesMissingFact = previous?.sections.some(
     (s) => s.sourceMemoryIds.some((id) => !presentIds.has(id))
   );
-  if (previous && previous.vaultWatermark === watermark && !hasStaleSections && !citesMissingFact) {
+  if (previous && previous.vaultWatermark === watermark && !hasStaleSections && !citesMissingFact && sameUnreadable) {
     const sameOrder = previous.sections.length === facets.length && facets.every((f, i) => previous.sections[i]?.key === f.key);
     if (sameOrder) {
       if (trendsEqual(previous.observationTrends, observationTrends)) return previous;
@@ -33733,12 +33740,13 @@ async function synthesizeProfile(ctx, options = {}) {
     };
   }
   const staleKeys = await computeStaleFacetKeys(
-    ctx,
+    recallCtx,
     memories,
     facets,
     previous,
     watermark,
-    options.reviewedMemoryIds
+    options.reviewedMemoryIds,
+    previousUnreadable
   );
   const memoriesById = new Map(memories.map((memory) => [memory.uniqueId, memory]));
   const fallbackPriors = /* @__PURE__ */ new Map();
@@ -33758,7 +33766,7 @@ async function synthesizeProfile(ctx, options = {}) {
       if (prior && !staleKeys.has(facet.key)) {
         return prior;
       }
-      return synthesizeFacet(facet, ctx, options, fallbackPriors.get(facet.key));
+      return synthesizeFacet(facet, recallCtx, options, fallbackPriors.get(facet.key));
     })
   );
   const sections = settled.map((r, i) => {
@@ -33773,12 +33781,18 @@ async function synthesizeProfile(ctx, options = {}) {
     );
     return fallbackSection(facet, fallbackPriors.get(facet.key));
   });
+  if (!sameUnreadable && unreadableMemoryIds.length > 0) {
+    getLogger().warn("[memory/synthesizeProfile] some memories could not be read", {
+      unreadable: unreadableMemoryIds.length
+    });
+  }
   return {
     version: PROFILE_DOC_VERSION,
     sections,
     vaultWatermark: watermark,
     config,
     observationTrends,
+    ...unreadableMemoryIds.length > 0 && { unreadableMemoryIds },
     generatedAt: Date.now()
   };
 }
@@ -33812,11 +33826,13 @@ function computeVaultWatermark(memories) {
   }
   return max;
 }
-async function computeStaleFacetKeys(ctx, memories, facets, previous, watermark, reviewedMemoryIds) {
+async function computeStaleFacetKeys(ctx, memories, facets, previous, watermark, reviewedMemoryIds, previouslyUnreadable) {
   const allKeys = new Set(facets.map((f) => f.key));
   if (previous && watermark < previous.vaultWatermark) return allKeys;
   if (!previous) return allKeys;
-  const changed = memories.filter((m) => changeTime(m) > previous.vaultWatermark);
+  const changed = memories.filter(
+    (m) => changeTime(m) > previous.vaultWatermark || previouslyUnreadable.has(m.uniqueId)
+  );
   const changedIds = new Set(changed.map((m) => m.uniqueId));
   const presentIds = new Set(memories.map((m) => m.uniqueId));
   const stale = /* @__PURE__ */ new Set();
@@ -33890,7 +33906,12 @@ async function attributeFacts(ctx, candidates, facets) {
   for (const fv of factVectors) {
     let matchedAny = false;
     for (let i = 0; i < facets.length; i++) {
-      if (cosineSimilarity(fv, queryVectors[i]) >= NEW_FACT_ATTRIBUTION_MIN_SCORE) {
+      const query = queryVectors[i];
+      const similarity = cosineSimilarity(
+        fv,
+        fv.length < query.length ? query.slice(0, fv.length) : query
+      );
+      if (similarity >= NEW_FACT_ATTRIBUTION_MIN_SCORE) {
         keys.add(facets[i].key);
         matchedAny = true;
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anuma/sdk",
-  "version": "6.41.0",
+  "version": "6.42.1",
   "description": "",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",