refactor(catalog): the HTTP layer reads through queries and writes through the service

Channels, search and sync do no database work in their routes any more: reads go through
catalog/queries, writes through catalog/service, and a live search's ingest is catalog/search.
What a catalog route needs from Reader (a playlist's channels, a user's tag links, the feed
projection of results) it asks reader/queries and reader/service. The scheduler and the runs page
read channel titles and the work queue through catalog/queries. Catalog is fenced below its HTTP
layer: its owner filters go through userscope, it reads no other unit's tables, and its ingest
jobs commit only where they are named.

backend/app/routes/sync.py

@@ -1,5 +1,4 @@
 from fastapi import APIRouter, Depends, HTTPException
-from sqlalchemy import and_, case, func, select, update
 from sqlalchemy.orm import Session
 
 from app import audit, quota, state
@@ -7,7 +6,7 @@ from app.audit import AuditAction
 from app.auth import admin_user, current_user, has_read_scope
 from app.db import get_db
 from app.models import User
-from app.catalog.models import Channel, Subscription, Video
+from app.catalog import queries, service
 from app.routes._common import youtube_refusal
 from app.ratelimit import RateLimiter
 from app.sync.runner import estimate_deep_backfill
@@ -48,19 +47,8 @@ def sync_subscriptions(user: User = Depends(current_user), db: Session = Depends
 
 @router.get("/status")
 def sync_status(user: User = Depends(current_user), db: Session = Depends(get_db)) -> dict:
-    sub_count = db.scalar(
-        select(func.count()).select_from(Subscription).where(Subscription.user_id == user.id)
-    )
     return {
-        "subscriptions": sub_count,
-        "channels_total": db.scalar(select(func.count()).select_from(Channel)),
-        "channels_backfilling": db.scalar(
-            select(func.count()).select_from(Channel).where(Channel.backfill_done.is_(False))
-        ),
-        "videos_total": db.scalar(select(func.count()).select_from(Video)),
-        "pending_enrich": db.scalar(
-            select(func.count()).select_from(Video).where(Video.enriched_at.is_(None))
-        ),
+        **queries.catalog_totals(db, user),
         "quota_used_today": quota.units_used_today(db),
         "quota_remaining_today": quota.remaining_today(db),
         "paused": state.is_sync_paused(db),
@@ -71,51 +59,21 @@ def sync_status(user: User = Depends(current_user), db: Session = Depends(get_db
 @router.get("/my-status")
 def my_status(user: User = Depends(current_user), db: Session = Depends(get_db)) -> dict:
     """Per-user sync progress: how far the channels *this* user subscribes to have synced."""
-    sub_join = and_(Subscription.channel_id == Channel.id, Subscription.user_id == user.id)
-    total, details_synced, recent_synced, all_deep_done = db.execute(
-        select(
-            func.count(Channel.id),
-            func.count(Channel.details_synced_at),
-            func.count(Channel.recent_synced_at),
-            func.sum(case((Channel.backfill_done.is_(True), 1), else_=0)),
-        )
-        .select_from(Channel)
-        .join(Subscription, sub_join)
-    ).one()
-    total = total or 0
-    all_deep_done = int(all_deep_done or 0)
+    total, details_synced, recent_synced, all_deep_done = queries.my_progress(db, user)
 
     # Per-user full-history (deep) backfill: channels this user has opted in, and an ETA
     # for the still-pending ones (quota-bound estimate).
-    deep_requested_channels = (
-        db.execute(
-            select(Channel).join(
-                Subscription,
-                and_(sub_join, Subscription.deep_requested.is_(True)),
-            )
-        )
-        .scalars()
-        .all()
-    )
+    deep_requested_channels = queries.my_deep_requested(db, user)
     deep_eta = estimate_deep_backfill(db, deep_requested_channels)
     # "done / requested" is shown as one ratio, so both halves count the SAME channels: the ones this
     # user asked full history for. Counting every subscribed channel whose back-catalog happens to be
     # complete (another user asked, or it was short) gave "342/329".
     deep_done = sum(1 for c in deep_requested_channels if c.backfill_done)
 
-    my_videos = db.scalar(
-        select(func.count(Video.id)).join(
-            Subscription,
-            and_(
-                Subscription.channel_id == Video.channel_id,
-                Subscription.user_id == user.id,
-                Subscription.hidden.is_(False),
-            ),
-        )
-    )
+    my_videos = queries.my_video_count(db, user)
     # Whole-catalog total (every video any user's subscriptions have pulled in), so the
     # header can show "yours" against the shared library size.
-    total_videos = db.scalar(select(func.count(Video.id)))
+    total_videos = queries.video_total(db)
     return {
         "channels_total": total,
         "channels_details_synced": details_synced,
@@ -126,8 +84,8 @@ def my_status(user: User = Depends(current_user), db: Session = Depends(get_db))
         "channels_deep_requested": len(deep_requested_channels),
         "deep_pending_count": deep_eta["channels_pending"],
         "deep_eta_seconds": deep_eta["eta_seconds"],
-        "my_videos": my_videos or 0,
-        "total_videos": total_videos or 0,
+        "my_videos": my_videos,
+        "total_videos": total_videos,
         "quota_used_today": quota.units_used_today(db),
         "quota_remaining_today": quota.remaining_today(db),
         "paused": state.is_sync_paused(db),
@@ -144,11 +102,9 @@ def deep_all(
     on: bool = True,
 ) -> dict:
     """Opt every one of the user's channels into (or out of) full-history backfill."""
-    result = db.execute(
-        update(Subscription).where(Subscription.user_id == user.id).values(deep_requested=on)
-    )
+    updated = service.set_deep_all(db, user, on)
     db.commit()
-    return {"ok": True, "updated": result.rowcount, "deep_requested": on}
+    return {"ok": True, "updated": updated, "deep_requested": on}
 
 
 @router.post("/pause")