refactor(B1): migrate to domain-driven project structure

Move all models/schemas/services/routers into app/domains/.
Keep backward-compat shims in old locations for imports.
Preserves domains/rendering/tasks.py from Phase A.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

backend/app/domains/notifications/__init__.py

@@ -0,0 +1 @@
+# Domain: notifications

backend/app/domains/notifications/models.py

@@ -0,0 +1,28 @@
+import uuid
+from datetime import datetime
+from sqlalchemy import String, Boolean, DateTime, ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+from sqlalchemy.dialects.postgresql import UUID, JSONB
+from app.database import Base
+
+
+class AuditLog(Base):
+    __tablename__ = "audit_log"
+
+    id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    user_id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), ForeignKey("users.id"), nullable=True)
+    action: Mapped[str] = mapped_column(String(100), nullable=False)
+    entity_type: Mapped[str] = mapped_column(String(100), nullable=True)
+    entity_id: Mapped[str] = mapped_column(String(255), nullable=True)
+    details: Mapped[dict] = mapped_column(JSONB, nullable=True)
+    timestamp: Mapped[datetime] = mapped_column(DateTime, default=datetime.utcnow, nullable=False)
+
+    # Notification center columns
+    target_user_id: Mapped[uuid.UUID | None] = mapped_column(
+        UUID(as_uuid=True), ForeignKey("users.id", ondelete="SET NULL"), nullable=True,
+    )
+    read_at: Mapped[datetime | None] = mapped_column(DateTime, nullable=True)
+    notification: Mapped[bool] = mapped_column(Boolean, default=False, nullable=False)
+
+    user: Mapped["User"] = relationship("User", back_populates="audit_logs", foreign_keys=[user_id])
+    target_user: Mapped["User"] = relationship("User", foreign_keys=[target_user_id])

backend/app/domains/notifications/router.py

@@ -0,0 +1,4 @@
+# Re-export from original router.
+from app.api.routers.notifications import router
+
+__all__ = ["router"]

backend/app/domains/notifications/service.py

@@ -0,0 +1,84 @@
+"""Notification emission helpers.
+
+Provides async (for routers) and sync (for Celery tasks) entry points
+to create notification rows in the audit_log table.
+"""
+import logging
+import uuid
+from datetime import datetime
+
+from sqlalchemy import create_engine
+from sqlalchemy.orm import Session
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domains.notifications.models import AuditLog
+
+logger = logging.getLogger(__name__)
+
+_engine = None
+
+
+def _get_engine():
+    global _engine
+    if _engine is None:
+        from app.config import settings as app_settings
+        _engine = create_engine(app_settings.database_url_sync)
+    return _engine
+
+
+async def emit_notification(
+    db: AsyncSession,
+    *,
+    actor_user_id: str | uuid.UUID | None = None,
+    target_user_id: str | uuid.UUID | None = None,
+    action: str,
+    entity_type: str | None = None,
+    entity_id: str | None = None,
+    details: dict | None = None,
+) -> None:
+    """Create a notification (async — for use inside FastAPI routers)."""
+    try:
+        entry = AuditLog(
+            user_id=str(actor_user_id) if actor_user_id else None,
+            target_user_id=str(target_user_id) if target_user_id else None,
+            action=action,
+            entity_type=entity_type,
+            entity_id=str(entity_id) if entity_id else None,
+            details=details,
+            notification=True,
+            timestamp=datetime.utcnow(),
+        )
+        db.add(entry)
+        await db.commit()
+    except Exception:
+        logger.exception("Failed to emit notification (async)")
+        await db.rollback()
+
+
+def emit_notification_sync(
+    *,
+    actor_user_id: str | uuid.UUID | None = None,
+    target_user_id: str | uuid.UUID | None = None,
+    action: str,
+    entity_type: str | None = None,
+    entity_id: str | None = None,
+    details: dict | None = None,
+) -> None:
+    """Create a notification (sync — for use inside Celery tasks)."""
+    engine = _get_engine()
+    try:
+        with Session(engine) as session:
+            entry = AuditLog(
+                user_id=str(actor_user_id) if actor_user_id else None,
+                target_user_id=str(target_user_id) if target_user_id else None,
+                action=action,
+                entity_type=entity_type,
+                entity_id=str(entity_id) if entity_id else None,
+                details=details,
+                notification=True,
+                timestamp=datetime.utcnow(),
+            )
+            session.add(entry)
+            session.commit()
+    except Exception:
+        logger.exception("Failed to emit notification (sync)")