fix(api): rerun coalesced index request even when the in-flight run fails

The trailing rerun sat after the try/finally, so an exception from
index_project skipped it and the request that coalesced behind the failed
run was silently dropped — exactly when it most needed a retry. Reschedule
inside finally, after the pending marker clears.

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

Author: phernandez

src/basic_memory/deps/services.py

@@ -964,10 +964,12 @@ async def _run_project_index(self, project_id: int, *, force_full: bool) -> None
         finally:
             rerun_force_full = _dirty_project_index.pop(project_id, None)
             _pending_project_index.discard(project_id)
-        # Re-arm outside the in-flight window (pending now cleared) so a request
-        # that raced the run gets its own pass. Bounded to one extra run per burst.
-        if rerun_force_full is not None:
-            self.schedule_project_index(project_id=project_id, force_full=rerun_force_full)
+            # Re-arm inside finally, outside the in-flight window (pending now
+            # cleared), so a request that raced the run gets its own pass even
+            # when this run raised — a failed run is exactly when the coalesced
+            # request most needs its retry. Bounded to one extra run per burst.
+            if rerun_force_full is not None:
+                self.schedule_project_index(project_id=project_id, force_full=rerun_force_full)
 
 
 @dataclass(frozen=True, slots=True)

tests/services/test_task_scheduler_semantic.py

@@ -128,6 +128,50 @@ async def test_project_index_scheduler_coalesces_requests_during_in_flight_run()
     assert 13 not in _dirty_project_index
 
 
+class FailingThenGatedProjectIndexRunner:
+    """Runner whose first run blocks until released, then raises."""
+
+    def __init__(self) -> None:
+        self.calls: list[tuple[int, bool]] = []
+        self.first_run_started = asyncio.Event()
+        self.release_first_run = asyncio.Event()
+
+    async def index_project(
+        self,
+        project_id: int,
+        *,
+        force_full: bool = False,
+    ) -> ProjectIndexCoordinatorResult:
+        self.calls.append((project_id, force_full))
+        if len(self.calls) == 1:
+            self.first_run_started.set()
+            await self.release_first_run.wait()
+            raise RuntimeError("scan blew up mid-run")
+        return cast(ProjectIndexCoordinatorResult, object())
+
+
+@pytest.mark.asyncio
+async def test_project_index_scheduler_reruns_coalesced_request_after_failed_run():
+    """A request coalesced behind a run that raises must still get its rerun —
+    a failed run is exactly when the coalesced request most needs its retry."""
+    from basic_memory.deps.services import _dirty_project_index, _pending_project_index
+
+    _clear_project_index_scheduler_state()
+    runner = FailingThenGatedProjectIndexRunner()
+    scheduler = LocalProjectIndexScheduler(project_index_runner=runner, test_mode=False)
+
+    scheduler.schedule_project_index(project_id=13)
+    await asyncio.wait_for(runner.first_run_started.wait(), timeout=1)
+    scheduler.schedule_project_index(project_id=13, force_full=True)
+
+    runner.release_first_run.set()
+    await drain_background_tasks()
+
+    assert runner.calls == [(13, False), (13, True)]
+    assert 13 not in _pending_project_index
+    assert 13 not in _dirty_project_index
+
+
 @pytest.mark.asyncio
 async def test_project_index_scheduler_single_flight_is_per_project():
     """One project's in-flight run must not block another project's run."""