feat: hide-from-views flag on folders

Adds a per-folder "hide from views" toggle so noisy subtrees
(screenshots, WhatsApp dumps, work archives) can be excluded from
cross-cutting views without losing indexing. Photos under a hidden
folder are still scanned, thumbnailed, embedded, OCR'd, face-
extracted — they just stop appearing in All Photos, Rated, Colors,
Map, Tags, People, Search, Duplicates, and the sidebar counts.
Navigating directly into the folder still shows every photo.

Schema (migration 0007_folder_hidden):
- folders.is_hidden   user-set toggle, default false
- photos.is_hidden    denormalized effective flag (true iff any
                      ancestor folder is hidden), indexed so cross-
                      cutting queries stay on the existing planner
                      paths

The denorm is maintained by two paths:
- The scanner walks the ancestry chain on insert, with a per-scan
  memoized cache so each folder is resolved once per scan.
- POST /api/v1/folders/{id}/hide flips folders.is_hidden and runs a
  WITH RECURSIVE CTE to recompute every folder's effective state in
  one query, then bulk-updates photos WHERE IS DISTINCT FROM. Runs
  in ~10 ms on a 13k-photo library.

Filters added (cross-cutting queries):
- /library/stats — every sidebar badge via a shared `visible` filter
- /photos (list) — only when neither folder_id nor heap_id is set;
  folder browse and heap browse always show everything
- /photos/map
- /library/duplicates/groups
- /folders/tree photo_count subquery
- /tags count_subq (drives Tags + People sidebar counts)
- services/duplicates.regroup_duplicates (so hidden dupes never
  contaminate the Duplicates view)
- services/search.hybrid_search — both semantic (pgvector) and FTS
  legs join photos so rankings don't include hidden results

Intentionally NOT filtered:
- /photos?folder_id=X and /photos?heap_id=X (user-intentional browse)
- /library/maintenance/pipeline-stats (tracks real worker state)
- cleanup service (disk-level ops, not views)

Frontend:
- sourceFolders.setHidden(id, hidden) API client method
- FolderTreeNode.is_hidden carried through the tree into TreeItem
- LeftSidebar kebab menu: "Hide from views" / "Show in views" with a
  mutation that invalidates folders, photos, stats, and tags caches
- Hidden folder rows swap the Folder icon for EyeOff and render the
  label italic/muted so the state is visible at a glance

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

backend/app/services/duplicates.py

@@ -131,14 +131,16 @@ async def regroup_duplicates(threshold: int = DEFAULT_THRESHOLD) -> dict:
     one.
     """
     async with AsyncSessionLocal() as session:
-        # Pull (id, phash) for every non-discarded photo with a hash.
-        # Discarded photos are excluded so we don't keep showing groups
-        # made up of trashed copies.
+        # Pull (id, phash) for every visible photo with a hash. Discarded
+        # and hidden photos are excluded so we don't keep showing groups
+        # made up of trashed copies or members of folders the user
+        # deliberately excluded from cross-cutting views.
         rows = (
             await session.execute(
                 select(Photo.id, Photo.phash)
                 .where(Photo.phash.is_not(None))
                 .where(Photo.is_discarded.is_(False))
+                .where(Photo.is_hidden.is_(False))
             )
         ).all()
 

backend/app/services/search.py

@@ -41,13 +41,19 @@ async def hybrid_search(
             embedder = registry.get_embedder()
             query_vec = embedder.embed_text(q)
 
-            # pgvector cosine distance: <=> returns distance (lower = closer)
+            # pgvector cosine distance: <=> returns distance (lower = closer).
+            # Join photos so we can filter out discarded / hidden rows
+            # inside the same query — otherwise a hidden-folder photo
+            # can take a top-N rank and starve the visible results.
             vec_str = "[" + ",".join(str(float(v)) for v in query_vec) + "]"
             stmt = text("""
                 SELECT e.photo_id,
                        (e.vector <=> :qvec::vector) AS distance
                 FROM embeddings e
+                JOIN photos p ON p.id = e.photo_id
                 WHERE e.model = :model
+                  AND p.is_trashed = false
+                  AND p.is_hidden = false
                 ORDER BY e.vector <=> :qvec::vector
                 LIMIT 200
             """)
@@ -65,15 +71,24 @@ async def hybrid_search(
     # ── FTS search (photos.search_vector + ocr_text) ────────────────
     if q:
         try:
+            # Same discarded/hidden filter as the semantic leg.
+            # The OCR branch joins photos (through photo_id) so we can
+            # filter there too; otherwise OCR hits in hidden folders
+            # would leak into results.
             fts_stmt = text("""
                 SELECT id, ts_rank(search_vector, plainto_tsquery('english', :q)) AS rank
                 FROM photos
                 WHERE search_vector @@ plainto_tsquery('english', :q)
+                  AND is_trashed = false
+                  AND is_hidden = false
                 UNION
                 SELECT o.photo_id AS id,
                        MAX(o.confidence) AS rank
                 FROM ocr_text o
+                JOIN photos p ON p.id = o.photo_id
                 WHERE to_tsvector('english', o.text) @@ plainto_tsquery('english', :q)
+                  AND p.is_trashed = false
+                  AND p.is_hidden = false
                 GROUP BY o.photo_id
                 ORDER BY rank DESC
                 LIMIT 200
@@ -100,7 +115,9 @@ async def hybrid_search(
 
     scored.sort(key=lambda x: -x[1])
 
-    # If no text query, fall back to recent photos
+    # If no text query, fall back to recent photos. Always filter out
+    # discarded + hidden here — this path backs the "Tags" and "People"
+    # browse views, which should honor the folder hide flag.
     if not q:
         if tag_ids:
             from app.models.tags import photo_tags
@@ -111,6 +128,10 @@ async def hybrid_search(
             stmt = select(Photo.id).join(sub, Photo.id == sub.c.photo_id)
         else:
             stmt = select(Photo.id)
+        stmt = stmt.where(
+            Photo.is_discarded.is_(False),
+            Photo.is_hidden.is_(False),
+        )
         stmt = stmt.order_by(Photo.added_at.desc())
         if date_from:
             stmt = stmt.where(Photo.taken_at >= date_from)