@desplega.ai/agent-swarm 1.158.0 → 1.160.0

package/dist/{cli-aehm1rbq.js → cli-jz4w45qt.js}

@@ -1,5 +1,17 @@
 import {
-  __esm
+  contentSha256,
+  init_profile_sync
+} from "./cli-25fcq4b4.js";
+import {
+  getDb,
+  getDbClient,
+  init_db,
+  isSqliteVecAvailable
+} from "./cli-qydf22qq.js";
+import {
+  __esm,
+  __export,
+  __toCommonJS
 } from "./cli-bc05qbss.js";
 
 // node_modules/openai/internal/tslib.mjs
@@ -7951,70 +7963,12 @@ var init_client = __esm(() => {
 });
 
 // node_modules/openai/azure.mjs
-var AzureOpenAI, _deployments_endpoints;
+var _deployments_endpoints;
 var init_azure = __esm(() => {
   init_headers();
   init_error2();
   init_utils2();
   init_client();
-  AzureOpenAI = class AzureOpenAI extends OpenAI {
-    constructor({ baseURL = readEnv("OPENAI_BASE_URL"), apiKey = readEnv("AZURE_OPENAI_API_KEY"), apiVersion = readEnv("OPENAI_API_VERSION"), endpoint, deployment, azureADTokenProvider, dangerouslyAllowBrowser, ...opts } = {}) {
-      if (!apiVersion) {
-        throw new OpenAIError("The OPENAI_API_VERSION environment variable is missing or empty; either provide it, or instantiate the AzureOpenAI client with an apiVersion option, like new AzureOpenAI({ apiVersion: 'My API Version' }).");
-      }
-      if (typeof azureADTokenProvider === "function") {
-        dangerouslyAllowBrowser = true;
-      }
-      if (!azureADTokenProvider && !apiKey) {
-        throw new OpenAIError("Missing credentials. Please pass one of `apiKey` and `azureADTokenProvider`, or set the `AZURE_OPENAI_API_KEY` environment variable.");
-      }
-      if (azureADTokenProvider && apiKey) {
-        throw new OpenAIError("The `apiKey` and `azureADTokenProvider` arguments are mutually exclusive; only one can be passed at a time.");
-      }
-      opts.defaultQuery = { ...opts.defaultQuery, "api-version": apiVersion };
-      if (!baseURL) {
-        if (!endpoint) {
-          endpoint = process.env["AZURE_OPENAI_ENDPOINT"];
-        }
-        if (!endpoint) {
-          throw new OpenAIError("Must provide one of the `baseURL` or `endpoint` arguments, or the `AZURE_OPENAI_ENDPOINT` environment variable");
-        }
-        baseURL = `${endpoint}/openai`;
-      } else {
-        if (endpoint) {
-          throw new OpenAIError("baseURL and endpoint are mutually exclusive");
-        }
-      }
-      super({
-        apiKey: azureADTokenProvider ?? apiKey,
-        baseURL,
-        ...opts,
-        ...dangerouslyAllowBrowser !== undefined ? { dangerouslyAllowBrowser } : {}
-      });
-      this.apiVersion = "";
-      this.apiVersion = apiVersion;
-      this.deploymentName = deployment;
-    }
-    async buildRequest(options, props = {}) {
-      if (_deployments_endpoints.has(options.path) && options.method === "post" && options.body !== undefined) {
-        if (!isObj(options.body)) {
-          throw new Error("Expected request body to be an object");
-        }
-        const model = this.deploymentName || options.body["model"] || options.__metadata?.["model"];
-        if (model !== undefined && !this.baseURL.includes("/deployments")) {
-          options.path = `/deployments/${model}${options.path}`;
-        }
-      }
-      return super.buildRequest(options, props);
-    }
-    async authHeaders(opts, schemes) {
-      const security = schemes ?? { bearerAuth: true, adminAPIKeyAuth: true };
-      if (security.bearerAuth && typeof this._options.apiKey === "string") {
-        return buildHeaders([{ "api-key": this.apiKey }]);
-      }
-      return super.authHeaders(opts, security);
-    }
-  };
   _deployments_endpoints = new Set([
     "/completions",
     "/chat/completions",
@@ -8039,4 +7993,1141 @@ var init_openai = __esm(() => {
   init_azure();
 });
 
-export { OpenAI, AzureOpenAI, init_openai };
+// src/be/memory/constants.ts
+function numEnv(key, fallback) {
+  const val = process.env[key];
+  if (val === undefined)
+    return fallback;
+  const parsed = Number(val);
+  return Number.isNaN(parsed) ? fallback : parsed;
+}
+function recencyDecayHalfLifeDays(source = "task_completion") {
+  const raw = process.env.MEMORY_RECENCY_HALF_LIFE_DAYS;
+  if (raw != null && raw !== "") {
+    const parsed = Number(raw);
+    if (Number.isFinite(parsed))
+      return parsed;
+  }
+  return DEFAULT_RECENCY_DECAY_HALF_LIFE[source];
+}
+function minSimilarity() {
+  return numEnv("MEMORY_MIN_SIMILARITY", 0.1);
+}
+function accessBoostMaxMultiplier() {
+  return numEnv("MEMORY_ACCESS_BOOST_MAX", 1.5);
+}
+function isHybridSearchEnabled() {
+  const val = process.env.MEMORY_HYBRID_SEARCH?.trim().toLowerCase();
+  return val !== "0" && val !== "false";
+}
+function isGraphExpansionEnabled() {
+  const val = process.env.MEMORY_GRAPH_EXPANSION?.trim().toLowerCase();
+  return val !== "0" && val !== "false";
+}
+var TTL_DEFAULTS, DEFAULT_RECENCY_DECAY_HALF_LIFE, SOURCE_QUALITY_MULTIPLIER, ACCESS_BOOST_RECENCY_WINDOW_HOURS, CANDIDATE_SET_MULTIPLIER, EMBEDDING_DIMENSIONS, DEFAULT_EMBEDDING_MODEL = "openai/text-embedding-3-small", PROTECTED_SOURCES;
+var init_constants = __esm(() => {
+  TTL_DEFAULTS = {
+    task_completion: 7,
+    session_summary: 3,
+    file_index: 30,
+    manual: null
+  };
+  DEFAULT_RECENCY_DECAY_HALF_LIFE = {
+    manual: Number.POSITIVE_INFINITY,
+    file_index: 180,
+    task_completion: 14,
+    session_summary: 7
+  };
+  SOURCE_QUALITY_MULTIPLIER = {
+    manual: 1.5,
+    file_index: 1,
+    task_completion: 0.7,
+    session_summary: 0.5
+  };
+  ACCESS_BOOST_RECENCY_WINDOW_HOURS = numEnv("MEMORY_ACCESS_RECENCY_HOURS", 48);
+  CANDIDATE_SET_MULTIPLIER = numEnv("MEMORY_CANDIDATE_MULTIPLIER", 3);
+  EMBEDDING_DIMENSIONS = numEnv("EMBEDDING_DIMENSIONS", 512);
+  PROTECTED_SOURCES = new Set(["manual"]);
+});
+
+// src/be/memory/providers/openai-embedding.ts
+var exports_openai_embedding = {};
+__export(exports_openai_embedding, {
+  OpenAIEmbeddingProvider: () => OpenAIEmbeddingProvider
+});
+
+class OpenAIEmbeddingProvider {
+  name;
+  dimensions;
+  client = null;
+  model;
+  apiKey;
+  constructor(config) {
+    this.apiKey = config?.apiKey ?? process.env.EMBEDDING_API_KEY ?? process.env.OPENAI_API_KEY;
+    this.model = config?.model ?? process.env.EMBEDDING_MODEL ?? "text-embedding-3-small";
+    this.dimensions = config?.dimensions ?? EMBEDDING_DIMENSIONS;
+    this.name = config?.model ? `openai/${config.model}` : process.env.EMBEDDING_MODEL ?? DEFAULT_EMBEDDING_MODEL;
+  }
+  isConfigured() {
+    return !!this.apiKey;
+  }
+  getClient() {
+    if (!this.apiKey)
+      return null;
+    if (!this.client)
+      this.client = new OpenAI({
+        baseURL: process.env.EMBEDDING_API_BASE_URL,
+        apiKey: this.apiKey
+      });
+    return this.client;
+  }
+  async embed(text) {
+    const client = this.getClient();
+    if (!client)
+      return null;
+    try {
+      const cleaned = text.replace(/[\n\r]/g, " ").trim();
+      if (!cleaned)
+        return null;
+      const response = await client.embeddings.create({
+        model: this.model,
+        input: cleaned,
+        dimensions: this.dimensions,
+        encoding_format: "float"
+      });
+      const values2 = response.data[0]?.embedding;
+      if (!values2)
+        return null;
+      if (values2.length !== this.dimensions) {
+        console.error(`[memory] Embedding dimension mismatch: expected=${this.dimensions} got=${values2.length}. Provider may not support the 'dimensions' parameter.`);
+        return null;
+      }
+      return new Float32Array(values2);
+    } catch (err) {
+      console.error("[memory] Embedding failed:", err.message);
+      return null;
+    }
+  }
+  async embedBatch(texts) {
+    const client = this.getClient();
+    if (!client)
+      return texts.map(() => null);
+    const cleaned = texts.map((t) => t.replace(/[\n\r]/g, " ").trim());
+    const nonEmptyIndices = [];
+    const nonEmptyTexts = [];
+    for (let i = 0;i < cleaned.length; i++) {
+      if (cleaned[i]) {
+        nonEmptyIndices.push(i);
+        nonEmptyTexts.push(cleaned[i]);
+      }
+    }
+    if (nonEmptyTexts.length === 0)
+      return texts.map(() => null);
+    try {
+      const response = await client.embeddings.create({
+        model: this.model,
+        input: nonEmptyTexts,
+        dimensions: this.dimensions,
+        encoding_format: "float"
+      });
+      const results = texts.map(() => null);
+      for (const item of response.data) {
+        const originalIndex = nonEmptyIndices[item.index];
+        if (originalIndex !== undefined && item.embedding) {
+          if (item.embedding.length !== this.dimensions) {
+            console.error(`[memory] Batch embedding dimension mismatch: expected=${this.dimensions} got=${item.embedding.length}. Provider may not support the 'dimensions' parameter.`);
+            continue;
+          }
+          results[originalIndex] = new Float32Array(item.embedding);
+        }
+      }
+      return results;
+    } catch (err) {
+      console.error("[memory] Batch embedding failed:", err.message);
+      return texts.map(() => null);
+    }
+  }
+}
+var init_openai_embedding = __esm(() => {
+  init_openai();
+  init_constants();
+});
+
+// src/be/embedding.ts
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length)
+    throw new Error("Vectors must have the same length");
+  if (a.length === 0)
+    return 0;
+  let dotProduct = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0;i < a.length; i++) {
+    const ai = a[i];
+    const bi = b[i];
+    dotProduct += ai * bi;
+    normA += ai * ai;
+    normB += bi * bi;
+  }
+  const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+  if (denominator === 0)
+    return 0;
+  return dotProduct / denominator;
+}
+function serializeEmbedding(embedding) {
+  return Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength);
+}
+function deserializeEmbedding(buffer) {
+  const copy = new ArrayBuffer(buffer.length);
+  const view = new Uint8Array(copy);
+  view.set(buffer);
+  return new Float32Array(copy);
+}
+var init_embedding = () => {};
+
+// src/be/memory/reranker.ts
+function recencyDecay(createdAt, now, source) {
+  const halfLife = recencyDecayHalfLifeDays(source);
+  if (!Number.isFinite(halfLife))
+    return 1;
+  const ageDays = (now.getTime() - new Date(createdAt).getTime()) / MS_PER_DAY;
+  if (ageDays <= 0)
+    return 1;
+  return 2 ** (-ageDays / halfLife);
+}
+function accessBoost(accessedAt, accessCount, now) {
+  if (accessCount <= 0)
+    return 1;
+  const hoursSinceAccess = (now.getTime() - new Date(accessedAt).getTime()) / MS_PER_HOUR;
+  const recencyFactor = hoursSinceAccess <= ACCESS_BOOST_RECENCY_WINDOW_HOURS ? 1 : 0.5;
+  const boost = 1 + Math.min(accessCount / 10, accessBoostMaxMultiplier() - 1) * recencyFactor;
+  return boost;
+}
+function sourceQuality(source) {
+  return SOURCE_QUALITY_MULTIPLIER[source] ?? 1;
+}
+function readDemotionFloor() {
+  const raw = process.env.MEMORY_DEMOTION_FLOOR;
+  const n = raw == null || raw === "" ? 1 : Number(raw);
+  return Number.isFinite(n) ? n : 1;
+}
+function usefulness(alpha, beta) {
+  const denom = alpha + beta;
+  if (denom <= 0)
+    return 1;
+  const mean = alpha / denom;
+  return Math.max(readDemotionFloor(), Math.min(2, 2 * mean));
+}
+function computeScore(candidate, now) {
+  const decay = candidate.recencyDecayApplied ? 1 : recencyDecay(candidate.createdAt, now, candidate.source);
+  return candidate.similarity * decay * accessBoost(candidate.accessedAt, candidate.accessCount, now) * sourceQuality(candidate.source) * usefulness(candidate.alpha, candidate.beta);
+}
+function rerank(candidates, options) {
+  const { limit: limit2, now = new Date } = options;
+  const uncapped = new Map;
+  for (const candidate of candidates)
+    uncapped.set(candidate.id, computeScore(candidate, now));
+  const byId = new Map(candidates.map((c) => [c.id, c]));
+  const capped = new Map;
+  const cappedScore = (candidate, seen) => {
+    const cached = capped.get(candidate.id);
+    if (cached !== undefined)
+      return cached;
+    let score = uncapped.get(candidate.id);
+    const parent = candidate.graphParentId ? byId.get(candidate.graphParentId) : undefined;
+    if (parent && !seen.has(parent.id)) {
+      seen.add(candidate.id);
+      score = Math.min(score, cappedScore(parent, seen));
+    }
+    capped.set(candidate.id, score);
+    return score;
+  };
+  const scored = candidates.map((candidate) => {
+    const rawSimilarity = candidate.rawSimilarity ?? candidate.similarity;
+    const compositeScore = cappedScore(candidate, new Set);
+    return {
+      ...candidate,
+      rawSimilarity,
+      compositeScore,
+      similarity: compositeScore
+    };
+  });
+  scored.sort((a, b) => b.similarity - a.similarity || b.rawSimilarity - a.rawSimilarity);
+  return scored.slice(0, limit2);
+}
+var MS_PER_DAY, MS_PER_HOUR;
+var init_reranker = __esm(() => {
+  init_constants();
+  MS_PER_DAY = 1000 * 60 * 60 * 24;
+  MS_PER_HOUR = 1000 * 60 * 60;
+});
+
+// src/be/memory/providers/sqlite-store.ts
+var exports_sqlite_store = {};
+__export(exports_sqlite_store, {
+  FTS_DELETE_EXTRA_SQL: () => FTS_DELETE_EXTRA_SQL,
+  FTS_MISSING_IDS_SQL: () => FTS_MISSING_IDS_SQL,
+  SqliteMemoryStore: () => SqliteMemoryStore,
+  applyEditMode: () => applyEditMode,
+  computeRrfScore: () => computeRrfScore,
+  fusedSimilarity: () => fusedSimilarity,
+  rowToCandidate: () => rowToCandidate
+});
+function rowToAgentMemory(row) {
+  return {
+    id: row.id,
+    agentId: row.agentId,
+    scope: row.scope,
+    key: row.key ?? null,
+    name: row.name,
+    content: row.content,
+    summary: row.summary,
+    source: row.source,
+    sourceTaskId: row.sourceTaskId,
+    sourcePath: row.sourcePath,
+    chunkIndex: row.chunkIndex,
+    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
+  };
+}
+function rowToCandidate(row, similarity) {
+  return {
+    ...rowToAgentMemory(row),
+    similarity,
+    accessCount: row.accessCount ?? 0,
+    expiresAt: row.expiresAt ?? null,
+    embeddingModel: row.embeddingModel ?? null,
+    alpha: row.alpha ?? 1,
+    beta: row.beta ?? 1
+  };
+}
+function retrievalSourceFor(sources) {
+  if (sources.has("fts") && sources.has("vec"))
+    return "hybrid";
+  if (sources.has("fts"))
+    return "fts";
+  if (sources.has("vec"))
+    return "vec";
+  return "fallback";
+}
+function computeRrfScore(rank, decayFactor, k = 60) {
+  return 1 / (k + rank + 1) * decayFactor;
+}
+function fusedSimilarity(cosine, rrfScore, k = 60) {
+  const agreement = Math.min(1, rrfScore * (k + 1) / 2);
+  return cosine * (0.5 + 0.5 * agreement);
+}
+function applyEditMode(mode, currentContent, fields) {
+  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) {
+  const ttlDays = TTL_DEFAULTS[source];
+  if (ttlDays == null)
+    return null;
+  return new Date(Date.now() + ttlDays * 86400000).toISOString();
+}
+
+class SqliteMemoryStore {
+  vecInitialized = false;
+  ftsInitialized = false;
+  ftsPopulate = null;
+  lastPopulate = null;
+  constructor() {
+    this.ensureVecTable();
+    this.ensureFtsTable();
+  }
+  ensureFtsTable() {
+    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.ftsInitialized = true;
+      this.ftsPopulate = this.populateFtsTable().catch((err) => {
+        console.error("[memory-fts] Failed to populate memory_fts:", err.message);
+      });
+    } catch (err) {
+      this.ftsInitialized = false;
+      console.error("[memory-fts] Failed to initialize memory_fts:", err.message);
+    }
+  }
+  async getFtsTableSchema() {
+    try {
+      const row = await getDbClient().get("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'memory_fts'");
+      return row?.sql ?? null;
+    } catch {
+      return null;
+    }
+  }
+  async populateFtsTable() {
+    const client = getDbClient();
+    const startedAt = performance.now();
+    const deletedExtra = await client.run(FTS_DELETE_EXTRA_SQL);
+    if (deletedExtra.changes > 0) {
+      console.warn(`[memory-fts] removed_extra_rows count=${deletedExtra.changes}`);
+    }
+    const missing = await client.query(FTS_MISSING_IDS_SQL);
+    for (let i = 0;i < missing.length; i += FTS_POPULATE_BATCH_SIZE) {
+      const ids = missing.slice(i, i + FTS_POPULATE_BATCH_SIZE).map((row) => row.id);
+      const placeholders = ids.map(() => "?").join(",");
+      await client.run(`INSERT INTO memory_fts(memory_id, name, content)
+         SELECT m.id, m.name, m.content
+         FROM agent_memory m
+         WHERE m.id IN (${placeholders})
+           AND m.id NOT IN (SELECT memory_id FROM memory_fts WHERE memory_id IS NOT NULL)`, ids);
+      await new Promise((resolve) => setImmediate(resolve));
+    }
+    console.log(`[memory-fts] populate missing=${missing.length} ms=${Math.round(performance.now() - startedAt)}`);
+  }
+  whenFtsPopulated() {
+    return this.ftsPopulate ?? Promise.resolve();
+  }
+  async syncFtsRow(memoryId, name, content) {
+    if (!this.ftsInitialized && !await this.getFtsTableSchema())
+      return;
+    try {
+      await getDbClient().run("DELETE FROM memory_fts WHERE memory_id = ?", [memoryId]);
+      await getDbClient().run("INSERT INTO memory_fts(memory_id, name, content) VALUES (?, ?, ?)", [
+        memoryId,
+        name,
+        content
+      ]);
+    } catch (err) {
+      console.error(`[memory-fts] sync failed memory_id=${memoryId}: ${err.message}`);
+    }
+  }
+  async deleteFtsRows(ids) {
+    if (ids.length === 0 || !await this.getFtsTableSchema())
+      return;
+    const placeholders = ids.map(() => "?").join(",");
+    await getDbClient().run(`DELETE FROM memory_fts WHERE memory_id IN (${placeholders})`, ids);
+  }
+  ensureVecTable() {
+    if (this.vecInitialized)
+      return;
+    if (!isSqliteVecAvailable()) {
+      console.warn("[memory-vec] sqlite-vec extension_loaded=false; retrieval_mode=fallback");
+      return;
+    }
+    const db = getDb();
+    try {
+      console.log(`[memory-vec] sqlite-vec extension_loaded=true vector_dimensions=${EMBEDDING_DIMENSIONS}`);
+      const existingSchema = this.getVecTableSchema();
+      if (existingSchema && !existingSchema.includes("distance_metric=cosine")) {
+        console.warn("[memory-vec] Existing memory_vec table is missing cosine distance metric; rebuilding from agent_memory");
+        db.run("DROP TABLE memory_vec");
+      }
+      db.run(`
+        CREATE VIRTUAL TABLE IF NOT EXISTS memory_vec USING vec0(
+          memory_id TEXT PRIMARY KEY,
+          embedding float[${EMBEDDING_DIMENSIONS}] distance_metric=cosine
+        )
+      `);
+      const healthBefore = this.getHealthCounts();
+      if (healthBefore.missingFromVec > 0 || healthBefore.extraInVec > 0) {
+        this.populateVecTable(healthBefore.memoryVec);
+      } else {
+        console.log(`[memory-vec] populate skipped attempted=0 inserted=0 memory_vec=${healthBefore.memoryVec} valid_embedding=${healthBefore.validEmbedding}`);
+      }
+      this.vecInitialized = true;
+    } catch (err) {
+      this.vecInitialized = false;
+      console.error("[memory-vec] Failed to initialize memory_vec:", err.message);
+    }
+  }
+  getVecTableSchema() {
+    try {
+      return getDb().prepare("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'memory_vec'").get()?.sql ?? null;
+    } catch {
+      return null;
+    }
+  }
+  getVecCount() {
+    if (!this.getVecTableSchema())
+      return 0;
+    return getDb().prepare("SELECT COUNT(*) as count FROM memory_vec").get()?.count ?? 0;
+  }
+  populateVecTable(beforeCount) {
+    const db = getDb();
+    const deletedExtra = db.prepare(`DELETE FROM memory_vec
+         WHERE memory_id NOT IN (SELECT id FROM agent_memory)`).run();
+    if (deletedExtra.changes > 0) {
+      console.warn(`[memory-vec] removed_extra_rows count=${deletedExtra.changes}`);
+    }
+    const rows = db.prepare("SELECT id, embedding FROM agent_memory WHERE embedding IS NOT NULL").all();
+    const deleteVec = db.prepare("DELETE FROM memory_vec WHERE memory_id = ?");
+    const insertVec = db.prepare("INSERT INTO memory_vec(memory_id, embedding) VALUES (?, ?)");
+    let attempted = 0;
+    let inserted = 0;
+    let skippedInvalidDimensions = 0;
+    let failed = 0;
+    for (const row of rows) {
+      const embeddingBuffer = this.toVecBuffer(row.embedding);
+      if (!embeddingBuffer) {
+        skippedInvalidDimensions++;
+        continue;
+      }
+      attempted++;
+      try {
+        deleteVec.run(row.id);
+        insertVec.run(row.id, embeddingBuffer);
+        inserted++;
+      } catch (err) {
+        failed++;
+        console.error(`[memory-vec] populate failed memory_id=${row.id}: ${err.message}`);
+      }
+    }
+    const afterCount = this.getVecCount();
+    this.lastPopulate = {
+      attempted,
+      inserted,
+      skippedInvalidDimensions,
+      failed,
+      beforeCount,
+      afterCount
+    };
+    console.log(`[memory-vec] populate attempted=${attempted} inserted=${inserted} skipped_invalid_dimensions=${skippedInvalidDimensions} failed=${failed} before_count=${beforeCount} after_count=${afterCount}`);
+    if (failed > 0 || afterCount < attempted) {
+      console.error(`[memory-vec] populate incomplete attempted=${attempted} after_count=${afterCount} failed=${failed}`);
+    }
+  }
+  toVecBuffer(embedding) {
+    if (embedding instanceof Float32Array) {
+      if (embedding.length !== EMBEDDING_DIMENSIONS)
+        return null;
+      return serializeEmbedding(embedding);
+    }
+    if (embedding.length !== VECTOR_BYTES)
+      return null;
+    return embedding;
+  }
+  async store(input) {
+    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 row = await getDbClient().transaction(async (tx) => {
+      const inserted = await tx.get(`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 *`, [
+        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 (!inserted)
+        throw new Error("Failed to create memory");
+      await tx.run(`INSERT INTO agent_memory_version (id, memory_id, version, content, contentHash, intent, operation, changedByAgentId, createdAt, updatedAt, created_by, updated_by)
+         VALUES (?, ?, ?, ?, ?, ?, 'create', ?, ?, ?, ?, ?)`, [
+        crypto.randomUUID(),
+        inserted.id,
+        version,
+        input.content,
+        contentHash,
+        input.intent ?? "create memory",
+        input.agentId ?? null,
+        now,
+        now,
+        input.agentId ?? null,
+        input.agentId ?? null
+      ]);
+      return inserted;
+    });
+    await this.syncFtsRow(row.id, row.name, row.content);
+    return rowToAgentMemory(row);
+  }
+  async storeBatch(inputs) {
+    const results = [];
+    await getDbClient().transaction(async () => {
+      for (const input of inputs) {
+        results.push(await this.store(input));
+      }
+    });
+    return results;
+  }
+  async get(id) {
+    const db = getDbClient();
+    const row = await db.get("SELECT * FROM agent_memory WHERE id = ?", [id]);
+    if (!row)
+      return null;
+    await db.run("UPDATE agent_memory SET accessedAt = ?, accessCount = accessCount + 1 WHERE id = ?", [new Date().toISOString(), id]);
+    return rowToAgentMemory(row);
+  }
+  async peek(id) {
+    const row = await getDbClient().get("SELECT * FROM agent_memory WHERE id = ?", [
+      id
+    ]);
+    if (!row)
+      return null;
+    return rowToAgentMemory(row);
+  }
+  async search(embedding, agentId, options = {}) {
+    const { scope = "all", limit: limit2 = 10, source, isLead = false, includeExpired = false } = options;
+    const health = this.getHealth();
+    if (isHybridSearchEnabled() && options.queryText && this.ftsInitialized && await this.getFtsTableSchema() && health.retrievalMode === "vec" && embedding.length === EMBEDDING_DIMENSIONS) {
+      console.log(`[memory-search] retrieval_path=hybrid scope=${scope} limit=${limit2} vec_rows=${health.counts.memoryVec} searchable=${health.counts.searchable}`);
+      return this.searchHybrid(embedding, options.queryText, agentId, {
+        scope,
+        limit: limit2,
+        source,
+        isLead,
+        includeExpired
+      });
+    }
+    if (health.retrievalMode === "vec" && embedding.length === EMBEDDING_DIMENSIONS) {
+      console.log(`[memory-search] retrieval_path=vec scope=${scope} limit=${limit2} vec_rows=${health.counts.memoryVec} searchable=${health.counts.searchable}`);
+      return this.searchWithVec(embedding, agentId, {
+        scope,
+        limit: limit2,
+        source,
+        isLead,
+        includeExpired
+      });
+    }
+    if (options.queryText && this.ftsInitialized && await this.getFtsTableSchema()) {
+      console.log(`[memory-search] retrieval_path=fts scope=${scope} limit=${limit2} reason=${embedding.length !== EMBEDDING_DIMENSIONS ? "query_dimension_mismatch" : health.reasons.join("|") || "vec_unavailable"}`);
+      return this.searchFts(options.queryText, agentId, {
+        scope,
+        limit: limit2,
+        source,
+        isLead,
+        includeExpired
+      });
+    }
+    console.log(`[memory-search] retrieval_path=fallback scope=${scope} limit=${limit2} reason=${embedding.length !== EMBEDDING_DIMENSIONS ? "query_dimension_mismatch" : health.reasons.join("|") || "vec_unavailable"}`);
+    return this.searchBruteForce(embedding, agentId, {
+      scope,
+      limit: limit2,
+      source,
+      isLead,
+      includeExpired
+    });
+  }
+  async searchHybrid(queryEmbedding, queryText, agentId, options) {
+    const overfetchLimit = Math.min(Math.max(options.limit * 4, options.limit), 100);
+    const vectorCandidates = await this.searchWithVec(queryEmbedding, agentId, {
+      ...options,
+      limit: overfetchLimit
+    });
+    const ftsCandidates = await this.searchFts(queryText, agentId, {
+      ...options,
+      limit: overfetchLimit
+    });
+    const byId = new Map;
+    const rrf = new Map;
+    const cosines = new Map;
+    const sources = new Map;
+    const add = (candidate, rank) => {
+      byId.set(candidate.id, byId.get(candidate.id) ?? candidate);
+      const retrievalSource = candidate.retrievalSource === "fts" ? "fts" : "vec";
+      const candidateSources = sources.get(candidate.id) ?? new Set;
+      candidateSources.add(retrievalSource);
+      sources.set(candidate.id, candidateSources);
+      if (retrievalSource === "vec")
+        cosines.set(candidate.id, candidate.similarity);
+      rrf.set(candidate.id, (rrf.get(candidate.id) ?? 0) + computeRrfScore(rank, 1));
+    };
+    vectorCandidates.forEach(add);
+    ftsCandidates.forEach(add);
+    await this.fillCosines(queryEmbedding, [...byId.keys()], cosines);
+    return [...byId.values()].map((candidate) => {
+      const similarity = fusedSimilarity(cosines.get(candidate.id) ?? 0, rrf.get(candidate.id) ?? 0);
+      return {
+        ...candidate,
+        rawSimilarity: similarity,
+        similarity,
+        retrievalSource: retrievalSourceFor(sources.get(candidate.id) ?? new Set),
+        recencyDecayApplied: false
+      };
+    }).sort((a, b) => b.similarity - a.similarity).slice(0, options.limit);
+  }
+  async fillCosines(queryEmbedding, ids, cosines) {
+    const missing = ids.filter((id) => !cosines.has(id));
+    if (missing.length === 0)
+      return;
+    const rows = await getDbClient().query(`SELECT id, embedding FROM agent_memory WHERE id IN (${missing.map(() => "?").join(",")})`, missing);
+    for (const row of rows) {
+      if (!row.embedding)
+        continue;
+      const embedding = deserializeEmbedding(row.embedding);
+      if (embedding.length !== queryEmbedding.length)
+        continue;
+      cosines.set(row.id, Math.max(0, cosineSimilarity(queryEmbedding, embedding)));
+    }
+  }
+  async searchFts(queryText, agentId, options) {
+    const match = this.buildFtsMatch(queryText);
+    if (!match)
+      return [];
+    const { scope, limit: limit2, source, isLead, includeExpired } = options;
+    const conditions = ["memory_fts MATCH ?"];
+    const params = [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(limit2 * 4, limit2), 100);
+      const rows = await getDbClient().query(`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 ?`, [...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)),
+          rawSimilarity,
+          retrievalSource: "fts",
+          recencyDecayApplied: true
+        };
+      }).sort((a, b) => b.similarity - a.similarity).slice(0, limit2);
+    } catch (err) {
+      console.warn("[memory-fts] query failed:", err.message);
+      return [];
+    }
+  }
+  buildFtsMatch(queryText) {
+    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 ");
+  }
+  async searchWithVec(queryEmbedding, agentId, options) {
+    const { scope, limit: limit2, source, isLead, includeExpired } = options;
+    const embeddingBuffer = serializeEmbedding(queryEmbedding);
+    const knnLimit = Math.min(Math.max(limit2, this.getVecCount()), 4096);
+    const conditions = ["v.embedding MATCH ?"];
+    const params = [embeddingBuffer];
+    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'))");
+    }
+    conditions.push("v.k = ?");
+    params.push(knnLimit);
+    const rows = await getDbClient().query(`SELECT m.*, v.distance
+       FROM memory_vec v
+       JOIN agent_memory m ON m.id = v.memory_id
+       WHERE ${conditions.join(" AND ")}
+       ORDER BY v.distance
+       LIMIT ?`, [...params, limit2]);
+    const candidates = [];
+    for (const row of rows) {
+      const similarity = 1 - row.distance;
+      if (similarity < minSimilarity())
+        continue;
+      candidates.push({ ...rowToCandidate(row, similarity), retrievalSource: "vec" });
+    }
+    return candidates;
+  }
+  async searchBruteForce(queryEmbedding, agentId, options) {
+    const { scope, limit: limit2, source, isLead, includeExpired } = options;
+    const conditions = ["embedding IS NOT NULL"];
+    const params = [];
+    this.addScopeConditions(conditions, params, agentId, scope, isLead);
+    if (source) {
+      conditions.push("source = ?");
+      params.push(source);
+    }
+    if (!includeExpired) {
+      conditions.push("(expiresAt IS NULL OR expiresAt > datetime('now'))");
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const rows = await getDbClient().query(`SELECT * FROM agent_memory ${whereClause}`, params);
+    const candidates = [];
+    for (const row of rows) {
+      if (!row.embedding)
+        continue;
+      const emb = deserializeEmbedding(row.embedding);
+      if (emb.length !== queryEmbedding.length)
+        continue;
+      const similarity = cosineSimilarity(queryEmbedding, emb);
+      if (similarity < minSimilarity())
+        continue;
+      candidates.push({ ...rowToCandidate(row, similarity), retrievalSource: "fallback" });
+    }
+    candidates.sort((a, b) => b.similarity - a.similarity);
+    return candidates.slice(0, limit2);
+  }
+  addScopeConditions(conditions, params, agentId, scope, isLead, tableAlias = "") {
+    const col = (name) => tableAlias ? `${tableAlias}.${name}` : name;
+    if (!isLead) {
+      if (scope === "agent") {
+        conditions.push(`${col("agentId")} = ? AND ${col("scope")} = 'agent'`);
+        params.push(agentId);
+      } else if (scope === "swarm") {
+        conditions.push(`${col("scope")} = 'swarm'`);
+      } else {
+        conditions.push(`(${col("agentId")} = ? OR ${col("scope")} = 'swarm')`);
+        params.push(agentId);
+      }
+    } else {
+      if (scope === "agent") {
+        conditions.push(`${col("scope")} = 'agent'`);
+      } else if (scope === "swarm") {
+        conditions.push(`${col("scope")} = 'swarm'`);
+      }
+    }
+  }
+  buildListWhereClause(agentId, options) {
+    const { scope = "all", isLead = false, ownerAgentId, source, sourcePath } = options;
+    const conditions = [];
+    const params = [];
+    this.addScopeConditions(conditions, params, agentId, scope, isLead);
+    if (ownerAgentId) {
+      conditions.push("agentId = ?");
+      params.push(ownerAgentId);
+    }
+    if (source) {
+      conditions.push("source = ?");
+      params.push(source);
+    }
+    const sourcePathNeedle = sourcePath?.trim().toLowerCase();
+    if (sourcePathNeedle) {
+      conditions.push("instr(lower(coalesce(sourcePath, '')), ?) > 0");
+      params.push(sourcePathNeedle);
+    }
+    return {
+      whereClause: conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "",
+      params
+    };
+  }
+  async list(agentId, options = {}) {
+    const { limit: limit2 = 20, offset = 0 } = options;
+    const { whereClause, params } = this.buildListWhereClause(agentId, options);
+    const queryParams = [...params, limit2, offset];
+    const rows = await getDbClient().query(`SELECT * FROM agent_memory ${whereClause} ORDER BY createdAt DESC LIMIT ? OFFSET ?`, queryParams);
+    return rows.map(rowToAgentMemory);
+  }
+  async count(agentId, options = {}) {
+    const { whereClause, params } = this.buildListWhereClause(agentId, options);
+    const row = await getDbClient().get(`SELECT COUNT(*) AS count FROM agent_memory ${whereClause}`, params);
+    return row?.count ?? 0;
+  }
+  isSourceProtected(source) {
+    return PROTECTED_SOURCES.has(source);
+  }
+  async edit(input) {
+    if (!input.id && !(input.key && input.scope)) {
+      throw new Error("memory edit requires either id or key+scope");
+    }
+    const { result, ftsContent } = await getDbClient().transaction(async (tx) => {
+      const row = input.id ? await tx.get("SELECT * FROM agent_memory WHERE id = ?", [input.id]) : await tx.get(`SELECT * FROM agent_memory
+             WHERE key = ? AND scope = ? AND coalesce(agentId, '') = coalesce(?, '')
+             ORDER BY chunkIndex ASC
+             LIMIT 1`, [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 {
+          result: {
+            memory: rowToAgentMemory(row),
+            changed: false,
+            previousVersion,
+            version: previousVersion,
+            contentHash: nextHash
+          },
+          ftsContent: null
+        };
+      }
+      const nextVersion = previousVersion + 1;
+      const now = new Date().toISOString();
+      await tx.run(`INSERT INTO agent_memory_version (id, memory_id, version, content, contentHash, intent, operation, changedByAgentId, createdAt, updatedAt, created_by, updated_by)
+         VALUES (?, ?, ?, ?, ?, ?, 'edit', ?, ?, ?, ?, ?)`, [
+        crypto.randomUUID(),
+        row.id,
+        nextVersion,
+        nextContent,
+        nextHash,
+        input.intent,
+        input.changedByAgentId ?? null,
+        now,
+        now,
+        input.changedByAgentId ?? null,
+        input.changedByAgentId ?? null
+      ]);
+      await tx.run(`UPDATE agent_memory
+         SET content = ?, contentHash = ?, version = ?, updatedAt = ?
+         WHERE id = ?`, [nextContent, nextHash, nextVersion, now, row.id]);
+      return {
+        result: {
+          memory: rowToAgentMemory({
+            ...row,
+            content: nextContent,
+            contentHash: nextHash,
+            version: nextVersion,
+            updatedAt: now
+          }),
+          changed: true,
+          previousVersion,
+          version: nextVersion,
+          contentHash: nextHash
+        },
+        ftsContent: nextContent
+      };
+    });
+    if (ftsContent !== null) {
+      await this.syncFtsRow(result.memory.id, result.memory.name, ftsContent);
+    }
+    return result;
+  }
+  async listForCuration(agentId) {
+    const db = getDbClient();
+    const protectedList = [...PROTECTED_SOURCES].map((s) => `'${s}'`).join(",");
+    if (agentId) {
+      return db.query(`SELECT id, source, name, createdAt FROM agent_memory
+         WHERE agentId = ? AND source NOT IN (${protectedList})`, [agentId]);
+    }
+    return db.query(`SELECT id, source, name, createdAt FROM agent_memory
+       WHERE source NOT IN (${protectedList})`);
+  }
+  async listForReembedding(options) {
+    const db = getDbClient();
+    if (options?.agentId) {
+      return db.query("SELECT id, content FROM agent_memory WHERE agentId = ?", [options.agentId]);
+    }
+    return db.query("SELECT id, content FROM agent_memory");
+  }
+  async purgeByIds(ids) {
+    if (ids.length === 0)
+      return;
+    if (this.vecInitialized && this.getVecTableSchema()) {
+      const placeholders = ids.map(() => "?").join(",");
+      await getDbClient().run(`DELETE FROM memory_vec WHERE memory_id IN (${placeholders})`, ids);
+    }
+    await this.deleteFtsRows(ids);
+  }
+  async delete(id) {
+    await this.purgeByIds([id]);
+    const result = await getDbClient().run("DELETE FROM agent_memory WHERE id = ?", [id]);
+    return result.changes > 0;
+  }
+  async deleteBySourcePath(sourcePath, agentId) {
+    const db = getDbClient();
+    const ids = await db.query("SELECT id FROM agent_memory WHERE sourcePath = ? AND agentId = ?", [sourcePath, agentId]);
+    await this.purgeByIds(ids.map((r) => r.id));
+    const result = await db.run("DELETE FROM agent_memory WHERE sourcePath = ? AND agentId = ?", [
+      sourcePath,
+      agentId
+    ]);
+    return ids.length || result.changes;
+  }
+  async purgeExpired() {
+    const db = getDbClient();
+    const expiredIds = await db.query("SELECT id FROM agent_memory WHERE expiresAt IS NOT NULL AND expiresAt <= datetime('now')");
+    if (expiredIds.length === 0)
+      return 0;
+    const batchSize = 500;
+    for (let i = 0;i < expiredIds.length; i += batchSize) {
+      await this.purgeByIds(expiredIds.slice(i, i + batchSize).map((r) => r.id));
+    }
+    const result = await db.run("DELETE FROM agent_memory WHERE expiresAt IS NOT NULL AND expiresAt <= datetime('now')");
+    console.log(`[memory] Purged ${result.changes} expired memory row(s) (vec cleanup: ${expiredIds.length} id(s))`);
+    return result.changes;
+  }
+  async updateEmbedding(id, embedding, model) {
+    const db = getDbClient();
+    const buffer = serializeEmbedding(embedding);
+    await db.run("UPDATE agent_memory SET embedding = ?, embeddingModel = ? WHERE id = ?", [
+      buffer,
+      model,
+      id
+    ]);
+    if (this.vecInitialized && this.getVecTableSchema()) {
+      const vecBuffer = this.toVecBuffer(embedding);
+      if (!vecBuffer) {
+        console.warn(`[memory-vec] update skipped memory_id=${id} reason=invalid_dimensions dimensions=${embedding.length} expected=${EMBEDDING_DIMENSIONS}`);
+        return;
+      }
+      try {
+        await db.run("DELETE FROM memory_vec WHERE memory_id = ?", [id]);
+        await db.run("INSERT INTO memory_vec(memory_id, embedding) VALUES (?, ?)", [id, vecBuffer]);
+      } catch (err) {
+        console.error(`[memory-vec] update failed memory_id=${id}: ${err.message}`);
+      }
+    }
+  }
+  async getStats(agentId) {
+    const db = getDbClient();
+    const total = await db.get("SELECT COUNT(*) as count FROM agent_memory WHERE agentId = ?", [agentId]);
+    const bySourceRows = await db.query("SELECT source, COUNT(*) as count FROM agent_memory WHERE agentId = ? GROUP BY source", [agentId]);
+    const byScopeRows = await db.query("SELECT scope, COUNT(*) as count FROM agent_memory WHERE agentId = ? GROUP BY scope", [agentId]);
+    const withEmbeddings = await db.get("SELECT COUNT(*) as count FROM agent_memory WHERE agentId = ? AND embedding IS NOT NULL", [agentId]);
+    const expired = await db.get("SELECT COUNT(*) as count FROM agent_memory WHERE agentId = ? AND expiresAt IS NOT NULL AND expiresAt <= datetime('now')", [agentId]);
+    const bySource = {};
+    for (const row of bySourceRows)
+      bySource[row.source] = row.count;
+    const byScope = {};
+    for (const row of byScopeRows)
+      byScope[row.scope] = row.count;
+    return {
+      total: total?.count ?? 0,
+      bySource,
+      byScope,
+      withEmbeddings: withEmbeddings?.count ?? 0,
+      expired: expired?.count ?? 0
+    };
+  }
+  getHealthCounts() {
+    const db = getDb();
+    const tableExists = this.getVecTableSchema() !== null;
+    const tableUsable = tableExists && isSqliteVecAvailable();
+    const count = (sql) => db.prepare(sql).get()?.count ?? 0;
+    return {
+      total: count("SELECT COUNT(*) as count FROM agent_memory"),
+      withEmbedding: count("SELECT COUNT(*) as count FROM agent_memory WHERE embedding IS NOT NULL"),
+      validEmbedding: count(`SELECT COUNT(*) as count FROM agent_memory WHERE embedding IS NOT NULL AND length(embedding) = ${VECTOR_BYTES}`),
+      invalidEmbedding: count(`SELECT COUNT(*) as count FROM agent_memory WHERE embedding IS NOT NULL AND length(embedding) != ${VECTOR_BYTES}`),
+      searchable: count(`SELECT COUNT(*) as count FROM agent_memory
+         WHERE embedding IS NOT NULL
+           AND length(embedding) = ${VECTOR_BYTES}
+           AND (expiresAt IS NULL OR expiresAt > datetime('now'))`),
+      memoryVec: tableUsable ? count("SELECT COUNT(*) as count FROM memory_vec") : 0,
+      missingFromVec: tableUsable ? count(`SELECT COUNT(*) as count
+             FROM agent_memory m
+             LEFT JOIN memory_vec v ON v.memory_id = m.id
+             WHERE m.embedding IS NOT NULL
+               AND length(m.embedding) = ${VECTOR_BYTES}
+               AND v.memory_id IS NULL`) : count(`SELECT COUNT(*) as count FROM agent_memory WHERE embedding IS NOT NULL AND length(embedding) = ${VECTOR_BYTES}`),
+      extraInVec: tableUsable ? count(`SELECT COUNT(*) as count
+             FROM memory_vec v
+             LEFT JOIN agent_memory m ON m.id = v.memory_id
+             WHERE m.id IS NULL`) : 0
+    };
+  }
+  getHealth() {
+    const schema = this.getVecTableSchema();
+    const counts = this.getHealthCounts();
+    const reasons = [];
+    if (!isSqliteVecAvailable())
+      reasons.push("sqlite_vec_extension_unavailable");
+    if (!schema)
+      reasons.push("memory_vec_table_missing");
+    if (!this.vecInitialized)
+      reasons.push("memory_vec_not_initialized");
+    if (counts.memoryVec === 0)
+      reasons.push("memory_vec_empty");
+    if (counts.missingFromVec > 0)
+      reasons.push("memory_vec_missing_embeddings");
+    if (counts.extraInVec > 0)
+      reasons.push("memory_vec_extra_rows");
+    return {
+      sqliteVec: {
+        extensionLoaded: isSqliteVecAvailable(),
+        tableExists: schema !== null,
+        initialized: this.vecInitialized,
+        vectorDimensions: EMBEDDING_DIMENSIONS,
+        distanceMetric: "cosine",
+        schema,
+        lastPopulate: this.lastPopulate
+      },
+      counts,
+      retrievalMode: reasons.length === 0 ? "vec" : "fallback",
+      reasons
+    };
+  }
+}
+var VECTOR_BYTES, FTS_DELETE_EXTRA_SQL = `DELETE FROM memory_fts
+  WHERE memory_id NOT IN (SELECT id FROM agent_memory)`, FTS_MISSING_IDS_SQL = `SELECT m.id FROM agent_memory m
+  WHERE m.id NOT IN (SELECT memory_id FROM memory_fts WHERE memory_id IS NOT NULL)`, FTS_POPULATE_BATCH_SIZE = 500;
+var init_sqlite_store = __esm(() => {
+  init_db();
+  init_embedding();
+  init_profile_sync();
+  init_constants();
+  init_reranker();
+  VECTOR_BYTES = EMBEDDING_DIMENSIONS * Float32Array.BYTES_PER_ELEMENT;
+});
+
+// src/be/memory/index.ts
+var embeddingProvider = null;
+var memoryStore = null;
+function getEmbeddingProvider() {
+  if (!embeddingProvider) {
+    const { OpenAIEmbeddingProvider: OpenAIEmbeddingProvider2 } = (init_openai_embedding(), __toCommonJS(exports_openai_embedding));
+    embeddingProvider = new OpenAIEmbeddingProvider2;
+  }
+  return embeddingProvider;
+}
+function resetEmbeddingProvider() {
+  embeddingProvider = null;
+}
+function getMemoryStore() {
+  if (!memoryStore) {
+    const { SqliteMemoryStore: SqliteMemoryStore2 } = (init_sqlite_store(), __toCommonJS(exports_sqlite_store));
+    memoryStore = new SqliteMemoryStore2;
+  }
+  return memoryStore;
+}
+
+export { cosineSimilarity, serializeEmbedding, deserializeEmbedding, init_embedding, OpenAI, init_openai, CANDIDATE_SET_MULTIPLIER, isGraphExpansionEnabled, EMBEDDING_DIMENSIONS, init_constants, computeScore, rerank, init_reranker, rowToCandidate, init_sqlite_store, getEmbeddingProvider, resetEmbeddingProvider, getMemoryStore };