@anuma/sdk 8.2.0 → 9.0.0

package/dist/react/index.mjs

@@ -4946,11 +4946,17 @@ async function generateEmbeddingsBatch(texts, headers, baseUrl, model, onUsage,
   }
   return response.data.data.map((item) => item.embedding ?? []);
 }
-async function generateEmbeddings(texts, options) {
+async function generateEmbeddings(texts, options, signal) {
+  signal?.throwIfAborted();
   if (texts.length === 0) return [];
   const total = options.totalTimeoutMs;
-  if (total === void 0) return embedMany(texts, options, void 0);
-  return withDeadline((signal) => embedMany(texts, options, signal), total, "embedding batch");
+  if (total === void 0) return embedMany(texts, options, signal);
+  return withDeadline(
+    (inner) => embedMany(texts, options, inner),
+    total,
+    "embedding batch",
+    signal
+  );
 }
 async function embedMany(texts, options, outer) {
   const { baseUrl = BASE_URL, model, batchSize, cache } = options;
@@ -10745,13 +10751,13 @@ function normalizeEntityName(name) {
   return name.trim().toLowerCase();
 }
 var TOPIC_SALIENCE_WEIGHTS = { primary: 1, secondary: 0.6, mention: 0.3 };
-function topicWeight(topic) {
-  return topic.source === "user" ? 1 : topic.weight ?? 1;
+function topicWeight(topic2) {
+  return topic2.source === "user" ? 1 : topic2.weight ?? 1;
 }
 function primaryTopic(topics) {
   let best = null;
-  for (const topic of topics ?? []) {
-    if (best === null || topicWeight(topic) > topicWeight(best)) best = topic;
+  for (const topic2 of topics ?? []) {
+    if (best === null || topicWeight(topic2) > topicWeight(best)) best = topic2;
   }
   return best;
 }
@@ -10889,7 +10895,7 @@ function resolveTopicsWrite(row, linked, inputs, source, mode) {
 }
 function weightsOf(stored2, inputs) {
   const out = /* @__PURE__ */ new Map();
-  for (const topic of stored2 ?? []) out.set(normalizeEntityName(topic.name), topic.weight);
+  for (const topic2 of stored2 ?? []) out.set(normalizeEntityName(topic2.name), topic2.weight);
   for (const input of inputs) {
     const weight = parseTopicWeight(input.weight);
     if (weight === void 0) continue;
@@ -14035,6 +14041,20 @@ async function getAllVaultMemoryContentsOp(ctx, options) {
 async function countActiveVaultMemoriesOp(ctx) {
   return ctx.vaultMemoryCollection.query(...baseVaultConditions(ctx)).fetchCount();
 }
+async function getVaultMemoryCountsOp(ctx) {
+  const [live, archived, quarantined] = await Promise.all([
+    countActiveVaultMemoriesOp(ctx),
+    ctx.vaultMemoryCollection.query(
+      ...baseVaultConditions(ctx, { includeArchived: true }),
+      Q9.where("archived_at", Q9.notEq(null))
+    ).fetchCount(),
+    ctx.vaultMemoryCollection.query(
+      ...baseVaultConditions(ctx, { includeQuarantined: true }),
+      Q9.where("trust_tier", "quarantined")
+    ).fetchCount()
+  ]);
+  return { live, archived, quarantined };
+}
 async function getActiveVaultMemoryIdsOp(ctx, ids) {
   if (ids.length === 0) return /* @__PURE__ */ new Set();
   const rows = await ctx.vaultMemoryCollection.query(...baseVaultConditions(ctx), Q9.where("id", Q9.oneOf(ids))).unsafeFetchRaw();
@@ -21190,7 +21210,8 @@ Each memory below is written as "<id>: <text>". Output strict JSON: {"memories":
 - exactly one element per input memory; copy its id EXACTLY as written (the token before the first ": "), with no brackets, quotes, or extra characters
 - "entities" may be empty when a memory mentions no named entities \u2014 most short memories have 0-3
 No prose.`;
-async function extractEntitiesForMemories(memories, options) {
+async function extractEntitiesForMemories(memories, options, signal) {
+  signal?.throwIfAborted();
   const out = /* @__PURE__ */ new Map();
   if (memories.length === 0) return out;
   const redactor = resolvePiiRedactor(options.piiRedaction);
@@ -21203,6 +21224,7 @@ When a memory refers to one of these, reuse the EXACT existing name (same spelli
 
 ` : "";
   for (let i = 0; i < memories.length; i += TOPIC_EXTRACTION_BATCH_SIZE) {
+    signal?.throwIfAborted();
     const batch = memories.slice(i, i + TOPIC_EXTRACTION_BATCH_SIZE);
     const start = Date.now();
     let attempts = 0;
@@ -21250,6 +21272,7 @@ List each memory's named entities.`,
       ...options.totalTimeoutMs !== void 0 && { totalTimeoutMs: options.totalTimeoutMs },
       ...options.backoffMs && { backoffMs: options.backoffMs }
     });
+    signal?.throwIfAborted();
     if (parsed === null) {
       reportBatch(batch.length);
       getLogger().warn(
@@ -21484,6 +21507,7 @@ function createLocalMemoryStore(options) {
     backfillTopics: (memoryIds) => backfillMemoryTopicsOp(vaultCtx, memoryIds)
   };
   return {
+    counts: () => getVaultMemoryCountsOp(vaultCtx),
     masksEmbeddingInput: options.embeddingOptions.maskInput !== void 0,
     list: (listOptions) => getAllVaultMemoriesOp(vaultCtx, listOptions),
     get: (id) => getVaultMemoryOp(vaultCtx, id),
@@ -21708,6 +21732,134 @@ async function decryptMemoryField(value, rings) {
   return decryptWith(value, rings);
 }
 
+// src/lib/memory/store/remoteTopics.ts
+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")
+    throw new Error("Invalid nearby topic");
+  return t;
+}
+function createRemoteTopicPersistence(request) {
+  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;
+    },
+    putTopic: async (value, expectedVersion) => {
+      if (!Number.isSafeInteger(expectedVersion) || expectedVersion < 0)
+        throw new Error("Expected topic version must be a nonnegative integer");
+      return topic(
+        await request("/topics", {
+          method: "PUT",
+          body: JSON.stringify({ topic: value, expected_version: expectedVersion })
+        })
+      );
+    },
+    importTopics: async (topics, signal) => {
+      for (let i = 0; i < topics.length; i += 50) {
+        signal?.throwIfAborted();
+        await request(
+          "/topics/import",
+          {
+            method: "POST",
+            body: JSON.stringify({ topics: topics.slice(i, i + 50) })
+          },
+          signal
+        );
+      }
+      signal?.throwIfAborted();
+    }
+  };
+}
+async function createRemoteTopic(persistence, name) {
+  const canonical = normalizeEntityName(name);
+  if (!canonical) return null;
+  const existing = (await persistence.topics()).find((t) => t.name === canonical);
+  if (existing && !existing.is_deleted) return canonical;
+  try {
+    await persistence.putTopic(
+      { name: canonical, is_deleted: false, ...existing?.kind && { kind: existing.kind } },
+      existing?.version ?? 0
+    );
+  } catch (error) {
+    if (!(error instanceof RemoteMemoryError) || error.code !== "version_conflict") throw error;
+    const current = (await persistence.topics()).find((t) => t.name === canonical);
+    if (!current || current.is_deleted) throw error;
+  }
+  return canonical;
+}
+
+// src/lib/memory/store/remoteWork.ts
+function createRemoteWorkPersistence(request) {
+  return {
+    claimWork: async (kind, processorVersion, token) => {
+      const result = await request("/work/claim", {
+        method: "POST",
+        body: JSON.stringify({
+          kind,
+          processor_version: processorVersion,
+          ...token && { token }
+        })
+      });
+      if (!result || typeof result !== "object") throw new Error("Invalid nearby work lease");
+      const lease = result.lease;
+      if (lease === void 0) return null;
+      if (!lease || lease.kind !== kind || typeof lease.token !== "string" || !lease.token || lease.processor_version !== processorVersion || typeof lease.expires_at !== "string" || !Number.isFinite(Date.parse(lease.expires_at)))
+        throw new Error("Invalid nearby work lease");
+      return lease;
+    },
+    releaseWork: async (kind, token) => {
+      await request("/work/release", { method: "POST", body: JSON.stringify({ kind, token }) });
+    }
+  };
+}
+async function withRemoteWorkLease(persistence, kind, processorVersion, task) {
+  const lease = await persistence.claimWork(kind, processorVersion);
+  if (!lease) return null;
+  const controller = new AbortController();
+  const leaseLostError = new RemoteMemoryError("Maintenance lease lost", 409, "work_lease_expired");
+  const cancelled = new Promise((_resolve, reject) => {
+    controller.signal.addEventListener("abort", () => reject(leaseLostError), {
+      once: true
+    });
+  });
+  let renewing;
+  const timer = setInterval(() => {
+    if (renewing || controller.signal.aborted) return;
+    renewing = persistence.claimWork(kind, processorVersion, lease.token).then((renewed) => {
+      if (!renewed) controller.abort(leaseLostError);
+    }).catch((error) => getLogger().warn("[memory/work] Lease renewal failed:", error)).finally(() => {
+      renewing = void 0;
+    });
+  }, 3e4);
+  try {
+    const result = await Promise.race([task(lease.token, controller.signal), cancelled]);
+    await renewing;
+    return controller.signal.aborted ? null : result;
+  } catch (error) {
+    if (controller.signal.aborted || isRemoteWorkLeaseExpired(error)) return null;
+    throw error;
+  } finally {
+    clearInterval(timer);
+    await renewing;
+    await persistence.releaseWork(kind, lease.token).catch((error) => getLogger().warn("[memory/work] Lease release failed:", error));
+  }
+}
+function isRemoteWorkLeaseExpired(error) {
+  return error instanceof RemoteMemoryError && error.code === "work_lease_expired";
+}
+
 // src/lib/memory/store/remotePersistence.ts
 var RemoteMemoryError = class extends Error {
   constructor(message, status, code, retryAfterMs) {
@@ -22087,6 +22239,33 @@ async function createRemoteMemoryPersistence(options) {
     };
   };
   return {
+    ...createRemoteTopicPersistence(request),
+    ...createRemoteWorkPersistence(request),
+    counts: async () => {
+      const result = await request("/counts", {});
+      if (!record(result) || ["live", "archived", "quarantined"].some(
+        (key) => !Number.isSafeInteger(result[key]) || result[key] < 0
+      ))
+        throw new Error("Invalid nearby memory counts");
+      return {
+        live: result.live,
+        archived: result.archived,
+        quarantined: result.quarantined
+      };
+    },
+    temporal: async (window2, limit = 100) => {
+      if (!Number.isFinite(window2.start) || !Number.isFinite(window2.end) || window2.end <= window2.start || !Number.isInteger(limit) || limit < 1 || limit > 100)
+        throw new Error("Temporal window must have end > start and limit must be 1\u2013100");
+      const result = await request("/temporal", {
+        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
+      ))
+        throw new Error("Invalid nearby temporal candidates");
+      return result.items.map((item) => item.memory_id);
+    },
     get: async (id, signal) => {
       try {
         return await decode(await request(memoryPath(id), {}, signal));
@@ -22135,7 +22314,7 @@ async function createRemoteMemoryPersistence(options) {
         write
       );
     },
-    putMany: async (writes, signal) => {
+    putMany: async (writes, signal, leaseToken) => {
       if (writes.length < 1 || writes.length > 50 || new Set(writes.map((w) => w.memory.memory_id)).size !== writes.length)
         throw new Error("Batch must contain 1\u201350 distinct memory ids");
       const prepared = await Promise.all(
@@ -22145,7 +22324,11 @@ async function createRemoteMemoryPersistence(options) {
         "/memories/batch",
         {
           method: "POST",
-          body: JSON.stringify({ key_id: options.keyId, writes: prepared.map((w) => w.body) })
+          body: JSON.stringify({
+            key_id: options.keyId,
+            writes: prepared.map((w) => w.body),
+            ...leaseToken && { lease_token: leaseToken }
+          })
         },
         signal
       );
@@ -22904,6 +23087,12 @@ async function migrateMemoriesToRemote(options) {
   let claimed = account.key_id === canonical.keyId;
   if (!active) await createDecaySweeper({ vaultCtx: options.vaultCtx }).runSweep();
   await backfillTopics(options.vaultCtx);
+  const localTopics = options.topics ?? (options.vaultCtx.singleTenant === true ? (await options.vaultCtx.database.get("entity").query().unsafeFetchRaw()).map((t) => ({
+    name: normalizeEntityName(typeof t.canonical_name === "string" ? t.canonical_name : ""),
+    ...typeof t.kind === "string" && { kind: t.kind }
+  })).filter((t) => t.name.length > 0) : []);
+  if (localTopics.length)
+    await createRemoteTopicPersistence(request).importTopics(localTopics, signal);
   const skipped = /* @__PURE__ */ new Map();
   const reembedded = /* @__PURE__ */ new Set();
   const unembedded = /* @__PURE__ */ new Set();
@@ -23030,7 +23219,6 @@ var MAX_QUERY_IDS = 1e3;
 var MAX_QUERY_TOPICS = 100;
 var MAX_QUERY_FILTER = 20;
 var GRAPH_LANE_ROWS = 256;
-var TEMPORAL_LANE_ROWS = 256;
 var REPAIR_ROWS = 50;
 var REPAIR_SCAN = 2e3;
 var DECAY_TRANSITIONS_PER_SWEEP = 200;
@@ -23101,21 +23289,21 @@ function subscriptionKey({ memory, version }, options) {
   ]);
 }
 function topicInputs(topics, source) {
-  return topics.flatMap((topic) => {
-    const name = (typeof topic === "string" ? topic : topic.name).trim();
-    const kind = typeof topic === "string" ? void 0 : topic.kind;
-    const weight = typeof topic === "string" || source === "user" ? void 0 : parseTopicWeight(topic.weight);
+  return topics.flatMap((topic2) => {
+    const name = (typeof topic2 === "string" ? topic2 : topic2.name).trim();
+    const kind = typeof topic2 === "string" ? void 0 : topic2.kind;
+    const weight = typeof topic2 === "string" || source === "user" ? void 0 : parseTopicWeight(topic2.weight);
     return name ? [{ name, ...kind && { kind }, source, ...weight && { weight } }] : [];
   });
 }
 function mergeTopics(existing, added) {
   const byName = /* @__PURE__ */ new Map();
-  for (const topic of [...existing, ...added]) {
-    const key = normalizeEntityName(topic.name);
+  for (const topic2 of [...existing, ...added]) {
+    const key = normalizeEntityName(topic2.name);
     const kept = byName.get(key);
-    if (!kept) byName.set(key, topic);
-    else if (kept.weight !== void 0 && topic.weight !== void 0 && topic.weight > kept.weight)
-      byName.set(key, { ...kept, weight: topic.weight });
+    if (!kept) byName.set(key, topic2);
+    else if (kept.weight !== void 0 && topic2.weight !== void 0 && topic2.weight > kept.weight)
+      byName.set(key, { ...kept, weight: topic2.weight });
   }
   return [...byName.values()];
 }
@@ -23126,7 +23314,7 @@ function sameTopics(stored2, next) {
   return next.every((t) => keys.has(key(t)));
 }
 function canonicalTopics(row) {
-  return new Set((parseTopics(row.topics) ?? []).map((topic) => normalizeEntityName(topic.name)));
+  return new Set((parseTopics(row.topics) ?? []).map((topic2) => normalizeEntityName(topic2.name)));
 }
 function createRemoteMemoryStore(options) {
   const { persistence, embeddingOptions } = options;
@@ -23201,20 +23389,7 @@ function createRemoteMemoryStore(options) {
   const eventTimeRanking = async (query, now) => {
     const window2 = parseQueryTimeWindow(query, now);
     if (!window2) return [];
-    const rows = await pages(
-      metadata2,
-      { event_time_overlaps: { start: window2.start, end: window2.end } },
-      TEMPORAL_LANE_ROWS
-    );
-    return rows.map(({ memory }) => ({
-      memoryId: memory.memory_id,
-      score: scoreEventTimeOverlap(
-        memory.event_time_start ?? null,
-        memory.event_time_end ?? null,
-        memory.event_time_kind ?? null,
-        window2
-      )
-    })).filter((row) => row.score > 0).sort((a, b) => b.score - a.score).map((row) => row.memoryId);
+    return persistence.temporal({ start: window2.start, end: window2.end });
   };
   const enumerateIds = async (read, ids, filters) => (await Promise.all(
     chunks2([...new Set(ids)], MAX_QUERY_IDS).map(
@@ -23265,22 +23440,28 @@ function createRemoteMemoryStore(options) {
     writeOptions?.signal?.throwIfAborted();
     const next = edit(structuredClone(record2.memory));
     if (!next) return null;
-    const saved = writeOptions?.signal ? await persistence.put(next, record2, writeOptions.signal) : await persistence.put(next, record2);
+    const saved = writeOptions?.leaseToken ? (await persistence.putMany(
+      [{ memory: next, expectedVersion: record2 }],
+      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]);
     return saved;
   };
   const mutate = (id, change, edit, writeOptions) => serialized(id, () => mutateLocked(id, change, edit, writeOptions));
   const serializedAll = (ids, task) => [...new Set(ids)].sort().reduceRight((inner, id) => () => serialized(id, inner), task)();
-  const mutateMany = async (ids, change, edit) => {
+  const mutateMany = async (ids, change, edit, leaseToken, signal) => {
     const saved = /* @__PURE__ */ new Map();
     const failed = /* @__PURE__ */ new Map();
     for (const slice of chunks2([...new Set(ids)], MAX_BATCH)) {
       await serializedAll(slice, async () => {
+        signal?.throwIfAborted();
         const writes = [];
         let read;
         try {
-          read = await readEveryState(slice);
+          read = await readEveryState(slice, signal);
         } catch (error) {
+          signal?.throwIfAborted();
           for (const id of slice) failed.set(id, error);
           return;
         }
@@ -23297,7 +23478,9 @@ function createRemoteMemoryStore(options) {
         if (writes.length === 0) return;
         try {
           const written = await persistence.putMany(
-            writes.map(({ before, memory }) => ({ memory, expectedVersion: before }))
+            writes.map(({ before, memory }) => ({ memory, expectedVersion: before })),
+            signal,
+            leaseToken
           );
           const byChange = /* @__PURE__ */ new Map();
           written.forEach((record2, i) => {
@@ -23307,7 +23490,9 @@ function createRemoteMemoryStore(options) {
           });
           for (const [kind, changed] of byChange) notify(kind, changed);
         } catch (error) {
-          const perRow = error instanceof RemoteMemoryError && (error.code === "version_conflict" || error.status === 429);
+          signal?.throwIfAborted();
+          if (isRemoteWorkLeaseExpired(error)) throw error;
+          const perRow = error instanceof RemoteMemoryError && (error.code === "version_conflict" || error.status === 429 && !leaseToken);
           for (const { before } of writes) {
             const id = before.memory.memory_id;
             if (!perRow) {
@@ -23315,9 +23500,16 @@ function createRemoteMemoryStore(options) {
               continue;
             }
             try {
-              const record2 = await mutateLocked(id, change, edit);
+              const record2 = await mutateLocked(
+                id,
+                change,
+                edit,
+                leaseToken || signal ? { leaseToken, signal } : void 0
+              );
               if (record2) saved.set(id, record2);
             } catch (rowError) {
+              signal?.throwIfAborted();
+              if (isRemoteWorkLeaseExpired(rowError)) throw rowError;
               failed.set(id, rowError);
             }
           }
@@ -23381,7 +23573,7 @@ function createRemoteMemoryStore(options) {
     return records.map((record2) => stored(record2.memory));
   };
   const asStored = (record2) => record2 ? stored(record2.memory) : null;
-  const knownKinds = async (topics) => {
+  const knownKinds = async (topics, signal) => {
     const unkinded = [
       ...new Set(topics.filter((t) => !t.kind).map((t) => normalizeEntityName(t.name)))
     ];
@@ -23391,21 +23583,22 @@ function createRemoteMemoryStore(options) {
         topics: names,
         include_archived: true,
         include_quarantined: true,
-        include_superseded: true
+        include_superseded: true,
+        ...signal && { signal }
       })) {
-        for (const topic of parseTopics(memory.topics) ?? []) {
-          const name = normalizeEntityName(topic.name);
-          if (topic.kind && !kinds.has(name)) kinds.set(name, topic.kind);
+        for (const topic2 of parseTopics(memory.topics) ?? []) {
+          const name = normalizeEntityName(topic2.name);
+          if (topic2.kind && !kinds.has(name)) kinds.set(name, topic2.kind);
         }
       }
     }
-    return (topic) => {
-      const kind = topic.kind ?? kinds.get(normalizeEntityName(topic.name));
-      return kind ? { ...topic, kind } : topic;
+    return (topic2) => {
+      const kind = topic2.kind ?? kinds.get(normalizeEntityName(topic2.name));
+      return kind ? { ...topic2, kind } : topic2;
     };
   };
   const withKnownKinds = async (topics) => topics.map(await knownKinds(topics));
-  const readEveryState = async (ids) => {
+  const readEveryState = async (ids, signal) => {
     const records = /* @__PURE__ */ new Map();
     const unreadable = /* @__PURE__ */ new Set();
     for (const memory_ids of chunks2(ids, MAX_QUERY_IDS)) {
@@ -23418,6 +23611,7 @@ function createRemoteMemoryStore(options) {
           include_quarantined: true,
           include_superseded: true,
           limit: 200,
+          ...signal && { signal },
           ...cursor2 && { cursor: cursor2 }
         });
         warnFailed(page.failed);
@@ -23428,6 +23622,111 @@ function createRemoteMemoryStore(options) {
     }
     return { records, unreadable };
   };
+  const extractTopicsUnlocked = async (memoryIds, extractOptions, leaseToken, signal) => {
+    const start = Date.now();
+    const extractedAt = extractOptions.now ?? start;
+    const skippedIds = [];
+    const skippedReasons = /* @__PURE__ */ new Map();
+    const skip = (id, reason) => {
+      if (skippedReasons.has(id)) return;
+      skippedIds.push(id);
+      skippedReasons.set(id, reason);
+    };
+    const ids = [...new Set(memoryIds)];
+    const { records, unreadable } = await readEveryState(ids, signal);
+    signal?.throwIfAborted();
+    const inputs = [];
+    for (const id of ids) {
+      const memory = records.get(id)?.memory;
+      if (unreadable.has(id)) skip(id, "unreadable");
+      else if (!memory) skip(id, "not-found");
+      else if (memory.is_deleted || memory.topics_user_managed) skip(id, "excluded");
+      else inputs.push({ id, content: memory.content });
+    }
+    const batches = [];
+    const llmFailures = /* @__PURE__ */ new Map();
+    const entitiesByMemory = await extractEntitiesForMemories(
+      inputs,
+      {
+        ...extractOptions,
+        onBatch: (batch) => {
+          batches.push(batch);
+          if (batch.failure) {
+            for (const id of batch.memoryIds) llmFailures.set(id, batch.failure);
+          }
+          notifyMemoryCallback(extractOptions.onBatch, batch);
+        }
+      },
+      signal
+    );
+    signal?.throwIfAborted();
+    const answered = /* @__PURE__ */ new Map();
+    for (const input of inputs) {
+      const entities = entitiesByMemory.get(input.id);
+      if (entities === void 0) skip(input.id, "llm-unanswered");
+      else
+        answered.set(input.id, { content: input.content, topics: topicInputs(entities, "auto") });
+    }
+    const stampedIds = [];
+    const fail = (id, reason) => {
+      skip(id, reason);
+      entitiesByMemory.delete(id);
+    };
+    try {
+      const kinded = await knownKinds(
+        [...answered.values()].flatMap((a) => a.topics),
+        signal
+      );
+      signal?.throwIfAborted();
+      const topics = new Map(
+        [...answered].map(([id, a]) => [id, mergeTopics([], a.topics.map(kinded))])
+      );
+      const unchanged = (memory) => sameTopics(parseTopics(memory.topics), topics.get(memory.memory_id));
+      const { saved, failed } = await mutateMany(
+        [...answered.keys()],
+        (before) => sameTopics(parseTopics(before.topics) ?? [], topics.get(before.memory_id)) ? "metadata" : "edit",
+        (memory) => {
+          if (memory.topics_user_managed || memory.content !== answered.get(memory.memory_id).content)
+            return null;
+          return {
+            ...memory,
+            ...!unchanged(memory) && {
+              topics: serializeTopics(topics.get(memory.memory_id)),
+              topics_updated_at: Date.now()
+            },
+            topics_extracted_at: Math.max(extractedAt, memory.updated_at),
+            topics_extracted_version: TOPICS_EXTRACTION_VERSION
+          };
+        },
+        leaseToken,
+        signal
+      );
+      for (const id of answered.keys()) {
+        if (saved.has(id)) stampedIds.push(id);
+        else fail(id, failed.has(id) ? "link-failed" : "link-declined");
+      }
+      if (failed.size)
+        getLogger().warn(
+          "[memory/remote-store] Failed to write extracted topics:",
+          failed.values().next().value
+        );
+    } catch (error) {
+      signal?.throwIfAborted();
+      if (isRemoteWorkLeaseExpired(error)) throw error;
+      getLogger().warn("[memory/remote-store] Failed to write extracted topics:", error);
+      for (const id of answered.keys()) fail(id, "link-failed");
+    }
+    return {
+      entitiesByMemory,
+      stampedIds,
+      skippedIds,
+      skippedReasons,
+      batchCount: batches.length,
+      durationMs: Date.now() - start,
+      batches,
+      llmFailures
+    };
+  };
   const topicMaintenance = {
     getTopicBacklog: async (backlogOptions = {}) => {
       const limit = backlogOptions.limit !== void 0 && backlogOptions.limit > 0 ? backlogOptions.limit : Infinity;
@@ -23445,97 +23744,12 @@ function createRemoteMemoryStore(options) {
         topicsBackfill: []
       };
     },
-    extractTopics: async (memoryIds, extractOptions) => {
-      const start = Date.now();
-      const extractedAt = extractOptions.now ?? start;
-      const skippedIds = [];
-      const skippedReasons = /* @__PURE__ */ new Map();
-      const skip = (id, reason) => {
-        if (skippedReasons.has(id)) return;
-        skippedIds.push(id);
-        skippedReasons.set(id, reason);
-      };
-      const ids = [...new Set(memoryIds)];
-      const { records, unreadable } = await readEveryState(ids);
-      const inputs = [];
-      for (const id of ids) {
-        const memory = records.get(id)?.memory;
-        if (unreadable.has(id)) skip(id, "unreadable");
-        else if (!memory) skip(id, "not-found");
-        else if (memory.is_deleted || memory.topics_user_managed) skip(id, "excluded");
-        else inputs.push({ id, content: memory.content });
-      }
-      const batches = [];
-      const llmFailures = /* @__PURE__ */ new Map();
-      const entitiesByMemory = await extractEntitiesForMemories(inputs, {
-        ...extractOptions,
-        onBatch: (batch) => {
-          batches.push(batch);
-          if (batch.failure) {
-            for (const id of batch.memoryIds) llmFailures.set(id, batch.failure);
-          }
-          notifyMemoryCallback(extractOptions.onBatch, batch);
-        }
-      });
-      const answered = /* @__PURE__ */ new Map();
-      for (const input of inputs) {
-        const entities = entitiesByMemory.get(input.id);
-        if (entities === void 0) skip(input.id, "llm-unanswered");
-        else
-          answered.set(input.id, { content: input.content, topics: topicInputs(entities, "auto") });
-      }
-      const stampedIds = [];
-      const fail = (id, reason) => {
-        skip(id, reason);
-        entitiesByMemory.delete(id);
-      };
-      try {
-        const kinded = await knownKinds([...answered.values()].flatMap((a) => a.topics));
-        const topics = new Map(
-          [...answered].map(([id, a]) => [id, mergeTopics([], a.topics.map(kinded))])
-        );
-        const unchanged = (memory) => sameTopics(parseTopics(memory.topics), topics.get(memory.memory_id));
-        const { saved, failed } = await mutateMany(
-          [...answered.keys()],
-          (before) => sameTopics(parseTopics(before.topics) ?? [], topics.get(before.memory_id)) ? "metadata" : "edit",
-          (memory) => {
-            if (memory.topics_user_managed || memory.content !== answered.get(memory.memory_id).content)
-              return null;
-            return {
-              ...memory,
-              ...!unchanged(memory) && {
-                topics: serializeTopics(topics.get(memory.memory_id)),
-                topics_updated_at: Date.now()
-              },
-              topics_extracted_at: Math.max(extractedAt, memory.updated_at),
-              topics_extracted_version: TOPICS_EXTRACTION_VERSION
-            };
-          }
-        );
-        for (const id of answered.keys()) {
-          if (saved.has(id)) stampedIds.push(id);
-          else fail(id, failed.has(id) ? "link-failed" : "link-declined");
-        }
-        if (failed.size)
-          getLogger().warn(
-            "[memory/remote-store] Failed to write extracted topics:",
-            failed.values().next().value
-          );
-      } catch (error) {
-        getLogger().warn("[memory/remote-store] Failed to write extracted topics:", error);
-        for (const id of answered.keys()) fail(id, "link-failed");
-      }
-      return {
-        entitiesByMemory,
-        stampedIds,
-        skippedIds,
-        skippedReasons,
-        batchCount: batches.length,
-        durationMs: Date.now() - start,
-        batches,
-        llmFailures
-      };
-    },
+    extractTopics: async (ids, extractOptions) => await withRemoteWorkLease(
+      persistence,
+      "topics",
+      String(TOPICS_EXTRACTION_VERSION),
+      (token, signal) => extractTopicsUnlocked(ids, extractOptions, token, signal)
+    ) ?? { ...await extractTopicsUnlocked([], extractOptions), deferred: true },
     stampTopicsExtracted: async (memoryIds, extractedAt, version = TOPICS_EXTRACTION_VERSION) => {
       const ids = [...new Set(memoryIds)];
       const { saved, failed } = await mutateMany(
@@ -23632,14 +23846,29 @@ function createRemoteMemoryStore(options) {
   let ready = false;
   let cursor;
   let pending = /* @__PURE__ */ new Set();
+  let topicFingerprint;
   let polling = false;
   const poll = () => {
     if (polling) return;
     polling = true;
     const current = generation;
-    changesSince(cursor, pending).then(({ records, resume, failed }) => {
+    changesSince(cursor, pending).then(async ({ records, resume, failed }) => {
+      let topicState;
+      if ([...subscribers].some((s) => s.options.topics))
+        try {
+          topicState = JSON.stringify(
+            (await persistence.topics()).map((t) => [t.name, t.version])
+          );
+        } catch (error) {
+          getLogger().warn("[memory/remote-store] Topic subscription poll failed:", error);
+        }
       if (current !== generation) return;
       const changed = /* @__PURE__ */ new Set();
+      if (topicState !== void 0 && topicFingerprint !== void 0 && topicState !== topicFingerprint) {
+        for (const subscriber of subscribers)
+          if (subscriber.options.topics) changed.add(subscriber);
+      }
+      if (topicState !== void 0) topicFingerprint = topicState;
       for (const record2 of records) {
         const id = record2.memory.memory_id;
         const previous = seen.get(id);
@@ -23663,11 +23892,11 @@ function createRemoteMemoryStore(options) {
   };
   const unrepairable = /* @__PURE__ */ new Set();
   let repairCursor;
-  const repairEmbeddings = async ({
+  const repairEmbeddingsUnlocked = async ({
     maxRows = REPAIR_ROWS,
     maxScan = REPAIR_SCAN,
     cursor: start = repairCursor
-  } = {}) => {
+  } = {}, leaseToken, signal) => {
     const scannedRows = [];
     let cursor2 = start;
     do {
@@ -23676,6 +23905,7 @@ function createRemoteMemoryStore(options) {
         include_archived: true,
         include_quarantined: true,
         include_superseded: true,
+        ...signal && { signal },
         limit: Math.min(200, Math.max(1, maxScan - scannedRows.length)),
         ...cursor2 && { cursor: cursor2 }
       });
@@ -23693,6 +23923,7 @@ function createRemoteMemoryStore(options) {
       skippedConflict: 0
     };
     const finish = () => {
+      signal?.throwIfAborted();
       const settled = allStale.every(
         ({ memory }) => repaired.has(memory.memory_id) || unrepairable.has(memory.memory_id)
       );
@@ -23701,13 +23932,15 @@ function createRemoteMemoryStore(options) {
     };
     const stale = allStale.slice(0, maxRows).map(({ memory }) => memory.memory_id);
     if (stale.length === 0) return finish();
-    const { records, unreadable } = await readEveryState(stale);
+    const { records, unreadable } = await readEveryState(stale, signal);
+    signal?.throwIfAborted();
     result.failed += unreadable.size;
     for (const id of stale)
       if (unreadable.has(id) || !records.get(id)?.memory.content.trim()) unrepairable.add(id);
     const targets = stale.filter((id) => !unrepairable.has(id)).map((id) => records.get(id));
     if (targets.length === 0) return finish();
-    const vectors = await embedForRepair(targets);
+    const vectors = await embedForRepair(targets, signal);
+    signal?.throwIfAborted();
     if (!vectors) {
       result.failed += targets.length;
       return finish();
@@ -23719,15 +23952,28 @@ function createRemoteMemoryStore(options) {
         continue;
       }
       await serialized(record2.memory.memory_id, async () => {
+        signal?.throwIfAborted();
         try {
-          const saved = await persistence.put(
-            { ...record2.memory, embedding: storedVector(vector), embedding_model: model },
-            record2
+          const [saved] = await persistence.putMany(
+            [
+              {
+                memory: {
+                  ...record2.memory,
+                  embedding: storedVector(vector),
+                  embedding_model: model
+                },
+                expectedVersion: record2
+              }
+            ],
+            signal,
+            leaseToken
           );
           notify("embedding", [saved]);
           repaired.add(record2.memory.memory_id);
           result.reembedded++;
         } catch (error) {
+          signal?.throwIfAborted();
+          if (isRemoteWorkLeaseExpired(error)) throw error;
           if (error instanceof RemoteMemoryError && error.code === "version_conflict")
             result.skippedConflict++;
           else result.failed++;
@@ -23736,19 +23982,28 @@ function createRemoteMemoryStore(options) {
     }
     return finish();
   };
-  const embedForRepair = async (targets) => {
+  const repairEmbeddings = async (repairOptions = {}) => await withRemoteWorkLease(
+    persistence,
+    "embeddings",
+    model,
+    (token, signal) => repairEmbeddingsUnlocked(repairOptions, token, signal)
+  ) ?? { scanned: 0, reembedded: 0, failed: 0, skippedConflict: 0, deferred: true };
+  const embedForRepair = async (targets, signal) => {
     const texts = targets.map(({ memory }) => memory.content);
     try {
-      return await generateEmbeddings(texts, embeddingOptions);
+      return await generateEmbeddings(texts, embeddingOptions, signal);
     } catch (error) {
+      signal?.throwIfAborted();
       getLogger().warn("[memory/remote-store] Failed to embed memories for repair:", error);
       if (!rejectsInput(error)) return null;
     }
     const vectors = [];
     for (const [i, text14] of texts.entries()) {
+      signal?.throwIfAborted();
       try {
-        [vectors[i]] = await generateEmbeddings([text14], embeddingOptions);
+        [vectors[i]] = await generateEmbeddings([text14], embeddingOptions, signal);
       } catch (error) {
+        signal?.throwIfAborted();
         if (!rejectsInput(error)) return null;
         unrepairable.add(targets[i].memory.memory_id);
       }
@@ -23756,6 +24011,26 @@ function createRemoteMemoryStore(options) {
     return vectors;
   };
   return {
+    createTopic: async (name) => {
+      const canonical = await createRemoteTopic(persistence, name);
+      if (canonical) notify("edit", []);
+      return canonical;
+    },
+    importTopics: async (topics) => {
+      if (!topics.length) return;
+      const existing = new Set((await persistence.topics()).map((topic2) => topic2.name));
+      const missing = topics.flatMap((topic2) => {
+        const name = normalizeEntityName(topic2.name);
+        if (existing.has(name)) return [];
+        existing.add(name);
+        return [{ ...topic2, name }];
+      });
+      if (!missing.length) return;
+      await persistence.importTopics(missing);
+      for (const subscriber of [...subscribers])
+        if (subscriber.options.topics) safely(subscriber.onChange);
+    },
+    counts: () => persistence.counts(),
     masksEmbeddingInput: embeddingOptions.maskInput !== void 0,
     topicMaintenance,
     repairEmbeddings,
@@ -23772,8 +24047,8 @@ function createRemoteMemoryStore(options) {
         include_quarantined: true,
         include_superseded: true
       })) {
-        for (const topic of parseTopics(memory.topics) ?? []) {
-          const name = normalizeEntityName(topic.name);
+        for (const topic2 of parseTopics(memory.topics) ?? []) {
+          const name = normalizeEntityName(topic2.name);
           if (!name) continue;
           const entry = topics.get(name) ?? {
             name,
@@ -23781,12 +24056,24 @@ function createRemoteMemoryStore(options) {
             memoryCount: 0,
             members: /* @__PURE__ */ new Set()
           };
-          entry.kind ?? (entry.kind = topic.kind ?? null);
+          entry.kind ?? (entry.kind = topic2.kind ?? null);
           entry.members.add(memory.memory_id);
           topics.set(name, entry);
         }
       }
-      return [...topics.values()].map(({ members, ...topic }) => ({ ...topic, memoryCount: members.size })).sort((a, b) => a.name.localeCompare(b.name));
+      for (const topic2 of await persistence.topics()) {
+        if (topic2.is_deleted) continue;
+        const current = topics.get(topic2.name);
+        if (current) current.kind ?? (current.kind = topic2.kind ?? null);
+        else
+          topics.set(topic2.name, {
+            name: topic2.name,
+            kind: topic2.kind ?? null,
+            memoryCount: 0,
+            members: /* @__PURE__ */ new Set()
+          });
+      }
+      return [...topics.values()].map(({ members, ...topic2 }) => ({ ...topic2, memoryCount: members.size })).sort((a, b) => a.name.localeCompare(b.name));
     },
     get: async (id) => asStored(await live(id)),
     listArchived: async () => (await enumerate({ archived_only: true, order: "archived", include_embeddings: true })).map(
@@ -23931,10 +24218,10 @@ function createRemoteMemoryStore(options) {
       if (!saved) return [];
       const now = /* @__PURE__ */ new Date();
       return mergeTopics([], added).map(
-        (topic) => ({
-          uniqueId: normalizeEntityName(topic.name),
-          canonicalName: normalizeEntityName(topic.name),
-          kind: topic.kind ?? null,
+        (topic2) => ({
+          uniqueId: normalizeEntityName(topic2.name),
+          canonicalName: normalizeEntityName(topic2.name),
+          kind: topic2.kind ?? null,
           createdAt: now,
           updatedAt: now
         })