fix(ops): leerer Ordner mit gesperrtem Eigen-Handle meldet nicht mehr falsch "completed" (Bug 4)

_delete_dir_skip_locked() wertete len(locked)==0 als Erfolg. Ein leerer Ordner,
dessen eigenes Handle gesperrt ist (kein gesperrtes Kind, sondern der Ordner selbst
-- z.B. von SearchIndexer.exe gehalten), hat keine gesperrte Innendatei; das
verschluckte p.rmdir()-OSError wurde so faelschlich als geloescht gewertet. Der
Worker markierte den Task "completed" und verwarf ihn statt zu retryen -- der Ordner
blieb fuer immer liegen.

Fix: Erfolg wird am echten FS-Zustand gemessen (not p.exists()); _delete_path()
liefert fuer den Eigen-Handle-Lock eine eigene Retry-Meldung.

Regressionstest: TestEmptyDirOwnHandleLocked (4 Tests). Suite 88 -> 92 gruen.
Ursache empirisch bestaetigt (Windows Search Indexer, 2026-06-13).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: Lukas Geiger

CHANGELOG.md

@@ -13,6 +13,16 @@ Format basiert auf [Keep a Changelog](https://keepachangelog.com/de/1.1.0/).
 - `.github/workflows/source-platform-smoke.yml`: CI-Matrix für `ubuntu-latest` und `macos-latest`, die die Smoke-Tests bei jedem Push/PR auf `main` ausführt.
 
 ### Behoben / Fixed
+- **Bug 4 — falsches „completed" bei leerem Verzeichnis mit gesperrtem Eigen-Handle:**
+  `_delete_dir_skip_locked()` meldete Erfolg anhand von `len(locked) == 0`. Ein
+  LEERER Ordner, dessen eigenes Handle gesperrt ist (kein gesperrtes Kind, sondern
+  der Ordner selbst — z. B. von `SearchIndexer.exe` gehalten), hat keine gesperrte
+  Innendatei; das verschluckte `p.rmdir()`-`OSError` wurde so fälschlich als gelöscht
+  gewertet. Folge: Der Worker markierte den Task „completed" und verwarf ihn, statt
+  ihn erneut zu versuchen — der Ordner blieb für immer liegen. Fix: Erfolg wird jetzt
+  am echten FS-Zustand gemessen (`not p.exists()`); `_delete_path()` liefert für den
+  Eigen-Handle-Lock eine eigene Retry-Meldung. Tests: `TestEmptyDirOwnHandleLocked`
+  (4 Tests). Ursache empirisch bestätigt (Windows Search Indexer, 2026-06-13).
 - Guard in `_refresh_status()` against race between queue reload and worker thread.
 - Thread-safe dict snapshot in `_watcher_tick` (tray).
 - `tick_all()` helper extracted; real snapshot test added.

README.de.md

@@ -109,7 +109,7 @@ stehen, aber temporär durch einen Cloud-Sync-Provider blockiert werden.
 - **P3 (fertig):** Präventiv-Wächter (Änderungsrate *konfigurierter* Ordner
   beobachten → Sync-Client automatisch pausieren/fortsetzen; bounded + stat-only,
   hydratisiert keine Online-only-Placeholder; opt-in).
-- **Tests:** `pytest`, **88 grün** (Core + P2/P3 + i18n + Multicloud-Regressionen).
+- **Tests:** `pytest`, **92 grün** (Core + P2/P3 + i18n + Multicloud + Leerordner-Eigen-Handle-Lock-Regressionen).
 - **Im Lifetest gehärtet (2026-05-29):** `is_running()/pause()` robust gegen
   nicht-UTF-8-`tasklist`-Ausgabe; `delete` entfernt read-only-Attribute statt an
   WinError 5 zu scheitern. Erster echter Einsatz: ein Ordner-Rename, den manuelle

README.md

@@ -110,7 +110,7 @@ cloud-sync provider.
 - **P3 (done):** Preventive watcher (observes the change rate of *configured*
   folders → pauses/resumes the sync client; bounded, stat-only, does not
   hydrate online-only placeholders; opt-in).
-- **Tests:** `pytest`, 88 passing (core + P2/P3 + i18n + multicloud regressions).
+- **Tests:** `pytest`, 92 passing (core + P2/P3 + i18n + multicloud + empty-dir own-handle-lock regressions).
 - **Open/future:** more provider adapters (Dropbox / Google Drive / iCloud);
   optional suppression of sync-client relaunch during long operations.
 

TODO.md

@@ -43,6 +43,12 @@ Beim Port der copy+delete-Logik in den ellmos-filecommander-mcp-Server (TypeScri
       `_delete_dir_skip_locked()` in ops.py: Best-effort-Bereinigung, überspringt EBUSY-Dateien.
       `_delete_path()` nutzt es automatisch wenn `_rmtree()` mit Lock-Fehler scheitert.
       Tests: TestDeleteDirSkipLocked (5 Tests).
+- [x] **Bug 4: leerer Ordner mit gesperrtem Eigen-Handle → falsches „completed"** — DONE 2026-06-13
+      `_delete_dir_skip_locked()` wertete `len(locked) == 0` als Erfolg; bei einem leeren,
+      am eigenen Handle gesperrten Ordner (z. B. Windows Search Indexer) gibt es keine
+      gesperrte Innendatei → das verschluckte `p.rmdir()`-OSError wurde als Erfolg gewertet,
+      der Worker verwarf den Task statt zu retryen. Fix: Erfolg = `not p.exists()`; eigene
+      Retry-Meldung in `_delete_path()`. Tests: TestEmptyDirOwnHandleLocked (4 Tests).
 
 ## Nächste Schritte (aus ROADMAP.md)
 

src/cloudlockfixer/ops.py

@@ -100,8 +100,14 @@ def _delete_path(p: Path) -> tuple[bool, str]:
                     ok, locked = _delete_dir_skip_locked(p)
                     if ok:
                         return True, "geloescht (gesperrte Innendateien uebersprungen)"
-                    names = ", ".join(str(lp.name) for lp in locked[:3])
-                    return False, f"Innendatei(en) noch gesperrt (EBUSY): {names}"
+                    if locked:
+                        names = ", ".join(str(lp.name) for lp in locked[:3])
+                        return False, f"Innendatei(en) noch gesperrt (EBUSY): {names}"
+                    # Bug 4: leeres Verzeichnis, aber sein eigenes Handle ist gesperrt
+                    return False, (
+                        "Verzeichnis-Handle selbst gesperrt (offenes Handle, "
+                        "z.B. Windows Search-Indexer) -- Retry"
+                    )
                 raise
         else:
             try:
@@ -150,7 +156,12 @@ def _delete_dir_skip_locked(p: Path) -> tuple[bool, list[Path]]:
         except OSError:
             pass
 
-    return len(locked) == 0, locked
+    # Bug 4: Erfolg am echten FS-Zustand messen, nicht an `locked`. Ein leeres
+    # Verzeichnis, dessen EIGENES Handle gesperrt ist (z.B. Windows Search-Indexer),
+    # hat KEINE gesperrte Innendatei -> locked bliebe [] und das oben verschluckte
+    # p.rmdir()-OSError wuerde faelschlich als Erfolg gewertet. Re-Check verhindert
+    # das stille "completed", sodass der Worker den Task korrekt erneut versucht.
+    return (not p.exists()), locked
 
 
 def _do_move(src: Path, dst: Path) -> tuple[bool, str, bool]:

tests/test_ebusy_and_lock_errors.py

@@ -240,3 +240,86 @@ def fake_skip(p):
 
         assert ok, f"_delete_path soll OK zurückgeben wenn skip_locked erfolgreich: {msg}"
         assert skip_called, "_delete_dir_skip_locked muss aufgerufen worden sein"
+
+
+# ── Bug 4: leeres Verzeichnis mit gesperrtem EIGEN-Handle (z.B. Search-Indexer) ──
+
+class TestEmptyDirOwnHandleLocked:
+    """Regression: ein LEERES Verzeichnis, dessen eigenes Handle gesperrt ist
+    (kein gesperrtes Kind, sondern der Ordner selbst — z.B. von SearchIndexer.exe
+    gehalten), darf NICHT fälschlich als gelöscht ('completed') gemeldet werden.
+    Sonst verwirft der Worker den Task statt ihn erneut zu versuchen (false-completed).
+    """
+
+    def _lock_rmdir(self, monkeypatch, target: Path) -> None:
+        """Path.rmdir für genau `target` mit EBUSY scheitern lassen (Handle gehalten)."""
+        original_rmdir = Path.rmdir
+
+        def fake_rmdir(self):
+            if self == target:
+                e = OSError(errno.EBUSY, "EBUSY: directory handle held by another process")
+                e.errno = errno.EBUSY
+                raise e
+            return original_rmdir(self)
+
+        monkeypatch.setattr(Path, "rmdir", fake_rmdir)
+
+    def test_skip_locked_reports_failure_when_own_handle_locked(self, tmp_path, monkeypatch):
+        d = tmp_path / "emptylocked"
+        d.mkdir()
+        self._lock_rmdir(monkeypatch, d)
+
+        ok, locked = _delete_dir_skip_locked(d)
+
+        assert not ok, "Leeres, am Eigen-Handle gesperrtes Verzeichnis darf nicht als Erfolg gelten"
+        assert locked == [], "Keine gesperrte Innendatei -> locked muss leer bleiben"
+        assert d.exists(), "Verzeichnis existiert noch (rmdir scheiterte) -> kein Erfolg"
+
+    def test_delete_path_reports_failure_and_retry_hint(self, tmp_path, monkeypatch):
+        d = tmp_path / "busyempty"
+        d.mkdir()
+
+        # rmtree muss mit Lock-Fehler scheitern, damit der skip_locked-Pfad genommen wird
+        def fake_rmtree(p, **kwargs):
+            e = OSError(errno.EBUSY, "EBUSY")
+            e.errno = errno.EBUSY
+            raise e
+
+        monkeypatch.setattr(ops, "_rmtree", fake_rmtree)
+        self._lock_rmdir(monkeypatch, d)
+
+        ok, msg = ops._delete_path(d)
+
+        assert not ok, "_delete_path muss Fehlschlag melden (kein stilles completed)"
+        assert d.exists()
+        assert "handle" in msg.lower() or "retry" in msg.lower(), \
+            f"Meldung soll Eigen-Handle-Lock/Retry benennen, war: '{msg}'"
+
+    def test_chain_stays_pending_not_completed(self, tmp_path, monkeypatch):
+        """execute_chain darf den Delete-Task NICHT als done markieren (-> Worker retryt)."""
+        d = tmp_path / "queuedempty"
+        d.mkdir()
+
+        def fake_rmtree(p, **kwargs):
+            e = OSError(errno.EBUSY, "EBUSY")
+            e.errno = errno.EBUSY
+            raise e
+
+        monkeypatch.setattr(ops, "_rmtree", fake_rmtree)
+        self._lock_rmdir(monkeypatch, d)
+
+        task = Task(chain=[Step(op="delete", src=str(d))])
+        result = ops.execute_chain(task)
+
+        assert result is False, "Kette muss fehlschlagen solange das Handle gesperrt ist"
+        assert task.status != "done", "Task darf nicht fälschlich 'done' sein"
+        assert task.last_error, "last_error muss gesetzt sein (Grundlage für nächsten Retry)"
+        assert d.exists()
+
+    def test_succeeds_once_handle_released(self, tmp_path):
+        """Gegenprobe: ohne Lock wird derselbe leere Ordner sauber gelöscht."""
+        d = tmp_path / "freed"
+        d.mkdir()
+        ok, msg = ops._delete_path(d)
+        assert ok, f"Ohne Lock muss der leere Ordner gelöscht werden: {msg}"
+        assert not d.exists()