deploy clean space v2

.gitattributes

@@ -0,0 +1,309 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_fix_profile/page_images/page_001.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_fix_profile/page_images/page_002.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_fix_profile/page_images/page_003.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_fix_profile/page_images/page_004.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_fix_profile/page_images/page_005.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_fix_profile/page_images/page_006.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_fix_profile/page_images/page_007.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_fix_profile/page_images/page_008.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_fix_profile/page_images/page_009.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_fix_profile/page_images/page_010.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_fix_profile/page_images/page_011.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_fix_profile/page_images/page_012.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_fix_profile/page_images/page_013.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_fix_profile/page_images/page_014.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_fix_profile/page_images/page_015.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_fix_profile/page_images/page_016.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_fix_profile/page_images/page_017.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_fix_profile/page_images/page_018.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_fix_profile/page_images/page_019.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_fix_profile/page_images/page_020.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_fix_profile/page_images/page_021.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_fix_profile/page_images/page_022.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_fix_profile/page_images/page_023.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_fix_profile/page_images/page_024.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_fix_profile/page_images/page_025.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_fix_profile/page_images/page_026.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_fix_profile/page_images/page_027.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_fix_profile/page_images/page_028.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_fix_profile/page_images/page_029.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_fix_profile/page_images/page_030.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_fix_profile/page_images/page_031.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_fix_profile/page_images/page_032.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_fix_profile/page_images/page_033.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_fix_profile/page_images/page_034.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_fix_profile/page_images/page_035.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_fix_profile/page_images/page_036.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_fix_profile/page_images/page_037.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_fix_profile/page_images/page_038.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_fix_profile/page_images/page_039.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr/page_images/page_001.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr/page_images/page_002.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr/page_images/page_003.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr/page_images/page_004.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr/page_images/page_005.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr/page_images/page_006.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr/page_images/page_007.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr/page_images/page_008.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr/page_images/page_009.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr/page_images/page_010.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr/page_images/page_011.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr/page_images/page_012.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr/page_images/page_013.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr/page_images/page_014.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr/page_images/page_015.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr/page_images/page_016.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr/page_images/page_017.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr/page_images/page_018.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr/page_images/page_019.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr/page_images/page_020.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr/page_images/page_021.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr/page_images/page_022.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr/page_images/page_023.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr/page_images/page_024.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr/page_images/page_025.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr/page_images/page_026.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr/page_images/page_027.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr/page_images/page_028.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr/page_images/page_029.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr/page_images/page_030.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr/page_images/page_031.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr/page_images/page_032.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr/page_images/page_033.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr/page_images/page_034.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr/page_images/page_035.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr/page_images/page_036.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr/page_images/page_037.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr/page_images/page_038.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr/page_images/page_039.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr2/page_images/page_001.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr2/page_images/page_002.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr2/page_images/page_003.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr2/page_images/page_004.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr2/page_images/page_005.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr2/page_images/page_006.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr2/page_images/page_007.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr2/page_images/page_008.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr2/page_images/page_009.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr2/page_images/page_010.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr2/page_images/page_011.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr2/page_images/page_012.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr2/page_images/page_013.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr2/page_images/page_014.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr2/page_images/page_015.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr2/page_images/page_016.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr2/page_images/page_017.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr2/page_images/page_018.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr2/page_images/page_019.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr2/page_images/page_020.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr2/page_images/page_021.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr2/page_images/page_022.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr2/page_images/page_023.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr2/page_images/page_024.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr2/page_images/page_025.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr2/page_images/page_026.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr2/page_images/page_027.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr2/page_images/page_028.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr2/page_images/page_029.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr2/page_images/page_030.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr2/page_images/page_031.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr2/page_images/page_032.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr2/page_images/page_033.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr2/page_images/page_034.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr2/page_images/page_035.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr2/page_images/page_036.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr2/page_images/page_037.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr2/page_images/page_038.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_ocr2/page_images/page_039.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai/page_images/page_001.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai/page_images/page_002.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai/page_images/page_003.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai/page_images/page_004.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai/page_images/page_005.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai/page_images/page_006.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai/page_images/page_007.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai/page_images/page_008.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai/page_images/page_009.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai/page_images/page_010.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai/page_images/page_011.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai/page_images/page_012.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai/page_images/page_013.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai/page_images/page_014.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai/page_images/page_015.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai/page_images/page_016.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai/page_images/page_017.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai/page_images/page_018.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai/page_images/page_019.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai/page_images/page_020.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai/page_images/page_021.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai/page_images/page_022.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai/page_images/page_023.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai/page_images/page_024.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai/page_images/page_025.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai/page_images/page_026.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai/page_images/page_027.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai/page_images/page_028.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai/page_images/page_029.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai/page_images/page_030.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai/page_images/page_031.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai/page_images/page_032.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai/page_images/page_033.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai/page_images/page_034.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai/page_images/page_035.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai/page_images/page_036.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai/page_images/page_037.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai/page_images/page_038.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai/page_images/page_039.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai2/page_images/page_001.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai2/page_images/page_002.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai2/page_images/page_003.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai2/page_images/page_004.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai2/page_images/page_005.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai2/page_images/page_006.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai2/page_images/page_007.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai2/page_images/page_008.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai2/page_images/page_009.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai2/page_images/page_010.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai2/page_images/page_011.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai2/page_images/page_012.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai2/page_images/page_013.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai2/page_images/page_014.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai2/page_images/page_015.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai2/page_images/page_016.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai2/page_images/page_017.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai2/page_images/page_018.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai2/page_images/page_019.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai2/page_images/page_020.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai2/page_images/page_021.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai2/page_images/page_022.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai2/page_images/page_023.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai2/page_images/page_024.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai2/page_images/page_025.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai2/page_images/page_026.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai2/page_images/page_027.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai2/page_images/page_028.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai2/page_images/page_029.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai2/page_images/page_030.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai2/page_images/page_031.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai2/page_images/page_032.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai2/page_images/page_033.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai2/page_images/page_034.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai2/page_images/page_035.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai2/page_images/page_036.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai2/page_images/page_037.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai2/page_images/page_038.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_openai2/page_images/page_039.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_page10/page_images/page_001.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_suffix/page_images/page_001.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_suffix/page_images/page_002.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_suffix/page_images/page_003.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_suffix/page_images/page_004.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_suffix/page_images/page_005.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_suffix/page_images/page_006.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_suffix/page_images/page_007.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_suffix/page_images/page_008.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_suffix/page_images/page_009.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_suffix/page_images/page_010.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_suffix/page_images/page_011.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_suffix/page_images/page_012.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_suffix/page_images/page_013.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_suffix/page_images/page_014.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_suffix/page_images/page_015.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_suffix/page_images/page_016.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_suffix/page_images/page_017.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_suffix/page_images/page_018.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_suffix/page_images/page_019.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_suffix/page_images/page_020.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_suffix/page_images/page_021.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_suffix/page_images/page_022.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_suffix/page_images/page_023.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_suffix/page_images/page_024.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_suffix/page_images/page_025.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_suffix/page_images/page_026.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_suffix/page_images/page_027.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_suffix/page_images/page_028.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_suffix/page_images/page_029.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_suffix/page_images/page_030.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_suffix/page_images/page_031.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_suffix/page_images/page_032.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_suffix/page_images/page_033.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_suffix/page_images/page_034.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_suffix/page_images/page_035.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_suffix/page_images/page_036.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_suffix/page_images/page_037.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_suffix/page_images/page_038.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test_suffix/page_images/page_039.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test1/page_images/page_001.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test1/page_images/page_002.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test1/page_images/page_003.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test1/page_images/page_004.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test1/page_images/page_005.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test1/page_images/page_006.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test1/page_images/page_007.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test1/page_images/page_008.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test1/page_images/page_009.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test1/page_images/page_010.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test1/page_images/page_011.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test1/page_images/page_012.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test1/page_images/page_013.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test1/page_images/page_014.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test1/page_images/page_015.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test1/page_images/page_016.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test1/page_images/page_017.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test1/page_images/page_018.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test1/page_images/page_019.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test1/page_images/page_020.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test1/page_images/page_021.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test1/page_images/page_022.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test1/page_images/page_023.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test1/page_images/page_024.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test1/page_images/page_025.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test1/page_images/page_026.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test1/page_images/page_027.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test1/page_images/page_028.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test1/page_images/page_029.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test1/page_images/page_030.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test1/page_images/page_031.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test1/page_images/page_032.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test1/page_images/page_033.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test1/page_images/page_034.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test1/page_images/page_035.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test1/page_images/page_036.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test1/page_images/page_037.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test1/page_images/page_038.png filter=lfs diff=lfs merge=lfs -text
+src/data/prepared/test1/page_images/page_039.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,12 @@
+# 忽略数据和生成文件
+src/data/
+*.pdf
+*.png
+*.jpg
+
+# Python
+__pycache__/
+*.pyc
+
+# 临时报告
+report_*.md

README.md

@@ -0,0 +1,14 @@
+---
+title: Yangtez Beta
+emoji: ⚡
+colorFrom: gray
+colorTo: blue
+sdk: gradio
+sdk_version: 6.11.0
+app_file: app.py
+pinned: false
+license: mit
+short_description: fund porposal reviewer
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,60 @@
+import gradio as gr
+import subprocess
+import os
+import uuid
+import shutil
+
+def run_pipeline(file):
+
+    try:
+        # 1️⃣ 生成唯一 ID（核心）
+        proposal_id = f"web_{uuid.uuid4().hex[:8]}"
+
+        # 2️⃣ 创建独立目录
+        work_dir = os.path.join("tmp", proposal_id)
+        os.makedirs(work_dir, exist_ok=True)
+
+        # 3️⃣ 保存上传文件（避免覆盖）
+        file_path = os.path.join(work_dir, os.path.basename(file.name))
+        shutil.copy(file.name, file_path)
+
+        # 4️⃣ 调用后端（安全方式）
+        result = subprocess.run(
+            ["python", "run_review.py", "--file", file_path, "--proposal_id", proposal_id],
+            check=True,
+            timeout=600,
+            capture_output=True,
+            text=True
+        )
+
+        print("STDOUT:\n", result.stdout)
+        print("STDERR:\n", result.stderr)
+
+        # 5️⃣ 找输出报告
+        report_path = os.path.join(
+            "src", "data", "runs", proposal_id, f"{proposal_id}_review_report.md"
+        )
+
+        if os.path.exists(report_path):
+            with open(report_path, "r", encoding="utf-8") as f:
+                return f.read()
+        else:
+            return "❌ Report not found."
+
+    except subprocess.TimeoutExpired:
+        return "⏱️ Error: Task timeout (too long)."
+
+    except Exception as e:
+        return f"❌ Error: {str(e)}"
+
+
+# UI
+demo = gr.Interface(
+    fn=run_pipeline,
+    inputs=gr.File(label="Upload PDF"),
+    outputs=gr.Textbox(label="Review Result"),
+    title="Yangtze AI Reviewer"
+)
+
+if __name__ == "__main__":
+    demo.launch()

packages.txt

@@ -0,0 +1,2 @@
+poppler-utils
+tesseract-ocr

requirements.txt

@@ -0,0 +1,30 @@
+pdfplumber
+langchain
+langchain-community
+langchain-huggingface
+sentence-transformers
+chromadb
+numpy
+pandas
+tqdm
+
+pdf2image
+pdfplumber
+pytesseract
+Pillow
+python-docx
+
+python-dotenv
+openai
+requests
+beautifulsoup4
+lxml
+pydantic
+
+# optional stronger multimodal/layout/table stack
+transformers
+torch
+accelerate
+# paddleocr
+torchvision
+timm

run_review.py

@@ -0,0 +1,808 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+from __future__ import annotations
+
+"""
+End-to-end Yangtze review runner.
+
+Pipeline:
+PDF -> prepared JSON -> domain profile -> metric check -> specialized prompts
+-> review JSON -> markdown report
+"""
+
+import argparse
+import json
+import os
+import re
+from collections import defaultdict
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, List, Sequence, Tuple
+
+from dotenv import load_dotenv
+from openai import OpenAI
+
+from src.tools.domain_profiler import profile_with_optional_llm
+from src.prompting.domain_adaptive import (
+    QUESTION_SEARCH_HINTS,
+    REVIEW_TASKS,
+    build_specialized_question,
+)
+from src.tools.prepare_proposal_text import prepare_text
+from src.tools.metric_checker import build_metric_report, build_metric_prompt_suffix
+
+load_dotenv()
+
+BASE_DIR = Path(__file__).resolve().parent
+DATA_DIR = BASE_DIR / "src" / "data"
+RUNS_DIR = DATA_DIR / "runs"
+
+
+@dataclass(frozen=True)
+class EvidenceSnippet:
+    page_index: int
+    text: str
+    score: float
+
+
+def _clean_text(text: str) -> str:
+    return re.sub(r"\s+", " ", text or "").strip()
+
+
+def _safe_name(name: str) -> str:
+    return re.sub(r"[^a-zA-Z0-9_\-]+", "_", name).strip("_") or "proposal"
+
+
+def load_pages(proposal_id: str) -> List[Dict[str, Any]]:
+    path = DATA_DIR / "prepared" / proposal_id / "pages.json"
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+TASK_KEYWORDS = {
+    "problem": ["背景", "需求", "意义", "motivation", "pain point", "problem", "行业背景"],
+    "objectives": ["目标", "scope", "deliverable", "计划", "路径", "objective"],
+    "methods": ["方法", "技术路线", "样机", "验证", "test", "prototype", "method"],
+    "evidence": ["样机", "测试", "专利", "数据", "成果", "validation", "evidence"],
+    "feasibility": ["交付", "timeline", "roadmap", "风险", "量产", "feasibility"],
+    "innovation": ["唯一", "领先", "创新", "novel", "differentiation", "突破"],
+    "risks": ["风险", "瓶颈", "dependency", "cost", "寿命", "竞争", "risk"],
+    "team": ["团队", "依托单位", "博士", "研究员", "roles", "team"],
+    "outcomes": ["市场", "订单", "收入", "profit", "impact", "evaluation", "融资"],
+}
+
+
+def score_page_for_task(task_id: str, page_text: str, profile: Dict[str, Any]) -> float:
+    text = _clean_text(page_text)
+    if not text:
+        return 0.0
+
+    lower = text.lower()
+    score = 0.0
+
+    for term in TASK_KEYWORDS.get(task_id, []):
+        if term.lower() in lower:
+            score += 2.0
+
+    dim_map = {
+        "problem": profile["evaluation_focus"]["problem"],
+        "objectives": profile["evaluation_focus"]["objectives"],
+        "methods": profile["methods"],
+        "evidence": profile["methods"],
+        "feasibility": profile["evaluation_focus"]["feasibility"] + profile["risks"],
+        "innovation": profile["evaluation_focus"]["innovation"],
+        "risks": profile["risks"],
+        "team": profile["evaluation_focus"]["team"],
+        "outcomes": profile["evaluation_focus"]["outcomes"],
+    }
+
+    for term in dim_map.get(task_id, []):
+        if term.lower() in lower:
+            score += 1.2
+
+    numbers = re.findall(r"\d+(?:\.\d+)?", text)
+    if task_id in {"evidence", "feasibility", "outcomes"}:
+        score += min(2.0, len(numbers) * 0.15)
+
+    if task_id == "team" and any(x in text for x in ["博士", "研究员", "教授", "工程师", "expert"]):
+        score += 2.0
+
+    if task_id == "innovation" and any(x in text for x in ["唯一", "领先", "首台", "first", "unique"]):
+        score += 1.5
+
+    return score
+
+
+def select_evidence(
+    task_id: str,
+    pages: Sequence[Dict[str, Any]],
+    profile: Dict[str, Any],
+    top_k: int = 4,
+) -> List[EvidenceSnippet]:
+    scored = []
+    for page in pages:
+        score = score_page_for_task(task_id, page.get("text", ""), profile)
+        if score > 0:
+            scored.append(
+                EvidenceSnippet(
+                    page_index=int(page["page_index"]),
+                    text=_clean_text(page["text"])[:420],
+                    score=score,
+                )
+            )
+    scored.sort(key=lambda x: (x.score, -x.page_index), reverse=True)
+    return scored[:top_k]
+
+
+def feature_flags(pages: Sequence[Dict[str, Any]], full_text: str) -> Dict[str, bool]:
+    return {
+        "has_team": bool(re.search(r"团队|leader|博士|教授|研究员", full_text)),
+        "has_timeline": bool(re.search(r"20\d{2}|timeline|roadmap|交付|研发路径", full_text)),
+        "has_budget": bool(re.search(r"融资|预算|资金|万元|million|cash|profit", full_text)),
+        "has_market": bool(re.search(r"市场|customer|订单|demand|销量|sales", full_text)),
+        "has_prototype": bool(re.search(r"样机|prototype|测试|验证|patent|专利", full_text)),
+        "has_risk_signal": bool(re.search(r"风险|瓶颈|challenge|uncertainty|dependency|��争", full_text)),
+        "has_metrics": bool(len(re.findall(r"\d+(?:\.\d+)?", full_text)) >= 10),
+    }
+
+
+def score_task(task_id: str, evidences: Sequence[EvidenceSnippet], flags: Dict[str, bool]) -> Tuple[float, float]:
+    base = 5.0
+    evidence_strength = min(2.0, sum(min(ev.score, 3.0) for ev in evidences) / 6.0)
+    score = base + evidence_strength
+    conf = 0.45 + min(0.45, len(evidences) * 0.08)
+
+    if task_id == "team" and flags["has_team"]:
+        score += 1.0
+        conf += 0.06
+    if task_id == "outcomes" and flags["has_market"] and flags["has_budget"]:
+        score += 0.6
+    if task_id == "feasibility" and flags["has_timeline"]:
+        score += 0.6
+    if task_id in {"methods", "evidence"} and flags["has_prototype"]:
+        score += 0.8
+    if task_id == "risks" and flags["has_risk_signal"]:
+        score += 0.6
+    if task_id == "innovation" and flags["has_metrics"]:
+        score += 0.2
+
+    if task_id == "outcomes" and not flags["has_market"]:
+        score -= 1.1
+    if task_id == "feasibility" and not flags["has_timeline"]:
+        score -= 1.0
+    if task_id == "team" and not flags["has_team"]:
+        score -= 1.2
+    if task_id in {"methods", "evidence"} and not flags["has_prototype"]:
+        score -= 1.2
+    if task_id == "risks" and not flags["has_risk_signal"]:
+        score -= 0.8
+
+    score = max(1.0, min(9.5, round(score, 1)))
+    conf = max(0.2, min(0.95, round(conf, 2)))
+    return score, conf
+
+
+TASK_TEMPLATES = {
+    "problem": (
+        "The proposal appears to target a concrete problem area with visible context and motivation.",
+        "The motivation would be stronger with clearer articulation of urgency, constraints, and why this is the right solution path now.",
+    ),
+    "objectives": (
+        "The objectives are broadly understandable and tied to an identifiable work direction.",
+        "The proposal would benefit from sharper success criteria, scope boundaries, and milestone-level deliverables.",
+    ),
+    "methods": (
+        "The technical or methodological path is visible and internally coherent at a high level.",
+        "The document still leaves gaps around assumptions, validation thresholds, and detailed implementation logic.",
+    ),
+    "evidence": (
+        "The proposal includes tangible supporting signals such as prototypes, tests, prior work, or enabling resources.",
+        "The evidence base remains incomplete for a decisive judgment because end-to-end validation and independent proof points are limited.",
+    ),
+    "feasibility": (
+        "The execution pathway is plausible and partially supported by roadmap and resource signals.",
+        "Feasibility remains exposed to delivery, integration, scaling, and dependency risks that are not fully closed.",
+    ),
+    "innovation": (
+        "The proposal makes a credible differentiation claim relative to standard alternatives.",
+        "The novelty case would be stronger with side-by-side benchmarking against the best current alternatives.",
+    ),
+    "risks": (
+        "The proposal contains signals of awareness around technical and operational constraints.",
+        "Risk treatment is not yet fully mature: several major failure modes are implied rather than explicitly mitigated.",
+    ),
+    "team": (
+        "The team profile suggests relevant expertise and some execution capability.",
+        "The commercial, manufacturing, or cross-functional governance setup is less developed than the technical story.",
+    ),
+    "outcomes": (
+        "The expected outcomes and impact direction are understandable and potentially meaningful.",
+        "Commercial or practical outcomes still rely on assumptions that need firmer validation and customer conversion evidence.",
+    ),
+}
+
+
+def build_task_assessment(
+    task_id: str,
+    task_title: str,
+    prompt_text: str,
+    evidences: Sequence[EvidenceSnippet],
+    score: float,
+    confidence: float,
+    metric_report: Dict[str, Any],
+) -> Dict[str, Any]:
+    pages = [ev.page_index for ev in evidences]
+    snippets = [ev.text[:120] for ev in evidences[:2] if ev.text]
+
+    if snippets:
+        evidence_text = " | ".join(snippets)
+        judgment = f"Based on evidence: {evidence_text}"
+    else:
+        judgment = "Limited direct evidence found in the document."
+
+    strengths: List[str] = []
+    weaknesses: List[str] = []
+
+    if evidences:
+        strengths.append(f"Evidence located on pages {', '.join(map(str, pages[:3]))}.")
+        if snippets:
+            strengths.append("The proposal includes concrete supporting details rather than only high-level claims.")
+
+    if score >= 7.5:
+        strengths.append("This dimension is relatively strong compared to others.")
+
+    # ❗减少模板味，增加针对性
+    if score <= 6.0:
+        weaknesses.append("Evidence is insufficient or not clearly connected to claims.")
+
+    if task_id == "outcomes":
+        weaknesses.append("Outcome claims are not tightly linked to measurable metrics.")
+    elif task_id == "feasibility":
+        weaknesses.append("Execution feasibility lacks detailed validation or timeline support.")
+    elif task_id == "risks":
+        weaknesses.append("Risk mitigation strategies are not sufficiently detailed.")
+    elif task_id == "team":
+        weaknesses.append("Team capability is not strongly evidenced by concrete roles or experience.")
+    else:
+        weaknesses.append("This aspect could be made more explicit and evidence-supported.")
+
+    evidence_level = metric_report.get("metric_signals", {}).get("evidence_level", "weak")
+
+    if evidence_level == "weak":
+        weaknesses.append("Quantitative evidence is weak, reducing confidence.")
+    elif evidence_level == "moderate":
+        weaknesses.append("Quantitative support exists but is not fully convincing.")
+
+    missing: List[str] = []
+
+    metric_missing = metric_report.get("metric_signals", {}).get("missing_metric_signals", [])
+    missing.extend(metric_missing[:3])
+
+    missing.extend([
+        "Explicit measurable success criteria",
+        "Clear assumptions or boundary conditions",
+    ])
+
+    # 去重
+    seen = set()
+    dedup_missing = []
+    for item in missing:
+        key = item.lower().strip()
+        if key and key not in seen:
+            seen.add(key)
+            dedup_missing.append(item)
+
+    return {
+        "task_id": task_id,
+        "title": task_title,
+        "prompt": prompt_text,
+        "judgment": judgment,
+        "strengths": strengths[:3],
+        "weaknesses": weaknesses[:3],
+        "missing_information": dedup_missing[:5],
+        "confidence": confidence,
+        "score_10": score,
+        "evidence": [ev.__dict__ for ev in evidences],
+    }
+
+
+def aggregate_dimension_scores(task_results: Sequence[Dict[str, Any]]) -> Dict[str, float]:
+    dim_scores: Dict[str, List[float]] = defaultdict(list)
+    for task, result in zip(REVIEW_TASKS, task_results):
+        dim_scores[task.dimension].append(float(result["score_10"]))
+    return {dim: round(sum(vals) / len(vals), 2) for dim, vals in dim_scores.items()}
+
+
+def compute_final_verdict(task_results: Sequence[Dict[str, Any]]) -> Tuple[float, float, str]:
+    scores = [float(r["score_10"]) for r in task_results]
+    confs = [float(r["confidence"]) for r in task_results]
+    overall = round(sum(scores) / len(scores), 2) if scores else 0.0
+    confidence = round(sum(confs) / len(confs), 2) if confs else 0.0
+
+    if overall >= 7.8 and confidence >= 0.7:
+        verdict = "SUPPORT"
+    elif overall >= 6.0:
+        verdict = "HOLD"
+    else:
+        verdict = "CONCERN"
+
+    return overall, confidence, verdict
+
+
+def generate_final_review(result, proposal_id="Unknown", domain="Unknown"):
+    from datetime import datetime
+
+    def score_to_level(score):
+        if score >= 0.8:
+            return "较高"
+        elif score >= 0.6:
+            return "中等偏上"
+        elif score >= 0.4:
+            return "中等"
+        else:
+            return "较低"
+
+    def generate_overall_comment(result):
+        score = result.get("overall_score", 0)
+
+        obj = result.get("objectives", {}).get("summary", "")
+        strat = result.get("strategy", {}).get("summary", "")
+        innov = result.get("innovation", {}).get("summary", "")
+        feas = result.get("feasibility", {}).get("summary", "")
+
+        # 去掉太原始/证据型文本
+        def clean(x):
+            if not x:
+                return ""
+            x = x.replace("Based on evidence:", "")
+            return x.strip()
+
+        obj = clean(obj)
+        strat = clean(strat)
+        innov = clean(innov)
+        feas = clean(feas)
+
+        # 分数 -> 总体判断
+        if score >= 0.8:
+            level = "整体表现较好"
+        elif score >= 0.6:
+            level = "整体表现中等偏上"
+        elif score >= 0.4:
+            level = "整体表现一般"
+        else:
+            level = "整体表现较弱"
+
+        # 动态拼接（关键）
+        parts = []
+
+        if obj:
+            parts.append(f"在研究目标方面，{obj}")
+        if strat:
+            parts.append(f"在技术路线方面，{strat}")
+        if innov:
+            parts.append(f"在创新性方面，{innov}")
+        if feas:
+            parts.append(f"在可行性方面，{feas}")
+
+        parts.append(f"总体来看，项目{level}，但仍存在进一步优化空间。")
+
+        return "。".join(parts) + "。"
+
+    def summarize_dimension(text, dim_name):
+        if not text:
+            return "该部分描述较为有限"
+
+        if dim_name == "team":
+            return "团队具备一定研究基础，但人员结构与分工说明仍不够充分"
+        elif dim_name == "objectives":
+            return "研究目标较为明确，但可量化程度有待提升"
+        elif dim_name == "strategy":
+            return "技术路线整体较为清晰，但部分关键环节需进一步细化"
+        elif dim_name == "innovation":
+            return "项目具有一���创新性，但创新点仍需进一步突出"
+        elif dim_name == "feasibility":
+            return "项目具备一定实施基础，但可行性论证仍需加强"
+        else:
+            return "该部分内容较为完整，但仍有提升空间"
+
+    def generate_strengths():
+        return [
+            "项目整体结构较为完整，涵盖研究目标、技术路线与实施方案",
+            "技术路线具有一定逻辑性，具备基础可行性",
+            "在相关领域具有一定探索性，体现出一定创新潜力"
+        ]
+
+    def generate_weaknesses():
+        return [
+            "研究目标缺乏明确的量化指标，难以进行效果评估",
+            "技术路线部分关键环节描述不够具体，存在一定不确定性",
+            "创新点与现有研究的差异性阐述不够充分",
+            "可行性分析偏弱，缺乏实验或数据支撑",
+            "风险识别与应对机制尚不完善"
+        ]
+
+    def generate_suggestions():
+        return [
+            "建议细化研究目标，增加可量化评价指标",
+            "建议完善技术路线描述，补充关键步骤说明",
+            "建议加强与现有研究的对比分析，突出创新点",
+            "建议补充实验验证或数据支撑，提高方案可信度",
+            "建议完善风险评估与应对策略"
+        ]
+
+    overall_score = result.get("overall_score", 0)
+    confidence = result.get("confidence", 0)
+    verdict = result.get("verdict", "HOLD")
+
+    team = result.get("team", {})
+    obj = result.get("objectives", {})
+    strat = result.get("strategy", {})
+    innov = result.get("innovation", {})
+    feas = result.get("feasibility", {})
+
+    strengths = generate_strengths()
+    weaknesses = generate_weaknesses()
+    suggestions = generate_suggestions()
+
+    now = datetime.now().strftime("%Y-%m-%d")
+
+    report = f"""
+# 科研项目评审报告
+
+## 一、项目基本信息
+项目名称：{proposal_id}
+申报领域：{domain}
+评审时间：{now}
+
+## 二、总体评价
+{generate_overall_comment(result)}
+
+## 三、总体评分
+综合评分：{round(overall_score * 10, 2)} / 10  
+评审置信度：{round(confidence, 3)}  
+评审结论：{verdict}
+
+## 四、分项评分
+
+| 评审维度 | 得分 | 评价 |
+|----------|------|------|
+| 研究团队 | {team.get("score", 0):.3f} | {summarize_dimension("", "team")} |
+| 研究目标 | {obj.get("score", 0):.3f} | {summarize_dimension("", "objectives")} |
+| 技术路线 | {strat.get("score", 0):.3f} | {summarize_dimension("", "strategy")} |
+| 创新性 | {innov.get("score", 0):.3f} | {summarize_dimension("", "innovation")} |
+| 可行性 | {feas.get("score", 0):.3f} | {summarize_dimension("", "feasibility")} |
+
+## 五、主要优点
+{chr(10).join([f"{i+1}. {s}" for i, s in enumerate(strengths)]) if strengths else "暂无明显优点总结"}
+
+## 六、主要问题
+{chr(10).join([f"{i+1}. {w}" for i, w in enumerate(weaknesses)]) if weaknesses else "暂无明显问题"}
+
+## 七、修改建议
+{chr(10).join([f"{i+1}. {s}" for i, s in enumerate(suggestions)]) if suggestions else "暂无具体建议"}
+
+## 八、最终结论
+综合以上分析，本项目整体达到{score_to_level(overall_score)}水平，建议：{verdict}。
+"""
+
+    return report
+
+
+def llm_generate_review(result, proposal_id, domain):
+    client = OpenAI()
+
+    prompt = f"""
+你是一位国家自然科学基金评审专家，请基于以下结构化评审结果，撰写一份正式、规范、严谨的科研项目评审报告。
+
+【严格要求】
+1. 必须使用中文
+2. 必须使用正式评审报告语气（严谨、客观、有判断）
+3. 不允许出现英文
+4. 不允许出现“根据数据/系统/模型”等字样
+5. 不允许输出JSON或解释过程
+6. 必须使用标准科研评审结构（如下）
+7. 最终结论必须与“评审结论”字段严格一致，不得出现前后矛盾。
+8. 当评审结论为 HOLD 时，最终结论应表述为“建议暂缓资助”或“建议补充完善后再评估”，不得写为“建议资助”。
+
+【报告结构（必须严格遵守）】
+
+# 科研项目评审报告
+
+## 一、项目基本信息
+项目名称：{proposal_id}
+申报领域：{domain}
+
+## 二、总体评价
+（必须为一段完整文字，总结目标、方法、创新、可行性，并给出整体判断）
+
+## 三、总体评分
+- 综合评分：X / 10（注意：必须转为10分制）
+- 评审置信度：X.XX
+- 评审结论：{result.get("verdict")}
+
+## 四、分项评分
+（必须为表格形式）
+
+| 评审维度 | 得分（0-1） | 评价 |
+|----------|------------|------|
+| 研究团队 | {result.get("team", {}).get("score", 0)} | （一句评价） |
+| 研究目标 | {result.get("objectives", {}).get("score", 0)} | （一句评价） |
+| 技术路线 | {result.get("strategy", {}).get("score", 0)} | （一句评价） |
+| 创新性 | {result.get("innovation", {}).get("score", 0)} | （一句评价） |
+| 可行性 | {result.get("feasibility", {}).get("score", 0)} | （一句评价） |
+
+## 五、主要优点
+（3–5条，必须是专家评价语气）
+
+## 六、主要问题
+（3–5条，必须具体、有判断）
+
+## 七、修改建议
+（必须与问题一一对应）
+
+## 八、最终结论
+（必须是正式评审结论语言，如：建议资助 / 有条件资助 / 暂缓资助 / 不建议资助）
+
+【输入数据】
+综合评分（0-1）：{result.get("overall_score")}
+置信度：{result.get("confidence")}
+
+Team: {result.get("team")}
+Objectives: {result.get("objectives")}
+Strategy: {result.get("strategy")}
+Innovation: {result.get("innovation")}
+Feasibility: {result.get("feasibility")}
+"""
+
+    response = client.chat.completions.create(
+        model="gpt-4o-mini",
+        messages=[{"role": "user", "content": prompt}],
+        temperature=0.3
+    )
+
+    return response.choices[0].message.content
+
+
+def generate_markdown_report(
+    proposal_id: str,
+    file_path: Path,
+    profile: Dict[str, Any],
+    task_results: Sequence[Dict[str, Any]],
+    dim_scores: Dict[str, float],
+    overall: float,
+    confidence: float,
+    verdict: str,
+    profiler_mode: str,
+) -> str:
+    lines: List[str] = []
+    lines.append(f"# Yangtze Review Report — {proposal_id}")
+    lines.append("")
+    lines.append(f"- Source file: `{file_path.name}`")
+    lines.append(f"- Profiler mode: `{profiler_mode}`")
+    lines.append(f"- Overall score: **{overall:.2f} / 10**")
+    lines.append(f"- Confidence: **{confidence:.2f}**")
+    lines.append(f"- Verdict: **{verdict}**")
+    lines.append("")
+    lines.append("## Domain Profile")
+    lines.append("")
+    lines.append(f"- Primary domain: **{profile['domain']['primary']}**")
+    if profile["domain"]["secondary"]:
+        lines.append(f"- Secondary tags: {', '.join(profile['domain']['secondary'])}")
+    lines.append(f"- Methods: {', '.join(profile['methods']) or 'N/A'}")
+    lines.append(f"- Risks: {', '.join(profile['risks']) or 'N/A'}")
+    lines.append(f"- Terminology: {', '.join(profile['terminology']) or 'N/A'}")
+    lines.append("")
+    lines.append("## Dimension Scores")
+    lines.append("")
+    for dim in ["team", "objectives", "strategy", "innovation", "feasibility"]:
+        value = dim_scores.get(dim)
+        if value is not None:
+            lines.append(f"- **{dim}**: {value:.2f} / 10")
+    lines.append("")
+
+    for result in task_results:
+        lines.append(f"## {result['title']}")
+        lines.append("")
+        lines.append(f"**Score:** {result['score_10']:.1f} / 10  ")
+        lines.append(f"**Confidence:** {result['confidence']:.2f}")
+        lines.append("")
+        lines.append(f"**Prompt used**: {result['prompt']}")
+        lines.append("")
+        lines.append(result["judgment"])
+        lines.append("")
+        lines.append("**Strengths**")
+        for item in result["strengths"]:
+            lines.append(f"- {item}")
+        lines.append("")
+        lines.append("**Weaknesses**")
+        for item in result["weaknesses"]:
+            lines.append(f"- {item}")
+        lines.append("")
+        lines.append("**Missing information**")
+        for item in result["missing_information"]:
+            lines.append(f"- {item}")
+        lines.append("")
+        lines.append("**Evidence excerpts**")
+        if result["evidence"]:
+            for ev in result["evidence"]:
+                snippet = _clean_text(ev["text"])
+                lines.append(f"- Page {ev['page_index']}: {snippet}")
+        else:
+            lines.append("- No strong evidence matched this task.")
+        lines.append("")
+
+    strongest = sorted(task_results, key=lambda r: r["score_10"], reverse=True)[:3]
+    weakest = sorted(task_results, key=lambda r: r["score_10"])[:3]
+
+    lines.append("## Executive Summary")
+    lines.append("")
+    lines.append("### Stronger areas")
+    for item in strongest:
+        lines.append(f"- {item['title']} ({item['score_10']:.1f}/10)")
+    lines.append("")
+    lines.append("### Weaker areas")
+    for item in weakest:
+        lines.append(f"- {item['title']} ({item['score_10']:.1f}/10)")
+    lines.append("")
+
+    if verdict == "SUPPORT":
+        rec = "The proposal is supportable as presented, though normal diligence is still recommended."
+    elif verdict == "HOLD":
+        rec = "The proposal has credible potential but should move forward only with targeted clarification, validation, and execution-risk reduction."
+    else:
+        rec = "The proposal requires substantial strengthening before it would be ready for a positive funding or approval decision."
+
+    lines.append(f"**Recommendation:** {rec}")
+    lines.append("")
+    return "\n".join(lines)
+
+
+def run_review(file_path: Path, proposal_id: str | None = None, use_ocr: bool = True) -> Dict[str, Any]:
+    file_path = file_path.resolve()
+    proposal_id = proposal_id or _safe_name(file_path.stem)
+    RUNS_DIR.mkdir(parents=True, exist_ok=True)
+
+    prep = prepare_text(file_path=file_path, proposal_id=proposal_id, use_ocr=use_ocr)
+    print("=== DEBUG PAGE 3 TEXT ===")
+    print(prep.get("reconstructed_full_text", "")[:2000])
+    pages = load_pages(proposal_id)
+    full_text_path = Path(prep["full_text_path"])
+    full_text = full_text_path.read_text(encoding="utf-8", errors="ignore")
+
+    run_dir = RUNS_DIR / proposal_id
+    run_dir.mkdir(parents=True, exist_ok=True)
+
+    profile, profiler_mode = profile_with_optional_llm(full_text, pages)
+    (run_dir / "domain_profile.json").write_text(
+        json.dumps(profile, ensure_ascii=False, indent=2),
+        encoding="utf-8",
+    )
+
+    metric_report = build_metric_report(full_text, pages)
+    (run_dir / "metric_report.json").write_text(
+        json.dumps(metric_report, ensure_ascii=False, indent=2),
+        encoding="utf-8",
+    )
+
+    metric_prompt_suffix = build_metric_prompt_suffix(metric_report)
+
+    prompt_items = []
+    task_results = []
+    flags = feature_flags(pages, full_text)
+
+    for task in REVIEW_TASKS:
+        base_prompt_text = build_specialized_question(task, profile)
+        prompt_text = f"{base_prompt_text} {metric_prompt_suffix}"
+        evidences = select_evidence(task.task_id, pages, profile, top_k=4)
+        score, conf = score_task(task.task_id, evidences, flags)
+
+        result = build_task_assessment(
+            task.task_id,
+            task.title,
+            prompt_text,
+            evidences,
+            score,
+            conf,
+            metric_report,
+        )
+
+        prompt_items.append({
+            "task_id": task.task_id,
+            "template_id": task.template_id,
+            "dimension": task.dimension,
+            "title": task.title,
+            "prompt": prompt_text,
+            "search_hints": QUESTION_SEARCH_HINTS.get(task.dimension, []),
+        })
+        task_results.append(result)
+
+    (run_dir / "prompts.json").write_text(
+        json.dumps(prompt_items, ensure_ascii=False, indent=2),
+        encoding="utf-8",
+    )
+    (run_dir / "task_results.json").write_text(
+        json.dumps(task_results, ensure_ascii=False, indent=2),
+        encoding="utf-8",
+    )
+
+    dim_scores = aggregate_dimension_scores(task_results)
+    overall, confidence, verdict = compute_final_verdict(task_results)
+
+    review_json = {
+        "proposal_id": proposal_id,
+        "source_file": str(file_path),
+        "profiler_mode": profiler_mode,
+        "overall_score_10": overall,
+        "confidence": confidence,
+        "verdict": verdict,
+        "dimension_scores": dim_scores,
+        "domain_profile": profile,
+        "metric_report": metric_report,
+        "tasks": task_results,
+    }
+    (run_dir / "review.json").write_text(
+        json.dumps(review_json, ensure_ascii=False, indent=2),
+        encoding="utf-8",
+    )
+
+    def _dim_bucket(dim: str) -> Dict[str, Any]:
+        dim_tasks = [t for t in task_results if any(rt.dimension == dim and rt.task_id == t["task_id"] for rt in REVIEW_TASKS)]
+        score_10 = dim_scores.get(dim, 0.0)
+        summary = ""
+        if dim_tasks:
+            top = sorted(dim_tasks, key=lambda x: x.get("score_10", 0), reverse=True)[0]
+            summary = top.get("judgment", "")[:120]
+        return {
+            "score": score_10 / 10.0,
+            "summary": summary,
+            "strengths": [s for t in dim_tasks for s in t.get("strengths", [])],
+            "weaknesses": [w for t in dim_tasks for w in t.get("weaknesses", [])],
+        }
+
+    result = {
+        "overall_score": overall / 10.0,
+        "confidence": confidence,
+        "verdict": verdict,
+        "team": _dim_bucket("team"),
+        "objectives": _dim_bucket("objectives"),
+        "strategy": _dim_bucket("strategy"),
+        "innovation": _dim_bucket("innovation"),
+        "feasibility": _dim_bucket("feasibility"),
+    }
+    domain = profile.get("domain", {}).get("primary", "Unknown")
+    final_report = llm_generate_review(result, proposal_id, domain)
+    print(final_report)
+
+    report_path = run_dir / f"{proposal_id}_review_report.md"
+    report_path.write_text(final_report, encoding="utf-8")
+
+    with open(f"report_{proposal_id}.md", "w", encoding="utf-8") as f:
+        f.write(final_report)
+
+    return {
+        "proposal_id": proposal_id,
+        "run_dir": str(run_dir),
+        "report_path": str(report_path),
+        "review_json_path": str(run_dir / "review.json"),
+        "overall_score_10": overall,
+        "confidence": confidence,
+        "verdict": verdict,
+        "profiler_mode": profiler_mode,
+    }
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description="Run the Yangtze domain-adaptive review pipeline end to end.")
+    ap.add_argument("--file", required=True, help="Path to PDF/DOCX/TXT/MD proposal file")
+    ap.add_argument("--proposal_id", default="", help="Optional proposal ID for output directories")
+    ap.add_argument("--no_ocr", action="store_true", help="Disable OCR fallback during PDF text preparation")
+    args = ap.parse_args()
+
+    result = run_review(
+        Path(args.file), 
+        proposal_id=args.proposal_id.strip() or None,
+        use_ocr=not args.no_ocr,
+    )
+
+
+if __name__ == "__main__":
+    main()

src/backend/retrievers/web_search.py

@@ -0,0 +1,662 @@
+# -*- coding: utf-8 -*-
+"""
+模块：Web Search（v2025.12 ProClean · TrustLayer + MustHave + Diagnostics + ReRank v1）
+保持签名：simple_search(query, max_results=8, dimension="general", hints=None, source="LLM")
+输出不变：src/data/evidence/{proposal_id}/{dimension}_combined.json
+
+新增要点（对相关性友好，且默认安全）：
+- Query 智能拼接：若用户 query 已含 site:/时间窗/负向词，则不重复注入；team 维度更少误杀
+- 轻量 ReRank（BM25-lite + 关键短语/实体加权 + 信息密度 + 来源置信度）
+- 文本近重复抑制（n-gram Jaccard，默认阈值 0.92）
+- 结果有序写入 combined（更相关的排前面，但仍保存全部）
+- Cache 命中不再覆盖 combined（之前已修）
+- 多线程 host 配额加锁（之前已修）
+"""
+import os, re, time, json, hashlib, warnings, math
+import requests, trafilatura
+from bs4 import BeautifulSoup, XMLParsedAsHTMLWarning
+from urllib.parse import urlparse, urlunparse, parse_qsl, urlencode
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from collections import Counter, defaultdict
+from pathlib import Path
+import threading
+
+warnings.filterwarnings("ignore", category=XMLParsedAsHTMLWarning)
+
+# ===== 外部依赖（可选）=====
+try:
+    from tavily import TavilyClient
+except ImportError:
+    TavilyClient = None
+try:
+    from duckduckgo_search import DDGS
+except ImportError:
+    DDGS = None
+
+# ===== LLM （仅用于小摘要，非必须）=====
+try:
+    from backend.utils.model_selector import get_llm_client
+    _llm_info = get_llm_client()
+    LLM_CLIENT = _llm_info["client"]
+    LLM_MODEL  = _llm_info["model_name"]
+    LLM_PROVIDER = _llm_info["provider"]
+    print(f"💬 WebSearch 使用 {LLM_PROVIDER.upper()} 模型：{LLM_MODEL}")
+except Exception:
+    LLM_CLIENT, LLM_MODEL = None, None
+
+# ===== 环境变量 =====
+TAVILY_KEY = os.getenv("TAVILY_API_KEY")
+GOOGLE_KEY = os.getenv("GOOGLE_API_KEY")
+GOOGLE_CX  = os.getenv("GOOGLE_CX")
+client_tavily = TavilyClient(api_key=TAVILY_KEY) if (TavilyClient and TAVILY_KEY) else None
+
+# 可调控开关（全部向后兼容）
+MUST_HAVE_STRICT = os.getenv("WEB_MUST_HAVE_STRICT", "1") != "0"
+RERANK_ENABLE    = os.getenv("WEB_RERANK_ENABLE", "1") != "0"   # 新增：开启轻量重排
+DEDUP_ENABLE     = os.getenv("WEB_DEDUP_ENABLE", "1") != "0"     # 新增：开启文本近重复抑制
+DEDUP_JACCARD    = float(os.getenv("WEB_DEDUP_JACCARD", "0.92")) # 新增：n-gram Jaccard 阈值
+
+# ===== 全局参数 =====
+MIN_LEN_BASE = 140
+MAX_LEN = 2600
+MAX_WORKERS = 8
+RETRY = 2
+TIMEOUT = 12
+HOST_QUOTA = 3
+EARLY_ACADEMIC_MIN = {"strategy": 4, "objectives": 4, "feasibility": 4, "innovation": 3, "team": 3}
+
+LANG_ALLOW = {"en", "zh", "zh-cn", "zh-tw", "und"}
+BLOCK_HOSTS = (
+    "facebook.", "twitter.", "x.com", "reddit.", "zhihu.", "bilibili.",
+    "medium.com", "pinterest.", "wechat.", "weibo.", "quora.", "csdn.",
+    "scribd.com", "moomoo.com", "sol-war.ru", "xmind.com", "islandenergy.je",
+    "glassdoor.", "indeed.", "join.com", "job", "careers", "recruit", "press"  # （已移除 "news"）
+)
+
+ACADEMIC_DOMAINS = [
+    "arxiv.org","openreview.net","aclweb.org","ieeexplore.ieee.org","dl.acm.org",
+    "springer.com","nature.com","sciencedirect.com","wiley.com","tandfonline.com",
+    "mdpi.com","frontiersin.org","osf.io","zenodo.org","doi.org"
+]
+INSTITUTIONAL_HINTS = (".edu", ".ac.", "university", "hospital")
+
+MUST_HAVE_BY_DIM = {
+    "innovation": ["novel", "innovation", "benchmark", "state of the art", "comparison"],
+    "strategy":   ["method", "workflow", "implementation", "architecture", "validation"],
+    "objectives": ["objective", "scope", "deliverable", "evaluation", "metric"],
+    "feasibility":["resource", "timeline", "risk", "dependency", "budget"],
+    "team":       ["team", "expertise", "affiliation", "leadership", "governance"]
+}
+MIN_LEN_BY_DIM = {"team": 80}
+
+NEGATIVE_BY_DIM = {
+    "strategy":   "-stock -finance -press -news -forum -blog -marketing",
+    "feasibility":"-press -news -forum -blog -marketing -stock -finance",
+    "objectives": "-news -press -blog -forum",
+    "innovation": "-press -news -blog -forum",
+    "team":       "-jobs -career -recruit -hiring -admissions"  # 放宽 team（不再 -press/-news）
+}
+
+_HTTP = requests.Session()
+_HTTP.headers.update({"User-Agent": "Mozilla/5.0 (compatible; RAG6View/2025; +https://rag6view.local/agent)"})
+
+
+# ===== 基础打分 =====
+def _clamp(x, lo=0.3, hi=1.0):
+    try: return max(lo, min(hi, float(x)))
+    except Exception: return lo
+
+def source_confidence(domain: str) -> float:
+    if not domain: return 0.55
+    d = domain.lower()
+    high = ["pubmed","pmc","nih","who","nature","fda","ema","sciencedirect","springer","clinicaltrials","nejm","thelancet","bmj","cell"]
+    medium = ["arxiv","biorxiv","medrxiv","researchsquare"]
+    low = ["news","press","blog","medium.com"]
+    if any(x in d for x in high): return 0.98
+    if any(x in d for x in medium): return 0.80
+    if any(x in d for x in low): return 0.50
+    return 0.62
+
+def info_density_score(text: str) -> float:
+    n_year = len(re.findall(r"\b(19|20)\d{2}\b", text))
+    n_unit = len(re.findall(r"\b(AI|ML|benchmark|dataset|trial|phase\s?(I|II|III)|accuracy|F1|AUC|API|prototype|workflow|framework)\b", text, re.I))
+    return _clamp((n_year + n_unit) / 24.0, 0.0, 1.0)
+
+
+# ===== URL/域名工具 =====
+UTM_KEYS = {"utm_source","utm_medium","utm_campaign","utm_term","utm_content","utm_id","gclid","fbclid","msclkid"}
+def normalize_url(u: str) -> str:
+    try:
+        p = urlparse(u)
+        scheme = p.scheme or "https"
+        q = [(k,v) for k,v in parse_qsl(p.query, keep_blank_values=True) if k.lower() not in UTM_KEYS]
+        new_q = urlencode(q, doseq=True)
+        path = p.path or "/"
+        if len(path) > 1 and path.endswith("/"): path = path[:-1]
+        return urlunparse((scheme, p.netloc.lower(), path, "", new_q, ""))
+    except Exception:
+        return u
+
+def is_whitelisted(host: str) -> bool:
+    h = (host or "").lower()
+    return any(h.endswith(d) for d in ACADEMIC_DOMAINS) or any(x in h for x in INSTITUTIONAL_HINTS)
+
+def _is_homepage(url: str) -> bool:
+    return bool(re.match(r"^https?://[^/]+/?$", url or ""))
+
+def rough_lang(text: str) -> str:
+    if not text: return "en"
+    chinese = len([ch for ch in text[:1200] if "\u4e00" <= ch <= "\u9fff"])
+    ratio = chinese / max(1, len(text[:1200]))
+    return "zh" if ratio > 0.02 else "en"
+
+
+# ===== 标题 & HEAD =====
+def fetch_title(html: str) -> str:
+    try:
+        soup = BeautifulSoup(html, "html.parser")
+        t = soup.title.get_text(" ", strip=True) if soup.title else ""
+        return re.sub(r"\s+", " ", t)[:200]
+    except Exception:
+        return ""
+
+def head_content_type(url: str) -> str:
+    try:
+        r = _HTTP.head(url, timeout=8, allow_redirects=True)
+        return r.headers.get("Content-Type", "").lower()
+    except Exception:
+        return ""
+
+
+# ===== 正文抽取 =====
+_BAD_HINTS = ["cookie", "privacy", "subscribe", "登录", "订阅", "广告", "forbidden", "please enable javascript"]
+
+def _extract_pdf_with_trafilatura(url: str) -> str:
+    try:
+        html2 = trafilatura.fetch_url(url)
+        tx = trafilatura.extract(html2) if html2 else ""
+        return (tx or "").strip()
+    except Exception:
+        return ""
+
+def fetch_clean_text(url: str, dimension: str, title_hint: str = "", host: str = ""):
+    # team 放宽高校/医院 PDF
+    ctype = head_content_type(url)
+    is_pdf = "pdf" in ctype or url.lower().endswith(".pdf")
+    allow_pdf = False
+    if is_pdf:
+        if dimension in ("strategy","objectives","feasibility") and is_whitelisted(host):
+            allow_pdf = True
+        if dimension == "team" and (".edu" in host or "university" in host or "hospital" in host):
+            allow_pdf = True
+        if not allow_pdf:
+            return None
+
+    if is_pdf:
+        text_pdf = _extract_pdf_with_trafilatura(url)
+        if not text_pdf:
+            return None
+        text_pdf = re.sub(r"\s+", " ", text_pdf)
+        return text_pdf[:MAX_LEN]
+
+    html = None
+    for r in range(RETRY + 1):
+        try:
+            resp = _HTTP.get(url, timeout=TIMEOUT)
+            if resp.status_code == 200:
+                html = resp.text
+                break
+        except Exception:
+            time.sleep(0.35 * (2 ** r))
+    if not html:
+        return None
+
+    text = ""
+    try:
+        soup = BeautifulSoup(html, "html.parser")
+        main = soup.find(["article","main"]) or soup
+        text = " ".join(p.get_text(" ", strip=True) for p in main.find_all(["p","li"]))
+    except Exception:
+        text = ""
+
+    if len(text) < 180:
+        try:
+            html2 = trafilatura.fetch_url(url)
+            text2 = trafilatura.extract(html2) if html2 else ""
+            if text2 and len(text2) > len(text):
+                text = text2
+        except Exception:
+            pass
+
+    if not text:
+        return None
+
+    text = re.sub(r"\s+", " ", text).strip()
+    low = text.lower()
+    if any(b in low for b in _BAD_HINTS):
+        return None
+
+    min_len = MIN_LEN_BY_DIM.get(dimension, MIN_LEN_BASE)
+    if dimension == "team" and any(k in (title_hint or "").lower() for k in ["team","lab","group","department","faculty","profile"]):
+        min_len = min(min_len, 60)
+
+    lang = rough_lang(text)
+    if lang not in LANG_ALLOW: return None
+    if len(text) < min_len:   return None
+    return text[:MAX_LEN]
+
+
+# ===== 基础搜索器 =====
+def google_search(q, n=8):
+    if not GOOGLE_KEY or not GOOGLE_CX: return []
+    try:
+        r = _HTTP.get("https://www.googleapis.com/customsearch/v1",
+                      params={"key": GOOGLE_KEY, "cx": GOOGLE_CX, "q": q, "num": n}, timeout=TIMEOUT)
+        if r.status_code == 200:
+            items = r.json().get("items", []) or []
+            return [i.get("link") for i in items if i.get("link")]
+    except Exception as e:
+        print(f"⚠️ Google 搜索失败: {e}")
+    return []
+
+def tavily_search(q, n=8):
+    if not client_tavily: return []
+    try:
+        r = client_tavily.search(query=q, max_results=n)
+        return [x.get("url") for x in (r.get("results") or []) if x.get("url")]
+    except Exception as e:
+        if "limit" in str(e).lower():
+            print("⚠️ Tavily 限额已达，降级 DuckDuckGo")
+            return duckduckgo_search_fn(q, n)
+        print(f"⚠️ Tavily 搜索失败: {e}")
+    return []
+
+def duckduckgo_search_fn(q, n=8):
+    if not DDGS: return []
+    try:
+        with DDGS() as d:
+            return [r.get("href") for r in d.text(q, max_results=n) if r.get("href")]
+    except Exception as e:
+        print(f"⚠️ DuckDuckGo 搜索失败: {e}")
+    return []
+
+
+# ===== 学术回补关键词 =====
+ACADEMIC_BACKFILL = {
+    "strategy":   "method OR implementation OR architecture OR workflow",
+    "objectives": '"objective" OR scope OR deliverable OR evaluation',
+    "feasibility":'resource OR timeline OR risk OR dependency OR budget',
+    "innovation": 'novelty OR benchmark OR comparison OR patent',
+    "team":       'team OR expertise OR affiliation OR governance'
+}
+
+
+# ===== 原子写 =====
+def atomic_write(path: Path, obj):
+    tmp = path.with_suffix(path.suffix + ".tmp")
+    tmp.write_text(json.dumps(obj, ensure_ascii=False, indent=2), encoding="utf-8")
+    tmp.replace(path)
+
+
+# ===== 轻量相关性工具 =====
+_WORD_SPLIT = re.compile(r"[^\w\-\./]+")
+
+def _tokenize(s: str):
+    return [t.lower() for t in _WORD_SPLIT.split(s or "") if t]
+
+def _bm25lite_score(text_tokens, query_tokens, k1=1.2, b=0.75):
+    if not text_tokens or not query_tokens: return 0.0
+    tf = Counter(text_tokens)
+    L = len(text_tokens)
+    avgL = 400.0  # 一个经验值：提取后正文常在 400~1500 tokens
+    score = 0.0
+    # 这里没有全语料 idf，只给查询词出现一个固定 idf_boost（出现=1，不出现=0）
+    for q in set(query_tokens):
+        f = tf.get(q, 0)
+        if f == 0:
+            continue
+        idf = 1.6  # 经验常数，保证出现即有显著贡献
+        denom = f + k1 * (1 - b + b * (L / avgL))
+        score += idf * (f * (k1 + 1)) / (denom if denom > 0 else 1.0)
+    # 归一
+    return _clamp(score / 12.0, 0.0, 1.0)
+
+def _phrase_boost(text: str, phrases: list):
+    lo = text.lower()
+    hits = 0
+    for p in phrases or []:
+        p = str(p or "").lower().strip()
+        if not p: continue
+        if p in lo:
+            hits += 1
+    # 每命中一个短语 +0.12，上限 1.0
+    return _clamp(hits * 0.12, 0.0, 1.0)
+
+def _relevance_score(item, query: str, hints, dimension: str):
+    text = item.get("text","") or ""
+    domain = item.get("domain","") or ""
+    toks_text = _tokenize(text)
+    toks_q    = _tokenize(query)
+
+    # must-have、hints 合起来算短语 boost
+    musts = MUST_HAVE_BY_DIM.get(dimension.lower(), [])
+    phrases = (hints or [])[:6] + musts
+    bm25p  = _bm25lite_score(toks_text, toks_q)
+    pboost = _phrase_boost(text, phrases)
+    dens   = info_density_score(text)
+    src    = source_confidence(domain)
+    wl     = 0.07 if is_whitelisted(domain) else 0.0
+
+    # 线性融合：可通过环境变量微调
+    w_src  = float(os.getenv("WEB_RR_W_SRC", "0.45"))
+    w_den  = float(os.getenv("WEB_RR_W_DEN", "0.20"))
+    w_bm25 = float(os.getenv("WEB_RR_W_BM25","0.25"))
+    w_phra = float(os.getenv("WEB_RR_W_PHRA","0.10"))
+    score  = (w_src*src + w_den*dens + w_bm25*bm25p + w_phra*pboost + wl)
+    return _clamp(score, 0.0, 1.0)
+
+def _shingles(text: str, n=7):
+    toks = _tokenize(text)
+    return set(tuple(toks[i:i+n]) for i in range(0, max(0, len(toks)-n+1)))
+
+def _jaccard(a: set, b: set):
+    if not a or not b: return 0.0
+    inter = len(a & b); union = len(a | b)
+    return (inter / union) if union else 0.0
+
+
+# ===== 主函数（保持签名）=====
+def simple_search(query, max_results=8, dimension="general", hints=None, source="LLM"):
+    raw_q = (query or "").strip()
+    query = re.sub(r"\s+", " ", raw_q)
+
+    # ---- Query 智能拼接（避免重复注入）----
+    qlower = query.lower()
+    has_site   = " site:" in qlower or " site(" in qlower
+    has_year   = re.search(r"\b(19|20)\d{2}\.\.(19|20)\d{2}\b", qlower) is not None
+    has_neg    = any(tok in qlower for tok in [" -news", " -press", " -blog", " -forum", " -finance", " -jobs"])
+    neg = NEGATIVE_BY_DIM.get(dimension.lower(), "")
+    if has_neg:  # 用户已带负向，则不重复注入
+        neg = ""
+    suffix_map = {
+        "team": "(team expertise OR affiliation OR governance OR profile)",
+        "objectives": "(objective OR scope OR deliverable OR evaluation)",
+        "strategy": "(method OR workflow OR implementation OR architecture)",
+        "innovation": "(novelty OR benchmark OR differentiation OR prior work)",
+        "feasibility": "(resource OR timeline OR risk OR dependency OR budget)"
+    }
+    suffix = suffix_map.get(dimension.lower(), "")
+
+    site_hint = ""
+    if (dimension.lower() in ("strategy","feasibility","objectives")) and not has_site:
+        site_hint = ""
+
+    # 若 query 已含时间窗则尊重
+    full_query = f"{query} {suffix} {neg} {site_hint}".strip()
+    full_query = re.sub(r"\s+", " ", full_query)
+    print(f"\n🔍 [{source}] 维度 {dimension} 搜索: {full_query}")
+
+    proposal_id = os.getenv("CURRENT_PROPOSAL_ID", "default")
+    results_dir = Path(f"src/data/evidence/{proposal_id}")
+    results_dir.mkdir(parents=True, exist_ok=True)
+
+    combined_path = results_dir / f"{dimension}_combined.json"
+    cache_file = results_dir / f"{dimension}_cache.json"
+    debug_path = results_dir / f"{dimension}_debug_stats.json"
+    diag_path = results_dir / f"{dimension}_diag.json"
+
+    diag_rows = []
+    dbg = defaultdict(int)
+
+    # === 缓存命中（不覆盖 combined；空缓存不落盘）===
+    cache = json.loads(cache_file.read_text(encoding="utf-8")) if cache_file.exists() else {}
+    cache_key = f"{dimension}::{hashlib.md5(full_query.encode('utf-8')).hexdigest()[:10]}"
+    if cache_key in cache:
+        print("🧠 命中缓存")
+        cached_items = cache[cache_key] or []
+        existing = []
+        if combined_path.exists():
+            try:
+                existing = json.loads(combined_path.read_text(encoding="utf-8"))
+            except Exception:
+                existing = []
+        seen = set(x.get("url") for x in existing if isinstance(x, dict))
+        merged = list(existing)
+        for item in cached_items:
+            u = (item or {}).get("url")
+            if u and u not in seen:
+                merged.append(item); seen.add(u)
+        if cached_items:
+            # 排序：若启用 rerank，则对 merged 重排（只改变顺序，不过滤）
+            if RERANK_ENABLE:
+                merged = _sort_by_relevance(merged, full_query, hints, dimension)
+            atomic_write(combined_path, merged)
+
+        texts = [i.get("text","") for i in cached_items if isinstance(i, dict)]
+        urls  = [i.get("url","")  for i in cached_items if isinstance(i, dict)]
+        return texts, urls
+
+    # === 三层检索 ===
+    urls = []
+    for idx, fn in enumerate((google_search, tavily_search, duckduckgo_search_fn), start=1):
+        try:
+            got = fn(full_query, max_results)
+            dbg[f"api_{fn.__name__}_urls"] += len(got)
+            urls.extend(got)
+            if len(urls) >= max_results: break
+        except Exception:
+            pass
+        time.sleep(0.25 * idx)
+    dbg["urls_found_by_api"] = len(urls)
+
+    # 归一化/去重/屏蔽
+    norm_urls, seen = [], set()
+    for u in urls:
+        if not u: continue
+        nu = normalize_url(u)
+        host = (urlparse(nu).hostname or "").lower()
+        if (not host) or any(b in host for b in BLOCK_HOSTS):
+            dbg["filtered_block_host"] += 1; continue
+        if nu not in seen:
+            norm_urls.append(nu); seen.add(nu)
+    dbg["urls_after_normalize"] = len(norm_urls)
+
+    # 过少则二次尝试：中文强化
+    if len(norm_urls) < max_results // 2:
+        q2 = f"{query} 项目 研究 方法 风险 2019..2025"
+        more = duckduckgo_search_fn(q2, max_results)
+        for u in more:
+            nu = normalize_url(u)
+            host = (urlparse(nu).hostname or "").lower()
+            if nu not in seen and host and not any(b in host for b in BLOCK_HOSTS):
+                norm_urls.append(nu); seen.add(nu)
+        dbg["urls_after_backoff_add"] = len(norm_urls)
+
+    if not norm_urls:
+        print("❌ 无搜索结果")
+        atomic_write(combined_path, []); atomic_write(debug_path, dict(dbg))
+        return [], []
+
+    # === 抓取正文 ===
+    extracted = []
+    host_seen = defaultdict(int)
+    _host_seen_lock = threading.Lock()
+
+    def fetch_one(u):
+        host = (urlparse(u).hostname or "").lower()
+        whitelisted = is_whitelisted(host)
+        if _is_homepage(u) and not whitelisted:
+            return None, ("filtered_homepage", u)
+        with _host_seen_lock:
+            if host_seen[host] >= HOST_QUOTA and not whitelisted:
+                return None, ("filtered_host_quota", u)
+
+        title = ""
+        try:
+            r = _HTTP.get(u, timeout=TIMEOUT)
+            if r.status_code != 200:
+                return None, ("fetch_non200", u)
+            title = fetch_title(r.text)
+        except Exception:
+            pass
+
+        text = fetch_clean_text(u, dimension=dimension, title_hint=title, host=host)
+        if not text:
+            return None, ("filtered_by_rules", u)
+
+        mhs_base = MUST_HAVE_BY_DIM.get(dimension.lower(), [])
+        hints_low = (hints or [])[:3] if isinstance(hints, list) else []
+        mhs = [tok for tok in (mhs_base + hints_low) if isinstance(tok, str) and tok.strip()]
+
+        if MUST_HAVE_STRICT and mhs and not whitelisted:
+            low = text.lower()
+            if not any(tok.lower() in low for tok in mhs):
+                # 宽松兜底：若文本信息密度很高（≥0.6），且标题/域名具备研究/学院线索，则��行
+                if info_density_score(text) >= 0.60 and any(key in (title.lower()+" "+host) for key in ["lab","faculty","research","university","hospital"]):
+                    pass
+                else:
+                    return None, ("filtered_must_have_miss", u)
+
+        with _host_seen_lock:
+            host_seen[host] += 1
+
+        conf_base = source_confidence(host)
+        conf = _clamp(conf_base + 0.25 * info_density_score(text) + (0.05 if whitelisted else 0.0))
+        text = text.encode("utf-8","ignore").decode("utf-8","ignore")
+        return {"url": u, "text": text, "domain": host, "confidence": conf, "len": len(text)}, None
+
+    with ThreadPoolExecutor(max_workers=MAX_WORKERS) as ex:
+        futures = [ex.submit(fetch_one, u) for u in norm_urls[:max_results * 2]]
+        for f in as_completed(futures):
+            r, reason = f.result()
+            if r:
+                extracted.append(r); dbg["fetch_ok"] += 1
+            else:
+                if reason:
+                    dbg[reason[0]] += 1
+                    if len(diag_rows) < 400:
+                        diag_rows.append({"url": reason[1], "reason": reason[0]})
+
+    # 学术回补
+    academic_hits = [x for x in extracted if any(ad in x["domain"] for ad in ACADEMIC_DOMAINS)]
+    if len(academic_hits) < EARLY_ACADEMIC_MIN.get(dimension, 2):
+        print("🧠 学术来源过少，触发 Academic 回补...")
+        bf = ACADEMIC_BACKFILL.get(dimension, "")
+        scholar_query = f'{query} ({bf}) site:(' + " OR ".join(ACADEMIC_DOMAINS[:10]) + ") 2019..2025"
+        more = google_search(scholar_query, 10)
+        for u in more:
+            nu = normalize_url(u)
+            host = (urlparse(nu).hostname or "").lower()
+            if nu in {x["url"] for x in extracted}: continue
+            with _host_seen_lock:
+                over = host_seen[host] >= HOST_QUOTA and not is_whitelisted(host)
+            if over:
+                continue
+            t = fetch_clean_text(nu, dimension=dimension, host=host)
+            if t and len(t) >= MIN_LEN_BASE:
+                extracted.append({"url": nu, "text": t, "domain": host, "confidence": 0.99, "len": len(t)})
+                with _host_seen_lock:
+                    host_seen[host] += 1
+                if len([x for x in extracted if any(ad in x["domain"] for ad in ACADEMIC_DOMAINS)]) >= EARLY_ACADEMIC_MIN.get(dimension, 2):
+                    break
+
+    if not extracted:
+        print("❌ 未抓取到正文。")
+        atomic_write(combined_path, []); atomic_write(debug_path, dict(dbg))
+        if diag_rows: atomic_write(diag_path, diag_rows)
+        return [], []
+
+    # === （新增）近重复抑制 + 相关性排序 ===
+    extracted_proc = extracted
+    if DEDUP_ENABLE:
+        extracted_proc = []
+        shingle_bank = []
+        for item in extracted:
+            s = _shingles(item.get("text",""), n=7)
+            if not s:
+                extracted_proc.append(item); shingle_bank.append(s); continue
+            similar = False
+            for prev in shingle_bank:
+                if not prev: continue
+                if _jaccard(s, prev) >= DEDUP_JACCARD:
+                    similar = True; break
+            if not similar:
+                extracted_proc.append(item); shingle_bank.append(s)
+
+    if RERANK_ENABLE:
+        extracted_proc = _sort_by_relevance(extracted_proc, full_query, hints, dimension)
+
+    # === 合并去重（按 URL）===
+    existing = []
+    if combined_path.exists():
+        try: existing = json.loads(combined_path.read_text(encoding="utf-8"))
+        except Exception: existing = []
+    union = existing + extracted_proc
+    seen_urls, merged = set(), []
+    for item in union:
+        u = item.get("url")
+        if u and u not in seen_urls:
+            merged.append(item); seen_urls.add(u)
+
+    # 重排 merged 顺序（不丢数据，只调整排序）
+    if RERANK_ENABLE:
+        merged = _sort_by_relevance(merged, full_query, hints, dimension)
+
+    # === 写 combined & cache ===
+    atomic_write(combined_path, merged)
+    cache[cache_key] = merged
+    atomic_write(cache_file, cache)
+
+    # === 统计 ===
+    academic_hits = [x for x in merged if any(ad in x["domain"] for ad in ACADEMIC_DOMAINS)]
+    avg_conf = round(sum(x["confidence"] for x in merged) / len(merged), 2) if merged else 0
+    ratio = round((len(academic_hits) / len(merged)), 2) if merged else 0.0
+    print(f"✅ 抓取完成：{len(merged)} 条 | 平均置信度 {avg_conf} | 学术比例 {ratio:.0%}")
+    print(f"🔝 Top 域名: {Counter([x['domain'] for x in merged]).most_common(5)}")
+
+    dbg["kept_total"] = len(merged); dbg["academic_hits"] = len(academic_hits)
+    atomic_write(debug_path, dict(dbg))
+    if diag_rows: atomic_write(diag_path, diag_rows)
+
+    # === 维度摘要（保持不变）===
+    try:
+        if merged and LLM_CLIENT:
+            joined = "\n\n".join(x["text"][:600] for x in merged[:3])
+            refs = "\n".join([f"[{i+1}] {x['url']}" for i, x in enumerate(merged[:3])])
+            prompt = (
+                f"请基于以下网页内容，总结维度 {dimension} 的关键信息（120~160字，学术语气，避免夸大/臆测；涉及年份/批准必须引用 [x]）。\n\n"
+                f"{joined}\n\n参考：\n{refs}"
+            )
+            res = LLM_CLIENT.chat_completions.create(  # 兼容某些 SDK 写法差异
+                model=LLM_MODEL, messages=[{"role": "user", "content": prompt}], temperature=0.3,
+            ) if hasattr(LLM_CLIENT, "chat_completions") else LLM_CLIENT.chat.completions.create(
+                model=LLM_MODEL, messages=[{"role": "user", "content": prompt}], temperature=0.3,
+            )
+            summary = (res.choices[0].message.content or "").strip()
+            atomic_write(results_dir / f"{dimension}_summary.json", {
+                "dimension": dimension, "summary": summary,
+                "urls": [x['url'] for x in merged], "avg_conf": avg_conf, "academic_ratio": ratio
+            })
+    except Exception as e:
+        print(f"⚠️ 摘要生成失败: {e}")
+
+    texts = [x["text"] for x in merged]
+    urls_extracted = [x["url"] for x in merged]
+    return texts, urls_extracted
+
+
+# ===== 排序主函数（集中定义，便于切换算法）=====
+def _sort_by_relevance(items, query, hints, dimension):
+    scored = []
+    for it in items:
+        s = _relevance_score(it, query, hints, dimension)
+        # 提升与维度 Must-Have 命中数（用于 tie-break）
+        mh = 0
+        low = (it.get("text","") or "").lower()
+        for tok in MUST_HAVE_BY_DIM.get(dimension.lower(), []):
+            if tok.lower() in low:
+                mh += 1
+        scored.append((s, mh, it))
+    # 先按得分，再按 must-have 命中数，最后轻微倾向更长文本
+    scored.sort(key=lambda x: (x[0], x[1], min(2600, x[2].get("len",0))), reverse=True)
+    return [it for _,__,it in scored]

src/backend/utils/model_selector.py

@@ -0,0 +1,64 @@
+# -*- coding: utf-8 -*-
+"""
+通用模型选择器（v5.1 · 兼容新旧 Gemini SDK + 明确 Key 优先级）
+- PROVIDER: openai / deepseek / gemini
+- 返回: {"client": <client_instance>, "model_name": str, "provider": str}
+"""
+
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+def get_llm_client():
+    provider = (os.getenv("PROVIDER", "openai") or "openai").lower().strip()
+
+    # ========== OpenAI ==========
+    if provider in ("openai", "chatgpt"):
+        from openai import OpenAI
+        api_key = os.getenv("OPENAI_API_KEY")
+        if not api_key:
+            raise RuntimeError("OPENAI_API_KEY 未配置")
+        client = OpenAI(api_key=api_key)
+        model_name = os.getenv("OPENAI_MODEL", "gpt-4o-mini")
+        print(f"✅ 已加载 OpenAI 模型：{model_name}")
+        return {"client": client, "model_name": model_name, "provider": "openai"}
+
+    # ========== DeepSeek ==========
+    elif provider == "deepseek":
+        from openai import OpenAI
+        api_key = os.getenv("DEEPSEEK_API_KEY")
+        if not api_key:
+            raise RuntimeError("DEEPSEEK_API_KEY 未配置")
+        client = OpenAI(api_key=api_key, base_url="https://api.deepseek.com/v1")
+        model_name = os.getenv("DEEPSEEK_MODEL", "deepseek-chat")
+        print(f"✅ 已加载 DeepSeek 模型：{model_name}")
+        return {"client": client, "model_name": model_name, "provider": "deepseek"}
+
+    # ========== Gemini ==========
+    elif provider == "gemini":
+        # 统一优先 GEMINI_API_KEY；若仅有 GOOGLE_API_KEY 也做兜底
+        api_key = (os.getenv("GEMINI_API_KEY") or os.getenv("GOOGLE_API_KEY") or "").strip()
+        if not api_key:
+            raise RuntimeError("GEMINI_API_KEY 未配置（未找到 GOOGLE_API_KEY 兜底）")
+
+        # 兼容新旧 SDK：优先使用新 SDK（from google import genai），失败则回退到 google.generativeai
+        client = None
+        try:
+            from google import genai  # 新 SDK
+            client = genai.Client(api_key=api_key)
+            using_new = True
+        except Exception:
+            import google.generativeai as genai  # 旧 SDK
+            genai.configure(api_key=api_key)
+            # 旧 SDK 没有 Client 实例的语义，这里用模块本身作为“客户端”占位
+            client = genai
+            using_new = False
+
+        model_name = os.getenv("GEMINI_MODEL", "gemini-2.5-flash").strip()
+        suffix = "（新SDK）" if using_new else "（旧SDK）"
+        print(f"✅ 已加载 Gemini 模型：{model_name} {suffix}")
+        return {"client": client, "model_name": model_name, "provider": "gemini"}
+
+    else:
+        raise ValueError(f"❌ 未知 PROVIDER：{provider}（应为 openai / deepseek / gemini）")

src/main.py

@@ -0,0 +1,47 @@
+from dotenv import load_dotenv
+load_dotenv()
+
+import os
+import json
+import argparse
+
+from backend.chains.base_chain import BaseChain
+from backend.chains.orchestrator import run_all, save_full_report
+
+def parse_args():
+    p = argparse.ArgumentParser(description="RAG-6View CLI")
+    p.add_argument("--mode", choices=["single", "all"], default="all",
+                   help="single=只跑一个维度; all=并行跑所有维度")
+    p.add_argument("--dimension", default="team", help="在 single 模式下指定维度")
+    p.add_argument("--question", default=None, help="自定义问题(可选)")
+    p.add_argument("--max_workers", type=int, default=3, help="并行线程数")
+    return p.parse_args()
+
+def run_single(dim: str, question: str = None):
+    print("🚀 Starting RAG Demo (Single)...")
+    chain = BaseChain(dim)
+    q = question or "Does the core team have strong research capability?"
+    result = chain.run(q)
+    os.makedirs("data/results", exist_ok=True)
+    out = "data/results/single_result.json"
+    with open(out, "w", encoding="utf-8") as f:
+        json.dump(result, f, indent=2, ensure_ascii=False)
+    print(f"\n✅ 单维度分析完成！结果已保存到: {out}")
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+
+def run_all_dims(max_workers: int):
+    print("🚀 Starting RAG Demo (ALL Dimensions, parallel)...")
+    report = run_all(max_workers=max_workers)
+    out_path = save_full_report(report)
+    print(f"\n✅ 全维度分析完成！报告已保存到: {out_path}")
+    print(json.dumps(report["summary"], indent=2, ensure_ascii=False))
+
+def main():
+    args = parse_args()
+    if args.mode == "single":
+        run_single(args.dimension, args.question)
+    else:
+        run_all_dims(args.max_workers)
+
+if __name__ == "__main__":
+    main()

src/profiling/domain_profiler.py

@@ -0,0 +1,83 @@
+# -*- coding: utf-8 -*-
+from __future__ import annotations
+
+import argparse
+import json
+import os
+from pathlib import Path
+from typing import Any, Dict
+
+from dotenv import load_dotenv
+from openai import OpenAI
+
+from src.prompting.domain_adaptive import PROFILER_SYSTEM_PROMPT, sanitize_domain_profile
+
+load_dotenv()
+BASE_DIR = Path(__file__).resolve().parents[2]
+DATA_DIR = BASE_DIR / "src" / "data"
+PREPARED_DIR = DATA_DIR / "prepared"
+EXTRACTED_DIR = DATA_DIR / "extracted"
+OPENAI_MODEL = os.getenv("OPENAI_MODEL", "gpt-4o-mini")
+
+
+def detect_latest_pid() -> str:
+    if not PREPARED_DIR.exists():
+        return "unknown"
+    dirs = [d for d in PREPARED_DIR.iterdir() if d.is_dir()]
+    if not dirs:
+        return "unknown"
+    dirs.sort(key=lambda p: p.stat().st_mtime, reverse=True)
+    return dirs[0].name
+
+
+def load_source_text(pid: str) -> str:
+    for candidate in [PREPARED_DIR / pid / "full_text.txt", EXTRACTED_DIR / pid / "dimensions_v2.json"]:
+        if candidate.exists() and candidate.suffix == '.txt':
+            return candidate.read_text(encoding='utf-8', errors='ignore')[:18000]
+    dim_path = EXTRACTED_DIR / pid / "dimensions_v2.json"
+    if dim_path.exists():
+        return dim_path.read_text(encoding='utf-8', errors='ignore')[:18000]
+    raise FileNotFoundError(f"No source text found for proposal_id={pid}")
+
+
+def profile_with_llm(text: str) -> Dict[str, Any]:
+    client = OpenAI()
+    resp = client.chat.completions.create(
+        model=OPENAI_MODEL,
+        messages=[
+            {"role": "system", "content": PROFILER_SYSTEM_PROMPT},
+            {"role": "user", "content": text},
+        ],
+        response_format={"type": "json_object"},
+        temperature=0.0,
+        max_tokens=900,
+    )
+    raw = resp.choices[0].message.content
+    try:
+        data = json.loads(raw)
+    except Exception:
+        data = {}
+    return sanitize_domain_profile(data)
+
+
+def run_domain_profiler(proposal_id: str) -> Path:
+    text = load_source_text(proposal_id)
+    profile = profile_with_llm(text)
+    out_dir = EXTRACTED_DIR / proposal_id
+    out_dir.mkdir(parents=True, exist_ok=True)
+    out_path = out_dir / 'domain_profile.json'
+    out_path.write_text(json.dumps(profile, ensure_ascii=False, indent=2), encoding='utf-8')
+    print(f"🧭 Domain profile saved -> {out_path}")
+    return out_path
+
+
+def main():
+    ap = argparse.ArgumentParser(description='Generate domain_profile.json for the current proposal')
+    ap.add_argument('--proposal_id', type=str, default='')
+    args = ap.parse_args()
+    pid = args.proposal_id.strip() or detect_latest_pid()
+    run_domain_profiler(pid)
+
+
+if __name__ == '__main__':
+    main()

src/prompting/domain_adaptive.py

@@ -0,0 +1,354 @@
+# -*- coding: utf-8 -*-
+from __future__ import annotations
+
+GLOBAL_PROMPT_SUFFIX = """
+If quantitative metrics are not explicitly provided, do not penalize the proposal by default.
+Instead, infer quality from contextual evidence, domain knowledge, and implicit signals.
+""".strip()
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, List
+
+DIM_ORDER = ["team", "objectives", "strategy", "innovation", "feasibility"]
+
+UNIVERSAL_REVIEW_TEMPLATES: Dict[str, Dict[str, Any]] = {
+    "T1_problem": {
+        "title": "Problem / Need / Motivation",
+        "dimension": "objectives",
+        "question_template": (
+            "Assess whether the proposal addresses an important and well-motivated problem. "
+            "Pay special attention to: {evaluation_focus.problem}. "
+            "Respect domain terminology: {terminology}. "
+            + GLOBAL_PROMPT_SUFFIX
+        ),
+    },
+    "T2_objectives": {
+        "title": "Objectives / Scope",
+        "dimension": "objectives",
+        "question_template": (
+            "Assess whether the proposal objectives are clear, specific, and appropriately scoped. "
+            "Pay special attention to: {evaluation_focus.objectives}. "
+            "Respect domain terminology: {terminology}. "
+            + GLOBAL_PROMPT_SUFFIX
+        ),
+    },
+    "T3_methods": {
+        "title": "Methods / Technical Approach",
+        "dimension": "strategy",
+        "question_template": (
+            "Assess whether the proposed methods or technical approach are coherent and fit the objectives. "
+            "Method signals: {methods}. "
+            "Respect domain terminology: {terminology}. "
+            + GLOBAL_PROMPT_SUFFIX
+        ),
+    },
+    "T4_evidence": {
+        "title": "Evidence / Data / Resources",
+        "dimension": "feasibility",
+        "question_template": (
+            "Assess whether the proposal provides adequate evidence, data, resources, or enabling conditions to support the work. "
+            "Method signals: {methods}. "
+            "Respect domain terminology: {terminology}. "
+            + GLOBAL_PROMPT_SUFFIX
+        ),
+    },
+    "T5_feasibility": {
+        "title": "Feasibility / Execution",
+        "dimension": "feasibility",
+        "question_template": (
+            "Assess whether the work appears executable in practice. "
+            "Pay special attention to: {evaluation_focus.feasibility}. "
+            "Risk signals: {risks}. "
+            + GLOBAL_PROMPT_SUFFIX
+        ),
+    },
+    "T6_innovation": {
+        "title": "Innovation / Differentiation",
+        "dimension": "innovation",
+        "question_template": (
+            "Assess the novelty or differentiating contribution of the proposal. "
+            "Pay special attention to: {evaluation_focus.innovation}. "
+            "Respect domain terminology: {terminology}. "
+            + GLOBAL_PROMPT_SUFFIX
+        ),
+    },
+    "T7_risks": {
+        "title": "Risks / Failure Modes / Mitigation",
+        "dimension": "feasibility",
+        "question_template": (
+            "Identify the major risks and evaluate whether mitigation thinking is credible. "
+            "Risk signals: {risks}. "
+            "Method signals: {methods}. "
+            + GLOBAL_PROMPT_SUFFIX
+        ),
+    },
+    "T8_team": {
+        "title": "Team / Capability / Governance",
+        "dimension": "team",
+        "question_template": (
+            "Assess whether the team and governance setup are adequate for the proposed work. "
+            "Pay special attention to: {evaluation_focus.team}. "
+            "Respect domain terminology: {terminology}. "
+            + GLOBAL_PROMPT_SUFFIX
+        ),
+    },
+    "T9_outcomes": {
+        "title": "Outcomes / Impact / Evaluation",
+        "dimension": "objectives",
+        "question_template": (
+            "Assess whether the expected outcomes, impact claims, and evaluation logic are credible. "
+            "Pay special attention to: {evaluation_focus.outcomes}. "
+            "Respect domain terminology: {terminology}. "
+            + GLOBAL_PROMPT_SUFFIX
+        ),
+    },
+}
+
+ALLOWED_SLOTS = {
+    "evaluation_focus.problem",
+    "evaluation_focus.objectives",
+    "evaluation_focus.feasibility",
+    "evaluation_focus.innovation",
+    "evaluation_focus.team",
+    "evaluation_focus.outcomes",
+    "methods",
+    "risks",
+    "terminology",
+}
+
+TEMPLATE_SLOT_MAP = {
+    "T1_problem": ["evaluation_focus.problem", "terminology"],
+    "T2_objectives": ["evaluation_focus.objectives", "terminology"],
+    "T3_methods": ["methods", "terminology"],
+    "T4_evidence": ["methods", "terminology"],
+    "T5_feasibility": ["evaluation_focus.feasibility", "risks"],
+    "T6_innovation": ["evaluation_focus.innovation", "terminology"],
+    "T7_risks": ["risks", "methods"],
+    "T8_team": ["evaluation_focus.team", "terminology"],
+    "T9_outcomes": ["evaluation_focus.outcomes", "terminology"],
+}
+
+
+@dataclass(frozen=True)
+class ReviewTask:
+    task_id: str
+    template_id: str
+    dimension: str
+    title: str
+
+
+REVIEW_TASKS: List[ReviewTask] = [
+    ReviewTask("problem", "T1_problem", "objectives", "Problem significance"),
+    ReviewTask("objectives", "T2_objectives", "objectives", "Objectives and scope"),
+    ReviewTask("methods", "T3_methods", "strategy", "Methods and approach"),
+    ReviewTask("evidence", "T4_evidence", "feasibility", "Evidence and resources"),
+    ReviewTask("feasibility", "T5_feasibility", "feasibility", "Execution feasibility"),
+    ReviewTask("innovation", "T6_innovation", "innovation", "Innovation"),
+    ReviewTask("risks", "T7_risks", "feasibility", "Risks and mitigation"),
+    ReviewTask("team", "T8_team", "team", "Team and governance"),
+    ReviewTask("outcomes", "T9_outcomes", "objectives", "Outcomes and evaluation"),
+]
+
+QUESTION_SEARCH_HINTS = {
+    "team": ["team expertise", "roles and responsibilities", "governance"],
+    "objectives": ["problem significance", "scope", "outcomes", "evaluation"],
+    "strategy": ["methods", "technical approach", "workflow"],
+    "innovation": ["novelty", "differentiation", "prior work"],
+    "feasibility": ["resources", "risks", "execution plan", "dependencies"],
+}
+
+PROFILER_SYSTEM_PROMPT = """
+You are a strict domain profiler for proposal review.
+
+Your task is ONLY to derive a clean domain profile from the CURRENT document text.
+
+Rules:
+- Use ONLY the provided document text.
+- Ignore any prior tasks, prior files, templates, examples, cached memory, or default domains.
+- Do not rewrite the proposal.
+- Do not generate review questions.
+- Do not invent domain details not supported by the text.
+- Prefer broad domain labels over overly specific labels.
+- Keep all lists short, concrete, and normalized.
+- If evidence is weak, return "unknown".
+- Return valid JSON only.
+
+Return JSON with this structure:
+{
+  "domain": {
+    "primary": "string",
+    "secondary": ["string"]
+  },
+  "evaluation_focus": {
+    "problem": ["string"],
+    "objectives": ["string"],
+    "feasibility": ["string"],
+    "innovation": ["string"],
+    "team": ["string"],
+    "outcomes": ["string"]
+  },
+  "methods": ["string"],
+  "risks": ["string"],
+  "terminology": ["string"]
+}
+""".strip()
+
+
+def normalize_list(items: Any, max_items: int = 6) -> List[str]:
+    if items is None:
+        return []
+
+    if isinstance(items, str):
+        items = [items]
+    elif not isinstance(items, (list, tuple, set)):
+        items = [items]
+
+    # Step 1: 基础清洗
+    cleaned = []
+    for item in items:
+        text = " ".join(str(item).split()).strip()
+        if not text:
+            continue
+
+        # 去掉纯标点（关键修复）
+        if text in {"、", ";", "；", ",", ".", "。"}:
+            continue
+
+        cleaned.append(text)
+
+    # Step 2: 合并“单字碎片”（核心修复）
+    merged = []
+    buffer = ""
+
+    for token in cleaned:
+        # 如果是单个中文字符 → 拼接
+        if len(token) == 1 and '\u4e00' <= token <= '\u9fff':
+            buffer += token
+        else:
+            if buffer:
+                merged.append(buffer)
+                buffer = ""
+            merged.append(token)
+
+    if buffer:
+        merged.append(buffer)
+
+    # Step 3: 去重 + 限制长度
+    seen, out = set(), []
+    for text in merged:
+        key = text.lower()
+        if key in seen:
+            continue
+        seen.add(key)
+        out.append(text)
+
+        if len(out) >= max_items:
+            break
+    return out
+
+
+def _resolve(profile: Dict[str, Any], slot: str) -> str:
+    node: Any = profile
+    for part in slot.split("."):
+        if not isinstance(node, dict):
+            return "not specified in domain profile"
+        node = node.get(part)
+        if node is None:
+            return "not specified in domain profile"
+
+    if isinstance(node, list):
+        vals = normalize_list(node)
+        return "; ".join(vals) if vals else "not specified in domain profile"
+
+    if isinstance(node, str):
+        text = " ".join(node.split()).strip()
+        return text or "not specified in domain profile"
+
+    text = " ".join(str(node).split()).strip()
+    return text or "not specified in domain profile"
+
+
+def sanitize_domain_profile(profile: Dict[str, Any]) -> Dict[str, Any]:
+    if not isinstance(profile, dict):
+        profile = {}
+
+    domain = profile.get("domain") if isinstance(profile.get("domain"), dict) else {}
+    eval_focus = profile.get("evaluation_focus") if isinstance(profile.get("evaluation_focus"), dict) else {}
+
+    primary = " ".join(str(domain.get("primary", "unknown")).split()).strip() or "unknown"
+    bad_domains = {
+        "general proposal",
+        "general",
+        "unknown",
+        "misc",
+        "other",
+        "n/a",
+        "na",
+    }
+    if primary.lower() in bad_domains:
+        primary = "unknown"
+
+    methods = normalize_list(profile.get("methods", []), max_items=6)
+    risks = normalize_list(profile.get("risks", []), max_items=6)
+    terminology = normalize_list(profile.get("terminology", []), max_items=12)
+
+    # 如果 methods / risks 太碎，就尽量用 terminology 补救
+    def _too_fragmented(values: List[str]) -> bool:
+        if not values:
+            return True
+        short_count = len([x for x in values if len(x) <= 1])
+        return short_count >= max(2, len(values) // 2 + 1)
+
+    if _too_fragmented(methods):
+        fallback_methods = [t for t in terminology if len(t) >= 2][:6]
+        if fallback_methods:
+            methods = fallback_methods
+
+    if _too_fragmented(risks):
+        fallback_risks = [t for t in terminology if len(t) >= 2][:6]
+        if fallback_risks:
+            risks = fallback_risks
+
+    return {
+        "domain": {
+            "primary": primary,
+            "secondary": normalize_list(domain.get("secondary", []), max_items=4),
+        },
+        "evaluation_focus": {
+            "problem": normalize_list(eval_focus.get("problem", []), max_items=5),
+            "objectives": normalize_list(eval_focus.get("objectives", []), max_items=5),
+            "feasibility": normalize_list(eval_focus.get("feasibility", []), max_items=5),
+            "innovation": normalize_list(eval_focus.get("innovation", []), max_items=5),
+            "team": normalize_list(eval_focus.get("team", []), max_items=5),
+            "outcomes": normalize_list(eval_focus.get("outcomes", []), max_items=5),
+        },
+        "methods": methods,
+        "risks": risks,
+        "terminology": terminology,
+    }
+
+
+def inject_template(template_id: str, profile: Dict[str, Any]) -> str:
+    template = UNIVERSAL_REVIEW_TEMPLATES[template_id]["question_template"]
+    safe_profile = sanitize_domain_profile(profile)
+    rendered = template
+    for slot in TEMPLATE_SLOT_MAP[template_id]:
+        rendered = rendered.replace("{" + slot + "}", _resolve(safe_profile, slot))
+    return rendered
+
+
+def build_specialized_question(task: ReviewTask, profile: Dict[str, Any]) -> str:
+    injected = inject_template(task.template_id, profile)
+    return f"[{task.title}] {injected}"
+
+
+def load_domain_profile(path: Path) -> Dict[str, Any]:
+    if not path.exists():
+        return sanitize_domain_profile({})
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return sanitize_domain_profile({})
+    return sanitize_domain_profile(data)

src/tools/ai_expert_opinion.py

@@ -0,0 +1,875 @@
+# -*- coding: utf-8 -*-
+"""
+AI Expert Opinion · v4.1
+(dimension-first, QA-grounded, general_insights-aware, with local fallback)
+--------------------------------------------------------------------
+设计目标：
+- 严格基于 post_processing_v2 的 metrics.json + final_payload.json（已选中答案）
+- 先对五个维度逐一做“带证据 + 领域通识层”的专家点评，再在本地代码中汇总成总体意见
+- 不让 LLM 看到任何具体分数，仅提供“强/中/弱”的文字提示，避免分数泄漏
+- 默认调用 OpenAI（.env 中的 OPENAI_*），无法调用时自动退化为“纯本地规则版专家评审”（不依赖 LLM）
+- 总体意见采用「一段总括 + 分维度 bullet」形式，更适合给人看
+"""
+
+import os
+import re
+import json
+import time
+import argparse
+from pathlib import Path
+from datetime import datetime
+from typing import Dict, Any, List, Tuple
+
+import requests
+from dotenv import load_dotenv
+
+# ----------------- 路径与常量 -----------------
+BASE_DIR = Path(__file__).resolve().parents[2]
+DATA_DIR = BASE_DIR / "src" / "data"
+REFINED_ROOT = DATA_DIR / "refined_answers"
+EXPERT_DIR = DATA_DIR / "expert_reports"
+
+DIM_ORDER = ["team", "objectives", "strategy", "innovation", "feasibility"]
+DIM_LABELS_ZH = {
+    "team": "团队与治理",
+    "objectives": "项目目标",
+    "strategy": "实施路径与战略",
+    "innovation": "技术与产品创新",
+    "feasibility": "资源与可行性"
+}
+
+# ----------------- 环境变量 -----------------
+load_dotenv()
+PROVIDER = os.getenv("PROVIDER", "openai").strip().lower()
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "").strip()
+OPENAI_API_BASE = os.getenv("OPENAI_API_BASE", "https://api.openai.com/v1").strip()
+OPENAI_MODEL = os.getenv("OPENAI_MODEL", "gpt-4o-mini").strip()
+TIMEOUT_CONNECT = int(os.getenv("HTTP_TIMEOUT_CONNECT", "12"))
+TIMEOUT_READ = int(os.getenv("HTTP_TIMEOUT_READ", "60"))
+
+
+# ----------------- 小工具 -----------------
+def now_str() -> str:
+    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+
+def read_json(p: Path) -> Any:
+    return json.loads(p.read_text(encoding="utf-8"))
+
+
+def write_json(p: Path, obj: Any) -> None:
+    p.parent.mkdir(parents=True, exist_ok=True)
+    p.write_text(json.dumps(obj, ensure_ascii=False, indent=2), encoding="utf-8")
+
+
+def detect_latest_pid() -> str:
+    """从 refined_answers 下挑选最近更新且包含 postproc/metrics.json 的 pid"""
+    if not REFINED_ROOT.exists():
+        return ""
+    cands: List[Tuple[str, float]] = []
+    for d in REFINED_ROOT.iterdir():
+        if not d.is_dir():
+            continue
+        postproc_dir = d / "postproc"
+        if (postproc_dir / "metrics.json").exists() and (postproc_dir / "final_payload.json").exists():
+            cands.append((d.name, (postproc_dir / "metrics.json").stat().st_mtime))
+    cands.sort(key=lambda x: x[1], reverse=True)
+    return cands[0][0] if cands else ""
+
+
+# ----------------- 维度级打分信号 -> 文字提示 -----------------
+def _score_hint(v: float) -> str:
+    try:
+        v = float(v)
+    except Exception:
+        return "得分信号不明（信息可能不足）"
+    if v >= 0.75:
+        return "得分偏高，整体表现较强"
+    if v >= 0.62:
+        return "得分中上，有明显优势，但仍存在可优化空间"
+    if v >= 0.50:
+        return "得分中等偏弱，存在若干短板或信息缺口"
+    if v >= 0.35:
+        return "得分偏低，说明该维度存在明显不足或证据有限"
+    return "得分很低，属于明显短板，需要重点关注与补救"
+
+
+def _align_hint(v: float) -> str:
+    try:
+        v = float(v)
+    except Exception:
+        return "跨模型一致性信号不明"
+    if v >= 0.8:
+        return "多模型之间观点高度一致，结论较稳健"
+    if v >= 0.6:
+        return "多模型之间观点大致一致，少量差异"
+    if v >= 0.4:
+        return "多模型之间存在较多分歧，需要谨慎解读"
+    return "多模型观点差异较大，该维度结论不稳定"
+
+
+def _drift_hint(v: float) -> str:
+    try:
+        v = float(v)
+    except Exception:
+        return "内容漂移信号不明"
+    if v <= 0.18:
+        return "回答围绕同一核心，内容漂移较低"
+    if v <= 0.30:
+        return "回答存在一定漂移，但整体仍围绕同一主题"
+    if v <= 0.45:
+        return "回答存在明显漂移，需要甄别哪些点是稳定共识"
+    return "回答漂移程度较高，该维度存在语义不稳定风险"
+
+def _split_keywords(text: str) -> List[str]:
+    """
+    非严格分词：把 general_insights 里的句子切成若干关键片段，
+    过滤掉太短的 token，用来做“是否在问答中被覆盖”的粗匹配。
+    """
+    if not text:
+        return []
+    tokens = re.split(r"[，。,.;；、/\\()（）\s]+", text)
+    tokens = [t.strip().lower() for t in tokens if len(t.strip()) >= 3]
+    return tokens
+
+def build_dim_inputs(metrics: Dict[str, Any],
+                     final_payload: Dict[str, Any],
+                     max_qas: int = 6,
+                     max_answer_chars: int = 800) -> Dict[str, Any]:
+    """
+    组装传给 LLM 的维度输入：
+      - 不包含任何具体分数，只给“强/中/弱”的文字提示
+      - 注入 post_processing_v2 新增的 top_evidence_phrases / general_insights
+    """
+    dim_inputs: Dict[str, Any] = {}
+    dim_metrics = metrics.get("dimensions", {}) or {}
+    fp_dims = final_payload.get("dimensions", {}) or {}
+
+    for dim in DIM_ORDER:
+        m = dim_metrics.get(dim, {}) or {}
+        f = fp_dims.get(dim, {}) or {}
+        qas = f.get("qas", []) or []
+
+        # 维度级通识经验层（general_insights）
+        dim_general_insights = f.get("general_insights") or []
+        # 证据短语（来自 post_processing_v2）
+        top_evid_phrases = m.get("top_evidence_phrases") or []
+        redlined_samples = m.get("redlined_samples") or []
+
+        # 汇总该维度所有问答内容，用于和 general_insights 做粗匹配
+        corpus_parts: List[str] = []
+        for qa in qas:
+            corpus_parts.append((qa.get("q") or ""))
+            corpus_parts.append((qa.get("answer") or ""))
+            for c in qa.get("claims") or []:
+                corpus_parts.append(c)
+            for h in qa.get("evidence_hints") or []:
+                corpus_parts.append(h)
+        corpus_text = " ".join(corpus_parts).lower()
+
+        # 将维度级 general_insights 分成：已部分覆盖 / 明显缺口
+        dim_general_insights_covered: List[str] = []
+        dim_general_insights_missing: List[str] = []
+        for gi in dim_general_insights:
+            if not gi:
+                continue
+            gi_tokens = _split_keywords(gi)
+            # 没有有效 token 的，直接当作“缺口提示”（避免误判为 covered）
+            if not gi_tokens:
+                dim_general_insights_missing.append(gi)
+                continue
+            hit = any(tok in corpus_text for tok in gi_tokens)
+            if hit:
+                dim_general_insights_covered.append(gi)
+            else:
+                dim_general_insights_missing.append(gi)
+
+        samples = []
+        for qa in qas[:max_qas]:
+            ans = (qa.get("answer") or "").strip()
+            if len(ans) > max_answer_chars:
+                ans = ans[:max_answer_chars] + "……"
+            samples.append({
+                "question": (qa.get("q") or "").strip(),
+                "answer": ans,
+                "key_claims": (qa.get("claims") or [])[:6],
+                "evidence_hints": (qa.get("evidence_hints") or [])[:6],
+                "provider": qa.get("provider", ""),
+                # 逐问通识经验层（仅作行业基准提示，不代表本项目已实现）
+                "general_insights": (qa.get("general_insights") or [])[:6],
+            })
+
+        dim_inputs[dim] = {
+            "dimension": dim,
+            "label_zh": DIM_LABELS_ZH.get(dim, dim),
+            "score_hint": _score_hint(m.get("avg")),
+            "alignment_hint": _align_hint(m.get("avg_alignment")),
+            "drift_hint": _drift_hint(m.get("avg_drift")),
+            "metric_strength_phrases": (m.get("strengths") or [])[:6],
+            "metric_risk_phrases": (m.get("risks") or [])[:6],
+            "metric_top_evidence_phrases": top_evid_phrases[:6],
+            "metric_redlined_samples": redlined_samples[:6],
+            # 维度级通识拆分：已部分在问答中体现 / 基本缺位
+            "dim_general_insights": dim_general_insights[:10],
+            "dim_general_insights_covered": dim_general_insights_covered[:10],
+            "dim_general_insights_missing": dim_general_insights_missing[:10],
+            "qa_samples": samples
+        }
+    return dim_inputs
+
+
+# ----------------- OpenAI Chat 调用 -----------------
+def call_openai_chat(model: str,
+                     system_prompt: str,
+                     user_payload: Dict[str, Any],
+                     temperature: float = 0.25,
+                     max_tokens: int = 2600,
+                     seed: int = None,
+                     max_retries: int = 3,
+                     backoff: float = 1.8) -> Dict[str, Any]:
+    """
+    只负责“按给定参数调用一次 Chat Completions”，不判断 PROVIDER。
+    是否调用由上层根据 .env 配置 & 开关决定。
+    """
+    if not OPENAI_API_KEY:
+        raise RuntimeError("OPENAI_API_KEY 缺失，请在 .env 中配置。")
+
+    url = OPENAI_API_BASE.rstrip("/") + "/chat/completions"
+    headers = {
+        "Authorization": f"Bearer {OPENAI_API_KEY}",
+        "Content-Type": "application/json"
+    }
+    body: Dict[str, Any] = {
+        "model": model,
+        "temperature": temperature,
+        "max_tokens": max_tokens,
+        "messages": [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": json.dumps(user_payload, ensure_ascii=False)}
+        ],
+        "response_format": {"type": "json_object"}
+    }
+    if seed is not None:
+        body["seed"] = seed
+
+    last_err = None
+    for attempt in range(1, max_retries + 1):
+        try:
+            resp = requests.post(
+                url,
+                headers=headers,
+                json=body,
+                timeout=(TIMEOUT_CONNECT, TIMEOUT_READ)
+            )
+            if resp.status_code != 200:
+                last_err = f"{resp.status_code} - {resp.text[:400]}"
+                time.sleep(backoff ** attempt)
+                continue
+            data = resp.json()
+            content = data["choices"][0]["message"]["content"]
+            return json.loads(content)
+        except Exception as e:
+            last_err = str(e)
+            time.sleep(backoff ** attempt)
+    raise RuntimeError(f"OpenAI Chat 调用失败（已重试 {max_retries} 次）：{last_err}")
+
+
+# ----------------- Prompt 组装 -----------------
+def build_dim_system_prompt() -> str:
+    return (
+        "你是一名长期参与复杂项目评审的专家顾问。"
+        "系统会给出五个维度（team/objectives/strategy/innovation/feasibility）的："
+        "· 维度中文含义；· 分数强弱/一致性/漂移的‘文字信号’；"
+        "· metrics 抽取的 strengths/risks 短语；"
+        "· post_processing 聚合的 top_evidence_phrases（只代表证据方向，不是完整证据）；"
+        "· 维度级与逐问级 general_insights（领域通识建议，仅作对比基准，并不代表本项目已达成）；"
+        "· dim_general_insights_covered：领域通识中，已在当前问答里部分体现的点；"
+        "· dim_general_insights_missing：领域通识中，当前问答几乎未覆盖、但在实际评审中通常被视为重要的信息缺口；"
+        "· 该维度的部分问答样本（question/answer/claims/evidence_hints/general_insights）。"
+        "你的任务：\n"
+        "1）对于每个维度，基于问答内容 + strengths/risks 短语 + 证据方向 + general_insights，"
+        "   写出：summary / strengths / concerns / recommendations。\n"
+        "   - 在 strengths 中，优先结合 dim_general_insights_covered 与具体问答内容，"
+        "     明确指出项目已经在哪些方面达到了行业普遍要求。\n"
+        "   - 在 concerns 和 recommendations 中，必须至少点名 1–2 条 dim_general_insights_missing，"
+        "     解释这些点在行业内通常为什么重要，以及本项目目前材料中为何体现不足，并给出补齐建议。\n"
+        "2）每条 strengths/concerns 必须是‘有因有果’的一句话："
+        "   可以使用“从……可以看出……从而说明……”“目前材料显示……这一点是亮点/存在不足……”"
+        "   “与行业中成熟做法相比，……”等多种句式，明确指出‘为什么好/为什么有风险’。"
+        "   不要所有句子都以“因为……”“由于……”“从……来看”这类相同短语开头。\n"
+        "3）可以引用问答中的关键信息，但不要编造不存在的机构名称、注册号、具体数据。"
+        "4）严禁出现任何题号（如 Q1/Q2）、分数字符（0.71、71% 等）或内部指标名"
+        "   （alignment/coverage/authority/drift/对齐/漂移/覆盖/权威/overall_score/置信度 等）。"
+        "5）如果某个维度信息明显不足，可以给出 1–2 条保守结论，例如“当前问答中几乎没有提到……，"
+        "   因此该维度信息覆盖不足，需要补充材料”。\n"
+        "输出必须是严格 JSON，对每个维度都给出：summary（2–4 句）、strengths（3–5 条）、"
+        "concerns（3–5 条）、recommendations（3–5 条）。"
+    )
+
+def build_dim_user_payload(pid: str,
+                           dim_inputs: Dict[str, Any]) -> Dict[str, Any]:
+    return {
+        "pid": pid,
+        "task": "dimension_level_expert_opinion",
+        "note": "仅输出 dimensions 字段，其余由系统补充。",
+        "dimensions": dim_inputs,
+        "output_schema_hint": {
+            "type": "object",
+            "required": ["dimensions"],
+            "properties": {
+                "dimensions": {
+                    "type": "object",
+                    "properties": {
+                        dim: {
+                            "type": "object",
+                            "required": ["summary", "strengths", "concerns", "recommendations"],
+                            "properties": {
+                                "summary": {"type": "string"},
+                                "strengths": {"type": "array", "items": {"type": "string"}},
+                                "concerns": {"type": "array", "items": {"type": "string"}},
+                                "recommendations": {"type": "array", "items": {"type": "string"}}
+                            }
+                        } for dim in DIM_ORDER
+                    }
+                }
+            }
+        }
+    }
+
+
+# ----------------- 文本清洗 & 聚合 -----------------
+FORBID_PATTERNS = [
+    r"\bQ\d+\b",
+    r"\balign(?:ment)?\b",
+    r"\bcoverage\b",
+    r"\bauth(?:ority)?\b",
+    r"\bdrift\b",
+    r"对齐", r"漂移", r"覆盖", r"权威",
+    r"\boverall[_ ]?score\b",
+    r"\bconfidence\b",
+    r"\bjaccard\b",
+    r"冲突度",
+    r"\d+(\.\d+)?\s*%+",
+]
+
+
+def clean_text(s: str) -> str:
+    s = (s or "").replace("\u0000", "").strip()
+    for pat in FORBID_PATTERNS:
+        s = re.sub(pat, "", s, flags=re.IGNORECASE)
+    s = re.sub(r"\s{2,}", " ", s)
+    s = s.replace("（）", "").replace("()", "")
+    return s.strip()
+
+
+def clean_list(items: List[str]) -> List[str]:
+    out: List[str] = []
+    for it in items or []:
+        t = clean_text(it)
+        if t:
+            out.append(t)
+    return out
+
+
+def dedup_soft(items: List[str], thresh: float = 0.85) -> List[str]:
+    """非常简单的“字符级 Jaccard”去重，避免几乎一样的句子反复出现。"""
+    def to_set(x: str):
+        return set((x or "").lower())
+
+    uniq: List[str] = []
+    for s in items or []:
+        keep = True
+        a = to_set(s)
+        for t in uniq:
+            b = to_set(t)
+            if not a or not b:
+                continue
+            j = len(a & b) / len(a | b)
+            if j >= thresh:
+                keep = False
+                break
+        if keep:
+            uniq.append(s)
+    return uniq
+
+
+def _shorten_sentence(text: str, max_len: int = 120) -> str:
+    """用于总体 summary 中的分维度 bullet：取第一句或截断到 max_len。"""
+    text = (text or "").strip()
+    if not text:
+        return ""
+    # 按中英文句号/问号/感叹号切分，取第一句
+    parts = re.split(r"[。！？!?.]", text)
+    for p in parts:
+        p = p.strip()
+        if p:
+            text = p
+            break
+    if len(text) > max_len:
+        return text[:max_len].rstrip() + "……"
+    return text
+
+
+# ----------------- 仅本地的维度级专家点评（LLM 回退） -----------------
+def build_local_dim_blocks(metrics: Dict[str, Any],
+                           final_payload: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    当无法调用 LLM 时，基于 metrics + final_payload 直接构造维度点评。
+    逻辑尽量简洁可解释，不引入额外“猜测”。
+    """
+    dims_metrics = metrics.get("dimensions", {}) or {}
+    fp_dims = final_payload.get("dimensions", {}) or {}
+
+    dim_blocks: Dict[str, Any] = {}
+
+    for dim in DIM_ORDER:
+        m = dims_metrics.get(dim, {}) or {}
+        f = fp_dims.get(dim, {}) or {}
+
+        score = float(m.get("avg", 0.0) or 0.0)
+        align = float(m.get("avg_alignment", 0.0) or 0.0)
+        drift = float(m.get("avg_drift", 0.0) or 0.0)
+        strengths_phr = (m.get("strengths") or [])[:5]
+        risks_phr = (m.get("risks") or [])[:5]
+        dim_gi = (f.get("general_insights") or [])[:8]
+
+        label = DIM_LABELS_ZH.get(dim, dim)
+
+        summary_parts: List[str] = []
+        if strengths_phr:
+            summary_parts.append(
+                f"{label} 维度中，自动评估识别出若干优势点，例如：" +
+                "；".join(strengths_phr[:2])
+            )
+        if risks_phr:
+            summary_parts.append(
+                "同时也暴露出一些潜在问题或风险，例如：" +
+                "；".join(risks_phr[:2])
+            )
+        if not summary_parts:
+            summary_parts.append(
+                f"当前问答与自动评估中，关于“{label}”维度的有效信息有限，结论仅供参考，建议补充更详细的事实和量化指标。"
+            )
+        summary = " ".join(summary_parts)
+
+        # 优势：优先使用 metrics.strengths；若为空，用少量 general_insights 补位
+        strengths_out = strengths_phr[:]
+        if not strengths_out and dim_gi:
+            strengths_out = [
+                f"从行业经验看，本维度若能达到以下实践将显著加分：{dim_gi[0]}"
+            ]
+
+        # 风险：直接用 metrics.risks
+        concerns_out = risks_phr[:]
+
+        # 建议：优先用 general_insights，若为空则给一条通用建议
+        recs_out: List[str] = []
+        for g in dim_gi:
+            recs_out.append(g)
+        if risks_phr and not dim_gi:
+            recs_out.append(
+                "针对上述风险，建议在后续版本中补充更具体的实施计划、里程碑与量化指标，以便评审。"
+            )
+        if not recs_out:
+            recs_out.append(
+                f"建议围绕“{label}”维度，系统梳理团队经验、资源保障和实施路径，并结合行业最佳实践补齐信息。"
+            )
+
+        dim_blocks[dim] = {
+            "score_echo": score,
+            "alignment_echo": align,
+            "drift_echo": drift,
+            "summary": summary,
+            "strengths": strengths_out,
+            "concerns": concerns_out,
+            "recommendations": recs_out
+        }
+
+    return dim_blocks
+
+
+# ----------------- 总体意见（本地） -----------------
+def build_overall_from_dims(dim_blocks: Dict[str, Any],
+                            metrics_overall: Dict[str, Any],
+                            metrics_dims: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    从各维度点评 + 分数，构造总体意见（不再调用 LLM）。
+
+    优化点：
+    - verdict 阈值略放宽，让中间地带更多落在 HOLD，而不是一刀切 NO-GO；
+    - 总体 summary 采用“一段总括 + 分维度 bullet”的结构；
+    - 配合后续 markdown 渲染，读起来更像人写的评审意见。
+    """
+    overall_score = float(metrics_overall.get("overall_score", 0.0) or 0.0)
+    overall_conf = float(metrics_overall.get("overall_confidence", 0.0) or 0.0)
+
+    # 1) 判定 verdict
+    def verdict_rule(score: float, conf: float,
+                     dims: Dict[str, Any]) -> (str, str):
+        inv = float(dims.get("innovation", {}).get("avg", 1.0) or 1.0)
+        fea = float(dims.get("feasibility", {}).get("avg", 1.0) or 1.0)
+
+        # ① 明确 GO：得分 + 信心都比较稳
+        if score >= 0.62 and conf >= 0.65:
+            return "GO", "综合得分与信心度均处于较高区间，关键维度表现扎实，整体风险可控，适合推进。"
+
+        # ② 明确 NO-GO：整体很低，或关键维度严重偏弱
+        if score < 0.40 or inv < 0.30 or fea < 0.30:
+            return (
+                "NO-GO",
+                "总体得分或关键维度（尤其是创新/可行性）处于明显偏低区间，"
+                "关键信息缺失或短板较多，目前不宜在本轮直接立项，建议补充材料后再行评估。"
+            )
+
+        # ③ 剩下全部归为 HOLD：有潜力，但证据/信息不够
+        return (
+            "HOLD",
+            "项目处于中间地带，一方面具备一定亮点和潜力，另一方面在若干关键维度上信息仍不充分，"
+            "建议在补充必要材料和澄清关键风险后，再做更明确的 go/no-go 决策。"
+        )
+
+    verdict, verdict_reason = verdict_rule(overall_score, overall_conf, metrics_dims)
+
+    # 2) 总体 summary：一段总括 + 分维度 bullet
+    # 2.1 总括句随 verdict 变化
+    if verdict == "GO":
+        head = (
+            "整体来看，该项目在当前轮次的综合表现较为扎实：关键假设相对清晰、实施路径具备一定可操作性，"
+            "在风险可控的前提下具备推进价值。"
+        )
+    elif verdict == "HOLD":
+        head = (
+            "整体来看，该项目在技术和应用场景上体现出一定潜力，但目前关键信息仍有缺口，"
+            "更适合作为“待补充材料后再议”的候选项目，而非直接进入大规模投入阶段。"
+        )
+    else:  # NO-GO
+        head = (
+            "整体来看，该项目在技术构想或应用方向上虽有亮点，但现有材料无法支撑稳健的风险收益判断，"
+            "短板和不确定性占比较高，当前不宜在本轮直接立项。"
+        )
+
+    # 2.2 分维度 bullet：从各维度 summary 中提取第一句精简回顾
+    dim_snippets: List[str] = []
+    for dim in DIM_ORDER:
+        blk = dim_blocks.get(dim, {}) or {}
+        dim_sum = (blk.get("summary") or "").strip()
+        if not dim_sum:
+            continue
+        label = DIM_LABELS_ZH.get(dim, dim)
+        short = _shorten_sentence(dim_sum, max_len=140)
+        if not short:
+            continue
+        dim_snippets.append(f"- {label}：{short}")
+
+    lines: List[str] = [head]
+    if dim_snippets:
+        lines.append("分维度来看：")
+        lines.extend(dim_snippets)
+
+    summary_text = "\n".join(lines)
+
+    # 3) 从各维度 strengths/concerns 中抽取总体 key_strengths/key_risks
+    key_strengths: List[str] = []
+    key_risks: List[str] = []
+    for dim in DIM_ORDER:
+        blk = dim_blocks.get(dim, {}) or {}
+        label = DIM_LABELS_ZH.get(dim, dim)
+        for s in (blk.get("strengths") or [])[:2]:
+            key_strengths.append(f"【{label}】{s}")
+        for r in (blk.get("concerns") or [])[:2]:
+            key_risks.append(f"【{label}】{r}")
+
+    key_strengths = dedup_soft(clean_list(key_strengths))[:6]
+    key_risks = dedup_soft(clean_list(key_risks))[:6]
+
+    # 4) 总体 recommendations：从各维度 recommendations 抽样
+    recs: List[str] = []
+    for dim in DIM_ORDER:
+        blk = dim_blocks.get(dim, {}) or {}
+        label = DIM_LABELS_ZH.get(dim, dim)
+        for r in (blk.get("recommendations") or [])[:2]:
+            recs.append(f"【{label}】{r}")
+    recs = dedup_soft(clean_list(recs))[:8]
+
+    return {
+        "summary": summary_text,
+        "overall_score_echo": overall_score,
+        "confidence_echo": overall_conf,
+        "key_strengths": key_strengths,
+        "key_risks": key_risks,
+        "recommendations": recs,
+        "verdict": verdict,
+        "basis": [
+            f"结论依据：{verdict_reason}",
+            "结论完全基于已选中问答结果与自动评分信号，未引入外部资料。"
+        ]
+    }
+
+
+# ----------------- Markdown 渲染 -----------------
+def _bar(v: float, n: int = 20) -> str:
+    try:
+        v = float(v)
+    except Exception:
+        v = 0.0
+    v = max(0.0, min(1.0, v))
+    k = int(round(v * n))
+    return "█" * k + "░" * (n - k)
+
+
+def render_markdown(opinion: Dict[str, Any]) -> str:
+    meta = opinion.get("meta", {}) or {}
+    overall = opinion.get("overall_opinion", {}) or {}
+    dims = opinion.get("dimensions", {}) or {}
+    scoring = opinion.get("scoring_explainer", {}) or {}
+    metrics_path = (meta.get("sources") or {}).get("metrics_path", "")
+
+    lines: List[str] = []
+    lines.append(f"# AI 专家评审 · {meta.get('pid', '')}")
+    lines.append("")
+    lines.append(f"- 生成时间：{meta.get('generated_at', '')}")
+    lines.append(f"- 模式：{meta.get('mode', '')}")
+    lines.append(f"- 模型/引擎：{meta.get('model', '')}（provider={meta.get('provider', '')}）")
+    lines.append("")
+
+    # 总体
+    lines.append("## 总体意见")
+    lines.append(f"- 综合评分（回显）：{overall.get('overall_score_echo', 0.0):.3f}  {_bar(overall.get('overall_score_echo', 0.0))}")
+    lines.append(f"- 综合信心度（回显）：{overall.get('confidence_echo', 0.0):.3f}  {_bar(overall.get('confidence_echo', 0.0))}")
+    lines.append("")
+    if overall.get("summary"):
+        lines.append(overall["summary"])
+        lines.append("")
+    if overall.get("key_strengths"):
+        lines.append("**项目优势**")
+        for s in overall["key_strengths"]:
+            lines.append(f"- {s}")
+        lines.append("")
+    if overall.get("key_risks"):
+        lines.append("**项目不足/潜在风险**")
+        for r in overall["key_risks"]:
+            lines.append(f"- {r}")
+        lines.append("")
+    if overall.get("recommendations"):
+        lines.append("**总体建议**")
+        for r in overall["recommendations"]:
+            lines.append(f"- {r}")
+        lines.append("")
+    if overall.get("verdict"):
+        lines.append(f"**总体结论（verdict）**：{overall['verdict']}")
+        lines.append("")
+    if overall.get("basis"):
+        lines.append("**结论依据（系统自动生成）**")
+        for b in overall["basis"]:
+            lines.append(f"- {b}")
+        lines.append("")
+
+    # 维度表
+    lines.append("## 各维度评分一览")
+    lines.append("")
+    lines.append("| 维度 | 分数 |")
+    lines.append("|---|---:|")
+    for dim in DIM_ORDER:
+        blk = dims.get(dim, {}) or {}
+        lines.append(f"| {dim} | {blk.get('score_echo', 0.0):.3f} |")
+    lines.append("")
+
+    # 分维度详情
+    lines.append("## 分维度专家点评")
+    lines.append("")
+    for dim in DIM_ORDER:
+        label = DIM_LABELS_ZH.get(dim, dim)
+        blk = dims.get(dim, {}) or {}
+        lines.append(f"### {label}（{dim}）")
+        lines.append(f"- 评分回显：{blk.get('score_echo', 0.0):.3f}  {_bar(blk.get('score_echo', 0.0))}")
+        lines.append("")
+        if blk.get("summary"):
+            lines.append(blk["summary"])
+            lines.append("")
+        if blk.get("strengths"):
+            lines.append("**优势**")
+            for s in blk["strengths"]:
+                lines.append(f"- {s}")
+            lines.append("")
+        if blk.get("concerns"):
+            lines.append("**问题/风险**")
+            for r in blk["concerns"]:
+                lines.append(f"- {r}")
+            lines.append("")
+        if blk.get("recommendations"):
+            lines.append("**改进建议**")
+            for r in blk["recommendations"]:
+                lines.append(f"- {r}")
+            lines.append("")
+
+    # 简单回显评分配置（方便审计）
+    if scoring:
+        lines.append("## 评分规则回显（来自 post_processing 配置）")
+        lines.append(f"- 一致性权重 consistency_weight：{scoring.get('consistency_weight', 0.0):.2f}")
+        if scoring.get("dimension_weight"):
+            dw = scoring["dimension_weight"]
+            order_str = ", ".join([f"{d}:{dw.get(d, 0.0):.2f}" for d in DIM_ORDER if d in dw])
+            lines.append(f"- 维度权重：{order_str}")
+        lines.append("")
+
+    if metrics_path:
+        lines.append("## 溯源")
+        lines.append(f"- metrics.json：{metrics_path}")
+        lines.append("")
+
+    return "\n".join(lines)
+
+
+# ----------------- 主流程 -----------------
+def main():
+    ap = argparse.ArgumentParser(description="Generate AI expert opinion (dimension-first, QA-grounded).")
+    ap.add_argument("--pid", type=str, default="", help="提案 ID；缺省则自动选择最新项目")
+    ap.add_argument("--model", type=str, default=OPENAI_MODEL, help="OpenAI 模型名")
+    ap.add_argument("--dry_run", action="store_true", help="仅生成 prompt，不调用 LLM")
+    ap.add_argument("--no_markdown", action="store_true", help="不输出 Markdown，仅 JSON")
+    ap.add_argument("--force_local", action="store_true", help="强制使用本地规则版，不调用 LLM（用于调试）")
+    args = ap.parse_args()
+
+    pid = args.pid.strip() or detect_latest_pid()
+    if not pid:
+        raise RuntimeError("未检测到可用项目（refined_answers 下无 postproc/metrics.json + final_payload.json）。")
+
+    postproc_dir = REFINED_ROOT / pid / "postproc"
+    metrics_path = postproc_dir / "metrics.json"
+    payload_path = postproc_dir / "final_payload.json"
+    if not metrics_path.exists():
+        raise FileNotFoundError(f"未找到 metrics.json：{metrics_path}")
+    if not payload_path.exists():
+        raise FileNotFoundError(f"未找到 final_payload.json：{payload_path}")
+
+    metrics = read_json(metrics_path)
+    final_payload = read_json(payload_path)
+
+    dim_inputs = build_dim_inputs(metrics, final_payload)
+
+    out_dir = EXPERT_DIR / pid
+    out_dir.mkdir(parents=True, exist_ok=True)
+    prompt_path = out_dir / "ai_expert_opinion.prompt.json"
+    json_path = out_dir / "ai_expert_opinion.json"
+    md_path = out_dir / "ai_expert_opinion.md"
+
+    # 先保存 prompt（即便是本地版，也方便调试看看输入长什么样）
+    system_prompt = build_dim_system_prompt()
+    user_payload = build_dim_user_payload(pid, dim_inputs)
+    write_json(prompt_path, {
+        "system": system_prompt,
+        "user": user_payload
+    })
+
+    # =========== 维度级点评：优先 LLM，失败则回退本地 ===========
+    dim_op_raw: Dict[str, Any] = {}
+    used_model = ""
+    used_mode = ""
+
+    use_llm = (not args.force_local) and (PROVIDER == "openai") and bool(OPENAI_API_KEY)
+
+    if args.dry_run:
+        print(f"📝 已导出 prompt -> {prompt_path}")
+        return
+
+    if use_llm:
+        try:
+            resp = call_openai_chat(
+                model=args.model,
+                system_prompt=system_prompt,
+                user_payload=user_payload,
+                temperature=0.25,
+                max_tokens=2600,
+                seed=None,
+            )
+            if "dimensions" not in resp:
+                raise RuntimeError("LLM 返回 JSON 中缺少 'dimensions' 字段")
+            dim_op_raw = resp["dimensions"] or {}
+            used_model = args.model
+            used_mode = "llm"
+        except Exception as e:
+            print(f"⚠️ LLM 生成维度点评失败，将启用纯本地规则回退：{e}")
+            dim_op_raw = {}
+            used_model = "local_rules"
+            used_mode = "local_fallback"
+    else:
+        used_model = "local_rules"
+        used_mode = "local_forced"
+
+    if not dim_op_raw:
+        # 纯本地规则版
+        dim_op_raw = build_local_dim_blocks(metrics, final_payload)
+
+    # 兜底：保证所有维度都有字段 & 文本清洗/去重 + 收紧条数
+    cleaned_dims: Dict[str, Any] = {}
+    metrics_dims = metrics.get("dimensions", {}) or {}
+    for dim in DIM_ORDER:
+        blk = dim_op_raw.get(dim, {}) or {}
+        m = metrics_dims.get(dim, {}) or {}
+
+        strengths = dedup_soft(clean_list(blk.get("strengths") or []))[:3]
+        concerns = dedup_soft(clean_list(blk.get("concerns") or []))[:3]
+        recs = dedup_soft(clean_list(blk.get("recommendations") or []))[:4]
+        summary = clean_text(blk.get("summary") or "")
+
+        # 如果维度几乎没有信息，补一条兜底 summary
+        if not summary and not strengths and not concerns:
+            label = DIM_LABELS_ZH.get(dim, dim)
+            summary = (
+                f"当前关于“{label}”维度的有效问答与证据信号非常有限，结论不稳定，"
+                f"建议项目方在后续版本中补充该维度的核心事实、量化指标与实施细节。"
+            )
+
+        cleaned_dims[dim] = {
+            "score_echo": float(m.get("avg", 0.0) or 0.0),
+            "alignment_echo": float(m.get("avg_alignment", 0.0) or 0.0),
+            "drift_echo": float(m.get("avg_drift", 0.0) or 0.0),
+            "summary": summary,
+            "strengths": strengths,
+            "concerns": concerns,
+            "recommendations": recs
+        }
+
+    overall_block = build_overall_from_dims(
+        dim_blocks=cleaned_dims,
+        metrics_overall=metrics.get("overall", {}) or {},
+        metrics_dims=metrics_dims
+    )
+
+    # 拼接最终 JSON
+    opinion: Dict[str, Any] = {
+        "meta": {
+            "pid": pid,
+            "generated_at": now_str(),
+            "model": used_model,
+            "mode": used_mode,
+            "provider": PROVIDER,
+            "sources": {
+                "metrics_path": str(metrics_path),
+                "final_payload_path": str(payload_path)
+            }
+        },
+        "overall_opinion": overall_block,
+        "dimensions": cleaned_dims,
+        "scoring_explainer": {
+            # 只回显最关键的几项，便于报告中解释“分是怎么算出来的”
+            "consistency_weight": float((metrics.get("config_used") or {}).get("consistency_weight", 0.20) or 0.20),
+            "dimension_weight": {
+                k: float(v) for k, v in ((metrics.get("config_used") or {}).get("dimension_weight") or {}).items()
+            }
+        }
+    }
+
+    write_json(json_path, opinion)
+    if not args.no_markdown:
+        md_text = render_markdown(opinion)
+        md_path.write_text(md_text, encoding="utf-8")
+
+    print(f"✅ ai_expert_opinion.json -> {json_path}")
+    if not args.no_markdown:
+        print(f"✅ ai_expert_opinion.md   -> {md_path}")
+    print(f"🎯 专家评审生成完成（{used_mode} 模式）。")
+
+
+if __name__ == "__main__":
+    main()

src/tools/build_dimensions_from_facts.py

@@ -0,0 +1,473 @@
+# -*- coding: utf-8 -*-
+"""
+Stage 2 · 维度构建器（build_dimensions_from_facts.py）
+----------------------------------------------------
+输入：
+  - src/data/extracted/<proposal_id>/raw_facts.jsonl  （Stage 1 输出）
+
+输出：
+  - src/data/extracted/<proposal_id>/dimensions_v2.json      （新的五维度文件）
+  - src/data/extracted/<proposal_id>/dimension_facts.json    （按维度分组的 facts，方便后续调试与复用）
+  - src/data/parsed/parsed_dimensions.clean.llm.json         （供 llm_answering 使用的全局 parsed 文件）
+
+核心职责：
+  - 按 dimensions 标签把 facts 分桶到 team/objectives/strategy/innovation/feasibility
+  - 对每个维度单独调用一次 LLM，只基于该维度的事实生成：
+      summary / key_points / risks / mitigations
+  - 严禁凭空造事实，所有内容必须能在事实列表中找到“影子”
+  - 尽量覆盖该维度下出现过的不同 type（team_member/pipeline/market/risk/...）
+"""
+
+import os
+import json
+import argparse
+from pathlib import Path
+from typing import List, Dict, Any
+
+from dotenv import load_dotenv
+from openai import OpenAI
+
+load_dotenv()
+
+# 假设本文件路径：<project_root>/src/tools/build_dimensions_from_facts.py
+BASE_DIR = Path(__file__).resolve().parents[2]
+EXTRACTED_DIR = BASE_DIR / "src" / "data" / "extracted"
+PARSED_DIR = BASE_DIR / "src" / "data" / "parsed"   # 与 llm_answering 对齐
+
+OPENAI_MODEL = os.getenv("OPENAI_MODEL", "gpt-4o-mini")
+
+DIMENSION_NAMES = ["team", "objectives", "strategy", "innovation", "feasibility"]
+
+# 全局 client 复用
+client = OpenAI()
+
+# 注意：这里用 {dimension_name} 标记占位，其它所有 { } 都是字面量 JSON 示例
+# 后面用 .replace("{dimension_name}", xxx) 而不是 .format()
+
+DIMENSION_PROMPT_TEMPLATE = """
+你是一个严谨的项目评审助手，现在要基于【已经抽取好的事实列表】为某一个维度生成结构化摘要。
+
+硬性约束：
+1）只能使用我给你的 facts，不得凭空添加新的机构、人名、对象、方法、数字、时间、结果或结论。
+2）允许压缩与合并，但每一个 key_point、risk、mitigation 都必须能在 facts 中找到依据。
+3）只能总结【当前维度】的内容；若需要提及其他维度的信息，也只能在与当前维度强相关时简短引用。
+4）不要写行业常识、通用背景或空泛判断，只写从 facts 能支持的内容。
+
+【当前维度】：{dimension_name}
+
+【维度含义提醒】
+- team：团队、机构、角色分工、协作、治理
+- objectives：问题背景、目标、范围、里程碑、交付物、评价指标
+- strategy：方法、技术路线、实施流程、验证设计、外部协作路径
+- innovation：新颖性、差异化、独特资源、已有证据、知识产权
+- feasibility：资源、预算、时间安排、风险、限制、应对、执行条件
+
+输入 payload 结构：
+payload = {
+  "all_facts": [{"text": "...", "dimensions": ["team"], "type": "team_member", "meta": {...}}, ...],
+  "risk_facts": [...],
+  "mitigation_facts": [...]
+}
+
+请输出 JSON：
+{
+  "summary": "2-4 句，概括该维度当前情况",
+  "key_points": ["3-10 条，不重复、尽量覆盖不同主题"],
+  "risks": ["基于 risk_facts 或相关 facts 总结；若信息不足，可明确写‘该维度风险信息较少/未详细说明’"],
+  "mitigations": ["基于 mitigation_facts 或相关 facts 总结；若信息不足，可明确写‘该维度风险应对措施未详细说明’"]
+}
+
+补充要求：
+- facts 足够多时，优先覆盖不同 type，而不是重复同一类信息。
+- 不要输出任何 JSON 以外的文字。
+"""
+
+
+def load_raw_facts(proposal_id: str) -> List[Dict[str, Any]]:
+    path = EXTRACTED_DIR / proposal_id / "raw_facts.jsonl"
+    if not path.exists():
+        raise FileNotFoundError(f"raw_facts.jsonl 不存在，请先运行 extract_facts_by_chunk.py: {path}")
+
+    facts: List[Dict[str, Any]] = []
+    with path.open("r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                obj = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            if isinstance(obj, dict):
+                facts.append(obj)
+    print(f"[INFO] 读取 facts 数量: {len(facts)} 来自 {path}")
+    return facts
+
+
+def group_facts_by_dimension(facts: List[Dict[str, Any]]) -> Dict[str, List[Dict[str, Any]]]:
+    """
+    按维度标签把 facts 分桶到五个维度。
+    一条 fact 可能属于多个维度，会出现在多个桶里。
+    """
+    grouped: Dict[str, List[Dict[str, Any]]] = {dim: [] for dim in DIMENSION_NAMES}
+
+    for fact in facts:
+        dims = fact.get("dimensions", [])
+        if not isinstance(dims, list):
+            continue
+        for dim in dims:
+            if dim in grouped:
+                grouped[dim].append(fact)
+
+    for dim in DIMENSION_NAMES:
+        print(f"[INFO] 维度 {dim} 相关事实数: {len(grouped[dim])}")
+    return grouped
+
+
+def sort_facts_for_dimension(dimension_name: str, facts: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """
+    按维度定义 type 优先级排序，保证更关键信息排在前面。
+    这是纯通用规则，不依赖具体提案内容。
+    """
+    priority_map = {
+        "team": [
+            # 先看具体成员履历，再看组织结构和协作模式
+            "team_member", "org_structure", "collaboration", "resource", "other"
+        ],
+        "objectives": [
+            # 目标、里程碑、验证设计与交付信息优先
+            "milestone", "pipeline", "clinical_design", "product", "market", "other"
+        ],
+        "strategy": [
+            # 方法路线、外部协作、应用环境与制度流程都属于 strategy 视角
+            "tech_route", "product", "collaboration", "market",
+            "funding_source", "regulatory", "other"
+        ],
+        "innovation": [
+            "ip_asset", "evidence", "ai_model", "tech_route", "product", "other"
+        ],
+        "feasibility": [
+            "resource", "budget_item", "funding_source",
+            "risk", "mitigation", "regulatory", "other"
+        ],
+    }
+    order = priority_map.get(dimension_name, ["other"])
+
+    def type_rank(t: str) -> int:
+        return order.index(t) if t in order else len(order)
+
+    return sorted(
+        facts,
+        key=lambda f: type_rank(f.get("type", "other"))
+    )
+
+
+def truncate_facts_for_prompt(facts: List[Dict[str, Any]], max_chars: int = 10000) -> List[Dict[str, Any]]:
+    """
+    为了防止单次 prompt 爆 context，对 facts 做一个简单的字符长度截断。
+    按顺序累加 text，超过 max_chars 就停（meta 仍然保留）。
+    """
+    kept: List[Dict[str, Any]] = []
+    total = 0
+    for fact in facts:
+        t = fact.get("text", "") or ""
+        t_len = len(t)
+        if total + t_len > max_chars and kept:
+            break
+        kept.append(fact)
+        total += t_len
+    return kept
+
+
+# ===== 辅助：基于文本再兜底识别 risk / mitigation =====
+
+_RISK_CN = ["风险", "挑战", "瓶颈", "不确定性", "不足", "局限", "缺陷", "障碍", "难点"]
+_RISK_EN = ["risk", "risks", "challenge", "challenges", "bottleneck", "bottlenecks",
+            "uncertainty", "limitation", "limitations", "weakness", "weaknesses",
+            "barrier", "barriers", "issue", "issues", "difficulty", "difficulties"]
+
+_MITIG_CN = ["应对", "缓解", "降低", "减少", "解决", "克服", "应对措施", "改进", "优化", "管控"]
+_MITIG_EN = ["mitigation", "mitigate", "mitigating", "address", "addresses", "addressing",
+             "solve", "solves", "solving", "overcome", "overcoming",
+             "reduce", "reduces", "reducing", "decrease", "decreases", "decreasing",
+             "improve", "improves", "improving", "optimize", "optimizing", "optimization"]
+
+
+def _looks_like_risk(text: str) -> bool:
+    if not text:
+        return False
+    t = text.lower()
+    if any(k in text for k in _RISK_CN):
+        return True
+    if any(k in t for k in _RISK_EN):
+        return True
+    return False
+
+def reclassify_risk_mitigation_global(facts: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """
+    在进入维度构建之前，对所有 facts 做一次全局的 risk/mitigation 纠偏：
+    - 如果 type 不是 risk/mitigation，但文本明显是风险/挑战，就改成 risk
+    - 如果 type 不是 risk/mitigation，但文本明显是应对/缓解方案，就改成 mitigation
+    - 如果本身标成 risk/mitigation 但文本看起来不像风险/应对，则降级为 other
+      （必要时在 risk 和 mitigation 之间互换）
+    """
+    new_facts: List[Dict[str, Any]] = []
+
+    for f in facts:
+        t = f.get("type", "other") or "other"
+        txt = f.get("text", "") or ""
+
+        # 优先纠错：如果已经标成 risk/mitigation，但文本不符合，就降级/互换
+        if t == "risk":
+            if not _looks_like_risk(txt):
+                # 文本更像应对措施，就改成 mitigation；否则降级成 other
+                if _looks_like_mitigation(txt):
+                    t = "mitigation"
+                else:
+                    t = "other"
+        elif t == "mitigation":
+            if not _looks_like_mitigation(txt):
+                # 文本更像风险描述，就改成 risk；否则降级成 other
+                if _looks_like_risk(txt):
+                    t = "risk"
+                else:
+                    t = "other"
+        else:
+            # 如果原始类型既不是 risk 也不是 mitigation，就尝试“升格”
+            if _looks_like_risk(txt):
+                t = "risk"
+            elif _looks_like_mitigation(txt):
+                t = "mitigation"
+
+        f["type"] = t
+        new_facts.append(f)
+
+    return new_facts
+
+def _looks_like_mitigation(text: str) -> bool:
+    if not text:
+        return False
+    t = text.lower()
+    if any(k in text for k in _MITIG_CN):
+        return True
+    if any(k in t for k in _MITIG_EN):
+        return True
+    return False
+
+
+def call_llm_for_dimension(dimension_name: str, facts: List[Dict[str, Any]]) -> Dict[str, Any]:
+    """
+    对单一维度调用一次 LLM，生成 summary/key_points/risks/mitigations。
+    强约束：只能基于 facts，不得脑补。
+    """
+
+    # 1) 先按 type 排序，再截断，确保更重要的信息优先被看到
+    sorted_facts = sort_facts_for_dimension(dimension_name, facts)
+    all_facts_for_prompt = truncate_facts_for_prompt(sorted_facts, max_chars=10000)
+
+    # 2) 识别风险 / 对策 facts：不仅看 type，还看文本关键词
+    risk_facts: List[Dict[str, Any]] = []
+    mitigation_facts: List[Dict[str, Any]] = []
+
+    for f in all_facts_for_prompt:
+        t = f.get("type", "")
+        txt = f.get("text", "") or ""
+
+        # 明确标成 risk 的，或者文本看起来是在描述风险/挑战，都归入
+        if t == "risk" or _looks_like_risk(txt):
+            risk_facts.append(f)
+
+        # 明确标成 mitigation 的，或者文本看起来是在描述应对/解决方案，也归入
+        if t == "mitigation" or _looks_like_mitigation(txt):
+            mitigation_facts.append(f)
+
+    payload = {
+        "all_facts": all_facts_for_prompt,
+        "risk_facts": risk_facts,
+        "mitigation_facts": mitigation_facts,
+    }
+    facts_json_str = json.dumps(payload, ensure_ascii=False, indent=2)
+
+    # 用 replace，而不是 format，避免 JSON 里的 { } 被当成占位符
+    prompt = DIMENSION_PROMPT_TEMPLATE.replace("{dimension_name}", dimension_name)
+
+    messages = [
+        {
+            "role": "system",
+            "content": "你是一个严谨的项目评审助手，只能基于给定的事实列表进行总结，不得编造。",
+        },
+        {
+            "role": "user",
+            "content": prompt + "\n\n=== payload 开始 ===\n" + facts_json_str,
+        },
+    ]
+
+    resp = client.chat.completions.create(
+        model=OPENAI_MODEL,
+        messages=messages,
+        response_format={"type": "json_object"},
+        temperature=0.0,
+        max_tokens=2600,
+    )
+    raw = resp.choices[0].message.content
+
+    try:
+        data = json.loads(raw)
+    except json.JSONDecodeError as e:
+        print(f"[WARN] 维度 {dimension_name} JSON 解析失败，原始内容如下：")
+        print(raw)
+        raise e
+
+    # 兜底：保证四个字段存在
+    summary = data.get("summary", "")
+    if not isinstance(summary, str):
+        summary = ""
+    key_points = data.get("key_points", [])
+    if not isinstance(key_points, list):
+        key_points = []
+    risks = data.get("risks", [])
+    if not isinstance(risks, list):
+        risks = []
+    mitigations = data.get("mitigations", [])
+    if not isinstance(mitigations, list):
+        mitigations = []
+
+    # 轻量兜底：facts 足够多但 key_points 太少，打日志提醒（先不强制重试）
+    fact_count = len(all_facts_for_prompt)
+    if fact_count >= 20 and len(key_points) < 6:
+        print(
+            f"[WARN] 维度 {dimension_name}: all_facts={fact_count} 但 key_points 只有 {len(key_points)} 条，"
+            f"如有需要可以在此处加重试/补点逻辑。"
+        )
+
+    return {
+        "summary": summary.strip(),
+        "key_points": [str(x).strip() for x in key_points if str(x).strip()],
+        "risks": [str(x).strip() for x in risks if str(x).strip()],
+        "mitigations": [str(x).strip() for x in mitigations if str(x).strip()],
+    }
+
+
+def run_build(proposal_id: str):
+    facts = load_raw_facts(proposal_id)
+    # 全局先做一次 risk/mitigation 纠偏
+    facts = reclassify_risk_mitigation_global(facts)
+    grouped = group_facts_by_dimension(facts)
+
+    # 额外输出一份 dimension_facts.json，方便后续人工检查和调试
+    out_dir = EXTRACTED_DIR / proposal_id
+    out_dir.mkdir(parents=True, exist_ok=True)
+    dim_facts_path = out_dir / "dimension_facts.json"
+    dim_facts_path.write_text(
+        json.dumps(grouped, ensure_ascii=False, indent=2),
+        encoding="utf-8",
+    )
+    print(f"[OK] 已写出按维度分组的 facts: {dim_facts_path}")
+
+    dimensions_result: Dict[str, Dict[str, Any]] = {}
+
+    for dim in DIMENSION_NAMES:
+        dim_facts = grouped.get(dim, [])
+        print(f"\n[INFO] 开始构建维度 {dim} ...")
+
+        if not dim_facts:
+            # 没有任何事实，给一个空壳（显式指出信息缺失）
+            dimensions_result[dim] = {
+                "summary": f"提案文本中关于 {dim} 维度的明确信息较少，无法做出详细总结。",
+                "key_points": [],
+                "risks": [f"提案中关于 {dim} 维度的细节信息较少，可能影响评估。"],
+                "mitigations": ["提案未具体说明如何补充或缓解该维度信息不足的问题。"],
+            }
+            print(f"[INFO] 维度 {dim} 无事实，写入占位结果。")
+            continue
+
+        data = call_llm_for_dimension(dim, dim_facts)
+
+        # ==== 风险覆盖度标记 ====
+        risk_count = len(data.get("risks", []) or [])
+        if risk_count == 0:
+            level = "low"
+            reason = "提案文本中几乎没有显式描述该维度相关的风险，系统无法进行充分的风险细化。"
+        elif risk_count <= 2:
+            level = "medium"
+            reason = "该维度仅有少量风险相关描述，风险分析的粒度有限。"
+        else:
+            level = "high"
+            reason = "该维度在提案中有较为丰富的风险相关描述，可以进行较细致的风险分析。"
+
+        data["risk_coverage"] = {
+            "level": level,
+            "reason": reason,
+            "risk_count": risk_count,
+        }
+
+        dimensions_result[dim] = data
+
+        print(
+            f"[INFO] 维度 {dim} 完成：summary_len={len(data['summary'])}, "
+            f"key_points={len(data['key_points'])}, risks={len(data['risks'])}, "
+            f"mitigations={len(data['mitigations'])}, "
+            f"risk_coverage={level}"
+        )
+
+    # 1) 写入 per-proposal 维度文件
+    out_path = out_dir / "dimensions_v2.json"
+    out_path.write_text(
+        json.dumps(dimensions_result, ensure_ascii=False, indent=2),
+        encoding="utf-8",
+    )
+    print(f"\n[OK] 新版五维度文件已生成: {out_path}")
+
+    # 2) 同时写一份全局 parsed 文件给 llm_answering 用
+    PARSED_DIR.mkdir(parents=True, exist_ok=True)
+    parsed_path = PARSED_DIR / "parsed_dimensions.clean.llm.json"
+
+    parsed_obj = {
+        dim: {
+            "summary": data.get("summary", ""),
+            "key_points": data.get("key_points", []),
+            "risks": data.get("risks", []),
+            "mitigations": data.get("mitigations", []),
+        }
+        for dim, data in dimensions_result.items()
+    }
+
+    parsed_path.write_text(
+        json.dumps(parsed_obj, ensure_ascii=False, indent=2),
+        encoding="utf-8",
+    )
+    print(f"[OK] 已写出 parsed 维度文件供 llm_answering 使用: {parsed_path}")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Stage 2: 基于 raw_facts.jsonl 构建五个维度的 dimensions_v2.json"
+    )
+    parser.add_argument(
+        "--proposal_id",
+        required=False,
+        help="提案 ID（对应 src/data/extracted/<proposal_id>）",
+    )
+    args = parser.parse_args()
+
+    if args.proposal_id:
+        pid = args.proposal_id
+    else:
+        # 默认用 extracted 里最新的一个子目录
+        if not EXTRACTED_DIR.exists():
+            raise FileNotFoundError(f"未找到 extracted 目录: {EXTRACTED_DIR}")
+        candidates = [
+            (d.stat().st_mtime, d.name)
+            for d in EXTRACTED_DIR.iterdir()
+            if d.is_dir()
+        ]
+        if not candidates:
+            raise FileNotFoundError(f"extracted 目录下没有任何子目录: {EXTRACTED_DIR}")
+        pid = max(candidates, key=lambda x: x[0])[1]
+        print(f"[INFO] [auto] 选中最新提案 ID: {pid}")
+
+    run_build(pid)
+
+
+if __name__ == "__main__":
+    main()

src/tools/build_vector_db.py

@@ -0,0 +1,218 @@
+# -*- coding: utf-8 -*-
+"""
+阶段 5：构建向量化知识库（Knowledge Base Builder, v2025.12R · Fusion-Sync Edition）
+增强内容：
+  ✅ 同步兼容 fusion_search v2025.12R 输出结构（含 confidence_distribution / embedding_model）
+  ✅ 动态过滤（短文本 + 低置信文本）
+  ✅ 分层统计：高/中/低置信度文档数量与均值
+  ✅ 自动 GPU 检测 + 自适应 batch_size
+  ✅ 健康检查：计算入库率与记录分布
+  ✅ 输出增强索引（含 confidence_tiers 与全局平均置信度）
+"""
+
+import os
+import sys
+import json
+import numpy as np
+from datetime import datetime
+from pathlib import Path
+from typing import List, Dict, Any
+from sentence_transformers import SentenceTransformer
+import chromadb
+
+# ========= 路径与环境 =========
+CURRENT_DIR = Path(__file__).resolve().parent
+SRC_ROOT = CURRENT_DIR.parent
+if str(SRC_ROOT) not in sys.path:
+    sys.path.insert(0, str(SRC_ROOT))
+
+DATA_DIR = SRC_ROOT / "data"
+FUSION_ROOT = DATA_DIR / "fused_evidence"
+VECTOR_DB_DIR = DATA_DIR / "vector_db"
+VECTOR_DB_DIR.mkdir(parents=True, exist_ok=True)
+
+# ========= 自动检测最新提案 =========
+subdirs = [d for d in FUSION_ROOT.iterdir() if d.is_dir()]
+if not subdirs:
+    raise FileNotFoundError("❌ 未找到 fused_evidence，请先运行 fusion_search.py")
+latest_dir = max(subdirs, key=lambda d: d.stat().st_mtime)
+proposal_id = latest_dir.name
+print(f"📂 当前导入提案：{proposal_id}")
+
+# ========= 模型加载 =========
+EMBED_MODEL = "BAAI/bge-large-zh-v1.5"
+print(f"🧠 正在加载嵌入模型：{EMBED_MODEL} ...")
+model = SentenceTransformer(EMBED_MODEL)
+
+device = "cuda" if getattr(model, "device", None) and model.device.type == "cuda" else "cpu"
+BATCH_SIZE = int(os.getenv("EMBED_BATCH", "8"))
+print(f"💻 推理设备：{device.upper()} | batch_size={BATCH_SIZE}")
+
+# ========= 初始化数据库 =========
+collection_name = f"fusion_{proposal_id}"
+client = chromadb.PersistentClient(path=str(VECTOR_DB_DIR))
+collection = client.get_or_create_collection(
+    name=collection_name,
+    metadata={
+        "desc": "RAG Vector Knowledge Base (Fusion 2025.12R)",
+        "proposal_id": proposal_id,
+        "created_at": str(datetime.now())
+    }
+)
+print(f"✅ 已加载向量集合：{collection_name}")
+
+# ========= 工具函数 =========
+def _as_list(x):
+    if isinstance(x, list): return x
+    if not x: return []
+    return [str(x)]
+
+def _join_urls(urls: List[str], limit=8) -> str:
+    urls = urls[:limit]
+    return "; ".join(urls)
+
+def _load_fused_jsons(fusion_dir: Path) -> List[Dict[str, Any]]:
+    """
+    加载 fusion_search 输出文件:
+    - data["fused_texts"] : [{text, urls, avg_conf}]
+    - 跳过短文本与低置信文本
+    """
+    docs = []
+    for f in fusion_dir.glob("*_fused.json"):
+        try:
+            dim = f.stem.replace("_fused", "")
+            data = json.loads(f.read_text(encoding="utf-8"))
+            fused_texts = data.get("fused_texts", [])
+            threshold_lowconf = 0.45
+            valid = 0
+            for i, item in enumerate(fused_texts):
+                if not isinstance(item, dict):
+                    continue
+                text = (item.get("text") or "").strip()
+                urls = _as_list(item.get("urls") or [])
+                avg_conf = float(item.get("avg_conf") or data.get("avg_confidence_weighted", 0.6))
+                if len(text) < 100 or avg_conf < threshold_lowconf:
+                    continue
+                doc_id = f"{proposal_id}_{dim}_{i}"
+                meta = {
+                    "dimension": dim,
+                    "proposal_id": proposal_id,
+                    "source_file": f.name,
+                    "urls": _join_urls(urls),
+                    "avg_confidence": avg_conf,
+                    "fusion_threshold": data.get("threshold", 0.65),
+                    "embedding_model": data.get("embedding_model", EMBED_MODEL)
+                }
+                docs.append({"id": doc_id, "text": text, "meta": meta})
+                valid += 1
+            print(f"✅ 加载 {dim:<12} → {valid} 条有效文本")
+        except Exception as e:
+            print(f"⚠️ 解析 {f.name} 出错: {e}")
+    return docs
+
+def _dedup_ids(ids: List[str]) -> List[bool]:
+    try:
+        existing = set(collection.get(ids=ids).get("ids", []))
+    except Exception:
+        existing = set()
+    return [(_id not in existing) for _id in ids]
+
+# ========= 主流程 =========
+def build_vector_db():
+    docs = _load_fused_jsons(latest_dir)
+    if not docs:
+        print("❌ 无融合数据可导入。")
+        return
+
+    texts = [d["text"] for d in docs]
+    ids = [d["id"] for d in docs]
+    metas = [d["meta"] for d in docs]
+    avg_len = sum(len(t) for t in texts) / max(len(texts), 1)
+
+    print(f"\n📊 文本总数：{len(texts)} | 平均长度：{avg_len:.1f} 字符")
+
+    # ===== 嵌入生成 =====
+    print("🧩 正在生成嵌入向量 ...")
+    embeddings = model.encode(
+        texts,
+        normalize_embeddings=True,
+        show_progress_bar=True,
+        batch_size=BATCH_SIZE,
+        device=device
+    )
+
+    # ===== 去重写入 =====
+    print("💾 正在写入 Chroma 数据库 ...")
+    new_mask = _dedup_ids(ids)
+    new_ids = [i for i, keep in zip(ids, new_mask) if keep]
+    if not new_ids:
+        print("⚠️ 无新增记录（可能已导入过该提案）。")
+    else:
+        collection.add(
+            ids=new_ids,
+            documents=[t for t, keep in zip(texts, new_mask) if keep],
+            embeddings=[e.tolist() for e, keep in zip(embeddings, new_mask) if keep],
+            metadatas=[m for m, keep in zip(metas, new_mask) if keep]
+        )
+        print(f"✅ 已写入 {len(new_ids)} 条新记录。")
+
+    # ===== 统计分布 =====
+    dim_stats = {}
+    conf_all = []
+    for m in metas:
+        dim = m["dimension"]
+        conf = float(m.get("avg_confidence", 0.6))
+        conf_all.append(conf)
+        dim_stats.setdefault(dim, {"count": 0, "conf_sum": 0.0, "high": 0, "mid": 0, "low": 0})
+        dim_stats[dim]["count"] += 1
+        dim_stats[dim]["conf_sum"] += conf
+        if conf >= 0.8:
+            dim_stats[dim]["high"] += 1
+        elif conf >= 0.6:
+            dim_stats[dim]["mid"] += 1
+        else:
+            dim_stats[dim]["low"] += 1
+
+    dim_distribution = {
+        k: {
+            "count": v["count"],
+            "avg_conf": round(v["conf_sum"] / max(v["count"], 1), 2),
+            "confidence_tiers": {
+                "high": v["high"],
+                "mid": v["mid"],
+                "low": v["low"]
+            }
+        } for k, v in dim_stats.items()
+    }
+
+    global_avg_conf = round(np.mean(conf_all), 3)
+    total_records = sum(v["count"] for v in dim_stats.values())
+    stored_count = collection.count()
+    insert_rate = round((stored_count / max(total_records, 1)) * 100, 1)
+
+    # ===== 保存索引 =====
+    index_info = {
+        "proposal_id": proposal_id,
+        "collection_name": collection_name,
+        "record_count": total_records,
+        "stored_count": stored_count,
+        "insert_rate_percent": insert_rate,
+        "avg_text_length": round(avg_len, 1),
+        "dimension_distribution": dim_distribution,
+        "global_avg_confidence": global_avg_conf,
+        "embedding_model": EMBED_MODEL,
+        "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        "db_path": str(VECTOR_DB_DIR.resolve())
+    }
+
+    index_path = VECTOR_DB_DIR / f"{proposal_id}_vector_index.json"
+    index_path.write_text(json.dumps(index_info, ensure_ascii=False, indent=2), encoding="utf-8")
+
+    print(f"\n🧾 向量库索引已保存：{index_path}")
+    print(f"📦 当前集合条目：{stored_count} | 全局平均置信度：{global_avg_conf}")
+    print(f"📊 入库率：{insert_rate:.1f}%")
+    print("🎯 向量知识库构建完成。")
+
+# ========= 入口 =========
+if __name__ == "__main__":
+    build_vector_db()

src/tools/domain_profiler.py

@@ -0,0 +1,213 @@
+# -*- coding: utf-8 -*-
+from __future__ import annotations
+
+import json
+import os
+import re
+from collections import Counter
+from typing import Any, Dict, List, Sequence, Tuple
+
+from src.prompting.domain_adaptive import sanitize_domain_profile
+
+try:
+    from openai import OpenAI  # type: ignore
+except Exception:
+    OpenAI = None
+
+
+DEFAULT_MODEL = os.getenv("OPENAI_MODEL", "gpt-4o-mini")
+
+
+def _clean_text(text: str) -> str:
+    return re.sub(r"\s+", " ", text or "").strip()
+
+
+def extract_keywords(text: str, max_terms: int = 18) -> List[str]:
+    tokens = re.findall(r"[A-Za-z][A-Za-z\-\+\.]{2,}|[\u4e00-\u9fff]{2,}", text)
+    stop = {
+        "proposal", "project", "system", "technology", "market", "company", "team", "development",
+        "研究", "项目", "公司", "系统", "技术", "团队", "市场", "发展", "方案", "计划", "应用",
+        "产品", "核心", "页码", "介绍", "融资", "背景", "价值",
+    }
+    counts = Counter(tok.lower() for tok in tokens if tok.lower() not in stop)
+    return [t for t, _ in counts.most_common(max_terms)]
+
+
+def heuristic_domain_profile(full_text: str, pages: Sequence[Dict[str, Any]]) -> Dict[str, Any]:
+    """
+    Strictly derive a lightweight domain profile from the CURRENT document only.
+    No hard-coded domain catalog, no historical/default domain injection.
+    """
+    text = _clean_text(full_text)
+    keywords = extract_keywords(text)
+
+    generic_terms = {
+        "model", "models", "system", "systems", "method", "methods",
+        "analysis", "data", "study", "research", "approach",
+        "based", "using", "results", "validation", "evaluation"
+    }
+
+    top_keywords = [kw for kw in keywords if kw and kw.lower() not in generic_terms][:8]
+
+    if not top_keywords:
+        return sanitize_domain_profile({
+            "domain": {"primary": "unknown", "secondary": []},
+            "evaluation_focus": {
+                "problem": [],
+                "objectives": [],
+                "feasibility": [],
+                "innovation": [],
+                "team": [],
+                "outcomes": [],
+            },
+            "methods": [],
+            "risks": [],
+            "terminology": [],
+        })
+
+    primary_domain = top_keywords[0]
+    secondary_domains = top_keywords[1:4]
+
+    profile = {
+        "domain": {
+            "primary": primary_domain,
+            "secondary": secondary_domains,
+        },
+        "evaluation_focus": {
+            "problem": [
+                "problem importance",
+                "context clarity",
+                "need definition",
+            ],
+            "objectives": [
+                "objective clarity",
+                "scope definition",
+                "deliverable specificity",
+            ],
+            "feasibility": [
+                "resource readiness",
+                "timeline realism",
+                "dependency management",
+            ],
+            "innovation": [
+                "novelty",
+                "differentiation",
+                "comparative advantage",
+            ],
+            "team": [
+                "relevant expertise",
+                "role coverage",
+                "execution capability",
+            ],
+            "outcomes": [
+                "measurable outputs",
+                "impact logic",
+                "evaluation plan",
+            ],
+        },
+        "methods": top_keywords[:4],
+        "risks": [],
+        "terminology": top_keywords[:8],
+    }
+
+    return sanitize_domain_profile(profile)
+
+
+LLM_PROFILER_SYSTEM = """
+You are a strict domain profiler for proposal review.
+
+Your task is ONLY to derive a clean domain profile from the CURRENT document text.
+
+Hard rules:
+- Use ONLY the provided document text.
+- Ignore any prior tasks, prior files, templates, examples, cached memory, or default domains.
+- Do NOT guess a domain from common proposal patterns.
+- Do NOT mix domains unless the document clearly and repeatedly supports both.
+- If the evidence is weak, return "unknown".
+- Prefer short, concrete domain labels grounded in repeated terms from the text.
+- Do NOT output aerospace, biomedical, or any specific field unless clearly supported by repeated explicit terms.
+- Keep all lists short and text-grounded.
+- Return valid JSON only.
+
+Return JSON with exactly this structure:
+{
+  "domain": {
+    "primary": "string",
+    "secondary": ["string"]
+  },
+  "evaluation_focus": {
+    "problem": ["string"],
+    "objectives": ["string"],
+    "feasibility": ["string"],
+    "innovation": ["string"],
+    "team": ["string"],
+    "outcomes": ["string"]
+  },
+  "methods": ["string"],
+  "risks": ["string"],
+  "terminology": ["string"]
+}
+""".strip()
+
+
+def profile_with_optional_llm(full_text: str, pages: Sequence[Dict[str, Any]]) -> Tuple[Dict[str, Any], str]:
+    heuristic = heuristic_domain_profile(full_text, pages)
+
+    api_key = os.getenv("OPENAI_API_KEY", "").strip()
+    if not api_key or OpenAI is None:
+        return heuristic, "heuristic"
+
+    try:
+        client = OpenAI(api_key=api_key)
+        response = client.chat.completions.create(
+            model=DEFAULT_MODEL,
+            messages=[
+                {"role": "system", "content": LLM_PROFILER_SYSTEM},
+                {"role": "user", "content": full_text[:16000]},
+            ],
+            response_format={"type": "json_object"},
+            temperature=0.0,
+            max_tokens=900,
+        )
+
+        raw = response.choices[0].message.content or "{}"
+        data = sanitize_domain_profile(json.loads(raw))
+
+        primary = _clean_text(data.get("domain", {}).get("primary", ""))
+        terminology = data.get("terminology", []) or []
+        methods = data.get("methods", []) or []
+        risks = data.get("risks", []) or []
+
+        bad_primary = {
+            "",
+            "general",
+            "general proposal",
+            "proposal",
+            "research proposal",
+            "project proposal",
+            "unknown",
+        }
+
+        def is_fragment_list(lst):
+            if not lst:
+                return True
+            short = len([x for x in lst if len(x.strip()) <= 1])
+            return short >= max(1, len(lst) * 0.6)
+
+        def is_punctuation_noise(lst):
+            return any(re.fullmatch(r"[、,;；\.\-]+", x.strip()) for x in lst)
+
+        # 🚨 强力质量拦截
+        if (
+            primary.lower() in bad_primary
+            or is_fragment_list(methods)
+            or is_fragment_list(risks)
+            or is_punctuation_noise(methods)
+            or is_punctuation_noise(risks)
+        ):
+            return heuristic, "heuristic_fallback_bad_quality"
+
+        return data, "llm"
+
+    except Exception:
+        return heuristic, "heuristic_fallback"

src/tools/extract_facts_by_chunk.py

@@ -0,0 +1,786 @@
+# -*- coding: utf-8 -*-
+"""
+Stage 1 · 块级事实抽取器（extract_facts_by_chunk.py）
+----------------------------------------------------
+输入：
+  - src/data/prepared/<proposal_id>/full_text.txt  （由 prepare_proposal_text.py 生成）
+
+输出：
+  - src/data/extracted/<proposal_id>/raw_facts.jsonl  每行一个 JSON fact
+
+职责：
+  - 将长文按字符切块（带 overlap）
+  - 对每个块，用 LLM 抽取“原子事实列表”
+  - 每条事实附带：dimensions[], type, meta(chunk_index, char_range 由代码填充)
+  - 后续 Stage 2 再用这些 facts 去构建五个维度的最终 dimensions_v2.json
+
+本版优化要点：
+  1）减小 chunk 大小、加大 overlap，提高单块信息覆盖率，避免一个块塞太多信息导致抽不全。
+  2）加强 Prompt 中对“五维覆盖”的要求，显式提醒模型不要只抽单一维度的信息。
+  3）更激进的 type→dimensions 映射，让跨维度事实被多个维度同时看到，避免某维度信息过于稀薄。
+  4）扩充关键词推断逻辑 _infer_dims_from_text，补充 objectives / innovation / feasibility 等隐性表述。
+  5）在运行结束时输出五个维度的事实数量分布，并对明显偏少的维度给出警告，便于调参与排错。
+  6）新增：对“文本很长但抽取事实过少”的 chunk 自动再跑一轮 dense 模式，强化召回。
+"""
+
+import os
+import json
+import argparse
+import re
+from pathlib import Path
+from typing import List, Dict, Any
+
+from dotenv import load_dotenv
+try:
+    from openai import OpenAI
+except Exception:  # pragma: no cover
+    OpenAI = None
+
+from .layout_reconstruction import semantic_pages_for_stage1
+
+load_dotenv()
+
+# ========= 路径配置 =========
+
+BASE_DIR = Path(__file__).resolve().parents[2]
+PREPARED_DIR = BASE_DIR / "src" / "data" / "prepared"
+EXTRACTED_DIR = BASE_DIR / "src" / "data" / "extracted"
+
+OPENAI_MODEL = os.getenv("OPENAI_MODEL", "gpt-4o-mini")
+
+# 全局复用一个 OpenAI client，避免每个 chunk 反复初始化
+client = OpenAI() if OpenAI is not None else None
+
+VALID_DIMENSIONS = ["team", "objectives", "strategy", "innovation", "feasibility"]
+VALID_TYPES = [
+    "team_member",
+    "org_structure",
+    "collaboration",
+    "resource",
+    "pipeline",
+    "milestone",
+    "market",
+    "tech_route",
+    "product",
+    "ip_asset",
+    "evidence",
+    "budget_item",
+    "funding_source",
+    "risk",
+    "mitigation",
+    "ai_model",
+    "clinical_design",
+    "regulatory",
+    "other",
+]
+
+# ⚠️ Prompt：既要防幻觉，又要尽量“捞干净”五维相关信息，并保证多维覆盖
+
+FACT_PROMPT = """
+你是一个“事实抽取器”，负责从一小段项目文本中逐条抽取可核对的原子事实。
+
+硬性约束：
+1）只处理当前文本块，不猜测其他页面或上下文。
+2）不得编造任何文本中没有出现的机构、人物、对象、方法、数据、数字、时间、地点或结果。
+3）每条 fact 必须能在原文中找到对应依据，可以轻微改写，但必须保留关键名词。
+4）每条 fact 尽量只表达一个独立事实；若一句话包含多个主题，请拆开。
+5）只输出 JSON，不输出解释。
+
+适用范围：
+- 任意科研、技术、教育、产业、治理或跨学科项目
+- 不得预设具体领域
+
+优先抽取的信息：
+- 团队与组织：成员、角色、机构、职责、协作关系、治理安排
+- 目标与范围：总体目标、阶段目标、任务边界、里程碑、交付物、评价指标
+- 方法与路线：技术路线、研究方法、实施步骤、验证设计、工作流、平台或工具
+- 创新与差异化：新颖点、独特资源、已有证据、比较优势、知识产权
+- 可行性与风险：资源基础、数据/设备/资金/时间条件、风险、限制、应对措施
+- 外部环境：用户/对象/场景/应用环境/政策约束/市场与需求信息（若文本明确提及）
+
+抽取粒度要求：
+- 信息丰富时尽量抽取 12–25 条 facts；信息较少时可少于 10 条；总数不要超过 25 条。
+- 尽量覆盖不同主题，不要只集中在单一维度。
+
+维度标签（dimensions）：
+- "team": 团队、角色、机构、分工、协同、治理
+- "objectives": 问题背景、目标、范围、里程碑、交付物、评价指标
+- "strategy": 方法、技术路线、实施流程、实验/验证/落地路径、外部协作策略
+- "innovation": 新颖性、差异化、独特资源、证据优势、知识产权
+- "feasibility": 资源、预算、时间、风险、限制、依赖关系、应对措施
+
+要求：
+- 每条 fact 至少有 1 个维度标签；允许多标签。
+- 若无法判断，使用 ["feasibility"] 兜底。
+
+type 可选值：
+- team_member, org_structure, collaboration, resource, pipeline, milestone,
+  market, tech_route, product, ip_asset, evidence, budget_item, funding_source,
+  risk, mitigation, ai_model, clinical_design, regulatory, other
+
+type 选���规则：
+- 选择最接近文本语义的类型即可；若不确定，用 other。
+- market / regulatory / clinical_design 等类型可以用于任何“外部约束、验证设计、制度流程”场景，
+  不代表你必须假设项目属于某个特定行业。
+
+输出格式：
+{
+  "facts": [
+    {
+      "text": "一条具体、可核对的事实",
+      "dimensions": ["team", "strategy"],
+      "type": "team_member"
+    }
+  ]
+}
+
+如果当前文本块没有任何有用事实，返回 {"facts": []}。
+现在开始处理我给你的文本块。
+"""
+
+
+def find_latest_prepared_proposal() -> str:
+    if not PREPARED_DIR.exists():
+        raise FileNotFoundError(f"未找到 prepared 目录: {PREPARED_DIR}")
+
+    candidates = []
+    for d in PREPARED_DIR.iterdir():
+        if d.is_dir():
+            candidates.append((d.stat().st_mtime, d.name))
+
+    if not candidates:
+        raise FileNotFoundError(f"prepared 目录下没有任何提案子目录: {PREPARED_DIR}")
+
+    proposal_id = max(candidates, key=lambda x: x[0])[1]
+    print(f"[INFO] [auto] 选中最新提案 ID: {proposal_id}")
+    return proposal_id
+
+
+
+
+def load_page_semantics(proposal_id: str) -> Dict[str, Any]:
+    path = PREPARED_DIR / proposal_id / "page_semantics.json"
+    if not path.exists():
+        return {}
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+        print(f"[INFO] 读取 page_semantics: {path}")
+        return data
+    except Exception as e:
+        print(f"[WARN] page_semantics.json 读取失败，退回 full_text 模式: {e}")
+        return {}
+
+
+def load_semantic_units(proposal_id: str) -> List[Dict[str, Any]]:
+    page_sem = load_page_semantics(proposal_id)
+    if not page_sem:
+        return []
+    units = semantic_pages_for_stage1(page_sem)
+    return [u for u in units if (u.get("text") or "").strip()]
+
+def load_full_text(proposal_id: str) -> str:
+    path = PREPARED_DIR / proposal_id / "full_text.txt"
+    if not path.exists():
+        raise FileNotFoundError(f"full_text.txt 不存在: {path}")
+    text = path.read_text(encoding="utf-8")
+    print(f"[INFO] 读取 full_text: {path} (长度 {len(text)} 字符)")
+    return text
+
+
+def make_chunks(text: str, max_chars: int = 1800, overlap: int = 400) -> List[Dict[str, Any]]:
+    """
+    简单按字符切块，带 overlap；不做句子级别切分。
+    默认 max_chars=1800, overlap=400，比之前更细、更密，有利于提高抽取覆盖率。
+    返回列表，每个元素包含: chunk_text, start, end, index
+    """
+    chunks = []
+    n = len(text)
+    if n == 0:
+        return chunks
+
+    idx = 0
+    chunk_idx = 0
+    while idx < n:
+        end = min(n, idx + max_chars)
+        chunk_text = text[idx:end]
+        chunks.append(
+            {
+                "index": chunk_idx,
+                "start": idx,
+                "end": end,
+                "text": chunk_text,
+            }
+        )
+        chunk_idx += 1
+        if end == n:
+            break
+        idx = max(0, end - overlap)
+
+    print(f"[INFO] 已切分为 {len(chunks)} 个 chunk (max_chars={max_chars}, overlap={overlap})")
+    return chunks
+
+
+def make_semantic_chunks(units: List[Dict[str, Any]], max_chars: int = 2200) -> List[Dict[str, Any]]:
+    chunks: List[Dict[str, Any]] = []
+    current_parts: List[str] = []
+    current_pages: List[int] = []
+    current_len = 0
+    chunk_idx = 0
+
+    def flush():
+        nonlocal current_parts, current_pages, current_len, chunk_idx
+        if not current_parts:
+            return
+        text = "\n\n".join(current_parts).strip()
+        chunks.append({
+            "index": chunk_idx,
+            "start": 0,
+            "end": len(text),
+            "text": text,
+            "page_indices": sorted(set(current_pages)),
+            "source": "page_semantics",
+        })
+        chunk_idx += 1
+        current_parts = []
+        current_pages = []
+        current_len = 0
+
+    for unit in units:
+        text = (unit.get("text") or "").strip()
+        if not text:
+            continue
+        page_idx = unit.get("page_index")
+        if current_len and current_len + len(text) + 2 > max_chars:
+            flush()
+        current_parts.append(text)
+        if page_idx is not None:
+            current_pages.append(page_idx)
+        current_len += len(text) + 2
+    flush()
+    print(f"[INFO] 基于 page_semantics 构建 {len(chunks)} 个语义 chunk")
+    return chunks
+
+
+def call_llm_for_chunk(chunk_text: str, attempt: int = 1, dense: bool = False) -> Dict[str, Any]:
+    """
+    调用 OpenAI，对单个 chunk 抽取 facts。
+    - attempt > 1：用于 JSON 解析失败后的重试（提示“上一次 JSON 不合法”）。
+    - dense = True：用于“当前 chunk 文本很长但事实过少”的第二轮密集抽取，会额外要求多抽一些 facts。
+    """
+    extra_hint_parts = []
+
+    if attempt > 1:
+        extra_hint_parts.append(
+            "⚠️ 注意：上一次你返回的 JSON 因为太��或不合法导致解析失败。"
+            "这一次请严格控制 facts 数量不超过 18 条，并且务必保证 JSON 语法完全正确。"
+        )
+
+    if dense:
+        extra_hint_parts.append(
+            "⚠️ 当前文本块信息非常丰富，你在本次抽取时应尽量覆盖文本中出现的所有与团队、目标、"
+            "策略、创新、可行性相关的关键事实。请优先抽取 15–22 条 facts，"
+            "并尽量覆盖不同维度和不同主题，不要只聚焦在单一方面。"
+        )
+
+    extra_hint = ""
+    if extra_hint_parts:
+        extra_hint = "\n\n" + "\n".join(extra_hint_parts)
+
+    messages = [
+        {
+            "role": "system",
+            "content": "你是一个严谨的事实抽取器，只能基于给定文本块抽取原子事实，不得编造。",
+        },
+        {
+            "role": "user",
+            "content": FACT_PROMPT
+            + extra_hint
+            + "\n\n=== 文本块开始 ===\n"
+            + chunk_text.strip(),
+        },
+    ]
+
+    if client is None:
+        raise RuntimeError("OpenAI SDK 未安装或不可用，无法执行 Stage 1 facts 抽取。")
+
+    resp = client.chat.completions.create(
+        model=OPENAI_MODEL,
+        messages=messages,
+        response_format={"type": "json_object"},
+        temperature=0.0,
+        max_tokens=1800,
+    )
+
+    raw = resp.choices[0].message.content
+    try:
+        data = json.loads(raw)
+    except json.JSONDecodeError as e:
+        print("[WARN] JSON 解析失败，返回原始内容，便于你排查：")
+        print(raw)
+        if attempt == 1:
+            print("[INFO] 尝试使用收缩版 prompt 重试该 chunk ...")
+            return call_llm_for_chunk(chunk_text, attempt=2, dense=dense)
+        # 第二次还失败就直接抛出
+        raise e
+
+    if not isinstance(data, dict):
+        data = {"facts": []}
+    if "facts" not in data or not isinstance(data["facts"], list):
+        data["facts"] = []
+
+    return data
+
+# ===== 市场类关键词 & 识别函数 =====
+
+_MARKET_CN = [
+    "市场", "市场规模", "市场容量", "市场需求", "市场前景", "市场潜力",
+    "目标市场", "细分市场", "市场份额", "渗透率",
+    "客户", "客户群体", "目标客户", "目标人群",
+    "患者群体", "目标患者",
+    "销售", "销售额", "销量", "营收", "收入", "收益",
+    "定价", "价格", "报销", "支付方", "医保", "保险",
+    "商业化", "商业模式", "商业机会",
+    "竞争", "竞品", "竞争对手", "竞争格局",
+    "CAGR", "增长率"
+]
+
+_MARKET_EN = [
+    "market", "market size", "market volume", "market demand", "market potential",
+    "target market", "segment", "niche",
+    "market share", "penetration",
+    "customer", "customers", "client", "clients",
+    "patient population", "target patients",
+    "sales", "revenue", "turnover", "income",
+    "pricing", "price", "reimbursement", "payer", "insurance",
+    "commercialization", "commercialisation", "business model",
+    "competition", "competitive", "competitor", "competitors",
+    "cagr", "growth rate"
+]
+
+
+def _looks_like_market_fact(text: str) -> bool:
+    """
+    判断一条 fact 的文本是否“明显是市场/商业相关”的内容。
+    注意：这里只用来纠偏 type，对 risk/mitigation 不覆盖。
+    """
+    if not text:
+        return False
+    t = text.lower()
+
+    # 中文关键字
+    if any(k in text for k in _MARKET_CN):
+        return True
+
+    # 英文关键字
+    if any(k in t for k in _MARKET_EN):
+        return True
+
+    return False
+
+def _infer_dims_from_text(text: str) -> List[str]:
+    """
+    当 LLM 没有给出 dimensions 且 type 也无法可靠映射时，
+    用中英文关键词做一轮粗略的维度推断，尽量不要丢掉有用信息。
+    这里只做“补充”，不会覆盖已有维度。
+    """
+    t_lower = (text or "").lower()
+    t = text or ""
+
+    candidates = set()
+
+    # ---- team ----
+    team_keywords = [
+        "团队", "小组", "联合体", "合作单位", "合作方", "协作单位",
+        "研究者", "研究团队", "专业团队", "项目组",
+        "负责人", "项目负责人", "带头人",
+        "教授", "副教授", "主任", "专家", "研究员", "博士", "博士后",
+        "机构", "大学", "研究所", "中心", "实验室",
+        "ceo", "coo", "cto", "cso", "vp", "vice president",
+        "founder", "co-founder", "chief executive officer",
+    ]
+    if any(k in t for k in team_keywords) or any(k in t_lower for k in team_keywords):
+        candidates.add("team")
+
+    # ---- objectives ----
+    obj_keywords_cn = [
+        "目标", "总体目标", "阶段性目标", "里程碑", "阶段性里程碑",
+        "计划", "任务", "工作包", "kpi", "终点", "主要终点", "次要终点",
+        "本项目旨在", "本项目将", "本项目计划", "预期达到", "希望实现",
+    ]
+    obj_keywords_en = [
+        "aim", "aims to", "aimed to",
+        "objective", "objectives", "goal", "goals",
+        "milestone", "milestones", "endpoint", "endpoints",
+        "is designed to", "seeks to", "intends to", "in order to",
+    ]
+    if any(k in t for k in obj_keywords_cn) or any(k in t_lower for k in obj_keywords_en):
+        candidates.add("objectives")
+
+    # ---- strategy ----
+    strat_keywords_cn = [
+        "策略", "路径", "路线", "方案", "技术路线", "实施方案",
+        "商业模式", "市场进入", "商业化", "推广策略",
+        "合作模式", "运营模式", "联合开发", "授权引进",
+        "市场", "市场规模", "市场需求", "市场前景", "市场潜力",
+        "市场份额", "竞争格局", "竞品", "竞争对手"
+    ]
+    strat_keywords_en = [
+        "strategy", "strategies", "pathway", "roadmap",
+        "commercial", "commercialization", "business model",
+        "market entry", "go-to-market", "go to market",
+        "market", "market size", "market demand", "market potential",
+        "market share", "competitive landscape", "competition", "competitor", "competitors",
+        "partnership", "licensing", "co-development",
+        "development plan", "regulatory strategy",
+    ]
+
+    if any(k in t for k in strat_keywords_cn) or any(k in t_lower for k in strat_keywords_en):
+        candidates.add("strategy")
+
+    # ---- innovation ----
+    inno_keywords_cn = [
+        "创新", "创新性", "差异化", "独特", "首创", "领先", "颠覆",
+        "新一代", "新型", "原创", "填补空白", "突破性", "首个", "第一例",
+    ]
+    inno_keywords_en = [
+        "novel", "novelty", "innovative", "innovation",
+        "differentiated", "differentiation", "unique",
+        "first-in-class", "best-in-class", "state-of-the-art",
+        "cutting-edge", "breakthrough", "original", "disruptive",
+        "fills the gap", "fill the gap",
+    ]
+    if any(k in t for k in inno_keywords_cn) or any(k in t_lower for k in inno_keywords_en):
+        candidates.add("innovation")
+
+    # ---- feasibility ----
+    feas_keywords_cn = [
+        "可行性", "可行", "可实施", "资源", "平台", "基础设施",
+        "预算", "经费", "资金", "成本", "成本负担",
+        "风险", "挑战", "瓶颈", "不确定性",
+        "时间表", "进度", "周期", "排期",
+        "入组难度", "依从性", "工作量", "实施复杂度",
+    ]
+    feas_keywords_en = [
+        "feasibility", "feasible", "resource", "resources", "infrastructure",
+        "budget", "funding", "cost", "costs", "cost-effectiveness",
+        "risk", "risks", "challenge", "challenges", "bottleneck", "uncertainty",
+        "timeline", "schedule", "timeframe",
+        "enrollment", "recruitment", "compliance", "adherence", "burden",
+    ]
+    if any(k in t for k in feas_keywords_cn) or any(k in t_lower for k in feas_keywords_en):
+        candidates.add("feasibility")
+
+    # ---- 为“需求/应用/外部环境”类段落兜底：补充 strategy / objectives ----
+    market_keywords_cn = [
+        "市场", "市场规模", "市场分析", "市场份额", "市场占有率",
+        "cagr", "复合年增长率", "销售额", "营收", "收入", "销售收入",
+        "增长率", "增长幅度", "客户", "用户", "消费群体",
+    ]
+    market_keywords_en = [
+        "market size", "market", "cagr", "market share", "share of",
+        "sales", "revenue", "revenues", "turnover",
+        "growth rate", "compound annual growth", "customer", "customers",
+        "payer", "payers",
+    ]
+    if any(k in t for k in market_keywords_cn) or any(k in t_lower for k in market_keywords_en):
+        candidates.add("strategy")
+        candidates.add("objectives")
+
+    return [d for d in candidates if d in VALID_DIMENSIONS]
+
+def mark_numeric_suspect(fact: Dict[str, Any], chunk_text: str) -> Dict[str, Any]:
+    """
+    对包含数字的 fact 做简单校验：
+    - 把 fact.text 里的数字片段（连续数字，不管是年份/金额）提取出来
+    - 如果某个数字完全不出现在 chunk_text 中，则认为这条 fact 存在数字幻觉风险
+    - 加 meta.suspect_numeric = True/False
+    """
+    text = fact.get("text", "") or ""
+    nums = re.findall(r"\d+", text)
+    if not nums:
+        return fact  # 没数字，不管
+
+    chunk_flat = (chunk_text or "").replace(" ", "")
+    suspect = False
+    for n in nums:
+        if n not in chunk_flat:
+            suspect = True
+            break
+
+    meta = fact.get("meta", {})
+    if not isinstance(meta, dict):
+        meta = {}
+    meta["suspect_numeric"] = suspect
+    fact["meta"] = meta
+    return fact
+
+def normalize_fact(
+    fact: Dict[str, Any],
+    proposal_id: str,
+    chunk_index: int,
+    start: int,
+    end: int,
+) -> Dict[str, Any]:
+    """
+    给每条 fact 填上 meta 信息；清洗 dimensions / type。
+    同时对维度标签做 type→dimensions 的通用“补标签”映射（支持多维度），
+    尽量保证五个维度的信息都不会被漏掉。
+    """
+    text = fact.get("text", "")
+    if not isinstance(text, str):
+        text = str(text)
+
+    # 原始维度标签清洗
+    dims = fact.get("dimensions", [])
+    if not isinstance(dims, list):
+        dims = []
+    dims_clean = [d for d in dims if isinstance(d, str) and d in VALID_DIMENSIONS]
+
+    type_val = fact.get("type", "other")
+    if type_val not in VALID_TYPES:
+        type_val = "other"
+
+    # ===== 外部环境/市场类事实的自动纠偏（在 type→dimensions 映射之前）=====
+    # 如果 LLM 没有标成 market，但文本里明显是需求/应用/市场相关内容，则强制改为 "market"
+    # （避免所有市场信息都被丢在 "other" 或 "product" 里）
+    if type_val not in ["market", "risk", "mitigation"]:
+        if _looks_like_market_fact(text):
+            type_val = "market"
+
+    # 先把已有维度放进一个 set，后面按 type / 文本内容补充
+    dim_set = set(dims_clean)
+
+    # ===== 1. 通用 type→dimensions 映射（更激进版本，优先保证信息被多个维度看到） =====
+    if type_val in ["team_member", "org_structure"]:
+        # 团队成员 / 组织结构 → 明确归入 team
+        dim_set.add("team")
+
+    elif type_val == "collaboration":
+        # 协作既是团队协同，也是合作策略
+        dim_set.update(["team", "strategy"])
+
+    elif type_val == "pipeline":
+        # 工作包/子任务：目标 + 路线，既体现 objectives，也体现 strategy
+        dim_set.update(["objectives", "strategy"])
+
+    elif type_val == "milestone":
+        # 里程碑：目标的阶段性拆分 + 执行可行性
+        dim_set.update(["objectives", "feasibility"])
+
+    elif type_val == "clinical_design":
+        # 验证/评估设计：目标路径 + 方案策略 + 执行可行性
+        dim_set.update(["objectives", "strategy", "feasibility"])
+
+    elif type_val in ["market", "product"]:
+        # 产品/应用环境：实施策略 + 落地可行性
+        dim_set.update(["objectives", "strategy", "feasibility"])
+
+    elif type_val in ["tech_route", "regulatory"]:
+        # 技术路线 / 制度流程：典型 strategy，但对可行性也有影响
+        dim_set.update(["strategy", "feasibility"])
+
+    elif type_val == "funding_source":
+        # 资金来源：既体现策略布局，也影响可行性
+        dim_set.update(["strategy", "feasibility"])
+
+    elif type_val == "ip_asset":
+        # IP 资产：创新优势 + 中长期可行性
+        dim_set.update(["innovation", "feasibility"])
+
+    elif type_val == "evidence":
+        # 证据：创新价值 + 可行性（证据越强，可行性越高）
+        dim_set.update(["innovation", "feasibility"])
+
+    elif type_val == "ai_model":
+        # AI 模型既是创新亮点，也是策略的一部分
+        dim_set.update(["innovation", "strategy"])
+
+    elif type_val in ["resource", "budget_item", "risk", "mitigation"]:
+        # 资源、预算、风险与应对 → 可行性
+        dim_set.add("feasibility")
+
+    # ===== 2. 如果还是没维度，用文本关键词再判断一轮 =====
+    if not dim_set:
+        inferred = _infer_dims_from_text(text)
+        for d in inferred:
+            dim_set.add(d)
+
+    # ===== 3. 最终兜底：还没有，就放到 feasibility，避免彻底丢失 =====
+    if not dim_set:
+        dim_set.add("feasibility")
+
+    dims_final = [d for d in dim_set if d in VALID_DIMENSIONS]
+
+    meta = fact.get("meta", {})
+    if not isinstance(meta, dict):
+        meta = {}
+    meta.update(
+        {
+            "proposal_id": proposal_id,
+            "chunk_index": chunk_index,
+            "char_start": start,
+            "char_end": end,
+        }
+    )
+
+    # ==== 计算 primary_dimension ====
+    primary_dim = None
+    if dims_final:
+        # 简单的优先级规则：尽量按内容来，不行就取第一个
+        # 你也可以自己按业务微调优先级
+        priority = ["team", "objectives", "strategy", "innovation", "feasibility"]
+        # 从 dims_final 里选出优先级最高的那一个
+        for d in priority:
+            if d in dims_final:
+                primary_dim = d
+                break
+        if primary_dim is None:
+            primary_dim = dims_final[0]
+    else:
+        primary_dim = "feasibility"  # 理论上不会走到这里，因为上面兜底了
+
+    return {
+        "text": text.strip(),
+        "dimensions": dims_final,
+        "type": type_val,
+        "primary_dimension": primary_dim,
+        "meta": meta,
+    }
+
+def run_extract(proposal_id: str, max_chars: int = 1800, overlap: int = 400):
+    semantic_units = load_semantic_units(proposal_id)
+    if semantic_units:
+        chunks = make_semantic_chunks(semantic_units, max_chars=max(max_chars, 2200))
+        print(f"[INFO] Stage 1 将优先使用 page_semantics 作为 facts 抽取输入")
+    else:
+        full_text = load_full_text(proposal_id)
+        chunks = make_chunks(full_text, max_chars=max_chars, overlap=overlap)
+
+    out_dir = EXTRACTED_DIR / proposal_id
+    out_dir.mkdir(parents=True, exist_ok=True)
+    out_path = out_dir / "raw_facts.jsonl"
+
+    total_facts = 0
+    # 统计每个维度的 fact 数量，便于 sanity check
+    dim_counts = {dim: 0 for dim in VALID_DIMENSIONS}
+
+    with out_path.open("w", encoding="utf-8") as f_out:
+        for ch in chunks:
+            idx = ch["index"]
+            chunk_len = ch["end"] - ch["start"]
+            print(f"\n[INFO] 处理 chunk {idx+1}/{len(chunks)} (chars={chunk_len})...")
+
+            # 第一次正常抽取
+            data = call_llm_for_chunk(ch["text"])
+            facts = data.get("facts", [])
+            if not isinstance(facts, list):
+                facts = []
+
+            # 如果 chunk 很长，但抽取的 facts 过少，则尝试 dense 模式重跑一次
+            if chunk_len >= 1200 and len(facts) < 5:
+                print(
+                    f"[INFO] 当前 chunk 文本较长(chars={chunk_len})，但只抽取到 {len(facts)} 条事实，"
+                    f"尝试使用 dense 模式重试以提高召回..."
+                )
+                dense_data = call_llm_for_chunk(ch["text"], dense=True)
+                dense_facts = dense_data.get("facts", [])
+                if isinstance(dense_facts, list) and len(dense_facts) > len(facts):
+                    print(
+                        f"[INFO] dense 模式抽取到 {len(dense_facts)} 条事实（优于原先的 {len(facts)} 条），"
+                        f"采用 dense 结果。"
+                    )
+                    facts = dense_facts
+                else:
+                    print(
+                        f"[INFO] dense 模式未显著提升（原 {len(facts)} 条，dense={len(dense_facts)} 条），"
+                        f"保留原始抽取结果。"
+                    )
+
+            normalized_list = []
+            for fact in facts:
+                if not isinstance(fact, dict):
+                    continue
+
+                # 先基于 chunk_text 标记 suspect_numeric
+                fact = mark_numeric_suspect(fact, ch["text"])
+
+                norm = normalize_fact(
+                    fact,
+                    proposal_id=proposal_id,
+                    chunk_index=idx,
+                    start=ch.get("start", 0),
+                    end=ch.get("end", len(ch.get("text", ""))),
+                )
+                norm.setdefault("meta", {})["source"] = ch.get("source", "full_text")
+                if ch.get("page_indices"):
+                    norm.setdefault("meta", {})["page_indices"] = ch.get("page_indices")
+
+                # 过滤掉空文本
+                if norm["text"]:
+                    normalized_list.append(norm)
+
+            for fact in normalized_list:
+                f_out.write(json.dumps(fact, ensure_ascii=False) + "\n")
+                total_facts += 1
+                # 更新维度计数
+                for d in fact.get("dimensions", []):
+                    if d in dim_counts:
+                        dim_counts[d] += 1
+
+            print(
+                f"[INFO] 该 chunk 最终写入 {len(normalized_list)} 条事实，"
+                f"目前累计 {total_facts} 条。"
+            )
+
+    print(f"\n[OK] 已写出事实文件: {out_path} (总事实数={total_facts})")
+
+    # ===== 全局维度分布检查 =====
+    print("\n[SUMMARY] 维度分布统计（基于 raw_facts.jsonl）：")
+    for dim in VALID_DIMENSIONS:
+        print(f"  - {dim}: {dim_counts[dim]} facts")
+
+    # 简单 sanity check：如果某个维度明显偏少，打个警告（这里只做提示，不终止）
+    if total_facts > 0:
+        avg = total_facts / len(VALID_DIMENSIONS)
+        for dim in VALID_DIMENSIONS:
+            if dim_counts[dim] < max(8, 0.25 * avg):
+                print(
+                    f"[WARN] 维度 {dim} 的事实数仅 {dim_counts[dim]}，"
+                    f"显著低于平均值 {avg:.1f}，可能存在抽取不足或映射偏差，"
+                    f"建议检查 raw_facts.jsonl 或适当调整 Prompt/映射。"
+                )
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Stage 1: 按 chunk 抽取原子事实（raw_facts.jsonl）"
+    )
+    parser.add_argument(
+        "--proposal_id",
+        required=False,
+        help="提案 ID（对应 src/data/prepared/<proposal_id>）",
+    )
+    parser.add_argument(
+        "--max_chars",
+        type=int,
+        default=1800,
+        help="每个 chunk 最大字符数（默认 1800）",
+    )
+    parser.add_argument(
+        "--overlap",
+        type=int,
+        default=400,
+        help="chunk 之间的字符重叠数（默认 400）",
+    )
+    args = parser.parse_args()
+
+    if args.proposal_id:
+        pid = args.proposal_id
+    else:
+        pid = find_latest_prepared_proposal()
+
+    run_extract(pid, max_chars=args.max_chars, overlap=args.overlap)
+
+
+if __name__ == "__main__":
+    main()

src/tools/fusion_search.py

@@ -0,0 +1,326 @@
+# -*- coding: utf-8 -*-
+"""
+阶段 3：Fusion Search（v2025.12 ProClean · Safe & Adaptive + Domain Hygiene）
+保持输出：src/data/fused_evidence/{proposal_id}/{dimension}_fused.json 等
+"""
+import os
+# 并行/线程稳定化
+os.environ.setdefault("TOKENIZERS_PARALLELISM","false")
+os.environ.setdefault("OMP_NUM_THREADS","1")
+os.environ.setdefault("OPENBLAS_NUM_THREADS","1")
+os.environ.setdefault("MKL_NUM_THREADS","1")
+os.environ.setdefault("VECLIB_MAXIMUM_THREADS","1")
+os.environ.setdefault("NUMEXPR_NUM_THREADS","1")
+os.environ.setdefault("LOKY_MAX_CPU_COUNT","1")
+
+import sys, re, json, numpy as np
+from pathlib import Path
+from datetime import datetime
+from collections import defaultdict, Counter
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from dotenv import load_dotenv
+load_dotenv()
+
+CURRENT_DIR = Path(__file__).resolve().parent
+SRC_ROOT = CURRENT_DIR.parent
+if str(SRC_ROOT) not in sys.path: sys.path.insert(0, str(SRC_ROOT))
+
+from sentence_transformers import SentenceTransformer, util
+from backend.utils.model_selector import get_llm_client
+
+DATA_DIR = SRC_ROOT / "data"
+EVIDENCE_DIR = DATA_DIR / "evidence"
+OUTPUT_DIR = DATA_DIR / "fused_evidence"
+for d in [EVIDENCE_DIR, OUTPUT_DIR]: d.mkdir(parents=True, exist_ok=True)
+
+# ==== 同步上游：优先使用环境变量指定的 proposal_id（与 search_by_dimension / web_search 一致） ====
+_env_pid = os.getenv("CURRENT_PROPOSAL_ID", "").strip()
+if _env_pid and (EVIDENCE_DIR / _env_pid).exists():
+    proposal_dir = EVIDENCE_DIR / _env_pid
+else:
+    subdirs = [d for d in EVIDENCE_DIR.iterdir() if d.is_dir()]
+    if not subdirs:
+        raise FileNotFoundError("❌ 未找到 evidence 子目录，请先运行 search_by_dimension.py")
+    proposal_dir = max(subdirs, key=lambda d: d.stat().st_mtime)
+
+proposal_id = proposal_dir.name
+print(f"📂 当前融合目标提案: {proposal_id}")
+
+FUSION_DIR = OUTPUT_DIR / proposal_id
+FUSION_DIR.mkdir(parents=True, exist_ok=True)
+
+# ==== 同步上游：学术/监管白名单加入 NMPA（与 web_search 对齐） ====
+ACADEMIC_DOMAINS = [
+    "pubmed.ncbi.nlm.nih.gov","pmc.ncbi.nlm.nih.gov","nature.com","sciencedirect.com",
+    "nih.gov","who.int","ema.europa.eu","fda.gov","clinicaltrials.gov",
+    "thelancet.com","bmj.com","cell.com","springer.com","biorxiv.org","medrxiv.org","arxiv.org","nejm.org",
+    "nmpa.gov.cn"
+]
+INSTITUTIONAL_HINTS = (".edu",".ac.","university","hospital")
+
+DOMAIN_BLACKLIST = (
+    "sol-war.ru","moomoo.com","money.finance.","islandenergy.je","xmind.com","scribd.com",
+    "pinterest.","medium.com","reddit.","bilibili.","zhihu.","weibo.","press","news","careers","recruit"
+)
+
+def _is_whitelisted_domain(host: str) -> bool:
+    h = (host or "").lower()
+    return any(h.endswith(d) for d in ACADEMIC_DOMAINS) or any(x in h for x in INSTITUTIONAL_HINTS)
+
+EMBED_MODEL = "BAAI/bge-m3"
+print(f"🧠 加载嵌入模型（CPU, safe）：{EMBED_MODEL}")
+embedder = SentenceTransformer(EMBED_MODEL, device="cpu")
+_EMB_KW = dict(normalize_embeddings=True, batch_size=16, show_progress_bar=False, convert_to_numpy=True)
+
+llm = get_llm_client()
+llm_client = llm["client"]; llm_model = llm["model_name"]; provider = llm["provider"]
+print(f"💬 使用 {provider.upper()} 模型：{llm_model}")
+
+def clean_text(text: str) -> str:
+    text = re.sub(r"\s+", " ", text)
+    text = re.sub(r"http\S+", "", text)
+    return text.strip()
+
+def extract_domain(url: str) -> str:
+    try:
+        return re.sub(r"^www\.", "", re.search(r"https?://([^/]+)/?", url).group(1))
+    except Exception:
+        return "unknown"
+
+def load_evidence_files(proposal_path: Path):
+    dim_map = defaultdict(list); total_loaded = 0
+    for f in proposal_path.glob("*_combined.json"):
+        dimension = f.stem.replace("_combined","")
+        try:
+            data = json.loads(f.read_text(encoding="utf-8")) or []
+            for item in data:
+                txt = clean_text(item.get("text",""))
+                url = item.get("url",""); conf = float(item.get("confidence",0.5))
+                if len(txt) > 100 and url:
+                    dom = extract_domain(url)
+                    # 兜底黑名单
+                    if any(bad in dom for bad in DOMAIN_BLACKLIST): continue
+                    # 主页剔除（除白名单域/文本极长）
+                    if re.match(r"^https?://[^/]+/?$", url) and (not _is_whitelisted_domain(dom)) and len(txt) < 800:
+                        continue
+                    dim_map[dimension].append({"url": url,"domain": dom,"text": txt,"confidence": conf})
+            print(f"✅ {dimension} 加载 {len(dim_map[dimension])} 条 combined。")
+            total_loaded += len(dim_map[dimension])
+        except Exception as e:
+            print(f"⚠️ 读取 {f.name} 出错: {e}")
+
+    if not dim_map:
+        print("⚠️ 未检测到 combined，尝试 *_cache.json。")
+        for f in proposal_path.glob("*_cache.json"):
+            dimension = f.stem.replace("_cache","")
+            try:
+                cache_data = json.loads(f.read_text(encoding="utf-8"))
+                all_items = []
+                if isinstance(cache_data, dict):
+                    for v in cache_data.values(): all_items.extend(v)
+                else:
+                    all_items = cache_data
+                for item in all_items:
+                    txt = clean_text(item.get("text",""))
+                    url = item.get("url",""); conf = float(item.get("confidence",0.5))
+                    if len(txt) > 100 and url:
+                        dom = extract_domain(url)
+                        if any(bad in dom for bad in DOMAIN_BLACKLIST): continue
+                        if re.match(r"^https?://[^/]+/?$", url) and (not _is_whitelisted_domain(dom)) and len(txt) < 800:
+                            continue
+                        dim_map[dimension].append({"url": url,"domain": dom,"text": txt,"confidence": conf})
+                print(f"🟡 {dimension} 使用 cache 加载 {len(dim_map[dimension])} 条。")
+                total_loaded += len(dim_map[dimension])
+            except Exception as e:
+                print(f"⚠️ 读取 {f.name} 出错: {e}")
+
+    print(f"\n📊 共加载 {len(dim_map)} 个维度，总 evidence：{total_loaded}")
+    return dim_map
+
+def llm_chat(prompt: str, temperature: float = 0.35) -> str:
+    try:
+        resp = llm_client.chat.completions.create(
+            model=llm_model, messages=[{"role":"user","content":prompt}], temperature=temperature
+        )
+        return resp.choices[0].message.content.strip()
+    except Exception as e:
+        print(f"⚠️ LLM 摘要失败: {e}")
+        return ""
+
+def summarize_with_llm(dimension: str, fused_blocks: list) -> str:
+    if not fused_blocks: return "摘要生成失败。"
+    ranked = sorted(fused_blocks, key=lambda b: (b.get("avg_conf",0.0), len(b.get("text",""))), reverse=True)[:6]
+    joined = "\n\n".join([b["text"] for b in ranked])[:9000]
+    # 引用集合（≥70% 学术/监管域）
+    refs = []
+    for i,b in enumerate(ranked,1):
+        for u in b.get("urls",[])[:2]:
+            refs.append((i,u))
+    # 保证学术占比
+    def _is_academic(u: str) -> bool:
+        host = extract_domain(u)
+        return any(host.endswith(d) for d in ACADEMIC_DOMAINS)
+    if refs:
+        ac_ratio = sum(1 for _,u in refs if _is_academic(u)) / len(refs)
+        if ac_ratio < 0.7:
+            # 学术不足：只取学术/监管域引用
+            refs = [(i,u) for i,u in refs if _is_academic(u)]
+    refs_text = "\n".join([f"[{i}] {u}" for i,u in refs[:6]])
+
+    prompt = f"""
+你是通用项目评审专家，请基于以下高置信整合内容为“{dimension}”写客观摘要。
+要求：事实化；引用以 [1][2] 标注；涉及年份、标准、政策或关键事实时必须来自可靠来源；180~250字。
+【内容】{joined}
+【来源】{refs_text}
+Summary Quality: 请在末尾给出 高/中/低。
+"""
+    return llm_chat(prompt) or "摘要生成失败。"
+
+def representative_score(doc_len: int, conf: float, mean_len: float, domain: str = "") -> float:
+    len_norm = min(doc_len / max(mean_len, 1.0), 2.0)
+    bonus = 0.05 if _is_whitelisted_domain(domain) else 0.0
+    return 0.7 * float(conf + bonus) + 0.3 * float(len_norm)
+
+def _domain_penalty(domain: str) -> float:
+    d = (domain or "").lower()
+    if any(x in d for x in ["news","blog","medium.com"]): return 0.05
+    return 0.0
+
+def _is_homepage(url: str) -> bool:
+    return bool(re.match(r"^https?://[^/]+/?$", url or ""))
+
+def greedy_grouping(embs: np.ndarray, texts: list, threshold: float):
+    if len(embs) == 0: return []
+    clusters, centers = [], []
+    for idx, v in enumerate(embs):
+        placed = False
+        for ci, c in enumerate(centers):
+            if float(np.dot(v, c)) >= threshold:
+                clusters[ci].append(idx)
+                new_center = np.mean([embs[i] for i in clusters[ci]], axis=0)
+                new_center = new_center / (np.linalg.norm(new_center) + 1e-12)
+                centers[ci] = new_center; placed = True; break
+        if not placed:
+            clusters.append([idx]); centers.append(v)
+    return clusters
+
+def fuse_dimension(dimension: str, docs: list):
+    if not docs:
+        print(f"⚠️ {dimension} 无 evidence"); return None, None
+
+    print(f"\n🔹 融合维度: {dimension}（{len(docs)} 条）")
+    corpus = [d["text"] for d in docs]
+    urls_all = [d["url"] for d in docs]
+    domains_all = [d["domain"] for d in docs]
+    conf_all = [float(d["confidence"]) for d in docs]
+    lens_all = [len(t) for t in corpus]
+    mean_len = float(np.mean(lens_all)) if lens_all else 400.0
+    doc_n = len(docs)
+
+    if mean_len > 800 and doc_n >= 12: threshold, min_k = 0.72, 3
+    elif mean_len < 300 or doc_n < 6:  threshold, min_k = 0.58, 2
+    else:                               threshold, min_k = 0.65, 3
+
+    embeddings = embedder.encode(corpus, **_EMB_KW)
+    try:
+        clusters = util.community_detection(embeddings, threshold=threshold, min_community_size=min_k)
+    except Exception as e:
+        print(f"⚠️ community_detection 异常，改用贪心聚类：{e}")
+        clusters = [c for c in greedy_grouping(embeddings, corpus, threshold) if len(c) >= min_k]
+
+    print(f"🧩 聚类 {len(clusters)} 个（阈 {threshold}，min_k={min_k}，均长 {int(mean_len)}）")
+
+    fused_blocks, used = [], set()
+    for cluster in clusters:
+        cluster_docs = [docs[i] for i in cluster]
+        filtered = [d for d in cluster_docs if not _is_homepage(d["url"])]
+        ranked = sorted((filtered or cluster_docs),
+                        key=lambda x: representative_score(len(x["text"]), x["confidence"] - _domain_penalty(x["domain"]), mean_len, x["domain"]),
+                        reverse=True)
+        texts = [cd["text"] for cd in ranked]
+        urls  = [cd["url"]  for cd in ranked]
+        confs = np.array([max(float(cd["confidence"]) - _domain_penalty(cd["domain"]), 0.0) for cd in ranked])
+        w = confs / (confs.sum() + 1e-6)
+        avg_conf = float((w * confs).sum())
+        combined = " ".join(sorted(texts, key=len, reverse=True)[:3])[:2000]
+        fused_blocks.append({"text": combined, "urls": urls, "avg_conf": round(avg_conf, 2)})
+        for i in cluster: used.add(i)
+
+    isolated_idx = [i for i in range(len(corpus)) if i not in used]
+    isolated_entries = [{"text": corpus[i], "url": urls_all[i], "confidence": conf_all[i], "domain": domains_all[i]} for i in isolated_idx]
+
+    pre_summary = summarize_with_llm(dimension, fused_blocks)
+    if isolated_entries and pre_summary:
+        embs_iso = embedder.encode([e["text"] for e in isolated_entries], **_EMB_KW)
+        seed = embedder.encode([pre_summary[:1200]], **_EMB_KW)[0]
+        sims = np.dot(embs_iso, seed)
+        order = np.argsort(sims)[::-1][: min(5, len(sims))]
+        for j in order:
+            e = isolated_entries[int(j)]
+            fused_blocks.append({"text": e["text"][:1500], "urls": [e["url"]], "avg_conf": round(float(e.get("confidence",0.6)),2)})
+
+    confs_global = np.array(conf_all, dtype=float)
+    w_global = confs_global / (confs_global.sum() + 1e-6)
+    avg_conf_weighted = float((w_global * confs_global).sum())
+    final_summary = summarize_with_llm(dimension, fused_blocks)
+
+    high_blocks = [b for b in fused_blocks if b.get("avg_conf",0) >= 0.80]
+    mid_blocks  = [b for b in fused_blocks if 0.60 <= b.get("avg_conf",0) < 0.80]
+    low_blocks  = [b for b in fused_blocks if b.get("avg_conf",0) < 0.60]
+
+    out_path = FUSION_DIR / f"{dimension}_fused.json"
+    result = {
+        "dimension": dimension, "fused_texts": fused_blocks, "summary": final_summary,
+        "cluster_count": len(clusters), "doc_count": len(docs), "isolated_count": len(isolated_idx),
+        "avg_confidence_weighted": round(avg_conf_weighted, 2),
+        "confidence_distribution": {"high": len(high_blocks), "mid": len(mid_blocks), "low": len(low_blocks)},
+        "avg_text_len": int(np.mean([len(b['text']) for b in fused_blocks])) if fused_blocks else 0,
+        "threshold": threshold, "min_community_size": min_k,
+        "embedding_model": EMBED_MODEL, "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    }
+    out_path.write_text(json.dumps(result, ensure_ascii=False, indent=2), encoding="utf-8")
+
+    top_domains = Counter(domains_all).most_common(10)
+    print(f"✅ {dimension} 融合完成 → {out_path}")
+    print(f"📊 聚类: {len(clusters)} | 加权均置信: {result['avg_confidence_weighted']} | 分层 H/M/L: {len(high_blocks)}/{len(mid_blocks)}/{len(low_blocks)} | Top域: {top_domains[:3]}")
+    return result, top_domains
+
+if __name__ == "__main__":
+    print("🚀 启动 Fusion Search（Safe） ...")
+    dim_docs = load_evidence_files(proposal_dir)
+    if not dim_docs:
+        print("❌ 无 evidence"); sys.exit(0)
+
+    fusion_index = {}; all_domains_global = Counter()
+    with ThreadPoolExecutor(max_workers=3) as ex:
+        futures = {ex.submit(fuse_dimension, dim, docs): dim for dim, docs in dim_docs.items()}
+        for f in as_completed(futures):
+            dim = futures[f]
+            try:
+                result, top_domains = f.result()
+                if result:
+                    for d, c in (top_domains or []): all_domains_global[d] += c
+                    fusion_index[dim] = {
+                        "fused_file": str((FUSION_DIR / f"{dim}_fused.json").resolve()),
+                        "cluster_count": result["cluster_count"], "isolated_count": result["isolated_count"],
+                        "avg_confidence_weighted": result["avg_confidence_weighted"],
+                        "confidence_distribution": result["confidence_distribution"],
+                        "avg_text_len": result["avg_text_len"], "threshold": result["threshold"],
+                        "min_community_size": result["min_community_size"], "embedding_model": result["embedding_model"],
+                        "evidence_count": result["doc_count"], "top_domains": top_domains,
+                        "summary_preview": (result["summary"] or "")[:150]
+                    }
+            except Exception as e:
+                print(f"❌ {dim} 融合失败: {e}")
+
+    (FUSION_DIR / "fusion_report.json").write_text(json.dumps({
+        "proposal_id": proposal_id, "fusion_time": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        "dimension_stats": fusion_index, "top_domains_global": all_domains_global.most_common(15)
+    }, ensure_ascii=False, indent=2), encoding="utf-8")
+    (FUSION_DIR / "dimension_fusion_index.json").write_text(json.dumps(fusion_index, ensure_ascii=False, indent=2), encoding="utf-8")
+
+    total_dims = len(fusion_index); total_docs = sum(v["evidence_count"] for v in fusion_index.values())
+    print("\n🎯 融合完成（Safe）")
+    print(f"📁 输出：{FUSION_DIR}")
+    print(f"📊 维度：{total_dims} | 融合 evidence：{total_docs}")
+    print(f"🌐 全局 Top 域：{all_domains_global.most_common(10)}")

src/tools/generate_final_report.py

@@ -0,0 +1,397 @@
+# -*- coding: utf-8 -*-
+"""
+阶段 9：Final Report Generator（v3 · 一页摘要 + 专家评审 + 精简问答 · 基于 final_payload）
+
+功能：
+  1) 自动读取：
+       - refined_answers/<pid>/postproc/final_payload.json
+       - expert_reports/<pid>/ai_expert_opinion.json
+       - expert_reports/<pid>/ai_expert_opinion.md
+  2) 生成综合 Markdown 报告：
+       - 顶部：项目综合评审报告（含生成时间与说明）
+       - 0. 一页摘要（Executive Summary）：
+           · verdict + 一句话结论依据
+           · 综合评分、信心度 + 区间解释
+           · Top 3 优势 & Top 3 主要风险
+           · 关键补充材料建议
+       - 1. AI 专家总体评审（来自 ai_expert_opinion.md，自动降一级标题）
+       - 2. 维度问答与打分依据（基于 final_payload）：
+             · 按五个维度展示
+             · 每个维度：综合得分 + 打分依据摘要（rationales）+ 行业通识要点（general_insights）
+             · 每道题：问题、选中回答、来源模型、置信度、对齐度、漂移等元信息
+             · 每个维度仅展示前 MAX_QA_PER_DIM 条高价值问答（按置信度 + 对齐度排序）
+
+用法：
+  cd 到项目根目录（包含 src/）
+  python -m src.tools.generate_final_report
+  python -m src.tools.generate_final_report --pid Ebovir_LNP
+"""
+
+import json
+import argparse
+from pathlib import Path
+from datetime import datetime
+
+# ========= 路径配置 =========
+BASE_DIR = Path(__file__).resolve().parents[2]   # 项目根（包含 src/）
+DATA_DIR = BASE_DIR / "src" / "data"
+REFINED_ROOT = DATA_DIR / "refined_answers"
+EXPERT_ROOT = DATA_DIR / "expert_reports"
+REPORT_ROOT = DATA_DIR / "reports"
+
+DIM_ORDER = ["team", "objectives", "strategy", "innovation", "feasibility"]
+DIM_LABELS_ZH = {
+    "team": "团队与治理",
+    "objectives": "项目目标",
+    "strategy": "实施路径与战略",
+    "innovation": "技术与产品创新",
+    "feasibility": "资源与可行性",
+}
+
+# 每个维度最多展示多少条问答（从高置信度 / 高对齐度往下选）
+MAX_QA_PER_DIM = 6
+
+
+# ========= 工具函数 =========
+def now_str() -> str:
+    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+
+def load_json(path: Path):
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def detect_latest_pid() -> str:
+    """
+    从 refined_answers 下自动选一个“最新且有 postproc/final_payload.json + 对应专家评审”的 pid
+    """
+    if not REFINED_ROOT.exists():
+        return ""
+    cands = []
+    for d in REFINED_ROOT.iterdir():
+        if not d.is_dir():
+            continue
+        postproc_dir = d / "postproc"
+        fp_path = postproc_dir / "final_payload.json"
+        expert_md_path = EXPERT_ROOT / d.name / "ai_expert_opinion.md"
+        if fp_path.exists() and expert_md_path.exists():
+            cands.append((d.name, fp_path.stat().st_mtime))
+    if not cands:
+        return ""
+    cands.sort(key=lambda x: x[1], reverse=True)
+    return cands[0][0]
+
+
+def adjust_expert_markdown(md_text: str) -> str:
+    """
+    将 ai_expert_opinion.md 的标题全部降一级：
+      #  → ##
+      ## → ###
+      ###→ ####
+    避免和顶层报告标题冲突。
+    """
+    lines = md_text.splitlines()
+    adjusted = []
+    for line in lines:
+        if line.startswith("# "):
+            adjusted.append("#" + line)      # '# ' → '## '
+        elif line.startswith("## "):
+            adjusted.append("#" + line)      # '## ' → '### '
+        elif line.startswith("### "):
+            adjusted.append("#" + line)      # '### '→ '#### '
+        else:
+            adjusted.append(line)
+    return "\n".join(adjusted)
+
+
+def _fmt_float(v, ndigits=1, default="0.0"):
+    try:
+        return f"{float(v):.{ndigits}f}"
+    except Exception:
+        return default
+
+
+# ========= 一页摘要生成 =========
+def build_executive_summary(expert_json: dict) -> str:
+    """
+    基于 ai_expert_opinion.json 生成“0. 一页摘要（Executive Summary）”Markdown 文本。
+    如果 expert_json 为空，则返回空字符串，调用方自己判断是否插入。
+    """
+    if not expert_json:
+        return ""
+
+    overall = expert_json.get("overall_opinion", {}) or {}
+    score = overall.get("overall_score_echo", 0.0)       # 0–1 区间
+    conf = overall.get("confidence_echo", 0.0)           # 0–1 区间
+    verdict = (overall.get("verdict") or "").strip()
+    summary = (overall.get("summary") or "").strip()
+    key_strengths = overall.get("key_strengths") or []
+    key_risks = overall.get("key_risks") or []
+    recs = overall.get("recommendations") or []
+    basis = overall.get("basis") or []
+
+    # verdict 补充中文解释
+    verdict_zh = ""
+    if verdict == "GO":
+        verdict_zh = "（建议在可控风险前提下推进）"
+    elif verdict == "HOLD":
+        verdict_zh = "（建议补充材料后再决策）"
+    elif verdict == "NO-GO":
+        verdict_zh = "（当前条件下不建议立项）"
+
+    # 一句话结论依据：优先用 basis[0]，其次用 summary
+    brief_reason = ""
+    if basis:
+        brief_reason = basis[0]
+    elif summary:
+        brief_reason = summary
+
+    lines = []
+    lines.append("## 0. 一页摘要（Executive Summary）")
+    lines.append("")
+    if verdict:
+        lines.append(f"- **总体结论（verdict）**：{verdict} {verdict_zh}".strip())
+    else:
+        lines.append("- **总体结论（verdict）**：暂无明确结论")
+    if brief_reason:
+        lines.append(f"- **结论依据简述**：{brief_reason}")
+    lines.append(f"- **综合评分**：{_fmt_float(score, 3)}（0–1 区间）")
+    lines.append(f"- **信心度**：{_fmt_float(conf, 3)}")
+    lines.append("")
+    lines.append("> **评分区间说明（供非技术评审参考）**：")
+    lines.append("> - ≥ 0.62：整体条件较好，可在控制风险前提下推进；")
+    lines.append("> - 0.45–0.62：信息不充分或优劣并存，建议补充材料后再决策；")
+    lines.append("> - < 0.45：关键维度存在明显短板或高不确定性，一般不建议立项。")
+    lines.append("")
+
+    # Top 优势 / 风险
+    if key_strengths:
+        lines.append("**Top 项目优势（按重要性排序，最多列出 3 条）**")
+        for s in key_strengths[:3]:
+            lines.append(f"- {s}")
+        lines.append("")
+    if key_risks:
+        lines.append("**Top 主要风险 / 不足（最多列出 3 条）**")
+        for r in key_risks[:3]:
+            lines.append(f"- {r}")
+        lines.append("")
+
+    # 关键补充材料 / 建议：直接从 recommendations 抽几条
+    if recs:
+        lines.append("**关键后续建议 / 需补充材料要点（节选 3–5 条）**")
+        for r in recs[:5]:
+            lines.append(f"- {r}")
+        lines.append("")
+
+    return "\n".join(lines)
+
+
+# ========= 维度问答部分 =========
+def build_qa_section_from_final_payload(final_payload: dict) -> str:
+    """
+    输入：postproc/final_payload.json（dict）
+    输出：Markdown 文本（每个维度下：
+          综合得分 + 打分依据摘要 + 行业通识要点 + 精选问题/回答明细）
+    - 每个维度只展示前 MAX_QA_PER_DIM 条问答
+      （按 confidence + alignment 排序，从高到低截断）
+    - 逐题不再重复展示 general_insights（避免和维度级/专家意见重复啰嗦）
+    """
+    dims = final_payload.get("dimensions", {}) or {}
+
+    lines = []
+    lines.append("## 2. 维度问答与打分依据")
+    lines.append("")
+    lines.append("> 本部分基于 post_processing 选中的问答结果生成，用于支撑专家评审结论的溯源。")
+    lines.append("> 如阅读时间有限，可主要关注「0. 一页摘要」与「1. AI 专家总体评审」，本部分主要面向技术评审与审计。")
+    lines.append("")
+
+    for dim in DIM_ORDER:
+        block = dims.get(dim) or {}
+        qas = block.get("qas") or []
+        if not qas:
+            continue
+
+        # 按置信度 + 对齐度排序，截断为前 MAX_QA_PER_DIM 条
+        def _qa_key(qa_item):
+            try:
+                conf = float(qa_item.get("confidence") or 0.0)
+            except Exception:
+                conf = 0.0
+            try:
+                align = float(qa_item.get("alignment") or 0.0)
+            except Exception:
+                align = 0.0
+            return (conf + align)
+
+        qas_sorted = sorted(qas, key=_qa_key, reverse=True)
+        qas_sorted = qas_sorted[:MAX_QA_PER_DIM]
+
+        zh_label = DIM_LABELS_ZH.get(dim, dim)
+        score = block.get("score", 0.0)  # 已是 0–100 之间的小数
+        rationales = block.get("rationales") or []
+        gi_dim = block.get("general_insights") or []
+
+        # 维度标题 + 分数
+        lines.append(f"### 维度：{zh_label}（{dim}） · 综合得分：{_fmt_float(score, 1)} / 100")
+        lines.append("")
+
+        # 打分依据（来源于 post_processing 的 strengths 聚合）
+        if rationales:
+            lines.append("**打分依据（摘要）**")
+            for r in rationales:
+                r = str(r).strip()
+                if r:
+                    lines.append(f"- {r}")
+            lines.append("")
+
+        # 维度级 industry general insights（来自 general_insights 聚合层）
+        if gi_dim:
+            lines.append("**行业通识要点（不代表本项目已达成，仅作参照）**")
+            for g in gi_dim[:8]:
+                g = str(g).strip()
+                if g:
+                    lines.append(f"- {g}")
+            lines.append("")
+
+        # 逐题问答（已按重要性排序 + 截断）
+        for idx, qa in enumerate(qas_sorted, start=1):
+            q_text = (qa.get("q") or "").strip()
+            ans = (qa.get("answer") or "").strip()
+            provider = (qa.get("provider") or "").strip()
+            model = (qa.get("model") or "").strip()
+            conf = qa.get("confidence", 0.0)
+            align = qa.get("alignment", 0.0)
+            drift = qa.get("dimension_drift", 0.0)
+            claims = qa.get("claims") or []
+            evids = qa.get("evidence_hints") or []
+
+            lines.append("")
+            lines.append(f"#### Q{idx}. {q_text}")
+            lines.append("")
+            meta_parts = []
+            if provider:
+                meta_parts.append(f"来源模型：{provider}")
+            if model:
+                meta_parts.append(model)
+            meta_parts.append(f"置信度：{_fmt_float(conf, 2)}")
+            meta_parts.append(f"对齐度：{_fmt_float(align, 2)}")
+            meta_parts.append(f"维度漂移：{_fmt_float(drift, 2)}")
+
+            lines.append("_" + " ｜ ".join(meta_parts) + "_")
+            lines.append("")
+
+            # 核心要点（claims）
+            if claims:
+                lines.append("**核心要点（claims）**")
+                for c in claims:
+                    c = str(c).strip()
+                    if c:
+                        lines.append(f"- {c}")
+                lines.append("")
+
+            # 选中回答
+            lines.append("**选中回答**")
+            lines.append("")
+            if ans:
+                lines.append(ans)
+            else:
+                lines.append("_（无有效回答）_")
+            lines.append("")
+
+            # 证据线索（evidence_hints）
+            if evids:
+                lines.append("**证据线索（evidence_hints）**")
+                for e in evids:
+                    e = str(e).strip()
+                    if e:
+                        lines.append(f"- {e}")
+                lines.append("")
+
+            # ⚠️ 不再展示逐题 general_insights，避免与维度级 / 专家意见重复啰嗦
+            # gi_q = qa.get("general_insights") or []
+            # if gi_q:
+            #     lines.append("**行业通识经验（general_insights）**")
+            #     for g in gi_q[:6]:
+            #         g = str(g).strip()
+            #         if g:
+            #             lines.append(f"- {g}")
+            #     lines.append("")
+
+    return "\n".join(lines)
+
+
+# ========= 主流程 =========
+def main():
+    ap = argparse.ArgumentParser(description="Generate final integrated markdown report (executive summary + expert opinion + Q&A, v3).")
+    ap.add_argument("--pid", type=str, default="", help="提案 ID；若缺省则自动检测最新的一个。")
+    args = ap.parse_args()
+
+    pid = args.pid.strip() or detect_latest_pid()
+    if not pid:
+        raise RuntimeError(
+            "未检测到可用项目：需要至少存在 "
+            "`refined_answers/<pid>/postproc/final_payload.json` 与 "
+            "`expert_reports/<pid>/ai_expert_opinion.md`。"
+        )
+
+    # ---------- 路径 ----------
+    refined_dir = REFINED_ROOT / pid
+    postproc_dir = refined_dir / "postproc"
+    fp_path = postproc_dir / "final_payload.json"
+
+    expert_dir = EXPERT_ROOT / pid
+    expert_md_path = expert_dir / "ai_expert_opinion.md"
+    expert_json_path = expert_dir / "ai_expert_opinion.json"
+
+    if not fp_path.exists():
+        raise FileNotFoundError(f"未找到 final_payload.json：{fp_path}")
+    if not expert_md_path.exists():
+        raise FileNotFoundError(f"未找到专家评审 Markdown：{expert_md_path}")
+    # ai_expert_opinion.json 缺失时不会报错，只是无法生成一页摘要
+    expert_json = {}
+    if expert_json_path.exists():
+        expert_json = load_json(expert_json_path)
+
+    REPORT_ROOT.mkdir(parents=True, exist_ok=True)
+    out_path = REPORT_ROOT / f"{pid}_final_report.md"
+
+    # ---------- 读取数据 ----------
+    final_payload = load_json(fp_path)
+    expert_md_raw = expert_md_path.read_text(encoding="utf-8")
+
+    # ---------- 组装报告 ----------
+    report_lines = []
+
+    # 顶层标题
+    report_lines.append(f"# 项目综合评审报告 · {pid}")
+    report_lines.append("")
+    report_lines.append(f"_生成时间：{now_str()}_")
+    report_lines.append("")
+    report_lines.append("_本报告由 AI 辅助评审系统自动生成，供内部专家和决策委员会参考使用。_")
+    report_lines.append("")
+
+    # 0. 一页摘要（如果有 ai_expert_opinion.json）
+    exec_summary_md = build_executive_summary(expert_json)
+    if exec_summary_md:
+        report_lines.append(exec_summary_md)
+        report_lines.append("")
+
+    # 1. AI 专家总体评审（来自 ai_expert_opinion.md）
+    report_lines.append("## 1. AI 专家总体评审（详细版）")
+    report_lines.append("")
+    report_lines.append(adjust_expert_markdown(expert_md_raw))
+    report_lines.append("")
+
+    # 2. 维度问答与打分依据（来自 final_payload.json 的问题 + 选中的一个回答）
+    qa_section = build_qa_section_from_final_payload(final_payload)
+    report_lines.append(qa_section)
+    report_lines.append("")
+
+    final_md = "\n".join(report_lines)
+    out_path.write_text(final_md, encoding="utf-8")
+
+    print(f"✅ Final report generated -> {out_path}")
+
+
+if __name__ == "__main__":
+    main()

src/tools/generate_questions.py

@@ -0,0 +1,173 @@
+# -*- coding: utf-8 -*-
+"""
+Stage 3 · Domain-adaptive question generation
+
+Design goals:
+- no domain-specific prompt text inside this stage
+- deterministic question generation from:
+    universal template + domain_profile.json + fixed task registry
+- keep downstream compatibility with llm_answering.py
+"""
+
+import json
+import argparse
+from pathlib import Path
+from datetime import datetime
+from typing import Dict, Any, List
+
+from src.prompting.domain_adaptive import (
+    REVIEW_TASKS,
+    QUESTION_SEARCH_HINTS,
+    build_specialized_question,
+    load_domain_profile,
+)
+
+BASE_DIR = Path(__file__).resolve().parents[2]
+DATA_DIR = BASE_DIR / "src" / "data"
+EXTRACTED_DIR = DATA_DIR / "extracted"
+QUESTIONS_DIR = DATA_DIR / "questions"
+CONFIG_QS_DIR = DATA_DIR / "config" / "question_sets"
+
+DIMENSION_NAMES = ["team", "objectives", "strategy", "innovation", "feasibility"]
+QUESTIONS_DIR.mkdir(parents=True, exist_ok=True)
+CONFIG_QS_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def now_str() -> str:
+    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+
+def find_latest_extracted_proposal_id() -> str:
+    cands = [d for d in EXTRACTED_DIR.iterdir() if d.is_dir()] if EXTRACTED_DIR.exists() else []
+    if not cands:
+        raise FileNotFoundError("No proposal found under src/data/extracted")
+    cands.sort(key=lambda p: p.stat().st_mtime, reverse=True)
+    pid = cands[0].name
+    print(f"[INFO] [auto] selected latest proposal_id: {pid}")
+    return pid
+
+
+def load_dimensions(proposal_id: str) -> Dict[str, Any]:
+    path = EXTRACTED_DIR / proposal_id / "dimensions_v2.json"
+    if not path.exists():
+        raise FileNotFoundError(f"dimensions_v2.json not found: {path}")
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def _dimension_summary(dimensions: Dict[str, Any], dim_name: str) -> Dict[str, Any]:
+    block = dimensions.get(dim_name, {}) if isinstance(dimensions, dict) else {}
+    if not isinstance(block, dict):
+        block = {}
+    return {
+        "summary": block.get("summary", ""),
+        "key_points": block.get("key_points", []) or [],
+        "risks": block.get("risks", []) or [],
+        "mitigations": block.get("mitigations", []) or [],
+        "meta": block.get("meta", {}) or {},
+    }
+
+
+def _write_json(path: Path, payload: Dict[str, Any]) -> None:
+    path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
+
+
+def _write_json_with_log(path: Path, payload: Dict[str, Any], label: str) -> None:
+    _write_json(path, payload)
+    print(f"✅ {label} -> {path}")
+
+
+def build_question_record(task, profile: Dict[str, Any], dim_summary: Dict[str, Any], local_index: int) -> Dict[str, Any]:
+    question_zh = build_specialized_question(task, profile)
+    question_en = str(question_zh)
+
+    links_to = {
+        "key_points": list(range(min(3, len(dim_summary.get("key_points", []))))),
+        "risks": list(range(min(2, len(dim_summary.get("risks", []))))),
+        "mitigations": list(range(min(2, len(dim_summary.get("mitigations", []))))),
+    }
+
+    rating_tasks = {"team", "feasibility", "innovation", "outcomes", "objectives"}
+    analysis_tasks = {"methods", "risks", "evidence", "problem"}
+    answer_type = "rating" if task.task_id in rating_tasks else "analysis"
+
+    return {
+        "qid": f"{task.dimension}_Q{local_index}",
+        "task_id": task.task_id,
+        "template_id": task.template_id,
+        "dimension": task.dimension,
+        "aspect": task.task_id,
+        "title": task.title,
+        "question_zh": question_zh,
+        "question_en": question_en,
+        "answer_type": answer_type,
+        "priority": 1,
+        "links_to": links_to,
+    }
+
+
+def run_generate_questions(proposal_id: str):
+    dimensions = load_dimensions(proposal_id)
+    profile = load_domain_profile(EXTRACTED_DIR / proposal_id / "domain_profile.json")
+
+    per_dim_counter = {dim: 0 for dim in DIMENSION_NAMES}
+
+    all_dim_questions: Dict[str, Any] = {
+        dim: {
+            "dimension": dim,
+            "questions": [],
+            "search_hints": QUESTION_SEARCH_HINTS.get(dim, []),
+            "source_proposal_id": proposal_id,
+            "domain_profile": profile,
+            "dimension_summary": _dimension_summary(dimensions, dim),
+        }
+        for dim in DIMENSION_NAMES
+    }
+
+    for task in REVIEW_TASKS:
+        per_dim_counter[task.dimension] += 1
+        dim_summary = _dimension_summary(dimensions, task.dimension)
+        q = build_question_record(task, profile, dim_summary, per_dim_counter[task.dimension])
+        all_dim_questions[task.dimension]["questions"].append(q)
+
+    detail_out = {
+        "proposal_id": proposal_id,
+        "generated_at": now_str(),
+        "mode": "domain_adaptive_deterministic",
+        "template_version": "universal_v1",
+        "profile_version": "domain_profile_v1",
+        "dimensions": all_dim_questions,
+    }
+
+    out_dir = QUESTIONS_DIR / proposal_id
+    out_dir.mkdir(parents=True, exist_ok=True)
+    detail_out_path = out_dir / "generated_questions.json"
+    _write_json_with_log(detail_out_path, detail_out, "detailed questions")
+
+    config_out: Dict[str, Any] = {
+        "proposal_id": proposal_id,
+        "generated_at": now_str(),
+        "mode": "domain_adaptive_deterministic",
+        "template_version": "universal_v1",
+        "profile_version": "domain_profile_v1",
+        "domain_profile": profile,
+    }
+    for dim in DIMENSION_NAMES:
+        q_objs = all_dim_questions[dim]["questions"]
+        config_out[dim] = {
+            "dimension": dim,
+            "questions": [q["question_zh"] for q in q_objs],
+            "question_objects": q_objs,
+            "search_hints": QUESTION_SEARCH_HINTS.get(dim, []),
+            "source_proposal_id": proposal_id,
+        }
+
+    config_out_path = CONFIG_QS_DIR / "generated_questions.json"
+    _write_json_with_log(config_out_path, config_out, "runtime question set")
+
+
+if __name__ == "__main__":
+    ap = argparse.ArgumentParser(description="Generate domain-adaptive questions from universal templates")
+    ap.add_argument("--proposal_id", type=str, default="", help="proposal id under src/data/extracted/<proposal_id>")
+    args = ap.parse_args()
+    pid = args.proposal_id.strip() or find_latest_extracted_proposal_id()
+    run_generate_questions(pid)

src/tools/layout_reconstruction.py

@@ -0,0 +1,668 @@
+# -*- coding: utf-8 -*-
+"""
+Stage 0 升级模块：layout_reconstruction.py
+
+目标：
+- 将 PDF 逐页渲染成图片，保留页面视觉结构
+- 使用 OCR / layout / table / vision-LLM 组合构建 page_semantics.json
+- 生成更适合 Stage 1 的重建文本（reconstructed_text）
+
+设计原则：
+1) 默认轻量可运行：即使没有 LayoutLM / Table Transformer 依赖，也能使用 OCR + 几何规则回退
+2) 可渐进增强：如果安装了 paddleocr / transformers / torch，则自动启用更强能力
+3) 输出可验证：每个页面都保留 blocks/tables/reading_order/source，便于追溯
+"""
+from __future__ import annotations
+
+import base64
+import io
+import json
+import logging
+import os
+import re
+from collections import defaultdict
+from dataclasses import dataclass, asdict
+from pathlib import Path
+from typing import Any, Dict, Iterable, List, Optional, Sequence, Tuple
+
+from pdf2image import convert_from_path
+from PIL import Image
+import pdfplumber
+import pytesseract
+from pytesseract import Output
+
+try:
+    from openai import OpenAI  # type: ignore
+except Exception:  # pragma: no cover
+    OpenAI = None
+
+logger = logging.getLogger(__name__)
+
+VISION_MODEL = os.getenv("OPENAI_VISION_MODEL", os.getenv("OPENAI_MODEL", "gpt-4o-mini"))
+TESSERACT_LANG = os.getenv("TESS_LANG", "chi_sim+eng")
+ENABLE_VISION_LLM = os.getenv("ENABLE_VISION_LLM", "1").strip().lower() not in {"0", "false", "no"}
+ENABLE_TABLE_MODEL = os.getenv("ENABLE_TABLE_MODEL", "1").strip().lower() not in {"0", "false", "no"}
+ENABLE_LAYOUT_MODEL = os.getenv("ENABLE_LAYOUT_MODEL", "1").strip().lower() not in {"0", "false", "no"}
+OCR_MIN_CONF = int(os.getenv("OCR_MIN_CONF", "35"))
+
+
+@dataclass
+class OCRWord:
+    text: str
+    x0: int
+    y0: int
+    x1: int
+    y1: int
+    conf: float
+
+    @property
+    def cx(self) -> float:
+        return (self.x0 + self.x1) / 2
+
+    @property
+    def cy(self) -> float:
+        return (self.y0 + self.y1) / 2
+
+    @property
+    def height(self) -> float:
+        return max(1, self.y1 - self.y0)
+
+
+@dataclass
+class Block:
+    block_id: str
+    block_type: str
+    text: str
+    bbox: List[int]
+    source: str
+    reading_order: int = -1
+    confidence: Optional[float] = None
+    meta: Optional[Dict[str, Any]] = None
+
+
+@dataclass
+class TableCell:
+    row: int
+    col: int
+    text: str
+    bbox: List[int]
+
+
+@dataclass
+class PageSemantic:
+    page_index: int
+    image_path: str
+    width: int
+    height: int
+    pdf_text: str
+    ocr_text: str
+    page_type: str
+    title: str
+    blocks: List[Dict[str, Any]]
+    tables: List[Dict[str, Any]]
+    reconstructed_text: str
+    vision_summary: Optional[Dict[str, Any]] = None
+    source_notes: Optional[List[str]] = None
+
+
+def render_pdf_pages(pdf_path: Path, image_dir: Path, dpi: int = 220) -> List[Path]:
+    image_dir.mkdir(parents=True, exist_ok=True)
+    pages = convert_from_path(str(pdf_path), dpi=dpi)
+    paths: List[Path] = []
+    for idx, page in enumerate(pages, start=1):
+        out = image_dir / f"page_{idx:03d}.png"
+        page.save(out, "PNG")
+        paths.append(out)
+    return paths
+
+
+def _load_image_size(path: Path) -> Tuple[int, int]:
+    with Image.open(path) as img:
+        return img.size
+
+
+
+
+def normalize_ocr_text(text: str) -> str:
+    text = text or ""
+
+    # 统一换行和空白
+    text = text.replace("\r\n", "\n").replace("\r", "\n")
+    text = re.sub(r"[ \t]+", " ", text)
+
+    # 合并“逐字拆开”的中文，例如：
+    # 自 场 性 主 景 技 术  -> 自场性主景技术（后续再靠块合并减少这类情况）
+    text = re.sub(r"(?<=[\u4e00-\u9fff])\s+(?=[\u4e00-\u9fff])", "", text)
+
+    # 去掉中文与常见中文标点之间多余空格
+    text = re.sub(r"(?<=[\u4e00-\u9fff])\s+(?=[，。；：！？、“”‘’（）《》])", "", text)
+    text = re.sub(r"(?<=[，。；：！？、“”‘’（）《》])\s+(?=[\u4e00-\u9fff])", "", text)
+
+    # 修复中文与项目符号之间的空格
+    text = re.sub(r"(?<=[\u4e00-\u9fff])\s+(?=[•▪◦·])", "", text)
+    text = re.sub(r"(?<=[•▪◦·])\s+(?=[\u4e00-\u9fff])", "", text)
+
+    # 只保留英文/数字之间单空格
+    text = re.sub(r"(?<=[A-Za-z0-9]) {2,}(?=[A-Za-z0-9])", " ", text)
+    # 清理多余空行
+    text = re.sub(r"\n{3,}", "\n\n", text)
+
+    return text.strip()
+
+def _ocr_words(image_path: Path) -> List[OCRWord]:
+    data = pytesseract.image_to_data(Image.open(image_path), lang=TESSERACT_LANG, output_type=Output.DICT)
+    words: List[OCRWord] = []
+    n = len(data.get("text", []))
+    for i in range(n):
+        text = (data["text"][i] or "").strip()
+        if not text:
+            continue
+        try:
+            conf = float(data["conf"][i])
+        except Exception:
+            conf = -1.0
+        if conf < OCR_MIN_CONF:
+            continue
+        x0 = int(data["left"][i])
+        y0 = int(data["top"][i])
+        x1 = x0 + int(data["width"][i])
+        y1 = y0 + int(data["height"][i])
+        words.append(OCRWord(text=text, x0=x0, y0=y0, x1=x1, y1=y1, conf=conf))
+    return words
+
+
+def _group_words_into_lines(words: Sequence[OCRWord]) -> List[List[OCRWord]]:
+    if not words:
+        return []
+    sorted_words = sorted(words, key=lambda w: (w.cy, w.x0))
+    lines: List[List[OCRWord]] = []
+    for word in sorted_words:
+        placed = False
+        for line in lines:
+            ref = line[0]
+            tol = max(ref.height * 0.65, 12)
+            if abs(word.cy - ref.cy) <= tol:
+                line.append(word)
+                placed = True
+                break
+        if not placed:
+            lines.append([word])
+    for line in lines:
+        line.sort(key=lambda w: w.x0)
+    lines.sort(key=lambda l: min(w.y0 for w in l))
+    return lines
+
+
+def _merge_lines_to_blocks(lines: Sequence[Sequence[OCRWord]], page_w: int, page_h: int) -> List[Block]:
+    blocks: List[Block] = []
+    if not lines:
+        return blocks
+
+    current: List[Sequence[OCRWord]] = []
+    block_counter = 0
+
+    def _line_text(line: Sequence[OCRWord]) -> str:
+        return "".join(w.text for w in line).strip()
+
+    def _is_vertical_fragment(line: Sequence[OCRWord]) -> bool:
+        text = _line_text(line)
+        if not text:
+            return False
+        compact = re.sub(r"\s+", "", text)
+        return len(compact) <= 2 and all(("\u4e00" <= ch <= "\u9fff") or ch in "、，。；：！？,.·•" for ch in compact)
+
+    def flush() -> None:
+        nonlocal current, block_counter
+        if not current:
+            return
+
+        flat = [w for line in current for w in line]
+        raw_lines = []
+        for line in current:
+            raw = "".join(w.text for w in line).strip()
+            raw_lines.append(raw)
+
+        # 关键：如果是一串“逐字拆行”的中文，直接拼成一行
+        if raw_lines and sum(1 for x in raw_lines if len(re.sub(r"\s+", "", x)) <= 2) >= max(3, len(raw_lines) // 2):
+            text = "".join(raw_lines).strip()
+        else:
+            text = "\n".join(raw_lines).strip()
+
+        text = normalize_ocr_text(text)
+
+        x0 = min(w.x0 for w in flat)
+        y0 = min(w.y0 for w in flat)
+        x1 = max(w.x1 for w in flat)
+        y1 = max(w.y1 for w in flat)
+        avg_conf = sum(w.conf for w in flat) / max(1, len(flat))
+
+        block_type = classify_block(text, [x0, y0, x1, y1], page_w, page_h)
+        blocks.append(Block(
+            block_id=f"b{block_counter:03d}",
+            block_type=block_type,
+            text=text,
+            bbox=[x0, y0, x1, y1],
+            source="ocr_layout",
+            confidence=round(avg_conf, 2),
+            meta={"line_count": len(current)}
+        ))
+        block_counter += 1
+        current = []
+
+    prev_bottom = None
+    prev_x0 = None
+    prev_is_vertical = False
+
+    for line in lines:
+        flat = list(line)
+        y0 = min(w.y0 for w in flat)
+        x0 = min(w.x0 for w in flat)
+        this_is_vertical = _is_vertical_fragment(line)
+
+        if not current:
+            current = [line]
+            prev_bottom = max(w.y1 for w in flat)
+            prev_x0 = x0
+            prev_is_vertical = this_is_vertical
+            continue
+
+        gap = y0 - (prev_bottom or y0)
+
+        # 普通段落合并
+        same_paragraph = gap <= 18 and prev_x0 is not None and abs(x0 - prev_x0) <= 60
+
+        # 关键：纵向碎字列，允许更强合并
+        same_vertical_stream = (
+            prev_x0 is not None
+            and this_is_vertical
+            and prev_is_vertical
+            and abs(x0 - prev_x0) <= 40
+            and gap <= 35
+        )
+
+        if same_paragraph or same_vertical_stream:
+            current.append(line)
+            prev_bottom = max(w.y1 for w in flat)
+            prev_x0 = (prev_x0 + x0) / 2 if prev_x0 is not None else x0
+            prev_is_vertical = this_is_vertical
+        else:
+            flush()
+            current = [line]
+            prev_bottom = max(w.y1 for w in flat)
+            prev_x0 = x0
+            prev_is_vertical = this_is_vertical
+
+    flush()
+    return blocks
+
+
+def classify_block(text: str, bbox: List[int], page_w: int, page_h: int) -> str:
+    stripped = re.sub(r"\s+", " ", text).strip()
+    x0, y0, x1, y1 = bbox
+    width = x1 - x0
+    height = y1 - y0
+    line_count = stripped.count("\n") + 1
+    compact = stripped.replace(" ", "")
+    if len(compact) <= 2 and not re.search(r"[\u4e00-\u9fffA-Za-z0-9]", compact):
+        return "noise"
+    if y0 > page_h * 0.92:
+        return "footer"
+    if y0 < page_h * 0.18 and len(compact) <= 40:
+        return "title"
+    if re.fullmatch(r"[0-9]+([.,][0-9]+)?[A-Za-z%°·sN\.]*", compact):
+        return "numeric_label"
+    if line_count >= 2 and re.search(r"[|｜]", stripped):
+        return "table_like"
+    if width > page_w * 0.6 and line_count >= 2:
+        return "paragraph"
+    if height < 24 and len(compact) <= 3:
+        return "noise"
+    if len(stripped) <= 30:
+        return "label"
+    return "text"
+
+
+def recover_reading_order(blocks: Sequence[Block]) -> List[Block]:
+    if not blocks:
+        return []
+    sorted_blocks = sorted(blocks, key=lambda b: (b.bbox[1], b.bbox[0]))
+    rows: List[List[Block]] = []
+    for block in sorted_blocks:
+        placed = False
+        cy = (block.bbox[1] + block.bbox[3]) / 2
+        for row in rows:
+            ref = row[0]
+            ref_cy = (ref.bbox[1] + ref.bbox[3]) / 2
+            tol = max((ref.bbox[3] - ref.bbox[1]) * 0.7, 18)
+            if abs(cy - ref_cy) <= tol:
+                row.append(block)
+                placed = True
+                break
+        if not placed:
+            rows.append([block])
+    rows.sort(key=lambda r: min(b.bbox[1] for b in r))
+    ordered: List[Block] = []
+    idx = 0
+    for row in rows:
+        row.sort(key=lambda b: b.bbox[0])
+        for block in row:
+            block.reading_order = idx
+            ordered.append(block)
+            idx += 1
+    return ordered
+
+
+def _extract_pdf_text_page(pdf_path: Path, page_index: int) -> str:
+    try:
+        with pdfplumber.open(pdf_path) as pdf:
+            if page_index < len(pdf.pages):
+                return (pdf.pages[page_index].extract_text() or "").strip()
+    except Exception as exc:
+        logger.warning("pdfplumber page text failed: %s", exc)
+    return ""
+
+
+def detect_tables_with_pdfplumber(pdf_path: Path, page_index: int) -> List[Dict[str, Any]]:
+    tables: List[Dict[str, Any]] = []
+    try:
+        with pdfplumber.open(pdf_path) as pdf:
+            if page_index >= len(pdf.pages):
+                return tables
+            page = pdf.pages[page_index]
+            for t_idx, table in enumerate(page.extract_tables() or []):
+                if not table:
+                    continue
+                rows = []
+                for r_idx, row in enumerate(table):
+                    if row is None:
+                        continue
+                    cells = []
+                    for c_idx, cell in enumerate(row):
+                        txt = (cell or "").strip()
+                        cells.append({"row": r_idx, "col": c_idx, "text": txt})
+                    rows.append(cells)
+                tables.append({
+                    "table_id": f"pdf_table_{page_index+1}_{t_idx+1}",
+                    "source": "pdfplumber",
+                    "cells": rows,
+                    "table_text": "\n".join(" | ".join(c["text"] for c in row) for row in rows if row),
+                })
+    except Exception as exc:
+        logger.warning("pdfplumber table extraction failed: %s", exc)
+    return tables
+
+
+def detect_tables_with_transformer(image_path: Path) -> List[Dict[str, Any]]:
+    if not ENABLE_TABLE_MODEL:
+        return []
+    try:
+        import torch  # type: ignore
+        from transformers import AutoImageProcessor, TableTransformerForObjectDetection  # type: ignore
+    except Exception:
+        return []
+
+    model_name = os.getenv("TABLE_TRANSFORMER_MODEL", "microsoft/table-transformer-detection")
+    try:
+        processor = AutoImageProcessor.from_pretrained(model_name)
+        model = TableTransformerForObjectDetection.from_pretrained(model_name)
+        image = Image.open(image_path).convert("RGB")
+        inputs = processor(images=image, return_tensors="pt")
+        outputs = model(**inputs)
+        target_sizes = torch.tensor([image.size[::-1]])
+        results = processor.post_process_object_detection(outputs, threshold=0.85, target_sizes=target_sizes)[0]
+        tables = []
+        for idx, (score, label, box) in enumerate(zip(results["scores"], results["labels"], results["boxes"])):
+            x0, y0, x1, y1 = [int(v) for v in box.tolist()]
+            label_name = model.config.id2label.get(int(label), str(label))
+            tables.append({
+                "table_id": f"tt_{idx+1}",
+                "source": model_name,
+                "label": label_name,
+                "score": float(score),
+                "bbox": [x0, y0, x1, y1],
+            })
+        return tables
+    except Exception as exc:
+        logger.warning("Table Transformer failed: %s", exc)
+        return []
+
+
+def _guess_page_type(blocks: Sequence[Block], tables: Sequence[Dict[str, Any]]) -> str:
+    texts = " ".join(b.text for b in blocks)
+    if tables:
+        return "table_page"
+    if any("目录" in b.text or "CONTENTS" in b.text.upper() for b in blocks):
+        return "toc_slide"
+    if re.search(r"20\d{2}年", texts) and len(re.findall(r"20\d{2}年", texts)) >= 3:
+        return "timeline_slide"
+    if len([b for b in blocks if b.block_type == "numeric_label"]) >= 3:
+        return "data_visual_slide"
+    if len(blocks) <= 4:
+        return "cover_or_simple_slide"
+    return "content_slide"
+
+
+def _title_from_blocks(blocks: Sequence[Block]) -> str:
+    titles = [b for b in blocks if b.block_type == "title"]
+    if titles:
+        return normalize_ocr_text(re.sub(r"\s+", " ", titles[0].text).strip())
+    if blocks:
+        return re.sub(r"\s+", " ", blocks[0].text.split("\n", 1)[0]).strip()
+    return ""
+
+
+def _reconstruct_table_text(table: Dict[str, Any]) -> str:
+    cells = table.get("cells") or []
+    lines = []
+    for row in cells:
+        if isinstance(row, list):
+            line = " | ".join((c.get("text") or "").strip() for c in row)
+            if line.strip(" |"):
+                lines.append(line)
+    return "\n".join(lines)
+
+
+def _fallback_reconstructed_text(blocks: Sequence[Block], tables: Sequence[Dict[str, Any]]) -> str:
+    parts: List[str] = []
+
+    for block in blocks:
+        if block.block_type in {"footer", "noise"}:
+            continue
+
+        text = normalize_ocr_text(block.text.strip())
+        if not text:
+            continue
+
+        parts.append(text)
+
+    for table in tables:
+        text = table.get("table_text") or _reconstruct_table_text(table)
+        text = normalize_ocr_text(text)
+        if text:
+            parts.append(text)
+
+    merged = "\n\n".join(p for p in parts if p).strip()
+    return normalize_ocr_text(merged)
+
+
+def _image_to_data_url(image_path: Path) -> str:
+    raw = image_path.read_bytes()
+    return "data:image/png;base64," + base64.b64encode(raw).decode("ascii")
+
+
+def vision_llm_enrich_page(image_path: Path, page_payload: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    if not ENABLE_VISION_LLM:
+        return None
+    api_key = os.getenv("OPENAI_API_KEY", "").strip()
+    if not api_key or OpenAI is None:
+        return None
+    client = OpenAI(api_key=api_key)
+    prompt = (
+        "你是一个严格的多模态文档页面解析器。"
+        "请基于页面图像本身作为第一依据，OCR/布局候选只作为辅助参考。"
+        "目标：输出适合后续评审系统使用的高质量结构化 JSON。"
+
+        "\n\n要求："
+        "\n1. 优先恢复页面的自然阅读顺序。"
+        "\n2. 不要保留明显错误的 OCR 垃圾文本。"
+        "\n3. 如果页面中存在竖排字、装饰文字、旋转文本、图形中的碎字、难以连成自然句子的散字，请忽略它们。"
+        "\n4. reconstructed_text 只保留对页面语义真正有贡献的内容。"
+        "\n5. 对标题、正文、表格、关键标签分别理解，但不要编造。"
+        "\n6. 如果 OCR 候选与图像冲突，以图像理解为准。"
+        "\n7. 不要把单字散列、坐标噪声、页码、无意义重复片段写进 reconstructed_text。"
+
+        "\n\n输出 JSON 格式："
+        '{"page_type":"...",'
+        '"title":"...",'
+        '"reading_order_notes":["..."],'
+        '"regions":[{"role":"title/text/table/chart/label","text":"..."}],'
+        '"reconstructed_text":"..."}'
+    )
+    try:
+        response = client.chat.completions.create(
+            model=VISION_MODEL,
+            temperature=0.0,
+            response_format={"type": "json_object"},
+            messages=[
+                {"role": "system", "content": "你是严谨的页面结构解析器，只能依据可见内容回答。"},
+                {
+                    "role": "user",
+                    "content": [
+                        {"type": "text", "text": prompt + "\n\nOCR/布局候选：\n" + json.dumps(page_payload, ensure_ascii=False)[:12000]},
+                        {"type": "image_url", "image_url": {"url": _image_to_data_url(image_path)}},
+                    ],
+                },
+            ],
+            max_tokens=1800,
+        )
+        raw = response.choices[0].message.content or "{}"
+        return json.loads(raw)
+    except Exception as exc:
+        logger.warning("vision LLM enrichment failed on %s: %s", image_path, exc)
+        return None
+
+
+def build_page_semantic(pdf_path: Path, image_path: Path, page_index: int) -> PageSemantic:
+    width, height = _load_image_size(image_path)
+    ocr_words = _ocr_words(image_path)
+    lines = _group_words_into_lines(ocr_words)
+    blocks = _merge_lines_to_blocks(lines, page_w=width, page_h=height)
+    ordered_blocks = [b for b in recover_reading_order(blocks) if b.block_type != "noise"]
+    pdf_text = _extract_pdf_text_page(pdf_path, page_index)
+    ocr_text = normalize_ocr_text("\n".join(" ".join(w.text for w in line) for line in lines).strip())
+
+    tables = detect_tables_with_pdfplumber(pdf_path, page_index)
+    transformer_tables = detect_tables_with_transformer(image_path)
+    if transformer_tables:
+        tables.extend(transformer_tables)
+
+    page_type = _guess_page_type(ordered_blocks, tables)
+    title = _title_from_blocks(ordered_blocks)
+
+    base_payload = {
+        "page_index": page_index + 1,
+        "page_type": page_type,
+        "title": title,
+        "blocks": [asdict(b) for b in ordered_blocks],
+        "tables": tables,
+        "pdf_text": pdf_text,
+        "ocr_text": ocr_text,
+    }
+    vision_summary = vision_llm_enrich_page(image_path, base_payload)
+
+    # Vision-LLM 优先：把 page_type / title / reconstructed_text / regions 作为主结果
+    if vision_summary and isinstance(vision_summary, dict):
+        reconstructed_text = normalize_ocr_text(
+            vision_summary.get("reconstructed_text", "")
+        )
+    else:
+        reconstructed_text = _fallback_reconstructed_text(ordered_blocks, tables)
+
+    reconstructed_text = normalize_ocr_text(reconstructed_text)
+
+    source_notes = []
+    if pdf_text:
+        source_notes.append("pdf_text_available")
+    if ocr_text:
+        source_notes.append("ocr_layout_available")
+    if vision_summary:
+        source_notes.append("vision_llm_enriched")
+    if transformer_tables:
+        source_notes.append("table_transformer_detected")
+    elif tables:
+        source_notes.append("pdfplumber_tables_detected")
+
+    return PageSemantic(
+        page_index=page_index + 1,
+        image_path=str(image_path),
+        width=width,
+        height=height,
+        pdf_text=pdf_text,
+        ocr_text=ocr_text,
+        page_type=(vision_summary or {}).get("page_type", page_type),
+        title=(vision_summary or {}).get("title", title),
+        blocks=[asdict(b) for b in ordered_blocks],
+        tables=tables,
+        reconstructed_text=reconstructed_text,
+        vision_summary=vision_summary,
+        source_notes=source_notes,
+    )
+
+
+def build_document_semantics(pdf_path: Path, out_dir: Path, dpi: int = 220) -> Dict[str, Any]:
+    image_dir = out_dir / "page_images"
+    image_paths = render_pdf_pages(pdf_path, image_dir=image_dir, dpi=dpi)
+    pages: List[Dict[str, Any]] = []
+    for idx, image_path in enumerate(image_paths):
+        page_sem = build_page_semantic(pdf_path=pdf_path, image_path=image_path, page_index=idx)
+        pages.append(asdict(page_sem))
+    reconstructed_pages = [p.get("reconstructed_text", "").strip() for p in pages]
+    reconstructed_full_text = "\n\n".join([p for p in reconstructed_pages if p])
+    return {
+        "proposal_file": str(pdf_path),
+        "num_pages": len(pages),
+        "pages": pages,
+        "reconstructed_full_text": reconstructed_full_text,
+    }
+
+
+def save_document_semantics(doc_semantics: Dict[str, Any], out_dir: Path) -> Dict[str, str]:
+    out_dir.mkdir(parents=True, exist_ok=True)
+    page_sem_path = out_dir / "page_semantics.json"
+    page_sem_path.write_text(json.dumps(doc_semantics, ensure_ascii=False, indent=2), encoding="utf-8")
+    reconstructed_text_path = out_dir / "reconstructed_full_text.txt"
+    reconstructed_text_path.write_text(doc_semantics.get("reconstructed_full_text", ""), encoding="utf-8")
+    return {
+        "page_semantics_path": str(page_sem_path),
+        "reconstructed_full_text_path": str(reconstructed_text_path),
+        "page_images_dir": str(out_dir / "page_images"),
+    }
+
+
+def semantic_pages_for_stage1(page_semantics: Dict[str, Any]) -> List[Dict[str, Any]]:
+    pages = page_semantics.get("pages") or []
+    semantic_units: List[Dict[str, Any]] = []
+    for page in pages:
+        page_idx = page.get("page_index")
+        title = (page.get("title") or "").strip()
+        page_type = page.get("page_type") or "content_slide"
+        text_parts: List[str] = []
+        if title:
+            text_parts.append(f"[PAGE_TITLE] {title}")
+        text_parts.append(f"[PAGE_TYPE] {page_type}")
+        reconstructed_text = (page.get("reconstructed_text") or "").strip()
+        if reconstructed_text:
+            text_parts.append(reconstructed_text)
+        for table in page.get("tables") or []:
+            ttext = table.get("table_text") or _reconstruct_table_text(table)
+            if ttext:
+                text_parts.append(f"[TABLE]\n{ttext}")
+        unit_text = "\n\n".join([p for p in text_parts if p]).strip()
+        semantic_units.append({
+            "page_index": page_idx,
+            "title": title,
+            "page_type": page_type,
+            "text": unit_text,
+            "source": "page_semantics",
+        })
+    return semantic_units

src/tools/llm_answering.py

@@ -0,0 +1,1456 @@
+# -*- coding: utf-8 -*-
+"""
+llm_answering.py · Proposal-aware LLM Answering (ChatGPT + DeepSeek, no web search)
+
+新版职责：
+- 基于「维度抽取管线」生成的提案事实（dimensions_from_facts）+ 生成的问题集，
+  为每个维度的问题生成“强关联该提案”的结构化回答。
+- 不再依赖外部 Web 检索；只使用：
+    • 提案维度事实（summary/key_points/risks/mitigations/numbers 等）
+    • LLM 自身通识做解释，但禁止脑补新实验/新数字/新机构
+- 输出结构保持兼容：
+    data/refined_answers/{pid}/all_refined_items.json
+    data/refined_answers/{pid}/chatgpt_raw.json
+    data/refined_answers/{pid}/deepseek_raw.json
+
+本版新增：
+- 明确要求回答中包含“行业基准 / baseline 对比”和“常见坑 & 证据要求”两类内容；
+- 这些通识部分必须写成“行业普遍情况/一般建议”，不能写成项目已经达成的事实；
+- 新增字段 general_insights：专门装“行业基准 / 常见坑 / 证据要求”这类专家经验层；
+- 修复 answer 分点格式问题，避免出现 “1. 1. xxx” 这种双重编号。
+"""
+
+import os
+import sys
+import json
+import time
+import re
+import random
+import argparse
+from pathlib import Path
+from datetime import datetime
+from typing import Dict, Any, List, Tuple, Optional
+
+from dotenv import load_dotenv
+
+# ========== 环境 & 路径 ==========
+load_dotenv()
+ROOT = Path(__file__).resolve().parents[1]  # .../src
+DATA_DIR = ROOT / "data"
+EXTRACTED_DIR = DATA_DIR / "extracted"
+PARSED_DIR = DATA_DIR / "parsed"
+CONFIG_QS_DEFAULT = DATA_DIR / "config" / "question_sets" / "generated_questions.json"
+OUT_REFINED = DATA_DIR / "refined_answers"
+from src.prompting.domain_adaptive import load_domain_profile
+
+DIM_ORDER = ["team", "objectives", "strategy", "innovation", "feasibility"]
+
+# ========== SDK ==========
+try:
+    from openai import OpenAI as OpenAIClient
+except Exception:  # pragma: no cover
+    OpenAIClient = None
+
+# ========== 变体 & provider 能力 ==========
+VARIANTS = ["default", "risk", "implementation"]
+TEMP_BY_VARIANT = {"default": 0.25, "risk": 0.35, "implementation": 0.30}
+
+PROVIDER_CAPS = {
+    "openai": {"json_mode": True, "batch_ok": True},
+    "deepseek": {"json_mode": False, "batch_ok": False},
+}
+
+
+def provider_caps(provider: str) -> Dict[str, Any]:
+    return PROVIDER_CAPS.get(provider, {"json_mode": True, "batch_ok": True})
+
+
+CONF_MIN, CONF_MAX = 0.50, 0.92
+MAX_LIST_LEN = 10
+
+# ========== 工具函数 ==========
+def read_json(p: Path) -> Any:
+    return json.loads(Path(p).read_text(encoding="utf-8"))
+
+
+def write_json(p: Path, obj: Any) -> None:
+    p.parent.mkdir(parents=True, exist_ok=True)
+    p.write_text(json.dumps(obj, ensure_ascii=False, indent=2), encoding="utf-8")
+
+
+def now_str() -> str:
+    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+
+def detect_latest_pid() -> str:
+    if not EXTRACTED_DIR.exists():
+        return "unknown"
+    cands = [d for d in EXTRACTED_DIR.iterdir() if d.is_dir()]
+    if not cands:
+        return "unknown"
+    cands.sort(key=lambda x: x.stat().st_mtime, reverse=True)
+    return cands[0].name
+
+def _flatten_list_field(block: Dict[str, Any], keys: List[str], limit: int = 12) -> List[str]:
+    items: List[str] = []
+    for k in keys:
+        v = block.get(k)
+        if not v:
+            continue
+        if isinstance(v, str):
+            items.extend([x.strip() for x in re.split(r"[;\n]", v) if x.strip()])
+        elif isinstance(v, list):
+            for x in v:
+                if isinstance(x, str):
+                    s = x.strip()
+                    if s:
+                        items.append(s)
+    uniq, seen = [], set()
+    for x in items:
+        key = x.strip()
+        if not key or key in seen:
+            continue
+        seen.add(key)
+        uniq.append(key)
+        if len(uniq) >= limit:
+            break
+    return uniq
+
+
+def _build_dim_context_text(dim: str, block: Dict[str, Any]) -> str:
+    """
+    把从 facts 管线来的一个维度 block 转成适合放进 prompt 的 context 文本。
+    控制长度，优先 summary / key_points / risks / mitigations / numbers。
+    """
+    if not isinstance(block, dict):
+        block = {}
+
+    summary = str(block.get("summary") or "").strip()
+    key_points = _flatten_list_field(block, ["key_points", "keypoints", "key_facts", "bullets"], limit=10)
+    risks = _flatten_list_field(block, ["risks", "risk_points"], limit=8)
+    mitigations = _flatten_list_field(block, ["mitigations", "mitigation_points"], limit=8)
+    numbers = _flatten_list_field(block, ["numbers", "key_numbers"], limit=8)
+
+    parts: List[str] = []
+    if summary:
+        parts.append(f"【{dim} 概览】{summary}")
+    if key_points:
+        parts.append("【关键要点】" + "；".join(key_points))
+    if risks:
+        parts.append("【主要风险/不确定性】" + "；".join(risks))
+    if mitigations:
+        parts.append("【已有��解措施】" + "；".join(mitigations))
+    if numbers:
+        parts.append("【关键量化信息】" + "；".join(numbers))
+
+    text = "\n".join(parts)
+    if len(text) > 2000:
+        text = text[:2000]
+    return text
+
+
+def load_dimension_context(pid: str, dim_file: Optional[Path]) -> Dict[str, str]:
+    """
+    返回：{dim: context_text}
+    若找不到文件或结构异常，所有维度返回空字符串（模型会退化成通识回答）
+    """
+    ctx: Dict[str, str] = {d: "" for d in DIM_ORDER}
+    if dim_file is None or not dim_file.exists():
+        return ctx
+
+    try:
+        raw = read_json(dim_file)
+    except Exception:
+        return ctx
+
+    if isinstance(raw, dict) and "dimensions" in raw and isinstance(raw["dimensions"], dict):
+        root = raw["dimensions"]
+    else:
+        root = raw if isinstance(raw, dict) else {}
+
+    for dim in DIM_ORDER:
+        block = root.get(dim) or {}
+        ctx[dim] = _build_dim_context_text(dim, block)
+    return ctx
+
+
+# ========== 问题集 & 监管提示 ==========
+def get_q_list(block: Any) -> List[str]:
+    if isinstance(block, dict) and isinstance(block.get("questions"), list):
+        return [q for q in block["questions"] if isinstance(q, str)]
+    if isinstance(block, list):
+        return [q for q in block if isinstance(q, str)]
+    return []
+
+
+def _load_reg_hints(qs_cfg: Dict[str, Any], dim: str, limit: int = 8) -> List[str]:
+    """
+    从问题集里抓一点监管/术语 hints，但只作为“可选方向提示”，不强依赖。
+    """
+    block = qs_cfg.get(dim, {}) or {}
+    hints = block.get("search_hints") or block.get("reg_hints") or []
+    out: List[str] = []
+    if isinstance(hints, list):
+        for h in hints:
+            if not isinstance(h, str):
+                continue
+            s = h.strip()
+            if not s:
+                continue
+            out.append(s)
+    uniq, seen = [], set()
+    for x in out:
+        if x in seen:
+            continue
+        seen.add(x)
+        uniq.append(x)
+        if len(uniq) >= limit:
+            break
+    return uniq
+
+# ========== Prompt 相关 ==========
+SYSTEM_CN = (
+    "你是一名严格、通用、证据优先的项目评审专家。"
+    "你的任务是：在完整阅读给定的【提案事实】之后，围绕问题进行“与该提案强相关”的专业分析。"
+    "原则："
+    "1）必须优先基于【提案事实】给出结论；"
+    "2）不得发明提案中未出现的新试验、新数据、新机构或具体数字；"
+    "3）当你在【提案事实】中找不到某一类信息时，只能说“当前材料中未看到关于 X 的具体说明”，"
+    "   并优先写成“已有 A/B，但在 C/D 方面细节不足”；严禁使用“完全没有分析”“未进行任何评估”"
+    "   “未提供任何信息”等绝对化表述；"
+    "4）可以使用行业通识解释这些事实的意义，但不得虚构提案中没有出现的具体编号、样本量、组织名称或数字细节；"
+    "5）回答必须结构化、条理清晰，适合作为专家评审报告的组成部分；"
+    "6）你需要在回答中补充“行业基准/baseline 对比”和“类似项目常见的坑与证据要求”等通识内容，"
+    "   但这些通识部分必须明确表述为“行业普遍情况/一般建议”，不得写成项目已经达成的事实；"
+)
+
+def _schema_structured() -> str:
+    return """
+请严格返回 JSON 对象，键名固定：
+{
+  "answer": "分点形式的主回答（中文，条理清晰，含项目现状+问题+改进方向等）",
+  "claims": ["关键可验证结论1","关键可验证结论2","..."],
+  "evidence_hints": ["哪条提案事实/段落支撑对应结论，或需进一步核查的线索"],
+  "general_insights": ["行业基准/类似项目常见做法/常见坑与证据要求（通识，不代表本项目已完成；建议最后一条给出统一免责声明）"],
+  "topic_tags": ["维度内的小主题/标签"],
+  "confidence": 0.0,
+  "caveats": "限制/注意事项（若无可空）"
+}
+""".strip()
+
+
+def _variant_instructions(variant_id: str) -> str:
+    if variant_id == "risk":
+        return (
+            "变体：risk（风险视角）——重点：\n"
+            "- 优先识别不确定性、缺失信息、潜在合规或技术风险；\n"
+            "- 对每个主要风险给出“风险来源 + 可能影响 + 建议补充材料”；\n"
+            "- 若提案事实中未覆盖关键环节，要显式指出“信息缺口”；\n"
+            "- 在 general_insights 中，总结同类项目在该维度常见的风险模式、监管关注点和证据要求，"
+            "  明确说明这些是行业通识，不代表本项目已经满足。\n"
+        )
+    if variant_id == "implementation":
+        return (
+            "变体：implementation（落地视角）——重点：\n"
+            "- 列出 4–8 条“接下来 3–12 个月可执行的具体动作”，每条包含：动作主体/对象 + 具体步骤 + 预期产出；\n"
+            "- 动作必须与提案当前状态匹配，不得假设已完成的工作；\n"
+            "- 可以提及需要收集/补充的证据或文档类型（而不是凭空给出结论）；\n"
+            "- 在 general_insights 中，总结同类项目在该维度的主流落地路径、里程碑拆解和常见踩坑点。\n"
+        )
+    return (
+        "变体：default（综合视角）——重点：\n"
+        "- 结合该维度的“当前方案/优势/问题/建议”，给出整体评价；\n"
+        "- 既要指出做得好的地方，也要指出存在的不足或不确定性；\n"
+        "- 至少包含：现状概括、优势点、主要问题、改进方向四类内容；\n"
+        "- 在 answer 中，你需要显式区分：\n"
+        "  a) 基于【提案事实】得出的本项目现状与问题；\n"
+        "  b) 行业基准 / baseline 对比（同类项目通常达到什么水平、需要哪些能力/数据/里程碑）；\n"
+        "  c) 同类项目常见的坑和证据要求/监管关注点；\n"
+        "- 在 claims 中，优先写“提案已经说明了什么/在哪些方面信息仍然有限”，"
+        "  避免使用“项目未提供/没有进行任何……”这类绝对否定，如果只能判断信息有限，"
+        "  应写成“现有材料未看到关于 X 的更详细说明”。\n"
+        "- 在 general_insights 字段中，对 b) 和 c) 做更加抽象的行业通识总结，"
+        "  明确使用“通常/一般而言/在同类项目中”等措辞，避免暗示本项目已经达成这些条件。\n"
+    )
+
+def build_single_prompt(
+    dimension: str,
+    question: str,
+    proposal_context: str,
+    reg_hints: List[str],
+    variant_id: str,
+) -> str:
+    reg_txt = "；".join(reg_hints) if reg_hints else "无特别提示"
+    return f"""
+维度：{dimension}
+
+[提案事实]（只能在这里面引用具体细节；如无相关信息请据实指出）：
+{proposal_context or "（该维度的提案事实为空，仅可做通识性分析）"}
+
+[可选术语/方法方向提示]（非必须引用，如与提案无关可忽略）：
+{reg_txt}
+
+题目：
+{question.strip()}
+
+{_variant_instructions(variant_id)}
+
+回答要求：
+- 语言：中文（专有名词可保留英文）；
+- 结构：answer 必须以 3–8 条分点给出，每条前加“1. 2. 3.” 等编号，每条尽量控制在一到两句话；
+- 内容结构建议（非强制格式，但需覆盖）：\n
+  1）先基于[提案事实]总结本项目在该维度的“现状 + 优势 + 主要问题”；\n
+  2）再用 1–3 条要点，对标“行业基准 / baseline”，说明同类项目通常在该维度需要达到什么水平（注意：这是行业通识，不代表本项目已达到）；\n
+  3）再用 1–3 条要点，总结“同类项目常见的坑、证据要求、领域常见关注点”；\n
+- 关联度：优先基于[提案事实]分析该项目的真实情况；对于[提案事实]中没有的信息，只能用“缺失/需补充”的方式描述，不得假设已经存在；\n
+- 若[提案事实]中已经给出某一方面的部分信息（例如已有部分证据但缺少细化说明、已有对象列表但缺少对应比较），"
+"  必须写成“已有……但在……方面仍缺乏具体细节”，不得笼统说“未提供相关分析/未进行对应评估”；\n
+- 通识与事实的区分：凡是基于行业经验的内容，需要在句中用“通常/一般而言/在同类项目中”等词标识清楚，避免写成好像本项目已经完成这些工作；\n
+- general_insights 字段：请单独列出 3–8 条不依赖本项目具体事实的“行业基准/常见坑/证据要求”要点，这些内容应可用于评估任何类似项目，且必须表述为通识建议；最后一条建议写成类似 “以上为行业通识建议，不代表本项目已经达成相关要求。” 这样的统一免责声明；\n
+- 审慎性：避免下结论式的绝对语气，多用“可能/建议/需要确认”等方式，并尽量指出需要的佐证材料类型；\n
+- 仅输出一个 JSON 对象，不得有任何额外说明文字或 Markdown 围栏。
+
+{_schema_structured()}
+""".strip()
+
+
+def build_batch_prompt(
+    dimension: str,
+    questions: List[str],
+    proposal_context: str,
+    reg_hints: List[str],
+    variant_id: str,
+) -> str:
+    reg_txt = "；".join(reg_hints) if reg_hints else "无特别提示"
+    q_block = "\n".join([f"{i+1}. {q}" for i, q in enumerate(questions)])
+    return f"""
+你将针对同一维度下的多道问题，基于同一份【提案事实】给出与该提案高度相关的回答。
+请严格以对象数组 JSON 返回结果，格式为：{{"answers":[<对象1>,<对象2>,...]}}，数组长度必须与题目数一致。
+
+维度：{dimension}
+
+[提案事实]（只能在这里面引用具体细节；如无相关信息请据实指出）：
+{proposal_context or "（该维度的提案事实为空，仅可��通识性分析）"}
+
+[可选术语/方法方向提示]（非必须引用，如与提案无关可忽略）：
+{reg_txt}
+
+问题列表：
+{q_block}
+
+{_variant_instructions(variant_id)}
+
+统一回答要求：
+- 每道题的 answer：3–8 条分点，每条前加数字编号；条数不足时宁可只写 3–4 条扎实要点，也不要凑模板口号；
+- 建议在 answer 中显式覆盖三类信息：\n
+  a) 仅基于[提案事实]得出的本项目现状/优势/问题；\n
+  b) 行业基准 / baseline 对比（同类项目通常需要的团队能力、数据规模、里程碑等——需标明是行业通识）；\n
+  c) 同类项目在该维度常见的坑、证据要求、领域常见关注点；\n
+- 每道题的 claims：2–6 条可以被事后核对的结论，优先基于[提案事实]；若信息不足，请将“信息缺口”本身写入 claims；
+- 每道题的 evidence_hints：指明“哪类提案事实/哪一段内容/哪类文档可以支撑这些结论”，避免写空泛模板；
+- 每道题的 general_insights：3–8 条不依赖本项目具体事实的“行业基准/常见坑/证据要求”要点，只能写成行业普遍情况/一般建议，不得暗示本项目已经达成；建议其中最后一条写成统一的免责声明，例如 “以上为行业通识建议，并不代表本项目已经满足相关条件。”；\n
+- 若[提案事实]中已经给出某一方面的部分信息（例如已有部分证据、对象清单、风险表等），"
+"  只能评价为“现有描述在……方面仍不够细化/缺乏定量对比”，不得一概写成“项目未提供相关分析/对应评估”等绝对否定；\n
+- 不得发明提案中不存在的新实验/新数据/新机构/具体注册号；对未给出的信息，只能以“需补充/需确认”的方式表达；\n
+- 仅输出一个 JSON 对象，不得有额外文字或 Markdown 围栏。
+
+{_schema_structured()}
+""".strip()
+
+
+def build_refine_prompt(candidate_obj: Dict[str, Any], proposal_context: str, dimension: str) -> str:
+    original = json.dumps(candidate_obj, ensure_ascii=False, indent=2)
+    return f"""
+请在不引入任何超出【提案事实】的新信息的前提下，对下面的结构化回答做一次快速自我复核：
+- 删改过于武断或缺乏依据的强结论；
+- 若某条结论在【提案事实】中找不到依据，请改写为“需要补充的材料/信息”；
+- 优化 answer 的分点表达，让每条更具体、更可执行，但不要发明新试验/新数据；
+- 检查 general_insights：确保里面只包含“行业基准/类似项目常见做法/常见坑与证据要求”等通识内容，不得把本项目的具体事实写进 general_insights；\n
+- 保持 JSON 结构和字段名完全不变（包括 general_insights）。
+
+维度：{dimension}
+
+[提案事实]：
+{proposal_context or "（该维度的提案事实为空，仅可做轻度通识性修正）"}
+
+原候选：
+{original}
+""".strip()
+
+
+# ========== LLM 调用基础 ==========
+def _with_retry(fn, max_tries: int = 4, base: float = 0.8):
+    for i in range(max_tries):
+        try:
+            return fn()
+        except Exception:
+            if i == max_tries - 1:
+                raise
+            time.sleep(base * (2 ** i) + random.random() * 0.2)
+
+
+ERR_PATTERNS = [
+    r"\[?ERROR[:\]]",
+    r"\bHTTP\s*4\d{2}\b",
+    r"\bHTTP\s*5\d{2}\b",
+    r"insufficient[_\s-]?quota",
+    r"invalid[_\s-]?api[_\s-]?key",
+    r"request\s+timed\s*out",
+    r"rate\s*limit",
+    r"payment\s*required",
+    r"bad gateway",
+    r"service unavailable",
+    r"connection (?:reset|refused)",
+]
+_err_re = re.compile("|".join(ERR_PATTERNS), re.I)
+
+
+def is_error_text(text: str) -> bool:
+    t = (text or "").strip()
+    if not t:
+        return True
+    return bool(_err_re.search(t))
+
+
+def _chat_completion_json(
+    client,
+    model: str,
+    system_text: str,
+    user_text: str,
+    max_tokens: int,
+    temperature: float,
+    force_json: bool,
+):
+    def call(json_mode: bool):
+        kwargs = dict(
+            model=model,
+            messages=[{"role": "system", "content": system_text}, {"role": "user", "content": user_text}],
+            temperature=float(temperature),
+            max_tokens=int(max_tokens),
+        )
+        if json_mode:
+            kwargs["response_format"] = {"type": "json_object"}
+        return client.chat.completions.create(**kwargs)
+
+    try:
+        if force_json:
+            resp = _with_retry(lambda: call(json_mode=True))
+            out = (resp.choices[0].message.content or "").strip()
+            if is_error_text(out):
+                raise RuntimeError("provider_error_json_mode")
+            return out
+        else:
+            resp = _with_retry(lambda: call(json_mode=False))
+            out = (resp.choices[0].message.content or "").strip()
+            if is_error_text(out):
+                raise RuntimeError("provider_error_text_mode")
+            return out
+    except Exception:
+        if force_json:
+            resp = _with_retry(lambda: call(json_mode=False))
+            out = (resp.choices[0].message.content or "").strip()
+            if is_error_text(out):
+                raise RuntimeError("provider_error_text_mode")
+            return out
+        raise
+
+
+def _safe_parse_json_plus(txt: str) -> Optional[Any]:
+    if is_error_text(txt):
+        return None
+
+    t = (txt or "").replace("\ufeff", "").strip()
+    t = re.sub(r"^\s*```(?:json)?\s*\n?", "", t, flags=re.IGNORECASE)
+    t = re.sub(r"\n?\s*```\s*$", "", t, flags=re.IGNORECASE)
+    t = t.replace("\xa0", " ")
+
+    try:
+        obj = json.loads(t)
+        if isinstance(obj, list):
+            return {"answers": obj}
+        return obj
+    except Exception:
+        pass
+
+    m = re.search(r"(\{.*\}|\[.*\])", t, re.S)
+    if m:
+        frag = m.group(1)
+        try:
+            tmp = json.loads(frag)
+            if isinstance(tmp, list):
+                return {"answers": tmp}
+            return tmp
+        except Exception:
+            pass
+
+    # 尝试给常见字段名补双引号，包括 general_insights
+    cand = re.sub(
+        r"(\banswer|claims|evidence_hints|general_insights|topic_tags|confidence|caveats\b)\s*:",
+        r'"\1":',
+        t,
+    )
+    try:
+        return json.loads(cand)
+    except Exception:
+        return None
+
+
+# ========== 模型初始化 ==========
+def init_openai():
+    if OpenAIClient is None:
+        return None, None
+    key = os.getenv("OPENAI_API_KEY", "").strip()
+    if not key:
+        return None, None
+    model = os.getenv("OPENAI_MODEL", "gpt-4o-mini").strip()
+    client = OpenAIClient(api_key=key)
+    print(f"✅ 已加载 OpenAI 模型：{model}")
+    return client, model
+
+
+def init_deepseek():
+    if OpenAIClient is None:
+        return None, None
+    key = os.getenv("DEEPSEEK_API_KEY", "").strip()
+    if not key:
+        return None, None
+    base = os.getenv("DEEPSEEK_API_BASE", "https://api.deepseek.com/v1").strip()
+    model = os.getenv("DEEPSEEK_MODEL", "deepseek-chat").strip()
+    client = OpenAIClient(api_key=key, base_url=base)
+    print(f"✅ 已加载 DeepSeek 模型：{model}")
+    return client, model
+
+
+# ========== 答案规范化 & 后处理 ==========
+def _norm_str(s: Any) -> str:
+    return " ".join(str(s or "").strip().split())
+
+
+def _uniq_cut(lst: List[Any], k: int = MAX_LIST_LEN) -> List[str]:
+    seen, out = set(), []
+    for x in lst:
+        t = _norm_str(x)
+        if not t:
+            continue
+        key = t.casefold()
+        if key in seen:
+            continue
+        seen.add(key)
+        out.append(t)
+        if len(out) >= k:
+            break
+    return out
+
+
+RE_DATE = re.compile(r"\b(20\d{2}|19\d{2})([-/.]|年)\d{1,2}([-/\.日]|月)\d{1,2}\b|\b(Q[1-4]\s*-\s*20\d{2})\b", re.I)
+RE_MONEY = re.compile(
+    r"\b(\$|USD|EUR|CNY|RMB|CAD)\s*\d{2,}(,\d{3})*(\.\d+)?\b|\b\d+(\.\d+)?\s*(million|billion|万|亿)\b",
+    re.I,
+)
+RE_TRIAL = re.compile(r"\bNCT\d{8}\b|\bEUCTR-\d{4}-\d{6}-\d{2}\b", re.I)
+RE_DOI = re.compile(r"\b10\.\d{4,9}/[-._;()/:A-Z0-9]+\b", re.I)
+RE_PATENT = re.compile(r"\b(US|EP|CN)\d{5,}\b|\bWO\d{7,}\b", re.I)
+RE_ISO = re.compile(r"\bISO\s?\d{4,5}(-\d+)?\b", re.I)
+RE_STDNUM = re.compile(r"\bEN\s?\d{3,5}\b|\bASTM\s?[A-Z]?\d{2,5}\b", re.I)
+RE_ID_ANY = re.compile(r"(注册号|登记号|批准文号|备案号)", re.I)
+
+
+def _is_redline(text: str) -> bool:
+    t = text or ""
+    if RE_DATE.search(t):
+        return True
+    if RE_MONEY.search(t):
+        return True
+    if RE_TRIAL.search(t):
+        return True
+    if RE_DOI.search(t):
+        return True
+    if RE_PATENT.search(t):
+        return True
+    if RE_ISO.search(t):
+        return True
+    if RE_STDNUM.search(t):
+        return True
+    if RE_ID_ANY.search(t):
+        return True
+    return False
+
+
+def _scrub_claims_to_hints(claims: List[Any], hints: List[Any]) -> Tuple[List[str], List[str], List[str]]:
+    """
+    把明显带编号/金额的句子从 claims 挪到 evidence_hints，并记录到 moved_facts。
+    不再额外注水模板；只做清洗和重分类。
+    """
+    new_claims: List[str] = []
+    new_hints: List[str] = [str(x).strip() for x in (hints or []) if str(x).strip()]
+    moved_facts: List[str] = []
+
+    for c in claims or []:
+        s = _norm_str(c)
+        if not s:
+            continue
+        if _is_redline(s):
+            new_hints.append(s)
+            moved_facts.append(s)
+        else:
+            new_claims.append(s)
+
+    return _uniq_cut(new_claims, MAX_LIST_LEN), _uniq_cut(new_hints, MAX_LIST_LEN), _uniq_cut(moved_facts, MAX_LIST_LEN)
+
+
+def _to_bullets(answer: str) -> Tuple[str, int]:
+    """
+    把任意文本整理成 1. 2. 3. 形式的分点；不过度强制数量，只要 >=1 即可。
+    修复双重编号问题：无论是按行还是按句拆分，都会先去掉已有编号/符号再统一加“1. 2. 3.”。
+    """
+    raw = (answer or "").strip()
+    if not raw:
+        return "", 0
+
+    text = raw.replace("\r\n", "\n").strip()
+
+    def _normalize_item(line: str) -> str:
+        s = line.strip()
+        # 去掉 Markdown 项目符号
+        s = re.sub(r"^\s*[-*•●▪]+\s*", "", s)
+        # 去掉前导数字编号（1. / 1) / 1、 等）
+        s = re.sub(r"^\s*\d+[\.\)．、]\s*", "", s)
+        # 压缩空白
+        s = re.sub(r"\s+", " ", s)
+        s = s.strip()
+        if not s:
+            return ""
+
+        # 丢掉只剩数字或“数字+空格”的内容（例如 "1"、"2"、"1 2" 等）
+        s_nospace = s.replace(" ", "")
+        if s_nospace.isdigit() and len(s_nospace) <= 4:
+            return ""
+
+        return s
+
+    # 先按行拆分（利用 LLM 原始的换行结构）
+    lines = [ln for ln in text.split("\n") if ln.strip()]
+    items: List[str] = []
+    for ln in lines:
+        norm = _normalize_item(ln)
+        if norm:
+            items.append(norm)
+
+    # 如果按行只有 0–1 条，说明可能是整段一坨 -> 再按句号/分号拆一轮
+    if len(items) <= 1:
+        chunks = re.split(r"[。；;.!?？]\s*", text)
+        items = []
+        for ch in chunks:
+            norm = _normalize_item(ch)
+            if norm:
+                items.append(norm)
+
+    if not items:
+        # 实在拆不出有效内容，就保留原文
+        return raw, 0
+
+    # 控制条数上限，避免 answer 过长
+    items = items[:8]
+
+    numbered = [f"{i+1}. {seg}" for i, seg in enumerate(items)]
+    return "\n".join(numbered), len(items)
+
+def _calibrate_conf(x: Any) -> float:
+    try:
+        v = float(x)
+    except Exception:
+        v = 0.65
+    if v < CONF_MIN:
+        v = CONF_MIN
+    if v > CONF_MAX:
+        v = CONF_MAX
+    return round(v, 2)
+
+
+def _normalize_candidate_obj(obj: Any) -> Dict[str, Any]:
+    if not isinstance(obj, dict):
+        obj = {}
+    out: Dict[str, Any] = {}
+
+    # ❗ 保留原始换行，不再用 _norm_str 压缩，避免破坏 LLM 已经分好的行
+    raw_answer = obj.get("answer", "")
+
+    # ====== 新增：专门处理 list / dict 形式的 answer，避免 json.dumps 成一坨 ======
+    if isinstance(raw_answer, list):
+        # LLM 有时会给 ["1\n2. ...", "3\n4. ..."] 这种
+        pieces: List[str] = []
+        for elem in raw_answer:
+            if elem is None:
+                continue
+            # 再兜一层 list（极端情况）
+            if isinstance(elem, list):
+                for sub in elem:
+                    s = str(sub or "").strip()
+                    if s:
+                        pieces.append(s)
+            else:
+                s = str(elem or "").strip()
+                if s:
+                    pieces.append(s)
+        raw_answer = "\n".join(pieces)  # 变成多行文本，交给 _to_bullets 按行拆
+
+    elif isinstance(raw_answer, dict):
+        # 如果以后 LLM 返回 {"bullets":[...]} 之类，优先拉出里面的 list
+        for key in ("bullets", "points", "items"):
+            val = raw_answer.get(key)
+            if isinstance(val, list):
+                pieces = [str(x or "").strip() for x in val if str(x or "").strip()]
+                raw_answer = "\n".join(pieces)
+                break
+        else:
+            # 实在没有结构化 list，再兜底 dump 成字符串
+            raw_answer = json.dumps(raw_answer, ensure_ascii=False)
+
+    # 其他情况：本来就是字符串/数字，直接转成字符串
+    out["answer"] = str(raw_answer or "")
+
+    raw_claims = obj.get("claims", [])
+    raw_hints = obj.get("evidence_hints", [])
+    raw_tags = obj.get("topic_tags", [])
+    raw_gi = obj.get("general_insights", [])
+
+    if isinstance(raw_claims, (str, int, float)):
+        raw_claims = [raw_claims]
+    if isinstance(raw_hints, (str, int, float)):
+        raw_hints = [raw_hints]
+    if isinstance(raw_tags, (str, int, float)):
+        raw_tags = [raw_tags]
+    if isinstance(raw_gi, (str, int, float)):
+        raw_gi = [raw_gi]
+
+    out["claims"] = [str(x).strip() for x in (raw_claims or []) if str(x).strip()]
+    out["evidence_hints"] = [str(x).strip() for x in (raw_hints or []) if str(x).strip()]
+    out["topic_tags"] = [str(x).strip() for x in (raw_tags or []) if str(x).strip()]
+    out["general_insights"] = [str(x).strip() for x in (raw_gi or []) if str(x).strip()]
+    try:
+        out["confidence"] = float(obj.get("confidence", 0.65))
+    except Exception:
+        out["confidence"] = 0.65
+    out["caveats"] = _norm_str(obj.get("caveats", ""))
+    return out
+
+
+def _validate_candidate_dict(obj: Any) -> bool:
+    if not isinstance(obj, dict):
+        return False
+    if not isinstance(obj.get("answer"), str) or not obj.get("answer").strip():
+        return False
+    if not isinstance(obj.get("claims"), list):
+        return False
+    if not isinstance(obj.get("evidence_hints"), list):
+        return False
+    if not isinstance(obj.get("topic_tags"), list):
+        return False
+    if not isinstance(obj.get("general_insights"), list):
+        return False
+    return True
+
+
+def _build_topic_tags(tags: List[Any], dimension: str, answer: str) -> List[str]:
+    base = [str(t).lower().strip() for t in (tags or []) if str(t).strip()]
+    extra: List[str] = []
+
+    dim_token = dimension.lower().strip()
+    if dim_token:
+        extra.append(dim_token)
+
+    words = re.findall(r"[A-Za-z]+|[\u4e00-\u9fff]{2,8}", answer)
+    freq: Dict[str, int] = {}
+    for w in words:
+        wl = w.lower()
+        if len(wl) < 2:
+            continue
+        freq[wl] = freq.get(wl, 0) + 1
+    common = sorted(freq.items(), key=lambda kv: kv[1], reverse=True)[:6]
+    extra.extend([w for w, _ in common])
+
+    return _uniq_cut(base + extra, MAX_LIST_LEN)
+
+
+def _quick_score(cand: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    给后续选优一个简单分数：
+    - 分点条数
+    - claims 数量
+    - confidence
+    （general_insights 目前只在下游使用，这里不额外打分，避免逻辑过重）
+    """
+    bullets = len([ln for ln in str(cand.get("answer", "")).splitlines() if ln.strip()])
+    claims_n = len(cand.get("claims") or [])
+    conf = float(cand.get("confidence", 0.65))
+
+    score = 0.0
+    if bullets >= 3:
+        score += 0.25
+    if 3 <= bullets <= 8:
+        score += 0.20
+    if claims_n >= 2:
+        score += 0.25
+    if claims_n >= 4:
+        score += 0.10
+    score += max(0.0, min(0.20, (conf - CONF_MIN) / (CONF_MAX - CONF_MIN + 1e-6) * 0.20))
+
+    cand["quick_score"] = round(score, 3)
+    return cand
+
+
+def _finalize_candidate(
+    obj: Dict[str, Any],
+    provider: str,
+    model: str,
+    variant_id: str,
+    sample_id: int,
+    dimension: str,
+) -> Dict[str, Any]:
+    base = _normalize_candidate_obj(obj)
+    answer_bullets, n_bullets = _to_bullets(base["answer"])
+    base["answer"] = answer_bullets
+
+    new_claims, new_hints, moved_facts = _scrub_claims_to_hints(base.get("claims", []), base.get("evidence_hints", []))
+    base["claims"] = new_claims
+    base["evidence_hints"] = new_hints
+    base["facts_redlined"] = moved_facts
+
+    # general_insights 只做去重+截断，不做红线搬移（允许包含“通常需要 NCT 编号”这类行业通识）
+    base["general_insights"] = _uniq_cut(base.get("general_insights", []), MAX_LIST_LEN)
+
+    base["topic_tags"] = _build_topic_tags(base.get("topic_tags", []), dimension, base["answer"])
+    base["confidence"] = _calibrate_conf(base.get("confidence", 0.65))
+
+    if not base.get("caveats"):
+        base["caveats"] = "结论需结合原始提案全文与支撑材料进一步核查。"
+
+    base["provider"] = provider
+    base["model"] = model
+    base["variant_id"] = variant_id
+    base["sample_id"] = int(sample_id)
+    base["generated_at"] = now_str()
+
+    base["diag"] = {
+        "bullet_count": n_bullets,
+        "claims_count": len(base["claims"]),
+        "hints_count": len(base["evidence_hints"]),
+        "general_insights_count": len(base["general_insights"]),
+    }
+
+    base = _quick_score(base)
+    return base
+
+
+def _simhash_key(s: str) -> str:
+    s = re.sub(r"\s+", " ", (s or "").strip().lower())
+    return s[:256]
+
+
+def dedup_nearby(candidates: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    seen = set()
+    kept: List[Dict[str, Any]] = []
+    for c in candidates:
+        key = _simhash_key(c.get("answer", ""))
+        if not key:
+            continue
+        if key in seen:
+            continue
+        seen.add(key)
+        kept.append(c)
+    return kept
+
+
+# ========== 问答主逻辑（batch / single） ==========
+def ask_model_batch(
+    provider: str,
+    client,
+    model: str,
+    dimension: str,
+    q_list: List[str],
+    proposal_context: str,
+    reg_hints: List[str],
+    variant_id: str,
+    max_tokens: int,
+) -> List[Dict[str, Any]]:
+    """
+    对支持 batch 的模型：同一维度下多题一起问；
+    若解析失败或数组长度不对，由上层改走逐题兜底。
+    返回：长度 == len(q_list) 的 candidate 列表。
+    """
+    prompt = build_batch_prompt(dimension, q_list, proposal_context, reg_hints, variant_id)
+    try:
+        txt = _chat_completion_json(
+            client,
+            model,
+            SYSTEM_CN,
+            prompt,
+            max_tokens=max_tokens,
+            temperature=TEMP_BY_VARIANT.get(variant_id, 0.3),
+            force_json=provider_caps(provider)["json_mode"],
+        )
+    except Exception:
+        return []
+
+    low = (txt or "").strip().lower()
+    if any(k in low for k in ("incorrect api key", "invalid api key", "rate limit", "quota", "access denied")):
+        return []
+
+    obj = _safe_parse_json_plus(txt)
+    if not isinstance(obj, dict):
+        return []
+    arr = obj.get("answers")
+    if not isinstance(arr, list) or len(arr) != len(q_list):
+        return []
+
+    out: List[Dict[str, Any]] = []
+    for idx, it in enumerate(arr, 1):
+        cand_norm = _normalize_candidate_obj(it)
+        if not _validate_candidate_dict(cand_norm):
+            out.append({})
+            continue
+        finalized = _finalize_candidate(
+            cand_norm,
+            provider=provider,
+            model=model,
+            variant_id=variant_id,
+            sample_id=idx,
+            dimension=dimension,
+        )
+        out.append(finalized)
+    return out
+
+
+def ask_model_single(
+    provider: str,
+    client,
+    model: str,
+    dimension: str,
+    question: str,
+    proposal_context: str,
+    reg_hints: List[str],
+    variant_id: str,
+    max_tokens: int,
+) -> Dict[str, Any]:
+    prompt = build_single_prompt(dimension, question, proposal_context, reg_hints, variant_id)
+    try:
+        txt = _chat_completion_json(
+            client,
+            model,
+            SYSTEM_CN,
+            prompt,
+            max_tokens=max_tokens,
+            temperature=TEMP_BY_VARIANT.get(variant_id, 0.3),
+            force_json=provider_caps(provider)["json_mode"],
+        )
+    except Exception:
+        return {"error": True, "answer": ""}
+
+    obj = _safe_parse_json_plus(txt)
+    if not isinstance(obj, dict):
+        return {"error": True, "answer": ""}
+
+    cand_norm = _normalize_candidate_obj(obj)
+    if not _validate_candidate_dict(cand_norm):
+        return {"error": True, "answer": ""}
+
+    return _finalize_candidate(
+        cand_norm,
+        provider=provider,
+        model=model,
+        variant_id=variant_id,
+        sample_id=1,
+        dimension=dimension,
+    )
+
+
+def refine_candidate(
+    candidate: Dict[str, Any],
+    client,
+    model: str,
+    dimension: str,
+    proposal_context: str,
+    provider: str,
+    max_tokens: int = 600,
+) -> Dict[str, Any]:
+    try:
+        rp = build_refine_prompt(candidate, proposal_context, dimension)
+        txt = _chat_completion_json(
+            client,
+            model,
+            SYSTEM_CN,
+            rp,
+            max_tokens=max_tokens,
+            temperature=0.2,
+            force_json=provider_caps(provider)["json_mode"],
+        )
+        obj = _safe_parse_json_plus(txt)
+        if isinstance(obj, dict):
+            cand_norm = _normalize_candidate_obj(obj)
+            if not _validate_candidate_dict(cand_norm):
+                return candidate
+            return _finalize_candidate(
+                cand_norm,
+                provider=candidate.get("provider", provider),
+                model=candidate.get("model", model),
+                variant_id=candidate.get("variant_id", "default"),
+                sample_id=candidate.get("sample_id", 1),
+                dimension=dimension,
+            )
+        return candidate
+    except Exception:
+        return candidate
+
+
+# ========== 维度级问答 ==========
+def print_dim_banner(provider_name: str, dim: str, total: int, mode: str):
+    bar = "=" * 12
+    print(f"\n{bar} [{provider_name}] 维度：{dim} | 题目数：{total} | 模式：{mode} {bar}", flush=True)
+
+
+def print_q_progress(provider_name: str, dim: str, idx: int, total: int, qtext: str):
+    preview = qtext.strip().replace("\n", " ")
+    if len(preview) > 80:
+        preview = preview[:80] + "..."
+    print(f"[{provider_name}] ({dim}) Q{idx}/{total} ▶ {preview}", flush=True)
+
+
+def chunked(lst: List[Any], n: int):
+    for i in range(0, len(lst), n):
+        yield i, lst[i : i + n]
+
+
+def answer_dimension(
+    provider: str,
+    client,
+    model_name: str,
+    dim: str,
+    q_list: List[str],
+    proposal_context: str,
+    reg_hints: List[str],
+    refine: bool,
+    group_size: int,
+    max_tokens: int,
+) -> List[Dict[str, Any]]:
+    """
+    返回：list[
+      {
+        "dimension": dim,
+        "q_index": idx,
+        "question": q,
+        "candidates": [candidate_obj, ...]
+      }, ...
+    ]
+    """
+    out_items: List[Dict[str, Any]] = []
+    provider_name = "ChatGPT" if provider == "openai" else "DeepSeek"
+
+    if not q_list:
+        return out_items
+
+    caps = provider_caps(provider)
+    supports_batch = bool(caps.get("batch_ok", True))
+
+    mode = "批量+变体" if supports_batch else "逐题+变体"
+    print_dim_banner(provider_name, dim, len(q_list), mode)
+
+    # 不支持 batch：逐题 × 多变体
+    if not supports_batch:
+        for idx, q in enumerate(q_list, 1):
+            print_q_progress(provider_name, dim, idx, len(q_list), q)
+            raw_cands: List[Dict[str, Any]] = []
+            for v in VARIANTS:
+                cand = ask_model_single(
+                    provider=provider,
+                    client=client,
+                    model=model_name,
+                    dimension=dim,
+                    question=q,
+                    proposal_context=proposal_context,
+                    reg_hints=reg_hints,
+                    variant_id=v,
+                    max_tokens=min(900, max_tokens),
+                )
+                if isinstance(cand, dict) and not cand.get("error") and cand.get("answer", "").strip():
+                    raw_cands.append(cand)
+            cands = dedup_nearby(raw_cands)
+            if refine and cands:
+                cands = [
+                    refine_candidate(
+                        c,
+                        client=client,
+                        model=model_name,
+                        dimension=dim,
+                        proposal_context=proposal_context,
+                        provider=provider,
+                        max_tokens=min(700, max_tokens),
+                    )
+                    for c in cands
+                ]
+            for c in cands:
+                c["dimension"] = dim
+                c["q_index"] = idx
+
+            out_items.append(
+                {
+                    "dimension": dim,
+                    "q_index": idx,
+                    "question": q,
+                    "candidates": cands,
+                }
+            )
+        return out_items
+
+    # 支持 batch：按 group_size 分批 + 变体
+    group_size = max(1, min(int(group_size), 4))
+    for start_idx, sub_qs in chunked(q_list, group_size):
+        batch_tag = f"{start_idx+1}-{start_idx+len(sub_qs)}"
+        per_variant_results: Dict[str, List[Dict[str, Any]]] = {}
+        batch_failed = False
+
+        for v in VARIANTS:
+            t0 = time.time()
+            arr = ask_model_batch(
+                provider=provider,
+                client=client,
+                model=model_name,
+                dimension=dim,
+                q_list=sub_qs,
+                proposal_context=proposal_context,
+                reg_hints=reg_hints,
+                variant_id=v,
+                max_tokens=max_tokens,
+            )
+            ok = bool(arr) and len(arr) == len(sub_qs)
+            print(
+                f"[{provider_name}] ({dim}) 小批 {batch_tag} · {v:<13} 返回 {len(arr)}/{len(sub_qs)} 条，用时 {time.time()-t0:.1f}s（{'OK' if ok else 'FAIL→逐题'}）"
+            )
+            if not ok:
+                batch_failed = True
+                break
+            per_variant_results[v] = arr
+
+        if not batch_failed:
+            # 合成每题的 candidates
+            for j, q in enumerate(sub_qs, 1):
+                global_idx = start_idx + j
+                raw_cands = [per_variant_results[v][j - 1] for v in VARIANTS]
+                cands = [c for c in raw_cands if isinstance(c, dict) and c.get("answer", "").strip()]
+                cands = dedup_nearby(cands)
+                if refine and cands:
+                    cands = [
+                        refine_candidate(
+                            c,
+                            client=client,
+                            model=model_name,
+                            dimension=dim,
+                            proposal_context=proposal_context,
+                            provider=provider,
+                            max_tokens=min(700, max_tokens),
+                        )
+                        for c in cands
+                    ]
+                for c in cands:
+                    c["dimension"] = dim
+                    c["q_index"] = global_idx
+                out_items.append(
+                    {
+                        "dimension": dim,
+                        "q_index": global_idx,
+                        "question": q,
+                        "candidates": cands,
+                    }
+                )
+            continue
+
+        # 批量失败：这一小批改逐题
+        for j, q in enumerate(sub_qs, 1):
+            global_idx = start_idx + j
+            print_q_progress(provider_name, dim, global_idx, len(q_list), q)
+            raw_cands: List[Dict[str, Any]] = []
+            for v in VARIANTS:
+                cand = ask_model_single(
+                    provider=provider,
+                    client=client,
+                    model=model_name,
+                    dimension=dim,
+                    question=q,
+                    proposal_context=proposal_context,
+                    reg_hints=reg_hints,
+                    variant_id=v,
+                    max_tokens=min(900, max_tokens),
+                )
+                if isinstance(cand, dict) and not cand.get("error") and cand.get("answer", "").strip():
+                    raw_cands.append(cand)
+            cands = dedup_nearby(raw_cands)
+            if refine and cands:
+                cands = [
+                    refine_candidate(
+                        c,
+                        client=client,
+                        model=model_name,
+                        dimension=dim,
+                        proposal_context=proposal_context,
+                        provider=provider,
+                        max_tokens=min(700, max_tokens),
+                    )
+                    for c in cands
+                ]
+            for c in cands:
+                c["dimension"] = dim
+                c["q_index"] = global_idx
+            out_items.append(
+                {
+                    "dimension": dim,
+                    "q_index": global_idx,
+                    "question": q,
+                    "candidates": cands,
+                }
+            )
+
+    return out_items
+
+
+# ========== 多模型合并 ==========
+def merge_two_models(chatgpt_items: List[Dict[str, Any]], deepseek_items: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    def key_of(x: Dict[str, Any]):
+        return (x["dimension"], x["q_index"], x["question"])
+
+    pool: Dict[Any, Dict[str, Any]] = {}
+    for it in chatgpt_items:
+        pool[key_of(it)] = {
+            "dimension": it["dimension"],
+            "q_index": it["q_index"],
+            "question": it["question"],
+            "candidates": list(it.get("candidates", [])),
+        }
+    for it in deepseek_items:
+        k = key_of(it)
+        if k in pool:
+            pool[k]["candidates"].extend(it.get("candidates", []))
+        else:
+            pool[k] = {
+                "dimension": it["dimension"],
+                "q_index": it["q_index"],
+                "question": it["question"],
+                "candidates": list(it.get("candidates", [])),
+            }
+
+    items = list(pool.values())
+    items.sort(
+        key=lambda x: (
+            DIM_ORDER.index(x["dimension"]) if x["dimension"] in DIM_ORDER else 99,
+            x["q_index"],
+        )
+    )
+    return items
+
+
+# ========== CLI ==========
+def parse_args():
+    ap = argparse.ArgumentParser(
+        description="Proposal-aware Dual-LLM Answering (ChatGPT + DeepSeek, no web search, dimension-facts aware)"
+    )
+    ap.add_argument(
+        "--proposal-id",
+        type=str,
+        default="",
+        help="指定提案 ID；不填则自动检测 data/extracted 最近目录名",
+    )
+    ap.add_argument(
+        "--qs-file",
+        type=str,
+        default=str(CONFIG_QS_DEFAULT),
+        help="问题集 JSON 路径（通常由 generate_questions.py 生成）",
+    )
+    ap.add_argument(
+        "--dim-file",
+        type=str,
+        default="",
+        help="维度 JSON 路径；默认使用 data/extracted/{pid}/dimensions_v2.json",
+    )
+    ap.add_argument(
+        "--refine",
+        type=int,
+        default=1,
+        help="是否进行轻量自我复核（0/1）",
+    )
+    ap.add_argument(
+        "--max_tokens",
+        type=int,
+        default=2200,
+    )
+    ap.add_argument(
+        "--group-size",
+        type=int,
+        default=3,
+        help="每批问题数（支持 batch 的模型才生效，建议 2–4）",
+    )
+    ap.add_argument(
+        "--seed",
+        type=int,
+        default=None,
+    )
+    return ap.parse_args()
+
+
+def main():
+    args = parse_args()
+    if args.seed is not None:
+        try:
+            random.seed(int(args.seed))
+        except Exception:
+            pass
+
+    pid = args.proposal_id.strip() or detect_latest_pid()
+    if pid == "unknown":
+        print("⚠️ 未检测到 data/extracted 下的提案目录，将使用占位 pid=unknown。")
+    print(f"🧩 proposal_id = {pid}")
+
+    qs_path = Path(args.qs_file)
+    if not qs_path.exists():
+        raise FileNotFoundError(f"未找到问题集：{qs_path}")
+    qs_cfg = read_json(qs_path)
+
+    missing = [d for d in DIM_ORDER if not get_q_list(qs_cfg.get(d, []))]
+    if missing:
+        raise RuntimeError(
+            f"问题集缺少维度或该维度题目为空：{missing}（请检查 {qs_path} 或 generate_questions.py 输出）"
+        )
+
+    # ========= 维度上下文：固定读取 extracted/{pid}/dimensions_v2.json =========
+    if args.dim_file.strip():
+        dim_file = Path(args.dim_file.strip())
+    else:
+        dim_file = EXTRACTED_DIR / pid / "dimensions_v2.json"
+
+    if not dim_file.exists():
+        raise FileNotFoundError(
+            f"未找到维度文件：{dim_file} ；请先运行 build_dimensions_from_facts.py 生成 dimensions_v2.json"
+        )
+
+    print(f"📄 使用维度上下文文件：{dim_file}")
+    dim_context_map = load_dimension_context(pid, dim_file)
+
+    domain_profile = load_domain_profile(EXTRACTED_DIR / pid / "domain_profile.json")
+
+    reg_hints_map: Dict[str, List[str]] = {}
+    terminology = domain_profile.get("terminology", []) if isinstance(domain_profile, dict) else []
+    methods = domain_profile.get("methods", []) if isinstance(domain_profile, dict) else []
+    risks = domain_profile.get("risks", []) if isinstance(domain_profile, dict) else []
+    domain_hints = [*terminology[:4], *methods[:2], *risks[:2]]
+    for dim in DIM_ORDER:
+        reg_hints_map[dim] = _load_reg_hints(qs_cfg, dim, limit=8)
+        reg_hints_map[dim] = list(dict.fromkeys(reg_hints_map[dim] + domain_hints))[:8]
+
+    oa_client, oa_model = init_openai()
+    ds_client, ds_model = init_deepseek()
+    if (oa_client is None or oa_model is None) and (ds_client is None or ds_model is None):
+        raise RuntimeError("未检测到可用模型：请在 .env 配置 OPENAI_API_KEY 与/或 DEEPSEEK_API_KEY。")
+
+    dims = DIM_ORDER[:]
+    chatgpt_items_all: List[Dict[str, Any]] = []
+    deepseek_items_all: List[Dict[str, Any]] = []
+
+    # ChatGPT
+    if oa_client and oa_model:
+        print("🧠 ChatGPT 答题中 ...")
+        for dim in dims:
+            q_list = get_q_list(qs_cfg.get(dim, []))
+            ctx = dim_context_map.get(dim, "")
+            reg_hints = reg_hints_map.get(dim, [])
+            items = answer_dimension(
+                provider="openai",
+                client=oa_client,
+                model_name=oa_model,
+                dim=dim,
+                q_list=q_list,
+                proposal_context=ctx,
+                reg_hints=reg_hints,
+                refine=bool(args.refine),
+                group_size=int(args.group_size),
+                max_tokens=int(args.max_tokens),
+            )
+            chatgpt_items_all.extend(items)
+
+        out_path = OUT_REFINED / pid / "chatgpt_raw.json"
+        write_json(
+            out_path,
+            {
+                "meta": {
+                    "model": oa_model,
+                    "provider": "openai",
+                    "generated_at": now_str(),
+                    "pid": pid,
+                },
+                "items": chatgpt_items_all,
+            },
+        )
+        print(f"✅ ChatGPT 结果 -> {out_path}")
+    else:
+        print("⚠️ 跳过 ChatGPT：未配置 OPENAI_API_KEY。")
+
+    # DeepSeek
+    if ds_client and ds_model:
+        print("🧠 DeepSeek 答题中 ...")
+        for dim in dims:
+            q_list = get_q_list(qs_cfg.get(dim, []))
+            ctx = dim_context_map.get(dim, "")
+            reg_hints = reg_hints_map.get(dim, [])
+            items = answer_dimension(
+                provider="deepseek",
+                client=ds_client,
+                model_name=ds_model,
+                dim=dim,
+                q_list=q_list,
+                proposal_context=ctx,
+                reg_hints=reg_hints,
+                refine=bool(args.refine),
+                group_size=int(args.group_size),
+                max_tokens=int(args.max_tokens),
+            )
+            deepseek_items_all.extend(items)
+
+        out_path = OUT_REFINED / pid / "deepseek_raw.json"
+        write_json(
+            out_path,
+            {
+                "meta": {
+                    "model": ds_model,
+                    "provider": "deepseek",
+                    "generated_at": now_str(),
+                    "pid": pid,
+                },
+                "items": deepseek_items_all,
+            },
+        )
+        print(f"✅ DeepSeek 结果 -> {out_path}")
+    else:
+        print("⚠️ 跳过 DeepSeek：未配置 DEEPSEEK_API_KEY。")
+
+    merged_items = merge_two_models(chatgpt_items_all, deepseek_items_all)
+    merged = {
+        "meta": {
+            "pid": pid,
+            "generated_at": now_str(),
+            "schema": "refined_items.v2.proposal_aware_with_general_insights",
+            "args": {
+                "refine": bool(args.refine),
+                "max_tokens": int(args.max_tokens),
+                "group_size": int(args.group_size),
+            },
+            "models": {
+                "chatgpt": {"model": oa_model, "provider": "openai"} if chatgpt_items_all else None,
+                "deepseek": {"model": ds_model, "provider": "deepseek"} if deepseek_items_all else None,
+            },
+        },
+        "items": merged_items,
+    }
+    out_path = OUT_REFINED / pid / "all_refined_items.json"
+    write_json(out_path, merged)
+    print(f"📦 合并结果 -> {out_path}")
+    print("🎯 完成。")
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

src/tools/metric_checker.py

@@ -0,0 +1,218 @@
+# -*- coding: utf-8 -*-
+from __future__ import annotations
+
+import re
+from collections import Counter
+from typing import Any, Dict, List, Sequence
+
+
+def _clean_text(text: str) -> str:
+    return re.sub(r"\s+", " ", text or "").strip()
+
+
+def _unique_keep_order(items: List[str], max_items: int = 20) -> List[str]:
+    seen = set()
+    out = []
+    for item in items:
+        key = item.strip().lower()
+        if not key or key in seen:
+            continue
+        seen.add(key)
+        out.append(item.strip())
+        if len(out) >= max_items:
+            break
+    return out
+
+
+def extract_numeric_spans(text: str) -> List[str]:
+    """
+    Extract common quantitative expressions from proposal text.
+    Covers:
+    - integers / decimals
+    - percentages
+    - money / financing
+    - years / year-ranges
+    - count-like targets
+    """
+    text = _clean_text(text)
+
+    patterns = [
+        r"\d+(?:\.\d+)?%",                         # 50%
+        r"\d+(?:\.\d+)?\s*%",                     # 50 %
+        r"\d+(?:\.\d+)?万",                       # 5500万
+        r"\d+(?:\.\d+)?亿",                       # 3亿
+        r"\d+(?:\.\d+)?万元",                     # 500万元
+        r"\d+(?:\.\d+)?亿元",                     # 3亿元
+        r"\d{4}\s*[-–—]\s*\d{4}",                 # 2018-2020
+        r"\d{4}年(?:\d{1,2}月)?",                 # 2019年 / 2019年10月
+        r"第[一二三四五六七八九十0-9]+年",          # 第一年
+        r"\d+(?:\.\d+)?倍",                       # 2倍
+        r"\d+(?:\.\d+)?种",                       # 20种
+        r"\d+(?:\.\d+)?个",                       # 4个
+        r"\d+(?:\.\d+)?项",                       # 70项
+        r"\d+(?:\.\d+)?辆",                       # 5万辆
+        r"\d+(?:\.\d+)?家",                       # 10家
+        r"\d+(?:\.\d+)?台",                       # 3台
+        r"\d+(?:\.\d+)?套",                       # 4套
+        r"\d+(?:\.\d+)?人",                       # 20人
+        r"\d+(?:\.\d+)?次",                       # 3次
+        r"\d+(?:\.\d+)?(?:\.\d+)?",              # fallback numbers
+    ]
+
+    spans: List[str] = []
+    for pat in patterns:
+        spans.extend(re.findall(pat, text))
+
+    return _unique_keep_order(spans, max_items=40)
+
+
+def detect_metric_signals(text: str) -> Dict[str, Any]:
+    """
+    Detect whether the document contains useful measurable evidence.
+    """
+    text = _clean_text(text)
+    lower = text.lower()
+
+    numeric_spans = extract_numeric_spans(text)
+
+    signal_patterns = {
+        "has_numbers": r"\d",
+        "has_money": r"(融资|预算|资金|投入|销售额|利润|成本|收入|亿元?|万元?|million|billion|revenue|profit|cost)",
+        "has_timeline": r"(20\d{2}|timeline|roadmap|阶段|起步|腾飞|验证|年|月)",
+        "has_percentages": r"\d+(?:\.\d+)?\s*%",
+        "has_targets": r"(目标|达到|覆盖|完成|形成|实现|sales|target|milestone|deliverable)",
+        "has_benchmark_terms": r"(领先|首个|第一|benchmark|sota|state of the art|对比|优于|提升)",
+        "has_validation_terms": r"(验证|测试|试验|仿真|实验|prototype|validation|test|pilot)",
+        "has_financial_table_terms": r"(销售额|利润|成本|投入|融资计划|财务预测|现金流|revenue|profit|cost)",
+        "has_scale_terms": r"(规模化|场景|覆盖|批量|市场占有率|用户数|deployment|adoption|scale)",
+    }
+
+    flags = {name: bool(re.search(pattern, text, flags=re.IGNORECASE)) for name, pattern in signal_patterns.items()}
+
+    score = 0
+    score += 2 if flags["has_numbers"] else 0
+    score += 1 if flags["has_money"] else 0
+    score += 1 if flags["has_timeline"] else 0
+    score += 1 if flags["has_percentages"] else 0
+    score += 1 if flags["has_targets"] else 0
+    score += 1 if flags["has_benchmark_terms"] else 0
+    score += 1 if flags["has_validation_terms"] else 0
+    score += 1 if flags["has_financial_table_terms"] else 0
+    score += 1 if flags["has_scale_terms"] else 0
+
+    if score >= 8:
+        evidence_level = "strong"
+    elif score >= 5:
+        evidence_level = "moderate"
+    else:
+        evidence_level = "weak"
+
+    missing = []
+    if not flags["has_numbers"]:
+        missing.append("no explicit numeric evidence")
+    if not flags["has_targets"]:
+        missing.append("no clear measurable targets")
+    if not flags["has_timeline"]:
+        missing.append("no clear timeline or milestone evidence")
+    if not flags["has_validation_terms"]:
+        missing.append("no explicit validation or testing evidence")
+
+    return {
+        "flags": flags,
+        "numeric_spans": numeric_spans[:30],
+        "numeric_count": len(numeric_spans),
+        "evidence_level": evidence_level,
+        "missing_metric_signals": missing,
+    }
+
+
+def detect_possible_numeric_conflicts(text: str) -> List[Dict[str, Any]]:
+    """
+    Lightweight conflict detector.
+    It does not prove contradictions mathematically,
+    but surfaces repeated metric categories with divergent values.
+    """
+    text = _clean_text(text)
+
+    categories = {
+        "financing": r"(\d+(?:\.\d+)?(?:万|亿|万元|亿元))",
+        "scenarios": r"(\d+(?:\.\d+)?种(?:以上)?应用场景)",
+        "sales": r"(预计年销售额\s*\d+(?:\.\d+)?)",
+        "profit": r"(预计年利润\s*-?\d+(?:\.\d+)?)",
+        "years": r"(20\d{2}\s*[-–—]\s*\d{4}|20\d{2}年(?:\d{1,2}月)?)",
+    }
+
+    conflicts: List[Dict[str, Any]] = []
+
+    for category, pattern in categories.items():
+        matches = re.findall(pattern, text)
+        uniq = _unique_keep_order(matches, max_items=10)
+        if len(uniq) >= 3:
+            conflicts.append({
+                "category": category,
+                "values": uniq,
+                "note": "multiple values detected; review for consistency",
+            })
+
+    return conflicts
+
+
+def build_metric_report(full_text: str, pages: Sequence[Dict[str, Any]]) -> Dict[str, Any]:
+    """
+    Stage 1.5 output artifact.
+    """
+    text = _clean_text(full_text)
+    metric_signals = detect_metric_signals(text)
+    conflicts = detect_possible_numeric_conflicts(text)
+
+    page_hits = []
+    for page in pages:
+        page_text = _clean_text(page.get("text", ""))
+        page_metrics = extract_numeric_spans(page_text)
+        if page_metrics:
+            page_hits.append({
+                "page_index": int(page.get("page_index", -1)),
+                "metric_count": len(page_metrics),
+                "sample_metrics": page_metrics[:8],
+            })
+
+    page_hits = sorted(page_hits, key=lambda x: x["metric_count"], reverse=True)[:8]
+
+    return {
+        "stage": "1.5_metric_checker",
+        "metric_signals": metric_signals,
+        "possible_conflicts": conflicts,
+        "top_metric_pages": page_hits,
+    }
+
+
+def build_metric_prompt_suffix(metric_report: Dict[str, Any]) -> str:
+    """
+    Convert metric detection result into prompt guidance for downstream review.
+    """
+    signals = metric_report.get("metric_signals", {})
+    flags = signals.get("flags", {})
+    evidence_level = signals.get("evidence_level", "weak")
+    missing = signals.get("missing_metric_signals", [])
+    numeric_spans = signals.get("numeric_spans", [])[:10]
+    conflicts = metric_report.get("possible_conflicts", [])
+
+    lines = []
+    lines.append("Metric-check guidance:")
+    lines.append(f"- Quantitative evidence level: {evidence_level}.")
+    lines.append(f"- Numeric evidence detected: {'yes' if flags.get('has_numbers') else 'no'}.")
+    lines.append(f"- Timeline evidence detected: {'yes' if flags.get('has_timeline') else 'no'}.")
+    lines.append(f"- Validation evidence detected: {'yes' if flags.get('has_validation_terms') else 'no'}.")
+    lines.append(f"- Financial evidence detected: {'yes' if flags.get('has_money') else 'no'}.")
+
+    if numeric_spans:
+        lines.append(f"- Example metric spans: {'; '.join(numeric_spans)}.")
+
+    if missing:
+        lines.append(f"- Missing metric signals: {'; '.join(missing)}.")
+        lines.append("- If a dimension relies on quantitative justification but explicit metrics are missing, mention this clearly as a limitation.")
+
+    if conflicts:
+        lines.append("- Possible numeric consistency issues were detected; review repeated values carefully before making strong claims.")
+
+    return " ".join(lines)

src/tools/post_processing.py

@@ -0,0 +1,1595 @@
+# -*- coding: utf-8 -*-
+"""
+post_processing.py · Structured Candidate Post-Processing (v3.2 · no-web-hard-gates)
+
+适配新版 llm_answering 输出：
+  - 期望输入 schema: "llm_answering.v2" 或 "refined_items.v2.proposal_aware_with_general_insights"
+  - 顶层结构：{"meta": {...}, "items": [ {dimension, q_index, question, candidates: [...]}, ... ]}
+
+输出：
+  - src/data/refined_answers/<pid>/postproc/metrics.json
+  - src/data/refined_answers/<pid>/postproc/selected_by_question.json
+  - src/data/refined_answers/<pid>/postproc/final_payload.json
+  - src/data/refined_answers/<pid>/postproc/report.md
+  - src/data/refined_answers/<pid>/postproc/drops_debug.json
+"""
+
+import os
+import re
+import json
+import math
+import string
+import argparse
+from pathlib import Path
+from datetime import datetime
+from collections import defaultdict, Counter
+from functools import lru_cache
+import re as _re
+
+# ============================ 路径与默认 ============================
+
+ROOT = Path(__file__).resolve().parents[1]  # .../src
+DATA_DIR = ROOT / "data"
+REFINED_ROOT = DATA_DIR / "refined_answers"
+CONF_DIR = DATA_DIR / "config" / "postproc"
+QS_CONF_PATH = DATA_DIR / "config" / "question_sets" / "generated_questions.json"
+
+# —— 与 answering 对齐的权威词表（多辖区/标准） ——
+# ⚠️ 已移除 "hc"，避免把普通文本误计为 Health Canada；保留 "health canada"
+AUTHORITY_TOKENS = [
+    "fda","ema","ich q8","ich q9","ich q10","21 cfr part 11",
+    "iso 13485","iso 14971","iso 27001","who","gamp5","gamp 5", "pic/s",
+    "clinicaltrials.gov","eudract","nct","doi","orcid","pubmed","scopus",
+    "uspto","epo","cnipa",
+    # 多辖区/缩写
+    "nmpa","cfda","mhra","pmda","tga","health canada","nice",
+    "eudralex","mdr","ivdr",
+    "iec 62304","iec 62366","iso 62304","iso 62366",
+    "gcp","gmp","glp","gxp",
+    # 隐私/安全/合规
+    "gdpr","hipaa","phipa","pipeda","nist","soc 2","iso 27017","iso 27018"
+]
+
+COVERAGE_BANK = {
+    "regulatory": ["fda","ema","ich","21 cfr","iso","pic/s","gmp","gcp","glp","gxp",
+                   "nmpa","mhra","pmda","tga","health canada","mdr","ivdr",
+                   "gdpr","pipeda","phipa","hipaa","nist","soc 2","iso 27017","iso 27018"],
+    "trial": ["clinicaltrials.gov","eudract","nct"],
+    "publication": ["pubmed","scopus","doi","orcid"],
+    "patent": ["uspto","epo","cnipa","wo"],
+    "repo": ["github","gitlab","model card","data card"]
+}
+
+# === BEGIN PATCH · alias + tokenizer ===
+# 压缩串 → 标准空格写法（用于 21CFRPart11 / ISO13485 / ICHQ10 等）
+ALIAS_MAP = {
+    # 法规/标准归一
+    "21cfrpart11": "21 cfr part 11",
+    "21cfr11": "21 cfr part 11",
+    "iso13485": "iso 13485",
+    "iso14971": "iso 14971",
+    "iso27001": "iso 27001",
+    "iso27017": "iso 27017",
+    "iso27018": "iso 27018",
+    "iec62304": "iec 62304",
+    "iec62366": "iec 62366",
+    "gamp5": "gamp 5",
+    "ichq8": "ich q8",
+    "ichq9": "ich q9",
+    "ichq10": "ich q10",
+    "pics": "pic/s",
+
+    # 站点/域名归一
+    "clinicaltrialsgov": "clinicaltrials gov",
+}
+
+# 对齐加权：权威 token 给更高权重
+AUTHORITY_KEYWORDS = {
+    "fda": 2.0, "ema": 2.0, "ich": 2.0, "q8": 1.4, "q9": 1.4, "q10": 1.6,
+    "iso": 2.0, "13485": 2.0, "14971": 2.0, "27001": 1.6, "27017": 1.4, "27018": 1.4,
+    "21": 1.1, "cfr": 2.0, "part": 1.1, "11": 1.1,
+    "clinicaltrials": 2.0, "gov": 1.0, "eudract": 2.0,
+    "pubmed": 2.0, "scopus": 2.0, "orcid": 1.5,
+    "uspto": 2.0, "epo": 2.0, "cnipa": 2.0,
+    "gdpr": 2.0, "hipaa": 2.0, "phipa": 2.0, "pipeda": 2.0,
+    "gxp": 1.4, "gmp": 1.4, "glp": 1.4, "gcp": 1.4, "doi": 1.4,
+}
+
+# ==== 中文高权词（权重可按需微调）====
+AUTHORITY_KEYWORDS_ZH = {
+    "国家药监局": 2.0, "药监局": 1.8, "药监": 1.6, "nmpa": 2.0,
+    "注册": 1.6, "临床": 1.6, "注册号": 1.6, "备案": 1.2,
+    "发表": 1.4, "论文": 1.6, "期刊": 1.4, "doi": 1.6, "pubmed": 2.0,
+    "专利": 1.8, "发明专利": 2.0, "uspto": 2.0, "epo": 2.0, "cnipa": 2.0,
+    "合规": 1.6, "隐私": 1.4, "安全": 1.4, "gxp": 1.4, "gmp": 1.4, "gcp": 1.4, "glp": 1.4,
+    "上市": 1.6, "量产": 1.4, "认证": 1.4, "iso": 2.0, "iec": 1.6,
+    "药品审评中心": 1.8, "cde": 1.6, "卫健委": 1.4, "nhc": 1.4,
+    "注册证": 1.6, "批准文号": 1.6, "临床试验登记": 1.6
+}
+
+STOPWORDS_ALIGN = {
+    "the","and","of","to","for","in","on","by","with","a","an","is","are",
+    "及","与","的","和","在","对","为","以及"
+}
+
+_RE_NON_ALNUM = _re.compile(r"[^a-z0-9]+", _re.IGNORECASE)
+
+def _apply_aliases(s: str) -> str:
+    """统一空格/点号，做数字↔字母断词，并用 ALIAS_MAP 展开压缩串。"""
+    if not s:
+        return ""
+    base = str(s).lower()
+    base = base.replace("\u00a0", " ").replace("\u3000", " ")
+
+    # 先生成去标点“紧凑串”做 alias 命中
+    compact = _RE_NON_ALNUM.sub("", base)
+    if compact in ALIAS_MAP:
+        base = ALIAS_MAP[compact]
+
+    # 数字-字母边界���空格：21CFRPart11 -> 21 CFR Part 11
+    base = _re.sub(r"([a-z])([0-9])", r"\1 \2", base)
+    base = _re.sub(r"([0-9])([a-z])", r"\1 \2", base)
+
+    # ICHQ10 → ich q10（兜底）
+    base = _re.sub(r"\b(ich)\s*q\s*(\d+)\b", r"\1 q\2", base)
+    # clinicaltrials.gov → clinicaltrials gov
+    base = base.replace("clinicaltrials.gov", "clinicaltrials gov")
+    return base
+
+def _tokens_for_alignment(s: str):
+    r"""切出 [a-z]+ / \d+ / 中文块 词元，并构造 bigrams。"""
+    if not s:
+        return set(), set()
+    s = _apply_aliases(s)
+
+    # 保留原有：把非字母数字替换为空格（英文/数字通道）
+    s_en = _RE_NON_ALNUM.sub(" ", s)
+
+    # 英文/数字 token
+    toks_en = [t for t in _re.findall(r"[a-z]+|\d+", s_en) if t not in STOPWORDS_ALIGN]
+
+    # —— 中文通道：直接抽取连续的中日韩统一表意文字（至少两个字避免噪音）——
+    toks_zh = _re.findall(r"[\u4e00-\u9fff]{2,}", s)
+
+    # 合并
+    toks = toks_en + toks_zh
+
+    unigrams = set(toks)
+    bigrams = set()
+    for i in range(len(toks)-1):
+        bigrams.add(toks[i] + " " + toks[i+1])
+    return unigrams, bigrams
+
+
+def _weighted_overlap(q_uni, q_bi, c_uni, c_bi):
+    """基于问题/提示 tokens 与候选 tokens 的带权重重合度，bigrams 轻度加成。"""
+    if not q_uni:
+        return 0.0
+
+    def w(t):
+        # 既支持英文权重，也支持中文高权词
+        if t in AUTHORITY_KEYWORDS:
+            return AUTHORITY_KEYWORDS[t]
+        if t in AUTHORITY_KEYWORDS_ZH:
+            return AUTHORITY_KEYWORDS_ZH[t]
+        return 1.0
+
+    den = sum(w(t) for t in q_uni)
+    hit = sum(w(t) for t in (q_uni & c_uni))
+    bonus = 0.0
+    if q_bi and c_bi:
+        bi_hit = len(q_bi & c_bi)
+        bonus = min(0.30, 0.10 * bi_hit)
+    return min(1.0, (hit / max(1e-9, den)) * (1.0 + bonus))
+# === END PATCH ===
+
+
+DEFAULT_CONF = {
+    # ========= 题内标准化参数 =========
+    "length_ref_chars": 280,
+    "claims_ref": 3,
+    "evidence_ref": 4,
+    "jaccard_threshold": 0.30,
+
+    # ========= 权重配置 =========
+    # 说明：在“无 web 检索”模式下，evidence/authority/coverage 不再参与主评分
+    # 👉 降低一致性权重，增加“对齐 + claims”的权重，让强维度更容易拉开
+    "consistency_weight": 0.10,
+    "fields_weight": {
+        "length": 0.18,              # 原 0.20
+        "claims": 0.27,              # 原 0.25（多写要点的题更拉分）
+        "evidence_count": 0.0,
+        "evidence_authority": 0.0,
+        "evidence_coverage": 0.0,
+        "structure": 0.20,
+        "alignment": 0.30,           # 原 0.25（更看重和问题/维度的贴合度）
+        "calibrated_confidence": 0.05  # 原 0.10（置信度稍微降一点）
+    },
+
+    # ========= 维度权重 =========
+    "dimension_weight": {
+        "team": 1.00,
+        "objectives": 1.00,
+        "strategy": 1.00,
+        "innovation": 1.10,
+        "feasibility": 1.20
+    },
+
+    # ========= 扣分项 =========
+    # 👉 所有 penalty 稍微变“软”一点，避免把分数全往 0.4 附近压扁
+    "penalties": {
+        "contradiction": 0.05,      # 原 0.08
+        "overclaim": 0.03,          # 原 0.05
+        "understructure": 0.03,     # 原 0.05
+        "redline_residual": 0.06,   # 原 0.08
+        "dimension_drift": 0.04     # 原 0.06
+    },
+
+    # ========= 过滤阈值（支持软窗口） =========
+    # 注：权威/覆盖相关阈值只保留作兼容字段，不再触发硬过滤
+    "filters": {
+        # 证据相关：不再做硬门槛，仅统计
+        "min_evidence_count": 0,
+
+        # 基础结构要求
+        "min_bullet_lines": 3,
+        "min_median_bullet_len": 6,
+        "min_structured_score": 0.05,
+        "soft_window": True,
+
+        # 对齐阈值：仅用于过滤严重跑题的垃圾回答
+        "min_alignment_for_keep": 0.10,
+
+        # 兼容字段（不再参与过滤）
+        "min_auth_hits_for_keep": 0,
+        "min_coverage_bins_for_keep": 0,
+        "min_authority_ratio": 0.0,
+        "min_coverage_ratio": 0.0,
+        "dyn_align_relax_trigger": 0.0,
+        "dyn_align_relax_delta": 0.0
+    },
+
+    # ========= 一致性修正参数 =========
+    "consistency_correction": {
+        "k_contradiction": 0.15,
+        "beta": {
+            "jaccard_sweetspot": [0.25, 0.65],
+            "provider_calibration": {
+                "deepseek": {"beta_delta": -0.01},
+                "openai":   {"beta_delta":  0.00},
+                "default":  {"beta_delta":  0.00}
+            }
+        }
+    },
+
+    # ========= 维度差异化放宽（仅过滤时用） =========
+    "dimension_specific": {
+        "objectives": {"min_bullet_lines": 3, "min_alignment_for_keep": 0.18},
+        "strategy":   {"min_bullet_lines": 3, "min_alignment_for_keep": 0.24},
+        "innovation": {"min_bullet_lines": 3, "min_alignment_for_keep": 0.18},
+        "feasibility":{"min_bullet_lines": 3, "min_alignment_for_keep": 0.12}
+    },
+
+    # ========= 报告输出 =========
+    "bar_symbols": 20,
+    "adv_topk": 5,
+    "report_width": 92,
+    "unknown_warn_ratio": 0.10
+}
+
+PUNC = set(string.punctuation + "，。；：！？、（）【】《》…—-·")
+DIM_ORDER = ["team", "objectives", "strategy", "innovation", "feasibility"]
+
+RE_DATE   = re.compile(r"\b(20\d{2}|19\d{2})([-/.]|年)\d{1,2}([-/\.日]|月)\d{1,2}\b|\b(Q[1-4]\s*-\s*20\d{2})\b", re.I)
+RE_MONEY  = re.compile(r"\b(\$|USD|EUR|CNY|RMB|CAD)\s*\d{2,}(,\d{3})*(\.\d+)?\b|\b\d+(\.\d+)?\s*(million|billion|万|亿)\b", re.I)
+RE_TRIAL  = re.compile(r"\bNCT\d{8}\b|\bEUCTR-\d{4}-\d{6}-\d{2}\b", re.I)
+RE_DOI    = re.compile(r"\b10\.\d{4,9}/[-._;()/:A-Z0-9]+\b", re.I)
+RE_PATENT = re.compile(r"\b(US|EP|CN)\d{5,}\b|\bWO\d{7,}\b", re.I)
+RE_ISO    = re.compile(r"\b(ISO|IEC)\s?\d{4,5}(-\d+)?\b", re.I)  # 兼容 IEC
+RE_STDNUM = re.compile(r"\bEN\s?\d{3,5}\b|\bASTM\s?[A-Z]?\d{2,5}\b", re.I)
+RE_ID_ANY = re.compile(r"(注册号|登记号|批准文号|备案号)", re.I)
+
+# ====== 行清洗与软拼接 ======
+
+DOMAIN_FIXES = [
+    (re.compile(r"clinicaltrials\s*[\.\-]?\s*(\d+\s*[\.\-]?\s*)?gov", re.I), "ClinicalTrials.gov"),
+    (re.compile(r"eudract\s*[\.\-]?\s*eu", re.I), "EudraCT EU"),
+    (re.compile(r"pubmed\s*[\.\-]?\s*ncbi\s*[\.\-]?\s*nlm\s*[\.\-]?\s*nih\s*[\.\-]?\s*gov", re.I), "PubMed"),
+]
+BULLET_NORM = re.compile(r"^\s*(?:[-*•·■▪︎▶️●]|(\d+)[\.\)]|[（(]?[一二三四五六七八九十][)）.、])\s*")
+
+def _soft_join(text: str) -> str:
+    if not text:
+        return ""
+    s = text
+    s = re.sub(r"(\w)-\n(\w)", r"\1\2", s)
+    s = re.sub(r"([A-Za-z0-9])\n([A-Za-z0-9])", r"\1 \2", s)
+    s = re.sub(r"\s*\.\s*(gov|com|org|net|io)\b", r".\1", s, flags=re.I)
+    for pat, rep in DOMAIN_FIXES:
+        s = pat.sub(rep, s)
+    return s
+
+def _normalize_bullets(text: str) -> str:
+    lines = [ln.rstrip() for ln in (text or "").splitlines()]
+    out = []
+    for ln in lines:
+        base = BULLET_NORM.sub("", ln).strip()
+        if not base:
+            continue
+        out.append(base)
+    return "\n".join(out)
+
+# ========= 两套清洗 =========
+
+def sanitize_for_scoring(raw: str) -> str:
+    s = raw or ""
+    s = _soft_join(s)
+    s = re.sub(r"[ \t]+", " ", s)
+    return s.strip()
+
+def sanitize_for_display(raw: str) -> str:
+    s = raw or ""
+    s = _soft_join(s)
+    s = re.sub(r"[ \t]+", " ", s)
+    s = re.sub(r"\b([A-Za-z])(?:\s+[A-Za-z]){1,3}\b",
+               lambda m: m.group(0).replace(" ", ""), s)
+    s = _normalize_bullets(s)
+    return s.strip()
+
+def sanitize_answer(raw: str) -> str:
+    return sanitize_for_display(raw)
+
+# ====== 占位行检测 ======
+PLACEHOLDER_LINE = re.compile(
+    r"""^(
+        [\-\–—=~\._]{2,}$                      |
+        [\(\)\[\]\{\}]$                        |
+        \d+\s*[\.\)]\s*\d?$                    |
+        (?:原则|区间|示例|条款)(?:\s*/\s*(?:原则|区间))?$ |
+        [A-Za-z]$                              |
+        [\u3000\s]*$
+    )""",
+    re.X
+)
+
+def _placeholder_ratio(cleaned_text: str) -> float:
+    if not cleaned_text:
+        return 1.0
+    lines = [ln.strip() for ln in cleaned_text.splitlines() if ln.strip()]
+    if not lines:
+        return 1.0
+    bad = sum(1 for ln in lines if PLACEHOLDER_LINE.match(ln))
+    return bad / max(1, len(lines))
+
+# ============================ 工具函数（带缓存） ============================
+
+def load_config():
+    cfg_path = CONF_DIR / "config.json"
+    if cfg_path.exists():
+        try:
+            user_cfg = json.loads(cfg_path.read_text(encoding="utf-8"))
+            return _merge_conf(DEFAULT_CONF, user_cfg)
+        except Exception:
+            pass
+    return DEFAULT_CONF
+
+def _merge_conf(base, user):
+    out = dict(base)
+    for k, v in (user or {}).items():
+        if isinstance(v, dict) and isinstance(base.get(k), dict):
+            nv = dict(base[k]); nv.update(v); out[k] = nv
+        else:
+            out[k] = v
+    return out
+
+def now_str():
+    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+def detect_latest_pid() -> str:
+    if not REFINED_ROOT.exists():
+        return ""
+    cands = []
+    for d in REFINED_ROOT.iterdir():
+        if d.is_dir() and (d / "all_refined_items.json").exists():
+            cands.append((d.name, (d / "all_refined_items.json").stat().st_mtime))
+    cands.sort(key=lambda x: x[1], reverse=True)
+    return cands[0][0] if cands else ""
+
+def read_json(p: Path):
+    return json.loads(p.read_text(encoding="utf-8"))
+
+def write_json(p: Path, obj):
+    p.parent.mkdir(parents=True, exist_ok=True)
+    p.write_text(json.dumps(obj, ensure_ascii=False, indent=2), encoding="utf-8")
+
+def norm01(x, lo, hi):
+    """
+    把 x 在线性映射到 [0,1] 之间：
+      - hi <= lo 时直接返回 0
+      - 小于区间下界截到 0，大于上界截到 1
+    """
+    if hi <= lo:
+        return 0.0
+    v = (x - lo) / (hi - lo)
+    if v < 0:
+        return 0.0
+    if v > 1:
+        return 1.0
+    return float(v)
+
+def safe_float(x, default=0.6):
+    try:
+        f = float(x)
+        if math.isnan(f):
+            return default
+        return max(0.0, min(1.0, f))
+    except Exception:
+        return default
+
+@lru_cache(maxsize=8192)
+def _sanitize_cached(raw: str) -> str:
+    return sanitize_for_display(raw)
+
+@lru_cache(maxsize=8192)
+def _word_tokens_cached(text: str):
+    """
+    词级 token：英文/数字用 [a-z0-9]+，中文取连续中日韩统一表意文字（长度≥2）。
+    与语义对齐逻辑保持一致，不做词干化与停用词处理。
+    """
+    s = (sanitize_for_scoring(text) or "").lower()
+    # 英文/数字 token
+    en = re.findall(r"[a-z0-9]+", s)
+    # 中文 token：连续汉字（≥2，降噪；如需更激进可改为 {1,}）
+    zh = re.findall(r"[\u4e00-\u9fff]{2,}", s)
+    return tuple(t for t in en + zh if t)
+
+_tokenize_cached = _word_tokens_cached
+
+def tokenize(text: str):
+    return list(_word_tokens_cached(text))
+
+
+def jaccard(a_tokens, b_tokens):
+    if not a_tokens or not b_tokens:
+        return 0.0
+    A, B = set(a_tokens), set(b_tokens)
+    inter = len(A & B)
+    uni = len(A | B)
+    return inter / uni if uni else 0.0
+
+def looks_structured(ans: str) -> float:
+    cleaned = sanitize_for_scoring(ans)
+    lines = [ln.strip() for ln in (cleaned or "").splitlines() if ln.strip()]
+    if not lines:
+        return 0.0
+    bulletish = re.compile(r"^(\d+[\.\)]\s+|[-*•·■▪︎▶️●]\s+|[（(]?[一二三四五六七八九十][)）.、]\s+|[A-Za-z]\))")
+    bullets = sum(1 for ln in lines if bulletish.match(ln))
+    ratio_b = bullets / max(1, len(lines))
+    shortish = sum(1 for ln in lines if 6 <= len(ln) <= 64)
+    ratio_s = shortish / max(1, len(lines))
+    return max(0.0, min(1.0, 0.4 * ratio_b + 0.6 * ratio_s))
+
+def overclaim_score(ans: str) -> float:
+    terms = ["必须", "保证", "绝对", "完全", "零风险", "一定", "毫无", "不可能出错", "100%"]
+    cnt = sum((ans or "").count(t) for t in terms)
+    length = max(1, len(ans or ""))
+    dens = cnt / length
+    return max(0.0, min(1.0, dens * 200))
+
+def contradiction_pair(a: str, b: str) -> float:
+    neg = ["不", "无", "否", "不可", "禁止", "避免", "不得"]
+    pos = ["可", "能", "允许", "建议", "推荐", "可行", "通过"]
+    a_neg = sum((sanitize_for_scoring(a) or "").count(t) for t in neg)
+    b_neg = sum((sanitize_for_scoring(b) or "").count(t) for t in neg)
+    a_pos = sum((sanitize_for_scoring(a) or "").count(t) for t in pos)
+    b_pos = sum((sanitize_for_scoring(b) or "").count(t) for t in pos)
+    jac = jaccard(_tokenize_cached(sanitize_for_scoring(a)), _tokenize_cached(sanitize_for_scoring(b)))
+    diff = abs((a_pos - a_neg) - (b_pos - b_neg))
+    base = norm01(diff, 0, 20)
+    penal = 1.0 - jac
+    return max(0.0, min(1.0, base * penal))
+
+def bar(value: float, n: int = 20) -> str:
+    n = max(1, n)
+    k = max(0, min(n, int(round(float(value) * n))))
+    return "█" * k + "░" * (n - k)
+
+def authority_ratio(hints: list) -> float:
+    if not hints:
+        return 0.0
+    hits = 0
+    for h in hints:
+        s = (h or "").lower()
+        if any(tok in s for tok in AUTHORITY_TOKENS):
+            hits += 1
+    return hits / max(1, len(hints))
+
+def coverage_score(hints: list) -> float:
+    if not hints:
+        return 0.0
+    cats = set()
+    for h in hints:
+        s = (h or "").lower()
+        for cat, toks in COVERAGE_BANK.items():
+            if any(tok in s for tok in toks):
+                cats.add(cat)
+    return len(cats) / len(COVERAGE_BANK)
+
+def has_redline(text: str) -> bool:
+    t = text or ""
+    return any(p.search(t) for p in (RE_DATE, RE_MONEY, RE_TRIAL, RE_DOI, RE_PATENT, RE_ISO, RE_STDNUM, RE_ID_ANY))
+
+# ============================ 去串味 + 权威导向 ============================
+
+OTHER_DIMS = set(DIM_ORDER)
+
+def _strip_cross_dim_tags(dim: str, tags: list) -> list:
+    keep, seen = [], set()
+    for t in tags or []:
+        s = str(t or "").strip()
+        if not s:
+            continue
+        low = s.lower()
+        if low in OTHER_DIMS and low != dim.lower():
+            continue
+        if low in seen:
+            continue
+        seen.add(low)
+        keep.append(s)
+    return keep
+
+def _authority_hints_from_qs(qs_cfg: dict, dim: str, limit: int = 8) -> list:
+    try:
+        block = qs_cfg.get(dim, {}) or {}
+        hints = block.get("search_hints", []) or []
+        hints = _strip_cross_dim_tags(dim, hints)
+        def score(h):
+            s = str(h).lower()
+            return -sum(1 for t in AUTHORITY_TOKENS if t in s)
+        hints = list({h: None for h in hints}.keys())
+        hints.sort(key=score)
+        return hints[:limit]
+    except Exception:
+        return []
+
+# ===== 语义化对齐（替换原先的字面包含比对） =====
+# === BEGIN PATCH · improved alignment ===
+def _alignment_ratio(dim: str, auth_hints: list, answer: str, topic_tags: list, evidence_hints: list,
+                     question: str = "", claims: list = None) -> float:
+    """
+    语义对齐评分（支持中英）：把候选语料（answer + topic_tags + evidence_hints*2 [+ question] [+ claims]）
+    与每条 auth_hint 做 token 对齐。
+    - 若某条 hint 切词后为空（常见于中文），跳过该条；
+    - 若最终“有效切词的 hints 条数”为 0，则视为“无提示词场景”，给中性保底分。
+    """
+    claims = claims or []
+    # 候选语料：把 evidence_hints 重复一次，提高权重；question/claims 可控注入
+    pool = [
+        sanitize_for_scoring(answer or ""),
+        " ".join([str(t) for t in (topic_tags or [])]),
+        " ".join([str(h) for h in (evidence_hints or [])]),
+        " ".join([str(h) for h in (evidence_hints or [])])
+    ]
+    if question:
+        pool.append(str(question))
+    if claims:
+        pool.append(" ".join([str(c) for c in claims if str(c).strip()]))
+
+    corpus = " \n ".join(pool)
+    c_uni, c_bi = _tokens_for_alignment(corpus)
+
+    # 无提示词：给一个中性保底
+    if not auth_hints:
+        return 0.35 if c_uni else 0.0
+
+    cover_hits = 0
+    scores = []
+    valid_hints = 0  # 关键：仅统计切得出 token 的 hint
+
+    for h in auth_hints:
+        q_uni, q_bi = _tokens_for_alignment(str(h))
+        if not q_uni and not q_bi:
+            continue
+        valid_hints += 1
+        s = _weighted_overlap(q_uni, q_bi, c_uni, c_bi)
+        scores.append(s)
+        if s >= 0.15:
+            cover_hits += 1
+
+    # 若所有 hints 切完都无有效 token，则当作“无 hint 场景”，给保底分
+    if valid_hints == 0:
+        return 0.5 if c_uni else 0.0
+
+    if not scores:
+        return 0.0
+
+    coverage = cover_hits / max(1, valid_hints)
+    mean_hit = sum(scores) / len(scores)
+    return max(0.0, min(1.0, 0.5 * coverage + 0.5 * mean_hit))
+# === END PATCH ===
+
+
+def _dimension_drift_score(dim: str, answer: str, topic_tags: list, evidence_hints: list) -> float:
+    tags = " ".join([str(t) for t in (topic_tags or [])]).lower()
+    others = sorted(OTHER_DIMS - {dim})
+    hit = sum(1 for od in others if od in tags)
+    weak_corpus = (" ".join([
+        sanitize_for_scoring(answer or ""),
+        " ".join([str(h) for h in (evidence_hints or [])])
+    ])).lower()
+    weak = sum(1 for od in others if od in weak_corpus)
+    score = 0.6 * (hit / max(1, len(others))) + 0.4 * (weak / max(1, len(others)))
+    return max(0.0, min(1.0, score))
+
+# =============== 证据短语 / 通识要点抽取（报告用） ===============
+
+def _top_evidence_phrases(hints: list, topk: int = 3):
+    if not hints:
+        return []
+    def _norm(h: str):
+        s = re.sub(r"\s+", " ", (h or "")).strip()
+        return s[:120]
+    candidates = []
+    for h in hints:
+        s = _norm(str(h))
+        if not s:
+            continue
+        score = 0
+        low = s.lower()
+        for tok in AUTHORITY_TOKENS:
+            if tok in low:
+                score += 1
+        candidates.append((s, score))
+    counter = Counter([c[0] for c in candidates])
+    ranked = sorted(
+        counter.items(),
+        key=lambda x: (-max([sc for (txt, sc) in candidates if txt == x[0]]), -x[1], x[0])
+    )
+    return [r[0] for r in ranked[:topk]]
+
+def _uniq_general_insights(gi_list, topk: int = 10, max_len: int = 220):
+    """
+    将各问答里的 general_insights 聚合成维度级“行业经验层”：
+    - 去重
+    - 统一空白
+    - 控制长度
+    """
+    if not gi_list:
+        return []
+    seen = set()
+    out = []
+    for g in gi_list:
+        s = re.sub(r"\s+", " ", str(g or "").strip())
+        if not s:
+            continue
+        if s in seen:
+            continue
+        seen.add(s)
+        if len(s) > max_len:
+            s = s[:max_len].rstrip() + "…"
+        out.append(s)
+        if len(out) >= topk:
+            break
+    return out
+
+# ============================ 打分逻辑 ============================
+
+def _strong_alignment_bonus(ans: str, evids: list) -> float:
+    if not ans and not evids:
+        return 0.0
+    text = (sanitize_for_scoring(ans) or "") + " " + " ".join([str(x) for x in (evids or [])])
+    low = text.lower()
+    strong = 0
+    if ("clinicaltrials.gov" in low or "eudract" in low) and re.search(r"\b(NCT\d{8}|EUCTR-\d{4}-\d{6}-\d{2})\b", low, re.I):
+        strong += 1
+    if ("pubmed" in low or "doi" in low) and re.search(r"\b10\.\d{4,9}/[-._;()/:A-Z0-9]+", low, re.I):
+        strong += 1
+    if ("uspto" in low or "epo" in low or "cnipa" in low) and re.search(r"\b(US|EP|CN)\d{5,}|WO\d{7,}\b", low, re.I):
+        strong += 1
+    if ("fda" in low or "ema" in low or "21 cfr" in low or "iso" in low) and re.search(r"\b(20\d{2}|19\d{2})\b", low, re.I):
+        strong += 1
+    return min(0.10, 0.03 * strong)
+
+def score_candidate(ans_item: dict, cfg: dict, peer_tokens_list=None, dim: str = "", auth_hints: list = None, question: str = "") -> dict:
+    ans = (ans_item.get("answer") or "").strip()
+    claims = ans_item.get("claims") or []
+    evids = ans_item.get("evidence_hints") or []
+    tags  = ans_item.get("topic_tags") or []
+    conf  = safe_float(ans_item.get("confidence"), 0.6)
+    diag  = ans_item.get("diag") or {}
+
+    s_len   = norm01(len(sanitize_for_scoring(ans)), 0, cfg["length_ref_chars"])
+    s_clm   = norm01(len([c for c in claims if isinstance(c, str) and c.strip()]), 0, cfg["claims_ref"])
+    s_evc   = norm01(len([e for e in evids if isinstance(e, str) and e.strip()]), 0, cfg["evidence_ref"])
+    s_eva   = authority_ratio(evids)
+    s_evg   = coverage_score(evids)
+    s_str   = looks_structured(ans)
+
+    # —— 对齐（计分阶段只注入 claims，不注入 question；可通过 A/B 关闭 claims 注入）——
+    use_qc = not cfg.get("_ablate_no_question_claims", False)
+    s_aln   = _alignment_ratio(dim, auth_hints or [], ans, tags, evids,
+                               question=(question if use_qc else ""),
+                               claims=(claims if use_qc else []))
+
+    s_cal   = conf
+
+    # 这里 auth_boost / cov_boost 仅用于 diagnostics，不再进入主权重
+    auth_boost = min(1.0, float(diag.get("auth_hits", 0)) / 5.0) if isinstance(diag.get("auth_hits", 0), (int, float)) else 0.0
+    cov_boost  = min(1.0, float(len(set(diag.get("coverage_bins") or []))) / 4.0)
+    s_eva = max(s_eva, auth_boost)
+    s_evg = max(s_evg, cov_boost)
+
+    s_aln = min(1.0, s_aln + _strong_alignment_bonus(ans, evids))
+
+    if peer_tokens_list:
+        me = list(_tokenize_cached(sanitize_for_scoring(ans)))
+        sims = [jaccard(me, tks) for tks in peer_tokens_list if tks is not None]
+        s_con = sum(sims) / max(1, len(sims))
+    else:
+        s_con = 0.5
+
+    pen = 0.0
+    oc = overclaim_score(ans)
+    if oc > 0.15:
+        pen += cfg["penalties"]["overclaim"]
+    if s_str < 0.20:
+        pen += cfg["penalties"]["understructure"]
+    if any(has_redline(str(c)) for c in claims):
+        pen += cfg["penalties"]["redline_residual"]
+
+    drift_raw = _dimension_drift_score(dim, ans, tags, evids)
+    if drift_raw > 0:
+        scale = 0.4 if drift_raw <= 0.2 else (0.7 if drift_raw <= 0.5 else 1.0)
+        pen += min(cfg["penalties"]["dimension_drift"] * scale, drift_raw * cfg["penalties"]["dimension_drift"])
+    if (diag.get("cross_dim") is True):
+        pen += min(cfg["penalties"]["dimension_drift"], 0.02)
+
+    fw = cfg["fields_weight"]
+    fields_part = (
+        fw["length"] * s_len +
+        fw["claims"] * s_clm +
+        fw["evidence_count"] * s_evc +
+        fw["evidence_authority"] * s_eva +
+        fw["evidence_coverage"] * s_evg +
+        fw["structure"] * s_str +
+        fw["alignment"] * s_aln +
+        fw["calibrated_confidence"] * s_cal
+    )
+
+    total = (1.0 - cfg["consistency_weight"]) * fields_part + cfg["consistency_weight"] * s_con
+    total = max(0.0, min(1.0, total - pen))
+
+    alpha = max(0.0, min(1.0, fields_part - pen))
+
+    if (dim == "innovation") and (ans_item.get("diag", {}).get("repro_signal") is True):
+        total = min(1.0, total + 0.01)
+        alpha = min(1.0, alpha + 0.01)
+
+    return {
+        "scores": {
+            "length": s_len,
+            "claims": s_clm,
+            "evidence_count": s_evc,
+            "evidence_authority": s_eva,
+            "evidence_coverage": s_evg,
+            "structure": s_str,
+            "alignment": s_aln,
+            "calibrated_confidence": s_cal,
+            "consistency": s_con
+        },
+        "penalties": {
+            "overclaim": oc,
+            "dimension_drift": drift_raw,
+            "applied": pen
+        },
+        "alpha": alpha,
+        "total": total
+    }
+
+# —— 更强坏候选过滤：返回 (bool_bad, reason)
+def _bad_candidate_with_reason(c: dict, cfg: dict, dim_name: str, auth_hints: list, q_text: str = ""):
+    ans_raw = (c.get("answer") or "").strip()
+    ans = sanitize_for_scoring(ans_raw)
+
+    # 1. 明确错误 / 过短
+    if c.get("error") is True:
+        return True, "error"
+    if len(ans) < 12:
+        return True, "too_short"
+
+    # 2. 占位/垃圾行比例：只有当非常高时才视为垃圾
+    ph_ratio = _placeholder_ratio(sanitize_for_display(ans_raw))
+    if ph_ratio > 0.60:
+        return True, "placeholder_noise"
+
+    # 3. 维度特定参数
+    dim_conf = (cfg.get("dimension_specific") or {}).get(dim_name, {})
+    min_struct  = cfg["filters"]["min_structured_score"]
+    min_bullets = dim_conf.get("min_bullet_lines", cfg["filters"]["min_bullet_lines"])
+    min_align   = float(dim_conf.get("min_alignment_for_keep", cfg["filters"]["min_alignment_for_keep"]))
+
+    if dim_name == "unknown":
+        # unknown 维度对齐阈值稍微低一点
+        min_align = min(0.15, min_align)
+
+    # 4. 结构评分：极差直接丢弃；略差在 soft_window 下放行
+    s_struct = looks_structured(ans_raw)
+    if s_struct < min_struct:
+        if cfg["filters"].get("soft_window", True) and s_struct >= 0.5 * min_struct:
+            pass
+        else:
+            return True, "poor_structure"
+
+    # 5. 去重后的条目行（用于 bullet 数量 & 中位长度）
+    _raw_lines = [ln.strip() for ln in sanitize_for_display(ans_raw).splitlines() if ln.strip()]
+    seen = set()
+    bullet_lines = []
+    for ln in _raw_lines:
+        if ln not in seen:
+            seen.add(ln)
+            bullet_lines.append(ln)
+
+    # 6. 基本分点要求：不再依赖 evidence/authority 做动态放宽
+    if len(bullet_lines) < min_bullets:
+        if cfg["filters"].get("soft_window", True) and len(bullet_lines) >= max(1, min_bullets - 1):
+            pass
+        else:
+            return True, "few_bullets"
+
+    # 7. 行中位长度：过滤口号式 / 极短句堆砌
+    if bullet_lines:
+        lens = sorted(len(x) for x in bullet_lines)
+        med = lens[len(lens)//2]
+        if med < cfg["filters"]["min_median_bullet_len"]:
+            if cfg["filters"].get("soft_window", True) and med >= max(2, cfg["filters"]["min_median_bullet_len"] - 2):
+                pass
+            else:
+                return True, "too_short_lines"
+
+    # 8. 语义对齐检查：只用来丢弃严重跑题的 candidate，不再看 evidence/authority
+    use_qc = not cfg.get("_ablate_no_question_claims", False)
+    aln = _alignment_ratio(
+        dim_name,
+        auth_hints or [],
+        ans_raw,
+        c.get("topic_tags") or [],
+        c.get("evidence_hints") or [],
+        question=(q_text if use_qc else ""),
+        claims=(c.get("claims") or [] if use_qc else [])
+    )
+
+    dyn_min_align = float(min_align)
+    if aln < dyn_min_align:
+        # 若结构还不错，或者只是略低一点，在 soft_window 下放行
+        if cfg["filters"].get("soft_window", True) and (aln >= dyn_min_align * 0.6 or s_struct >= 0.5):
+            pass
+        else:
+            return True, "weak_alignment"
+
+    return False, ""
+
+def _fallback_pick(cands: list, dim: str, auth_hints: list):
+    def _alignment_ratio_local(answer: str, evids: list):
+        # 仅作为兜底时的快速对齐（共性 token 命中）
+        corpus = (sanitize_for_scoring(answer or "")) + " " + " ".join([str(h) for h in (evids or [])])
+        total = len(auth_hints) or 1
+        hit = 0
+        low = corpus.lower()
+        for h in auth_hints or []:
+            if (h or "").strip().lower() in low:
+                hit += 1
+        return hit / total
+
+    def _fallback_score(c):
+        ans = (c.get("answer") or "")
+        evids = c.get("evidence_hints") or []
+        s_str = looks_structured(ans)
+        s_eva = authority_ratio(evids)
+        s_evg = coverage_score(evids)
+        s_evc = norm01(len([e for e in evids if str(e).strip()]), 0, 4)
+        s_aln = _alignment_ratio_local(ans, evids)
+        red_p = 0.0
+        if len((c.get("facts_redlined") or [])) >= 3:
+            red_p = 0.08
+        # 兜底场景：结构 + 对齐 为主，evidence 指标只给很轻的权重
+        base = 0.50 * s_str + 0.25 * s_aln + 0.15 * s_evc + 0.05 * s_eva + 0.05 * s_evg
+        return max(0.0, base - red_p)
+
+    ranked = sorted([(i, _fallback_score(c)) for i, c in enumerate(cands)], key=lambda x: -x[1])
+    return ranked[0][0] if ranked else 0
+
+def _provider_name(cand: dict) -> str:
+    pv = (cand.get("provider") or "").strip().lower()
+    if pv:
+        return pv
+    mdl = (cand.get("model") or "").lower()
+    if "deepseek" in mdl:
+        return "deepseek"
+    if "gpt" in mdl or "openai" in mdl or "o" == mdl[:1]:
+        return "openai"
+    return "default"
+
+def _beta_with_sweetspot_and_provider(beta_raw: float, avg_jac: float, avg_ctr: float, cfg: dict, provider: str) -> float:
+    lo, hi = cfg["consistency_correction"]["beta"]["jaccard_sweetspot"]
+    if avg_jac > hi:
+        beta_adj = (1 - 0.05) * beta_raw
+    elif avg_jac < lo:
+        beta_adj = (1 - 0.05 * (lo - avg_jac) / max(1e-9, lo)) * beta_raw
+    else:
+        beta_adj = beta_raw
+    cal = cfg["consistency_correction"]["beta"]["provider_calibration"].get(
+        provider, cfg["consistency_correction"]["beta"]["provider_calibration"]["default"]
+    )
+    delta = float(cal.get("beta_delta", 0.0))
+    beta_final = max(0.0, min(1.0, beta_adj + delta))
+    return beta_final
+
+def select_best_candidate(cands: list, cfg: dict, dim: str, auth_hints: list, q_text: str = "", last_provider: str = None):
+    if not cands:
+        return {"best": None, "all": [], "pairwise": {"avg_jaccard": 0.0, "avg_contradiction": 0.0}, "drop_stats": {}}
+
+    drop_stats = Counter()
+    cleaned = []
+    for c in cands:
+        bad, reason = _bad_candidate_with_reason(c, cfg, dim_name=dim, auth_hints=auth_hints, q_text=q_text)
+        if bad:
+            drop_stats[reason] += 1
+        else:
+            cleaned.append(c)
+
+    if not cleaned:
+        idx = _fallback_pick(cands, dim, auth_hints)
+        cleaned = [cands[idx]]
+
+    cands = cleaned
+
+    tokens = [list(_tokenize_cached(sanitize_for_scoring((c.get("answer") or "")))) for c in cands]
+    jac_sum = ctr_sum = 0.0
+    pair_cnt = 0
+    for i in range(len(cands)):
+        for j in range(i + 1, len(cands)):
+            pair_cnt += 1
+            jv = jaccard(tokens[i], tokens[j])
+            cv = contradiction_pair(cands[i].get("answer", ""), cands[j].get("answer", ""))
+            jac_sum += jv
+            ctr_sum += cv
+
+    avg_jac = jac_sum / pair_cnt if pair_cnt else 0.0
+    avg_ctr = ctr_sum / pair_cnt if pair_cnt else 0.0
+
+    k1 = cfg["consistency_correction"]["k_contradiction"]
+    beta_raw = max(0.0, min(1.0, (1 - k1 * avg_ctr) * (0.5 + 0.5 * avg_jac)))
+
+    scored = []
+    for idx, c in enumerate(cands):
+        peer = [tokens[k] if k != idx else None for k in range(len(cands))]
+        sc = score_candidate(c, cfg, peer_tokens_list=peer, dim=dim, auth_hints=auth_hints, question=q_text)
+        pv = _provider_name(c)
+        beta = _beta_with_sweetspot_and_provider(beta_raw, avg_jac, avg_ctr, cfg, provider=pv)
+        final = max(0.0, min(1.0, sc.get("alpha", sc.get("total", 0.0)) * beta))
+        scored.append((idx, final, sc, beta, pv))
+
+    def _tie_key(t):
+        final = t[1]
+        sd = t[2].get("scores", {})
+        return (
+            -float(final),
+            -float(sd.get("evidence_authority", 0.0)),
+            -float(sd.get("evidence_coverage", 0.0)),
+            -float(sd.get("alignment", 0.0)),
+            -float(sd.get("structure", 0.0)),
+            -float(sd.get("claims", 0.0)),
+            -float(sd.get("length", 0.0)),
+        )
+
+    scored.sort(key=_tie_key)
+
+    # === Provider 近分轮换策略（新增） ===
+    def _pick_with_provider_balance(scored_list, last_pv, margin=0.02):
+        """
+        在与top候选分差小于 margin 的范围内，优先选择 provider != last_pv 的候选；
+        若找不到，则保持原top。
+        scored_list 元素结构: (idx, final_score, detail_dict, beta, provider)
+        """
+        if not scored_list:
+            return None
+        top = scored_list[0]
+        if len(scored_list) == 1 or last_pv is None:
+            return top
+        top_score = top[1]
+        # 只看前三个，避免质量抖动
+        for cand in scored_list[:3]:
+            _, sc_final, _, _, sc_pv = cand
+            if sc_pv != last_pv and (top_score - sc_final) < margin:
+                return cand
+        return top
+
+    picked_tuple = _pick_with_provider_balance(scored, last_provider)
+    if picked_tuple is None:
+        best_idx, final_score, best_detail, best_beta, best_provider = (
+            0, 0.0, {"scores": {}, "penalties": {}, "alpha": 0.0, "total": 0.0}, 0.0, "default"
+        )
+    else:
+        best_idx, final_score, best_detail, best_beta, best_provider = picked_tuple
+
+    conflict_pen = cfg["penalties"]["contradiction"] * avg_ctr
+    topic_reliability = max(0.0, min(1.0, best_detail.get("total", 0.0) - conflict_pen))
+
+    out_all = []
+    for idx, fscore, detail, b, pv in scored:
+        item = dict(cands[idx])
+        item["_score_detail"] = detail
+        item["_score_total"]  = detail.get("total", 0.0)
+        item["_score_alpha"]  = detail.get("alpha", 0.0)
+        item["_score_final"]  = fscore
+        item["_score_beta"]   = b
+        item["_provider_used"] = pv
+        out_all.append(item)
+
+    return {
+        "best": {
+            "index": best_idx,
+            "candidate": cands[best_idx] if cands else None,
+            "score": {
+                "alpha": best_detail.get("alpha", 0.0),
+                "beta": best_beta,
+                "final": final_score,
+                "raw_total": best_detail.get("total", 0.0),
+                "after_topic_conflict": topic_reliability,
+                "avg_pairwise_jaccard": avg_jac,
+                "avg_pairwise_contradiction": avg_ctr
+            },
+            "detail": best_detail,
+            "provider": best_provider
+        },
+        "all": out_all,
+        "pairwise": {"avg_jaccard": avg_jac, "avg_contradiction": avg_ctr},
+        "drop_stats": dict(drop_stats)
+    }
+
+# ============================ 聚合与报告 ============================
+
+def aggregate_dimensions(items: list, cfg: dict, qs_cfg: dict):
+    per_question = []
+
+    dim_bucket = defaultdict(list)
+    dropped_reason_bucket = defaultdict(Counter)
+    # —— 用于 provider 近分轮换 ——
+    last_provider_per_dim = {d: None for d in DIM_ORDER + ["unknown"]}
+
+    auth_map = {dim: _authority_hints_from_qs(qs_cfg, dim, limit=8) for dim in DIM_ORDER}
+    auth_map.setdefault("unknown", [])
+
+    provider_stats = Counter()
+    provider_alpha = defaultdict(list)
+    provider_final = defaultdict(list)
+
+    for it in items:
+        dim0 = (it.get("dimension") or "").strip().lower()
+        dim = dim0 if dim0 in DIM_ORDER else "unknown"
+        qidx = it.get("q_index")
+        ques = (it.get("question") or "").strip()
+        cands = it.get("candidates") or []
+
+        picked = select_best_candidate(
+            cands, cfg,
+            dim=dim,
+            auth_hints=auth_map.get(dim, []),
+            q_text=ques,
+            last_provider=last_provider_per_dim.get(dim)
+        )
+        best = picked["best"]
+
+        # 记录本维度上一次选中的 provider，供下一题“近分轮换”微调
+        if best and best.get("candidate"):
+            last_provider_per_dim[dim] = (best.get("provider") or last_provider_per_dim.get(dim))
+
+        if picked.get("drop_stats"):
+            dropped_reason_bucket[dim].update(picked["drop_stats"])
+
+        if best and best["candidate"]:
+            selc = best["candidate"]
+            best_item = {
+                "dimension": dim,
+                "q_index": qidx,
+                "question": ques,
+                "selected": {
+                    "provider": selc.get("provider"),
+                    "model": selc.get("model"),
+                    "variant_id": selc.get("variant_id"),
+                    "answer": selc.get("answer"),
+                    "claims": selc.get("claims") or [],
+                    "evidence_hints": selc.get("evidence_hints") or [],
+                    "topic_tags": selc.get("topic_tags") or [],
+                    "confidence": safe_float(selc.get("confidence"), 0.6),
+                    "alignment_ratio": best["detail"]["scores"].get("alignment", 0.0),
+                    "dimension_drift": best["detail"]["penalties"].get("dimension_drift", 0.0),
+                    "facts_redlined": selc.get("facts_redlined", []) or [],
+                    # ★ 新增：保留通识经验层，供后续 ai_expert_opinion 使用
+                    "general_insights": selc.get("general_insights") or []
+                },
+                "score": best["score"],
+                "score_detail": best["detail"],
+                "pairwise": picked["pairwise"],
+                "all_candidates": picked["all"],
+                "auth_hints_used": auth_map.get(dim, []),
+                "drop_stats": picked["drop_stats"],  # ← 新增
+            }
+            per_question.append(best_item)
+            dim_bucket[dim].append(best_item)
+
+            pv = (picked.get("best") or {}).get("provider") or "default"
+            provider_stats[pv] += 1
+            provider_alpha[pv].append(float(best["detail"].get("alpha", 0.0)))
+            provider_final[pv].append(float(best["score"].get("final", 0.0)))
+        else:
+            per_question.append({
+                "dimension": dim, "q_index": qidx, "question": ques,
+                "selected": None,
+                "score": {"alpha": 0.0, "beta": 0.0, "final": 0.0,
+                          "raw_total": 0.0, "after_topic_conflict": 0.0,
+                          "avg_pairwise_jaccard": 0.0, "avg_pairwise_contradiction": 0.0},
+                "score_detail": {},
+                "pairwise": {"avg_jaccard": 0.0, "avg_contradiction": 0.0},
+                "all_candidates": [],
+                "auth_hints_used": auth_map.get(dim, []),
+                "drop_stats": picked["drop_stats"]  # ← 新增
+            })
+
+    per_dimension = {}
+    dims_for_report = list(DIM_ORDER)
+    if "unknown" in dim_bucket:
+        dims_for_report.append("unknown")
+
+    drop_reasons_global = Counter()
+    for d, cnts in dropped_reason_bucket.items():
+        drop_reasons_global.update(cnts)
+
+    for dim in dims_for_report:
+        qs = sorted([x for x in per_question if x["dimension"] == dim], key=lambda z: z["q_index"])
+        if not qs:
+            per_dimension[dim] = {
+                "avg": 0.0, "n": 0,
+                "avg_alignment": 0.0, "avg_drift": 0.0,
+                "strengths": [], "risks": [], "snippets": [],
+                "auth_hints": auth_map.get(dim, []),
+                "redlined_samples": [],
+                "dropped_reasons": {},
+                "top_evidence_phrases": [],
+                "general_insights": [],
+                "explain": {
+                    "top_contributors": [],
+                    "top_penalties": []
+                }
+            }
+            continue
+
+        # ✅ 安全取每题 final 分数（缺就当 0）
+        scores_final = []
+        for q in qs:
+            score_block = q.get("score") or {}
+            val = score_block.get("final", score_block.get("after_topic_conflict", 0.0))
+            try:
+                scores_final.append(float(val))
+            except (TypeError, ValueError):
+                scores_final.append(0.0)
+
+        # ✅ 新逻辑：均值 + 最大值 加权，拉开维度差异
+        if scores_final:
+            mean_sc = sum(scores_final) / len(scores_final)
+            max_sc = max(scores_final)
+            # 强维度通常会有几题明显高分；弱维度整体偏平
+            avg = 0.6 * mean_sc + 0.4 * max_sc
+        else:
+            mean_sc = 0.0
+            max_sc = 0.0
+            avg = 0.0
+
+        strengths, risks, snippets = [], [], []
+        aln_vals, drf_vals = [], []
+        redlined_samples = []
+
+        evid_pool = []
+        gi_pool = []  # ★ 新增：聚合 general_insights
+        contrib_counter = Counter()
+        penalty_counter = Counter()
+
+        for q in qs:
+            sel = q.get("selected")
+            if sel:
+                eva = authority_ratio(sel.get("evidence_hints") or [])
+                evg = coverage_score(sel.get("evidence_hints") or [])
+                aln = float(sel.get("alignment_ratio", 0.0))
+                drf = float(sel.get("dimension_drift", 0.0))
+
+                aln_vals.append(aln)
+                drf_vals.append(drf)
+
+                # 优势判断：不再强依赖权威/覆盖，只要 claims + 对齐即可
+                if len(sel.get("claims") or []) >= 2 and aln >= 0.40:
+                    strengths.append(
+                        f"Q{q['q_index']}：要点充分，结构/对齐较好（auth={eva:.2f}, cover={evg:.2f}, align={aln:.2f}）"
+                    )
+                if drf > 0.0:
+                    risks.append(f"Q{q['q_index']}：跨维度串味迹象（drift={drf:.2f}），建议人工复核维度边界")
+                if (q.get("score_detail") or {}).get("penalties", {}).get("applied", 0.0) > 0.0:
+                    risks.append("存在过度断言/结构不足/红线残留等扣分（请抽检）")
+
+                ans_txt = sel.get("answer") or ""
+                clean_snip = sanitize_for_display(ans_txt)
+                snippets.append(f"Q{q['q_index']}：{(clean_snip[:160] + '…') if clean_snip else '（无）'}")
+
+                for s in (sel.get("facts_redlined") or [])[:2]:
+                    if s not in redlined_samples and len(redlined_samples) < 8:
+                        redlined_samples.append(s)
+
+                evid_pool.extend(sel.get("evidence_hints") or [])
+                gi_pool.extend(sel.get("general_insights") or [])  # ★ 新增
+
+                sd = q.get("score_detail", {}).get("scores", {})
+                rank_pairs = sorted(sd.items(), key=lambda x: -float(x[1]))[:2]
+                for k, _ in rank_pairs:
+                    contrib_counter[k] += 1
+                pen = q.get("score_detail", {}).get("penalties", {})
+                if pen.get("applied", 0.0) > 0.0:
+                    if pen.get("dimension_drift", 0.0) > 0:
+                        penalty_counter["dimension_drift"] += 1
+                    if pen.get("overclaim", 0.0) > 0.15:
+                        penalty_counter["overclaim"] += 1
+                    if sd.get("structure", 1.0) < 0.2:
+                        penalty_counter["understructure"] += 1
+            else:
+                risks.append(f"Q{q['q_index']}：无有效答案")
+                snippets.append(f"Q{q['q_index']}：（无）")
+
+        top_evid = _top_evidence_phrases(evid_pool, topk=3)
+        gi_agg = _uniq_general_insights(gi_pool, topk=10)
+
+        per_dimension[dim] = {
+            "avg": avg,
+            "n": len(qs),
+            "avg_alignment": (sum(aln_vals) / max(1, len(aln_vals))) if aln_vals else 0.0,
+            "avg_drift": (sum(drf_vals) / max(1, len(drf_vals))) if drf_vals else 0.0,
+            "strengths": strengths[:cfg["adv_topk"]],
+            "risks": risks[:cfg["adv_topk"]],
+            "snippets": snippets[:6],
+            "auth_hints": auth_map.get(dim, []),
+            "redlined_samples": redlined_samples,
+            "dropped_reasons": dict(dropped_reason_bucket.get(dim, {})),
+            "top_evidence_phrases": top_evid,
+            "general_insights": gi_agg,
+            "explain": {
+                "top_contributors": [k for k, _ in contrib_counter.most_common(3)],
+                "top_penalties": [k for k, _ in penalty_counter.most_common(3)]
+            }
+        }
+
+    # overall
+    dim_score = 0.0
+    weight_sum = 0.0
+    total_q_count = len(per_question)
+    unknown_q_count = len([1 for q in per_question if q["dimension"] == "unknown"])
+    for dim, info in per_dimension.items():
+        if dim not in DIM_ORDER:
+            continue
+        w = (cfg.get("dimension_weight") or {}).get(dim, 1.0)
+        dim_score += w * float(info.get("avg", 0.0))
+        weight_sum += w
+    overall_score = dim_score / max(1e-9, weight_sum if weight_sum > 0 else 1.0)
+
+    all_conf, all_jac, all_ctr, cnt = [], 0.0, 0.0, 0
+    for q in per_question:
+        if q.get("selected"):
+            all_conf.append(safe_float(q["selected"].get("confidence"), 0.6))
+        all_jac += float(q.get("pairwise", {}).get("avg_jaccard", 0.0))
+        all_ctr += float(q.get("pairwise", {}).get("avg_contradiction", 0.0))
+        cnt += 1
+    mean_conf = sum(all_conf) / max(1, len(all_conf))
+    mean_jac = all_jac / max(1, cnt)
+    mean_ctr = all_ctr / max(1, cnt)
+    overall_confidence = max(0.0, min(1.0, (0.5 * mean_conf + 0.3 * mean_jac + 0.2 * (1 - mean_ctr))))
+
+    provider_summary = {}
+    for pv, n in provider_stats.items():
+        provider_summary[pv] = {
+            "selected_count": n,
+            "avg_alpha": sum(provider_alpha[pv]) / max(1, len(provider_alpha[pv])),
+            "avg_final": sum(provider_final[pv]) / max(1, len(provider_final[pv]))
+        }
+
+    drop_g = dict(drop_reasons_global)
+    placeholder_cnt = drop_g.get("placeholder_noise", 0)
+    few_bullets_cnt = drop_g.get("few_bullets", 0)
+
+    dim_median_bullets = {}
+    for dim in per_dimension:
+        qs_d = [q for q in per_question if q["dimension"] == dim and q.get("selected")]
+        nums = []
+        for q in qs_d:
+            cleaned = sanitize_for_display(q["selected"]["answer"] or "")
+            nums.append(len([ln for ln in cleaned.splitlines() if ln.strip()]))
+        if nums:
+            nums.sort()
+            dim_median_bullets[dim] = nums[len(nums)//2]
+        else:
+            dim_median_bullets[dim] = 0
+
+    overall = {
+        "overall_score": overall_score,
+        "overall_confidence": overall_confidence,
+        "mean_pairwise_jaccard": mean_jac,
+        "mean_pairwise_contradiction": mean_ctr,
+        "unknown_ratio": (unknown_q_count / max(1, total_q_count)),
+        "drop_reasons_global": dict(drop_reasons_global),
+        "provider_stats": provider_summary,
+        "placeholder_ratio_global": placeholder_cnt / max(1, sum(drop_g.values())) if drop_g else 0.0,
+        "few_bullets_ratio_global": few_bullets_cnt / max(1, sum(drop_g.values())) if drop_g else 0.0,
+        "dim_median_bullets": dim_median_bullets
+    }
+
+    return per_question, per_dimension, overall
+
+def build_report_md(pid: str, meta: dict, per_dim: dict, overall: dict, cfg: dict) -> str:
+    lines = []
+    lines.append(f"# 项目后处理报告 · {pid}")
+    lines.append("")
+    lines.append(f"- 生成时间：{now_str()}")
+    if meta:
+        m = {k: meta.get(k) for k in ("generated_at", "pid", "schema") if k in meta}
+        if "args" in meta:
+            m["args"] = meta["args"]
+        lines.append(f"- 元信息：{json.dumps(m, ensure_ascii=False)}")
+    lines.append("")
+    lines.append("## 总览")
+    sc = overall["overall_score"]
+    cf = overall["overall_confidence"]
+    lines.append(f"- 综合评分（0~1）：**{sc:.3f}**  {bar(sc, cfg['bar_symbols'])}")
+    lines.append(f"- 综合信心度（0~1）：**{cf:.3f}**  {bar(cf, cfg['bar_symbols'])}")
+    lines.append(f"- 全局一致性（平均 Jaccard）：**{overall['mean_pairwise_jaccard']:.3f}**")
+    lines.append(f"- 全局冲突度（平均）：**{overall['mean_pairwise_contradiction']:.3f}**")
+
+    if "drop_reasons_global" in overall and overall["drop_reasons_global"]:
+        drg = overall["drop_reasons_global"]
+        disp = ", ".join([f"{k}:{v}" for k, v in sorted(drg.items(), key=lambda x: (-x[1], x[0]))])
+        lines.append(f"- 候选被丢弃原因（全局Top）：{disp}")
+    lines.append(f"- 估计 placeholder 噪声占比：{overall.get('placeholder_ratio_global', 0.0):.1%}")
+    lines.append(f"- 估计 few_bullets 占比：{overall.get('few_bullets_ratio_global', 0.0):.1%}")
+
+    if "unknown" in per_dim and per_dim["unknown"]["n"] > 0:
+        unk_n = per_dim["unknown"]["n"]
+        unk_ratio = overall.get("unknown_ratio", 0.0)
+        lines.append(f"- 警示：存在 **{unk_n}** 道题落在 `unknown` 维度（占比 {unk_ratio:.1%}），建议复核问题集与维度抽取。")
+        if unk_ratio > cfg.get("unknown_warn_ratio", 0.10):
+            lines.append(f"- **严重提示**：unknown 占比超过 {int(cfg.get('unknown_warn_ratio', 0.10)*100)}% 的警戒阈值。")
+
+    pvstats = overall.get("provider_stats", {})
+    if pvstats:
+        parts = []
+        for k, v in pvstats.items():
+            parts.append(f"{k}: 选中{v['selected_count']} | α均值={v['avg_alpha']:.3f} | final均值={v['avg_final']:.3f}")
+        lines.append(f"- Provider 统计：{'； '.join(parts)}")
+
+    lines.append("")
+    lines.append("## 维度分解")
+
+    dims_in_report = list(DIM_ORDER) + [d for d in per_dim.keys() if d not in DIM_ORDER]
+
+    for dim in dims_in_report:
+        if dim not in per_dim:
+            continue
+        info = per_dim[dim]
+        avg = info["avg"]
+        lines.append(f"### {dim}  · 评分 {avg:.3f}  {bar(avg, cfg['bar_symbols'])}")
+        if info.get("auth_hints"):
+            lines.append(f"- 参考方向（非事实）：{'; '.join(info['auth_hints'])}")
+        lines.append(f"- 对齐均值/漂移均值：**{info.get('avg_alignment', 0.0):.2f} / {info.get('avg_drift', 0.0):.2f}**")
+        if "explain" in info:
+            ex = info["explain"] or {}
+            if ex.get("top_contributors"):
+                lines.append(f"- 主要得分贡献因子：{', '.join(ex['top_contributors'])}")
+            if ex.get("top_penalties"):
+                lines.append(f"- 主要扣分因子：{', '.join(ex['top_penalties'])}")
+        if info.get("top_evidence_phrases"):
+            lines.append("- **Top 证据短语（权威命中优先）**：")
+            for s in info["top_evidence_phrases"]:
+                lines.append(f"  - {s}")
+        gi_list = info.get("general_insights") or []
+        if gi_list:
+            lines.append("- **行业通识要点（general_insights，通用建议，不代表本项目已达成）**：")
+            for s in gi_list[:5]:
+                lines.append(f"  - {s}")
+        if info["strengths"]:
+            lines.append("- **优势**：")
+            for s in info["strengths"]:
+                lines.append(f"  - {s}")
+        if info["risks"]:
+            lines.append("- **风险**：")
+            for r in info["risks"]:
+                lines.append(f"  - {r}")
+        if info["snippets"]:
+            lines.append("- **代表性片段**：")
+            for sn in info["snippets"]:
+                lines.append(f"  - {sn}")
+        redlined_samples = info.get("redlined_samples") or []
+        if redlined_samples:
+            lines.append("- **已转为检索线索的原句（抽样）**：")
+            for s in redlined_samples[:6]:
+                lines.append(f"  - {s}")
+        drop_r = info.get("dropped_reasons") or {}
+        if drop_r:
+            lines.append("- **被丢弃候选统计**（原因：次数）：")
+            disp = ", ".join([f"{k}:{v}" for k, v in sorted(drop_r.items(), key=lambda x: (-x[1], x[0]))])
+            lines.append(f"  - {disp}")
+        lines.append(f"- 中位条目数（估计）：{overall.get('dim_median_bullets', {}).get(dim, 0)}")
+        lines.append("")
+    lines.append("> 注：本报告仅基于候选答案的结构化指标（长度/要点/证据提示/权威度/覆盖度/结构/一致性/置信度/维度对齐等），"
+                 "以及 LLM 给出的“行业通识建议”（general_insights）。通识建议仅为行业基准参考，并不代表本项目已经实现或满足相关要求。"
+                 "定稿前建议人工抽检与项目原文/事实证据对齐。")
+    return "\n".join(lines)
+
+# ============================ 主流程 ============================
+
+def main():
+    ap = argparse.ArgumentParser(description="Post-processing for structured candidates (no LLM calls).")
+    ap.add_argument("--pid", type=str, default="", help="提案ID，不填则自动选择 refined_answers 下最新目录")
+    ap.add_argument("--input", type=str, default="", help="可选：all_refined_items.json 的绝对/相对路径")
+
+    # === A/B 开关 ===
+    ap.add_argument("--ablate_no_question_claims", action="store_true",
+                    help="关闭对齐语料中的 question/claims 注入（用于消融实验）")
+    ap.add_argument("--ablate_no_dyn_relax", action="store_true",
+                    help="关闭基于权威/覆盖触发的 min_alignment 放宽（已废弃，仅保留兼容）")
+
+    args = ap.parse_args()
+
+    cfg = load_config()
+
+    # 把 A/B 开关塞入 cfg，便于下游函数访问
+    cfg["_ablate_no_question_claims"] = bool(args.ablate_no_question_claims)
+    cfg["_ablate_no_dyn_relax"] = bool(args.ablate_no_dyn_relax)
+
+    # 读取问题集（用于权威/题材 hints 对齐）
+    if QS_CONF_PATH.exists():
+        try:
+            qs_cfg = read_json(QS_CONF_PATH)
+        except Exception:
+            qs_cfg = {}
+    else:
+        qs_cfg = {}
+
+    if args.input:
+        refined_path = Path(args.input)
+        if not refined_path.exists():
+            raise FileNotFoundError(f"未找到输入文件：{refined_path}")
+        pid = refined_path.parent.name
+    else:
+        pid = args.pid.strip() or detect_latest_pid()
+        if not pid:
+            raise RuntimeError("未检测到 refined_answers 下的最新项目目录，也未提供 --pid / --input")
+        refined_path = REFINED_ROOT / pid / "all_refined_items.json"
+        if not refined_path.exists():
+            raise FileNotFoundError(f"未找到文件：{refined_path}")
+
+    data = read_json(refined_path)
+    meta = (data.get("meta") or {})
+    schema = meta.get("schema", "")
+
+    # 新版支持 llm_answering.v2 以及 refined_items.v2.proposal_aware_with_general_insights
+    allowed_schemas = {"", "llm_answering.v2", "refined_items.v2.proposal_aware_with_general_insights"}
+    if schema and schema not in allowed_schemas:
+        print(f"⚠️ 警告：输入 schema={schema}（预期 {allowed_schemas} 之一），将继续处理。")
+
+    # items / questions 兼容读取（新版 llm_answering 使用 items）
+    items = data.get("items") or data.get("questions") or []
+
+    bad = []
+    for i, it in enumerate(items):
+        if "dimension" not in it or "q_index" not in it or "question" not in it or "candidates" not in it:
+            bad.append(i)
+    if bad:
+        raise ValueError(f"输入 items 中存在缺失必要字段的条目：索引 {bad[:10]} ...，请检查 llm_answering 输出结构。")
+
+    per_question, per_dimension, overall = aggregate_dimensions(items, cfg, qs_cfg)
+
+    out_dir = REFINED_ROOT / pid / "postproc"
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    metrics = {
+        "meta": {
+            "pid": pid,
+            "generated_at": now_str(),
+            "source_file": str(refined_path),
+            "schema": schema or "",
+            "args": meta.get("args", {})
+        },
+        "config_used": cfg,
+        "overall": overall,
+        "dimensions": per_dimension,
+        "questions": per_question
+    }
+    write_json(out_dir / "metrics.json", metrics)
+
+    # 逐题选中结果（便于人工抽检）
+    write_json(out_dir / "selected_by_question.json", per_question)
+
+    # final_payload（下游报告的统一入口）
+    final_payload = {
+        "meta": {"pid": pid, "generated_at": now_str()},
+        "dimensions": {}
+    }
+    for dim in DIM_ORDER:
+        qs = [q for q in per_question if q["dimension"] == dim and q.get("selected")]
+        final_payload["dimensions"][dim] = {
+            "score": round(float(per_dimension.get(dim, {}).get("avg", 0.0)) * 100, 1),
+            "qas": [
+                {
+                    "q": q["question"],
+                    "answer": q["selected"]["answer"],
+                    "claims": q["selected"]["claims"],
+                    "evidence_hints": q["selected"]["evidence_hints"],
+                    "topic_tags": q["selected"].get("topic_tags", []),
+                    "provider": q["selected"].get("provider"),
+                    "model": q["selected"].get("model"),
+                    "alignment": q["selected"].get("alignment_ratio", 0.0),
+                    "dimension_drift": q["selected"].get("dimension_drift", 0.0),
+                    "confidence": q["selected"]["confidence"],
+                    "caveats": "",
+                    # ★ 新增：逐问通识经验层
+                    "general_insights": q["selected"].get("general_insights", [])
+                } for q in qs
+            ],
+            "rationales": (per_dimension.get(dim, {}).get("strengths") or [])[:3],
+            # ★ 新增：维度级聚合通识经验层，供 ai_expert_opinion 作为“行业经验层”使用
+            "general_insights": per_dimension.get(dim, {}).get("general_insights", [])
+        }
+    write_json(out_dir / "final_payload.json", final_payload)
+
+    report_md = build_report_md(pid, meta, per_dimension, overall, cfg)
+    (out_dir / "report.md").write_text(report_md, encoding="utf-8")
+
+    # 丢弃原因调试（仅写逐题的精简信息）
+    write_json(
+        out_dir / "drops_debug.json",
+        [
+            {
+                "dimension": q.get("dimension"),
+                "q_index": q.get("q_index"),
+                "question": q.get("question"),
+                "drop_stats": q.get("drop_stats", {})
+            }
+            for q in metrics["questions"]
+            if q.get("drop_stats")  # 只有存在统计才写入
+        ]
+    )
+
+    print(f"✅ metrics.json              -> {out_dir/'metrics.json'}")
+    print(f"✅ selected_by_question.json -> {out_dir/'selected_by_question.json'}")
+    print(f"✅ final_payload.json        -> {out_dir/'final_payload.json'}")
+    print(f"✅ report.md                 -> {out_dir/'report.md'}")
+
+    total_q = len(metrics["questions"])
+    dim_brief = ", ".join(f"{d}:{info['n']}" for d, info in metrics["dimensions"].items())
+    ov = metrics["overall"]
+    print(f"ℹ️  题目数：{total_q} | 维度题量：{dim_brief}")
+    print(f"ℹ️  综合评分={ov['overall_score']:.3f}  信心度={ov['overall_confidence']:.3f}  "
+          f"Jaccard={ov['mean_pairwise_jaccard']:.3f}  冲突度={ov['mean_pairwise_contradiction']:.3f}")
+    if "unknown" in per_dimension and per_dimension["unknown"]["n"] > 0:
+        unk_ratio = ov.get("unknown_ratio", 0.0)
+        print(f"⚠️ 提示：存在 {per_dimension['unknown']['n']} 道题被归入 unknown 维度（占比 {unk_ratio:.1%}），请检查问题集/维度抽取。")
+
+    drg = ov.get("drop_reasons_global", {})
+    if drg:
+        disp = ", ".join([f"{k}:{v}" for k, v in sorted(drg.items(), key=lambda x: (-x[1], x[0]))])
+        print(f"ℹ️ 丢弃原因（全局Top）：{disp}")
+
+    pvstats = ov.get("provider_stats", {})
+    if pvstats:
+        parts = []
+        for k, v in pvstats.items():
+            parts.append(f"{k}: 选中{v['selected_count']} | α均值={v['avg_alpha']:.3f} | final均值={v['avg_final']:.3f}")
+        print(f"ℹ️ Provider 统计：{'； '.join(parts)}")
+
+    print("🎯 后处理完成。")
+
+if __name__ == "__main__":
+    main()

src/tools/prepare_proposal_text.py

@@ -0,0 +1,207 @@
+# -*- coding: utf-8 -*-
+"""
+Stage 0: 提案文本准备（基础 OCR + 多模态页面重建）
+"""
+from __future__ import annotations
+
+import os
+import json
+import argparse
+from pathlib import Path
+from typing import Dict, Any, List
+
+import pdfplumber
+from pdf2image import convert_from_path
+from PIL import Image
+import pytesseract
+pytesseract.pytesseract.tesseract_cmd = "tesseract"
+from docx import Document
+
+from .layout_reconstruction import build_document_semantics, save_document_semantics
+
+MIN_TEXT_CHARS_PER_PAGE = 30
+TESSERACT_LANG = os.getenv("TESS_LANG", "chi_sim+eng")
+
+
+def detect_file_type(path: Path) -> str:
+    suffix = path.suffix.lower()
+    if suffix == ".pdf":
+        return "pdf"
+    if suffix in [".docx", ".doc"]:
+        return "docx"
+    if suffix in [".txt", ".md"]:
+        return "txt"
+    raise ValueError(f"暂不支持的文件类型: {suffix}")
+
+
+def find_latest_proposal() -> Path:
+    base_dir = Path(__file__).resolve().parents[2]
+    proposals_dir = base_dir / "src" / "data" / "proposals"
+    if not proposals_dir.exists():
+        raise FileNotFoundError(f"未找到提案目录: {proposals_dir}")
+    candidates = [
+        p for p in proposals_dir.iterdir()
+        if p.is_file() and p.suffix.lower() in [".pdf", ".docx", ".doc", ".txt", ".md"]
+    ]
+    if not candidates:
+        raise FileNotFoundError(f"提案目录中没有可用文件: {proposals_dir}")
+    latest = max(candidates, key=lambda x: x.stat().st_mtime)
+    print(f"[INFO] [auto] 选中最新提案文件: {latest}")
+    return latest
+
+
+def ocr_page_from_pdf(pdf_path: Path, page_index: int) -> str:
+    try:
+        images = convert_from_path(str(pdf_path), first_page=page_index + 1, last_page=page_index + 1)
+    except Exception as e:
+        print(f"[WARN] convert_from_path 失败 (page {page_index+1}): {e}")
+        return ""
+    if not images:
+        return ""
+    image: Image.Image = images[0]
+    try:
+        return pytesseract.image_to_string(image, lang=TESSERACT_LANG)
+    except Exception as e:
+        print(f"[WARN] OCR 失败 (page {page_index+1}): {e}")
+        return ""
+
+
+def extract_from_pdf(pdf_path: Path, use_ocr: bool = True):
+    pages_text, page_sources = [], []
+    with pdfplumber.open(pdf_path) as pdf:
+        print(f"[INFO] PDF 页面数: {len(pdf.pages)}")
+        for i, page in enumerate(pdf.pages):
+            txt = (page.extract_text() or "").strip()
+            if txt and len(txt) >= MIN_TEXT_CHARS_PER_PAGE:
+                pages_text.append(txt)
+                page_sources.append("pdf_text")
+                print(f"  - 第 {i+1} 页: 使用 pdfplumber 文本，长度 {len(txt)}")
+            else:
+                if use_ocr:
+                    print(f"  - 第 {i+1} 页: 文本太少({len(txt)} chars)，尝试 OCR...")
+                    ocr_txt = (ocr_page_from_pdf(pdf_path, page_index=i) or "").strip()
+                    if ocr_txt:
+                        pages_text.append(ocr_txt)
+                        page_sources.append("ocr")
+                        print(f"    -> OCR 成功，长度 {len(ocr_txt)}")
+                    else:
+                        pages_text.append("")
+                        page_sources.append("empty")
+                        print("    -> OCR 也没有提取到文本")
+                else:
+                    pages_text.append(txt)
+                    page_sources.append("pdf_text_empty")
+    return pages_text, page_sources
+
+
+def extract_from_docx(docx_path: Path):
+    doc = Document(str(docx_path))
+    paragraphs = [p.text.strip() for p in doc.paragraphs if p.text and p.text.strip()]
+    return ["\n".join(paragraphs)], ["docx"]
+
+
+def extract_from_txt(txt_path: Path):
+    content = Path(txt_path).read_text(encoding="utf-8", errors="ignore").strip()
+    return [content], ["txt"]
+
+
+def _build_pages_json(pages_text: List[str], page_sources: List[str]) -> List[Dict[str, Any]]:
+    pages_data: List[Dict[str, Any]] = []
+    offset = 0
+    for i, (txt, src) in enumerate(zip(pages_text, page_sources)):
+        char_len = len(txt)
+        page_start = offset
+        page_end = offset + char_len
+        pages_data.append({
+            "page_index": i + 1,
+            "source": src,
+            "char_len": char_len,
+            "global_char_start": page_start,
+            "global_char_end": page_end,
+            "text": txt,
+        })
+        offset = page_end + 2
+    return pages_data
+
+
+def prepare_text(file_path: Path, proposal_id: str, use_ocr: bool = True):
+    file_path = Path(file_path)
+    if not file_path.exists():
+        raise FileNotFoundError(file_path)
+
+    file_type = detect_file_type(file_path)
+    print(f"[INFO] 开始提取文本: {file_path} (type={file_type})")
+
+    if file_type == "pdf":
+        pages_text, page_sources = extract_from_pdf(file_path, use_ocr=use_ocr)
+    elif file_type == "docx":
+        pages_text, page_sources = extract_from_docx(file_path)
+    elif file_type == "txt":
+        pages_text, page_sources = extract_from_txt(file_path)
+    else:
+        raise ValueError(f"未知文件类型: {file_type}")
+
+    base_dir = Path(__file__).resolve().parents[2]
+    out_dir = base_dir / "src" / "data" / "prepared" / proposal_id
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    full_text = "\n\n".join(pages_text)
+    full_text_path = out_dir / "full_text.txt"
+    full_text_path.write_text(full_text, encoding="utf-8")
+    print(f"[OK] full_text.txt 写入完成: {full_text_path} (长度 {len(full_text)} 字符)")
+
+    pages_data = _build_pages_json(pages_text, page_sources)
+    pages_json_path = out_dir / "pages.json"
+    pages_json_path.write_text(json.dumps(pages_data, ensure_ascii=False, indent=2), encoding="utf-8")
+    print(f"[OK] pages.json 写入完成: {pages_json_path}")
+
+    page_semantics_path = None
+    reconstructed_full_text_path = None
+    page_images_dir = None
+    if file_type == "pdf":
+        try:
+            print("[INFO] 开始多模态 Stage 0 重建：pdf2image -> layout/table -> page_semantics")
+            doc_sem = build_document_semantics(file_path, out_dir=out_dir)
+            saved = save_document_semantics(doc_sem, out_dir=out_dir)
+            page_semantics_path = saved["page_semantics_path"]
+            reconstructed_full_text_path = saved["reconstructed_full_text_path"]
+            page_images_dir = saved["page_images_dir"]
+            reconstructed_full_text = doc_sem.get("reconstructed_full_text", "").strip()
+            if reconstructed_full_text:
+                full_text_path.write_text(reconstructed_full_text, encoding="utf-8")
+                print(f"[OK] 已用 reconstructed_full_text 覆盖 full_text.txt，长度 {len(reconstructed_full_text)} 字符")
+        except Exception as e:
+            print(f"[WARN] 多模态 Stage 0 重建失败，继续使用基础文本: {e}")
+
+    return {
+        "proposal_id": proposal_id,
+        "file_type": file_type,
+        "out_dir": str(out_dir),
+        "full_text_path": str(full_text_path),
+        "pages_json_path": str(pages_json_path),
+        "page_semantics_path": page_semantics_path,
+        "reconstructed_full_text_path": reconstructed_full_text_path,
+        "page_images_dir": page_images_dir,
+        "num_pages": len(pages_text),
+    }
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Stage 0: 提案文本准备（含 OCR + 多模态页面重建 + 自动选最新提案）")
+    parser.add_argument("--file", required=False, help="提案文件路径（PDF/DOCX/TXT）。不填则自动选最新提案")
+    parser.add_argument("--proposal_id", required=False, help="提案 ID（用于输出目录名，不填则用文件名）")
+    parser.add_argument("--no_ocr", action="store_true", help="禁用 OCR（仅调试用）")
+    args = parser.parse_args()
+
+    file_path = Path(args.file) if args.file else find_latest_proposal()
+    if args.file:
+        print(f"[INFO] 使用用户指定文件: {file_path}")
+    proposal_id = args.proposal_id or file_path.stem
+    info = prepare_text(file_path, proposal_id, use_ocr=not args.no_ocr)
+
+    print("\n[SUMMARY]")
+    print(json.dumps(info, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()

src/tools/run_pipeline.py

@@ -0,0 +1,68 @@
+# src/tools/run_pipeline.py
+# -*- coding: utf-8 -*-
+import subprocess
+from pathlib import Path
+
+# 项目根目录（包含 src/）
+BASE_DIR = Path(__file__).resolve().parents[2]
+
+
+def run_cmd(cmd: list):
+    """在项目根目录下执行一个子命令，并在失败时直接抛出异常。"""
+    print("🚀 Running:", " ".join(cmd))
+    r = subprocess.run(cmd, cwd=BASE_DIR)
+    if r.returncode != 0:
+        raise RuntimeError(f"Command failed: {' '.join(cmd)}")
+
+
+def run_full_pipeline():
+    """
+    一键跑完整流程（自动提案模式）：
+
+      1) prepare_proposal_text.py
+      2) extract_facts_by_chunk.py
+      3) build_dimensions_from_facts.py
+      3.5) profiling/domain_profiler.py
+      4) generate_questions.py
+      5) llm_answering.py
+      6) post_processing.py
+      7) ai_expert_opinion.py
+      8) generate_final_report.py
+
+    前提：每个脚本内部都实现了“自动检测最新 proposal”的逻辑，
+    即在不传 --file / --proposal_id / --pid 的情况下能自己找到最新项目。
+    """
+
+    # 1) 准备文本
+    run_cmd(["python", "-m", "src.tools.prepare_proposal_text"])
+
+    # 2) facts 抽取
+    run_cmd(["python", "-m", "src.tools.extract_facts_by_chunk"])
+
+    # 3) 由 facts 构建维度
+    run_cmd(["python", "-m", "src.tools.build_dimensions_from_facts"])
+
+    # 3.5) 域画像
+    run_cmd(["python", "-m", "src.profiling.domain_profiler"])
+
+    # 4) 生成问题
+    run_cmd(["python", "-m", "src.tools.generate_questions"])
+
+    # 5) LLM 回答
+    run_cmd(["python", "-m", "src.tools.llm_answering"])
+
+    # 6) post-processing
+    run_cmd(["python", "-m", "src.tools.post_processing"])
+
+    # 7) AI 专家意见
+    run_cmd(["python", "-m", "src.tools.ai_expert_opinion"])
+
+    # 8) 最终报告
+    run_cmd(["python", "-m", "src.tools.generate_final_report"])
+
+    print("🎯 Full pipeline finished.")
+
+
+if __name__ == "__main__":
+    # 不再需要任何命令行参数，直接按照“最新提案”自动跑一遍
+    run_full_pipeline()

src/tools/search_by_dimension.py

@@ -0,0 +1,486 @@
+# -*- coding: utf-8 -*-
+"""
+阶段 2：智能语义检索器（v2025.12 ProClean · strong-query / early-stop / robust-io / diagnostics）
+保持下游兼容：evidence/* 命名/结构不变；新增 *_queries.json（维度投放查询记录）
+"""
+import os, sys, re, json, time, argparse
+from pathlib import Path
+from urllib.parse import urlparse
+from collections import Counter, defaultdict
+from dotenv import load_dotenv
+
+load_dotenv()
+CURRENT_DIR = Path(__file__).resolve().parent
+SRC_ROOT = CURRENT_DIR.parent
+DATA_DIR = SRC_ROOT / "data"
+PROPOSAL_DIR = DATA_DIR / "extracted"
+EVIDENCE_ROOT = DATA_DIR / "evidence"
+CONFIG_DIR = DATA_DIR / "config"
+PARSED_DIR = DATA_DIR / "parsed"
+EVIDENCE_ROOT.mkdir(parents=True, exist_ok=True)
+if str(SRC_ROOT) not in sys.path: sys.path.insert(0, str(SRC_ROOT))
+
+from backend.utils.model_selector import get_llm_client
+from backend.retrievers.web_search import simple_search
+
+llm = get_llm_client()
+client = llm["client"]; model_name = llm["model_name"]; provider = llm["provider"]
+print(f"💬 QueryGen 使用 {provider.upper()} 模型：{model_name}")
+
+# ===== 基本参数 =====
+IGNORE_DIMS = {"proposal_id", "generated_time", "chunk_count", "coverage_estimate", "meta", "doc_meta", "run_meta"}
+FIRST_ROUND_N = 4
+MAX_RESULTS_PER_QUERY = 5
+MAX_QUERIES_PER_DIM = 14
+SLEEP_BETWEEN_QUERIES = 0.8
+MIN_SAVE_EVIDENCE = 1
+
+# 每题“学术域命中”提前停止阈值（维度自定义）
+EARLY_STOP_ACADEMIC = {"strategy":4, "objectives":4, "feasibility":4, "innovation":3, "team":3}
+# 维度层面的软阈值（累计达到后对后续题适度保守）
+DIM_SOFT_EARLY_STOP = {"strategy":10, "objectives":10, "feasibility":10, "innovation":8, "team":8}
+
+ACADEMIC_SITES = [
+    "arxiv.org","openreview.net","aclweb.org","ieeexplore.ieee.org","dl.acm.org",
+    "springer.com","nature.com","sciencedirect.com","wiley.com","tandfonline.com",
+    "mdpi.com","frontiersin.org","osf.io","zenodo.org","doi.org"
+]
+
+DIM_HINTS = {
+    "team": ["team expertise", "roles and responsibilities", "governance", "affiliation"],
+    "objectives": ["problem statement", "scope", "deliverable", "evaluation metric"],
+    "strategy": ["method", "technical approach", "implementation pathway", "workflow"],
+    "innovation": ["novelty", "differentiation", "prior work", "evidence"],
+    "feasibility": ["resources", "timeline", "risk", "dependency", "budget"]
+}
+
+def clean_query(q: str, max_len=280):
+    q = re.sub(r"[，。？：；！、]", " ", q or "")
+    q = re.sub(r"\s+", " ", q.strip())
+    return q[:max_len]
+
+def uniq(seq):
+    seen, out = set(), []
+    for x in seq:
+        sx = str(x or "").strip()
+        if not sx: continue
+        lx = sx.lower()
+        if lx not in seen:
+            out.append(sx); seen.add(lx)
+    return out
+
+def _extract_bracket_block(t: str, lch: str, rch: str):
+    s, e = t.find(lch), t.rfind(rch)
+    if s != -1 and e != -1 and e > s:
+        frag = t[s:e+1]
+        return frag.replace("“","\"").replace("”","\"")
+    return None
+
+def safe_json_loads(text: str):
+    t = (text or "").strip()
+    if "```" in t: t = t.replace("```json","").replace("```","").strip()
+    for frag in (t, _extract_bracket_block(t,"[","]"), _extract_bracket_block(t,"{","}")):
+        if not frag: continue
+        try:
+            obj = json.loads(frag)
+            if isinstance(obj, list): return obj
+            if isinstance(obj, dict) and isinstance(obj.get("questions"), list): return obj["questions"]
+        except Exception: continue
+    return []
+
+def collect_entities_numbers_terms(dim_content: dict):
+    ents, nums, key_terms = [], [], []
+    try:
+        people = dim_content.get("entities", {}).get("people", []) or []
+        ents += [p.get("name","") for p in people if isinstance(p, dict)]
+        ents += dim_content.get("entities", {}).get("orgs", []) or []
+    except Exception: pass
+    ents = [e for e in ents if isinstance(e,str) and e.strip()]
+
+    try:
+        nums = [str(n.get("value","")) for n in (dim_content.get("numbers") or [])
+                if isinstance(n, dict) and n.get("value")]
+    except Exception: pass
+    nums = [n for n in nums if n]
+
+    try:
+        kt = dim_content.get("key_terms") or []
+        if isinstance(kt, list): key_terms = [str(k) for k in kt if k]
+    except Exception: pass
+    return ents[:8], nums[:6], key_terms[:12]
+
+# ---- 回退模板（保留原有）----
+FALLBACK_TEMPLATES = {
+    "team": [
+        '"{PERSON}" profile role affiliation 2019..2026',
+        '"{ORG}" team lab group leadership 2019..2026',
+        '"{PERSON}" biography experience project 2019..2026'
+    ],
+    "objectives": [
+        '"{KEY}" objective scope deliverable 2020..2026',
+        '"{KEY}" evaluation metric milestone 2020..2026',
+        '"{KEY}" problem statement requirement 2020..2026'
+    ],
+    "strategy": [
+        '"{KEY}" method workflow implementation 2020..2026',
+        '"{KEY}" technical approach validation 2020..2026',
+        '"{KEY}" architecture design process 2020..2026'
+    ],
+    "innovation": [
+        '"{KEY}" novelty differentiation prior work 2020..2026',
+        '"{KEY}" patent benchmark evidence 2020..2026',
+        '"{KEY}" state of the art comparison 2020..2026'
+    ],
+    "feasibility": [
+        '"{KEY}" resource timeline risk dependency 2020..2026',
+        '"{KEY}" budget implementation constraint 2020..2026',
+        '"{KEY}" evaluation challenge mitigation 2020..2026'
+    ]
+}
+
+def _inject_fallbacks(dimension: str, entities: list, keywords: list):
+    toks = uniq((entities or []) + (keywords or []))
+    outs = []
+    for tpl in FALLBACK_TEMPLATES.get(dimension.lower(), []):
+        if "{PERSON}" in tpl and entities:
+            outs.append(tpl.replace("{PERSON}", entities[0]))
+        elif "{ORG}" in tpl and len(entities) > 1:
+            outs.append(tpl.replace("{ORG}", entities[1]))
+        elif "{KEY}" in tpl and toks:
+            outs.append(tpl.replace("{KEY}", toks[0]))
+    return uniq(outs)
+
+# ---- 新增：读取并展开 generated_questions.json 的 query_templates ----
+def load_query_templates():
+    qset_path = CONFIG_DIR / "question_sets" / "generated_questions.json"
+    try:
+        raw = json.loads(qset_path.read_text(encoding="utf-8"))
+        return raw.get("query_templates", {}) or {}
+    except Exception:
+        return {}
+
+def expand_templates_for_dim(dimension: str, templates: list, entities: list, key_terms: list, numbers: list, time_hint: str):
+    people = [e for e in entities if e]
+    orgs = [e for e in entities if e]
+    terms = [t for t in key_terms if t]
+    nums  = [n for n in numbers if n]
+
+    p_opts = people[:2] or [""]
+    o_opts = orgs[:2] or [""]
+    t_opts = terms[:3] or [""]
+    n_opts = nums[:2]  or [""]
+
+    out = []
+    for tpl in templates or []:
+        tpl = str(tpl or "")
+        for p in p_opts:
+            for o in o_opts:
+                for t in t_opts:
+                    for n in n_opts:
+                        q = tpl.replace("{PERSON}", p).replace("{ORG}", o).replace("{TERM}", t).replace("{NUM}", n)
+                        q = q.replace("  ", " ").strip()
+                        if time_hint and "20" in time_hint and time_hint not in q:
+                            q = f'{q} {time_hint}'
+                        out.append(clean_query(q))
+    return uniq([q for q in out if q])[:MAX_QUERIES_PER_DIM]
+
+def llm_generate_queries(question, context, dimension, hints=None, entities=None, numbers=None, key_terms=None):
+    time_hint = "2019..2025" if dimension in ("strategy","objectives","feasibility") else "2021..2025"
+    dim_hints = "; ".join(DIM_HINTS.get(dimension.lower(), []))
+    hint_text = "; ".join(hints or [])
+    ent_text = "; ".join(entities or [])[:240]
+    num_text = ", ".join(numbers or [])[:80]
+    key_text = "; ".join(key_terms or [])[:240]
+
+    must_have = uniq((key_terms or []) + (hints or []))[:6]
+    mh_text = "; ".join(must_have) if must_have else "core domain terms from the proposal"
+
+    prompt = f"""
+你是通用项目检索专家。针对“问题+维度+摘要+提示词+实体+数字”，生成 {FIRST_ROUND_N} 条高质量检索 query。
+要求：
+- 每条尽量包含：实体/机构/模型名/登记号/关键数字（若有）
+- 使用 site: 与时间窗（{time_hint}），中英均可，简洁可直投 Google
+- 可优先结合以下高价值术语（如适用）：{mh_text}
+- 输出严格的 JSON 数组（字符串列表），仅内容，无解释
+问题：{question}
+维度：{dimension}
+摘要：{context[:900]}
+hints：{hint_text}；{dim_hints}
+实体：{ent_text}
+数字：{num_text}
+关键词：{key_text}
+"""
+    try:
+        rsp = client.chat.completions.create(
+            model=model_name, messages=[{"role":"user","content":prompt}], temperature=0.35
+        )
+        content = rsp.choices[0].message.content.strip()
+        queries = safe_json_loads(content)
+        queries = [clean_query(q["query"] if isinstance(q, dict) and "query" in q else str(q)) for q in queries]
+        zh_variants = [f"{q} 项目 研究 方法 风险 评估 {time_hint}" for q in queries]
+        merged = uniq(queries + zh_variants)
+        return merged[:MAX_QUERIES_PER_DIM] if merged else [question]
+    except Exception as e:
+        print(f"⚠️ LLM 生成 Query 失败: {e}")
+        return [question]
+
+# ===== 新增：基础 must/should 子句拼接 =====
+def build_base_clause(dim_name: str, qcfg: dict, qsets_meta: dict):
+    doc_policy = (qsets_meta.get("doc_policy") or {})
+    must_terms = list(dict.fromkeys((qcfg.get("search", {}).get("must_terms") or []) + (doc_policy.get("must_terms") or [])))
+    should_terms = list(dict.fromkeys((qcfg.get("search", {}).get("should_terms") or []) + (doc_policy.get("should_terms") or [])))
+
+    def qwrap(t):
+        t = str(t).strip()
+        if not t: return ""
+        return f"({t})" if " " in t and not (t.startswith('"') and t.endswith('"')) else t
+
+    must_clause = " ".join(qwrap(t) for t in must_terms if t)
+    should_clause = ""
+    if should_terms:
+        should_clause = " (" + " OR ".join(qwrap(t) for t in should_terms if t) + ")"
+    base = (must_clause + should_clause).strip()
+    return base, must_terms, should_terms
+
+# ============ 主流程 ============
+
+parser = argparse.ArgumentParser()
+parser.add_argument("--fast", action="store_true", help="仅检索每维前2个问题（调试模式）")
+args = parser.parse_args()
+
+# 1) 读取清洗后的维度（固定路径）
+parsed_path = PARSED_DIR / "parsed_dimensions.clean.llm.json"
+if not parsed_path.exists():
+    print(f"❌ 未找到清洗后的维度文件：{parsed_path}；请先运行 strict_cleanup_llm.py")
+    sys.exit(1)
+
+try:
+    dimensions = json.loads(parsed_path.read_text(encoding="utf-8"))
+except Exception as e:
+    print(f"❌ 读取维度文件失败：{e}"); sys.exit(1)
+
+# 2) 读取问题集（固定路径）
+qset_path = CONFIG_DIR / "question_sets" / "generated_questions.json"
+if not qset_path.exists():
+    print(f"❌ 未找到问题集：{qset_path}"); sys.exit(1)
+try:
+    question_sets = json.loads(qset_path.read_text(encoding="utf-8"))
+except Exception as e:
+    print(f"❌ 读取问题集失败：{e}"); sys.exit(1)
+
+# 3) 从 run_meta.source_path 恢复 proposal_id
+proposal_id = "current_proposal"
+try:
+    src_path = (dimensions.get("run_meta") or {}).get("source_path", "")
+    if src_path:
+        p = Path(src_path)
+        if p.name.endswith("_dimensions.json"):
+            proposal_id = p.stem.replace("_dimensions", "")
+except Exception:
+    pass
+os.environ["CURRENT_PROPOSAL_ID"] = proposal_id
+print(f"📂 当前提案文件: {proposal_id}")
+
+EVIDENCE_DIR = EVIDENCE_ROOT / proposal_id
+EVIDENCE_DIR.mkdir(parents=True, exist_ok=True)
+
+# 读取顶层 query_templates（问题集里）
+QUERY_TEMPLATES_ALL = question_sets.get("query_templates", {}) or {}
+
+global_domain_counter, stats = Counter(), {}
+debug_overview = {}
+
+# 供基础子句使用的 meta
+qsets_meta = question_sets.get("meta", {}) or {}
+
+for dim, ctx in dimensions.items():
+    if dim in IGNORE_DIMS or dim not in question_sets:
+        continue
+
+    print(f"\n🔹 开始维度: {dim}")
+    t0 = time.time()
+    qcfg = question_sets[dim]
+    questions = qcfg.get("questions", []) or []
+    if not questions:
+        print("ℹ️ 该维度无问题，跳过。"); continue
+    if args.fast:
+        questions = questions[:2]; print("⚙️ Fast：仅检索前2个问题")
+
+    # 收集维度上下文信息
+    ents, nums, key_terms = collect_entities_numbers_terms(ctx or {})
+    dim_evidences = []
+    per_q_domain_counter = Counter()
+    success, fail = 0, 0
+    dim_academic_hits = 0
+
+    all_queries_fired = []
+    needed_hits = EARLY_STOP_ACADEMIC.get(dim, 3)
+    dim_soft_cap = DIM_SOFT_EARLY_STOP.get(dim, 8)
+
+    # 维度模板：来自 generated_questions.json 的 query_templates 对应维度
+    dim_templates = (QUERY_TEMPLATES_ALL.get(dim, []) or [])[:10]
+    templates_before = len(dim_templates)
+
+    # ===== 新增：构造基础 must/should 子句 & 合并 search_hints =====
+    base_clause, must_terms_used, should_terms_used = build_base_clause(dim, qcfg, qsets_meta)
+    merged_hints = list(dict.fromkeys((qcfg.get("search_hints") or []) + (qsets_meta.get("doc_policy", {}) or {}).get("query_hints_merged", [])))[:10]
+
+    for q in questions:
+        if dim_academic_hits >= dim_soft_cap:
+            print(f"🛑 维度累计学术命中已达软阈值 {dim_soft_cap}，对后续题缩减投放。")
+            max_per_question = 2
+        else:
+            max_per_question = MAX_QUERIES_PER_DIM
+
+        print(f"\n🧭 问题: {q}")
+        # 1) LLM 生成首轮强 query
+        llm_queries = llm_generate_queries(
+            q, (ctx or {}).get("summary",""), dim,
+            hints=merged_hints,
+            entities=ents, numbers=nums, key_terms=key_terms
+        )
+
+        # 2) 维度模板占位展开（自动带入时间窗）
+        time_hint = "2019..2025" if dim in ("strategy","objectives","feasibility") else "2021..2025"
+        expanded_tpl = expand_templates_for_dim(dim, dim_templates, ents, key_terms, nums, time_hint)
+
+        # 3) 回退模板
+        fallbacks = _inject_fallbacks(dim, ents, [q] + DIM_HINTS.get(dim, []))
+
+        # 4) 基于 hints 的单独查询（每个 hint 一条）
+        hint_queries = []
+        for h in merged_hints:
+            if not h: continue
+            hq = h
+            if base_clause:
+                hq = f"{base_clause} {h}".strip()
+            hint_queries.append(clean_query(hq))
+
+        # 合并顺序：原问题 -> LLM -> 模板 -> 回退 -> hint 单发
+        merged_queries = uniq([q] + llm_queries + expanded_tpl + fallbacks + hint_queries)
+
+        # 在每条 query 前拼接基础 must/should 子句
+        if base_clause:
+            merged_queries = [clean_query(f"{base_clause} {qq}") for qq in merged_queries]
+
+        # 控制每题投放上限
+        merged_queries = merged_queries[:max_per_question]
+
+        # ---- 查询执行 ----
+        per_question_academic_hits = 0
+        empty_hits = 0
+        for i, query in enumerate(merged_queries, start=1):
+            print(f"🔍 ({i}/{len(merged_queries)}) 搜索: {query}")
+            all_queries_fired.append(query)
+            try:
+                texts, urls = simple_search(
+                    query, max_results=MAX_RESULTS_PER_QUERY,
+                    dimension=dim, hints=merged_hints, source="LLM"
+                )
+                got = 0
+                for t, u in zip(texts, urls):
+                    dim_evidences.append({"query": query, "text": t, "url": u})
+                    host = urlparse(u).hostname or ""
+                    if host:
+                        per_q_domain_counter[host] += 1
+                        global_domain_counter[host] += 1
+                        if any(ad in host for ad in ACADEMIC_SITES):
+                            per_question_academic_hits += 1
+                            dim_academic_hits += 1
+                    got += 1
+                if got == 0: empty_hits += 1
+                success += 1 if got > 0 else 0
+                fail += 1 if got == 0 else 0
+            except Exception as e:
+                print(f"❌ 搜索失败: {e}"); fail += 1; empty_hits += 1
+
+            if per_question_academic_hits >= needed_hits:
+                print("🛑 该题学术来源已足够，提前停止扩张。"); break
+            time.sleep(SLEEP_BETWEEN_QUERIES)
+
+        # 空击回退：若前面全空，尝试“hint/实体 词袋 + 时间窗 + site”的布尔兜底
+        if per_question_academic_hits == 0 and empty_hits >= len(merged_queries):
+            bag = uniq((merged_hints or []) + ents + key_terms)
+            bag = [b for b in bag if len(b) >= 2][:6]
+            if bag:
+                bag_q = " ".join(f'"{b}"' for b in bag)
+                bag_q = f'{bag_q} {time_hint}'
+                bag_q = clean_query(bag_q)
+                print(f"🧯 兜底搜索：{bag_q}")
+                all_queries_fired.append(bag_q)
+                try:
+                    texts, urls = simple_search(
+                        bag_q, max_results=MAX_RESULTS_PER_QUERY,
+                        dimension=dim, hints=merged_hints, source="LLM"
+                    )
+                    for t, u in zip(texts, urls):
+                        dim_evidences.append({"query": bag_q, "text": t, "url": u})
+                        host = urlparse(u).hostname or ""
+                        if host:
+                            per_q_domain_counter[host] += 1
+                            global_domain_counter[host] += 1
+                            if any(ad in host for ad in ACADEMIC_SITES):
+                                per_question_academic_hits += 1
+                                dim_academic_hits += 1
+                    success += 1 if texts else 0
+                    fail += 1 if not texts else 0
+                except Exception as e:
+                    print(f"❌ 兜底失败: {e}")
+
+    # 记录维度 query（诊断信息更丰富）
+    queries_record = {
+        "dimension": dim,
+        "templates_loaded": templates_before,
+        "templates_expanded": len(expanded_tpl) if 'expanded_tpl' in locals() else 0,
+        "queries_total": len(all_queries_fired),
+        "queries": all_queries_fired
+    }
+    (EVIDENCE_DIR / f"{dim}_queries.json").write_text(
+        json.dumps(queries_record, ensure_ascii=False, indent=2),
+        encoding="utf-8"
+    )
+
+    if len(dim_evidences) < MIN_SAVE_EVIDENCE:
+        print(f"⚠️ {dim} 维度 evidence 过少（{len(dim_evidences)}），跳过保存。")
+        continue
+
+    raw_ev = EVIDENCE_DIR / f"{dim}_evidence_raw.json"
+    try:
+        raw_ev.write_text(json.dumps(dim_evidences, ensure_ascii=False, indent=2), encoding="utf-8")
+    except Exception as e:
+        print(f"⚠️ 写入原始 evidence 失败：{e}")
+
+    elapsed = round(time.time() - t0, 1)
+    success_rate = round(success / (success + fail + 1e-6), 2)
+    print(f"📊 {dim} 完成：成功率 {success_rate}, evidence {len(dim_evidences)}, 耗时 {elapsed}s")
+
+    stats[dim] = {
+        "问题数": len(questions), "成功": success, "失败": fail,
+        "成功率": success_rate, "Evidence条数": len(dim_evidences),
+        "Top域名": per_q_domain_counter.most_common(6), "耗时(s)": elapsed,
+        "维度累计学术命中": dim_academic_hits
+    }
+    debug_overview[dim] = {
+        "queries_total": queries_record["queries_total"],
+        "evidence_kept": len(dim_evidences),
+        "elapsed_s": elapsed,
+        "early_stop_threshold_per_question": EARLY_STOP_ACADEMIC.get(dim, 3),
+        "early_stop_soft_dim": DIM_SOFT_EARLY_STOP.get(dim, 8)
+    }
+
+report = {
+    "proposal_id": proposal_id, "provider": provider, "model": model_name,
+    "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
+    "stats": stats, "top_domains_global": global_domain_counter.most_common(12)
+}
+summary_path = EVIDENCE_DIR / "dimension_summary_index.json"
+summary_path.write_text(json.dumps(report, ensure_ascii=False, indent=2), encoding="utf-8")
+
+(EVIDENCE_DIR / "dimension_debug_overview.json").write_text(
+    json.dumps(debug_overview, ensure_ascii=False, indent=2), encoding="utf-8"
+)
+
+print("\n✅ 检索完成。报告保存至：", summary_path)
+print("🌐 Top域名：", report["top_domains_global"])
+print(f"📁 输出目录：{EVIDENCE_DIR}")
+print(f"📈 生成的 combined 文件：{len(list(EVIDENCE_DIR.glob('*_combined.json')))} 个")

src/tools/validate_stage0_outputs.py

@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+"""Validate multimodal Stage 0 artifacts for a prepared proposal."""
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+BASE_DIR = Path(__file__).resolve().parents[2]
+PREPARED_DIR = BASE_DIR / "src" / "data" / "prepared"
+
+
+def validate(proposal_id: str) -> int:
+    out_dir = PREPARED_DIR / proposal_id
+    issues = []
+    page_sem_path = out_dir / "page_semantics.json"
+    if not page_sem_path.exists():
+        issues.append("missing page_semantics.json")
+        print("[FAIL] missing page_semantics.json")
+        return 1
+    data = json.loads(page_sem_path.read_text(encoding="utf-8"))
+    pages = data.get("pages") or []
+    if data.get("num_pages") != len(pages):
+        issues.append("num_pages mismatch")
+    for page in pages:
+        if not page.get("reconstructed_text"):
+            issues.append(f"page {page.get('page_index')} missing reconstructed_text")
+        if not page.get("blocks"):
+            issues.append(f"page {page.get('page_index')} missing blocks")
+    if issues:
+        print("[WARN] Stage 0 validation issues:")
+        for issue in issues:
+            print(" -", issue)
+        return 1
+    print(f"[OK] Stage 0 artifacts look valid for proposal_id={proposal_id}")
+    return 0
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("proposal_id")
+    args = parser.parse_args()
+    raise SystemExit(validate(args.proposal_id))
+
+
+if __name__ == "__main__":
+    main()