@anuma/sdk 6.41.0 → 6.42.0

package/dist/expo/index.cjs

@@ -21843,12 +21843,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 +21866,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 +21877,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 +21897,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 +21923,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 +21938,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 +21983,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 +22063,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

@@ -9821,6 +9821,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 +9880,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

@@ -9821,6 +9821,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 +9880,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

@@ -20206,12 +20206,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 +20229,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 +20240,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 +20260,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 +20286,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 +20301,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 +20346,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 +20426,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

@@ -25216,12 +25216,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 +25239,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 +25250,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 +25270,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 +25296,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 +25311,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 +25356,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 +25436,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

@@ -12057,6 +12057,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 +12116,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

@@ -12057,6 +12057,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 +12116,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

@@ -23308,12 +23308,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 +23331,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 +23342,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 +23362,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 +23388,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 +23403,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 +23448,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 +23528,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.0",
   "description": "",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",