@anuma/sdk 3.2.0 → 3.3.1

package/dist/react/{chunk-Y7PMXJT6.mjs → chunk-PWTWECXY.mjs}

@@ -2105,6 +2105,36 @@ async function getMemoriesByEntityNamesOp(ctx, entityNames) {
   }
   return out;
 }
+async function getEntitiesByMemoryIdsOp(ctx, memoryIds) {
+  const unique = Array.from(new Set(memoryIds.filter((id) => id.length > 0)));
+  if (unique.length === 0) return /* @__PURE__ */ new Map();
+  const linkConditions = [Q2.where("memory_id", Q2.oneOf(unique))];
+  if (ctx.userId !== void 0) {
+    if (ctx.allowUnscopedRows) {
+      linkConditions.push(Q2.or(Q2.where("user_id", ctx.userId), Q2.where("user_id", null)));
+    } else {
+      linkConditions.push(Q2.where("user_id", ctx.userId));
+    }
+  }
+  const links = await ctx.memoryEntityCollection.query(...linkConditions).fetch();
+  if (links.length === 0) return /* @__PURE__ */ new Map();
+  const entityIds = Array.from(new Set(links.map((l) => String(l.entityId))));
+  const entityRows = await ctx.entityCollection.query(Q2.where("id", Q2.oneOf(entityIds))).fetch();
+  const entityIdToName = new Map(entityRows.map((e) => [e.id, e.canonicalName]));
+  const out = /* @__PURE__ */ new Map();
+  for (const link of links) {
+    const entityName = entityIdToName.get(String(link.entityId));
+    if (!entityName) continue;
+    const memoryId = String(link.memoryId);
+    let bucket = out.get(memoryId);
+    if (!bucket) {
+      bucket = /* @__PURE__ */ new Set();
+      out.set(memoryId, bucket);
+    }
+    bucket.add(entityName);
+  }
+  return out;
+}
 
 // src/lib/db/memoryVault/operations.ts
 import { Q as Q3 } from "@nozbe/watermelondb";
@@ -2142,11 +2172,18 @@ function isOwnedByCtxUser(ctx, record) {
 function baseVaultConditions(ctx, options) {
   return [
     ...options?.includeDeleted ? [] : [Q3.where("is_deleted", false)],
+    ...options?.includeArchived ? [] : [Q3.where("archived_at", Q3.eq(null))],
+    ...options?.includeQuarantined ? [] : [Q3.where("trust_tier", Q3.notEq("quarantined"))],
     ...options?.includeSuperseded ? [] : [Q3.where("superseded_by", null)],
     ...ctx.userId !== void 0 ? [Q3.where("user_id", ctx.userId)] : [],
     ...options?.since ? [Q3.where("updated_at", Q3.gt(options.since.getTime()))] : []
   ];
 }
+var KNOWN_TRUST_TIERS = /* @__PURE__ */ new Set(["quarantined", "trusted"]);
+function normalizeTrustTier(value) {
+  if (value === void 0 || value === null) return null;
+  return KNOWN_TRUST_TIERS.has(value) ? value : null;
+}
 async function mapInBatches(items, fn) {
   const BATCH = 50;
   const results = [];
@@ -2187,6 +2224,9 @@ function vaultMemoryToStoredRaw(memory) {
     supersededBy: memory.supersededBy ?? null,
     supersededAt: memory.supersededAt ?? null,
     lastObservedAt: memory.lastObservedAt ?? null,
+    factType: memory.factType ?? null,
+    archivedAt: memory.archivedAt ?? null,
+    trustTier: memory.trustTier ?? null,
     createdAt: memory.createdAt,
     updatedAt: memory.updatedAt,
     isDeleted: memory.isDeleted
@@ -2228,6 +2268,12 @@ async function createVaultMemoryOp(ctx, opts) {
         record._setRaw("event_time_end", opts.eventTime.end ?? null);
         record._setRaw("event_time_kind", opts.eventTime.kind ?? null);
       }
+      if (opts.factType !== void 0) {
+        record._setRaw("fact_type", opts.factType);
+      }
+      if (opts.trustTier !== void 0) {
+        record._setRaw("trust_tier", normalizeTrustTier(opts.trustTier));
+      }
     });
   });
   return vaultMemoryToStored(created, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner);
@@ -2368,6 +2414,12 @@ async function createVaultMemoriesBatchOp(ctx, optionsArray) {
           record._setRaw("event_time_end", opts.eventTime.end ?? null);
           record._setRaw("event_time_kind", opts.eventTime.kind ?? null);
         }
+        if (opts.factType !== void 0) {
+          record._setRaw("fact_type", opts.factType);
+        }
+        if (opts.trustTier !== void 0) {
+          record._setRaw("trust_tier", normalizeTrustTier(opts.trustTier));
+        }
       })
     );
     await ctx.database.batch(...prepared);
@@ -2428,6 +2480,9 @@ function vaultMemoryRawToStoredRaw(raw) {
     supersededBy: raw.superseded_by ?? null,
     supersededAt: raw.superseded_at ?? null,
     lastObservedAt: raw.last_observed_at ?? null,
+    factType: raw.fact_type ?? null,
+    archivedAt: raw.archived_at ?? null,
+    trustTier: raw.trust_tier ?? null,
     createdAt: new Date(raw.created_at),
     updatedAt: new Date(raw.updated_at),
     isDeleted: raw.is_deleted === true || raw.is_deleted === 1
@@ -2445,6 +2500,7 @@ async function getAllVaultMemoriesOp(ctx, options) {
     ...baseVaultConditions(ctx, options),
     ...options?.scopes?.length ? [Q3.where("scope", Q3.oneOf(options.scopes))] : [],
     ...options?.folderId !== void 0 ? [Q3.where("folder_id", options.folderId)] : [],
+    ...options?.factTypes?.length ? [Q3.where("fact_type", Q3.oneOf(options.factTypes))] : [],
     Q3.sortBy(options?.since ? "updated_at" : "created_at", Q3.desc),
     ...options?.limit !== null && options?.limit !== void 0 && options.limit > 0 ? [Q3.take(options.limit)] : []
   ];
@@ -2466,6 +2522,14 @@ async function getAllVaultMemoryContentsOp(ctx, options) {
     return stored.content;
   });
 }
+async function countActiveVaultMemoriesOp(ctx) {
+  return ctx.vaultMemoryCollection.query(...baseVaultConditions(ctx)).fetchCount();
+}
+async function getActiveVaultMemoryIdsOp(ctx, ids) {
+  if (ids.length === 0) return /* @__PURE__ */ new Set();
+  const rows = await ctx.vaultMemoryCollection.query(...baseVaultConditions(ctx), Q3.where("id", Q3.oneOf(ids))).unsafeFetchRaw();
+  return new Set(rows.map((r) => r.id));
+}
 async function updateVaultMemoryOp(ctx, id, opts) {
   try {
     const probe = await ctx.vaultMemoryCollection.find(id);
@@ -2519,6 +2583,15 @@ async function updateVaultMemoryOp(ctx, id, opts) {
         if (opts.lastObservedAt !== void 0) {
           r._setRaw("last_observed_at", opts.lastObservedAt);
         }
+        if (opts.factType !== void 0) {
+          r._setRaw("fact_type", opts.factType);
+        }
+        if (opts.trustTier !== void 0) {
+          r._setRaw("trust_tier", normalizeTrustTier(opts.trustTier));
+        }
+        if (opts.restore) {
+          r._setRaw("archived_at", null);
+        }
         if (opts.preserveUpdatedAt) {
           r._setRaw("updated_at", originalUpdatedAt);
         }
@@ -2775,6 +2848,98 @@ async function deleteAllVaultMemoriesForUserOp(ctx, userId) {
   }
   return records.length;
 }
+function assertVaultScopeForSweep(ctx) {
+  if (ctx.userId === void 0 && ctx.singleTenant !== true) {
+    throw new Error(
+      "Refusing to run a decay sweep on an unscoped vault context: it has no userId and is not marked singleTenant, so it would sweep across all tenants. Set ctx.userId on server/multi-tenant contexts, or ctx.singleTenant = true on a per-wallet, physically single-tenant client DB. (walletAddress alone is no longer accepted \u2014 it does not scope the sweep query.)"
+    );
+  }
+}
+async function getDecayCandidatesRawOp(ctx) {
+  assertVaultScopeForSweep(ctx);
+  const results = await ctx.vaultMemoryCollection.query(...baseVaultConditions(ctx, { includeArchived: true, includeQuarantined: true })).unsafeFetchRaw();
+  return results.map((raw) => ({
+    uniqueId: raw.id,
+    factType: raw.fact_type ?? null,
+    eventTimeEnd: raw.event_time_end ?? null,
+    eventTimeKind: raw.event_time_kind ?? null,
+    updatedAt: raw.updated_at,
+    archivedAt: raw.archived_at ?? null,
+    source: raw.source ?? null,
+    trustTier: raw.trust_tier ?? null
+  }));
+}
+async function archiveVaultMemoryOp(ctx, id, opts) {
+  try {
+    const record = await ctx.vaultMemoryCollection.find(id);
+    if (record.isDeleted || !isOwnedByCtxUser(ctx, record)) return false;
+    let stale = false;
+    const archivedAtValue = opts?.now ?? Date.now();
+    await ctx.database.write(async () => {
+      if (record.isDeleted || !isOwnedByCtxUser(ctx, record) || record.archivedAt !== null) {
+        stale = true;
+        return;
+      }
+      if (opts?.expectedUpdatedAt !== void 0 && record.updatedAt.getTime() !== opts.expectedUpdatedAt) {
+        stale = true;
+        return;
+      }
+      await record.update((r) => {
+        r._setRaw("archived_at", archivedAtValue);
+      });
+    });
+    return !stale;
+  } catch {
+    return false;
+  }
+}
+async function restoreVaultMemoryOp(ctx, id) {
+  try {
+    const record = await ctx.vaultMemoryCollection.find(id);
+    if (record.isDeleted || !isOwnedByCtxUser(ctx, record)) return false;
+    let stale = false;
+    await ctx.database.write(async () => {
+      if (record.isDeleted || !isOwnedByCtxUser(ctx, record)) {
+        stale = true;
+        return;
+      }
+      await record.update((r) => {
+        r._setRaw("archived_at", null);
+      });
+    });
+    return !stale;
+  } catch {
+    return false;
+  }
+}
+async function hardDeleteDecayedOp(ctx, id, opts) {
+  try {
+    const record = await ctx.vaultMemoryCollection.find(id);
+    if (record.isDeleted || !isOwnedByCtxUser(ctx, record)) return false;
+    const now = opts.now ?? Date.now();
+    let stale = false;
+    await ctx.database.write(async () => {
+      const archivedAt = record.archivedAt;
+      if (record.isDeleted || !isOwnedByCtxUser(ctx, record) || archivedAt === null || now - archivedAt <= opts.hardDeleteWindowMs) {
+        stale = true;
+        return;
+      }
+      await record.update((r) => {
+        r._setRaw("is_deleted", true);
+      });
+    });
+    if (stale) return false;
+    if (ctx.entityCtx) {
+      try {
+        await unlinkMemoryEntitiesOp(ctx.entityCtx, [id]);
+      } catch {
+      }
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
 async function updateVaultMemoryEmbeddingOp(ctx, id, embedding, embeddingModel) {
   try {
     const record = await ctx.vaultMemoryCollection.find(id);
@@ -2954,6 +3119,9 @@ async function withEmbeddingRetry(call) {
     }
   }
   if (threw) throw lastThrown;
+  if (last?.error instanceof Error && last.response?.status === void 0) {
+    throw last.error;
+  }
   return last;
 }
 var EmbeddingHttpError = class extends Error {
@@ -3800,6 +3968,7 @@ function rankVaultMemories(_query, queryEmbedding, items, options) {
     sourceChunkIds: item.sourceChunkIds,
     eventTimeEnd: item.eventTimeEnd,
     eventTimeKind: item.eventTimeKind,
+    factType: item.factType,
     similarity: cosineSimilarity(queryEmbedding, item.embedding)
   }));
   const filtered = scored.filter((r) => r.similarity >= minSimilarity);
@@ -3850,6 +4019,7 @@ function rankFusedVaultMemories(query, queryEmbedding, items, options) {
   const recencyAlpha = options?.recencyAlpha ?? 1;
   const proofCountAlpha = options?.proofCountAlpha ?? 0.1;
   const bm25AdmissionDivisor = options?.bm25AdmissionDivisor ?? 50;
+  const factTypeWeights = options?.factTypeWeights;
   if (items.length === 0) return [];
   const baseRanked = rankVaultMemories(query, queryEmbedding, items, {
     limit: items.length,
@@ -3881,7 +4051,8 @@ function rankFusedVaultMemories(query, queryEmbedding, items, options) {
       eventTimeStart: item.eventTimeStart,
       sourceChunkIds: item.sourceChunkIds,
       eventTimeEnd: item.eventTimeEnd,
-      eventTimeKind: item.eventTimeKind
+      eventTimeKind: item.eventTimeKind,
+      factType: item.factType
     });
   }
   const boostFor = (id) => {
@@ -3890,7 +4061,9 @@ function rankFusedVaultMemories(query, queryEmbedding, items, options) {
     const recencyBoost = 1 + recencyAlpha * (recency - 0.5);
     const proofCount = Math.max(1, item?.proofCount ?? 1);
     const proofBoost = 1 + proofCountAlpha * Math.log(1 + proofCount) - proofCountAlpha * Math.log(2);
-    return recencyBoost * proofBoost;
+    const rawTypeWeight = item?.factType ? factTypeWeights?.[item.factType] : void 0;
+    const typeWeight = rawTypeWeight !== void 0 && Number.isFinite(rawTypeWeight) && rawTypeWeight > 0 ? rawTypeWeight : 1;
+    return recencyBoost * proofBoost * typeWeight;
   };
   let combined = [...baseRanked, ...admitted].map((r) => ({
     ...r,
@@ -3942,7 +4115,8 @@ async function rankFusedVaultMemoriesAsync(query, queryEmbedding, items, options
     supersessionWindow: options?.supersessionWindow,
     proofCountAlpha: options?.proofCountAlpha,
     bm25AdmissionDivisor: options?.bm25AdmissionDivisor,
-    rrfK: options?.rrfK
+    rrfK: options?.rrfK,
+    ...options?.factTypeWeights && { factTypeWeights: options.factTypeWeights }
   });
   if (options?.v2HeadStats) {
     options.v2HeadStats.hadResults = v2Ranked.length > 0;
@@ -4035,7 +4209,8 @@ async function rankFusedVaultMemoriesAsync(query, queryEmbedding, items, options
         eventTimeStart: orig?.eventTimeStart,
         sourceChunkIds: orig?.sourceChunkIds,
         eventTimeEnd: orig?.eventTimeEnd,
-        eventTimeKind: orig?.eventTimeKind
+        eventTimeKind: orig?.eventTimeKind,
+        factType: orig?.factType
       };
     });
     const remainingTail = combined.filter((r) => !pickedIds.has(r.uniqueId));
@@ -4061,7 +4236,8 @@ async function rankComposite(originalQuery, originalQueryEmbedding, subQueries,
     ...options?.bm25AdmissionDivisor !== void 0 && {
       bm25AdmissionDivisor: options.bm25AdmissionDivisor
     },
-    ...options?.rrfK !== void 0 && { rrfK: options.rrfK }
+    ...options?.rrfK !== void 0 && { rrfK: options.rrfK },
+    ...options?.factTypeWeights && { factTypeWeights: options.factTypeWeights }
   };
   const originalRanked = rankFusedVaultMemories(originalQuery, originalQueryEmbedding, items, {
     limit: perFacetTopN,
@@ -4099,7 +4275,8 @@ async function rankComposite(originalQuery, originalQueryEmbedding, subQueries,
         eventTimeStart: item.eventTimeStart,
         sourceChunkIds: item.sourceChunkIds,
         eventTimeEnd: item.eventTimeEnd,
-        eventTimeKind: item.eventTimeKind
+        eventTimeKind: item.eventTimeKind,
+        factType: item.factType
       };
     }
   );
@@ -4123,7 +4300,8 @@ async function rankComposite(originalQuery, originalQueryEmbedding, subQueries,
           eventTimeStart: item.eventTimeStart,
           sourceChunkIds: item.sourceChunkIds,
           eventTimeEnd: item.eventTimeEnd,
-          eventTimeKind: item.eventTimeKind
+          eventTimeKind: item.eventTimeKind,
+          factType: item.factType
         });
       }
     }
@@ -4180,7 +4358,8 @@ async function rankComposite(originalQuery, originalQueryEmbedding, subQueries,
         eventTimeStart: orig?.eventTimeStart,
         sourceChunkIds: orig?.sourceChunkIds,
         eventTimeEnd: orig?.eventTimeEnd,
-        eventTimeKind: orig?.eventTimeKind
+        eventTimeKind: orig?.eventTimeKind,
+        factType: orig?.factType
       };
     });
     const remainingTail = combined.filter((r) => !pickedIds.has(r.uniqueId));
@@ -4252,6 +4431,8 @@ async function searchVaultMemoriesWithSize(query, vaultCtx, embeddingOptions, ca
   const queryOpts = {};
   if (scopes?.length) queryOpts.scopes = scopes;
   if (folderId !== void 0) queryOpts.folderId = folderId;
+  if (searchOptions?.factTypes?.length) queryOpts.factTypes = searchOptions.factTypes;
+  if (searchOptions?.includeArchived) queryOpts.includeArchived = true;
   const loaded = await getAllVaultMemoriesOp(
     vaultCtx,
     Object.keys(queryOpts).length > 0 ? queryOpts : void 0
@@ -4323,7 +4504,8 @@ async function searchVaultMemoriesWithSize(query, vaultCtx, embeddingOptions, ca
     eventTimeStart: m.eventTimeStart,
     sourceChunkIds: m.sourceChunkIds,
     eventTimeEnd: m.eventTimeEnd,
-    eventTimeKind: normalizeEventTimeKind(m.eventTimeKind)
+    eventTimeKind: normalizeEventTimeKind(m.eventTimeKind),
+    factType: m.factType
   }));
   if (queryEmbedding.length > 0) {
     const mismatched = embeddedItems.filter(
@@ -4367,7 +4549,8 @@ async function searchVaultMemoriesWithSize(query, vaultCtx, embeddingOptions, ca
     ...searchOptions?.bm25AdmissionDivisor !== void 0 && {
       bm25AdmissionDivisor: searchOptions.bm25AdmissionDivisor
     },
-    ...searchOptions?.rrfK !== void 0 && { rrfK: searchOptions.rrfK }
+    ...searchOptions?.rrfK !== void 0 && { rrfK: searchOptions.rrfK },
+    ...searchOptions?.factTypeWeights && { factTypeWeights: searchOptions.factTypeWeights }
   };
   if (useFusion && searchOptions?.decompose === "llm" && searchOptions.decomposeOptions) {
     const decomp = await decomposeQuery(query, searchOptions.decomposeOptions);
@@ -4534,7 +4717,7 @@ function createMemoryVaultSearchTool(vaultCtx, embeddingOptions, cache, searchOp
             legacy.map((r) => ({ id: r.uniqueId, content: r.content, score: r.similarity }))
           );
         }
-        const { recall: recall2 } = await import("./recall-GYNSL2DS.mjs");
+        const { recall: recall2 } = await import("./recall-FZVV5XUU.mjs");
         const result = await recall2(
           query,
           { vaultCtx, embeddingOptions, vaultCache: cache },
@@ -4645,6 +4828,159 @@ function extractQueryEntities(query) {
   return [...seen];
 }
 
+// src/lib/memory/graphTraversal.ts
+var MAX_HOPS = 2;
+var ENTITY_FANOUT = 8;
+var MIN_REFINER_CANDIDATES = 16;
+var MAX_REFINER_CANDIDATES = 64;
+var NODE_BUDGET = 64;
+var VAULT_SIZE_HOP_CAP = 1e3;
+function clampPositiveInt(value, fallback) {
+  if (value === void 0 || !Number.isFinite(value) || value < 1) return fallback;
+  return Math.floor(value);
+}
+function capHopsForDensity(maxHops, vaultSize) {
+  if (vaultSize !== void 0 && vaultSize > VAULT_SIZE_HOP_CAP) return Math.min(maxHops, 1);
+  return maxHops;
+}
+function rankMemoriesByOverlap(map) {
+  return [...map.entries()].sort((a, b) => b[1].size - a[1].size).map(([memoryId]) => memoryId);
+}
+async function traverseGraphLane(query, entityCtx, options = {}) {
+  const seedNames = extractQueryEntities(query);
+  if (seedNames.length === 0) return [];
+  const entityFanout = clampPositiveInt(options.entityFanout, ENTITY_FANOUT);
+  const nodeBudget = clampPositiveInt(options.nodeBudget, NODE_BUDGET);
+  const maxHops = capHopsForDensity(clampPositiveInt(options.maxHops, MAX_HOPS), options.vaultSize);
+  const keepActive = async (map) => {
+    if (!options.filterActiveMemoryIds || map.size === 0) return map;
+    const active = await options.filterActiveMemoryIds([...map.keys()]);
+    const filtered = /* @__PURE__ */ new Map();
+    for (const [id, names] of map) if (active.has(id)) filtered.set(id, names);
+    return filtered;
+  };
+  const hop1 = await keepActive(await getMemoriesByEntityNamesOp(entityCtx, seedNames));
+  if (hop1.size === 0) return [];
+  const hop1Ranking = rankMemoriesByOverlap(hop1);
+  if (maxHops <= 1) return hop1Ranking;
+  const hop1Emitted = hop1Ranking.slice(0, nodeBudget);
+  const perHopRankings = [hop1Emitted];
+  const firstHopOf = /* @__PURE__ */ new Map();
+  for (const id of hop1Emitted) if (!firstHopOf.has(id)) firstHopOf.set(id, 1);
+  const accumulated = new Set(hop1Emitted);
+  const seenEntities = new Set(seedNames);
+  let frontier = hop1Emitted;
+  for (let hop = 2; hop <= maxHops; hop++) {
+    if (frontier.length === 0) break;
+    if (accumulated.size >= nodeBudget) break;
+    const memoryToEntities = await getEntitiesByMemoryIdsOp(entityCtx, frontier);
+    const neighborCounts = /* @__PURE__ */ new Map();
+    for (const names of memoryToEntities.values()) {
+      for (const name of names) {
+        if (seenEntities.has(name)) continue;
+        neighborCounts.set(name, (neighborCounts.get(name) ?? 0) + 1);
+      }
+    }
+    if (neighborCounts.size === 0) break;
+    const rankedNeighbors = [...neighborCounts.entries()].sort((a, b) => b[1] - a[1]).map(([name]) => name);
+    let topNeighbors = rankedNeighbors.slice(0, entityFanout);
+    if (options.refineNeighbors && rankedNeighbors.length > entityFanout) {
+      try {
+        const refinerCandidateCap = Math.min(
+          Math.max(entityFanout * 2, MIN_REFINER_CANDIDATES),
+          MAX_REFINER_CANDIDATES
+        );
+        const refinerCandidates = rankedNeighbors.slice(0, refinerCandidateCap);
+        const refined = await options.refineNeighbors.refine(
+          query,
+          refinerCandidates,
+          entityFanout
+        );
+        const valid = [];
+        const seen = /* @__PURE__ */ new Set();
+        for (const name of refined) {
+          if (!neighborCounts.has(name) || seen.has(name)) continue;
+          seen.add(name);
+          valid.push(name);
+          if (valid.length >= entityFanout) break;
+        }
+        if (valid.length > 0) topNeighbors = valid;
+      } catch (err) {
+        getLogger().warn(
+          `[memory/graph] neighbor refine failed; using co-occurrence order: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+    for (const name of topNeighbors) seenEntities.add(name);
+    const hopMap = await keepActive(await getMemoriesByEntityNamesOp(entityCtx, topNeighbors));
+    if (hopMap.size === 0) break;
+    const hopRanking = rankMemoriesByOverlap(hopMap);
+    const newlyDiscovered = [];
+    for (const id of hopRanking) {
+      if (accumulated.has(id)) continue;
+      accumulated.add(id);
+      newlyDiscovered.push(id);
+      firstHopOf.set(id, hop);
+      if (accumulated.size >= nodeBudget) break;
+    }
+    if (newlyDiscovered.length === 0) break;
+    perHopRankings.push(newlyDiscovered);
+    frontier = newlyDiscovered;
+  }
+  const fused = rrfFuse(perHopRankings, options.rrfK);
+  return [...fused.entries()].sort((a, b) => {
+    const hopA = firstHopOf.get(a[0]) ?? Infinity;
+    const hopB = firstHopOf.get(b[0]) ?? Infinity;
+    if (hopA !== hopB) return hopA - hopB;
+    return b[1] - a[1];
+  }).map(([id]) => id);
+}
+var DEFAULT_REFINER_MODEL = "inclusionai/ling-2.6-flash";
+var DEFAULT_REFINER_ATTEMPTS = 1;
+var DEFAULT_REFINER_TOTAL_TIMEOUT_MS = 8e3;
+function createLlmNeighborRefiner(options) {
+  return {
+    async refine(query, candidates, limit) {
+      if (candidates.length === 0) return [];
+      const numbered = candidates.map((name, i) => `[${i + 1}] ${name}`).join("\n");
+      const systemPrompt = `You help a memory-retrieval system decide which related topics to explore.
+
+Given a user's question and a numbered list of candidate topics/entities linked to memories found so far, pick the ones most likely to lead to memories that help ANSWER the question. Choose at most ${limit}. Prefer topics semantically related to the question; ignore incidental ones.
+
+Output strict JSON, no prose: { "expand": [<entity names to expand, verbatim from the list>] }`;
+      const parsed = await callPortalJsonCompletion({
+        ...options.apiKey !== void 0 && { apiKey: options.apiKey },
+        ...options.getToken !== void 0 && { getToken: options.getToken },
+        ...options.baseUrl !== void 0 && { baseUrl: options.baseUrl },
+        model: options.model ?? DEFAULT_REFINER_MODEL,
+        systemPrompt,
+        userMessage: `Question: ${query}
+
+Candidate topics:
+${numbered}
+
+Which should be expanded?`,
+        tag: "memory/graph-refine",
+        maxAttempts: options.maxAttempts ?? DEFAULT_REFINER_ATTEMPTS,
+        totalTimeoutMs: options.totalTimeoutMs ?? DEFAULT_REFINER_TOTAL_TIMEOUT_MS,
+        ...options.backoffMs && { backoffMs: options.backoffMs },
+        ...options.fetchFn && { fetchFn: options.fetchFn }
+      });
+      if (parsed === null || typeof parsed !== "object") return [];
+      const list = parsed.expand;
+      if (!Array.isArray(list)) return [];
+      const byNormalized = new Map(candidates.map((c) => [normalizeEntityName(c), c]));
+      const out = [];
+      for (const raw of list) {
+        if (typeof raw !== "string") continue;
+        const match = byNormalized.get(normalizeEntityName(raw));
+        if (match) out.push(match);
+      }
+      return out;
+    }
+  };
+}
+
 // src/lib/memory/queryTemporal.ts
 var RELATIVE_DAY_ENTRIES = [
   [/\btoday\b/, "today", 0],
@@ -4857,12 +5193,12 @@ var DEFAULT_CHUNK_MIN_SCORE = 0.5;
 function flagsForBudget(budget) {
   switch (budget) {
     case "high":
-      return { rerank: true, decompose: true };
+      return { rerank: true, decompose: true, traverse: true };
     case "mid":
-      return { rerank: true, decompose: false };
+      return { rerank: true, decompose: false, traverse: false };
     case "low":
     default:
-      return { rerank: false, decompose: false };
+      return { rerank: false, decompose: false, traverse: false };
   }
 }
 function dedupeBy(items, ...keys) {
@@ -4930,11 +5266,25 @@ async function recall(query, ctx, options = {}) {
   }
   const needsChunkEmbedding = types.includes("chunk") && ctx.storageCtx;
   const wantsTemporal = types.includes("fact") && ctx.vaultCtx;
+  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),
-    buildGraphLaneRanking(query, ctx),
-    wantsTemporal ? buildTemporalLaneRanking(query, ctx.vaultCtx, options.now) : Promise.resolve([])
+    // 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
+    // empty ranking instead (mirrors safeCountVault's fail-soft posture).
+    safeLane(
+      "graph",
+      () => buildGraphLaneRanking(query, ctx, flags.traverse, {
+        ...options.maxHops !== void 0 && { maxHops: options.maxHops },
+        ...options.entityFanout !== void 0 && { entityFanout: options.entityFanout },
+        ...options.nodeBudget !== void 0 && { nodeBudget: options.nodeBudget },
+        ...options.rrfK !== void 0 && { rrfK: options.rrfK },
+        ...graphRefiner && { refineNeighbors: graphRefiner }
+      })
+    ),
+    wantsTemporal ? safeLane("temporal", () => buildTemporalLaneRanking(query, ctx.vaultCtx, options.now)) : Promise.resolve([])
   ]);
   prepMs = nowMs() - prepStart;
   if (types.includes("fact") && ctx.vaultCtx && ctx.vaultCache) {
@@ -4984,6 +5334,8 @@ async function recall(query, ctx, options = {}) {
         },
         ...options.scopes && { scopes: options.scopes },
         ...options.folderId !== void 0 && { folderId: options.folderId },
+        ...options.factTypes?.length && { factTypes: options.factTypes },
+        ...options.factTypeWeights && { factTypeWeights: options.factTypeWeights },
         ...entityRanking.length > 0 && { entityRanking },
         ...temporalRanking.length > 0 && { temporalRanking }
       }
@@ -5105,6 +5457,9 @@ function toFactMemory(r) {
     ...r.eventTimeStart !== void 0 && { eventTimeStart: r.eventTimeStart },
     ...r.eventTimeEnd !== void 0 && { eventTimeEnd: r.eventTimeEnd },
     ...r.eventTimeKind !== void 0 && { eventTimeKind: r.eventTimeKind },
+    // Typed memory (PR1) — surfaced from VaultSearchResult so recall results
+    // (and UI reading them) carry the fact's type. Undefined when untyped.
+    ...r.factType !== void 0 && { factType: r.factType },
     ...r.sourceChunkIds !== void 0 && r.sourceChunkIds !== null && { sourceChunkIds: r.sourceChunkIds },
     // r.similarity from searchVaultMemoriesWithSize is the fused score
     // (cosine + BM25 + RRF + recency + proof) when useFusion=true (the
@@ -5118,14 +5473,47 @@ function toFactMemory(r) {
     updatedAt: r.updatedAt ?? /* @__PURE__ */ new Date(0)
   };
 }
-async function buildGraphLaneRanking(query, ctx) {
+async function buildGraphLaneRanking(query, ctx, traverse = false, traversalOptions = {}) {
   const entityCtx = ctx.entityCtx ?? ctx.vaultCtx?.entityCtx;
   if (!entityCtx) return [];
+  if (traverse) {
+    const vaultSize = await safeCountVault(ctx);
+    const vaultCtx2 = ctx.vaultCtx;
+    return traverseGraphLane(query, entityCtx, {
+      ...traversalOptions,
+      ...vaultSize !== void 0 && { vaultSize },
+      ...vaultCtx2 && {
+        filterActiveMemoryIds: (ids) => getActiveVaultMemoryIdsOp(vaultCtx2, ids)
+      }
+    });
+  }
   const queryEntities = extractQueryEntities(query);
   if (queryEntities.length === 0) return [];
   const memoryToEntities = await getMemoriesByEntityNamesOp(entityCtx, queryEntities);
   if (memoryToEntities.size === 0) return [];
-  return [...memoryToEntities.entries()].sort((a, b) => b[1].size - a[1].size).map(([memoryId]) => memoryId);
+  const ranked = [...memoryToEntities.entries()].sort((a, b) => b[1].size - a[1].size).map(([memoryId]) => memoryId);
+  const vaultCtx = ctx.vaultCtx;
+  if (!vaultCtx) return ranked;
+  const activeIds = await getActiveVaultMemoryIdsOp(vaultCtx, ranked);
+  return ranked.filter((id) => activeIds.has(id));
+}
+async function safeCountVault(ctx) {
+  if (!ctx.vaultCtx) return void 0;
+  try {
+    return await countActiveVaultMemoriesOp(ctx.vaultCtx);
+  } catch {
+    return void 0;
+  }
+}
+async function safeLane(label, run) {
+  try {
+    return await run();
+  } catch (err) {
+    getLogger().warn(
+      `[memory/recall] ${label} lane failed; continuing without it: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return [];
+  }
 }
 async function buildTemporalLaneRanking(query, vaultCtx, now) {
   const window2 = parseQueryTimeWindow(query, now);
@@ -5239,6 +5627,7 @@ export {
   replaceMemoryEntitiesGuardedOp,
   backfillMemoryEntityUserIdsOp,
   getMemoriesByEntityNamesOp,
+  getEntitiesByMemoryIdsOp,
   vaultMemoryToStored,
   createVaultMemoryOp,
   createSupersedingMemoryOp,
@@ -5256,12 +5645,24 @@ export {
   getMemoriesNeedingTopicExtractionOp,
   stampTopicsExtractedAtOp,
   deleteAllVaultMemoriesForUserOp,
+  assertVaultScopeForSweep,
+  getDecayCandidatesRawOp,
+  archiveVaultMemoryOp,
+  restoreVaultMemoryOp,
+  hardDeleteDecayedOp,
   updateVaultMemoryEmbeddingOp,
   RerankerUnavailableError,
   isRerankerAvailable,
   DEFAULT_VAULT_CACHE_SIZE,
   LRUCache,
   createVaultEmbeddingCache,
+  MAX_HOPS,
+  ENTITY_FANOUT,
+  NODE_BUDGET,
+  VAULT_SIZE_HOP_CAP,
+  capHopsForDensity,
+  traverseGraphLane,
+  createLlmNeighborRefiner,
   recall,
   preEmbedVaultMemories,
   eagerEmbedContent,