```

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/legacy_mysql/services/task_sync.py

@@ -0,0 +1,189 @@
+from typing import Any
+
+from fastapi import HTTPException, status
+from sqlalchemy import select
+
+from app.core.constants import ActorValue
+from app.core.utils.time import utc_now
+from app.modules.audit.constants import AuditAction, AuditRiskLevel, AuditSource, AuditStatus
+from app.modules.audit.schemas import AuditLogCreate
+from app.modules.audit.service import AuditService
+from app.modules.business.constants import BusinessDomain, SourceSystem, StatusValue
+from app.modules.business.models import LegacySyncRun, WorkTask
+from app.modules.business.service import serialize_model
+from app.modules.events.constants import (
+    EventAggregateType,
+    EventPayloadKey,
+    EventSource,
+    EventType,
+)
+from app.modules.events.services import EventService
+from app.modules.legacy_mysql.constants import (
+    LEGACY_SYNC_MISSING_ID_REASON,
+    LEGACY_TASK_QUERY_SOURCE,
+    LEGACY_TASK_SYNC_NOTE,
+    LEGACY_TASK_SYNC_RUN_CODE_PREFIX,
+    LegacyQueryError,
+    LegacyQueryName,
+    LegacyResponseKey,
+    LegacySyncAction,
+    LegacyTaskField,
+)
+
+from app.modules.legacy_mysql.services.common import _query_name_text
+
+
+class LegacyTaskSyncMixin:
+    def sync_tasks(
+        self,
+        source_query: str | None = None,
+        source_query_name: str | None = None,
+        field_map: dict[str, str] | None = None,
+        limit: int = 100,
+        dry_run: bool = True,
+        actor: str = ActorValue.API,
+    ) -> dict[str, Any]:
+        if self.db is None:
+            raise HTTPException(
+                status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+                detail=LegacyQueryError.APP_DB_UNAVAILABLE,
+            )
+
+        query_name = source_query_name or LegacyQueryName.TASKS
+        if source_query:
+            rows = self.execute_readonly(
+                source_query,
+                {LegacyResponseKey.LIMIT: limit},
+                limit=limit,
+            )[LegacyResponseKey.ROWS]
+            query_ref = LegacySyncAction.ALLOWLISTED_INLINE_SQL
+        else:
+            rows = self.execute_allowed_query(
+                query_name,
+                {LegacyResponseKey.LIMIT: limit},
+                limit=limit,
+            )[LegacyResponseKey.ROWS]
+            query_ref = _query_name_text(query_name)
+        field_map = field_map or {}
+        created = 0
+        updated = 0
+        skipped = 0
+        items: list[dict[str, Any]] = []
+
+        for row in rows:
+            payload = self._task_payload(row, field_map)
+            if not payload[LegacyTaskField.EXTERNAL_ID] and not payload[LegacyTaskField.CODE]:
+                skipped += 1
+                items.append(
+                    {
+                        LegacyResponseKey.ACTION: LegacySyncAction.SKIPPED,
+                        LegacyResponseKey.REASON: LEGACY_SYNC_MISSING_ID_REASON,
+                        LegacyResponseKey.SOURCE: row,
+                    }
+                )
+                continue
+
+            stmt = select(WorkTask).where(
+                WorkTask.source_system == SourceSystem.LEGACY_MYSQL,
+                WorkTask.external_id == payload[LegacyTaskField.EXTERNAL_ID],
+            )
+            record = self.db.execute(stmt).scalar_one_or_none()
+            if record is None:
+                record = self.db.execute(
+                    select(WorkTask).where(WorkTask.code == payload[LegacyTaskField.CODE])
+                ).scalar_one_or_none()
+
+            if record is None:
+                created += 1
+                action = LegacySyncAction.CREATE
+                result = payload
+                if not dry_run:
+                    record = WorkTask(**payload)
+                    self.db.add(record)
+                    self.db.flush()
+                    result = serialize_model(record)
+            else:
+                updated += 1
+                action = LegacySyncAction.UPDATE
+                if not dry_run:
+                    for key, value in payload.items():
+                        setattr(record, key, value)
+                    self.db.flush()
+                    result = serialize_model(record)
+                else:
+                    result = payload
+            items.append(
+                {
+                    LegacyResponseKey.ACTION: action,
+                    LegacyResponseKey.TASK: result,
+                    LegacyResponseKey.SOURCE: row,
+                }
+            )
+
+        if not dry_run:
+            self.db.commit()
+
+        result = {
+            LegacyResponseKey.DRY_RUN: dry_run,
+            LegacyResponseKey.CREATED: created,
+            LegacyResponseKey.UPDATED: updated,
+            LegacyResponseKey.SKIPPED: skipped,
+            LegacyResponseKey.ITEMS: items,
+        }
+        sync_run = LegacySyncRun(
+            code=f"{LEGACY_TASK_SYNC_RUN_CODE_PREFIX}-{utc_now():%Y%m%d%H%M%S%f}",
+            domain=BusinessDomain.TASKS,
+            source_table=LEGACY_TASK_QUERY_SOURCE,
+            status=StatusValue.DRY_RUN if dry_run else AuditStatus.SUCCESS,
+            finished_at=utc_now(),
+            created_count=created,
+            updated_count=updated,
+            skipped_count=skipped,
+            note=LEGACY_TASK_SYNC_NOTE,
+        )
+        self.db.add(sync_run)
+        self.db.commit()
+        self.db.refresh(sync_run)
+        result[LegacyResponseKey.SYNC_RUN_CODE] = sync_run.code
+
+        AuditService(self.db).log(
+            AuditLogCreate(
+                actor=actor,
+                source=AuditSource.LEGACY_MYSQL,
+                action=AuditAction.LEGACY_SYNC_TASKS,
+                target_type=BusinessDomain.TASKS,
+                risk_level=AuditRiskLevel.MEDIUM,
+                request_payload={
+                    LegacyResponseKey.SOURCE_QUERY: query_ref,
+                    LegacyResponseKey.FIELD_MAP: field_map,
+                    LegacyResponseKey.LIMIT: limit,
+                    LegacyResponseKey.DRY_RUN: dry_run,
+                },
+                response_payload={
+                    key: result[key]
+                    for key in [
+                        LegacyResponseKey.DRY_RUN,
+                        LegacyResponseKey.CREATED,
+                        LegacyResponseKey.UPDATED,
+                        LegacyResponseKey.SKIPPED,
+                    ]
+                },
+            )
+        )
+        EventService(self.db).emit(
+            event_type=EventType.LEGACY_SYNC_COMPLETED,
+            source=EventSource.LEGACY_MYSQL,
+            aggregate_type=EventAggregateType.LEGACY_SYNC_RUN,
+            aggregate_id=sync_run.code,
+            actor=actor,
+            payload={
+                EventPayloadKey.CODE: sync_run.code,
+                EventPayloadKey.DOMAIN: BusinessDomain.TASKS,
+                EventPayloadKey.STATUS: sync_run.status,
+                EventPayloadKey.CREATED: created,
+                EventPayloadKey.UPDATED: updated,
+                EventPayloadKey.SKIPPED: skipped,
+            },
+            idempotency_key=f"legacy-sync:{sync_run.code}",
+        )
+        return result