```

refactor(core,ai): 调整模块导入路径并移除废弃文件

- 修复 scheduler.py 中的导入路径错误，将 reports.service
  改为 reports.services
- 移除废弃的 app/core/background/task_queue.py 文件
- 移除废弃的 app/modules/ai_agent/adapters.py 文件
- 修复 ai_memory/service.py 中的导入路径错误，将
  events.service 改为 events.services
```

app/modules/events/services/dispatch.py

@@ -0,0 +1,145 @@
+from datetime import timedelta
+from typing import Any
+from uuid import uuid4
+
+from fastapi import HTTPException, status
+from sqlalchemy import or_, select
+
+from app.core.config import get_settings
+from app.core.constants import ActorValue
+from app.core.http.pagination import bounded_limit
+from app.core.utils.time import utc_now
+from app.modules.audit.constants import (
+    AuditAction,
+    AuditRiskLevel,
+    AuditSource,
+    AuditTargetType,
+)
+from app.modules.audit.schemas import AuditLogCreate
+from app.modules.audit.service import AuditService
+from app.modules.events.constants import (
+    EventErrorDetail,
+    EventPayloadKey,
+    EventStatus,
+)
+from app.modules.events.models import DomainEvent
+from app.modules.events.services.serialization import _serialize_event
+
+
+class EventDispatchMixin:
+    def dispatch_event(self, event_id: str, worker_id: str | None = None) -> DomainEvent:
+        record = self.get_event(event_id)
+        if record.status == EventStatus.PROCESSED:
+            return record
+        if not self._can_attempt(record):
+            return record
+        settings = get_settings()
+        now = utc_now()
+        lock_owner = worker_id or f"api:{uuid4().hex}"
+        record.locked_by = lock_owner
+        record.locked_until = now + timedelta(seconds=settings.event_dispatch_lock_seconds)
+        record.status = EventStatus.PENDING
+        record.attempts += 1
+        try:
+            self._handle_event(record)
+        except Exception as exc:
+            retryable = record.attempts < self._max_attempts(record)
+            record.status = EventStatus.PENDING if retryable else EventStatus.FAILED
+            record.last_error = str(exc)
+            record.next_attempt_at = (
+                utc_now() + timedelta(seconds=settings.event_dispatch_retry_delay_seconds)
+                if retryable
+                else None
+            )
+            record.locked_by = None
+            record.locked_until = None
+            self.db.commit()
+            self.db.refresh(record)
+            self._audit_dispatch(record)
+            return record
+        record.status = EventStatus.PROCESSED
+        record.last_error = None
+        record.processed_at = utc_now()
+        record.next_attempt_at = None
+        record.locked_by = None
+        record.locked_until = None
+        self.db.commit()
+        self.db.refresh(record)
+        self._audit_dispatch(record)
+        return record
+
+    def dispatch_pending(
+        self,
+        limit: int = 100,
+        worker_id: str | None = None,
+    ) -> list[dict[str, Any]]:
+        now = utc_now()
+        stmt = (
+            select(DomainEvent)
+            .where(
+                DomainEvent.status == EventStatus.PENDING,
+                or_(
+                    DomainEvent.next_attempt_at.is_(None),
+                    DomainEvent.next_attempt_at <= now,
+                ),
+                or_(
+                    DomainEvent.locked_until.is_(None),
+                    DomainEvent.locked_until <= now,
+                ),
+                or_(
+                    DomainEvent.max_attempts.is_(None),
+                    DomainEvent.attempts < DomainEvent.max_attempts,
+                ),
+            )
+            .order_by(DomainEvent.id.asc())
+            .limit(bounded_limit(limit))
+        )
+        records = list(self.db.execute(stmt).scalars())
+        lock_owner = worker_id or f"worker:{uuid4().hex}"
+        return [
+            _serialize_event(self.dispatch_event(record.event_id, worker_id=lock_owner))
+            for record in records
+        ]
+
+    def retry_event(self, event_id: str, actor: str = ActorValue.API) -> DomainEvent:
+        record = self.get_event(event_id)
+        if record.status == EventStatus.PROCESSED:
+            raise HTTPException(
+                status_code=status.HTTP_409_CONFLICT,
+                detail=EventErrorDetail.EVENT_NOT_RETRYABLE,
+            )
+        record.status = EventStatus.PENDING
+        record.actor = actor
+        record.attempts = 0
+        record.max_attempts = record.max_attempts or get_settings().event_dispatch_max_attempts
+        record.last_error = None
+        record.locked_by = None
+        record.locked_until = None
+        record.next_attempt_at = utc_now()
+        self.db.commit()
+        self.db.refresh(record)
+        return record
+
+    def _audit_dispatch(self, record: DomainEvent) -> None:
+        AuditService(self.db).log(
+            AuditLogCreate(
+                actor=record.actor,
+                source=AuditSource.EVENTS,
+                action=AuditAction.EVENT_DISPATCH,
+                target_type=AuditTargetType.DOMAIN_EVENT,
+                target_id=record.event_id,
+                risk_level=AuditRiskLevel.LOW,
+                response_payload={
+                    EventPayloadKey.STATUS: record.status,
+                    EventPayloadKey.ATTEMPTS: record.attempts,
+                    EventPayloadKey.ERROR_MESSAGE: record.last_error,
+                },
+            )
+        )
+
+    def _can_attempt(self, record: DomainEvent) -> bool:
+        return record.attempts < self._max_attempts(record)
+
+    @staticmethod
+    def _max_attempts(record: DomainEvent) -> int:
+        return record.max_attempts or get_settings().event_dispatch_max_attempts