```

refactor(Dockerfile): 使用requirements.txt替代硬编码依赖

将Dockerfile中的硬编码pip包列表替换为通过requirements.txt文件安装，
提高依赖管理的灵活性和可维护性。

feat(scheduling): 移除内置APScheduler，采用独立调度系统

移除app/core/background/scheduler.py中原来的APScheduler实现，
改为使用新的应用级调度系统app.application.scheduling。

refactor(task_queue): 调整任务队列模块结构和导入路径

将任务队列相关常量从app.core.background.task_queue.constants迁移至
app.tasks.constants，并更新所有相关导入路径和引用。

refactor(events): 将事件服务重构为独立的应用层组件

将事件分发逻辑从核心层迁移到应用层，使用app.application.events.EventDispatchService
替代原有的app.modules.events.services.EventService。

feat(ai_memory): 增强AI记忆自动写入的安全策略

新增ai_memory_blocked_content_terms配置项用于阻止敏感内容，
添加TTL过期机制控制自动写入条目的生命周期。

fix(security): 强化生产环境安全验证机制

增加model_validator确保生产环境中数据库连接、API密钥、CORS设置等
关键安全配置符合要求。

feat(risks): 优化风险事件操作动作的外键约束

为RiskEventAction模型的风险事件ID字段添加外键约束，
防止孤立记录并增强数据完整性。

refactor(audit): 优化审计服务方法命名和事务处理

将AuditService的log方法重命名为record以反映其阶段行为，
并调整事务提交时机以提高性能。

feat(events): 增强领域事件并发处理和响应模型

添加事件锁定机制防止重复处理，更新API响应模型以提供
更准确的数据类型定义。
```

app/application/feishu/events.py

@@ -0,0 +1,144 @@
+from typing import Any
+
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.orm import Session
+
+from app.application.feishu.commands import FeishuCommandService
+from app.core.constants import ActorValue
+from app.modules.audit.constants import AuditAction, AuditSource
+from app.modules.audit.schemas import AuditLogCreate
+from app.modules.feishu.constants import (
+    FeishuCommandKey,
+    FeishuEventReceiptKey,
+    FeishuEventSource,
+    FeishuPayloadKey,
+    FeishuResponseKey,
+)
+from app.modules.feishu.models import FeishuEventReceipt
+from app.modules.feishu.service import FeishuService
+
+FEISHU_EVENT_ACTIONS = {
+    FeishuEventSource.WEBHOOK: AuditAction.FEISHU_WEBHOOK_EVENT,
+    FeishuEventSource.LONG_CONNECTION: AuditAction.FEISHU_LONG_CONNECTION_EVENT,
+}
+
+
+class FeishuEventService:
+    """Handle Feishu message events from webhook or long connection."""
+
+    def __init__(self, db: Session):
+        self.db = db
+        self.feishu = FeishuService(db)
+        self.commands = FeishuCommandService(db)
+
+    def handle_event(
+        self,
+        payload: dict[str, Any],
+        source: str | FeishuEventSource,
+        auto_reply: bool = True,
+    ) -> dict[str, Any]:
+        self.feishu.verify_event(payload)
+        challenge = payload.get(FeishuPayloadKey.CHALLENGE)
+        if challenge:
+            return {FeishuResponseKey.CHALLENGE: challenge}
+        source_value = _normalize_source(source)
+        event_identity = _event_identity(payload, source)
+        if event_identity and not self._register_event(event_identity):
+            return {
+                FeishuResponseKey.OK: True,
+                FeishuResponseKey.HANDLED: False,
+                FeishuResponseKey.DUPLICATE: True,
+            }
+        self.feishu.audit.log(
+            AuditLogCreate(
+                actor=ActorValue.FEISHU,
+                source=AuditSource.FEISHU,
+                action=FEISHU_EVENT_ACTIONS[source_value],
+                target_type=source_value,
+                target_id=(
+                    event_identity.get(FeishuEventReceiptKey.EVENT_KEY)
+                    if event_identity
+                    else None
+                ),
+                request_payload=_audit_event_metadata(payload),
+                response_payload={FeishuResponseKey.ACCEPTED: True},
+            )
+        )
+        command = self.commands.extract_event_command(payload)
+        if not command:
+            return {FeishuResponseKey.OK: True, FeishuResponseKey.HANDLED: False}
+        result = self.commands.handle_text(
+            command[FeishuCommandKey.TEXT],
+            chat_id=command[FeishuCommandKey.CHAT_ID],
+            actor=command[FeishuCommandKey.ACTOR],
+            auto_reply=auto_reply,
+        )
+        return {
+            FeishuResponseKey.OK: True,
+            FeishuResponseKey.HANDLED: True,
+            FeishuResponseKey.RESULT: result,
+        }
+
+    def _register_event(self, event_identity: dict[str, str | None]) -> bool:
+        receipt = FeishuEventReceipt(
+            event_key=str(event_identity[FeishuEventReceiptKey.EVENT_KEY]),
+            source=str(event_identity[FeishuEventReceiptKey.SOURCE]),
+            event_id=event_identity.get(FeishuEventReceiptKey.EVENT_ID),
+            message_id=event_identity.get(FeishuEventReceiptKey.MESSAGE_ID),
+        )
+        self.db.add(receipt)
+        try:
+            self.db.flush()
+        except IntegrityError:
+            self.db.rollback()
+            return False
+        return True
+
+
+def _audit_event_metadata(payload: dict[str, Any]) -> dict[str, Any]:
+    """Keep webhook audit evidence without storing message content or tokens."""
+
+    header = payload.get(FeishuPayloadKey.HEADER) or {}
+    event = payload.get(FeishuPayloadKey.EVENT) or {}
+    message = event.get(FeishuPayloadKey.MESSAGE) or {}
+    sender = event.get(FeishuPayloadKey.SENDER) or {}
+    sender_id = sender.get(FeishuPayloadKey.SENDER_ID) or {}
+    return {
+        "schema": payload.get("schema"),
+        FeishuPayloadKey.EVENT_ID: header.get(FeishuPayloadKey.EVENT_ID),
+        FeishuPayloadKey.EVENT_TYPE: header.get(FeishuPayloadKey.EVENT_TYPE),
+        FeishuPayloadKey.MESSAGE_ID: message.get(FeishuPayloadKey.MESSAGE_ID),
+        FeishuCommandKey.CHAT_ID: message.get(FeishuCommandKey.CHAT_ID),
+        FeishuPayloadKey.MESSAGE_TYPE: message.get(FeishuPayloadKey.MESSAGE_TYPE),
+        FeishuPayloadKey.OPEN_ID: sender_id.get(FeishuPayloadKey.OPEN_ID),
+    }
+
+
+def _normalize_source(source: str | FeishuEventSource) -> FeishuEventSource:
+    return FeishuEventSource(source)
+
+
+def _event_identity(
+    payload: dict[str, Any],
+    source: str | FeishuEventSource,
+) -> dict[str, str | None] | None:
+    source_value = _normalize_source(source)
+    header = payload.get(FeishuPayloadKey.HEADER) or {}
+    event = payload.get(FeishuPayloadKey.EVENT) or {}
+    message = event.get(FeishuPayloadKey.MESSAGE) or {}
+    event_id = header.get(FeishuPayloadKey.EVENT_ID)
+    message_id = message.get(FeishuPayloadKey.MESSAGE_ID)
+    stable_id = event_id or message_id
+    if not stable_id:
+        return None
+    event_type = header.get(FeishuPayloadKey.EVENT_TYPE)
+    event_key = ":".join(
+        str(part)
+        for part in (source_value, event_type or FeishuPayloadKey.EVENT, stable_id)
+    )
+    return {
+        FeishuEventReceiptKey.EVENT_KEY: event_key,
+        FeishuEventReceiptKey.SOURCE: source_value,
+        FeishuEventReceiptKey.EVENT_ID: str(event_id) if event_id else None,
+        FeishuEventReceiptKey.MESSAGE_ID: str(message_id) if message_id else None,
+    }