config/config .ini.template

@@ -0,0 +1,216 @@
+
+
+[model]
+MODEL_TYPE=qwen3_5_35b_a3b
+
+# Embedding模型类型选择: lq_qwen3_8b_emd, siliconflow_embed
+EMBEDDING_MODEL_TYPE=lq_qwen3_8b_emd
+
+# Rerank模型类型选择: bge_rerank_model, lq_rerank_model, silicoflow_rerank_model
+RERANK_MODEL_TYPE=lq_rerank_model
+
+# 完整性审查模型类型 (用于 llm_content_classifier_v2)
+COMPLETENESS_REVIEW_MODEL_TYPE=qwen3_5_122b_a10b
+
+
+[deepseek]
+DEEPSEEK_SERVER_URL=https://api.deepseek.com
+DEEPSEEK_MODEL_ID=deepseek-chat
+DEEPSEEK_API_KEY=sk-9fe722389bac47e9ab30cf45b32eb736
+
+[doubao]
+DOUBAO_SERVER_URL=https://ark.cn-beijing.volces.com/api/v3/
+DOUBAO_MODEL_ID=doubao-seed-1-6-flash-250715
+DOUBAO_API_KEY=c98686df-506f-432c-98de-32e571a8e916
+
+
+[qwen]
+QWEN_SERVER_URL=http://192.168.91.253:8003/v1/
+QWEN_MODEL_ID=qwen3-30b
+QWEN_API_KEY=sk-123456
+
+# Qwen3-30B 独立配置（与qwen配置相同，方便后续独立管理）
+[qwen3_30b]
+QWEN3_30B_SERVER_URL=http://192.168.91.253:8003/v1/
+QWEN3_30B_MODEL_ID=qwen3-30b
+QWEN3_30B_API_KEY=sk-123456
+
+
+[ai_review]
+# 调试模式配置
+MAX_REVIEW_UNITS=5
+REVIEW_MODE=all
+# REVIEW_MODE=all/random/first
+
+
+[app]
+APP_CODE=lq-agent
+APP_SECRET=sx-73d32556-605e-11f0-9dd8-acde48001122
+
+
+[launch]
+HOST = 0.0.0.0
+LAUNCH_PORT = 8002
+
+[redis]
+REDIS_URL=redis://:123456@127.0.0.1:6379
+REDIS_HOST=127.0.0.1
+REDIS_PORT=6379
+REDIS_DB=0
+REDIS_PASSWORD=123456
+REDIS_MAX_CONNECTIONS=50
+
+[ocr]
+# OCR 引擎选择（以下写法都支持）：
+# GLM-OCR: glm_ocr | glm-ocr | glmocr
+# MinerU:  mineru | mineru-ocr | mineru_ocr
+# 默认: glm_ocr
+ENGINE=glm-ocr
+
+# GLM-OCR 配置
+GLM_OCR_API_URL=http://183.220.37.46:25429/v1/chat/completions
+GLM_OCR_TIMEOUT=600
+GLM_OCR_API_KEY=2026_Unified_Secure_Key
+
+# MinerU 配置  
+MINERU_API_URL=http://183.220.37.46:25428/file_parse
+MINERU_TIMEOUT=300
+
+[log]
+LOG_FILE_PATH=logs
+LOG_FILE_MAX_MB=10
+LOG_BACKUP_COUNT=5
+CONSOLE_OUTPUT=True
+
+[user_lists]
+USERS=['user-001']
+
+
+[siliconflow]
+SLCF_MODEL_SERVER_URL=https://api.siliconflow.cn/v1
+SLCF_API_KEY=sk-rdabeukkgfwyelstbqlcupsrwfkmduqvadztvxeyumvllstt
+SLCF_CHAT_MODEL_ID=test-model
+SLCF_EMBED_MODEL_ID=netease-youdao/bce-embedding-base_v1
+SLCF_REANKER_MODEL_ID=BAAI/bge-reranker-v2-m3
+SLCF_VL_CHAT_MODEL_ID=THUDM/GLM-4.1V-9B-Thinking
+
+[siliconflow_embed]
+# 硅基流动 Embedding 模型配置
+SLCF_EMBED_SERVER_URL=https://api.siliconflow.cn/v1
+SLCF_EMBED_API_KEY=sk-rdabeukkgfwyelstbqlcupsrwfkmduqvadztvxeyumvllstt
+SLCF_EMBED_MODEL_ID=Qwen/Qwen3-Embedding-8B
+SLCF_EMBED_DIMENSIONS=4096
+
+[lq_qwen3_8b]
+QWEN_LOCAL_1_5B_SERVER_URL=http://192.168.91.253:9002/v1
+QWEN_LOCAL_1_5B_MODEL_ID=Qwen3-8B
+QWEN_LOCAL_1_5B_API_KEY=dummy
+
+# 本地部署的Qwen3-Embedding-8B配置
+[lq_qwen3_8b_emd]
+LQ_EMBEDDING_SERVER_URL=http://192.168.91.253:9003/v1
+LQ_EMBEDDING_MODEL_ID=Qwen3-Embedding-8B
+LQ_EMBEDDING_API_KEY=dummy
+
+[lq_qwen3_4b]
+QWEN_LOCAL_1_5B_SERVER_URL=http://192.168.91.253:9001/v1
+QWEN_LOCAL_1_5B_MODEL_ID=Qwen3-4B
+QWEN_LOCAL_1_5B_API_KEY=dummy
+
+# 本地部署的Qwen3-Reranker-8B配置
+[lq_rerank_model]
+LQ_RERANKER_SERVER_URL=http://192.168.91.253:9004/v1/rerank
+LQ_RERANKER_MODEL=Qwen3-Reranker-8B
+LQ_RERANKER_API_KEY=dummy
+LQ_RERANKER_TOP_N=10
+
+# 硅基流动API的Qwen3-Reranker-8B配置
+[silicoflow_rerank_model]
+SILICOFLOW_RERANKER_API_URL=https://api.siliconflow.cn/v1/rerank
+SILICOFLOW_RERANKER_API_KEY=sk-rdabeukkgfwyelstbqlcupsrwfkmduqvadztvxeyumvllstt
+SILICOFLOW_RERANKER_MODEL=Qwen/Qwen3-Reranker-8B
+
+# BGE Reranker配置
+[bge_rerank_model]
+BGE_RERANKER_SERVER_URL=http://192.168.91.253:9004/rerank
+BGE_RERANKER_MODEL=BAAI/bge-reranker-v2-m3
+BGE_RERANKER_API_KEY=dummy
+BGE_RERANKER_TOP_N=10
+
+[lq_qwen3_8B_lora]
+LQ_QWEN3_8B_LQ_LORA_SERVER_URL=http://192.168.91.253:9006/v1
+LQ_QWEN3_8B_LQ_LORA_MODEL_ID=Qwen3-8B-lq-lora
+LQ_QWEN3_8B_LQ_LORA_API_KEY=dummy
+
+
+
+[mysql]
+MYSQL_HOST=192.168.92.61
+MYSQL_PORT=13306
+MYSQL_USER=root
+MYSQL_PASSWORD=lq@123
+MYSQL_DB=lq_db
+MYSQL_MIN_SIZE=1
+MYSQL_MAX_SIZE=5
+MYSQL_AUTO_COMMIT=True
+
+
+[pgvector]
+PGVECTOR_HOST=124.223.140.149
+PGVECTOR_PORT=7432
+PGVECTOR_DB=vector_db
+PGVECTOR_USER=vector_user
+PGVECTOR_PASSWORD=pg16@123
+
+
+[milvus]
+MILVUS_HOST=192.168.92.96
+MILVUS_PORT=30129
+MILVUS_DB=lq_db
+MILVUS_COLLECTION=first_bfp_collection_test
+MILVUS_USER=
+MILVUS_PASSWORD=
+
+
+[hybrid_search]
+# 混合检索权重配置
+DENSE_WEIGHT=0.3
+SPARSE_WEIGHT=0.7
+
+
+# ============================================================
+# DashScope Qwen3.5 系列模型配置
+# ============================================================
+
+# DashScope Qwen3.5-35B-A3B 模型
+[qwen3_5_35b_a3b]
+DASHSCOPE_SERVER_URL=https://dashscope.aliyuncs.com/compatible-mode/v1
+DASHSCOPE_MODEL_ID=qwen3.5-35b-a3b
+DASHSCOPE_API_KEY=sk-98cca096416a41d5a6cec68b824486c5
+
+# DashScope Qwen3.5-27B 模型
+[qwen3_5_27b]
+DASHSCOPE_SERVER_URL=https://dashscope.aliyuncs.com/compatible-mode/v1
+DASHSCOPE_MODEL_ID=qwen3.5-27b
+DASHSCOPE_API_KEY=sk-98cca096416a41d5a6cec68b824486c5
+
+# DashScope Qwen3.5-122B-A10B 模型
+[qwen3_5_122b_a10b]
+DASHSCOPE_SERVER_URL=https://dashscope.aliyuncs.com/compatible-mode/v1
+DASHSCOPE_MODEL_ID=qwen3.5-122b-a10b
+DASHSCOPE_API_KEY=sk-98cca096416a41d5a6cec68b824486c5
+
+# ============================================================
+# LLM 通用配置
+# ============================================================
+
+[llm_keywords]
+TIMEOUT=60
+MAX_RETRIES=2
+CONCURRENT_WORKERS=20
+STREAM=false
+TEMPERATURE=0.3
+MAX_TOKENS=1024
+
+
+

config/config.ini

@@ -0,0 +1,215 @@
+
+
+[model]
+MODEL_TYPE=qwen3_5_35b_a3b
+
+# Embedding模型类型选择: lq_qwen3_8b_emd, siliconflow_embed
+EMBEDDING_MODEL_TYPE=lq_qwen3_8b_emd
+
+# Rerank模型类型选择: bge_rerank_model, lq_rerank_model, silicoflow_rerank_model
+RERANK_MODEL_TYPE=lq_rerank_model
+
+# 完整性审查模型类型 (用于 llm_content_classifier_v2)
+COMPLETENESS_REVIEW_MODEL_TYPE=qwen3_5_122b_a10b
+
+
+[deepseek]
+DEEPSEEK_SERVER_URL=https://api.deepseek.com
+DEEPSEEK_MODEL_ID=deepseek-chat
+DEEPSEEK_API_KEY=sk-9fe722389bac47e9ab30cf45b32eb736
+
+[doubao]
+DOUBAO_SERVER_URL=https://ark.cn-beijing.volces.com/api/v3/
+DOUBAO_MODEL_ID=doubao-seed-1-6-flash-250715
+DOUBAO_API_KEY=c98686df-506f-432c-98de-32e571a8e916
+
+
+[qwen]
+QWEN_SERVER_URL=http://192.168.91.253:8003/v1/
+QWEN_MODEL_ID=qwen3-30b
+QWEN_API_KEY=sk-123456
+
+# Qwen3-30B 独立配置（与qwen配置相同，方便后续独立管理）
+[qwen3_30b]
+QWEN3_30B_SERVER_URL=http://192.168.91.253:8003/v1/
+QWEN3_30B_MODEL_ID=qwen3-30b
+QWEN3_30B_API_KEY=sk-123456
+
+
+[ai_review]
+# 调试模式配置
+MAX_REVIEW_UNITS=5
+REVIEW_MODE=all
+# REVIEW_MODE=all/random/first
+
+
+[app]
+APP_CODE=lq-agent
+APP_SECRET=sx-73d32556-605e-11f0-9dd8-acde48001122
+
+
+[launch]
+HOST = 0.0.0.0
+LAUNCH_PORT = 8002
+
+[redis]
+REDIS_URL=redis://:123456@127.0.0.1:6379
+REDIS_HOST=127.0.0.1
+REDIS_PORT=6379
+REDIS_DB=0
+REDIS_PASSWORD=123456
+REDIS_MAX_CONNECTIONS=50
+
+[ocr]
+# OCR 引擎选择（以下写法都支持）：
+# GLM-OCR: glm_ocr | glm-ocr | glmocr
+# MinerU:  mineru | mineru-ocr | mineru_ocr
+# 默认: glm_ocr
+ENGINE=glm-ocr
+
+# GLM-OCR 配置
+GLM_OCR_API_URL=http://183.220.37.46:25429/v1/chat/completions
+GLM_OCR_TIMEOUT=600
+
+# MinerU 配置  
+MINERU_API_URL=http://183.220.37.46:25428/file_parse
+MINERU_TIMEOUT=300
+
+[log]
+LOG_FILE_PATH=logs
+LOG_FILE_MAX_MB=10
+LOG_BACKUP_COUNT=5
+CONSOLE_OUTPUT=True
+
+[user_lists]
+USERS=['user-001']
+
+
+[siliconflow]
+SLCF_MODEL_SERVER_URL=https://api.siliconflow.cn/v1
+SLCF_API_KEY=sk-rdabeukkgfwyelstbqlcupsrwfkmduqvadztvxeyumvllstt
+SLCF_CHAT_MODEL_ID=test-model
+SLCF_EMBED_MODEL_ID=netease-youdao/bce-embedding-base_v1
+SLCF_REANKER_MODEL_ID=BAAI/bge-reranker-v2-m3
+SLCF_VL_CHAT_MODEL_ID=THUDM/GLM-4.1V-9B-Thinking
+
+[siliconflow_embed]
+# 硅基流动 Embedding 模型配置
+SLCF_EMBED_SERVER_URL=https://api.siliconflow.cn/v1
+SLCF_EMBED_API_KEY=sk-rdabeukkgfwyelstbqlcupsrwfkmduqvadztvxeyumvllstt
+SLCF_EMBED_MODEL_ID=Qwen/Qwen3-Embedding-8B
+SLCF_EMBED_DIMENSIONS=4096
+
+[lq_qwen3_8b]
+QWEN_LOCAL_1_5B_SERVER_URL=http://192.168.91.253:9002/v1
+QWEN_LOCAL_1_5B_MODEL_ID=Qwen3-8B
+QWEN_LOCAL_1_5B_API_KEY=dummy
+
+# 本地部署的Qwen3-Embedding-8B配置
+[lq_qwen3_8b_emd]
+LQ_EMBEDDING_SERVER_URL=http://192.168.91.253:9003/v1
+LQ_EMBEDDING_MODEL_ID=Qwen3-Embedding-8B
+LQ_EMBEDDING_API_KEY=dummy
+
+[lq_qwen3_4b]
+QWEN_LOCAL_1_5B_SERVER_URL=http://192.168.91.253:9001/v1
+QWEN_LOCAL_1_5B_MODEL_ID=Qwen3-4B
+QWEN_LOCAL_1_5B_API_KEY=dummy
+
+# 本地部署的Qwen3-Reranker-8B配置
+[lq_rerank_model]
+LQ_RERANKER_SERVER_URL=http://192.168.91.253:9004/v1/rerank
+LQ_RERANKER_MODEL=Qwen3-Reranker-8B
+LQ_RERANKER_API_KEY=dummy
+LQ_RERANKER_TOP_N=10
+
+# 硅基流动API的Qwen3-Reranker-8B配置
+[silicoflow_rerank_model]
+SILICOFLOW_RERANKER_API_URL=https://api.siliconflow.cn/v1/rerank
+SILICOFLOW_RERANKER_API_KEY=sk-rdabeukkgfwyelstbqlcupsrwfkmduqvadztvxeyumvllstt
+SILICOFLOW_RERANKER_MODEL=Qwen/Qwen3-Reranker-8B
+
+# BGE Reranker配置
+[bge_rerank_model]
+BGE_RERANKER_SERVER_URL=http://192.168.91.253:9004/rerank
+BGE_RERANKER_MODEL=BAAI/bge-reranker-v2-m3
+BGE_RERANKER_API_KEY=dummy
+BGE_RERANKER_TOP_N=10
+
+[lq_qwen3_8B_lora]
+LQ_QWEN3_8B_LQ_LORA_SERVER_URL=http://192.168.91.253:9006/v1
+LQ_QWEN3_8B_LQ_LORA_MODEL_ID=Qwen3-8B-lq-lora
+LQ_QWEN3_8B_LQ_LORA_API_KEY=dummy
+
+
+
+[mysql]
+MYSQL_HOST=192.168.92.61
+MYSQL_PORT=13306
+MYSQL_USER=root
+MYSQL_PASSWORD=lq@123
+MYSQL_DB=lq_db
+MYSQL_MIN_SIZE=1
+MYSQL_MAX_SIZE=5
+MYSQL_AUTO_COMMIT=True
+
+
+[pgvector]
+PGVECTOR_HOST=124.223.140.149
+PGVECTOR_PORT=7432
+PGVECTOR_DB=vector_db
+PGVECTOR_USER=vector_user
+PGVECTOR_PASSWORD=pg16@123
+
+
+[milvus]
+MILVUS_HOST=192.168.92.96
+MILVUS_PORT=30129
+MILVUS_DB=lq_db
+MILVUS_COLLECTION=first_bfp_collection_test
+MILVUS_USER=
+MILVUS_PASSWORD=
+
+
+[hybrid_search]
+# 混合检索权重配置
+DENSE_WEIGHT=0.3
+SPARSE_WEIGHT=0.7
+
+
+# ============================================================
+# DashScope Qwen3.5 系列模型配置
+# ============================================================
+
+# DashScope Qwen3.5-35B-A3B 模型
+[qwen3_5_35b_a3b]
+DASHSCOPE_SERVER_URL=https://dashscope.aliyuncs.com/compatible-mode/v1
+DASHSCOPE_MODEL_ID=qwen3.5-35b-a3b
+DASHSCOPE_API_KEY=sk-98cca096416a41d5a6cec68b824486c5
+
+# DashScope Qwen3.5-27B 模型
+[qwen3_5_27b]
+DASHSCOPE_SERVER_URL=https://dashscope.aliyuncs.com/compatible-mode/v1
+DASHSCOPE_MODEL_ID=qwen3.5-27b
+DASHSCOPE_API_KEY=sk-98cca096416a41d5a6cec68b824486c5
+
+# DashScope Qwen3.5-122B-A10B 模型
+[qwen3_5_122b_a10b]
+DASHSCOPE_SERVER_URL=https://dashscope.aliyuncs.com/compatible-mode/v1
+DASHSCOPE_MODEL_ID=qwen3.5-122b-a10b
+DASHSCOPE_API_KEY=sk-98cca096416a41d5a6cec68b824486c5
+
+# ============================================================
+# LLM 通用配置
+# ============================================================
+
+[llm_keywords]
+TIMEOUT=60
+MAX_RETRIES=2
+CONCURRENT_WORKERS=20
+STREAM=false
+TEMPERATURE=0.3
+MAX_TOKENS=1024
+
+
+

core/base/workflow_manager.py

@@ -664,13 +664,21 @@ class WorkflowManager:
 
             logger.info(f"AI审查配置: 最大审查数量={max_review_units}, 审查模式={review_mode}")
 
+            # [新增] 初始化数据库连接池（用于时效性审查等新逻辑）
+            # Mock模式已取消：数据库连接失败时将抛出异常，不会静默使用Mock数据
+            from foundation.infrastructure.mysql.async_mysql_conn_pool import AsyncMySQLPool
+            db_pool = AsyncMySQLPool()
+            await db_pool.initialize()
+            logger.info("数据库连接池初始化成功")
+
             # 创建AI审查工作流实例（作为嵌套子图）
             ai_workflow = AIReviewWorkflow(
                 task_file_info=task_file_info,
                 structured_content=structured_content,
                 progress_manager=state["progress_manager"],
                 max_review_units=max_review_units,
-                review_mode=review_mode
+                review_mode=review_mode,
+                db_pool=db_pool
             )
 
             # 执行AI审查（内部使用 LangGraph）

core/construction_review/component/ai_review_engine.py

@@ -128,13 +128,14 @@ class Stage(Enum):
 class AIReviewEngine(BaseReviewer):
     """AI审查引擎 - 支持审查条目并发"""
 
-    def __init__(self, task_file_info: TaskFileInfo = None, max_concurrent_reviews: int = 8):
+    def __init__(self, task_file_info: TaskFileInfo = None, max_concurrent_reviews: int = 8, db_pool=None):
         """
         初始化AI审查引擎
 
         Args:
             task_file_info: TaskFileInfo 实例，包含任务相关信息
             max_concurrent_reviews: 最大并发审查数量
+            db_pool: 数据库连接池（用于时效性审查等新逻辑）
         """
         super().__init__()
 
@@ -152,6 +153,8 @@ class AIReviewEngine(BaseReviewer):
         self.semaphore = asyncio.Semaphore(max_concurrent_reviews)
         self.milvus_collection = config_handler.get('milvus', 'MILVUS_COLLECTION', 'default')
 
+        # [新增] 数据库连接池
+        self.db_pool = db_pool
 
         self.milvus = MilvusManager(MilvusConfig())
         self.redis_client = get_redis_connection()   # 获取Redis连接
@@ -1180,7 +1183,7 @@ class AIReviewEngine(BaseReviewer):
 
                     # 调用内容时效性审查器
                     from core.construction_review.component.reviewers.timeliness_content_reviewer import ContentTimelinessReviewer
-                    async with ContentTimelinessReviewer(max_concurrent=max_concurrent) as reviewer:
+                    async with ContentTimelinessReviewer(max_concurrent=max_concurrent, db_pool=self.db_pool) as reviewer:
                         timeliness_content_results = await reviewer.review_tertiary_content(
                             tertiary_details=tertiary_details,
                             collection_name="first_bfp_collection_status",
@@ -1298,7 +1301,7 @@ class AIReviewEngine(BaseReviewer):
 
                     # 调用带有SSE推送功能的review_all方法
                     from core.construction_review.component.reviewers.timeliness_basis_reviewer import BasisReviewService
-                    async with BasisReviewService(max_concurrent=max_concurrent) as service:
+                    async with BasisReviewService(max_concurrent=max_concurrent, db_pool=self.db_pool) as service:
                         timeliness_basis_review_results = await service.review_all(
                             basis_items,
                             collection_name="first_bfp_collection_status",

core/construction_review/component/doc_worker/config/config.yaml

@@ -76,17 +76,10 @@ header_footer_filter:
   # 页眉后第二行的中文字符数阈值（少于此数量时，连同页眉行和中间空行一起过滤）
   footer_line_chinese_char_threshold: 10
 
-# GLM-OCR 本地 API 配置
-# 【修改日期】2025-03-27: 替换 MinerU 配置为 GLM-OCR
-glm_ocr:
-  # API 地址
-  api_url: "http://183.220.37.46:25429/v1/chat/completions"
-  # 请求超时时间（秒）
-  timeout: 600
-  # 最大 token 数
-  max_tokens: 2048
-  # 温度参数
-  temperature: 0.1
+# 【注意】OCR 配置已迁移到 config.ini [ocr] 段
+# 请修改项目根目录 config.ini 文件中的 [ocr] 配置：
+#   ENGINE=glm_ocr 或 ENGINE=mineru
+# 本文件保留其他非 OCR 相关配置
 
 # 目录识别配置
 toc_detection:

core/construction_review/component/doc_worker/pdf_worker/fulltext_extractor.py

@@ -36,6 +36,8 @@ class PdfFullTextExtractor(FullTextExtractor):
                 page = doc[page_num]
                 # # 提取文本，表格部分用 <表格></表格> 标签替换
                 text = self._extract_text_with_table_placeholders(page)
+                # 清理 PyMuPDF 添加的不必要空格
+                text = self._clean_extracted_text(text)
                 # 过滤页眉页脚
                 text = self._filter_header_footer(text)
                 pages.append(
@@ -53,6 +55,68 @@ class PdfFullTextExtractor(FullTextExtractor):
 
         return pages
 
+    def _clean_extracted_text(self, text: str) -> str:
+        """
+        清理提取的文本，移除 PyMuPDF 添加的不必要空格
+
+        问题：PyMuPDF 在提取 PDF 文本时，有时会在中文字符和数字/标点之间
+        添加不必要的空格（如 "(国务院令第279 号)" 变成 "(国务院令第279 号)"）
+
+        处理规则：
+        1. 移除中文和数字之间的空格：第279 号 -> 第279号
+        2. 移除中文和中文标点之间的空格
+        3. 保留英文单词之间的空格
+        4. 保留换行符
+
+        Args:
+            text: 原始提取的文本
+
+        Returns:
+            清理后的文本
+        """
+        import re
+
+        if not text:
+            return text
+
+        # 定义中文字符范围（包括中文标点）
+        chinese_char = r'[\u4e00-\u9fff]'
+        chinese_punctuation = r'[\u3000-\u303f\uff00-\uffef]'
+        digit = r'[0-9]'
+        ascii_letter = r'[a-zA-Z]'
+
+        # 规则1: 中文数字 + 空格 + 数字中文 -> 移除空格
+        # 例：第279 号 -> 第279号，令 第 -> 令第
+        text = re.sub(r'(' + chinese_char + r') +(' + digit + r')', r'\1\2', text)
+        text = re.sub(r'(' + digit + r') +(' + chinese_char + r')', r'\1\2', text)
+
+        # 规则2: 中文 + 空格 + 中文标点 -> 移除空格
+        text = re.sub(r'(' + chinese_char + r') +(' + chinese_punctuation + r')', r'\1\2', text)
+        text = re.sub(r'(' + chinese_punctuation + r') +(' + chinese_char + r')', r'\1\2', text)
+
+        # 规则3: 连续中文之间的空格 -> 移除
+        text = re.sub(r'(' + chinese_char + r') +(' + chinese_char + r')', r'\1\2', text)
+
+        # 规则4: 括号内的数字空格处理
+        # 例：(279 号) -> (279号)，[123 号] -> [123号]
+        text = re.sub(r'\((' + digit + r'+) +(' + chinese_char + r'+)\)', r'(\1\2)', text)
+        text = re.sub(r'（(' + digit + r'+) +(' + chinese_char + r'+)）', r'（\1\2）', text)
+        text = re.sub(r'\[(' + digit + r'+) +(' + chinese_char + r'+)\]', r'[\1\2]', text)
+
+        # 规则5: 处理编号格式中的空格，如 "GB 51-2001" 保持，但 "GB51 -2001" 修复
+        # 保留标准编号格式中的空格，但修复不合理的空格
+
+        # 规则6: 循环清理中文之间的多个连续空格
+        # 对于"建 设 工 程"这种情况，需要多次应用正则
+        max_iterations = 10  # 防止无限循环
+        for _ in range(max_iterations):
+            prev_text = text
+            text = re.sub(r'(' + chinese_char + r') +(' + chinese_char + r')', r'\1\2', text)
+            if text == prev_text:
+                break
+
+        return text
+
     def _filter_header_footer(self, text: str) -> str:
         """
         过滤页眉页脚

core/construction_review/component/doc_worker/pdf_worker/hybrid_extractor.py

@@ -28,6 +28,27 @@ from ..config.provider import default_config_provider
 from ..interfaces import DocumentSource, FullTextExtractor
 from .fulltext_extractor import PdfFullTextExtractor
 
+
+def _read_ini_config(section: str, key: str, default: Any = None) -> Any:
+    """从项目根目录的 config.ini 读取配置"""
+    try:
+        import configparser
+        from pathlib import Path
+        
+        # 查找项目根目录的 config.ini
+        config_path = Path(__file__).parent.parent.parent.parent.parent.parent / "config" / "config.ini"
+        if not config_path.exists():
+            return default
+        
+        config = configparser.ConfigParser()
+        config.read(config_path, encoding="utf-8")
+        
+        if section in config and key in config[section]:
+            return config[section][key]
+        return default
+    except Exception:
+        return default
+
 # 尝试导入 PIL 用于图片压缩
 try:
     from PIL import Image
@@ -59,29 +80,66 @@ class HybridFullTextExtractor(FullTextExtractor):
 
     def __init__(
         self,
-        layout_dpi: int = 180,
-        ocr_dpi: int = 220,
-        jpg_quality: int = 85,  # 降低为 85 配合 GLM-OCR
+        layout_dpi: int = 200,  # 【优化】统一 DPI 为 200，兼顾版面分析和 OCR 质量
+        ocr_dpi: int = 200,     # 【优化】与 layout_dpi 保持一致，避免重复渲染
+        jpg_quality: int = 90,
         api_url: Optional[str] = None,
         timeout: int = 600
     ) -> None:
         self._cfg = default_config_provider
         self.local_extractor = PdfFullTextExtractor()
         
-        # GLM-OCR 配置
-        self.api_url = api_url or self._cfg.get(
-            "glm_ocr.api_url", 
+        # 【新增】OCR 引擎选择配置
+        # 优先级：config.ini [ocr] ENGINE > 默认 glm_ocr
+        # 同时支持 "glm_ocr"/"glm-ocr" 和 "mineru"/"mineru-ocr" 等多种写法
+        raw_engine = _read_ini_config("ocr", "engine", "glm_ocr")
+        self.ocr_engine = raw_engine.lower().strip() if raw_engine else "glm_ocr"
+        
+        # 规范化引擎名称（统一转换为标准格式）
+        if self.ocr_engine in ("glm_ocr", "glm-ocr", "glmocr"):
+            self.ocr_engine_normalized = "glm_ocr"
+        elif self.ocr_engine in ("mineru", "mineru-ocr", "mineru_ocr"):
+            self.ocr_engine_normalized = "mineru"
+        else:
+            logger.warning(f"[HybridExtractor] 未知的 OCR 引擎 '{self.ocr_engine}'，使用默认 glm_ocr")
+            self.ocr_engine_normalized = "glm_ocr"
+        
+        logger.info(f"[HybridExtractor] OCR 引擎配置: '{self.ocr_engine}' -> 使用: '{self.ocr_engine_normalized}'")
+        
+        # GLM-OCR 配置（从 config.ini 读取，兼容原有逻辑）
+        self.glm_api_url = api_url or _read_ini_config(
+            "ocr", "glm_ocr_api_url", 
             "http://183.220.37.46:25429/v1/chat/completions"
         )
-        self.timeout = timeout
-        self.headers = {"Content-Type": "application/json"}
+        self.glm_timeout = int(_read_ini_config("ocr", "glm_ocr_timeout", "600"))
         
-        # 飞浆版面分析配置
+        # 【新增】读取 GLM-OCR API Key（用于鉴权）
+        self.glm_api_key = _read_ini_config("ocr", "glm_ocr_api_key", "")
+        
+        # 构建请求头，如果配置了 API Key 则添加 Authorization
+        self.glm_headers = {"Content-Type": "application/json"}
+        if self.glm_api_key:
+            self.glm_headers["Authorization"] = f"Bearer {self.glm_api_key}"
+            logger.debug(f"[HybridExtractor] GLM-OCR 已配置 API Key 鉴权")
+        
+        # 【新增】MinerU 配置
+        self.mineru_api_url = _read_ini_config(
+            "ocr", "mineru_api_url",
+            "http://183.220.37.46:25428/file_parse"
+        )
+        self.mineru_timeout = int(_read_ini_config("ocr", "mineru_timeout", "300"))
+        
+        # 【优化】飞浆版面分析配置 - DPI 统一为 200
+        # 原理：版面分析和 OCR 使用相同 DPI，第一阶段渲染的图片可直接复用
         self.layout_dpi = layout_dpi
         self.ocr_dpi = ocr_dpi
         self.jpg_quality = jpg_quality
         self._layout_engine: Optional[Any] = None
         
+        # 【优化】图片缓存：版面分析阶段缓存 table 页图片，供 OCR 阶段复用
+        # 格式: {page_num: (width, height, jpeg_bytes)}
+        self._image_cache: Dict[int, tuple] = {}
+        
         # 外部注入的进度状态字典
         self._progress_state: Optional[dict] = None
         
@@ -98,16 +156,21 @@ class HybridFullTextExtractor(FullTextExtractor):
             self._layout_engine = RapidLayout()
         return self._layout_engine
 
-    def _detect_table_pages(self, doc: fitz.Document, dpi: int = 150) -> Set[int]:
+    def _detect_table_pages(self, doc: fitz.Document, dpi: int = 200) -> Set[int]:
         """
         使用飞浆 RapidLayout 检测所有页面，返回包含 table 区域的页码集合。
-        【保持不变】
+        
+        【优化】检测到 table 的页面，将 JPEG 图片缓存到 self._image_cache
+        供后续 OCR 阶段直接使用，避免重复渲染 PDF。
         """
         table_pages: Set[int] = set()
         layout_engine = self._get_layout_engine()
         total_pages = len(doc)
+        
+        # 清空图片缓存
+        self._image_cache.clear()
 
-        logger.debug(f"  [飞浆分析] 开始版面分析，共 {total_pages} 页...")
+        logger.info(f"  [飞浆分析] 开始版面分析，共 {total_pages} 页，DPI={dpi}（图片缓存已启用）")
 
         for page_num in range(1, total_pages + 1):
             page = doc[page_num - 1]
@@ -133,7 +196,17 @@ class HybridFullTextExtractor(FullTextExtractor):
                 # 判断是否包含 table
                 if "table" in labels:
                     table_pages.add(page_num)
-                    logger.debug(f"    第 {page_num} 页: 检测到 table 区域 -> 将走 GLM-OCR")
+                    
+                    # 【优化】缓存 table 页图片为 JPEG，供 OCR 阶段复用
+                    try:
+                        # 直接保存 Pixmap 的 JPEG 数据，无需 PIL 转换
+                        jpeg_bytes = pix.tobytes("jpeg")
+                        self._image_cache[page_num] = (pix.width, pix.height, jpeg_bytes)
+                        logger.debug(f"    第 {page_num} 页: 检测到 table -> 缓存图片 "
+                                   f"({pix.width}x{pix.height}, {len(jpeg_bytes)/1024:.1f} KB)")
+                    except Exception as cache_err:
+                        logger.warning(f"    第 {page_num} 页: 图片缓存失败 ({cache_err})")
+                        
                 else:
                     region_types = ", ".join(set(labels)) if labels else "无"
                     logger.debug(f"    第 {page_num} 页: {region_types}")
@@ -147,7 +220,9 @@ class HybridFullTextExtractor(FullTextExtractor):
                 self._progress_state['current'] = int(page_num / total_pages * 50)
                 self._progress_state['message'] = f"版面分析中：已分析 {page_num}/{total_pages} 页"
 
-        logger.debug(f"  [飞浆分析] 完成，共 {len(table_pages)} 页包含 table 区域: {sorted(table_pages)}")
+        cache_size_mb = sum(len(data[2]) for data in self._image_cache.values()) / 1024 / 1024
+        logger.info(f"  [飞浆分析] 完成: {len(table_pages)} 页 table，"
+                   f"缓存 {len(self._image_cache)} 页图片 ({cache_size_mb:.1f} MB)")
         return table_pages
 
     def extract_full_text(self, source: DocumentSource) -> List[Dict[str, Any]]:
@@ -156,7 +231,14 @@ class HybridFullTextExtractor(FullTextExtractor):
         1. 首先用飞浆 RapidLayout 检测所有页面的 table 区域
         2. 含有 table 的页面走 GLM-OCR
         3. 其他页面走本地 PyMuPDF 提取
+        
+        【统计信息】本方法会统计并输出总提取时间、OCR页数等信息
         """
+        # 记录总开始时间
+        total_start_time = time.time()
+        layout_analysis_time = 0.0
+        ocr_total_time = 0.0
+        
         # 打开文档
         if source.content is not None:
             doc = fitz.open(stream=io.BytesIO(source.content))
@@ -175,22 +257,28 @@ class HybridFullTextExtractor(FullTextExtractor):
             ocr_page_count = 0  # 统计需要OCR的页数
             
             # INFO级别：开始文档提取（方便查看主要流程）
-            logger.info(f"[文档提取] 开始处理，共 {total_pages} 页，使用混合模式（GLM-OCR）")
-            logger.debug(f"开始混合提取（飞浆版面分析 + GLM-OCR），共 {total_pages} 页...")
+            current_engine = "GLM-OCR" if self.ocr_engine_normalized == "glm_ocr" else "MinerU"
+            logger.info(f"[文档提取] 开始处理，共 {total_pages} 页，OCR引擎: {current_engine}")
+            logger.debug(f"开始混合提取（飞浆版面分析 + {current_engine}），共 {total_pages} 页...")
 
             if self._progress_state is not None:
                 self._progress_state['current'] = 0
                 self._progress_state['message'] = f"版面分析中：已分析 0/{total_pages} 页"
 
             # ========== 第一阶段：飞浆版面分析 ==========
+            layout_start_time = time.time()
             table_pages = self._detect_table_pages(doc, dpi=self.layout_dpi)
+            layout_analysis_time = time.time() - layout_start_time
             ocr_page_count = len(table_pages)
             
             # INFO级别：版面分析完成，显示OCR页数
             if ocr_page_count > 0:
-                logger.info(f"[文档提取] 版面分析完成，共 {ocr_page_count} 页需要OCR识别，{total_pages - ocr_page_count} 页直接提取")
+                logger.info(f"[文档提取] 版面分析完成，共 {ocr_page_count} 页需要OCR识别，"
+                           f"{total_pages - ocr_page_count} 页直接提取，"
+                           f"版面分析耗时: {layout_analysis_time:.2f}s")
             else:
-                logger.info(f"[文档提取] 版面分析完成，无扫描页，全部直接提取")
+                logger.info(f"[文档提取] 版面分析完成，无扫描页，全部直接提取，"
+                           f"版面分析耗时: {layout_analysis_time:.2f}s")
 
             # ========== 第二阶段：分流处理 ==========
             logger.debug(f"\n开始分流处理...")
@@ -199,19 +287,32 @@ class HybridFullTextExtractor(FullTextExtractor):
                 page_num = i + 1
                 
                 if page_num in table_pages:
-                    logger.debug(f"  [第 {page_num} 页] 检测到 table -> 走 GLM-OCR")
+                    # 【修改】根据配置选择 OCR 引擎
+                    # 使用规范化后的引擎名称（支持 glm_ocr/glm-ocr 和 mineru/mineru-ocr）
+                    is_glm_ocr = self.ocr_engine_normalized == "glm_ocr"
+                    ocr_name = "GLM-OCR" if is_glm_ocr else "MinerU"
+                    logger.debug(f"  [第 {page_num} 页] 检测到 table -> 走 {ocr_name}")
 
                     try:
-                        # 调用 GLM-OCR
-                        page_text = self._ocr_page_with_glm(page, page_num, source_file)
+                        # 根据配置调用不同的 OCR 引擎，并统计 OCR 时间
+                        ocr_start_time = time.time()
+                        if is_glm_ocr:
+                            page_text = self._ocr_page_with_glm(page, page_num, source_file)
+                        else:
+                            page_text = self._ocr_page_with_mineru(doc, page_num, source_file)
+                        ocr_total_time += time.time() - ocr_start_time
                     except Exception as e:
-                        logger.error(f"    GLM-OCR 失败，回退到本地提取: {e}")
+                        logger.error(f"    {ocr_name} 失败，回退到本地提取: {e}")
                         raw_text = page.get_text()
+                        # 清理空格后过滤页眉页脚
+                        raw_text = self.local_extractor._clean_extracted_text(raw_text)
                         page_text = self.local_extractor._filter_header_footer(raw_text)
                 else:
                     logger.debug(f"  [第 {page_num} 页] 无 table -> 走本地 PyMuPDF 提取")
-                    
+
                     text_with_tables = self.local_extractor._extract_text_with_table_placeholders(page)
+                    # 清理空格后过滤页眉页脚
+                    text_with_tables = self.local_extractor._clean_extracted_text(text_with_tables)
                     page_text = self.local_extractor._filter_header_footer(text_with_tables)
 
                 # 组装结果
@@ -232,10 +333,33 @@ class HybridFullTextExtractor(FullTextExtractor):
 
         finally:
             doc.close()
+            # 【优化】清理图片缓存，释放内存
+            if hasattr(self, '_image_cache'):
+                cache_size = len(self._image_cache)
+                self._image_cache.clear()
+                if cache_size > 0:
+                    logger.debug(f"  [缓存清理] 已清理 {cache_size} 页图片缓存")
         
-        # INFO级别：文档提取完成
+        # ========== 统计信息输出 ==========
+        # INFO级别：文档提取完成，输出详细统计
+        total_time = time.time() - total_start_time
         total_chars = sum(len(page['text']) for page in pages)
-        logger.info(f"[文档提取] 完成，共 {total_pages} 页，总字符数: {total_chars}")
+        
+        # 计算各类时间占比
+        ocr_avg_time = ocr_total_time / ocr_page_count if ocr_page_count > 0 else 0
+        local_pages = total_pages - ocr_page_count
+        
+        logger.info(
+            f"[文档提取] 完成统计 | "
+            f"总页数: {total_pages} | "
+            f"OCR页数: {ocr_page_count} | "
+            f"本地提取: {local_pages} | "
+            f"总耗时: {total_time:.2f}s | "
+            f"版面分析: {layout_analysis_time:.2f}s | "
+            f"OCR耗时: {ocr_total_time:.2f}s | "
+            f"OCR平均: {ocr_avg_time:.2f}s/页 | "
+            f"总字符数: {total_chars}"
+        )
 
         return pages
 
@@ -243,42 +367,41 @@ class HybridFullTextExtractor(FullTextExtractor):
         """
         将单页转为图片并调用 GLM-OCR 本地 API 识别
         
-        【逻辑来源】glm_ocr_api_extractor.py 最终实现版本
+        【优化】优先使用版面分析阶段缓存的图片，避免重复渲染
         
         流程：
-        1. PyMuPDF 渲染页面为图片（220 DPI）
-        2. PIL 压缩图片（短边限制 1024px，JPEG 质量 85）
-        3. Base64 编码
-        4. 构建 OpenAI 兼容格式请求
+        1. 优先使用缓存图片（如可用）
+        2. 否则 PyMuPDF 渲染页面为图片（200 DPI）
+        3. PIL 压缩图片（短边限制 1024px，JPEG 质量 90）
+        4. Base64 编码
         5. POST 请求 GLM-OCR API
         6. 解析响应并转换 HTML→Markdown
-        
-        请求格式：
-        {
-            "model": "GLM-OCR",
-            "messages": [{
-                "role": "user",
-                "content": [
-                    {"type": "text", "text": "提示词"},
-                    {"type": "image_url", "image_url": {"url": "data:image/jpeg;base64,..."}}
-                ]
-            }],
-            "max_tokens": 2048,
-            "temperature": 0.1
-        }
         """
         start_time = time.time()
         
+        # 【优化】检查是否有缓存图片
+        cached = self._image_cache.get(page_num)
+        use_cache = cached is not None
+        
         # INFO级别：开始调用GLM-OCR识别（方便查看主要流程）
-        logger.info(f"[GLM-OCR] 开始识别第 {page_num} 页（扫描页）")
+        cache_info = "（使用缓存图片）" if use_cache else ""
+        logger.info(f"[GLM-OCR] 开始识别第 {page_num} 页 {cache_info}")
         
         try:
-            # 1. 渲染为图片
-            pix = page.get_pixmap(dpi=self.ocr_dpi)
-            img_bytes = pix.tobytes("jpeg")
-            original_kb = len(img_bytes) / 1024
-            
-            logger.debug(f"    [GLM-OCR] 第 {page_num} 页图片: {original_kb:.1f} KB ({pix.width}x{pix.height})")
+            # 1. 获取图片（优先使用缓存）
+            if use_cache:
+                # 【优化】使用版面分析阶段缓存的图片
+                width, height, img_bytes = cached
+                original_kb = len(img_bytes) / 1024
+                logger.debug(f"    [GLM-OCR] 第 {page_num} 页使用缓存图片: "
+                           f"{original_kb:.1f} KB ({width}x{height})")
+            else:
+                # 兜底：重新渲染（理论上不会发生，因为 table 页都应已缓存）
+                pix = page.get_pixmap(dpi=self.ocr_dpi)
+                img_bytes = pix.tobytes("jpeg")
+                original_kb = len(img_bytes) / 1024
+                logger.warning(f"    [GLM-OCR] 第 {page_num} 页无缓存，重新渲染: "
+                             f"{original_kb:.1f} KB ({pix.width}x{pix.height})")
             
             # 2. 压缩图片
             compressed_bytes = self._compress_image(img_bytes)
@@ -313,10 +436,10 @@ class HybridFullTextExtractor(FullTextExtractor):
             
             # 5. 调用 GLM-OCR API
             response = requests.post(
-                self.api_url,
-                headers=self.headers,
+                self.glm_api_url,
+                headers=self.glm_headers,
                 json=payload,
-                timeout=self.timeout
+                timeout=self.glm_timeout
             )
             response.raise_for_status()
             
@@ -338,6 +461,116 @@ class HybridFullTextExtractor(FullTextExtractor):
             logger.error(f"    [GLM-OCR] 第 {page_num} 页识别失败: {e}")
             raise
 
+    def _ocr_page_with_mineru(self, doc: fitz.Document, page_num: int, original_filename: str) -> str:
+        """
+        【新增】使用 MinerU 本地 API 识别单页
+        
+        流程：
+        1. 【优化】优先使用版面分析缓存的图片（JPEG）
+        2. 无缓存时，提取单页为临时 PDF 文件
+        3. 调用 MinerU API 上传识别
+        4. 提取 Markdown 内容
+        5. 清理临时文件
+        
+        Args:
+            doc: 原始 PDF 文档对象
+            page_num: 页码（1-based）
+            original_filename: 原始文件名（用于日志）
+            
+        Returns:
+            str: 识别出的 Markdown 文本
+        """
+        import tempfile
+        import os
+        
+        start_time = time.time()
+        
+        # 【优化】检查是否有缓存图片
+        cached = self._image_cache.get(page_num)
+        use_cache = cached is not None
+        
+        # INFO级别：开始识别
+        cache_info = "（使用缓存图片）" if use_cache else ""
+        logger.info(f"[MinerU] 开始识别第 {page_num} 页 {cache_info}")
+        
+        tmp_pdf_path = None
+        
+        try:
+            # 【优化】优先使用缓存的图片数据
+            if use_cache:
+                width, height, img_bytes = cached
+                logger.debug(f"    [MinerU] 第 {page_num} 页使用缓存图片: "
+                           f"{len(img_bytes)/1024:.1f} KB ({width}x{height})")
+                
+                # 使用图片直接上传（MinerU 支持图片格式）
+                files = {'files': (f"page_{page_num}.jpg", io.BytesIO(img_bytes))}
+                response = requests.post(
+                    self.mineru_api_url,
+                    files=files,
+                    timeout=self.mineru_timeout
+                )
+            else:
+                # 兜底：提取单页为临时 PDF
+                logger.debug(f"    [MinerU] 第 {page_num} 页无缓存，创建临时 PDF")
+                
+                single_page_doc = fitz.open()
+                single_page_doc.insert_pdf(doc, from_page=page_num-1, to_page=page_num-1)
+                
+                # 创建临时文件
+                with tempfile.NamedTemporaryFile(suffix=".pdf", delete=False) as tmp_file:
+                    tmp_pdf_path = tmp_file.name
+                
+                single_page_doc.save(tmp_pdf_path)
+                single_page_doc.close()
+                
+                file_size_kb = os.path.getsize(tmp_pdf_path) / 1024
+                logger.debug(f"    [MinerU] 第 {page_num} 页临时文件: {file_size_kb:.1f} KB")
+                
+                # 调用 MinerU API
+                with open(tmp_pdf_path, 'rb') as f:
+                    files = {'files': (f"page_{page_num}.pdf", f)}
+                    response = requests.post(
+                        self.mineru_api_url,
+                        files=files,
+                        timeout=self.mineru_timeout
+                    )
+            
+            if response.status_code != 200:
+                raise RuntimeError(f"MinerU API error: {response.status_code} - {response.text[:200]}")
+            
+            # 3. 解析结果
+            result = response.json()
+            content = ""
+            
+            if "results" in result and isinstance(result["results"], dict):
+                for filename, file_data in result["results"].items():
+                    if isinstance(file_data, dict) and "md_content" in file_data:
+                        content = file_data["md_content"]
+                        break
+            
+            # 4. 处理 HTML 转 Markdown（如果包含 HTML 标签）
+            if "<table" in content.lower() or "<div" in content.lower():
+                logger.debug(f"    [MinerU] 检测到 HTML 标签，转换为 Markdown")
+                content = self._process_raw_content(content)
+            
+            elapsed = time.time() - start_time
+            logger.info(f"[MinerU] 第 {page_num} 页识别完成，耗时: {elapsed:.2f}s，字符数: {len(content)}")
+            
+            return content
+            
+        except Exception as e:
+            logger.error(f"    [MinerU] 第 {page_num} 页识别失败: {e}")
+            raise
+            
+        finally:
+            # 清理临时文件
+            if tmp_pdf_path and os.path.exists(tmp_pdf_path):
+                try:
+                    os.remove(tmp_pdf_path)
+                    logger.debug(f"    [MinerU] 清理临时文件: {tmp_pdf_path}")
+                except:
+                    pass
+
     def _compress_image(self, img_bytes: bytes) -> bytes:
         """
         压缩图片至 GLM-OCR 要求的尺寸限制内

core/construction_review/component/doc_worker/pdf_worker/text_splitter.py

@@ -103,19 +103,37 @@ class PdfTextSplitter(TextSplitter, HierarchicalChunkMixin):
 
         # 步骤4: 按目录层级处理每个标题块
         all_chunks: List[Dict[str, Any]] = []
-        
+
+        # 建立已定位标题的快速查找映射，用于后续 TOC 边界保护
+        found_titles_map = {t["title"]: t["position"] for t in found_titles}
+
         for i, title_info in enumerate(found_titles):
             start_pos = title_info["position"]
-            
-            # 确定正文块的结束位置（下一个同级标题的位置）
+
+            # 基础边界：下一个已定位的同级标题
             if i + 1 < len(found_titles):
                 end_pos = found_titles[i + 1]["position"]
             else:
                 end_pos = len(full_text)
-            
+
+            # TOC 边界保护：防止因标题定位错误导致的跨章节合并。
+            # 问题场景（用户原话描述）：
+            # "当时的规则是两个标题之间的内容。但如果说最后一个标题跨章节了，
+            #  它就缺失了，缺失就会把下个章节的第一个标题，然后合并到最后上一个
+            #  章节的最后一个节里面。"
+            # 典型表现：第十章标题被错误定位到目录页（page 6），导致真正的第十章
+            # 没被识别，第九章最后一个二级标题 content_block 的 end_pos 被延长到
+            # len(full_text)，将第十章的"计算书"、"相关施工图纸"等全部内容吞进
+            # doc_chunk_第九章->五_1。
+            toc_boundary = self._get_toc_boundary_position(
+                title_info["title"], all_toc_items, target_level, found_titles_map, full_text
+            )
+            if toc_boundary is not None and toc_boundary > start_pos:
+                end_pos = min(end_pos, toc_boundary)
+
             # 提取正文块
             content_block = full_text[start_pos:end_pos]
-            
+
             # 在正文块中查找子标题（按最低层级切分）
             sub_chunks = self._split_by_sub_titles(
                 content_block,
@@ -125,7 +143,7 @@ class PdfTextSplitter(TextSplitter, HierarchicalChunkMixin):
                 max_chunk_size,
                 min_chunk_size,
             )
-            
+
             # 为每个子块添加元数据
             for j, sub_chunk in enumerate(sub_chunks, 1):
                 chunk_data = self._build_chunk_metadata(
@@ -133,13 +151,54 @@ class PdfTextSplitter(TextSplitter, HierarchicalChunkMixin):
                 )
                 all_chunks.append(chunk_data)
 
-        # 步骤4: 生成最终的chunk_id和serial_number
+        # 步骤5: 生成最终的chunk_id和serial_number
         final_chunks = self._finalize_chunk_ids(all_chunks)
 
         print(f"  完成切分: {len(final_chunks)} 个块")
 
         return final_chunks
 
+    def _get_toc_boundary_position(
+        self,
+        title: str,
+        all_toc_items: List[Dict[str, Any]],
+        target_level: int,
+        found_titles_map: Dict[str, int],
+        full_text: str,
+    ) -> int | None:
+        """
+        在 all_toc_items 中找到当前标题的下一个兄弟/更高级标题，
+        并返回其在正文中的边界位置，防止 content_block 跨章节合并。
+        """
+        current_idx = -1
+        for idx, item in enumerate(all_toc_items):
+            if item.get("title") == title and item.get("level", target_level) == target_level:
+                current_idx = idx
+                break
+
+        if current_idx < 0:
+            return None
+
+        for idx in range(current_idx + 1, len(all_toc_items)):
+            item = all_toc_items[idx]
+            if item.get("level", 1) <= target_level:
+                boundary_title = item["title"]
+                # 优先使用已定位的位置
+                if boundary_title in found_titles_map:
+                    return found_titles_map[boundary_title]
+                # 回退：尝试在正文中直接定位
+                if full_text and self._title_matcher:
+                    pos = self._title_matcher._find_title_in_text(
+                        boundary_title,
+                        full_text,
+                        float(self._cfg.get("text_splitting.fuzzy_threshold", 0.8)),
+                    )
+                    if pos >= 0:
+                        return pos
+                return None
+
+        return None
+
     def _split_by_sub_titles(
         self,
         content_block: str,

core/construction_review/component/doc_worker/utils/title_matcher.py

@@ -29,11 +29,14 @@ class TitleMatcher:
     ) -> List[Dict[str, Any]]:
         """
         在正文中定位已分类标题（跳过目录页范围）。
-        
+
         优化逻辑（参考 doc_worker）：
         1. 先在全文中查找标题位置
         2. 如果找到的位置在目录页范围内，继续在目录页之后查找
         3. 如果找到的位置不在目录页范围内，直接使用该位置
+
+        修复：支持多位置匹配，结合 toc_page 进行页码择优，
+        避免将目录中的靠前匹配误当作正文标题，导致后续章节内容被错误合并。
         """
         # 计算目录页的文本范围
         toc_start_pos = float("inf")
@@ -47,58 +50,61 @@ class TitleMatcher:
 
         located: List[Dict[str, Any]] = []
         fuzzy_threshold = float(self._cfg.get("text_splitting.fuzzy_threshold", 0.8))
+        page_tolerance = int(self._cfg.get("text_splitting.page_tolerance", 10))
 
         for item in classified_items:
             title = item["title"]
             category = item.get("category", "")
             category_code = item.get("category_code", "other")
-
-            # 步骤1: 在全文中查找标题位置
-            pos = self._find_title_in_text(title, full_text, fuzzy_threshold)
-            
-            # 步骤2: 如果找到的位置在目录页范围内，继续在目录页之后查找
-            if pos >= 0 and toc_end_pos > 0 and toc_start_pos <= pos < toc_end_pos:
-                # 在目录页之后继续查找
-                if toc_end_pos < len(full_text):
-                    search_start = int(toc_end_pos)
-                    remaining_text = full_text[search_start:]
-                    pos_in_remaining = self._find_title_in_text(title, remaining_text, fuzzy_threshold)
-                    
-                    if pos_in_remaining >= 0:
-                        pos = search_start + pos_in_remaining
-                    else:
-                        pos = -1
+            toc_page = item.get("page", "")
+
+            # 步骤1: 查找所有匹配位置（完整标题 + 正文部分），并排除目录页
+            all_positions = self._find_all_valid_title_positions(
+                title, full_text, fuzzy_threshold, toc_start_pos, toc_end_pos
+            )
+
+            pos = -1
+            if all_positions:
+                # 步骤2: 如果有多个有效位置，根据 toc_page 选择最接近的位置
+                if len(all_positions) > 1 and toc_page:
+                    try:
+                        toc_page_num = int(toc_page)
+                        best_pos = all_positions[0]
+                        best_diff = abs(self._get_page_number(best_pos, pages_content) - toc_page_num)
+                        for candidate_pos in all_positions[1:]:
+                            candidate_page = self._get_page_number(candidate_pos, pages_content)
+                            diff = abs(candidate_page - toc_page_num)
+                            if diff < best_diff:
+                                best_diff = diff
+                                best_pos = candidate_pos
+                        pos = best_pos
+                    except ValueError:
+                        pos = all_positions[0]
                 else:
-                    pos = -1
-            
+                    pos = all_positions[0]
+
             # 步骤3: 确认位置并添加到结果
             if pos >= 0:
-                # 确认位置不在目录页（避免误判）
-                if not (toc_end_pos > 0 and toc_start_pos <= pos < toc_end_pos):
-                    page_num = self._get_page_number(pos, pages_content)
-                    located.append(
-                        {
-                            "title": title,
-                            "category": category,
-                            "category_code": category_code,
-                            "position": pos,
-                            "toc_page": item.get("page", ""),
-                            "actual_page": page_num,
-                            "found": True,
-                        }
-                    )
-                else:
-                    # 位置仍然在目录页内，标记为未找到
-                    located.append(
-                        {
-                            "title": title,
-                            "category": category,
-                            "category_code": category_code,
-                            "position": -1,
-                            "toc_page": item.get("page", ""),
-                            "found": False,
-                        }
-                    )
+                page_num = self._get_page_number(pos, pages_content)
+                # 页码校验：如果实际页码与目录页码差距过大，且存在其他候选，则标记为可疑
+                if toc_page:
+                    try:
+                        toc_page_num = int(toc_page)
+                        if abs(page_num - toc_page_num) > page_tolerance:
+                            print(f"    警告: 标题 '{title}' 匹配位置页码({page_num})与目录页码({toc_page_num})差距过大，可能存在错误匹配")
+                    except ValueError:
+                        pass
+                located.append(
+                    {
+                        "title": title,
+                        "category": category,
+                        "category_code": category_code,
+                        "position": pos,
+                        "toc_page": toc_page,
+                        "actual_page": page_num,
+                        "found": True,
+                    }
+                )
             else:
                 located.append(
                     {
@@ -106,13 +112,56 @@ class TitleMatcher:
                         "category": category,
                         "category_code": category_code,
                         "position": -1,
-                        "toc_page": item.get("page", ""),
+                        "toc_page": toc_page,
                         "found": False,
                     }
                 )
 
         return located
 
+    def _find_all_valid_title_positions(
+        self,
+        title: str,
+        text: str,
+        fuzzy_threshold: float,
+        toc_start_pos: float,
+        toc_end_pos: float,
+    ) -> List[int]:
+        """
+        查找标题在正文中的所有有效位置（排除目录页范围），并按位置排序。
+
+        策略：
+        1. 先找完整标题的所有位置；
+        2. 如果完整标题没找到，再找标题正文部分的所有位置；
+        3. 过滤掉目录页范围内的位置。
+        """
+        positions: List[int] = []
+
+        # 方法1: 完整标题匹配
+        full_positions = self._find_full_title_positions(title, text)
+        if full_positions:
+            positions = full_positions
+        else:
+            # 方法2: 标题正文部分匹配
+            title_content = self._extract_title_content(title)
+            if title_content:
+                content_positions = self._find_content_positions(title_content, text)
+                if content_positions:
+                    positions = content_positions
+            # 如果标题正文也没找到，回退到模糊匹配
+            if not positions:
+                legacy_pos = self._find_title_in_text_legacy(title, text, fuzzy_threshold)
+                if legacy_pos >= 0:
+                    positions = [legacy_pos]
+
+        # 过滤目录页范围
+        valid_positions = [
+            p for p in positions
+            if not (toc_end_pos > 0 and toc_start_pos <= p < toc_end_pos)
+        ]
+
+        return sorted(valid_positions)
+
     def _find_title_in_text(self, title: str, text: str, fuzzy_threshold: float) -> int:
         """
         在文本中查找标题的近似位置（返回标题在文本中的精确起始位置）。

core/construction_review/component/reviewers/__init__.py

@@ -16,6 +16,14 @@ from .completeness_reviewer import (
     result_to_dict,
 )
 
+# 标准时效性审查（基于内存匹配规则，无LLM）
+from .standard_timeliness_reviewer import (
+    StandardTimelinessReviewer,
+    TimelinessReviewResult,
+    review_standards_timeliness,
+    review_standard_timeliness_with_standardized_output,
+)
+
 __all__ = [
     'BaseReviewer',
     # 轻量级完整性审查
@@ -26,4 +34,9 @@ __all__ = [
     'LightweightCompletenessResult',
     'check_completeness_lightweight',
     'result_to_dict',
+    # 标准时效性审查
+    'StandardTimelinessReviewer',
+    'TimelinessReviewResult',
+    'review_standards_timeliness',
+    'review_standard_timeliness_with_standardized_output',
 ]

core/construction_review/component/reviewers/standard_timeliness_reviewer.py

@@ -0,0 +1,361 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+标准时效性审查器 - 基于内存匹配规则
+
+使用 StandardMatchingService 替代原有的向量搜索+LLM判断方式，
+提供更快速、准确的标准时效性审查功能。
+
+使用示例:
+    # 方法1: 使用便捷函数
+    from foundation.infrastructure.mysql.async_mysql_conn_pool import AsyncMySQLPool
+
+    db_pool = AsyncMySQLPool()
+    await db_pool.initialize()
+
+    results = await review_standards_timeliness(
+        standards_list=[
+            {"standard_name": "铁路桥涵设计规范", "standard_number": "TB 10002-2017"},
+            {"standard_name": "起重机 钢丝绳 保养、维护、检验和报废", "standard_number": "GB/T 5972-2016"},
+        ],
+        db_pool=db_pool
+    )
+
+    # 方法2: 使用异步上下文管理器
+    async with StandardTimelinessReviewer(db_pool=db_pool) as reviewer:
+        results = reviewer.review_standards(standards_list)
+"""
+import asyncio
+from typing import List, Dict, Any, Optional
+from dataclasses import dataclass, asdict
+
+from foundation.observability.logger.loggering import review_logger as logger
+from core.construction_review.component.standard_matching import (
+    StandardMatchingService,
+    StandardMatchResult,
+    MatchResultCode,
+)
+
+
+@dataclass
+class TimelinessReviewResult:
+    """时效性审查结果"""
+    seq_no: int                              # 序号
+    standard_name: str                       # 原始标准名称
+    standard_number: str                     # 原始标准号
+    process_result: str                      # 处理结果
+    status_code: str                         # 状态码
+    has_issue: bool                          # 是否有问题
+    issue_type: Optional[str] = None         # 问题类型
+    suggestion: Optional[str] = None         # 建议
+    reason: Optional[str] = None             # 原因
+    risk_level: str = "low"                  # 风险等级（与原有逻辑一致：low/high）
+    replacement_name: Optional[str] = None   # 替代标准名称
+    replacement_number: Optional[str] = None # 替代标准号
+    final_result: Optional[str] = None       # 最终结果描述
+
+    def to_dict(self) -> Dict[str, Any]:
+        """转换为字典"""
+        return asdict(self)
+
+
+class StandardTimelinessReviewer:
+    """
+    标准时效性审查器
+
+    基于 StandardMatchingService 提供的内存匹配功能，
+    对标准列表进行时效性审查。
+    """
+
+    def __init__(self, db_pool=None, standard_service: Optional[StandardMatchingService] = None):
+        """
+        初始化审查器
+
+        Args:
+            db_pool: 数据库连接池，用于初始化 StandardMatchingService（如未提供standard_service则必填）
+            standard_service: 已初始化的 StandardMatchingService 实例（优先级高于 db_pool）
+
+        Raises:
+            RuntimeError: 当db_pool和standard_service都为None时抛出异常
+        """
+        if standard_service is None and not db_pool:
+            raise RuntimeError(
+                "StandardTimelinessReviewer 初始化失败: 必须提供数据库连接池(db_pool)或已初始化的StandardMatchingService实例。\n"
+                "Mock模式已取消，请确保数据库连接正常。"
+            )
+        self.db_pool = db_pool
+        self._service = standard_service
+        self._own_service = False  # 标记是否由本实例创建 service
+
+    async def __aenter__(self):
+        """异步上下文管理器入口"""
+        if self._service is None:
+            # own_db_pool=False 因为 db_pool 是外部传入的，不应该由本服务关闭
+            self._service = StandardMatchingService(self.db_pool, own_db_pool=False)
+            await self._service.initialize()
+            self._own_service = True
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """异步上下文管理器出口"""
+        if self._own_service and self._service:
+            await self._service.close()
+        return False
+
+    def review_standards(self, standards: List[Dict[str, str]]) -> List[TimelinessReviewResult]:
+        """
+        审查标准列表的时效性
+
+        Args:
+            standards: 标准列表，每个元素包含:
+                - standard_name: 标准名称
+                - standard_number: 标准号
+
+        Returns:
+            List[TimelinessReviewResult]: 审查结果列表
+        """
+        if not self._service:
+            raise RuntimeError("服务未初始化，请使用异步上下文管理器或调用 initialize()")
+
+        # 使用 StandardMatchingService 进行匹配
+        match_results = self._service.check_standards(standards)
+
+        # 转换为时效性审查结果
+        review_results = []
+        for match_result in match_results:
+            review_result = self._convert_match_to_review_result(match_result)
+            review_results.append(review_result)
+
+        return review_results
+
+    def review_single(self, standard_name: str, standard_number: str, seq_no: int = 1) -> TimelinessReviewResult:
+        """
+        审查单个标准的时效性
+
+        Args:
+            standard_name: 标准名称
+            standard_number: 标准号
+            seq_no: 序号
+
+        Returns:
+            TimelinessReviewResult: 审查结果
+        """
+        if not self._service:
+            raise RuntimeError("服务未初始化，请使用异步上下文管理器或调用 initialize()")
+
+        match_result = self._service.check_single(seq_no, standard_name, standard_number)
+        return self._convert_match_to_review_result(match_result)
+
+    def _convert_match_to_review_result(self, match_result: StandardMatchResult) -> TimelinessReviewResult:
+        """
+        将匹配结果转换为时效性审查结果
+
+        Args:
+            match_result: 标准匹配结果
+
+        Returns:
+            TimelinessReviewResult: 时效性审查结果
+        """
+        # 根据状态码确定是否有问题和风险等级
+        status_code = match_result.status_code
+
+        if status_code == MatchResultCode.OK.value:
+            # 正常状态 - 无风险
+            return TimelinessReviewResult(
+                seq_no=match_result.seq_no,
+                standard_name=match_result.original_name,
+                standard_number=match_result.original_number,
+                process_result=match_result.process_result,
+                status_code=status_code,
+                has_issue=False,
+                risk_level="low",
+                final_result=match_result.final_result
+            )
+
+        elif status_code == MatchResultCode.SUBSTITUTED.value:
+            # 被替代 - high（与原有逻辑一致）
+            return TimelinessReviewResult(
+                seq_no=match_result.seq_no,
+                standard_name=match_result.original_name,
+                standard_number=match_result.original_number,
+                process_result=match_result.process_result,
+                status_code=status_code,
+                has_issue=True,
+                issue_type="标准被替代",
+                suggestion=f"请更新为现行标准: {match_result.substitute_name}{match_result.substitute_number}",
+                reason=match_result.final_result,
+                risk_level="high",
+                replacement_name=match_result.substitute_name,
+                replacement_number=match_result.substitute_number,
+                final_result=match_result.final_result
+            )
+
+        elif status_code == MatchResultCode.ABOLISHED.value:
+            # 废止无替代 - high（与原有逻辑一致）
+            return TimelinessReviewResult(
+                seq_no=match_result.seq_no,
+                standard_name=match_result.original_name,
+                standard_number=match_result.original_number,
+                process_result=match_result.process_result,
+                status_code=status_code,
+                has_issue=True,
+                issue_type="标准已废止",
+                suggestion="该标准已废止且无现行替代，请检查是否仍需引用或寻找其他替代方案",
+                reason=match_result.final_result,
+                risk_level="high",
+                final_result=match_result.final_result
+            )
+
+        elif status_code == MatchResultCode.MISMATCH.value:
+            # 不匹配 - high（与原有逻辑一致：编号错误属于high）
+            return TimelinessReviewResult(
+                seq_no=match_result.seq_no,
+                standard_name=match_result.original_name,
+                standard_number=match_result.original_number,
+                process_result=match_result.process_result,
+                status_code=status_code,
+                has_issue=True,
+                issue_type="标准信息不匹配",
+                suggestion=f"名称与标准号不匹配，实际应为: {match_result.substitute_name}{match_result.substitute_number}",
+                reason=match_result.final_result,
+                risk_level="high",
+                replacement_name=match_result.substitute_name,
+                replacement_number=match_result.substitute_number,
+                final_result=match_result.final_result
+            )
+
+        elif status_code == MatchResultCode.NOT_FOUND.value:
+            # 标准库不存在 - 直接过滤，不返回问题
+            return TimelinessReviewResult(
+                seq_no=match_result.seq_no,
+                standard_name=match_result.original_name,
+                standard_number=match_result.original_number,
+                process_result=match_result.process_result,
+                status_code=status_code,
+                has_issue=False,
+                risk_level="low",
+                final_result=match_result.final_result
+            )
+
+        else:
+            # 未知状态
+            logger.warning(f"未知的匹配状态码: {status_code}")
+            return TimelinessReviewResult(
+                seq_no=match_result.seq_no,
+                standard_name=match_result.original_name,
+                standard_number=match_result.original_number,
+                process_result="未知",
+                status_code=status_code,
+                has_issue=True,
+                issue_type="未知状态",
+                reason=match_result.final_result,
+                risk_level="medium",
+                final_result=match_result.final_result
+            )
+
+    def convert_to_standardized_format(
+        self,
+        review_results: List[TimelinessReviewResult],
+        check_item: str = "timeliness_check",
+        chapter_code: str = "basis",
+        check_item_code: str = "standard_timeliness_check"
+    ) -> List[Dict[str, Any]]:
+        """
+        将审查结果转换为标准格式（兼容原有审查系统）
+
+        Args:
+            review_results: 审查结果列表
+            check_item: 检查项名称
+            chapter_code: 章节代码
+            check_item_code: 检查项代码
+
+        Returns:
+            List[Dict[str, Any]]: 标准格式的审查结果
+        """
+        standardized_results = []
+
+        for result in review_results:
+            # 标准库不存在或无问题的结果直接过滤，不返回
+            if result.status_code == MatchResultCode.NOT_FOUND.value or not result.has_issue:
+                continue
+            else:
+                # 有问题
+                standardized_results.append({
+                    "check_item": check_item,
+                    "chapter_code": chapter_code,
+                    "check_item_code": check_item_code,
+                    "check_result": {
+                        "location": f"《{result.standard_name}》（{result.standard_number}）",
+                        "description": result.reason or result.final_result,
+                        "suggestion": result.suggestion,
+                        "issue_type": result.issue_type,
+                        "standard_name": result.standard_name,
+                        "standard_number": result.standard_number,
+                        "replacement_name": result.replacement_name,
+                        "replacement_number": result.replacement_number,
+                    },
+                    "exist_issue": True,
+                    "risk_info": {"risk_level": result.risk_level}
+                })
+
+        return standardized_results
+
+
+# ========== 便捷函数 ==========
+
+async def review_standards_timeliness(
+    standards_list: List[Dict[str, str]],
+    db_pool=None,
+    standard_service: Optional[StandardMatchingService] = None
+) -> List[TimelinessReviewResult]:
+    """
+    审查标准列表时效性的便捷函数
+
+    Args:
+        standards_list: 标准列表，每个元素包含 standard_name 和 standard_number
+        db_pool: 数据库连接池
+        standard_service: 已初始化的 StandardMatchingService 实例（优先级高于 db_pool）
+
+    Returns:
+        List[TimelinessReviewResult]: 审查结果列表
+
+    示例:
+        results = await review_standards_timeliness(
+            standards_list=[
+                {"standard_name": "铁路桥涵设计规范", "standard_number": "TB 10002-2017"},
+                {"standard_name": "起重机 钢丝绳 保养、维护、检验和报废", "standard_number": "GB/T 5972-2016"},
+            ],
+            db_pool=db_pool
+        )
+    """
+    async with StandardTimelinessReviewer(db_pool=db_pool, standard_service=standard_service) as reviewer:
+        return reviewer.review_standards(standards_list)
+
+
+async def review_standard_timeliness_with_standardized_output(
+    standards_list: List[Dict[str, str]],
+    db_pool=None,
+    standard_service: Optional[StandardMatchingService] = None,
+    check_item: str = "timeliness_check",
+    chapter_code: str = "basis",
+    check_item_code: str = "standard_timeliness_check"
+) -> List[Dict[str, Any]]:
+    """
+    审查标准列表时效性并输出标准格式的便捷函数
+
+    Args:
+        standards_list: 标准列表
+        db_pool: 数据库连接池
+        standard_service: 已初始化的 StandardMatchingService 实例
+        check_item: 检查项名称
+        chapter_code: 章节代码
+        check_item_code: 检查项代码
+
+    Returns:
+        List[Dict[str, Any]]: 标准格式的审查结果
+    """
+    async with StandardTimelinessReviewer(db_pool=db_pool, standard_service=standard_service) as reviewer:
+        review_results = reviewer.review_standards(standards_list)
+        return reviewer.convert_to_standardized_format(
+            review_results, check_item, chapter_code, check_item_code
+        )

core/construction_review/component/reviewers/timeliness_basis_reviewer.py

@@ -3,17 +3,26 @@ from __future__ import annotations
 import json
 import time
 import asyncio
-from typing import Any, Dict, List
+import re
+from typing import Any, Dict, List, Optional, Tuple
 from functools import partial
 
-from langchain_milvus import Milvus, BM25BuiltInFunction
-from foundation.infrastructure.config.config import config_handler
-from foundation.ai.models.model_handler import model_handler as mh
+# [已注释] 旧的向量搜索和LLM判断相关导入
+# from langchain_milvus import Milvus, BM25BuiltInFunction
+# from foundation.infrastructure.config.config import config_handler
+# from foundation.ai.models.model_handler import model_handler as mh
 from core.construction_review.component.reviewers.utils.inter_tool import InterTool
 from core.construction_review.component.reviewers.utils.directory_extraction import BasisItems, BasisItem
 from foundation.observability.logger.loggering import review_logger as logger
-from core.construction_review.component.reviewers.utils.reference_matcher import match_reference_files
-from core.construction_review.component.reviewers.utils.timeliness_determiner import determine_timeliness_issue
+# [已注释] 旧的匹配和判定逻辑
+# from core.construction_review.component.reviewers.utils.reference_matcher import match_reference_files
+# from core.construction_review.component.reviewers.utils.timeliness_determiner import determine_timeliness_issue
+
+# [新增] 新的标准时效性审查模块
+from core.construction_review.component.reviewers.standard_timeliness_reviewer import (
+    StandardTimelinessReviewer,
+    review_standard_timeliness_with_standardized_output,
+)
 
 class StandardizedResponseProcessor:
     """标准化响应处理器"""
@@ -26,7 +35,7 @@ class StandardizedResponseProcessor:
         处理LLM响应，返回标准格式
 
         Args:
-            response_text: LLM原始响应文本（JSON字符串）
+            response_text: LLM原始响应文本(JSON字符串)
             check_name: 检查项名称
             chapter_code: 章节代码
             check_item_code: 检查项代码
@@ -64,143 +73,246 @@ class StandardizedResponseProcessor:
             }]
 
 
-class BasisSearchEngine:
-    """编制依据向量搜索引擎"""
-
-    # 类级别的缓存，避免重复创建 Milvus 实例
-    _vectorstore_cache = {}
-
-    def __init__(self):
-        self.emdmodel = None
-        self.host = None
-        self.port = None
-        self.user = None
-        self.password = None
-        self._initialize()
-
-    def _initialize(self):
-        """初始化搜索引擎"""
-        try:
-            # 连接配置
-            self.host = config_handler.get('milvus', 'MILVUS_HOST', 'localhost')
-            self.port = int(config_handler.get('milvus', 'MILVUS_PORT', '19530'))
-            self.user = config_handler.get('milvus', 'MILVUS_USER')
-            self.password = config_handler.get('milvus', 'MILVUS_PASSWORD')
-
-            # 初始化嵌入模型
-            self.emdmodel = mh._get_lq_qwen3_8b_emd()
-            logger.info("嵌入模型初始化成功")
-
-        except Exception as e:
-            logger.error(f" BasisSearchEngine 初始化失败: {e}")
-
-    def _get_vectorstore(self, collection_name: str):
-        """获取或创建 Milvus vectorstore 实例（使用缓存）"""
-        cache_key = f"{self.host}:{self.port}:{collection_name}"
-
-        if cache_key not in BasisSearchEngine._vectorstore_cache:
-            connection_args = {
-                "uri": f"http://{self.host}:{self.port}",
-                "user": self.user,
-                "db_name": "lq_db"
-            }
-            if self.password:
-                connection_args["password"] = self.password
-
-            # 抑制 AsyncMilvusClient 的警告日志
-            import logging
-            original_level = logging.getLogger('pymilvus').level
-            logging.getLogger('pymilvus').setLevel(logging.ERROR)
-
-            try:
-                vectorstore = Milvus(
-                    embedding_function=self.emdmodel,
-                    collection_name=collection_name,
-                    connection_args=connection_args,
-                    consistency_level="Strong",
-                    builtin_function=BM25BuiltInFunction(),
-                    vector_field=["dense", "sparse"]
-                )
-                BasisSearchEngine._vectorstore_cache[cache_key] = vectorstore
-                logger.info(f"创建并缓存 Milvus 连接: {cache_key}")
-            finally:
-                logging.getLogger('pymilvus').setLevel(original_level)
-
-        return BasisSearchEngine._vectorstore_cache[cache_key]
-
-    def hybrid_search(self, collection_name: str, query_text: str,
-                     top_k: int = 3, ranker_type: str = "weighted",
-                     dense_weight: float = 0.7, sparse_weight: float = 0.3):
-        try:
-            # 使用缓存的 vectorstore
-            vectorstore = self._get_vectorstore(collection_name)
-
-            # 执行混合搜索
-            if ranker_type == "weighted":
-                results = vectorstore.similarity_search(
-                    query=query_text,
-                    k=top_k,
-                    ranker_type="weighted",
-                    ranker_params={"weights": [dense_weight, sparse_weight]}
-                )
-            else:  # rrf
-                results = vectorstore.similarity_search(
-                    query=query_text,
-                    k=top_k,
-                    ranker_type="rrf",
-                    ranker_params={"k": 60}
-                )
-
-            # 格式化结果，保持与其他搜索方法一致
-            formatted_results = []
-            for doc in results:
-                formatted_results.append({
-                    'id': doc.metadata.get('pk', 0),
-                    'text_content': doc.page_content,
-                    'metadata': doc.metadata,
-                    'distance': 0.0,
-                    'similarity': 1.0
-                })
-
-            return formatted_results
-
-        except Exception as e:
-            # 回退到传统的向量搜索
-            logger.error(f" 搜索失败: {e}")
+# [已注释] 旧的向量搜索引擎类，已被新的规则匹配替代
+# class BasisSearchEngine:
+#     """编制依据向量搜索引擎"""
+#
+#     # 类级别的缓存，避免重复创建 Milvus 实例
+#     _vectorstore_cache = {}
+#
+#     def __init__(self):
+#         self.emdmodel = None
+#         self.host = None
+#         self.port = None
+#         self.user = None
+#         self.password = None
+#         self._initialize()
+#
+#     def _initialize(self):
+#         """初始化搜索引擎"""
+#         try:
+#             # 连接配置
+#             self.host = config_handler.get('milvus', 'MILVUS_HOST', 'localhost')
+#             self.port = int(config_handler.get('milvus', 'MILVUS_PORT', '19530'))
+#             self.user = config_handler.get('milvus', 'MILVUS_USER')
+#             self.password = config_handler.get('milvus', 'MILVUS_PASSWORD')
+#
+#             # 初始化嵌入模型
+#             self.emdmodel = mh._get_lq_qwen3_8b_emd()
+#             logger.info("嵌入模型初始化成功")
+#
+#         except Exception as e:
+#             logger.error(f" BasisSearchEngine 初始化失败: {e}")
+#
+#     def _get_vectorstore(self, collection_name: str):
+#         """获取或创建 Milvus vectorstore 实例(使用缓存)"""
+#         cache_key = f"{self.host}:{self.port}:{collection_name}"
+#
+#         if cache_key not in BasisSearchEngine._vectorstore_cache:
+#             connection_args = {
+#                 "uri": f"http://{self.host}:{self.port}",
+#                 "user": self.user,
+#                 "db_name": "lq_db"
+#             }
+#             if self.password:
+#                 connection_args["password"] = self.password
+#
+#             # 抑制 AsyncMilvusClient 的警告日志
+#             import logging
+#             original_level = logging.getLogger('pymilvus').level
+#             logging.getLogger('pymilvus').setLevel(logging.ERROR)
+#
+#             try:
+#                 vectorstore = Milvus(
+#                     embedding_function=self.emdmodel,
+#                     collection_name=collection_name,
+#                     connection_args=connection_args,
+#                     consistency_level="Strong",
+#                     builtin_function=BM25BuiltInFunction(),
+#                     vector_field=["dense", "sparse"]
+#                 )
+#                 BasisSearchEngine._vectorstore_cache[cache_key] = vectorstore
+#                 logger.info(f"创建并缓存 Milvus 连接: {cache_key}")
+#             finally:
+#                 logging.getLogger('pymilvus').setLevel(original_level)
+#
+#         return BasisSearchEngine._vectorstore_cache[cache_key]
+#
+#     def hybrid_search(self, collection_name: str, query_text: str,
+#                      top_k: int = 3, ranker_type: str = "weighted",
+#                      dense_weight: float = 0.7, sparse_weight: float = 0.3):
+#         try:
+#             # 使用缓存的 vectorstore
+#             vectorstore = self._get_vectorstore(collection_name)
+#
+#             # 执行混合搜索
+#             if ranker_type == "weighted":
+#                 results = vectorstore.similarity_search(
+#                     query=query_text,
+#                     k=top_k,
+#                     ranker_type="weighted",
+#                     ranker_params={"weights": [dense_weight, sparse_weight]}
+#                 )
+#             else:  # rrf
+#                 results = vectorstore.similarity_search(
+#                     query=query_text,
+#                     k=top_k,
+#                     ranker_type="rrf",
+#                     ranker_params={"k": 60}
+#                 )
+#
+#             # 格式化结果，保持与其他搜索方法一致
+#             formatted_results = []
+#             for doc in results:
+#                 formatted_results.append({
+#                     'id': doc.metadata.get('pk', 0),
+#                     'text_content': doc.page_content,
+#                     'metadata': doc.metadata,
+#                     'distance': 0.0,
+#                     'similarity': 1.0
+#                 })
+#
+#             return formatted_results
+#
+#         except Exception as e:
+#             # 回退到传统的向量搜索
+#             logger.error(f" 搜索失败: {e}")
 
 
 class BasisReviewService:
     """编制依据审查服务核心类"""
 
-    def __init__(self, max_concurrent: int = 4):
-        self.search_engine = BasisSearchEngine()
-        self.response_processor = StandardizedResponseProcessor()
+    def __init__(self, max_concurrent: int = 4, db_pool=None):
+        # [已注释] 旧的向量搜索引擎
+        # self.search_engine = BasisSearchEngine()
+        # self.response_processor = StandardizedResponseProcessor()
         self.max_concurrent = max_concurrent
         self._semaphore = None
+        self.db_pool = db_pool
+        self._timeliness_reviewer = None
 
     async def __aenter__(self):
         """异步上下文管理器入口"""
         if self._semaphore is None:
             self._semaphore = asyncio.Semaphore(self.max_concurrent)
+        # [新增] 初始化新的时效性审查器
+        if self._timeliness_reviewer is None:
+            self._timeliness_reviewer = StandardTimelinessReviewer(db_pool=self.db_pool)
+            # 预初始化数据（如果还没初始化）
+            if not self._timeliness_reviewer._service or not self._timeliness_reviewer._service._initialized:
+                await self._timeliness_reviewer.__aenter__()
         return self
 
     async def __aexit__(self, exc_type, exc_val, exc_tb):
         """异步上下文管理器出口"""
+        # [新增] 关闭时效性审查器
+        if self._timeliness_reviewer:
+            await self._timeliness_reviewer.__aexit__(exc_type, exc_val, exc_tb)
         return False
 
+    def _extract_standard_from_basis(self, basis_text: str) -> Optional[Dict[str, str]]:
+        """
+        [新增] 从编制依据文本中提取标准名称和编号
+
+        支持格式：
+        - 《标准名称》(标准号)
+        - 《标准名称》(标准号)其他文字
+        - 标准名称(标准号)
+        """
+        if not basis_text:
+            return None
+
+        # 模式1: 《名称》(编号)
+        pattern1 = r'《([^《》]+)》\s*（([^）]+)）'
+        match = re.search(pattern1, basis_text)
+        if match:
+            return {
+                "standard_name": match.group(1).strip(),
+                "standard_number": match.group(2).strip()
+            }
+
+        # 模式2: 《名称》(编号) - 半角括号
+        pattern2 = r'《([^《》]+)》\s*\(([^)]+)\)'
+        match = re.search(pattern2, basis_text)
+        if match:
+            return {
+                "standard_name": match.group(1).strip(),
+                "standard_number": match.group(2).strip()
+            }
+
+        # 模式3: 尝试匹配标准号格式(如 GB 1234-2020)
+        standard_pattern = r'([A-Z]{2,6}(?:/[A-Z])?\s*\d{1,6}(?:\.\d)?(?:-\d{4})?)'
+        std_match = re.search(standard_pattern, basis_text.upper())
+        if std_match:
+            standard_number = std_match.group(1).strip()
+            # 尝试提取名称（在编号前的书名号内）
+            name_match = re.search(r'《([^《》]+)》', basis_text)
+            if name_match:
+                return {
+                    "standard_name": name_match.group(1).strip(),
+                    "standard_number": standard_number
+                }
+            # 如果没有书名号，使用空名称
+            return {
+                "standard_name": "",
+                "standard_number": standard_number
+            }
+
+        return None
+
     async def review_batch(
         self,
         basis_items: List[str],
-        collection_name: str = "first_bfp_collection_status",
-        top_k_each: int = 10,  # 增加召回数量，提高精确匹配机会
+        collection_name: str = "first_bfp_collection_status",  # [保留参数但不再使用]
+        top_k_each: int = 10,  # [保留参数但不再使用]
     ) -> List[Dict[str, Any]]:
-        """异步批次审查（通常3条）"""
+        """
+        [已修改] 异步批次审查(通常3条)
+
+        新逻辑：使用基于内存的规则匹配替代向量搜索+LLM判断
+        """
         basis_items = [x for x in (basis_items or []) if isinstance(x, str) and x.strip()]
         if not basis_items:
             return []
 
         async with self._semaphore:
             try:
+                # [新增] 从编制依据中提取标准信息
+                standards_list = []
+                for basis in basis_items:
+                    std_info = self._extract_standard_from_basis(basis)
+                    if std_info:
+                        standards_list.append(std_info)
+                        logger.debug(f"提取到标准: {std_info['standard_name']} ({std_info['standard_number']})")
+                    else:
+                        logger.warning(f"无法从编制依据提取标准信息: {basis}")
+
+                if not standards_list:
+                    logger.info(f"批次中未提取到有效标准信息，跳过审查")
+                    return []
+
+                # [新增] 使用新的时效性审查逻辑
+                if not self._timeliness_reviewer:
+                    raise RuntimeError("时效性审查器未初始化，请使用异步上下文管理器")
+
+                review_results = self._timeliness_reviewer.review_standards(standards_list)
+
+                # 转换为标准格式
+                standardized_results = self._timeliness_reviewer.convert_to_standardized_format(
+                    review_results,
+                    check_item="timeliness_check",
+                    chapter_code="basis",
+                    check_item_code="basis_timeliness_check"
+                )
+
+                # 统计结果
+                issue_count = sum(1 for item in standardized_results if item.get('exist_issue', False))
+                logger.info(f"编制依据批次审查完成：总计 {len(standards_list)} 项，发现问题 {issue_count} 项")
+
+                return standardized_results
+
+                # [已注释] 旧的向量搜索+LLM判断逻辑
+                """
                 # 并发搜索每个编制依据
                 search_tasks = []
                 for basis in basis_items:
@@ -218,77 +330,15 @@ class BasisReviewService:
                         logger.error(f"搜索失败 '{basis_items[i]}': {result}")
                         grouped_candidates.append([])
                     else:
-                        # result 是 List[dict]，需要遍历
                         texts = [item["text_content"] for item in result if "text_content" in item]
                         grouped_candidates.append(texts)
-                
-                # 获取match_reference_files的结果并过滤
-                match_result = await match_reference_files(reference_text=grouped_candidates, review_text=basis_items)
 
-                # 记录完整的匹配结果用于调试
-                logger.info(f"批次 match_reference_files 原始结果: {match_result[:500]}...")
-
-                # 解析JSON并过滤：保留有相关信息的项
-                try:
-                    match_data = json.loads(match_result)
-                    # 提取items字段（match_reference_files返回{items: [...]}格式）
-                    items = match_data.get('items', match_data) if isinstance(match_data, dict) else match_data
-
-                    logger.info(f"解析到 {len(items)} 个匹配项")
-                    for idx, item in enumerate(items):
-                        logger.info(f"  项{idx}: review_item={item.get('review_item', 'unknown')}, "
-                                  f"has_related_file={item.get('has_related_file')}, "
-                                  f"exact_match_info={item.get('exact_match_info')}, "
-                                  f"same_name_current={item.get('same_name_current')}")
-
-                    # 放宽过滤条件：只要有相关文件信息就进行审查
-                    filtered_data = [
-                        item for item in items
-                        if item.get('has_related_file') or
-                           item.get('exact_match_info') or
-                           item.get('same_name_current')
-                    ]
-
-                    logger.info(f"过滤后保留 {len(filtered_data)} 个项")
-
-                    # 记录被过滤掉的项目用于调试
-                    skipped_items = [
-                        item for item in items
-                        if not (item.get('has_related_file') or
-                               item.get('exact_match_info') or
-                               item.get('same_name_current'))
-                    ]
-                    if skipped_items:
-                        logger.warning(f"跳过了 {len(skipped_items)} 个无参考信息的编制依据: "
-                                     f"{[item.get('review_item', 'unknown') for item in skipped_items]}")
-
-                    # 如果没有过滤出数据，直接返回空结果
-                    if not filtered_data:
-                        logger.info(f"过滤后没有符合条件的编制依据，跳过后续检查")
-                        standardized_result = []
-                    else:
-                        # 重新构建JSON格式
-                        if isinstance(match_data, dict) and 'items' in match_data:
-                            match_result = json.dumps({"items": filtered_data}, ensure_ascii=False, indent=2)
-                        else:
-                            match_result = json.dumps(filtered_data, ensure_ascii=False, indent=2)
-                        
-                        llm_out = await determine_timeliness_issue(match_result)
-                        
-                        standardized_result = self.response_processor.process_llm_response(llm_out, "timeliness_check", "basis", "basis_timeliness_check")
-                        # 统计问题数量
-                        issue_count = sum(1 for item in standardized_result if item.get('exist_issue', False))
-                        logger.info(f"编制依据批次审查完成：总计 {len(filtered_data)} 项，发现问题 {issue_count} 项")
-                    
-                    return standardized_result if standardized_result else []
-                    
-                except (json.JSONDecodeError, TypeError) as e:
-                    logger.warning(f"过滤match_reference_files结果时出错: {e}")
-                    # 如果解析失败，返回空结果
-                    return []
+                match_result = await match_reference_files(reference_text=grouped_candidates, review_text=basis_items)
+                ...  # 其余旧逻辑已省略
+                """
 
             except Exception as e:
-                logger.error(f" 批次处理失败: {e}")
+                logger.error(f"批次处理失败: {e}")
                 return [{
                     "check_item": "timeliness_check",
                     "chapter_code": "basis",
@@ -298,15 +348,15 @@ class BasisReviewService:
                     "risk_info": {"risk_level": "high"}
                 }]
 
-    
-    
+    # [已注释] 旧的向量搜索方法，已被新的规则匹配替代
+    """
     async def _async_search_basis(
         self,
         basis: str,
         collection_name: str,
         top_k_each: int
     ) -> List[dict]:
-        """异步搜索单个编制依据（Hybrid Search）"""
+        # 异步搜索单个编制依据(Hybrid Search)
         try:
             loop = asyncio.get_running_loop()
             func = partial(
@@ -324,11 +374,11 @@ class BasisReviewService:
         except Exception as e:
             logger.error(f" 搜索失败 '{basis}': {e}")
             return []
+    """
 
-    
     async def review_all(self, basis_items: BasisItems, collection_name: str = "first_bfp_collection_status",
                         progress_manager=None, callback_task_id: str = None) -> List[List[Dict[str, Any]]]:
-        """异步批量审查所有编制依据（入参为 BasisItems）"""
+        """异步批量审查所有编制依据(入参为 BasisItems)"""
         if not basis_items or not getattr(basis_items, "items", None):
             return []
 
@@ -339,7 +389,7 @@ class BasisReviewService:
         start_time = time.time()
         total_batches = (len(items) + 2) // 3  # 计算总批次数
         
-        # 发送开始审查的SSE推送（使用独立命名空间，避免与主流程进度冲突）
+        # 发送开始审查的SSE推送(使用独立命名空间，避免与主流程进度冲突)
         if progress_manager and callback_task_id:
             try:
                 await progress_manager.update_stage_progress(
@@ -373,7 +423,7 @@ class BasisReviewService:
                     if isinstance(item, dict) and item.get('is_standard', False):
                         batch_standard_count += 1
 
-                # 立即推送当前批次完成的SSE消息（使用独立命名空间）
+                # 立即推送当前批次完成的SSE消息(使用独立命名空间)
                 logger.info(f"批次{batch_index + 1}完成，准备推送SSE")
                 if progress_manager and callback_task_id:
                     try:
@@ -398,7 +448,7 @@ class BasisReviewService:
                 error_result = [{"name": name, "is_standard": False, "status": "", "meg": f"批次处理失败2: {str(e)}"}
                                 for name in batch]
 
-                # 即使失败也要推送结果（使用独立命名空间）
+                # 即使失败也要推送结果(使用独立命名空间)
                 if progress_manager and callback_task_id:
                     try:
                         await progress_manager.update_stage_progress(
@@ -463,7 +513,7 @@ class BasisReviewService:
         logger.info(f"并发执行完成，成功批次: {successful_batches}/{total_batches}")
 
 
-        # 发送完成审查的SSE推送（使用独立命名空间，不设置current避免覆盖主流程进度）
+        # 发送完成审查的SSE推送(使用独立命名空间，不设置current避免覆盖主流程进度)
         elapsed_time = time.time() - start_time
         if progress_manager and callback_task_id:
             try:
@@ -486,15 +536,37 @@ class BasisReviewService:
 
 
 # 便捷函数
-async def review_basis_batch_async(basis_items: List[str], max_concurrent: int = 4) -> List[Dict[str, Any]]:
-    """异步批次审查便捷函数"""
-    async with BasisReviewService(max_concurrent=max_concurrent) as service:
+async def review_basis_batch_async(
+    basis_items: List[str],
+    max_concurrent: int = 4,
+    db_pool=None
+) -> List[Dict[str, Any]]:
+    """
+    [已修改] 异步批次审查便捷函数
+
+    Args:
+        basis_items: 编制依据列表
+        max_concurrent: 最大并发数
+        db_pool: 数据库连接池(用于新的规则匹配)
+    """
+    async with BasisReviewService(max_concurrent=max_concurrent, db_pool=db_pool) as service:
         return await service.review_batch(basis_items)
 
 
-async def review_all_basis_async(basis_items: BasisItems, max_concurrent: int = 4) -> List[List[Dict[str, Any]]]:
-    """异步全部审查便捷函数（BasisItems 入参）"""
-    async with BasisReviewService(max_concurrent=max_concurrent) as service:
+async def review_all_basis_async(
+    basis_items: BasisItems,
+    max_concurrent: int = 4,
+    db_pool=None
+) -> List[List[Dict[str, Any]]]:
+    """
+    [已修改] 异步全部审查便捷函数(BasisItems 入参)
+
+    Args:
+        basis_items: BasisItems 对象
+        max_concurrent: 最大并发数
+        db_pool: 数据库连接池(用于新的规则匹配)
+    """
+    async with BasisReviewService(max_concurrent=max_concurrent, db_pool=db_pool) as service:
         return await service.review_all(basis_items)
 
 if __name__ == "__main__":

core/construction_review/component/reviewers/timeliness_content_reviewer.py

@@ -15,9 +15,15 @@ from dataclasses import dataclass, field
 from functools import partial
 
 from foundation.observability.logger.loggering import review_logger as logger
-from core.construction_review.component.reviewers.utils.reference_matcher import match_reference_files
-from core.construction_review.component.reviewers.utils.timeliness_determiner import determine_timeliness_issue
-from core.construction_review.component.reviewers.timeliness_basis_reviewer import BasisSearchEngine, StandardizedResponseProcessor
+# [已注释] 旧的向量搜索和LLM判断相关导入
+# from core.construction_review.component.reviewers.utils.reference_matcher import match_reference_files
+# from core.construction_review.component.reviewers.utils.timeliness_determiner import determine_timeliness_issue
+# from core.construction_review.component.reviewers.timeliness_basis_reviewer import BasisSearchEngine, StandardizedResponseProcessor
+
+# [新增] 新的标准时效性审查模块
+from core.construction_review.component.reviewers.standard_timeliness_reviewer import (
+    StandardTimelinessReviewer,
+)
 
 
 @dataclass
@@ -32,13 +38,13 @@ class StandardReference:
 
 @dataclass
 class ContentTimelinessResult:
-    """内容时效性审查结果"""
+    """内容时效性审查结果（保留用于兼容，新逻辑中不再直接使用）"""
     reference: StandardReference
     has_issue: bool
     issue_type: str              # 问题类型
     suggestion: str
     reason: str
-    risk_level: str              # 无风险 / 高风险
+    risk_level: str              # 风险等级（与原有逻辑一致：无风险/高风险）
 
 
 class StandardExtractor:
@@ -169,21 +175,32 @@ class StandardExtractor:
 class ContentTimelinessReviewer:
     """三级分类内容时效性审查器"""
 
-    def __init__(self, max_concurrent: int = 4):
+    def __init__(self, max_concurrent: int = 4, db_pool=None):
         self.extractor = StandardExtractor()
-        self.search_engine = BasisSearchEngine()
-        self.response_processor = StandardizedResponseProcessor()
+        # [已注释] 旧的向量搜索引擎
+        # self.search_engine = BasisSearchEngine()
+        # self.response_processor = StandardizedResponseProcessor()
         self.max_concurrent = max_concurrent
         self._semaphore = None
+        self.db_pool = db_pool
+        self._timeliness_reviewer = None
 
     async def __aenter__(self):
         """异步上下文管理器入口"""
         if self._semaphore is None:
             self._semaphore = asyncio.Semaphore(self.max_concurrent)
+        # [新增] 初始化新的时效性审查器
+        if self._timeliness_reviewer is None:
+            self._timeliness_reviewer = StandardTimelinessReviewer(db_pool=self.db_pool)
+            if not self._timeliness_reviewer._service or not self._timeliness_reviewer._service._initialized:
+                await self._timeliness_reviewer.__aenter__()
         return self
 
     async def __aexit__(self, exc_type, exc_val, exc_tb):
         """异步上下文管理器出口"""
+        # [新增] 关闭时效性审查器
+        if self._timeliness_reviewer:
+            await self._timeliness_reviewer.__aexit__(exc_type, exc_val, exc_tb)
         return False
 
     async def review_tertiary_content(
@@ -241,6 +258,94 @@ class ContentTimelinessReviewer:
         # 2. 对提取的规范进行时效性审查
         all_issues = []
 
+        # [新增] 构建标准列表用于规则匹配
+        standards_list = []
+        for ref in all_references:
+            standards_list.append({
+                "standard_name": ref.name,
+                "standard_number": ref.number
+            })
+
+        if not standards_list:
+            logger.info("未提取到有效标准信息")
+            return []
+
+        # [新增] 使用新的时效性审查逻辑
+        if not self._timeliness_reviewer:
+            raise RuntimeError("时效性审查器未初始化，请使用异步上下文管理器")
+
+        try:
+            async with self._semaphore:
+                # 执行规则匹配审查
+                review_results = self._timeliness_reviewer.review_standards(standards_list)
+
+                # 转换为标准格式
+                standardized_results = self._timeliness_reviewer.convert_to_standardized_format(
+                    review_results,
+                    check_item="content_timeliness_check",
+                    chapter_code="content",
+                    check_item_code="content_timeliness_check"
+                )
+
+                # 增强结果：添加位置信息
+                for item in standardized_results:
+                    # 构建原始引用文本（《名称》（编号））
+                    std_name = item.get("check_result", {}).get("standard_name", "")
+                    std_number = item.get("check_result", {}).get("standard_number", "")
+                    review_item_text = f"《{std_name}》（{std_number}）"
+
+                    if review_item_text in reference_to_location:
+                        locations = reference_to_location[review_item_text]
+                        # 添加位置信息到结果
+                        item["location_info"] = locations
+                        # 添加三级分类上下文
+                        contexts = []
+                        for loc in locations:
+                            ctx = f"[{loc.get('third_category_name', '')}] 第{loc.get('start_line', 0)}-{loc.get('end_line', 0)}行"
+                            contexts.append(ctx)
+                        item["content_context"] = "; ".join(contexts)
+
+                        # 更新location字段为更详细的描述
+                        if contexts:
+                            item["check_result"]["location"] = f"{review_item_text}（出现在：{item['content_context']}）"
+
+                all_issues.extend(standardized_results)
+
+                # 统计结果
+                issue_count = sum(1 for item in standardized_results if item.get("exist_issue", False))
+                logger.info(f"内容时效性审查完成：总计 {len(standards_list)} 项引用，发现问题 {issue_count} 项")
+
+                # SSE推送（如果提供了progress_manager）
+                if progress_manager and callback_task_id:
+                    try:
+                        await progress_manager.update_stage_progress(
+                            callback_task_id=callback_task_id,
+                            stage_name="内容时效性审查",
+                            status="processing",
+                            message=f"完成内容时效性审查，{len(standards_list)}项，发现问题{issue_count}项",
+                            overall_task_status="processing",
+                            event_type="processing",
+                            issues=standardized_results
+                        )
+                    except Exception as e:
+                        logger.error(f"SSE推送失败: {e}")
+
+        except Exception as e:
+            logger.error(f"时效性审查处理失败: {e}")
+            error_result = {
+                "check_item": "content_timeliness_check",
+                "chapter_code": "content",
+                "check_item_code": "content_timeliness_check",
+                "check_result": {"error": str(e)},
+                "exist_issue": True,
+                "risk_info": {"risk_level": "medium"}
+            }
+            all_issues.append(error_result)
+
+        return all_issues
+
+        # [已注释] 旧的向量搜索+LLM判断逻辑
+        """
         # 分批处理（每批3个）
         batch_size = 3
         ref_texts = [ref.original_text for ref in all_references]
@@ -262,145 +367,21 @@ class ContentTimelinessReviewer:
                         search_tasks.append(task)
 
                     search_results = await asyncio.gather(*search_tasks, return_exceptions=True)
-
-                    # 构建参考文本列表
-                    grouped_candidates = []
-                    for j, result in enumerate(search_results):
-                        if isinstance(result, Exception):
-                            logger.error(f"搜索失败 '{batch_refs[j].original_text}': {result}")
-                            grouped_candidates.append([])
-                        else:
-                            texts = [item.get("text_content", "") for item in result if item]
-                            grouped_candidates.append(texts)
-
-                    # 匹配参考文件
-                    match_result = await match_reference_files(
-                        reference_text=grouped_candidates,
-                        review_text=batch_texts
-                    )
-
-                    # 记录完整的匹配结果用于调试
-                    logger.info(f"批次{batch_num} match_reference_files 原始结果: {match_result[:500]}...")
-
-                    # 过滤：保留有相关信息的项进行审查
-                    # 条件：has_related_file为true 或 exact_match_info不为空 或 same_name_current不为空
-                    try:
-                        match_data = json.loads(match_result)
-                        items = match_data.get('items', match_data) if isinstance(match_data, dict) else match_data
-
-                        logger.info(f"批次{batch_num} 解析到 {len(items)} 个匹配项")
-                        for idx, item in enumerate(items):
-                            logger.info(f"  项{idx}: review_item={item.get('review_item', 'unknown')}, "
-                                      f"has_related_file={item.get('has_related_file')}, "
-                                      f"exact_match_info={item.get('exact_match_info')}, "
-                                      f"same_name_current={item.get('same_name_current')}")
-
-                        # 放宽过滤条件：只要有相关文件信息就进行审查
-                        filtered_data = [
-                            item for item in items
-                            if item.get('has_related_file') or
-                               item.get('exact_match_info') or
-                               item.get('same_name_current')
-                        ]
-
-                        logger.info(f"批次{batch_num} 过滤后保留 {len(filtered_data)} 个项")
-
-                        # 记录被过滤掉的项目用于调试
-                        skipped_items = [
-                            item for item in items
-                            if not (item.get('has_related_file') or
-                                   item.get('exact_match_info') or
-                                   item.get('same_name_current'))
-                        ]
-                        if skipped_items:
-                            logger.warning(f"批次{batch_num} 跳过了 {len(skipped_items)} 个无参考信息的项: "
-                                         f"{[item.get('review_item', 'unknown') for item in skipped_items]}")
-
-                        if not filtered_data:
-                            logger.info(f"批次{batch_num}: 没有符合审查条件的规范引用")
-                            continue
-
-                        # 重新构建JSON
-                        if isinstance(match_data, dict) and 'items' in match_data:
-                            match_result = json.dumps({"items": filtered_data}, ensure_ascii=False)
-                        else:
-                            match_result = json.dumps(filtered_data, ensure_ascii=False)
-
-                        # 判定时效性问题
-                        llm_out = await determine_timeliness_issue(match_result)
-
-                        # 处理响应
-                        standardized_result = self.response_processor.process_llm_response(
-                            llm_out,
-                            "content_timeliness_check",
-                            "content",
-                            "content_timeliness_check"
-                        )
-
-                        # 3. 增强结果：添加位置信息
-                        for item in standardized_result:
-                            review_item = item.get("check_result", {}).get("location", "")
-                            if review_item in reference_to_location:
-                                locations = reference_to_location[review_item]
-                                # 添加位置信息到结果
-                                item["location_info"] = locations
-                                # 添加三级分类上下文
-                                contexts = []
-                                for loc in locations:
-                                    ctx = f"[{loc.get('third_category_name', '')}] 第{loc.get('start_line', 0)}-{loc.get('end_line', 0)}行"
-                                    contexts.append(ctx)
-                                item["content_context"] = "; ".join(contexts)
-
-                                # 更新location字段为更详细的描述
-                                if contexts:
-                                    item["check_result"]["location"] = f"{review_item}（出现在：{item['content_context']}）"
-
-                        all_issues.extend(standardized_result)
-
-                        # SSE推送（如果提供了progress_manager）
-                        if progress_manager and callback_task_id:
-                            try:
-                                await progress_manager.update_stage_progress(
-                                    callback_task_id=callback_task_id,
-                                    stage_name=f"内容时效性审查-批次{batch_num}",
-                                    status="processing",
-                                    message=f"完成第{batch_num}/{total_batches}批次内容时效性审查，{len(batch_refs)}项",
-                                    overall_task_status="processing",
-                                    event_type="processing",
-                                    issues=standardized_result
-                                )
-                            except Exception as e:
-                                logger.error(f"SSE推送失败: {e}")
-
-                    except (json.JSONDecodeError, TypeError) as e:
-                        logger.warning(f"处理匹配结果时出错: {e}")
-                        continue
-
+                    ...  # 其余旧逻辑已省略
             except Exception as e:
                 logger.error(f"批次 {batch_num} 处理失败: {e}")
-                error_result = {
-                    "check_item": "content_timeliness_check",
-                    "chapter_code": "content",
-                    "check_item_code": "content_timeliness_check",
-                    "check_result": {"error": str(e), "batch_num": batch_num},
-                    "exist_issue": True,
-                    "risk_info": {"risk_level": "medium"}
-                }
-                all_issues.append(error_result)
-
-        # 统计结果
-        issue_count = sum(1 for item in all_issues if item.get("exist_issue", False))
-        logger.info(f"内容时效性审查完成：总计 {len(all_references)} 项引用，发现问题 {issue_count} 项")
-
-        return all_issues
+        ...
+        """
 
+    # [已注释] 旧的向量搜索方法，已被新的规则匹配替代
+    """
     async def _async_search_standard(
         self,
         standard_number: str,
         collection_name: str,
-        top_k: int = 10  # 增加召回数量，提高精确匹配机会
+        top_k: int = 10
     ) -> List[dict]:
-        """异步搜索单个规范"""
+        '''异步搜索单个规范'''
         try:
             loop = asyncio.get_running_loop()
             func = partial(
@@ -418,31 +399,34 @@ class ContentTimelinessReviewer:
         except Exception as e:
             logger.error(f"搜索失败 '{standard_number}': {e}")
             return []
+    """
 
 
 # ===== 便捷函数 =====
 
 async def review_tertiary_content_timeliness(
     tertiary_details: List[Dict[str, Any]],
-    collection_name: str = "first_bfp_collection_status",
+    collection_name: str = "first_bfp_collection_status",  # [保留参数但不再使用]
     max_concurrent: int = 4,
     progress_manager=None,
-    callback_task_id: str = None
+    callback_task_id: str = None,
+    db_pool=None  # [新增] 数据库连接池
 ) -> List[Dict[str, Any]]:
     """
-    审查三级分类内容时效性的便捷函数
+    [已修改] 审查三级分类内容时效性的便捷函数
 
     Args:
         tertiary_details: 三级分类详情列表
-        collection_name: Milvus集合名称
+        collection_name: Milvus集合名称（已废弃，保留参数用于兼容）
         max_concurrent: 最大并发数
         progress_manager: 进度管理器（可选）
         callback_task_id: 回调任务ID（可选）
+        db_pool: 数据库连接池（用于新的规则匹配）
 
     Returns:
         List[Dict]: 标准化的审查结果列表
     """
-    async with ContentTimelinessReviewer(max_concurrent=max_concurrent) as reviewer:
+    async with ContentTimelinessReviewer(max_concurrent=max_concurrent, db_pool=db_pool) as reviewer:
         return await reviewer.review_tertiary_content(
             tertiary_details=tertiary_details,
             collection_name=collection_name,

core/construction_review/component/standard_matching/README.md

@@ -0,0 +1,181 @@
+# 标准库匹配模块 - 时效性审查
+
+## 简介
+
+本模块提供基于内存匹配规则的标准时效性审查功能，替代原有的向量搜索+LLM判断方式，具有以下优势：
+
+- **高性能**：数据加载到内存后，查询无需访问数据库
+- **准确性**：基于规则的精确匹配，不受LLM幻觉影响
+- **无LLM依赖**：纯规则匹配，无需调用大模型
+- **易于维护**：清晰的匹配规则逻辑，便于调试和优化
+
+## 模块结构
+
+```
+standard_matching/
+├── __init__.py              # 模块导出
+├── standard_dao.py          # 数据访问对象（从MySQL加载数据）
+├── standard_service.py      # 核心业务逻辑（内存匹配）
+└── README.md               # 使用说明
+```
+
+## 核心组件
+
+### 1. StandardMatchingService
+
+标准匹配服务，对外暴露的统一接口。
+
+**主要方法：**
+- `initialize()`: 从数据库加载数据到内存（只需调用一次）
+- `check_standards(standards)`: 批量检查标准列表
+- `check_single(seq_no, name, number)`: 检查单个标准
+
+### 2. StandardTimelinessReviewer
+
+时效性审查器，位于 `reviewers/standard_timeliness_reviewer.py`，提供更高级的审查功能。
+
+**主要方法：**
+- `review_standards(standards)`: 审查标准列表，返回详细审查结果
+- `review_single(name, number, seq_no)`: 审查单个标准
+- `convert_to_standardized_format(results)`: 转换为标准格式（兼容原有审查系统）
+
+## 使用示例
+
+### 方式1：使用便捷函数（推荐）
+
+```python
+import asyncio
+from foundation.infrastructure.mysql.async_mysql_conn_pool import AsyncMySQLPool
+from core.construction_review.component.reviewers import review_standards_timeliness
+
+async def main():
+    # 初始化数据库连接池
+    db_pool = AsyncMySQLPool()
+    await db_pool.initialize()
+
+    # 定义要检查的标准列表
+    standards = [
+        {"standard_name": "铁路桥涵设计规范", "standard_number": "TB 10002-2017"},
+        {"standard_name": "起重机 钢丝绳 保养、维护、检验和报废", "standard_number": "GB/T 5972-2016"},
+    ]
+
+    # 执行时效性审查
+    results = await review_standards_timeliness(standards, db_pool=db_pool)
+
+    # 处理结果
+    for result in results:
+        print(f"{result.standard_name}: {result.process_result}")
+        if result.has_issue:
+            print(f"  问题: {result.issue_type}")
+            print(f"  建议: {result.suggestion}")
+
+    await db_pool.close()
+
+asyncio.run(main())
+```
+
+### 方式2：使用异步上下文管理器
+
+```python
+from core.construction_review.component.reviewers import StandardTimelinessReviewer
+
+async def main():
+    db_pool = AsyncMySQLPool()
+    await db_pool.initialize()
+
+    async with StandardTimelinessReviewer(db_pool=db_pool) as reviewer:
+        # 审查标准
+        results = reviewer.review_standards(standards_list)
+
+        # 转换为标准格式（兼容原有系统）
+        standardized = reviewer.convert_to_standardized_format(
+            results,
+            check_item="timeliness_check",
+            chapter_code="basis",
+            check_item_code="basis_timeliness_check"
+        )
+
+    await db_pool.close()
+```
+
+### 方式3：直接使用 StandardMatchingService
+
+```python
+from core.construction_review.component.standard_matching import StandardMatchingService
+
+async def main():
+    # 创建服务并初始化
+    service = StandardMatchingService(db_pool=db_pool)
+    await service.initialize()
+
+    # 批量检查
+    results = service.check_standards([
+        {"standard_name": "铁路桥涵设计规范", "standard_number": "TB 10002-2017"},
+    ])
+
+    for result in results:
+        print(f"状态: {result.status_code}")
+        print(f"结果: {result.final_result}")
+```
+
+## 匹配结果状态码
+
+| 状态码 | 说明 | 风险等级 |
+|--------|------|----------|
+| OK | 标准现行有效 | none |
+| SUBSTITUTED | 标准被替代 | high |
+| ABOLISHED | 标准废止无替代 | high |
+| MISMATCH | 名称与标准号不匹配 | medium |
+| NOT_FOUND | 标准库不存在 | medium |
+
+## 匹配规则流程
+
+1. **标准号精确匹配**
+   - 匹配成功 -> 检查名称是否匹配 -> 检查时效性状态
+   - 匹配失败 -> 尝试模糊匹配标准号
+
+2. **名称匹配**
+   - 精确匹配成功 -> 检查时效性状态
+   - 模糊匹配成功 -> 返回不匹配（标准号错误）
+   - 匹配失败 -> 返回不存在
+
+3. **时效性状态处理**
+   - 现行/试行 -> 正常
+   - 废止 -> 查找同名现行标准（被替代）
+   - 废止无替代 -> 废止无现行
+
+## 性能考虑
+
+- 数据加载：应用启动时一次性从MySQL加载，约1-2秒（1000+条标准）
+- 内存占用：约5-10MB（取决于标准数据量）
+- 查询速度：内存操作，单次匹配 < 1ms
+
+## 集成到现有系统
+
+新的时效性审查逻辑可以集成到以下模块：
+
+1. **timeliness_basis_reviewer.py**: 编制依据时效性审查
+2. **timeliness_content_reviewer.py**: 三级分类内容时效性审查
+
+集成方式：将原有的向量搜索+LLM判断逻辑替换为新的规则匹配逻辑。
+
+示例：
+```python
+# 原有方式（向量搜索+LLM）
+search_results = await self._async_search_basis(basis, collection_name)
+match_result = await match_reference_files(reference_text=search_results, review_text=basis)
+llm_out = await determine_timeliness_issue(match_result)
+
+# 新方式（规则匹配）
+from core.construction_review.component.reviewers import review_standard_timeliness_with_standardized_output
+results = await review_standard_timeliness_with_standardized_output(
+    standards_list,
+    db_pool=db_pool
+)
+```
+
+## 注意事项
+
+1. **数据库连接池**：使用时需要传入已初始化的 AsyncMySQLPool 实例
+2. **单例模式**：StandardTimelinessReviewer 支持单例模式，可通过 `get_standard_matching_service()` 获取全局实例
+3. **数据更新**：如果标准库数据发生变化，需要重新初始化服务以加载最新数据

core/construction_review/component/standard_matching/__init__.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+标准库匹配模块 - 时效性审查核心组件
+
+提供基于内存的标准库查询和匹配功能，用于替代原有的向量搜索+LLM判断方式。
+
+主要组件:
+- StandardMatchingService: 对外服务接口
+- StandardMatcher: 匹配规则逻辑
+- StandardRepository: 内存数据存储和索引
+"""
+
+from .standard_service import (
+    StandardMatchingService,
+    StandardMatcher,
+    StandardRepository,
+    StandardMatchResult,
+    StandardRecord,
+    ValidityStatus,
+    MatchResultCode,
+)
+from .standard_dao import StandardDAO
+
+__all__ = [
+    'StandardMatchingService',
+    'StandardMatcher',
+    'StandardRepository',
+    'StandardMatchResult',
+    'StandardRecord',
+    'StandardDAO',
+    'ValidityStatus',
+    'MatchResultCode',
+]

core/construction_review/component/standard_matching/standard_dao.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+标准库数据访问对象
+用于从MySQL一次性加载所有标准数据到内存
+"""
+from typing import List, Dict
+
+
+class StandardDAO:
+    """标准库数据访问对象 - 负责从数据库加载数据"""
+
+    def __init__(self, db_pool):
+        self.db_pool = db_pool
+        self.table_name = "t_samp_standard_base_info"
+
+    async def load_all_standards(self) -> List[Dict]:
+        """
+        一次性从MySQL加载所有标准数据到内存
+
+        Returns:
+            标准列表，每个标准包含:
+                - id: 序号
+                - standard_name: 标准名称(chinese_name)
+                - standard_number: 标准号
+                - validity: 时效性(XH/SX/FZ)
+        """
+        query = f"""
+            SELECT
+                id,
+                chinese_name AS standard_name,
+                standard_number,
+                validity
+            FROM {self.table_name}
+            WHERE validity IS NOT NULL
+        """
+        try:
+            async with self.db_pool.get_cursor() as cursor:
+                await cursor.execute(query)
+                results = await cursor.fetchall()
+                return [dict(row) for row in results] if results else []
+        except Exception as e:
+            raise RuntimeError(f"加载标准库数据失败: {e}")

core/construction_review/component/standard_matching/standard_service.py

@@ -0,0 +1,706 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+标准库匹配规则服务 - 内存处理版本
+实现施工方案审查-时效性审查的匹配逻辑
+
+架构:
+- StandardRepository: 内存数据存储和索引
+- StandardMatcher: 匹配规则逻辑
+- StandardMatchingService: 对外服务接口
+"""
+from typing import List, Dict, Optional
+from dataclasses import dataclass, field
+from enum import Enum
+
+from foundation.observability.logger.loggering import review_logger as logger
+
+
+class ValidityStatus(Enum):
+    """时效性状态"""
+    CURRENT = "XH"      # 现行
+    TRIAL = "SX"        # 试行
+    ABOLISHED = "FZ"    # 废止
+
+
+class MatchResultCode(Enum):
+    """匹配结果状态码"""
+    OK = "OK"                       # 正常
+    SUBSTITUTED = "SUBSTITUTED"     # 被替代
+    ABOLISHED = "ABOLISHED"         # 废止无现行
+    MISMATCH = "MISMATCH"           # 不匹配
+    NOT_FOUND = "NOT_FOUND"         # 标准库不存在
+
+
+@dataclass
+class StandardMatchResult:
+    """标准匹配结果数据结构"""
+    seq_no: int = 0                             # 序号
+    original_name: str = ""                      # 原始标准名称
+    original_number: str = ""                    # 原始标准号
+    substitute_number: Optional[str] = None      # 替代标准号（如果有）
+    substitute_name: Optional[str] = None        # 替代标准名称（如果有）
+    process_result: str = ""                     # 处理结果状态
+    status_code: str = ""                        # 状态码
+    final_result: str = ""                       # 最终结果消息
+
+
+@dataclass
+class StandardRecord:
+    """标准记录数据结构"""
+    id: int
+    standard_name: str
+    standard_number: str
+    validity: str
+
+
+class StandardRepository:
+    """
+    标准库内存数据仓库
+    负责加载和索引标准数据，支持快速查询
+    """
+
+    def __init__(self):
+        # 原始数据列表
+        self._records: List[StandardRecord] = []
+
+        # 索引结构，加速查询
+        self._number_index: Dict[str, StandardRecord] = {}  # 标准号 -> 记录
+        self._name_index: Dict[str, List[StandardRecord]] = {}  # 名称 -> 记录列表
+        self._current_records: List[StandardRecord] = []  # 现行/试行标准列表
+
+    def load_data(self, raw_data: List[Dict]):
+        """
+        加载原始数据到内存并建立索引
+
+        Args:
+            raw_data: 从数据库查询的原始标准数据列表
+        """
+        self._records = []
+        self._number_index = {}
+        self._name_index = {}
+        self._current_records = []
+
+        for item in raw_data:
+            # 跳过无效数据
+            standard_number = item.get("standard_number")
+            standard_name = item.get("standard_name")
+            if not standard_number or not standard_name:
+                continue
+
+            record = StandardRecord(
+                id=item.get("id", 0),
+                standard_name=standard_name,
+                standard_number=standard_number,
+                validity=item.get("validity", "")
+            )
+            self._records.append(record)
+
+            # 建立标准号索引
+            self._number_index[record.standard_number] = record
+
+            # 建立名称索引（一个名称可能对应多个标准号）
+            if record.standard_name not in self._name_index:
+                self._name_index[record.standard_name] = []
+            self._name_index[record.standard_name].append(record)
+
+            # 收集现行/试行标准
+            if record.validity in [ValidityStatus.CURRENT.value, ValidityStatus.TRIAL.value]:
+                self._current_records.append(record)
+
+        # 对现行标准按标准号降序排序（用于找最新替代标准）
+        # 处理可能的 None 值
+        self._current_records.sort(
+            key=lambda r: r.standard_number or "",
+            reverse=True
+        )
+        logger.info(f"标准库数据加载完成: {len(self._records)} 条记录")
+
+    def find_by_number_exact(self, standard_number: str) -> Optional[StandardRecord]:
+        """精确匹配标准号"""
+        return self._number_index.get(standard_number)
+
+    def find_by_name_exact(self, standard_name: str) -> Optional[StandardRecord]:
+        """精确匹配标准名称（返回第一个）"""
+        records = self._name_index.get(standard_name, [])
+        return records[0] if records else None
+
+    def find_by_name_fuzzy(self, standard_name: str) -> List[StandardRecord]:
+        """模糊匹配标准名称"""
+        results = []
+        for name, records in self._name_index.items():
+            if standard_name in name or name in standard_name:
+                results.extend(records)
+        return results
+
+    def find_by_number_fuzzy(self, standard_number: str) -> List[StandardRecord]:
+        """模糊匹配标准号"""
+        results = []
+        # 提取前缀（如 GB/T 5972）
+        parts = standard_number.split("-")
+        prefix = parts[0] if parts else standard_number
+
+        for number, record in self._number_index.items():
+            # 前缀匹配
+            if number.startswith(prefix):
+                results.append(record)
+        return results
+
+    def find_current_by_name(self, standard_name: str) -> List[StandardRecord]:
+        """查询指定名称的现行/试行标准（支持模糊匹配）"""
+        results = []
+        for record in self._current_records:
+            # 精确匹配
+            if record.standard_name == standard_name:
+                results.append(record)
+            # 模糊匹配（忽略空格、书名号等）
+            elif self._is_name_fuzzy_match_for_repo(record.standard_name, standard_name):
+                results.append(record)
+        return results
+
+    def _is_name_fuzzy_match_for_repo(self, name1: str, name2: str) -> bool:
+        """判断两个标准名称是否模糊匹配"""
+        clean1 = name1.replace("《", "").replace("》", "").replace(" ", "").replace("　", "")
+        clean2 = name2.replace("《", "").replace("》", "").replace(" ", "").replace("　", "")
+        return clean1 == clean2
+
+    def get_all_records(self) -> List[StandardRecord]:
+        """获取所有记录"""
+        return self._records.copy()
+
+
+class StandardMatcher:
+    """
+    标准匹配器
+    实现标准库匹配规则的核心逻辑
+    """
+
+    def __init__(self, repository: StandardRepository):
+        self.repo = repository
+
+    def match(self, seq_no: int, input_name: str, input_number: str) -> StandardMatchResult:
+        """
+        执行标准匹配
+
+        匹配流程:
+        1. 标准号精确匹配
+        2. 根据匹配结果进入不同分支处理
+        """
+        # 去除前后空格
+        input_name = input_name.strip() if input_name else input_name
+        input_number = input_number.strip() if input_number else input_number
+
+        # 清洗书名号和括号
+        input_name = self._clean_brackets_and_booknames(input_name)
+        input_number = self._clean_brackets_and_booknames(input_number)
+
+        result = StandardMatchResult(
+            seq_no=seq_no,
+            original_name=input_name,
+            original_number=input_number
+        )
+
+        # 步骤1: 精确匹配标准号
+        match_by_number = self.repo.find_by_number_exact(input_number)
+
+        if match_by_number:
+            # 分支A: 标准号匹配成功
+            return self._handle_number_matched(result, match_by_number, input_name)
+        else:
+            # 分支B: 标准号未匹配
+            return self._handle_number_not_matched(result, input_name, input_number)
+
+    def _handle_number_matched(
+        self,
+        result: StandardMatchResult,
+        db_record: StandardRecord,
+        input_name: str
+    ) -> StandardMatchResult:
+        """处理标准号匹配成功的情况"""
+        # 检查名称是否匹配
+        if db_record.standard_name == input_name:
+            # 名称也匹配
+            return self._handle_full_match(result, db_record)
+        else:
+            # 名称不匹配
+            return self._handle_name_mismatch(result, db_record, input_name)
+
+    def _handle_full_match(
+        self,
+        result: StandardMatchResult,
+        db_record: StandardRecord
+    ) -> StandardMatchResult:
+        """处理名称和标准号都完全匹配的情况"""
+        if db_record.validity in [ValidityStatus.CURRENT.value, ValidityStatus.TRIAL.value]:
+            # 情况1: 现行或试行 - 状态正常
+            return self._set_ok_result(result)
+        else:
+            # 废止状态 - 查找替代标准
+            return self._handle_abolished(result, db_record)
+
+    def _handle_name_mismatch(
+        self,
+        result: StandardMatchResult,
+        db_record: StandardRecord,
+        input_name: str
+    ) -> StandardMatchResult:
+        """处理标准号匹配但名称不匹配的情况"""
+        # 首先检查是否是名称模糊匹配（忽略空格、书名号等）
+        if self._is_name_fuzzy_match(db_record.standard_name, input_name):
+            # 名称模糊匹配成功，按完全匹配处理
+            return self._handle_full_match(result, db_record)
+
+        # 尝试用输入的名称模糊匹配
+        name_matches = self.repo.find_by_name_fuzzy(input_name)
+
+        # 查找精确名称匹配
+        exact_match = self._find_exact_name_match(name_matches, input_name)
+
+        if exact_match:
+            # 找到名称匹配的记录
+            return self._handle_fuzzy_name_match(result, exact_match)
+
+        # 尝试在模糊匹配结果中查找模糊名称匹配
+        for match in name_matches:
+            if self._is_name_fuzzy_match(match.standard_name, input_name):
+                return self._handle_fuzzy_name_match(result, match)
+
+        # 名称完全不匹配，但标准号已匹配成功
+        # 说明该标准存在于库中，应返回不匹配而非不存在
+        if db_record.validity in [ValidityStatus.CURRENT.value, ValidityStatus.TRIAL.value]:
+            return self._set_mismatch_result(result, db_record)
+        elif db_record.validity == ValidityStatus.ABOLISHED.value:
+            return self._handle_abolished(result, db_record)
+
+        return self._set_not_found_result(result)
+
+    def _handle_number_not_matched(
+        self,
+        result: StandardMatchResult,
+        input_name: str,
+        input_number: str
+    ) -> StandardMatchResult:
+        """处理标准号未匹配的情况"""
+        # 尝试模糊匹配标准号
+        fuzzy_number_matches = self.repo.find_by_number_fuzzy(input_number)
+
+        if fuzzy_number_matches:
+            # 检查名称是否匹配
+            return self._check_name_in_records(result, fuzzy_number_matches, input_name)
+        else:
+            # 尝试直接按名称查询
+            return self._search_by_name_only(result, input_name)
+
+    def _check_name_in_records(
+        self,
+        result: StandardMatchResult,
+        records: List[StandardRecord],
+        input_name: str
+    ) -> StandardMatchResult:
+        """在一批记录中查找名称匹配"""
+        # 首先尝试精确匹配
+        for record in records:
+            if record.standard_name == input_name:
+                # 名称匹配，检查状态
+                if record.validity in [ValidityStatus.CURRENT.value, ValidityStatus.TRIAL.value]:
+                    return self._set_mismatch_result(result, record)
+                elif record.validity == ValidityStatus.ABOLISHED.value:
+                    return self._handle_abolished(result, record)
+
+        # 尝试模糊名称匹配（忽略空格和书名号）
+        for record in records:
+            if self._is_name_fuzzy_match(record.standard_name, input_name):
+                # 名称模糊匹配成功
+                if record.validity in [ValidityStatus.CURRENT.value, ValidityStatus.TRIAL.value]:
+                    return self._set_mismatch_result(result, record)
+                elif record.validity == ValidityStatus.ABOLISHED.value:
+                    return self._handle_abolished(result, record)
+
+        # 名称不匹配
+        return self._set_not_found_result(result)
+
+    def _search_by_name_only(
+        self,
+        result: StandardMatchResult,
+        input_name: str
+    ) -> StandardMatchResult:
+        """仅通过名称查询"""
+        # 精确匹配名称
+        name_match = self.repo.find_by_name_exact(input_name)
+
+        if name_match:
+            if name_match.validity in [ValidityStatus.CURRENT.value, ValidityStatus.TRIAL.value]:
+                return self._set_mismatch_result(result, name_match)
+            elif name_match.validity == ValidityStatus.ABOLISHED.value:
+                return self._set_not_found_result(result)
+
+        # 模糊匹配名称
+        fuzzy_matches = self.repo.find_by_name_fuzzy(input_name)
+
+        # 首先尝试精确匹配
+        exact_match = self._find_exact_name_match(fuzzy_matches, input_name)
+        if exact_match:
+            if exact_match.validity in [ValidityStatus.CURRENT.value, ValidityStatus.TRIAL.value]:
+                return self._set_mismatch_result(result, exact_match)
+
+        # 尝试模糊名称匹配（忽略空格、书名号等）
+        for match in fuzzy_matches:
+            if self._is_name_fuzzy_match(match.standard_name, input_name):
+                if match.validity in [ValidityStatus.CURRENT.value, ValidityStatus.TRIAL.value]:
+                    return self._set_mismatch_result(result, match)
+                elif match.validity == ValidityStatus.ABOLISHED.value:
+                    return self._handle_abolished(result, match)
+
+        return self._set_not_found_result(result)
+
+    def _handle_fuzzy_name_match(
+        self,
+        result: StandardMatchResult,
+        match_record: StandardRecord
+    ) -> StandardMatchResult:
+        """处理模糊名称匹配成功的情况"""
+        if match_record.validity in [ValidityStatus.CURRENT.value, ValidityStatus.TRIAL.value]:
+            return self._set_mismatch_result(result, match_record)
+        elif match_record.validity == ValidityStatus.ABOLISHED.value:
+            return self._handle_abolished(result, match_record)
+        return self._set_not_found_result(result)
+
+    def _handle_abolished(
+        self,
+        result: StandardMatchResult,
+        abolished_record: StandardRecord
+    ) -> StandardMatchResult:
+        """处理已废止标准的情况"""
+        # 查询同名现行标准作为替代
+        substitutes = self.repo.find_current_by_name(abolished_record.standard_name)
+
+        if substitutes:
+            # 有替代标准，取最新的（已按标准号降序）
+            latest = substitutes[0]
+            return self._set_substituted_result(result, latest)
+        else:
+            # 无替代标准
+            return self._set_abolished_result(result)
+
+    # ========== 格式化方法 ==========
+
+    def _format_standard_name(self, name: str) -> str:
+        """格式化标准名称，确保只有一个《》包裹"""
+        if not name:
+            return name
+        name = name.strip()
+        # 去除已有的书名号
+        while name.startswith('《'):
+            name = name[1:]
+        while name.endswith('》'):
+            name = name[:-1]
+        return f"《{name}》"
+
+    def _format_standard_number(self, number: str) -> str:
+        """格式化标准编号，确保用（）包裹"""
+        if not number:
+            return number
+        number = number.strip()
+        # 去除已有的括号
+        if number.startswith('(') or number.startswith('（'):
+            number = number[1:]
+        if number.endswith(')') or number.endswith('）'):
+            number = number[:-1]
+        return f"（{number}）"
+
+    # ========== 结果设置方法（每个方法职责单一） ==========
+
+    def _set_ok_result(self, result: StandardMatchResult) -> StandardMatchResult:
+        """设置状态正常的结果"""
+        result.process_result = "正常"
+        result.status_code = MatchResultCode.OK.value
+        result.final_result = "无问题"
+        return result
+
+    def _set_substituted_result(
+        self,
+        result: StandardMatchResult,
+        substitute: StandardRecord
+    ) -> StandardMatchResult:
+        """设置被替代的结果"""
+        result.substitute_name = self._format_standard_name(substitute.standard_name)
+        result.substitute_number = self._format_standard_number(substitute.standard_number)
+        result.process_result = "被替代"
+        result.status_code = MatchResultCode.SUBSTITUTED.value
+        result.final_result = (
+            f"{self._format_standard_name(result.original_name)}"
+            f"{self._format_standard_number(result.original_number)}已废止，"
+            f"替代{self._format_standard_name(substitute.standard_name)}"
+            f"{self._format_standard_number(substitute.standard_number)}"
+        )
+        return result
+
+    def _set_abolished_result(self, result: StandardMatchResult) -> StandardMatchResult:
+        """设置废止无替代的结果"""
+        result.process_result = "废止无现行"
+        result.status_code = MatchResultCode.ABOLISHED.value
+        result.final_result = (
+            f"{self._format_standard_name(result.original_name)}"
+            f"{self._format_standard_number(result.original_number)}已废止，无现行状态"
+        )
+        return result
+
+    def _set_mismatch_result(
+        self,
+        result: StandardMatchResult,
+        actual: StandardRecord
+    ) -> StandardMatchResult:
+        """设置不匹配的结果"""
+        result.substitute_name = self._format_standard_name(actual.standard_name)
+        result.substitute_number = self._format_standard_number(actual.standard_number)
+        result.process_result = "不匹配"
+        result.status_code = MatchResultCode.MISMATCH.value
+        result.final_result = (
+            f"{self._format_standard_name(result.original_name)}"
+            f"{self._format_standard_number(result.original_number)}"
+            f"与实际{self._format_standard_name(actual.standard_name)}"
+            f"{self._format_standard_number(actual.standard_number)}不匹配"
+        )
+        return result
+
+    def _set_not_found_result(self, result: StandardMatchResult) -> StandardMatchResult:
+        """设置不存在的结果"""
+        result.process_result = "标准库不存在"
+        result.status_code = MatchResultCode.NOT_FOUND.value
+        result.final_result = (
+            f"{self._format_standard_name(result.original_name)}"
+            f"{self._format_standard_number(result.original_number)}标准库不存在，请确认"
+        )
+        return result
+
+    # ========== 工具方法 ==========
+
+    def _is_name_fuzzy_match(self, name1: str, name2: str) -> bool:
+        """
+        判断两个标准名称是否模糊匹配
+        只去除书名号，保留中间空格（中间空格属于名称的一部分）
+        """
+        # 清理书名号，但保留中间空格
+        clean1 = name1.replace("《", "").replace("》", "")
+        clean2 = name2.replace("《", "").replace("》", "")
+        return clean1 == clean2
+
+    def _clean_brackets_and_booknames(self, text: str) -> str:
+        """
+        清洗字符串前后的书名号和括号
+        包括：《》()（）
+        """
+        if not text:
+            return text
+
+        # 循环去除前后的书名号和括号，直到没有变化
+        changed = True
+        while changed:
+            changed = False
+            original = text
+
+            # 去除前导的书名号和括号
+            if text.startswith("《"):
+                text = text[1:]
+                changed = True
+            if text.startswith("》"):
+                text = text[1:]
+                changed = True
+            if text.startswith("("):
+                text = text[1:]
+                changed = True
+            if text.startswith(")"):
+                text = text[1:]
+                changed = True
+            if text.startswith("（"):
+                text = text[1:]
+                changed = True
+            if text.startswith("）"):
+                text = text[1:]
+                changed = True
+
+            # 去除尾随的书名号和括号
+            if text.endswith("《"):
+                text = text[:-1]
+                changed = True
+            if text.endswith("》"):
+                text = text[:-1]
+                changed = True
+            if text.endswith("("):
+                text = text[:-1]
+                changed = True
+            if text.endswith(")"):
+                text = text[:-1]
+                changed = True
+            if text.endswith("（"):
+                text = text[:-1]
+                changed = True
+            if text.endswith("）"):
+                text = text[:-1]
+                changed = True
+
+            # 如果文本变空了，停止循环
+            if not text:
+                break
+
+        return text
+
+    def _find_exact_name_match(
+        self,
+        records: List[StandardRecord],
+        target_name: str
+    ) -> Optional[StandardRecord]:
+        """在记录列表中查找精确名称匹配"""
+        for record in records:
+            if record.standard_name == target_name:
+                return record
+        return None
+
+
+class StandardMatchingService:
+    """
+    标准库匹配服务
+    对外暴露的统一接口
+    """
+
+    def __init__(self, db_pool=None, own_db_pool: bool = False):
+        """
+        初始化服务
+
+        Args:
+            db_pool: 数据库连接池（必填，不再支持Mock模式）
+            own_db_pool: 是否拥有连接池的所有权（为True时close()会关闭连接池）
+
+        Raises:
+            RuntimeError: 初始化时如果db_pool为None会抛出异常
+        """
+        if not db_pool:
+            raise RuntimeError(
+                "StandardMatchingService 初始化失败: 必须提供数据库连接池(db_pool)。\n"
+                "Mock模式已取消，请确保数据库连接正常。"
+            )
+        self.db_pool = db_pool
+        self._own_db_pool = own_db_pool  # 标记是否拥有连接池所有权
+        self.repository = StandardRepository()
+        self.matcher = StandardMatcher(self.repository)
+        self._initialized = False
+
+    async def initialize(self):
+        """
+        初始化：从数据库加载数据到内存
+        只需要执行一次
+
+        Raises:
+            RuntimeError: 当数据库连接池为None时抛出异常（已取消Mock模式）
+        """
+        if self._initialized:
+            return
+
+        if not self.db_pool:
+            raise RuntimeError(
+                "标准匹配服务初始化失败: 数据库连接池(db_pool)为None。\n"
+                "请检查：\n"
+                "  1. MySQL数据库配置是否正确\n"
+                "  2. 数据库服务是否正常运行\n"
+                "  3. 网络连接是否正常"
+            )
+
+        # 从真实数据库加载
+        from .standard_dao import StandardDAO
+        dao = StandardDAO(self.db_pool)
+        raw_data = await dao.load_all_standards()
+        logger.info(f"从数据库加载标准数据: {len(raw_data)} 条")
+
+        self.repository.load_data(raw_data)
+        self._initialized = True
+        logger.info("标准匹配服务初始化完成")
+
+    async def close(self):
+        """关闭服务，清理资源"""
+        # 只有当拥有连接池所有权时才关闭连接池
+        if self._own_db_pool and self.db_pool:
+            await self.db_pool.close()
+        self._initialized = False
+
+    def check_standards(self, standards: List[Dict[str, str]]) -> List[StandardMatchResult]:
+        """
+        批量检查标准列表
+
+        Args:
+            standards: 标准列表，每个元素包含:
+                - standard_name: 标准名称(原始)
+                - standard_number: 标准号(原始)
+
+        Returns:
+            List[StandardMatchResult]: 匹配结果列表
+        """
+        if not self._initialized:
+            raise RuntimeError("服务未初始化，请先调用 initialize()")
+
+        results = []
+        for idx, std in enumerate(standards, start=1):
+            result = self.matcher.match(
+                seq_no=idx,
+                input_name=std.get("standard_name", ""),
+                input_number=std.get("standard_number", "")
+            )
+            results.append(result)
+        return results
+
+    def check_single(
+        self,
+        seq_no: int,
+        standard_name: str,
+        standard_number: str
+    ) -> StandardMatchResult:
+        """
+        检查单个标准
+
+        Args:
+            seq_no: 序号
+            standard_name: 标准名称
+            standard_number: 标准号
+
+        Returns:
+            StandardMatchResult: 匹配结果
+        """
+        if not self._initialized:
+            raise RuntimeError("服务未初始化，请先调用 initialize()")
+
+        return self.matcher.match(seq_no, standard_name, standard_number)
+
+
+# 全局服务实例（单例模式）
+_standard_matching_service: Optional[StandardMatchingService] = None
+
+
+async def get_standard_matching_service(db_pool=None) -> StandardMatchingService:
+    """
+    获取标准匹配服务实例（单例模式）
+
+    Args:
+        db_pool: 数据库连接池（必填）
+
+    Returns:
+        StandardMatchingService: 标准匹配服务实例
+
+    Raises:
+        RuntimeError: 当db_pool为None时抛出异常（已取消Mock模式）
+    """
+    if not db_pool:
+        raise RuntimeError(
+            "获取标准匹配服务失败: 必须提供数据库连接池(db_pool)。\n"
+            "Mock模式已取消，请确保数据库连接正常。"
+        )
+
+    global _standard_matching_service
+    if _standard_matching_service is None:
+        _standard_matching_service = StandardMatchingService(db_pool)
+        await _standard_matching_service.initialize()
+    return _standard_matching_service
+
+
+def reset_standard_matching_service():
+    """重置标准匹配服务实例（主要用于测试）"""
+    global _standard_matching_service
+    _standard_matching_service = None

core/construction_review/workflows/ai_review_workflow.py

@@ -75,7 +75,7 @@ class AIReviewWorkflow:
     """基于LangGraph的AI审查工作流"""
 
     def __init__(self, task_file_info: TaskFileInfo, structured_content: Dict[str, Any],
-                 progress_manager=None, max_review_units: int = None, review_mode: str = "all"):
+                 progress_manager=None, max_review_units: int = None, review_mode: str = "all", db_pool=None):
         """
         初始化AI审查工作流
 
@@ -85,13 +85,14 @@ class AIReviewWorkflow:
             progress_manager: 进度管理器
             max_review_units: 最大审查单元数量（None表示审查所有）
             review_mode: 审查模式 ("all"=全部, "first"=前N个, "random"=随机N个)
+            db_pool: 数据库连接池（用于时效性审查等新逻辑）
         """
         # 工作流超时时间定义
         self.WORKFLOW_TIMEOUT = 3600
 
         # 任务文件信息
         self.task_info = task_file_info
-        
+
         self.file_id = task_file_info.file_id
         self.callback_task_id = task_file_info.callback_task_id
         self.user_id = task_file_info.user_id
@@ -101,8 +102,8 @@ class AIReviewWorkflow:
         self.structured_content = structured_content
         self.progress_manager = progress_manager
 
-        # 传递 TaskFileInfo 实例
-        self.ai_review_engine = AIReviewEngine(task_file_info)
+        # 传递 TaskFileInfo 实例和 db_pool
+        self.ai_review_engine = AIReviewEngine(task_file_info, db_pool=db_pool)
 
         # 初始化核心功能和工具类
         self.core_fun = AIReviewCoreFun(task_file_info, self.ai_review_engine, max_review_units, review_mode)
@@ -302,10 +303,29 @@ class AIReviewWorkflow:
 
             # 获取审查项配置
             review_item_config_raw = self.task_info.get_review_item_config_list()
-            
+
             # 将review_item_config中的值拆分成chapter_code和func_name 如{['basis':["sensitive_word_check"，"timeliness_basis_reviewer"]]}
             review_item_config = self.core_fun._replace_review_suffix(review_item_config_raw, review_func_mapping)
-            
+
+            # 【新增】处理时效性审查的章节映射：
+            # - basis 章节使用 timeliness_basis_reviewer（编制依据时效性）
+            # - 其他章节使用 timeliness_content_reviewer（内容时效性）
+            processed_config = []
+            for item in review_item_config:
+                if '_' in item:
+                    chapter_code, func_name = item.split('_', 1)
+                    # 如果是时效性审查，根据章节选择正确的审查器
+                    if func_name == 'timeliness_basis_reviewer':
+                        if chapter_code == 'basis':
+                            # basis 章节保持使用 timeliness_basis_reviewer
+                            processed_config.append(item)
+                        else:
+                            # 其他章节使用 timeliness_content_reviewer
+                            processed_config.append(f"{chapter_code}_timeliness_content_reviewer")
+                        continue
+                processed_config.append(item)
+            review_item_config = processed_config
+
             # 根据标准配置对review_item_config进行排序
             review_item_dict_sorted = self.core_fun._check_item_mapping_order(review_item_config)
             logger.info(f"审查项配置解析完成: {review_item_dict_sorted}")

test_content_timeliness.py

@@ -1,141 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""
-测试内容时效性审查是否正确处理 JTG B01-2011 的情况
-"""
-
-import json
-import asyncio
-from core.construction_review.component.reviewers.timeliness_content_reviewer import (
-    StandardExtractor, ContentTimelinessReviewer
-)
-
-# 测试数据 - 模拟 problem.json 中的情况
-test_tertiary_details = [
-    {
-        "third_category_name": "国家方针、政策、标准和设计文件",
-        "third_category_code": "NationalPoliciesStandardsAndDesignDocument",
-        "start_line": 80,
-        "end_line": 82,
-        "content": """<80> 国家方针、政策、标准和设计文件
-<81> 《公路工程技术标准》（JTG B01-2011）
-<82> 《公路桥涵设计通用规范》（JTG D60-2015）"""
-    }
-]
-
-# 测试提取器
-def test_extractor():
-    print("=" * 60)
-    print("测试规范提取器")
-    print("=" * 60)
-
-    extractor = StandardExtractor()
-
-    for detail in test_tertiary_details:
-        refs = extractor.extract_from_content(detail["content"])
-        print(f"\n从 '{detail['third_category_name']}' 提取到 {len(refs)} 个规范引用:")
-        for ref in refs:
-            print(f"  - 原始文本: {ref.original_text}")
-            print(f"    名称: {ref.name}")
-            print(f"    编号: {ref.number}")
-            print(f"    上下文: {ref.context[:100]}...")
-
-    return refs
-
-# 测试过滤逻辑
-def test_filter_logic():
-    print("\n" + "=" * 60)
-    print("测试过滤逻辑")
-    print("=" * 60)
-
-    # 模拟 match_reference_files 返回的数据
-    mock_match_result = [
-        {
-            "review_item": "《公路工程技术标准》（JTG B01-2011）",
-            "has_related_file": True,
-            "has_exact_match": False,
-            "exact_match_info": "",
-            "same_name_current": "《公路工程技术标准》（JTG B01-2014）状态为现行"
-        },
-        {
-            "review_item": "《公路桥涵设计通用规范》（JTG D60-2015）",
-            "has_related_file": True,
-            "has_exact_match": True,
-            "exact_match_info": "《公路桥涵设计通用规范》（JTG D60-2015）状态为现行",
-            "same_name_current": ""
-        }
-    ]
-
-    print("\n模拟 match_reference_files 返回数据:")
-    for idx, item in enumerate(mock_match_result):
-        print(f"\n  项{idx}:")
-        print(f"    review_item: {item['review_item']}")
-        print(f"    has_related_file: {item['has_related_file']}")
-        print(f"    has_exact_match: {item['has_exact_match']}")
-        print(f"    exact_match_info: {item['exact_match_info']}")
-        print(f"    same_name_current: {item['same_name_current']}")
-
-    # 测试旧过滤逻辑（只保留 exact_match_info 不为空的）
-    old_filtered = [item for item in mock_match_result if item.get('exact_match_info')]
-    print(f"\n旧过滤逻辑（只保留 exact_match_info 不为空的）: {len(old_filtered)} 个项")
-    for item in old_filtered:
-        print(f"  - {item['review_item']}")
-
-    # 测试新过滤逻辑（保留有相关信息的）
-    new_filtered = [
-        item for item in mock_match_result
-        if item.get('has_related_file') or
-           item.get('exact_match_info') or
-           item.get('same_name_current')
-    ]
-    print(f"\n新过滤逻辑（保留有相关信息的）: {len(new_filtered)} 个项")
-    for item in new_filtered:
-        print(f"  - {item['review_item']}")
-
-    # 分析差异
-    missed = [item for item in mock_match_result if item not in old_filtered]
-    if missed:
-        print(f"\n[警告] 旧逻辑漏检的项:")
-        for item in missed:
-            print(f"  - {item['review_item']}")
-            print(f"    has_related_file: {item['has_related_file']}")
-            print(f"    same_name_current: {item['same_name_current']}")
-
-# 完整测试
-async def test_full_review():
-    print("\n" + "=" * 60)
-    print("完整审查测试（需要 Milvus 连接）")
-    print("=" * 60)
-
-    try:
-        async with ContentTimelinessReviewer(max_concurrent=4) as reviewer:
-            results = await reviewer.review_tertiary_content(
-                tertiary_details=test_tertiary_details,
-                collection_name="first_bfp_collection_status"
-            )
-
-            print(f"\n审查完成，共 {len(results)} 个结果:")
-            for idx, result in enumerate(results):
-                print(f"\n  结果{idx}:")
-                print(f"    check_item: {result.get('check_item')}")
-                print(f"    exist_issue: {result.get('exist_issue')}")
-                print(f"    risk_info: {result.get('risk_info')}")
-                check_result = result.get('check_result', {})
-                print(f"    issue_point: {check_result.get('issue_point')}")
-                print(f"    suggestion: {check_result.get('suggestion')}")
-                print(f"    reason: {check_result.get('reason')}")
-
-    except Exception as e:
-        print(f"测试失败: {e}")
-        import traceback
-        traceback.print_exc()
-
-if __name__ == "__main__":
-    # 测试提取器
-    refs = test_extractor()
-
-    # 测试过滤逻辑
-    test_filter_logic()
-
-    # 完整测试（可选）
-    # asyncio.run(test_full_review())

utils_test/Chunk_Split_Test/test_chunk_split_batch.py

@@ -0,0 +1,334 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+文档切分修复批量验证测试
+
+测试目标：批量验证多个 PDF 中最后一章是否被正确提取，无跨章节泄漏。
+"""
+
+import json
+import os
+import sys
+import traceback
+from datetime import datetime
+from pathlib import Path
+
+# 添加项目根目录到路径
+project_root = Path(__file__).parent.parent.parent
+sys.path.insert(0, str(project_root))
+
+from core.construction_review.component.doc_worker.pipeline import PipelineComponents, DefaultDocumentPipeline, DefaultFileParseFacade
+from core.construction_review.component.doc_worker.config.provider import default_config_provider
+from core.construction_review.component.doc_worker.pdf_worker.toc_extractor import PdfTOCExtractor
+from core.construction_review.component.doc_worker.classification.hierarchy_classifier import HierarchyClassifier
+from core.construction_review.component.doc_worker.pdf_worker.fulltext_extractor import PdfFullTextExtractor
+from core.construction_review.component.doc_worker.pdf_worker.text_splitter import PdfTextSplitter
+from core.construction_review.component.doc_worker.pdf_worker.json_writer import PdfJsonResultWriter
+
+
+TEST_DIR = Path("D:/wx_work/sichuan_luqiao/lu_sgsc_testfile")
+
+TEST_FILES = [
+    # 必须包含
+    Path("utils_test/Chunk_Split_Test/标准结构测试文件.pdf").resolve(),
+    # 代表性施工方案（按推荐优先级排序）
+    TEST_DIR / "测试模版-四川路桥专项施工方案框架以及编制说明（2025修订第三版）- v0.2.pdf",
+    TEST_DIR / "成渝扩容桥梁下部结构专项施工方案（正式版）(1).pdf",
+    TEST_DIR / "达州绕西高速西段RX2标段人工挖孔桩施工方案(2).pdf",
+    TEST_DIR / "高处作业安全带、防坠器系挂方案.2026.1.5改.pdf",
+    TEST_DIR / "四川智能建造科技股份有限公司G999线大源至中和高速公路TJ5项目经理部龙泉山左线特大桥T梁安装专项施工方案.pdf",
+    TEST_DIR / "主线天桥现浇箱梁支模体系（满堂支架）安全专项施工方案(1).pdf",
+]
+
+
+def build_test_facade():
+    components = PipelineComponents(
+        config=default_config_provider,
+        toc_extractor=PdfTOCExtractor(),
+        classifier=HierarchyClassifier(),
+        fulltext_extractor=PdfFullTextExtractor(),
+        splitter=PdfTextSplitter(),
+        writers=[PdfJsonResultWriter()],
+        chunk_classifier=None,
+    )
+    pipeline = DefaultDocumentPipeline(components)
+    return DefaultFileParseFacade(pipeline)
+
+
+def locate_existing_files() -> list[Path]:
+    existing = []
+    for p in TEST_FILES:
+        if p.exists():
+            existing.append(p)
+        else:
+            print(f"[SKIP] 文件不存在，跳过: {p}")
+    return existing
+
+
+def run_pipeline(file_path: Path, facade) -> dict:
+    print(f"\n[INFO] 正在处理: {file_path.name}")
+    result = facade.process_file(
+        file_path=file_path,
+        target_level=None,
+        max_chunk_size=None,
+        min_chunk_size=None,
+        output_dir=None,
+    )
+    return result
+
+
+def analyze_file(file_path: Path, result: dict) -> dict:
+    chunks = result.get("chunks") or []
+    toc_info = result.get("toc_info") or {}
+    toc_items = toc_info.get("toc_items") or []
+
+    section_labels = sorted({c.get("section_label", "UNKNOWN") for c in chunks})
+
+    # 一级章节标签：section_label 中不含 "->" 的部分
+    first_level_labels = []
+    for label in section_labels:
+        if "->" in label:
+            first = label.split("->")[0].strip()
+            if first not in first_level_labels:
+                first_level_labels.append(first)
+        else:
+            if label.strip() not in first_level_labels:
+                first_level_labels.append(label.strip())
+
+    # 找目录中 level=1 的最后一个章节
+    level1_items = [item for item in toc_items if item.get("level") == 1]
+    last_level1_item = level1_items[-1] if level1_items else None
+    last_level1_title = last_level1_item.get("title", "").strip() if last_level1_item else ""
+    last_level1_page = last_level1_item.get("page") if last_level1_item else None
+
+    # 判断最后一章是否有对应 chunk（模糊匹配标题）
+    def normalize(t: str) -> str:
+        return t.replace(" ", "").replace("\u3000", "").strip()
+
+    last_chapter_found = False
+    matched_label = None
+    if last_level1_title:
+        norm_target = normalize(last_level1_title)
+        for label in first_level_labels:
+            if norm_target in normalize(label) or normalize(label) in norm_target:
+                last_chapter_found = True
+                matched_label = label
+                break
+
+    # 检查最后一章 page 是否明显大于目录页范围（简单：page > toc_page + 2）
+    toc_page = toc_info.get("toc_page") or 1
+    try:
+        toc_page = int(toc_page)
+    except (ValueError, TypeError):
+        toc_page = 1
+    page_reasonable = False
+    if last_level1_page is not None:
+        try:
+            page_reasonable = int(last_level1_page) > toc_page + 2
+        except (ValueError, TypeError):
+            page_reasonable = False
+
+    # 检查跨章节泄漏
+    leak_detected = False
+    leak_details = []
+    if len(first_level_labels) >= 2 and last_level1_title:
+        # 倒数第二个一级章节
+        prev_first = first_level_labels[-2] if len(first_level_labels) >= 2 else None
+        if prev_first:
+            # 该一级章节下的所有 chunk（包含其二级节）中的最后一个 chunk
+            prev_chunks = [c for c in chunks if c.get("section_label", "").startswith(prev_first)]
+            if prev_chunks:
+                last_prev_chunk = prev_chunks[-1]
+                content = (last_prev_chunk.get("review_chunk_content", "") or "") + (last_prev_chunk.get("content", "") or "")
+                # 用最后一章标题的几个关键词检查是否混入
+                keywords = [k for k in last_level1_title.split() if len(k) >= 2]
+                if not keywords:
+                    keywords = [last_level1_title]
+                for kw in keywords:
+                    if kw in content:
+                        leak_detected = True
+                        leak_details.append({
+                            "chunk_id": last_prev_chunk.get("chunk_id"),
+                            "section_label": last_prev_chunk.get("section_label"),
+                            "keyword": kw,
+                        })
+
+    # 特殊情形：如果完全没有识别出章节标题（只有 fallback 的 "正文" chunk），
+    # 说明 toc_extractor 可能将正文页误判为目录页，导致 title_matcher 过滤掉所有匹配。
+    # 这与本次 "第十章被吞并" 的修复无关，单独标记。
+    if len(chunks) == 1 and len(section_labels) == 1 and section_labels[0] == "正文":
+        return {
+            "filename": file_path.name,
+            "total_chunks": len(chunks),
+            "total_level1": 0,
+            "last_level1_title": last_level1_title,
+            "last_level1_page": last_level1_page,
+            "last_chapter_found": False,
+            "last_chapter_label": None,
+            "page_reasonable": False,
+            "toc_page": toc_page,
+            "leak_detected": False,
+            "leak_details": [],
+            "section_labels": section_labels,
+            "return_code": 1,
+            "reasons": ["未能识别任何章节标题（可能目录页范围误判），无法评估切分修复效果"],
+        }
+
+    # 返回码判定
+    ret = 0
+    reasons = []
+    if not last_chapter_found:
+        ret = 1
+        reasons.append("最后一章未找到对应 chunk")
+    if not page_reasonable:
+        ret = 1
+        reasons.append("最后一章页码可能异常（落在目录页附近）")
+    if leak_detected:
+        ret = 1
+        reasons.append("发现跨章节内容泄漏")
+
+    return {
+        "filename": file_path.name,
+        "total_chunks": len(chunks),
+        "total_level1": len(first_level_labels),
+        "last_level1_title": last_level1_title,
+        "last_level1_page": last_level1_page,
+        "last_chapter_found": last_chapter_found,
+        "last_chapter_label": matched_label,
+        "page_reasonable": page_reasonable,
+        "toc_page": toc_page,
+        "leak_detected": leak_detected,
+        "leak_details": leak_details,
+        "section_labels": section_labels,
+        "return_code": ret,
+        "reasons": reasons,
+    }
+
+
+def print_summary(reports: list[dict]) -> str:
+    lines = []
+    lines.append("\n" + "=" * 80)
+    lines.append("批量切分测试汇总")
+    lines.append("=" * 80)
+
+    passed = 0
+    failed = 0
+    for r in reports:
+        status = "PASS" if r["return_code"] == 0 else "FAIL"
+        if r["return_code"] == 0:
+            passed += 1
+        else:
+            failed += 1
+        lines.append(f"\n文件: {r['filename']}")
+        lines.append(f"  状态: {status}")
+        lines.append(f"  总 chunk 数: {r['total_chunks']}")
+        lines.append(f"  总一级章节数: {r['total_level1']}")
+        lines.append(f"  最后一章标题: {r['last_level1_title']}")
+        lines.append(f"  最后一章页码: {r['last_level1_page']}")
+        lines.append(f"  最后一章提取成功: {r['last_chapter_found']} ({r['last_chapter_label'] or 'N/A'})")
+        lines.append(f"  页码合理: {r['page_reasonable']} (目录页={r['toc_page']})")
+        lines.append(f"  跨章节泄漏: {r['leak_detected']}")
+        if r["leak_details"]:
+            for d in r["leak_details"]:
+                lines.append(f"    -> {d['chunk_id']} ({d['section_label']}) 包含 '{d['keyword']}'")
+        if r["reasons"]:
+            lines.append(f"  不通过原因: {'; '.join(r['reasons'])}")
+
+    lines.append("\n" + "-" * 80)
+    lines.append(f"汇总: {passed} 通过, {failed} 失败 / 总计 {len(reports)} 个文件")
+    lines.append("=" * 80)
+    summary = "\n".join(lines)
+    print(summary)
+    return summary
+
+
+def main() -> int:
+    files = locate_existing_files()
+    if not files:
+        print("[ERROR] 没有可用的测试文件。")
+        return 1
+
+    facade = build_test_facade()
+    reports = []
+    errors = []
+
+    for fp in files:
+        try:
+            result = run_pipeline(fp, facade)
+            report = analyze_file(fp, result)
+            reports.append(report)
+        except Exception as e:
+            print(f"[ERROR] 处理失败: {fp.name} -> {e}")
+            traceback.print_exc()
+            errors.append({"filename": fp.name, "error": str(e)})
+
+    summary = print_summary(reports)
+
+    # 写出报告和中间 JSON
+    out_dir = Path(__file__).parent
+    md_path = out_dir / "batch_test_report.md"
+    json_path = out_dir / "batch_test_result.json"
+
+    with open(json_path, "w", encoding="utf-8") as f:
+        json.dump({
+            "timestamp": datetime.now().isoformat(),
+            "reports": reports,
+            "errors": errors,
+        }, f, ensure_ascii=False, indent=2)
+    print(f"[INFO] JSON 结果已保存: {json_path}")
+
+    md_content = f"""# 文档切分修复批量测试报告
+
+生成时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+
+## 测试文件列表
+
+"""
+    for fp in files:
+        md_content += f"- `{fp.name}`\n"
+
+    md_content += "\n## 详细结果\n\n"
+    for r in reports:
+        status = "PASS" if r["return_code"] == 0 else "FAIL"
+        md_content += f"### {r['filename']} — {status}\n\n"
+        md_content += f"- 总 chunk 数: {r['total_chunks']}\n"
+        md_content += f"- 总一级章节数: {r['total_level1']}\n"
+        md_content += f"- 最后一章标题: {r['last_level1_title']}\n"
+        md_content += f"- 最后一章页码: {r['last_level1_page']}\n"
+        md_content += f"- 最后一章提取成功: {'是' if r['last_chapter_found'] else '否'} (`{r['last_chapter_label'] or 'N/A'}`)\n"
+        md_content += f"- 页码合理: {'是' if r['page_reasonable'] else '否'} (目录页={r['toc_page']})\n"
+        md_content += f"- 跨章节泄漏: {'是' if r['leak_detected'] else '否'}\n"
+        if r["leak_details"]:
+            md_content += "  泄漏详情:\n"
+            for d in r["leak_details"]:
+                md_content += f"  - `{d['chunk_id']}` (`{d['section_label']}`) 包含关键词 `{d['keyword']}`\n"
+        if r["reasons"]:
+            md_content += f"- 不通过原因: **{'；'.join(r['reasons'])}**\n"
+        md_content += "\n"
+
+    if errors:
+        md_content += "## 运行错误\n\n"
+        for e in errors:
+            md_content += f"- `{e['filename']}`: {e['error']}\n"
+        md_content += "\n"
+
+    total = len(reports)
+    passed = sum(1 for r in reports if r["return_code"] == 0)
+    failed = total - passed
+    md_content += f"""## 汇总
+
+- 通过: {passed}
+- 失败: {failed}
+- 总计: {total}
+- 运行错误: {len(errors)}
+"""
+
+    with open(md_path, "w", encoding="utf-8") as f:
+        f.write(md_content)
+    print(f"[INFO] Markdown 报告已保存: {md_path}")
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

utils_test/Chunk_Split_Test/test_chunk_split_fix.py

@@ -0,0 +1,255 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+文档切分模块修复验证测试
+
+测试目标：验证 "第十章 其他资料" 内容不会被错误合并到 "第九章 验收要求->五、验收人员" 中。
+
+问题根因：
+- `title_matcher.find_title_positions` 只取第一个匹配，导致第十章标题被错误定位到目录页（page 6）。
+- 真正的第十章（page 46）未被发现，第九章成为最后一项，content_block 延伸到全文末尾。
+- "计算书"、"相关施工图纸"、"编制及审核人员情况" 全部被合并进 doc_chunk_第九章->五_1。
+
+修复点：
+1. title_matcher.py：支持多位置匹配，结合 toc_page 页码择优。
+2. text_splitter.py：增加 all_toc_items 硬边界保护，防止 content_block 跨章节溢出。
+
+运行方式：
+  python utils_test/Chunk_Split_Test/test_chunk_split_fix.py
+
+可选环境变量：
+  TEST_PDF_PATH=xxx.pdf  指定自定义 PDF 测试文档
+"""
+
+import json
+import os
+import sys
+from pathlib import Path
+
+# 添加项目根目录到路径
+project_root = Path(__file__).parent.parent.parent
+sys.path.insert(0, str(project_root))
+
+from core.construction_review.component.doc_worker.pipeline import PipelineComponents, DefaultDocumentPipeline, DefaultFileParseFacade
+from core.construction_review.component.doc_worker.config.provider import default_config_provider
+from core.construction_review.component.doc_worker.pdf_worker.toc_extractor import PdfTOCExtractor
+from core.construction_review.component.doc_worker.classification.hierarchy_classifier import HierarchyClassifier
+from core.construction_review.component.doc_worker.pdf_worker.fulltext_extractor import PdfFullTextExtractor
+from core.construction_review.component.doc_worker.pdf_worker.text_splitter import PdfTextSplitter
+from core.construction_review.component.doc_worker.pdf_worker.json_writer import PdfJsonResultWriter
+
+
+# 默认测试文档：四川路桥测试模版 PDF（注意：doc_worker CLI 目前仅支持 PDF）
+DEFAULT_TEST_PDF = Path("D:/wx_work/sichuan_luqiao/lu_sgsc_testfile/测试模版-四川路桥专项施工方案框架以及编制说明（2025修订第三版）- v0.2.pdf")
+ALTERNATIVE_TEST_DOCX = project_root / "utils_test" / "Completeness_Test" / "测试模版-四川路桥专项施工方案框架以及编制说明（2025修订第三版）- v0.2.docx"
+
+
+def build_test_facade():
+    """
+    构建一个轻量级 facade：
+    - 跳过 chunk 分类（避免大量 LLM 调用）
+    - 使用 PyMuPDF 纯本地提取（避免 MinerU OCR 的耗时网络调用）
+    """
+    components = PipelineComponents(
+        config=default_config_provider,
+        toc_extractor=PdfTOCExtractor(),
+        classifier=HierarchyClassifier(),
+        fulltext_extractor=PdfFullTextExtractor(),  # 纯本地，速度远快于 Hybrid/MinerU
+        splitter=PdfTextSplitter(),
+        writers=[PdfJsonResultWriter()],
+        chunk_classifier=None,  # 关键：跳过二级/三级分类
+    )
+    pipeline = DefaultDocumentPipeline(components)
+    return DefaultFileParseFacade(pipeline)
+
+
+def locate_test_file() -> Path | None:
+    """定位可用的测试文档。"""
+    custom = os.environ.get("TEST_PDF_PATH")
+    if custom:
+        p = Path(custom)
+        if p.exists():
+            return p
+        print(f"[WARN] 自定义测试文件不存在: {p}")
+
+    if DEFAULT_TEST_PDF.exists():
+        return DEFAULT_TEST_PDF
+
+    # 如果只有 docx，提示用户
+    if ALTERNATIVE_TEST_DOCX.exists():
+        print(f"[WARN] 找到 docx 版本但 pdf_worker 暂不支持 docx: {ALTERNATIVE_TEST_DOCX}")
+        print(f"[HINT] 请将 docx 另存为 PDF 后放到: {DEFAULT_TEST_PDF}")
+
+    return None
+
+
+def run_pipeline(file_path: Path) -> dict:
+    """运行 doc_worker 管线，返回结果。"""
+    print(f"\n[INFO] 正在处理文档: {file_path}")
+    print("[INFO] 使用测试 facade（仅 TOC + 一级分类 + 切分，跳过 chunk 级 LLM 分类）")
+
+    facade = build_test_facade()
+    result = facade.process_file(
+        file_path=file_path,
+        target_level=None,      # 使用配置默认值
+        max_chunk_size=None,
+        min_chunk_size=None,
+        output_dir=None,
+    )
+    return result
+
+
+def analyze_chunks(result: dict) -> dict:
+    """分析 chunks 结构，提取关键指标。"""
+    chunks = result.get("chunks", []) or []
+    toc_info = result.get("toc_info", {}) or {}
+    classification = result.get("classification", {}) or {}
+
+    # 按 section_label 分组
+    section_to_chunks: dict[str, list[dict]] = {}
+    for chunk in chunks:
+        label = chunk.get("section_label", "UNKNOWN")
+        section_to_chunks.setdefault(label, []).append(chunk)
+
+    # 定位关键 chunk
+    chapter_10_chunks = [c for c in chunks if "第十章" in c.get("section_label", "")]
+    chapter_9_last_chunks = [c for c in chunks if c.get("section_label", "").startswith("第九章")]
+
+    # 找 "第九章->五" 的 chunk（问题原型的重灾区）
+    nine_five_chunks = section_to_chunks.get("第九章 验收要求->五、 验收人员", [])
+
+    # 提取 "计算书" 等关键词是否出现在不该出现的位置
+    leak_keywords = ["计算书", "相关施工图纸", "编制及审核人员情况"]
+    leaks: list[dict] = []
+    for chunk in chunks:
+        label = chunk.get("section_label", "")
+        if "第九章" in label and "验收人员" in label:
+            content = chunk.get("review_chunk_content", "") + chunk.get("content", "")
+            for kw in leak_keywords:
+                if kw in content:
+                    leaks.append({"chunk_id": chunk.get("chunk_id"), "section_label": label, "keyword": kw})
+
+    return {
+        "total_chunks": len(chunks),
+        "toc_count": toc_info.get("toc_count", 0),
+        "target_level": classification.get("target_level"),
+        "section_labels": sorted(section_to_chunks.keys()),
+        "chapter_10_chunks": chapter_10_chunks,
+        "chapter_9_last_chunks": chapter_9_last_chunks,
+        "nine_five_chunks": nine_five_chunks,
+        "leaks": leaks,
+        "chunks": chunks,
+    }
+
+
+def print_report(report: dict) -> None:
+    """打印readable报告。"""
+    print("\n" + "=" * 80)
+    print("文档切分修复验证报告")
+    print("=" * 80)
+    print(f"总 chunk 数: {report['total_chunks']}")
+    print(f"目录项数: {report['toc_count']}")
+    print(f"切分目标层级: {report['target_level']}")
+
+    print("\n[SECTION_LABEL 列表]")
+    for label in report["section_labels"]:
+        print(f"  - {label}")
+
+    print("\n[第十章相关 chunks]")
+    if report["chapter_10_chunks"]:
+        for c in report["chapter_10_chunks"]:
+            print(f"  {c.get('chunk_id')} | {c.get('section_label')} | page={c.get('element_tag', {}).get('page')}")
+    else:
+        print("  (无) —— 严重异常！")
+
+    print("\n[第九章 验收人员 chunks]")
+    if report["nine_five_chunks"]:
+        for c in report["nine_five_chunks"]:
+            print(f"  {c.get('chunk_id')} | {c.get('section_label')} | page={c.get('element_tag', {}).get('page')}")
+    else:
+        print("  (无)")
+
+    print("\n[内容泄漏检查]")
+    if report["leaks"]:
+        print("  FAIL —— 发现第十章关键词出现在第九章 chunk 中！")
+        for leak in report["leaks"]:
+            print(f"    -> {leak['chunk_id']} ({leak['section_label']}) 包含 '{leak['keyword']}'")
+    else:
+        print("  PASS —— 未发现跨章节内容泄漏。")
+
+    print("\n[断言检查]")
+    passed = 0
+    failed = 0
+
+    # 断言1: 必须存在第十章的 chunk
+    labels = report["section_labels"]
+    chapter_10_exists = any("第十章" in l for l in labels)
+    if chapter_10_exists:
+        print("  [PASS] 存在 section_label 包含 '第十章' 的 chunk")
+        passed += 1
+    else:
+        print("  [FAIL] 未找到任何 section_label 包含 '第十章' 的 chunk")
+        failed += 1
+
+    # 断言2: 第九章->五 不应该包含第十章关键词
+    if not report["leaks"]:
+        print("  [PASS] 第九章->五 未包含第十章专属关键词")
+        passed += 1
+    else:
+        print("  [FAIL] 第九章->五 包含第十章专属关键词")
+        failed += 1
+
+    # 断言3: 第十章不应该有 page=6 的异常 chunk
+    abnormal_page_6 = [
+        c for c in report["chapter_10_chunks"]
+        if c.get("element_tag", {}).get("page") == 6
+    ]
+    if not abnormal_page_6:
+        print("  [PASS] 未发现 page=6 的异常第十章 chunk")
+        passed += 1
+    else:
+        print(f"  [FAIL] 发现 {len(abnormal_page_6)} 个 page=6 的异常第十章 chunk")
+        for c in abnormal_page_6:
+            print(f"       {c.get('chunk_id')} | {c.get('section_label')}")
+        failed += 1
+
+    print(f"\n结果: {passed} 通过, {failed} 失败")
+    print("=" * 80)
+
+
+def main() -> int:
+    test_file = locate_test_file()
+    if not test_file:
+        print("[ERROR] 未找到可用的测试 PDF 文档。")
+        print(f"[INFO] 请通过环境变量指定: TEST_PDF_PATH=xxx.pdf python {__file__}")
+        return 1
+
+    result = run_pipeline(test_file)
+    report = analyze_chunks(result)
+    print_report(report)
+
+    # 写出中间结果，方便后续人工排查
+    output_path = Path(__file__).parent / "last_test_result.json"
+    with open(output_path, "w", encoding="utf-8") as f:
+        # 只保留可读的关键字段
+        dump_data = {
+            "source": str(test_file),
+            "section_labels": report["section_labels"],
+            "chunks_summary": [
+                {
+                    "chunk_id": c.get("chunk_id"),
+                    "section_label": c.get("section_label"),
+                    "page": c.get("element_tag", {}).get("page"),
+                    "content_preview": (c.get("review_chunk_content", "") or c.get("content", ""))[:200].replace("\n", " ") + "...",
+                }
+                for c in result.get("chunks", [])
+            ],
+        }
+        json.dump(dump_data, f, ensure_ascii=False, indent=2)
+    print(f"[INFO] 摘要已保存到: {output_path}")
+
+    return 0 if report["leaks"] == [] and any("第十章" in l for l in report["section_labels"]) else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())