```

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

@@ -0,0 +1,4 @@
+from app.application.feishu.commands import FeishuCommandService
+from app.application.feishu.events import FeishuEventService
+
+__all__ = ["FeishuCommandService", "FeishuEventService"]

app/application/feishu/commands.py

@@ -0,0 +1,201 @@
+import json
+import re
+from typing import Any
+
+from sqlalchemy.orm import Session
+
+from app.application.feishu.delivery import send_card_if_configured, send_text_if_configured
+from app.application.feishu.handlers import (
+    handle_finance_command,
+    handle_market_command,
+    handle_rule_command,
+)
+from app.application.feishu.results import command_result
+from app.core.constants import ActorValue
+from app.modules.ai_agent.constants import AIResponseKey
+from app.modules.ai_agent.service import AIService
+from app.modules.audit.constants import AuditSource
+from app.modules.feishu.constants import (
+    FEISHU_AI_REPLY_TITLE,
+    FEISHU_MENTION_PATTERN,
+    FEISHU_ZERO_WIDTH_SPACE,
+    FeishuCommandKey,
+    FeishuCommandName,
+    FeishuPayloadKey,
+    FeishuReplyType,
+)
+from app.modules.feishu.service import FeishuService
+from app.modules.reports.constants import ReportResponseKey
+from app.modules.reports.services import ReportService
+
+DAILY_REPORT_KEYWORDS = ("日报", "晨报", "经营日报", "经营晨报")
+PROJECT_WEEKLY_KEYWORDS = ("周报", "项目周报")
+ATTENDANCE_KEYWORDS = ("打卡", "考勤", "attendance")
+RISK_KEYWORDS = ("风险", "预警", "risk")
+AI_COMMAND_PREFIXES = ("问 ", "ai ", "AI ", "/ask ")
+DEFAULT_AI_PROMPT = "请说明你能做什么。"
+
+
+def _parse_content_text(content: Any) -> str:
+    """Extract plain command text from a Feishu message content payload."""
+
+    if isinstance(content, dict):
+        return str(
+            content.get(FeishuPayloadKey.TEXT) or content.get(FeishuPayloadKey.CONTENT) or ""
+        )
+    if not isinstance(content, str):
+        return ""
+    try:
+        data = json.loads(content)
+    except json.JSONDecodeError:
+        return content
+    if isinstance(data, dict):
+        return str(data.get(FeishuPayloadKey.TEXT) or data.get(FeishuPayloadKey.CONTENT) or "")
+    return content
+
+
+def _clean_command_text(text: str) -> str:
+    """Remove mentions and invisible characters from Feishu command text."""
+
+    text = re.sub(FEISHU_MENTION_PATTERN, "", text or "")
+    text = text.replace(FEISHU_ZERO_WIDTH_SPACE, "")
+    return text.strip()
+
+
+class FeishuCommandService:
+    """Route Feishu text commands to focused application handlers."""
+
+    def __init__(self, db: Session):
+        self.db = db
+        self.feishu = FeishuService(db)
+
+    def extract_event_command(self, payload: dict[str, Any]) -> dict[str, Any] | None:
+        event = payload.get(FeishuPayloadKey.EVENT) or {}
+        message = event.get(FeishuPayloadKey.MESSAGE) or {}
+        if not message:
+            return None
+        text = _clean_command_text(_parse_content_text(message.get(FeishuPayloadKey.CONTENT)))
+        if not text:
+            return None
+        sender = event.get(FeishuPayloadKey.SENDER) or {}
+        sender_id = sender.get(FeishuPayloadKey.SENDER_ID) or {}
+        actor = (
+            sender_id.get(FeishuPayloadKey.OPEN_ID)
+            or sender_id.get(FeishuPayloadKey.USER_ID)
+            or ActorValue.FEISHU
+        )
+        return {
+            FeishuCommandKey.TEXT: text,
+            FeishuCommandKey.CHAT_ID: message.get(FeishuCommandKey.CHAT_ID),
+            FeishuCommandKey.ACTOR: actor,
+        }
+
+    def handle_text(
+        self,
+        text: str,
+        chat_id: str | None = None,
+        actor: str = ActorValue.FEISHU,
+        auto_reply: bool = True,
+    ) -> dict[str, Any]:
+        command_text = _clean_command_text(text)
+        lowered = command_text.lower()
+
+        for handler in (
+            handle_rule_command,
+            handle_finance_command,
+            handle_market_command,
+        ):
+            result = handler(
+                self.db,
+                self.feishu,
+                command_text,
+                chat_id,
+                actor,
+                auto_reply,
+            )
+            if result is not None:
+                return result
+
+        report_result = self._handle_report_command(command_text, chat_id, actor, auto_reply)
+        if report_result is not None:
+            return report_result
+        return self._handle_ai_command(command_text, lowered, chat_id, actor, auto_reply)
+
+    def _handle_report_command(
+        self,
+        command_text: str,
+        chat_id: str | None,
+        actor: str,
+        auto_reply: bool,
+    ) -> dict[str, Any] | None:
+        service = ReportService(self.db)
+        if any(keyword in command_text for keyword in DAILY_REPORT_KEYWORDS):
+            command = FeishuCommandName.DAILY_BRIEF
+            report = service.daily_brief()
+        elif any(keyword in command_text for keyword in PROJECT_WEEKLY_KEYWORDS):
+            command = FeishuCommandName.PROJECT_WEEKLY
+            report = service.project_weekly()
+        elif any(keyword in command_text for keyword in ATTENDANCE_KEYWORDS):
+            command = FeishuCommandName.ATTENDANCE_SUMMARY
+            report = service.attendance_summary()
+        elif any(keyword in command_text for keyword in RISK_KEYWORDS):
+            command = FeishuCommandName.RISK_SUMMARY
+            report = service.risk_progress()
+        else:
+            return None
+        response = (
+            send_card_if_configured(
+                self.feishu,
+                chat_id,
+                report[ReportResponseKey.TITLE],
+                report[ReportResponseKey.LINES],
+                actor,
+            )
+            if auto_reply
+            else None
+        )
+        return command_result(
+            command,
+            FeishuReplyType.CARD,
+            report[ReportResponseKey.TITLE],
+            report[ReportResponseKey.CONTENT],
+            response,
+            report[ReportResponseKey.LINES],
+        )
+
+    def _handle_ai_command(
+        self,
+        command_text: str,
+        lowered: str,
+        chat_id: str | None,
+        actor: str,
+        auto_reply: bool,
+    ) -> dict[str, Any]:
+        prompt = command_text
+        for prefix in AI_COMMAND_PREFIXES:
+            if command_text.startswith(prefix):
+                prompt = command_text[len(prefix) :].strip()
+                break
+        if not prompt:
+            prompt = DEFAULT_AI_PROMPT
+        ai_result = AIService(self.db).ask(
+            prompt,
+            context={},
+            actor=actor,
+            source=AuditSource.FEISHU,
+        )
+        content = ai_result[AIResponseKey.ANSWER]
+        is_explicit_ai = any(
+            command_text.startswith(prefix) or lowered.startswith(prefix)
+            for prefix in AI_COMMAND_PREFIXES
+        )
+        response = (
+            send_text_if_configured(self.feishu, chat_id, content, actor) if auto_reply else None
+        )
+        return command_result(
+            FeishuCommandName.AI_ASK if is_explicit_ai else FeishuCommandName.FALLBACK_AI,
+            FeishuReplyType.TEXT,
+            FEISHU_AI_REPLY_TITLE,
+            content,
+            response,
+        )

app/application/feishu/delivery.py

@@ -0,0 +1,34 @@
+from typing import Any
+
+from app.core.config import get_settings
+from app.modules.feishu.service import FeishuService
+
+
+def send_text_if_configured(
+    feishu: FeishuService,
+    chat_id: str | None,
+    text: str,
+    actor: str,
+) -> dict[str, Any] | None:
+    """Send a text reply only when Feishu credentials are configured."""
+
+    settings = get_settings()
+    if not (settings.feishu_app_id and settings.feishu_app_secret):
+        return None
+    return feishu.send_text(text, receive_id=chat_id, actor=actor)
+
+
+def send_card_if_configured(
+    feishu: FeishuService,
+    chat_id: str | None,
+    title: str,
+    lines: list[str],
+    actor: str,
+) -> dict[str, Any] | None:
+    """Send a basic card only when Feishu credentials are configured."""
+
+    settings = get_settings()
+    if not (settings.feishu_app_id and settings.feishu_app_secret):
+        return None
+    card = FeishuService.build_basic_card(title, lines)
+    return feishu.send_card(card, receive_id=chat_id, actor=actor)

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,
+    }

app/application/feishu/handlers/__init__.py

@@ -0,0 +1,9 @@
+from app.application.feishu.handlers.finance import handle_finance_command
+from app.application.feishu.handlers.market import handle_market_command
+from app.application.feishu.handlers.rules import handle_rule_command
+
+__all__ = [
+    "handle_finance_command",
+    "handle_market_command",
+    "handle_rule_command",
+]

app/application/feishu/handlers/finance.py

@@ -0,0 +1,141 @@
+import re
+from typing import Any
+
+from sqlalchemy.orm import Session
+
+from app.application.feishu.delivery import send_text_if_configured
+from app.application.feishu.results import command_result
+from app.core.config import get_settings
+from app.modules.ai_agent.constants import AIResponseKey
+from app.modules.feishu.constants import FeishuCommandName, FeishuReplyType
+from app.modules.feishu.service import FeishuService
+from app.modules.reports.chart import lifecycle_chart_alt, render_lifecycle_chart
+from app.modules.reports.constants import ReportResponseKey
+from app.modules.reports.services import ReportService
+
+PROJECT_FINANCE_PATTERN = re.compile(r"^项目资金\s+(.+)$")
+FINANCE_COMMANDS = {"资金需求", "未来30天资金需求"}
+
+
+def handle_finance_command(
+    db: Session,
+    feishu: FeishuService,
+    command_text: str,
+    chat_id: str | None,
+    actor: str,
+    auto_reply: bool,
+) -> dict[str, Any] | None:
+    """Handle project cash-needs commands."""
+
+    project_match = PROJECT_FINANCE_PATTERN.fullmatch(command_text)
+    if command_text not in FINANCE_COMMANDS and project_match is None:
+        return None
+    command = (
+        FeishuCommandName.PROJECT_FINANCE if project_match else FeishuCommandName.FINANCE_NEEDS
+    )
+    if not get_settings().finance_needs_enabled:
+        return _text_result(
+            feishu,
+            command,
+            "项目资金需求分析",
+            "项目资金需求分析尚未启用，请先配置并启用财务只读同步。",
+            chat_id,
+            actor,
+            auto_reply,
+        )
+
+    project_code = project_match.group(1).strip() if project_match else None
+    service = ReportService(db)
+    preview = service.project_finance_needs_report(
+        project_code=project_code,
+        include_ai=False,
+        actor=actor,
+    )
+    if project_code and not preview["items"]:
+        return _text_result(
+            feishu,
+            command,
+            "项目资金需求分析",
+            f"未找到项目“{project_code}”，请使用稳定项目编号或展示编号。",
+            chat_id,
+            actor,
+            auto_reply,
+        )
+    if not preview["summary"]["data_available"]:
+        return _text_result(
+            feishu,
+            command,
+            "项目资金需求分析",
+            "项目财务数据未接入或无有效记录，暂不生成资金分析报告。",
+            chat_id,
+            actor,
+            auto_reply,
+        )
+
+    report = service.project_finance_needs_report(
+        project_code=project_code,
+        include_ai=True,
+        actor=actor,
+    )
+    ai_analysis = report.get("ai_analysis") or {}
+    if not ai_analysis.get(AIResponseKey.OK):
+        return _text_result(
+            feishu,
+            command,
+            "AI 暂不可用",
+            "AI 当前不可用，本次项目资金分析报告未发送。请检查模型服务。",
+            chat_id,
+            actor,
+            auto_reply,
+        )
+
+    provider_response = None
+    if auto_reply:
+        provider_response = _send_finance_card(feishu, chat_id, report, actor)
+    return command_result(
+        command,
+        FeishuReplyType.CARD,
+        report[ReportResponseKey.TITLE],
+        report[ReportResponseKey.CONTENT],
+        provider_response,
+        report[ReportResponseKey.LINES],
+    )
+
+
+def _text_result(
+    feishu: FeishuService,
+    command: FeishuCommandName,
+    title: str,
+    content: str,
+    chat_id: str | None,
+    actor: str,
+    auto_reply: bool,
+) -> dict[str, Any]:
+    response = send_text_if_configured(feishu, chat_id, content, actor) if auto_reply else None
+    return command_result(command, FeishuReplyType.TEXT, title, content, response)
+
+
+def _send_finance_card(
+    feishu: FeishuService,
+    chat_id: str | None,
+    report: dict[str, Any],
+    actor: str,
+) -> dict[str, Any] | None:
+    settings = get_settings()
+    if not (settings.feishu_app_id and settings.feishu_app_secret):
+        return None
+    chart_data = {
+        "period": report.get("as_of"),
+        "finance": report.get("finance_chart_data"),
+    }
+    image_result = feishu.upload_image(render_lifecycle_chart(chart_data), actor)
+    image_key = (image_result.get("data") or {}).get("image_key")
+    if not image_key:
+        raise ValueError("Feishu image upload did not return image_key")
+    card = FeishuService.build_basic_card(
+        report[ReportResponseKey.TITLE],
+        report[ReportResponseKey.LINES],
+        image_key=image_key,
+        image_alt=lifecycle_chart_alt(chart_data),
+    )
+    return feishu.send_card(card, receive_id=chat_id, actor=actor)

app/application/feishu/handlers/market.py

@@ -0,0 +1,243 @@
+import re
+from typing import Any
+
+from fastapi import HTTPException
+from sqlalchemy.orm import Session
+
+from app.application.feishu.delivery import send_text_if_configured
+from app.application.feishu.results import command_result
+from app.core.config import get_settings
+from app.modules.feishu.constants import FeishuCommandName, FeishuReplyType
+from app.modules.feishu.service import FeishuService
+from app.modules.market.chart import render_market_chart
+from app.modules.market.service import MarketService
+
+STOCK_ANALYSIS_PATTERN = re.compile(
+    r"^(?:股票分析|估值分析|财报分析)\s+([0-9]{6}(?:\.(?:SH|SZ|BJ))?)$", re.IGNORECASE
+)
+WATCHLIST_ADD_PATTERN = re.compile(r"^加入自选\s+([0-9]{6}(?:\.(?:SH|SZ|BJ))?)$", re.IGNORECASE)
+MARKET_COMMANDS = {
+    "市场分析",
+    "今日收盘分析",
+    "本周市场分析",
+    "宏观金融分析",
+    "最新公告",
+}
+INDUSTRY_ANALYSIS_PATTERN = re.compile(r"^行业分析\s+(.+)$")
+STOCK_COMPARE_PATTERN = re.compile(
+    r"^股票对比\s+([0-9]{6}(?:\.(?:SH|SZ|BJ))?)\s+"
+    r"([0-9]{6}(?:\.(?:SH|SZ|BJ))?)$",
+    re.IGNORECASE,
+)
+
+
+def handle_market_command(
+    db: Session,
+    feishu: FeishuService,
+    text: str,
+    chat_id: str | None,
+    actor: str,
+    auto_reply: bool,
+) -> dict[str, Any] | None:
+    """Handle market analysis and watchlist commands."""
+
+    stock = STOCK_ANALYSIS_PATTERN.fullmatch(text)
+    add = WATCHLIST_ADD_PATTERN.fullmatch(text)
+    industry = INDUSTRY_ANALYSIS_PATTERN.fullmatch(text)
+    comparison = STOCK_COMPARE_PATTERN.fullmatch(text)
+    if (
+        text not in MARKET_COMMANDS
+        and text != "查看自选"
+        and not stock
+        and not add
+        and not industry
+        and not comparison
+    ):
+        return None
+    if not get_settings().market_analysis_enabled:
+        return _text_result(
+            feishu,
+            FeishuCommandName.MARKET_OVERVIEW,
+            "市场分析",
+            "市场分析尚未启用，请配置市场数据源后启用。",
+            chat_id,
+            actor,
+            auto_reply,
+        )
+
+    service = MarketService(db)
+    if add:
+        if get_settings().read_only_mode:
+            return _text_result(
+                feishu,
+                FeishuCommandName.WATCHLIST_ADD,
+                "自选股",
+                "当前为只读模式，不能修改自选股。请由管理员启用操作后重试。",
+                chat_id,
+                actor,
+                auto_reply,
+            )
+        item = service.add_watchlist(actor, add.group(1))
+        return _text_result(
+            feishu,
+            FeishuCommandName.WATCHLIST_ADD,
+            "自选股",
+            f"已加入自选：{item['symbol']}",
+            chat_id,
+            actor,
+            auto_reply,
+        )
+    if text == "查看自选":
+        items = service.watchlist(actor)
+        content = "自选股：" + ("、".join(item["symbol"] for item in items) or "暂无")
+        return _text_result(
+            feishu,
+            FeishuCommandName.WATCHLIST_LIST,
+            "自选股",
+            content,
+            chat_id,
+            actor,
+            auto_reply,
+        )
+    if text == "最新公告":
+        items = service.announcements(limit=10)["items"]
+        content = (
+            "最新公告：\n"
+            + "\n".join(
+                f"- {item['announcement_date']} {item['symbol'] or '市场'}：{item['title']}"
+                for item in items
+            )
+            if items
+            else "公告元数据尚未接入。"
+        )
+        return _text_result(
+            feishu,
+            FeishuCommandName.MARKET_ANNOUNCEMENTS,
+            "最新公告",
+            content,
+            chat_id,
+            actor,
+            auto_reply,
+        )
+    if industry:
+        try:
+            data = service.industry_analysis(industry.group(1).strip())
+            content = (
+                f"{data['industry']} 平均涨跌 {data['average_pct_change']}%\n"
+                + "\n".join(
+                    f"- {item['name']}（{item['symbol']}）：{item['pct_change']}%"
+                    for item in data["items"][:10]
+                )
+            )
+        except HTTPException:
+            content = "未找到该行业的最新市场数据。"
+        return _text_result(
+            feishu,
+            FeishuCommandName.MARKET_OVERVIEW,
+            "行业分析",
+            content,
+            chat_id,
+            actor,
+            auto_reply,
+        )
+    if comparison:
+        try:
+            content = service.compare_stocks([comparison.group(1), comparison.group(2)])["content"]
+        except HTTPException:
+            content = "至少一只股票缺少可用行情，暂时无法比较。"
+        return _text_result(
+            feishu,
+            FeishuCommandName.STOCK_ANALYSIS,
+            "股票对比",
+            content,
+            chat_id,
+            actor,
+            auto_reply,
+        )
+    return _analysis_result(service, feishu, text, stock.group(1) if stock else None, chat_id, actor, auto_reply)
+
+
+def _analysis_result(
+    service: MarketService,
+    feishu: FeishuService,
+    text: str,
+    symbol: str | None,
+    chat_id: str | None,
+    actor: str,
+    auto_reply: bool,
+) -> dict[str, Any]:
+    command = FeishuCommandName.STOCK_ANALYSIS if symbol else FeishuCommandName.MARKET_OVERVIEW
+    if text == "宏观金融分析":
+        command = FeishuCommandName.MARKET_MACRO
+    try:
+        if symbol:
+            report = service.stock_analysis(symbol, True, actor)
+        elif text == "本周市场分析":
+            report = service.weekly_overview(include_ai=True, actor=actor)
+        elif text == "宏观金融分析":
+            report = service.macro_analysis(include_ai=True, actor=actor)
+        else:
+            report = service.market_overview(include_ai=True, actor=actor)
+    except HTTPException:
+        return _text_result(
+            feishu,
+            command,
+            "股票分析",
+            "未找到该股票的可用行情，请确认代码或先执行行情同步。",
+            chat_id,
+            actor,
+            auto_reply,
+        )
+    ai = report.get("ai_analysis") or {}
+    if not report.get("data_available"):
+        content = "市场数据未接入，暂不生成分析报告。"
+    elif not ai.get("ok"):
+        content = "AI 当前不可用，本次市场分析报告未发送。"
+    else:
+        content = report["content"]
+    response = _send_analysis(feishu, text, report, content, chat_id, actor) if auto_reply else None
+    return command_result(
+        command,
+        FeishuReplyType.CARD if ai.get("ok") and text != "宏观金融分析" else FeishuReplyType.TEXT,
+        report["title"],
+        content,
+        response,
+        report["lines"] if ai.get("ok") else None,
+    )
+
+
+def _send_analysis(
+    feishu: FeishuService,
+    text: str,
+    report: dict[str, Any],
+    content: str,
+    chat_id: str | None,
+    actor: str,
+) -> dict[str, Any] | None:
+    ai = report.get("ai_analysis") or {}
+    if not ai.get("ok") or text == "宏观金融分析":
+        return send_text_if_configured(feishu, chat_id, content, actor)
+    image = feishu.upload_image(render_market_chart(report), actor)
+    image_key = (image.get("data") or {}).get("image_key")
+    if not image_key:
+        raise ValueError("Feishu image upload did not return image_key")
+    card = FeishuService.build_basic_card(
+        report["title"],
+        report["lines"],
+        image_key=image_key,
+        image_alt=report["title"],
+    )
+    return feishu.send_card(card, receive_id=chat_id, actor=actor)
+
+
+def _text_result(
+    feishu: FeishuService,
+    command: FeishuCommandName,
+    title: str,
+    content: str,
+    chat_id: str | None,
+    actor: str,
+    auto_reply: bool,
+) -> dict[str, Any]:
+    response = send_text_if_configured(feishu, chat_id, content, actor) if auto_reply else None
+    return command_result(command, FeishuReplyType.TEXT, title, content, response)

app/application/feishu/handlers/rules.py

@@ -0,0 +1,192 @@
+import re
+from typing import Any
+
+from fastapi import HTTPException
+from sqlalchemy.orm import Session
+
+from app.application.feishu.delivery import send_text_if_configured
+from app.application.feishu.results import command_result
+from app.core.config import get_settings
+from app.modules.ai_memory.constants import AIMemoryStatus
+from app.modules.ai_memory.service import AIMemoryService
+from app.modules.feishu.constants import FeishuCommandName, FeishuReplyType
+from app.modules.feishu.service import FeishuService
+
+RULE_TITLE = "AI 学习规则"
+RULE_CREATE_PATTERN = re.compile(r"^学习规则(?:\s+(\d{1,3}))?\s*[：:]\s*(.*)$")
+MARKET_RULE_CREATE_PATTERN = re.compile(
+    r"^学习市场规则(?:\s+(\d{1,3}))?\s*[：:]\s*(.*)$"
+)
+RULE_DISABLE_PATTERN = re.compile(r"^停用规则\s+(MEM-[A-Za-z0-9-]+)$", re.IGNORECASE)
+RULE_ENABLE_PATTERN = re.compile(r"^启用规则\s+(MEM-[A-Za-z0-9-]+)$", re.IGNORECASE)
+RULE_LIST_COMMANDS = {"查看规则", "规则列表", "查看市场规则"}
+RULE_COMMAND_PREFIXES = (
+    "学习市场规则",
+    "学习规则",
+    "查看市场规则",
+    "查看规则",
+    "规则列表",
+    "停用规则",
+    "启用规则",
+)
+RULE_COMMAND_HELP = (
+    "规则指令格式：\n"
+    "学习规则：<规则内容>\n"
+    "学习规则 80：<规则内容>\n"
+    "学习市场规则 80：<仅用于市场分析的规则内容>\n"
+    "查看规则\n"
+    "停用规则 <规则编号>\n"
+    "启用规则 <规则编号>"
+)
+
+
+def handle_rule_command(
+    db: Session,
+    feishu: FeishuService,
+    command_text: str,
+    chat_id: str | None,
+    actor: str,
+    auto_reply: bool,
+) -> dict[str, Any] | None:
+    """Handle persistent AI rule commands."""
+
+    if not command_text.startswith(RULE_COMMAND_PREFIXES):
+        return None
+    command = _command_name(command_text)
+    if command in {
+        FeishuCommandName.RULE_CREATE,
+        FeishuCommandName.RULE_DISABLE,
+        FeishuCommandName.RULE_ENABLE,
+    } and get_settings().read_only_mode:
+        return _result(
+            feishu,
+            command,
+            "当前为只读模式，不能新增或修改学习规则。请由管理员启用操作后重试。",
+            chat_id,
+            actor,
+            auto_reply,
+        )
+
+    content = RULE_COMMAND_HELP
+    try:
+        command, content = _execute(db, command_text, command, actor)
+    except HTTPException as exc:
+        detail = str(exc.detail)
+        if "secret-like" in detail:
+            content = "规则疑似包含密码、令牌或其他密钥信息，已拒绝学习。"
+        elif exc.status_code == 404:
+            content = "没有找到该规则，请先发送“查看规则”确认规则编号。"
+        elif "priority" in detail:
+            content = "规则优先级必须在 1 到 100 之间。"
+        else:
+            content = "规则未保存，请检查指令内容后重试。"
+    return _result(feishu, command, content, chat_id, actor, auto_reply)
+
+
+def _execute(
+    db: Session,
+    command_text: str,
+    command: FeishuCommandName,
+    actor: str,
+) -> tuple[FeishuCommandName, str]:
+    market_create_match = MARKET_RULE_CREATE_PATTERN.fullmatch(command_text)
+    create_match = market_create_match or RULE_CREATE_PATTERN.fullmatch(command_text)
+    disable_match = RULE_DISABLE_PATTERN.fullmatch(command_text)
+    enable_match = RULE_ENABLE_PATTERN.fullmatch(command_text)
+    memory = AIMemoryService(db)
+    if create_match:
+        return command, _create_rule(memory, create_match, market_create_match is not None, actor)
+    if command_text in RULE_LIST_COMMANDS:
+        return FeishuCommandName.RULE_LIST, _list_rules(memory, command_text)
+    if disable_match or enable_match:
+        enabled = enable_match is not None
+        match = enable_match or disable_match
+        rule = memory.update_rule(
+            code=match.group(1),
+            content=None,
+            priority=None,
+            tags=None,
+            enabled=enabled,
+            actor=actor,
+        )
+        state = "已启用" if enabled else "已停用"
+        return (
+            FeishuCommandName.RULE_ENABLE if enabled else FeishuCommandName.RULE_DISABLE,
+            f"规则{state}。\n"
+            f"编号：{rule['code']}\n"
+            f"优先级：{rule['importance']}\n"
+            f"范围：{rule['scope']} / {rule['subject']}\n"
+            f"状态：{state}",
+        )
+    return command, RULE_COMMAND_HELP
+
+
+def _create_rule(
+    memory: AIMemoryService,
+    match: re.Match[str],
+    market_rule: bool,
+    actor: str,
+) -> str:
+    priority = int(match.group(1) or 50)
+    content = match.group(2).strip()
+    if not content:
+        return f"规则内容不能为空。\n\n{RULE_COMMAND_HELP}"
+    if not 1 <= priority <= 100:
+        return "规则优先级必须在 1 到 100 之间。"
+    rule = memory.create_rule(
+        content=content,
+        scope="market" if market_rule else "global",
+        subject="market" if market_rule else "company",
+        priority=priority,
+        tags=["feishu", *(["market"] if market_rule else [])],
+        actor=actor,
+    )
+    return (
+        "规则已学习。\n"
+        f"编号：{rule['code']}\n"
+        f"优先级：{rule['importance']}\n"
+        f"范围：{rule['scope']} / {rule['subject']}\n"
+        "状态：已启用"
+    )
+
+
+def _list_rules(memory: AIMemoryService, command_text: str) -> str:
+    rules = memory.list_rules(
+        scope="market" if command_text == "查看市场规则" else None,
+        status_filter=AIMemoryStatus.ACTIVE,
+        limit=20,
+    )
+    if not rules:
+        return "当前没有已启用的学习规则。"
+    lines = ["当前已启用的学习规则："]
+    for rule in rules:
+        rule_text = str(rule["content"])
+        if len(rule_text) > 80:
+            rule_text = f"{rule_text[:80]}…"
+        lines.append(
+            f"{rule['code']}｜优先级 {rule['importance']}｜"
+            f"{rule['scope']}/{rule['subject']}\n{rule_text}"
+        )
+    return "\n\n".join(lines)
+
+
+def _command_name(command_text: str) -> FeishuCommandName:
+    if command_text.startswith("停用规则"):
+        return FeishuCommandName.RULE_DISABLE
+    if command_text.startswith("启用规则"):
+        return FeishuCommandName.RULE_ENABLE
+    if command_text.startswith(("查看市场规则", "查看规则", "规则列表")):
+        return FeishuCommandName.RULE_LIST
+    return FeishuCommandName.RULE_CREATE
+
+
+def _result(
+    feishu: FeishuService,
+    command: FeishuCommandName,
+    content: str,
+    chat_id: str | None,
+    actor: str,
+    auto_reply: bool,
+) -> dict[str, Any]:
+    response = send_text_if_configured(feishu, chat_id, content, actor) if auto_reply else None
+    return command_result(command, FeishuReplyType.TEXT, RULE_TITLE, content, response)

app/application/feishu/results.py

@@ -0,0 +1,29 @@
+from typing import Any
+
+from app.modules.feishu.constants import (
+    FeishuCommandName,
+    FeishuCommandResultKey,
+    FeishuReplyType,
+)
+
+
+def command_result(
+    command: FeishuCommandName,
+    reply_type: FeishuReplyType,
+    title: str,
+    content: str,
+    provider_response: dict[str, Any] | None = None,
+    lines: list[str] | None = None,
+) -> dict[str, Any]:
+    """Build the stable command response contract."""
+
+    result: dict[str, Any] = {
+        FeishuCommandResultKey.COMMAND: command,
+        FeishuCommandResultKey.REPLY_TYPE: reply_type,
+        FeishuCommandResultKey.TITLE: title,
+        FeishuCommandResultKey.CONTENT: content,
+        FeishuCommandResultKey.PROVIDER_RESPONSE: provider_response,
+    }
+    if lines is not None:
+        result[FeishuCommandResultKey.LINES] = lines
+    return result