@desplega.ai/agent-swarm 1.103.0 → 1.104.0

package/src/be/memory/providers/sqlite-store.ts

@@ -1,17 +1,23 @@
 import { getDb, isSqliteVecAvailable } from "@/be/db";
 import { cosineSimilarity, deserializeEmbedding, serializeEmbedding } from "@/be/embedding";
+import { contentSha256 } from "@/commands/profile-sync";
 import type { AgentMemory, AgentMemoryScope, AgentMemorySource } from "@/types";
 import {
   EMBEDDING_DIMENSIONS,
+  isHybridSearchEnabled,
   MIN_SIMILARITY,
   PROTECTED_SOURCES,
   TTL_DEFAULTS,
 } from "../constants";
+import { recencyDecay } from "../reranker";
 import type {
   MemoryCandidate,
+  MemoryEditInput,
+  MemoryEditResult,
   MemoryHealth,
   MemoryInput,
   MemoryListOptions,
+  MemoryRetrievalSource,
   MemorySearchOptions,
   MemoryStats,
   MemoryStore,
@@ -41,6 +47,10 @@ type AgentMemoryRow = {
   embeddingModel: string | null;
   alpha: number;
   beta: number;
+  key: string | null;
+  contentHash: string | null;
+  version: number;
+  updatedAt: string | null;
 };
 
 function rowToAgentMemory(row: AgentMemoryRow): AgentMemory {
@@ -48,6 +58,7 @@ function rowToAgentMemory(row: AgentMemoryRow): AgentMemory {
     id: row.id,
     agentId: row.agentId,
     scope: row.scope as AgentMemoryScope,
+    key: row.key ?? null,
     name: row.name,
     content: row.content,
     summary: row.summary,
@@ -58,10 +69,13 @@ function rowToAgentMemory(row: AgentMemoryRow): AgentMemory {
     totalChunks: row.totalChunks,
     tags: JSON.parse(row.tags || "[]"),
     createdAt: row.createdAt,
+    updatedAt: row.updatedAt ?? null,
     accessedAt: row.accessedAt,
     expiresAt: row.expiresAt ?? null,
     accessCount: row.accessCount ?? 0,
     embeddingModel: row.embeddingModel ?? null,
+    contentHash: row.contentHash ?? null,
+    version: row.version ?? 1,
   };
 }
 
@@ -77,6 +91,60 @@ function rowToCandidate(row: AgentMemoryRow, similarity: number): MemoryCandidat
   };
 }
 
+function retrievalSourceFor(sources: Set<MemoryRetrievalSource>): MemoryRetrievalSource {
+  if (sources.has("fts") && sources.has("vec")) return "hybrid";
+  if (sources.has("fts")) return "fts";
+  if (sources.has("vec")) return "vec";
+  return "fallback";
+}
+
+/**
+ * RRF (Reciprocal Rank Fusion) score for hybrid search.
+ *
+ * Combines rankings from vector (semantic) and FTS (keyword) arms into a single
+ * comparable score using the standard RRF formula: score = Σ 1/(k + rank + 1)
+ * where k=60 is the smoothing constant that prevents top-ranked results from
+ * dominating. The score is then modulated by source-aware recency decay so
+ * ephemeral sources (session_summary, task_completion) naturally age out.
+ *
+ * A memory that appears in BOTH vec and FTS arms receives two reciprocal-rank
+ * contributions that SUM, boosting it above single-arm matches (compounding).
+ *
+ * Score range: (0, ~0.033] per arm contribution (1/(60+0+1)=0.0164 max per arm).
+ * After decay: [0, ~0.033]. Scores are directly comparable across results.
+ */
+export function computeRrfScore(rank: number, decayFactor: number, k = 60): number {
+  return (1 / (k + rank + 1)) * decayFactor;
+}
+
+/**
+ * Compute the next content for a memory edit. Returns the new content string.
+ * Throws if validation fails (missing fields, oldString not found, ambiguous match).
+ */
+export function applyEditMode(
+  mode: "replace" | "exact",
+  currentContent: string,
+  fields: { content?: string; oldString?: string; newString?: string },
+): string {
+  if (mode === "replace") {
+    if (fields.content == null) throw new Error("replace mode requires content");
+    return fields.content;
+  }
+  if (!fields.oldString || fields.newString == null) {
+    throw new Error("exact mode requires oldString and newString");
+  }
+  const first = currentContent.indexOf(fields.oldString);
+  if (first === -1) throw new Error("oldString not found");
+  if (currentContent.indexOf(fields.oldString, first + fields.oldString.length) !== -1) {
+    throw new Error("oldString is ambiguous");
+  }
+  return (
+    currentContent.slice(0, first) +
+    fields.newString +
+    currentContent.slice(first + fields.oldString.length)
+  );
+}
+
 function computeExpiresAt(source: AgentMemorySource): string | null {
   const ttlDays = TTL_DEFAULTS[source];
   if (ttlDays == null) return null;
@@ -85,10 +153,91 @@ function computeExpiresAt(source: AgentMemorySource): string | null {
 
 export class SqliteMemoryStore implements MemoryStore {
   private vecInitialized = false;
+  private ftsInitialized = false;
   private lastPopulate: MemoryVecPopulateStats | null = null;
 
   constructor() {
     this.ensureVecTable();
+    this.ensureFtsTable();
+  }
+
+  private ensureFtsTable(): void {
+    if (this.ftsInitialized) return;
+    const db = getDb();
+    try {
+      db.run(`
+        CREATE VIRTUAL TABLE IF NOT EXISTS memory_fts USING fts5(
+          memory_id UNINDEXED,
+          name,
+          content,
+          tokenize='porter unicode61'
+        )
+      `);
+      this.populateFtsTable();
+      this.ftsInitialized = true;
+    } catch (err) {
+      this.ftsInitialized = false;
+      console.error("[memory-fts] Failed to initialize memory_fts:", (err as Error).message);
+    }
+  }
+
+  private getFtsTableSchema(): string | null {
+    try {
+      return (
+        getDb()
+          .prepare<{ sql: string | null }, []>(
+            "SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'memory_fts'",
+          )
+          .get()?.sql ?? null
+      );
+    } catch {
+      return null;
+    }
+  }
+
+  private populateFtsTable(): void {
+    const db = getDb();
+    const deletedExtra = db
+      .prepare(
+        `DELETE FROM memory_fts
+         WHERE memory_id NOT IN (SELECT id FROM agent_memory)`,
+      )
+      .run();
+    if (deletedExtra.changes > 0) {
+      console.warn(`[memory-fts] removed_extra_rows count=${deletedExtra.changes}`);
+    }
+
+    const inserted = db
+      .prepare(
+        `INSERT INTO memory_fts(memory_id, name, content)
+         SELECT m.id, m.name, m.content
+         FROM agent_memory m
+         WHERE NOT EXISTS (SELECT 1 FROM memory_fts f WHERE f.memory_id = m.id)`,
+      )
+      .run();
+    console.log(`[memory-fts] populate inserted=${inserted.changes}`);
+  }
+
+  private syncFtsRow(memoryId: string, name: string, content: string): void {
+    if (!this.ftsInitialized && !this.getFtsTableSchema()) return;
+    const db = getDb();
+    try {
+      db.prepare("DELETE FROM memory_fts WHERE memory_id = ?").run(memoryId);
+      db.prepare("INSERT INTO memory_fts(memory_id, name, content) VALUES (?, ?, ?)").run(
+        memoryId,
+        name,
+        content,
+      );
+    } catch (err) {
+      console.error(`[memory-fts] sync failed memory_id=${memoryId}: ${(err as Error).message}`);
+    }
+  }
+
+  private deleteFtsRows(ids: string[]): void {
+    if (ids.length === 0 || (!this.ftsInitialized && !this.getFtsTableSchema())) return;
+    const db = getDb();
+    const placeholders = ids.map(() => "?").join(",");
+    db.prepare(`DELETE FROM memory_fts WHERE memory_id IN (${placeholders})`).run(...ids);
   }
 
   private ensureVecTable(): void {
@@ -237,56 +386,65 @@ export class SqliteMemoryStore implements MemoryStore {
     const id = crypto.randomUUID();
     const now = new Date().toISOString();
     const expiresAt = computeExpiresAt(input.source);
+    const key = input.key ?? `${input.scope}/${input.source}/${id}`;
+    const contentHash = contentSha256(input.content);
+    const version = 1;
+    const db = getDb();
 
-    const row = getDb()
-      .prepare<
-        AgentMemoryRow,
-        [
-          string,
-          string | null,
-          string,
-          string,
-          string,
-          string | null,
-          string,
-          string | null,
-          string | null,
-          number,
-          number,
-          string,
-          string,
-          string,
-          string | null,
-          number,
-          string | null,
-          string | null,
-        ]
-      >(
-        `INSERT INTO agent_memory (id, agentId, scope, name, content, summary, source, sourceTaskId, sourcePath, chunkIndex, totalChunks, tags, createdAt, accessedAt, expiresAt, accessCount, embeddingModel, contextKey)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING *`,
-      )
-      .get(
-        id,
-        input.agentId ?? null,
-        input.scope,
-        input.name,
+    let row: AgentMemoryRow | null | undefined;
+    const tx = db.transaction(() => {
+      row = db
+        .prepare<AgentMemoryRow, (string | number | null)[]>(
+          `INSERT INTO agent_memory (id, agentId, scope, key, name, content, summary, source, sourceTaskId, sourcePath, chunkIndex, totalChunks, tags, createdAt, updatedAt, accessedAt, expiresAt, accessCount, embeddingModel, contextKey, contentHash, version)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING *`,
+        )
+        .get(
+          id,
+          input.agentId ?? null,
+          input.scope,
+          key,
+          input.name,
+          input.content,
+          input.summary ?? null,
+          input.source,
+          input.sourceTaskId ?? null,
+          input.sourcePath ?? null,
+          input.chunkIndex ?? 0,
+          input.totalChunks ?? 1,
+          JSON.stringify(input.tags ?? []),
+          now,
+          now,
+          now,
+          expiresAt,
+          0,
+          null,
+          input.contextKey ?? null,
+          contentHash,
+          version,
+        );
+
+      if (!row) throw new Error("Failed to create memory");
+      db.prepare(
+        `INSERT INTO agent_memory_version (id, memory_id, version, content, contentHash, intent, operation, changedByAgentId, createdAt, updatedAt, created_by, updated_by)
+         VALUES (?, ?, ?, ?, ?, ?, 'create', ?, ?, ?, ?, ?)`,
+      ).run(
+        crypto.randomUUID(),
+        row.id,
+        version,
         input.content,
-        input.summary ?? null,
-        input.source,
-        input.sourceTaskId ?? null,
-        input.sourcePath ?? null,
-        input.chunkIndex ?? 0,
-        input.totalChunks ?? 1,
-        JSON.stringify(input.tags ?? []),
+        contentHash,
+        input.intent ?? "create memory",
+        input.agentId ?? null,
         now,
         now,
-        expiresAt,
-        0,
-        null,
-        input.contextKey ?? null,
+        input.agentId ?? null,
+        input.agentId ?? null,
       );
+    });
+    tx();
 
     if (!row) throw new Error("Failed to create memory");
+    this.syncFtsRow(row.id, row.name, row.content);
     return rowToAgentMemory(row);
   }
 
@@ -333,6 +491,26 @@ export class SqliteMemoryStore implements MemoryStore {
     const { scope = "all", limit = 10, source, isLead = false, includeExpired = false } = options;
 
     const health = this.getHealth();
+    if (
+      isHybridSearchEnabled() &&
+      options.queryText &&
+      this.ftsInitialized &&
+      this.getFtsTableSchema() &&
+      health.retrievalMode === "vec" &&
+      embedding.length === EMBEDDING_DIMENSIONS
+    ) {
+      console.log(
+        `[memory-search] retrieval_path=hybrid scope=${scope} limit=${limit} vec_rows=${health.counts.memoryVec} searchable=${health.counts.searchable}`,
+      );
+      return this.searchHybrid(embedding, options.queryText, agentId, {
+        scope,
+        limit,
+        source,
+        isLead,
+        includeExpired,
+      });
+    }
+
     if (health.retrievalMode === "vec" && embedding.length === EMBEDDING_DIMENSIONS) {
       console.log(
         `[memory-search] retrieval_path=vec scope=${scope} limit=${limit} vec_rows=${health.counts.memoryVec} searchable=${health.counts.searchable}`,
@@ -346,6 +524,19 @@ export class SqliteMemoryStore implements MemoryStore {
       });
     }
 
+    if (options.queryText && this.ftsInitialized && this.getFtsTableSchema()) {
+      console.log(
+        `[memory-search] retrieval_path=fts scope=${scope} limit=${limit} reason=${embedding.length !== EMBEDDING_DIMENSIONS ? "query_dimension_mismatch" : health.reasons.join("|") || "vec_unavailable"}`,
+      );
+      return this.searchFts(options.queryText, agentId, {
+        scope,
+        limit,
+        source,
+        isLead,
+        includeExpired,
+      });
+    }
+
     console.log(
       `[memory-search] retrieval_path=fallback scope=${scope} limit=${limit} reason=${embedding.length !== EMBEDDING_DIMENSIONS ? "query_dimension_mismatch" : health.reasons.join("|") || "vec_unavailable"}`,
     );
@@ -358,6 +549,132 @@ export class SqliteMemoryStore implements MemoryStore {
     });
   }
 
+  private searchHybrid(
+    queryEmbedding: Float32Array,
+    queryText: string,
+    agentId: string,
+    options: {
+      scope: string;
+      limit: number;
+      source?: AgentMemorySource;
+      isLead: boolean;
+      includeExpired: boolean;
+    },
+  ): MemoryCandidate[] {
+    const overfetchLimit = Math.min(Math.max(options.limit * 4, options.limit), 100);
+    const vectorCandidates = this.searchWithVec(queryEmbedding, agentId, {
+      ...options,
+      limit: overfetchLimit,
+    });
+    const ftsCandidates = this.searchFts(queryText, agentId, { ...options, limit: overfetchLimit });
+    if (ftsCandidates.length === 0) return vectorCandidates.slice(0, options.limit);
+
+    const byId = new Map<string, MemoryCandidate>();
+    const scores = new Map<string, number>();
+    const sources = new Map<string, Set<MemoryRetrievalSource>>();
+    const now = new Date();
+    const add = (candidate: MemoryCandidate, rank: number) => {
+      byId.set(candidate.id, byId.get(candidate.id) ?? candidate);
+      const retrievalSource = candidate.retrievalSource === "fts" ? "fts" : "vec";
+      const candidateSources = sources.get(candidate.id) ?? new Set<MemoryRetrievalSource>();
+      candidateSources.add(retrievalSource);
+      sources.set(candidate.id, candidateSources);
+
+      const decay = recencyDecay(candidate.createdAt, now, candidate.source);
+      scores.set(candidate.id, (scores.get(candidate.id) ?? 0) + computeRrfScore(rank, decay));
+    };
+
+    vectorCandidates.forEach(add);
+    ftsCandidates.forEach(add);
+
+    return [...byId.values()]
+      .map((candidate) => ({
+        ...candidate,
+        rawSimilarity: candidate.rawSimilarity ?? candidate.similarity,
+        similarity: scores.get(candidate.id) ?? candidate.similarity,
+        retrievalSource: retrievalSourceFor(sources.get(candidate.id) ?? new Set()),
+        recencyDecayApplied: true,
+      }))
+      .sort((a, b) => b.similarity - a.similarity)
+      .slice(0, options.limit);
+  }
+
+  private searchFts(
+    queryText: string,
+    agentId: string,
+    options: {
+      scope: string;
+      limit: number;
+      source?: AgentMemorySource;
+      isLead: boolean;
+      includeExpired: boolean;
+    },
+  ): MemoryCandidate[] {
+    const match = this.buildFtsMatch(queryText);
+    if (!match) return [];
+
+    const db = getDb();
+    const { scope, limit, source, isLead, includeExpired } = options;
+    const conditions: string[] = ["memory_fts MATCH ?"];
+    const params: (Buffer | string | number | null)[] = [match];
+
+    this.addScopeConditions(conditions, params, agentId, scope, isLead, "m");
+
+    if (source) {
+      conditions.push("m.source = ?");
+      params.push(source);
+    }
+
+    if (!includeExpired) {
+      conditions.push("(m.expiresAt IS NULL OR m.expiresAt > datetime('now'))");
+    }
+
+    try {
+      const sqlLimit = Math.min(Math.max(limit * 4, limit), 100);
+      const rows = db
+        .prepare<AgentMemoryRow & { rank: number }, (Buffer | string | number | null)[]>(
+          `SELECT m.*, bm25(memory_fts) AS rank
+           FROM memory_fts
+           JOIN agent_memory m ON m.id = memory_fts.memory_id
+           WHERE ${conditions.join(" AND ")}
+           ORDER BY rank
+           LIMIT ?`,
+        )
+        .all(...params, sqlLimit);
+
+      const now = new Date();
+      return rows
+        .map((row, index) => {
+          const rawSimilarity = 1 / (index + 1);
+          return {
+            ...rowToCandidate(
+              row,
+              rawSimilarity * recencyDecay(row.createdAt, now, row.source as AgentMemorySource),
+            ),
+            rawSimilarity,
+            retrievalSource: "fts" as const,
+            recencyDecayApplied: true,
+          };
+        })
+        .sort((a, b) => b.similarity - a.similarity)
+        .slice(0, limit);
+    } catch (err) {
+      console.warn("[memory-fts] query failed:", (err as Error).message);
+      return [];
+    }
+  }
+
+  private buildFtsMatch(queryText: string): string | null {
+    const terms = queryText
+      .trim()
+      .split(/[^\p{L}\p{N}_-]+/u)
+      .map((term) => term.trim())
+      .filter((term) => term.length > 0)
+      .slice(0, 12);
+    if (terms.length === 0) return null;
+    return terms.map((term) => `"${term.replaceAll('"', '""')}"`).join(" OR ");
+  }
+
   private searchWithVec(
     queryEmbedding: Float32Array,
     agentId: string,
@@ -408,7 +725,7 @@ export class SqliteMemoryStore implements MemoryStore {
     for (const row of rows) {
       const similarity = 1 - row.distance;
       if (similarity < MIN_SIMILARITY) continue;
-      candidates.push(rowToCandidate(row, similarity));
+      candidates.push({ ...rowToCandidate(row, similarity), retrievalSource: "vec" });
     }
 
     return candidates;
@@ -455,7 +772,7 @@ export class SqliteMemoryStore implements MemoryStore {
       if (emb.length !== queryEmbedding.length) continue;
       const similarity = cosineSimilarity(queryEmbedding, emb);
       if (similarity < MIN_SIMILARITY) continue;
-      candidates.push(rowToCandidate(row, similarity));
+      candidates.push({ ...rowToCandidate(row, similarity), retrievalSource: "fallback" });
     }
 
     candidates.sort((a, b) => b.similarity - a.similarity);
@@ -553,6 +870,92 @@ export class SqliteMemoryStore implements MemoryStore {
     return PROTECTED_SOURCES.has(source);
   }
 
+  edit(input: MemoryEditInput): MemoryEditResult {
+    if (!input.id && !(input.key && input.scope)) {
+      throw new Error("memory edit requires either id or key+scope");
+    }
+
+    const db = getDb();
+    const row = input.id
+      ? db
+          .prepare<AgentMemoryRow, [string]>("SELECT * FROM agent_memory WHERE id = ?")
+          .get(input.id)
+      : db
+          .prepare<AgentMemoryRow, [string, string, string | null]>(
+            `SELECT * FROM agent_memory
+             WHERE key = ? AND scope = ? AND coalesce(agentId, '') = coalesce(?, '')
+             ORDER BY chunkIndex ASC
+             LIMIT 1`,
+          )
+          .get(input.key!, input.scope!, input.agentId ?? null);
+
+    if (!row) throw new Error("memory not found");
+    if ((row.totalChunks ?? 1) !== 1)
+      throw new Error("memory edit only supports single-chunk rows");
+    if (input.expectedVersion && input.expectedVersion !== (row.version ?? 1)) {
+      throw new Error("memory version conflict");
+    }
+
+    const previousVersion = row.version ?? 1;
+    const nextContent = applyEditMode(input.mode, row.content, {
+      content: input.content,
+      oldString: input.oldString,
+      newString: input.newString,
+    });
+
+    const nextHash = contentSha256(nextContent);
+    if (nextHash === row.contentHash) {
+      return {
+        memory: rowToAgentMemory(row),
+        changed: false,
+        previousVersion,
+        version: previousVersion,
+        contentHash: nextHash,
+      };
+    }
+
+    const nextVersion = previousVersion + 1;
+    const now = new Date().toISOString();
+    const tx = db.transaction(() => {
+      db.prepare(
+        `INSERT INTO agent_memory_version (id, memory_id, version, content, contentHash, intent, operation, changedByAgentId, createdAt, updatedAt, created_by, updated_by)
+         VALUES (?, ?, ?, ?, ?, ?, 'edit', ?, ?, ?, ?, ?)`,
+      ).run(
+        crypto.randomUUID(),
+        row.id,
+        nextVersion,
+        nextContent,
+        nextHash,
+        input.intent,
+        input.changedByAgentId ?? null,
+        now,
+        now,
+        input.changedByAgentId ?? null,
+        input.changedByAgentId ?? null,
+      );
+      db.prepare(
+        `UPDATE agent_memory
+         SET content = ?, contentHash = ?, version = ?, updatedAt = ?
+         WHERE id = ?`,
+      ).run(nextContent, nextHash, nextVersion, now, row.id);
+    });
+    tx();
+
+    this.syncFtsRow(row.id, row.name, nextContent);
+    const updated = db
+      .prepare<AgentMemoryRow, [string]>("SELECT * FROM agent_memory WHERE id = ?")
+      .get(row.id);
+    if (!updated) throw new Error("memory disappeared after edit");
+
+    return {
+      memory: rowToAgentMemory(updated),
+      changed: true,
+      previousVersion,
+      version: nextVersion,
+      contentHash: nextHash,
+    };
+  }
+
   listForCuration(
     agentId?: string,
   ): { id: string; source: string; name: string; createdAt: string }[] {
@@ -588,11 +991,19 @@ export class SqliteMemoryStore implements MemoryStore {
       .all();
   }
 
-  delete(id: string): boolean {
+  private purgeByIds(ids: string[]): void {
+    if (ids.length === 0) return;
     const db = getDb();
     if (this.vecInitialized && this.getVecTableSchema()) {
-      db.prepare("DELETE FROM memory_vec WHERE memory_id = ?").run(id);
+      const placeholders = ids.map(() => "?").join(",");
+      db.prepare(`DELETE FROM memory_vec WHERE memory_id IN (${placeholders})`).run(...ids);
     }
+    this.deleteFtsRows(ids);
+  }
+
+  delete(id: string): boolean {
+    const db = getDb();
+    this.purgeByIds([id]);
     const result = db.prepare("DELETE FROM agent_memory WHERE id = ?").run(id);
     return result.changes > 0;
   }
@@ -600,26 +1011,18 @@ export class SqliteMemoryStore implements MemoryStore {
   deleteBySourcePath(sourcePath: string, agentId: string): number {
     const db = getDb();
 
-    if (this.vecInitialized && this.getVecTableSchema()) {
-      // Get IDs first for vec table cleanup
-      const ids = db
-        .prepare<{ id: string }, [string, string]>(
-          "SELECT id FROM agent_memory WHERE sourcePath = ? AND agentId = ?",
-        )
-        .all(sourcePath, agentId);
+    const ids = db
+      .prepare<{ id: string }, [string, string]>(
+        "SELECT id FROM agent_memory WHERE sourcePath = ? AND agentId = ?",
+      )
+      .all(sourcePath, agentId);
 
-      if (ids.length > 0) {
-        const placeholders = ids.map(() => "?").join(",");
-        db.prepare(`DELETE FROM memory_vec WHERE memory_id IN (${placeholders})`).run(
-          ...ids.map((r) => r.id),
-        );
-      }
-    }
+    this.purgeByIds(ids.map((r) => r.id));
 
     const result = db
       .prepare("DELETE FROM agent_memory WHERE sourcePath = ? AND agentId = ?")
       .run(sourcePath, agentId);
-    return result.changes;
+    return ids.length || result.changes;
   }
 
   purgeExpired(): number {
@@ -633,15 +1036,9 @@ export class SqliteMemoryStore implements MemoryStore {
 
     if (expiredIds.length === 0) return 0;
 
-    if (this.vecInitialized && this.getVecTableSchema()) {
-      const batchSize = 500;
-      for (let i = 0; i < expiredIds.length; i += batchSize) {
-        const batch = expiredIds.slice(i, i + batchSize);
-        const placeholders = batch.map(() => "?").join(",");
-        db.prepare(`DELETE FROM memory_vec WHERE memory_id IN (${placeholders})`).run(
-          ...batch.map((r) => r.id),
-        );
-      }
+    const batchSize = 500;
+    for (let i = 0; i < expiredIds.length; i += batchSize) {
+      this.purgeByIds(expiredIds.slice(i, i + batchSize).map((r) => r.id));
     }
 
     const result = db