feat(core): surgical file create/delete/rename updates via FileMonitor

- Add singleFileScanned signal and scan_single_file() to FileScanner
- Connect FileMonitor signals to TabController for per-file updates
- Add addSingleItem/removeSingleItem slots to RowBuilder
- Pre-compute thumbnailUrl in RowBuilder (eliminates blocking Python calls during scroll)
- Add selection tracking to TabController (updateSelection slot)
- Deprecate AppBridge.getThumbnailPath (moved to RowBuilder load-time)
- Disable full-directory reload on FileMonitor events

Author: dragon-Elec

core/file_monitor.py

@@ -109,11 +109,13 @@ def _on_changed(self, monitor, file, other_file, event_type):
         # Map GIO events to our signals
         if event_type == Gio.FileMonitorEvent.CREATED:
             if path:
+                print(f"[DEBUG-SURGICAL] FileMonitor: CREATED {path}")
                 self.fileCreated.emit(path)
                 self._debounce_timer.start()
 
         elif event_type == Gio.FileMonitorEvent.DELETED:
             if path:
+                print(f"[DEBUG-SURGICAL] FileMonitor: DELETED {path}")
                 self.fileDeleted.emit(path)
                 self._debounce_timer.start()
 
@@ -124,6 +126,7 @@ def _on_changed(self, monitor, file, other_file, event_type):
 
         elif event_type == Gio.FileMonitorEvent.RENAMED:
             if path and other_path:
+                print(f"[DEBUG-SURGICAL] FileMonitor: RENAMED {path} -> {other_path}")
                 self.fileRenamed.emit(path, other_path)
                 self._debounce_timer.start()
 

core/gio_bridge/scanner.py

@@ -18,6 +18,7 @@
 from gi.repository import Gio, GLib, GnomeDesktop
 import urllib.parse
 from uuid import uuid4
+import os
 
 from PySide6.QtCore import QObject, Signal, Slot, QTimer
 # from PySide6.QtGui import QImageReader # REMOVED: No longer used in main thread
@@ -40,6 +41,7 @@ class FileScanner(QObject):
     scanFinished = Signal(str)       # (session_id)
     scanError = Signal(str)
     fileAttributeUpdated = Signal(str, str, object)  # path, attribute_name, value
+    singleFileScanned = Signal(str, dict) # session_id, item dict
 
     # Valid visual extensions (thumbnails needed)
     # VISUAL_EXTENSIONS removed in favor of MIME type detection
@@ -154,6 +156,27 @@ def scan_directory(self, path: str) -> None:
             cancellable # Pass token as user_data
         )
 
+    @Slot(str)
+    def scan_single_file(self, path: str) -> None:
+        """
+        Scans a single file synchronously and emits singleFileScanned.
+        Used for surgical UI updates when a file is created/copied.
+        """
+        gfile = Gio.File.new_for_path(path)
+        try:
+            info = gfile.query_info(
+                self.QUERY_ATTRIBUTES,
+                Gio.FileQueryInfoFlags.NONE,
+                None
+            )
+            # Use the existing _process_batch logic (it expects a list of infos and parent dir)
+            parent_path = os.path.dirname(path)
+            batch = self._process_batch([info], parent_path)
+            if batch:
+                self.singleFileScanned.emit(self._session_id, batch[0])
+        except GLib.Error as e:
+            print(f"[FileScanner] Could not scan single file {path}: {e}")
+
     @Slot()
     def cancel(self) -> None:
         """Cancel any in-progress scan."""

ui/managers/row_builder.py

@@ -14,6 +14,9 @@
 
 from PySide6.QtCore import QObject, Slot, Signal, Property, QTimer
 from core.sorter import Sorter
+import hashlib
+import urllib.parse
+import os
 
 class RowBuilder(QObject):
     rowsChanged = Signal()
@@ -156,6 +159,32 @@ def setFiles(self, files: list) -> None:
     # GNOME Thumbnail Cache Size (LARGE = 256px longest edge)
     THUMBNAIL_CACHE_SIZE = 256
 
+    # GNOME thumbnail cache directory (resolved once)
+    _THUMB_CACHE_DIR = os.path.expanduser("~/.cache/thumbnails/large")
+
+    @staticmethod
+    def _resolve_thumbnail_url(path: str) -> str:
+        """
+        Pre-compute the thumbnail URL for a visual item.
+        
+        Checks the GNOME thumbnail cache (MD5 of URI -> ~/.cache/thumbnails/large/).
+        Returns a direct file:// URL if cached, else falls back to the async
+        image://thumbnail/ provider.
+        
+        This runs once per item at load time, removing all blocking I/O
+        from the QML render path.
+        """
+        try:
+            uri = "file://" + urllib.parse.quote(path)
+            md5_hash = hashlib.md5(uri.encode('utf-8')).hexdigest()
+            thumb_path = os.path.join(RowBuilder._THUMB_CACHE_DIR, f"{md5_hash}.png")
+            # [DEBUG] Force disable direct file access to test if it causes lag
+            # if os.path.exists(thumb_path):
+            #    return f"file://{thumb_path}"
+        except Exception:
+            pass
+        return f"image://thumbnail/{path}"
+
     @Slot(list)
     def appendFiles(self, new_files: list) -> None:
         """Append files (streaming mode)."""
@@ -174,6 +203,12 @@ def appendFiles(self, new_files: list) -> None:
 
             # Calculate thumbnail cap dimensions
             self._calculate_thumbnail_cap(item)
+            
+            # [PERF] Pre-compute thumbnail URL (removes blocking I/O from QML render path)
+            if item.get("isVisual") and path:
+                item["thumbnailUrl"] = self._resolve_thumbnail_url(path)
+            else:
+                item["thumbnailUrl"] = ""
 
         self._items.extend(new_files)
         self._sorted_items.extend(new_files)
@@ -224,6 +259,47 @@ def clear(self) -> None:
         self._is_loading = False
         self.rowsChanged.emit()
 
+    @Slot(dict)
+    def addSingleItem(self, item: dict) -> None:
+        """Surgically insert a single file without forcing a full scan reload."""
+        path = item.get("path")
+        print(f"[DEBUG-SURGICAL] RowBuilder: addSingleItem called for {path}")
+        if not path: return
+        
+        # Check if already exists (debounce protection)
+        for existing in self._items:
+            if existing.get("path") == path:
+                print(f"[DEBUG-SURGICAL] RowBuilder: Item already exists, ignoring {path}")
+                return
+                
+        # Apply pending dimensions
+        if path in self._pending_dimensions:
+            w, h = self._pending_dimensions.pop(path)
+            item["width"] = w
+            item["height"] = h
+            
+        self._calculate_thumbnail_cap(item)
+        if item.get("isVisual"):
+            item["thumbnailUrl"] = self._resolve_thumbnail_url(path)
+        else:
+            item["thumbnailUrl"] = ""
+            
+        self._items.append(item)
+        self._reapply_sort_and_layout()
+        print(f"[DEBUG-SURGICAL] RowBuilder: Item added. Total items: {len(self._items)}")
+        
+    @Slot(str)
+    def removeSingleItem(self, path: str) -> None:
+        """Surgically remove a single file."""
+        print(f"[DEBUG-SURGICAL] RowBuilder: removeSingleItem called for {path}")
+        if not path: return
+        for i, item in enumerate(self._items):
+            if item.get("path") == path:
+                self._items.pop(i)
+                self._reapply_sort_and_layout()
+                print(f"[DEBUG-SURGICAL] RowBuilder: Item {path} removed. Total items: {len(self._items)}")
+                break
+
     @Slot(result="QVariant") # type: ignore # Returns list of lists
     def getRows(self):
         return self._rows

ui/models/app_bridge.py

@@ -141,8 +141,13 @@ def showBackgroundContextMenu(self):
     @Slot(str, result=str)
     def getThumbnailPath(self, path: str) -> str:
         """
-        Check if a native GNOME thumbnail exists for the file.
+        [DEPRECATED] Check if a native GNOME thumbnail exists for the file.
         Returns direct file:// URL if cached, else fallback to image:// provider.
+        
+        NOTE: This method is no longer called from QML during scroll.
+        Thumbnail URL resolution has been moved to RowBuilder._resolve_thumbnail_url()
+        which pre-computes the URL at load time, eliminating blocking I/O from
+        the render path. Kept for backward compatibility.
         """
         import hashlib
         import urllib.parse

ui/models/tab_model.py

@@ -31,8 +31,14 @@ def __init__(self, main_window, initial_path: str | None = None):
         self.scanner.filesFound.connect(self._on_files_found)
         self.scanner.scanFinished.connect(self._on_scan_finished)
         self.scanner.fileAttributeUpdated.connect(self.row_builder.updateItem)
+        self.scanner.singleFileScanned.connect(self._on_single_file_scanned)
         self.selectAllRequested.connect(self.row_builder.selectAllRequested)
 
+        # 1.5. FileMonitor -> Surgical Updates
+        self.mw.file_monitor.fileCreated.connect(self._on_file_created)
+        self.mw.file_monitor.fileDeleted.connect(self._on_file_deleted)
+        self.mw.file_monitor.fileRenamed.connect(self._on_file_renamed)
+        
         # 2. Bridge reference
         # Duck-type the bridge's tab reference
         self.bridge._tab = self 
@@ -42,6 +48,18 @@ def __init__(self, main_window, initial_path: str | None = None):
         self.future_stack = []
         self._is_history_nav = False
         self._current_session_id = ""
+        self._selection = []
+
+    @property
+    def selection(self):
+        """Returns the current list of selected file paths."""
+        return self._selection
+
+    @Slot(list)
+    def updateSelection(self, paths):
+        """Receive selection updates from QML."""
+        self._selection = paths
+
 
     @Property(str, notify=pathChanged)
     def currentPath(self):
@@ -114,6 +132,31 @@ def _on_files_found(self, session_id: str, batch: list):
             return
         self.row_builder.appendFiles(batch)
 
+    def _on_single_file_scanned(self, session_id: str, item: dict):
+        if session_id != self._current_session_id:
+            return
+        print(f"[DEBUG-SURGICAL] TabController: Received single file scan for {item.get('path')}")
+        self.row_builder.addSingleItem(item)
+
+    @Slot(str)
+    def _on_file_created(self, path: str):
+        print(f"[DEBUG-SURGICAL] TabController: _on_file_created: {path} | Current path: {self._current_path}")
+        if os.path.dirname(path) == os.path.abspath(self._current_path):
+            self.scanner.scan_single_file(path)
+
+    @Slot(str)
+    def _on_file_deleted(self, path: str):
+        print(f"[DEBUG-SURGICAL] TabController: _on_file_deleted: {path} | Current path: {self._current_path}")
+        if os.path.dirname(path) == os.path.abspath(self._current_path):
+            self.row_builder.removeSingleItem(path)
+
+    @Slot(str, str)
+    def _on_file_renamed(self, old_path: str, new_path: str):
+        print(f"[DEBUG-SURGICAL] TabController: _on_file_renamed: {old_path} -> {new_path}")
+        if os.path.dirname(old_path) == os.path.abspath(self._current_path):
+            self.row_builder.removeSingleItem(old_path)
+            self.scanner.scan_single_file(new_path)
+
     def _on_scan_finished(self, session_id: str):
         if session_id != self._current_session_id:
             return
@@ -127,6 +170,15 @@ def _on_scan_finished(self, session_id: str):
     def cleanup(self):
         """Cleanup resources when tab is closed."""
         self.scanner.cancel()
+        
+        # Disconnect surgical updates
+        try: self.mw.file_monitor.fileCreated.disconnect(self._on_file_created)
+        except: pass
+        try: self.mw.file_monitor.fileDeleted.disconnect(self._on_file_deleted)
+        except: pass
+        try: self.mw.file_monitor.fileRenamed.disconnect(self._on_file_renamed)
+        except: pass
+            
         try:
             self.scanner.filesFound.disconnect()
         except: pass