@anuma/sdk 6.33.2 → 6.35.0

package/dist/expo/index.mjs

@@ -2622,13 +2622,13 @@ async function searchChunksOp(ctx, queryVector, options) {
   const storedById = new Map(
     await Promise.all(
       Array.from(uniqueMessages, async ([id, m]) => {
-        const stored = await messageRawToStored(
+        const stored2 = await messageRawToStored(
           m,
           ctx.walletAddress,
           ctx.signMessage,
           ctx.embeddedWalletSigner
         );
-        return [id, stored];
+        return [id, stored2];
       })
     )
   );
@@ -2646,18 +2646,18 @@ async function searchChunksOp(ctx, queryVector, options) {
     })
   );
   return topK.map(({ message, similarity, chunkTextSource }) => {
-    const stored = { ...storedById.get(message.id) };
+    const stored2 = { ...storedById.get(message.id) };
     let chunkText2;
     if (chunkTextSource.kind === "chunk") {
-      chunkText2 = resolveChunkText(stored.content, chunkTextSource.chunk, chunkTextSource.siblings);
+      chunkText2 = resolveChunkText(stored2.content, chunkTextSource.chunk, chunkTextSource.siblings);
     } else if (chunkTextSource.kind === "chunk-cached") {
       const state = chunkStateByMsgId.get(message.id);
       const chunk = state && state.version === chunkTextSource.version ? state.chunks[chunkTextSource.chunkIndex] : void 0;
-      chunkText2 = resolveChunkText(stored.content, chunk, state?.chunks);
+      chunkText2 = resolveChunkText(stored2.content, chunk, state?.chunks);
     } else {
-      chunkText2 = stored.content;
+      chunkText2 = stored2.content;
     }
-    return { chunkText: chunkText2, message: stored, similarity };
+    return { chunkText: chunkText2, message: stored2, similarity };
   });
 }
 function makeSyntheticStoredMessage(opts) {
@@ -3776,7 +3776,7 @@ async function embedOne(text12, options, outer) {
 }
 var DEFAULT_EMBEDDING_BATCH_SIZE = 100;
 var DEFAULT_EMBEDDING_BATCH_CONCURRENCY = 3;
-async function generateEmbeddingsBatch(texts, headers, baseUrl, model, onUsage, maskInput, timeoutMs) {
+async function generateEmbeddingsBatch(texts, headers, baseUrl, model, onUsage, maskInput, timeoutMs, outer) {
   const response = await withEmbeddingRetry(
     () => withDeadline(
       (signal) => postApiV1Embeddings({
@@ -3786,8 +3786,10 @@ async function generateEmbeddingsBatch(texts, headers, baseUrl, model, onUsage,
         ...signal && { signal }
       }),
       timeoutMs,
-      "embedding batch request"
-    )
+      "embedding batch request",
+      outer
+    ),
+    outer
   );
   if (response.error) {
     throw embeddingErrorFrom(response);
@@ -3805,6 +3807,11 @@ async function generateEmbeddingsBatch(texts, headers, baseUrl, model, onUsage,
 }
 async function generateEmbeddings(texts, options) {
   if (texts.length === 0) return [];
+  const total = options.totalTimeoutMs;
+  if (total === void 0) return embedMany(texts, options, void 0);
+  return withDeadline((signal) => embedMany(texts, options, signal), total, "embedding batch");
+}
+async function embedMany(texts, options, outer) {
   const { baseUrl = BASE_URL, model, batchSize, cache } = options;
   const timeoutMs = options.timeoutMs ?? DEFAULT_EMBEDDING_REQUEST_TIMEOUT_MS;
   const chunkSize = batchSize ?? DEFAULT_EMBEDDING_BATCH_SIZE;
@@ -3825,7 +3832,8 @@ async function generateEmbeddings(texts, options) {
   if (uncachedTexts.length === 0) {
     return results;
   }
-  const headers = await resolveAuthHeaders(options);
+  const headers = await resolveAuthHeaders(options, outer);
+  if (outer?.aborted) throw outer.reason;
   const embeddingModel = model ?? DEFAULT_API_EMBEDDING_MODEL;
   let newEmbeddings;
   if (uncachedTexts.length <= chunkSize) {
@@ -3836,7 +3844,8 @@ async function generateEmbeddings(texts, options) {
       embeddingModel,
       options.onUsage,
       options.maskInput,
-      timeoutMs
+      timeoutMs,
+      outer
     );
   } else {
     const chunks = [];
@@ -3847,6 +3856,7 @@ async function generateEmbeddings(texts, options) {
     let nextIndex = 0;
     const worker = async () => {
       while (nextIndex < chunks.length) {
+        if (outer?.aborted) throw outer.reason;
         const idx = nextIndex++;
         allEmbeddings[idx] = await generateEmbeddingsBatch(
           chunks[idx],
@@ -3855,7 +3865,8 @@ async function generateEmbeddings(texts, options) {
           embeddingModel,
           options.onUsage,
           options.maskInput,
-          timeoutMs
+          timeoutMs,
+          outer
         );
       }
     };
@@ -3866,6 +3877,7 @@ async function generateEmbeddings(texts, options) {
     await Promise.all(workers);
     newEmbeddings = allEmbeddings.flat();
   }
+  if (outer?.aborted) throw outer.reason;
   for (let i = 0; i < uncachedIndices.length; i++) {
     const f32Embedding = Float32Array.from(newEmbeddings[i]);
     results[uncachedIndices[i]] = Array.from(f32Embedding);
@@ -8940,15 +8952,15 @@ function createSummaryContext(database) {
     summariesCollection: database.get("conversation_summaries")
   };
 }
-function modelToStored(record) {
+function modelToStored(record2) {
   return {
-    uniqueId: record.id,
-    conversationId: record.conversationId,
-    summary: record.summary,
-    summarizedUpTo: record.summarizedUpTo,
-    tokenCount: record.tokenCount,
-    createdAt: record.createdAt,
-    updatedAt: record.updatedAt
+    uniqueId: record2.id,
+    conversationId: record2.conversationId,
+    summary: record2.summary,
+    summarizedUpTo: record2.summarizedUpTo,
+    tokenCount: record2.tokenCount,
+    createdAt: record2.createdAt,
+    updatedAt: record2.updatedAt
   };
 }
 async function getConversationSummaryOp(ctx, conversationId) {
@@ -8957,17 +8969,17 @@ async function getConversationSummaryOp(ctx, conversationId) {
   return modelToStored(results[0]);
 }
 async function upsertConversationSummaryOp(ctx, conversationId, summary, summarizedUpTo, tokenCount) {
-  let record;
+  let record2;
   await ctx.database.write(async () => {
     const existing = await ctx.summariesCollection.query(Q2.where("conversation_id", conversationId)).fetch();
     if (existing.length > 0) {
-      record = await existing[0].update((rec) => {
+      record2 = await existing[0].update((rec) => {
         rec.summary = summary;
         rec.summarizedUpTo = summarizedUpTo;
         rec.tokenCount = tokenCount;
       });
     } else {
-      record = await ctx.summariesCollection.create((rec) => {
+      record2 = await ctx.summariesCollection.create((rec) => {
         rec.conversationId = conversationId;
         rec.summary = summary;
         rec.summarizedUpTo = summarizedUpTo;
@@ -8975,13 +8987,13 @@ async function upsertConversationSummaryOp(ctx, conversationId, summary, summari
       });
     }
   });
-  return modelToStored(record);
+  return modelToStored(record2);
 }
 async function deleteConversationSummaryOp(ctx, conversationId) {
   await ctx.database.write(async () => {
     const existing = await ctx.summariesCollection.query(Q2.where("conversation_id", conversationId)).fetch();
-    for (const record of existing) {
-      await record.destroyPermanently();
+    for (const record2 of existing) {
+      await record2.destroyPermanently();
     }
   });
 }
@@ -9234,6 +9246,15 @@ __decorateClass([
 __decorateClass([
   text6("scope")
 ], VaultMemory.prototype, "scope", 2);
+__decorateClass([
+  field5("kind")
+], VaultMemory.prototype, "kind", 2);
+__decorateClass([
+  field5("kind_value")
+], VaultMemory.prototype, "kindValue", 2);
+__decorateClass([
+  field5("level")
+], VaultMemory.prototype, "level", 2);
 __decorateClass([
   field5("folder_id")
 ], VaultMemory.prototype, "folderId", 2);
@@ -9459,7 +9480,7 @@ __decorateClass([
 ], VaultFolder.prototype, "context", 2);
 
 // src/lib/db/schema.ts
-var SDK_SCHEMA_VERSION = 47;
+var SDK_SCHEMA_VERSION = 48;
 var sdkSchema = appSchema2({
   version: SDK_SCHEMA_VERSION,
   tables: [
@@ -9554,6 +9575,9 @@ var sdkSchema = appSchema2({
       columns: [
         { name: "content", type: "string" },
         { name: "scope", type: "string", isIndexed: true },
+        { name: "kind", type: "string", isOptional: true, isIndexed: true },
+        { name: "kind_value", type: "string", isOptional: true },
+        { name: "level", type: "string", isOptional: true, isIndexed: true },
         { name: "folder_id", type: "string", isOptional: true, isIndexed: true },
         { name: "created_at", type: "number", isIndexed: true },
         { name: "updated_at", type: "number", isIndexed: true },
@@ -10230,6 +10254,22 @@ var sdkMigrations = schemaMigrations2({
           ]
         })
       ]
+    },
+    {
+      toVersion: 48,
+      steps: [
+        addColumns2({
+          table: "memory_vault",
+          columns: [
+            { name: "kind", type: "string", isOptional: true, isIndexed: true },
+            { name: "kind_value", type: "string", isOptional: true },
+            { name: "level", type: "string", isOptional: true, isIndexed: true }
+          ]
+        }),
+        unsafeExecuteSql(
+          "UPDATE memory_vault SET level = CASE WHEN scope IN ('shared', 'public') THEN 'matching' ELSE 'private' END WHERE level IS NULL;"
+        )
+      ]
     }
   ]
 });
@@ -10486,25 +10526,25 @@ async function upsertEntitiesInWrite(ctx, entities) {
   const kindBackfills = existing.filter((e) => {
     const incoming = kindByName.get(e.canonicalName);
     return incoming !== void 0 && (e.kind === null || e.kind === void 0 || e.kind === "");
-  }).map((record) => ({ record, kind: kindByName.get(record.canonicalName) }));
+  }).map((record2) => ({ record: record2, kind: kindByName.get(record2.canonicalName) }));
   const missing = unique.filter((n) => !existingNames.has(n));
   const created = missing.map(
-    (name) => ctx.entityCollection.prepareCreate((record) => {
-      record._setRaw("canonical_name", name);
+    (name) => ctx.entityCollection.prepareCreate((record2) => {
+      record2._setRaw("canonical_name", name);
       const kind = kindByName.get(name);
-      if (kind !== void 0) record._setRaw("kind", kind);
+      if (kind !== void 0) record2._setRaw("kind", kind);
     })
   );
   for (const e of existing) out.set(e.canonicalName, entityToStored(e));
-  for (const record of created) out.set(record.canonicalName, entityToStored(record));
-  for (const { record, kind } of kindBackfills) {
-    out.set(record.canonicalName, { ...entityToStored(record), kind });
+  for (const record2 of created) out.set(record2.canonicalName, entityToStored(record2));
+  for (const { record: record2, kind } of kindBackfills) {
+    out.set(record2.canonicalName, { ...entityToStored(record2), kind });
   }
   return { entities: out, operations: created, kindBackfills };
 }
 function prepareKindBackfills(backfills) {
   return backfills.map(
-    ({ record, kind }) => record.prepareUpdate((r) => {
+    ({ record: record2, kind }) => record2.prepareUpdate((r) => {
       r._setRaw("kind", kind);
     })
   );
@@ -10535,10 +10575,10 @@ function displayNamesOf(entities) {
   }
   return out;
 }
-function topicsEqual(stored, computed) {
-  if (stored === null || stored.length !== computed.length) return false;
+function topicsEqual(stored2, computed) {
+  if (stored2 === null || stored2.length !== computed.length) return false;
   const key = (t) => JSON.stringify([t.name, t.kind ?? null, t.source]);
-  const storedKeys = stored.map(key).sort();
+  const storedKeys = stored2.map(key).sort();
   const computedKeys = computed.map(key).sort();
   return storedKeys.every((k, i) => k === computedKeys[i]);
 }
@@ -10604,10 +10644,10 @@ async function linkMemoryEntitiesOp(ctx, memoryId, entityInputs, options) {
       return;
     }
     const linkOps = toCreate.map(
-      (e) => ctx.memoryEntityCollection.prepareCreate((record) => {
-        record._setRaw("memory_id", memoryId);
-        record._setRaw("entity_id", e.uniqueId);
-        if (userId !== void 0) record._setRaw("user_id", userId);
+      (e) => ctx.memoryEntityCollection.prepareCreate((record2) => {
+        record2._setRaw("memory_id", memoryId);
+        record2._setRaw("entity_id", e.uniqueId);
+        if (userId !== void 0) record2._setRaw("user_id", userId);
       })
     );
     await ctx.database.batch(
@@ -10675,10 +10715,10 @@ async function replaceMemoryEntities(ctx, memoryId, entityInputs, options) {
       ...entityOps,
       ...prepareKindBackfills(kindBackfills),
       ...toCreate.map(
-        (e) => ctx.memoryEntityCollection.prepareCreate((record) => {
-          record._setRaw("memory_id", memoryId);
-          record._setRaw("entity_id", e.uniqueId);
-          if (userId !== void 0) record._setRaw("user_id", userId);
+        (e) => ctx.memoryEntityCollection.prepareCreate((record2) => {
+          record2._setRaw("memory_id", memoryId);
+          record2._setRaw("entity_id", e.uniqueId);
+          if (userId !== void 0) record2._setRaw("user_id", userId);
         })
       ),
       ...toDestroy.map((l) => l.prepareDestroyPermanently()),
@@ -10795,13 +10835,54 @@ async function decryptVaultMemoryFields(memory, address, signMessage, embeddedWa
     }
   }
   const decryptedContent = await decryptField(memory.content, address);
+  const decryptedKindValue = typeof memory.kindValue === "string" ? await decryptField(memory.kindValue, address) : memory.kindValue;
   return {
     ...memory,
-    content: decryptedContent
+    content: decryptedContent,
+    ...decryptedKindValue !== void 0 && { kindValue: decryptedKindValue }
   };
 }
 
 // src/lib/db/memoryVault/types.ts
+var MEMORY_KINDS = [
+  "display_name",
+  "birth_date",
+  "bio",
+  "occupation",
+  "interest",
+  "gender",
+  "height_cm",
+  "looking_for",
+  "politics",
+  "religion",
+  "ethnicity",
+  "smoking",
+  "drinking",
+  "exercise",
+  "sexuality",
+  "prompt"
+];
+var MEMORY_LEVELS = ["private", "matching", "profile"];
+var MemoryLevelError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MemoryLevelError";
+  }
+};
+var PUBLISHED_SCOPES = /* @__PURE__ */ new Set(["shared", "public"]);
+function levelFromScope(scope) {
+  return typeof scope === "string" && PUBLISHED_SCOPES.has(scope) ? "matching" : "private";
+}
+function scopeForLevel(level) {
+  return level === "private" ? "private" : "shared";
+}
+function resolveMemoryLevel(level, scope) {
+  return typeof level === "string" && MEMORY_LEVELS.includes(level) ? level : levelFromScope(scope);
+}
+function levelForScopeChange(current, nextScope) {
+  const implied = levelFromScope(nextScope);
+  return implied === "matching" && resolveMemoryLevel(current.level, current.scope) === "profile" ? "profile" : implied;
+}
 function parseMedia(value) {
   if (typeof value !== "string" || value === "") return null;
   try {
@@ -10831,8 +10912,58 @@ function visibilityConditions(requested) {
   if (excluded.length === 0) return [];
   return [Q5.or(Q5.where("visibility", null), Q5.where("visibility", Q5.notIn(excluded)))];
 }
-function isOwnedByCtxUser(ctx, record) {
-  return ctx.userId === void 0 || record.userId === ctx.userId;
+function isKinded(record2) {
+  return record2.kind !== null && record2.kind !== void 0;
+}
+function assertValidKindLevel(kind, level) {
+  const hasKind = kind !== null && kind !== void 0;
+  if (hasKind && !MEMORY_KINDS.includes(kind)) {
+    throw new MemoryLevelError(`Unknown memory kind: ${kind}`);
+  }
+  if (level !== void 0 && !MEMORY_LEVELS.includes(level)) {
+    throw new MemoryLevelError(`Unknown memory level: ${level}`);
+  }
+  if (level === "profile" && !hasKind) {
+    throw new MemoryLevelError("Only a memory with a kind can be at level 'profile'");
+  }
+}
+function resolveCreateLevel(opts) {
+  if (opts.level !== void 0) return { level: opts.level, scope: scopeForLevel(opts.level) };
+  if (opts.scope !== void 0) return { level: levelFromScope(opts.scope), scope: opts.scope };
+  return { level: "private", scope: "private" };
+}
+async function encryptKindValue(ctx, value) {
+  if (typeof value !== "string" || !ctx.walletAddress || !ctx.signMessage) return value;
+  return encryptVaultMemoryContent(
+    value,
+    ctx.walletAddress,
+    ctx.signMessage,
+    ctx.embeddedWalletSigner
+  );
+}
+function levelConditions(requested) {
+  if (!requested?.length) return [];
+  const published = ["shared", "public"];
+  const wantsMatching = requested.includes("matching");
+  const wantsPrivate = requested.includes("private");
+  const unresolved = Q5.or(Q5.where("level", null), Q5.where("level", Q5.notIn([...MEMORY_LEVELS])));
+  const byLevel = Q5.where("level", Q5.oneOf([...requested]));
+  if (wantsMatching && wantsPrivate) return [Q5.or(byLevel, unresolved)];
+  if (wantsMatching) {
+    return [Q5.or(byLevel, Q5.and(unresolved, Q5.where("scope", Q5.oneOf(published))))];
+  }
+  if (wantsPrivate) {
+    return [
+      Q5.or(
+        byLevel,
+        Q5.and(unresolved, Q5.or(Q5.where("scope", null), Q5.where("scope", Q5.notIn(published))))
+      )
+    ];
+  }
+  return [byLevel];
+}
+function isOwnedByCtxUser(ctx, record2) {
+  return ctx.userId === void 0 || record2.userId === ctx.userId;
 }
 function baseVaultConditions(ctx, options) {
   return [
@@ -10874,6 +11005,9 @@ function vaultMemoryToStoredRaw(memory) {
     uniqueId: memory.id,
     content: memory.content,
     scope: memory.scope,
+    kind: memory.kind ?? null,
+    kindValue: memory.kindValue ?? null,
+    level: resolveMemoryLevel(memory.level, memory.scope),
     folderId: memory.folderId ?? null,
     userId: memory.userId ?? null,
     embedding: memory.embedding ?? null,
@@ -10912,42 +11046,48 @@ async function vaultMemoryToStored(memory, walletAddress, signMessage, embeddedW
   }
   return raw;
 }
-function populateNewVaultMemory(record, ctx, opts, encryptedContent) {
-  record._setRaw("content", encryptedContent);
-  record._setRaw("scope", opts.scope ?? "private");
-  record._setRaw("folder_id", opts.folderId ?? null);
-  record._setRaw("user_id", ctx.userId ?? null);
-  record._setRaw("is_deleted", false);
+function populateNewVaultMemory(record2, ctx, opts, encryptedContent, encryptedKindValue) {
+  const { level, scope } = resolveCreateLevel(opts);
+  record2._setRaw("content", encryptedContent);
+  record2._setRaw("scope", scope);
+  record2._setRaw("level", level);
+  record2._setRaw("kind", opts.kind ?? null);
+  record2._setRaw("kind_value", encryptedKindValue ?? null);
+  record2._setRaw("folder_id", opts.folderId ?? null);
+  record2._setRaw("user_id", ctx.userId ?? null);
+  record2._setRaw("is_deleted", false);
   if (opts.embedding !== void 0) {
-    record._setRaw("embedding", opts.embedding);
-    record._setRaw("embedding_model", opts.embeddingModel ?? null);
+    record2._setRaw("embedding", opts.embedding);
+    record2._setRaw("embedding_model", opts.embeddingModel ?? null);
   }
   if (opts.sourceChunkIds !== void 0) {
-    record._setRaw("source_chunk_ids", JSON.stringify(opts.sourceChunkIds));
+    record2._setRaw("source_chunk_ids", JSON.stringify(opts.sourceChunkIds));
   }
-  record._setRaw("proof_count", opts.proofCount ?? 1);
-  record._setRaw("source", opts.source ?? "manual");
+  record2._setRaw("proof_count", opts.proofCount ?? 1);
+  record2._setRaw("source", opts.source ?? "manual");
   if (opts.eventTime) {
-    record._setRaw("event_time_start", opts.eventTime.start ?? null);
-    record._setRaw("event_time_end", opts.eventTime.end ?? null);
-    record._setRaw("event_time_kind", opts.eventTime.kind ?? null);
+    record2._setRaw("event_time_start", opts.eventTime.start ?? null);
+    record2._setRaw("event_time_end", opts.eventTime.end ?? null);
+    record2._setRaw("event_time_kind", opts.eventTime.kind ?? null);
   }
   if (opts.factType !== void 0) {
-    record._setRaw("fact_type", opts.factType);
+    record2._setRaw("fact_type", opts.factType);
   }
   if (opts.trustTier !== void 0) {
-    record._setRaw("trust_tier", normalizeTrustTier(opts.trustTier));
+    record2._setRaw("trust_tier", normalizeTrustTier(opts.trustTier));
   }
-  record._setRaw("visibility", opts.visibility ?? "private");
-  record._setRaw(
+  record2._setRaw("visibility", opts.visibility ?? "private");
+  record2._setRaw(
     "published_at",
     opts.visibility && opts.visibility !== "private" ? opts.publishedAt ?? Date.now() : null
   );
   if (opts.geohash !== void 0) {
-    record._setRaw("geohash", opts.geohash);
+    record2._setRaw("geohash", opts.geohash);
   }
 }
 async function createVaultMemoryOp(ctx, opts) {
+  assertValidKindLevel(opts.kind, resolveCreateLevel(opts).level);
+  const encryptedKindValue = await encryptKindValue(ctx, opts.kindValue);
   const encryptedContent = ctx.walletAddress && ctx.signMessage ? await encryptVaultMemoryContent(
     opts.content,
     ctx.walletAddress,
@@ -10958,13 +11098,15 @@ async function createVaultMemoryOp(ctx, opts) {
     if (ctx.canWrite && !await ctx.canWrite())
       throw new Error("Memory source is no longer eligible");
     return ctx.vaultMemoryCollection.create(
-      (record) => populateNewVaultMemory(record, ctx, opts, encryptedContent)
+      (record2) => populateNewVaultMemory(record2, ctx, opts, encryptedContent, encryptedKindValue)
     );
   });
   return vaultMemoryToStored(created, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner);
 }
 async function createSupersedingMemoryOp(ctx, opts, targetId) {
   if (!targetId) return { created: null, retired: false };
+  assertValidKindLevel(opts.kind, resolveCreateLevel(opts).level);
+  const encryptedKindValue = await encryptKindValue(ctx, opts.kindValue);
   const encryptedContent = ctx.walletAddress && ctx.signMessage ? await encryptVaultMemoryContent(
     opts.content,
     ctx.walletAddress,
@@ -10981,9 +11123,10 @@ async function createSupersedingMemoryOp(ctx, opts, targetId) {
     } catch {
       return;
     }
-    if (target.isDeleted || target.supersededBy || !isOwnedByCtxUser(ctx, target)) return;
+    if (target.isDeleted || target.supersededBy || isKinded(target) || !isOwnedByCtxUser(ctx, target))
+      return;
     createdRecord = await ctx.vaultMemoryCollection.create(
-      (record) => populateNewVaultMemory(record, ctx, opts, encryptedContent)
+      (record2) => populateNewVaultMemory(record2, ctx, opts, encryptedContent, encryptedKindValue)
     );
     await target.update((r) => {
       r._setRaw("superseded_by", createdRecord.id);
@@ -11047,6 +11190,10 @@ async function getMemoriesByEventTimeOp(ctx, windowStart, windowEnd) {
 }
 async function createVaultMemoriesBatchOp(ctx, optionsArray) {
   if (optionsArray.length === 0) return [];
+  for (const opts of optionsArray) assertValidKindLevel(opts.kind, resolveCreateLevel(opts).level);
+  const encryptedKindValues = await Promise.all(
+    optionsArray.map((opts) => encryptKindValue(ctx, opts.kindValue))
+  );
   const encryptedContents = await Promise.all(
     optionsArray.map(async (opts) => {
       if (ctx.walletAddress && ctx.signMessage) {
@@ -11065,7 +11212,7 @@ async function createVaultMemoriesBatchOp(ctx, optionsArray) {
       throw new Error("Memory source is no longer eligible");
     const prepared = optionsArray.map(
       (opts, i) => ctx.vaultMemoryCollection.prepareCreate(
-        (record) => populateNewVaultMemory(record, ctx, opts, encryptedContents[i])
+        (record2) => populateNewVaultMemory(record2, ctx, opts, encryptedContents[i], encryptedKindValues[i])
       )
     );
     await ctx.database.batch(...prepared);
@@ -11073,16 +11220,16 @@ async function createVaultMemoriesBatchOp(ctx, optionsArray) {
   });
   return Promise.all(
     created.map(
-      (record) => vaultMemoryToStored(record, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner)
+      (record2) => vaultMemoryToStored(record2, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner)
     )
   );
 }
 async function getVaultMemoryOp(ctx, id) {
   try {
-    const record = await ctx.vaultMemoryCollection.find(id);
-    if (record.isDeleted || !isOwnedByCtxUser(ctx, record)) return null;
+    const record2 = await ctx.vaultMemoryCollection.find(id);
+    if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) return null;
     return vaultMemoryToStored(
-      record,
+      record2,
       ctx.walletAddress,
       ctx.signMessage,
       ctx.embeddedWalletSigner
@@ -11108,6 +11255,9 @@ function vaultMemoryRawToStoredRaw(raw) {
     uniqueId: raw.id,
     content: raw.content ?? "",
     scope: raw.scope ?? "",
+    kind: raw.kind ?? null,
+    kindValue: raw.kind_value ?? null,
+    level: resolveMemoryLevel(raw.level, raw.scope),
     folderId: raw.folder_id ?? null,
     userId: raw.user_id ?? null,
     embedding: raw.embedding ?? null,
@@ -11140,17 +11290,19 @@ function vaultMemoryRawToStoredRaw(raw) {
   };
 }
 async function vaultMemoryRawToStored(raw, walletAddress, signMessage, embeddedWalletSigner) {
-  const stored = vaultMemoryRawToStoredRaw(raw);
+  const stored2 = vaultMemoryRawToStoredRaw(raw);
   if (walletAddress) {
-    return decryptVaultMemoryFields(stored, walletAddress, signMessage, embeddedWalletSigner);
+    return decryptVaultMemoryFields(stored2, walletAddress, signMessage, embeddedWalletSigner);
   }
-  return stored;
+  return stored2;
 }
 async function getAllVaultMemoriesOp(ctx, options) {
   const conditions = [
     ...baseVaultConditions(ctx, options),
     ...options?.scopes?.length ? [Q5.where("scope", Q5.oneOf(options.scopes))] : [],
     ...visibilityConditions(options?.visibility),
+    ...levelConditions(options?.levels),
+    ...options?.kinds?.length ? [Q5.where("kind", Q5.oneOf(options.kinds))] : [],
     ...options?.folderId !== void 0 ? [Q5.where("folder_id", options.folderId)] : [],
     ...options?.factTypes?.length ? [Q5.where("fact_type", Q5.oneOf(options.factTypes))] : [],
     Q5.sortBy(options?.since ? "updated_at" : "created_at", Q5.desc),
@@ -11296,13 +11448,13 @@ async function getVaultMemoriesByIdsOp(ctx, ids, options) {
 async function getAllVaultMemoryContentsOp(ctx, options) {
   const results = await ctx.vaultMemoryCollection.query(...baseVaultConditions(ctx, options)).unsafeFetchRaw();
   return mapInBatches(results, async (raw) => {
-    const stored = await vaultMemoryRawToStored(
+    const stored2 = await vaultMemoryRawToStored(
       raw,
       ctx.walletAddress,
       ctx.signMessage,
       ctx.embeddedWalletSigner
     );
-    return stored.content;
+    return stored2.content;
   });
 }
 async function countActiveVaultMemoriesOp(ctx) {
@@ -11317,6 +11469,14 @@ async function updateVaultMemoryOp(ctx, id, opts) {
   try {
     const probe = await ctx.vaultMemoryCollection.find(id);
     if (probe.isDeleted || probe.supersededBy || !isOwnedByCtxUser(ctx, probe)) return null;
+    if (opts.freeFormOnly && isKinded(probe)) return null;
+    const levelAfter = (current) => {
+      if (opts.level !== void 0) return opts.level;
+      if (opts.scope === void 0) return resolveMemoryLevel(current.level, current.scope);
+      return levelForScopeChange(current, opts.scope);
+    };
+    assertValidKindLevel(opts.kind !== void 0 ? opts.kind : probe.kind, levelAfter(probe));
+    const encryptedKindValue = await encryptKindValue(ctx, opts.kindValue);
     const encryptedContent = ctx.walletAddress && ctx.signMessage ? await encryptVaultMemoryContent(
       opts.content,
       ctx.walletAddress,
@@ -11324,30 +11484,43 @@ async function updateVaultMemoryOp(ctx, id, opts) {
       ctx.embeddedWalletSigner
     ) : opts.content;
     let stale = false;
-    const record = probe;
-    const originalUpdatedAt = record.updatedAt.getTime();
+    const record2 = probe;
+    const originalUpdatedAt = record2.updatedAt.getTime();
     await ctx.database.write(async () => {
       if (ctx.canWrite && !await ctx.canWrite())
         throw new Error("Memory source is no longer eligible");
-      if (record.isDeleted || record.supersededBy || !isOwnedByCtxUser(ctx, record)) {
+      if (record2.isDeleted || record2.supersededBy || !isOwnedByCtxUser(ctx, record2) || opts.freeFormOnly && isKinded(record2)) {
         stale = true;
         return;
       }
+      const nextKind = opts.kind !== void 0 ? opts.kind : record2.kind;
+      const nextLevel = levelAfter(record2);
+      assertValidKindLevel(nextKind, nextLevel);
       let observedSources = [];
       let replayedObservation = false;
       if (opts.observationSourceIds?.length) {
         try {
-          const parsed = JSON.parse(record.sourceChunkIds ?? "[]");
+          const parsed = JSON.parse(record2.sourceChunkIds ?? "[]");
           if (Array.isArray(parsed))
             observedSources = parsed.filter((id2) => typeof id2 === "string");
         } catch {
         }
         replayedObservation = opts.observationSourceIds.every((id2) => observedSources.includes(id2));
       }
-      await record.update((r) => {
+      await record2.update((r) => {
         r._setRaw("content", encryptedContent);
-        if (opts.scope !== void 0) {
+        if (opts.level !== void 0) {
+          r._setRaw("level", nextLevel);
+          r._setRaw("scope", scopeForLevel(nextLevel));
+        } else if (opts.scope !== void 0) {
           r._setRaw("scope", opts.scope);
+          r._setRaw("level", nextLevel);
+        }
+        if (opts.kind !== void 0) {
+          r._setRaw("kind", opts.kind);
+        }
+        if (encryptedKindValue !== void 0) {
+          r._setRaw("kind_value", encryptedKindValue);
         }
         if (opts.folderId !== void 0) {
           r._setRaw("folder_id", opts.folderId);
@@ -11401,12 +11574,13 @@ async function updateVaultMemoryOp(ctx, id, opts) {
     });
     if (stale) return null;
     return vaultMemoryToStored(
-      record,
+      record2,
       ctx.walletAddress,
       ctx.signMessage,
       ctx.embeddedWalletSigner
     );
-  } catch {
+  } catch (err) {
+    if (err instanceof MemoryLevelError) throw err;
     return null;
   }
 }
@@ -11415,21 +11589,21 @@ async function setMemoryEntitiesOp(ctx, memoryId, entities) {
   if (!entityCtx) {
     throw new Error("setMemoryEntitiesOp requires ctx.entityCtx (entity collections)");
   }
-  let record;
+  let record2;
   try {
-    record = await ctx.vaultMemoryCollection.find(memoryId);
+    record2 = await ctx.vaultMemoryCollection.find(memoryId);
   } catch {
     return null;
   }
-  if (record.isDeleted || !isOwnedByCtxUser(ctx, record)) return null;
+  if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) return null;
   let stale = false;
-  const originalUpdatedAt = record.updatedAt.getTime();
+  const originalUpdatedAt = record2.updatedAt.getTime();
   await ctx.database.write(async (writer) => {
-    if (record.isDeleted || !isOwnedByCtxUser(ctx, record)) {
+    if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) {
       stale = true;
       return;
     }
-    await record.update((r) => {
+    await record2.update((r) => {
       r._setRaw("topics_user_managed", true);
       r._setRaw("updated_at", originalUpdatedAt);
     });
@@ -11453,25 +11627,25 @@ async function setMemoryEntitiesOp(ctx, memoryId, entities) {
     );
   });
   if (stale) return null;
-  return vaultMemoryToStored(record, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner);
+  return vaultMemoryToStored(record2, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner);
 }
 async function clearMemoryTopicsOverrideOp(ctx, memoryId, options) {
-  let record;
+  let record2;
   try {
-    record = await ctx.vaultMemoryCollection.find(memoryId);
+    record2 = await ctx.vaultMemoryCollection.find(memoryId);
   } catch {
     return false;
   }
-  if (record.isDeleted || !isOwnedByCtxUser(ctx, record)) return false;
-  const originalUpdatedAt = record.updatedAt.getTime();
+  if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) return false;
+  const originalUpdatedAt = record2.updatedAt.getTime();
   let cleared = false;
   await ctx.database.write(async () => {
-    if (options?.unlessTopicsRecorded && parseTopics(record.topics) !== null) return;
+    if (options?.unlessTopicsRecorded && parseTopics(record2.topics) !== null) return;
     cleared = true;
-    await record.update((r) => {
+    await record2.update((r) => {
       r._setRaw("topics_user_managed", false);
       r._setRaw("topics_extracted_version", null);
-      if (record.topicsExtractedAt === null) {
+      if (record2.topicsExtractedAt === null) {
         r._setRaw("topics_extracted_at", originalUpdatedAt);
       }
       r._setRaw("updated_at", originalUpdatedAt);
@@ -11480,22 +11654,22 @@ async function clearMemoryTopicsOverrideOp(ctx, memoryId, options) {
   return cleared;
 }
 async function setMemoryVisibilityOp(ctx, id, opts) {
-  let record;
+  let record2;
   try {
-    record = await ctx.vaultMemoryCollection.find(id);
+    record2 = await ctx.vaultMemoryCollection.find(id);
   } catch {
     return null;
   }
-  if (record.isDeleted || !isOwnedByCtxUser(ctx, record)) return null;
+  if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) return null;
   let stale = false;
   await ctx.database.write(async () => {
-    if (record.isDeleted || !isOwnedByCtxUser(ctx, record)) {
+    if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) {
       stale = true;
       return;
     }
-    const currentUpdatedAt = record.updatedAt.getTime();
-    const currentPublishedAt = record.publishedAt ?? null;
-    await record.update((r) => {
+    const currentUpdatedAt = record2.updatedAt.getTime();
+    const currentPublishedAt = record2.publishedAt ?? null;
+    await record2.update((r) => {
       r._setRaw("visibility", opts.visibility);
       if (opts.visibility === "private") {
         r._setRaw("published_at", null);
@@ -11509,19 +11683,19 @@ async function setMemoryVisibilityOp(ctx, id, opts) {
     });
   });
   if (stale) return null;
-  return vaultMemoryToStored(record, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner);
+  return vaultMemoryToStored(record2, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner);
 }
 async function deleteVaultMemoryOp(ctx, id) {
   try {
-    const record = await ctx.vaultMemoryCollection.find(id);
-    if (record.isDeleted || !isOwnedByCtxUser(ctx, record)) return false;
+    const record2 = await ctx.vaultMemoryCollection.find(id);
+    if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) return false;
     let stale = false;
     await ctx.database.write(async () => {
-      if (record.isDeleted || !isOwnedByCtxUser(ctx, record)) {
+      if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) {
         stale = true;
         return;
       }
-      await record.update((r) => {
+      await record2.update((r) => {
         r._setRaw("is_deleted", true);
       });
     });
@@ -11540,8 +11714,9 @@ async function deleteVaultMemoryOp(ctx, id) {
 async function supersedeVaultMemoryOp(ctx, id, supersededById) {
   if (id === supersededById) return false;
   try {
-    const record = await ctx.vaultMemoryCollection.find(id);
-    if (record.isDeleted || record.supersededBy || !isOwnedByCtxUser(ctx, record)) return false;
+    const record2 = await ctx.vaultMemoryCollection.find(id);
+    if (record2.isDeleted || record2.supersededBy || !isOwnedByCtxUser(ctx, record2)) return false;
+    if (isKinded(record2)) return false;
     let successor;
     try {
       successor = await ctx.vaultMemoryCollection.find(supersededById);
@@ -11555,7 +11730,7 @@ async function supersedeVaultMemoryOp(ctx, id, supersededById) {
     await ctx.database.write(async () => {
       if (ctx.canWrite && !await ctx.canWrite())
         throw new Error("Memory source is no longer eligible");
-      if (record.isDeleted || record.supersededBy || !isOwnedByCtxUser(ctx, record)) {
+      if (record2.isDeleted || record2.supersededBy || !isOwnedByCtxUser(ctx, record2)) {
         stale = true;
         return;
       }
@@ -11563,7 +11738,7 @@ async function supersedeVaultMemoryOp(ctx, id, supersededById) {
         stale = true;
         return;
       }
-      await record.update((r) => {
+      await record2.update((r) => {
         r._setRaw("superseded_by", supersededById);
         r._setRaw("superseded_at", Date.now());
       });
@@ -11582,7 +11757,7 @@ async function getUnfiledVaultMemoriesOp(ctx) {
   const results = await ctx.vaultMemoryCollection.query(...conditions).fetch();
   return mapInBatches(
     results,
-    (record) => vaultMemoryToStored(record, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner)
+    (record2) => vaultMemoryToStored(record2, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner)
   );
 }
 var TOPICS_EXTRACTION_VERSION = 3;
@@ -11724,17 +11899,17 @@ async function stampTopicsExtractedAtOp(ctx, memoryIds, extractedAt, version = T
         }
       }
       const eligible = records.filter(
-        (record) => !record.isDeleted && isOwnedByCtxUser(ctx, record) && !record.topicsUserManaged
+        (record2) => !record2.isDeleted && isOwnedByCtxUser(ctx, record2) && !record2.topicsUserManaged
       );
-      const prepared = eligible.map((record) => {
-        const originalUpdatedAt = record.updatedAt.getTime();
-        return record.prepareUpdate((r) => {
+      const prepared = eligible.map((record2) => {
+        const originalUpdatedAt = record2.updatedAt.getTime();
+        return record2.prepareUpdate((r) => {
           r._setRaw("topics_extracted_at", extractedAt);
           r._setRaw("topics_extracted_version", version);
           r._setRaw("updated_at", originalUpdatedAt);
         });
       });
-      for (const record of eligible) stamped.push(record.id);
+      for (const record2 of eligible) stamped.push(record2.id);
       if (prepared.length > 0) await ctx.database.batch(...prepared);
     });
   }
@@ -11749,14 +11924,14 @@ async function relinkMemoryTopicsOp(ctx, memoryIds) {
   for (const id of Array.from(new Set(memoryIds))) {
     try {
       await ctx.database.write(async (writer) => {
-        let record;
+        let record2;
         try {
-          record = await ctx.vaultMemoryCollection.find(id);
+          record2 = await ctx.vaultMemoryCollection.find(id);
         } catch {
           return;
         }
-        if (record.isDeleted || !isOwnedByCtxUser(ctx, record)) return;
-        const topics = parseTopics(record.topics);
+        if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) return;
+        const topics = parseTopics(record2.topics);
         if (topics === null) return;
         await writer.callWriter(() => relinkMemoryEntitiesFromTopicsOp(entityCtx, id, topics));
         relinked.push(id);
@@ -11781,20 +11956,20 @@ async function backfillMemoryTopicsOp(ctx, memoryIds) {
     await ctx.database.write(async () => {
       const writes = [];
       for (const id of chunkIds) {
-        let record;
+        let record2;
         try {
-          record = await ctx.vaultMemoryCollection.find(id);
+          record2 = await ctx.vaultMemoryCollection.find(id);
         } catch {
           continue;
         }
-        if (record.isDeleted || !isOwnedByCtxUser(ctx, record)) continue;
-        if (parseTopics(record.topics) !== null) continue;
+        if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) continue;
+        if (parseTopics(record2.topics) !== null) continue;
         const links = await entityCtx.memoryEntityCollection.query(Q5.where("memory_id", id)).unsafeFetchRaw();
         const entityIds = links.map((l) => String(l.entity_id));
         if (entityIds.length === 0) continue;
         const entities = await entityCtx.entityCollection.query(Q5.where("id", Q5.oneOf(entityIds))).fetch();
         if (entities.length === 0) continue;
-        const source = record.topicsUserManaged ? "user" : "auto";
+        const source = record2.topicsUserManaged ? "user" : "auto";
         const write = await resolveMemoryTopicsWrite(entityCtx, id, entities, [], source);
         if (write) writes.push(write);
       }
@@ -11812,7 +11987,7 @@ async function deleteAllVaultMemoriesForUserOp(ctx, userId) {
   if (records.length === 0) return 0;
   await ctx.database.write(async () => {
     const prepared = records.map(
-      (record) => record.prepareUpdate((r) => {
+      (record2) => record2.prepareUpdate((r) => {
         r._setRaw("is_deleted", true);
       })
     );
@@ -11842,7 +12017,10 @@ function assertVaultScopeForSweep(ctx) {
 }
 async function getDecayCandidatesRawOp(ctx) {
   assertVaultScopeForSweep(ctx);
-  const results = await ctx.vaultMemoryCollection.query(...baseVaultConditions(ctx, { includeArchived: true, includeQuarantined: true })).unsafeFetchRaw();
+  const results = await ctx.vaultMemoryCollection.query(
+    ...baseVaultConditions(ctx, { includeArchived: true, includeQuarantined: true }),
+    Q5.where("kind", null)
+  ).unsafeFetchRaw();
   return results.map((raw) => ({
     uniqueId: raw.id,
     factType: raw.fact_type ?? null,
@@ -11857,20 +12035,20 @@ async function getDecayCandidatesRawOp(ctx) {
 }
 async function archiveVaultMemoryOp(ctx, id, opts) {
   try {
-    const record = await ctx.vaultMemoryCollection.find(id);
-    if (record.isDeleted || !isOwnedByCtxUser(ctx, record)) return false;
+    const record2 = await ctx.vaultMemoryCollection.find(id);
+    if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) 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) {
+      if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2) || record2.archivedAt !== null) {
         stale = true;
         return;
       }
-      if (opts?.expectedUpdatedAt !== void 0 && record.updatedAt.getTime() !== opts.expectedUpdatedAt || opts?.expectedLastObservedAt !== void 0 && (record.lastObservedAt ?? null) !== opts.expectedLastObservedAt) {
+      if (opts?.expectedUpdatedAt !== void 0 && record2.updatedAt.getTime() !== opts.expectedUpdatedAt || opts?.expectedLastObservedAt !== void 0 && (record2.lastObservedAt ?? null) !== opts.expectedLastObservedAt) {
         stale = true;
         return;
       }
-      await record.update((r) => {
+      await record2.update((r) => {
         r._setRaw("archived_at", archivedAtValue);
       });
     });
@@ -11881,15 +12059,15 @@ async function archiveVaultMemoryOp(ctx, id, opts) {
 }
 async function restoreVaultMemoryOp(ctx, id) {
   try {
-    const record = await ctx.vaultMemoryCollection.find(id);
-    if (record.isDeleted || !isOwnedByCtxUser(ctx, record)) return false;
+    const record2 = await ctx.vaultMemoryCollection.find(id);
+    if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) return false;
     let stale = false;
     await ctx.database.write(async () => {
-      if (record.isDeleted || !isOwnedByCtxUser(ctx, record)) {
+      if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) {
         stale = true;
         return;
       }
-      await record.update((r) => {
+      await record2.update((r) => {
         r._setRaw("archived_at", null);
       });
     });
@@ -11900,17 +12078,17 @@ async function restoreVaultMemoryOp(ctx, id) {
 }
 async function hardDeleteDecayedOp(ctx, id, opts) {
   try {
-    const record = await ctx.vaultMemoryCollection.find(id);
-    if (record.isDeleted || !isOwnedByCtxUser(ctx, record)) return false;
+    const record2 = await ctx.vaultMemoryCollection.find(id);
+    if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) 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) {
+      const archivedAt = record2.archivedAt;
+      if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2) || archivedAt === null || now - archivedAt <= opts.hardDeleteWindowMs) {
         stale = true;
         return;
       }
-      await record.update((r) => {
+      await record2.update((r) => {
         r._setRaw("is_deleted", true);
       });
     });
@@ -11928,14 +12106,14 @@ async function hardDeleteDecayedOp(ctx, id, opts) {
 }
 async function updateVaultMemoryEmbeddingOp(ctx, id, embedding, embeddingModel, expected) {
   try {
-    const record = await ctx.vaultMemoryCollection.find(id);
-    if (record.isDeleted || !isOwnedByCtxUser(ctx, record)) return false;
-    const readUpdatedAt = record.updatedAt.getTime();
-    const readStoredContent = record._getRaw("content");
+    const record2 = await ctx.vaultMemoryCollection.find(id);
+    if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) return false;
+    const readUpdatedAt = record2.updatedAt.getTime();
+    const readStoredContent = record2._getRaw("content");
     if (expected?.updatedAt !== void 0 && expected.updatedAt !== readUpdatedAt) return false;
     if (expected?.content !== void 0) {
       const current = await vaultMemoryToStored(
-        record,
+        record2,
         ctx.walletAddress,
         ctx.signMessage,
         ctx.embeddedWalletSigner
@@ -11944,11 +12122,11 @@ async function updateVaultMemoryEmbeddingOp(ctx, id, embedding, embeddingModel,
     }
     let written = false;
     await ctx.database.write(async () => {
-      if (record.isDeleted || !isOwnedByCtxUser(ctx, record)) return;
-      const originalUpdatedAt = record.updatedAt.getTime();
-      if (originalUpdatedAt !== readUpdatedAt || record._getRaw("content") !== readStoredContent)
+      if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) return;
+      const originalUpdatedAt = record2.updatedAt.getTime();
+      if (originalUpdatedAt !== readUpdatedAt || record2._getRaw("content") !== readStoredContent)
         return;
-      await record.update((r) => {
+      await record2.update((r) => {
         r._setRaw("embedding", embedding);
         r._setRaw("embedding_model", embeddingModel);
         r._setRaw("updated_at", originalUpdatedAt);
@@ -11963,8 +12141,8 @@ async function updateVaultMemoryEmbeddingOp(ctx, id, embedding, embeddingModel,
 function normalizeForDedupe(content) {
   return content.normalize("NFKC").trim().replace(/\s+/g, " ").toLowerCase();
 }
-async function findQuarantinedDuplicateOp(ctx, content, sourceIds, where) {
-  const wanted = [...new Set(sourceIds)].sort().join("\0");
+async function findQuarantinedDuplicateOp(ctx, content, sourceIds2, where) {
+  const wanted = [...new Set(sourceIds2)].sort().join("\0");
   const target = normalizeForDedupe(content);
   const rows = await ctx.vaultMemoryCollection.query(
     Q5.where("trust_tier", "quarantined"),
@@ -11983,13 +12161,13 @@ async function findQuarantinedDuplicateOp(ctx, content, sourceIds, where) {
     if (!Array.isArray(ids)) continue;
     const key = [...new Set(ids.filter((id) => typeof id === "string"))].sort().join("\0");
     if (key !== wanted) continue;
-    const stored = await vaultMemoryRawToStored(
+    const stored2 = await vaultMemoryRawToStored(
       raw,
       ctx.walletAddress,
       ctx.signMessage,
       ctx.embeddedWalletSigner
     );
-    if (normalizeForDedupe(stored.content) === target) return stored.uniqueId;
+    if (normalizeForDedupe(stored2.content) === target) return stored2.uniqueId;
   }
   return null;
 }
@@ -12098,25 +12276,26 @@ async function ingestPublishedPhotoMemoriesOp(ctx, rows) {
     inserted = writable.length;
     if (writable.length === 0) return;
     const prepared = writable.map(
-      ({ row, content }) => ctx.vaultMemoryCollection.prepareCreate((record) => {
-        record._raw.id = row.memoryId;
-        record._setRaw("content", content);
-        record._setRaw("scope", "shared");
-        record._setRaw("folder_id", null);
-        record._setRaw("user_id", ctx.userId ?? null);
-        record._setRaw("is_deleted", false);
-        record._setRaw("proof_count", 1);
-        record._setRaw("source", SOURCE_PHOTO);
-        record._setRaw(
+      ({ row, content }) => ctx.vaultMemoryCollection.prepareCreate((record2) => {
+        record2._raw.id = row.memoryId;
+        record2._setRaw("content", content);
+        record2._setRaw("scope", "shared");
+        record2._setRaw("level", "matching");
+        record2._setRaw("folder_id", null);
+        record2._setRaw("user_id", ctx.userId ?? null);
+        record2._setRaw("is_deleted", false);
+        record2._setRaw("proof_count", 1);
+        record2._setRaw("source", SOURCE_PHOTO);
+        record2._setRaw(
           "media",
           row.media && row.media.length > 0 ? JSON.stringify(row.media) : null
         );
-        record._setRaw("visibility", "public");
-        record._setRaw("published_at", now);
+        record2._setRaw("visibility", "public");
+        record2._setRaw("published_at", now);
         if (row.eventTime) {
-          record._setRaw("event_time_start", row.eventTime.start ?? null);
-          record._setRaw("event_time_end", row.eventTime.end ?? null);
-          record._setRaw("event_time_kind", row.eventTime.kind ?? null);
+          record2._setRaw("event_time_start", row.eventTime.start ?? null);
+          record2._setRaw("event_time_end", row.eventTime.end ?? null);
+          record2._setRaw("event_time_kind", row.eventTime.kind ?? null);
         }
       })
     );
@@ -12480,11 +12659,11 @@ function folderToStored(folder) {
 }
 async function createVaultFolderOp(ctx, opts) {
   const created = await ctx.database.write(async () => {
-    return ctx.vaultFolderCollection.create((record) => {
-      record._setRaw("name", opts.name);
-      record._setRaw("scope", opts.scope ?? "private");
-      record._setRaw("is_system", opts.isSystem ?? false);
-      record._setRaw("is_deleted", false);
+    return ctx.vaultFolderCollection.create((record2) => {
+      record2._setRaw("name", opts.name);
+      record2._setRaw("scope", opts.scope ?? "private");
+      record2._setRaw("is_system", opts.isSystem ?? false);
+      record2._setRaw("is_deleted", false);
     });
   });
   return folderToStored(created);
@@ -12495,14 +12674,14 @@ async function getAllVaultFoldersOp(ctx) {
 }
 async function updateVaultFolderOp(ctx, id, opts) {
   try {
-    const record = await ctx.vaultFolderCollection.find(id);
-    if (record.isDeleted) return null;
-    const scopeChanged = opts.scope !== void 0 && opts.scope !== record.scope;
+    const record2 = await ctx.vaultFolderCollection.find(id);
+    if (record2.isDeleted) return null;
+    const scopeChanged = opts.scope !== void 0 && opts.scope !== record2.scope;
     const updated = await ctx.database.write(async () => {
       const memories = scopeChanged ? await ctx.vaultMemoryCollection.query(Q6.where("folder_id", id), Q6.where("is_deleted", false)).fetch() : [];
       const updates = [];
       updates.push(
-        record.prepareUpdate((r) => {
+        record2.prepareUpdate((r) => {
           if (opts.name !== void 0) r._setRaw("name", opts.name);
           if (opts.scope !== void 0) r._setRaw("scope", opts.scope);
         })
@@ -12510,6 +12689,7 @@ async function updateVaultFolderOp(ctx, id, opts) {
       for (const memory of memories) {
         updates.push(
           memory.prepareUpdate((r) => {
+            r._setRaw("level", levelForScopeChange(r, opts.scope));
             r._setRaw("scope", opts.scope);
           })
         );
@@ -12524,17 +12704,18 @@ async function updateVaultFolderOp(ctx, id, opts) {
 }
 async function deleteVaultFolderOp(ctx, id) {
   try {
-    const record = await ctx.vaultFolderCollection.find(id);
-    if (record.isDeleted) return false;
+    const record2 = await ctx.vaultFolderCollection.find(id);
+    if (record2.isDeleted) return false;
     await ctx.database.write(async () => {
       const memories = await ctx.vaultMemoryCollection.query(Q6.where("folder_id", id), Q6.where("is_deleted", false)).fetch();
       const preparedMemories = memories.map(
         (memory) => memory.prepareUpdate((r) => {
           r._setRaw("folder_id", null);
+          r._setRaw("level", levelForScopeChange(r, "private"));
           r._setRaw("scope", "private");
         })
       );
-      const preparedFolder = record.prepareUpdate((r) => {
+      const preparedFolder = record2.prepareUpdate((r) => {
         r._setRaw("is_deleted", true);
       });
       await ctx.database.batch(...preparedMemories, preparedFolder);
@@ -12567,6 +12748,7 @@ async function moveMemoriesToFolderOp(ctx, memoryIds, folderId) {
       const prepared = memories.map(
         (memory) => memory.prepareUpdate((r) => {
           r._setRaw("folder_id", folderId);
+          r._setRaw("level", levelForScopeChange(r, targetScope));
           r._setRaw("scope", targetScope);
         })
       );
@@ -12580,11 +12762,11 @@ async function moveMemoriesToFolderOp(ctx, memoryIds, folderId) {
 }
 async function updateVaultFolderContextOp(ctx, id, context) {
   try {
-    const record = await ctx.vaultFolderCollection.find(id);
-    if (record.isDeleted) return null;
+    const record2 = await ctx.vaultFolderCollection.find(id);
+    if (record2.isDeleted) return null;
     const updated = await ctx.database.write(async () => {
       await ctx.database.batch(
-        record.prepareUpdate((r) => {
+        record2.prepareUpdate((r) => {
           r._setRaw("context", context);
         })
       );
@@ -14641,7 +14823,7 @@ async function rankPreparedVaultCandidates(query, prepared, embeddingOptions, se
   if (useFusion && !embeddingsUnavailable && facetQueries) {
     let subEmbeddings;
     try {
-      subEmbeddings = await generateEmbeddings(facetQueries, embeddingOptions);
+      subEmbeddings = prepared.facetEmbeddings ?? await generateEmbeddings(facetQueries, embeddingOptions);
     } catch (err) {
       getLogger().warn(
         "memoryVault: sub-query embedding failed \u2014 falling back to single-query ranking: " + (err instanceof Error ? err.message : String(err))
@@ -14826,6 +15008,35 @@ var DEFAULT_SCOPE = "private";
 var DEFAULT_CONSOLIDATE_THRESHOLD = 0.55;
 var DEFAULT_CONSOLIDATE_TOP_K = 20;
 async function retain(content, ctx, options = {}) {
+  return retainWithPersistence(
+    content,
+    {
+      embeddingOptions: ctx.embeddingOptions,
+      vaultCache: ctx.vaultCache,
+      persistence: {
+        prepare: (query, searchOptions) => prepareVaultCandidates(
+          query,
+          ctx.vaultCtx,
+          ctx.embeddingOptions,
+          ctx.vaultCache,
+          searchOptions
+        ),
+        get: (id) => getVaultMemoryOp(ctx.vaultCtx, id),
+        tombstones: (_embedding, _model, scope, folderId) => getAllVaultMemoriesOp(ctx.vaultCtx, {
+          includeDeleted: true,
+          scopes: [scope],
+          ...folderId !== void 0 && { folderId }
+        }),
+        create: (input) => createVaultMemoryOp(ctx.vaultCtx, input),
+        update: (id, patch) => updateVaultMemoryOp(ctx.vaultCtx, id, patch),
+        supersede: (id, successor) => supersedeVaultMemoryOp(ctx.vaultCtx, id, successor),
+        createSuperseding: (input, target) => createSupersedingMemoryOp(ctx.vaultCtx, input, target)
+      }
+    },
+    options
+  );
+}
+async function retainWithPersistence(content, ctx, options = {}) {
   const trimmed = content.trim();
   if (trimmed.length === 0) {
     throw new Error("retain: content cannot be empty");
@@ -14838,19 +15049,14 @@ async function retain(content, ctx, options = {}) {
   let supersedeContent;
   let prepared;
   if (enableAutoMerge) {
-    prepared = await prepareVaultCandidates(
-      trimmed,
-      ctx.vaultCtx,
-      ctx.embeddingOptions,
-      ctx.vaultCache,
-      {
-        limit: Math.max(options.consolidateTopK ?? DEFAULT_CONSOLIDATE_TOP_K, 1),
-        useFusion: false,
-        scopes: [resolvedScope],
-        includeArchived: true,
-        ...options.folderId !== void 0 && { folderId: options.folderId }
-      }
-    );
+    prepared = await ctx.persistence.prepare(trimmed, {
+      limit: Math.max(options.consolidateTopK ?? DEFAULT_CONSOLIDATE_TOP_K, 1),
+      useFusion: false,
+      scopes: [resolvedScope],
+      includeArchived: true,
+      ...options.folderId !== void 0 && { folderId: options.folderId }
+    });
+    prepared = withoutKindedRows(prepared);
     if (prepared.embeddingFailure || prepared.embeddingsUnavailable) {
       throw new Error(
         "retain: embeddings unavailable \u2014 refusing to auto-merge against an inert cosine lane, which would create a duplicate instead of merging into the existing memory. Retry when embeddings recover, or pass enableAutoMerge: false to force a create."
@@ -14881,7 +15087,7 @@ async function retain(content, ctx, options = {}) {
       );
       if (matches.length > 0) {
         const targetId = matches[0].uniqueId;
-        const existing = await getVaultMemoryOp(ctx.vaultCtx, targetId);
+        const existing = await ctx.persistence.get(targetId);
         if (existing && !existing.supersededBy) {
           const mergedSourceIds = unionStrings(
             existing.sourceChunkIds ?? [],
@@ -14890,8 +15096,9 @@ async function retain(content, ctx, options = {}) {
           const eventTimeUpdate = pickEventTimeUpdate(existing, options.eventTime);
           const factTypeUpdate = pickFactTypeUpdate(existing, options.factType);
           const resurrect = resurrectFields(existing);
-          const updated = await updateVaultMemoryOp(ctx.vaultCtx, targetId, {
+          const updated = await ctx.persistence.update(targetId, {
             content: existing.content,
+            freeFormOnly: true,
             proofCountIncrement: 1,
             observationSourceIds: options.sourceChunkIds,
             sourceChunkIds: mergedSourceIds,
@@ -14917,7 +15124,8 @@ async function retain(content, ctx, options = {}) {
   }
   const contentToWrite = supersedeContent ?? trimmed;
   const reusableQueryEmbedding = supersedeContent === void 0 && prepared && prepared.queryEmbedding.length > 0 ? prepared.queryEmbedding : void 0;
-  const embedding = reusableQueryEmbedding ?? await generateEmbedding(contentToWrite, ctx.embeddingOptions);
+  const generatedEmbedding = reusableQueryEmbedding ?? await generateEmbedding(contentToWrite, ctx.embeddingOptions);
+  const embedding = ctx.normalizeEmbedding?.(generatedEmbedding) ?? generatedEmbedding;
   const embeddingModel = ctx.embeddingOptions.model ?? DEFAULT_API_EMBEDDING_MODEL;
   if (options.respectTombstones) {
     const tombstone = await findTombstoneMatch(embedding, embeddingModel, resolvedScope, ctx, {
@@ -14957,8 +15165,7 @@ async function retain(content, ctx, options = {}) {
   };
   if (supersedeTargetIds.length > 0) {
     const [primaryTargetId, ...restTargetIds] = supersedeTargetIds;
-    const { created: created2, retired } = await createSupersedingMemoryOp(
-      ctx.vaultCtx,
+    const { created: created2, retired } = await ctx.persistence.createSuperseding(
       createOpts,
       primaryTargetId
     );
@@ -14974,11 +15181,11 @@ async function retain(content, ctx, options = {}) {
       for (const staleId of restTargetIds) {
         let ok = false;
         try {
-          ok = await supersedeVaultMemoryOp(ctx.vaultCtx, staleId, created2.uniqueId) === true;
+          ok = await ctx.persistence.supersede(staleId, created2.uniqueId) === true;
         } catch {
         }
         if (ok) continue;
-        const stillLive = await getVaultMemoryOp(ctx.vaultCtx, staleId).catch(() => null);
+        const stillLive = await (ctx.persistence.getFresh ? ctx.persistence.getFresh(staleId) : ctx.persistence.get(staleId)).catch(() => null);
         if (stillLive && !stillLive.supersededBy) liveLeftovers.push(staleId);
       }
       if (liveLeftovers.length > 0) {
@@ -15005,7 +15212,7 @@ async function retain(content, ctx, options = {}) {
       `supersede: primary target ${primaryTargetId} retired or deleted inside the atomic write`
     );
   }
-  const created = await createVaultMemoryOp(ctx.vaultCtx, createOpts);
+  const created = await ctx.persistence.create(createOpts);
   cacheRowVector(
     ctx.vaultCache,
     created.uniqueId,
@@ -15020,15 +15227,22 @@ async function retain(content, ctx, options = {}) {
     ...consolidationDecidedCreate && { consolidation: "create" }
   };
 }
+function withoutKindedRows(prepared) {
+  const kinded = new Set(
+    prepared.memories.filter((m) => m.kind !== null && m.kind !== void 0).map((m) => m.uniqueId)
+  );
+  if (kinded.size === 0) return prepared;
+  return {
+    ...prepared,
+    memories: prepared.memories.filter((m) => !kinded.has(m.uniqueId)),
+    embeddedItems: prepared.embeddedItems.filter((item) => !kinded.has(item.id))
+  };
+}
 function unionStrings(a, b) {
   return [.../* @__PURE__ */ new Set([...a, ...b])];
 }
 async function findTombstoneMatch(embedding, embeddingModel, scope, ctx, opts) {
-  const rows = await getAllVaultMemoriesOp(ctx.vaultCtx, {
-    includeDeleted: true,
-    scopes: [scope],
-    ...opts.folderId !== void 0 && { folderId: opts.folderId }
-  });
+  const rows = await ctx.persistence.tombstones(embedding, embeddingModel, scope, opts.folderId);
   let bestId = null;
   let bestSim = opts.threshold;
   for (const row of rows) {
@@ -15095,7 +15309,7 @@ async function tryConsolidate(trimmed, ctx, options, prepared) {
     if (requestedIds.length === 0) return null;
     const valid = [];
     for (const id of requestedIds) {
-      const existing = await getVaultMemoryOp(ctx.vaultCtx, id);
+      const existing = await ctx.persistence.get(id);
       if (existing && !existing.supersededBy) valid.push(id);
     }
     if (valid.length === 0) {
@@ -15107,7 +15321,7 @@ async function tryConsolidate(trimmed, ctx, options, prepared) {
     return { supersede: valid, content: decision.content };
   }
   if (decision.action === "noop" && decision.targetId) {
-    const existing = await getVaultMemoryOp(ctx.vaultCtx, decision.targetId);
+    const existing = await ctx.persistence.get(decision.targetId);
     if (!existing || existing.supersededBy) {
       return abandonToRace(
         options,
@@ -15121,8 +15335,9 @@ async function tryConsolidate(trimmed, ctx, options, prepared) {
     const eventTimeUpdate = pickEventTimeUpdate(existing, options.eventTime);
     const factTypeUpdate = pickFactTypeUpdate(existing, options.factType);
     const resurrect = resurrectFields(existing);
-    const updated = await updateVaultMemoryOp(ctx.vaultCtx, decision.targetId, {
+    const updated = await ctx.persistence.update(decision.targetId, {
       content: existing.content,
+      freeFormOnly: true,
       proofCountIncrement: 1,
       observationSourceIds: options.sourceChunkIds,
       sourceChunkIds: mergedSourceIds,
@@ -15149,7 +15364,7 @@ async function tryConsolidate(trimmed, ctx, options, prepared) {
     };
   }
   if (decision.action === "update" && decision.targetId && decision.content) {
-    const existing = await getVaultMemoryOp(ctx.vaultCtx, decision.targetId);
+    const existing = await ctx.persistence.get(decision.targetId);
     if (!existing || existing.supersededBy) {
       return abandonToRace(
         options,
@@ -15160,13 +15375,15 @@ async function tryConsolidate(trimmed, ctx, options, prepared) {
       existing.sourceChunkIds ?? [],
       options.sourceChunkIds ?? []
     );
-    const newEmbedding = await generateEmbedding(decision.content, ctx.embeddingOptions);
+    const generatedEmbedding = await generateEmbedding(decision.content, ctx.embeddingOptions);
+    const newEmbedding = ctx.normalizeEmbedding?.(generatedEmbedding) ?? generatedEmbedding;
     const consolidatedModel = ctx.embeddingOptions.model ?? DEFAULT_API_EMBEDDING_MODEL;
     const eventTimeUpdate = pickEventTimeUpdate(existing, options.eventTime);
     const factTypeUpdate = pickFactTypeUpdate(existing, options.factType);
     const resurrect = resurrectFields(existing);
-    const updated = await updateVaultMemoryOp(ctx.vaultCtx, decision.targetId, {
+    const updated = await ctx.persistence.update(decision.targetId, {
       content: decision.content,
+      freeFormOnly: true,
       proofCountIncrement: 1,
       observationSourceIds: options.sourceChunkIds,
       sourceChunkIds: mergedSourceIds,
@@ -15209,8 +15426,8 @@ async function tryConsolidate(trimmed, ctx, options, prepared) {
   return null;
 }
 async function assertMergeTargetGoneOrThrow(ctx, targetId) {
-  const stillExists = await getVaultMemoryOp(ctx.vaultCtx, targetId);
-  if (stillExists) {
+  const stillExists = await (ctx.persistence.getFresh ? ctx.persistence.getFresh(targetId) : ctx.persistence.get(targetId));
+  if (stillExists && (stillExists.kind === null || stillExists.kind === void 0)) {
     throw new Error(`retain: merge into memory ${targetId} failed to persist`);
   }
 }
@@ -15724,9 +15941,9 @@ function createAutoExtractor(options) {
   const persistCursor = (conversationId, messages, advancedToId, contiguous) => {
     if (!cursorStore || conversationId === void 0 || !contiguous) return;
     try {
-      const stored = cursorStore.get(conversationId);
-      if (stored && stored !== advancedToId) {
-        const storedIdx = messages.findIndex((m) => m.id === stored);
+      const stored2 = cursorStore.get(conversationId);
+      if (stored2 && stored2 !== advancedToId) {
+        const storedIdx = messages.findIndex((m) => m.id === stored2);
         const newIdx = messages.findIndex((m) => m.id === advancedToId);
         if (storedIdx !== -1 && newIdx !== -1 && storedIdx >= newIdx) return;
       }
@@ -16695,7 +16912,7 @@ async function recall(query, ctx, options = {}) {
     if (graphLaneFailed) degraded.push("graph-lane-failed");
     if (temporalLaneFailed) degraded.push("temporal-lane-failed");
     if (chunksScopeRestricted) degraded.push("chunks-scope-restricted");
-    const laneRan = types.includes("fact") && !!ctx.vaultCtx && !!ctx.vaultCache || types.includes("chunk") && !!ctx.storageCtx || chunksScopeRestricted && !!ctx.storageCtx;
+    const laneRan = types.includes("fact") && (!!ctx.factSource || !!ctx.vaultCtx && !!ctx.vaultCache) || types.includes("chunk") && !!ctx.storageCtx || chunksScopeRestricted && !!ctx.storageCtx;
     const scores = admitted.map((m) => m.score);
     const minScoreApplied = factResults.length > 0 ? factFloor : chunkResults.length > 0 ? chunkFloor : factFloor >= 0 ? factFloor : chunkFloor;
     const diagnostics = {
@@ -16737,7 +16954,7 @@ async function recall(query, ctx, options = {}) {
     return { memories: [], usedBudget, reranked: false, candidateCount: 0 };
   }
   const needsChunkEmbedding = types.includes("chunk") && ctx.storageCtx;
-  const wantsTemporal = types.includes("fact") && ctx.vaultCtx;
+  const wantsTemporal = types.includes("fact") && (ctx.factSource || ctx.vaultCtx);
   const graphRefiner = flags.traverse && options.graphRefine && options.decomposeOptions ? createLlmNeighborRefiner(options.decomposeOptions) : void 0;
   const queryEmbedTotalTimeoutMs = options.queryEmbedTotalTimeoutMs ?? DEFAULT_QUERY_EMBED_TOTAL_TIMEOUT_MS;
   const prepStart = nowMs2();
@@ -16767,7 +16984,7 @@ async function recall(query, ctx, options = {}) {
     safeLane(
       "graph",
       () => graphLaneFailed = true,
-      () => buildGraphLaneRanking(query, ctx, flags.traverse, {
+      () => ctx.factSource ? ctx.factSource.graphRanking(query, flags.traverse, options) : 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 },
@@ -16778,13 +16995,13 @@ async function recall(query, ctx, options = {}) {
     wantsTemporal ? safeLane(
       "temporal",
       () => temporalLaneFailed = true,
-      () => buildTemporalLaneRanking(query, ctx.vaultCtx, options.now)
+      () => ctx.factSource ? ctx.factSource.temporalRanking(query, options.now) : buildTemporalLaneRanking(query, ctx.vaultCtx, options.now)
     ) : Promise.resolve([])
   ]);
   prepMs = nowMs2() - prepStart;
   graphLaneCount = entityRanking.length;
   temporalLaneCount = temporalRanking.length;
-  if (types.includes("fact") && ctx.vaultCtx && ctx.vaultCache) {
+  if (types.includes("fact") && (ctx.factSource || ctx.vaultCtx && ctx.vaultCache)) {
     const factStart = nowMs2();
     const vaultMinScore = options.minScore ?? DEFAULT_FACT_MIN_SCORE;
     factFloor = vaultMinScore;
@@ -16800,50 +17017,50 @@ async function recall(query, ctx, options = {}) {
       rankedOnCosine: factRankedOnCosine,
       decryptLast: factDecryptLast,
       rowsDecrypted: factRowsDecrypted
-    } = await searchVaultMemoriesWithSize(
-      query,
+    } = await (ctx.factSource?.search.bind(ctx.factSource) ?? ((searchQuery, searchOptions) => searchVaultMemoriesWithSize(
+      searchQuery,
       ctx.vaultCtx,
       ctx.embeddingOptions,
       ctx.vaultCache,
-      {
-        limit: types.includes("chunk") ? Math.max(limit * 2, 16) : limit,
-        minSimilarity: vaultMinScore,
-        useFusion: true,
-        rerank: flags.rerank,
-        ...options.rerankTopN !== void 0 && { rerankTopN: options.rerankTopN },
-        ...options.ceWeight !== void 0 && { ceWeight: options.ceWeight },
-        ...options.rerankLoadTimeoutMs !== void 0 && {
-          rerankLoadTimeoutMs: options.rerankLoadTimeoutMs
-        },
-        ...options.recencyAlpha !== void 0 && { recencyAlpha: options.recencyAlpha },
-        ...options.recency && { recency: options.recency },
-        ...options.mmr !== void 0 && { mmr: options.mmr },
-        ...options.supersessionBoost !== void 0 && {
-          supersessionBoost: options.supersessionBoost
-        },
-        ...options.supersessionWindow !== void 0 && {
-          supersessionWindow: options.supersessionWindow
-        },
-        ...options.proofCountAlpha !== void 0 && {
-          proofCountAlpha: options.proofCountAlpha
-        },
-        ...options.bm25AdmissionDivisor !== void 0 && {
-          bm25AdmissionDivisor: options.bm25AdmissionDivisor
-        },
-        ...options.rrfK !== void 0 && { rrfK: options.rrfK },
-        ...options.decryptLast !== void 0 && { decryptLast: options.decryptLast },
-        ...subQueries && { subQueries },
-        ...options.scopes && { scopes: options.scopes },
-        ...options.folderId !== void 0 && { folderId: options.folderId },
-        ...options.factTypes?.length && { factTypes: options.factTypes },
-        ...options.memoryIds !== void 0 && { memoryIds: options.memoryIds },
-        ...options.factTypeWeights && { factTypeWeights: options.factTypeWeights },
-        ...entityRanking.length > 0 && { entityRanking },
-        ...temporalRanking.length > 0 && { temporalRanking },
-        ...needsChunkEmbedding && { queryEmbedding: queryEmbedding ?? [] },
-        queryEmbedTotalTimeoutMs
-      }
-    );
+      searchOptions
+    )))(query, {
+      limit: types.includes("chunk") ? Math.max(limit * 2, 16) : limit,
+      minSimilarity: vaultMinScore,
+      useFusion: true,
+      rerank: flags.rerank,
+      ...options.rerankTopN !== void 0 && { rerankTopN: options.rerankTopN },
+      ...options.ceWeight !== void 0 && { ceWeight: options.ceWeight },
+      ...options.rerankLoadTimeoutMs !== void 0 && {
+        rerankLoadTimeoutMs: options.rerankLoadTimeoutMs
+      },
+      ...options.recencyAlpha !== void 0 && { recencyAlpha: options.recencyAlpha },
+      ...options.recency && { recency: options.recency },
+      ...options.mmr !== void 0 && { mmr: options.mmr },
+      ...options.supersessionBoost !== void 0 && {
+        supersessionBoost: options.supersessionBoost
+      },
+      ...options.supersessionWindow !== void 0 && {
+        supersessionWindow: options.supersessionWindow
+      },
+      ...options.proofCountAlpha !== void 0 && {
+        proofCountAlpha: options.proofCountAlpha
+      },
+      ...options.bm25AdmissionDivisor !== void 0 && {
+        bm25AdmissionDivisor: options.bm25AdmissionDivisor
+      },
+      ...options.rrfK !== void 0 && { rrfK: options.rrfK },
+      ...options.decryptLast !== void 0 && { decryptLast: options.decryptLast },
+      ...subQueries && { subQueries },
+      ...options.scopes && { scopes: options.scopes },
+      ...options.folderId !== void 0 && { folderId: options.folderId },
+      ...options.factTypes?.length && { factTypes: options.factTypes },
+      ...options.memoryIds !== void 0 && { memoryIds: options.memoryIds },
+      ...options.factTypeWeights && { factTypeWeights: options.factTypeWeights },
+      ...entityRanking.length > 0 && { entityRanking },
+      ...temporalRanking.length > 0 && { temporalRanking },
+      ...needsChunkEmbedding && { queryEmbedding: queryEmbedding ?? [] },
+      queryEmbedTotalTimeoutMs
+    });
     factResults.push(
       ...dedupeBy(
         results,
@@ -17648,26 +17865,26 @@ async function extractAndLinkEntitiesForMemoriesOp(ctx, memoryIds, options) {
   };
   const inputs = [];
   for (const id of new Set(memoryIds)) {
-    let record;
+    let record2;
     try {
-      record = await ctx.vaultMemoryCollection.find(id);
+      record2 = await ctx.vaultMemoryCollection.find(id);
     } catch (err) {
       log.warn("[memory/topics] vault lookup failed for extraction", err);
       skip(id, "not-found");
       continue;
     }
-    if (record.isDeleted || ctx.userId !== void 0 && record.userId !== ctx.userId || record.topicsUserManaged) {
+    if (record2.isDeleted || ctx.userId !== void 0 && record2.userId !== ctx.userId || record2.topicsUserManaged) {
       skip(id, "excluded");
       continue;
     }
     try {
-      const stored = await vaultMemoryToStored(
-        record,
+      const stored2 = await vaultMemoryToStored(
+        record2,
         ctx.walletAddress,
         ctx.signMessage,
         ctx.embeddedWalletSigner
       );
-      inputs.push({ id, content: stored.content });
+      inputs.push({ id, content: stored2.content });
     } catch (err) {
       log.warn("[memory/topics] failed to load memory for extraction", err);
       skip(id, "unreadable");
@@ -17852,6 +18069,780 @@ function createLocalMemoryStore(options) {
   };
 }
 
+// src/lib/memory/store/remotePersistence.ts
+var RemoteMemoryError = class extends Error {
+  constructor(message, status, code) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "RemoteMemoryError";
+  }
+};
+var ciphertextPattern = /^enc:v\d+:[0-9a-f]+$/i;
+var memoryFields = {
+  memory_id: true,
+  content: true,
+  scope: true,
+  created_at: true,
+  updated_at: true,
+  is_deleted: true,
+  embedding: true,
+  embedding_model: true,
+  kind: true,
+  kind_value: true,
+  level: true,
+  folder_id: true,
+  source_chunk_ids: true,
+  proof_count: true,
+  source: true,
+  event_time_start: true,
+  event_time_end: true,
+  event_time_kind: true,
+  topics_user_managed: true,
+  topics: true,
+  topics_updated_at: true,
+  media: true,
+  topics_extracted_at: true,
+  topics_extracted_version: true,
+  superseded_by: true,
+  superseded_at: true,
+  last_observed_at: true,
+  fact_type: true,
+  archived_at: true,
+  trust_tier: true,
+  visibility: true,
+  twin_opt_in: true,
+  published_at: true,
+  geohash: true
+};
+var candidateListLimits = [
+  ["scopes", 20],
+  ["fact_types", 20],
+  ["memory_ids", 1e3],
+  ["force_ids", 100]
+];
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function memoryRecord(value) {
+  if (!record(value) || !record(value.memory) || typeof value.memory.memory_id !== "string" || typeof value.memory.content !== "string" || typeof value.memory.scope !== "string" || typeof value.memory.created_at !== "number" || typeof value.memory.updated_at !== "number" || typeof value.memory.is_deleted !== "boolean" || !Number.isSafeInteger(value.version) || value.version < 1 || typeof value.server_updated_at !== "string" || value.score !== void 0 && (typeof value.score !== "number" || !Number.isFinite(value.score))) {
+    throw new Error("Invalid nearby private-memory response");
+  }
+  return value;
+}
+async function createRemoteMemoryPersistence(options) {
+  const base = new URL(options.baseUrl);
+  if (!/^https?:$/.test(base.protocol) || base.username || base.password || base.search || base.hash) {
+    throw new Error(
+      "baseUrl must be an HTTP(S) origin or base path without credentials, query or fragment"
+    );
+  }
+  if (!options.keyId || options.keyId.length > 256)
+    throw new Error("A canonical keyId is required");
+  const timeoutMs = options.timeoutMs ?? 3e4;
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0)
+    throw new Error("timeoutMs must be a positive number");
+  const root = base.href.replace(/\/$/, "") + "/api/private-memories";
+  const fetcher = options.fetch ?? globalThis.fetch;
+  const request = async (path, init = {}, signal) => {
+    const controller = new AbortController();
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+    }, timeoutMs);
+    const forwardAbort = () => controller.abort(signal?.reason);
+    if (signal?.aborted) forwardAbort();
+    else signal?.addEventListener("abort", forwardAbort, { once: true });
+    let rejectAborted;
+    const aborted = new Promise((_, reject) => {
+      rejectAborted = () => reject(
+        controller.signal.reason instanceof Error ? controller.signal.reason : new Error("Nearby request aborted")
+      );
+      if (controller.signal.aborted) rejectAborted();
+      else controller.signal.addEventListener("abort", rejectAborted, { once: true });
+    });
+    aborted.catch(() => void 0);
+    try {
+      const token = await Promise.race([options.getToken(), aborted]);
+      if (controller.signal.aborted) await aborted;
+      if (!token) throw new RemoteMemoryError("Authentication required", 401);
+      const response = await fetcher(root + path, {
+        ...init,
+        headers: {
+          Authorization: `Bearer ${token}`,
+          ...init.body ? { "Content-Type": "application/json" } : {}
+        },
+        redirect: "error",
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        const body = await response.json().catch(() => null);
+        throw new RemoteMemoryError(
+          record(body) && typeof body.detail === "string" ? body.detail : `Nearby request failed (${response.status})`,
+          response.status,
+          record(body) && typeof body.code === "string" ? body.code : void 0
+        );
+      }
+      return await response.json();
+    } catch (error) {
+      if (timedOut) throw new RemoteMemoryError("Nearby request timed out", 408, "timeout");
+      throw error;
+    } finally {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", forwardAbort);
+      if (rejectAborted) controller.signal.removeEventListener("abort", rejectAborted);
+    }
+  };
+  const account = await request("/account", {}, options.signal);
+  if (!record(account) || account.state !== "active") {
+    throw new RemoteMemoryError(
+      "Complete and verify migration before using remote memories",
+      409,
+      "memory_not_active"
+    );
+  }
+  if (account.key_id !== options.keyId) {
+    throw new RemoteMemoryError(
+      "The canonical memory key does not match this account",
+      409,
+      "key_mismatch"
+    );
+  }
+  const snapshots = /* @__PURE__ */ new WeakMap();
+  const decode = async (value) => {
+    const item = memoryRecord(value);
+    const decrypt = async (ciphertext) => {
+      if (!ciphertextPattern.test(ciphertext))
+        throw new Error("Nearby returned unencrypted memory content");
+      const plaintext = await options.decrypt(ciphertext);
+      if (plaintext === ciphertext) throw new Error("Memory decryption failed");
+      return plaintext;
+    };
+    const decoded = {
+      ...item,
+      memory: {
+        ...item.memory,
+        content: await decrypt(item.memory.content),
+        ...item.memory.kind_value !== void 0 && {
+          kind_value: await decrypt(item.memory.kind_value)
+        }
+      }
+    };
+    return remember(decoded, item);
+  };
+  const remember = (decoded, item) => {
+    snapshots.set(decoded, {
+      id: item.memory.memory_id,
+      version: item.version,
+      content: decoded.memory.content,
+      kindValue: decoded.memory.kind_value,
+      encryptedContent: item.memory.content,
+      encryptedKindValue: item.memory.kind_value
+    });
+    return decoded;
+  };
+  const decodeAll = async (values) => {
+    const records = values.map(memoryRecord);
+    const settled = await Promise.allSettled(records.map(decode));
+    const items = [];
+    const failed = [];
+    settled.forEach((result, i) => {
+      if (result.status === "fulfilled") items.push(result.value);
+      else
+        failed.push({
+          memory_id: records[i].memory.memory_id,
+          version: records[i].version,
+          error: result.reason instanceof Error ? result.reason : new Error(String(result.reason))
+        });
+    });
+    return { items, failed };
+  };
+  const decodeCommitted = async (value, write) => {
+    const item = memoryRecord(value);
+    if (item.memory.memory_id !== write.body.memory.memory_id || item.memory.content !== write.body.memory.content || item.memory.kind_value !== write.body.memory.kind_value)
+      return decode(item);
+    return remember(
+      {
+        ...item,
+        memory: {
+          ...item.memory,
+          content: write.content,
+          ...write.kindValue !== void 0 && { kind_value: write.kindValue }
+        }
+      },
+      item
+    );
+  };
+  const encryptField2 = async (plaintext) => {
+    const ciphertext = await options.encrypt(plaintext);
+    if (ciphertext === plaintext || !ciphertextPattern.test(ciphertext))
+      throw new Error("Field encryption must return SDK ciphertext; refusing to upload plaintext");
+    return ciphertext;
+  };
+  const memoryPath = (id) => {
+    if (!id || id.length > 128) throw new Error("memory_id must be 1\u2013128 characters");
+    return "/memories/" + encodeURIComponent(id);
+  };
+  const prepareWrite = async (memory, expectedVersion, signal) => {
+    const unknown = Object.keys(memory).filter(
+      (key) => !Object.prototype.hasOwnProperty.call(memoryFields, key)
+    );
+    if (unknown.length) {
+      throw new RemoteMemoryError(
+        `Unknown private-memory fields (${unknown.join(", ")}); refusing to forward them`,
+        400,
+        "unknown_field"
+      );
+    }
+    memory = { ...memory, ...memory.embedding && { embedding: [...memory.embedding] } };
+    const path = memoryPath(memory.memory_id);
+    const snapshot = typeof expectedVersion === "number" ? void 0 : snapshots.get(expectedVersion);
+    if (typeof expectedVersion !== "number" && (!snapshot || snapshot.id !== memory.memory_id || snapshot.version !== expectedVersion.version))
+      throw new Error(
+        "Expected snapshot must be an unmodified version from this persistence instance"
+      );
+    expectedVersion = typeof expectedVersion === "number" ? expectedVersion : snapshot.version;
+    if (!Number.isSafeInteger(expectedVersion) || expectedVersion < 0)
+      throw new Error("expectedVersion must be a nonnegative integer");
+    const conflict = () => new RemoteMemoryError("The memory changed since it was read", 409, "version_conflict");
+    let existing;
+    if (expectedVersion !== 0 && !snapshot) {
+      try {
+        existing = memoryRecord(await request(path, {}, signal));
+      } catch (error) {
+        if (error instanceof RemoteMemoryError && error.status === 404) throw conflict();
+        throw error;
+      }
+    }
+    if (existing && existing.version !== expectedVersion) throw conflict();
+    const decoded = existing ? await decode(existing).catch(() => void 0) : void 0;
+    const content = (snapshot?.content ?? decoded?.memory.content) === memory.content ? snapshot?.encryptedContent ?? existing.memory.content : await encryptField2(memory.content);
+    const kindValue = memory.kind_value === void 0 ? void 0 : (snapshot?.kindValue ?? decoded?.memory.kind_value) === memory.kind_value ? snapshot?.encryptedKindValue ?? existing.memory.kind_value : await encryptField2(memory.kind_value);
+    return {
+      body: {
+        expected_version: expectedVersion,
+        memory: { ...memory, content, ...kindValue !== void 0 && { kind_value: kindValue } }
+      },
+      content: memory.content,
+      kindValue: memory.kind_value
+    };
+  };
+  const fetchCandidates = async (embedding, candidateOptions, withCounts) => {
+    const limit = candidateOptions.limit ?? 100;
+    if (!Number.isInteger(limit) || limit < 1 || limit > 100)
+      throw new Error("Candidate limit must be 1\u2013100");
+    for (const [key, max] of candidateListLimits) {
+      const values = candidateOptions[key];
+      if (values && values.length > max)
+        throw new Error(`Candidate ${key} accepts at most ${max} entries (got ${values.length})`);
+    }
+    const result = await request(
+      "/candidates",
+      {
+        method: "POST",
+        body: JSON.stringify({
+          embedding,
+          limit,
+          force_ids: candidateOptions.force_ids ?? [],
+          ...withCounts && { with_counts: true },
+          ...Object.fromEntries(
+            [
+              "scopes",
+              "memory_ids",
+              "embedding_model",
+              "strict_model",
+              "include_deleted",
+              "deleted_only"
+            ].filter(
+              (key) => candidateOptions[key] !== void 0
+            ).map((key) => [key, candidateOptions[key]])
+          ),
+          ...candidateOptions.fact_types !== void 0 && {
+            fact_types: candidateOptions.fact_types
+          },
+          ...candidateOptions.include_archived !== void 0 && {
+            include_archived: candidateOptions.include_archived
+          },
+          ...candidateOptions.include_quarantined !== void 0 && {
+            include_quarantined: candidateOptions.include_quarantined
+          },
+          ...candidateOptions.include_superseded !== void 0 && {
+            include_superseded: candidateOptions.include_superseded
+          }
+        })
+      },
+      candidateOptions.signal
+    );
+    if (!record(result) || !Array.isArray(result.items))
+      throw new Error("Invalid nearby candidate response");
+    return result;
+  };
+  const candidateSet = async (embedding, candidateOptions = {}) => {
+    const result = await fetchCandidates(embedding, candidateOptions, true);
+    if (!Number.isSafeInteger(result.total_count) || result.total_count < 0 || !Number.isSafeInteger(result.unavailable_count) || result.unavailable_count < 0)
+      throw new Error("Invalid nearby candidate response");
+    return {
+      ...await decodeAll(result.items),
+      total_count: result.total_count,
+      unavailable_count: result.unavailable_count
+    };
+  };
+  return {
+    get: async (id, signal) => {
+      try {
+        return await decode(await request(memoryPath(id), {}, signal));
+      } catch (error) {
+        if (error instanceof RemoteMemoryError && error.status === 404) return null;
+        throw error;
+      }
+    },
+    list: async (listOptions = {}) => {
+      const { signal, ...query } = listOptions;
+      if (query.limit !== void 0 && (!Number.isInteger(query.limit) || query.limit < 1 || query.limit > 200)) {
+        throw new Error("Page limit must be 1\u2013200");
+      }
+      const params = new URLSearchParams();
+      for (const key of [
+        "cursor",
+        "limit",
+        "include_deleted",
+        "include_archived",
+        "include_quarantined",
+        "include_superseded",
+        "include_embeddings"
+      ]) {
+        if (query[key] !== void 0) params.set(key, String(query[key]));
+      }
+      const page = await request("/memories?" + params.toString(), {}, signal);
+      if (!record(page) || !Array.isArray(page.items) || page.next_cursor !== void 0 && typeof page.next_cursor !== "string") {
+        throw new Error("Invalid nearby private-memory page");
+      }
+      return {
+        ...await decodeAll(page.items),
+        ...page.next_cursor !== void 0 && { next_cursor: page.next_cursor }
+      };
+    },
+    put: async (memory, expectedVersion, signal) => {
+      const write = await prepareWrite(memory, expectedVersion, signal);
+      return decodeCommitted(
+        await request(
+          memoryPath(write.body.memory.memory_id),
+          {
+            method: "PUT",
+            body: JSON.stringify({ key_id: options.keyId, ...write.body })
+          },
+          signal
+        ),
+        write
+      );
+    },
+    putMany: async (writes, signal) => {
+      if (writes.length < 1 || writes.length > 50 || new Set(writes.map((w) => w.memory.memory_id)).size !== writes.length)
+        throw new Error("Batch must contain 1\u201350 distinct memory ids");
+      const prepared = await Promise.all(
+        writes.map((w) => prepareWrite(w.memory, w.expectedVersion, signal))
+      );
+      const result = await request(
+        "/memories/batch",
+        {
+          method: "POST",
+          body: JSON.stringify({ key_id: options.keyId, writes: prepared.map((w) => w.body) })
+        },
+        signal
+      );
+      if (!record(result) || !Array.isArray(result.items) || result.items.length !== prepared.length)
+        throw new Error("Invalid nearby batch response");
+      return Promise.all(result.items.map((item, i) => decodeCommitted(item, prepared[i])));
+    },
+    candidateSet,
+    candidates: async (embedding, candidateOptions = {}) => decodeAll((await fetchCandidates(embedding, candidateOptions, false)).items)
+  };
+}
+
+// src/lib/memory/store/remotePipeline.ts
+import { v7 as uuidv74 } from "uuid";
+function storedVector(vector) {
+  if (!Array.isArray(vector) || vector.length !== 1536 && vector.length !== 4096 || vector.some((v) => !Number.isFinite(v)))
+    throw new Error("Remote memories require a finite 1536/4096-dimensional vector");
+  const out = vector.slice(0, 1536);
+  const norm = Math.sqrt(out.reduce((sum, v) => sum + v * v, 0));
+  if (!norm) throw new Error("Remote query/content vector has no direction after MRL truncation");
+  return out.map((v) => v / norm);
+}
+function sourceIds(value) {
+  if (!value) return [];
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed.filter((id) => typeof id === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function isMemoryLevel(value) {
+  return MEMORY_LEVELS.includes(value);
+}
+function stored(row) {
+  return {
+    uniqueId: row.memory_id,
+    content: row.content,
+    scope: row.scope,
+    folderId: row.folder_id ?? null,
+    userId: null,
+    kind: row.kind ?? null,
+    kindValue: row.kind_value ?? null,
+    ...isMemoryLevel(row.level) && { level: row.level },
+    embedding: row.embedding ? JSON.stringify(row.embedding) : null,
+    embeddingModel: row.embedding_model ?? null,
+    sourceChunkIds: row.source_chunk_ids === void 0 ? null : sourceIds(row.source_chunk_ids),
+    proofCount: row.proof_count ?? null,
+    source: row.source ?? null,
+    media: parseMedia(row.media),
+    eventTimeStart: row.event_time_start ?? null,
+    eventTimeEnd: row.event_time_end ?? null,
+    eventTimeKind: row.event_time_kind ?? null,
+    topicsUserManaged: row.topics_user_managed ?? false,
+    topics: parseTopics(row.topics),
+    topicsUpdatedAt: row.topics_updated_at ?? null,
+    topicsExtractedAt: row.topics_extracted_at ?? null,
+    topicsExtractedVersion: row.topics_extracted_version ?? null,
+    supersededBy: row.superseded_by ?? null,
+    supersededAt: row.superseded_at ?? null,
+    lastObservedAt: row.last_observed_at ?? null,
+    factType: row.fact_type ?? null,
+    archivedAt: row.archived_at ?? null,
+    trustTier: row.trust_tier ?? null,
+    visibility: row.visibility === "public" ? "public" : "private",
+    twinOptIn: row.twin_opt_in ?? false,
+    publishedAt: row.published_at ?? null,
+    geohash: row.geohash ?? null,
+    createdAt: new Date(row.created_at),
+    updatedAt: new Date(row.updated_at),
+    isDeleted: row.is_deleted
+  };
+}
+function createRemoteMemoryPipeline(options) {
+  const { persistence, embeddingOptions } = options;
+  const model = embeddingOptions.model ?? DEFAULT_API_EMBEDDING_MODEL;
+  const operation = (mode) => {
+    const rejectUndecryptable = (failed) => {
+      if (!failed.length) return;
+      if (mode === "retain")
+        throw new Error(
+          `Remote memories could not decrypt ${failed.length} candidate row(s); refusing to retain until they are repaired`
+        );
+      getLogger().warn(
+        `[memory/remote] Skipping ${failed.length} undecryptable candidate row(s)`,
+        failed.map((failure) => failure.memory_id)
+      );
+    };
+    const snapshots = /* @__PURE__ */ new Map();
+    const remember = (items) => {
+      items.forEach((item) => snapshots.set(item.memory.memory_id, item));
+      return items.map((item) => stored(item.memory));
+    };
+    const get = async (id) => {
+      const snapshot = snapshots.get(id) ?? await persistence.get(id);
+      if (!snapshot || snapshot.memory.is_deleted || snapshot.memory.superseded_by) return null;
+      snapshots.set(id, snapshot);
+      return stored(snapshot.memory);
+    };
+    const prepare = async (query, search = {}) => {
+      if (search.folderId !== void 0)
+        throw new Error("Remote memories do not support folder filters");
+      const facets = normalizeSubQueries(search.subQueries);
+      const facetQueries = facets.length >= 2 ? facets : [];
+      const start = Date.now();
+      const budgetMs = search.queryEmbedTotalTimeoutMs ?? 8e3;
+      const embed = (texts) => generateEmbeddings(texts, {
+        ...embeddingOptions,
+        totalTimeoutMs: budgetMs
+      });
+      const embedFacets = async () => {
+        if (!facetQueries.length) return [];
+        try {
+          const vectors2 = await embed(facetQueries);
+          if (vectors2.length !== facetQueries.length)
+            throw new Error("Incomplete facet embeddings");
+          return vectors2.map(storedVector);
+        } catch (error) {
+          getLogger().warn(
+            "[memory/remote] Facet embeddings unavailable; using primary query",
+            error
+          );
+          return [];
+        }
+      };
+      const [primary, facetEmbeddings] = await Promise.all([
+        search.queryEmbedding ?? embed([query]).then((vectors2) => vectors2[0]),
+        embedFacets()
+      ]);
+      const queryEmbedding = storedVector(primary);
+      const queryEmbedMs = Date.now() - start;
+      const graph = search.entityRanking ?? [];
+      const temporal = search.temporalRanking ?? [];
+      const forced = /* @__PURE__ */ new Set();
+      for (let i = 0; i < Math.max(graph.length, temporal.length) && forced.size < 100; i++) {
+        if (graph[i] !== void 0) forced.add(graph[i]);
+        if (forced.size < 100 && temporal[i] !== void 0) forced.add(temporal[i]);
+      }
+      const forceIds = [...forced];
+      const windowOptions = (i, signal) => ({
+        limit: Math.min(100, Math.max((search.limit ?? 8) * 3, 30)),
+        force_ids: i === 0 ? forceIds : [],
+        ...search.scopes && { scopes: search.scopes },
+        ...search.factTypes && { fact_types: search.factTypes },
+        ...search.memoryIds !== void 0 && { memory_ids: search.memoryIds },
+        include_archived: search.includeArchived,
+        embedding_model: model,
+        ...signal && { signal }
+      });
+      const vectors = [queryEmbedding, ...facetEmbeddings];
+      let windows;
+      if (mode === "retain") {
+        windows = await Promise.all(
+          vectors.map((embedding, i) => persistence.candidateSet(embedding, windowOptions(i)))
+        );
+      } else {
+        const deadline = new AbortController();
+        const timer = setTimeout(
+          () => deadline.abort(
+            new RemoteMemoryError("Remote recall exceeded its query budget", 408, "timeout")
+          ),
+          Math.max(0, start + budgetMs - Date.now())
+        );
+        try {
+          windows = await Promise.all(
+            vectors.map(
+              (embedding, i) => persistence.candidates(embedding, windowOptions(i, deadline.signal))
+            )
+          );
+        } finally {
+          clearTimeout(timer);
+        }
+      }
+      rejectUndecryptable([
+        ...new Map(
+          windows.flatMap((window2) => window2.failed).map((failure) => [failure.memory_id, failure])
+        ).values()
+      ]);
+      const items = [
+        ...new Map(
+          windows.flatMap((window2) => window2.items).map((item) => [item.memory.memory_id, item])
+        ).values()
+      ];
+      const memories = remember(items);
+      return {
+        memories,
+        embeddedItems: memories.map((memory) => ({
+          id: memory.uniqueId,
+          content: memory.content,
+          embedding: JSON.parse(memory.embedding ?? "[]"),
+          createdAt: memory.createdAt,
+          updatedAt: memory.updatedAt,
+          proofCount: memory.proofCount,
+          lastObservedAt: memory.lastObservedAt,
+          eventTimeStart: memory.eventTimeStart,
+          eventTimeEnd: memory.eventTimeEnd,
+          eventTimeKind: memory.eventTimeKind === "point" || memory.eventTimeKind === "range" || memory.eventTimeKind === "ongoing" ? memory.eventTimeKind : null,
+          factType: memory.factType,
+          sourceChunkIds: memory.sourceChunkIds
+        })),
+        queryEmbedding,
+        facetEmbeddings,
+        vaultSize: Math.max(windows[0].total_count ?? 0, items.length),
+        embeddingFailure: windows.some((window2) => (window2.unavailable_count ?? 0) > 0),
+        embeddingsUnavailable: (windows[0].total_count ?? items.length) > 0 && !memories.some((memory) => memory.embedding),
+        decryptLast: true,
+        rowsDecrypted: items.length,
+        queryEmbedMs,
+        rowsEmbedded: 0
+      };
+    };
+    const createRow = (input) => {
+      if (input.folderId !== void 0 && input.folderId !== null)
+        throw new Error("Remote memories do not support folders");
+      const now = Date.now();
+      return {
+        memory_id: uuidv74(),
+        content: input.content,
+        scope: input.scope ?? "private",
+        created_at: now,
+        updated_at: now,
+        is_deleted: false,
+        ...input.embedding !== void 0 && {
+          embedding: storedVector(JSON.parse(input.embedding)),
+          embedding_model: input.embeddingModel
+        },
+        source_chunk_ids: JSON.stringify(input.sourceChunkIds ?? []),
+        proof_count: input.proofCount ?? 1,
+        source: input.source ?? "manual",
+        ...input.eventTime && {
+          event_time_start: input.eventTime.start ?? void 0,
+          event_time_end: input.eventTime.end ?? void 0,
+          event_time_kind: input.eventTime.kind ?? void 0
+        },
+        fact_type: input.factType,
+        trust_tier: normalizeTrustTier(input.trustTier) ?? void 0,
+        geohash: input.geohash,
+        visibility: "private",
+        twin_opt_in: false
+      };
+    };
+    const write = async (memory, snapshot) => remember([await persistence.put(memory, snapshot)])[0];
+    const port = {
+      prepare,
+      get,
+      getFresh: async (id) => {
+        const current = await persistence.get(id);
+        return current && !current.memory.is_deleted && !current.memory.superseded_by ? stored(current.memory) : null;
+      },
+      tombstones: async (embedding, embeddingModel, scope, folderId) => {
+        if (folderId !== void 0) throw new Error("Remote memories do not support folders");
+        const window2 = await persistence.candidateSet(storedVector(embedding), {
+          limit: 1,
+          scopes: [scope],
+          embedding_model: embeddingModel,
+          strict_model: true,
+          include_deleted: true,
+          deleted_only: true
+        });
+        rejectUndecryptable(window2.failed);
+        return remember(window2.items);
+      },
+      create: (input) => write(createRow(input), 0),
+      update: async (id, patch) => {
+        const existing = await get(id);
+        if (!existing || patch.freeFormOnly && existing.kind !== null && existing.kind !== void 0)
+          return null;
+        const snapshot = snapshots.get(id);
+        const memory = {
+          ...snapshot.memory,
+          content: patch.content,
+          updated_at: patch.preserveUpdatedAt ? snapshot.memory.updated_at : Date.now()
+        };
+        if (patch.scope !== void 0) memory.scope = patch.scope;
+        if (patch.embedding === void 0 && patch.content !== snapshot.memory.content) {
+          delete memory.embedding;
+          delete memory.embedding_model;
+        }
+        if (patch.embedding !== void 0) {
+          memory.embedding = patch.embedding === null ? [] : storedVector(JSON.parse(patch.embedding));
+          memory.embedding_model = patch.embeddingModel ?? void 0;
+        }
+        const observed = sourceIds(memory.source_chunk_ids);
+        const replay = !!patch.observationSourceIds?.length && patch.observationSourceIds.every((id2) => observed.includes(id2));
+        if (patch.sourceChunkIds !== void 0)
+          memory.source_chunk_ids = JSON.stringify(
+            patch.observationSourceIds?.length ? [.../* @__PURE__ */ new Set([...observed, ...patch.sourceChunkIds])] : patch.sourceChunkIds
+          );
+        if (!replay) {
+          if (patch.proofCountIncrement !== void 0)
+            memory.proof_count = (memory.proof_count ?? 1) + patch.proofCountIncrement;
+          else if (patch.proofCount !== void 0) memory.proof_count = patch.proofCount;
+          if (patch.lastObservedAt !== void 0) memory.last_observed_at = patch.lastObservedAt;
+        }
+        if (patch.source !== void 0) memory.source = patch.source;
+        if (patch.factType !== void 0) memory.fact_type = patch.factType;
+        if (patch.trustTier !== void 0)
+          memory.trust_tier = normalizeTrustTier(patch.trustTier) ?? void 0;
+        if (patch.topicsUserManaged !== void 0)
+          memory.topics_user_managed = patch.topicsUserManaged;
+        if (patch.eventTime !== void 0) {
+          memory.event_time_start = patch.eventTime.start ?? void 0;
+          memory.event_time_end = patch.eventTime.end ?? void 0;
+          memory.event_time_kind = patch.eventTime.kind ?? void 0;
+        }
+        if (patch.restore) memory.archived_at = void 0;
+        return write(memory, snapshot);
+      },
+      supersede: async (id, successor) => {
+        const [target, newer] = await Promise.all([get(id), get(successor)]);
+        if (!target || !newer || id === successor) return false;
+        const old = snapshots.get(id);
+        const next = snapshots.get(successor);
+        remember(
+          await persistence.putMany([
+            {
+              memory: { ...old.memory, superseded_by: successor, superseded_at: Date.now() },
+              expectedVersion: old
+            },
+            { memory: next.memory, expectedVersion: next }
+          ])
+        );
+        return true;
+      },
+      createSuperseding: async (input, targetId) => {
+        const target = await get(targetId);
+        if (!target) return { created: null, retired: false };
+        const snapshot = snapshots.get(targetId);
+        const successor = createRow(input);
+        const rows = remember(
+          await persistence.putMany([
+            { memory: successor, expectedVersion: 0 },
+            {
+              memory: {
+                ...snapshot.memory,
+                superseded_by: successor.memory_id,
+                superseded_at: Date.now()
+              },
+              expectedVersion: snapshot
+            }
+          ])
+        );
+        return { created: rows[0], retired: true };
+      }
+    };
+    return { prepare, port };
+  };
+  return {
+    recall: async (query, recallOptions = {}) => {
+      const { prepare } = operation("recall");
+      return recall(
+        query,
+        {
+          embeddingOptions,
+          factSource: {
+            graphRanking: options.graphRanking,
+            temporalRanking: options.temporalRanking,
+            search: async (text12, searchOptions) => {
+              const prepared = await prepare(text12, searchOptions);
+              const ranked = await rankPreparedVaultCandidates(
+                text12,
+                prepared,
+                embeddingOptions,
+                searchOptions
+              );
+              return {
+                ...ranked,
+                rankedOnCosine: prepared.memories.length > 0 && !prepared.embeddingsUnavailable,
+                decryptLast: true,
+                rowsDecrypted: prepared.rowsDecrypted,
+                queryEmbedMs: prepared.queryEmbedMs,
+                rowsEmbedded: 0
+              };
+            }
+          }
+        },
+        { ...recallOptions, types: ["fact"] }
+      );
+    },
+    retain: async (content, retainOptions) => {
+      const { port } = operation("retain");
+      return retainWithPersistence(
+        content,
+        {
+          persistence: port,
+          embeddingOptions,
+          vaultCache: /* @__PURE__ */ new Map(),
+          normalizeEmbedding: storedVector
+        },
+        retainOptions
+      );
+    }
+  };
+}
+
 // src/lib/memory/synthesizeProfile.ts
 var DEFAULT_SYNTHESIS_MODEL = "inclusionai/ling-2.6-flash";
 var DEFAULT_FACET_RECALL_LIMIT = 20;
@@ -21262,7 +22253,7 @@ function useChat(options) {
 
 // src/expo/useChatStorage.ts
 import { useCallback as useCallback4, useEffect as useEffect4, useMemo, useRef as useRef4, useState as useState4 } from "react";
-import { v7 as uuidv75 } from "uuid";
+import { v7 as uuidv76 } from "uuid";
 
 // src/lib/chat/assembleMessages.ts
 function assembleMessagesWithHistory(historyMessages, callerMessages, summarySystemMessage) {
@@ -21919,9 +22910,9 @@ async function decryptMediaFields(media, address, signMessage, embeddedWalletSig
 }
 
 // src/lib/db/media/types.ts
-import { v7 as uuidv74 } from "uuid";
+import { v7 as uuidv75 } from "uuid";
 function generateMediaId() {
-  return `media_${uuidv74()}`;
+  return `media_${uuidv75()}`;
 }
 
 // src/lib/db/media/operations.ts
@@ -22128,10 +23119,10 @@ function extractImageModelFromToolEvents(toolCallEvents) {
   }
   return void 0;
 }
-function storedToLlmapiMessage(stored) {
-  const content = [{ type: "text", text: stored.content }];
-  if (stored.role !== "assistant" && stored.files?.length) {
-    for (const file of stored.files) {
+function storedToLlmapiMessage(stored2) {
+  const content = [{ type: "text", text: stored2.content }];
+  if (stored2.role !== "assistant" && stored2.files?.length) {
+    for (const file of stored2.files) {
       if (isSendableImageURL(file.url)) {
         content.push({
           type: "image_url",
@@ -22141,11 +23132,11 @@ function storedToLlmapiMessage(stored) {
     }
   }
   const messages = [];
-  if (stored.role === "assistant" && stored.toolCallEvents?.length) {
+  if (stored2.role === "assistant" && stored2.toolCallEvents?.length) {
     messages.push({
-      role: stored.role,
+      role: stored2.role,
       content: void 0,
-      tool_calls: stored.toolCallEvents.map((event) => ({
+      tool_calls: stored2.toolCallEvents.map((event) => ({
         id: event.id,
         type: "function",
         function: {
@@ -22154,7 +23145,7 @@ function storedToLlmapiMessage(stored) {
         }
       }))
     });
-    for (const event of stored.toolCallEvents) {
+    for (const event of stored2.toolCallEvents) {
       if (event.id && event.output !== void 0 && event.output !== null) {
         messages.push({
           role: "tool",
@@ -22163,14 +23154,14 @@ function storedToLlmapiMessage(stored) {
         });
       }
     }
-    const postToolText = stored.content.replace(/!\[[^\]]*\]\(https?:\/\/[a-z0-9]+\.r2\.cloudflarestorage\.com\/[^)]+\)/g, "").replace(/https?:\/\/[a-z0-9]+\.r2\.cloudflarestorage\.com\/[^\s)]+/g, "").replace(/!\[[^\]]*\]\(https?:\/\/[^)\s]+\/api\/v1\/media\/[^/)\s]+\/[^)]+\)/g, "").replace(/https?:\/\/[^\s)]+\/api\/v1\/media\/[^/\s)]+\/[^\s)]+/g, "").replace(/\n{3,}/g, "\n\n").trim();
+    const postToolText = stored2.content.replace(/!\[[^\]]*\]\(https?:\/\/[a-z0-9]+\.r2\.cloudflarestorage\.com\/[^)]+\)/g, "").replace(/https?:\/\/[a-z0-9]+\.r2\.cloudflarestorage\.com\/[^\s)]+/g, "").replace(/!\[[^\]]*\]\(https?:\/\/[^)\s]+\/api\/v1\/media\/[^/)\s]+\/[^)]+\)/g, "").replace(/https?:\/\/[^\s)]+\/api\/v1\/media\/[^/\s)]+\/[^\s)]+/g, "").replace(/\n{3,}/g, "\n\n").trim();
     messages.push({
-      role: stored.role,
+      role: stored2.role,
       content: [{ type: "text", text: postToolText }]
     });
   } else {
     messages.push({
-      role: stored.role,
+      role: stored2.role,
       content
     });
   }
@@ -22877,7 +23868,7 @@ function useChatStorage(options) {
         };
       };
       pendingResumeRef.current = null;
-      const effectiveAssistantUniqueId = assistantUniqueId ?? (resumable ? `msg_${uuidv75()}` : void 0);
+      const effectiveAssistantUniqueId = assistantUniqueId ?? (resumable ? `msg_${uuidv76()}` : void 0);
       const embedToolText = (text12, mask, masked, token) => {
         const opts = {
           getToken: token,
@@ -23395,7 +24386,7 @@ function useChatStorage(options) {
       const detachedResult = result;
       if (detachedResult.detached) {
         recordToolSetTurn(database, convId, matchedToolSets);
-        const rowId = effectiveAssistantUniqueId ?? `msg_${uuidv75()}`;
+        const rowId = effectiveAssistantUniqueId ?? `msg_${uuidv76()}`;
         pendingResumeRef.current = {
           handle: detachedResult.resume ?? null,
           convId,
@@ -23904,6 +24895,9 @@ export {
   LoggerProvider,
   MAX_HOPS,
   MEDIUM_TTL_MS,
+  MEMORY_KINDS,
+  MEMORY_LEVELS,
+  MemoryLevelError,
   NEVER_TTL_MS,
   NODE_BUDGET,
   NOTION_OAUTH_CONFIG,
@@ -23914,6 +24908,7 @@ export {
   QueueManager,
   RECALL_MAX_LIMIT,
   RECALL_TOOL_NAME,
+  RemoteMemoryError,
   RerankerUnavailableError,
   SDK_SCHEMA_VERSION,
   SHORT_TTL_MS,
@@ -23977,6 +24972,8 @@ export {
   createNotionTools,
   createPlatformCursorStore,
   createRecallTool,
+  createRemoteMemoryPersistence,
+  createRemoteMemoryPipeline,
   createStockPricePreProcessor,
   createStreamingDeAnonymizer,
   createVaultEmbeddingCache,