@anuma/sdk 10.9.0 → 11.0.0

package/dist/react/index.cjs

@@ -2394,9 +2394,9 @@ async function refreshEncryptionKeyIfMatches(walletAddress, probeCiphertext, sig
     return false;
   }
   const startEpoch = sessionEpoch;
-  const cached = refreshCandidatesByAddress.get(walletAddress);
-  if (cached) {
-    return tryCommitCandidatesIfProbeMatches(walletAddress, parsed, cached, startEpoch);
+  const cached2 = refreshCandidatesByAddress.get(walletAddress);
+  if (cached2) {
+    return tryCommitCandidatesIfProbeMatches(walletAddress, parsed, cached2, startEpoch);
   }
   let derivePromise = pendingCandidateDerives.get(walletAddress);
   if (!derivePromise) {
@@ -2748,10 +2748,10 @@ function parsePlaintextToken(raw, walletAddress) {
     return null;
   }
   if (!parsed || typeof parsed !== "object") return null;
-  const record2 = parsed;
-  const data = record2.token?.accessToken ? record2.token : record2;
+  const record3 = parsed;
+  const data = record3.token?.accessToken ? record3.token : record3;
   if (!data?.accessToken) return null;
-  if (record2.wallet && record2.wallet !== walletAddress) return null;
+  if (record3.wallet && record3.wallet !== walletAddress) return null;
   return data;
 }
 function promoteUnscopedRow(raw, data, store, scopedKey, unscopedKey, walletAddress) {
@@ -2843,10 +2843,10 @@ async function discoverOAuthMetadata() {
 }
 async function getOAuthMetadata() {
   if (typeof window !== "undefined") {
-    const cached = sessionStorage.getItem(OAUTH_METADATA_KEY);
-    if (cached) {
+    const cached2 = sessionStorage.getItem(OAUTH_METADATA_KEY);
+    if (cached2) {
       try {
-        return JSON.parse(cached);
+        return JSON.parse(cached2);
       } catch {
       }
     }
@@ -2950,8 +2950,8 @@ async function storeTokenData(data, walletAddress) {
     } catch {
     }
   }
-  const record2 = { wallet: walletAddress, token: data };
-  sessionStorage.setItem(getTokenStorageKey(walletAddress), JSON.stringify(record2));
+  const record3 = { wallet: walletAddress, token: data };
+  sessionStorage.setItem(getTokenStorageKey(walletAddress), JSON.stringify(record3));
 }
 async function getStoredTokenData(walletAddress) {
   if (typeof window === "undefined") return null;
@@ -3355,25 +3355,25 @@ var TRUNCATION_MARKER_HEAD = "... (tool output truncated, ";
 var TRUNCATION_MARKER_TAIL = " characters omitted)";
 var MAX_PERSISTED_TOOL_RESULT_CHARS = 1e5;
 function buildToolResultContent(results) {
-  const entries = results.map(
+  const entries2 = results.map(
     (r) => `Tool "${r.name}" returned: ${JSON.stringify(r.result)}`.replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029")
   );
-  const framing = HEADER.length + FOOTER.length + ENTRY_SEPARATOR.length * Math.max(0, entries.length - 1);
-  const summary = capEntries(entries, MAX_PERSISTED_TOOL_RESULT_CHARS - framing).join(
+  const framing = HEADER.length + FOOTER.length + ENTRY_SEPARATOR.length * Math.max(0, entries2.length - 1);
+  const summary = capEntries(entries2, MAX_PERSISTED_TOOL_RESULT_CHARS - framing).join(
     ENTRY_SEPARATOR
   );
   return `${HEADER}${summary}${FOOTER}`;
 }
-function capToolResultEntries(entries, budget) {
-  return capEntries(entries, budget);
+function capToolResultEntries(entries2, budget) {
+  return capEntries(entries2, budget);
 }
-function capEntries(entries, budget) {
-  const smallestFirst = entries.map((_, index) => index).sort((a, b) => entries[a].length - entries[b].length);
-  const capped = [...entries];
+function capEntries(entries2, budget) {
+  const smallestFirst = entries2.map((_, index) => index).sort((a, b) => entries2[a].length - entries2[b].length);
+  const capped = [...entries2];
   let remaining = budget;
-  let unassigned = entries.length;
+  let unassigned = entries2.length;
   for (const index of smallestFirst) {
-    capped[index] = truncateEntry(entries[index], Math.floor(remaining / unassigned));
+    capped[index] = truncateEntry(entries2[index], Math.floor(remaining / unassigned));
     remaining -= capped[index].length;
     unassigned--;
   }
@@ -4265,11 +4265,11 @@ var ToolCallEventIndex = class {
     this.pending = /* @__PURE__ */ new Map();
     this.resetCount = collection.database._resetCount;
     collection.experimentalSubscribe((changes) => {
-      for (const { record: record2, type } of changes) {
+      for (const { record: record3, type } of changes) {
         this.replace(
-          record2.id,
-          type === "destroyed" ? void 0 : record2.conversationId,
-          type === "destroyed" ? void 0 : record2._getRaw("tool_call_events")
+          record3.id,
+          type === "destroyed" ? void 0 : record3.conversationId,
+          type === "destroyed" ? void 0 : record3._getRaw("tool_call_events")
         );
       }
     });
@@ -5395,7 +5395,7 @@ async function updateMessageErrorOp(ctx, uniqueId, error) {
   }
   await ctx.database.write(async () => {
     await message.update((msg) => {
-      msg._setRaw("error", error);
+      msg._setRaw("error", error ?? "");
     });
   });
   return messageToStored(message, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner);
@@ -5712,15 +5712,15 @@ async function searchChunksOp(ctx, queryVector, options) {
       staleSkipped++;
       continue;
     }
-    const cached = chunkCache?.get(key3.id);
-    if (!cached || cached.version !== key3.version) {
+    const cached2 = chunkCache?.get(key3.id);
+    if (!cached2 || cached2.version !== key3.version) {
       missIds.push(key3.id);
       continue;
     }
     cacheHits++;
-    if (cached.chunks.length > 0) {
-      for (let ci = 0; ci < cached.chunks.length; ci++) {
-        const vec = cached.chunks[ci];
+    if (cached2.chunks.length > 0) {
+      for (let ci = 0; ci < cached2.chunks.length; ci++) {
+        const vec = cached2.chunks[ci];
         if (vec.length === 0) continue;
         const similarity = cosineSimilarity(queryVector, vec);
         if (similarity >= minSimilarity) {
@@ -5733,8 +5733,8 @@ async function searchChunksOp(ctx, queryVector, options) {
           });
         }
       }
-    } else if (cached.fallback) {
-      const similarity = cosineSimilarity(queryVector, cached.fallback);
+    } else if (cached2.fallback) {
+      const similarity = cosineSimilarity(queryVector, cached2.fallback);
       if (similarity >= minSimilarity) {
         candidates.push({
           id: key3.id,
@@ -6550,11 +6550,11 @@ var mergeConfigs = (a, b) => {
   return config;
 };
 var headersEntries = (headers) => {
-  const entries = [];
+  const entries2 = [];
   headers.forEach((value, key3) => {
-    entries.push([key3, value]);
+    entries2.push([key3, value]);
   });
-  return entries;
+  return entries2;
 };
 var mergeHeaders = (...headers) => {
   const mergedHeaders = new Headers();
@@ -7034,9 +7034,9 @@ async function embedOne(text16, options, outer) {
   const { cache } = options;
   if (!cache) return Array.from(await requestEmbedding(text16, options, outer));
   const model = options.model ?? DEFAULT_API_EMBEDDING_MODEL;
-  const cached = cache.get(text16);
-  const cachedModel = cached && cachedEmbeddingModels.get(cached);
-  if (cached && (cachedModel === void 0 || cachedModel === model)) return Array.from(cached);
+  const cached2 = cache.get(text16);
+  const cachedModel = cached2 && cachedEmbeddingModels.get(cached2);
+  if (cached2 && (cachedModel === void 0 || cachedModel === model)) return Array.from(cached2);
   const inFlight = inFlightByCache.get(cache) ?? /* @__PURE__ */ new Map();
   inFlightByCache.set(cache, inFlight);
   const requestKey = JSON.stringify([model, text16]);
@@ -7151,10 +7151,10 @@ async function embedMany(texts, options, outer) {
   const uncachedTexts = [];
   for (let i = 0; i < texts.length; i++) {
     if (cache) {
-      const cached = cache.get(texts[i]);
-      const cachedModel = cached && cachedEmbeddingModels.get(cached);
-      if (cached && (cachedModel === void 0 || cachedModel === embeddingModel)) {
-        results[i] = Array.from(cached);
+      const cached2 = cache.get(texts[i]);
+      const cachedModel = cached2 && cachedEmbeddingModels.get(cached2);
+      if (cached2 && (cachedModel === void 0 || cachedModel === embeddingModel)) {
+        results[i] = Array.from(cached2);
         continue;
       }
     }
@@ -7540,8 +7540,12 @@ function createCryptoPricePreProcessor(options = {}) {
 }
 
 // src/lib/memory/store/remotePersistence.ts
+init_logger();
 init_portalLlm();
 
+// src/lib/memory/store/remoteTopics.ts
+init_logger();
+
 // src/lib/db/entities/types.ts
 var ENTITY_KINDS = [
   "person",
@@ -7598,58 +7602,337 @@ function parseTopics(value) {
   return out;
 }
 
+// src/lib/memory/store/topicCodec.ts
+var ciphertextPattern = /^enc:v\d+:[0-9a-f]+$/i;
+var topicHashPattern = /^[0-9a-f]{64}$/;
+var MAX_SEALED_TOPIC_NAME_BYTES = 1024;
+function normalizeTopicName(name) {
+  return normalizeEntityName(name).normalize("NFC");
+}
+function sealedTopicNamesFit(json5) {
+  return (entries(json5) ?? []).every(
+    (entry) => !hashed(entry) || typeof entry.name !== "string" || entry.name.length <= MAX_SEALED_TOPIC_NAME_BYTES
+  );
+}
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hashed(entry) {
+  return record(entry) && typeof entry.name_hash === "string";
+}
+function entries(json5) {
+  if (typeof json5 !== "string") return void 0;
+  try {
+    const parsed = JSON.parse(json5);
+    return Array.isArray(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function cached(cache, key3, load) {
+  let pending = cache.get(key3);
+  if (!pending) {
+    const loading = load();
+    pending = loading;
+    cache.set(key3, loading);
+    loading.catch(() => {
+      if (cache.get(key3) === loading) cache.delete(key3);
+    });
+  }
+  return pending;
+}
+function createTopicCodec(cipher) {
+  const hashes = /* @__PURE__ */ new Map();
+  const opened = /* @__PURE__ */ new Map();
+  const seals = /* @__PURE__ */ new Map();
+  const legacyNames = /* @__PURE__ */ new Map();
+  const hash = async (name) => {
+    const normalized2 = normalizeTopicName(name);
+    if (!normalized2) return null;
+    return cached(hashes, normalized2, async () => {
+      const digest = await cipher.hashTopic(normalized2);
+      if (!topicHashPattern.test(digest))
+        throw new Error("Topic hashing must return 64 lowercase hex characters");
+      return digest;
+    });
+  };
+  const seal = async (display) => {
+    const nameHash = await hash(display);
+    if (nameHash === null) return null;
+    return cached(seals, display, async () => {
+      const name = await cipher.encrypt(display);
+      if (name === display || !ciphertextPattern.test(name))
+        throw new Error(
+          "Topic encryption must return SDK ciphertext; refusing to upload plaintext"
+        );
+      opened.set(name, Promise.resolve(display));
+      return { name_hash: nameHash, name };
+    });
+  };
+  const plain2 = (name) => {
+    if (!ciphertextPattern.test(name)) return Promise.resolve(name);
+    let pending = legacyNames.get(name);
+    if (!pending) {
+      pending = cipher.decrypt(name).catch(() => name);
+      legacyNames.set(name, pending);
+    }
+    return pending;
+  };
+  const open = async ({ name, name_hash: nameHash }) => {
+    if (nameHash === void 0) return plain2(name);
+    if (typeof name !== "string" || typeof nameHash !== "string" || !topicHashPattern.test(nameHash) || !ciphertextPattern.test(name))
+      throw new Error("Nearby returned a malformed topic name");
+    const plaintext = await cached(opened, name, async () => {
+      const value = await cipher.decrypt(name);
+      if (value === name) throw new Error("Topic decryption failed");
+      return value;
+    });
+    if (await hash(plaintext) !== nameHash) throw new Error("Topic name does not match its hash");
+    if (!seals.has(plaintext)) seals.set(plaintext, Promise.resolve({ name_hash: nameHash, name }));
+    return plaintext;
+  };
+  return {
+    hash,
+    seal,
+    open,
+    encodeTopics: async (json5) => {
+      const list = entries(json5);
+      if (!list) return json5;
+      const sealed2 = await Promise.all(
+        list.map(async (entry) => {
+          if (!record(entry) || typeof entry.name !== "string") return null;
+          const name = await seal(await plain2(entry.name));
+          return name && { ...entry, name: name.name, name_hash: name.name_hash };
+        })
+      );
+      return JSON.stringify(sealed2.filter((entry) => entry !== null));
+    },
+    decodeTopics: async (json5) => {
+      const list = entries(json5);
+      if (!list?.some(
+        (entry) => hashed(entry) || record(entry) && typeof entry.name === "string" && ciphertextPattern.test(entry.name)
+      ))
+        return json5;
+      const decoded = await Promise.all(
+        list.map(async (entry) => {
+          if (!hashed(entry))
+            return record(entry) && typeof entry.name === "string" ? { ...entry, name: await plain2(entry.name) } : entry;
+          const { name_hash: nameHash, ...rest } = entry;
+          return { ...rest, name: await open({ name: entry.name, name_hash: nameHash }) };
+        })
+      );
+      return JSON.stringify(decoded);
+    },
+    isLegacy: (json5) => (entries(json5) ?? []).some(
+      (entry) => record(entry) && typeof entry.name === "string" && !hashed(entry)
+    ),
+    matchesLegacy: async (json5, names, hashes2) => {
+      const list = typeof json5 === "string" ? entries(json5) ?? [] : [];
+      if (list.some((entry) => hashed(entry) && hashes2.has(entry.name_hash))) return false;
+      const legacy = await Promise.all(
+        list.map(
+          async (entry) => record(entry) && typeof entry.name === "string" && !hashed(entry) ? normalizeTopicName(await plain2(entry.name)) : null
+        )
+      );
+      return legacy.some((name) => name !== null && names.has(name));
+    },
+    encodeCatalog: async (topic2) => {
+      const sealed2 = await seal(normalizeTopicName(await plain2(topic2.name)));
+      return sealed2 && { ...topic2, name: sealed2.name, name_hash: sealed2.name_hash };
+    },
+    decodeCatalog: async (item) => {
+      const { name_hash: nameHash, ...rest } = item;
+      return { ...rest, name: await open({ name: item.name, name_hash: nameHash }) };
+    }
+  };
+}
+
 // src/lib/memory/store/remoteTopics.ts
+var RETIRE_CONCURRENCY = 8;
 function topic(value) {
   const t = value;
-  if (!t || typeof t.name !== "string" || !t.name || !Number.isSafeInteger(t.version) || t.version < 1 || typeof t.is_deleted !== "boolean" || typeof t.server_updated_at !== "string" || t.kind !== void 0 && typeof t.kind !== "string")
+  if (!t || typeof t.name !== "string" || !t.name || t.name_hash !== void 0 && typeof t.name_hash !== "string" || !Number.isSafeInteger(t.version) || t.version < 1 || typeof t.is_deleted !== "boolean" || typeof t.server_updated_at !== "string" || t.kind !== void 0 && typeof t.kind !== "string")
     throw new Error("Invalid nearby topic");
   return t;
 }
-function createRemoteTopicPersistence(request) {
+async function wireTopics(request, signal) {
+  const out = [];
+  let cursor;
+  do {
+    const page = await request(
+      "/topics?limit=200" + (cursor ? `&cursor=${encodeURIComponent(cursor)}` : ""),
+      {},
+      signal
+    );
+    if (!Array.isArray(page.items) || page.next_cursor !== void 0 && typeof page.next_cursor !== "string")
+      throw new Error("Invalid nearby topic page");
+    out.push(...page.items.map(topic));
+    cursor = page.next_cursor;
+  } while (cursor);
+  return out;
+}
+function hashesOf(items) {
+  return new Set(items.flatMap((t) => t.name_hash === void 0 ? [] : [t.name_hash]));
+}
+async function sealedImport(request, codec, topics, signal) {
+  let oversized = 0;
+  for (let i = 0; i < topics.length; i += 50) {
+    signal?.throwIfAborted();
+    const sealed2 = (await Promise.all(topics.slice(i, i + 50).map((t) => codec.encodeCatalog(t)))).filter((t) => {
+      if (t === null) return false;
+      if (t.name.length <= MAX_SEALED_TOPIC_NAME_BYTES) return true;
+      oversized++;
+      return false;
+    });
+    if (sealed2.length)
+      await request(
+        "/topics/import",
+        { method: "POST", body: JSON.stringify({ topics: sealed2 }) },
+        signal
+      );
+  }
+  signal?.throwIfAborted();
+  if (oversized)
+    getLogger().warn(
+      `[memory/remote] Skipped ${oversized} topic catalog entries whose sealed name exceeds ${MAX_SEALED_TOPIC_NAME_BYTES} bytes`
+    );
+}
+function createRemoteTopicPersistence(request, codec) {
+  let legacyOnly = /* @__PURE__ */ new Set();
   return {
     topics: async () => {
-      const out = [];
-      let cursor;
-      do {
-        const page = await request(
-          "/topics?limit=200" + (cursor ? `&cursor=${encodeURIComponent(cursor)}` : ""),
-          {}
-        );
-        if (!Array.isArray(page.items) || page.next_cursor !== void 0 && typeof page.next_cursor !== "string")
-          throw new Error("Invalid nearby topic page");
-        out.push(...page.items.map(topic));
-        cursor = page.next_cursor;
-      } while (cursor);
-      return out;
+      const items = await wireTopics(request);
+      const hashed2 = hashesOf(items);
+      const legacy = /* @__PURE__ */ new Set();
+      const decoded = await Promise.all(
+        items.map(async (item) => {
+          const plain2 = await codec.decodeCatalog(item);
+          const name = normalizeTopicName(plain2.name);
+          if (item.name_hash === void 0) {
+            const hash = await codec.hash(name);
+            if (hash !== null && hashed2.has(hash)) return null;
+            legacy.add(name);
+          }
+          return { ...plain2, name };
+        })
+      );
+      legacyOnly = legacy;
+      return decoded.filter((t) => t !== null);
     },
     putTopic: async (value, expectedVersion) => {
       if (!Number.isSafeInteger(expectedVersion) || expectedVersion < 0)
         throw new Error("Expected topic version must be a nonnegative integer");
-      return topic(
+      const sealed2 = await codec.encodeCatalog(value);
+      if (!sealed2) throw new Error("Topic name must not be empty");
+      const saved = topic(
         await request("/topics", {
           method: "PUT",
-          body: JSON.stringify({ topic: value, expected_version: expectedVersion })
+          body: JSON.stringify({
+            topic: sealed2,
+            expected_version: legacyOnly.has(normalizeTopicName(value.name)) ? 0 : expectedVersion
+          })
         })
       );
-    },
-    importTopics: async (topics, signal) => {
-      for (let i = 0; i < topics.length; i += 50) {
-        signal?.throwIfAborted();
-        await request(
-          "/topics/import",
-          {
-            method: "POST",
-            body: JSON.stringify({ topics: topics.slice(i, i + 50) })
-          },
-          signal
-        );
-      }
+      const decoded = await codec.decodeCatalog(saved);
+      legacyOnly.delete(decoded.name);
+      return decoded;
+    },
+    importTopics: (topics, signal) => sealedImport(
+      request,
+      codec,
+      topics.map(({ name, kind }) => ({ name, ...kind !== void 0 && { kind } })),
+      signal
+    )
+  };
+}
+async function retireLegacyTopics(request, codec, topics, imported, signal) {
+  const failures = [];
+  const put = async (topic2, expectedVersion) => {
+    try {
+      await request(
+        "/topics",
+        { method: "PUT", body: JSON.stringify({ topic: topic2, expected_version: expectedVersion }) },
+        signal
+      );
+      return "saved";
+    } catch (error) {
+      if (signal?.aborted) throw error;
+      if (error instanceof RemoteMemoryError && error.status === 409) return "conflict";
+      failures.push(error);
+      return "failed";
+    }
+  };
+  const retire = (item) => put(
+    { name: item.name, ...item.kind !== void 0 && { kind: item.kind }, is_deleted: true },
+    item.version
+  );
+  const changed = [];
+  let next = 0;
+  const worker = async () => {
+    while (next < topics.length) {
       signal?.throwIfAborted();
+      const item = topics[next++];
+      if (await retire(item) === "conflict") changed.push(item);
     }
   };
+  await Promise.all(
+    Array.from({ length: Math.min(RETIRE_CONCURRENCY, topics.length) }, () => worker())
+  );
+  if (changed.length) {
+    const current = await wireTopics(request, signal);
+    for (const stale of changed) {
+      const legacy = current.find((t) => t.name_hash === void 0 && t.name === stale.name);
+      if (!legacy || legacy.is_deleted) continue;
+      const hash = await codec.hash(await codec.open(legacy));
+      const copy = current.find((t) => t.name_hash !== void 0 && t.name_hash === hash);
+      if (!copy || hash === null) continue;
+      const newer = imported.has(hash) || Date.parse(legacy.server_updated_at) > Date.parse(copy.server_updated_at);
+      if (newer && (copy.is_deleted || legacy.kind !== copy.kind)) {
+        const sealed2 = await codec.encodeCatalog({
+          name: legacy.name,
+          ...legacy.kind !== void 0 && { kind: legacy.kind },
+          is_deleted: false
+        });
+        if (!sealed2 || await put(sealed2, copy.version) !== "saved") continue;
+      }
+      await retire(legacy);
+    }
+  }
+  if (failures.length)
+    getLogger().warn(
+      `[memory/remote] Could not retire ${failures.length} upgraded topic catalog entries:`,
+      failures[0]
+    );
+}
+async function upgradeLegacyTopicCatalog(request, codec, signal) {
+  const items = await wireTopics(request, signal);
+  const hashed2 = hashesOf(items);
+  const hashes = await Promise.all(
+    items.map(
+      async (item) => item.name_hash === void 0 ? codec.hash(await codec.open(item)) : null
+    )
+  );
+  const sources = /* @__PURE__ */ new Map();
+  const live2 = [];
+  items.forEach((item, i) => {
+    const hash = hashes[i];
+    if (hash === null) return;
+    if (!item.is_deleted) live2.push(item);
+    if (hashed2.has(hash)) return;
+    const source = sources.get(hash);
+    if (!source || source.is_deleted && !item.is_deleted) sources.set(hash, item);
+  });
+  const legacy = [...sources.values()].map((item) => ({
+    name: item.name,
+    ...item.kind !== void 0 && { kind: item.kind },
+    ...item.is_deleted && { is_deleted: true }
+  }));
+  await sealedImport(request, codec, legacy, signal);
+  await retireLegacyTopics(request, codec, live2, new Set(sources.keys()), signal);
+  return legacy.length;
 }
 async function createRemoteTopic(persistence, name) {
-  const canonical = normalizeEntityName(name);
+  const canonical = normalizeTopicName(name);
   if (!canonical) return null;
   const existing = (await persistence.topics()).find((t) => t.name === canonical);
   if (existing && !existing.is_deleted) return canonical;
@@ -7738,7 +8021,10 @@ var RemoteMemoryError = class extends Error {
     this.name = "RemoteMemoryError";
   }
 };
-var ciphertextPattern = /^enc:v\d+:[0-9a-f]+$/i;
+var TOPIC_UPGRADE_PROCESSOR = "topic-hash-v1";
+var TOPIC_UPGRADE_PAGE = 50;
+var LEGACY_TOPIC_CURSOR = "legacy-topics:";
+var LEGACY_TOPIC_RECHECK_MS = 6e4;
 var memoryFields = {
   memory_id: true,
   content: true,
@@ -7798,7 +8084,8 @@ var queryFields = [
   "fact_types",
   "visibility",
   "memory_ids",
-  "topics",
+  "topic_hashes",
+  "topics_legacy",
   "updated_after",
   "topics_due",
   "topics_extracted",
@@ -7808,11 +8095,17 @@ var queryFields = [
   "limit",
   "include_embeddings"
 ];
-function record(value) {
+function isVersionConflict(error) {
+  return error instanceof RemoteMemoryError && error.code === "version_conflict";
+}
+function isRejectedRow(error) {
+  return error instanceof RemoteMemoryError && error.status === 400;
+}
+function record2(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))) {
+  if (!record2(value) || !record2(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;
@@ -7892,14 +8185,14 @@ function createNearbyRequest(options, apiPath = "/api/private-memories") {
         const body = await response.json().catch(() => null);
         const retryAfter = parseRetryAfterMs(response.headers.get("Retry-After"));
         const error = new RemoteMemoryError(
-          record(body) && typeof body.detail === "string" ? body.detail : `Nearby request failed (${response.status})`,
+          record2(body) && typeof body.detail === "string" ? body.detail : `Nearby request failed (${response.status})`,
           response.status,
-          record(body) && typeof body.code === "string" ? body.code : void 0,
+          record2(body) && typeof body.code === "string" ? body.code : void 0,
           retryAfter ?? void 0,
-          record(body) && typeof body.rate_limit_bucket === "string" ? body.rate_limit_bucket : void 0
+          record2(body) && typeof body.rate_limit_bucket === "string" ? body.rate_limit_bucket : void 0
         );
         if (response.status === 429 && retryAfter !== null && retryAfter > 0 && (!error.code || error.code === "rate_limited")) {
-          const bucket = error.rateLimitBucket && budgets.includes(error.rateLimitBucket) ? error.rateLimitBucket : record(body) && (body.limit_scope === "account" || body.limit_scope === "ip") && !error.rateLimitBucket ? "*" : route;
+          const bucket = error.rateLimitBucket && budgets.includes(error.rateLimitBucket) ? error.rateLimitBucket : record2(body) && (body.limit_scope === "account" || body.limit_scope === "ip") && !error.rateLimitBucket ? "*" : route;
           cooldowns.set(bucket, { until: Date.now() + retryAfter, error });
         }
         throw error;
@@ -7922,7 +8215,7 @@ async function createRemoteMemoryPersistence(options) {
     throw new Error("A canonical keyId is required");
   const request = createNearbyRequest(options);
   const account = await request("/account", {}, options.signal);
-  if (!record(account) || account.state !== "active") {
+  if (!record2(account) || account.state !== "active") {
     throw new RemoteMemoryError(
       "Complete and verify migration before using remote memories",
       409,
@@ -7936,6 +8229,25 @@ async function createRemoteMemoryPersistence(options) {
       "key_mismatch"
     );
   }
+  const codec = createTopicCodec(options);
+  let legacyTopicRows = typeof account.legacy_topic_memories === "number" && account.legacy_topic_memories > 0;
+  if (typeof account.legacy_topic_catalog === "number" && account.legacy_topic_catalog > 0)
+    void upgradeLegacyTopicCatalog(request, codec, options.signal).catch((error) => {
+      if (!options.signal?.aborted)
+        getLogger().warn("[memory/remote] Topic catalog upgrade failed:", error);
+    });
+  let legacyCheckedAt = Date.now();
+  let legacyCheck;
+  const recheckLegacyTopicRows = () => {
+    if (legacyCheck || Date.now() - legacyCheckedAt < LEGACY_TOPIC_RECHECK_MS) return;
+    legacyCheckedAt = Date.now();
+    legacyCheck = request("/account", {}, options.signal).then((current) => {
+      if (record2(current) && current.legacy_topic_memories === 0) legacyTopicRows = false;
+    }).catch(() => {
+    }).finally(() => {
+      legacyCheck = void 0;
+    });
+  };
   const snapshots = /* @__PURE__ */ new WeakMap();
   const decode = async (value) => {
     const item = memoryRecord(value);
@@ -7953,6 +8265,9 @@ async function createRemoteMemoryPersistence(options) {
         content: item.memory.is_deleted && item.memory.content === "" ? "" : await decrypt(item.memory.content),
         ...item.memory.kind_value !== void 0 && {
           kind_value: await decrypt(item.memory.kind_value)
+        },
+        ...item.memory.topics !== void 0 && {
+          topics: await codec.decodeTopics(item.memory.topics)
         }
       }
     };
@@ -7964,8 +8279,10 @@ async function createRemoteMemoryPersistence(options) {
       version: item.version,
       content: decoded.memory.content,
       kindValue: decoded.memory.kind_value,
+      topics: decoded.memory.topics,
       encryptedContent: item.memory.content,
-      encryptedKindValue: item.memory.kind_value
+      encryptedKindValue: item.memory.kind_value,
+      encryptedTopics: item.memory.topics
     });
     return decoded;
   };
@@ -7987,7 +8304,7 @@ async function createRemoteMemoryPersistence(options) {
   };
   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)
+    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 || item.memory.topics !== write.body.memory.topics)
       return decode(item);
     return remember(
       {
@@ -7995,7 +8312,8 @@ async function createRemoteMemoryPersistence(options) {
         memory: {
           ...item.memory,
           content: write.content,
-          ...write.kindValue !== void 0 && { kind_value: write.kindValue }
+          ...write.kindValue !== void 0 && { kind_value: write.kindValue },
+          ...write.topics !== void 0 && { topics: write.topics }
         }
       },
       item
@@ -8047,13 +8365,21 @@ async function createRemoteMemoryPersistence(options) {
     const reusableContent = snapshot?.encryptedContent ?? existing?.memory.content;
     const content = reusableContent && (snapshot?.content ?? decoded?.memory.content) === memory.content ? reusableContent : 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);
+    const wireTopics2 = snapshot ? snapshot.encryptedTopics : existing?.memory.topics;
+    const topics = memory.topics === void 0 ? void 0 : (snapshot?.topics ?? decoded?.memory.topics) === memory.topics && wireTopics2 !== void 0 && !codec.isLegacy(wireTopics2) ? wireTopics2 : await codec.encodeTopics(memory.topics);
     return {
       body: {
         expected_version: expectedVersion,
-        memory: { ...memory, content, ...kindValue !== void 0 && { kind_value: kindValue } }
+        memory: {
+          ...memory,
+          content,
+          ...kindValue !== void 0 && { kind_value: kindValue },
+          ...topics !== void 0 && { topics }
+        }
       },
       content: memory.content,
-      kindValue: memory.kind_value
+      kindValue: memory.kind_value,
+      topics: memory.topics
     };
   };
   const fetchCandidates = async (embedding2, candidateOptions, withCounts) => {
@@ -8102,32 +8428,72 @@ async function createRemoteMemoryPersistence(options) {
       },
       candidateOptions.signal
     );
-    if (!record(result) || !Array.isArray(result.items))
+    if (!record2(result) || !Array.isArray(result.items))
       throw new Error("Invalid nearby candidate response");
     return result;
   };
   const fetchQueryPage = async (queryOptions) => {
-    const { signal, ...query } = queryOptions;
-    if (query.limit !== void 0 && (!Number.isInteger(query.limit) || query.limit < 1 || query.limit > 200))
+    const { signal, topics: names, ...wire2 } = queryOptions;
+    if (wire2.limit !== void 0 && (!Number.isInteger(wire2.limit) || wire2.limit < 1 || wire2.limit > 200))
       throw new Error("Page limit must be 1\u2013200");
     for (const [key3, max] of queryListLimits) {
-      const values = query[key3];
+      const values = queryOptions[key3];
       if (values && values.length > max)
         throw new Error(`Query ${key3} accepts at most ${max} entries (got ${values.length})`);
     }
+    const body = wire2;
+    if (names === void 0) return postQuery(body, signal);
+    const hashes = [
+      ...new Set(
+        (await Promise.all(names.map((name) => codec.hash(name)))).filter((h) => h !== null)
+      )
+    ];
+    if (names.length > 0 && hashes.length === 0) return { items: [] };
+    if (hashes.length > 0 && wire2.cursor?.startsWith(LEGACY_TOPIC_CURSOR)) {
+      const page2 = await postQuery(
+        {
+          ...wire2,
+          cursor: wire2.cursor.slice(LEGACY_TOPIC_CURSOR.length) || void 0,
+          topics_legacy: true
+        },
+        signal
+      );
+      const wanted = new Set(names.map(normalizeTopicName));
+      const hashed2 = new Set(hashes);
+      const matches = await Promise.all(
+        page2.items.map(
+          (item) => codec.matchesLegacy(
+            record2(item) && record2(item.memory) ? item.memory.topics : void 0,
+            wanted,
+            hashed2
+          )
+        )
+      );
+      return {
+        ...page2,
+        items: page2.items.filter((_, i) => matches[i]),
+        next_cursor: page2.next_cursor === void 0 ? void 0 : LEGACY_TOPIC_CURSOR + page2.next_cursor
+      };
+    }
+    const page = await postQuery({ ...body, topic_hashes: hashes }, signal);
+    if (hashes.length === 0 || page.next_cursor !== void 0 || !legacyTopicRows) return page;
+    recheckLegacyTopicRows();
+    return { ...page, next_cursor: LEGACY_TOPIC_CURSOR };
+  };
+  const postQuery = async (body, signal) => {
     const page = await request(
       "/memories/query",
       {
         method: "POST",
         body: JSON.stringify(
           Object.fromEntries(
-            queryFields.filter((key3) => query[key3] !== void 0).map((key3) => [key3, query[key3]])
+            queryFields.filter((key3) => body[key3] !== void 0).map((key3) => [key3, body[key3]])
           )
         )
       },
       signal
     );
-    if (!record(page) || !Array.isArray(page.items) || page.next_cursor !== void 0 && typeof page.next_cursor !== "string" || page.changes_cursor !== void 0 && typeof page.changes_cursor !== "string")
+    if (!record2(page) || !Array.isArray(page.items) || page.next_cursor !== void 0 && typeof page.next_cursor !== "string" || page.changes_cursor !== void 0 && typeof page.changes_cursor !== "string")
       throw new Error("Invalid nearby private-memory page");
     return page;
   };
@@ -8141,13 +8507,13 @@ async function createRemoteMemoryPersistence(options) {
       unavailable_count: result.unavailable_count
     };
   };
-  return {
-    ...createRemoteTopicPersistence(request),
+  const persistence = {
+    ...createRemoteTopicPersistence(request, codec),
     ...createRemoteWorkPersistence(request),
     supportsRealtimeChanges: account.realtime_changes === true,
     counts: async () => {
       const result = await request("/counts", {});
-      if (!record(result) || ["live", "archived", "quarantined"].some(
+      if (!record2(result) || ["live", "archived", "quarantined"].some(
         (key3) => !Number.isSafeInteger(result[key3]) || result[key3] < 0
       ))
         throw new Error("Invalid nearby memory counts");
@@ -8164,8 +8530,8 @@ async function createRemoteMemoryPersistence(options) {
         method: "POST",
         body: JSON.stringify({ ...window2, limit })
       });
-      if (!record(result) || !Array.isArray(result.items) || result.items.some(
-        (item) => !record(item) || typeof item.memory_id !== "string" || !item.memory_id || typeof item.score !== "number" || !Number.isFinite(item.score) || item.score <= 0 || item.score > 1
+      if (!record2(result) || !Array.isArray(result.items) || result.items.some(
+        (item) => !record2(item) || typeof item.memory_id !== "string" || !item.memory_id || typeof item.score !== "number" || !Number.isFinite(item.score) || item.score <= 0 || item.score > 1
       ))
         throw new Error("Invalid nearby temporal candidates");
       return result.items.map((item) => item.memory_id);
@@ -8196,7 +8562,7 @@ async function createRemoteMemoryPersistence(options) {
         if (query[key3] !== void 0) params.set(key3, String(query[key3]));
       }
       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") {
+      if (!record2(page) || !Array.isArray(page.items) || page.next_cursor !== void 0 && typeof page.next_cursor !== "string") {
         throw new Error("Invalid nearby private-memory page");
       }
       return {
@@ -8236,7 +8602,7 @@ async function createRemoteMemoryPersistence(options) {
         },
         signal
       );
-      if (!record(result) || !Array.isArray(result.items) || result.items.length !== prepared.length)
+      if (!record2(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])));
     },
@@ -8251,20 +8617,87 @@ async function createRemoteMemoryPersistence(options) {
     queryMetadata: async (queryOptions = {}) => {
       const page = await fetchQueryPage(queryOptions);
       return {
-        items: page.items.map((item) => {
-          const {
-            memory: { content: _content, kind_value: _kindValue, ...memory },
-            version,
-            server_updated_at
-          } = memoryRecord(item);
-          return { memory, version, server_updated_at };
-        }),
+        items: await Promise.all(
+          page.items.map(async (item) => {
+            const {
+              memory: { content: _content, kind_value: _kindValue, topics, ...memory },
+              version,
+              server_updated_at
+            } = memoryRecord(item);
+            const plain2 = topics === void 0 ? void 0 : await codec.decodeTopics(topics).catch(() => null);
+            return {
+              memory: { ...memory, ...typeof plain2 === "string" && { topics: plain2 } },
+              version,
+              server_updated_at
+            };
+          })
+        ),
         ...page.next_cursor !== void 0 && { next_cursor: page.next_cursor }
       };
     },
     candidateSet,
     candidates: async (embedding2, candidateOptions = {}) => decodeAll((await fetchCandidates(embedding2, candidateOptions, false)).items)
   };
+  let rejectedRows = 0;
+  const rewriteLegacyTopics = async (records, token) => {
+    const write = (batch) => persistence.putMany(
+      batch.map((item) => ({ memory: item.memory, expectedVersion: item })),
+      options.signal,
+      token
+    );
+    try {
+      await write(records);
+      return true;
+    } catch (error) {
+      if (!isVersionConflict(error) && !isRejectedRow(error)) throw error;
+      if (records.length === 1) {
+        if (isRejectedRow(error)) rejectedRows++;
+        return false;
+      }
+      let complete = true;
+      for (const item of records)
+        await write([item]).catch((rowError) => {
+          if (isRejectedRow(rowError)) rejectedRows++;
+          else if (!isVersionConflict(rowError)) throw rowError;
+          complete = false;
+        });
+      return complete;
+    }
+  };
+  const upgradeLegacyTopics = () => withRemoteWorkLease(persistence, "topics", TOPIC_UPGRADE_PROCESSOR, async (token, lease) => {
+    let cursor;
+    let complete = true;
+    do {
+      options.signal?.throwIfAborted();
+      if (lease.aborted) return false;
+      const page = await fetchQueryPage({
+        topics_legacy: true,
+        include_archived: true,
+        include_quarantined: true,
+        include_superseded: true,
+        limit: TOPIC_UPGRADE_PAGE,
+        ...cursor !== void 0 && { cursor },
+        signal: options.signal
+      });
+      const { items } = await decodeAll(page.items);
+      const legacy = items.filter((item) => codec.isLegacy(snapshots.get(item)?.encryptedTopics));
+      if (legacy.length && !await rewriteLegacyTopics(legacy, token)) complete = false;
+      cursor = page.next_cursor;
+    } while (cursor);
+    if (rejectedRows)
+      getLogger().warn(
+        `[memory/remote] Nearby rejected ${rejectedRows} rows during the topic upgrade; they keep legacy topics`
+      );
+    return complete;
+  });
+  if (legacyTopicRows)
+    void upgradeLegacyTopics().then((complete) => {
+      if (complete) legacyTopicRows = false;
+    }).catch((error) => {
+      if (!options.signal?.aborted)
+        getLogger().warn("[memory/remote] Topic upgrade failed:", error);
+    });
+  return persistence;
 }
 
 // src/lib/chat/inbox.ts
@@ -8354,6 +8787,67 @@ async function openInboxItem(item, keyPair) {
   }
   return opened;
 }
+function inboxReplaces(row, opened) {
+  if (row.error) return true;
+  return row.wasStopped === true && opened.status === "completed";
+}
+async function clearTurnErrors(backend, answer) {
+  const parentId = answer.parentMessageId;
+  if (parentId) {
+    const [parent] = await backend.getMessagesByIds([parentId]);
+    if (parent?.error) await backend.updateMessageError(parentId, null);
+  }
+  if (!answer.error) return answer;
+  return await backend.updateMessageError(answer.uniqueId, null) ?? answer;
+}
+async function deliverInboxAnswers(options) {
+  const { inbox, keyPair, backend, store } = options;
+  const results = [];
+  for (const item of await inbox.list()) {
+    let opened;
+    try {
+      opened = await openInboxItem(item, keyPair);
+    } catch (err) {
+      results.push({
+        id: item.id,
+        conversationId: null,
+        status: "unreadable",
+        assistantMessage: null,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      continue;
+    }
+    const base = { id: item.id, conversationId: opened.conversation_id };
+    try {
+      const messageId = opened.assistant_message_id ?? `msg_bg_${opened.inference_id}`;
+      const [found] = await backend.getMessagesByIds([messageId]);
+      const existing = found && inboxReplaces(found, opened) ? void 0 : found;
+      if (!found) {
+        const parent = opened.parent_message_id;
+        const ownsTurn = parent ? (await backend.getMessagesByIds([parent])).length > 0 : await backend.getConversation(opened.conversation_id) !== null;
+        if (!ownsTurn) {
+          results.push({ ...base, status: "elsewhere", assistantMessage: null });
+          continue;
+        }
+      }
+      const stored2 = existing ?? await store(opened, messageId);
+      await inbox.remove(item.id);
+      results.push({
+        ...base,
+        status: existing ? "delivered" : "stored",
+        assistantMessage: stored2
+      });
+    } catch (err) {
+      results.push({
+        ...base,
+        status: "retry",
+        assistantMessage: null,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return results;
+}
 
 // src/lib/chat/reservationReceipts.ts
 var ACTIONS = [
@@ -8765,9 +9259,9 @@ function toResponsesFormat(tool) {
 function getCachedServerTools() {
   if (typeof localStorage === "undefined") return null;
   try {
-    const cached = localStorage.getItem(SERVER_TOOLS_CACHE_KEY);
-    if (!cached) return null;
-    const parsed = JSON.parse(cached);
+    const cached2 = localStorage.getItem(SERVER_TOOLS_CACHE_KEY);
+    if (!cached2) return null;
+    const parsed = JSON.parse(cached2);
     if (parsed.version !== CACHE_VERSION) {
       removeLocalStorageCache();
       return null;
@@ -8811,8 +9305,8 @@ function clearServerToolsCache(cache = localStorageToolsCache) {
   return cache.clear?.();
 }
 function getToolsChecksum2(cache = localStorageToolsCache) {
-  const cached = cache.get();
-  return cached instanceof Promise ? cached.then((c) => c?.checksum) : cached?.checksum;
+  const cached2 = cache.get();
+  return cached2 instanceof Promise ? cached2.then((c) => c?.checksum) : cached2?.checksum;
 }
 function shouldRefreshTools(responseChecksum, cache = localStorageToolsCache) {
   if (!responseChecksum) {
@@ -8875,33 +9369,33 @@ async function getServerTools(options) {
   } catch (error) {
     getLogger().warn("[serverTools] Cache read failed; falling through to server fetch:", error);
   }
-  const cached = rawCached && rawCached.version === CACHE_VERSION ? rawCached : null;
-  const cacheValid = !isCacheExpired(cached, cacheExpirationMs);
-  if (cached && cacheValid && !forceRefresh) {
-    return cached.tools;
+  const cached2 = rawCached && rawCached.version === CACHE_VERSION ? rawCached : null;
+  const cacheValid = !isCacheExpired(cached2, cacheExpirationMs);
+  if (cached2 && cacheValid && !forceRefresh) {
+    return cached2.tools;
   }
   try {
     const { BASE_URL: BASE_URL2 } = await Promise.resolve().then(() => (init_clientConfig(), clientConfig_exports));
     const effectiveBaseUrl = baseUrl ?? BASE_URL2;
-    const validator = cached && !forceRefresh ? cached.etag : void 0;
+    const validator = cached2 && !forceRefresh ? cached2.etag : void 0;
     let authHeaders;
     if (apiKey) {
       authHeaders = { "X-API-Key": apiKey };
     } else {
       if (!getToken) {
         getLogger().warn("[serverTools] No auth method available for fetching tools");
-        return cached?.tools ?? [];
+        return cached2?.tools ?? [];
       }
       const token = await getToken();
       if (!token) {
         getLogger().warn("[serverTools] No auth token available for fetching tools");
-        return cached?.tools ?? [];
+        return cached2?.tools ?? [];
       }
       authHeaders = { Authorization: `Bearer ${token}` };
     }
     const result = await fetchServerToolsFromApi(effectiveBaseUrl, authHeaders, validator);
     if (result.notModified) {
-      const confirmed = cached;
+      const confirmed = cached2;
       await persistCache({ ...confirmed, timestamp: Date.now() });
       return confirmed.tools;
     }
@@ -8909,9 +9403,9 @@ async function getServerTools(options) {
     return result.tools;
   } catch (error) {
     getLogger().error("[serverTools] Failed to fetch server tools:", error);
-    if (cached?.tools) {
+    if (cached2?.tools) {
       getLogger().warn("[serverTools] Using stale cached tools due to fetch error");
-      return cached.tools;
+      return cached2.tools;
     }
     return [];
   }
@@ -9845,6 +10339,13 @@ function createErrorResult(message, onError) {
 function isAbortError(err) {
   return err instanceof Error && err.name === "AbortError";
 }
+var ProviderStreamError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.name = "ProviderStreamError";
+    this.code = code;
+  }
+};
 function getInStreamErrorMessage(chunk) {
   if (!chunk || typeof chunk !== "object") return null;
   const obj = chunk;
@@ -10042,13 +10543,13 @@ function extractParamGroups(content) {
 }
 function mergeXaiInlineParameterTags(content, toolCalls) {
   if (!content || !content.includes(PARAM_MARKER)) return content;
-  const entries = Array.from(toolCalls.values());
-  if (entries.length === 0) return content;
+  const entries2 = Array.from(toolCalls.values());
+  if (entries2.length === 0) return content;
   const groups = extractParamGroups(content);
   if (groups.length === 0) return content;
-  const pairCount = Math.min(groups.length, entries.length);
+  const pairCount = Math.min(groups.length, entries2.length);
   for (let i = 0; i < pairCount; i++) {
-    const target = entries[i];
+    const target = entries2[i];
     const params = groups[i];
     if (!target || !params) continue;
     let args = {};
@@ -10131,7 +10632,7 @@ var CompletionsStrategy = class {
   processStreamChunk(chunk, accumulator) {
     const result = { content: null, thinking: null };
     const inStreamErr = getInStreamErrorMessage(chunk);
-    if (inStreamErr) throw new Error(inStreamErr);
+    if (inStreamErr) throw new ProviderStreamError(inStreamErr);
     const rawChunk = chunk;
     const typedChunk = rawChunk.response && rawChunk.type === "response" ? rawChunk.response : chunk;
     if (typedChunk.id && !accumulator.responseId) {
@@ -10982,7 +11483,7 @@ var ResponsesStrategy = class {
     const result = { content: null, thinking: null };
     const typedChunk = chunk;
     const inStreamErr = getInStreamErrorMessage(chunk);
-    if (inStreamErr) throw new Error(inStreamErr);
+    if (inStreamErr) throw new ProviderStreamError(inStreamErr);
     if (typedChunk.type === "response.failed") {
       const resp = typedChunk.response;
       const err = resp?.error;
@@ -10999,9 +11500,12 @@ var ResponsesStrategy = class {
           }
         }
         const label = code ? `[${code}] ` : "";
-        throw new Error(`${label}${message || "Upstream request failed"}`);
+        throw new ProviderStreamError(
+          `${label}${message || "Upstream request failed"}`,
+          code || void 0
+        );
       }
-      throw new Error("Upstream request failed (response.failed)");
+      throw new ProviderStreamError("Upstream request failed (response.failed)");
     }
     if (typedChunk.type === "response" && typedChunk.response) {
       const resp = typedChunk.response;
@@ -11625,13 +12129,6 @@ function isRetriableStreamError(err) {
   if (msg.includes("connection refused") || msg.includes("connect error")) return true;
   return false;
 }
-var ProviderStreamError = class extends Error {
-  constructor(message, code) {
-    super(message);
-    this.name = "ProviderStreamError";
-    this.code = code;
-  }
-};
 function extractProviderStreamError(chunk) {
   if (!chunk || typeof chunk !== "object") return null;
   const errField = chunk.error;
@@ -12012,6 +12509,7 @@ async function runToolLoop(options) {
     thinking: redactor.deAnonymize(acc.thinking)
   }) : strategy.buildFinalResponse(acc);
   const finalContentText = (acc) => redactor ? redactor.deAnonymize(acc.content) : acc.content;
+  let streamingAccumulator = null;
   try {
     let sseError = null;
     let apiTools = toolsToApiFormat(tools, resolved);
@@ -12163,6 +12661,7 @@ async function runToolLoop(options) {
         }
       });
       accumulator = createStreamAccumulator(model || void 0);
+      streamingAccumulator = accumulator;
       contentSmoother = new StreamSmoother((text16) => {
         if (emitData) emitData(text16);
       }, smoothing);
@@ -12673,6 +13172,7 @@ Executing tool: ${toolInfo}
           }
         });
         currentAccumulator = createStreamAccumulator(model || void 0);
+        streamingAccumulator = currentAccumulator;
         contContentSmoother = new StreamSmoother((text16) => {
           if (emitData) emitData(text16);
         }, smoothing);
@@ -12870,7 +13370,7 @@ Executing tool: ${toolInfo}
     const statusCode = err instanceof Error && "statusCode" in err ? err.statusCode : void 0;
     const connectionLost = !(err instanceof ProviderStreamError) && !(err instanceof SseError);
     return {
-      data: null,
+      data: connectionLost && streamingAccumulator ? buildResponseFinal(streamingAccumulator) : null,
       error: errorMsg,
       statusCode,
       ...connectionLost ? { connectionLost: true } : {}
@@ -13371,21 +13871,21 @@ function contextFields(context) {
   );
 }
 function conversationContext(data) {
-  const entries = Object.entries(data).filter(([field10]) => field10.startsWith(CONTEXT_FIELD_PREFIX)).map(([field10, value]) => [field10.slice(CONTEXT_FIELD_PREFIX.length), value]);
-  return entries.length > 0 ? plain(Object.fromEntries(entries)) : void 0;
+  const entries2 = Object.entries(data).filter(([field10]) => field10.startsWith(CONTEXT_FIELD_PREFIX)).map(([field10, value]) => [field10.slice(CONTEXT_FIELD_PREFIX.length), value]);
+  return entries2.length > 0 ? plain(Object.fromEntries(entries2)) : void 0;
 }
-function toConversation(record2) {
-  const pinnedAt = number(record2.data.pinnedAt);
-  const projectId = text3(record2.data.projectId);
-  const context = conversationContext(record2.data);
+function toConversation(record3) {
+  const pinnedAt = number(record3.data.pinnedAt);
+  const projectId = text3(record3.data.projectId);
+  const context = conversationContext(record3.data);
   return {
-    uniqueId: record2.id,
-    conversationId: record2.id,
-    title: text3(record2.data.title) ?? "",
+    uniqueId: record3.id,
+    conversationId: record3.id,
+    title: text3(record3.data.title) ?? "",
     ...projectId ? { projectId } : {},
-    createdAt: new Date(record2.createdAt),
-    updatedAt: new Date(record2.updatedAt),
-    isDeleted: record2.isDeleted,
+    createdAt: new Date(record3.createdAt),
+    updatedAt: new Date(record3.updatedAt),
+    isDeleted: record3.isDeleted,
     pinnedAt: pinnedAt ? new Date(pinnedAt) : null,
     ...context ? { context } : {}
   };
@@ -13407,21 +13907,21 @@ function messageData(options) {
     ...anuma ? { anuma } : {}
   });
 }
-function toMessage(record2) {
-  const { chunkOffsets: _offsets, truncated: _truncated, anuma: rawAnuma, ...fields } = record2.data;
+function toMessage(record3) {
+  const { chunkOffsets: _offsets, truncated: _truncated, anuma: rawAnuma, ...fields } = record3.data;
   const anuma = readAnumaTurn(rawAnuma);
   return {
     ...anuma ? { anuma } : {},
     ...fields,
-    uniqueId: record2.id,
-    messageId: record2.sortKey,
-    conversationId: record2.conversationId,
-    createdAt: new Date(record2.createdAt),
-    updatedAt: new Date(record2.updatedAt)
+    uniqueId: record3.id,
+    messageId: record3.sortKey,
+    conversationId: record3.conversationId,
+    createdAt: new Date(record3.createdAt),
+    updatedAt: new Date(record3.updatedAt)
   };
 }
-function chunkOffsets(record2) {
-  const offsets = record2.data.chunkOffsets;
+function chunkOffsets(record3) {
+  const offsets = record3.data.chunkOffsets;
   return Array.isArray(offsets) ? offsets : void 0;
 }
 function toSkeletons(records) {
@@ -13442,15 +13942,15 @@ function toSkeletons(records) {
     };
   });
 }
-function toSummary(record2) {
+function toSummary(record3) {
   return {
-    uniqueId: record2.id,
-    conversationId: record2.id,
-    summary: text3(record2.data.summary) ?? "",
-    summarizedUpTo: text3(record2.data.summarizedUpTo) ?? "",
-    tokenCount: number(record2.data.tokenCount) ?? 0,
-    createdAt: new Date(record2.createdAt),
-    updatedAt: new Date(record2.updatedAt)
+    uniqueId: record3.id,
+    conversationId: record3.id,
+    summary: text3(record3.data.summary) ?? "",
+    summarizedUpTo: text3(record3.data.summarizedUpTo) ?? "",
+    tokenCount: number(record3.data.tokenCount) ?? 0,
+    createdAt: new Date(record3.createdAt),
+    updatedAt: new Date(record3.updatedAt)
   };
 }
 function links(data) {
@@ -13476,10 +13976,10 @@ function applyLinkOps(data, ops) {
   }
   return plain({ links: current });
 }
-function toLinks(record2) {
-  return links(record2.data).map((l) => ({
-    uniqueId: `${record2.id}:${l.memoryId}`,
-    conversationId: record2.id,
+function toLinks(record3) {
+  return links(record3.data).map((l) => ({
+    uniqueId: `${record3.id}:${l.memoryId}`,
+    conversationId: record3.id,
     memoryId: l.memoryId,
     score: l.score,
     createdAt: new Date(l.createdAt)
@@ -13488,24 +13988,24 @@ function toLinks(record2) {
 function bytes(value) {
   return new TextEncoder().encode(JSON.stringify(value)).length;
 }
-function fitRecord(record2) {
-  if (record2.kind !== "message" || bytes(record2) <= recordBudgetBytes) return record2;
-  const data = { ...record2.data };
+function fitRecord(record3) {
+  if (record3.kind !== "message" || bytes(record3) <= recordBudgetBytes) return record3;
+  const data = { ...record3.data };
   const truncated = [];
   for (const field10 of droppable) {
-    if (bytes({ ...record2, data }) <= recordBudgetBytes) break;
+    if (bytes({ ...record3, data }) <= recordBudgetBytes) break;
     if (data[field10] === void 0) continue;
     delete data[field10];
     truncated.push(field10);
   }
   const content = text3(data.content) ?? "";
-  const over = bytes({ ...record2, data }) - recordBudgetBytes;
+  const over = bytes({ ...record3, data }) - recordBudgetBytes;
   if (over > 0) {
     const encoded = new TextEncoder().encode(content);
     data.content = new TextDecoder().decode(encoded.slice(0, Math.max(0, encoded.length - over - 64))).replace(/�$/, "");
     truncated.push("content");
   }
-  return { ...record2, data: { ...data, truncated } };
+  return { ...record3, data: { ...data, truncated } };
 }
 function acceptedVector(vector2) {
   if (!vector2 || !acceptedDims.has(vector2.length)) return void 0;
@@ -13549,8 +14049,8 @@ function anumaTurnContent(bubbles) {
   return bubbles.join("\n\n");
 }
 function anumaLastReadSortKey(conversation) {
-  const record2 = conversation && "record" in conversation ? conversation.record : conversation;
-  const state = record2?.data.anuma;
+  const record3 = conversation && "record" in conversation ? conversation.record : conversation;
+  const state = record3?.data.anuma;
   if (!isObject(state)) return 0;
   const sortKey = state.lastReadSortKey;
   return Number.isSafeInteger(sortKey) && sortKey > 0 ? sortKey : 0;
@@ -13603,19 +14103,19 @@ async function markAnumaRead(store, sortKey, options = {}) {
     const current = await ensureAnumaConversation(store, options);
     const read = anumaLastReadSortKey(current);
     if (sortKey <= read) return current;
-    const record2 = current.record;
-    const state = isObject(record2.data.anuma) ? record2.data.anuma : {};
-    const data = plain({ ...record2.data, anuma: { ...state, lastReadSortKey: sortKey } });
+    const record3 = current.record;
+    const state = isObject(record3.data.anuma) ? record3.data.anuma : {};
+    const data = plain({ ...record3.data, anuma: { ...state, lastReadSortKey: sortKey } });
     try {
       const [written] = await store.putMany(
         [
           {
             expectedVersion: current.version,
             record: {
-              ...record2,
+              ...record3,
               data,
-              sortKey: conversationSortKey(data, record2.createdAt),
-              updatedAt: Math.max(record2.updatedAt, now())
+              sortKey: conversationSortKey(data, record3.createdAt),
+              updatedAt: Math.max(record3.updatedAt, now())
             }
           }
         ],
@@ -13651,22 +14151,22 @@ function createSummaryContext(database, encryption = {}) {
     summariesCollection: database.get("conversation_summaries")
   };
 }
-function modelToStored(record2, summary) {
+function modelToStored(record3, summary) {
   return {
-    uniqueId: record2.id,
-    conversationId: record2.conversationId,
+    uniqueId: record3.id,
+    conversationId: record3.conversationId,
     summary,
-    summarizedUpTo: record2.summarizedUpTo,
-    tokenCount: record2.tokenCount,
-    createdAt: record2.createdAt,
-    updatedAt: record2.updatedAt
+    summarizedUpTo: record3.summarizedUpTo,
+    tokenCount: record3.tokenCount,
+    createdAt: record3.createdAt,
+    updatedAt: record3.updatedAt
   };
 }
 async function getConversationSummaryOp(ctx, conversationId) {
   const results = await ctx.summariesCollection.query(import_watermelondb6.Q.where("conversation_id", conversationId)).fetch();
   if (results.length === 0) return null;
-  const record2 = results[0];
-  const stored2 = modelToStored(record2, record2.summary);
+  const record3 = results[0];
+  const stored2 = modelToStored(record3, record3.summary);
   if (ctx.walletAddress && isEncrypted(stored2.summary)) {
     if (ctx.signMessage) {
       try {
@@ -13685,7 +14185,7 @@ async function getConversationSummaryOp(ctx, conversationId) {
         ctx.embeddedWalletSigner
       );
       await ctx.database.write(async () => {
-        const current = await ctx.summariesCollection.query(import_watermelondb6.Q.where("id", record2.id)).fetch();
+        const current = await ctx.summariesCollection.query(import_watermelondb6.Q.where("id", record3.id)).fetch();
         if (current[0]?.summary === stored2.summary) {
           await current[0].update((rec) => {
             rec.summary = encryptedSummary;
@@ -13700,19 +14200,19 @@ async function getConversationSummaryOp(ctx, conversationId) {
 }
 async function upsertConversationSummaryOp(ctx, conversationId, summary, summarizedUpTo, tokenCount) {
   const revision2 = getConversationRevision(ctx.database, conversationId);
-  let record2;
+  let record3;
   const encryptedSummary = ctx.walletAddress ? await encryptField(summary, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner) : summary;
   await ctx.database.write(async () => {
     assertConversationRevision(ctx.database, conversationId, revision2);
     const existing = await ctx.summariesCollection.query(import_watermelondb6.Q.where("conversation_id", conversationId)).fetch();
     if (existing.length > 0) {
-      record2 = await existing[0].update((rec) => {
+      record3 = await existing[0].update((rec) => {
         rec.summary = encryptedSummary;
         rec.summarizedUpTo = summarizedUpTo;
         rec.tokenCount = tokenCount;
       });
     } else {
-      record2 = await ctx.summariesCollection.create((rec) => {
+      record3 = await ctx.summariesCollection.create((rec) => {
         rec.conversationId = conversationId;
         rec.summary = encryptedSummary;
         rec.summarizedUpTo = summarizedUpTo;
@@ -13720,13 +14220,13 @@ async function upsertConversationSummaryOp(ctx, conversationId, summary, summari
       });
     }
   });
-  return modelToStored(record2, summary);
+  return modelToStored(record3, summary);
 }
 async function deleteConversationSummaryOp(ctx, conversationId) {
   await ctx.database.write(async () => {
     const existing = await ctx.summariesCollection.query(import_watermelondb6.Q.where("conversation_id", conversationId)).fetch();
-    for (const record2 of existing) {
-      await record2.destroyPermanently();
+    for (const record3 of existing) {
+      await record3.destroyPermanently();
     }
   });
 }
@@ -13802,7 +14302,7 @@ function messageRecord(message) {
   const fitted = chunks3?.length ? fitChunks(chunks3) : void 0;
   const single = fitted ? void 0 : acceptedVector(vector2);
   const embeddings2 = fitted?.map((c) => c.vector) ?? (single ? [single] : void 0);
-  const record2 = fitRecord({
+  const record3 = fitRecord({
     kind: "message",
     id: message.uniqueId,
     conversationId: message.conversationId,
@@ -13816,7 +14316,7 @@ function messageRecord(message) {
     }
   });
   return {
-    record: record2,
+    record: record3,
     ...embeddings2 ? { embeddings: embeddings2 } : {},
     ...embeddings2 && message.embeddingModel ? { embeddingModel: message.embeddingModel } : {}
   };
@@ -13964,15 +14464,15 @@ function ref(value) {
 function sameMetadata(a, b) {
   return metadata.every((key3) => a[key3] === b[key3]);
 }
-function wire(record2, payload) {
+function wire(record3, payload) {
   return {
-    kind: record2.kind,
-    id: record2.id,
-    conversation_id: record2.conversationId,
-    sort_key: record2.sortKey,
-    created_at: record2.createdAt,
-    updated_at: record2.updatedAt,
-    is_deleted: record2.isDeleted,
+    kind: record3.kind,
+    id: record3.id,
+    conversation_id: record3.conversationId,
+    sort_key: record3.sortKey,
+    created_at: record3.createdAt,
+    updated_at: record3.updatedAt,
+    is_deleted: record3.isDeleted,
     payload
   };
 }
@@ -14029,10 +14529,10 @@ async function createRemoteChatStore(options) {
       serverUpdatedAt: value.server_updated_at
     };
   };
-  const seal = async (record2, signal) => {
-    if (record2.isDeleted) return "";
+  const seal = async (record3, signal) => {
+    if (record3.isDeleted) return "";
     const payload = await encrypt(
-      JSON.stringify({ schema: 1, account_id: accountId, key_id: keyId, record: record2 })
+      JSON.stringify({ schema: 1, account_id: accountId, key_id: keyId, record: record3 })
     );
     signal?.throwIfAborted();
     if (!cipherPattern.test(payload) || payload.length > maxPayload) invalid();
@@ -14396,8 +14896,8 @@ var emptyMessage = {
 var maxPasses = 5;
 var verifyBatch = 1e3;
 var writeBatch = 25;
-function key(record2) {
-  return `${record2.kind}/${record2.id}`;
+function key(record3) {
+  return `${record3.kind}/${record3.id}`;
 }
 function sealed(value) {
   if (typeof value === "string") return isEncrypted(value);
@@ -14526,11 +15026,11 @@ async function missing(store, records, signal) {
   const out = /* @__PURE__ */ new Set();
   for (let i = 0; i < records.length; i += verifyBatch) {
     const refs = await store.verify(
-      records.slice(i, i + verifyBatch).map(({ record: record2 }) => ({
-        kind: record2.kind,
-        id: record2.id,
-        updatedAt: record2.updatedAt,
-        isDeleted: record2.isDeleted
+      records.slice(i, i + verifyBatch).map(({ record: record3 }) => ({
+        kind: record3.kind,
+        id: record3.id,
+        updatedAt: record3.updatedAt,
+        isDeleted: record3.isDeleted
       })),
       signal
     );
@@ -14570,14 +15070,14 @@ async function deletedSinceUpload(store, journal, local, signal) {
   const live2 = (await store.getMany(gone.map(ref2), signal)).filter((s) => !s.record.isDeleted);
   const tombstoning = new Set(live2.map((s) => key(s.record)));
   await journal.drop(gone.filter((k) => !tombstoning.has(k)));
-  return live2.map(({ record: record2, version }) => {
-    const empty = emptied[record2.kind];
+  return live2.map(({ record: record3, version }) => {
+    const empty = emptied[record3.kind];
     return {
       record: {
-        ...record2,
+        ...record3,
         isDeleted: !empty,
         data: empty ?? {},
-        updatedAt: Math.max(Date.now(), record2.updatedAt + 1)
+        updatedAt: Math.max(Date.now(), record3.updatedAt + 1)
       },
       expectedVersion: version
     };
@@ -14926,8 +15426,8 @@ function createVaultAttachments(options) {
     },
     async read(attachmentId, signal) {
       if (!attachmentIdPattern2.test(attachmentId)) invalidAttachment();
-      const cached = await cache?.get(attachmentId).catch(() => null);
-      if (cached) return cached;
+      const cached2 = await cache?.get(attachmentId).catch(() => null);
+      if (cached2) return cached2;
       for (let attempt = 0; ; attempt++) {
         const found = await withRetry(() => store.attachments.get(attachmentId, signal), signal);
         if (!found?.download) return null;
@@ -14956,8 +15456,8 @@ function validRef(value) {
   const ref3 = value;
   return typeof ref3.attachmentId === "string" && attachmentIdPattern2.test(ref3.attachmentId) && typeof ref3.fileId === "string" && ref3.fileId.length > 0 && typeof ref3.name === "string" && typeof ref3.type === "string" && Number.isSafeInteger(ref3.size) && ref3.size >= 0;
 }
-function vaultAttachmentRefs(record2) {
-  const refs = record2.data.vaultAttachments;
+function vaultAttachmentRefs(record3) {
+  const refs = record3.data.vaultAttachments;
   return Array.isArray(refs) ? refs.filter(validRef) : [];
 }
 function journalKey(messageId, fileId) {
@@ -15165,14 +15665,14 @@ function sameRecord(a, b) {
   return a.sortKey === b.sortKey && a.isDeleted === b.isDeleted && sameJson(a.data, b.data);
 }
 function toWrite(base, patch) {
-  const record2 = applyPatch(base?.record, patch);
-  if (!record2) return void 0;
-  if (base && patch.embeddings === void 0 && sameRecord(base.record, record2)) return null;
+  const record3 = applyPatch(base?.record, patch);
+  if (!record3) return void 0;
+  if (base && patch.embeddings === void 0 && sameRecord(base.record, record3)) return null;
   return {
-    record: fitRecord(record2),
+    record: fitRecord(record3),
     expectedVersion: base?.version ?? 0,
-    ...patch.embeddings !== void 0 && !record2.isDeleted ? { embeddings: patch.embeddings } : {},
-    ...patch.embeddingModel !== void 0 && !record2.isDeleted ? { embeddingModel: patch.embeddingModel } : {}
+    ...patch.embeddings !== void 0 && !record3.isDeleted ? { embeddings: patch.embeddings } : {},
+    ...patch.embeddingModel !== void 0 && !record3.isDeleted ? { embeddingModel: patch.embeddingModel } : {}
   };
 }
 var maxWrites = 25;
@@ -15306,11 +15806,11 @@ function createVaultChatBackend(options) {
     for (const listener of [...listeners]) listener(event);
   };
   const view = (k) => {
-    let record2 = confirmed.get(k)?.record;
+    let record3 = confirmed.get(k)?.record;
     for (const patch of [inflight.get(k), pending.get(k)]) {
-      if (patch) record2 = applyPatch(record2, patch) ?? record2;
+      if (patch) record3 = applyPatch(record3, patch) ?? record3;
     }
-    return record2;
+    return record3;
   };
   const conversationLive = (conversationId) => {
     const conversation2 = view(key2("conversation", conversationId));
@@ -15321,10 +15821,10 @@ function createVaultChatBackend(options) {
     const out = [];
     for (const k of keys) {
       if (!k.startsWith(`${kind}/`)) continue;
-      const record2 = view(k);
-      if (!record2 || record2.isDeleted && !includeDeleted) continue;
-      if (conversationId !== void 0 && record2.conversationId !== conversationId) continue;
-      out.push(record2);
+      const record3 = view(k);
+      if (!record3 || record3.isDeleted && !includeDeleted) continue;
+      if (conversationId !== void 0 && record3.conversationId !== conversationId) continue;
+      out.push(record3);
     }
     return out;
   };
@@ -15335,7 +15835,7 @@ function createVaultChatBackend(options) {
       account: cache.account,
       cursor: cursor ?? "",
       records: [...confirmed.values()].filter(
-        ({ record: record2 }) => record2.kind === "conversation" || record2.kind !== "project" && keep.has(record2.conversationId)
+        ({ record: record3 }) => record3.kind === "conversation" || record3.kind !== "project" && keep.has(record3.conversationId)
       ),
       threads: kept,
       absent: [...checked].filter((k) => {
@@ -15649,17 +16149,17 @@ function createVaultChatBackend(options) {
     return loading;
   };
   const applyRemote = (snapshot) => {
-    const { record: record2 } = snapshot;
-    const k = key2(record2.kind, record2.id);
-    if (record2.kind === "conversation") {
+    const { record: record3 } = snapshot;
+    const k = key2(record3.kind, record3.id);
+    if (record3.kind === "conversation") {
       if (!merge(snapshot)) return;
-      if (record2.isDeleted) forgetConversation(record2.id);
-      announce([record2]);
+      if (record3.isDeleted) forgetConversation(record3.id);
+      announce([record3]);
       return;
     }
-    if (record2.kind === "project") return;
-    const relevant2 = threads.has(record2.conversationId) || confirmed.has(k) || checked.has(k) && record2.kind !== "message";
-    if (relevant2 && merge(snapshot)) announce([record2]);
+    if (record3.kind === "project") return;
+    const relevant2 = threads.has(record3.conversationId) || confirmed.has(k) || checked.has(k) && record3.kind !== "message";
+    if (relevant2 && merge(snapshot)) announce([record3]);
   };
   const listIndex = async (source) => {
     const index = [];
@@ -15810,8 +16310,8 @@ function createVaultChatBackend(options) {
       checked.add(k);
       if (found) merge(found);
     }
-    const record2 = view(k);
-    return record2 && !record2.isDeleted && conversationLive(record2.conversationId) ? record2 : void 0;
+    const record3 = view(k);
+    return record3 && !record3.isDeleted && conversationLive(record3.conversationId) ? record3 : void 0;
   };
   const child = async (kind, conversationId) => {
     await available2();
@@ -15848,19 +16348,19 @@ function createVaultChatBackend(options) {
     await backend.deleteSummary(conversationId);
   };
   const storedMessage = async (uniqueId) => {
-    const record2 = await message(uniqueId);
-    return record2 ? toMessage(record2) : null;
+    const record3 = await message(uniqueId);
+    return record3 ? toMessage(record3) : null;
   };
   const patchMessage = async (uniqueId, patch) => {
-    const record2 = await message(uniqueId);
-    if (!record2) return null;
+    const record3 = await message(uniqueId);
+    if (!record3) return null;
     await enqueue({
       kind: "message",
       id: uniqueId,
-      conversationId: record2.conversationId,
+      conversationId: record3.conversationId,
       ...patch
     });
-    emit({ type: "messages", conversationId: record2.conversationId, origin: "local" });
+    emit({ type: "messages", conversationId: record3.conversationId, origin: "local" });
     const updated = view(key2("message", uniqueId));
     return updated && !updated.isDeleted ? toMessage(updated) : null;
   };
@@ -15885,12 +16385,12 @@ function createVaultChatBackend(options) {
   });
   const backend = {
     async getConversation(conversationId) {
-      const record2 = await conversation(conversationId);
-      return record2 && !record2.isDeleted ? toConversation(record2) : null;
+      const record3 = await conversation(conversationId);
+      return record3 && !record3.isDeleted ? toConversation(record3) : null;
     },
     async getConversations(query) {
       await available2();
-      return all("conversation").filter((record2) => record2.id !== ANUMA_CONVERSATION_ID).map(toConversation).filter(
+      return all("conversation").filter((record3) => record3.id !== ANUMA_CONVERSATION_ID).map(toConversation).filter(
         (c) => query?.projectId === void 0 || (query.projectId === null ? !c.projectId : c.projectId === query.projectId)
       ).sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
     },
@@ -15929,13 +16429,13 @@ function createVaultChatBackend(options) {
     async updateConversationContext(conversationId, context) {
       const set = contextFields(context);
       if (Object.keys(set).length > 0) return updateConversation(conversationId, set);
-      const record2 = await conversation(conversationId);
-      return !!record2 && !record2.isDeleted;
+      const record3 = await conversation(conversationId);
+      return !!record3 && !record3.isDeleted;
     },
     async deleteConversation(conversationId) {
       if (conversationId === ANUMA_CONVERSATION_ID) return false;
-      const record2 = await conversation(conversationId);
-      if (!record2 || record2.isDeleted) return false;
+      const record3 = await conversation(conversationId);
+      if (!record3 || record3.isDeleted) return false;
       for (const [k, patch] of pending)
         if (patch.conversationId === conversationId) pending.delete(k);
       await enqueue({ kind: "conversation", id: conversationId, conversationId: "", delete: true });
@@ -15971,8 +16471,8 @@ function createVaultChatBackend(options) {
       const unknown = ids.map((id2) => key2("message", id2)).filter((k) => !view(k) && !checked.has(k));
       await refresh(unknown);
       return ids.flatMap((id2) => {
-        const record2 = view(key2("message", id2));
-        return record2 && !record2.isDeleted && conversationLive(record2.conversationId) ? [toMessage(record2)] : [];
+        const record3 = view(key2("message", id2));
+        return record3 && !record3.isDeleted && conversationLive(record3.conversationId) ? [toMessage(record3)] : [];
       });
     },
     async getMessageCount(conversationId) {
@@ -15980,8 +16480,8 @@ function createVaultChatBackend(options) {
     },
     async getToolCallEventIds(conversationId) {
       const ids = /* @__PURE__ */ new Set();
-      for (const record2 of await thread(conversationId)) {
-        const events = record2.data.toolCallEvents;
+      for (const record3 of await thread(conversationId)) {
+        const events = record3.data.toolCallEvents;
         if (!Array.isArray(events)) continue;
         for (const event of events)
           if (event && typeof event === "object" && !Array.isArray(event) && typeof event.id === "string")
@@ -16074,21 +16574,21 @@ function createVaultChatBackend(options) {
     },
     async clearMessages(conversationId) {
       await invalidateSummary(conversationId);
-      for (const record2 of await thread(conversationId))
-        await enqueue({ kind: "message", id: record2.id, conversationId, delete: true });
+      for (const record3 of await thread(conversationId))
+        await enqueue({ kind: "message", id: record3.id, conversationId, delete: true });
       emit({ type: "messages", conversationId, origin: "local" });
     },
     async deleteMessage(uniqueId) {
-      const record2 = await message(uniqueId);
-      if (!record2) return null;
-      await invalidateSummary(record2.conversationId, record2);
+      const record3 = await message(uniqueId);
+      if (!record3) return null;
+      await invalidateSummary(record3.conversationId, record3);
       await enqueue({
         kind: "message",
         id: uniqueId,
-        conversationId: record2.conversationId,
+        conversationId: record3.conversationId,
         delete: true
       });
-      emit({ type: "messages", conversationId: record2.conversationId, origin: "local" });
+      emit({ type: "messages", conversationId: record3.conversationId, origin: "local" });
       return uniqueId;
     },
     observeMessages(conversationId) {
@@ -16101,13 +16601,13 @@ function createVaultChatBackend(options) {
       await available2();
       if (query?.conversationId) await loadThread(query.conversationId);
       const files = [];
-      for (const record2 of all("message", query?.conversationId)) {
-        if (!conversationLive(record2.conversationId)) continue;
-        const stored2 = toMessage(record2);
+      for (const record3 of all("message", query?.conversationId)) {
+        if (!conversationLive(record3.conversationId)) continue;
+        const stored2 = toMessage(record3);
         for (const file of stored2.files ?? [])
           files.push({
             ...file,
-            conversationId: record2.conversationId,
+            conversationId: record3.conversationId,
             createdAt: stored2.createdAt,
             messageRole: stored2.role
           });
@@ -16146,8 +16646,8 @@ function createVaultChatBackend(options) {
       return results;
     },
     async getSummary(conversationId) {
-      const record2 = await child("summary", conversationId);
-      return record2 && !record2.isDeleted && record2.data.summarizedUpTo ? toSummary(record2) : null;
+      const record3 = await child("summary", conversationId);
+      return record3 && !record3.isDeleted && record3.data.summarizedUpTo ? toSummary(record3) : null;
     },
     async upsertSummary(conversationId, summary, summarizedUpTo, tokenCount) {
       await child("summary", conversationId);
@@ -16163,8 +16663,8 @@ function createVaultChatBackend(options) {
       return toSummary(view(key2("summary", conversationId)));
     },
     async deleteSummary(conversationId) {
-      const record2 = await child("summary", conversationId);
-      if (!record2 || record2.isDeleted) return;
+      const record3 = await child("summary", conversationId);
+      if (!record3 || record3.isDeleted) return;
       await enqueue({
         kind: "summary",
         id: conversationId,
@@ -16174,8 +16674,8 @@ function createVaultChatBackend(options) {
       emit({ type: "summary", conversationId, origin: "local" });
     },
     async getMemoryLinks(conversationId) {
-      const record2 = await child("memory_links", conversationId);
-      return record2 && !record2.isDeleted ? toLinks(record2) : [];
+      const record3 = await child("memory_links", conversationId);
+      return record3 && !record3.isDeleted ? toLinks(record3) : [];
     },
     async addMemoryLinks(conversationId, items) {
       if (!conversationId || items.length === 0) return;
@@ -16190,8 +16690,8 @@ function createVaultChatBackend(options) {
       emit({ type: "links", conversationId, origin: "local" });
     },
     async clearMemoryLinks(conversationId) {
-      const record2 = await child("memory_links", conversationId);
-      if (!record2 || record2.isDeleted) return;
+      const record3 = await child("memory_links", conversationId);
+      if (!record3 || record3.isDeleted) return;
       await enqueue({
         kind: "memory_links",
         id: conversationId,
@@ -16209,8 +16709,8 @@ function createVaultChatBackend(options) {
     async importChats(chats) {
       await ready();
       const seen = /* @__PURE__ */ new Set();
-      const unique = (items) => items.filter(({ record: record2 }) => {
-        const k = key2(record2.kind, record2.id);
+      const unique = (items) => items.filter(({ record: record3 }) => {
+        const k = key2(record3.kind, record3.id);
         if (seen.has(k)) return false;
         seen.add(k);
         return true;
@@ -16234,15 +16734,15 @@ function createVaultChatBackend(options) {
         for (const batch of batches(messages))
           messageCount += await connected.importRecords(batch);
       } finally {
-        for (const { record: record2 } of messages) checked.delete(key2("message", record2.id));
-        await refresh(conversations.map(({ record: record2 }) => key2("conversation", record2.id))).catch(
+        for (const { record: record3 } of messages) checked.delete(key2("message", record3.id));
+        await refresh(conversations.map(({ record: record3 }) => key2("conversation", record3.id))).catch(
           () => void 0
         );
-        for (const { record: record2 } of conversations) threads.delete(record2.id);
+        for (const { record: record3 } of conversations) threads.delete(record3.id);
         channel?.postMessage("changed");
         emit({ type: "conversations", origin: "local" });
-        for (const { record: record2 } of conversations)
-          emit({ type: "messages", conversationId: record2.id, origin: "local" });
+        for (const { record: record3 } of conversations)
+          emit({ type: "messages", conversationId: record3.id, origin: "local" });
       }
       return { conversations: conversationCount, messages: messageCount };
     },
@@ -16261,8 +16761,8 @@ function createVaultChatBackend(options) {
     }
   };
   const updateConversation = async (conversationId, set) => {
-    const record2 = await conversation(conversationId);
-    if (!record2 || record2.isDeleted) return false;
+    const record3 = await conversation(conversationId);
+    if (!record3 || record3.isDeleted) return false;
     await enqueue({ kind: "conversation", id: conversationId, conversationId: "", set });
     emit({ type: "conversations", origin: "local" });
     return true;
@@ -16438,10 +16938,10 @@ async function decryptConversationTitle(encryptedTitle, address) {
     );
   }
   const cacheKey = buildCacheKey(address, encryptedTitle);
-  const cached = titleCache.get(cacheKey);
-  if (cached !== void 0) {
-    touchEntry(cacheKey, cached);
-    return cached;
+  const cached2 = titleCache.get(cacheKey);
+  if (cached2 !== void 0) {
+    touchEntry(cacheKey, cached2);
+    return cached2;
   }
   const inFlight = pendingDecrypts.get(cacheKey);
   if (inFlight) return inFlight;
@@ -16700,25 +17200,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((record2) => ({ record: record2, kind: kindByName.get(record2.canonicalName) }));
+  }).map((record3) => ({ record: record3, kind: kindByName.get(record3.canonicalName) }));
   const missing2 = unique.filter((n) => !existingNames.has(n));
   const created = missing2.map(
-    (name) => ctx.entityCollection.prepareCreate((record2) => {
-      record2._setRaw("canonical_name", name);
+    (name) => ctx.entityCollection.prepareCreate((record3) => {
+      record3._setRaw("canonical_name", name);
       const kind = kindByName.get(name);
-      if (kind !== void 0) record2._setRaw("kind", kind);
+      if (kind !== void 0) record3._setRaw("kind", kind);
     })
   );
   for (const e of existing) out.set(e.canonicalName, entityToStored(e));
-  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 });
+  for (const record3 of created) out.set(record3.canonicalName, entityToStored(record3));
+  for (const { record: record3, kind } of kindBackfills) {
+    out.set(record3.canonicalName, { ...entityToStored(record3), kind });
   }
   return { entities: out, operations: created, kindBackfills };
 }
 function prepareKindBackfills(backfills) {
   return backfills.map(
-    ({ record: record2, kind }) => record2.prepareUpdate((r) => {
+    ({ record: record3, kind }) => record3.prepareUpdate((r) => {
       r._setRaw("kind", kind);
     })
   );
@@ -16846,10 +17346,10 @@ async function linkMemoryEntitiesOp(ctx, memoryId, entityInputs, options) {
       return;
     }
     const linkOps = toCreate.map(
-      (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);
+      (e) => ctx.memoryEntityCollection.prepareCreate((record3) => {
+        record3._setRaw("memory_id", memoryId);
+        record3._setRaw("entity_id", e.uniqueId);
+        if (userId !== void 0) record3._setRaw("user_id", userId);
       })
     );
     await ctx.database.batch(
@@ -16919,10 +17419,10 @@ async function replaceMemoryEntities(ctx, memoryId, entityInputs, options) {
       ...entityOps,
       ...prepareKindBackfills(kindBackfills),
       ...toCreate.map(
-        (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);
+        (e) => ctx.memoryEntityCollection.prepareCreate((record3) => {
+          record3._setRaw("memory_id", memoryId);
+          record3._setRaw("entity_id", e.uniqueId);
+          if (userId !== void 0) record3._setRaw("user_id", userId);
         })
       ),
       ...toDestroy.map((l) => l.prepareDestroyPermanently()),
@@ -18251,9 +18751,9 @@ var DatabaseManager = class {
    */
   getDatabase(walletAddress) {
     const dbName = this.getDbName(walletAddress);
-    const cached = this.databases.get(dbName);
-    if (cached) {
-      return cached;
+    const cached2 = this.databases.get(dbName);
+    if (cached2) {
+      return cached2;
     }
     const needsMigration = this.handleSchemaMigration(walletAddress);
     if (needsMigration) {
@@ -19393,8 +19893,8 @@ function visibilityConditions(requested) {
   if (excluded.length === 0) return [];
   return [import_watermelondb24.Q.or(import_watermelondb24.Q.where("visibility", null), import_watermelondb24.Q.where("visibility", import_watermelondb24.Q.notIn(excluded)))];
 }
-function isKinded(record2) {
-  return record2.kind !== null && record2.kind !== void 0;
+function isKinded(record3) {
+  return record3.kind !== null && record3.kind !== void 0;
 }
 async function assertCanWrite2(ctx) {
   if (ctx.canWrite && !await ctx.canWrite()) {
@@ -19448,8 +19948,8 @@ function levelConditions(requested) {
   }
   return [byLevel];
 }
-function isOwnedByCtxUser(ctx, record2) {
-  return ctx.userId === void 0 || record2.userId === ctx.userId;
+function isOwnedByCtxUser(ctx, record3) {
+  return ctx.userId === void 0 || record3.userId === ctx.userId;
 }
 function baseVaultConditions(ctx, options) {
   return [
@@ -19532,43 +20032,43 @@ async function vaultMemoryToStored(memory, walletAddress, signMessage, embeddedW
   }
   return raw;
 }
-function populateNewVaultMemory(record2, ctx, opts, encryptedContent, encryptedKindValue) {
+function populateNewVaultMemory(record3, 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);
+  record3._setRaw("content", encryptedContent);
+  record3._setRaw("scope", scope);
+  record3._setRaw("level", level);
+  record3._setRaw("kind", opts.kind ?? null);
+  record3._setRaw("kind_value", encryptedKindValue ?? null);
+  record3._setRaw("folder_id", opts.folderId ?? null);
+  record3._setRaw("user_id", ctx.userId ?? null);
+  record3._setRaw("is_deleted", false);
   if (opts.embedding !== void 0) {
-    record2._setRaw("embedding", opts.embedding);
-    record2._setRaw("embedding_model", opts.embeddingModel ?? null);
+    record3._setRaw("embedding", opts.embedding);
+    record3._setRaw("embedding_model", opts.embeddingModel ?? null);
   }
   if (opts.sourceChunkIds !== void 0) {
-    record2._setRaw("source_chunk_ids", serializeSourceChunkIds(opts.sourceChunkIds));
+    record3._setRaw("source_chunk_ids", serializeSourceChunkIds(opts.sourceChunkIds));
   }
-  record2._setRaw("proof_count", opts.proofCount ?? 1);
-  record2._setRaw("source", opts.source ?? "manual");
+  record3._setRaw("proof_count", opts.proofCount ?? 1);
+  record3._setRaw("source", opts.source ?? "manual");
   if (opts.eventTime) {
-    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);
+    record3._setRaw("event_time_start", opts.eventTime.start ?? null);
+    record3._setRaw("event_time_end", opts.eventTime.end ?? null);
+    record3._setRaw("event_time_kind", opts.eventTime.kind ?? null);
   }
   if (opts.factType !== void 0) {
-    record2._setRaw("fact_type", opts.factType);
+    record3._setRaw("fact_type", opts.factType);
   }
   if (opts.trustTier !== void 0) {
-    record2._setRaw("trust_tier", normalizeTrustTier(opts.trustTier));
+    record3._setRaw("trust_tier", normalizeTrustTier(opts.trustTier));
   }
-  record2._setRaw("visibility", opts.visibility ?? "private");
-  record2._setRaw(
+  record3._setRaw("visibility", opts.visibility ?? "private");
+  record3._setRaw(
     "published_at",
     opts.visibility && opts.visibility !== "private" ? opts.publishedAt ?? Date.now() : null
   );
   if (opts.geohash !== void 0) {
-    record2._setRaw("geohash", opts.geohash);
+    record3._setRaw("geohash", opts.geohash);
   }
 }
 async function createVaultMemoryOp(ctx, opts) {
@@ -19583,7 +20083,7 @@ async function createVaultMemoryOp(ctx, opts) {
   const created = await ctx.database.write(async () => {
     await assertCanWrite2(ctx);
     return ctx.vaultMemoryCollection.create(
-      (record2) => populateNewVaultMemory(record2, ctx, opts, encryptedContent, encryptedKindValue)
+      (record3) => populateNewVaultMemory(record3, ctx, opts, encryptedContent, encryptedKindValue)
     );
   });
   return vaultMemoryToStored(created, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner);
@@ -19610,7 +20110,7 @@ async function createSupersedingMemoryOp(ctx, opts, targetId) {
     if (target.isDeleted || target.supersededBy || isKinded(target) || !isOwnedByCtxUser(ctx, target))
       return;
     createdRecord = await ctx.vaultMemoryCollection.create(
-      (record2) => populateNewVaultMemory(record2, ctx, opts, encryptedContent, encryptedKindValue)
+      (record3) => populateNewVaultMemory(record3, ctx, opts, encryptedContent, encryptedKindValue)
     );
     await target.update((r) => {
       r._setRaw("superseded_by", createdRecord.id);
@@ -19695,7 +20195,7 @@ async function createVaultMemoriesBatchOp(ctx, optionsArray) {
     await assertCanWrite2(ctx);
     const prepared = optionsArray.map(
       (opts, i) => ctx.vaultMemoryCollection.prepareCreate(
-        (record2) => populateNewVaultMemory(record2, ctx, opts, encryptedContents[i], encryptedKindValues[i])
+        (record3) => populateNewVaultMemory(record3, ctx, opts, encryptedContents[i], encryptedKindValues[i])
       )
     );
     await ctx.database.batch(...prepared);
@@ -19703,16 +20203,16 @@ async function createVaultMemoriesBatchOp(ctx, optionsArray) {
   });
   return Promise.all(
     created.map(
-      (record2) => vaultMemoryToStored(record2, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner)
+      (record3) => vaultMemoryToStored(record3, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner)
     )
   );
 }
 async function getVaultMemoryOp(ctx, id2) {
   try {
-    const record2 = await ctx.vaultMemoryCollection.find(id2);
-    if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) return null;
+    const record3 = await ctx.vaultMemoryCollection.find(id2);
+    if (record3.isDeleted || !isOwnedByCtxUser(ctx, record3)) return null;
     return vaultMemoryToStored(
-      record2,
+      record3,
       ctx.walletAddress,
       ctx.signMessage,
       ctx.embeddedWalletSigner
@@ -20051,29 +20551,29 @@ async function updateVaultMemoryOp(ctx, id2, opts) {
       ctx.embeddedWalletSigner
     ) : opts.content;
     let stale = false;
-    const record2 = probe;
+    const record3 = probe;
     await ctx.database.write(async () => {
       await assertCanWrite2(ctx);
-      if (record2.isDeleted || record2.supersededBy || !isOwnedByCtxUser(ctx, record2) || opts.freeFormOnly && isKinded(record2) || opts.expectedContent !== void 0 && record2._getRaw("content") !== readStoredContent) {
+      if (record3.isDeleted || record3.supersededBy || !isOwnedByCtxUser(ctx, record3) || opts.freeFormOnly && isKinded(record3) || opts.expectedContent !== void 0 && record3._getRaw("content") !== readStoredContent) {
         stale = true;
         return;
       }
-      const originalUpdatedAt = record2.updatedAt.getTime();
-      const nextKind = opts.kind !== void 0 ? opts.kind : record2.kind;
-      const nextLevel = levelAfter(record2);
+      const originalUpdatedAt = record3.updatedAt.getTime();
+      const nextKind = opts.kind !== void 0 ? opts.kind : record3.kind;
+      const nextLevel = levelAfter(record3);
       assertValidKindLevel(nextKind, nextLevel);
       let observedSources = [];
       let replayedObservation = false;
       if (opts.observationSourceIds?.length) {
         try {
-          const parsed = JSON.parse(record2.sourceChunkIds ?? "[]");
+          const parsed = JSON.parse(record3.sourceChunkIds ?? "[]");
           if (Array.isArray(parsed))
             observedSources = parsed.filter((id3) => typeof id3 === "string");
         } catch {
         }
         replayedObservation = opts.observationSourceIds.every((id3) => observedSources.includes(id3));
       }
-      await record2.update((r) => {
+      await record3.update((r) => {
         if (encryptedContent !== void 0) r._setRaw("content", encryptedContent);
         if (opts.level !== void 0) {
           r._setRaw("level", nextLevel);
@@ -20140,7 +20640,7 @@ async function updateVaultMemoryOp(ctx, id2, opts) {
     });
     if (stale) return null;
     return vaultMemoryToStored(
-      record2,
+      record3,
       ctx.walletAddress,
       ctx.signMessage,
       ctx.embeddedWalletSigner
@@ -20155,22 +20655,22 @@ async function setMemoryEntitiesOp(ctx, memoryId, entities) {
   if (!entityCtx) {
     throw new Error("setMemoryEntitiesOp requires ctx.entityCtx (entity collections)");
   }
-  let record2;
+  let record3;
   try {
-    record2 = await ctx.vaultMemoryCollection.find(memoryId);
+    record3 = await ctx.vaultMemoryCollection.find(memoryId);
   } catch {
     return null;
   }
-  if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) return null;
+  if (record3.isDeleted || !isOwnedByCtxUser(ctx, record3)) return null;
   let stale = false;
-  const originalUpdatedAt = record2.updatedAt.getTime();
+  const originalUpdatedAt = record3.updatedAt.getTime();
   await ctx.database.write(async (writer) => {
     await assertCanWrite2(ctx);
-    if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) {
+    if (record3.isDeleted || !isOwnedByCtxUser(ctx, record3)) {
       stale = true;
       return;
     }
-    await record2.update((r) => {
+    await record3.update((r) => {
       r._setRaw("topics_user_managed", true);
       r._setRaw("updated_at", originalUpdatedAt);
     });
@@ -20194,26 +20694,26 @@ async function setMemoryEntitiesOp(ctx, memoryId, entities) {
     );
   });
   if (stale) return null;
-  return vaultMemoryToStored(record2, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner);
+  return vaultMemoryToStored(record3, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner);
 }
 async function clearMemoryTopicsOverrideOp(ctx, memoryId, options) {
-  let record2;
+  let record3;
   try {
-    record2 = await ctx.vaultMemoryCollection.find(memoryId);
+    record3 = await ctx.vaultMemoryCollection.find(memoryId);
   } catch {
     return false;
   }
-  if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) return false;
-  const originalUpdatedAt = record2.updatedAt.getTime();
+  if (record3.isDeleted || !isOwnedByCtxUser(ctx, record3)) return false;
+  const originalUpdatedAt = record3.updatedAt.getTime();
   let cleared = false;
   await ctx.database.write(async () => {
     await assertCanWrite2(ctx);
-    if (options?.unlessTopicsRecorded && parseTopics(record2.topics) !== null) return;
+    if (options?.unlessTopicsRecorded && parseTopics(record3.topics) !== null) return;
     cleared = true;
-    await record2.update((r) => {
+    await record3.update((r) => {
       r._setRaw("topics_user_managed", false);
       r._setRaw("topics_extracted_version", null);
-      if (record2.topicsExtractedAt === null) {
+      if (record3.topicsExtractedAt === null) {
         r._setRaw("topics_extracted_at", originalUpdatedAt);
       }
       r._setRaw("updated_at", originalUpdatedAt);
@@ -20222,23 +20722,23 @@ async function clearMemoryTopicsOverrideOp(ctx, memoryId, options) {
   return cleared;
 }
 async function setMemoryVisibilityOp(ctx, id2, opts) {
-  let record2;
+  let record3;
   try {
-    record2 = await ctx.vaultMemoryCollection.find(id2);
+    record3 = await ctx.vaultMemoryCollection.find(id2);
   } catch {
     return null;
   }
-  if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) return null;
+  if (record3.isDeleted || !isOwnedByCtxUser(ctx, record3)) return null;
   let stale = false;
   await ctx.database.write(async () => {
     await assertCanWrite2(ctx);
-    if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) {
+    if (record3.isDeleted || !isOwnedByCtxUser(ctx, record3)) {
       stale = true;
       return;
     }
-    const currentUpdatedAt = record2.updatedAt.getTime();
-    const currentPublishedAt = record2.publishedAt ?? null;
-    await record2.update((r) => {
+    const currentUpdatedAt = record3.updatedAt.getTime();
+    const currentPublishedAt = record3.publishedAt ?? null;
+    await record3.update((r) => {
       r._setRaw("visibility", opts.visibility);
       if (opts.visibility === "private") {
         r._setRaw("published_at", null);
@@ -20252,20 +20752,20 @@ async function setMemoryVisibilityOp(ctx, id2, opts) {
     });
   });
   if (stale) return null;
-  return vaultMemoryToStored(record2, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner);
+  return vaultMemoryToStored(record3, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner);
 }
 async function deleteVaultMemoryOp(ctx, id2) {
   try {
-    const record2 = await ctx.vaultMemoryCollection.find(id2);
-    if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) return false;
+    const record3 = await ctx.vaultMemoryCollection.find(id2);
+    if (record3.isDeleted || !isOwnedByCtxUser(ctx, record3)) return false;
     let stale = false;
     await ctx.database.write(async () => {
       await assertCanWrite2(ctx);
-      if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) {
+      if (record3.isDeleted || !isOwnedByCtxUser(ctx, record3)) {
         stale = true;
         return;
       }
-      await record2.update((r) => {
+      await record3.update((r) => {
         r._setRaw("is_deleted", true);
       });
     });
@@ -20284,9 +20784,9 @@ async function deleteVaultMemoryOp(ctx, id2) {
 async function supersedeVaultMemoryOp(ctx, id2, supersededById) {
   if (id2 === supersededById) return false;
   try {
-    const record2 = await ctx.vaultMemoryCollection.find(id2);
-    if (record2.isDeleted || record2.supersededBy || !isOwnedByCtxUser(ctx, record2)) return false;
-    if (isKinded(record2)) return false;
+    const record3 = await ctx.vaultMemoryCollection.find(id2);
+    if (record3.isDeleted || record3.supersededBy || !isOwnedByCtxUser(ctx, record3)) return false;
+    if (isKinded(record3)) return false;
     let successor;
     try {
       successor = await ctx.vaultMemoryCollection.find(supersededById);
@@ -20299,7 +20799,7 @@ async function supersedeVaultMemoryOp(ctx, id2, supersededById) {
     let stale = false;
     await ctx.database.write(async () => {
       await assertCanWrite2(ctx);
-      if (record2.isDeleted || record2.supersededBy || !isOwnedByCtxUser(ctx, record2)) {
+      if (record3.isDeleted || record3.supersededBy || !isOwnedByCtxUser(ctx, record3)) {
         stale = true;
         return;
       }
@@ -20307,7 +20807,7 @@ async function supersedeVaultMemoryOp(ctx, id2, supersededById) {
         stale = true;
         return;
       }
-      await record2.update((r) => {
+      await record3.update((r) => {
         r._setRaw("superseded_by", supersededById);
         r._setRaw("superseded_at", Date.now());
       });
@@ -20326,7 +20826,7 @@ async function getUnfiledVaultMemoriesOp(ctx) {
   const results = await ctx.vaultMemoryCollection.query(...conditions).fetch();
   return mapInBatches(
     results,
-    (record2) => vaultMemoryToStored(record2, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner)
+    (record3) => vaultMemoryToStored(record3, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner)
   );
 }
 var TOPICS_EXTRACTION_VERSION = 3;
@@ -20487,17 +20987,17 @@ async function stampTopicsExtractedAtOp(ctx, memoryIds, extractedAt, version = T
         }
       }
       const eligible = records.filter(
-        (record2) => !record2.isDeleted && isOwnedByCtxUser(ctx, record2) && !record2.topicsUserManaged
+        (record3) => !record3.isDeleted && isOwnedByCtxUser(ctx, record3) && !record3.topicsUserManaged
       );
-      const prepared = eligible.map((record2) => {
-        const originalUpdatedAt = record2.updatedAt.getTime();
-        return record2.prepareUpdate((r) => {
+      const prepared = eligible.map((record3) => {
+        const originalUpdatedAt = record3.updatedAt.getTime();
+        return record3.prepareUpdate((r) => {
           r._setRaw("topics_extracted_at", extractedAt);
           r._setRaw("topics_extracted_version", version);
           r._setRaw("updated_at", originalUpdatedAt);
         });
       });
-      for (const record2 of eligible) stamped.push(record2.id);
+      for (const record3 of eligible) stamped.push(record3.id);
       if (prepared.length > 0) await ctx.database.batch(...prepared);
     });
   }
@@ -20513,14 +21013,14 @@ async function relinkMemoryTopicsOp(ctx, memoryIds) {
     try {
       await ctx.database.write(async (writer) => {
         await assertCanWrite2(ctx);
-        let record2;
+        let record3;
         try {
-          record2 = await ctx.vaultMemoryCollection.find(id2);
+          record3 = await ctx.vaultMemoryCollection.find(id2);
         } catch {
           return;
         }
-        if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) return;
-        const topics = parseTopics(record2.topics);
+        if (record3.isDeleted || !isOwnedByCtxUser(ctx, record3)) return;
+        const topics = parseTopics(record3.topics);
         if (topics === null) return;
         await writer.callWriter(() => relinkMemoryEntitiesFromTopicsOp(entityCtx, id2, topics));
         relinked.push(id2);
@@ -20546,18 +21046,18 @@ async function backfillMemoryTopicsOp(ctx, memoryIds) {
       await assertCanWrite2(ctx);
       const records = [];
       for (const id2 of chunkIds) {
-        let record2;
+        let record3;
         try {
-          record2 = await ctx.vaultMemoryCollection.find(id2);
+          record3 = await ctx.vaultMemoryCollection.find(id2);
         } catch {
           continue;
         }
-        if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) continue;
-        if (parseTopics(record2.topics) !== null) continue;
-        records.push(record2);
+        if (record3.isDeleted || !isOwnedByCtxUser(ctx, record3)) continue;
+        if (parseTopics(record3.topics) !== null) continue;
+        records.push(record3);
       }
       if (records.length === 0) return;
-      const links2 = await entityCtx.memoryEntityCollection.query(import_watermelondb24.Q.where("memory_id", import_watermelondb24.Q.oneOf(records.map((record2) => record2.id)))).unsafeFetchRaw();
+      const links2 = await entityCtx.memoryEntityCollection.query(import_watermelondb24.Q.where("memory_id", import_watermelondb24.Q.oneOf(records.map((record3) => record3.id)))).unsafeFetchRaw();
       const entityIds = Array.from(new Set(links2.map((link) => String(link.entity_id))));
       const entitiesById = /* @__PURE__ */ new Map();
       for (let j = 0; j < entityIds.length; j += CHUNK) {
@@ -20577,13 +21077,13 @@ async function backfillMemoryTopicsOp(ctx, memoryIds) {
         entities.add(entity);
       }
       const writes = [];
-      for (const record2 of records) {
-        const entities = entitiesByMemory.get(record2.id);
+      for (const record3 of records) {
+        const entities = entitiesByMemory.get(record3.id);
         if (!entities?.size) continue;
-        const source = record2.topicsUserManaged ? "user" : "auto";
+        const source = record3.topicsUserManaged ? "user" : "auto";
         const write = await resolveMemoryTopicsWrite(
           entityCtx,
-          record2.id,
+          record3.id,
           Array.from(entities),
           [],
           source
@@ -20605,7 +21105,7 @@ async function deleteAllVaultMemoriesForUserOp(ctx, userId) {
   await ctx.database.write(async () => {
     await assertCanWrite2(ctx);
     const prepared = records.map(
-      (record2) => record2.prepareUpdate((r) => {
+      (record3) => record3.prepareUpdate((r) => {
         r._setRaw("is_deleted", true);
       })
     );
@@ -20676,22 +21176,22 @@ async function applyDecayTransitionsOp(ctx, candidates, opts) {
           import_watermelondb24.Q.where("id", import_watermelondb24.Q.oneOf(ids.slice(i, i + CHUNK))),
           ...ctx.userId !== void 0 ? [import_watermelondb24.Q.where("user_id", ctx.userId)] : []
         ).fetch();
-        const eligible = records.filter((record2) => {
-          if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) return false;
+        const eligible = records.filter((record3) => {
+          if (record3.isDeleted || !isOwnedByCtxUser(ctx, record3)) return false;
           if (opts.transition === "delete") {
-            return record2.archivedAt !== null && opts.now - record2.archivedAt > opts.hardDeleteWindowMs;
+            return record3.archivedAt !== null && opts.now - record3.archivedAt > opts.hardDeleteWindowMs;
           }
-          const candidate = byId.get(record2.id);
-          return record2.archivedAt === null && record2.updatedAt.getTime() === candidate.updatedAt && (record2.lastObservedAt ?? null) === (candidate.lastObservedAt ?? null);
+          const candidate = byId.get(record3.id);
+          return record3.archivedAt === null && record3.updatedAt.getTime() === candidate.updatedAt && (record3.lastObservedAt ?? null) === (candidate.lastObservedAt ?? null);
         });
         const prepared = eligible.map(
-          (record2) => record2.prepareUpdate((row) => {
+          (record3) => record3.prepareUpdate((row) => {
             if (opts.transition === "archive") row._setRaw("archived_at", opts.now);
             else row._setRaw("is_deleted", true);
           })
         );
         if (prepared.length > 0) await ctx.database.batch(prepared);
-        applied = eligible.map((record2) => record2.id);
+        applied = eligible.map((record3) => record3.id);
       });
     } catch {
       continue;
@@ -20709,21 +21209,21 @@ async function applyDecayTransitionsOp(ctx, candidates, opts) {
 }
 async function archiveVaultMemoryOp(ctx, id2, opts) {
   try {
-    const record2 = await ctx.vaultMemoryCollection.find(id2);
-    if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) return false;
+    const record3 = await ctx.vaultMemoryCollection.find(id2);
+    if (record3.isDeleted || !isOwnedByCtxUser(ctx, record3)) return false;
     let stale = false;
     const archivedAtValue = opts?.now ?? Date.now();
     await ctx.database.write(async () => {
       await assertCanWrite2(ctx);
-      if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2) || record2.archivedAt !== null) {
+      if (record3.isDeleted || !isOwnedByCtxUser(ctx, record3) || record3.archivedAt !== null) {
         stale = true;
         return;
       }
-      if (opts?.expectedUpdatedAt !== void 0 && record2.updatedAt.getTime() !== opts.expectedUpdatedAt || opts?.expectedLastObservedAt !== void 0 && (record2.lastObservedAt ?? null) !== opts.expectedLastObservedAt) {
+      if (opts?.expectedUpdatedAt !== void 0 && record3.updatedAt.getTime() !== opts.expectedUpdatedAt || opts?.expectedLastObservedAt !== void 0 && (record3.lastObservedAt ?? null) !== opts.expectedLastObservedAt) {
         stale = true;
         return;
       }
-      await record2.update((r) => {
+      await record3.update((r) => {
         r._setRaw("archived_at", archivedAtValue);
       });
     });
@@ -20734,16 +21234,16 @@ async function archiveVaultMemoryOp(ctx, id2, opts) {
 }
 async function restoreVaultMemoryOp(ctx, id2) {
   try {
-    const record2 = await ctx.vaultMemoryCollection.find(id2);
-    if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) return false;
+    const record3 = await ctx.vaultMemoryCollection.find(id2);
+    if (record3.isDeleted || !isOwnedByCtxUser(ctx, record3)) return false;
     let stale = false;
     await ctx.database.write(async () => {
       await assertCanWrite2(ctx);
-      if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) {
+      if (record3.isDeleted || !isOwnedByCtxUser(ctx, record3)) {
         stale = true;
         return;
       }
-      await record2.update((r) => {
+      await record3.update((r) => {
         r._setRaw("archived_at", null);
       });
     });
@@ -20754,18 +21254,18 @@ async function restoreVaultMemoryOp(ctx, id2) {
 }
 async function hardDeleteDecayedOp(ctx, id2, opts) {
   try {
-    const record2 = await ctx.vaultMemoryCollection.find(id2);
-    if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) return false;
+    const record3 = await ctx.vaultMemoryCollection.find(id2);
+    if (record3.isDeleted || !isOwnedByCtxUser(ctx, record3)) return false;
     const now = opts.now ?? Date.now();
     let stale = false;
     await ctx.database.write(async () => {
       await assertCanWrite2(ctx);
-      const archivedAt = record2.archivedAt;
-      if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2) || archivedAt === null || now - archivedAt <= opts.hardDeleteWindowMs) {
+      const archivedAt = record3.archivedAt;
+      if (record3.isDeleted || !isOwnedByCtxUser(ctx, record3) || archivedAt === null || now - archivedAt <= opts.hardDeleteWindowMs) {
         stale = true;
         return;
       }
-      await record2.update((r) => {
+      await record3.update((r) => {
         r._setRaw("is_deleted", true);
       });
     });
@@ -20783,14 +21283,14 @@ async function hardDeleteDecayedOp(ctx, id2, opts) {
 }
 async function updateVaultMemoryEmbeddingOp(ctx, id2, embedding2, embeddingModel, expected) {
   try {
-    const record2 = await ctx.vaultMemoryCollection.find(id2);
-    if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) return false;
-    const readUpdatedAt = record2.updatedAt.getTime();
-    const readStoredContent = record2._getRaw("content");
+    const record3 = await ctx.vaultMemoryCollection.find(id2);
+    if (record3.isDeleted || !isOwnedByCtxUser(ctx, record3)) return false;
+    const readUpdatedAt = record3.updatedAt.getTime();
+    const readStoredContent = record3._getRaw("content");
     if (expected?.updatedAt !== void 0 && expected.updatedAt !== readUpdatedAt) return false;
     if (expected?.content !== void 0) {
       const current = await vaultMemoryToStored(
-        record2,
+        record3,
         ctx.walletAddress,
         ctx.signMessage,
         ctx.embeddedWalletSigner
@@ -20800,11 +21300,11 @@ async function updateVaultMemoryEmbeddingOp(ctx, id2, embedding2, embeddingModel
     let written = false;
     await ctx.database.write(async () => {
       await assertCanWrite2(ctx);
-      if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) return;
-      const originalUpdatedAt = record2.updatedAt.getTime();
-      if (originalUpdatedAt !== readUpdatedAt || record2._getRaw("content") !== readStoredContent)
+      if (record3.isDeleted || !isOwnedByCtxUser(ctx, record3)) return;
+      const originalUpdatedAt = record3.updatedAt.getTime();
+      if (originalUpdatedAt !== readUpdatedAt || record3._getRaw("content") !== readStoredContent)
         return;
-      await record2.update((r) => {
+      await record3.update((r) => {
         r._setRaw("embedding", embedding2);
         r._setRaw("embedding_model", embeddingModel);
         r._setRaw("updated_at", originalUpdatedAt);
@@ -20969,26 +21469,26 @@ async function ingestPublishedPhotoMemoriesOp(ctx, rows) {
     inserted = writable.length;
     if (writable.length === 0) return;
     const prepared = writable.map(
-      ({ 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(
+      ({ row, content }) => ctx.vaultMemoryCollection.prepareCreate((record3) => {
+        record3._raw.id = row.memoryId;
+        record3._setRaw("content", content);
+        record3._setRaw("scope", "shared");
+        record3._setRaw("level", "matching");
+        record3._setRaw("folder_id", null);
+        record3._setRaw("user_id", ctx.userId ?? null);
+        record3._setRaw("is_deleted", false);
+        record3._setRaw("proof_count", 1);
+        record3._setRaw("source", SOURCE_PHOTO);
+        record3._setRaw(
           "media",
           row.media && row.media.length > 0 ? JSON.stringify(row.media) : null
         );
-        record2._setRaw("visibility", "public");
-        record2._setRaw("published_at", now);
+        record3._setRaw("visibility", "public");
+        record3._setRaw("published_at", now);
         if (row.eventTime) {
-          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);
+          record3._setRaw("event_time_start", row.eventTime.start ?? null);
+          record3._setRaw("event_time_end", row.eventTime.end ?? null);
+          record3._setRaw("event_time_kind", row.eventTime.kind ?? null);
         }
       })
     );
@@ -21820,11 +22320,11 @@ function folderToStored(folder) {
 }
 async function createVaultFolderOp(ctx, opts) {
   const created = await ctx.database.write(async () => {
-    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 ctx.vaultFolderCollection.create((record3) => {
+      record3._setRaw("name", opts.name);
+      record3._setRaw("scope", opts.scope ?? "private");
+      record3._setRaw("is_system", opts.isSystem ?? false);
+      record3._setRaw("is_deleted", false);
     });
   });
   return folderToStored(created);
@@ -21835,14 +22335,14 @@ async function getAllVaultFoldersOp(ctx) {
 }
 async function updateVaultFolderOp(ctx, id2, opts) {
   try {
-    const record2 = await ctx.vaultFolderCollection.find(id2);
-    if (record2.isDeleted) return null;
-    const scopeChanged = opts.scope !== void 0 && opts.scope !== record2.scope;
+    const record3 = await ctx.vaultFolderCollection.find(id2);
+    if (record3.isDeleted) return null;
+    const scopeChanged = opts.scope !== void 0 && opts.scope !== record3.scope;
     const updated = await ctx.database.write(async () => {
       const memories = scopeChanged ? await ctx.vaultMemoryCollection.query(import_watermelondb32.Q.where("folder_id", id2), import_watermelondb32.Q.where("is_deleted", false)).fetch() : [];
       const updates = [];
       updates.push(
-        record2.prepareUpdate((r) => {
+        record3.prepareUpdate((r) => {
           if (opts.name !== void 0) r._setRaw("name", opts.name);
           if (opts.scope !== void 0) r._setRaw("scope", opts.scope);
         })
@@ -21865,8 +22365,8 @@ async function updateVaultFolderOp(ctx, id2, opts) {
 }
 async function deleteVaultFolderOp(ctx, id2) {
   try {
-    const record2 = await ctx.vaultFolderCollection.find(id2);
-    if (record2.isDeleted) return false;
+    const record3 = await ctx.vaultFolderCollection.find(id2);
+    if (record3.isDeleted) return false;
     await ctx.database.write(async () => {
       const memories = await ctx.vaultMemoryCollection.query(import_watermelondb32.Q.where("folder_id", id2), import_watermelondb32.Q.where("is_deleted", false)).fetch();
       const preparedMemories = memories.map(
@@ -21876,7 +22376,7 @@ async function deleteVaultFolderOp(ctx, id2) {
           r._setRaw("scope", "private");
         })
       );
-      const preparedFolder = record2.prepareUpdate((r) => {
+      const preparedFolder = record3.prepareUpdate((r) => {
         r._setRaw("is_deleted", true);
       });
       await ctx.database.batch(...preparedMemories, preparedFolder);
@@ -21923,11 +22423,11 @@ async function moveMemoriesToFolderOp(ctx, memoryIds, folderId) {
 }
 async function updateVaultFolderContextOp(ctx, id2, context) {
   try {
-    const record2 = await ctx.vaultFolderCollection.find(id2);
-    if (record2.isDeleted) return null;
+    const record3 = await ctx.vaultFolderCollection.find(id2);
+    if (record3.isDeleted) return null;
     const updated = await ctx.database.write(async () => {
       await ctx.database.batch(
-        record2.prepareUpdate((r) => {
+        record3.prepareUpdate((r) => {
           r._setRaw("context", context);
         })
       );
@@ -23046,9 +23546,9 @@ function loadVaultCorpus(ctx, options, preparation) {
   const key3 = JSON.stringify(options ?? {});
   let request = pending.get(key3);
   if (!request) {
-    const entries = pending;
+    const entries2 = pending;
     request = getAllVaultMemoriesOp(ctx, options).catch((error) => {
-      entries.delete(key3);
+      entries2.delete(key3);
       throw error;
     });
     pending.set(key3, request);
@@ -23089,7 +23589,7 @@ function embedVaultRows(ctx, options, rows, preparation) {
     if (!pending.has(keys[index]) && !prepared?.has(keys[index])) missing2.set(keys[index], row);
   });
   if (missing2.size > 0) {
-    const entries = pending;
+    const entries2 = pending;
     const batch = Promise.resolve().then(
       () => generateEmbeddings(
         [...missing2.values()].map((row) => row.content),
@@ -23106,16 +23606,16 @@ function embedVaultRows(ctx, options, rows, preparation) {
         });
         return vector2;
       }).finally(() => {
-        entries.delete(key3);
-        if (entries.size === 0) pendingRows.get(ctx)?.delete(options.maskInput);
+        entries2.delete(key3);
+        if (entries2.size === 0) pendingRows.get(ctx)?.delete(options.maskInput);
       });
       pending.set(key3, request);
     });
   }
   return Promise.all(
     keys.map((key3) => {
-      const cached = prepared?.get(key3);
-      if (cached) return cached;
+      const cached2 = prepared?.get(key3);
+      if (cached2) return cached2;
       const request = pending.get(key3);
       if (!prepared) return request;
       const retained = request.catch((error) => {
@@ -23815,10 +24315,10 @@ async function buildProjectedCorpus(query, vaultCtx, embeddingOptions, cache, qu
   const resolvedThisCall = /* @__PURE__ */ new Set();
   if (!embeddingsDegraded) {
     for (const k2 of keys) {
-      const cached = cachedRowVector(cache, k2.uniqueId, k2.updatedAt);
-      if (cached && cached.length === queryEmbedding.length) {
+      const cached2 = cachedRowVector(cache, k2.uniqueId, k2.updatedAt);
+      if (cached2 && cached2.length === queryEmbedding.length) {
         corpusStats.cacheHits++;
-        vectored.push({ uniqueId: k2.uniqueId, embedding: cached, updatedAt: k2.updatedAt });
+        vectored.push({ uniqueId: k2.uniqueId, embedding: cached2, updatedAt: k2.updatedAt });
         continue;
       }
       corpusStats.cacheMisses++;
@@ -24116,12 +24616,12 @@ async function prepareVaultCandidates(query, vaultCtx, embeddingOptions, cache,
     for (let i = 0; queryEmbedding.length > 0 && i < memories.length; i++) {
       const content = memories[i].content;
       const memoryId = memories[i].uniqueId;
-      const cached = cachedRowVector(cache, memoryId, memories[i].updatedAt, content);
-      if (cached && cached.length === queryEmbedding.length) {
-        resolvedVectors.set(memoryId, cached);
+      const cached2 = cachedRowVector(cache, memoryId, memories[i].updatedAt, content);
+      if (cached2 && cached2.length === queryEmbedding.length) {
+        resolvedVectors.set(memoryId, cached2);
         continue;
       }
-      if (cached) cache.delete(memoryId);
+      if (cached2) cache.delete(memoryId);
       const storedModel = memories[i].embeddingModel;
       const modelCompatible = (storedModel ?? currentModel) === currentModel;
       if (memories[i].embedding && modelCompatible) {
@@ -25812,9 +26312,9 @@ function createDecaySweeperOver(backend, options) {
     if (ruleVerdict !== "keep") return rule;
     if (!classifier || !isBorderline(input)) return rule;
     if (input.id) {
-      const cached = classifierCache.get(input.id);
-      if (cached && cached.activityAt === lastActivityAt(input))
-        return { verdict: cached.verdict, source: "classifierDriven" };
+      const cached2 = classifierCache.get(input.id);
+      if (cached2 && cached2.activityAt === lastActivityAt(input))
+        return { verdict: cached2.verdict, source: "classifierDriven" };
     }
     if (sweep.classifierCalls >= maxClassifierCalls) {
       sweep.classifierCapHits++;
@@ -27678,21 +28178,21 @@ async function extractAndLinkEntitiesForMemoriesOp(ctx, memoryIds, options) {
   };
   const inputs = [];
   for (const id2 of new Set(memoryIds)) {
-    let record2;
+    let record3;
     try {
-      record2 = await ctx.vaultMemoryCollection.find(id2);
+      record3 = await ctx.vaultMemoryCollection.find(id2);
     } catch (err) {
       log.warn("[memory/topics] vault lookup failed for extraction", err);
       skip(id2, "not-found");
       continue;
     }
-    if (record2.isDeleted || ctx.userId !== void 0 && record2.userId !== ctx.userId || record2.topicsUserManaged) {
+    if (record3.isDeleted || ctx.userId !== void 0 && record3.userId !== ctx.userId || record3.topicsUserManaged) {
       skip(id2, "excluded");
       continue;
     }
     try {
       const stored2 = await vaultMemoryToStored(
-        record2,
+        record3,
         ctx.walletAddress,
         ctx.signMessage,
         ctx.embeddedWalletSigner
@@ -27999,6 +28499,7 @@ function createLocalMemoryStore(options) {
 
 // src/lib/memory/store/memoryKeys.ts
 var KEY_ID_DOMAIN = "anuma-private-memory-key-id-v1";
+var TOPIC_HASH_INFO = "anuma-private-memory-topic-hash-v1";
 var MemoryKeyError = class extends Error {
   constructor(message) {
     super(message);
@@ -28014,17 +28515,40 @@ async function importAesKey(hex) {
     ["encrypt", "decrypt"]
   );
 }
+async function deriveTopicHashKey(hex) {
+  const material = await crypto.subtle.importKey(
+    "raw",
+    hexToBytes(hex).buffer,
+    { name: "HKDF" },
+    false,
+    ["deriveBits"]
+  );
+  const bits = await crypto.subtle.deriveBits(
+    {
+      name: "HKDF",
+      hash: "SHA-256",
+      salt: new Uint8Array(32),
+      info: new TextEncoder().encode(TOPIC_HASH_INFO)
+    },
+    material,
+    256
+  );
+  return crypto.subtle.importKey("raw", bits, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+}
+function toHex(bytes4) {
+  return Array.from(new Uint8Array(bytes4), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
 async function deriveMemoryKeyRing(signatureHex) {
   const v3Hex = await deriveKeyFromSignatureV3(signatureHex);
   const digest = await crypto.subtle.digest(
     "SHA-256",
     new TextEncoder().encode(`${KEY_ID_DOMAIN}:${v3Hex}`)
   );
-  const keyId = "v3:" + Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
   return {
-    keyId,
+    keyId: "v3:" + toHex(digest),
     v3: await importAesKey(v3Hex),
-    v2: await importAesKey(await deriveKeyFromSignature(signatureHex))
+    v2: await importAesKey(await deriveKeyFromSignature(signatureHex)),
+    topicHash: await deriveTopicHashKey(v3Hex)
   };
 }
 async function decryptWith(value, rings) {
@@ -28045,7 +28569,10 @@ function memoryCipher(canonical) {
       if (!ciphertext.startsWith("enc:v3:") || !isEncrypted(ciphertext))
         throw new MemoryKeyError("Remote memory content must be enc:v3 ciphertext");
       return decryptWith(ciphertext, [canonical]);
-    }
+    },
+    hashTopic: async (normalized2) => toHex(
+      await crypto.subtle.sign("HMAC", canonical.topicHash, new TextEncoder().encode(normalized2))
+    )
   };
 }
 async function reencryptMemoryField(value, canonical, fallbacks = []) {
@@ -28481,8 +29008,9 @@ var DEFAULT_RATE_LIMIT_WAIT_MS = 1e4;
 var MAX_ID_BYTES = 128;
 var MAX_CONTENT_BYTES = 32 << 10;
 var MAX_TEXT_BYTES = 16 << 10;
+var MAX_TOPICS_BYTES = 32 << 10;
 var MAX_SHORT_BYTES = 256;
-var TEXT_FIELDS = ["topics", "media", "source_chunk_ids"];
+var TEXT_FIELDS = ["media", "source_chunk_ids"];
 var SHORT_FIELDS = [
   "scope",
   "kind",
@@ -28585,7 +29113,7 @@ function bytes3(value) {
   return value === void 0 ? 0 : utf82.encode(value).length;
 }
 function fitsNearby(row) {
-  return bytes3(row.memory_id) <= MAX_ID_BYTES && bytes3(row.content) <= MAX_CONTENT_BYTES && bytes3(row.kind_value) <= MAX_CONTENT_BYTES && TEXT_FIELDS.every((field10) => bytes3(row[field10]) <= MAX_TEXT_BYTES) && SHORT_FIELDS.every((field10) => bytes3(row[field10]) <= MAX_SHORT_BYTES);
+  return bytes3(row.memory_id) <= MAX_ID_BYTES && bytes3(row.content) <= MAX_CONTENT_BYTES && bytes3(row.kind_value) <= MAX_CONTENT_BYTES && bytes3(row.topics) <= MAX_TOPICS_BYTES && sealedTopicNamesFit(row.topics) && TEXT_FIELDS.every((field10) => bytes3(row[field10]) <= MAX_TEXT_BYTES) && SHORT_FIELDS.every((field10) => bytes3(row[field10]) <= MAX_SHORT_BYTES);
 }
 function invalid2(raw) {
   const id2 = raw.id;
@@ -28629,7 +29157,7 @@ function defined(value) {
     Object.entries(value).filter(([, field10]) => field10 !== void 0)
   );
 }
-async function prepareRow(raw, canonical, rings, model, updatedAt) {
+async function prepareRow(raw, canonical, codec, rings, model, updatedAt) {
   const deleted = bool(raw.is_deleted) ?? false;
   const { encrypt } = memoryCipher(canonical);
   const localKindValue = text15(raw.kind_value);
@@ -28643,10 +29171,12 @@ async function prepareRow(raw, canonical, rings, model, updatedAt) {
     plaintext = void 0;
     kindValue = void 0;
   }
+  const fields = metadata2(raw, model);
   const row = {
     ...defined({
-      ...metadata2(raw, model),
-      kind_value: kindValue === void 0 ? void 0 : await encrypt(kindValue)
+      ...fields,
+      kind_value: kindValue === void 0 ? void 0 : await encrypt(kindValue),
+      topics: fields.topics === void 0 ? void 0 : await codec.encodeTopics(fields.topics)
     }),
     memory_id: raw.id,
     content: await encrypt(plaintext ?? ""),
@@ -28690,6 +29220,8 @@ function sameMetadata2(local, remote, model) {
     if (field10 === "visibility") return (a ?? "private") === (b ?? "private");
     if (field10 === "is_deleted" || field10 === "topics_user_managed" || field10 === "twin_opt_in")
       return (a ?? false) === (b ?? false);
+    if (field10 === "topics")
+      return JSON.stringify(parseTopics(a)) === JSON.stringify(parseTopics(b));
     return a === b;
   });
 }
@@ -28745,7 +29277,7 @@ async function missingIds(request, revisions, signal) {
   }
   return missing2;
 }
-async function remoteMetadata(request, ids, signal) {
+async function remoteMetadata(request, codec, ids, signal) {
   const rows = /* @__PURE__ */ new Map();
   for (const batch of chunks(ids, QUERY_IDS)) {
     let cursor;
@@ -28769,7 +29301,12 @@ async function remoteMetadata(request, ids, signal) {
       if (!Array.isArray(page.items)) throw new Error("Invalid nearby private-memory page");
       for (const item of page.items)
         if (item.memory && typeof item.memory.memory_id === "string")
-          rows.set(item.memory.memory_id, item.memory);
+          rows.set(item.memory.memory_id, {
+            ...item.memory,
+            ...typeof item.memory.topics === "string" && {
+              topics: await codec.decodeTopics(item.memory.topics).catch(() => null)
+            }
+          });
       cursor = typeof page.next_cursor === "string" ? page.next_cursor : void 0;
     } while (cursor);
   }
@@ -28787,6 +29324,7 @@ async function migrateMemoriesToRemote(options) {
   const rings = [canonical, ...options.fallbacks ?? []];
   const model = options.embeddingOptions?.model ?? DEFAULT_API_EMBEDDING_MODEL;
   const request = createNearbyRequest(options);
+  const codec = createTopicCodec(memoryCipher(canonical));
   const account = await request("/account", {}, signal);
   if (typeof account.key_id === "string" && account.key_id !== canonical.keyId)
     throw new RemoteMemoryError(
@@ -28803,7 +29341,7 @@ async function migrateMemoriesToRemote(options) {
     ...typeof t.kind === "string" && { kind: t.kind }
   })).filter((t) => t.name.length > 0) : []);
   if (localTopics.length)
-    await createRemoteTopicPersistence(request).importTopics(localTopics, signal);
+    await createRemoteTopicPersistence(request, codec).importTopics(localTopics, signal);
   const skipped = /* @__PURE__ */ new Map();
   const reembedded = /* @__PURE__ */ new Set();
   const unembedded = /* @__PURE__ */ new Set();
@@ -28822,6 +29360,7 @@ async function migrateMemoriesToRemote(options) {
       if (pending.size === 0 && !active) {
         const remote = await remoteMetadata(
           request,
+          codec,
           candidates.map((raw) => raw.id),
           signal
         );
@@ -28866,7 +29405,7 @@ async function migrateMemoriesToRemote(options) {
         const updatedAt = pending.get(raw.id);
         if (updatedAt === void 0) continue;
         try {
-          prepared.push(await prepareRow(raw, canonical, rings, model, updatedAt));
+          prepared.push(await prepareRow(raw, canonical, codec, rings, model, updatedAt));
         } catch (error) {
           if (!(error instanceof MemoryKeyError)) throw error;
           skipped.set(raw.id, "unreadable");
@@ -29026,7 +29565,7 @@ function topicInputs(topics, source) {
 function mergeTopics(existing, added) {
   const byName = /* @__PURE__ */ new Map();
   for (const topic2 of [...existing, ...added]) {
-    const key3 = normalizeEntityName(topic2.name);
+    const key3 = normalizeTopicName(topic2.name);
     const kept = byName.get(key3);
     if (!kept) byName.set(key3, topic2);
     else if (kept.weight !== void 0 && topic2.weight !== void 0 && topic2.weight > kept.weight)
@@ -29041,7 +29580,7 @@ function sameTopics(stored2, next) {
   return next.every((t) => keys.has(key3(t)));
 }
 function canonicalTopics(row) {
-  return new Set((parseTopics(row.topics) ?? []).map((topic2) => normalizeEntityName(topic2.name)));
+  return new Set((parseTopics(row.topics) ?? []).map((topic2) => normalizeTopicName(topic2.name)));
 }
 function createRemoteMemoryStore(options) {
   const { persistence, embeddingOptions } = options;
@@ -29088,10 +29627,10 @@ function createRemoteMemoryStore(options) {
   const notify = (change, records = []) => {
     invalidateReads();
     if (subscribers.size)
-      for (const record2 of records) {
-        const previous = seen.get(record2.memory.memory_id);
-        if ((previous?.version ?? 0) + 1 === record2.version)
-          seen.set(record2.memory.memory_id, subscriptionState(record2));
+      for (const record3 of records) {
+        const previous = seen.get(record3.memory.memory_id);
+        if ((previous?.version ?? 0) + 1 === record3.version)
+          seen.set(record3.memory.memory_id, subscriptionState(record3));
       }
     for (const subscriber of [...subscribers])
       if (relevant(change, subscriber.options)) safely(subscriber.onChange);
@@ -29144,7 +29683,7 @@ function createRemoteMemoryStore(options) {
   };
   const enumerate = (filters, max = Infinity) => pages(decrypted, filters, max);
   const memoriesByTopics = async (names) => {
-    const wanted = new Set(names.map(normalizeEntityName).filter(Boolean));
+    const wanted = new Set(names.map(normalizeTopicName).filter(Boolean));
     const out = /* @__PURE__ */ new Map();
     const pages2 = await Promise.all(
       chunks2([...wanted], MAX_QUERY_TOPICS).map((topics) => enumerate({ topics }))
@@ -29156,7 +29695,7 @@ function createRemoteMemoryStore(options) {
     return out;
   };
   const topicGraphRanking = async (query, recallOptions = {}) => {
-    const wanted = new Set(extractQueryEntities(query).map(normalizeEntityName).filter(Boolean));
+    const wanted = new Set(extractQueryEntities(query).map(normalizeTopicName).filter(Boolean));
     if (wanted.size === 0 || recallOptions.memoryIds?.length === 0) return [];
     const rows = await pages(
       metadata3,
@@ -29214,25 +29753,25 @@ function createRemoteMemoryStore(options) {
     return run;
   };
   const live2 = async (id2) => {
-    const record2 = await persistence.get(id2);
-    return record2 && !record2.memory.is_deleted ? record2 : null;
+    const record3 = await persistence.get(id2);
+    return record3 && !record3.memory.is_deleted ? record3 : null;
   };
   const mutateLocked = async (id2, change, edit, writeOptions) => {
     writeOptions?.signal?.throwIfAborted();
-    const record2 = writeOptions?.signal ? await persistence.get(id2, writeOptions.signal) : await live2(id2);
-    if (!record2) return null;
-    if (record2.memory.is_deleted) return null;
+    const record3 = writeOptions?.signal ? await persistence.get(id2, writeOptions.signal) : await live2(id2);
+    if (!record3) return null;
+    if (record3.memory.is_deleted) return null;
     if (writeOptions?.canWrite && !await writeOptions.canWrite())
       throw new MemorySourceIneligibleError();
     writeOptions?.signal?.throwIfAborted();
-    const next = edit(structuredClone(record2.memory));
+    const next = edit(structuredClone(record3.memory));
     if (!next) return null;
     const saved = writeOptions?.leaseToken ? (await persistence.putMany(
-      [{ memory: next, expectedVersion: record2 }],
+      [{ memory: next, expectedVersion: record3 }],
       writeOptions.signal,
       writeOptions.leaseToken
-    ))[0] : writeOptions?.signal ? await persistence.put(next, record2, writeOptions.signal) : await persistence.put(next, record2);
-    notify(typeof change === "function" ? change(record2.memory) : change, [saved]);
+    ))[0] : writeOptions?.signal ? await persistence.put(next, record3, writeOptions.signal) : await persistence.put(next, record3);
+    notify(typeof change === "function" ? change(record3.memory) : change, [saved]);
     return saved;
   };
   const mutate = (id2, change, edit, writeOptions) => serialized(id2, () => mutateLocked(id2, change, edit, writeOptions));
@@ -29254,12 +29793,12 @@ function createRemoteMemoryStore(options) {
         }
         const { records, unreadable } = read;
         for (const id2 of slice) {
-          const record2 = records.get(id2);
+          const record3 = records.get(id2);
           if (unreadable.has(id2)) failed.set(id2, new Error(`Memory ${id2} could not be decrypted`));
-          else if (!record2) failed.set(id2, new Error(`Memory ${id2} was not found`));
-          else if (!record2.memory.is_deleted) {
-            const memory = edit(structuredClone(record2.memory));
-            if (memory) writes.push({ before: record2, memory });
+          else if (!record3) failed.set(id2, new Error(`Memory ${id2} was not found`));
+          else if (!record3.memory.is_deleted) {
+            const memory = edit(structuredClone(record3.memory));
+            if (memory) writes.push({ before: record3, memory });
           }
         }
         if (writes.length === 0) return;
@@ -29270,10 +29809,10 @@ function createRemoteMemoryStore(options) {
             leaseToken
           );
           const byChange = /* @__PURE__ */ new Map();
-          written.forEach((record2, i) => {
-            saved.set(record2.memory.memory_id, record2);
+          written.forEach((record3, i) => {
+            saved.set(record3.memory.memory_id, record3);
             const kind = change(writes[i].before.memory);
-            byChange.set(kind, [...byChange.get(kind) ?? [], record2]);
+            byChange.set(kind, [...byChange.get(kind) ?? [], record3]);
           });
           for (const [kind, changed] of byChange) notify(kind, changed);
         } catch (error) {
@@ -29287,13 +29826,13 @@ function createRemoteMemoryStore(options) {
               continue;
             }
             try {
-              const record2 = await mutateLocked(
+              const record3 = await mutateLocked(
                 id2,
                 change,
                 edit,
                 leaseToken || signal ? { leaseToken, signal } : void 0
               );
-              if (record2) saved.set(id2, record2);
+              if (record3) saved.set(id2, record3);
             } catch (rowError) {
               signal?.throwIfAborted();
               if (isRemoteWorkLeaseExpired(rowError)) throw rowError;
@@ -29389,12 +29928,12 @@ function createRemoteMemoryStore(options) {
   const created = (records, inputs) => {
     embedInBackground(records.filter((_, i) => inputs[i].embedding === void 0));
     notify("membership", records);
-    return records.map((record2) => stored(record2.memory));
+    return records.map((record3) => stored(record3.memory));
   };
-  const asStored = (record2) => record2 ? stored(record2.memory) : null;
+  const asStored = (record3) => record3 ? stored(record3.memory) : null;
   const knownKinds = async (topics, signal) => {
     const unkinded = [
-      ...new Set(topics.filter((t) => !t.kind).map((t) => normalizeEntityName(t.name)))
+      ...new Set(topics.filter((t) => !t.kind).map((t) => normalizeTopicName(t.name)))
     ];
     const kinds2 = /* @__PURE__ */ new Map();
     for (const names of chunks2(unkinded, MAX_QUERY_TOPICS)) {
@@ -29406,13 +29945,13 @@ function createRemoteMemoryStore(options) {
         ...signal && { signal }
       })) {
         for (const topic2 of parseTopics(memory.topics) ?? []) {
-          const name = normalizeEntityName(topic2.name);
+          const name = normalizeTopicName(topic2.name);
           if (topic2.kind && !kinds2.has(name)) kinds2.set(name, topic2.kind);
         }
       }
     }
     return (topic2) => {
-      const kind = topic2.kind ?? kinds2.get(normalizeEntityName(topic2.name));
+      const kind = topic2.kind ?? kinds2.get(normalizeTopicName(topic2.name));
       return kind ? { ...topic2, kind } : topic2;
     };
   };
@@ -29435,7 +29974,7 @@ function createRemoteMemoryStore(options) {
           ...cursor2 && { cursor: cursor2 }
         });
         warnFailed(page.failed);
-        for (const record2 of page.items) records.set(record2.memory.memory_id, record2);
+        for (const record3 of page.items) records.set(record3.memory.memory_id, record3);
         for (const failure of page.failed) unreadable.add(failure.memory_id);
         cursor2 = page.next_cursor;
       } while (cursor2);
@@ -29631,8 +30170,8 @@ function createRemoteMemoryStore(options) {
     const failed = /* @__PURE__ */ new Map();
     const collect = (page) => {
       warnFailed(page.failed);
-      for (const record2 of page.items)
-        records.push({ id: record2.memory.memory_id, state: subscriptionState(record2) });
+      for (const record3 of page.items)
+        records.push({ id: record3.memory.memory_id, state: subscriptionState(record3) });
       for (const failure of page.failed) failed.set(failure.memory_id, failure.version);
     };
     let resume = cursor2;
@@ -29837,7 +30376,7 @@ function createRemoteMemoryStore(options) {
       result.failed += targets.length;
       return finish();
     }
-    const writes = targets.flatMap((record2, i) => {
+    const writes = targets.flatMap((record3, i) => {
       const vector2 = vectors[i];
       if (!vector2) {
         result.failed++;
@@ -29847,11 +30386,11 @@ function createRemoteMemoryStore(options) {
         return [
           {
             memory: {
-              ...record2.memory,
+              ...record3.memory,
               embedding: storedVector(vector2),
               embedding_model: model
             },
-            expectedVersion: record2
+            expectedVersion: record3
           }
         ];
       } catch {
@@ -29866,7 +30405,7 @@ function createRemoteMemoryStore(options) {
           signal?.throwIfAborted();
           const commit = async (slice) => {
             const saved = await persistence.putMany(slice, signal, leaseToken);
-            for (const record2 of saved) repaired.add(record2.memory.memory_id);
+            for (const record3 of saved) repaired.add(record3.memory.memory_id);
             result.reembedded += saved.length;
             notify("embedding", saved);
           };
@@ -29950,7 +30489,7 @@ function createRemoteMemoryStore(options) {
       if (!topics.length) return;
       const existing = new Set((await readTopics()).map((topic2) => topic2.name));
       const missing2 = topics.flatMap((topic2) => {
-        const name = normalizeEntityName(topic2.name);
+        const name = normalizeTopicName(topic2.name);
         if (existing.has(name)) return [];
         existing.add(name);
         return [{ ...topic2, name }];
@@ -29981,7 +30520,7 @@ function createRemoteMemoryStore(options) {
           include_superseded: true
         })) {
           for (const topic2 of parseTopics(memory.topics) ?? []) {
-            const name = normalizeEntityName(topic2.name);
+            const name = normalizeTopicName(topic2.name);
             if (!name) continue;
             const entry = topics.get(name) ?? {
               name,
@@ -30019,7 +30558,7 @@ function createRemoteMemoryStore(options) {
     },
     get: async (id2) => asStored(await live2(id2)),
     listArchived: async () => (await enumerate({ archived_only: true, order: "archived", include_embeddings: true })).map(
-      (record2) => stored(record2.memory)
+      (record3) => stored(record3.memory)
     ),
     memoriesByTopics,
     topicsByMemories: async (memoryIds) => {
@@ -30035,8 +30574,8 @@ function createRemoteMemoryStore(options) {
       return out;
     },
     create: async (input) => {
-      const record2 = await persistence.put(newRow(input), 0);
-      return created([record2], [input])[0];
+      const record3 = await persistence.put(newRow(input), 0);
+      return created([record3], [input])[0];
     },
     createMany: async (inputs) => {
       const out = [];
@@ -30123,12 +30662,12 @@ function createRemoteMemoryStore(options) {
       (memory) => memory.archived_at === void 0 || memory.archived_at === null ? { ...memory, archived_at: Date.now() } : null
     ),
     restore: (id2) => serialized(id2, async () => {
-      const record2 = await live2(id2);
-      if (!record2) return false;
-      if (record2.memory.archived_at === void 0 || record2.memory.archived_at === null)
+      const record3 = await live2(id2);
+      if (!record3) return false;
+      if (record3.memory.archived_at === void 0 || record3.memory.archived_at === null)
         return true;
-      const { archived_at: _archivedAt, ...memory } = record2.memory;
-      notify("edit", [await persistence.put(memory, record2)]);
+      const { archived_at: _archivedAt, ...memory } = record3.memory;
+      notify("edit", [await persistence.put(memory, record3)]);
       return true;
     }),
     setTopics: async (memoryId, topics) => {
@@ -30161,8 +30700,8 @@ function createRemoteMemoryStore(options) {
       const now = /* @__PURE__ */ new Date();
       return mergeTopics([], added).map(
         (topic2) => ({
-          uniqueId: normalizeEntityName(topic2.name),
-          canonicalName: normalizeEntityName(topic2.name),
+          uniqueId: normalizeTopicName(topic2.name),
+          canonicalName: normalizeTopicName(topic2.name),
           kind: topic2.kind ?? null,
           createdAt: now,
           updatedAt: now
@@ -33539,16 +34078,16 @@ var ZipProcessor = class {
     try {
       const arrayBuffer = await dataUrlToArrayBuffer(file.dataUrl);
       const zip = await import_jszip.default.loadAsync(arrayBuffer);
-      const entries = [];
+      const entries2 = [];
       const processedContents = [];
       zip.forEach((relativePath, zipEntry) => {
-        entries.push({
+        entries2.push({
           path: relativePath,
           isDirectory: zipEntry.dir,
           zipObject: zipEntry
         });
       });
-      const visibleEntries = this.includeHidden ? entries : entries.filter((entry) => !this.isHidden(entry.path));
+      const visibleEntries = this.includeHidden ? entries2 : entries2.filter((entry) => !this.isHidden(entry.path));
       visibleEntries.sort((a, b) => {
         if (a.isDirectory !== b.isDirectory) {
           return a.isDirectory ? -1 : 1;
@@ -33662,17 +34201,17 @@ var ZipProcessor = class {
   /**
    * Format the output with file listing and processed contents
    */
-  formatOutput(entries, processedContents) {
+  formatOutput(entries2, processedContents) {
     const lines = [];
     lines.push("## Archive Contents\n");
     lines.push("```");
-    for (const entry of entries) {
+    for (const entry of entries2) {
       const icon = entry.isDirectory ? "\u{1F4C1}" : "\u{1F4C4}";
       lines.push(`${icon} ${entry.path}`);
     }
     lines.push("```\n");
-    const fileCount = entries.filter((e) => !e.isDirectory).length;
-    const dirCount = entries.filter((e) => e.isDirectory).length;
+    const fileCount = entries2.filter((e) => !e.isDirectory).length;
+    const dirCount = entries2.filter((e) => e.isDirectory).length;
     lines.push(
       `**Summary:** ${fileCount} file${fileCount !== 1 ? "s" : ""}, ${dirCount} director${dirCount !== 1 ? "ies" : "y"}
 `
@@ -34856,13 +35395,13 @@ function serializeInline(node) {
 function openTag(node, indent, depth, selfClose, maxLineWidth) {
   const head = `<${tagName(node.tag)}`;
   const tail = selfClose ? " />" : ">";
-  const entries = Object.entries(node.attrs);
-  if (entries.length === 0) return `${head}${tail}`;
-  const single = `${head} ${entries.map(([k, v]) => formatAttr(k, v)).join(" ")}${tail}`;
+  const entries2 = Object.entries(node.attrs);
+  if (entries2.length === 0) return `${head}${tail}`;
+  const single = `${head} ${entries2.map(([k, v]) => formatAttr(k, v)).join(" ")}${tail}`;
   if (single.length <= maxLineWidth) return single;
   const attrPad = indent.repeat(depth + 1);
   const closePad = indent.repeat(depth);
-  const body = entries.map(([k, v]) => `${attrPad}${formatAttr(k, v)}`).join("\n");
+  const body = entries2.map(([k, v]) => `${attrPad}${formatAttr(k, v)}`).join("\n");
   return `${head}
 ${body}
 ${closePad}${selfClose ? "/>" : ">"}`;
@@ -34874,13 +35413,13 @@ function formatAttr(name, value) {
   return `${name}={${formatObjectAttr(value)}}`;
 }
 function formatObjectAttr(obj) {
-  const entries = Object.entries(obj).map(([k, v]) => {
+  const entries2 = Object.entries(obj).map(([k, v]) => {
     const key3 = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(k) ? k : JSON.stringify(k);
     if (typeof v === "string") return `${key3}: ${JSON.stringify(v)}`;
     if (typeof v === "number") return `${key3}: ${String(v)}`;
     return `${key3}: ${v ? "true" : "false"}`;
   });
-  return `{ ${entries.join(", ")} }`;
+  return `{ ${entries2.join(", ")} }`;
 }
 function isSafeJsxText(text16) {
   if (/[<>{}&]/.test(text16)) return false;
@@ -36267,7 +36806,7 @@ async function uploadFileToICloud(filename, content, backupRevision) {
   const recordName = `backup_${filename.replace(/[^a-zA-Z0-9]/g, "_")}`;
   const arrayBuffer = await content.arrayBuffer();
   const base64Data = uint8ArrayToBase64(new Uint8Array(arrayBuffer));
-  const record2 = {
+  const record3 = {
     recordType: RECORD_TYPE,
     recordName,
     fields: {
@@ -36278,7 +36817,7 @@ async function uploadFileToICloud(filename, content, backupRevision) {
       ...backupRevision ? { backupRevision: { value: backupRevision } } : {}
     }
   };
-  const response = await database.saveRecords(record2);
+  const response = await database.saveRecords(record3);
   if (!response.records || response.records.length === 0) {
     throw new Error("Failed to upload file to iCloud");
   }
@@ -36305,12 +36844,12 @@ async function listICloudFiles() {
   while (response.continuationMarker) {
     break;
   }
-  const files = allRecords.map((record2) => ({
-    recordName: record2.recordName,
-    filename: record2.fields.filename?.value ?? "",
-    modifiedAt: new Date(record2.modified?.timestamp ?? Date.now()),
-    backupRevision: record2.fields.backupRevision?.value,
-    size: typeof record2.fields.data?.value === "object" && record2.fields.data?.value !== null ? record2.fields.data.value.size : 0
+  const files = allRecords.map((record3) => ({
+    recordName: record3.recordName,
+    filename: record3.fields.filename?.value ?? "",
+    modifiedAt: new Date(record3.modified?.timestamp ?? Date.now()),
+    backupRevision: record3.fields.backupRevision?.value,
+    size: typeof record3.fields.data?.value === "object" && record3.fields.data?.value !== null ? record3.fields.data.value.size : 0
   }));
   return files.sort((a, b) => b.modifiedAt.getTime() - a.modifiedAt.getTime());
 }
@@ -36323,8 +36862,8 @@ async function downloadICloudFile(recordName) {
   if (!response.records || response.records.length === 0) {
     throw new Error(`File not found: ${recordName}`);
   }
-  const record2 = response.records[0];
-  const dataField = record2.fields.data?.value;
+  const record3 = response.records[0];
+  const dataField = record3.fields.data?.value;
   if (!dataField) {
     throw new Error("No data in record");
   }
@@ -36358,13 +36897,13 @@ async function findICloudFile(filename) {
   if (!response.records || response.records.length === 0) {
     return null;
   }
-  const record2 = response.records[0];
+  const record3 = response.records[0];
   return {
-    recordName: record2.recordName,
-    filename: record2.fields.filename?.value ?? "",
-    modifiedAt: new Date(record2.modified?.timestamp ?? Date.now()),
-    backupRevision: record2.fields.backupRevision?.value,
-    size: typeof record2.fields.data?.value === "object" && record2.fields.data?.value !== null ? record2.fields.data.value.size : 0
+    recordName: record3.recordName,
+    filename: record3.fields.filename?.value ?? "",
+    modifiedAt: new Date(record3.modified?.timestamp ?? Date.now()),
+    backupRevision: record3.fields.backupRevision?.value,
+    size: typeof record3.fields.data?.value === "object" && record3.fields.data?.value !== null ? record3.fields.data.value.size : 0
   };
 }
 
@@ -37720,13 +38259,13 @@ function useConversationRedactors(database, account, storage, secondaryStorage)
   return (0, import_react5.useCallback)(
     (conversationId, nerDetector) => {
       if (!scope.active) return retiredRedactor;
-      const cached = scope.redactors.get(conversationId);
-      if (cached && cached.detector === nerDetector) {
+      const cached2 = scope.redactors.get(conversationId);
+      if (cached2 && cached2.detector === nerDetector) {
         scope.redactors.delete(conversationId);
-        scope.redactors.set(conversationId, cached);
-        return cached.redactor;
+        scope.redactors.set(conversationId, cached2);
+        return cached2.redactor;
       }
-      if (cached) scope.evicted.push(cached.redactor);
+      if (cached2) scope.evicted.push(cached2.redactor);
       const redactor = new PiiRedactor({ nerDetector });
       scope.redactors.set(conversationId, { redactor, detector: nerDetector });
       if (scope.redactors.size > REDACTOR_LIMIT) {
@@ -40184,82 +40723,45 @@ function useChatStorage(options) {
       await inbox.putPublicKey(publicKey);
       registeredInboxKeyRef.current = { inbox, publicKey };
     }
-    const results = [];
-    for (const item of await inbox.list()) {
-      let opened;
-      try {
-        opened = await openInboxItem(item, keyPair);
-      } catch (err) {
-        results.push({
-          id: item.id,
-          conversationId: null,
-          status: "unreadable",
-          assistantMessage: null,
-          error: err instanceof Error ? err.message : String(err)
+    return deliverInboxAnswers({
+      inbox,
+      keyPair,
+      backend,
+      store: async (opened, messageId) => {
+        const { redactor } = resolveCallPii(
+          void 0,
+          piiRedaction,
+          () => getConversationRedactor(opened.conversation_id, nerDetectorRef.current)
+        );
+        const knownToolCallEventIds = await backend.getToolCallEventIds(opened.conversation_id);
+        const { fields, fileIds } = await toAssistantMessageFields(
+          opened.response,
+          opened.conversation_id,
+          knownToolCallEventIds
+        );
+        const upserted = await backend.upsertMessage({
+          ...fields,
+          content: redactor ? redactor.deAnonymize(fields.content) : fields.content,
+          thinking: redactor && fields.thinking ? redactor.deAnonymize(fields.thinking) : fields.thinking,
+          conversationId: opened.conversation_id,
+          role: "assistant",
+          model: opened.model,
+          parentMessageId: opened.parent_message_id ?? void 0,
+          wasStopped: opened.status === "tool_request",
+          uniqueId: messageId
         });
-        continue;
-      }
-      const base = { id: item.id, conversationId: opened.conversation_id };
-      try {
-        const messageId = opened.assistant_message_id ?? `msg_bg_${opened.inference_id}`;
-        const [existing] = await backend.getMessagesByIds([messageId]);
-        if (!existing) {
-          const parent = opened.parent_message_id;
-          const ownsTurn = parent ? (await backend.getMessagesByIds([parent])).length > 0 : await backend.getConversation(opened.conversation_id) !== null;
-          if (!ownsTurn) {
-            results.push({ ...base, status: "elsewhere", assistantMessage: null });
-            continue;
-          }
-        }
-        let stored2 = existing;
-        if (!stored2) {
-          const { redactor } = resolveCallPii(
-            void 0,
-            piiRedaction,
-            () => getConversationRedactor(opened.conversation_id, nerDetectorRef.current)
-          );
-          const knownToolCallEventIds = await backend.getToolCallEventIds(opened.conversation_id);
-          const { fields, fileIds } = await toAssistantMessageFields(
-            opened.response,
-            opened.conversation_id,
-            knownToolCallEventIds
-          );
-          stored2 = await backend.createMessage({
-            ...fields,
-            content: redactor ? redactor.deAnonymize(fields.content) : fields.content,
-            thinking: redactor && fields.thinking ? redactor.deAnonymize(fields.thinking) : fields.thinking,
-            conversationId: opened.conversation_id,
-            role: "assistant",
-            model: opened.model,
-            parentMessageId: opened.parent_message_id ?? void 0,
-            wasStopped: opened.status === "tool_request" ? true : void 0,
-            uniqueId: messageId
-          });
-          if (fileIds.length > 0) {
-            try {
-              await updateMediaMessageIdBatchOp(mediaCtx, fileIds, stored2.uniqueId);
-            } catch (err) {
-              getLogger().warn("[useChatStorage] Failed to link inbox media:", err);
-            }
+        const stored2 = await clearTurnErrors(backend, upserted);
+        if (fileIds.length > 0) {
+          try {
+            await updateMediaMessageIdBatchOp(mediaCtx, fileIds, stored2.uniqueId);
+          } catch (err) {
+            getLogger().warn("[useChatStorage] Failed to link inbox media:", err);
           }
-          void embedMessageAsync(stored2, (text16) => redactor ? redactor.maskText(text16) : text16);
         }
-        await inbox.remove(item.id);
-        results.push({
-          ...base,
-          status: existing ? "delivered" : "stored",
-          assistantMessage: stored2
-        });
-      } catch (err) {
-        results.push({
-          ...base,
-          status: "retry",
-          assistantMessage: null,
-          error: err instanceof Error ? err.message : String(err)
-        });
+        void embedMessageAsync(stored2, (text16) => redactor ? redactor.maskText(text16) : text16);
+        return stored2;
       }
-    }
-    return results;
+    });
   }, [
     inbox,
     walletAddress,
@@ -41255,11 +41757,11 @@ async function fetchAllModelPages(baseUrl, provider, headers, previous, signal)
   return { pages, models, fetchedAt: Date.now() };
 }
 function loadModels(key3, baseUrl, provider, headers, force, signal) {
-  const cached = modelsCache.get(key3);
-  if (cached && !force && Date.now() - cached.fetchedAt < MODELS_CACHE_TTL_MS) {
-    return Promise.resolve([...cached.models]);
+  const cached2 = modelsCache.get(key3);
+  if (cached2 && !force && Date.now() - cached2.fetchedAt < MODELS_CACHE_TTL_MS) {
+    return Promise.resolve([...cached2.models]);
   }
-  const shared = (force ? void 0 : modelsInFlight.get(key3)) ?? startSharedRequest(key3, baseUrl, provider, headers, cached);
+  const shared = (force ? void 0 : modelsInFlight.get(key3)) ?? startSharedRequest(key3, baseUrl, provider, headers, cached2);
   return waitForSharedRequest(key3, shared, signal).then((models) => [...models]);
 }
 function startSharedRequest(key3, baseUrl, provider, headers, previous) {
@@ -42116,20 +42618,20 @@ function startObserve(entry, walletAddress) {
     "updated_at"
   ]).subscribe({
     next: (records) => {
-      const record2 = records[0];
-      if (!record2) return;
+      const record3 = records[0];
+      if (!record3) return;
       const patch = {
         userPreference: {
-          uniqueId: record2.id,
-          walletAddress: record2.walletAddress,
-          nickname: record2.nickname,
-          occupation: record2.occupation,
-          description: record2.description,
-          models: record2.models,
-          personality: record2.personality,
-          externalWallets: record2.externalWallets,
-          createdAt: record2.createdAt,
-          updatedAt: record2.updatedAt
+          uniqueId: record3.id,
+          walletAddress: record3.walletAddress,
+          nickname: record3.nickname,
+          occupation: record3.occupation,
+          description: record3.description,
+          models: record3.models,
+          personality: record3.personality,
+          externalWallets: record3.externalWallets,
+          createdAt: record3.createdAt,
+          updatedAt: record3.updatedAt
         }
       };
       if (isInitialEmission) {