@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 [project]
 name = "audio-transcode-watcher"
 
-version = "0.5.0"
+version = "0.5.1"
 
 description = "Watch a source folder and automatically transcode audio files to multiple formats"
 readme = "README.md"
 
@@ -21,6 +21,7 @@
     has_audio_extension,
     has_sidecar_extension,
     is_audio_file,
+    nfc_path,
     remove_empty_dirs,
     walk_audio_files,
 )
@@ -29,26 +30,47 @@
 class AudioSyncHandler(FileSystemEventHandler):
     """
     Watchdog event handler for audio file changes.
-    
+
     Handles file creation, modification, deletion, and rename events.
     """
-    
+
+    # Ignore on_modified events for files processed within this window.
+    # Prevents encode-delete loops caused by spurious filesystem events
+    # (e.g. directory mtime change after .lrc sidecar creation).
+    _EVENT_COOLDOWN = 10.0
+
     def __init__(self, config: Config) -> None:
         super().__init__()
         self.config = config
-    
+        self._processed_at: dict[str, float] = {}
+        self._processed_lock = threading.Lock()
+
+    def _mark_processed(self, path: str) -> None:
+        """Record that a file was just processed."""
+        key = nfc_path(path)
+        with self._processed_lock:
+            self._processed_at[key] = time.monotonic()
+
+    def _is_cooling_down(self, path: str) -> bool:
+        """Check if a file was recently processed and should be skipped."""
+        key = nfc_path(path)
+        with self._processed_lock:
+            ts = self._processed_at.get(key, 0.0)
+        return (time.monotonic() - ts) < self._EVENT_COOLDOWN
+
     def _process_later(self, path: str, force: bool = False) -> None:
         """Process a file after a brief delay to coalesce rapid events."""
         if not is_audio_file(path):
             return
-        
+
         # Small delay to coalesce burst events
         time.sleep(0.2)
-        
+
         if safety_guard_active(self.config):
             return
-        
+
         process_source_file(path, self.config, force=force, check_stable=True)
+        self._mark_processed(path)
 
     def on_created(self, event) -> None:
         """Handle file creation (audio or sidecar)."""
@@ -64,14 +86,18 @@ def on_modified(self, event) -> None:
         """Handle file modification (audio or sidecar)."""
         if event.is_directory:
             return
-        
+
         if safety_guard_active(self.config):
             return
-        
+
         if has_sidecar_extension(event.src_path):
             sync_sidecars(event.src_path, self.config)
-        else:
-            # Delete old outputs first, then re-encode
+        elif has_audio_extension(event.src_path):
+            # Skip spurious events for files we just finished processing.
+            # Common on Docker bind mounts where .lrc creation triggers
+            # a directory mtime change that emits modify for siblings.
+            if self._is_cooling_down(event.src_path):
+                return
             delete_outputs(event.src_path, self.config)
             self._process_later(event.src_path, force=True)
 
 
@@ -0,0 +1,158 @@
+"""Tests for the watcher module."""
+
+import time
+from types import SimpleNamespace
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from audio_transcode_watcher.config import Config, OutputConfig
+from audio_transcode_watcher.watcher import AudioSyncHandler
+
+
+@pytest.fixture
+def handler(tmp_path):
+    """Create an AudioSyncHandler with a temp config."""
+    src = tmp_path / "source"
+    src.mkdir()
+    out = tmp_path / "output"
+    out.mkdir()
+    config = Config(
+        source_path=str(src),
+        outputs=[
+            OutputConfig(name="mp3", codec="mp3", path=str(out), bitrate="192k"),
+        ],
+    )
+    return AudioSyncHandler(config)
+
+
+def _event(src_path, is_directory=False, dest_path=None):
+    """Create a minimal event object."""
+    ev = SimpleNamespace(src_path=src_path, is_directory=is_directory)
+    if dest_path is not None:
+        ev.dest_path = dest_path
+    return ev
+
+
+class TestCooldown:
+    """Tests for the event cooldown mechanism."""
+
+    def test_not_cooling_down_initially(self, handler):
+        assert not handler._is_cooling_down("/music/song.flac")
+
+    def test_cooling_down_after_mark(self, handler):
+        handler._mark_processed("/music/song.flac")
+        assert handler._is_cooling_down("/music/song.flac")
+
+    def test_cooldown_expires(self, handler):
+        handler._mark_processed("/music/song.flac")
+        # Monkey-patch the timestamp to simulate expiry
+        key = "/music/song.flac"
+        with handler._processed_lock:
+            handler._processed_at[key] = time.monotonic() - handler._EVENT_COOLDOWN - 1
+        assert not handler._is_cooling_down("/music/song.flac")
+
+    def test_cooldown_per_file(self, handler):
+        handler._mark_processed("/music/song1.flac")
+        assert handler._is_cooling_down("/music/song1.flac")
+        assert not handler._is_cooling_down("/music/song2.flac")
+
+
+class TestOnModified:
+    """Tests for on_modified event handling."""
+
+    def test_ignores_directory_events(self, handler):
+        with patch("audio_transcode_watcher.watcher.delete_outputs") as mock_del:
+            handler.on_modified(_event("/music/subdir", is_directory=True))
+            mock_del.assert_not_called()
+
+    @patch("audio_transcode_watcher.watcher.sync_sidecars")
+    @patch("audio_transcode_watcher.watcher.safety_guard_active", return_value=False)
+    def test_syncs_sidecar_on_modify(self, _safety, mock_sync, handler):
+        handler.on_modified(_event("/music/source/song.lrc"))
+        mock_sync.assert_called_once()
+
+    @patch("audio_transcode_watcher.watcher.process_source_file")
+    @patch("audio_transcode_watcher.watcher.delete_outputs")
+    @patch("audio_transcode_watcher.watcher.safety_guard_active", return_value=False)
+    @patch("audio_transcode_watcher.watcher.is_audio_file", return_value=True)
+    @patch("time.sleep")
+    def test_skips_modify_during_cooldown(
+        self, _sleep, _is_audio, _safety, mock_del, mock_proc, handler
+    ):
+        """The core bug fix: on_modified must not delete+re-encode during cooldown."""
+        handler._mark_processed("/music/source/song.flac")
+        handler.on_modified(_event("/music/source/song.flac"))
+        mock_del.assert_not_called()
+        mock_proc.assert_not_called()
+
+    @patch("audio_transcode_watcher.watcher.process_source_file")
+    @patch("audio_transcode_watcher.watcher.delete_outputs")
+    @patch("audio_transcode_watcher.watcher.safety_guard_active", return_value=False)
+    @patch("audio_transcode_watcher.watcher.is_audio_file", return_value=True)
+    @patch("time.sleep")
+    def test_processes_modify_after_cooldown(
+        self, _sleep, _is_audio, _safety, mock_del, mock_proc, handler
+    ):
+        """Real modifications (after cooldown) must still delete+re-encode."""
+        # Mark processed long ago
+        key = "/music/source/song.flac"
+        with handler._processed_lock:
+            handler._processed_at[key] = time.monotonic() - handler._EVENT_COOLDOWN - 1
+        handler.on_modified(_event(key))
+        mock_del.assert_called_once()
+        mock_proc.assert_called_once()
+
+    @patch("audio_transcode_watcher.watcher.delete_outputs")
+    @patch("audio_transcode_watcher.watcher.safety_guard_active", return_value=False)
+    def test_ignores_non_audio_non_sidecar(self, _safety, mock_del, handler):
+        """Non-audio, non-sidecar files (e.g. .txt) must be ignored."""
+        handler.on_modified(_event("/music/source/notes.txt"))
+        mock_del.assert_not_called()
+
+
+class TestOnCreated:
+    """Tests for on_created event handling."""
+
+    def test_ignores_directory_events(self, handler):
+        with patch("audio_transcode_watcher.watcher.sync_sidecars") as mock_sync:
+            handler.on_created(_event("/music/subdir", is_directory=True))
+            mock_sync.assert_not_called()
+
+    @patch("audio_transcode_watcher.watcher.sync_sidecars")
+    def test_syncs_sidecar_on_create(self, mock_sync, handler):
+        handler.on_created(_event("/music/source/song.lrc"))
+        mock_sync.assert_called_once()
+
+
+class TestOnDeleted:
+    """Tests for on_deleted event handling."""
+
+    @patch("audio_transcode_watcher.watcher.delete_outputs")
+    def test_deletes_outputs_for_audio(self, mock_del, handler):
+        handler.on_deleted(_event("/music/source/song.flac"))
+        mock_del.assert_called_once()
+
+    @patch("audio_transcode_watcher.watcher.delete_sidecars")
+    def test_deletes_sidecars_for_lrc(self, mock_del, handler):
+        handler.on_deleted(_event("/music/source/song.lrc"))
+        mock_del.assert_called_once()
+
+    @patch("audio_transcode_watcher.watcher.delete_outputs")
+    def test_ignores_non_audio(self, mock_del, handler):
+        handler.on_deleted(_event("/music/source/notes.txt"))
+        mock_del.assert_not_called()
+
+
+class TestProcessLater:
+    """Tests for _process_later marking cooldown."""
+
+    @patch("audio_transcode_watcher.watcher.process_source_file")
+    @patch("audio_transcode_watcher.watcher.safety_guard_active", return_value=False)
+    @patch("audio_transcode_watcher.watcher.is_audio_file", return_value=True)
+    @patch("time.sleep")
+    def test_marks_processed_after_encoding(
+        self, _sleep, _is_audio, _safety, _proc, handler
+    ):
+        handler._process_later("/music/source/song.flac")
+        assert handler._is_cooling_down("/music/source/song.flac")