```

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/core/background/task_queue/__init__.py

@@ -0,0 +1,30 @@
+from app.core.background.task_queue.constants import (
+    TASK_DISPATCH_PENDING_EVENTS,
+    TASK_GENERATE_RISK_EVENTS,
+    TASK_PUSH_DAILY_BRIEF,
+    TASK_PUSH_PROJECT_WEEKLY,
+    TASK_SYNC_LEGACY_PROJECTS,
+    TASK_SYNC_LEGACY_TASKS,
+)
+from app.core.background.task_queue.dispatcher import dispatch_task
+from app.core.background.task_queue.events import enqueue_event_dispatch
+from app.core.background.task_queue.legacy import enqueue_legacy_project_sync, enqueue_legacy_task_sync
+from app.core.background.task_queue.reports import enqueue_daily_brief_push, enqueue_project_weekly_push
+from app.core.background.task_queue.risk import enqueue_risk_event_generation
+
+
+__all__ = [
+    "TASK_DISPATCH_PENDING_EVENTS",
+    "TASK_GENERATE_RISK_EVENTS",
+    "TASK_PUSH_DAILY_BRIEF",
+    "TASK_PUSH_PROJECT_WEEKLY",
+    "TASK_SYNC_LEGACY_PROJECTS",
+    "TASK_SYNC_LEGACY_TASKS",
+    "dispatch_task",
+    "enqueue_daily_brief_push",
+    "enqueue_event_dispatch",
+    "enqueue_legacy_project_sync",
+    "enqueue_legacy_task_sync",
+    "enqueue_project_weekly_push",
+    "enqueue_risk_event_generation",
+]

app/core/background/task_queue/constants.py

@@ -0,0 +1,6 @@
+TASK_PUSH_DAILY_BRIEF = "reports.push_daily_brief"
+TASK_PUSH_PROJECT_WEEKLY = "reports.push_project_weekly"
+TASK_GENERATE_RISK_EVENTS = "risks.generate_events"
+TASK_SYNC_LEGACY_PROJECTS = "legacy.sync_projects"
+TASK_SYNC_LEGACY_TASKS = "legacy.sync_tasks"
+TASK_DISPATCH_PENDING_EVENTS = "events.dispatch_pending"

app/core/background/task_queue/dispatcher.py

@@ -0,0 +1,30 @@
+from collections.abc import Callable
+from typing import Any
+
+from app.core.config import get_settings
+
+
+def dispatch_task(
+    task_name: str,
+    kwargs: dict[str, Any],
+    inline: Callable[[], Any],
+) -> dict[str, Any]:
+    """Dispatch a task through Celery when enabled, otherwise run inline."""
+
+    settings = get_settings()
+    if settings.task_queue_enabled:
+        from app.tasks import celery_app
+
+        async_result = celery_app.signature(task_name, kwargs=kwargs).apply_async()
+        return {
+            "queued": True,
+            "mode": "celery",
+            "task_name": task_name,
+            "task_id": async_result.id,
+        }
+    return {
+        "queued": False,
+        "mode": "inline",
+        "task_name": task_name,
+        "result": inline(),
+    }

app/core/background/task_queue/events.py

@@ -0,0 +1,31 @@
+from typing import Any
+
+from app.core.config import get_settings
+from app.core.background.task_queue.constants import (
+    TASK_DISPATCH_PENDING_EVENTS,
+)
+from app.core.background.task_queue.dispatcher import dispatch_task
+
+
+def enqueue_event_dispatch(
+    limit: int | None = None,
+    actor: str = "scheduler",
+) -> dict[str, Any]:
+    def inline() -> Any:
+        from app.core.database import SessionLocal
+        from app.modules.events.services import EventService
+
+        db = SessionLocal()
+        try:
+            return EventService(db).dispatch_pending(
+                limit=limit or get_settings().event_dispatch_batch_size,
+                worker_id=actor,
+            )
+        finally:
+            db.close()
+
+    return dispatch_task(
+        TASK_DISPATCH_PENDING_EVENTS,
+        {"limit": limit, "actor": actor},
+        inline,
+    )

app/core/background/task_queue/legacy.py

@@ -0,0 +1,84 @@
+from typing import Any
+
+from app.core.background.task_queue.constants import (
+    TASK_SYNC_LEGACY_PROJECTS,
+    TASK_SYNC_LEGACY_TASKS,
+)
+from app.core.background.task_queue.dispatcher import dispatch_task
+
+
+def enqueue_legacy_project_sync(
+    source_query: str | None = None,
+    source_query_name: str | None = None,
+    field_map: dict[str, str] | None = None,
+    limit: int = 100,
+    dry_run: bool = False,
+    actor: str = "scheduler",
+) -> dict[str, Any]:
+    def inline() -> Any:
+        from app.core.database import SessionLocal
+        from app.modules.legacy_mysql.services import LegacyMySQLService
+
+        db = SessionLocal()
+        try:
+            return LegacyMySQLService(db).sync_projects(
+                source_query=source_query,
+                source_query_name=source_query_name,
+                field_map=field_map or {},
+                limit=limit,
+                dry_run=dry_run,
+                actor=actor,
+            )
+        finally:
+            db.close()
+
+    return dispatch_task(
+        TASK_SYNC_LEGACY_PROJECTS,
+        {
+            "source_query": source_query,
+            "source_query_name": source_query_name,
+            "field_map": field_map or {},
+            "limit": limit,
+            "dry_run": dry_run,
+            "actor": actor,
+        },
+        inline,
+    )
+
+def enqueue_legacy_task_sync(
+    source_query: str | None = None,
+    source_query_name: str | None = None,
+    field_map: dict[str, str] | None = None,
+    limit: int = 100,
+    dry_run: bool = False,
+    actor: str = "scheduler",
+) -> dict[str, Any]:
+    def inline() -> Any:
+        from app.core.database import SessionLocal
+        from app.modules.legacy_mysql.services import LegacyMySQLService
+
+        db = SessionLocal()
+        try:
+            return LegacyMySQLService(db).sync_tasks(
+                source_query=source_query,
+                source_query_name=source_query_name,
+                field_map=field_map or {},
+                limit=limit,
+                dry_run=dry_run,
+                actor=actor,
+            )
+        finally:
+            db.close()
+
+    return dispatch_task(
+        TASK_SYNC_LEGACY_TASKS,
+        {
+            "source_query": source_query,
+            "source_query_name": source_query_name,
+            "field_map": field_map or {},
+            "limit": limit,
+            "dry_run": dry_run,
+            "actor": actor,
+        },
+        inline,
+    )

app/core/background/task_queue/reports.py

@@ -0,0 +1,144 @@
+from typing import Any
+
+from app.core.config import get_settings
+from app.modules.feishu.constants import FeishuReceiveIdType
+from app.core.background.task_queue.constants import (
+    TASK_PUSH_DAILY_BRIEF,
+    TASK_PUSH_PROJECT_WEEKLY,
+)
+from app.core.background.task_queue.dispatcher import dispatch_task
+
+
+def enqueue_daily_brief_push(
+    receive_id: str | None = None,
+    receive_id_type: str = FeishuReceiveIdType.CHAT_ID,
+    actor: str = "scheduler",
+) -> dict[str, Any]:
+    settings = get_settings()
+    if settings.task_queue_enabled:
+        from app.core.database import SessionLocal
+        from app.modules.reports.constants import ReportPushStatus, ReportTitle, ReportType
+        from app.modules.reports.services import ReportService
+        from app.tasks import celery_app
+
+        db = SessionLocal()
+        try:
+            push_run = ReportService(db).create_push_run(
+                report_type=ReportType.DAILY,
+                title=ReportTitle.DAILY_BRIEF,
+                receive_id=receive_id,
+                receive_id_type=receive_id_type,
+                actor=actor,
+                status=ReportPushStatus.QUEUED,
+            )
+            async_result = celery_app.signature(
+                TASK_PUSH_DAILY_BRIEF,
+                kwargs={
+                    "receive_id": receive_id,
+                    "receive_id_type": receive_id_type,
+                    "actor": actor,
+                    "push_run_code": push_run.code,
+                },
+            ).apply_async()
+            ReportService(db).update_push_run(
+                push_run.code,
+                ReportPushStatus.QUEUED,
+                task_id=async_result.id,
+            )
+        finally:
+            db.close()
+        return {
+            "queued": True,
+            "mode": "celery",
+            "task_name": TASK_PUSH_DAILY_BRIEF,
+            "task_id": async_result.id,
+            "push_run_code": push_run.code,
+        }
+
+    def inline() -> Any:
+        from app.core.database import SessionLocal
+        from app.modules.reports.services import ReportService
+
+        db = SessionLocal()
+        try:
+            report = ReportService(db).daily_brief()
+            return ReportService(db).push_report(report, receive_id, receive_id_type, actor)
+        finally:
+            db.close()
+
+    return dispatch_task(
+        TASK_PUSH_DAILY_BRIEF,
+        {
+            "receive_id": receive_id,
+            "receive_id_type": receive_id_type,
+            "actor": actor,
+        },
+        inline,
+    )
+
+def enqueue_project_weekly_push(
+    receive_id: str | None = None,
+    receive_id_type: str = FeishuReceiveIdType.CHAT_ID,
+    actor: str = "scheduler",
+) -> dict[str, Any]:
+    settings = get_settings()
+    if settings.task_queue_enabled:
+        from app.core.database import SessionLocal
+        from app.modules.reports.constants import ReportPushStatus, ReportTitle, ReportType
+        from app.modules.reports.services import ReportService
+        from app.tasks import celery_app
+
+        db = SessionLocal()
+        try:
+            push_run = ReportService(db).create_push_run(
+                report_type=ReportType.WEEKLY,
+                title=ReportTitle.PROJECT_WEEKLY,
+                receive_id=receive_id,
+                receive_id_type=receive_id_type,
+                actor=actor,
+                status=ReportPushStatus.QUEUED,
+            )
+            async_result = celery_app.signature(
+                TASK_PUSH_PROJECT_WEEKLY,
+                kwargs={
+                    "receive_id": receive_id,
+                    "receive_id_type": receive_id_type,
+                    "actor": actor,
+                    "push_run_code": push_run.code,
+                },
+            ).apply_async()
+            ReportService(db).update_push_run(
+                push_run.code,
+                ReportPushStatus.QUEUED,
+                task_id=async_result.id,
+            )
+        finally:
+            db.close()
+        return {
+            "queued": True,
+            "mode": "celery",
+            "task_name": TASK_PUSH_PROJECT_WEEKLY,
+            "task_id": async_result.id,
+            "push_run_code": push_run.code,
+        }
+
+    def inline() -> Any:
+        from app.core.database import SessionLocal
+        from app.modules.reports.services import ReportService
+
+        db = SessionLocal()
+        try:
+            report = ReportService(db).project_weekly()
+            return ReportService(db).push_report(report, receive_id, receive_id_type, actor)
+        finally:
+            db.close()
+
+    return dispatch_task(
+        TASK_PUSH_PROJECT_WEEKLY,
+        {
+            "receive_id": receive_id,
+            "receive_id_type": receive_id_type,
+            "actor": actor,
+        },
+        inline,
+    )

app/core/background/task_queue/risk.py

@@ -0,0 +1,24 @@
+from typing import Any
+
+from app.core.background.task_queue.constants import (
+    TASK_GENERATE_RISK_EVENTS,
+)
+from app.core.background.task_queue.dispatcher import dispatch_task
+
+
+def enqueue_risk_event_generation(actor: str = "scheduler") -> dict[str, Any]:
+    def inline() -> Any:
+        from app.core.database import SessionLocal
+        from app.modules.risk.services import RiskService
+
+        db = SessionLocal()
+        try:
+            return RiskService(db).generate_events(actor=actor)
+        finally:
+            db.close()
+
+    return dispatch_task(
+        TASK_GENERATE_RISK_EVENTS,
+        {"actor": actor},
+        inline,
+    )