feat: add face detection, recognition, and clustering

- Create face_embeddings table with pgvector Vector(128) + HNSW index
- Implement extract_faces task (YuNet detection + SFace recognition)
- Implement recluster_faces task (DBSCAN clustering → Tag(kind=face_cluster))
- Clusters are named "Person N" and get representative_photo_id
- cluster_id FK → tags.id, SET NULL on delete for merge/rename support

Migration 0005 creates the face_embeddings table.

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

backend/app/tasks/vision.py

@@ -198,8 +198,117 @@ async def _detect_objects_async(photo_id: str):
 
 @shared_task(name='extract_faces', queue='vision')
 def extract_faces(photo_id: str):
-    """Detect faces and extract embeddings — implemented in PR7."""
-    return {'status': 'not_implemented'}
+    """Detect faces and store recognition embeddings. Clustering is
+    handled separately by recluster_faces (periodic task)."""
+    if not settings.vision.enabled or not settings.vision.faces.enabled:
+        return {'status': 'skipped', 'reason': 'faces disabled'}
+    return asyncio.run(_extract_faces_async(photo_id))
+
+
+async def _extract_faces_async(photo_id: str):
+    image = _load_thumb(photo_id, "large")  # 1280px for better face detection
+    if image is None:
+        return {'status': 'error', 'message': 'thumbnail not found'}
+
+    from app.services.vision.registry import registry
+    face_proc = registry.get_face_processor()
+    faces = face_proc.process(image)
+
+    if not faces:
+        logger.info("No faces detected for photo %s", photo_id)
+        return {'status': 'success', 'photo_id': photo_id, 'faces': 0}
+
+    from app.models.face_embedding import FaceEmbedding
+
+    async with AsyncSessionLocal() as session:
+        # Wipe previous face results for this photo (re-run safe)
+        await session.execute(
+            delete(FaceEmbedding).where(FaceEmbedding.photo_id == photo_id)
+        )
+        for face in faces:
+            session.add(FaceEmbedding(
+                photo_id=photo_id,
+                bbox=face.bbox,
+                vector=face.embedding.tolist(),
+                quality=face.quality,
+                cluster_id=None,  # assigned by recluster_faces
+            ))
+        await session.commit()
+
+    logger.info("Extracted %d faces from photo %s", len(faces), photo_id)
+    return {'status': 'success', 'photo_id': photo_id, 'faces': len(faces)}
+
+
+@shared_task(name='recluster_faces', queue='vision')
+def recluster_faces():
+    """Run DBSCAN clustering over all face embeddings and assign/create
+    Tag(kind=face_cluster) entries. Should be called periodically or
+    manually after a batch of new faces is extracted."""
+    if not settings.vision.enabled or not settings.vision.faces.enabled:
+        return {'status': 'skipped', 'reason': 'faces disabled'}
+    return asyncio.run(_recluster_faces_async())
+
+
+async def _recluster_faces_async():
+    from app.models.face_embedding import FaceEmbedding
+    from app.models.tags import Tag
+    from app.services.vision.clustering import cluster_faces
+
+    async with AsyncSessionLocal() as session:
+        # Load all face embeddings
+        result = await session.execute(
+            select(FaceEmbedding).order_by(FaceEmbedding.created_at)
+        )
+        face_rows = result.scalars().all()
+
+        if len(face_rows) < 2:
+            logger.info("Not enough faces for clustering (%d)", len(face_rows))
+            return {'status': 'success', 'clusters': 0}
+
+        embeddings = np.array([f.vector for f in face_rows], dtype=np.float32)
+        labels = cluster_faces(
+            embeddings,
+            eps=settings.vision.faces.cluster_eps,
+        )
+
+        # Map cluster labels → Tag(kind=face_cluster)
+        cluster_tag_map: dict[int, str] = {}
+        source_name = "vision:sface"
+
+        for i, label in enumerate(labels):
+            if label == -1:
+                face_rows[i].cluster_id = None
+                continue
+
+            if label not in cluster_tag_map:
+                # Check if a cluster tag already exists for this cluster
+                cluster_name = f"Person {label + 1}"
+                tag_result = await session.execute(
+                    select(Tag).where(
+                        Tag.kind == 'face_cluster',
+                        Tag.source == source_name,
+                        Tag.name == cluster_name,
+                    )
+                )
+                tag = tag_result.scalar_one_or_none()
+                if not tag:
+                    tag = Tag(
+                        name=cluster_name,
+                        kind='face_cluster',
+                        source=source_name,
+                        representative_photo_id=face_rows[i].photo_id,
+                    )
+                    session.add(tag)
+                    await session.flush()
+                cluster_tag_map[label] = tag.id
+
+            face_rows[i].cluster_id = cluster_tag_map[label]
+
+        await session.commit()
+
+    n_clusters = len(cluster_tag_map)
+    logger.info("Face clustering: %d clusters from %d faces", n_clusters, len(face_rows))
+    return {'status': 'success', 'clusters': n_clusters, 'faces': len(face_rows)}
 
 
 @shared_task(name='backfill_vision')