```

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/reports/routes.py

@@ -12,7 +12,7 @@ from app.modules.reports.schemas import (
     ReportResponse,
     WorkReportGenerateRequest,
 )
-from app.modules.reports.service import ReportService
+from app.modules.reports.services import ReportService
 
 router = APIRouter(dependencies=[Depends(require_api_key)])
 

app/modules/reports/services/__init__.py

@@ -0,0 +1,4 @@
+from app.modules.reports.services.service import ReportService
+
+
+__all__ = ["ReportService"]

app/modules/reports/services/common.py

@@ -0,0 +1,95 @@
+from datetime import date, datetime
+from decimal import Decimal
+from typing import Any
+
+from sqlalchemy import func, select
+
+from app.core.http.pagination import bounded_limit
+from app.core.utils.time import utc_now
+from app.modules.reports.constants import ReportStatus
+
+
+def _money(value: Decimal | int | float | None) -> str:
+    """Format a numeric value as a two-decimal money string."""
+
+    amount = Decimal(value or 0)
+    return f"{amount:,.2f}"
+
+
+def _json_safe(value: Any) -> Any:
+    """Convert nested report payloads into JSON-storable values."""
+
+    if isinstance(value, Decimal):
+        return float(value)
+    if isinstance(value, (datetime, date)):
+        return value.isoformat()
+    if isinstance(value, list):
+        return [_json_safe(item) for item in value]
+    if isinstance(value, dict):
+        return {key: _json_safe(item) for key, item in value.items()}
+    return value
+
+
+def _next_code(prefix: str) -> str:
+    """Build a compact unique code for generated report records."""
+
+    return f"{prefix}-{utc_now():%Y%m%d%H%M%S%f}"
+
+
+def _rate(numerator: int | Decimal, denominator: int | Decimal) -> float:
+    """Return a rounded percentage rate, using zero when the denominator is empty."""
+
+    if not denominator:
+        return 0.0
+    return round(float(numerator) / float(denominator) * 100, 2)
+
+
+def _as_decimal(value: Decimal | int | float | None) -> Decimal:
+    return Decimal(str(value or 0))
+
+
+class ReportQueryMixin:
+    def _count(self, model: type, *conditions: Any) -> int:
+        stmt = select(func.count()).select_from(model)
+        for condition in conditions:
+            stmt = stmt.where(condition)
+        return int(self.db.execute(stmt).scalar() or 0)
+
+    def _sum(self, column: Any, *conditions: Any) -> Decimal:
+        stmt = select(func.sum(column))
+        for condition in conditions:
+            stmt = stmt.where(condition)
+        return _as_decimal(self.db.execute(stmt).scalar())
+
+    def _avg(self, column: Any, *conditions: Any) -> float:
+        stmt = select(func.avg(column))
+        for condition in conditions:
+            stmt = stmt.where(condition)
+        value = self.db.execute(stmt).scalar()
+        return round(float(value or 0), 2)
+
+    def _group_counts(self, model: type, column: Any, *conditions: Any) -> dict[str, int]:
+        stmt = select(column, func.count()).select_from(model)
+        for condition in conditions:
+            stmt = stmt.where(condition)
+        stmt = stmt.group_by(column)
+        return {
+            str(key or ReportStatus.UNKNOWN): int(count)
+            for key, count in self.db.execute(stmt).all()
+        }
+
+    def _records(
+        self,
+        model: type,
+        *conditions: Any,
+        limit: int = 10,
+        order_by: Any | None = None,
+    ) -> list[Any]:
+        stmt = select(model)
+        for condition in conditions:
+            stmt = stmt.where(condition)
+        if order_by is not None:
+            stmt = stmt.order_by(order_by)
+        else:
+            stmt = stmt.order_by(model.id.desc())
+        return list(self.db.execute(stmt.limit(bounded_limit(limit))).scalars())

app/modules/reports/services/delivery.py

@@ -0,0 +1,95 @@
+
+
+from app.modules.audit.constants import AuditAction, AuditSource
+from app.modules.audit.schemas import AuditLogCreate
+from app.modules.audit.service import AuditService
+from app.modules.events.constants import (
+    EventAggregateType,
+    EventPayloadKey,
+    EventSource,
+    EventType,
+)
+from app.modules.events.services import EventService
+from app.modules.feishu.service import FeishuService
+from app.modules.reports.constants import (
+    ReportPushStatus,
+    ReportResponseKey,
+)
+
+
+class ReportDeliveryMixin:
+    def push_report(
+        self,
+        report: dict,
+        receive_id: str | None,
+        receive_id_type: str,
+        actor: str,
+        push_run_code: str | None = None,
+    ) -> dict:
+        report_type = str(report.get(ReportResponseKey.REPORT_TYPE) or report.get("type") or "report")
+        title = report.get(ReportResponseKey.TITLE)
+        push_run = (
+            self._get_push_run(push_run_code)
+            if push_run_code
+            else self.create_push_run(
+                report_type=report_type,
+                title=title,
+                receive_id=receive_id,
+                receive_id_type=receive_id_type,
+                actor=actor,
+            )
+        )
+        card = FeishuService.build_basic_card(
+            report[ReportResponseKey.TITLE],
+            report[ReportResponseKey.LINES],
+        )
+        try:
+            result = FeishuService(self.db).send_card(card, receive_id, receive_id_type, actor)
+        except Exception as exc:
+            failed_run = self.update_push_run(
+                push_run.code,
+                ReportPushStatus.FAILED,
+                error_message=str(exc),
+            )
+            EventService(self.db).emit(
+                event_type=EventType.REPORT_PUSH_FAILED,
+                source=EventSource.REPORTS,
+                aggregate_type=EventAggregateType.REPORT_PUSH_RUN,
+                aggregate_id=failed_run.code,
+                actor=actor,
+                payload={
+                    EventPayloadKey.CODE: failed_run.code,
+                    EventPayloadKey.STATUS: failed_run.status,
+                    EventPayloadKey.ERROR_MESSAGE: failed_run.error_message,
+                },
+                idempotency_key=f"report-push:{failed_run.code}:{failed_run.status}",
+            )
+            raise
+        success_run = self.update_push_run(
+            push_run.code,
+            ReportPushStatus.SUCCESS,
+            provider_response=result,
+            sent=True,
+        )
+        EventService(self.db).emit(
+            event_type=EventType.REPORT_PUSH_SUCCEEDED,
+            source=EventSource.REPORTS,
+            aggregate_type=EventAggregateType.REPORT_PUSH_RUN,
+            aggregate_id=success_run.code,
+            actor=actor,
+            payload={
+                EventPayloadKey.CODE: success_run.code,
+                EventPayloadKey.STATUS: success_run.status,
+            },
+            idempotency_key=f"report-push:{success_run.code}:{success_run.status}",
+        )
+        AuditService(self.db).log(
+            AuditLogCreate(
+                actor=actor,
+                source=AuditSource.REPORTS,
+                action=AuditAction.REPORT_PUSH,
+                target_id=push_run.code,
+                response_payload={"status": ReportPushStatus.SUCCESS},
+            )
+        )
+        return result

app/modules/reports/services/enterprise.py

@@ -0,0 +1,194 @@
+from datetime import date
+from typing import Any
+
+
+from app.core.constants import ActorValue
+from app.modules.audit.constants import AuditAction, AuditSource, AuditTargetType
+from app.modules.audit.schemas import AuditLogCreate
+from app.modules.audit.service import AuditService
+from app.modules.business.models import (
+    PerformanceMetric,
+)
+from app.modules.events.constants import (
+    EventAggregateType,
+    EventPayloadKey,
+    EventSource,
+    EventType,
+)
+from app.modules.events.services import EventService
+from app.modules.reports.constants import (
+    EnterpriseAnalyticsKey,
+    LifecycleResponseKey,
+    LifecycleSection,
+    MetricKey,
+    ReportStatus,
+    ReportText,
+    ReportTitle,
+)
+
+from app.modules.reports.services.common import _json_safe, _money, _next_code, _rate
+
+
+class ReportEnterpriseAnalyticsMixin:
+    def enterprise_analytics(
+        self,
+        project_code: str | None = None,
+        owner: str | None = None,
+        period_start: date | None = None,
+        period_end: date | None = None,
+        actor: str = ActorValue.API,
+    ) -> dict[str, Any]:
+        """Build V3 read-only finance, procurement, performance, and operations analytics."""
+
+        code = _next_code("ANALYTICS")
+        lifecycle = self.project_lifecycle_report(
+            project_code=project_code,
+            owner=owner,
+            period_start=period_start,
+            period_end=period_end,
+            include_ai=False,
+            actor=actor,
+        )
+        metrics = lifecycle[LifecycleResponseKey.METRICS]
+        projects = metrics[LifecycleSection.PROJECTS]
+        procurements = metrics[LifecycleSection.PROCUREMENTS]
+        expenses = metrics[LifecycleSection.EXPENSES]
+        funds = metrics[LifecycleSection.FUNDS]
+        tasks = metrics[LifecycleSection.TASKS]
+        risks = metrics[LifecycleSection.RISKS]
+        health = metrics[LifecycleSection.HEALTH]
+        finance = {
+            MetricKey.BUDGET_TOTAL: projects[MetricKey.BUDGET_TOTAL],
+            MetricKey.ACTUAL_TOTAL: projects[MetricKey.ACTUAL_TOTAL],
+            MetricKey.BUDGET_USAGE_RATE: projects[MetricKey.BUDGET_USAGE_RATE],
+            MetricKey.CURRENT_BALANCE_TOTAL: funds[MetricKey.CURRENT_BALANCE_TOTAL],
+            MetricKey.NET_POSITION: funds[MetricKey.NET_POSITION],
+            MetricKey.RISK_ACCOUNTS: funds[MetricKey.RISK_ACCOUNTS],
+            MetricKey.PAYMENT_EXPOSURE: (
+                procurements[MetricKey.ACTUAL_TOTAL] + expenses[MetricKey.AMOUNT_TOTAL]
+            ),
+        }
+        procurement = {
+            MetricKey.TOTAL: procurements[MetricKey.TOTAL],
+            MetricKey.PENDING_APPROVAL: procurements[MetricKey.PENDING_APPROVAL],
+            MetricKey.PENDING_DELIVERY: procurements[MetricKey.PENDING_DELIVERY],
+            MetricKey.UNPAID: procurements[MetricKey.UNPAID],
+            MetricKey.EXPECTED_TOTAL: procurements[MetricKey.EXPECTED_TOTAL],
+            MetricKey.ACTUAL_TOTAL: procurements[MetricKey.ACTUAL_TOTAL],
+            MetricKey.DELIVERY_RISK: procurements[MetricKey.PENDING_DELIVERY],
+        }
+        performance = self._enterprise_performance_stats()
+        operations = {
+            MetricKey.READINESS_SCORE: health[MetricKey.SCORE],
+            MetricKey.LEVEL: health[MetricKey.LEVEL],
+            MetricKey.COMPLETION_RATE: tasks[MetricKey.COMPLETION_RATE],
+            MetricKey.OVERDUE_TASKS: risks[MetricKey.OVERDUE_TASKS],
+            MetricKey.DELAYED_PROJECTS: risks[MetricKey.DELAYED_PROJECTS],
+            MetricKey.OVER_BUDGET_PROJECTS: risks[MetricKey.OVER_BUDGET_PROJECTS],
+            MetricKey.OPEN_EVENTS: risks[MetricKey.OPEN_EVENTS],
+            MetricKey.HIGH_EVENTS: risks[MetricKey.HIGH_EVENTS],
+        }
+        recommendations = lifecycle[LifecycleResponseKey.RECOMMENDATIONS]
+        lines = self._enterprise_analytics_lines(
+            lifecycle[LifecycleResponseKey.FILTERS],
+            finance,
+            procurement,
+            performance,
+            operations,
+            recommendations,
+        )
+        report = _json_safe(
+            {
+                EnterpriseAnalyticsKey.CODE: code,
+                EnterpriseAnalyticsKey.TITLE: ReportTitle.ENTERPRISE_ANALYTICS,
+                EnterpriseAnalyticsKey.FILTERS: lifecycle[LifecycleResponseKey.FILTERS],
+                EnterpriseAnalyticsKey.FINANCE: finance,
+                EnterpriseAnalyticsKey.PROCUREMENT: procurement,
+                EnterpriseAnalyticsKey.PERFORMANCE: performance,
+                EnterpriseAnalyticsKey.OPERATIONS: operations,
+                EnterpriseAnalyticsKey.RECOMMENDATIONS: recommendations,
+                EnterpriseAnalyticsKey.LINES: lines,
+                EnterpriseAnalyticsKey.CONTENT: "\n".join(lines),
+            }
+        )
+        AuditService(self.db).log(
+            AuditLogCreate(
+                actor=actor,
+                source=AuditSource.REPORTS,
+                action=AuditAction.ENTERPRISE_ANALYTICS,
+                target_type=AuditTargetType.ENTERPRISE_ANALYTICS,
+                target_id=code,
+                response_payload=report,
+            )
+        )
+        EventService(self.db).emit(
+            event_type=EventType.ENTERPRISE_ANALYTICS_GENERATED,
+            source=EventSource.ANALYTICS,
+            aggregate_type=EventAggregateType.ENTERPRISE_ANALYTICS,
+            aggregate_id=code,
+            actor=actor,
+            payload={
+                EventPayloadKey.CODE: code,
+                EventPayloadKey.STATUS: ReportStatus.GENERATED,
+            },
+            idempotency_key=f"enterprise-analytics:{code}",
+            dispatch=True,
+        )
+        return report
+
+    def _enterprise_performance_stats(self) -> dict[str, Any]:
+        total = self._count(PerformanceMetric)
+        confirmed = self._count(PerformanceMetric, PerformanceMetric.confirmed_score.is_not(None))
+        return {
+            MetricKey.TOTAL: total,
+            MetricKey.CONFIRMED: confirmed,
+            MetricKey.CONFIRMED_RATE: _rate(confirmed, total),
+            MetricKey.AVERAGE_AUTO_SCORE: self._avg(PerformanceMetric.auto_score),
+            MetricKey.AVERAGE_CONFIRMED_SCORE: self._avg(PerformanceMetric.confirmed_score),
+            MetricKey.WEIGHT_TOTAL: self._sum(PerformanceMetric.weight),
+            MetricKey.BY_STATUS: self._group_counts(PerformanceMetric, PerformanceMetric.status),
+        }
+
+    def _enterprise_analytics_lines(
+        self,
+        filters: dict[str, Any],
+        finance: dict[str, Any],
+        procurement: dict[str, Any],
+        performance: dict[str, Any],
+        operations: dict[str, Any],
+        recommendations: list[str],
+    ) -> list[str]:
+        scope = (
+            "、".join(f"{key}={value}" for key, value in filters.items() if value)
+            or ReportText.DEFAULT_SCOPE
+        )
+        lines = [
+            f"- 范围：{scope}",
+            (
+                f"- 财务：预算 {_money(finance[MetricKey.BUDGET_TOTAL])}，"
+                f"实际 {_money(finance[MetricKey.ACTUAL_TOTAL])}，"
+                f"净头寸 {_money(finance[MetricKey.NET_POSITION])}，"
+                f"支付暴露 {_money(finance[MetricKey.PAYMENT_EXPOSURE])}"
+            ),
+            (
+                f"- 采购：总数 {procurement[MetricKey.TOTAL]}，"
+                f"待审批 {procurement[MetricKey.PENDING_APPROVAL]}，"
+                f"待交付 {procurement[MetricKey.PENDING_DELIVERY]}，"
+                f"未付款 {procurement[MetricKey.UNPAID]}"
+            ),
+            (
+                f"- 绩效：指标 {performance[MetricKey.TOTAL]}，"
+                f"已确认 {performance[MetricKey.CONFIRMED]}，"
+                f"确认率 {performance[MetricKey.CONFIRMED_RATE]}%，"
+                f"平均自动分 {performance[MetricKey.AVERAGE_AUTO_SCORE]}"
+            ),
+            (
+                f"- 运营：准备度 {operations[MetricKey.READINESS_SCORE]}，"
+                f"任务完成率 {operations[MetricKey.COMPLETION_RATE]}%，"
+                f"逾期任务 {operations[MetricKey.OVERDUE_TASKS]}，"
+                f"打开风险 {operations[MetricKey.OPEN_EVENTS]}"
+            ),
+            ReportText.ACTION_HEADER,
+        ]
+        lines.extend(f"  - {item}" for item in recommendations)
+        return lines

app/modules/reports/services/lifecycle/__init__.py

@@ -0,0 +1,15 @@
+from app.modules.reports.services.lifecycle.filters import ReportLifecycleFilterMixin
+from app.modules.reports.services.lifecycle.health import ReportLifecycleHealthMixin
+from app.modules.reports.services.lifecycle.rendering import ReportLifecycleRenderingMixin
+from app.modules.reports.services.lifecycle.report import ReportLifecycleReportMixin
+from app.modules.reports.services.lifecycle.stats import ReportLifecycleStatsMixin
+
+
+class ReportLifecycleMixin(
+    ReportLifecycleReportMixin,
+    ReportLifecycleRenderingMixin,
+    ReportLifecycleHealthMixin,
+    ReportLifecycleStatsMixin,
+    ReportLifecycleFilterMixin,
+):
+    """Project lifecycle report composition and supporting calculations."""

app/modules/reports/services/lifecycle/filters.py

@@ -0,0 +1,87 @@
+from datetime import date, datetime
+from typing import Any
+
+from sqlalchemy import or_
+
+from app.modules.business.models import (
+    AttendanceRecord,
+    Expense,
+    Procurement,
+    Project,
+    RiskEvent,
+    WorkTask,
+)
+from app.modules.reports.constants import (
+    LifecycleFilterKey,
+    LifecycleSection,
+)
+
+
+class ReportLifecycleFilterMixin:
+    def _lifecycle_filters(
+        self,
+        project_code: str | None,
+        owner: str | None,
+        period_start: date | None,
+        period_end: date | None,
+    ) -> dict[str, Any]:
+        project_conditions: list[Any] = []
+        task_conditions: list[Any] = []
+        procurement_conditions: list[Any] = []
+        expense_conditions: list[Any] = []
+        attendance_conditions: list[Any] = []
+        risk_conditions: list[Any] = []
+        labels = {
+            LifecycleFilterKey.PROJECT_CODE: project_code,
+            LifecycleFilterKey.OWNER: owner,
+            LifecycleFilterKey.PERIOD_START: period_start.isoformat() if period_start else None,
+            LifecycleFilterKey.PERIOD_END: period_end.isoformat() if period_end else None,
+        }
+
+        if project_code:
+            project_conditions.append(Project.code == project_code)
+            task_conditions.append(WorkTask.project_code == project_code)
+            procurement_conditions.append(Procurement.project_code == project_code)
+            expense_conditions.append(Expense.project_code == project_code)
+            attendance_conditions.append(AttendanceRecord.project_code == project_code)
+            risk_conditions.append(RiskEvent.project_code == project_code)
+        if owner:
+            project_conditions.append(Project.owner == owner)
+            task_conditions.append(WorkTask.owner == owner)
+            risk_conditions.append(RiskEvent.owner == owner)
+        if period_start:
+            project_conditions.append(
+                or_(Project.due_date.is_(None), Project.due_date >= period_start)
+            )
+            task_conditions.append(WorkTask.due_date >= period_start)
+            attendance_conditions.append(AttendanceRecord.work_date >= period_start)
+            risk_conditions.append(
+                RiskEvent.detected_at >= datetime.combine(period_start, datetime.min.time())
+            )
+        if period_end:
+            project_conditions.append(
+                or_(Project.start_date.is_(None), Project.start_date <= period_end)
+            )
+            task_conditions.append(WorkTask.due_date <= period_end)
+            attendance_conditions.append(AttendanceRecord.work_date <= period_end)
+            risk_conditions.append(
+                RiskEvent.detected_at <= datetime.combine(period_end, datetime.max.time())
+            )
+        if period_start:
+            start_at = datetime.combine(period_start, datetime.min.time())
+            procurement_conditions.append(Procurement.created_at >= start_at)
+            expense_conditions.append(Expense.created_at >= start_at)
+        if period_end:
+            end_at = datetime.combine(period_end, datetime.max.time())
+            procurement_conditions.append(Procurement.created_at <= end_at)
+            expense_conditions.append(Expense.created_at <= end_at)
+
+        return {
+            LifecycleFilterKey.LABELS: labels,
+            LifecycleSection.PROJECTS: project_conditions,
+            LifecycleSection.TASKS: task_conditions,
+            LifecycleSection.PROCUREMENTS: procurement_conditions,
+            LifecycleSection.EXPENSES: expense_conditions,
+            LifecycleSection.ATTENDANCE: attendance_conditions,
+            LifecycleSection.RISKS: risk_conditions,
+        }

app/modules/reports/services/lifecycle/health.py

@@ -0,0 +1,138 @@
+from datetime import date
+from typing import Any
+
+
+from app.modules.business.constants import (
+    DONE_STATUSES,
+    PROJECT_CLOSED_STATUSES,
+)
+from app.modules.business.models import (
+    Project,
+    WorkTask,
+)
+from app.modules.business.service import serialize_model
+from app.modules.reports.constants import (
+    ATTENTION_SCORE_THRESHOLD,
+    HEALTH_PENALTY_WEIGHTS,
+    HEALTH_SCORE_MAX,
+    HEALTH_SCORE_MIN,
+    HEALTHY_SCORE_THRESHOLD,
+    HealthLevel,
+    LifecycleAttentionKey,
+    MetricKey,
+    ReportText,
+)
+
+
+class ReportLifecycleHealthMixin:
+    def _lifecycle_health(
+        self,
+        projects: dict[str, Any],
+        tasks: dict[str, Any],
+        risks: dict[str, Any],
+        suppliers: dict[str, Any],
+        include_global_risk: bool,
+    ) -> dict[str, Any]:
+        penalty = (
+            risks[MetricKey.OVERDUE_TASKS] * HEALTH_PENALTY_WEIGHTS[MetricKey.OVERDUE_TASKS]
+            + risks[MetricKey.DELAYED_PROJECTS]
+            * HEALTH_PENALTY_WEIGHTS[MetricKey.DELAYED_PROJECTS]
+            + risks[MetricKey.OVER_BUDGET_PROJECTS]
+            * HEALTH_PENALTY_WEIGHTS[MetricKey.OVER_BUDGET_PROJECTS]
+            + risks[MetricKey.EXTERNAL_HIGH_EVENTS]
+            * HEALTH_PENALTY_WEIGHTS[MetricKey.EXTERNAL_HIGH_EVENTS]
+            + max(
+                HEALTH_SCORE_MIN,
+                projects[MetricKey.BUDGET_USAGE_RATE] - HEALTH_SCORE_MAX,
+            )
+            * HEALTH_PENALTY_WEIGHTS[MetricKey.BUDGET_USAGE_RATE]
+            + (HEALTH_SCORE_MAX - tasks[MetricKey.COMPLETION_RATE])
+            * HEALTH_PENALTY_WEIGHTS[MetricKey.COMPLETION_RATE]
+        )
+        if include_global_risk:
+            penalty += suppliers[MetricKey.BLACKLISTED] * HEALTH_PENALTY_WEIGHTS[
+                MetricKey.BLACKLISTED
+            ]
+        score = max(
+            HEALTH_SCORE_MIN,
+            min(HEALTH_SCORE_MAX, round(HEALTH_SCORE_MAX - penalty, 2)),
+        )
+        if score >= HEALTHY_SCORE_THRESHOLD:
+            level = HealthLevel.HEALTHY
+        elif score >= ATTENTION_SCORE_THRESHOLD:
+            level = HealthLevel.ATTENTION
+        else:
+            level = HealthLevel.CRITICAL
+        return {MetricKey.SCORE: score, MetricKey.LEVEL: level}
+
+    def _lifecycle_attention(
+        self,
+        project_conditions: list[Any],
+        task_conditions: list[Any],
+    ) -> dict[str, Any]:
+        delayed = self._records(
+            Project,
+            Project.due_date.is_not(None),
+            Project.due_date < date.today(),
+            Project.status.notin_(PROJECT_CLOSED_STATUSES),
+            *project_conditions,
+            limit=10,
+            order_by=Project.due_date.asc(),
+        )
+        over_budget = self._records(
+            Project,
+            Project.budget_amount > 0,
+            Project.actual_amount > Project.budget_amount,
+            *project_conditions,
+            limit=10,
+            order_by=Project.id.desc(),
+        )
+        overdue_tasks = self._records(
+            WorkTask,
+            WorkTask.due_date.is_not(None),
+            WorkTask.due_date < date.today(),
+            WorkTask.status.notin_(DONE_STATUSES),
+            *task_conditions,
+            limit=10,
+            order_by=WorkTask.due_date.asc(),
+        )
+        return {
+            LifecycleAttentionKey.DELAYED_PROJECTS: [serialize_model(item) for item in delayed],
+            LifecycleAttentionKey.OVER_BUDGET_PROJECTS: [
+                serialize_model(item) for item in over_budget
+            ],
+            LifecycleAttentionKey.OVERDUE_TASKS: [
+                serialize_model(item) for item in overdue_tasks
+            ],
+        }
+
+    def _lifecycle_recommendations(
+        self,
+        projects: dict[str, Any],
+        tasks: dict[str, Any],
+        procurements: dict[str, Any],
+        expenses: dict[str, Any],
+        funds: dict[str, Any],
+        suppliers: dict[str, Any],
+        risks: dict[str, Any],
+        include_global_risk: bool,
+    ) -> list[str]:
+        recommendations: list[str] = []
+        if risks[MetricKey.DELAYED_PROJECTS]:
+            recommendations.append(ReportText.RECOMMEND_DELAYED)
+        if risks[MetricKey.OVER_BUDGET_PROJECTS]:
+            recommendations.append(ReportText.RECOMMEND_OVER_BUDGET)
+        if tasks[MetricKey.OVERDUE]:
+            recommendations.append(ReportText.RECOMMEND_OVERDUE_TASKS)
+        if (
+            procurements[MetricKey.PENDING_APPROVAL]
+            or expenses[MetricKey.PENDING_APPROVAL]
+        ):
+            recommendations.append(ReportText.RECOMMEND_APPROVALS)
+        if include_global_risk and funds[MetricKey.RISK_ACCOUNTS]:
+            recommendations.append(ReportText.RECOMMEND_FUNDS)
+        if include_global_risk and suppliers[MetricKey.RISKY]:
+            recommendations.append(ReportText.RECOMMEND_SUPPLIERS)
+        if not recommendations:
+            recommendations.append(ReportText.RECOMMEND_STABLE)
+        return [str(item) for item in recommendations]

app/modules/reports/services/lifecycle/rendering.py

@@ -0,0 +1,97 @@
+from typing import Any
+
+
+from app.modules.reports.constants import (
+    LifecycleResponseKey,
+    LifecycleSection,
+    MetricKey,
+    ReportText,
+)
+from app.modules.reports.services.common import _json_safe, _money
+
+
+class ReportLifecycleRenderingMixin:
+    def _lifecycle_lines(
+        self,
+        filters: dict[str, Any],
+        metrics: dict[str, Any],
+        recommendations: list[str],
+    ) -> list[str]:
+        scope = (
+            "、".join(f"{key}={value}" for key, value in filters.items() if value)
+            or ReportText.DEFAULT_SCOPE
+        )
+        projects = metrics[LifecycleSection.PROJECTS]
+        tasks = metrics[LifecycleSection.TASKS]
+        procurements = metrics[LifecycleSection.PROCUREMENTS]
+        expenses = metrics[LifecycleSection.EXPENSES]
+        funds = metrics[LifecycleSection.FUNDS]
+        suppliers = metrics[LifecycleSection.SUPPLIERS]
+        attendance = metrics[LifecycleSection.ATTENDANCE]
+        risks = metrics[LifecycleSection.RISKS]
+        health = metrics[LifecycleSection.HEALTH]
+        lines = [
+            f"- 范围：{scope}",
+            f"- 生命周期健康分：{health[MetricKey.SCORE]}（{health[MetricKey.LEVEL]}）",
+            (
+                f"- 项目：总数 {projects[MetricKey.TOTAL]}，"
+                f"活跃 {projects[MetricKey.ACTIVE]}，"
+                f"平均进度 {projects[MetricKey.AVERAGE_PROGRESS_PERCENT]}%"
+            ),
+            (
+                f"- 成本：预算 {_money(projects[MetricKey.BUDGET_TOTAL])}，"
+                f"实际 {_money(projects[MetricKey.ACTUAL_TOTAL])}，"
+                f"预算使用率 {projects[MetricKey.BUDGET_USAGE_RATE]}%"
+            ),
+            (
+                f"- 任务：总数 {tasks[MetricKey.TOTAL]}，"
+                f"完成 {tasks[MetricKey.COMPLETED]}，"
+                f"完成率 {tasks[MetricKey.COMPLETION_RATE]}%，"
+                f"逾期 {tasks[MetricKey.OVERDUE]}"
+            ),
+            (
+                f"- 采购/费用：待批采购 {procurements[MetricKey.PENDING_APPROVAL]}，"
+                f"待批费用 {expenses[MetricKey.PENDING_APPROVAL]}，"
+                f"未付款采购 {procurements[MetricKey.UNPAID]}"
+            ),
+            (
+                f"- 资金：余额 {_money(funds[MetricKey.CURRENT_BALANCE_TOTAL])}，"
+                f"净头寸 {_money(funds[MetricKey.NET_POSITION])}，"
+                f"风险账户 {funds[MetricKey.RISK_ACCOUNTS]}"
+            ),
+            (
+                f"- 风险：等级 {risks[MetricKey.RISK_LEVEL]}，"
+                f"风险分 {risks[MetricKey.RISK_SCORE]}，"
+                f"延期项目 {risks[MetricKey.DELAYED_PROJECTS]}，"
+                f"超预算项目 {risks[MetricKey.OVER_BUDGET_PROJECTS]}，"
+                f"打开事件 {risks[MetricKey.OPEN_EVENTS]}"
+            ),
+            (
+                f"- 供应商/考勤：风险供应商 {suppliers[MetricKey.RISKY]}，"
+                f"异常打卡 {attendance[MetricKey.ABNORMAL]}，"
+                f"异常率 {attendance[MetricKey.ABNORMAL_RATE]}%"
+            ),
+            ReportText.ACTION_HEADER,
+        ]
+        lines.extend(f"  - {item}" for item in recommendations)
+        return lines
+
+    def _lifecycle_ai_analysis(self, report: dict[str, Any], actor: str) -> dict[str, Any]:
+        try:
+            from app.modules.ai_agent.constants import AIResponseKey
+            from app.modules.ai_agent.skills import AISkillId
+            from app.modules.ai_agent.service import AIService
+
+            report_snapshot = _json_safe(report)
+            result = AIService(self.db).run_skill(
+                AISkillId.PROJECT_LIFECYCLE_ANALYSIS,
+                context={LifecycleResponseKey.PROJECT_LIFECYCLE_REPORT: report_snapshot},
+                actor=actor,
+            )
+        except Exception as exc:
+            return {
+                AIResponseKey.OK: False,
+                AIResponseKey.ERROR: str(exc),
+                AIResponseKey.TYPE: type(exc).__name__,
+            }
+        return _json_safe({AIResponseKey.OK: True, **result})

app/modules/reports/services/lifecycle/report.py

@@ -0,0 +1,94 @@
+from datetime import date
+from typing import Any
+
+
+from app.core.constants import ActorValue
+from app.modules.reports.constants import (
+    LifecycleFilterKey,
+    LifecycleResponseKey,
+    LifecycleSection,
+    ReportTitle,
+)
+from app.modules.reports.services.common import _json_safe
+
+
+class ReportLifecycleReportMixin:
+    def project_lifecycle_report(
+        self,
+        project_code: str | None = None,
+        owner: str | None = None,
+        period_start: date | None = None,
+        period_end: date | None = None,
+        include_ai: bool = False,
+        actor: str = ActorValue.API,
+    ) -> dict[str, Any]:
+        """Build a full lifecycle report for project progress, delivery, cost, and risk."""
+
+        filters = self._lifecycle_filters(project_code, owner, period_start, period_end)
+        project_conditions = filters[LifecycleSection.PROJECTS]
+        task_conditions = filters[LifecycleSection.TASKS]
+        procurement_conditions = filters[LifecycleSection.PROCUREMENTS]
+        expense_conditions = filters[LifecycleSection.EXPENSES]
+        attendance_conditions = filters[LifecycleSection.ATTENDANCE]
+        risk_conditions = filters[LifecycleSection.RISKS]
+
+        project_stats = self._lifecycle_project_stats(project_conditions)
+        task_stats = self._lifecycle_task_stats(task_conditions)
+        procurement_stats = self._lifecycle_procurement_stats(procurement_conditions)
+        expense_stats = self._lifecycle_expense_stats(expense_conditions)
+        fund_stats = self._lifecycle_fund_stats()
+        supplier_stats = self._lifecycle_supplier_stats()
+        attendance_stats = self._lifecycle_attendance_stats(attendance_conditions)
+        risk_stats = self._lifecycle_risk_stats(
+            project_conditions,
+            task_conditions,
+            risk_conditions,
+        )
+        include_global_risk = not (project_code or owner)
+        health = self._lifecycle_health(
+            project_stats,
+            task_stats,
+            risk_stats,
+            supplier_stats,
+            include_global_risk,
+        )
+        attention = self._lifecycle_attention(project_conditions, task_conditions)
+        recommendations = self._lifecycle_recommendations(
+            project_stats,
+            task_stats,
+            procurement_stats,
+            expense_stats,
+            fund_stats,
+            supplier_stats,
+            risk_stats,
+            include_global_risk,
+        )
+
+        metrics = {
+            LifecycleSection.HEALTH: health,
+            LifecycleSection.PROJECTS: project_stats,
+            LifecycleSection.TASKS: task_stats,
+            LifecycleSection.PROCUREMENTS: procurement_stats,
+            LifecycleSection.EXPENSES: expense_stats,
+            LifecycleSection.FUNDS: fund_stats,
+            LifecycleSection.SUPPLIERS: supplier_stats,
+            LifecycleSection.ATTENDANCE: attendance_stats,
+            LifecycleSection.RISKS: risk_stats,
+        }
+        lines = self._lifecycle_lines(
+            filters[LifecycleFilterKey.LABELS],
+            metrics,
+            recommendations,
+        )
+        report = {
+            LifecycleResponseKey.TITLE: ReportTitle.PROJECT_LIFECYCLE,
+            LifecycleResponseKey.FILTERS: filters[LifecycleFilterKey.LABELS],
+            LifecycleResponseKey.METRICS: _json_safe(metrics),
+            LifecycleResponseKey.ATTENTION: _json_safe(attention),
+            LifecycleResponseKey.RECOMMENDATIONS: recommendations,
+            LifecycleResponseKey.LINES: lines,
+            LifecycleResponseKey.CONTENT: "\n".join(lines),
+        }
+        if include_ai:
+            report[LifecycleResponseKey.AI_ANALYSIS] = self._lifecycle_ai_analysis(report, actor)
+        return report

app/modules/reports/services/lifecycle/stats.py

@@ -0,0 +1,270 @@
+from datetime import date
+from typing import Any
+
+
+from app.modules.business.constants import (
+    ATTENDANCE_ABNORMAL_STATUSES,
+    DONE_STATUSES,
+    GENERATED_RISK_EVENT_TYPES,
+    PROJECT_CLOSED_STATUSES,
+    PENDING_APPROVAL_STATUSES,
+    SUPPLIER_RISK_LEVELS,
+    RiskLevel,
+    StatusValue,
+)
+from app.modules.business.models import (
+    AttendanceRecord,
+    Expense,
+    FundAccount,
+    Procurement,
+    Project,
+    RiskEvent,
+    Supplier,
+    WorkTask,
+)
+from app.modules.reports.constants import (
+    LIFECYCLE_RISK_SCORE_WEIGHTS,
+    MetricKey,
+)
+from app.modules.reports.services.common import _rate
+from app.modules.risk.constants import risk_level_for_score
+
+
+class ReportLifecycleStatsMixin:
+    def _lifecycle_project_stats(self, conditions: list[Any]) -> dict[str, Any]:
+        total = self._count(Project, *conditions)
+        active = self._count(Project, Project.status.notin_(PROJECT_CLOSED_STATUSES), *conditions)
+        closed = total - active
+        budget_total = self._sum(Project.budget_amount, *conditions)
+        actual_total = self._sum(Project.actual_amount, *conditions)
+        delayed = self._count(
+            Project,
+            Project.due_date.is_not(None),
+            Project.due_date < date.today(),
+            Project.status.notin_(PROJECT_CLOSED_STATUSES),
+            *conditions,
+        )
+        over_budget = self._count(
+            Project,
+            Project.budget_amount > 0,
+            Project.actual_amount > Project.budget_amount,
+            *conditions,
+        )
+        return {
+            MetricKey.TOTAL: total,
+            MetricKey.ACTIVE: active,
+            MetricKey.CLOSED: closed,
+            MetricKey.AVERAGE_PROGRESS_PERCENT: self._avg(
+                Project.progress_percent,
+                *conditions,
+            ),
+            MetricKey.BY_STATUS: self._group_counts(Project, Project.status, *conditions),
+            MetricKey.BY_RISK_LEVEL: self._group_counts(Project, Project.risk_level, *conditions),
+            MetricKey.BUDGET_TOTAL: budget_total,
+            MetricKey.ACTUAL_TOTAL: actual_total,
+            MetricKey.BUDGET_USAGE_RATE: _rate(actual_total, budget_total),
+            MetricKey.DELAYED: delayed,
+            MetricKey.OVER_BUDGET: over_budget,
+        }
+
+    def _lifecycle_task_stats(self, conditions: list[Any]) -> dict[str, Any]:
+        total = self._count(WorkTask, *conditions)
+        completed = self._count(WorkTask, WorkTask.status.in_(DONE_STATUSES), *conditions)
+        overdue = self._count(
+            WorkTask,
+            WorkTask.due_date.is_not(None),
+            WorkTask.due_date < date.today(),
+            WorkTask.status.notin_(DONE_STATUSES),
+            *conditions,
+        )
+        blocked = self._count(
+            WorkTask,
+            WorkTask.blocker.is_not(None),
+            WorkTask.status.notin_(DONE_STATUSES),
+            *conditions,
+        )
+        return {
+            MetricKey.TOTAL: total,
+            MetricKey.COMPLETED: completed,
+            MetricKey.OPEN: total - completed,
+            MetricKey.OVERDUE: overdue,
+            MetricKey.BLOCKED: blocked,
+            MetricKey.COMPLETION_RATE: _rate(completed, total),
+            MetricKey.BY_STATUS: self._group_counts(WorkTask, WorkTask.status, *conditions),
+            MetricKey.BY_PRIORITY: self._group_counts(WorkTask, WorkTask.priority, *conditions),
+        }
+
+    def _lifecycle_procurement_stats(self, conditions: list[Any]) -> dict[str, Any]:
+        total = self._count(Procurement, *conditions)
+        pending_approval = self._count(
+            Procurement,
+            Procurement.approval_status.in_(PENDING_APPROVAL_STATUSES),
+            *conditions,
+        )
+        pending_delivery = self._count(
+            Procurement,
+            Procurement.delivery_status.notin_(DONE_STATUSES),
+            *conditions,
+        )
+        unpaid = self._count(
+            Procurement,
+            Procurement.payment_status != StatusValue.PAID,
+            *conditions,
+        )
+        expected_total = self._sum(Procurement.expected_amount, *conditions)
+        actual_total = self._sum(Procurement.actual_amount, *conditions)
+        return {
+            MetricKey.TOTAL: total,
+            MetricKey.PENDING_APPROVAL: pending_approval,
+            MetricKey.PENDING_DELIVERY: pending_delivery,
+            MetricKey.UNPAID: unpaid,
+            MetricKey.EXPECTED_TOTAL: expected_total,
+            MetricKey.ACTUAL_TOTAL: actual_total,
+            MetricKey.ACTUAL_VS_EXPECTED_RATE: _rate(actual_total, expected_total),
+        }
+
+    def _lifecycle_expense_stats(self, conditions: list[Any]) -> dict[str, Any]:
+        total = self._count(Expense, *conditions)
+        pending_approval = self._count(
+            Expense,
+            Expense.approval_status.in_(PENDING_APPROVAL_STATUSES),
+            *conditions,
+        )
+        unpaid = self._count(Expense, Expense.payment_status != StatusValue.PAID, *conditions)
+        return {
+            MetricKey.TOTAL: total,
+            MetricKey.PENDING_APPROVAL: pending_approval,
+            MetricKey.UNPAID: unpaid,
+            MetricKey.AMOUNT_TOTAL: self._sum(Expense.amount, *conditions),
+            MetricKey.BY_TYPE: self._group_counts(Expense, Expense.expense_type, *conditions),
+        }
+
+    def _lifecycle_fund_stats(self) -> dict[str, Any]:
+        balance = self._sum(FundAccount.current_balance)
+        receivable = self._sum(FundAccount.expected_receivable)
+        payable = self._sum(FundAccount.expected_payable)
+        safety_line = self._sum(FundAccount.safety_line)
+        risk_accounts = self._count(
+            FundAccount,
+            FundAccount.current_balance < FundAccount.safety_line,
+        )
+        return {
+            MetricKey.ACCOUNTS_TOTAL: self._count(FundAccount),
+            MetricKey.CURRENT_BALANCE_TOTAL: balance,
+            MetricKey.EXPECTED_RECEIVABLE_TOTAL: receivable,
+            MetricKey.EXPECTED_PAYABLE_TOTAL: payable,
+            MetricKey.SAFETY_LINE_TOTAL: safety_line,
+            MetricKey.NET_POSITION: balance + receivable - payable,
+            MetricKey.RISK_ACCOUNTS: risk_accounts,
+        }
+
+    def _lifecycle_supplier_stats(self) -> dict[str, Any]:
+        risky = self._count(
+            Supplier,
+            (Supplier.blacklist_status != StatusValue.NORMAL)
+            | Supplier.risk_level.in_(SUPPLIER_RISK_LEVELS),
+        )
+        blacklisted = self._count(Supplier, Supplier.blacklist_status != StatusValue.NORMAL)
+        return {
+            MetricKey.TOTAL: self._count(Supplier),
+            MetricKey.RISKY: risky,
+            MetricKey.BLACKLISTED: blacklisted,
+            MetricKey.BY_RISK_LEVEL: self._group_counts(Supplier, Supplier.risk_level),
+        }
+
+    def _lifecycle_attendance_stats(self, conditions: list[Any]) -> dict[str, Any]:
+        total = self._count(AttendanceRecord, *conditions)
+        abnormal = self._count(
+            AttendanceRecord,
+            AttendanceRecord.status.in_(ATTENDANCE_ABNORMAL_STATUSES),
+            *conditions,
+        )
+        return {
+            MetricKey.TOTAL: total,
+            MetricKey.ABNORMAL: abnormal,
+            MetricKey.ABNORMAL_RATE: _rate(abnormal, total),
+            MetricKey.BY_STATUS: self._group_counts(
+                AttendanceRecord,
+                AttendanceRecord.status,
+                *conditions,
+            ),
+        }
+
+    def _lifecycle_risk_stats(
+        self,
+        project_conditions: list[Any],
+        task_conditions: list[Any],
+        risk_conditions: list[Any],
+    ) -> dict[str, Any]:
+        overdue_tasks = self._count(
+            WorkTask,
+            WorkTask.due_date.is_not(None),
+            WorkTask.due_date < date.today(),
+            WorkTask.status.notin_(DONE_STATUSES),
+            *task_conditions,
+        )
+        delayed_projects = self._count(
+            Project,
+            Project.due_date.is_not(None),
+            Project.due_date < date.today(),
+            Project.status.notin_(PROJECT_CLOSED_STATUSES),
+            *project_conditions,
+        )
+        over_budget_projects = self._count(
+            Project,
+            Project.budget_amount > 0,
+            Project.actual_amount > Project.budget_amount,
+            *project_conditions,
+        )
+        open_events = self._count(
+            RiskEvent,
+            RiskEvent.status == StatusValue.OPEN,
+            *risk_conditions,
+        )
+        high_events = self._count(
+            RiskEvent,
+            RiskEvent.status == StatusValue.OPEN,
+            RiskEvent.risk_level == RiskLevel.HIGH,
+            *risk_conditions,
+        )
+        external_open_events = self._count(
+            RiskEvent,
+            RiskEvent.status == StatusValue.OPEN,
+            RiskEvent.risk_type.notin_(GENERATED_RISK_EVENT_TYPES),
+            *risk_conditions,
+        )
+        external_high_events = self._count(
+            RiskEvent,
+            RiskEvent.status == StatusValue.OPEN,
+            RiskEvent.risk_level == RiskLevel.HIGH,
+            RiskEvent.risk_type.notin_(GENERATED_RISK_EVENT_TYPES),
+            *risk_conditions,
+        )
+        risk_score = (
+            overdue_tasks * LIFECYCLE_RISK_SCORE_WEIGHTS[MetricKey.OVERDUE_TASKS]
+            + delayed_projects * LIFECYCLE_RISK_SCORE_WEIGHTS[MetricKey.DELAYED_PROJECTS]
+            + over_budget_projects * LIFECYCLE_RISK_SCORE_WEIGHTS[MetricKey.OVER_BUDGET_PROJECTS]
+            + external_open_events * LIFECYCLE_RISK_SCORE_WEIGHTS[MetricKey.EXTERNAL_OPEN_EVENTS]
+            + external_high_events * LIFECYCLE_RISK_SCORE_WEIGHTS[MetricKey.EXTERNAL_HIGH_EVENTS]
+        )
+        return {
+            MetricKey.RISK_LEVEL: risk_level_for_score(risk_score),
+            MetricKey.RISK_SCORE: risk_score,
+            MetricKey.OVERDUE_TASKS: overdue_tasks,
+            MetricKey.DELAYED_PROJECTS: delayed_projects,
+            MetricKey.OVER_BUDGET_PROJECTS: over_budget_projects,
+            MetricKey.OPEN_EVENTS: open_events,
+            MetricKey.HIGH_EVENTS: high_events,
+            MetricKey.EXTERNAL_OPEN_EVENTS: external_open_events,
+            MetricKey.EXTERNAL_HIGH_EVENTS: external_high_events,
+            MetricKey.EVENTS_BY_TYPE: self._group_counts(
+                RiskEvent,
+                RiskEvent.risk_type,
+                *risk_conditions,
+            ),
+            MetricKey.EVENTS_BY_LEVEL: self._group_counts(
+                RiskEvent,
+                RiskEvent.risk_level,
+                *risk_conditions,
+            ),
+        }

app/modules/reports/services/push_runs.py

@@ -0,0 +1,97 @@
+from typing import Any
+
+from fastapi import HTTPException, status
+from sqlalchemy import select
+
+from app.core.http.pagination import bounded_limit
+from app.core.utils.time import utc_now
+from app.modules.business.models import (
+    ReportPushRun,
+)
+from app.modules.business.service import serialize_model
+from app.modules.reports.constants import (
+    ReportErrorDetail,
+    ReportPushStatus,
+)
+
+from app.modules.reports.services.common import _json_safe, _next_code
+
+
+class ReportPushRunMixin:
+    def create_push_run(
+        self,
+        report_type: str,
+        title: str | None,
+        receive_id: str | None,
+        receive_id_type: str,
+        actor: str,
+        status: str = ReportPushStatus.PENDING,
+    ) -> ReportPushRun:
+        record = ReportPushRun(
+            code=_next_code("PUSH"),
+            report_type=report_type,
+            title=title,
+            receive_id=receive_id,
+            receive_id_type=receive_id_type,
+            status=status,
+            actor=actor,
+            queued_at=utc_now(),
+        )
+        self.db.add(record)
+        self.db.commit()
+        self.db.refresh(record)
+        return record
+
+    def update_push_run(
+        self,
+        code: str,
+        status: str,
+        task_id: str | None = None,
+        provider_response: dict[str, Any] | None = None,
+        error_message: str | None = None,
+        sent: bool = False,
+    ) -> ReportPushRun:
+        record = self._get_push_run(code)
+        record.status = status
+        if task_id is not None:
+            record.task_id = task_id
+        if provider_response is not None:
+            record.provider_response = _json_safe(provider_response)
+        record.error_message = error_message
+        if sent:
+            record.sent_at = utc_now()
+        self.db.commit()
+        self.db.refresh(record)
+        return record
+
+    def list_push_runs(
+        self,
+        status_filter: str | None = None,
+        limit: int = 100,
+    ) -> list[dict[str, Any]]:
+        stmt = select(ReportPushRun).order_by(ReportPushRun.id.desc()).limit(
+            bounded_limit(limit)
+        )
+        if status_filter:
+            stmt = (
+                select(ReportPushRun)
+                .where(ReportPushRun.status == status_filter)
+                .order_by(ReportPushRun.id.desc())
+                .limit(bounded_limit(limit))
+            )
+        return [serialize_model(item) for item in self.db.execute(stmt).scalars()]
+
+    def get_push_run(self, code: str) -> dict[str, Any]:
+        return serialize_model(self._get_push_run(code))
+
+    def _get_push_run(self, code: str) -> ReportPushRun:
+
+        record = self.db.execute(
+            select(ReportPushRun).where(ReportPushRun.code == code)
+        ).scalar_one_or_none()
+        if record is None:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail=ReportErrorDetail.PUSH_RUN_NOT_FOUND,
+            )
+        return record

app/modules/reports/services/service.py

@@ -0,0 +1,26 @@
+from sqlalchemy.orm import Session
+
+from app.modules.reports.services.common import ReportQueryMixin
+from app.modules.reports.services.delivery import ReportDeliveryMixin
+from app.modules.reports.services.enterprise import ReportEnterpriseAnalyticsMixin
+from app.modules.reports.services.lifecycle import ReportLifecycleMixin
+from app.modules.reports.services.push_runs import ReportPushRunMixin
+from app.modules.reports.services.summaries import ReportSummaryMixin
+from app.modules.reports.services.work_reports import ReportWorkReportMixin
+from app.modules.risk.services import RiskService
+
+
+class ReportService(
+    ReportDeliveryMixin,
+    ReportWorkReportMixin,
+    ReportEnterpriseAnalyticsMixin,
+    ReportLifecycleMixin,
+    ReportSummaryMixin,
+    ReportPushRunMixin,
+    ReportQueryMixin,
+):
+    """Build operational reports and push them through Feishu."""
+
+    def __init__(self, db: Session):
+        self.db = db
+        self.risks = RiskService(db)

app/modules/reports/services/summaries.py

@@ -0,0 +1,131 @@
+from datetime import date
+from decimal import Decimal
+from typing import Any
+
+from sqlalchemy import func, select
+
+from app.modules.business.constants import (
+    ATTENDANCE_ABNORMAL_STATUSES,
+    PROJECT_CLOSED_STATUSES,
+    PENDING_APPROVAL_STATUSES,
+    StatusValue,
+)
+from app.modules.business.models import (
+    AttendanceRecord,
+    Expense,
+    FundAccount,
+    Procurement,
+    Project,
+    WorkTask,
+)
+from app.modules.reports.constants import (
+    ReportResponseKey,
+    ReportTitle,
+)
+from app.modules.risk.constants import RiskSummaryKey
+
+from app.modules.reports.services.common import _money
+
+
+class ReportSummaryMixin:
+    def daily_brief(self) -> dict:
+        project_count = self._count(Project)
+        task_count = self._count(WorkTask)
+        procurement_pending = self._count(
+            Procurement,
+            Procurement.approval_status.in_(PENDING_APPROVAL_STATUSES),
+        )
+        expense_pending = self._count(
+            Expense,
+            Expense.approval_status.in_(PENDING_APPROVAL_STATUSES),
+        )
+        fund_total = (
+            self.db.execute(select(func.sum(FundAccount.current_balance))).scalar()
+            or Decimal("0")
+        )
+        risk_summary = self.risks.summary()
+        attendance = self.attendance_summary()
+        lines = [
+            f"- 项目总数：{project_count}",
+            f"- 任务总数：{task_count}",
+            f"- 待处理采购：{procurement_pending}",
+            f"- 待处理费用：{expense_pending}",
+            f"- 当前账户总余额：{_money(fund_total)}",
+            (
+                f"- 今日打卡记录：{attendance[ReportResponseKey.TOTAL]}，"
+                f"异常：{attendance[ReportResponseKey.ABNORMAL_TOTAL]}"
+            ),
+            f"- 逾期任务：{len(risk_summary[RiskSummaryKey.OVERDUE_TASKS])}",
+            f"- 延期项目：{len(risk_summary[RiskSummaryKey.DELAYED_PROJECTS])}",
+            f"- 超预算项目：{len(risk_summary[RiskSummaryKey.OVER_BUDGET_PROJECTS])}",
+            f"- 资金风险账户：{len(risk_summary[RiskSummaryKey.FUND_RISKS])}",
+            f"- 供应商风险：{len(risk_summary[RiskSummaryKey.SUPPLIER_RISKS])}",
+            f"- 打开风险事件：{len(risk_summary[RiskSummaryKey.OPEN_EVENTS])}",
+            f"- 综合风险等级：{risk_summary[RiskSummaryKey.RISK_LEVEL]}",
+        ]
+        return {
+            ReportResponseKey.TITLE: ReportTitle.DAILY_BRIEF,
+            ReportResponseKey.LINES: lines,
+            ReportResponseKey.CONTENT: "\n".join(lines),
+        }
+
+    def project_weekly(self) -> dict:
+        active = self._count(
+            Project,
+            Project.status.notin_(PROJECT_CLOSED_STATUSES),
+        )
+        delayed = self.risks.delayed_projects()
+        over_budget = self.risks.over_budget_projects()
+        open_risks = self.risks.list_events(status_filter=StatusValue.OPEN)
+        lines = [
+            f"- 活跃项目：{active}",
+            f"- 延期项目：{len(delayed)}",
+            f"- 超预算项目：{len(over_budget)}",
+            f"- 打开风险事件：{len(open_risks)}",
+            "- 需要管理层关注：",
+        ]
+        for item in delayed[:10]:
+            lines.append(
+                f"  - 延期：{item.get('code')} {item.get('name')}，"
+                f"负责人 {item.get('owner')}"
+            )
+        for item in over_budget[:10]:
+            lines.append(f"  - 超预算：{item.get('code')} {item.get('name')}")
+        return {
+            ReportResponseKey.TITLE: ReportTitle.PROJECT_WEEKLY,
+            ReportResponseKey.LINES: lines,
+            ReportResponseKey.CONTENT: "\n".join(lines),
+        }
+
+    def attendance_summary(self, work_date: date | None = None) -> dict[str, Any]:
+        """Summarize attendance records for one business day."""
+
+        target_date = work_date or date.today()
+        rows = self.db.execute(
+            select(AttendanceRecord.status, func.count())
+            .where(AttendanceRecord.work_date == target_date)
+            .group_by(AttendanceRecord.status)
+        ).all()
+        status_counts = {str(status): int(count) for status, count in rows}
+        abnormal_total = sum(
+            count
+            for status, count in status_counts.items()
+            if status in ATTENDANCE_ABNORMAL_STATUSES
+        )
+        total = sum(status_counts.values())
+        lines = [
+            f"- 日期：{target_date.isoformat()}",
+            f"- 打卡记录：{total}",
+            f"- 异常记录：{abnormal_total}",
+        ]
+        for status, count in sorted(status_counts.items()):
+            lines.append(f"- {status}：{count}")
+        return {
+            ReportResponseKey.TITLE: ReportTitle.ATTENDANCE_SUMMARY,
+            ReportResponseKey.WORK_DATE: target_date.isoformat(),
+            ReportResponseKey.TOTAL: total,
+            ReportResponseKey.ABNORMAL_TOTAL: abnormal_total,
+            ReportResponseKey.STATUS_COUNTS: status_counts,
+            ReportResponseKey.LINES: lines,
+            ReportResponseKey.CONTENT: "\n".join(lines),
+        }

app/modules/reports/services/work_reports.py

@@ -0,0 +1,225 @@
+from datetime import date, timedelta
+from typing import Any
+
+
+from app.core.constants import ActorValue
+from app.modules.audit.constants import AuditSource, AuditTargetType
+from app.modules.audit.schemas import AuditLogCreate
+from app.modules.audit.service import AuditService
+from app.modules.business.constants import (
+    DONE_STATUSES,
+    PROJECT_CLOSED_STATUSES,
+    PENDING_APPROVAL_STATUSES,
+    StatusValue,
+)
+from app.modules.business.models import (
+    AttendanceRecord,
+    Expense,
+    Procurement,
+    Project,
+    RiskEvent,
+    WorkReport,
+    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.reports.constants import (
+    ReportResponseKey,
+    ReportTitle,
+    ReportType,
+    WorkReportMetricKey,
+)
+from app.modules.risk.constants import RiskSummaryKey
+
+from app.modules.reports.services.common import _json_safe, _next_code
+
+
+class ReportWorkReportMixin:
+    def generate_work_report(
+        self,
+        report_type: str = ReportType.DAILY,
+        reporter: str = ActorValue.SYSTEM,
+        department: str | None = None,
+        project_code: str | None = None,
+        period_start: date | None = None,
+        period_end: date | None = None,
+        persist: bool = True,
+        actor: str = ActorValue.API,
+    ) -> dict[str, Any]:
+        """Generate a daily or weekly operating report, optionally persisting it."""
+
+        start, end = self._resolve_period(report_type, period_start, period_end)
+        metrics = self._report_metrics(start, end, project_code, department)
+        risk_summary = _json_safe(self.risks.summary())
+        title = (
+            ReportTitle.WORK_DAILY
+            if report_type == ReportType.DAILY
+            else ReportTitle.WORK_WEEKLY
+        )
+        lines = self._work_report_lines(title, start, end, metrics, risk_summary)
+        report = {
+            ReportResponseKey.TITLE: title,
+            ReportResponseKey.REPORT_TYPE: report_type,
+            ReportResponseKey.PERIOD_START: start.isoformat(),
+            ReportResponseKey.PERIOD_END: end.isoformat(),
+            ReportResponseKey.LINES: lines,
+            ReportResponseKey.CONTENT: "\n".join(lines),
+            ReportResponseKey.METRICS: metrics,
+            ReportResponseKey.RISK_SUMMARY: risk_summary,
+        }
+
+        record_data = None
+        if persist:
+            record = WorkReport(
+                code=_next_code(f"REPORT-{report_type.upper()}"),
+                report_type=report_type,
+                title=title,
+                reporter=reporter,
+                department=department,
+                project_code=project_code,
+                period_start=start,
+                period_end=end,
+                content=report[ReportResponseKey.CONTENT],
+                metrics=metrics,
+                risk_summary=risk_summary,
+            )
+            self.db.add(record)
+            self.db.commit()
+            self.db.refresh(record)
+            record_data = serialize_model(record)
+            AuditService(self.db).log(
+                AuditLogCreate(
+                    actor=actor,
+                    source=AuditSource.REPORTS,
+                    action=f"generate_{report_type}_report",
+                    target_type=AuditTargetType.WORK_REPORTS,
+                    target_id=str(record.id),
+                    response_payload=record_data,
+                )
+            )
+            EventService(self.db).emit(
+                event_type=EventType.REPORT_GENERATED,
+                source=EventSource.REPORTS,
+                aggregate_type=EventAggregateType.WORK_REPORT,
+                aggregate_id=record.code,
+                actor=actor,
+                payload={
+                    EventPayloadKey.CODE: record.code,
+                    EventPayloadKey.STATUS: record.status,
+                },
+                idempotency_key=f"report-generated:{record.code}",
+                dispatch=True,
+            )
+
+        return {ReportResponseKey.REPORT: report, ReportResponseKey.DATA: record_data}
+
+    def _resolve_period(
+        self,
+        report_type: str,
+        period_start: date | None,
+        period_end: date | None,
+    ) -> tuple[date, date]:
+        today = date.today()
+        if report_type == ReportType.DAILY:
+            start = period_start or period_end or today
+            return start, period_end or start
+        end = period_end or today
+        start = period_start or end - timedelta(days=6)
+        return start, end
+
+    def _report_metrics(
+        self,
+        start: date,
+        end: date,
+        project_code: str | None,
+        department: str | None,
+    ) -> dict[str, Any]:
+        task_filters = [
+            WorkTask.due_date.is_not(None),
+            WorkTask.due_date >= start,
+            WorkTask.due_date <= end,
+        ]
+        project_filters = []
+        risk_filters = [RiskEvent.status == StatusValue.OPEN]
+        procurement_filters = [
+            Procurement.approval_status.in_(PENDING_APPROVAL_STATUSES),
+        ]
+        expense_filters = [
+            Expense.approval_status.in_(PENDING_APPROVAL_STATUSES),
+        ]
+        attendance_filters = [
+            AttendanceRecord.work_date >= start,
+            AttendanceRecord.work_date <= end,
+        ]
+        if project_code:
+            project_filters.append(Project.code == project_code)
+            task_filters.append(WorkTask.project_code == project_code)
+            procurement_filters.append(Procurement.project_code == project_code)
+            expense_filters.append(Expense.project_code == project_code)
+            attendance_filters.append(AttendanceRecord.project_code == project_code)
+            risk_filters.append(RiskEvent.project_code == project_code)
+        if department:
+            expense_filters.append(Expense.department == department)
+            attendance_filters.append(AttendanceRecord.department == department)
+
+        completed_tasks = self._count(WorkTask, WorkTask.status.in_(DONE_STATUSES), *task_filters)
+        overdue_tasks = self._count(
+            WorkTask,
+            WorkTask.due_date < date.today(),
+            WorkTask.status.notin_(DONE_STATUSES),
+            *task_filters,
+        )
+        return {
+            WorkReportMetricKey.PROJECTS_TOTAL: self._count(Project, *project_filters),
+            WorkReportMetricKey.ACTIVE_PROJECTS: self._count(
+                Project,
+                Project.status.notin_(PROJECT_CLOSED_STATUSES),
+                *project_filters,
+            ),
+            WorkReportMetricKey.TASKS_TOTAL: self._count(WorkTask, *task_filters),
+            WorkReportMetricKey.TASKS_COMPLETED: completed_tasks,
+            WorkReportMetricKey.TASKS_OVERDUE: overdue_tasks,
+            WorkReportMetricKey.PROCUREMENTS_PENDING: self._count(
+                Procurement,
+                *procurement_filters,
+            ),
+            WorkReportMetricKey.EXPENSES_PENDING: self._count(Expense, *expense_filters),
+            WorkReportMetricKey.ATTENDANCE_TOTAL: self._count(
+                AttendanceRecord,
+                *attendance_filters,
+            ),
+            WorkReportMetricKey.OPEN_RISK_EVENTS: self._count(RiskEvent, *risk_filters),
+        }
+
+    def _work_report_lines(
+        self,
+        title: str,
+        start: date,
+        end: date,
+        metrics: dict[str, Any],
+        risk_summary: dict[str, Any],
+    ) -> list[str]:
+        return [
+            f"- 报告：{title}",
+            f"- 周期：{start.isoformat()} 至 {end.isoformat()}",
+            (
+                f"- 项目：总数 {metrics[WorkReportMetricKey.PROJECTS_TOTAL]}，"
+                f"活跃 {metrics[WorkReportMetricKey.ACTIVE_PROJECTS]}"
+            ),
+            (
+                f"- 任务：总数 {metrics[WorkReportMetricKey.TASKS_TOTAL]}，"
+                f"完成 {metrics[WorkReportMetricKey.TASKS_COMPLETED]}"
+            ),
+            f"- 逾期任务：{metrics[WorkReportMetricKey.TASKS_OVERDUE]}",
+            f"- 待处理采购：{metrics[WorkReportMetricKey.PROCUREMENTS_PENDING]}",
+            f"- 待处理费用：{metrics[WorkReportMetricKey.EXPENSES_PENDING]}",
+            f"- 打卡记录：{metrics[WorkReportMetricKey.ATTENDANCE_TOTAL]}",
+            f"- 打开风险事件：{metrics[WorkReportMetricKey.OPEN_RISK_EVENTS]}",
+            f"- 综合风险等级：{risk_summary[RiskSummaryKey.RISK_LEVEL]}",
+        ]