fix(sync): tolerate concurrently deleted entities in moved-entity search refresh

RepositoryProjectIndexMovedEntitySearchRefresher raised RuntimeError when
any moved entity id no longer had a database row at refresh time. Move
batches commit before the refresh runs, so a concurrent delete (file
removed, note deleted via API) between move-batch commit and refresh is a
benign race — but the raise aborted the whole coordinator run before
delete batches and file indexing executed, stalling the scan.

A missing entity at refresh time is now logged and skipped; the surviving
moved entities are still refreshed. The vanished entity's search rows were
already removed with its row, so there is nothing left to repair.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Signed-off-by: phernandez <paul@basicmachines.co>

Author: phernandez

src/basic_memory/indexing/project_index_maintenance.py

@@ -6,6 +6,7 @@
 from dataclasses import dataclass
 from typing import Protocol
 
+from loguru import logger
 from sqlalchemy import bindparam, case, column, delete, select, table, text, update
 from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
 
@@ -685,14 +686,24 @@ async def refresh_moved_entities(self, entity_ids: Sequence[int]) -> None:
         missing_entity_ids = [
             entity_id for entity_id in unique_entity_ids if entity_id not in entities_by_id
         ]
+        # Trigger: a moved entity id has no row by the time the refresh reloads it.
+        # Why: move batches commit before this refresh runs, so a concurrent delete
+        #      (file removed, note deleted via API) can legitimately retire the row
+        #      in between; failing here would abort the coordinator run before delete
+        #      batches and file indexing, stalling the whole scan over a benign race.
+        # Outcome: skip the vanished ids (their search rows were removed with the
+        #          entity) and refresh the survivors.
         if missing_entity_ids:
-            raise RuntimeError(
-                "Moved entities disappeared before search refresh: "
-                f"{', '.join(str(entity_id) for entity_id in missing_entity_ids)}"
+            logger.warning(
+                "Skipping search refresh for moved entities deleted mid-run",
+                entity_ids=missing_entity_ids,
             )
 
         for entity_id in unique_entity_ids:
-            await self.entity_indexer.index_entity(entities_by_id[entity_id])
+            entity = entities_by_id.get(entity_id)
+            if entity is None:
+                continue
+            await self.entity_indexer.index_entity(entity)
 
 
 def build_project_index_move_batch_plan(

tests/indexing/test_project_index_maintenance.py

@@ -1,6 +1,6 @@
 """Tests for project-index move/delete maintenance."""
 
-from collections.abc import AsyncIterator, Iterator
+from collections.abc import AsyncIterator, Iterator, Sequence
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
 from types import SimpleNamespace
@@ -23,12 +23,14 @@
     ProjectIndexMoveRun,
     ProjectIndexMoveTarget,
     RepositoryProjectIndexMaintenanceStore,
+    RepositoryProjectIndexMovedEntitySearchRefresher,
     StoreProjectIndexMaintenanceRunner,
     build_project_index_delete_batch_plan,
     build_project_index_move_batch_plan,
     run_project_index_delete_batches,
     run_project_index_move_batches,
 )
+from basic_memory.models import Entity
 
 
 def _stub_move_store(
@@ -172,6 +174,67 @@ async def update_moved_file_content(
         return self.updates.get(moved_file.entity_id)
 
 
+@dataclass(slots=True)
+class StaticMovedEntityRepository:
+    """Return only the moved entities that still have a database row."""
+
+    entities: list[Entity]
+
+    async def find_by_ids(
+        self,
+        session: AsyncSession,
+        ids: list[int],
+    ) -> Sequence[Entity]:
+        del session
+        return [entity for entity in self.entities if entity.id in ids]
+
+
+@dataclass(slots=True)
+class RecordingMovedEntityIndexer:
+    """Record which moved entities were search-refreshed."""
+
+    indexed_entity_ids: list[int] = field(default_factory=list)
+
+    async def index_entity(self, entity: Entity) -> object:
+        self.indexed_entity_ids.append(entity.id)
+        return entity
+
+
+@pytest.mark.asyncio
+async def test_moved_entity_search_refresher_skips_entities_deleted_mid_run(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """A moved entity deleted between move commit and refresh must not abort the run."""
+    session_maker = cast(async_sessionmaker[AsyncSession], object())
+    session = FakeProjectIndexSession(results=[])
+
+    @asynccontextmanager
+    async def fake_scoped_session(
+        scoped_session_maker: async_sessionmaker[AsyncSession],
+    ) -> AsyncIterator[FakeProjectIndexSession]:
+        assert scoped_session_maker is session_maker
+        yield session
+
+    monkeypatch.setattr(
+        project_index_maintenance_module.db,
+        "scoped_session",
+        fake_scoped_session,
+    )
+
+    surviving_entity = cast(Entity, SimpleNamespace(id=10))
+    entity_indexer = RecordingMovedEntityIndexer()
+    refresher = RepositoryProjectIndexMovedEntitySearchRefresher(
+        session_maker=session_maker,
+        entity_repository=StaticMovedEntityRepository(entities=[surviving_entity]),
+        entity_indexer=entity_indexer,
+    )
+
+    # Entity 5 was deleted concurrently; only entity 10 can still be refreshed.
+    await refresher.refresh_moved_entities([10, 5, 10])
+
+    assert entity_indexer.indexed_entity_ids == [10]
+
+
 def test_project_index_move_batch_plan_builds_batches_and_progress_metadata() -> None:
     plan = build_project_index_move_batch_plan(
         moved_files={