@anuma/sdk 10.10.0 → 11.0.0

package/dist/expo/index.mjs

@@ -214,25 +214,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--;
   }
@@ -934,9 +934,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) {
@@ -1901,11 +1901,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")
         );
       }
     });
@@ -3316,15 +3316,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) {
@@ -3337,8 +3337,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,
@@ -4151,11 +4151,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();
@@ -4583,9 +4583,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]);
@@ -4700,10 +4700,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;
       }
     }
@@ -5144,58 +5144,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
+          })
         })
       );
+      const decoded = await codec.decodeCatalog(saved);
+      legacyOnly.delete(decoded.name);
+      return decoded;
     },
-    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
-        );
-      }
+    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;
@@ -5283,7 +5562,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,
@@ -5343,7 +5625,8 @@ var queryFields = [
   "fact_types",
   "visibility",
   "memory_ids",
-  "topics",
+  "topic_hashes",
+  "topics_legacy",
   "updated_after",
   "topics_due",
   "topics_extracted",
@@ -5353,11 +5636,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;
@@ -5437,14 +5726,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;
@@ -5467,7 +5756,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,
@@ -5481,6 +5770,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);
@@ -5498,6 +5806,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)
         }
       }
     };
@@ -5509,8 +5820,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;
   };
@@ -5532,7 +5845,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(
       {
@@ -5540,7 +5853,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
@@ -5592,13 +5906,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) => {
@@ -5647,32 +5969,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;
   };
@@ -5686,13 +6048,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");
@@ -5709,8 +6071,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);
@@ -5741,7 +6103,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 {
@@ -5781,7 +6143,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])));
     },
@@ -5796,20 +6158,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
@@ -6283,9 +6712,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;
@@ -6329,8 +6758,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) {
@@ -6393,33 +6822,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 import("./clientConfig-VPOGQRNP.mjs");
     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;
     }
@@ -6427,9 +6856,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 [];
   }
@@ -7515,13 +7944,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 = {};
@@ -10985,21 +11414,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 } : {}
   };
@@ -11021,21 +11450,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) {
@@ -11056,15 +11485,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) {
@@ -11090,10 +11519,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)
@@ -11102,24 +11531,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;
@@ -11163,8 +11592,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;
@@ -11217,19 +11646,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())
             }
           }
         ],
@@ -11264,22 +11693,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(Q4.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 {
@@ -11298,7 +11727,7 @@ async function getConversationSummaryOp(ctx, conversationId) {
         ctx.embeddedWalletSigner
       );
       await ctx.database.write(async () => {
-        const current = await ctx.summariesCollection.query(Q4.where("id", record2.id)).fetch();
+        const current = await ctx.summariesCollection.query(Q4.where("id", record3.id)).fetch();
         if (current[0]?.summary === stored2.summary) {
           await current[0].update((rec) => {
             rec.summary = encryptedSummary;
@@ -11313,19 +11742,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(Q4.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;
@@ -11333,13 +11762,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(Q4.where("conversation_id", conversationId)).fetch();
-    for (const record2 of existing) {
-      await record2.destroyPermanently();
+    for (const record3 of existing) {
+      await record3.destroyPermanently();
     }
   });
 }
@@ -11415,7 +11844,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,
@@ -11429,7 +11858,7 @@ function messageRecord(message) {
     }
   });
   return {
-    record: record2,
+    record: record3,
     ...embeddings2 ? { embeddings: embeddings2 } : {},
     ...embeddings2 && message.embeddingModel ? { embeddingModel: message.embeddingModel } : {}
   };
@@ -11577,15 +12006,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
   };
 }
@@ -11642,10 +12071,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();
@@ -12009,8 +12438,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);
@@ -12139,11 +12568,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
     );
@@ -12183,14 +12612,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
     };
@@ -12539,8 +12968,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;
@@ -12569,8 +12998,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) {
@@ -12778,14 +13207,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;
@@ -12919,11 +13348,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));
@@ -12934,10 +13363,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;
   };
@@ -12948,7 +13377,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) => {
@@ -13262,17 +13691,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 = [];
@@ -13423,8 +13852,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();
@@ -13461,19 +13890,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;
   };
@@ -13498,12 +13927,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());
     },
@@ -13542,13 +13971,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 });
@@ -13584,8 +14013,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) {
@@ -13593,8 +14022,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")
@@ -13687,21 +14116,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) {
@@ -13714,13 +14143,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
           });
@@ -13759,8 +14188,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);
@@ -13776,8 +14205,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,
@@ -13787,8 +14216,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;
@@ -13803,8 +14232,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,
@@ -13822,8 +14251,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;
@@ -13847,15 +14276,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 };
     },
@@ -13874,8 +14303,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;
@@ -13949,10 +14378,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;
@@ -15374,9 +15803,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) {
@@ -15568,25 +15997,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);
     })
   );
@@ -15714,10 +16143,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(
@@ -15787,10 +16216,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()),
@@ -15942,8 +16371,8 @@ function visibilityConditions(requested) {
   if (excluded.length === 0) return [];
   return [Q6.or(Q6.where("visibility", null), Q6.where("visibility", Q6.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()) {
@@ -15997,8 +16426,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 [
@@ -16081,43 +16510,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) {
@@ -16132,7 +16561,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);
@@ -16159,7 +16588,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);
@@ -16244,7 +16673,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);
@@ -16252,16 +16681,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
@@ -16600,29 +17029,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);
@@ -16689,7 +17118,7 @@ async function updateVaultMemoryOp(ctx, id2, opts) {
     });
     if (stale) return null;
     return vaultMemoryToStored(
-      record2,
+      record3,
       ctx.walletAddress,
       ctx.signMessage,
       ctx.embeddedWalletSigner
@@ -16704,22 +17133,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);
     });
@@ -16743,26 +17172,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);
@@ -16771,23 +17200,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);
@@ -16801,20 +17230,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);
       });
     });
@@ -16833,9 +17262,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);
@@ -16848,7 +17277,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;
       }
@@ -16856,7 +17285,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());
       });
@@ -16875,7 +17304,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;
@@ -17036,17 +17465,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);
     });
   }
@@ -17062,14 +17491,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);
@@ -17095,18 +17524,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(Q6.where("memory_id", Q6.oneOf(records.map((record2) => record2.id)))).unsafeFetchRaw();
+      const links2 = await entityCtx.memoryEntityCollection.query(Q6.where("memory_id", Q6.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) {
@@ -17126,13 +17555,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
@@ -17154,7 +17583,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);
       })
     );
@@ -17225,22 +17654,22 @@ async function applyDecayTransitionsOp(ctx, candidates, opts) {
           Q6.where("id", Q6.oneOf(ids.slice(i, i + CHUNK))),
           ...ctx.userId !== void 0 ? [Q6.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;
@@ -17258,21 +17687,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);
       });
     });
@@ -17283,16 +17712,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);
       });
     });
@@ -17303,18 +17732,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);
       });
     });
@@ -17332,14 +17761,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
@@ -17349,11 +17778,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);
@@ -17517,26 +17946,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);
         }
       })
     );
@@ -17900,11 +18329,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);
@@ -17915,14 +18344,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(Q8.where("folder_id", id2), Q8.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);
         })
@@ -17945,8 +18374,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(Q8.where("folder_id", id2), Q8.where("is_deleted", false)).fetch();
       const preparedMemories = memories.map(
@@ -17956,7 +18385,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);
@@ -18003,11 +18432,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);
         })
       );
@@ -19101,9 +19530,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);
@@ -19144,7 +19573,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),
@@ -19161,16 +19590,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) => {
@@ -19870,10 +20299,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++;
@@ -20171,12 +20600,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) {
@@ -21860,9 +22289,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++;
@@ -23685,21 +24114,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
@@ -24006,6 +24435,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);
@@ -24021,17 +24451,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) {
@@ -24052,7 +24505,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 = []) {
@@ -24484,8 +24940,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",
@@ -24588,7 +25045,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;
@@ -24632,7 +25089,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);
@@ -24646,10 +25103,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 ?? ""),
@@ -24693,6 +25152,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;
   });
 }
@@ -24748,7 +25209,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;
@@ -24772,7 +25233,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);
   }
@@ -24790,6 +25256,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(
@@ -24806,7 +25273,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();
@@ -24825,6 +25292,7 @@ async function migrateMemoriesToRemote(options) {
       if (pending.size === 0 && !active) {
         const remote = await remoteMetadata(
           request,
+          codec,
           candidates.map((raw) => raw.id),
           signal
         );
@@ -24869,7 +25337,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");
@@ -25028,7 +25496,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)
@@ -25043,7 +25511,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;
@@ -25090,10 +25558,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);
@@ -25146,7 +25614,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 }))
@@ -25158,7 +25626,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,
@@ -25216,25 +25684,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));
@@ -25256,12 +25724,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;
@@ -25272,10 +25740,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) {
@@ -25289,13 +25757,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;
@@ -25391,12 +25859,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)) {
@@ -25408,13 +25876,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;
     };
   };
@@ -25437,7 +25905,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);
@@ -25633,8 +26101,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;
@@ -25839,7 +26307,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++;
@@ -25849,11 +26317,11 @@ function createRemoteMemoryStore(options) {
         return [
           {
             memory: {
-              ...record2.memory,
+              ...record3.memory,
               embedding: storedVector(vector2),
               embedding_model: model
             },
-            expectedVersion: record2
+            expectedVersion: record3
           }
         ];
       } catch {
@@ -25868,7 +26336,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);
           };
@@ -25952,7 +26420,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 }];
@@ -25983,7 +26451,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,
@@ -26021,7 +26489,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) => {
@@ -26037,8 +26505,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 = [];
@@ -26125,12 +26593,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) => {
@@ -26163,8 +26631,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
@@ -29038,11 +29506,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) {
@@ -29286,9 +29754,9 @@ async function initializeMCPSession(accessToken) {
   return sessionId;
 }
 async function ensureMCPSession(accessToken) {
-  const cached = sessionCache.get(accessToken);
-  if (cached) {
-    return cached;
+  const cached2 = sessionCache.get(accessToken);
+  if (cached2) {
+    return cached2;
   }
   return initializeMCPSession(accessToken);
 }
@@ -31262,13 +31730,13 @@ function useConversationRedactors(database, account, storage, secondaryStorage)
   return useCallback4(
     (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) {