@anuma/sdk 3.11.2 → 3.11.3

package/dist/expo/{chunk-7CTI3XR6.mjs → chunk-7AW2VD5W.mjs}

@@ -4273,6 +4273,11 @@ function applyMMR(candidates, k, lambda = 0.5) {
   return selected;
 }
 
+// src/lib/memory/recallConstants.ts
+var RECALL_TOOL_NAME = "recall_memory";
+var RECALL_MAX_LIMIT = 50;
+var EMBEDDINGS_DEGRADED_EMPTY = "Semantic memory search is temporarily unavailable, so only keyword matching ran and it found no matches. Do not conclude the user has no such memory \u2014 say the memory lookup was degraded, or retry with different keywords.";
+
 // src/lib/memory/recency.ts
 var DAY_MS = 1e3 * 60 * 60 * 24;
 var DEFAULT_PER_YEAR_DECAY = 0.2;
@@ -5255,6 +5260,24 @@ async function eagerEmbedContent(content, embeddingOptions, cache, vaultCtx, mem
     );
   }
 }
+async function embedQueryOrDegrade(query, embeddingOptions, onDegraded) {
+  try {
+    const embedding = await generateEmbedding(query, embeddingOptions);
+    if (embedding.length === 0) {
+      getLogger().warn(
+        "memoryVault: query embedding came back empty \u2014 falling back to BM25-only ranking for this search"
+      );
+      onDegraded?.();
+    }
+    return embedding;
+  } catch (err) {
+    getLogger().warn(
+      "memoryVault: query embedding failed \u2014 falling back to BM25-only ranking for this search: " + (err instanceof Error ? err.message : String(err))
+    );
+    onDegraded?.();
+    return [];
+  }
+}
 function admitVaultProjections(queryEmbedding, vectored, k) {
   return vectored.map((it) => ({ it, score: cosineSimilarity(queryEmbedding, it.embedding) })).sort((a, b) => b.score - a.score || b.it.updatedAt.getTime() - a.it.updatedAt.getTime()).slice(0, k).map((s) => s.it.uniqueId);
 }
@@ -5266,23 +5289,36 @@ async function buildProjectedCorpus(query, vaultCtx, embeddingOptions, cache, qu
   const hydrateOpts = queryOpts.includeArchived ? { includeArchived: true } : void 0;
   const vaultSize = keys.length;
   if (keys.length === 0) {
-    return { memories: [], embeddedItems: [], queryEmbedding: [], vaultSize: 0 };
+    return {
+      memories: [],
+      embeddedItems: [],
+      queryEmbedding: [],
+      vaultSize: 0,
+      laneEmbedFailed: false
+    };
   }
-  const queryEmbedding = await generateEmbedding(query, embeddingOptions);
+  const queryEmbedding = await embedQueryOrDegrade(
+    query,
+    embeddingOptions,
+    opts.onEmbeddingDegraded
+  );
+  const embeddingsDegraded = queryEmbedding.length === 0;
   const currentModel = embeddingOptions.model ?? DEFAULT_API_EMBEDDING_MODEL;
   const vectored = [];
   const missIds = [];
   const noVectorIds = [];
   const keyById = new Map(keys.map((k2) => [k2.uniqueId, k2]));
-  for (const k2 of keys) {
-    const cached = cache.get(k2.uniqueId);
-    if (cached && cached.length === queryEmbedding.length) {
-      vectored.push({ uniqueId: k2.uniqueId, embedding: cached, updatedAt: k2.updatedAt });
-      continue;
+  if (!embeddingsDegraded) {
+    for (const k2 of keys) {
+      const cached = cache.get(k2.uniqueId);
+      if (cached && cached.length === queryEmbedding.length) {
+        vectored.push({ uniqueId: k2.uniqueId, embedding: cached, updatedAt: k2.updatedAt });
+        continue;
+      }
+      const modelCompatible = (k2.embeddingModel ?? currentModel) === currentModel;
+      if (modelCompatible) missIds.push(k2.uniqueId);
+      else noVectorIds.push(k2.uniqueId);
     }
-    const modelCompatible = (k2.embeddingModel ?? currentModel) === currentModel;
-    if (modelCompatible) missIds.push(k2.uniqueId);
-    else noVectorIds.push(k2.uniqueId);
   }
   if (missIds.length > 0) {
     const rows = await getVaultEmbeddingsByIdsOp(vaultCtx, missIds, hydrateOpts);
@@ -5303,6 +5339,7 @@ async function buildProjectedCorpus(query, vaultCtx, embeddingOptions, cache, qu
     }
     for (const id of missIds) if (!gotVector.has(id)) noVectorIds.push(id);
   }
+  let laneEmbedFailed = false;
   if (noVectorIds.length > 0) {
     const laneIds = noVectorIds.slice(0, opts.unembeddedCap);
     if (noVectorIds.length > laneIds.length) {
@@ -5314,26 +5351,44 @@ async function buildProjectedCorpus(query, vaultCtx, embeddingOptions, cache, qu
       (m) => !isEncrypted(m.content)
     );
     if (laneRows.length > 0) {
-      const laneVecs = await generateEmbeddings(
-        laneRows.map((m) => m.content),
-        embeddingOptions
-      );
-      laneRows.forEach((m, i) => {
-        const vec = Float32Array.from(laneVecs[i]);
-        cache.set(m.uniqueId, vec);
-        vectored.push({ uniqueId: m.uniqueId, embedding: vec, updatedAt: m.updatedAt });
-        updateVaultMemoryEmbeddingOp(
-          vaultCtx,
-          m.uniqueId,
-          JSON.stringify(laneVecs[i]),
-          currentModel
-        ).catch(() => {
+      let laneVecs;
+      try {
+        laneVecs = await generateEmbeddings(
+          laneRows.map((m) => m.content),
+          embeddingOptions
+        );
+      } catch (err) {
+        laneEmbedFailed = true;
+        getLogger().warn(
+          `memoryVault: un-embedded lane embedding failed for ${laneRows.length} rows \u2014 they rank on BM25 alone for this search: ` + (err instanceof Error ? err.message : String(err))
+        );
+      }
+      if (laneVecs) {
+        const vecs = laneVecs;
+        laneRows.forEach((m, i) => {
+          const vec = Float32Array.from(vecs[i]);
+          cache.set(m.uniqueId, vec);
+          vectored.push({ uniqueId: m.uniqueId, embedding: vec, updatedAt: m.updatedAt });
+          updateVaultMemoryEmbeddingOp(
+            vaultCtx,
+            m.uniqueId,
+            JSON.stringify(vecs[i]),
+            currentModel
+          ).catch(() => {
+          });
         });
-      });
+      }
     }
   }
   const k = Math.max(opts.limit * opts.admitFactor, opts.admitFloor);
   const admittedIds = admitVaultProjections(queryEmbedding, vectored, k);
+  if ((embeddingsDegraded || laneEmbedFailed) && admittedIds.length < k) {
+    const already = new Set(admittedIds);
+    for (const key of [...keys].sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime())) {
+      if (admittedIds.length >= k) break;
+      if (!already.has(key.uniqueId)) admittedIds.push(key.uniqueId);
+    }
+  }
   const admissionSet = new Set(admittedIds);
   if (opts.forceIncludeIds) {
     for (const id of opts.forceIncludeIds) {
@@ -5361,11 +5416,18 @@ async function buildProjectedCorpus(query, vaultCtx, embeddingOptions, cache, qu
     eventTimeKind: normalizeEventTimeKind(m.eventTimeKind),
     factType: m.factType
   }));
-  return { memories, embeddedItems, queryEmbedding, vaultSize };
+  return { memories, embeddedItems, queryEmbedding, vaultSize, laneEmbedFailed };
 }
 async function prepareVaultCandidates(query, vaultCtx, embeddingOptions, cache, searchOptions) {
   if (!query || typeof query !== "string") {
-    return { memories: [], embeddedItems: [], queryEmbedding: [], vaultSize: 0 };
+    return {
+      memories: [],
+      embeddedItems: [],
+      queryEmbedding: [],
+      vaultSize: 0,
+      embeddingsUnavailable: false,
+      embeddingFailure: false
+    };
   }
   const limit = searchOptions?.limit ?? 5;
   const scopes = searchOptions?.scopes;
@@ -5382,6 +5444,12 @@ async function prepareVaultCandidates(query, vaultCtx, embeddingOptions, cache,
   let embeddedItems;
   let queryEmbedding;
   let vaultSize;
+  let embeddingsUnavailable = false;
+  let embeddingFailure = false;
+  const onEmbeddingDegraded = () => {
+    embeddingsUnavailable = true;
+    embeddingFailure = true;
+  };
   if (searchOptions?.decryptLast) {
     const forceIncludeIds = [
       ...searchOptions.entityRanking ?? [],
@@ -5392,14 +5460,30 @@ async function prepareVaultCandidates(query, vaultCtx, embeddingOptions, cache,
       admitFactor: ADMIT_FACTOR,
       admitFloor: ADMIT_FLOOR,
       unembeddedCap: UNEMBEDDED_CAP,
-      ...forceIncludeIds.length > 0 && { forceIncludeIds }
+      ...forceIncludeIds.length > 0 && { forceIncludeIds },
+      onEmbeddingDegraded
     });
     if (corpus.vaultSize === 0) {
-      return { memories: [], embeddedItems: [], queryEmbedding: [], vaultSize: 0 };
+      return {
+        memories: [],
+        embeddedItems: [],
+        queryEmbedding: [],
+        vaultSize: 0,
+        embeddingsUnavailable: false,
+        embeddingFailure: false
+      };
     }
     ({ memories, embeddedItems, queryEmbedding, vaultSize } = corpus);
+    if (corpus.laneEmbedFailed) embeddingFailure = true;
     if (memories.length === 0) {
-      return { memories: [], embeddedItems: [], queryEmbedding: [], vaultSize };
+      return {
+        memories: [],
+        embeddedItems: [],
+        queryEmbedding: [],
+        vaultSize,
+        embeddingsUnavailable,
+        embeddingFailure
+      };
     }
   } else {
     const loaded = await getAllVaultMemoriesOp(
@@ -5414,14 +5498,21 @@ async function prepareVaultCandidates(query, vaultCtx, embeddingOptions, cache,
       );
     }
     if (memories.length === 0) {
-      return { memories: [], embeddedItems: [], queryEmbedding: [], vaultSize: loaded.length };
+      return {
+        memories: [],
+        embeddedItems: [],
+        queryEmbedding: [],
+        vaultSize: loaded.length,
+        embeddingsUnavailable: false,
+        embeddingFailure: false
+      };
     }
-    queryEmbedding = await generateEmbedding(query, embeddingOptions);
+    queryEmbedding = await embedQueryOrDegrade(query, embeddingOptions, onEmbeddingDegraded);
     const currentModel = embeddingOptions.model ?? DEFAULT_API_EMBEDDING_MODEL;
     const uncachedTexts = [];
     const uncachedIndices = [];
     let staleReembedCount = 0;
-    for (let i = 0; i < memories.length; i++) {
+    for (let i = 0; queryEmbedding.length > 0 && i < memories.length; i++) {
       const content = memories[i].content;
       const memoryId = memories[i].uniqueId;
       const cached = cache.get(memoryId);
@@ -5449,20 +5540,30 @@ async function prepareVaultCandidates(query, vaultCtx, embeddingOptions, cache,
       );
     }
     if (uncachedTexts.length > 0) {
-      const newEmbeddings = await generateEmbeddings(uncachedTexts, embeddingOptions);
-      for (let j = 0; j < uncachedTexts.length; j++) {
-        cache.set(memories[uncachedIndices[j]].uniqueId, Float32Array.from(newEmbeddings[j]));
-        updateVaultMemoryEmbeddingOp(
-          vaultCtx,
-          memories[uncachedIndices[j]].uniqueId,
-          JSON.stringify(newEmbeddings[j]),
-          currentModel
-        ).catch(
-          // Silently swallow – SDK must not use console.*; embedding will be retried on next search
-          () => {
-          }
+      let newEmbeddings;
+      try {
+        newEmbeddings = await generateEmbeddings(uncachedTexts, embeddingOptions);
+      } catch (err) {
+        embeddingFailure = true;
+        getLogger().warn(
+          `memoryVault: (re)embedding ${uncachedTexts.length} vault rows failed \u2014 they rank on BM25 alone for this search: ` + (err instanceof Error ? err.message : String(err))
         );
       }
+      if (newEmbeddings) {
+        for (let j = 0; j < uncachedTexts.length; j++) {
+          cache.set(memories[uncachedIndices[j]].uniqueId, Float32Array.from(newEmbeddings[j]));
+          updateVaultMemoryEmbeddingOp(
+            vaultCtx,
+            memories[uncachedIndices[j]].uniqueId,
+            JSON.stringify(newEmbeddings[j]),
+            currentModel
+          ).catch(
+            // Silently swallow – SDK must not use console.*; embedding will be retried on next search
+            () => {
+            }
+          );
+        }
+      }
     }
     embeddedItems = memories.map((m) => ({
       id: m.uniqueId,
@@ -5479,12 +5580,22 @@ async function prepareVaultCandidates(query, vaultCtx, embeddingOptions, cache,
       factType: m.factType
     }));
   }
-  return { memories, embeddedItems, queryEmbedding, vaultSize };
+  if (!embeddingsUnavailable && !embeddedItems.some((it) => it.embedding.length > 0)) {
+    embeddingsUnavailable = true;
+  }
+  return {
+    memories,
+    embeddedItems,
+    queryEmbedding,
+    vaultSize,
+    embeddingsUnavailable,
+    embeddingFailure
+  };
 }
 async function rankPreparedVaultCandidates(query, prepared, embeddingOptions, searchOptions) {
   const limit = searchOptions?.limit ?? 5;
   const minSimilarity = searchOptions?.minSimilarity ?? 0.1;
-  const { memories, embeddedItems, queryEmbedding, vaultSize } = prepared;
+  const { memories, embeddedItems, queryEmbedding, vaultSize, embeddingsUnavailable } = prepared;
   if (queryEmbedding.length > 0) {
     const mismatched = embeddedItems.filter(
       (it) => it.embedding.length > 0 && it.embedding.length !== queryEmbedding.length
@@ -5521,7 +5632,8 @@ async function rankPreparedVaultCandidates(query, prepared, embeddingOptions, se
       results: results2,
       vaultSize: out.vaultSize,
       reranked: out.reranked ?? false,
-      hadV2Head: out.hadV2Head ?? false
+      hadV2Head: out.hadV2Head ?? false,
+      embeddingsUnavailable
     };
   };
   const rerankStats = { applied: false };
@@ -5544,36 +5656,46 @@ async function rankPreparedVaultCandidates(query, prepared, embeddingOptions, se
     ...searchOptions?.rrfK !== void 0 && { rrfK: searchOptions.rrfK },
     ...searchOptions?.factTypeWeights && { factTypeWeights: searchOptions.factTypeWeights }
   };
-  if (useFusion && searchOptions?.decompose === "llm" && searchOptions.decomposeOptions) {
+  if (useFusion && !embeddingsUnavailable && searchOptions?.decompose === "llm" && searchOptions.decomposeOptions) {
     const decomp = await decomposeQuery(query, searchOptions.decomposeOptions);
     if (decomp.mode === "composite") {
-      const subEmbeddings = await generateEmbeddings(decomp.subQueries, embeddingOptions);
-      const subQueries = decomp.subQueries.map((sq, i) => ({
-        query: sq,
-        embedding: subEmbeddings[i]
-      }));
-      const v2HeadStats = { hadResults: false };
-      const composite = await rankComposite(query, queryEmbedding, subQueries, embeddedItems, {
-        limit,
-        minSimilarity,
-        rerank: !!searchOptions.rerank,
-        ...searchOptions.rerankTopN !== void 0 && {
-          rerankTopN: searchOptions.rerankTopN
-        },
-        ...searchOptions.ceWeight !== void 0 && { ceWeight: searchOptions.ceWeight },
-        ...searchOptions.mmr !== void 0 && { mmr: searchOptions.mmr },
-        ...tuning,
-        ...searchOptions.entityRanking && { entityRanking: searchOptions.entityRanking },
-        ...searchOptions.temporalRanking && { temporalRanking: searchOptions.temporalRanking },
-        rerankStats,
-        v2HeadStats
-      });
-      return stampTimestamps({
-        results: composite,
-        vaultSize,
-        reranked: rerankStats.applied,
-        hadV2Head: v2HeadStats.hadResults
-      });
+      let subEmbeddings;
+      try {
+        subEmbeddings = await generateEmbeddings(decomp.subQueries, embeddingOptions);
+      } catch (err) {
+        getLogger().warn(
+          "memoryVault: sub-query embedding failed \u2014 falling back to single-query ranking: " + (err instanceof Error ? err.message : String(err))
+        );
+        subEmbeddings = [];
+      }
+      if (subEmbeddings.length > 0) {
+        const subQueries = decomp.subQueries.map((sq, i) => ({
+          query: sq,
+          embedding: subEmbeddings[i]
+        }));
+        const v2HeadStats = { hadResults: false };
+        const composite = await rankComposite(query, queryEmbedding, subQueries, embeddedItems, {
+          limit,
+          minSimilarity,
+          rerank: !!searchOptions.rerank,
+          ...searchOptions.rerankTopN !== void 0 && {
+            rerankTopN: searchOptions.rerankTopN
+          },
+          ...searchOptions.ceWeight !== void 0 && { ceWeight: searchOptions.ceWeight },
+          ...searchOptions.mmr !== void 0 && { mmr: searchOptions.mmr },
+          ...tuning,
+          ...searchOptions.entityRanking && { entityRanking: searchOptions.entityRanking },
+          ...searchOptions.temporalRanking && { temporalRanking: searchOptions.temporalRanking },
+          rerankStats,
+          v2HeadStats
+        });
+        return stampTimestamps({
+          results: composite,
+          vaultSize,
+          reranked: rerankStats.applied,
+          hadV2Head: v2HeadStats.hadResults
+        });
+      }
     }
   }
   if (useFusion && searchOptions?.rerank) {
@@ -5624,7 +5746,14 @@ async function rankPreparedVaultCandidates(query, prepared, embeddingOptions, se
 }
 async function searchVaultMemoriesWithSize(query, vaultCtx, embeddingOptions, cache, searchOptions) {
   if (!query || typeof query !== "string") {
-    return { results: [], vaultSize: 0, reranked: false, hadV2Head: false };
+    return {
+      results: [],
+      vaultSize: 0,
+      reranked: false,
+      hadV2Head: false,
+      embeddingsUnavailable: false,
+      rankedOnCosine: false
+    };
   }
   const prepared = await prepareVaultCandidates(
     query,
@@ -5634,12 +5763,32 @@ async function searchVaultMemoriesWithSize(query, vaultCtx, embeddingOptions, ca
     searchOptions
   );
   if (prepared.vaultSize === 0) {
-    return { results: [], vaultSize: 0, reranked: false, hadV2Head: false };
+    return {
+      results: [],
+      vaultSize: 0,
+      reranked: false,
+      hadV2Head: false,
+      embeddingsUnavailable: prepared.embeddingsUnavailable,
+      rankedOnCosine: false
+    };
   }
   if (prepared.memories.length === 0) {
-    return { results: [], vaultSize: prepared.vaultSize, reranked: false, hadV2Head: false };
+    return {
+      results: [],
+      vaultSize: prepared.vaultSize,
+      reranked: false,
+      hadV2Head: false,
+      embeddingsUnavailable: prepared.embeddingsUnavailable,
+      rankedOnCosine: false
+    };
   }
-  return rankPreparedVaultCandidates(query, prepared, embeddingOptions, searchOptions);
+  const ranked = await rankPreparedVaultCandidates(
+    query,
+    prepared,
+    embeddingOptions,
+    searchOptions
+  );
+  return { ...ranked, rankedOnCosine: !ranked.embeddingsUnavailable };
 }
 async function searchVaultMemories(query, vaultCtx, embeddingOptions, cache, searchOptions) {
   const { results } = await searchVaultMemoriesWithSize(
@@ -5651,6 +5800,7 @@ async function searchVaultMemories(query, vaultCtx, embeddingOptions, cache, sea
   );
   return results;
 }
+var EMBEDDINGS_DEGRADED_EMPTY_NO_LEXICAL = "Memory search is temporarily unavailable \u2014 the semantic lookup failed and this search mode has no keyword fallback, so no memory search ran at all. Do not conclude the user has no such memory; say the memory lookup was unavailable.";
 function formatVaultHits(hits) {
   return hits.map((h, i) => `[${i + 1}] (id: ${h.id}, similarity: ${h.score.toFixed(2)})
 ${h.content}`).join("\n\n");
@@ -5713,26 +5863,36 @@ function createMemoryVaultSearchTool(vaultCtx, embeddingOptions, cache, searchOp
         const budget = searchOptions?.decompose === "llm" && searchOptions.decomposeOptions ? "high" : searchOptions?.rerank ? "mid" : "low";
         const folderId = searchOptions?.folderId ?? argFolderId;
         if (searchOptions?.useFusion === false) {
-          const legacy = await searchVaultMemories(query, vaultCtx, embeddingOptions, cache, {
-            limit: requestLimit,
-            minSimilarity,
-            useFusion: false,
-            ...tuningForward,
-            ...folderId !== void 0 && { folderId },
-            ...searchOptions?.scopes && { scopes: searchOptions.scopes }
-          });
+          const { results: legacy, embeddingsUnavailable } = await searchVaultMemoriesWithSize(
+            query,
+            vaultCtx,
+            embeddingOptions,
+            cache,
+            {
+              limit: requestLimit,
+              minSimilarity,
+              useFusion: false,
+              ...tuningForward,
+              ...folderId !== void 0 && { folderId },
+              ...searchOptions?.scopes && { scopes: searchOptions.scopes }
+            }
+          );
           if (legacy.length === 0) {
-            return "No relevant memories found in the vault.";
+            return embeddingsUnavailable ? EMBEDDINGS_DEGRADED_EMPTY_NO_LEXICAL : "No relevant memories found in the vault.";
           }
           return formatVaultHits(
             legacy.map((r) => ({ id: r.uniqueId, content: r.content, score: r.similarity }))
           );
         }
-        const { recall: recall2 } = await import("./recall-IBGUFY4P.mjs");
+        const { recall: recall2 } = await import("./recall-JWQ4IJX6.mjs");
+        let recallDegraded = [];
         const result = await recall2(
           query,
           { vaultCtx, embeddingOptions, vaultCache: cache },
           {
+            onDiagnostics: (d) => {
+              recallDegraded = d.degraded;
+            },
             types: ["fact"],
             limit: requestLimit,
             minScore: minSimilarity,
@@ -5753,7 +5913,7 @@ function createMemoryVaultSearchTool(vaultCtx, embeddingOptions, cache, searchOp
           return "The memory vault is empty. No memories have been saved yet.";
         }
         if (result.memories.length === 0) {
-          return "No relevant memories found in the vault.";
+          return recallDegraded.includes("embeddings-unavailable") ? EMBEDDINGS_DEGRADED_EMPTY : "No relevant memories found in the vault.";
         }
         const formatted = formatVaultHits(
           result.memories.map((m) => ({
@@ -6308,6 +6468,9 @@ async function recall(query, ctx, options = {}) {
   let vaultSize;
   let didRerank = false;
   let hadV2Head = false;
+  let embeddingsUnavailable = false;
+  let chunkEmbedFailed = false;
+  let factLaneRankedOnCosine = false;
   const emitDiagnostics = (candidateCount) => {
     const cb = options.onDiagnostics;
     if (!cb) return;
@@ -6316,6 +6479,7 @@ async function recall(query, ctx, options = {}) {
       degraded.push("rerank-unavailable");
     }
     if (flags.decompose && !decomposeAvailable) degraded.push("decompose-unavailable");
+    if (embeddingsUnavailable) degraded.push("embeddings-unavailable");
     const diagnostics = {
       usedBudget,
       reranked: didRerank,
@@ -6346,7 +6510,26 @@ async function recall(query, ctx, options = {}) {
   const graphRefiner = flags.traverse && options.graphRefine && options.decomposeOptions ? createLlmNeighborRefiner(options.decomposeOptions) : void 0;
   const prepStart = nowMs();
   const [queryEmbedding, entityRanking, temporalRanking] = await Promise.all([
-    needsChunkEmbedding ? generateEmbedding(query, ctx.embeddingOptions) : Promise.resolve(void 0),
+    // The chunk lane is cosine-only — `searchChunksOp` needs a real vector, and
+    // there is no lexical fallback for it — so an embeddings outage must SKIP the
+    // lane, not reject this shared Promise.all and take the primary fact lane
+    // (which BM25 can still serve) down with it. Mirrors safeLane's posture.
+    needsChunkEmbedding ? generateEmbedding(query, ctx.embeddingOptions).then((vec) => {
+      if (vec.length === 0) {
+        getLogger().warn(
+          "[memory/recall] chunk-lane query embedding came back empty; skipping the chunk lane"
+        );
+        chunkEmbedFailed = true;
+        return void 0;
+      }
+      return vec;
+    }).catch((err) => {
+      getLogger().warn(
+        `[memory/recall] chunk-lane query embedding failed; skipping the chunk lane: ${err instanceof Error ? err.message : String(err)}`
+      );
+      chunkEmbedFailed = true;
+      return void 0;
+    }) : Promise.resolve(void 0),
     // The graph + temporal lanes are AUXILIARY (RRF side-signals). A transient
     // WatermelonDB throw in either must NOT reject this Promise.all and take
     // PRIMARY cosine/BM25 recall down with it — degrade the failing lane to an
@@ -6371,7 +6554,9 @@ async function recall(query, ctx, options = {}) {
       results,
       vaultSize: size,
       reranked,
-      hadV2Head: v2Head
+      hadV2Head: v2Head,
+      embeddingsUnavailable: factEmbeddingsUnavailable,
+      rankedOnCosine: factRankedOnCosine
     } = await searchVaultMemoriesWithSize(
       query,
       ctx.vaultCtx,
@@ -6428,8 +6613,11 @@ async function recall(query, ctx, options = {}) {
     vaultSize = size;
     didRerank = reranked;
     hadV2Head = v2Head;
+    if (factEmbeddingsUnavailable) embeddingsUnavailable = true;
+    factLaneRankedOnCosine = factRankedOnCosine;
     factLaneMs = nowMs() - factStart;
   }
+  if (chunkEmbedFailed && !factLaneRankedOnCosine) embeddingsUnavailable = true;
   if (types.includes("chunk") && ctx.storageCtx && queryEmbedding) {
     const chunkStart = nowMs();
     const chunkMinScore = options.minScore ?? DEFAULT_CHUNK_MIN_SCORE;
@@ -6724,6 +6912,9 @@ export {
   restoreVaultMemoryOp,
   hardDeleteDecayedOp,
   updateVaultMemoryEmbeddingOp,
+  RECALL_TOOL_NAME,
+  RECALL_MAX_LIMIT,
+  EMBEDDINGS_DEGRADED_EMPTY,
   RerankerUnavailableError,
   isRerankerAvailable,
   DEFAULT_VAULT_CACHE_SIZE,