memorix 1.8.8 → 1.9.0

package/dist/media-audio-runner.js

@@ -6976,6 +6976,14 @@ __export(orama_store_exports, {
   updateObservationMetadata: () => updateObservationMetadata
 });
 import { create, insert as insert2, insertMultiple, search, remove as remove2, update, count, getByID } from "@orama/orama";
+function rememberSearchMode(key, value) {
+  if (!lastSearchModeByProject.has(key) && lastSearchModeByProject.size >= MAX_SEARCH_MODE_KEYS) {
+    const oldest = lastSearchModeByProject.keys().next().value;
+    if (oldest !== void 0) lastSearchModeByProject.delete(oldest);
+  }
+  lastSearchModeByProject.delete(key);
+  lastSearchModeByProject.set(key, value);
+}
 function getLastSearchMode(projectId) {
   return lastSearchModeByProject.get(projectId ?? SEARCH_MODE_DEFAULT_KEY) ?? "fulltext";
 }
@@ -6988,9 +6996,6 @@ function makeEntryKey(projectId, observationId2) {
 function rememberObservationDoc(doc) {
   const publicDoc = { ...doc };
   delete publicDoc.embedding;
-  if (doc.projectId && typeof doc.observationId === "number") {
-    docByObservationKey.set(makeEntryKey(doc.projectId, doc.observationId), publicDoc);
-  }
   return publicDoc;
 }
 function isCommandLikeQuery(query) {
@@ -7094,7 +7099,6 @@ async function resetDb() {
   indexEmbeddingProvider = null;
   deferredCachedVectorHydration = null;
   lastSearchModeByProject.clear();
-  docByObservationKey.clear();
 }
 function isEmbeddingEnabled() {
   return embeddingEnabled;
@@ -7157,78 +7161,72 @@ function isCompatibleCachedVector(vector) {
     vector && embeddingDimensions !== null && vector.length === embeddingDimensions && vector.every(Number.isFinite)
   );
 }
-async function attachCachedVectors(database, candidates) {
-  const cachedVectors = await getCachedEmbeddings(
-    candidates.map(({ observation }) => observationEmbeddingText(observation))
-  );
-  if (db !== database) return;
-  for (let index = 0; index < candidates.length; index++) {
-    const vector = cachedVectors[index];
-    if (!isCompatibleCachedVector(vector)) continue;
-    const existing = getByID(database, candidates[index].id);
-    if (!existing || documentEmbeddingText(existing) !== observationEmbeddingText(candidates[index].observation)) continue;
-    try {
-      await update(database, candidates[index].id, { ...existing, embedding: vector });
-    } catch {
-    }
-    if (index % 50 === 0) {
-      await new Promise((resolve2) => setImmediate(resolve2));
+async function attachCachedVectors(database, observations2) {
+  const batchSize = 200;
+  for (let start = 0; start < observations2.length; start += batchSize) {
+    const batch = observations2.slice(start, start + batchSize);
+    const cachedVectors = await getCachedEmbeddings(batch.map(observationEmbeddingText));
+    if (db !== database) return;
+    for (let index = 0; index < batch.length; index++) {
+      const vector = cachedVectors[index];
+      if (!isCompatibleCachedVector(vector)) continue;
+      const id = makeOramaObservationId(batch[index].projectId, batch[index].id);
+      const existing = getByID(database, id);
+      if (!existing || documentEmbeddingText(existing) !== observationEmbeddingText(batch[index])) continue;
+      try {
+        await update(database, id, { ...existing, embedding: vector });
+      } catch {
+      }
     }
+    await new Promise((resolve2) => setImmediate(resolve2));
   }
 }
 async function hydrateIndex(observations2, options = {}) {
   const database = await getDb({ allowNetworkProbe: options.allowNetworkProbe });
-  const candidates = [];
-  for (const observation of observations2) {
-    if (!observation || !observation.id || !observation.projectId) continue;
-    const id = makeOramaObservationId(observation.projectId, observation.id);
-    if (getByID(database, id)) continue;
-    candidates.push({ observation, id });
-  }
   const deferCachedVectors = options.deferCachedVectors === true && Boolean(indexEmbeddingProvider?.getCachedEmbeddings);
-  const cachedVectors = deferCachedVectors ? candidates.map(() => null) : await getCachedEmbeddings(candidates.map(({ observation }) => observationEmbeddingText(observation)));
-  const documents = [];
-  for (let index = 0; index < candidates.length; index++) {
-    const { observation: obs, id } = candidates[index];
-    try {
-      const vector = cachedVectors[index];
-      const compatibleVector = isCompatibleCachedVector(vector) ? vector : null;
-      const doc = {
-        id,
-        observationId: obs.id,
-        entityName: obs.entityName || "",
-        type: obs.type || "discovery",
-        title: obs.title || "",
-        narrative: obs.narrative || "",
-        facts: Array.isArray(obs.facts) ? obs.facts.join(" ") : "",
-        filesModified: Array.isArray(obs.filesModified) ? obs.filesModified.join(" ") : "",
-        concepts: Array.isArray(obs.concepts) ? obs.concepts.join(" ") : "",
-        tokens: obs.tokens ?? 0,
-        createdAt: obs.createdAt || "",
-        projectId: obs.projectId,
-        accessCount: obs.accessCount ?? 0,
-        lastAccessedAt: obs.lastAccessedAt || "",
-        status: obs.status ?? "active",
-        source: obs.source || "agent",
-        sourceDetail: obs.sourceDetail ?? "",
-        valueCategory: obs.valueCategory ?? "",
-        admissionState: obs.admissionState ?? "",
-        admissionReason: obs.admissionReason ?? "",
-        visibility: obs.visibility ?? "project",
-        createdByAgentId: obs.createdByAgentId ?? "",
-        sharedWithAgentIds: JSON.stringify(obs.sharedWithAgentIds ?? []),
-        documentType: "observation",
-        knowledgeLayer: resolveKnowledgeLayer("observation", obs.sourceDetail, obs.source),
-        ...compatibleVector ? { embedding: compatibleVector } : {}
-      };
-      documents.push(doc);
-    } catch {
-    }
-  }
   let inserted = 0;
   const hydrationBatchSize = 200;
-  for (let start = 0; start < documents.length; start += hydrationBatchSize) {
-    const batch = documents.slice(start, start + hydrationBatchSize);
+  for (let start = 0; start < observations2.length; start += hydrationBatchSize) {
+    const batchObservations = observations2.slice(start, start + hydrationBatchSize).filter((observation) => observation && observation.id && observation.projectId).filter((observation) => !getByID(database, makeOramaObservationId(observation.projectId, observation.id)));
+    if (batchObservations.length === 0) continue;
+    const cachedVectors = deferCachedVectors || options.skipCachedVectors ? batchObservations.map(() => null) : await getCachedEmbeddings(batchObservations.map(observationEmbeddingText));
+    const batch = [];
+    for (let index = 0; index < batchObservations.length; index++) {
+      const obs = batchObservations[index];
+      try {
+        const compatibleVector = isCompatibleCachedVector(cachedVectors[index]) ? cachedVectors[index] : null;
+        batch.push({
+          id: makeOramaObservationId(obs.projectId, obs.id),
+          observationId: obs.id,
+          entityName: obs.entityName || "",
+          type: obs.type || "discovery",
+          title: obs.title || "",
+          narrative: obs.narrative || "",
+          facts: Array.isArray(obs.facts) ? obs.facts.join(" ") : "",
+          filesModified: Array.isArray(obs.filesModified) ? obs.filesModified.join(" ") : "",
+          concepts: Array.isArray(obs.concepts) ? obs.concepts.join(" ") : "",
+          tokens: obs.tokens ?? 0,
+          createdAt: obs.createdAt || "",
+          projectId: obs.projectId,
+          accessCount: obs.accessCount ?? 0,
+          lastAccessedAt: obs.lastAccessedAt || "",
+          status: obs.status ?? "active",
+          source: obs.source || "agent",
+          sourceDetail: obs.sourceDetail ?? "",
+          valueCategory: obs.valueCategory ?? "",
+          admissionState: obs.admissionState ?? "",
+          admissionReason: obs.admissionReason ?? "",
+          visibility: obs.visibility ?? "project",
+          createdByAgentId: obs.createdByAgentId ?? "",
+          sharedWithAgentIds: JSON.stringify(obs.sharedWithAgentIds ?? []),
+          documentType: "observation",
+          knowledgeLayer: resolveKnowledgeLayer("observation", obs.sourceDetail, obs.source),
+          ...compatibleVector ? { embedding: compatibleVector } : {}
+        });
+      } catch {
+      }
+    }
+    if (batch.length === 0) continue;
     try {
       await insertMultiple(database, batch, batch.length);
       for (const doc of batch) rememberObservationDoc(doc);
@@ -7250,7 +7248,7 @@ async function hydrateIndex(observations2, options = {}) {
     }
     await new Promise((resolve2) => setImmediate(resolve2));
   }
-  deferredCachedVectorHydration = options.skipCachedVectors ? null : deferCachedVectors ? attachCachedVectors(database, candidates).catch(() => {
+  deferredCachedVectorHydration = options.skipCachedVectors ? null : deferCachedVectors ? attachCachedVectors(database, observations2).catch(() => {
   }) : null;
   return inserted;
 }
@@ -7287,12 +7285,6 @@ async function updateObservationMetadata(projectId, observationId2, patch) {
 async function removeObservation(oramaId) {
   const database = await getDb();
   await remove2(database, oramaId);
-  for (const [key, doc] of docByObservationKey.entries()) {
-    if (doc.id === oramaId) {
-      docByObservationKey.delete(key);
-      break;
-    }
-  }
 }
 async function searchObservations(options) {
   const perf = !!process.env.MEMORIX_PERF;
@@ -7307,7 +7299,7 @@ async function searchObservations(options) {
   const modeKey = options.projectId ?? SEARCH_MODE_DEFAULT_KEY;
   const quality = options.quality ?? "balanced";
   const database = await getDb();
-  lastSearchModeByProject.set(
+  rememberSearchMode(
     modeKey,
     quality === "fast" ? "fulltext (fast profile)" : embeddingEnabled ? "hybrid" : "fulltext"
   );
@@ -7374,7 +7366,7 @@ async function searchObservations(options) {
       if (provider2) {
         const activeVectorDimensions = getVectorDimensions();
         if (activeVectorDimensions !== null && provider2.dimensions !== activeVectorDimensions) {
-          lastSearchModeByProject.set(
+          rememberSearchMode(
             modeKey,
             `fulltext (embedding dimension mismatch: provider ${provider2.dimensions}d vs index ${activeVectorDimensions}d)`
           );
@@ -7399,7 +7391,7 @@ async function searchObservations(options) {
           mark("embedding");
           const cjkRatio = (originalQuery.match(/[\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af]/g) || []).length / originalQuery.length;
           const isCJKHeavy = cjkRatio > 0.3;
-          lastSearchModeByProject.set(modeKey, "hybrid");
+          rememberSearchMode(modeKey, "hybrid");
           searchParams = {
             ...searchParams,
             mode: "hybrid",
@@ -7415,7 +7407,7 @@ async function searchObservations(options) {
         }
       }
     } catch (error) {
-      lastSearchModeByProject.set(modeKey, "fulltext (embedding unavailable)");
+      rememberSearchMode(modeKey, "fulltext (embedding unavailable)");
       console.error("[memorix] Embedding failed or timed out, falling back to fulltext search");
     }
   }
@@ -7425,7 +7417,7 @@ async function searchObservations(options) {
     results = await search(database, searchParams);
   } catch (error) {
     if (queryVector && isVectorDimensionMismatchError(error)) {
-      lastSearchModeByProject.set(modeKey, "fulltext (embedding dimension mismatch)");
+      rememberSearchMode(modeKey, "fulltext (embedding dimension mismatch)");
       console.error("[memorix] Vector search dimension mismatch detected, retrying without embeddings");
       results = await search(database, stripVectorSearchParams(searchParams));
     } else {
@@ -7447,7 +7439,7 @@ async function searchObservations(options) {
         },
         similarity: 0.25
       };
-      lastSearchModeByProject.set(modeKey, "vector-only (hybrid empty fallback)");
+      rememberSearchMode(modeKey, "vector-only (hybrid empty fallback)");
       results = await search(database, vectorOnlyParams);
     } catch {
     }
@@ -7688,7 +7680,7 @@ async function searchObservations(options) {
           const rerankedTop = neural.map((row) => candidateMap.get(row.id)).filter((entry) => entry != null);
           if (rerankedTop.length > 0) {
             intermediate = [...rerankedTop, ...intermediate.slice(RERANK_TOP_K)];
-            lastSearchModeByProject.set(modeKey, (lastSearchModeByProject.get(modeKey) ?? "fulltext") + " + neural rerank");
+            rememberSearchMode(modeKey, (lastSearchModeByProject.get(modeKey) ?? "fulltext") + " + neural rerank");
             mark("rerank(usedNeural=true)");
           }
         }
@@ -7705,7 +7697,7 @@ async function searchObservations(options) {
         );
         mark(`rerank(usedLLM=${usedLLM})`);
         if (usedLLM) {
-          lastSearchModeByProject.set(modeKey, (lastSearchModeByProject.get(modeKey) ?? "fulltext") + " + LLM rerank");
+          rememberSearchMode(modeKey, (lastSearchModeByProject.get(modeKey) ?? "fulltext") + " + LLM rerank");
           const rerankedTop = reranked.map((row) => candidateMap.get(row.id)).filter((entry) => entry != null);
           if (rerankedTop.length > 0) {
             intermediate = [...rerankedTop, ...intermediate.slice(RERANK_TOP_K)];
@@ -7778,13 +7770,6 @@ async function getObservationsByIds(ids, projectId) {
   const database = await getDb();
   const results = [];
   for (const id of ids) {
-    if (projectId) {
-      const cached = docByObservationKey.get(makeEntryKey(projectId, id));
-      if (cached) {
-        results.push(cached);
-        continue;
-      }
-    }
     const searchResult = await search(database, {
       term: "",
       includeVectors: true,
@@ -7884,7 +7869,7 @@ function formatTime(isoDate) {
     return isoDate;
   }
 }
-var db, dbInitPromise, dbGeneration, embeddingEnabled, embeddingDimensions, indexEmbeddingProvider, deferredCachedVectorHydration, docByObservationKey, NON_CJK_HYBRID_SIMILARITY, lastSearchModeByProject, SEARCH_MODE_DEFAULT_KEY, COMMAND_LOG_TITLE, COMMAND_STYLE_TITLE, COMMAND_LIKE_QUERY2, COMMAND_INTENT_QUERY, NATURAL_LANGUAGE_MARKERS;
+var db, dbInitPromise, dbGeneration, embeddingEnabled, embeddingDimensions, indexEmbeddingProvider, deferredCachedVectorHydration, NON_CJK_HYBRID_SIMILARITY, lastSearchModeByProject, SEARCH_MODE_DEFAULT_KEY, MAX_SEARCH_MODE_KEYS, COMMAND_LOG_TITLE, COMMAND_STYLE_TITLE, COMMAND_LIKE_QUERY2, COMMAND_INTENT_QUERY, NATURAL_LANGUAGE_MARKERS;
 var init_orama_store = __esm({
   "src/store/orama-store.ts"() {
     "use strict";
@@ -7905,10 +7890,10 @@ var init_orama_store = __esm({
     embeddingDimensions = null;
     indexEmbeddingProvider = null;
     deferredCachedVectorHydration = null;
-    docByObservationKey = /* @__PURE__ */ new Map();
     NON_CJK_HYBRID_SIMILARITY = 0.45;
     lastSearchModeByProject = /* @__PURE__ */ new Map();
     SEARCH_MODE_DEFAULT_KEY = "__global__";
+    MAX_SEARCH_MODE_KEYS = 4096;
     COMMAND_LOG_TITLE = /^(Ran:|Command:|Executed:)\s/i;
     COMMAND_STYLE_TITLE = /(\bfindstr\b|\bSelect-String\b|\bGet-Content\b|\bnpx\s+vitest\b|\bnpx\s+tsc\b|\b2>&1\b)/i;
     COMMAND_LIKE_QUERY2 = /\b(git|npm|npx|pnpm|yarn|node|bash|powershell|curl|memorix)\b/i;
@@ -8804,6 +8789,56 @@ var init_evidence_store = __esm({
   }
 });
 
+// src/runtime/maintenance-targets.ts
+function rowToTarget(row) {
+  return {
+    projectId: row.project_id,
+    projectRoot: row.project_root,
+    dataDir: row.data_dir,
+    updatedAt: Number(row.updated_at)
+  };
+}
+var MaintenanceTargetStore;
+var init_maintenance_targets = __esm({
+  "src/runtime/maintenance-targets.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_sqlite_db();
+    MaintenanceTargetStore = class {
+      db;
+      constructor(dataDir) {
+        this.db = getDatabase(dataDir);
+      }
+      register(input) {
+        if (!input.projectId.trim()) throw new Error("Maintenance target requires a project ID");
+        if (!input.projectRoot.trim()) throw new Error("Maintenance target requires a project root");
+        if (!input.dataDir.trim()) throw new Error("Maintenance target requires a data directory");
+        const now3 = input.now ?? Date.now();
+        this.db.prepare(`
+      INSERT INTO maintenance_targets (project_id, project_root, data_dir, updated_at)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT(project_id) DO UPDATE SET
+        project_root = excluded.project_root,
+        data_dir = excluded.data_dir,
+        updated_at = excluded.updated_at
+    `).run(input.projectId, input.projectRoot, input.dataDir, now3);
+        return this.get(input.projectId);
+      }
+      get(projectId) {
+        const row = this.db.prepare(`
+      SELECT * FROM maintenance_targets WHERE project_id = ?
+    `).get(projectId);
+        return row ? rowToTarget(row) : void 0;
+      }
+      list() {
+        return this.db.prepare(`
+      SELECT * FROM maintenance_targets ORDER BY updated_at DESC
+    `).all().map(rowToTarget);
+      }
+    };
+  }
+});
+
 // src/knowledge/workspace-store.ts
 import { randomUUID as randomUUID5 } from "crypto";
 function arrayValue(raw) {
@@ -149668,10 +149703,21 @@ __export(vector_backfill_runner_exports, {
   launchDetachedVectorBackfill: () => launchDetachedVectorBackfill,
   main: () => main,
   parseVectorBackfillRequest: () => parseVectorBackfillRequest,
-  resolveVectorBackfillRunnerPath: () => resolveVectorBackfillRunnerPath
+  releaseVectorBackfillLock: () => releaseVectorBackfillLock,
+  resolveVectorBackfillRunnerPath: () => resolveVectorBackfillRunnerPath,
+  vectorBackfillLockPath: () => vectorBackfillLockPath
 });
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync10 } from "fs";
+import {
+  closeSync,
+  existsSync as existsSync10,
+  mkdirSync as mkdirSync2,
+  openSync,
+  readFileSync as readFileSync9,
+  statSync as statSync4,
+  unlinkSync,
+  writeFileSync as writeFileSync2
+} from "fs";
 import path19 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function isNonEmptyString(value) {
@@ -149698,10 +149744,104 @@ function parseVectorBackfillRequest(raw) {
     dataDir: value.dataDir
   };
 }
+function vectorBackfillLockPath(dataDir) {
+  return path19.join(dataDir, VECTOR_BACKFILL_LOCK_FILE);
+}
+function processIsAlive(pid) {
+  if (!Number.isSafeInteger(pid) || pid == null || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function readVectorBackfillLock(lockPath) {
+  try {
+    const value = JSON.parse(readFileSync9(lockPath, "utf8"));
+    if (typeof value.parentPid !== "number" || !Number.isSafeInteger(value.parentPid) || typeof value.startedAt !== "number" || !Number.isFinite(value.startedAt) || typeof value.projectId !== "string") return void 0;
+    return {
+      parentPid: value.parentPid,
+      ...typeof value.childPid === "number" ? { childPid: value.childPid } : {},
+      startedAt: value.startedAt,
+      projectId: value.projectId
+    };
+  } catch {
+    return void 0;
+  }
+}
+function writeVectorBackfillLock(lockPath, value) {
+  writeFileSync2(lockPath, `${JSON.stringify(value)}
+`, "utf8");
+}
+function acquireVectorBackfillLock(dataDir, projectId, preferredPath) {
+  const lockPath = preferredPath ?? vectorBackfillLockPath(dataDir);
+  mkdirSync2(path19.dirname(lockPath), { recursive: true });
+  const initial = {
+    parentPid: process.pid,
+    startedAt: Date.now(),
+    projectId
+  };
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const fd = openSync(lockPath, "wx");
+      try {
+        writeFileSync2(fd, `${JSON.stringify(initial)}
+`, "utf8");
+      } finally {
+        closeSync(fd);
+      }
+      return {
+        path: lockPath,
+        setChildPid(pid) {
+          try {
+            writeVectorBackfillLock(lockPath, { ...initial, childPid: pid });
+          } catch {
+          }
+        },
+        release() {
+          try {
+            unlinkSync(lockPath);
+          } catch {
+          }
+        }
+      };
+    } catch (error) {
+      if (error.code !== "EEXIST") return void 0;
+      const existing = readVectorBackfillLock(lockPath);
+      const ownerAlive = existing && (processIsAlive(existing.childPid) || processIsAlive(existing.parentPid));
+      if (ownerAlive) return void 0;
+      let stale = false;
+      try {
+        stale = Date.now() - statSync4(lockPath).mtimeMs >= STALE_LOCK_RECOVERY_MS;
+      } catch {
+        stale = false;
+      }
+      if (!existing && !stale) return void 0;
+      try {
+        unlinkSync(lockPath);
+      } catch {
+        return void 0;
+      }
+    }
+  }
+  return void 0;
+}
+function releaseVectorBackfillLock(lockPath = process.env.MEMORIX_VECTOR_BACKFILL_LOCK) {
+  if (!lockPath) return;
+  const lock = readVectorBackfillLock(lockPath);
+  if (lock && lock.childPid !== process.pid) return;
+  try {
+    unlinkSync(lockPath);
+  } catch {
+  }
+}
 function launchDetachedVectorBackfill(request, options = {}) {
   const runnerPath = options.runnerPath ?? resolveVectorBackfillRunnerPath();
   const exists = options.exists ?? existsSync10;
   if (!exists(runnerPath)) return false;
+  const lock = acquireVectorBackfillLock(request.dataDir, request.projectId, options.lockPath);
+  if (!lock) return false;
   try {
     const child = (options.spawn ?? spawn2)(process.execPath, [runnerPath], {
       cwd: request.projectRoot,
@@ -149711,14 +149851,23 @@ function launchDetachedVectorBackfill(request, options = {}) {
       stdio: "ignore",
       // The request contains only local project metadata, never credentials.
       // Environment transport avoids a live stdin pipe keeping the CLI alive.
-      env: { ...process.env, MEMORIX_VECTOR_BACKFILL_REQUEST: JSON.stringify(request) },
+      env: {
+        ...process.env,
+        MEMORIX_VECTOR_BACKFILL_REQUEST: JSON.stringify(request),
+        MEMORIX_VECTOR_BACKFILL_LOCK: lock.path
+      },
       windowsHide: true
     });
+    if (child.pid) lock.setChildPid(child.pid);
+    else lock.release();
     child.once?.("error", () => {
     });
+    child.once?.("close", () => lock.release());
+    if (typeof child.once !== "function") lock.release();
     child.unref();
-    return true;
+    return Boolean(child.pid);
   } catch {
+    lock.release();
     return false;
   }
 }
@@ -149730,12 +149879,32 @@ async function executeVectorBackfill(request) {
   await prepareSearchIndex();
   await getDeferredCachedVectorHydration()?.catch(() => {
   });
+  const queue = new MaintenanceJobStore(request.dataDir);
+  const targets = new MaintenanceTargetStore(request.dataDir);
+  let preparedRoot = request.projectRoot;
+  const prepareTarget = async (target) => {
+    if (target.projectRoot === preparedRoot) return;
+    initProjectRoot(target.projectRoot);
+    loadDotenv(target.projectRoot);
+    preparedRoot = target.projectRoot;
+  };
+  const handler = async (job) => {
+    const target = targets.get(job.projectId) ?? (job.projectId === request.projectId ? { projectId: request.projectId, projectRoot: request.projectRoot, dataDir: request.dataDir, updatedAt: Date.now() } : void 0);
+    if (!target) return { action: "reschedule", delayMs: 3e4 };
+    await prepareTarget(target);
+    return createProjectMaintenanceHandler(job.projectId, target.dataDir, target.projectRoot)(job);
+  };
   const worker = new MaintenanceJobWorker(
-    new MaintenanceJobStore(request.dataDir),
-    createProjectMaintenanceHandler(request.projectId, request.dataDir, request.projectRoot),
-    { projectId: request.projectId, kinds: ["vector-backfill"] }
+    queue,
+    handler,
+    { kinds: ["vector-backfill"] }
   );
-  return worker.runOnce();
+  let result = { state: "idle" };
+  while (true) {
+    result = await worker.runOnce();
+    if (result.state === "idle") break;
+  }
+  return result;
 }
 async function readStdin() {
   return new Promise((resolve2, reject) => {
@@ -149758,9 +149927,11 @@ async function main() {
 `);
     process.exitCode = 1;
   } finally {
+    releaseVectorBackfillLock();
     closeAllDatabases();
   }
 }
+var VECTOR_BACKFILL_LOCK_FILE, STALE_LOCK_RECOVERY_MS;
 var init_vector_backfill_runner = __esm({
   "src/runtime/vector-backfill-runner.ts"() {
     "use strict";
@@ -149773,7 +149944,10 @@ var init_vector_backfill_runner = __esm({
     init_orama_store();
     init_sqlite_db();
     init_maintenance_jobs();
+    init_maintenance_targets();
     init_project_maintenance();
+    VECTOR_BACKFILL_LOCK_FILE = ".memorix-vector-backfill.lock";
+    STALE_LOCK_RECOVERY_MS = 24 * 60 * 60 * 1e3;
     if (process.argv[1] && process.argv[1].endsWith("vector-backfill-runner.js")) {
       void main();
     }
@@ -149815,11 +149989,17 @@ function resetObservationRuntime() {
   embeddingWorkerProjectRoot = void 0;
   vectorMissingIds.clear();
   vectorSchemaUpgradePromise = null;
+  embeddingFailureLogTimestamps.clear();
 }
 function logEmbeddingFailureOnce(key, message) {
   const now3 = Date.now();
   const last = embeddingFailureLogTimestamps.get(key) ?? 0;
   if (now3 - last < EMBEDDING_FAILURE_LOG_COOLDOWN_MS) return;
+  if (!embeddingFailureLogTimestamps.has(key) && embeddingFailureLogTimestamps.size >= MAX_EMBEDDING_FAILURE_KEYS) {
+    const oldest = embeddingFailureLogTimestamps.keys().next().value;
+    if (oldest !== void 0) embeddingFailureLogTimestamps.delete(oldest);
+  }
+  embeddingFailureLogTimestamps.delete(key);
   embeddingFailureLogTimestamps.set(key, now3);
   console.error(message);
 }
@@ -149849,13 +150029,14 @@ function queueVectorBackfill(projectId, options = {}) {
   const dataDir = projectDir;
   if (!dataDir) return;
   void Promise.resolve().then(() => (init_maintenance_jobs(), maintenance_jobs_exports)).then(({ MaintenanceJobStore: MaintenanceJobStore2 }) => {
-    new MaintenanceJobStore2(dataDir).enqueue({
+    const job = new MaintenanceJobStore2(dataDir).enqueue({
       projectId,
       kind: "vector-backfill",
       dedupeKey: "vector-backfill",
       payload: { limit: 12 }
     });
-    if (options.detachedWorker && options.projectRoot) {
+    const due = !job || job.status === "pending" && job.runAfter <= Date.now();
+    if (due && options.detachedWorker && options.projectRoot) {
       void Promise.resolve().then(() => (init_vector_backfill_runner(), vector_backfill_runner_exports)).then(({ launchDetachedVectorBackfill: launchDetachedVectorBackfill2 }) => {
         launchDetachedVectorBackfill2({
           projectId,
@@ -150786,7 +150967,7 @@ async function backfillVectorEmbeddings(options = {}) {
     ...lastFailure ? { lastError: lastFailure } : {}
   };
 }
-var observations, nextId, projectDir, searchIndexPrepared, embeddingWriteMode, embeddingWorkerProjectRoot, corpusLoaded, loadedObservationStore, vectorMissingIds, vectorBackfillRunning, vectorSchemaUpgradePromise, lastVectorBackfill, embeddingFailureLogTimestamps, EMBEDDING_FAILURE_LOG_COOLDOWN_MS;
+var observations, nextId, projectDir, searchIndexPrepared, embeddingWriteMode, embeddingWorkerProjectRoot, corpusLoaded, loadedObservationStore, vectorMissingIds, vectorBackfillRunning, vectorSchemaUpgradePromise, lastVectorBackfill, embeddingFailureLogTimestamps, EMBEDDING_FAILURE_LOG_COOLDOWN_MS, MAX_EMBEDDING_FAILURE_KEYS;
 var init_observations = __esm({
   "src/memory/observations.ts"() {
     "use strict";
@@ -150814,6 +150995,7 @@ var init_observations = __esm({
     lastVectorBackfill = null;
     embeddingFailureLogTimestamps = /* @__PURE__ */ new Map();
     EMBEDDING_FAILURE_LOG_COOLDOWN_MS = 3e4;
+    MAX_EMBEDDING_FAILURE_KEYS = 1024;
   }
 });