feat: add SQLite-based persistent recipe cache for faster startup

Introduce a new PersistentRecipeCache service that stores recipe metadata in an SQLite database to significantly reduce application startup time. The cache eliminates the need to walk directories and parse JSON files on each launch by persisting recipe data between sessions.

Key features:
- Thread-safe singleton implementation with library-specific instances
- Automatic schema initialization and migration support
- JSON serialization for complex recipe fields (LoRAs, checkpoints, generation parameters, tags)
- File system monitoring with mtime/size validation for cache invalidation
- Environment variable toggle (LORA_MANAGER_DISABLE_PERSISTENT_CACHE) for debugging
- Comprehensive test suite covering save/load cycles, cache invalidation, and edge cases

The cache improves user experience by enabling near-instantaneous recipe loading after the initial cache population, while maintaining data consistency through file change detection.

py/services/recipe_fts_index.py

@@ -403,6 +403,78 @@ class RecipeFTSIndex:
         except Exception:
             return 0
 
+    def get_indexed_recipe_ids(self) -> Set[str]:
+        """Return all recipe IDs currently in the index.
+
+        Returns:
+            Set of recipe ID strings.
+        """
+        if not self._schema_initialized:
+            self.initialize()
+
+        if not self._schema_initialized:
+            return set()
+
+        try:
+            with self._lock:
+                conn = self._connect(readonly=True)
+                try:
+                    cursor = conn.execute("SELECT recipe_id FROM recipe_fts")
+                    return {row[0] for row in cursor.fetchall() if row[0]}
+                finally:
+                    conn.close()
+        except FileNotFoundError:
+            return set()
+        except Exception as exc:
+            logger.debug("Failed to get indexed recipe IDs: %s", exc)
+            return set()
+
+    def validate_index(self, recipe_count: int, recipe_ids: Set[str]) -> bool:
+        """Check if the FTS index matches the expected recipes.
+
+        This method validates whether the existing FTS index can be reused
+        without a full rebuild. It checks:
+        1. The index has been initialized
+        2. The count matches
+        3. The recipe IDs match
+
+        Args:
+            recipe_count: Expected number of recipes.
+            recipe_ids: Expected set of recipe IDs.
+
+        Returns:
+            True if the index is valid and can be reused, False otherwise.
+        """
+        if not self._schema_initialized:
+            self.initialize()
+
+        if not self._schema_initialized:
+            return False
+
+        try:
+            indexed_count = self.get_indexed_count()
+            if indexed_count != recipe_count:
+                logger.debug(
+                    "FTS index count mismatch: indexed=%d, expected=%d",
+                    indexed_count, recipe_count
+                )
+                return False
+
+            indexed_ids = self.get_indexed_recipe_ids()
+            if indexed_ids != recipe_ids:
+                missing = recipe_ids - indexed_ids
+                extra = indexed_ids - recipe_ids
+                if missing:
+                    logger.debug("FTS index missing %d recipe IDs", len(missing))
+                if extra:
+                    logger.debug("FTS index has %d extra recipe IDs", len(extra))
+                return False
+
+            return True
+        except Exception as exc:
+            logger.debug("FTS index validation failed: %s", exc)
+            return False
+
     # Internal helpers
 
     def _connect(self, readonly: bool = False) -> sqlite3.Connection: