superlocalmemory 3.8.9 → 3.8.10

package/src/superlocalmemory/storage/embedding_migrator.py

@@ -412,29 +412,43 @@ def backfill_missing_embeddings(
                 continue
             try:
                 embedding_json = json.dumps(vec)
-                # Mirror run_embedding_migration's write path exactly.
-                db.execute(
-                    "UPDATE atomic_facts SET embedding = ? WHERE fact_id = ?",
-                    (embedding_json, fid),
-                )
                 # Metadata is not an independent record: it is the pointer to
                 # a sqlite-vec row. Creating it before the vector payload leaves
                 # semantic recall permanently blind while reporting success.
                 # VectorStore owns the atomic pair and repairs legacy orphans.
-                if (
-                    vector_store is not None
-                    and getattr(vector_store, "available", False)
-                    and not vector_store.upsert(
+                projection_written = False
+                if vector_store is not None and getattr(vector_store, "available", False):
+                    projection_written = vector_store.upsert(
                         fid,
                         pid,
                         vec,
                         model_name=current_model,
                     )
-                ):
-                    logger.warning(
-                        "backfill: vector projection failed for fact %s",
-                        fid[:16],
+                    if not projection_written:
+                        # Keep the canonical embedding NULL so the next
+                        # bounded self-heal pass retries this fact.  The old
+                        # order wrote JSON first, permanently removed the fact
+                        # from the backfill query, and silently stranded recall
+                        # without its sqlite-vec projection.
+                        logger.warning(
+                            "backfill: vector projection failed for fact %s; "
+                            "leaving it pending for retry",
+                            fid[:16],
+                        )
+                        continue
+
+                try:
+                    # Publish the canonical JSON only after the derived vector
+                    # projection is durable.  When sqlite-vec is unavailable,
+                    # this remains the supported JSON-only fallback path.
+                    db.execute(
+                        "UPDATE atomic_facts SET embedding = ? WHERE fact_id = ?",
+                        (embedding_json, fid),
                     )
+                except Exception:
+                    if projection_written and vector_store is not None:
+                        vector_store.delete(fid)
+                    raise
                 embedded += 1
                 # Cooperative yield: release db._lock briefly so concurrent
                 # user writes can acquire it between facts.  Without this,

package/src/superlocalmemory/storage/write_coordinator.py

@@ -223,6 +223,7 @@ class _Execution:
     result: WriteResult | None = None
     error: BaseException | None = None
     cancelled: bool = False
+    commit_started: bool = False
 
 
 class WriteCoordinator:
@@ -432,11 +433,7 @@ class WriteCoordinator:
             deadline=time.monotonic() + timeout,
         )
         self._enqueue(item)
-        remaining = max(0.0, item.deadline - time.monotonic())
-        if not item.completion.wait(remaining):
-            with self._condition:
-                item.cancelled = True
-            raise WriteDeadlineExceededError("canonical write exceeded its caller deadline")
+        self._wait_for_completion(item)
         if item.error is not None:
             raise item.error
         return item.rows or []
@@ -480,17 +477,31 @@ class WriteCoordinator:
             command=command,
         )
         self._enqueue(item)
-        remaining = max(0.0, item.deadline - time.monotonic())
-        if not item.completion.wait(remaining):
-            with self._condition:
-                item.cancelled = True
-            raise WriteDeadlineExceededError("canonical write exceeded its caller deadline")
+        self._wait_for_completion(item)
         if item.error is not None:
             raise item.error
         if item.result is None:  # pragma: no cover - defensive worker invariant
             raise WriteCoordinatorError("canonical command completed without a receipt")
         return item.result
 
+    def _wait_for_completion(self, item: _Execution) -> None:
+        """Cancel before commit or wait through an already-linearized commit."""
+        remaining = max(0.0, item.deadline - time.monotonic())
+        if item.completion.wait(remaining):
+            return
+        with self._condition:
+            if item.completion.is_set():
+                return
+            if not item.commit_started:
+                item.cancelled = True
+                raise WriteDeadlineExceededError(
+                    "canonical write exceeded its caller deadline"
+                )
+        # Commit is the linearization point. Once it starts, return its real
+        # result instead of reporting an ambiguous timeout followed by a
+        # durable mutation.
+        item.completion.wait()
+
     def _enqueue(self, item: _Execution) -> None:
         with self._condition:
             if self._stopping:
@@ -562,19 +573,54 @@ class WriteCoordinator:
             item.error = WriteDeadlineExceededError("canonical write expired before execution")
             item.completion.set()
             return
+        remaining = max(0.0, item.deadline - time.monotonic())
+        if not self._process_write_lock.acquire(timeout=remaining):
+            item.error = WriteDeadlineExceededError(
+                "canonical write expired waiting for its process lock"
+            )
+            item.completion.set()
+            return
         try:
-            with self._process_write_lock:
-                synchronous = "FULL" if item.lane is Lane.FOREGROUND else "NORMAL"
-                conn.execute(f"PRAGMA synchronous={synchronous}")
-                conn.execute("BEGIN IMMEDIATE")
-                if item.command is not None:
-                    item.result = self._execute_command(conn, item.command)
+            remaining = item.deadline - time.monotonic()
+            if remaining <= 0:
+                item.error = WriteDeadlineExceededError(
+                    "canonical write expired after waiting for its process lock"
+                )
+                return
+            remaining_ms = max(
+                1,
+                int(remaining * 1_000),
+            )
+            conn.execute(f"PRAGMA busy_timeout={remaining_ms}")
+            synchronous = "FULL" if item.lane is Lane.FOREGROUND else "NORMAL"
+            conn.execute(f"PRAGMA synchronous={synchronous}")
+            conn.execute("BEGIN IMMEDIATE")
+            with self._condition:
+                if item.cancelled or time.monotonic() >= item.deadline:
+                    item.error = WriteDeadlineExceededError(
+                        "canonical write expired before its mutation"
+                    )
+            if item.error is not None:
+                conn.rollback()
+                return
+            if item.command is not None:
+                item.result = self._execute_command(conn, item.command)
+            else:
+                if item.sql is None:  # pragma: no cover - execution invariant
+                    raise WriteCoordinatorError("missing coordinator SQL command")
+                cursor = conn.execute(item.sql, item.parameters)
+                item.rows = cursor.fetchall()
+            with self._condition:
+                if item.cancelled or time.monotonic() >= item.deadline:
+                    item.error = WriteDeadlineExceededError(
+                        "canonical write expired during its mutation"
+                    )
                 else:
-                    if item.sql is None:  # pragma: no cover - execution invariant
-                        raise WriteCoordinatorError("missing coordinator SQL command")
-                    cursor = conn.execute(item.sql, item.parameters)
-                    item.rows = cursor.fetchall()
-                conn.commit()
+                    item.commit_started = True
+            if item.error is not None:
+                conn.rollback()
+                return
+            conn.commit()
         except WriteCoordinatorError as exc:
             conn.rollback()
             item.error = exc
@@ -590,6 +636,7 @@ class WriteCoordinator:
             item.error = WriteCoordinatorError("canonical write command failed")
             item.error.__cause__ = exc
         finally:
+            self._process_write_lock.release()
             item.completion.set()
 
     def _execute_command(self, conn: sqlite3.Connection, command: WriteCommand) -> WriteResult: