Browse Source

Merge pull request #953 from jphJack/feature/papermind-agent-v2

[毕业设计] PaperMind - 多Agent论文创新点生成系统
Sizhou Chen 1 month ago
parent
commit
f97c9c58d0
79 changed files with 15741 additions and 0 deletions
  1. 27 0
      Co-creation-projects/jphJack-PaperMindAgent/.env.example
  2. 45 0
      Co-creation-projects/jphJack-PaperMindAgent/.gitignore
  3. 261 0
      Co-creation-projects/jphJack-PaperMindAgent/README.md
  4. 2 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/__init__.py
  5. 4 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/agents/__init__.py
  6. 58 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/agents/base.py
  7. 70 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/agents/hello_agents_runner.py
  8. 593 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/agents/report_agent.py
  9. 128 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/agents/specialized.py
  10. 4 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/api/__init__.py
  11. 97 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/api/main.py
  12. 428 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/api/routes.py
  13. 151 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/api/tasks.py
  14. 51 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/config.py
  15. 6 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/evaluator/__init__.py
  16. 149 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/evaluator/evaluator.py
  17. 261 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/evaluator/quality.py
  18. 118 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/evaluator/tracker.py
  19. 11 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/llm/__init__.py
  20. 122 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/llm/client.py
  21. 178 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/llm/function_calling.py
  22. 56 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/llm/json_utils.py
  23. 6 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/memory/__init__.py
  24. 64 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/memory/conversation.py
  25. 290 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/memory/long_term.py
  26. 38 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/memory/manager.py
  27. 1 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/models/__init__.py
  28. 171 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/models/schemas.py
  29. 6 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/orchestrator/__init__.py
  30. 1244 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/orchestrator/controller.py
  31. 223 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/orchestrator/reflexion.py
  32. 298 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/orchestrator/workflow.py
  33. 7 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/rag/__init__.py
  34. 105 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/rag/bm25_store.py
  35. 272 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/rag/embedding.py
  36. 197 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/rag/hybrid_search.py
  37. 131 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/rag/vector_store.py
  38. 15 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/requirements.txt
  39. 1 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/storage/__init__.py
  40. 258 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/storage/paper_library.py
  41. 1 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/tools/__init__.py
  42. 215 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/tools/analyze_gaps.py
  43. 61 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/tools/base.py
  44. 208 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/tools/build_vector_index.py
  45. 152 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/tools/design_experiments.py
  46. 483 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/tools/extract_paper_structure.py
  47. 124 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/tools/extract_schema.py
  48. 208 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/tools/generate_innovations.py
  49. 117 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/tools/hello_agents_bridge.py
  50. 50 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/tools/hybrid_search_tool.py
  51. 74 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/tools/memory_tools.py
  52. 311 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/tools/parse_pdf.py
  53. 50 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/tools/registry.py
  54. 63 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/tools/scan_folder.py
  55. 134 0
      Co-creation-projects/jphJack-PaperMindAgent/backend/tools/web_search.py
  56. 51 0
      Co-creation-projects/jphJack-PaperMindAgent/benchmark_index.py
  57. 12 0
      Co-creation-projects/jphJack-PaperMindAgent/frontend/index.html
  58. 2901 0
      Co-creation-projects/jphJack-PaperMindAgent/frontend/package-lock.json
  59. 23 0
      Co-creation-projects/jphJack-PaperMindAgent/frontend/package.json
  60. 434 0
      Co-creation-projects/jphJack-PaperMindAgent/frontend/src/App.tsx
  61. 153 0
      Co-creation-projects/jphJack-PaperMindAgent/frontend/src/api.ts
  62. 169 0
      Co-creation-projects/jphJack-PaperMindAgent/frontend/src/components/EvaluationPanel.tsx
  63. 123 0
      Co-creation-projects/jphJack-PaperMindAgent/frontend/src/components/PaperLibrary.tsx
  64. 34 0
      Co-creation-projects/jphJack-PaperMindAgent/frontend/src/components/ProgressBar.tsx
  65. 40 0
      Co-creation-projects/jphJack-PaperMindAgent/frontend/src/components/ReportView.tsx
  66. 73 0
      Co-creation-projects/jphJack-PaperMindAgent/frontend/src/components/StepsTimeline.tsx
  67. 1249 0
      Co-creation-projects/jphJack-PaperMindAgent/frontend/src/index.css
  68. 10 0
      Co-creation-projects/jphJack-PaperMindAgent/frontend/src/main.tsx
  69. 162 0
      Co-creation-projects/jphJack-PaperMindAgent/frontend/src/types.ts
  70. 20 0
      Co-creation-projects/jphJack-PaperMindAgent/frontend/tsconfig.json
  71. 15 0
      Co-creation-projects/jphJack-PaperMindAgent/frontend/vite.config.ts
  72. 193 0
      Co-creation-projects/jphJack-PaperMindAgent/main.ipynb
  73. 1426 0
      Co-creation-projects/jphJack-PaperMindAgent/pipeline_walkthrough.html
  74. BIN
      Co-creation-projects/jphJack-PaperMindAgent/plan.docx
  75. 24 0
      Co-creation-projects/jphJack-PaperMindAgent/requirements.txt
  76. 13 0
      Co-creation-projects/jphJack-PaperMindAgent/run_backend.py
  77. 94 0
      Co-creation-projects/jphJack-PaperMindAgent/smoke_test_hello_agents.py
  78. 120 0
      Co-creation-projects/jphJack-PaperMindAgent/staged-skills/paper-innovation-designer/SKILL.md
  79. 4 0
      Co-creation-projects/jphJack-PaperMindAgent/staged-skills/paper-innovation-designer/agents/openai.yaml

+ 27 - 0
Co-creation-projects/jphJack-PaperMindAgent/.env.example

@@ -0,0 +1,27 @@
+# DeepSeek API 配置(必填)
+DEEPSEEK_API_KEY=your_deepseek_api_key_here
+DEEPSEEK_BASE_URL=https://api.deepseek.com
+DEEPSEEK_MODEL=deepseek-chat
+
+# Embedding 模型(本地,默认 BGE-m3)
+EMBEDDING_MODEL=BAAI/bge-m3
+
+# 向量库与缓存路径
+CHROMA_PATH=./data/chroma
+CACHE_DIR=./data/cache
+REPORT_DIR=./data/reports
+
+# 超时与重试
+LLM_TIMEOUT=120
+LLM_TEMPERATURE=1.0
+PDF_PARSE_TIMEOUT=60
+TOOL_MAX_RETRIES=3
+
+# Reflexion 置信度阈值
+CONFIDENCE_THRESHOLD=0.7
+
+# 并发控制
+MAX_CONCURRENT_PAPERS=5
+
+# 联网搜索(新颖性去重,可选,默认用 DuckDuckGo)
+WEB_SEARCH_BACKEND=duckduckgo

+ 45 - 0
Co-creation-projects/jphJack-PaperMindAgent/.gitignore

@@ -0,0 +1,45 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.venv/
+venv/
+env/
+
+# 环境变量
+.env
+
+# 数据与缓存
+data/
+*.jsonl
+!backend/**/__init__.py
+
+# HelloAgents 框架运行时输出(traces/devlogs/todos/sessions,位于项目根目录)
+memory/
+
+# 保留 backend/memory 目录(根仓库 .gitignore 全局排除了 memory/)
+!backend/memory/
+!backend/memory/**
+# 但继续忽略其中的编译缓存
+backend/memory/__pycache__/
+
+# 前端
+frontend/node_modules/
+frontend/dist/
+frontend/tsconfig.tsbuildinfo
+
+# IDE
+.vscode/
+.idea/
+.trae/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# 日志
+日志.docx
+
+# 临时脚本(含密钥,禁止提交)
+create_pr_retry.py
+pr_result.json

+ 261 - 0
Co-creation-projects/jphJack-PaperMindAgent/README.md

@@ -0,0 +1,261 @@
+# PaperMind · 论文创新点发现 Agent
+
+> 一个面向研究生的多 Agent 协作系统:批量阅读本地 PDF 论文 → 漏斗式信息收敛 → 识别研究空白 → 生成 2-3 个可落地的创新点与完整实验方案。
+
+[![Python](https://img.shields.io/badge/Python-3.12-blue)](https://www.python.org/)
+[![FastAPI](https://img.shields.io/badge/FastAPI-0.115-009688)](https://fastapi.tiangolo.com/)
+[![React](https://img.shields.io/badge/React-18-61DAFB)](https://react.dev/)
+[![HelloAgents](https://img.shields.io/badge/HelloAgents-Framework-7B61FF)](https://pypi.org/project/hello-agents/)
+[![License](https://img.shields.io/badge/license-MIT-green)](#license)
+
+---
+
+## ✨ 项目亮点
+
+- 🧠 **Plan-and-Execute + Reflexion**:Controller 动态规划执行路径,关键步骤自校验,置信度低自动回退
+- 🤝 **多 Agent 协作**:1 个 Controller + 6 个专职 Agent(Parser / Extractor / Indexer / GapAnalyzer / InnovationGenerator / ExperimentDesigner)+ 1 个 Evaluator
+- 🛠 **DeepSeek Function Calling**:`tool_choice="auto"`,模型自主选工具(10+ 工具)
+- 🔌 **基于 HelloAgents 框架构建**:LLM 调用统一走框架 `HelloAgentsLLM`,工具经桥接注册为框架 `ToolRegistry`,Reflexion 自校验由框架 `SimpleAgent` 执行,复杂步骤可切换框架 `ReActAgent` 调度
+- 🔍 **RAG 全链路**:BGE-m3 Embedding + Chroma 向量库 + BM25 关键词 → 混合搜索
+- 💾 **双层 Memory**:会话级对话记忆 + 跨会话长期知识记忆(向量库 + JSON 元数据)
+- 📊 **评估体系**:输出三维评分(新颖性 / 可行性 / 显著性)+ 工具调用成功率 + 自校验置信度
+- 🪜 **七步漏斗式主链路**:严格遵循 `plan.docx` 信息收敛架构
+- 🛡 **稳定性设计**:单篇失败隔离、JSON 容错、工具重试降级、超时控制
+
+---
+
+## 🏗 系统架构
+
+```
+                ┌─────────────────────────────────────┐
+                │   Controller (Plan-and-Execute)     │
+                └──────────────┬──────────────────────┘
+                               │  动态调度
+        ┌──────────────┬───────┼────────┬─────────────┐
+        ▼              ▼       ▼        ▼             ▼
+  ┌──────────┐  ┌──────────┐ ... ┌──────────┐  ┌──────────────┐
+  │  Parser  │  │ Extractor│     │  Gap    │  │  Evaluator   │
+  └──────────┘  └──────────┘     │ Analyzer│  └──────────────┘
+                                 └──────────┘
+        ▲              ▲                       ▲
+        │              │   Reflexion 自校验     │
+        └──────────────┴───────────────────────┘
+
+七步漏斗主链路:
+  ① PDF 解析  →  ② 结构化抽取  →  ③ 向量索引
+   →  ④ 跨论文 Gap 识别  →  ⑤ 创新点生成
+   →  ⑥ 实验方案设计   →  ⑦ 整合研究报告
+```
+
+---
+
+## 📂 目录结构
+
+```
+paper-agent-trae/
+├── backend/                  # FastAPI 后端
+│   ├── agents/               # Controller + 6 专职 Agent + HelloAgents 框架 Agent 封装
+│   ├── llm/                  # HelloAgentsLLM 客户端 + Function Calling 循环
+│   ├── tools/                # Function Calling 工具集(10+ 工具)+ HelloAgents 工具桥接
+│   ├── rag/                  # Embedding + Chroma + BM25 混合搜索
+│   ├── memory/               # 对话记忆 + 长期知识记忆
+│   ├── orchestrator/         # 工作流编排 + Reflexion
+│   ├── evaluator/            # 评估体系(质量评分 + 调用追踪)
+│   ├── api/                  # FastAPI 异步接口
+│   ├── models/               # Pydantic Schema
+│   └── config.py             # 全局配置
+├── frontend/                 # React + Vite 前端
+│   ├── src/
+│   │   ├── components/       # 报告视图 / 进度条 / 评估面板
+│   │   ├── App.tsx
+│   │   └── api.ts
+│   └── package.json
+├── data/                     # 向量库 / 缓存 / 报告(运行时生成)
+├── .env.example              # 环境变量样例
+├── .gitignore
+├── run_backend.py            # 启动入口
+└── plan.docx                 # 漏斗式架构原始设计文档
+```
+
+---
+
+## 🚀 快速开始
+
+### 1. 克隆与配置
+
+```bash
+git clone https://github.com/jphJack/PaperMind-Agent.git
+cd PaperMind-Agent
+
+# 复制环境变量样例
+cp .env.example .env
+# 编辑 .env,填入 DEEPSEEK_API_KEY
+```
+
+### 2. 启动后端
+
+```bash
+# 推荐 Python 3.12
+pip install -r backend/requirements.txt   # 含 hello-agents 框架
+python run_backend.py
+# 服务监听 http://0.0.0.0:8000
+```
+
+### 3. 启动前端
+
+```bash
+cd frontend
+npm install
+npm run dev
+# 浏览器访问 http://localhost:5173
+```
+
+### 4. 使用流程
+
+1. 在前端输入本地 PDF 文件夹路径
+2. 点击「启动分析」
+3. 实时查看七步漏斗的进度与中间产物
+4. 分析完成后查看结构化研究报告 + 评估指标
+
+---
+
+## 🔧 核心工具集(Function Calling)
+
+| 工具 | 功能 |
+|---|---|
+| `scan_folder` | 扫描目标文件夹收集 PDF |
+| `parse_pdf` | PyMuPDF 解析 + 章节结构保留 |
+| `extract_paper_structure` | 强制 JSON 输出固定 schema |
+| `build_vector_index` | 章节分块 → BGE-m3 → Chroma 入库 |
+| `hybrid_search` | 向量相似度 + BM25 关键词混合检索 |
+| `analyze_gaps` | 跨论文综合分析,识别四类 Gap 信号 |
+| `generate_innovations` | 创新点生成与三维评分筛选 |
+| `design_experiments` | 生成可执行实验方案 |
+| `web_search` | 近 1-2 年新颖性去重 |
+| `save_memory` / `load_memory` | Memory 读写 |
+
+---
+
+## 📊 结构化抽取 Schema
+
+每篇论文抽取为如下 JSON(节选):
+
+```json
+{
+  "title": "...",
+  "task": "...",
+  "method": "...",
+  "key_contributions": ["..."],
+  "datasets": ["..."],
+  "metrics": ["..."],
+  "results": "...",
+  "limitations": ["..."],
+  "future_work": ["..."],
+  "source_sections": {
+    "method": ["3.1", "3.2"],
+    "limitations": ["6.2"]
+  }
+}
+```
+
+`source_sections` 字段保证所有结论可回溯到原文具体章节,避免 LLM 编造。
+
+---
+
+## 📈 评估体系
+
+最终报告附带三类评估指标:
+
+- **输出质量三维评分**:新颖性 / 可行性 / 显著性(0-10 分)
+- **工具调用统计**:调用次数 / 成功率 / 平均耗时
+- **Reflexion 置信度**:关键步骤的自校验置信度统计
+
+---
+
+## ⚙️ 环境变量
+
+完整配置见 [`.env.example`](.env.example),核心项:
+
+| 变量 | 说明 | 默认值 |
+|---|---|---|
+| `DEEPSEEK_API_KEY` | DeepSeek API Key(必填) | - |
+| `DEEPSEEK_MODEL` | 模型名 | `deepseek-chat` |
+| `LLM_TEMPERATURE` | HelloAgentsLLM 采样温度 | `1.0` |
+| `EMBEDDING_MODEL` | 本地 Embedding 模型 | `BAAI/bge-m3` |
+| `CHROMA_PATH` | 向量库路径 | `./data/chroma` |
+| `CONFIDENCE_THRESHOLD` | Reflexion 置信度阈值 | `0.7` |
+| `MAX_CONCURRENT_PAPERS` | 并发抽取数 | `5` |
+| `TOOL_MAX_RETRIES` | 工具调用最大重试次数 | `3` |
+
+---
+
+## 🛣 七步漏斗式主链路
+
+严格遵循 [`plan.docx`](plan.docx) 定义的漏斗式信息收敛架构:
+
+1. **PDF 解析** — PyMuPDF + 章节结构保留
+2. **单篇结构化抽取** — 固定 schema + source_sections 回溯
+3. **向量索引构建** — BGE-m3 + Chroma
+4. **跨论文综合分析 + Gap 识别** — 重复局限 / 方法空白 / 矛盾结论 / 未兑现未来工作
+5. **创新点生成与筛选** — 方法组合 / 局限改进 / 跨域迁移 / 新场景应用
+6. **实验方案设计** — 假设 / 数据 / 基线 / 指标 / 消融 / 步骤 / 风险
+7. **整合输出** — Markdown 研究提案,含背景综述 / 创新点论证 / 实验方案 / 参考文献溯源
+
+---
+
+## 🛡 稳定性设计
+
+- ✅ 单篇论文失败隔离,独立缓存可单独重跑
+- ✅ Function Calling 强制 JSON + 程序层校验
+- ✅ 工具调用 3 次重试 + 降级路径
+- ✅ 单篇 / 单步超时阈值控制
+- ✅ Controller 异常捕获与恢复
+
+---
+
+## 🧪 技术栈
+
+**后端**:Python 3.12 · FastAPI · **HelloAgents 框架(HelloAgentsLLM / SimpleAgent / ReActAgent / ToolRegistry)** · OpenAI SDK(兼容 DeepSeek)· ChromaDB · sentence-transformers · PyMuPDF · rank-bm25 · Pydantic · SSE
+
+**前端**:React 18 · Vite 5 · TypeScript · react-markdown
+
+**AI**:DeepSeek-chat · BAAI/bge-m3 Embedding
+
+---
+
+## 🔌 HelloAgents 框架集成
+
+PaperMind 构建在 [HelloAgents](https://pypi.org/project/hello-agents/) 框架之上,框架能力在三个层面落地:
+
+| 层次 | 框架组件 | 集成方式 |
+|---|---|---|
+| LLM 层 | `HelloAgentsLLM` | `backend/llm/client.py` 中 `DeepSeekClient` 底层由框架 LLM 驱动,OpenAI 兼容适配器自动识别 DeepSeek,全部模型调用经框架发出 |
+| 工具层 | `Tool` / `ToolRegistry` / `ToolResponse` | `backend/tools/hello_agents_bridge.py` 将 10+ 项目工具桥接为框架原生 Tool(ToolResponse 协议、熔断器保护),供框架 Agent 直接调度 |
+| Agent 层 | `SimpleAgent` / `ReActAgent` | `backend/agents/hello_agents_runner.py` 封装框架 Agent:Reflexion 质量审核由 `SimpleAgent` 执行;`ReActAgent` 携带桥接工具集可对任意步骤做框架原生推理调度 |
+
+```python
+from hello_agents import HelloAgentsLLM, ReActAgent
+from backend.tools.registry import build_default_registry
+from backend.tools.hello_agents_bridge import build_hello_agents_registry
+
+llm = HelloAgentsLLM()  # 经 DeepSeekClient 配置模型/密钥/地址
+agent = ReActAgent(
+    "GapAnalyzer",
+    llm,
+    tool_registry=build_hello_agents_registry(build_default_registry()),
+    system_prompt="你是研究空白识别专家……",
+)
+result = await agent.arun("分析这些论文并识别研究空白")
+```
+
+---
+
+## 📄 License
+
+MIT
+
+---
+
+## 🙋 关于
+
+本项目为人工智能专业研究生的「Agent 开发深度理解」项目作品,旨在展示主流 Agent 工程能力(推理框架、多智能体协作、Function Calling、RAG、Memory、动态编排、评估体系)的完整落地。

+ 2 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/__init__.py

@@ -0,0 +1,2 @@
+"""Paper Innovation Agent - 后端包"""
+__version__ = "0.1.0"

+ 4 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/agents/__init__.py

@@ -0,0 +1,4 @@
+"""Agent 模块:Controller 与各专职 Agent"""
+from backend.agents.report_agent import ReportAgent
+
+__all__ = ["ReportAgent"]

+ 58 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/agents/base.py

@@ -0,0 +1,58 @@
+"""Agent 基类:所有专职 Agent 与 Controller 的公共接口"""
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from backend.llm.client import DeepSeekClient
+from backend.llm.function_calling import ToolLoop
+from backend.tools.base import ToolRegistry
+
+
+class BaseAgent:
+    """专职 Agent 基类:绑定角色提示词 + 工具子集,通过 ToolLoop 执行任务"""
+
+    def __init__(
+        self,
+        name: str,
+        role: str,
+        client: DeepSeekClient,
+        registry: ToolRegistry,
+        tool_names: Optional[list[str]] = None,
+    ):
+        self.name = name
+        self.role = role  # system prompt 角色描述
+        self.client = client
+        self.registry = registry
+        # 该 Agent 可用的工具子集(None 表示全部)
+        self.tool_names = tool_names or registry.names()
+
+    def _build_tools_schema(self) -> list[dict]:
+        """构建该 Agent 可用工具的 JSON schema 列表"""
+        all_schemas = {s["function"]["name"]: s for s in self.registry.get_schemas()}
+        return [all_schemas[n] for n in self.tool_names if n in all_schemas]
+
+    def _build_callables(self) -> dict:
+        """构建该 Agent 可用工具的 name->func 字典"""
+        all_callables = self.registry.get_callables()
+        return {n: all_callables[n] for n in self.tool_names if n in all_callables}
+
+    async def run(self, task: str, context: Optional[str] = None) -> dict:
+        """执行任务:构造消息→ToolLoop 循环→返回结果与工具调用记录"""
+        messages = [{"role": "system", "content": self.role}]
+        user_content = task
+        if context:
+            user_content = f"上下文:\n{context}\n\n任务:\n{task}"
+        messages.append({"role": "user", "content": user_content})
+
+        tool_loop = ToolLoop(self.client, self._build_callables())
+        result_text = await tool_loop.run(
+            messages=messages,
+            tools_schema=self._build_tools_schema(),
+            max_iterations=15,
+        )
+
+        return {
+            "agent": self.name,
+            "result": result_text,
+            "tool_calls": [tc.model_dump() for tc in tool_loop.get_tool_records()],
+        }

+ 70 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/agents/hello_agents_runner.py

@@ -0,0 +1,70 @@
+"""HelloAgents 框架 Agent 封装:把框架原生 Agent 接入 PaperMind 执行链路
+
+提供两类框架 Agent 封装:
+- build_reviewer_agent: 基于框架 SimpleAgent 的质量审核 Agent(Reflexion 自校验使用)
+- run_react_task: 基于框架 ReActAgent 的单步任务执行(桥接项目工具,框架原生工具调度)
+"""
+from __future__ import annotations
+
+import logging
+from typing import Any, Optional
+
+from hello_agents import HelloAgentsLLM, ReActAgent, SimpleAgent
+
+from backend.tools.base import ToolRegistry as PaperMindToolRegistry
+from backend.tools.hello_agents_bridge import build_hello_agents_registry
+
+logger = logging.getLogger(__name__)
+
+
+def build_reviewer_agent(
+    llm: HelloAgentsLLM,
+    name: str = "QualityReviewer",
+    system_prompt: str = "你是质量审核员,负责对照上下文检查 Agent 输出质量。只输出 JSON。",
+) -> SimpleAgent:
+    """构建框架 SimpleAgent 形态的质量审核 Agent(无工具,纯推理)"""
+    return SimpleAgent(name=name, llm=llm, system_prompt=system_prompt)
+
+
+async def run_reviewer_check(agent: SimpleAgent, prompt: str) -> str:
+    """通过框架 SimpleAgent 异步执行审核,返回文本结果"""
+    return await agent.arun(prompt)
+
+
+def build_react_agent(
+    name: str,
+    llm: HelloAgentsLLM,
+    registry: PaperMindToolRegistry,
+    system_prompt: str,
+    tool_names: Optional[list[str]] = None,
+    max_steps: int = 8,
+) -> ReActAgent:
+    """构建框架 ReActAgent:项目工具经桥接进入框架工具注册表"""
+    ha_registry = build_hello_agents_registry(registry, tool_names)
+    return ReActAgent(
+        name=name,
+        llm=llm,
+        tool_registry=ha_registry,
+        system_prompt=system_prompt,
+        max_steps=max_steps,
+    )
+
+
+async def run_react_task(
+    name: str,
+    llm: HelloAgentsLLM,
+    registry: PaperMindToolRegistry,
+    system_prompt: str,
+    task: str,
+    tool_names: Optional[list[str]] = None,
+    max_steps: int = 8,
+) -> dict[str, Any]:
+    """用框架 ReActAgent 执行单步任务,返回项目统一的结果结构
+
+    Returns:
+        {"agent": name, "result": str, "tool_calls": []}
+        (框架 ReActAgent 内部完成工具调度,工具明细由框架 TraceLogger 记录)
+    """
+    agent = build_react_agent(name, llm, registry, system_prompt, tool_names, max_steps)
+    result = await agent.arun(task)
+    return {"agent": name, "result": result, "tool_calls": []}

+ 593 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/agents/report_agent.py

@@ -0,0 +1,593 @@
+"""步骤7 整合输出 Agent:将前序步骤产物整合为结构化研究提案(Markdown 报告)
+
+输入:pipeline_results 含 papers_records / gaps / innovations / experiment_plans
+输出:{background_review, innovations, experiment_plans, references, markdown}
+"""
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any, Optional
+
+from backend.llm.client import DeepSeekClient
+from backend.llm.json_utils import parse_json_safe
+
+logger = logging.getLogger(__name__)
+
+# 模块级懒加载单例 DeepSeekClient
+_client: Optional[DeepSeekClient] = None
+
+
+def get_default_client() -> DeepSeekClient:
+    """懒加载 DeepSeek 客户端单例,供未显式注入 client 时使用"""
+    global _client
+    if _client is None:
+        _client = DeepSeekClient()
+    return _client
+
+
+class ReportAgent:
+    """步骤7 整合输出 Agent:调用 LLM 把前序产物整合为结构化研究提案
+
+    职责:
+    1. 基于 Gap 分析梳理领域背景综述;
+    2. 对每个创新点论证 Gap 来源 + 创新思路 + 三维评分 + 论据支撑;
+    3. 汇总每个创新点的完整实验方案;
+    4. 整理参考文献溯源(含 source_sections,可追溯至具体章节);
+    5. 输出 Markdown 格式报告字符串与结构化 dict。
+    """
+
+    def __init__(self, client: Optional[DeepSeekClient] = None) -> None:
+        # 未显式注入则使用模块级懒加载单例
+        self.client = client or get_default_client()
+
+    # ------------------------------------------------------------------
+    # 公共入口
+    # ------------------------------------------------------------------
+    async def generate_report(self, pipeline_results: dict) -> dict:
+        """整合前序步骤产物,生成结构化研究提案
+
+        输入 pipeline_results 字段:
+        - papers_records:结构化记录列表(PaperRecord dict)
+        - gaps:Gap 列表(Gap dict)
+        - innovations:创新点列表(Innovation dict)
+        - experiment_plans:实验方案列表(ExperimentPlan dict)
+
+        返回 dict:
+        - background_review:背景综述字符串
+        - innovations:创新点列表(含论据支撑)
+        - experiment_plans:实验方案列表
+        - references:参考文献溯源列表 [{title, path, sections}]
+        - markdown:完整 Markdown 报告字符串
+        """
+        import time as _time
+
+        _t_total = _time.perf_counter()
+        papers_records = pipeline_results.get("papers_records", []) or []
+        gaps = pipeline_results.get("gaps", []) or []
+        innovations = pipeline_results.get("innovations", []) or []
+        experiment_plans = pipeline_results.get("experiment_plans", []) or []
+
+        logger.info(
+            "[ReportAgent] 输入规模: papers=%d gaps=%d innovations=%d plans=%d",
+            len(papers_records), len(gaps), len(innovations), len(experiment_plans),
+        )
+
+        # 1. 构造整合提示词
+        _t_prompt0 = _time.perf_counter()
+        prompt = self._build_report_prompt(pipeline_results)
+        logger.info("[ReportAgent timing] 构造 prompt: %.3fs", _time.perf_counter() - _t_prompt0)
+
+        messages = [
+            {
+                "role": "system",
+                "content": (
+                    "你是学术研究提案撰写专家,擅长把多篇论文的 Gap 分析、创新点与实验方案"
+                    "整合为结构清晰、可追溯的研究提案。严格输出 JSON,不要输出任何额外说明文本。"
+                ),
+            },
+            {"role": "user", "content": prompt},
+        ]
+
+        # 2. 调用 LLM(ReportAgent 输出较长,显式放大 max_tokens 避免 JSON 被截断)
+        try:
+            _t_llm0 = _time.perf_counter()
+            response = await self.client.chat(messages=messages, max_tokens=8192)
+            content = response.choices[0].message.content or ""
+            # 记录 finish_reason,length 表示被 max_tokens 截断
+            finish_reason = response.choices[0].finish_reason
+            usage = getattr(response, "usage", None)
+            logger.info(
+                "[ReportAgent timing] LLM 调用: %.2fs, 输出 %d 字符, finish_reason=%s, usage=%s",
+                _time.perf_counter() - _t_llm0, len(content), finish_reason, usage,
+            )
+        except Exception as exc:
+            logger.warning("ReportAgent LLM 调用失败,降级为本地格式化: %s", exc)
+            content = ""
+
+        # 3. 解析 LLM 返回的结构化数据
+        _t_parse0 = _time.perf_counter()
+        structured_from_llm: dict = {}
+        if content:
+            parsed = parse_json_safe(content)
+            if isinstance(parsed, dict):
+                structured_from_llm = parsed
+            else:
+                logger.warning(
+                    "ReportAgent JSON 解析失败,原始内容前 200 字: %s",
+                    content[:200],
+                )
+
+        # 4. 组装最终结构化结果(LLM 输出优先,缺失字段用原始输入补齐)
+        background_review = (
+            structured_from_llm.get("background_review")
+            or self._build_default_background(gaps, papers_records)
+        )
+
+        # 创新点:保留原始输入,合并 LLM 补充的论据支撑
+        merged_innovations = self._merge_innovations(
+            innovations, structured_from_llm.get("innovations", [])
+        )
+
+        # 实验方案:优先用 LLM 输出,缺失则回退原始输入
+        merged_plans = self._merge_experiment_plans(
+            experiment_plans, structured_from_llm.get("experiment_plans", [])
+        )
+
+        # 参考文献溯源:从 papers_records 抽取,保证可追溯
+        references = self._build_references(papers_records)
+
+        # 5. 生成 Markdown 报告:LLM 已返回 markdown 则直接用,否则本地格式化
+        markdown = structured_from_llm.get("markdown") or ""
+        if not markdown.strip():
+            markdown = self._format_markdown(
+                {
+                    "background_review": background_review,
+                    "innovations": merged_innovations,
+                    "experiment_plans": merged_plans,
+                    "references": references,
+                }
+            )
+        logger.info(
+            "[ReportAgent timing] 解析+组装+markdown: %.3fs",
+            _time.perf_counter() - _t_parse0,
+        )
+
+        logger.info(
+            "[ReportAgent timing] 总耗时: %.2fs, markdown %d 字符",
+            _time.perf_counter() - _t_total, len(markdown),
+        )
+        return {
+            "background_review": background_review,
+            "innovations": merged_innovations,
+            "experiment_plans": merged_plans,
+            "references": references,
+            "markdown": markdown,
+        }
+
+    # ------------------------------------------------------------------
+    # 提示词构造
+    # ------------------------------------------------------------------
+    def _build_report_prompt(self, pipeline_results: dict) -> str:
+        """构造整合提示词(中文)
+
+        把 papers_records / gaps / innovations / experiment_plans 序列化为
+        可读文本,要求 LLM 输出严格 JSON。
+        """
+        papers_records = pipeline_results.get("papers_records", []) or []
+        gaps = pipeline_results.get("gaps", []) or []
+        innovations = pipeline_results.get("innovations", []) or []
+        experiment_plans = pipeline_results.get("experiment_plans", []) or []
+
+        # 论文记录精简版(含 source_sections 便于溯源)
+        papers_block = self._serialize_papers(papers_records)
+        gaps_block = self._serialize_gaps(gaps)
+        innovations_block = self._serialize_innovations(innovations)
+        plans_block = self._serialize_experiment_plans(experiment_plans)
+
+        # 推断研究主题:取首个创新点标题或首个 Gap 描述
+        topic = ""
+        if innovations:
+            topic = innovations[0].get("title", "")
+        if not topic and gaps:
+            topic = gaps[0].get("description", "")[:40]
+        if not topic:
+            topic = "未指定主题"
+
+        return f"""请基于以下前序步骤产物,整合为一份结构化研究提案。
+
+## 研究主题
+{topic}
+
+## 一、论文结构化记录(含 source_sections,可追溯)
+{papers_block}
+
+## 二、识别到的 Gap 列表
+{gaps_block}
+
+## 三、创新点列表(含三维评分)
+{innovations_block}
+
+## 四、实验方案列表
+{plans_block}
+
+## 整合任务
+1. 背景综述:基于 Gap 分析梳理领域现状与脉络,说明研究空白所在;
+2. 创新点论证:对每个创新点补充 Gap 来源 + 创新思路 + 三维评分 + 论据支撑(论据须引用具体论文或 Gap 证据);
+3. 实验方案:保留每个创新点的完整实验方案要素;
+4. 参考文献溯源:所有引用论文的来源标注,可追溯至具体章节(source_sections);
+5. Markdown 报告:按以下结构生成完整 Markdown 文本。
+
+## Markdown 报告结构要求
+```
+# 研究提案:[主题]
+## 一、背景综述
+...
+## 二、创新点论证
+### 创新点 1:[标题]
+- Gap 来源:...
+- 创新思路:...
+- 三维评分:新颖性 X / 可行性 X / 显著性 X
+- 论据支撑:...
+### 创新点 2:...
+## 三、实验方案
+### 创新点 1 实验方案
+- 研究假设:...
+- 数据集:...
+- 基线方法:...
+- 评估指标:...
+- 消融实验:...
+- 实验步骤:...
+- 预期结果:...
+- 风险:...
+## 四、参考文献溯源
+1. [论文标题] - 出处章节:...
+```
+
+## 输出要求
+严格输出 JSON,不要包含任何额外说明文本或代码块标记。格式如下:
+{{
+  "background_review": "背景综述文本(可含换行)",
+  "innovations": [
+    {{
+      "title": "创新点标题",
+      "idea": "创新思路",
+      "gap_origin": "Gap 来源描述",
+      "score": {{"novelty": 8.0, "feasibility": 7.5, "significance": 8.0}},
+      "supporting_evidence": "论据支撑,引用具体论文或 Gap 证据"
+    }}
+  ],
+  "experiment_plans": [
+    {{
+      "innovation_title": "对应创新点标题",
+      "hypothesis": "研究假设",
+      "datasets": ["数据集1"],
+      "baselines": ["基线方法1"],
+      "metrics": ["评估指标1"],
+      "ablation": ["消融实验1"],
+      "steps": ["实验步骤1"],
+      "expected_results": "预期结果",
+      "risks": "风险"
+    }}
+  ],
+  "references": [
+    {{"title": "论文标题", "path": "论文路径", "sections": ["出处章节1", "出处章节2"]}}
+  ],
+  "markdown": "完整 Markdown 报告字符串"
+}}
+
+注意:
+- references 必须可追溯至具体章节(source_sections);
+- 不得编造论文或证据,所有引用须来自上述论文记录;
+- 若某字段在输入中缺失,对应位置写"暂无"而非编造。"""
+
+    # ------------------------------------------------------------------
+    # Markdown 格式化(降级路径)
+    # ------------------------------------------------------------------
+    def _format_markdown(self, structured: dict) -> str:
+        """把结构化数据格式化为清晰 Markdown(LLM 未返回 markdown 时使用)"""
+        background_review = structured.get("background_review", "") or "暂无"
+        innovations = structured.get("innovations", []) or []
+        experiment_plans = structured.get("experiment_plans", []) or []
+        references = structured.get("references", []) or []
+
+        # 主题推断
+        topic = ""
+        if innovations:
+            topic = innovations[0].get("title", "")
+        if not topic:
+            topic = "未指定主题"
+
+        lines: list[str] = []
+        lines.append(f"# 研究提案:{topic}")
+        lines.append("")
+
+        # 一、背景综述
+        lines.append("## 一、背景综述")
+        lines.append(background_review.strip() or "暂无")
+        lines.append("")
+
+        # 二、创新点论证
+        lines.append("## 二、创新点论证")
+        if innovations:
+            for idx, inn in enumerate(innovations, 1):
+                title = inn.get("title", f"创新点{idx}")
+                idea = inn.get("idea", "暂无")
+                gap_origin = inn.get("gap_origin", "暂无")
+                score = inn.get("score", {}) or {}
+                novelty = score.get("novelty", "-")
+                feasibility = score.get("feasibility", "-")
+                significance = score.get("significance", "-")
+                evidence = inn.get("supporting_evidence", "暂无")
+
+                lines.append(f"### 创新点 {idx}:{title}")
+                lines.append(f"- Gap 来源:{gap_origin}")
+                lines.append(f"- 创新思路:{idea}")
+                lines.append(
+                    f"- 三维评分:新颖性 {novelty} / 可行性 {feasibility} / 显著性 {significance}"
+                )
+                lines.append(f"- 论据支撑:{evidence}")
+                lines.append("")
+        else:
+            lines.append("暂无创新点")
+            lines.append("")
+
+        # 三、实验方案
+        lines.append("## 三、实验方案")
+        if experiment_plans:
+            for idx, plan in enumerate(experiment_plans, 1):
+                inn_title = plan.get("innovation_title", f"创新点{idx}")
+                hypothesis = plan.get("hypothesis", "暂无")
+                datasets = plan.get("datasets", []) or []
+                baselines = plan.get("baselines", []) or []
+                metrics = plan.get("metrics", []) or []
+                ablation = plan.get("ablation", []) or []
+                steps = plan.get("steps", []) or []
+                expected = plan.get("expected_results", "暂无")
+                risks = plan.get("risks", "暂无")
+
+                lines.append(f"### 创新点 {idx} 实验方案({inn_title})")
+                lines.append(f"- 研究假设:{hypothesis}")
+                lines.append(f"- 数据集:{', '.join(datasets) if datasets else '暂无'}")
+                lines.append(
+                    f"- 基线方法:{', '.join(baselines) if baselines else '暂无'}"
+                )
+                lines.append(
+                    f"- 评估指标:{', '.join(metrics) if metrics else '暂无'}"
+                )
+                lines.append(
+                    f"- 消融实验:{'; '.join(ablation) if ablation else '暂无'}"
+                )
+                if steps:
+                    steps_text = "; ".join(steps)
+                else:
+                    steps_text = "暂无"
+                lines.append(f"- 实验步骤:{steps_text}")
+                lines.append(f"- 预期结果:{expected}")
+                lines.append(f"- 风险:{risks}")
+                lines.append("")
+        else:
+            lines.append("暂无实验方案")
+            lines.append("")
+
+        # 四、参考文献溯源
+        lines.append("## 四、参考文献溯源")
+        if references:
+            for idx, ref in enumerate(references, 1):
+                title = ref.get("title", "未知标题")
+                sections = ref.get("sections", []) or []
+                if sections:
+                    sections_text = "; ".join(sections)
+                else:
+                    sections_text = "未标注"
+                lines.append(f"{idx}. [{title}] - 出处章节:{sections_text}")
+        else:
+            lines.append("暂无参考文献")
+        lines.append("")
+
+        return "\n".join(lines)
+
+    # ------------------------------------------------------------------
+    # 私有辅助方法
+    # ------------------------------------------------------------------
+    def _serialize_papers(self, papers_records: list[dict]) -> str:
+        """把论文记录序列化为可读文本(含 source_sections)"""
+        if not papers_records:
+            return "(无论文记录)"
+
+        field_labels = {
+            "task_problem": "研究任务/问题",
+            "method": "核心方法",
+            "key_contributions": "主要贡献",
+            "datasets": "数据集",
+            "metrics": "评估指标",
+            "results": "实验结果",
+            "limitations": "局限性",
+            "future_work": "未来工作",
+        }
+
+        lines: list[str] = []
+        for idx, rec in enumerate(papers_records, 1):
+            title = rec.get("title", f"论文{idx}")
+            path = rec.get("path", "")
+            lines.append(f"----- 论文 {idx}: {title} (path={path}) -----")
+            for field, label in field_labels.items():
+                val = rec.get(field)
+                if val is None:
+                    continue
+                # FieldSource 结构:{value, source_sections, confidence}
+                if isinstance(val, dict):
+                    text = val.get("value", "")
+                    src = val.get("source_sections", []) or []
+                    src_text = "; ".join(src) if src else "未标注"
+                    lines.append(f"  [{label}] {text}  (出处章节: {src_text})")
+                else:
+                    lines.append(f"  [{label}] {val}")
+            lines.append("")
+        return "\n".join(lines)
+
+    def _serialize_gaps(self, gaps: list[dict]) -> str:
+        """把 Gap 列表序列化为可读文本"""
+        if not gaps:
+            return "(无 Gap)"
+
+        lines: list[str] = []
+        for idx, gap in enumerate(gaps, 1):
+            desc = gap.get("description", "")
+            gtype = gap.get("gap_type", "")
+            src = gap.get("source_papers", []) or []
+            evidence = gap.get("evidence", "")
+            conf = gap.get("confidence", "")
+            src_text = "; ".join(src) if src else "未标注"
+            lines.append(
+                f"Gap {idx} [{gtype}] (置信度={conf}): {desc}\n"
+                f"  来源论文: {src_text}\n"
+                f"  论证: {evidence}"
+            )
+        return "\n".join(lines)
+
+    def _serialize_innovations(self, innovations: list[dict]) -> str:
+        """把创新点列表序列化为可读文本"""
+        if not innovations:
+            return "(无创新点)"
+
+        lines: list[str] = []
+        for idx, inn in enumerate(innovations, 1):
+            title = inn.get("title", f"创新点{idx}")
+            idea = inn.get("idea", "")
+            source = inn.get("source", "")
+            gap_origin = inn.get("gap_origin", "")
+            score = inn.get("score", {}) or {}
+            novelty = score.get("novelty", "-")
+            feasibility = score.get("feasibility", "-")
+            significance = score.get("significance", "-")
+            novelty_check = inn.get("novelty_check", "")
+            evidence = inn.get("supporting_evidence", "")
+
+            lines.append(
+                f"创新点 {idx}: {title} (来源={source})\n"
+                f"  创新思路: {idea}\n"
+                f"  Gap 来源: {gap_origin}\n"
+                f"  三维评分: 新颖性 {novelty} / 可行性 {feasibility} / 显著性 {significance}\n"
+                f"  新颖性验证: {novelty_check}\n"
+                f"  论据支撑: {evidence}"
+            )
+        return "\n".join(lines)
+
+    def _serialize_experiment_plans(self, plans: list[dict]) -> str:
+        """把实验方案列表序列化为可读文本"""
+        if not plans:
+            return "(无实验方案)"
+
+        lines: list[str] = []
+        for idx, plan in enumerate(plans, 1):
+            inn_title = plan.get("innovation_title", f"创新点{idx}")
+            hypothesis = plan.get("hypothesis", "")
+            datasets = plan.get("datasets", []) or []
+            baselines = plan.get("baselines", []) or []
+            metrics = plan.get("metrics", []) or []
+            ablation = plan.get("ablation", []) or []
+            steps = plan.get("steps", []) or []
+            expected = plan.get("expected_results", "")
+            risks = plan.get("risks", "")
+
+            lines.append(
+                f"方案 {idx} (对应: {inn_title})\n"
+                f"  研究假设: {hypothesis}\n"
+                f"  数据集: {', '.join(datasets)}\n"
+                f"  基线方法: {', '.join(baselines)}\n"
+                f"  评估指标: {', '.join(metrics)}\n"
+                f"  消融实验: {'; '.join(ablation)}\n"
+                f"  实验步骤: {'; '.join(steps)}\n"
+                f"  预期结果: {expected}\n"
+                f"  风险: {risks}"
+            )
+        return "\n".join(lines)
+
+    def _build_default_background(self, gaps: list[dict], papers_records: list[dict]) -> str:
+        """LLM 未返回背景综述时,基于 Gap 与论文记录生成默认综述"""
+        if not gaps:
+            return (
+                f"本次分析共覆盖 {len(papers_records)} 篇论文,"
+                "未识别到显著跨论文 Gap,建议结合具体场景进一步分析。"
+            )
+
+        lines: list[str] = []
+        lines.append(
+            f"本次分析共覆盖 {len(papers_records)} 篇论文,识别到 {len(gaps)} 个研究空白:"
+        )
+        for idx, gap in enumerate(gaps, 1):
+            desc = gap.get("description", "")
+            gtype = gap.get("gap_type", "")
+            lines.append(f"{idx}. [{gtype}] {desc}")
+        return "\n".join(lines)
+
+    def _merge_innovations(
+        self, original: list[dict], from_llm: list[dict]
+    ) -> list[dict]:
+        """合并原始创新点与 LLM 补充的论据支撑
+
+        以原始输入为基准,按 title 匹配 LLM 输出,补充 supporting_evidence。
+        """
+        if not original:
+            return from_llm if isinstance(from_llm, list) else []
+
+        # 以 title 为键建立 LLM 输出索引
+        llm_index: dict[str, dict] = {}
+        for item in from_llm:
+            if isinstance(item, dict):
+                title = item.get("title", "")
+                if title:
+                    llm_index[title] = item
+
+        merged: list[dict] = []
+        for inn in original:
+            if not isinstance(inn, dict):
+                continue
+            title = inn.get("title", "")
+            llm_item = llm_index.get(title, {})
+            # LLM 补充的论据支撑优先,否则保留原始
+            evidence = llm_item.get("supporting_evidence") or inn.get(
+                "supporting_evidence", ""
+            )
+            merged_item = dict(inn)
+            if evidence:
+                merged_item["supporting_evidence"] = evidence
+            merged.append(merged_item)
+        return merged
+
+    def _merge_experiment_plans(
+        self, original: list[dict], from_llm: list[dict]
+    ) -> list[dict]:
+        """合并原始实验方案与 LLM 输出
+
+        优先使用 LLM 输出(若存在且非空),否则回退原始输入。
+        """
+        if isinstance(from_llm, list) and from_llm:
+            return from_llm
+        return original
+
+    def _build_references(self, papers_records: list[dict]) -> list[dict]:
+        """从 papers_records 抽取参考文献溯源列表
+
+        每条含 {title, path, sections},sections 汇总该论文所有字段的 source_sections,
+        保证可追溯至具体章节。
+        """
+        references: list[dict] = []
+        for rec in papers_records:
+            if not isinstance(rec, dict):
+                continue
+            title = rec.get("title", "未知标题")
+            path = rec.get("path", "")
+            sections: list[str] = []
+            # 遍历所有 FieldSource 字段,收集 source_sections
+            for key, val in rec.items():
+                if isinstance(val, dict) and "source_sections" in val:
+                    src = val.get("source_sections", []) or []
+                    for s in src:
+                        if s and s not in sections:
+                            sections.append(s)
+            references.append(
+                {"title": title, "path": path, "sections": sections}
+            )
+        return references

+ 128 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/agents/specialized.py

@@ -0,0 +1,128 @@
+"""6 个专职 Agent:每个绑定角色提示词与工具子集"""
+from __future__ import annotations
+
+from backend.agents.base import BaseAgent
+from backend.llm.client import DeepSeekClient
+from backend.tools.base import ToolRegistry
+
+
+class PaperParserAgent(BaseAgent):
+    """步骤1:扫描文件夹并解析 PDF 为结构化文本"""
+
+    def __init__(self, client: DeepSeekClient, registry: ToolRegistry):
+        super().__init__(
+            name="PaperParser",
+            role=(
+                "你是论文解析专家。你的任务是扫描本地文件夹中的 PDF 论文,"
+                "使用 parse_pdf 工具将每篇 PDF 解析为保留章节结构的文本。"
+                "输出格式:每篇论文含 {path, title, sections:[{heading, content, figure_captions}]}。"
+                "若某篇解析失败,记录错误并跳过,继续处理其余论文。"
+                "你可以自主决定调用顺序,支持并行处理多篇。"
+            ),
+            client=client,
+            registry=registry,
+            tool_names=["scan_folder", "parse_pdf"],
+        )
+
+
+class ExtractorAgent(BaseAgent):
+    """步骤2:单篇论文结构化抽取(核心主干)"""
+
+    def __init__(self, client: DeepSeekClient, registry: ToolRegistry):
+        super().__init__(
+            name="Extractor",
+            role=(
+                "你是论文结构化抽取专家。你的任务是对每篇已解析论文调用 extract_paper_structure 工具,"
+                "抽取固定 schema 的结构化记录(title/task_problem/method/key_contributions/"
+                "datasets/metrics/results/limitations/future_work),每字段标注 source_sections 与 confidence。"
+                "limitations 是重点字段,必须是论文明确承认或可从结果推断的,不允许臆造。"
+                "缺失字段触发针对性补抽。可调用 hybrid_search 回溯原文细节。"
+                "每篇结果独立缓存,失败可单独重跑。"
+            ),
+            client=client,
+            registry=registry,
+            tool_names=["extract_paper_structure", "hybrid_search"],
+        )
+
+
+class IndexerAgent(BaseAgent):
+    """步骤3:向量索引构建"""
+
+    def __init__(self, client: DeepSeekClient, registry: ToolRegistry):
+        super().__init__(
+            name="Indexer",
+            role=(
+                "你是向量索引构建专家。你的任务是对已解析论文调用 build_vector_index 工具,"
+                "将论文全文按章节分块向量化存入 Chroma 向量库,为后续混合搜索提供点查询能力。"
+                "索引构建是增强能力,失败时可降级(跳过 RAG 仅用结构化字段)。"
+            ),
+            client=client,
+            registry=registry,
+            tool_names=["build_vector_index"],
+        )
+
+
+class GapAnalyzerAgent(BaseAgent):
+    """步骤4:跨论文综合分析与 Gap 识别"""
+
+    def __init__(self, client: DeepSeekClient, registry: ToolRegistry):
+        super().__init__(
+            name="GapAnalyzer",
+            role=(
+                "你是研究空白(Gap)识别专家。你的任务是对结构化字段调用 analyze_gaps 工具,"
+                "识别四类 Gap 信号:重复局限、方法空白、矛盾结论、未兑现的未来工作。"
+                "需要原文细节佐证时调用 hybrid_search 检索相关段落。"
+                "输出候选 Gap 列表,每个 Gap 标注来源论文、Gap 类型、论证与置信度。"
+            ),
+            client=client,
+            registry=registry,
+            tool_names=["analyze_gaps", "hybrid_search"],
+        )
+
+
+class InnovationGeneratorAgent(BaseAgent):
+    """步骤5:创新点生成与筛选"""
+
+    def __init__(self, client: DeepSeekClient, registry: ToolRegistry):
+        super().__init__(
+            name="InnovationGenerator",
+            role=(
+                "你是创新点生成专家。你的任务是对候选 Gap 调用 generate_innovations 工具,"
+                "生成四类来源的创新方向(方法组合/局限改进/跨域迁移/新场景应用),"
+                "用三维评分(新颖性/可行性/显著性)筛选,取综合得分最高的 2-3 个。"
+                "调用 web_search 检索近 1-2 年相关工作做新颖性去重。"
+                "调用 load_memory 加载历史创新点避免重复,调用 save_memory 保存新创新点。"
+            ),
+            client=client,
+            registry=registry,
+            tool_names=["generate_innovations", "web_search", "load_memory", "save_memory"],
+        )
+
+
+class ExperimentDesignerAgent(BaseAgent):
+    """步骤6:实验方案设计"""
+
+    def __init__(self, client: DeepSeekClient, registry: ToolRegistry):
+        super().__init__(
+            name="ExperimentDesigner",
+            role=(
+                "你是实验方案设计专家。你的任务是对每个创新点调用 design_experiments 工具,"
+                "输出可执行研究方案:研究假设、数据集、基线方法、评估指标、消融实验、"
+                "实验步骤、预期结果与风险。方案须具体可执行。"
+            ),
+            client=client,
+            registry=registry,
+            tool_names=["design_experiments"],
+        )
+
+
+def build_all_specialized_agents(client: DeepSeekClient, registry: ToolRegistry) -> dict:
+    """构建全部 6 个专职 Agent,返回 name->agent 字典"""
+    return {
+        "PaperParser": PaperParserAgent(client, registry),
+        "Extractor": ExtractorAgent(client, registry),
+        "Indexer": IndexerAgent(client, registry),
+        "GapAnalyzer": GapAnalyzerAgent(client, registry),
+        "InnovationGenerator": InnovationGeneratorAgent(client, registry),
+        "ExperimentDesigner": ExperimentDesignerAgent(client, registry),
+    }

+ 4 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/api/__init__.py

@@ -0,0 +1,4 @@
+"""API 模块:FastAPI 异步接口"""
+from backend.api.main import app
+
+__all__ = ["app"]

+ 97 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/api/main.py

@@ -0,0 +1,97 @@
+"""FastAPI 应用入口:挂载路由、配置 CORS、启动 uvicorn
+
+启动方式:
+    python run_backend.py
+    或
+    uvicorn backend.api.main:app --host 0.0.0.0 --port 8000 --reload
+"""
+from __future__ import annotations
+
+import logging
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from backend.api.routes import router
+
+# 配置日志
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+app = FastAPI(
+    title="Paper Innovation Agent API",
+    description="论文创新 Agent 异步接口:提交分析、SSE 进度推送、报告查询",
+    version="1.0.0",
+)
+
+# 配置 CORS:允许前端 localhost:5173 访问
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=[
+        "http://localhost:5173",
+        "http://127.0.0.1:5173",
+    ],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# 挂载路由
+app.include_router(router)
+
+
+@app.on_event("startup")
+async def on_startup() -> None:
+    """应用启动日志 + 预加载重型模块
+
+    预加载 torch/transformers/chromadb 等重型依赖,避免首次处理论文时
+    才触发 import(实测 import torch 单独就要 100+ 秒)。
+    """
+    import time as _t
+
+    _t0 = _t.perf_counter()
+    logger.info("Paper Innovation Agent API 已启动,开始预加载重型模块...")
+
+    # 顺序预加载:torch → transformers → chromadb → embedding(含模型加载)
+    try:
+        _t1 = _t.perf_counter()
+        import torch  # noqa: F401
+        logger.info("[预加载] import torch: %.2fs", _t.perf_counter() - _t1)
+
+        _t2 = _t.perf_counter()
+        from transformers import AutoModel, AutoTokenizer  # noqa: F401
+        logger.info("[预加载] import transformers: %.2fs", _t.perf_counter() - _t2)
+
+        _t3 = _t.perf_counter()
+        import chromadb  # noqa: F401
+        logger.info("[预加载] import chromadb: %.2fs", _t.perf_counter() - _t3)
+
+        # 预加载 Embedder 单例(首次会触发模型加载 + CUDA 上下文初始化)
+        _t4 = _t.perf_counter()
+        from backend.rag.embedding import get_default_embedder
+        _embedder = get_default_embedder()  # 注册为模块级单例
+        # 触发模型加载 + 首次 forward(完成 CUDA 上下文初始化)
+        _embedder.embed_texts(["预加载测试文本"])
+        logger.info(
+            "[预加载] Embedder 模型加载 + CUDA warmup: %.2fs (device=%s)",
+            _t.perf_counter() - _t4,
+            getattr(_embedder, "_device", "unknown"),
+        )
+    except Exception as exc:
+        logger.warning("[预加载] 失败(不影响启动): %s", exc)
+
+    logger.info("[预加载] 全部完成: %.2fs", _t.perf_counter() - _t0)
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(
+        "backend.api.main:app",
+        host="0.0.0.0",
+        port=8000,
+        reload=False,
+    )

+ 428 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/api/routes.py

@@ -0,0 +1,428 @@
+"""FastAPI 路由:分析任务提交、SSE 进度推送、报告查询、健康检查、论文上传与管理
+
+后台分析用 asyncio.create_task 启动,不阻塞 API 响应;
+SSE 用 sse_starlette.EventSourceResponse,从 task_manager 事件历史推送。
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+import shutil
+import time
+from pathlib import Path
+from typing import Any, Optional
+
+from fastapi import APIRouter, File, HTTPException, UploadFile
+from pydantic import BaseModel, Field
+from sse_starlette.sse import EventSourceResponse
+
+from backend.agents.report_agent import ReportAgent
+from backend.api.tasks import task_manager
+from backend.config import settings
+from backend.evaluator.evaluator import Evaluator
+from backend.llm.client import DeepSeekClient
+from backend.memory.manager import MemoryManager
+from backend.orchestrator.workflow import WorkflowOrchestrator
+from backend.storage.paper_library import compute_paper_id, get_paper_library
+from backend.tools.registry import build_default_registry
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api", tags=["paper-innovation"])
+
+
+# ---------------------------------------------------------------------- #
+# 请求模型
+# ---------------------------------------------------------------------- #
+
+class AnalyzeRequest(BaseModel):
+    """POST /api/analyze 请求体"""
+    folder_path: Optional[str] = Field(default=None, description="待分析的 PDF 文件夹路径(与 paper_ids 二选一)")
+    paper_ids: Optional[list[str]] = Field(default=None, description="上传论文 ID 列表(与 folder_path 二选一)")
+    research_direction: Optional[str] = Field(default=None, description="用户研究方向(可选)")
+
+
+# ---------------------------------------------------------------------- #
+# 后台分析函数
+# ---------------------------------------------------------------------- #
+
+async def run_analysis(
+    task_id: str,
+    folder_path: Optional[str] = None,
+    paper_ids: Optional[list[str]] = None,
+    research_direction: Optional[str] = None,
+) -> None:
+    """后台分析主流程:编排工作流 → 生成报告 → 生成评估 → 更新任务状态
+
+    Args:
+        task_id: 任务 ID
+        folder_path: PDF 文件夹路径(与 paper_ids 二选一)
+        paper_ids: 上传论文 ID 列表(与 folder_path 二选一)
+        research_direction: 用户研究方向(可选)
+    """
+    logger.info(
+        "启动后台分析: task_id=%s, folder=%s, paper_ids=%d, direction=%s",
+        task_id, folder_path or "N/A", len(paper_ids or []),
+        "有" if research_direction else "无",
+    )
+    try:
+        # 标记为运行中
+        task_manager.update_task(
+            task_id, status="running", progress=0.0, current_stage=None
+        )
+
+        # 初始化组件:DeepSeek 客户端 + 工具注册表 + 记忆管理器
+        client = DeepSeekClient()
+        registry = build_default_registry()
+        memory = MemoryManager()
+        orchestrator = WorkflowOrchestrator(client, registry, memory)
+
+        # 进度回调:更新任务状态 + 追加事件
+        async def progress_callback(
+            stage: str,
+            status: str,
+            message: str,
+            progress: float,
+            payload: Optional[dict] = None,
+        ) -> None:
+            task_manager.update_task(
+                task_id, progress=progress, current_stage=stage
+            )
+            task_manager.add_event(
+                task_id,
+                {
+                    "stage": stage,
+                    "status": status,
+                    "message": message,
+                    "progress": progress,
+                    "payload": payload,
+                },
+            )
+
+        # 执行工作流流水线
+        _t_pipe0 = time.perf_counter()
+        pipeline_output = await orchestrator.run_pipeline(
+            folder_path=folder_path,
+            paper_ids=paper_ids,
+            research_direction=research_direction,
+            progress_callback=progress_callback,
+        )
+        logger.info("[task timing] run_pipeline: %.2fs", time.perf_counter() - _t_pipe0)
+        final_results = pipeline_output.get("final_results", {}) or {}
+        evaluation_data = pipeline_output.get("evaluation_data", {}) or {}
+
+        # 用 ReportAgent 生成最终报告
+        _t_rep0 = time.perf_counter()
+        report_agent = ReportAgent(client=client)
+        report = await report_agent.generate_report(final_results)
+        logger.info("[task timing] ReportAgent.generate_report: %.2fs", time.perf_counter() - _t_rep0)
+
+        # 用 Evaluator 生成评估
+        _t_eval0 = time.perf_counter()
+        evaluator = Evaluator(client=client)
+        evaluation = await evaluator.evaluate(
+            final_results,
+            evaluation_data.get("tool_call_records", []),
+            evaluation_data.get("confidence_stats", {}),
+        )
+        logger.info("[task timing] Evaluator.evaluate: %.2fs", time.perf_counter() - _t_eval0)
+
+        # 存储最终结果,标记完成
+        task_manager.update_task(
+            task_id,
+            status="completed",
+            progress=1.0,
+            result={
+                "markdown": report.get("markdown", ""),
+                "report": report,
+                "evaluation": evaluation,
+            },
+        )
+        logger.info("[task timing] 任务完成: task_id=%s", task_id)
+
+    except Exception as exc:
+        logger.error(
+            "任务失败: task_id=%s, error=%s", task_id, exc, exc_info=True
+        )
+        task_manager.update_task(task_id, status="failed", error=str(exc))
+
+
+# ---------------------------------------------------------------------- #
+# 路由
+# ---------------------------------------------------------------------- #
+
+@router.post("/analyze")
+async def analyze(request: AnalyzeRequest) -> dict:
+    """提交分析任务:创建 task_id 并后台启动,立即返回 task_id
+
+    Args:
+        request: 含 folder_path 或 paper_ids + 可选 research_direction 的请求体
+
+    Returns:
+        {"task_id": str}
+    """
+    # 校验:folder_path 与 paper_ids 至少提供一个
+    if not request.folder_path and not request.paper_ids:
+        raise HTTPException(
+            status_code=400,
+            detail="必须提供 folder_path 或 paper_ids 之一",
+        )
+
+    # 创建任务
+    task_id = task_manager.create_task(
+        folder_path=request.folder_path,
+        paper_ids=request.paper_ids,
+        research_direction=request.research_direction,
+    )
+
+    # 后台启动分析(不阻塞响应)
+    asyncio.create_task(
+        run_analysis(
+            task_id,
+            folder_path=request.folder_path,
+            paper_ids=request.paper_ids,
+            research_direction=request.research_direction,
+        )
+    )
+
+    return {"task_id": task_id}
+
+
+# ---------------------------------------------------------------------- #
+# 论文上传与管理
+# ---------------------------------------------------------------------- #
+
+@router.post("/upload")
+async def upload_paper(file: UploadFile = File(...)) -> dict:
+    """上传 PDF 论文
+
+    保存到 data/uploads/{paper_id}.pdf,注册到论文库。
+    同一文件重复上传返回 duplicate=true。
+
+    Args:
+        file: PDF 文件
+
+    Returns:
+        {"paper_id": str, "filename": str, "duplicate": bool}
+    """
+    if not file.filename or not file.filename.lower().endswith(".pdf"):
+        raise HTTPException(status_code=400, detail="仅支持 PDF 文件")
+
+    # 保存到临时文件以计算内容哈希
+    tmp_path = settings.UPLOADS_DIR / f"tmp_{file.filename}"
+    try:
+        with open(tmp_path, "wb") as f:
+            shutil.copyfileobj(file.file, f)
+
+        # 计算内容哈希作为 paper_id
+        paper_id = compute_paper_id(str(tmp_path))
+
+        # 检查是否已存在
+        library = get_paper_library()
+        existing = library.get(paper_id)
+        duplicate = existing is not None
+
+        # 移动到正式存储路径
+        final_path = settings.UPLOADS_DIR / f"{paper_id}.pdf"
+        if not final_path.exists():
+            shutil.move(str(tmp_path), str(final_path))
+        else:
+            # 已存在同名文件,删除临时文件
+            tmp_path.unlink(missing_ok=True)
+
+        # 注册到论文库
+        library.register(
+            paper_id=paper_id,
+            filename=file.filename,
+            source="upload",
+            original_path=str(final_path),
+        )
+
+        logger.info("上传论文: paper_id=%s, filename=%s, duplicate=%s", paper_id[:12], file.filename, duplicate)
+        return {
+            "paper_id": paper_id,
+            "filename": file.filename,
+            "duplicate": duplicate,
+        }
+    except HTTPException:
+        raise
+    except Exception as exc:
+        logger.error("上传论文失败: %s", exc, exc_info=True)
+        # 清理临时文件
+        tmp_path.unlink(missing_ok=True)
+        raise HTTPException(status_code=500, detail=f"上传失败: {exc}")
+
+
+@router.get("/papers")
+async def list_papers() -> dict:
+    """列出论文库全部论文及预处理状态
+
+    Returns:
+        {"papers": [PaperMetadata]}
+    """
+    library = get_paper_library()
+    papers = library.list_all()
+    return {"papers": papers}
+
+
+@router.delete("/papers/{paper_id}")
+async def delete_paper(paper_id: str) -> dict:
+    """删除论文:移除库记录 + 缓存文件 + Chroma chunks + 上传原文件
+
+    Args:
+        paper_id: 论文 ID
+
+    Returns:
+        {"deleted": bool, "paper_id": str}
+    """
+    library = get_paper_library()
+    deleted = library.delete(paper_id)
+    if not deleted:
+        raise HTTPException(status_code=404, detail=f"论文 {paper_id} 不存在")
+    return {"deleted": True, "paper_id": paper_id}
+
+
+@router.get("/progress/{task_id}")
+async def progress(task_id: str) -> EventSourceResponse:
+    """SSE 流:推送任务进度事件,任务结束时推送 done 事件并关闭
+
+    Args:
+        task_id: 任务 ID
+
+    Returns:
+        EventSourceResponse:逐条推送 {stage, status, message, progress, payload}
+    """
+    task = task_manager.get_task(task_id)
+    if task is None:
+        raise HTTPException(status_code=404, detail=f"任务 {task_id} 不存在")
+
+    async def event_generator():
+        """SSE 事件生成器:从事件历史增量推送,任务结束发 done"""
+        last_index = 0
+        while True:
+            # 1. 排空所有未发送事件
+            events = task_manager.get_events(task_id)
+            while last_index < len(events):
+                event = events[last_index]
+                last_index += 1
+                yield {
+                    "event": "progress",
+                    "data": json.dumps(event, ensure_ascii=False, default=str),
+                }
+
+            # 2. 检查任务是否结束
+            current = task_manager.get_task(task_id)
+            if current is None:
+                yield {
+                    "event": "error",
+                    "data": json.dumps(
+                        {"message": "任务不存在"}, ensure_ascii=False
+                    ),
+                }
+                return
+            if current["status"] in ("completed", "failed"):
+                yield {
+                    "event": "done",
+                    "data": json.dumps(
+                        {
+                            "status": current["status"],
+                            "task_id": task_id,
+                            "progress": current.get("progress", 0.0),
+                            "error": current.get("error"),
+                        },
+                        ensure_ascii=False,
+                        default=str,
+                    ),
+                }
+                return
+
+            # 3. 清除通知标志后再次检查事件,避免竞态漏推
+            notifier = task_manager.get_notifier(task_id)
+            if notifier is not None:
+                notifier.clear()
+                # 清除后若有新事件,回到循环顶部发送
+                events = task_manager.get_events(task_id)
+                if last_index < len(events):
+                    continue
+                # 等待新事件到达(带超时作为 keepalive)
+                try:
+                    await asyncio.wait_for(notifier.wait(), timeout=15.0)
+                except asyncio.TimeoutError:
+                    # 超时发送 keepalive 注释,保持连接
+                    yield {"comment": "keepalive"}
+            else:
+                # 无通知器则短睡后重试
+                await asyncio.sleep(0.5)
+
+    return EventSourceResponse(event_generator(), ping=15)
+
+
+@router.get("/report/{task_id}")
+async def report(task_id: str) -> dict:
+    """获取最终报告
+
+    Args:
+        task_id: 任务 ID
+
+    Returns:
+        {markdown, report, evaluation, status}
+    """
+    task = task_manager.get_task(task_id)
+    if task is None:
+        raise HTTPException(status_code=404, detail=f"任务 {task_id} 不存在")
+
+    status = task.get("status")
+    result = task.get("result") or {}
+
+    if status == "completed":
+        return {
+            "markdown": result.get("markdown", ""),
+            "report": result.get("report", {}),
+            "evaluation": result.get("evaluation", {}),
+            "status": status,
+        }
+    elif status == "failed":
+        raise HTTPException(
+            status_code=500,
+            detail=f"任务失败: {task.get('error', '未知错误')}",
+        )
+    else:
+        # pending / running:返回当前进度状态
+        return {
+            "markdown": "",
+            "report": {},
+            "evaluation": {},
+            "status": status,
+            "progress": task.get("progress", 0.0),
+            "current_stage": task.get("current_stage"),
+        }
+
+
+@router.get("/tasks/{task_id}")
+async def task_status(task_id: str) -> dict:
+    """获取任务状态
+
+    Args:
+        task_id: 任务 ID
+
+    Returns:
+        {task_id, status, progress, current_stage}
+    """
+    task = task_manager.get_task(task_id)
+    if task is None:
+        raise HTTPException(status_code=404, detail=f"任务 {task_id} 不存在")
+
+    return {
+        "task_id": task_id,
+        "status": task.get("status", "pending"),
+        "progress": task.get("progress", 0.0),
+        "current_stage": task.get("current_stage"),
+    }
+
+
+@router.get("/health")
+async def health() -> dict:
+    """健康检查"""
+    return {"status": "ok", "model": settings.DEEPSEEK_MODEL}

+ 151 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/api/tasks.py

@@ -0,0 +1,151 @@
+"""异步任务管理器:维护内存中任务状态与进度事件,供 SSE 推送使用
+
+任务状态机:pending → running → completed / failed
+每个任务附带一个 asyncio.Event 通知器,add_event / update_task 时触发,
+SSE 生成器据此感知新事件到达,避免忙轮询。
+"""
+from __future__ import annotations
+
+import asyncio
+import logging
+import uuid
+from datetime import datetime
+from typing import Any, Optional
+
+logger = logging.getLogger(__name__)
+
+# 合法的任务状态
+TASK_STATUSES = ("pending", "running", "completed", "failed")
+
+
+class TaskManager:
+    """内存级任务管理器(单进程内有效)
+
+    任务状态 dict 结构:
+        {
+            "task_id": str,
+            "folder_path": str,
+            "status": "pending" | "running" | "completed" | "failed",
+            "progress": float,            # 整体进度 0-1
+            "current_stage": str | None,  # 当前步骤 stage
+            "result": dict | None,        # 完成后的最终结果 {markdown, report, evaluation}
+            "error": str | None,          # 失败时的错误信息
+            "events": list[dict],         # 进度事件历史
+            "created_at": str,            # ISO 时间戳
+            "updated_at": str,            # ISO 时间戳
+        }
+    """
+
+    def __init__(self) -> None:
+        self._tasks: dict[str, dict] = {}
+        # 每个任务一个通知器,用于 SSE 生成器等待新事件
+        self._notifiers: dict[str, asyncio.Event] = {}
+
+    # ------------------------------------------------------------------ #
+    # 任务生命周期
+    # ------------------------------------------------------------------ #
+
+    def create_task(
+        self,
+        folder_path: Optional[str] = None,
+        paper_ids: Optional[list[str]] = None,
+        research_direction: Optional[str] = None,
+    ) -> str:
+        """创建新任务,返回 task_id(uuid)
+
+        Args:
+            folder_path: 待分析的 PDF 文件夹路径(与 paper_ids 二选一)
+            paper_ids: 上传论文 ID 列表(与 folder_path 二选一)
+            research_direction: 用户研究方向(可选)
+
+        Returns:
+            新生成的 task_id
+        """
+        task_id = str(uuid.uuid4())
+        now = datetime.now().isoformat()
+        self._tasks[task_id] = {
+            "task_id": task_id,
+            "folder_path": folder_path or "",
+            "paper_ids": paper_ids or [],
+            "research_direction": research_direction or "",
+            "status": "pending",
+            "progress": 0.0,
+            "current_stage": None,
+            "result": None,
+            "error": None,
+            "events": [],
+            "created_at": now,
+            "updated_at": now,
+        }
+        self._notifiers[task_id] = asyncio.Event()
+        logger.info(
+            "创建任务: task_id=%s, folder=%s, paper_ids=%d, direction=%s",
+            task_id, folder_path or "N/A", len(paper_ids or []),
+            "有" if research_direction else "无",
+        )
+        return task_id
+
+    def update_task(self, task_id: str, **kwargs: Any) -> None:
+        """更新任务状态字段(任意关键字参数)
+
+        Args:
+            task_id: 任务 ID
+            **kwargs: 需更新的字段,如 status / progress / current_stage / result / error
+        """
+        task = self._tasks.get(task_id)
+        if task is None:
+            logger.warning("更新任务失败:task_id=%s 不存在", task_id)
+            return
+        task.update(kwargs)
+        task["updated_at"] = datetime.now().isoformat()
+        # 触发通知器,唤醒等待中的 SSE 生成器
+        self._notify(task_id)
+
+    def add_event(self, task_id: str, event: dict) -> None:
+        """追加进度事件到任务事件历史
+
+        Args:
+            task_id: 任务 ID
+            event: 进度事件 dict,含 {stage, status, message, progress, payload}
+        """
+        task = self._tasks.get(task_id)
+        if task is None:
+            logger.warning("添加事件失败:task_id=%s 不存在", task_id)
+            return
+        task["events"].append(event)
+        task["updated_at"] = datetime.now().isoformat()
+        # 触发通知器
+        self._notify(task_id)
+
+    # ------------------------------------------------------------------ #
+    # 查询
+    # ------------------------------------------------------------------ #
+
+    def get_task(self, task_id: str) -> Optional[dict]:
+        """获取任务完整状态 dict,不存在返回 None"""
+        return self._tasks.get(task_id)
+
+    def get_events(self, task_id: str) -> list[dict]:
+        """获取任务进度事件列表,不存在返回空列表"""
+        task = self._tasks.get(task_id)
+        if task is None:
+            return []
+        return task.get("events", [])
+
+    def get_notifier(self, task_id: str) -> Optional[asyncio.Event]:
+        """获取任务的通知器(供 SSE 生成器 await),不存在返回 None"""
+        return self._notifiers.get(task_id)
+
+    # ------------------------------------------------------------------ #
+    # 内部辅助
+    # ------------------------------------------------------------------ #
+
+    def _notify(self, task_id: str) -> None:
+        """触发任务通知器,唤醒等待中的 SSE 生成器"""
+        notifier = self._notifiers.get(task_id)
+        if notifier is not None:
+            notifier.set()
+
+
+# 模块级单例,供路由与后台任务共享
+task_manager = TaskManager()

+ 51 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/config.py

@@ -0,0 +1,51 @@
+"""全局配置:从 .env 读取"""
+import os
+from pathlib import Path
+from dotenv import load_dotenv
+
+load_dotenv(Path(__file__).resolve().parent.parent / ".env", override=True)
+
+
+class Settings:
+    # DeepSeek
+    DEEPSEEK_API_KEY: str = os.getenv("DEEPSEEK_API_KEY", "")
+    DEEPSEEK_BASE_URL: str = os.getenv("DEEPSEEK_BASE_URL", "https://api.deepseek.com")
+    DEEPSEEK_MODEL: str = os.getenv("DEEPSEEK_MODEL", "deepseek-chat")
+
+    # Embedding:默认使用本地已下载的 bge-large-zh-v1.5
+    # 如需使用其他模型,在 .env 中覆盖 EMBEDDING_MODEL
+    EMBEDDING_MODEL: str = os.getenv("EMBEDDING_MODEL", "BAAI/bge-large-zh-v1.5")
+
+    # 路径
+    BASE_DIR: Path = Path(__file__).resolve().parent.parent
+    CHROMA_PATH: Path = Path(os.getenv("CHROMA_PATH", "./data/chroma"))
+    CACHE_DIR: Path = Path(os.getenv("CACHE_DIR", "./data/cache"))
+    REPORT_DIR: Path = Path(os.getenv("REPORT_DIR", "./data/reports"))
+    UPLOADS_DIR: Path = Path(os.getenv("UPLOADS_DIR", "./data/uploads"))
+
+    # 超时与重试
+    LLM_TIMEOUT: int = int(os.getenv("LLM_TIMEOUT", "120"))
+    LLM_TEMPERATURE: float = float(os.getenv("LLM_TEMPERATURE", "1.0"))
+    PDF_PARSE_TIMEOUT: int = int(os.getenv("PDF_PARSE_TIMEOUT", "60"))
+    TOOL_MAX_RETRIES: int = int(os.getenv("TOOL_MAX_RETRIES", "3"))
+
+    # Reflexion
+    CONFIDENCE_THRESHOLD: float = float(os.getenv("CONFIDENCE_THRESHOLD", "0.7"))
+
+    # 并发
+    MAX_CONCURRENT_PAPERS: int = int(os.getenv("MAX_CONCURRENT_PAPERS", "5"))
+
+    # 联网搜索
+    WEB_SEARCH_BACKEND: str = os.getenv("WEB_SEARCH_BACKEND", "duckduckgo")
+
+    def ensure_dirs(self):
+        for d in (self.CHROMA_PATH, self.CACHE_DIR, self.REPORT_DIR, self.UPLOADS_DIR):
+            d.mkdir(parents=True, exist_ok=True)
+
+
+settings = Settings()
+settings.CHROMA_PATH = settings.BASE_DIR / settings.CHROMA_PATH if not settings.CHROMA_PATH.is_absolute() else settings.CHROMA_PATH
+settings.CACHE_DIR = settings.BASE_DIR / settings.CACHE_DIR if not settings.CACHE_DIR.is_absolute() else settings.CACHE_DIR
+settings.REPORT_DIR = settings.BASE_DIR / settings.REPORT_DIR if not settings.REPORT_DIR.is_absolute() else settings.REPORT_DIR
+settings.UPLOADS_DIR = settings.BASE_DIR / settings.UPLOADS_DIR if not settings.UPLOADS_DIR.is_absolute() else settings.UPLOADS_DIR
+settings.ensure_dirs()

+ 6 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/evaluator/__init__.py

@@ -0,0 +1,6 @@
+"""评估模块:输出质量评分 + 工具调用追踪"""
+from backend.evaluator.evaluator import Evaluator
+from backend.evaluator.quality import QualityEvaluator
+from backend.evaluator.tracker import ToolCallTracker
+
+__all__ = ["ToolCallTracker", "QualityEvaluator", "Evaluator"]

+ 149 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/evaluator/evaluator.py

@@ -0,0 +1,149 @@
+"""评估汇总:组合工具调用追踪与输出质量评估,产出统一评估结果"""
+from __future__ import annotations
+
+import logging
+from typing import Optional
+
+from backend.evaluator.quality import QualityEvaluator
+from backend.evaluator.tracker import ToolCallTracker
+from backend.llm.client import DeepSeekClient
+from backend.models.schemas import EvaluationReport, ThreeDScore, ToolCallRecord
+
+logger = logging.getLogger(__name__)
+
+
+class Evaluator:
+    """评估汇总器:组合 ToolCallTracker + QualityEvaluator"""
+
+    def __init__(
+        self,
+        tracker: Optional[ToolCallTracker] = None,
+        quality: Optional[QualityEvaluator] = None,
+        client: Optional[DeepSeekClient] = None,
+    ) -> None:
+        self.tracker = tracker or ToolCallTracker()
+        # 优先复用传入的 quality;否则用 client 构造(client 为 None 时 quality 内部走单例)
+        self.quality = quality or QualityEvaluator(client=client)
+
+    async def evaluate(
+        self,
+        pipeline_results: dict,
+        tool_call_records: list[dict],
+        confidence_stats: dict,
+    ) -> dict:
+        """汇总评估:创新点三维评分、工具调用成功率、平均置信度
+
+        参数:
+            pipeline_results: 流水线产出,至少包含 innovations 列表与可选的 final_report
+            tool_call_records: Controller 累计的工具调用记录 dict 列表
+            confidence_stats: 自校验置信度统计,形如 {avg_confidence, ...}
+
+        返回:
+            {innovations_scores, tool_call_success_rate, total_tool_calls,
+             failed_tool_calls, avg_confidence, tool_calls, quality_assessment}
+        """
+        # 1. 录入工具调用记录
+        for rec in tool_call_records or []:
+            self.tracker.record_from_dict(rec)
+
+        summary = self.tracker.summary()
+        tool_call_success_rate = summary["success_rate"]
+        total_tool_calls = summary["total"]
+        failed_tool_calls = summary["failed"]
+
+        # 2. 创新点三维评分
+        innovations = (
+            pipeline_results.get("innovations", [])
+            if isinstance(pipeline_results, dict)
+            else []
+        )
+        if not isinstance(innovations, list):
+            innovations = []
+        innovations_scores = await self.quality.evaluate_innovations(innovations)
+
+        # 3. 平均置信度
+        avg_confidence = 0.0
+        if isinstance(confidence_stats, dict):
+            try:
+                avg_confidence = float(confidence_stats.get("avg_confidence", 0.0))
+            except (TypeError, ValueError):
+                avg_confidence = 0.0
+
+        # 4. 报告整体质量评估
+        final_report = (
+            pipeline_results.get("final_report")
+            if isinstance(pipeline_results, dict)
+            else None
+        )
+        if not isinstance(final_report, dict):
+            # 退化:用 pipeline_results 自身作为报告概览
+            final_report = (
+                pipeline_results if isinstance(pipeline_results, dict) else {}
+            )
+        quality_assessment = await self.quality.evaluate_report(final_report)
+
+        return {
+            "innovations_scores": innovations_scores,
+            "tool_call_success_rate": tool_call_success_rate,
+            "total_tool_calls": total_tool_calls,
+            "failed_tool_calls": failed_tool_calls,
+            "avg_confidence": avg_confidence,
+            "tool_calls": self.tracker.to_report(),
+            "quality_assessment": quality_assessment,
+        }
+
+    def build_evaluation_report(self, eval_data: dict) -> dict:
+        """转为 EvaluationReport 兼容格式(返回 dict,便于序列化)
+
+        将 evaluate() 产出的 eval_data 映射到 EvaluationReport schema,
+        额外保留 quality_assessment 字段以供下游使用。
+        """
+        # 构造 ThreeDScore 列表
+        innovations_scores: list[ThreeDScore] = []
+        for item in eval_data.get("innovations_scores", []):
+            if not isinstance(item, dict):
+                continue
+            score = item.get("score", {})
+            if not isinstance(score, dict):
+                score = {}
+            try:
+                innovations_scores.append(
+                    ThreeDScore(
+                        novelty=float(score.get("novelty", 0.0)),
+                        feasibility=float(score.get("feasibility", 0.0)),
+                        significance=float(score.get("significance", 0.0)),
+                    )
+                )
+            except Exception as exc:
+                logger.warning("ThreeDScore 构造失败: %s", exc)
+
+        # 构造 ToolCallRecord 列表
+        tool_calls: list[ToolCallRecord] = []
+        for rec in eval_data.get("tool_calls", []):
+            if not isinstance(rec, dict):
+                continue
+            try:
+                tool_calls.append(
+                    ToolCallRecord(
+                        tool_name=rec.get("tool_name", ""),
+                        args_summary=rec.get("args_summary", ""),
+                        success=bool(rec.get("success", False)),
+                        duration_sec=float(rec.get("duration_sec", 0.0)),
+                        error=rec.get("error"),
+                    )
+                )
+            except Exception as exc:
+                logger.warning("ToolCallRecord 构造失败: %s", exc)
+
+        report = EvaluationReport(
+            innovations_scores=innovations_scores,
+            tool_call_success_rate=float(eval_data.get("tool_call_success_rate", 0.0)),
+            total_tool_calls=int(eval_data.get("total_tool_calls", 0)),
+            failed_tool_calls=int(eval_data.get("failed_tool_calls", 0)),
+            avg_confidence=float(eval_data.get("avg_confidence", 0.0)),
+            tool_calls=tool_calls,
+        )
+        # 兼容 EvaluationReport 字段,同时保留质量评估附加信息
+        result = report.model_dump()
+        result["quality_assessment"] = eval_data.get("quality_assessment")
+        return result

+ 261 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/evaluator/quality.py

@@ -0,0 +1,261 @@
+"""输出质量评估:基于 LLM 对创新点与最终报告进行质量评分"""
+from __future__ import annotations
+
+import logging
+from typing import Optional
+
+from backend.llm.client import DeepSeekClient
+from backend.llm.json_utils import parse_json_safe
+
+logger = logging.getLogger(__name__)
+
+# 模块级懒加载单例
+_client: Optional[DeepSeekClient] = None
+
+
+def get_client() -> DeepSeekClient:
+    """懒加载 DeepSeek 客户端单例"""
+    global _client
+    if _client is None:
+        _client = DeepSeekClient()
+    return _client
+
+
+def _clamp_score(value: float) -> float:
+    """将评分限制在 0-10 范围内,非法值降级为 0.0"""
+    try:
+        v = float(value)
+    except (TypeError, ValueError):
+        return 0.0
+    return max(0.0, min(10.0, v))
+
+
+class QualityEvaluator:
+    """输出质量评估器:调用 LLM 对创新点与报告做三维/多维评分"""
+
+    def __init__(self, client: Optional[DeepSeekClient] = None) -> None:
+        # 优先使用注入的 client,否则使用模块级懒加载单例
+        self.client = client or get_client()
+
+    async def evaluate_innovations(self, innovations: list[dict]) -> list[dict]:
+        """对每个创新点用 LLM 评估三维评分(novelty/feasibility/significance 0-10)
+
+        若创新点已有 score 则校验/调整,否则新生成。
+        返回 [{innovation_title, score: {novelty, feasibility, significance}, reasoning}]
+        """
+        if not innovations:
+            return []
+
+        results: list[dict] = []
+        for inv in innovations:
+            if not isinstance(inv, dict):
+                continue
+            results.append(await self._evaluate_single_innovation(inv))
+        return results
+
+    async def _evaluate_single_innovation(self, inv: dict) -> dict:
+        """评估单个创新点:构造提示词→调用 LLM→解析三维评分"""
+        title = inv.get("title", "")
+        idea = inv.get("idea", "")
+        existing_score = inv.get("score")
+
+        # 已有分数则校验/调整,否则新生成
+        if isinstance(existing_score, dict) and existing_score:
+            score_hint = (
+                f"该创新点已有初步评分:novelty={existing_score.get('novelty', 0)}, "
+                f"feasibility={existing_score.get('feasibility', 0)}, "
+                f"significance={existing_score.get('significance', 0)}。"
+                "请基于以上信息进行校验与调整。"
+            )
+        else:
+            score_hint = "该创新点暂无评分,请生成新的三维评分。"
+
+        prompt = f"""你是一位严谨的学术评审专家,请对以下创新点进行三维评分(0-10 分,保留一位小数)。
+
+## 创新点信息
+- 标题:{title}
+- 思路:{idea}
+- 论据支撑:{inv.get('supporting_evidence', '')}
+- 新颖性检查:{inv.get('novelty_check', '') or '无'}
+
+## 评分维度
+- novelty(新颖性):与现有工作的差异程度
+- feasibility(可行性):技术实现与资源获取的难度
+- significance(显著性):学术或应用价值
+
+## 当前状态
+{score_hint}
+
+## 输出要求
+严格输出 JSON,不要包含任何额外说明文本或代码块标记。格式如下:
+{{
+  "innovation_title": "{title}",
+  "score": {{
+    "novelty": 0.0到10.0,
+    "feasibility": 0.0到10.0,
+    "significance": 0.0到10.0
+  }},
+  "reasoning": "评分理由,简明扼要"
+}}
+"""
+        messages = [
+            {
+                "role": "system",
+                "content": "你是一位学术评审专家,擅长对创新点进行多维评分。只输出严格 JSON,不要输出任何其他内容。",
+            },
+            {"role": "user", "content": prompt},
+        ]
+
+        try:
+            response = await self.client.chat(messages=messages)
+            content = response.choices[0].message.content or ""
+            data = parse_json_safe(content)
+            if isinstance(data, dict):
+                score = data.get("score", {})
+                if not isinstance(score, dict):
+                    score = {}
+                return {
+                    "innovation_title": data.get("innovation_title", title),
+                    "score": {
+                        "novelty": _clamp_score(score.get("novelty", 0.0)),
+                        "feasibility": _clamp_score(score.get("feasibility", 0.0)),
+                        "significance": _clamp_score(score.get("significance", 0.0)),
+                    },
+                    "reasoning": data.get("reasoning", ""),
+                }
+            logger.warning("创新点评分 JSON 解析失败: %s", content[:200])
+        except Exception as exc:
+            logger.warning("创新点 '%s' 评分失败: %s", title, exc)
+
+        # 降级:使用已有分数或全 0
+        fallback = existing_score if isinstance(existing_score, dict) else {}
+        return {
+            "innovation_title": title,
+            "score": {
+                "novelty": _clamp_score(fallback.get("novelty", 0.0)),
+                "feasibility": _clamp_score(fallback.get("feasibility", 0.0)),
+                "significance": _clamp_score(fallback.get("significance", 0.0)),
+            },
+            "reasoning": "LLM 评分解析失败,使用降级分数",
+        }
+
+    async def evaluate_report(self, report: dict) -> dict:
+        """对最终报告整体质量评估:结构完整性、论证严谨性、可执行性、可追溯性
+
+        返回 {overall_score, dimensions: {...}, suggestions: [...]}
+        """
+        if not report:
+            return {
+                "overall_score": 0.0,
+                "dimensions": {
+                    "structural_completeness": 0.0,
+                    "argument_rigor": 0.0,
+                    "executability": 0.0,
+                    "traceability": 0.0,
+                },
+                "suggestions": ["报告为空,无法评估"],
+            }
+
+        # 提取报告关键内容用于评估
+        background = report.get("background_review", "")
+        innovations = report.get("innovations", [])
+        plans = report.get("experiment_plans", [])
+        references = report.get("references", [])
+
+        innovations_text = "\n".join(
+            f"- {inv.get('title', '')}: {inv.get('idea', '')[:100]}"
+            for inv in innovations
+            if isinstance(inv, dict)
+        )
+        plans_text = "\n".join(
+            f"- {p.get('innovation_title', '')}: 假设={p.get('hypothesis', '')[:80]}"
+            for p in plans
+            if isinstance(p, dict)
+        )
+        refs_count = len(references) if isinstance(references, list) else 0
+
+        prompt = f"""你是一位学术报告评审专家,请对以下最终报告进行整体质量评估。
+
+## 报告概览
+- 背景综述长度:{len(background) if isinstance(background, str) else 0} 字符
+- 创新点数量:{len(innovations) if isinstance(innovations, list) else 0}
+- 实验方案数量:{len(plans) if isinstance(plans, list) else 0}
+- 参考文献数量:{refs_count}
+
+## 创新点列表
+{innovations_text or '无'}
+
+## 实验方案列表
+{plans_text or '无'}
+
+## 评估维度(0-10 分,保留一位小数)
+- structural_completeness(结构完整性):背景/创新/方案/参考是否齐全
+- argument_rigor(论证严谨性):论据是否充分、逻辑是否自洽
+- executability(可执行性):实验方案是否可落地
+- traceability(可追溯性):是否标注来源、可回溯原文
+
+## 输出要求
+严格输出 JSON,不要包含任何额外说明文本或代码块标记。格式如下:
+{{
+  "overall_score": 0.0到10.0,
+  "dimensions": {{
+    "structural_completeness": 0.0到10.0,
+    "argument_rigor": 0.0到10.0,
+    "executability": 0.0到10.0,
+    "traceability": 0.0到10.0
+  }},
+  "suggestions": ["改进建议1", "改进建议2"]
+}}
+"""
+        messages = [
+            {
+                "role": "system",
+                "content": "你是一位学术报告评审专家,擅长整体质量评估。只输出严格 JSON,不要输出任何其他内容。",
+            },
+            {"role": "user", "content": prompt},
+        ]
+
+        try:
+            response = await self.client.chat(messages=messages)
+            content = response.choices[0].message.content or ""
+            data = parse_json_safe(content)
+            if isinstance(data, dict):
+                dimensions = data.get("dimensions", {})
+                if not isinstance(dimensions, dict):
+                    dimensions = {}
+                suggestions = data.get("suggestions", [])
+                if not isinstance(suggestions, list):
+                    suggestions = []
+                return {
+                    "overall_score": _clamp_score(data.get("overall_score", 0.0)),
+                    "dimensions": {
+                        "structural_completeness": _clamp_score(
+                            dimensions.get("structural_completeness", 0.0)
+                        ),
+                        "argument_rigor": _clamp_score(
+                            dimensions.get("argument_rigor", 0.0)
+                        ),
+                        "executability": _clamp_score(
+                            dimensions.get("executability", 0.0)
+                        ),
+                        "traceability": _clamp_score(
+                            dimensions.get("traceability", 0.0)
+                        ),
+                    },
+                    "suggestions": [str(s) for s in suggestions],
+                }
+            logger.warning("报告评估 JSON 解析失败: %s", content[:200])
+        except Exception as exc:
+            logger.warning("报告评估失败: %s", exc)
+
+        # 降级返回
+        return {
+            "overall_score": 0.0,
+            "dimensions": {
+                "structural_completeness": 0.0,
+                "argument_rigor": 0.0,
+                "executability": 0.0,
+                "traceability": 0.0,
+            },
+            "suggestions": ["评估调用失败,请检查 LLM 服务"],
+        }

+ 118 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/evaluator/tracker.py

@@ -0,0 +1,118 @@
+"""工具调用追踪器:记录与统计工具调用情况"""
+from __future__ import annotations
+
+import logging
+from typing import Optional
+
+from backend.models.schemas import ToolCallRecord
+
+logger = logging.getLogger(__name__)
+
+
+class ToolCallTracker:
+    """工具调用追踪器:维护工具调用记录,提供成功率与分工具统计"""
+
+    def __init__(self) -> None:
+        # 维护全部工具调用记录(按调用先后顺序)
+        self.records: list[ToolCallRecord] = []
+
+    def record(
+        self,
+        tool_name: str,
+        args_summary: str,
+        success: bool,
+        duration_sec: float,
+        error: Optional[str] = None,
+    ) -> ToolCallRecord:
+        """记录一次工具调用
+
+        参数:
+            tool_name: 工具名称
+            args_summary: 参数摘要(通常为截断后的 JSON 字符串)
+            success: 是否调用成功
+            duration_sec: 耗时(秒)
+            error: 失败时的错误信息,成功时为 None
+        """
+        record = ToolCallRecord(
+            tool_name=tool_name,
+            args_summary=args_summary,
+            success=success,
+            duration_sec=duration_sec,
+            error=error,
+        )
+        self.records.append(record)
+        return record
+
+    def record_from_dict(self, record_dict: dict) -> Optional[ToolCallRecord]:
+        """从 dict 记录一次工具调用(接收 Controller 累计的 tool_calls)
+
+        兼容 ToolCallRecord.model_dump() 产出的字典格式,
+        timestamp 字段若存在则忽略(由 ToolCallRecord 自动生成)。
+        """
+        if not isinstance(record_dict, dict):
+            logger.warning("record_from_dict 接收非 dict 入参: %r", type(record_dict))
+            return None
+
+        tool_name = record_dict.get("tool_name", "")
+        args_summary = record_dict.get("args_summary", "")
+        success = bool(record_dict.get("success", False))
+        try:
+            duration_sec = float(record_dict.get("duration_sec", 0.0))
+        except (TypeError, ValueError):
+            duration_sec = 0.0
+        error = record_dict.get("error")
+
+        return self.record(
+            tool_name=tool_name,
+            args_summary=args_summary,
+            success=success,
+            duration_sec=duration_sec,
+            error=error,
+        )
+
+    def success_rate(self) -> float:
+        """返回成功率 0-1,无记录时返回 0.0"""
+        if not self.records:
+            return 0.0
+        success_count = sum(1 for r in self.records if r.success)
+        return success_count / len(self.records)
+
+    def summary(self) -> dict:
+        """返回汇总统计
+
+        结构:
+            {
+                total, success, failed, success_rate,
+                by_tool: {tool_name: {total, success, rate}}
+            }
+        """
+        total = len(self.records)
+        success = sum(1 for r in self.records if r.success)
+        failed = total - success
+        rate = self.success_rate()
+
+        # 按工具名聚合
+        by_tool: dict[str, dict] = {}
+        for r in self.records:
+            entry = by_tool.setdefault(
+                r.tool_name, {"total": 0, "success": 0, "rate": 0.0}
+            )
+            entry["total"] += 1
+            if r.success:
+                entry["success"] += 1
+        for entry in by_tool.values():
+            entry["rate"] = (
+                entry["success"] / entry["total"] if entry["total"] else 0.0
+            )
+
+        return {
+            "total": total,
+            "success": success,
+            "failed": failed,
+            "success_rate": rate,
+            "by_tool": by_tool,
+        }
+
+    def to_report(self) -> list[dict]:
+        """返回所有记录的 dict 列表(可直接序列化)"""
+        return [r.model_dump() for r in self.records]

+ 11 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/llm/__init__.py

@@ -0,0 +1,11 @@
+"""LLM 模块:DeepSeek 客户端与 Function Calling 工具循环"""
+from backend.llm.client import DeepSeekClient
+from backend.llm.function_calling import ToolLoop
+from backend.llm.json_utils import parse_json_safe, validate_required_fields
+
+__all__ = [
+    "DeepSeekClient",
+    "ToolLoop",
+    "parse_json_safe",
+    "validate_required_fields",
+]

+ 122 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/llm/client.py

@@ -0,0 +1,122 @@
+"""DeepSeek LLM 客户端:基于 HelloAgents 框架的 HelloAgentsLLM 实现
+
+PaperMind 的多 Agent 编排构建在 HelloAgents 框架之上:
+- LLM 调用统一走框架的 HelloAgentsLLM(OpenAI 兼容适配器,自动适配 DeepSeek)
+- chat() 返回与 OpenAI SDK ChatCompletion 兼容的对象,ToolLoop 等既有调用方无需改动
+"""
+import asyncio
+import logging
+from typing import Any, Optional
+
+from hello_agents import HelloAgentsLLM
+
+from backend.config import settings
+
+logger = logging.getLogger(__name__)
+
+
+class _ShimMessage:
+    """把 HelloAgentsLLM 的文本响应包装为 OpenAI ChatCompletion.message 形状"""
+
+    def __init__(self, content: str, reasoning_content: Optional[str] = None) -> None:
+        self.role = "assistant"
+        self.content = content
+        self.reasoning_content = reasoning_content
+        self.tool_calls = None
+
+
+class _ShimChoice:
+    def __init__(self, message: _ShimMessage) -> None:
+        self.message = message
+        self.finish_reason = "stop"
+        self.index = 0
+
+
+class ChatCompletionShim:
+    """无工具调用的文本响应适配:兼容 response.choices[0].message.content 访问方式"""
+
+    def __init__(self, llm_response: Any) -> None:
+        self.choices = [
+            _ShimChoice(
+                _ShimMessage(
+                    content=getattr(llm_response, "content", "") or "",
+                    reasoning_content=getattr(llm_response, "reasoning_content", None),
+                )
+            )
+        ]
+        self.model = getattr(llm_response, "model", settings.DEEPSEEK_MODEL)
+        self.usage = getattr(llm_response, "usage", None)
+        self.id = "papermind-hello-agents"
+
+
+class DeepSeekClient:
+    """DeepSeek 异步客户端:底层由 HelloAgents 框架的 HelloAgentsLLM 驱动
+
+    HelloAgentsLLM 基于 OpenAI 兼容适配器访问 DeepSeek,
+    chat() 对外保持与 OpenAI SDK ChatCompletion 兼容的返回形状。
+    """
+
+    def __init__(self) -> None:
+        # 框架 LLM:模型/密钥/地址来自项目配置,适配器自动识别 DeepSeek
+        self.llm = HelloAgentsLLM(
+            model=settings.DEEPSEEK_MODEL,
+            api_key=settings.DEEPSEEK_API_KEY,
+            base_url=settings.DEEPSEEK_BASE_URL,
+            temperature=settings.LLM_TEMPERATURE,
+            timeout=settings.LLM_TIMEOUT,
+        )
+        self.model = settings.DEEPSEEK_MODEL
+        self.timeout = settings.LLM_TIMEOUT
+        self.max_retries = settings.TOOL_MAX_RETRIES
+
+    async def chat(
+        self,
+        messages: list[dict],
+        tools: Optional[list[dict]] = None,
+        tool_choice: str = "auto",
+        max_tokens: Optional[int] = None,
+    ) -> Any:
+        """调用 Chat Completions,返回模型回复(ChatCompletion 兼容对象)
+
+        有工具时走框架 ainvoke_with_tools(返回原生 ChatCompletion);
+        无工具时走框架 ainvoke,包装为兼容形状。
+        单次调用失败时按指数退避重试 max_retries 次。
+        max_tokens: 显式设置输出 token 上限,None 用 API 默认值(4096)。
+        """
+        kwargs: dict[str, Any] = {}
+        if max_tokens is not None:
+            kwargs["max_tokens"] = max_tokens
+
+        last_exc: Optional[Exception] = None
+        total_attempts = self.max_retries + 1  # 初次调用 + 重试次数
+        for attempt in range(total_attempts):
+            try:
+                if tools:
+                    # Function Calling:框架返回原生 ChatCompletion(含 tool_calls)
+                    response = await self.llm.ainvoke_with_tools(
+                        messages=messages,
+                        tools=tools,
+                        tool_choice=tool_choice,
+                        **kwargs,
+                    )
+                    return response
+
+                # 纯文本:框架返回 LLMResponse,包装为 ChatCompletion 兼容形状
+                response = await self.llm.ainvoke(messages=messages, **kwargs)
+                return ChatCompletionShim(response)
+            except Exception as exc:
+                last_exc = exc
+                logger.warning(
+                    "DeepSeek 调用失败 (attempt=%d/%d): %s",
+                    attempt + 1,
+                    total_attempts,
+                    exc,
+                )
+                if attempt < self.max_retries:
+                    # 指数退避:1s, 2s, 4s ...
+                    backoff = 2 ** attempt
+                    await asyncio.sleep(backoff)
+
+        raise RuntimeError(
+            f"DeepSeek 调用失败,已重试 {self.max_retries} 次"
+        ) from last_exc

+ 178 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/llm/function_calling.py

@@ -0,0 +1,178 @@
+"""Function Calling 工具调用循环:调用模型→执行工具→回填结果→继续调用"""
+import asyncio
+import json
+import logging
+import time
+from typing import Any, Awaitable, Callable, Optional, Union
+
+from backend.config import settings
+from backend.llm.client import DeepSeekClient
+from backend.models.schemas import ToolCallRecord
+
+logger = logging.getLogger(__name__)
+
+# 工具可调用对象类型:同步或异步函数均可
+ToolCallable = Union[Callable[..., Any], Callable[..., Awaitable[Any]]]
+
+
+def _message_to_dict(message: Any) -> dict:
+    """把 OpenAI 返回的 message 对象转为可序列化的 dict,便于回填到 messages"""
+    msg: dict = {"role": message.role, "content": message.content or ""}
+    tool_calls = getattr(message, "tool_calls", None)
+    if tool_calls:
+        msg["tool_calls"] = [
+            {
+                "id": tc.id,
+                "type": "function",
+                "function": {
+                    "name": tc.function.name,
+                    "arguments": tc.function.arguments,
+                },
+            }
+            for tc in tool_calls
+        ]
+    return msg
+
+
+class ToolLoop:
+    """工具调用循环
+
+    循环逻辑:调用模型 → 若返回 tool_calls 则执行对应工具 →
+    把工具结果以 role=tool 回填 → 继续调用,直到模型无 tool_calls 返回最终文本。
+    """
+
+    def __init__(
+        self,
+        client: DeepSeekClient,
+        tool_registry: dict[str, ToolCallable],
+    ) -> None:
+        self.client = client
+        self.tool_registry = tool_registry
+        self.tool_calls: list[ToolCallRecord] = []
+
+    async def run(
+        self,
+        messages: list[dict],
+        tools_schema: list[dict],
+        max_iterations: int = 10,
+    ) -> str:
+        """运行工具调用循环,返回模型最终文本回复"""
+        # 复制一份消息,避免修改入参
+        working_messages = list(messages)
+        final_content = ""
+
+        for iteration in range(max_iterations):
+            response = await self.client.chat(
+                messages=working_messages,
+                tools=tools_schema,
+                tool_choice="auto",
+            )
+
+            choice = response.choices[0]
+            message = choice.message
+            final_content = message.content or ""
+
+            # 把模型消息追加到对话上下文
+            working_messages.append(_message_to_dict(message))
+
+            tool_calls = getattr(message, "tool_calls", None)
+            if not tool_calls:
+                # 模型未请求工具,返回最终文本
+                return final_content
+
+            # 依次执行每个工具调用并回填结果
+            for tool_call in tool_calls:
+                record, content = await self._execute_tool_call(tool_call)
+                working_messages.append(
+                    {
+                        "role": "tool",
+                        "tool_call_id": tool_call.id,
+                        "content": content,
+                    }
+                )
+
+        # 达到最大迭代次数仍未结束,降级返回最后一次内容
+        logger.warning("工具调用循环达到最大迭代次数 %d", max_iterations)
+        return final_content
+
+    async def _invoke(self, tool_fn: ToolCallable, args: dict) -> Any:
+        """调用工具,自动区分同步/异步函数
+
+        同步工具用 asyncio.to_thread 包装,避免阻塞事件循环;
+        异步工具直接 await。
+        """
+        if asyncio.iscoroutinefunction(tool_fn):
+            return await tool_fn(**args)
+        return await asyncio.to_thread(tool_fn, **args)
+
+    async def _execute_tool_call(self, tool_call: Any) -> tuple[ToolCallRecord, str]:
+        """执行单个工具调用,返回 (调用记录, 回填结果文本)
+
+        工具执行失败时重试 TOOL_MAX_RETRIES 次,仍失败则记录错误并继续(降级不崩溃)。
+        """
+        tool_name = tool_call.function.name
+        # 解析工具参数
+        try:
+            args = json.loads(tool_call.function.arguments or "{}")
+        except json.JSONDecodeError:
+            args = {}
+        args_summary = json.dumps(args, ensure_ascii=False)[:200]
+
+        # 查找工具
+        tool_fn = self.tool_registry.get(tool_name)
+        if tool_fn is None:
+            record = ToolCallRecord(
+                tool_name=tool_name,
+                args_summary=args_summary,
+                success=False,
+                duration_sec=0.0,
+                error=f"未注册的工具: {tool_name}",
+            )
+            self.tool_calls.append(record)
+            return record, f"工具执行失败: 未注册的工具 {tool_name}"
+
+        # 执行工具(带重试)
+        start = time.perf_counter()
+        last_error: Optional[str] = None
+        result: Any = None
+        success = False
+        total_attempts = settings.TOOL_MAX_RETRIES + 1  # 初次 + 重试次数
+        for attempt in range(total_attempts):
+            try:
+                result = await self._invoke(tool_fn, args)
+                success = True
+                break
+            except Exception as exc:
+                last_error = str(exc)
+                logger.warning(
+                    "工具 %s 执行失败 (attempt=%d/%d): %s",
+                    tool_name,
+                    attempt + 1,
+                    total_attempts,
+                    exc,
+                )
+        duration = time.perf_counter() - start
+
+        record = ToolCallRecord(
+            tool_name=tool_name,
+            args_summary=args_summary,
+            success=success,
+            duration_sec=round(duration, 3),
+            error=None if success else last_error,
+            result=result if success else None,  # 持久化工具返回值,供 ReportAgent 整合
+        )
+        self.tool_calls.append(record)
+
+        # 构造回填内容:成功则序列化结果,失败则回填错误信息(降级继续)
+        if success:
+            if isinstance(result, str):
+                content = result
+            else:
+                content = json.dumps(result, ensure_ascii=False, default=str)
+        else:
+            content = f"工具执行失败: {last_error}"
+        return record, content
+
+    def get_tool_records(self) -> list[ToolCallRecord]:
+        """返回所有工具调用记录"""
+        return list(self.tool_calls)

+ 56 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/llm/json_utils.py

@@ -0,0 +1,56 @@
+"""JSON 解析容错工具:从模型文本中稳健地提取与校验 JSON"""
+import json
+import re
+from typing import Any, Optional
+
+
+def parse_json_safe(text: str) -> Optional[Any]:
+    """从模型文本中提取 JSON,解析失败返回 None
+
+    依次处理以下情况:
+    1. 纯 JSON 文本,直接解析;
+    2. ```json ... ``` 或 ``` ... ``` 代码块包裹的 JSON;
+    3. 前后含多余说明文本时,提取首个 {...} 或 [...] 片段。
+    """
+    if not text:
+        return None
+
+    raw = text.strip()
+
+    # 1. 直接解析
+    try:
+        return json.loads(raw)
+    except json.JSONDecodeError:
+        pass
+
+    # 2. 提取 ```json ... ``` 或 ``` ... ``` 代码块
+    fence_pattern = re.compile(
+        r"```(?:json)?\s*(.*?)\s*```", re.DOTALL | re.IGNORECASE
+    )
+    match = fence_pattern.search(raw)
+    if match:
+        try:
+            return json.loads(match.group(1).strip())
+        except json.JSONDecodeError:
+            pass
+
+    # 3. 提取首个 {...} 或 [...] 片段(去除前后多余文本)
+    for opener, closer in (("{", "}"), ("[", "]")):
+        start = raw.find(opener)
+        end = raw.rfind(closer)
+        if start != -1 and end != -1 and end > start:
+            snippet = raw[start : end + 1]
+            try:
+                return json.loads(snippet)
+            except json.JSONDecodeError:
+                continue
+
+    return None
+
+
+def validate_required_fields(data: Any, required_fields: list[str]) -> list[str]:
+    """校验必填字段,返回缺失字段列表(空列表表示全部齐全)"""
+    if not isinstance(data, dict):
+        # 非字典结构,视为全部缺失
+        return list(required_fields)
+    return [f for f in required_fields if f not in data]

+ 6 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/memory/__init__.py

@@ -0,0 +1,6 @@
+"""Memory 模块:对话记忆 + 长期知识记忆"""
+from backend.memory.conversation import ConversationMemory
+from backend.memory.long_term import LongTermMemory
+from backend.memory.manager import MemoryManager
+
+__all__ = ["ConversationMemory", "LongTermMemory", "MemoryManager"]

+ 64 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/memory/conversation.py

@@ -0,0 +1,64 @@
+"""会话级对话记忆:维护单次会话的消息列表与中间状态"""
+from __future__ import annotations
+
+from typing import Any
+
+
+class ConversationMemory:
+    """单次会话的对话记忆
+
+    - messages:对话消息列表,每条形如 {role, content}
+    - intermediate:七步链路中间产物(如已解析论文数、已抽取记录等)
+    """
+
+    def __init__(self) -> None:
+        # 对话消息列表,每条 {role: str, content: str}
+        self._messages: list[dict] = []
+        # 中间状态存储,key -> value
+        self._intermediate: dict[str, Any] = {}
+
+    def add(self, role: str, content: str) -> None:
+        """添加一条对话消息(role: system/user/assistant/tool 等)"""
+        self._messages.append({"role": role, "content": content})
+
+    def add_system(self, content: str) -> None:
+        """添加 system 消息,插入到列表开头(保证 system 始终在前)"""
+        # 若已存在 system 消息,则将新的 system 插入到所有 system 之后、其他消息之前
+        insert_idx = 0
+        for i, msg in enumerate(self._messages):
+            if msg.get("role") == "system":
+                insert_idx = i + 1
+            else:
+                break
+        self._messages.insert(insert_idx, {"role": "system", "content": content})
+
+    def get_messages(self) -> list[dict]:
+        """返回全部消息(浅拷贝,避免外部直接修改内部状态)"""
+        return list(self._messages)
+
+    def get_recent(self, n: int = 10) -> list[dict]:
+        """返回最近 n 条消息,防止上下文过长
+
+        注意:system 消息始终保留在最前,以保证系统提示不被截断
+        """
+        if n <= 0 or not self._messages:
+            return []
+        # 分离 system 消息与其他消息
+        system_msgs = [m for m in self._messages if m.get("role") == "system"]
+        non_system = [m for m in self._messages if m.get("role") != "system"]
+        # 取非 system 消息的最近 n 条
+        recent_non_system = non_system[-n:] if n < len(non_system) else non_system
+        return system_msgs + recent_non_system
+
+    def add_intermediate(self, key: str, value: Any) -> None:
+        """存储中间状态(七步链路中间产物,如已解析论文数、已抽取记录等)"""
+        self._intermediate[key] = value
+
+    def get_intermediate(self, key: str, default: Any = None) -> Any:
+        """读取中间状态,不存在则返回 default"""
+        return self._intermediate.get(key, default)
+
+    def clear(self) -> None:
+        """清空对话消息与中间状态"""
+        self._messages.clear()
+        self._intermediate.clear()

+ 290 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/memory/long_term.py

@@ -0,0 +1,290 @@
+"""长期知识记忆:基于 Chroma 向量库存储 Gap / Innovation / 通用知识
+
+- 与 RAG 模块共用 Embedder(从 backend.rag.embedding 导入),但使用独立 collection
+- Embedder 与 Chroma 均较重,采用懒加载
+- 所有 IO 操作异步化(Chroma 为同步接口,用 asyncio.to_thread 包装)
+"""
+from __future__ import annotations
+
+import asyncio
+import uuid
+from typing import Any, Optional
+
+# 尝试从 RAG 模块导入 Embedder;若依赖未装或模块尚未实现,则兜底为 None,不影响模块定义
+try:
+    from backend.rag.embedding import Embedder  # type: ignore
+except Exception:  # noqa: BLE001 - 兜底导入,任何失败都降级为 None
+    Embedder = None  # type: ignore
+
+from backend.config import settings
+
+
+# 长期知识使用的独立 collection 名称
+LONG_TERM_COLLECTION = "long_term_knowledge"
+
+
+def _gap_to_text(gap: Any) -> str:
+    """将 Gap 模型转为可向量化的文本"""
+    # 兼容 pydantic 模型与普通对象
+    gap_type = getattr(getattr(gap, "gap_type", None), "value", getattr(gap, "gap_type", ""))
+    source_papers = getattr(gap, "source_papers", []) or []
+    source_str = "; ".join(source_papers) if source_papers else "无"
+    return (
+        f"【研究空白 / {gap_type}】\n"
+        f"描述:{getattr(gap, 'description', '')}\n"
+        f"来源论文:{source_str}\n"
+        f"论证:{getattr(gap, 'evidence', '')}\n"
+        f"置信度:{getattr(gap, 'confidence', '')}"
+    )
+
+
+def _innovation_to_text(innovation: Any) -> str:
+    """将 Innovation 模型转为可向量化的文本"""
+    source = getattr(getattr(innovation, "source", None), "value", getattr(innovation, "source", ""))
+    score = getattr(innovation, "score", None)
+    score_str = ""
+    if score is not None:
+        novelty = getattr(score, "novelty", "")
+        feasibility = getattr(score, "feasibility", "")
+        significance = getattr(score, "significance", "")
+        score_str = f"新颖性={novelty} 可行性={feasibility} 显著性={significance}"
+    return (
+        f"【创新点 / {source}】\n"
+        f"标题:{getattr(innovation, 'title', '')}\n"
+        f"思路:{getattr(innovation, 'idea', '')}\n"
+        f"Gap 来源:{getattr(innovation, 'gap_origin', '')}\n"
+        f"评分:{score_str}\n"
+        f"论据支撑:{getattr(innovation, 'supporting_evidence', '')}"
+    )
+
+
+def _flatten_metadata(metadata: dict) -> dict:
+    """将 metadata 中的复杂类型扁平化为 Chroma 支持的基本类型(str/int/float/bool/None)"""
+    flat: dict[str, Any] = {}
+    for k, v in (metadata or {}).items():
+        if v is None or isinstance(v, (str, int, float, bool)):
+            flat[k] = v
+        else:
+            # 列表/字典等转为字符串
+            flat[k] = str(v)
+    return flat
+
+
+class LongTermMemory:
+    """长期知识记忆:向量库存储与语义检索
+
+    每条知识条目结构:{type: gap/innovation/knowledge, content, metadata}
+    """
+
+    def __init__(self) -> None:
+        # 懒加载:仅在首次使用时初始化 Embedder 与 Chroma
+        self._embedder: Any = None
+        self._embedder_loaded: bool = False
+        self._client: Any = None
+        self._collection: Any = None
+
+    # ---------- 懒加载 ----------
+
+    def _get_embedder(self) -> Any:
+        """懒加载 Embedder 实例"""
+        if not self._embedder_loaded:
+            self._embedder_loaded = True
+            if Embedder is None:
+                raise RuntimeError(
+                    "Embedder 不可用:backend.rag.embedding 导入失败"
+                    "(请安装 sentence-transformers 并实现 Embedder)"
+                )
+            # Embedder 可能是类或工厂,统一实例化
+            self._embedder = Embedder()
+        return self._embedder
+
+    def _get_collection(self) -> Any:
+        """懒加载 Chroma collection(同步,仅在主线程初始化一次)"""
+        if self._collection is None:
+            import chromadb  # 局部导入,避免模块加载即依赖
+
+            path = str(settings.CHROMA_PATH)
+            # PersistentClient 将数据持久化到磁盘
+            self._client = chromadb.PersistentClient(path=path)
+            self._collection = self._client.get_or_create_collection(
+                name=LONG_TERM_COLLECTION,
+                metadata={"description": "Paper Innovation Agent 长期知识记忆"},
+            )
+        return self._collection
+
+    async def _embed(self, texts: list[str]) -> list[list[float]]:
+        """异步向量化文本列表,兼容同步/异步 Embedder 接口
+
+        依次尝试:aembed(异步)-> embed(同步,丢入线程池)-> encode(同步,丢入线程池)
+        """
+        embedder = self._get_embedder()
+        # 1. 异步接口优先
+        aembed = getattr(embedder, "aembed", None)
+        if callable(aembed):
+            result = await aembed(texts)
+            return self._normalize_embeddings(result)
+        # 2. 同步 embed 接口
+        embed = getattr(embedder, "embed", None)
+        if callable(embed):
+            result = await asyncio.to_thread(embed, texts)
+            return self._normalize_embeddings(result)
+        # 3. sentence-transformers 风格 encode
+        encode = getattr(embedder, "encode", None)
+        if callable(encode):
+            result = await asyncio.to_thread(encode, texts)
+            return self._normalize_embeddings(result)
+        raise RuntimeError("Embedder 未提供 aembed/embed/encode 方法")
+
+    @staticmethod
+    def _normalize_embeddings(result: Any) -> list[list[float]]:
+        """将各种返回形态统一为 list[list[float]]"""
+        # numpy ndarray / tensor 等
+        if hasattr(result, "tolist"):
+            result = result.tolist()
+        # 嵌套列表直接返回
+        if result and isinstance(result[0], (list, tuple)):
+            return [list(v) for v in result]
+        # 单条向量被压平的情况(不太可能,兜底)
+        return [list(result)]
+
+    # ---------- 写入 ----------
+
+    async def _add(self, entry_type: str, content: str, metadata: dict) -> str:
+        """通用写入:向量化 content 并存入 Chroma"""
+        # 生成唯一 id
+        entry_id = f"{entry_type}_{uuid.uuid4().hex[:12]}"
+        flat_meta = _flatten_metadata({"type": entry_type, **metadata})
+
+        # 向量化(异步)
+        embeddings = await self._embed([content])
+
+        # Chroma 写入为同步阻塞操作,丢入线程池
+        collection = self._get_collection()
+
+        def _do_add() -> None:
+            collection.add(
+                ids=[entry_id],
+                documents=[content],
+                metadatas=[flat_meta],
+                embeddings=embeddings,
+            )
+
+        await asyncio.to_thread(_do_add)
+        return entry_id
+
+    async def save_gap(self, gap: Any) -> str:
+        """保存 Gap 到长期记忆
+
+        Args:
+            gap: Gap 模型实例(backend.models.schemas.Gap)
+        Returns:
+            存入向量库的条目 id
+        """
+        content = _gap_to_text(gap)
+        gap_type = getattr(getattr(gap, "gap_type", None), "value", getattr(gap, "gap_type", ""))
+        metadata = {
+            "gap_type": gap_type,
+            "source_papers": getattr(gap, "source_papers", []),
+            "confidence": getattr(gap, "confidence", 1.0),
+            "description": getattr(gap, "description", ""),
+        }
+        return await self._add("gap", content, metadata)
+
+    async def save_innovation(self, innovation: Any) -> str:
+        """保存 Innovation 到长期记忆
+
+        Args:
+            innovation: Innovation 模型实例
+        Returns:
+            存入向量库的条目 id
+        """
+        content = _innovation_to_text(innovation)
+        source = getattr(getattr(innovation, "source", None), "value", getattr(innovation, "source", ""))
+        score = getattr(innovation, "score", None)
+        metadata = {
+            "title": getattr(innovation, "title", ""),
+            "source": source,
+            "gap_origin": getattr(innovation, "gap_origin", ""),
+            "novelty": getattr(score, "novelty", 0.0) if score else 0.0,
+            "feasibility": getattr(score, "feasibility", 0.0) if score else 0.0,
+            "significance": getattr(score, "significance", 0.0) if score else 0.0,
+        }
+        return await self._add("innovation", content, metadata)
+
+    async def save_knowledge(self, content: str, metadata: Optional[dict] = None) -> str:
+        """保存通用知识条目
+
+        Args:
+            content: 知识文本
+            metadata: 附加元数据
+        Returns:
+            存入向量库的条目 id
+        """
+        return await self._add("knowledge", content, metadata or {})
+
+    # ---------- 检索 ----------
+
+    async def search(
+        self,
+        query: str,
+        top_k: int = 5,
+        filter_type: Optional[str] = None,
+    ) -> list[dict]:
+        """语义检索相关历史记忆
+
+        Args:
+            query: 查询文本
+            top_k: 返回条数上限
+            filter_type: 可选,按类型过滤(gap/innovation/knowledge)
+        Returns:
+            命中条目列表,每条 {id, type, content, metadata, distance}
+        """
+        query_embeddings = await self._embed([query])
+        collection = self._get_collection()
+
+        where = {"type": filter_type} if filter_type else None
+
+        def _do_query() -> dict:
+            return collection.query(
+                query_embeddings=query_embeddings,
+                n_results=top_k,
+                where=where,
+            )
+
+        result = await asyncio.to_thread(_do_query)
+
+        # 解析 Chroma 返回结构(每项都是 list[list[...]],对应批量查询)
+        ids_batch = result.get("ids", [[]])
+        docs_batch = result.get("documents", [[]])
+        metas_batch = result.get("metadatas", [[]])
+        dists_batch = result.get("distances", [[]])
+
+        ids = ids_batch[0] if ids_batch else []
+        docs = docs_batch[0] if docs_batch else []
+        metas = metas_batch[0] if metas_batch else []
+        dists = dists_batch[0] if dists_batch else []
+
+        items: list[dict] = []
+        for i, doc in enumerate(docs):
+            meta = metas[i] if i < len(metas) else {}
+            items.append({
+                "id": ids[i] if i < len(ids) else "",
+                "type": meta.get("type", ""),
+                "content": doc,
+                "metadata": meta,
+                "distance": dists[i] if i < len(dists) else None,
+            })
+        return items
+
+    async def load_relevant(self, query: str, top_k: int = 5) -> list[dict]:
+        """加载与查询相关的历史 Gap 和 Innovation(用于创新点去重)
+
+        分别按 gap / innovation 类型检索,合并后按距离排序取 top_k
+        """
+        # 每类各取 top_k,合并后截断
+        gaps = await self.search(query, top_k=top_k, filter_type="gap")
+        innovations = await self.search(query, top_k=top_k, filter_type="innovation")
+        merged = gaps + innovations
+        # 距离越小越相关,升序排序
+        merged.sort(key=lambda x: x.get("distance") if x.get("distance") is not None else float("inf"))
+        return merged[:top_k]

+ 38 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/memory/manager.py

@@ -0,0 +1,38 @@
+"""Memory 管理器:组合会话记忆与长期记忆"""
+from __future__ import annotations
+
+from backend.memory.conversation import ConversationMemory
+from backend.memory.long_term import LongTermMemory
+
+
+class MemoryManager:
+    """统一管理会话级对话记忆与长期知识记忆
+
+    - conversation:当前会话的对话记忆(每次 new_session 替换)
+    - long_term:跨会话的长期知识记忆(单例,全生命周期共享)
+    """
+
+    def __init__(self) -> None:
+        # 长期记忆跨会话共享,懒加载内部依赖
+        self._long_term: LongTermMemory = LongTermMemory()
+        # 初始化首个会话记忆
+        self._conversation: ConversationMemory = ConversationMemory()
+
+    @property
+    def conversation(self) -> ConversationMemory:
+        """当前会话记忆"""
+        return self._conversation
+
+    @property
+    def long_term(self) -> LongTermMemory:
+        """长期知识记忆"""
+        return self._long_term
+
+    def new_session(self) -> ConversationMemory:
+        """创建新的会话记忆(替换当前会话)
+
+        Returns:
+            新创建的 ConversationMemory 实例
+        """
+        self._conversation = ConversationMemory()
+        return self._conversation

+ 1 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/models/__init__.py

@@ -0,0 +1 @@
+"""数据模型:Pydantic schemas"""

+ 171 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/models/schemas.py

@@ -0,0 +1,171 @@
+"""共享数据模型:Pydantic schemas,跨模块复用"""
+from __future__ import annotations
+
+from datetime import datetime
+from enum import Enum
+from typing import Any, Optional
+
+from pydantic import BaseModel, Field
+
+
+# ---------- 步骤1:PDF 解析 ----------
+
+class Section(BaseModel):
+    """论文章节"""
+    heading: str = Field(description="章节标题")
+    content: str = Field(description="章节正文")
+    figure_captions: list[str] = Field(default_factory=list, description="章节内图表标题")
+
+
+class ParsedPaper(BaseModel):
+    """步骤1 输出:解析后的论文"""
+    path: str
+    title: str
+    sections: list[Section]
+    parsed_at: datetime = Field(default_factory=datetime.now)
+
+
+# ---------- 步骤2:结构化抽取 ----------
+
+class FieldSource(BaseModel):
+    """字段来源标注,防编造、可回溯"""
+    value: str
+    source_sections: list[str] = Field(description="原文出处章节")
+    confidence: float = Field(ge=0.0, le=1.0, default=1.0)
+
+
+class PaperRecord(BaseModel):
+    """步骤2 输出:单篇论文结构化记录(papers.jsonl 一行一条)"""
+    path: str
+    title: str
+    task_problem: FieldSource = Field(description="研究任务/问题")
+    method: FieldSource = Field(description="核心方法")
+    key_contributions: FieldSource = Field(description="主要贡献")
+    datasets: FieldSource = Field(description="使用的数据集")
+    metrics: FieldSource = Field(description="评估指标")
+    results: FieldSource = Field(description="实验结果")
+    limitations: FieldSource = Field(description="局限性(重点字段,须论文明确承认或可推断)")
+    future_work: FieldSource = Field(description="未来工作")
+    extracted_at: datetime = Field(default_factory=datetime.now)
+
+
+# ---------- 步骤4:Gap 识别 ----------
+
+class GapType(str, Enum):
+    REPEATED_LIMITATION = "repeated_limitation"  # 重复局限
+    METHOD_GAP = "method_gap"                      # 方法空白
+    CONTRADICTORY = "contradictory"                # 矛盾结论
+    UNFULFILLED_FUTURE = "unfulfilled_future"      # 未兑现的未来工作
+
+
+class Gap(BaseModel):
+    """候选研究空白"""
+    description: str
+    gap_type: GapType
+    source_papers: list[str] = Field(description="来源论文标题列表")
+    evidence: str = Field(description="论证")
+    confidence: float = Field(ge=0.0, le=1.0, default=1.0)
+
+
+# ---------- 步骤5:创新点 ----------
+
+class InnovationSource(str, Enum):
+    METHOD_COMBINATION = "method_combination"    # 方法组合
+    LIMITATION_FIX = "limitation_fix"            # 局限改进
+    CROSS_DOMAIN = "cross_domain"                # 跨域迁移
+    NEW_SCENARIO = "new_scenario"                # 新场景应用
+
+
+class ThreeDScore(BaseModel):
+    """三维评分:新颖性/可行性/显著性"""
+    novelty: float = Field(ge=0.0, le=10.0)
+    feasibility: float = Field(ge=0.0, le=10.0)
+    significance: float = Field(ge=0.0, le=10.0)
+
+    @property
+    def total(self) -> float:
+        return round(self.novelty + self.feasibility + self.significance, 2)
+
+
+class Innovation(BaseModel):
+    """创新点"""
+    title: str
+    idea: str = Field(description="创新思路")
+    source: InnovationSource
+    gap_origin: str = Field(description="Gap 来源描述")
+    score: ThreeDScore
+    novelty_check: Optional[str] = Field(default=None, description="联网新颖性验证结果")
+    supporting_evidence: str = Field(default="", description="论据支撑")
+
+
+# ---------- 步骤6:实验方案 ----------
+
+class ExperimentPlan(BaseModel):
+    """实验方案"""
+    innovation_title: str
+    hypothesis: str = Field(description="研究假设")
+    datasets: list[str]
+    baselines: list[str] = Field(description="基线方法")
+    metrics: list[str]
+    ablation: list[str] = Field(description="消融实验设计")
+    steps: list[str] = Field(description="实验步骤")
+    expected_results: str
+    risks: str
+
+
+# ---------- 评估 ----------
+
+class ToolCallRecord(BaseModel):
+    """工具调用记录"""
+    tool_name: str
+    args_summary: str
+    success: bool
+    duration_sec: float
+    error: Optional[str] = None
+    # 工具返回的结构化结果(dict/list/str),供 ReportAgent 整合使用
+    result: Optional[Any] = None
+    timestamp: datetime = Field(default_factory=datetime.now)
+
+
+class EvaluationReport(BaseModel):
+    """评估报告"""
+    innovations_scores: list[ThreeDScore]
+    tool_call_success_rate: float = Field(description="工具调用成功率 0-1")
+    total_tool_calls: int
+    failed_tool_calls: int
+    avg_confidence: float = Field(description="平均自校验置信度")
+    tool_calls: list[ToolCallRecord]
+
+
+# ---------- 最终报告 ----------
+
+class FinalReport(BaseModel):
+    """步骤7 整合输出"""
+    background_review: str = Field(description="背景综述")
+    innovations: list[Innovation]
+    experiment_plans: list[ExperimentPlan]
+    references: list[dict] = Field(description="参考文献溯源 {title, path, sections}")
+    evaluation: Optional[EvaluationReport] = None
+    markdown: str = Field(default="", description="完整 Markdown 报告")
+    generated_at: datetime = Field(default_factory=datetime.now)
+
+
+# ---------- 进度事件 ----------
+
+class StepStage(str, Enum):
+    PARSE = "step1_parse"
+    EXTRACT = "step2_extract"
+    INDEX = "step3_index"
+    GAP = "step4_gap"
+    INNOVATION = "step5_innovation"
+    EXPERIMENT = "step6_experiment"
+    INTEGRATE = "step7_integrate"
+
+
+class ProgressEvent(BaseModel):
+    """前端进度推送事件"""
+    stage: StepStage
+    status: str = Field(description="running/done/failed/degraded")
+    message: str
+    progress: float = Field(ge=0.0, le=1.0, description="整体进度 0-1")
+    payload: Optional[dict[str, Any]] = None

+ 6 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/orchestrator/__init__.py

@@ -0,0 +1,6 @@
+"""编排模块:Plan-and-Execute Controller + Reflexion 自校验 + 动态工作流编排"""
+from backend.orchestrator.controller import Controller
+from backend.orchestrator.reflexion import Reflexion
+from backend.orchestrator.workflow import WorkflowOrchestrator
+
+__all__ = ["Controller", "Reflexion", "WorkflowOrchestrator"]

+ 1244 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/orchestrator/controller.py

@@ -0,0 +1,1244 @@
+"""Plan-and-Execute Controller Agent:动态规划执行路径并调度专职 Agent
+
+核心职责:
+- Plan 阶段:调用 LLM 生成动态执行计划(步骤列表),失败时回退默认七步
+- Execute 阶段:逐步执行计划,支持并行调度、动态调整、异常降级
+- Controller 自主决定调用哪个 Agent/工具,体现 Plan-and-Execute 框架
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+import re
+from typing import Any, Callable, Optional
+
+from backend.agents.specialized import build_all_specialized_agents
+from backend.config import settings
+from backend.llm.client import DeepSeekClient
+from backend.llm.json_utils import parse_json_safe
+from backend.memory.manager import MemoryManager
+from backend.storage.paper_library import compute_paper_id, get_paper_library
+from backend.tools.base import ToolRegistry
+
+logger = logging.getLogger(__name__)
+
+# Agent 名称 → 前端进度 stage 映射(与 StepStage 枚举值一致)
+AGENT_STAGE_MAP: dict[str, str] = {
+    "PaperParser": "step1_parse",
+    "Extractor": "step2_extract",
+    "Indexer": "step3_index",
+    "GapAnalyzer": "step4_gap",
+    "InnovationGenerator": "step5_innovation",
+    "ExperimentDesigner": "step6_experiment",
+    "Integration": "step7_integrate",
+}
+
+# 默认七步计划模板(LLM 生成失败时的兜底)
+DEFAULT_PLAN: list[dict] = [
+    {
+        "step": 1,
+        "agent": "PaperParser",
+        "action": "扫描文件夹并解析所有 PDF 论文为结构化文本",
+        "depends_on": [],
+    },
+    {
+        "step": 2,
+        "agent": "Extractor",
+        "action": "对每篇已解析论文抽取结构化字段",
+        "depends_on": [1],
+    },
+    {
+        "step": 3,
+        "agent": "Indexer",
+        "action": "对已解析论文构建向量索引",
+        "depends_on": [1],
+    },
+    {
+        "step": 4,
+        "agent": "GapAnalyzer",
+        "action": "跨论文综合分析识别研究空白",
+        "depends_on": [2],
+    },
+    {
+        "step": 5,
+        "agent": "InnovationGenerator",
+        "action": "针对 Gap 生成创新点并筛选",
+        "depends_on": [4],
+    },
+    {
+        "step": 6,
+        "agent": "ExperimentDesigner",
+        "action": "为创新点设计实验方案",
+        "depends_on": [5],
+    },
+    {
+        "step": 7,
+        "agent": "Integration",
+        "action": "整合所有结果输出最终研究提案",
+        "depends_on": [6],
+    },
+]
+
+# progress_callback 类型别名
+ProgressCallback = Callable[[str, str, str, float, Optional[dict]], Any]
+
+
+class Controller:
+    """Plan-and-Execute Controller:规划执行路径并逐步调度专职 Agent
+
+    Controller 自主决定调用哪个 Agent/工具,而非硬编码固定流程。
+    每步执行后根据结果动态调整剩余计划,支持并行调度与异常降级。
+    """
+
+    def __init__(
+        self,
+        client: DeepSeekClient,
+        registry: ToolRegistry,
+        memory: MemoryManager,
+    ) -> None:
+        self.client = client
+        self.registry = registry
+        self.memory = memory
+        # 初始化 6 个专职 Agent
+        self.agents = build_all_specialized_agents(client, registry)
+
+        # 执行状态
+        self.plan: list[dict] = []
+        self.step_results: dict[int, dict] = {}
+        self.tool_call_records: list[dict] = []
+        self.degraded_steps: list[dict] = []
+
+        # 步骤1 产出的已解析论文列表,供步骤2 并行抽取使用
+        self._parsed_papers: list[dict] = []
+        # 步骤2 产出的已抽取记录列表,供步骤4 Gap 分析使用
+        self._extracted_records: list[dict] = []
+        # 用户研究方向(步骤5 创新生成时注入提示词)
+        self.research_direction: Optional[str] = None
+        # 论文库单例
+        self._paper_library = get_paper_library()
+
+    # ------------------------------------------------------------------ #
+    # Plan 阶段
+    # ------------------------------------------------------------------ #
+
+    async def plan_task(self, folder_path: str) -> list[dict]:
+        """Plan 阶段:调用 LLM 生成动态执行计划
+
+        让 LLM 根据任务自主规划步骤顺序/增减,体现动态编排。
+        LLM 调用失败或输出无效时回退到默认七步计划。
+
+        Args:
+            folder_path: 待分析的 PDF 文件夹路径
+
+        Returns:
+            计划列表,每步含 {step, agent, action, depends_on}
+        """
+        agent_descriptions = "\n".join(
+            f"- {name}:{cls.__doc__ or ''}"
+            for name, cls in [
+                ("PaperParser", "扫描文件夹并解析 PDF"),
+                ("Extractor", "单篇论文结构化抽取"),
+                ("Indexer", "向量索引构建"),
+                ("GapAnalyzer", "跨论文 Gap 识别"),
+                ("InnovationGenerator", "创新点生成与筛选"),
+                ("ExperimentDesigner", "实验方案设计"),
+                ("Integration", "整合输出研究提案"),
+            ]
+        )
+
+        prompt = (
+            f"你是论文创新 Agent 的 Controller。请为以下任务生成动态执行计划。\n\n"
+            f"任务:分析文件夹 {folder_path} 中的 PDF 论文,"
+            f"识别研究空白,生成 2-3 个创新点并设计实验方案。\n\n"
+            f"可用 Agent:\n{agent_descriptions}\n\n"
+            f"请生成执行计划,输出 JSON 数组,每个元素含:\n"
+            f"- step: 步骤序号(整数)\n"
+            f"- agent: Agent 名称(上述之一)\n"
+            f"- action: 该步骤具体任务描述\n"
+            f"- depends_on: 依赖的步骤序号列表\n\n"
+            f"你可以根据任务自主调整顺序或增减步骤。"
+            f"默认链路:解析→抽取→索引→Gap分析→创新生成→实验设计→整合。\n"
+            f"严格只输出 JSON 数组,不要其他文本。"
+        )
+
+        messages = [
+            {
+                "role": "system",
+                "content": "你是 Agent 编排器,负责生成可执行的动态计划。只输出 JSON。",
+            },
+            {"role": "user", "content": prompt},
+        ]
+
+        try:
+            response = await self.client.chat(messages=messages)
+            content = response.choices[0].message.content or ""
+            raw_plan = parse_json_safe(content)
+            if isinstance(raw_plan, list) and len(raw_plan) > 0:
+                normalized = self._normalize_plan(raw_plan)
+                if normalized:
+                    logger.info("LLM 生成计划成功,共 %d 步", len(normalized))
+                    self.plan = normalized
+                    return normalized
+            logger.warning("LLM 计划输出无效,回退默认计划")
+        except Exception as exc:
+            logger.warning("LLM 生成计划失败,回退默认计划: %s", exc)
+
+        # 兜底:默认七步计划
+        default = [dict(s) for s in DEFAULT_PLAN]
+        default[0]["action"] = f"扫描文件夹 {folder_path} 并解析所有 PDF 论文为结构化文本"
+        self.plan = default
+        return default
+
+    def _normalize_plan(self, plan: list) -> list[dict]:
+        """规范化 LLM 输出的计划:补全字段、过滤无效项"""
+        normalized: list[dict] = []
+        for idx, item in enumerate(plan):
+            if not isinstance(item, dict):
+                continue
+            agent = str(item.get("agent", "")).strip()
+            action = str(item.get("action", "")).strip()
+            if not agent or not action:
+                continue
+            step = item.get("step", idx + 1)
+            depends_on = item.get("depends_on", [])
+            if not isinstance(depends_on, list):
+                depends_on = []
+            normalized.append(
+                {
+                    "step": step,
+                    "agent": agent,
+                    "action": action,
+                    "depends_on": depends_on,
+                }
+            )
+        return normalized
+
+    # ------------------------------------------------------------------ #
+    # Execute 阶段
+    # ------------------------------------------------------------------ #
+
+    async def execute_plan(
+        self,
+        plan: list[dict],
+        progress_callback: Optional[ProgressCallback] = None,
+        post_step_hook: Optional[Callable] = None,
+    ) -> dict:
+        """Execute 阶段:逐步执行计划,动态调整,并行调度,异常降级
+
+        Args:
+            plan: 计划列表
+            progress_callback: 进度回调 async (stage, status, message, progress, payload)
+            post_step_hook: 步骤后钩子 async (step, result) -> result,用于插入 Reflexion
+
+        Returns:
+            {steps_results, tool_call_records, degraded_steps}
+        """
+        remaining = list(plan)
+        total = max(len(remaining), 1)
+        completed = 0
+
+        while remaining:
+            step = remaining.pop(0)
+            step_num = step.get("step", completed + 1)
+            agent_name = step.get("agent", "")
+            action = step.get("action", "")
+            progress = completed / total
+
+            # 推送 running 进度
+            await self._emit_progress(
+                progress_callback, agent_name, "running", action, progress
+            )
+
+            # 构建上下文
+            context = self._build_context(step)
+
+            try:
+                result = await self._execute_step(step, context, progress_callback)
+
+                # 步骤后钩子(供 WorkflowOrchestrator 插入 Reflexion 自校验)
+                if post_step_hook is not None:
+                    try:
+                        hooked = await post_step_hook(step, result)
+                        if hooked is not None:
+                            result = hooked
+                    except Exception as exc:
+                        logger.warning("post_step_hook 执行失败: %s", exc)
+
+                self.step_results[step_num] = result
+                self.tool_call_records.extend(result.get("tool_calls", []))
+
+                # 动态调整剩余计划
+                remaining = self._adjust_plan(remaining, step, result)
+
+                await self._emit_progress(
+                    progress_callback,
+                    agent_name,
+                    "done",
+                    f"步骤 {step_num}({agent_name})完成",
+                    (completed + 1) / total,
+                    {"step": step_num, "agent": agent_name},
+                )
+            except Exception as exc:
+                logger.error(
+                    "步骤 %d(%s)执行失败: %s", step_num, agent_name, exc, exc_info=True
+                )
+                self.step_results[step_num] = {
+                    "agent": agent_name,
+                    "result": "",
+                    "tool_calls": [],
+                    "error": str(exc),
+                }
+
+                # 评估是否降级
+                degraded = self._evaluate_degradation(agent_name, str(exc))
+                if degraded:
+                    self.degraded_steps.append(degraded)
+                    await self._emit_progress(
+                        progress_callback,
+                        agent_name,
+                        "degraded",
+                        f"步骤 {step_num} 降级: {degraded['reason']}",
+                        (completed + 1) / total,
+                        {"step": step_num, "degradation": degraded},
+                    )
+                else:
+                    await self._emit_progress(
+                        progress_callback,
+                        agent_name,
+                        "failed",
+                        f"步骤 {step_num} 失败: {exc}",
+                        (completed + 1) / total,
+                        {"step": step_num, "error": str(exc)},
+                    )
+
+            completed += 1
+            total = completed + len(remaining)
+
+        return {
+            "steps_results": self.step_results,
+            "tool_call_records": self.tool_call_records,
+            "degraded_steps": self.degraded_steps,
+        }
+
+    async def _execute_step(
+        self,
+        step: dict,
+        context: str,
+        progress_callback: Optional[ProgressCallback] = None,
+    ) -> dict:
+        """执行单个步骤:根据 agent 名称选择执行策略"""
+        agent_name = step.get("agent", "")
+        action = step.get("action", "")
+
+        # Integration 步骤:Controller 直接调用 LLM 整合
+        if agent_name == "Integration" or agent_name not in self.agents:
+            return await self._execute_integration(action, context)
+
+        # Extractor 步骤:若已有多篇解析论文,并行抽取
+        if agent_name == "Extractor" and self._parsed_papers:
+            return await self._execute_extraction_parallel(action, context)
+
+        # GapAnalyzer 步骤:直接用预处理阶段的抽取记录调用工具
+        if agent_name == "GapAnalyzer" and self._extracted_records:
+            return await self._execute_gap_analysis(action, context)
+
+        # InnovationGenerator 步骤:直接调用工具并注入 research_direction
+        if agent_name == "InnovationGenerator":
+            return await self._execute_innovation_generation(action, context)
+
+        # ExperimentDesigner 步骤:直接调用工具并注入 innovations
+        if agent_name == "ExperimentDesigner":
+            return await self._execute_experiment_design(action, context)
+
+        # 其他步骤:单 Agent 执行
+        return await self._execute_single(agent_name, action, context)
+
+    async def _execute_single(
+        self, agent_name: str, action: str, context: str
+    ) -> dict:
+        """单 Agent 执行步骤"""
+        agent = self.agents.get(agent_name)
+        if agent is None:
+            raise ValueError(f"未知 Agent: {agent_name}")
+
+        result = await agent.run(task=action, context=context)
+
+        # PaperParser 完成后,收集已解析论文供后续并行抽取
+        if agent_name == "PaperParser":
+            await self._collect_parsed_papers(result, action)
+
+        return result
+
+    async def _execute_extraction_parallel(
+        self, action: str, context: str
+    ) -> dict:
+        """并行抽取多篇论文结构化字段
+
+        使用 asyncio.gather + semaphore(MAX_CONCURRENT_PAPERS) 并行调度。
+        每篇论文独立处理,失败隔离不影响其余。
+        """
+        if not self._parsed_papers:
+            # 无已解析论文,降级为单 Agent 执行
+            logger.warning("无已解析论文,Extractor 降级为单 Agent 执行")
+            return await self._execute_single("Extractor", action, context)
+
+        semaphore = asyncio.Semaphore(settings.MAX_CONCURRENT_PAPERS)
+        agent = self.agents["Extractor"]
+
+        async def extract_one(paper: dict) -> dict:
+            """单篇论文抽取任务:直接调用 extract_paper_structure 工具(绕过模型 Function Calling)
+
+            说明:参数已由 Controller 确定(paper_path + parsed_paper),
+            让模型再选一次工具反而会出现参数传递错误(DeepSeek 有时把整段 JSON 当字符串传),
+            浪费迭代次数。这里直接用 ToolLoop 调用工具,再让模型基于结果生成摘要。
+            """
+            async with semaphore:
+                paper_path = paper.get("path", "")
+                try:
+                    # 1) 直接调用 extract_paper_structure 工具(参数已知)
+                    extract_fn = self.registry.get_callable("extract_paper_structure")
+                    if extract_fn is None:
+                        raise RuntimeError("extract_paper_structure 工具未注册")
+
+                    import time as _time
+                    _t0 = _time.perf_counter()
+                    extraction_result = await self._invoke_tool(
+                        "extract_paper_structure",
+                        paper_path=paper_path,
+                        parsed_paper=paper,
+                    )
+                    _duration = round(_time.perf_counter() - _t0, 3)
+
+                    # 2) 记录工具调用
+                    self.tool_call_records.append(
+                        {
+                            "tool_name": "extract_paper_structure",
+                            "args_summary": json.dumps(
+                                {"paper_path": paper_path}, ensure_ascii=False
+                            )[:200],
+                            "success": True,
+                            "duration_sec": _duration,
+                            "error": None,
+                        }
+                    )
+
+                    # 3) 让 LLM 基于抽取结果生成一段摘要(用于前端展示 + 下游 Agent)
+                    if isinstance(extraction_result, str):
+                        extraction_text = extraction_result
+                    else:
+                        extraction_text = json.dumps(
+                            extraction_result, ensure_ascii=False, default=str
+                        )
+
+                    summary_messages = [
+                        {
+                            "role": "system",
+                            "content": (
+                                "你是论文结构化抽取结果的整理助手。"
+                                "请基于给定的抽取结果,输出 200 字以内的核心摘要,"
+                                "包含 title/task_problem/method/key_contributions 四项要点。"
+                            ),
+                        },
+                        {
+                            "role": "user",
+                            "content": f"论文路径:{paper_path}\n\n抽取结果:\n{extraction_text[:6000]}",
+                        },
+                    ]
+                    try:
+                        resp = await self.client.chat(messages=summary_messages)
+                        summary_text = resp.choices[0].message.content or extraction_text[:2000]
+                    except Exception:
+                        # LLM 摘要失败时直接用原始抽取结果
+                        summary_text = extraction_text[:2000]
+
+                    return {
+                        "agent": "Extractor",
+                        "result": summary_text,
+                        "tool_calls": [
+                            {
+                                "tool_name": "extract_paper_structure",
+                                "args_summary": json.dumps(
+                                    {"paper_path": paper_path}, ensure_ascii=False
+                                )[:200],
+                                "success": True,
+                                "duration_sec": _duration,
+                                "error": None,
+                                "result": extraction_result,  # 供 ReportAgent 聚合使用
+                            }
+                        ],
+                        "paper_path": paper_path,
+                        "extraction": extraction_result,
+                    }
+                except Exception as exc:
+                    logger.warning("论文 %s 抽取失败: %s", paper_path, exc)
+                    return {
+                        "agent": "Extractor",
+                        "result": "",
+                        "tool_calls": [],
+                        "error": str(exc),
+                        "paper_path": paper_path,
+                    }
+
+        # 并行调度所有论文抽取
+        results = await asyncio.gather(
+            *[extract_one(p) for p in self._parsed_papers]
+        )
+
+        # 合并结果与工具调用记录
+        all_tool_calls: list[dict] = []
+        result_parts: list[str] = []
+        success_count = 0
+        for r in results:
+            all_tool_calls.extend(r.get("tool_calls", []))
+            result_text = r.get("result", "")
+            if result_text:
+                result_parts.append(result_text)
+                success_count += 1
+
+        logger.info(
+            "并行抽取完成: %d/%d 篇成功", success_count, len(self._parsed_papers)
+        )
+
+        return {
+            "agent": "Extractor",
+            "result": "\n---\n".join(result_parts),
+            "tool_calls": all_tool_calls,
+            "papers_count": len(results),
+            "success_count": success_count,
+            "individual_results": results,
+        }
+
+    async def _execute_gap_analysis(self, action: str, context: str) -> dict:
+        """GapAnalyzer 步骤:直接用预处理阶段的抽取记录调用 analyze_gaps 工具
+
+        绕过 Function Calling,避免参数传递错误(与 Extractor 并行抽取同理)。
+        """
+        import time as _time
+
+        if not self._extracted_records:
+            logger.warning("无已抽取记录,GapAnalyzer 降级为单 Agent 执行")
+            return await self._execute_single("GapAnalyzer", action, context)
+
+        _t0 = _time.perf_counter()
+        try:
+            gaps_result = await self._invoke_tool(
+                "analyze_gaps", papers_records=self._extracted_records
+            )
+            _duration = round(_time.perf_counter() - _t0, 3)
+
+            tool_call = {
+                "tool_name": "analyze_gaps",
+                "args_summary": json.dumps(
+                    {"papers_count": len(self._extracted_records)}, ensure_ascii=False
+                )[:200],
+                "success": True,
+                "duration_sec": _duration,
+                "error": None,
+                "result": gaps_result,
+            }
+
+            # 生成摘要文本供前端展示与下游 Integration 使用
+            gaps = gaps_result.get("gaps", []) if isinstance(gaps_result, dict) else []
+            summary_text = f"识别到 {len(gaps)} 个研究空白(Gap)"
+
+            return {
+                "agent": "GapAnalyzer",
+                "result": summary_text,
+                "tool_calls": [tool_call],
+                "gaps_count": len(gaps),
+            }
+        except Exception as exc:
+            logger.error("Gap 分析失败: %s", exc)
+            return {
+                "agent": "GapAnalyzer",
+                "result": "",
+                "tool_calls": [],
+                "error": str(exc),
+            }
+
+    async def _execute_innovation_generation(self, action: str, context: str) -> dict:
+        """InnovationGenerator 步骤:直接调用 generate_innovations 工具,注入 research_direction
+
+        从上一个步骤(GapAnalyzer)的结果中提取 gaps,直接调用工具,
+        避免 Function Calling 不可靠地传递 research_direction 参数。
+        """
+        import time as _time
+
+        # 从 step_results 中提取 gaps(GapAnalyzer 的 tool_calls 里)
+        gaps: list[dict] = []
+        for step_num, result in self.step_results.items():
+            if not isinstance(result, dict):
+                continue
+            if result.get("agent") != "GapAnalyzer":
+                continue
+            for tc in result.get("tool_calls", []):
+                if isinstance(tc, dict) and tc.get("tool_name") == "analyze_gaps":
+                    res = tc.get("result")
+                    if isinstance(res, dict):
+                        gaps = res.get("gaps", [])
+                    break
+            if gaps:
+                break
+
+        if not gaps:
+            logger.warning("无 Gap 数据,InnovationGenerator 跳过")
+            return {
+                "agent": "InnovationGenerator",
+                "result": "无 Gap 数据,未生成创新点",
+                "tool_calls": [],
+            }
+
+        _t0 = _time.perf_counter()
+        try:
+            innovations_result = await self._invoke_tool(
+                "generate_innovations",
+                gaps=gaps,
+                research_direction=self.research_direction,
+            )
+            _duration = round(_time.perf_counter() - _t0, 3)
+
+            tool_call = {
+                "tool_name": "generate_innovations",
+                "args_summary": json.dumps(
+                    {"gaps_count": len(gaps), "research_direction": self.research_direction or ""},
+                    ensure_ascii=False,
+                )[:200],
+                "success": True,
+                "duration_sec": _duration,
+                "error": None,
+                "result": innovations_result,
+            }
+
+            innovations = innovations_result.get("innovations", []) if isinstance(innovations_result, dict) else []
+            summary_text = f"生成 {len(innovations)} 个创新点"
+
+            return {
+                "agent": "InnovationGenerator",
+                "result": summary_text,
+                "tool_calls": [tool_call],
+                "innovations_count": len(innovations),
+            }
+        except Exception as exc:
+            logger.error("创新点生成失败: %s", exc)
+            return {
+                "agent": "InnovationGenerator",
+                "result": "",
+                "tool_calls": [],
+                "error": str(exc),
+            }
+
+    async def _execute_experiment_design(self, action: str, context: str) -> dict:
+        """ExperimentDesigner 步骤:直接调用 design_experiments 工具,注入 innovations
+
+        从上一个步骤(InnovationGenerator)的结果中提取 innovations,直接调用工具,
+        避免 Function Calling 不可靠地传递 innovations 参数(实测 LLM 经常漏传)。
+        """
+        import time as _time
+
+        # 从 step_results 中提取 innovations(InnovationGenerator 的 tool_calls 里)
+        innovations: list[dict] = []
+        for step_num, result in self.step_results.items():
+            if not isinstance(result, dict):
+                continue
+            if result.get("agent") != "InnovationGenerator":
+                continue
+            for tc in result.get("tool_calls", []):
+                if isinstance(tc, dict) and tc.get("tool_name") == "generate_innovations":
+                    res = tc.get("result")
+                    if isinstance(res, dict):
+                        innovations = res.get("innovations", [])
+                    break
+            if innovations:
+                break
+
+        if not innovations:
+            logger.warning("无 Innovation 数据,ExperimentDesigner 跳过")
+            return {
+                "agent": "ExperimentDesigner",
+                "result": "无创新点数据,未生成实验方案",
+                "tool_calls": [],
+            }
+
+        _t0 = _time.perf_counter()
+        try:
+            plans_result = await self._invoke_tool(
+                "design_experiments", innovations=innovations
+            )
+            _duration = round(_time.perf_counter() - _t0, 3)
+
+            tool_call = {
+                "tool_name": "design_experiments",
+                "args_summary": json.dumps(
+                    {"innovations_count": len(innovations)}, ensure_ascii=False
+                )[:200],
+                "success": True,
+                "duration_sec": _duration,
+                "error": None,
+                "result": plans_result,
+            }
+
+            plans = plans_result.get("experiment_plans", []) if isinstance(plans_result, dict) else []
+            summary_text = f"为 {len(plans)} 个创新点设计了实验方案"
+
+            return {
+                "agent": "ExperimentDesigner",
+                "result": summary_text,
+                "tool_calls": [tool_call],
+                "plans_count": len(plans),
+            }
+        except Exception as exc:
+            logger.error("实验方案设计失败: %s", exc)
+            return {
+                "agent": "ExperimentDesigner",
+                "result": "",
+                "tool_calls": [],
+                "error": str(exc),
+            }
+
+    async def _execute_integration(self, action: str, context: str) -> dict:
+        """Integration 步骤:Controller 直接调用 LLM 整合所有步骤结果"""
+        import time as _time
+
+        _t0 = _time.perf_counter()
+        parts: list[str] = []
+        for step_num, result in self.step_results.items():
+            result_text = (
+                result.get("result", "") if isinstance(result, dict) else str(result)
+            )
+            if result_text:
+                parts.append(f"## 步骤 {step_num} 结果\n{result_text[:3000]}")
+
+        all_results = "\n\n".join(parts) if parts else context
+
+        messages = [
+            {
+                "role": "system",
+                "content": (
+                    "你是研究提案整合专家。请整合各步骤结果,"
+                    "输出结构化研究提案(背景综述/创新点论证/实验方案/参考文献溯源)。"
+                ),
+            },
+            {
+                "role": "user",
+                "content": f"任务:{action}\n\n各步骤结果:\n{all_results[:10000]}",
+            },
+        ]
+
+        try:
+            _t_llm0 = _time.perf_counter()
+            response = await self.client.chat(messages=messages)
+            logger.info(
+                "[Integration timing] LLM 整合调用: %.2fs",
+                _time.perf_counter() - _t_llm0,
+            )
+            result_text = response.choices[0].message.content or ""
+        except Exception as exc:
+            logger.error("整合步骤失败: %s", exc)
+            result_text = ""
+
+        logger.info(
+            "[Integration timing] 整合步骤总耗时: %.2fs, 输出 %d 字符",
+            _time.perf_counter() - _t0, len(result_text),
+        )
+        return {
+            "agent": "Integration",
+            "result": result_text,
+            "tool_calls": [],
+        }
+
+    async def _collect_parsed_papers(self, result: dict, action: str) -> None:
+        """从 PaperParser 结果中收集已解析论文,供后续并行抽取使用
+
+        优先从结果文本解析 JSON;失败则直接调用 scan_folder + parse_pdf 工具获取。
+        """
+        # 尝试从结果文本中解析 JSON 论文列表
+        text = result.get("result", "")
+        papers = parse_json_safe(text)
+        if isinstance(papers, list) and papers:
+            self._parsed_papers = papers
+            logger.info("从 PaperParser 结果收集到 %d 篇论文", len(papers))
+            return
+
+        # 兜底:从 action 提取文件夹路径,直接调用工具获取结构化论文
+        folder_path = self._extract_folder_path(action)
+        if not folder_path:
+            logger.warning("无法从 action 提取文件夹路径,跳过论文收集")
+            return
+
+        try:
+            scan_result = await self._invoke_tool("scan_folder", folder_path=folder_path)
+            pdf_files = scan_result.get("pdf_files", [])
+            logger.info("扫描到 %d 个 PDF 文件,开始解析", len(pdf_files))
+
+            # 并行解析所有 PDF
+            semaphore = asyncio.Semaphore(settings.MAX_CONCURRENT_PAPERS)
+
+            async def parse_one(pdf_path: str) -> dict:
+                async with semaphore:
+                    try:
+                        return await self._invoke_tool("parse_pdf", file_path=pdf_path)
+                    except Exception as exc:
+                        logger.warning("解析 %s 失败: %s", pdf_path, exc)
+                        return {"path": pdf_path, "error": str(exc)}
+
+            parsed = await asyncio.gather(*[parse_one(p) for p in pdf_files])
+            # 过滤掉解析失败的
+            self._parsed_papers = [p for p in parsed if "error" not in p]
+            logger.info("成功解析 %d 篇论文", len(self._parsed_papers))
+        except Exception as exc:
+            logger.error("收集已解析论文失败: %s", exc)
+            self._parsed_papers = []
+
+    def _extract_folder_path(self, action: str) -> str:
+        """从 action 描述中提取文件夹路径"""
+        # 匹配 "扫描文件夹 {path}" 或 "文件夹 {path}" 模式
+        match = re.search(r"文件夹\s+([^\s,,。]+)", action)
+        if match:
+            return match.group(1)
+        return ""
+
+    async def _invoke_tool(self, tool_name: str, **kwargs) -> Any:
+        """调用注册表中的工具(自动区分同步/异步)"""
+        fn = self.registry.get_callable(tool_name)
+        if fn is None:
+            raise ValueError(f"工具 {tool_name} 未注册")
+        if asyncio.iscoroutinefunction(fn):
+            return await fn(**kwargs)
+        return await asyncio.to_thread(fn, **kwargs)
+
+    # ------------------------------------------------------------------ #
+    # 动态调整与降级
+    # ------------------------------------------------------------------ #
+
+    def _adjust_plan(
+        self, remaining: list[dict], step: dict, result: dict
+    ) -> list[dict]:
+        """根据当前步骤结果动态调整剩余计划
+
+        - 抽取完全失败 → 跳过依赖它的 Gap 分析及后续步骤
+        - 索引失败 → 不跳过后续步骤,但标记降级(GapAnalyzer 仅用结构化字段)
+        """
+        agent_name = step.get("agent", "")
+        has_error = isinstance(result, dict) and bool(result.get("error"))
+
+        if agent_name == "Extractor":
+            # 抽取结果为空或全部失败 → 跳过后续依赖步骤
+            success_count = result.get("success_count", 0) if isinstance(result, dict) else 0
+            papers_count = result.get("papers_count", 0) if isinstance(result, dict) else 0
+            if has_error or (papers_count > 0 and success_count == 0):
+                logger.warning("抽取无有效结果,跳过 Gap 分析及后续步骤")
+                remaining = [
+                    s
+                    for s in remaining
+                    if s.get("agent")
+                    not in ("GapAnalyzer", "InnovationGenerator", "ExperimentDesigner")
+                ]
+
+        if agent_name == "Indexer" and has_error:
+            # 索引失败,后续 GapAnalyzer 仅用结构化字段(不跳过,仅记录降级)
+            logger.info("索引失败,后续步骤将仅用结构化字段(跳过 RAG)")
+
+        return remaining
+
+    def _evaluate_degradation(
+        self, agent_name: str, error: str
+    ) -> Optional[dict]:
+        """评估步骤失败是否可降级继续
+
+        Returns:
+            降级记录 dict,或 None(不可降级)
+        """
+        if agent_name == "Indexer":
+            return {
+                "step": agent_name,
+                "reason": f"向量索引构建失败: {error};降级为仅用结构化字段,跳过 RAG",
+                "strategy": "skip_rag",
+            }
+        if agent_name == "InnovationGenerator":
+            err_lower = error.lower()
+            if "web_search" in err_lower or "search" in err_lower or "联网" in error:
+                return {
+                    "step": agent_name,
+                    "reason": f"联网搜索失败: {error};降级为跳过新颖性去重",
+                    "strategy": "skip_novelty_check",
+                }
+        return None
+
+    # ------------------------------------------------------------------ #
+    # 辅助方法
+    # ------------------------------------------------------------------ #
+
+    def _build_context(self, step: dict) -> str:
+        """构建步骤上下文:从依赖步骤的结果中提取"""
+        depends_on = step.get("depends_on", [])
+        if not depends_on:
+            return ""
+        parts: list[str] = []
+        for dep in depends_on:
+            if dep in self.step_results:
+                result = self.step_results[dep]
+                result_str = json.dumps(result, ensure_ascii=False, default=str)[
+                    :5000
+                ]
+                parts.append(f"步骤 {dep} 结果:\n{result_str}")
+        return "\n\n".join(parts)
+
+    async def _emit_progress(
+        self,
+        callback: Optional[ProgressCallback],
+        agent_name: str,
+        status: str,
+        message: str,
+        progress: float,
+        payload: Optional[dict] = None,
+    ) -> None:
+        """推送进度事件到回调"""
+        if callback is None:
+            return
+        stage = AGENT_STAGE_MAP.get(agent_name, agent_name)
+        try:
+            await callback(stage, status, message, progress, payload)
+        except Exception as exc:
+            logger.warning("进度回调执行失败: %s", exc)
+
+    # ------------------------------------------------------------------ #
+    # 预处理阶段(步骤1-3:解析 → 抽取 → 索引)
+    # ------------------------------------------------------------------ #
+
+    async def _preprocess_papers(
+        self,
+        folder_path: Optional[str] = None,
+        paper_ids: Optional[list[str]] = None,
+        progress_callback: Optional[ProgressCallback] = None,
+    ) -> None:
+        """预处理阶段:PDF 解析 → 结构化抽取 → 向量索引,带缓存复用
+
+        对每篇论文检查 PaperLibrary 中的预处理状态:
+        - 已完成的步骤直接从磁盘加载(标记 cached)
+        - 未完成的步骤执行后写盘并更新状态
+
+        Args:
+            folder_path: PDF 文件夹路径(与 paper_ids 二选一)
+            paper_ids: 上传论文 ID 列表(与 folder_path 二选一)
+            progress_callback: 进度回调
+        """
+        import time as _time
+
+        # 1. 收集待处理论文文件路径列表
+        paper_files: list[tuple[str, str]] = []  # [(file_path, filename), ...]
+        if paper_ids:
+            for pid in paper_ids:
+                entry = self._paper_library.get(pid)
+                if entry is None:
+                    logger.warning("论文 paper_id=%s 不在库中,跳过", pid[:12])
+                    continue
+                file_path = entry.get("original_path", "")
+                if file_path:
+                    paper_files.append((file_path, entry.get("filename", "")))
+        elif folder_path:
+            scan_result = await self._invoke_tool("scan_folder", folder_path=folder_path)
+            pdf_files = scan_result.get("pdf_files", [])
+            for fp in pdf_files:
+                paper_files.append((fp, os.path.basename(fp)))
+        else:
+            logger.warning("未提供 folder_path 或 paper_ids,跳过预处理")
+            return
+
+        if not paper_files:
+            logger.warning("未找到任何 PDF 文件")
+            return
+
+        _pre_t0 = _time.perf_counter()
+        logger.info("预处理开始:共 %d 篇论文", len(paper_files))
+
+        # 2. 步骤1:PDF 解析(带缓存)
+        _parse_t0 = _time.perf_counter()
+        await self._emit_progress(
+            progress_callback, "PaperParser", "running",
+            f"开始解析 {len(paper_files)} 篇 PDF", 0.0,
+        )
+
+        semaphore = asyncio.Semaphore(settings.MAX_CONCURRENT_PAPERS)
+        all_cached_parse = True
+
+        async def parse_one(file_path: str, filename: str) -> dict:
+            nonlocal all_cached_parse
+            async with semaphore:
+                try:
+                    paper_id = compute_paper_id(file_path)
+                    # 注册到论文库
+                    source = "upload" if paper_ids else "folder"
+                    self._paper_library.register(paper_id, filename, source, file_path)
+                    entry = self._paper_library.get(paper_id)
+
+                    # 检查缓存
+                    if entry and entry.get("parse_status") == "done":
+                        from backend.tools.parse_pdf import load_parsed
+                        cached = load_parsed(paper_id)
+                        if cached and "error" not in cached:
+                            logger.info("论文 %s 解析结果命中缓存", file_path)
+                            return cached
+
+                    all_cached_parse = False
+                    # 执行解析
+                    parsed = await self._invoke_tool("parse_pdf", file_path=file_path)
+                    if "error" in parsed:
+                        self._paper_library.update_status(paper_id, parse_status="failed")
+                        return parsed
+
+                    # 写入缓存
+                    from backend.tools.parse_pdf import save_parsed
+                    save_parsed(paper_id, parsed)
+                    title = parsed.get("title", "") if isinstance(parsed, dict) else ""
+                    self._paper_library.update_status(
+                        paper_id, parse_status="done", title=title
+                    )
+                    return parsed
+                except Exception as exc:
+                    logger.error("解析 %s 失败: %s", file_path, exc)
+                    return {"error": f"解析失败: {exc}", "path": file_path}
+
+        parsed_results = await asyncio.gather(
+            *[parse_one(fp, fn) for fp, fn in paper_files]
+        )
+        _parse_done = _time.perf_counter()
+        logger.info(
+            "[预处理 timing] 步骤1 解析完成: %.2fs (含 gather),成功 %d/%d",
+            _parse_done - _parse_t0,
+            len([p for p in parsed_results if "error" not in p]),
+            len(parsed_results),
+        )
+        self._parsed_papers = [p for p in parsed_results if "error" not in p]
+
+        parse_status = "cached" if all_cached_parse and self._parsed_papers else "done"
+        await self._emit_progress(
+            progress_callback, "PaperParser", parse_status,
+            f"解析完成:{len(self._parsed_papers)}/{len(paper_files)} 篇成功", 0.15,
+        )
+
+        if not self._parsed_papers:
+            logger.error("无有效解析结果,终止预处理")
+            return
+
+        # 3. 步骤2:结构化抽取(带缓存)
+        _extract_t0 = _time.perf_counter()
+        await self._emit_progress(
+            progress_callback, "Extractor", "running",
+            f"开始抽取 {len(self._parsed_papers)} 篇论文结构化字段", 0.2,
+        )
+
+        all_cached_extract = True
+
+        async def extract_one(paper: dict) -> dict:
+            nonlocal all_cached_extract
+            async with semaphore:
+                paper_path = paper.get("path", "")
+                try:
+                    paper_id = compute_paper_id(paper_path)
+                    entry = self._paper_library.get(paper_id)
+
+                    # 检查缓存
+                    if entry and entry.get("extract_status") == "done":
+                        from backend.tools.extract_paper_structure import load_record
+                        cached = load_record(paper_path, paper_id=paper_id)
+                        if cached:
+                            logger.info("论文 %s 抽取结果命中缓存", paper_path)
+                            return cached
+
+                    all_cached_extract = False
+                    # 执行抽取
+                    _t0 = _time.perf_counter()
+                    extraction = await self._invoke_tool(
+                        "extract_paper_structure",
+                        paper_path=paper_path,
+                        parsed_paper=paper,
+                    )
+                    _duration = round(_time.perf_counter() - _t0, 3)
+
+                    if isinstance(extraction, dict) and extraction.get("path"):
+                        # 写入缓存
+                        from backend.tools.extract_paper_structure import save_record
+                        save_record(extraction, paper_id=paper_id)
+                        self._paper_library.update_status(paper_id, extract_status="done")
+
+                        # 记录工具调用(供 _build_final_results 聚合)
+                        self.tool_call_records.append({
+                            "tool_name": "extract_paper_structure",
+                            "args_summary": json.dumps(
+                                {"paper_path": paper_path}, ensure_ascii=False
+                            )[:200],
+                            "success": True,
+                            "duration_sec": _duration,
+                            "error": None,
+                            "result": extraction,
+                        })
+                    return extraction
+                except Exception as exc:
+                    logger.warning("论文 %s 抽取失败: %s", paper_path, exc)
+                    return {}
+
+        extract_results = await asyncio.gather(
+            *[extract_one(p) for p in self._parsed_papers]
+        )
+        _extract_done = _time.perf_counter()
+        logger.info(
+            "[预处理 timing] 步骤2 抽取完成: %.2fs (含 gather),成功 %d/%d",
+            _extract_done - _extract_t0,
+            len([r for r in extract_results if r and "path" in r]),
+            len(extract_results),
+        )
+        self._extracted_records = [r for r in extract_results if r and "path" in r]
+
+        extract_status = "cached" if all_cached_extract and self._extracted_records else "done"
+        await self._emit_progress(
+            progress_callback, "Extractor", extract_status,
+            f"抽取完成:{len(self._extracted_records)}/{len(self._parsed_papers)} 篇成功", 0.4,
+        )
+
+        # 将抽取阶段的 tool_calls 存入 step_results,供 _build_final_results 聚合
+        _t_agg0 = _time.perf_counter()
+        extract_tool_calls = [
+            tc for tc in self.tool_call_records
+            if tc.get("tool_name") == "extract_paper_structure"
+        ]
+        self.step_results[2] = {
+            "agent": "Extractor",
+            "result": f"抽取完成:{len(self._extracted_records)} 篇",
+            "tool_calls": extract_tool_calls,
+            "papers_count": len(self._parsed_papers),
+            "success_count": len(self._extracted_records),
+        }
+
+        # 4. 步骤3:向量索引构建(带去重)
+        _index_t0 = _time.perf_counter()
+        logger.info(
+            "[预处理 timing] 抽取→索引间隔: %.2fs (聚合 step_results + emit_progress)",
+            _index_t0 - _extract_done,
+        )
+        await self._emit_progress(
+            progress_callback, "Indexer", "running",
+            "开始构建向量索引", 0.45,
+        )
+
+        all_cached_index = True
+        papers_to_index: list[dict] = []
+        _dedup_t0 = _time.perf_counter()
+        for paper in self._parsed_papers:
+            paper_path = paper.get("path", "")
+            try:
+                paper_id = compute_paper_id(paper_path)
+                entry = self._paper_library.get(paper_id)
+                if entry and entry.get("index_status") == "done":
+                    logger.info("论文 %s 已索引,跳过", paper_path)
+                    continue
+                all_cached_index = False
+                papers_to_index.append(paper)
+            except Exception:
+                papers_to_index.append(paper)
+        logger.info(
+            "[预处理 timing] 索引去重检查(paper_library): %.2fs,待索引 %d 篇",
+            _time.perf_counter() - _dedup_t0, len(papers_to_index),
+        )
+
+        if papers_to_index:
+            _t0 = _time.perf_counter()
+            index_result = await self._invoke_tool(
+                "build_vector_index", papers_json=papers_to_index
+            )
+            _duration = round(_time.perf_counter() - _t0, 3)
+            indexed_count = index_result.get("indexed_count", 0) if isinstance(index_result, dict) else 0
+
+            # 更新索引状态
+            for paper in papers_to_index:
+                paper_path = paper.get("path", "")
+                try:
+                    paper_id = compute_paper_id(paper_path)
+                    self._paper_library.update_status(paper_id, index_status="done")
+                except Exception:
+                    pass
+
+            self.tool_call_records.append({
+                "tool_name": "build_vector_index",
+                "args_summary": json.dumps(
+                    {"papers_count": len(papers_to_index)}, ensure_ascii=False
+                )[:200],
+                "success": True,
+                "duration_sec": _duration,
+                "error": None,
+                "result": index_result,
+            })
+
+        index_status = "cached" if all_cached_index else "done"
+        await self._emit_progress(
+            progress_callback, "Indexer", index_status,
+            f"索引构建完成(新索引 {len(papers_to_index)} 篇,复用缓存 {len(self._parsed_papers) - len(papers_to_index)} 篇)", 0.5,
+        )
+
+        logger.info(
+            "[预处理 timing] 步骤3 索引完成: %.2fs | 预处理总耗时: %.2fs | 解析=%d 抽取=%d 待索引=%d",
+            _time.perf_counter() - _index_t0,
+            _time.perf_counter() - _pre_t0,
+            len(self._parsed_papers), len(self._extracted_records), len(papers_to_index),
+        )
+
+    # ------------------------------------------------------------------ #
+    # 完整流程
+    # ------------------------------------------------------------------ #
+
+    async def run(
+        self,
+        folder_path: Optional[str] = None,
+        paper_ids: Optional[list[str]] = None,
+        research_direction: Optional[str] = None,
+        progress_callback: Optional[ProgressCallback] = None,
+        post_step_hook: Optional[Callable] = None,
+    ) -> dict:
+        """完整流程:预处理(步骤1-3) → plan_task → execute_plan(步骤4-7) → 返回最终结果
+
+        Args:
+            folder_path: PDF 文件夹路径(与 paper_ids 二选一)
+            paper_ids: 上传论文 ID 列表(与 folder_path 二选一)
+            research_direction: 用户研究方向(可选,注入创新生成提示词)
+            progress_callback: 进度回调
+            post_step_hook: 步骤后钩子(供 Reflexion 插入)
+
+        Returns:
+            {steps_results, tool_call_records, degraded_steps, plan}
+        """
+        # 重置状态
+        self.step_results = {}
+        self.tool_call_records = []
+        self.degraded_steps = []
+        self._parsed_papers = []
+        self._extracted_records = []
+        self.research_direction = research_direction
+
+        # Phase 1: 预处理(步骤1-3:解析 → 抽取 → 索引),带缓存复用
+        await self._preprocess_papers(
+            folder_path=folder_path,
+            paper_ids=paper_ids,
+            progress_callback=progress_callback,
+        )
+
+        # Phase 2: Plan 阶段(仅步骤4-7)
+        task_desc = folder_path or f"已上传的 {len(paper_ids or [])} 篇论文"
+        self.plan = await self.plan_task(task_desc)
+        # 过滤掉步骤1-3(已由预处理阶段完成)
+        self.plan = [
+            s for s in self.plan
+            if s.get("agent") not in ("PaperParser", "Extractor", "Indexer")
+        ]
+        # 若过滤后为空,使用默认步骤4-7
+        if not self.plan:
+            self.plan = [dict(s) for s in DEFAULT_PLAN if s.get("agent") not in ("PaperParser", "Extractor", "Indexer")]
+
+        # Phase 3: Execute 阶段(步骤4-7)
+        result = await self.execute_plan(
+            self.plan, progress_callback, post_step_hook
+        )
+
+        # 附加计划信息,供后续整合输出 Agent 使用
+        result["plan"] = self.plan
+        return result

+ 223 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/orchestrator/reflexion.py

@@ -0,0 +1,223 @@
+"""Reflexion 自校验机制:关键步骤后自检质量,低于阈值触发针对性补抽/重试
+
+核心职责:
+- self_check:让模型对照上下文检查结果质量,输出置信度与问题
+- reflect_and_retry:自校验 + 针对性重试(非整篇重跑),最多重试 2 次
+- 记录所有自校验置信度,提供统计接口
+"""
+from __future__ import annotations
+
+import json
+import logging
+from typing import Callable
+
+from backend.config import settings
+from backend.agents.hello_agents_runner import build_reviewer_agent, run_reviewer_check
+from backend.llm.client import DeepSeekClient
+from backend.llm.json_utils import parse_json_safe
+
+logger = logging.getLogger(__name__)
+
+# 审核 Agent 的系统提示词
+REVIEWER_SYSTEM_PROMPT = "你是质量审核员,负责对照上下文检查 Agent 输出质量。只输出 JSON。"
+
+# 最多重试次数
+MAX_RETRIES = 2
+
+
+class Reflexion:
+    """Reflexion 自校验机制
+
+    在关键步骤(抽取/Gap/创新)后启用:
+    1. 对照上下文自检结果质量,输出置信度;
+    2. 置信度低于阈值时触发针对性补抽/重试(retry_func),非整篇重跑;
+    3. 最多重试 MAX_RETRIES 次,仍不达标则标记 needs_human_review。
+    """
+
+    def __init__(self, client: DeepSeekClient) -> None:
+        self.client = client
+        # 记录所有自校验的置信度
+        self.confidences: list[float] = []
+
+    async def self_check(
+        self,
+        step_name: str,
+        result: dict,
+        context: str = "",
+    ) -> dict:
+        """让模型对照上下文检查结果质量
+
+        Args:
+            step_name: 步骤名称(如 Extractor / GapAnalyzer / InnovationGenerator)
+            result: 步骤执行结果 dict
+            context: 校验上下文(依赖步骤的结果或原文摘要)
+
+        Returns:
+            {
+                "confidence": float,        # 0-1 置信度
+                "issues": list[str],        # 发现的问题
+                "needs_retry": bool,        # 是否需要重试
+                "retry_fields": list[str],  # 需重试的字段或方面
+            }
+        """
+        # 序列化结果,截断避免超长
+        if isinstance(result, dict):
+            result_str = json.dumps(result, ensure_ascii=False, default=str)[:6000]
+        else:
+            result_str = str(result)[:6000]
+
+        context_str = context[:4000] if context else "(无额外上下文)"
+
+        prompt = (
+            f"请对照上下文检查以下步骤的结果质量。\n\n"
+            f"步骤:{step_name}\n"
+            f"上下文:\n{context_str}\n\n"
+            f"结果:\n{result_str}\n\n"
+            f"检查要求:\n"
+            f"1. 评估结果是否准确、完整、无臆造;\n"
+            f"2. 输出 0-1 的置信度(confidence);\n"
+            f"3. 列出发现的问题(issues);\n"
+            f"4. 置信度低于 {settings.CONFIDENCE_THRESHOLD} 时 needs_retry=true;\n"
+            f"5. 指出需重试的字段或方面(retry_fields)。\n\n"
+            f"严格以 JSON 输出,格式:\n"
+            f'{{"confidence": 0.85, "issues": ["问题1"], '
+            f'"needs_retry": false, "retry_fields": []}}'
+        )
+
+        # 通过 HelloAgents 框架 SimpleAgent(质量审核员角色)执行自校验
+        try:
+            reviewer = build_reviewer_agent(
+                self.client.llm, system_prompt=REVIEWER_SYSTEM_PROMPT
+            )
+            content = await run_reviewer_check(reviewer, prompt)
+            data = parse_json_safe(content)
+            if not isinstance(data, dict):
+                data = {}
+        except Exception as exc:
+            logger.warning("自校验 LLM 调用失败: %s", exc)
+            data = {}
+
+        # 解析置信度
+        try:
+            confidence = float(data.get("confidence", 0.0))
+        except (TypeError, ValueError):
+            confidence = 0.0
+        confidence = max(0.0, min(1.0, confidence))
+
+        # 解析是否需要重试
+        needs_retry = data.get("needs_retry", False)
+        if not isinstance(needs_retry, bool):
+            needs_retry = bool(needs_retry)
+        # 置信度低于阈值强制标记重试
+        if confidence < settings.CONFIDENCE_THRESHOLD:
+            needs_retry = True
+
+        # 解析问题列表
+        issues = data.get("issues", [])
+        if not isinstance(issues, list):
+            issues = [str(issues)] if issues else []
+
+        # 解析重试字段
+        retry_fields = data.get("retry_fields", [])
+        if not isinstance(retry_fields, list):
+            retry_fields = [str(retry_fields)] if retry_fields else []
+
+        # 记录置信度
+        self.confidences.append(confidence)
+
+        check_result = {
+            "confidence": confidence,
+            "issues": issues,
+            "needs_retry": needs_retry,
+            "retry_fields": retry_fields,
+        }
+
+        logger.info(
+            "步骤 %s 自校验: confidence=%.2f, needs_retry=%s",
+            step_name,
+            confidence,
+            needs_retry,
+        )
+
+        return check_result
+
+    async def reflect_and_retry(
+        self,
+        step_name: str,
+        result: dict,
+        context: str,
+        retry_func: Callable,
+    ) -> dict:
+        """自校验 + 针对性重试
+
+        流程:
+        1. 调用 self_check 检查结果质量;
+        2. 若 needs_retry,调用 retry_func 进行针对性补抽/重试(非整篇重跑);
+        3. 最多重试 MAX_RETRIES 次;
+        4. 仍不达标则标记 needs_human_review 并返回当前结果。
+
+        Args:
+            step_name: 步骤名称
+            result: 原始结果
+            context: 校验上下文
+            retry_func: 重试函数(async,无参,返回新的 result dict)
+
+        Returns:
+            更新后的 result dict,附加 reflexion 字段与可能的 needs_human_review
+        """
+        current = result
+        check = await self.self_check(step_name, current, context)
+
+        retries = 0
+        while check["needs_retry"] and retries < MAX_RETRIES:
+            retries += 1
+            logger.info(
+                "步骤 %s 自校验未达标 (confidence=%.2f),触发针对性重试 %d/%d",
+                step_name,
+                check["confidence"],
+                retries,
+                MAX_RETRIES,
+            )
+            try:
+                current = await retry_func()
+                # 重试后重新自校验
+                check = await self.self_check(step_name, current, context)
+            except Exception as exc:
+                logger.warning("步骤 %s 重试失败: %s", step_name, exc)
+                break
+
+        # 仍不达标,标记需人工复核
+        needs_human_review = check["needs_retry"]
+        if needs_human_review:
+            logger.warning(
+                "步骤 %s 经 %d 次重试仍未达标 (confidence=%.2f),标记需人工复核",
+                step_name,
+                retries,
+                check["confidence"],
+            )
+
+        # 将自校验结果附加到 result
+        if isinstance(current, dict):
+            current["reflexion"] = check
+            if needs_human_review:
+                current["needs_human_review"] = True
+            return current
+        return {
+            "result": current,
+            "reflexion": check,
+            "needs_human_review": needs_human_review,
+        }
+
+    def get_confidence_stats(self) -> dict:
+        """返回置信度统计
+
+        Returns:
+            {avg_confidence, min_confidence, count}
+        """
+        if not self.confidences:
+            return {"avg_confidence": 0.0, "min_confidence": 0.0, "count": 0}
+        return {
+            "avg_confidence": round(sum(self.confidences) / len(self.confidences), 4),
+            "min_confidence": round(min(self.confidences), 4),
+            "count": len(self.confidences),
+        }

+ 298 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/orchestrator/workflow.py

@@ -0,0 +1,298 @@
+"""动态工作流编排与降级:组合 Controller + Reflexion
+
+核心职责:
+- 调用 Controller.run 执行主流程
+- 在关键步骤(抽取/Gap/创新)后插入 Reflexion 自校验
+- 低于阈值的触发针对性补抽
+- 降级策略:索引失败→跳过 RAG 仅用结构化字段;联网搜索失败→跳过新颖性去重
+- 返回 {final_results, evaluation_data}(含工具调用记录、置信度统计、降级记录)
+"""
+from __future__ import annotations
+
+import json
+import logging
+from datetime import datetime
+from typing import Optional
+
+from backend.llm.client import DeepSeekClient
+from backend.memory.manager import MemoryManager
+from backend.orchestrator.controller import Controller, ProgressCallback
+from backend.orchestrator.reflexion import Reflexion
+from backend.tools.base import ToolRegistry
+
+logger = logging.getLogger(__name__)
+
+# 需要插入 Reflexion 自校验的关键步骤
+REFLEXION_STEPS = {"Extractor", "GapAnalyzer", "InnovationGenerator"}
+
+
+class WorkflowOrchestrator:
+    """动态工作流编排器:组合 Controller + Reflexion
+
+    在 Controller 的 Plan-and-Execute 主流程上叠加 Reflexion 自校验:
+    1. Controller 规划并逐步执行;
+    2. 关键步骤完成后,Reflexion 对照上下文自检质量;
+    3. 低于阈值的触发针对性补抽/重试;
+    4. 降级策略保证流程在部分失败时仍能继续。
+    """
+
+    def __init__(
+        self,
+        client: DeepSeekClient,
+        registry: ToolRegistry,
+        memory: MemoryManager,
+    ) -> None:
+        self.controller = Controller(client, registry, memory)
+        self.reflexion = Reflexion(client)
+        # 降级记录
+        self.degradations: list[dict] = []
+
+    async def run_pipeline(
+        self,
+        folder_path: Optional[str] = None,
+        paper_ids: Optional[list[str]] = None,
+        research_direction: Optional[str] = None,
+        progress_callback: Optional[ProgressCallback] = None,
+    ) -> dict:
+        """执行完整工作流:Controller 主流程 + Reflexion 自校验 + 降级处理
+
+        Args:
+            folder_path: PDF 文件夹路径(与 paper_ids 二选一)
+            paper_ids: 上传论文 ID 列表(与 folder_path 二选一)
+            research_direction: 用户研究方向(可选)
+            progress_callback: 进度回调
+
+        Returns:
+            {
+                "final_results": 各步骤结果 dict,
+                "evaluation_data": {
+                    "tool_call_records": 工具调用记录,
+                    "confidence_stats": 置信度统计,
+                    "degradation_records": 降级记录,
+                    "degraded_steps": 降级步骤,
+                    "needs_human_review": 需人工复核的步骤,
+                }
+            }
+        """
+        # 重置降级记录
+        self.degradations = []
+
+        # 定义步骤后钩子:在关键步骤后插入 Reflexion 自校验
+        async def post_step_hook(step: dict, result: dict) -> dict:
+            return await self._reflexion_hook(step, result, progress_callback)
+
+        # 调用 Controller.run 执行主流程(带 Reflexion 钩子)
+        results = await self.controller.run(
+            folder_path=folder_path,
+            paper_ids=paper_ids,
+            research_direction=research_direction,
+            progress_callback=progress_callback,
+            post_step_hook=post_step_hook,
+        )
+
+        # 处理 Controller 自身的降级记录
+        for degraded in results.get("degraded_steps", []):
+            self._record_degradation(
+                degraded.get("step", ""), degraded.get("reason", "")
+            )
+
+        # 收集需人工复核的步骤
+        needs_human_review = self._collect_human_review(results)
+
+        # 编译评估数据
+        evaluation_data = {
+            "tool_call_records": results.get("tool_call_records", []),
+            "confidence_stats": self.reflexion.get_confidence_stats(),
+            "degradation_records": self.degradations,
+            "degraded_steps": results.get("degraded_steps", []),
+            "needs_human_review": needs_human_review,
+        }
+
+        logger.info(
+            "工作流完成: 置信度统计=%s, 降级记录=%d 条, 需人工复核=%d 步",
+            self.reflexion.get_confidence_stats(),
+            len(self.degradations),
+            len(needs_human_review),
+        )
+
+        # 从各步骤的 tool_calls 里聚合结构化数据,组装成 ReportAgent 期望的 4 字段
+        steps_results = results.get("steps_results", {})
+        final_results = self._build_final_results(steps_results)
+
+        return {
+            "final_results": final_results,
+            "evaluation_data": evaluation_data,
+        }
+
+    def _build_final_results(self, steps_results: dict) -> dict:
+        """从 steps_results 中各步骤的 tool_calls 聚合结构化数据。
+
+        ReportAgent 期望的输入字段:
+          - papers_records:步骤2 Extractor 抽取的 PaperRecord 列表
+          - gaps:步骤4 GapAnalyzer 工具返回的 Gap 列表
+          - innovations:步骤5 InnovationGenerator 工具返回的 Innovation 列表
+          - experiment_plans:步骤6 ExperimentDesigner 工具返回的 ExperimentPlan 列表
+        """
+        final: dict = {
+            "papers_records": [],
+            "gaps": [],
+            "innovations": [],
+            "experiment_plans": [],
+        }
+
+        for step_num, step_result in steps_results.items():
+            if not isinstance(step_result, dict):
+                continue
+            tool_calls = step_result.get("tool_calls", []) or []
+            for tc in tool_calls:
+                if not isinstance(tc, dict) or not tc.get("success"):
+                    continue
+                tool_name = tc.get("tool_name", "")
+                result_data = tc.get("result")
+                if result_data is None:
+                    continue
+
+                # extract_paper_structure:单条 PaperRecord dict
+                if tool_name == "extract_paper_structure":
+                    if isinstance(result_data, dict):
+                        final["papers_records"].append(result_data)
+                    elif isinstance(result_data, list):
+                        final["papers_records"].extend(
+                            [x for x in result_data if isinstance(x, dict)]
+                        )
+
+                # analyze_gaps:{"gaps": [...]}
+                elif tool_name == "analyze_gaps":
+                    gaps = (
+                        result_data.get("gaps", [])
+                        if isinstance(result_data, dict)
+                        else []
+                    )
+                    final["gaps"].extend(gaps)
+
+                # generate_innovations:{"innovations": [...]}
+                elif tool_name == "generate_innovations":
+                    innovations = (
+                        result_data.get("innovations", [])
+                        if isinstance(result_data, dict)
+                        else []
+                    )
+                    final["innovations"].extend(innovations)
+
+                # design_experiments:{"experiment_plans": [...]}
+                elif tool_name == "design_experiments":
+                    plans = (
+                        result_data.get("experiment_plans", [])
+                        if isinstance(result_data, dict)
+                        else []
+                    )
+                    final["experiment_plans"].extend(plans)
+
+        logger.info(
+            "结构化数据聚合: papers=%d, gaps=%d, innovations=%d, plans=%d",
+            len(final["papers_records"]),
+            len(final["gaps"]),
+            len(final["innovations"]),
+            len(final["experiment_plans"]),
+        )
+        return final
+
+    async def _reflexion_hook(
+        self,
+        step: dict,
+        result: dict,
+        progress_callback: Optional[ProgressCallback] = None,
+    ) -> dict:
+        """步骤后 Reflexion 钩子:对关键步骤自校验,低于阈值触发针对性补抽
+
+        Args:
+            step: 计划步骤 dict
+            result: 步骤执行结果
+            progress_callback: 进度回调
+
+        Returns:
+            校验/重试后的结果
+        """
+        agent_name = step.get("agent", "")
+
+        # 仅对关键步骤启用 Reflexion
+        if agent_name not in REFLEXION_STEPS:
+            return result
+
+        # 构建自校验上下文(依赖步骤的结果)
+        context = self._build_reflexion_context(step)
+
+        # 定义针对性重试函数:重新执行该步骤
+        async def retry_func() -> dict:
+            logger.info("步骤 %s 触发针对性补抽/重试", agent_name)
+            # 推送重试进度
+            if progress_callback:
+                await self.controller._emit_progress(
+                    progress_callback,
+                    agent_name,
+                    "running",
+                    f"步骤 {agent_name} 触发针对性重试",
+                    0.0,
+                    {"retry": True, "step": step.get("step")},
+                )
+            # 重新执行该步骤
+            step_context = self.controller._build_context(step)
+            return await self.controller._execute_step(
+                step, step_context, progress_callback
+            )
+
+        # Reflexion 自校验 + 重试
+        checked_result = await self.reflexion.reflect_and_retry(
+            step_name=agent_name,
+            result=result,
+            context=context,
+            retry_func=retry_func,
+        )
+
+        # 若重试后产生了新的工具调用记录,追加到 Controller
+        if isinstance(checked_result, dict):
+            new_tool_calls = checked_result.get("tool_calls", [])
+            if new_tool_calls and new_tool_calls != result.get("tool_calls", []):
+                self.controller.tool_call_records.extend(new_tool_calls)
+
+        return checked_result
+
+    def _build_reflexion_context(self, step: dict) -> str:
+        """构建 Reflexion 自校验上下文:从依赖步骤的结果中提取"""
+        depends_on = step.get("depends_on", [])
+        if not depends_on:
+            return ""
+        parts: list[str] = []
+        for dep in depends_on:
+            if dep in self.controller.step_results:
+                result = self.controller.step_results[dep]
+                result_str = json.dumps(result, ensure_ascii=False, default=str)[
+                    :3000
+                ]
+                parts.append(f"步骤 {dep} 结果:\n{result_str}")
+        return "\n\n".join(parts)
+
+    def _record_degradation(self, step: str, reason: str) -> None:
+        """记录降级事件"""
+        record = {
+            "step": step,
+            "reason": reason,
+            "timestamp": datetime.now().isoformat(),
+        }
+        self.degradations.append(record)
+        logger.warning("降级记录: step=%s, reason=%s", step, reason)
+
+    def _collect_human_review(self, results: dict) -> list[dict]:
+        """收集需人工复核的步骤"""
+        review_list: list[dict] = []
+        steps_results = results.get("steps_results", {})
+        for step_num, result in steps_results.items():
+            if isinstance(result, dict) and result.get("needs_human_review"):
+                review_list.append(
+                    {
+                        "step": step_num,
+                        "agent": result.get("agent", ""),
+                        "reflexion": result.get("reflexion", {}),
+                    }
+                )
+        return review_list

+ 7 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/rag/__init__.py

@@ -0,0 +1,7 @@
+"""RAG 模块:Embedding + 向量库 + BM25 + 混合搜索"""
+from backend.rag.bm25_store import BM25Store
+from backend.rag.embedding import Embedder
+from backend.rag.hybrid_search import HybridSearcher
+from backend.rag.vector_store import ChromaStore
+
+__all__ = ["Embedder", "ChromaStore", "BM25Store", "HybridSearcher"]

+ 105 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/rag/bm25_store.py

@@ -0,0 +1,105 @@
+"""BM25 关键词检索:基于 rank_bm25 的内存检索,中英文兼容分词"""
+from __future__ import annotations
+
+import re
+from typing import Optional
+
+from rank_bm25 import BM25Okapi
+
+
+class BM25Store:
+    """BM25 内存文档库,懒构建索引"""
+
+    def __init__(self):
+        # 原始文档与对应分词结果并行维护
+        self._docs: list[dict] = []
+        self._tokenized: list[list[str]] = []
+        self._bm25: Optional[BM25Okapi] = None
+        self._dirty = False  # 标记索引是否需要重建
+
+    @staticmethod
+    def _tokenize(text: str) -> list[str]:
+        """中英文兼容分词(不依赖 jieba)。
+
+        - 英文/数字:按连续字母数字切词,统一小写
+        - 中文:按单字切分(字粒度,兼容无词典场景)
+        """
+        if not text:
+            return []
+        tokens: list[str] = []
+        # 英文单词与数字
+        for m in re.findall(r"[A-Za-z0-9]+", text):
+            tokens.append(m.lower())
+        # 中文字符逐字切分
+        for ch in re.findall(r"[\u4e00-\u9fff]", text):
+            tokens.append(ch)
+        return tokens
+
+    def add_chunks(self, chunks: list[dict]):
+        """添加文档。
+
+        每个 chunk 形如 {text, paper_path, title, section}。
+        """
+        for c in chunks:
+            doc = {
+                "text": c.get("text", ""),
+                "paper_path": c.get("paper_path", ""),
+                "title": c.get("title", ""),
+                "section": c.get("section", ""),
+            }
+            self._docs.append(doc)
+            self._tokenized.append(self._tokenize(doc["text"]))
+        self._dirty = True
+
+    def _ensure_index(self):
+        """懒构建 BM25 索引:有新增时重建"""
+        if self._dirty or self._bm25 is None:
+            if self._tokenized:
+                self._bm25 = BM25Okapi(self._tokenized)
+            else:
+                self._bm25 = None
+            self._dirty = False
+
+    def bm25_search(self, query: str, top_k: int = 5) -> list[dict]:
+        """BM25 检索,返回 top_k 结果。
+
+        Returns:
+            list[dict],每项 {text, paper_path, title, section, score}
+        """
+        self._ensure_index()
+        if self._bm25 is None or not self._docs:
+            return []
+        q_tokens = self._tokenize(query)
+        if not q_tokens:
+            return []
+        scores = self._bm25.get_scores(q_tokens)
+        q_set = set(q_tokens)
+        # 仅保留至少包含一个查询词的文档,避免返回无关结果
+        # (注意:小语料下 BM25Okapi 的 IDF 可能为 0,不能再用 score>0 过滤)
+        candidate_idx = [
+            i for i, toks in enumerate(self._tokenized) if q_set & set(toks)
+        ]
+        if not candidate_idx:
+            return []
+        # 在候选中按分数降序取 top_k
+        candidate_idx.sort(key=lambda i: scores[i], reverse=True)
+        out: list[dict] = []
+        for i in candidate_idx[:top_k]:
+            doc = self._docs[i]
+            out.append(
+                {
+                    "text": doc["text"],
+                    "paper_path": doc["paper_path"],
+                    "title": doc["title"],
+                    "section": doc["section"],
+                    "score": float(scores[i]),
+                }
+            )
+        return out
+
+    def clear(self):
+        """清空文档库"""
+        self._docs = []
+        self._tokenized = []
+        self._bm25 = None
+        self._dirty = False

+ 272 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/rag/embedding.py

@@ -0,0 +1,272 @@
+"""本地 Embedding:直接用 transformers 加载 BGE 模型(绕开 sentence-transformers 与 pyarrow)。
+
+为什么不用 sentence-transformers:
+  你的环境里 pyarrow 在 import datasets 时触发 0xC0000005 访问冲突,
+  而 sentence-transformers 强依赖 datasets → pyarrow,整条链路崩溃。
+  这里直接用 transformers 加载 BERT backbone + CLS Pooling,向量结果与 sentence-transformers 等价。
+"""
+from __future__ import annotations
+
+import os
+import threading
+import logging
+from typing import List, Optional
+
+# tokenizers 并行告警抑制;CUDA 由 torch 自行检测(GPU 优先,CPU 兜底)
+os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+# 强制 transformers / huggingface_hub 走离线模式,不再请求 Hub
+os.environ.setdefault("TRANSFORMERS_OFFLINE", "1")
+os.environ.setdefault("HF_HUB_OFFLINE", "1")
+
+from backend.config import settings
+
+logger = logging.getLogger(__name__)
+
+# mini-batch 大小:GPU 16,CPU 8(避免内存爆 + 减少 padding 浪费)
+EMBED_BATCH_SIZE = 16
+
+
+class Embedder:
+    """本地 Embedder,懒加载 BGE 系列模型。
+
+    支持任意 HuggingFace 上有 BertModel + AutoTokenizer 结构的嵌入模型
+    (bge-large-zh-v1.5 / bge-base-zh / bge-small-zh / bge-m3 等)。
+    """
+
+    def __init__(self, model_name: Optional[str] = None):
+        self.model_name = model_name or settings.EMBEDDING_MODEL
+        self._model = None
+        self._tokenizer = None
+        self._lock = threading.Lock()
+        # 自动检测:GPU 可用则用 GPU,否则回退 CPU
+        self._device = self._detect_device()
+        self._batch_size = EMBED_BATCH_SIZE if self._device != "cpu" else 8
+
+    @staticmethod
+    def _detect_device() -> str:
+        """检测可用设备:CUDA 优先,CPU 兜底。"""
+        try:
+            import torch
+
+            if torch.cuda.is_available():
+                return "cuda"
+        except Exception:
+            pass
+        return "cpu"
+
+    def _resolve_local_snapshot(self, model_name: str) -> Optional[str]:
+        """如果 HF 本地缓存已有该模型的 snapshot,直接返回快照路径。"""
+        try:
+            from pathlib import Path as _P
+            from huggingface_hub.constants import HF_HUB_CACHE
+
+            repo_dir_name = "models--" + model_name.replace("/", "--")
+            snapshots_dir = _P(HF_HUB_CACHE) / repo_dir_name / "snapshots"
+            if snapshots_dir.is_dir():
+                snapshots = sorted(
+                    [p for p in snapshots_dir.iterdir() if p.is_dir()],
+                    key=lambda p: p.stat().st_mtime,
+                    reverse=True,
+                )
+                if snapshots:
+                    snap = snapshots[0]
+                    if (snap / "config.json").exists():
+                        return str(snap)
+        except Exception:
+            pass
+        return None
+
+    def _load(self):
+        """懒加载模型:首次调用时加载,双重检查锁保证线程安全。"""
+        import time as _time_load
+        _t_entry = _time_load.perf_counter()
+        logger.info("[_load] 进入 _load: model_is_none=%s", self._model is None)
+        if self._model is None:
+            _t_lock0 = _time_load.perf_counter()
+            logger.info("[_load] 等待 self._lock...")
+            with self._lock:
+                _t_lock1 = _time_load.perf_counter()
+                logger.info("[_load] 获得 self._lock: 等待 %.3fs", _t_lock1 - _t_lock0)
+                if self._model is None:
+                    import time as _time
+                    _t_imp_t = _time.perf_counter()
+                    import torch
+                    _t_imp_torch = _time.perf_counter()
+                    from transformers import AutoModel, AutoTokenizer
+                    _t_imp_tf = _time.perf_counter()
+                    logger.info(
+                        "[_load] imports 完成: 总耗时 %.3fs (torch=%.3fs transformers=%.3fs, 从获得锁算起)",
+                        _t_imp_tf - _t_lock1,
+                        _t_imp_torch - _t_imp_t,
+                        _t_imp_tf - _t_imp_torch,
+                    )
+
+                    _t0 = _time.perf_counter()
+                    local_snapshot = self._resolve_local_snapshot(self.model_name)
+                    if local_snapshot:
+                        load_path = local_snapshot
+                    else:
+                        load_path = self.model_name
+                    _t_resolve = _time.perf_counter()
+
+                    # 注意:bge 官方建议 query 加指令前缀 "为这个句子生成表示以用于检索中文文档:"
+                    self._tokenizer = AutoTokenizer.from_pretrained(
+                        load_path, local_files_only=bool(local_snapshot)
+                    )
+                    _t_tok = _time.perf_counter()
+
+                    self._model = AutoModel.from_pretrained(
+                        load_path, local_files_only=bool(local_snapshot)
+                    )
+                    _t_model_load = _time.perf_counter()
+
+                    # 关键:将模型迁移到 device,并验证实际驻留设备
+                    self._model = self._model.to(self._device)
+                    _t_to_device = _time.perf_counter()
+
+                    # 探测模型参数实际所在设备(防止 .to("cuda") 静默失败)
+                    try:
+                        param = next(self._model.parameters())
+                        actual_device = str(param.device)
+                    except Exception:
+                        actual_device = "unknown"
+
+                    self._model.eval()
+                    _t_eval = _time.perf_counter()
+
+                    # 注意:不做 CUDA warmup。
+                    # 实测在 uvicorn 长驻进程里,dummy forward 反而要 24s(首次 CUDA 上下文初始化)。
+                    # 让第一次真实 forward 自然完成初始化即可,避免额外开销。
+                    _t_warmup = _t_eval
+
+                    logger.info(
+                        "Embedder 模型加载完成: model=%s, device=%s, actual_param_device=%s, batch_size=%d | "
+                        "resolve=%.2fs tokenizer=%.2fs model_load=%.2fs to_device=%.2fs eval=%.2fs cuda_warmup=%.2fs total=%.2fs",
+                        self.model_name, self._device, actual_device, self._batch_size,
+                        _t_resolve - _t0, _t_tok - _t_resolve, _t_model_load - _t_tok,
+                        _t_to_device - _t_model_load, _t_eval - _t_to_device,
+                        _t_warmup - _t_eval, _t_warmup - _t0,
+                    )
+
+    @staticmethod
+    def _last_token_pool(last_hidden_states, attention_mask):
+        """BGE 系列使用的 last-token pooling(等价于 sentence-transformers 的 cls + 末尾 token)。"""
+        left_padding = attention_mask[:, -1].sum() == attention_mask.shape[0]
+        if left_padding:
+            return last_hidden_states[:, -1]
+        sequence_lengths = attention_mask.sum(dim=1) - 1
+        batch_size = last_hidden_states.shape[0]
+        return last_hidden_states[
+            torch.arange(batch_size, device=last_hidden_states.device),
+            sequence_lengths,
+        ]
+
+    def _encode(self, texts: List[str]):
+        import time as _time
+        import torch
+
+        # BGE 官方推荐:query 加指令前缀,passage 不加
+        is_query = getattr(self, "_is_query", True)
+        if is_query and "bge" in self.model_name.lower() and "zh" in self.model_name.lower():
+            prefix = "为这个句子生成表示以用于检索中文文档:"
+            texts = [prefix + t for t in texts]
+
+        # 探测模型实际驻留设备(防止 .to("cuda") 静默失败导致实际跑 CPU)
+        try:
+            _actual_dev = str(next(self._model.parameters()).device)
+        except Exception:
+            _actual_dev = "unknown"
+
+        # mini-batching:避免一次性把全部 chunk 喂入模型(CPU/显存压力 + padding 浪费)
+        all_embeddings: List[List[float]] = []
+        bs = max(1, self._batch_size)
+        n_batches = (len(texts) + bs - 1) // bs
+        _t_enc_start = _time.perf_counter()
+        logger.info(
+            "[_encode] 开始编码: %d texts, batch_size=%d, %d batches, model_device=%s, declared=%s",
+            len(texts), bs, n_batches, _actual_dev, self._device,
+        )
+        for i in range(0, len(texts), bs):
+            bi = i // bs
+            batch = texts[i : i + bs]
+            _t_b0 = _time.perf_counter()
+            inputs = self._tokenizer(
+                batch,
+                padding=True,
+                truncation=True,
+                max_length=512,
+                return_tensors="pt",
+            ).to(self._device)
+            _t_tok = _time.perf_counter()
+
+            with torch.no_grad():
+                outputs = self._model(**inputs)
+                # bge 用 last_token_pool;其它 BERT 类模型退化为 [CLS] pooling
+                try:
+                    embeddings = self._last_token_pool(
+                        outputs.last_hidden_state, inputs["attention_mask"]
+                    )
+                except Exception:
+                    embeddings = outputs.last_hidden_state[:, 0]
+                embeddings = torch.nn.functional.normalize(embeddings, p=2, dim=1)
+            # GPU 同步,确保 forward 真正完成后再计时
+            if "cuda" in _actual_dev:
+                torch.cuda.synchronize()
+            _t_fwd = _time.perf_counter()
+            all_embeddings.extend(embeddings.cpu().numpy().tolist())
+            _t_cpu = _time.perf_counter()
+
+            # 每个批次都打印(首次诊断用;定位后可改为每 10 批打印一次)
+            if bi < 3 or bi % 10 == 0 or bi == n_batches - 1:
+                logger.info(
+                    "[_encode] batch %d/%d: size=%d, tok=%.3fs fwd=%.3fs to_cpu=%.3fs (elapsed %.2fs)",
+                    bi + 1, n_batches, len(batch),
+                    _t_tok - _t_b0, _t_fwd - _t_tok, _t_cpu - _t_fwd, _t_cpu - _t_enc_start,
+                )
+        logger.info(
+            "[_encode] 完成: %d texts, total=%.2fs, avg=%.3fs/text",
+            len(texts), _time.perf_counter() - _t_enc_start,
+            (_time.perf_counter() - _t_enc_start) / max(1, len(texts)),
+        )
+        return all_embeddings
+
+    def embed_texts(self, texts: List[str]) -> List[List[float]]:
+        """批量向量化(passage/documents):不加 query 前缀。"""
+        import time as _time_et
+        logger.info("[embed_texts] 入口: %d texts, model_loaded=%s", len(texts), self._model is not None)
+        if not texts:
+            return []
+        _t_et0 = _time_et.perf_counter()
+        self._load()
+        logger.info("[embed_texts] _load 返回: %.3fs", _time_et.perf_counter() - _t_et0)
+        old = getattr(self, "_is_query", True)
+        self._is_query = False
+        try:
+            return self._encode(texts)
+        finally:
+            self._is_query = old
+
+    def embed_query(self, text: str) -> List[float]:
+        """单条查询向量化:加 query 前缀。"""
+        self._load()
+        self._is_query = True
+        return self._encode([text])[0]
+
+
+# ---------- 模块级单例 ----------
+_default_embedder: Optional["Embedder"] = None
+_embedder_lock = threading.Lock()
+
+
+def get_default_embedder() -> "Embedder":
+    """获取模块级单例 Embedder,复用已加载的模型与 CUDA 上下文。
+
+    业务流程应优先调用此函数,而非直接 Embedder(),避免重复加载模型(每次 12s)
+    和重复触发 CUDA 上下文初始化(首次 forward 42s)。
+    """
+    global _default_embedder
+    if _default_embedder is None:
+        with _embedder_lock:
+            if _default_embedder is None:
+                _default_embedder = Embedder()
+    return _default_embedder

+ 197 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/rag/hybrid_search.py

@@ -0,0 +1,197 @@
+"""混合搜索:组合向量检索 + BM25 检索,加权分数归一化重排"""
+from __future__ import annotations
+
+import asyncio
+import logging
+import time
+from typing import Optional
+
+from backend.models.schemas import ParsedPaper, Section
+from backend.rag.bm25_store import BM25Store
+from backend.rag.embedding import Embedder, get_default_embedder
+from backend.rag.vector_store import ChromaStore
+
+logger = logging.getLogger(__name__)
+
+# 分块目标字符数
+CHUNK_SIZE = 500
+
+
+class HybridSearcher:
+    """混合检索器:ChromaStore + BM25Store + Embedder"""
+
+    def __init__(
+        self,
+        vector_store: Optional[ChromaStore] = None,
+        bm25_store: Optional[BM25Store] = None,
+        embedder: Optional[Embedder] = None,
+        chunk_size: int = CHUNK_SIZE,
+    ):
+        self.embedder = embedder or get_default_embedder()
+        self.vector_store = vector_store or ChromaStore(embedder=self.embedder)
+        self.bm25_store = bm25_store or BM25Store()
+        self.chunk_size = chunk_size
+
+    # ---------- 分块 ----------
+
+    def _chunk_section(self, section: Section) -> list[dict]:
+        """将单章节按段落分块,块大小约 chunk_size 字符。
+
+        Returns:
+            list[dict],每项 {section, text}
+        """
+        content = section.content or ""
+        heading = section.heading or ""
+        # 按换行切段落,丢弃空段
+        paragraphs = [p.strip() for p in content.split("\n") if p.strip()]
+        chunks: list[dict] = []
+        buf = ""
+        for para in paragraphs:
+            # 累计超过阈值则落块
+            if buf and len(buf) + len(para) > self.chunk_size:
+                chunks.append({"section": heading, "text": buf})
+                buf = para
+            else:
+                buf = f"{buf}\n{para}".strip() if buf else para
+        if buf:
+            chunks.append({"section": heading, "text": buf})
+
+        # 处理单段过长的情况:按 chunk_size 强制切分
+        final: list[dict] = []
+        for c in chunks:
+            text = c["text"]
+            if len(text) <= self.chunk_size * 2:
+                final.append(c)
+            else:
+                for i in range(0, len(text), self.chunk_size):
+                    final.append(
+                        {"section": c["section"], "text": text[i : i + self.chunk_size]}
+                    )
+        return final
+
+    # ---------- 写入 ----------
+
+    def add_paper(self, paper: ParsedPaper):
+        """把单篇论文章节分块后加入向量库与 BM25 库"""
+        t_start = time.perf_counter()
+        all_chunks: list[dict] = []
+        for section in paper.sections:
+            all_chunks.extend(self._chunk_section(section))
+        t_chunk = time.perf_counter()
+        logger.info(
+            "[add_paper] %s 分块完成: %d sections → %d chunks, 用时 %.2fs",
+            paper.path, len(paper.sections), len(all_chunks), t_chunk - t_start,
+        )
+        if not all_chunks:
+            return
+        # 向量库:传入 paper_path/title + chunks[{section, text}]
+        self.vector_store.add_chunks(paper.path, paper.title, all_chunks)
+        t_vec = time.perf_counter()
+        logger.info(
+            "[add_paper] %s 向量库写入完成: 用时 %.2fs (累计 %.2fs)",
+            paper.path, t_vec - t_chunk, t_vec - t_start,
+        )
+        # BM25:chunks 需带 paper_path/title
+        bm25_chunks = [
+            {**c, "paper_path": paper.path, "title": paper.title} for c in all_chunks
+        ]
+        self.bm25_store.add_chunks(bm25_chunks)
+        t_bm25 = time.perf_counter()
+        logger.info(
+            "[add_paper] %s BM25 写入完成: 用时 %.2fs (累计 %.2fs)",
+            paper.path, t_bm25 - t_vec, t_bm25 - t_start,
+        )
+
+    def load_all(self, papers: list[ParsedPaper]):
+        """批量加载多篇论文"""
+        for paper in papers:
+            self.add_paper(paper)
+
+    # ---------- 检索 ----------
+
+    def search(
+        self,
+        query: str,
+        top_k: int = 5,
+        vector_weight: float = 0.6,
+        bm25_weight: float = 0.4,
+    ) -> list[dict]:
+        """混合检索:向量 + BM25 各取 top_k*2,加权分数归一化重排。
+
+        Returns:
+            list[dict],每项 {text, paper_path, title, section, score},按融合分数降序
+        """
+        fetch_k = top_k * 2
+        vector_results = self.vector_store.vector_search(query, top_k=fetch_k)
+        bm25_results = self.bm25_store.bm25_search(query, top_k=fetch_k)
+
+        # 各路结果做 min-max 归一化到 [0,1]
+        vector_results = self._normalize(vector_results)
+        bm25_results = self._normalize(bm25_results)
+
+        # 以 text 为 key 合并去重,加权累加分数
+        merged: dict[str, dict] = {}
+        for r in vector_results:
+            key = r["text"]
+            s = vector_weight * r["norm_score"]
+            if key not in merged:
+                merged[key] = {
+                    "text": r["text"],
+                    "paper_path": r["paper_path"],
+                    "title": r["title"],
+                    "section": r["section"],
+                    "score": s,
+                }
+            else:
+                merged[key]["score"] += s
+        for r in bm25_results:
+            key = r["text"]
+            s = bm25_weight * r["norm_score"]
+            if key not in merged:
+                merged[key] = {
+                    "text": r["text"],
+                    "paper_path": r["paper_path"],
+                    "title": r["title"],
+                    "section": r["section"],
+                    "score": s,
+                }
+            else:
+                merged[key]["score"] += s
+
+        # 按融合分数降序取 top_k
+        out = sorted(merged.values(), key=lambda x: x["score"], reverse=True)[:top_k]
+        return out
+
+    @staticmethod
+    def _normalize(results: list[dict]) -> list[dict]:
+        """对结果列表的 score 做 min-max 归一化,写入 norm_score 字段"""
+        if not results:
+            return results
+        scores = [r["score"] for r in results]
+        lo, hi = min(scores), max(scores)
+        rng = hi - lo if hi > lo else 1.0
+        for r in results:
+            r["norm_score"] = (r["score"] - lo) / rng
+        return results
+
+    # ---------- 异步友好封装 ----------
+
+    async def async_add_paper(self, paper: ParsedPaper):
+        """异步写入单篇论文"""
+        await asyncio.to_thread(self.add_paper, paper)
+
+    async def async_load_all(self, papers: list[ParsedPaper]):
+        """异步批量加载"""
+        await asyncio.to_thread(self.load_all, papers)
+
+    async def async_search(
+        self,
+        query: str,
+        top_k: int = 5,
+        vector_weight: float = 0.6,
+        bm25_weight: float = 0.4,
+    ) -> list[dict]:
+        """异步混合检索"""
+        return await asyncio.to_thread(
+            self.search, query, top_k, vector_weight, bm25_weight
+        )

+ 131 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/rag/vector_store.py

@@ -0,0 +1,131 @@
+"""Chroma 向量库:基于 chromadb 的本地持久化向量存储"""
+from __future__ import annotations
+
+import logging
+import time
+import uuid
+from typing import Optional
+
+from backend.config import settings
+from backend.rag.embedding import Embedder
+
+logger = logging.getLogger(__name__)
+
+
+class ChromaStore:
+    """Chroma 向量库封装,懒初始化 client 与 collection"""
+
+    def __init__(
+        self,
+        chroma_path: Optional[str] = None,
+        embedder: Optional[Embedder] = None,
+        collection_name: str = "paper_chunks",
+    ):
+        # 路径默认取配置中的 CHROMA_PATH
+        self.chroma_path = str(chroma_path or settings.CHROMA_PATH)
+        self.embedder = embedder or Embedder()
+        self.collection_name = collection_name
+        self._client = None
+        self._collection = None
+
+    def _ensure(self):
+        """懒初始化 client 和 collection,首次访问时建立"""
+        if self._client is None:
+            _t0 = time.perf_counter()
+            # 延迟导入,避免模块导入即触发 chromadb 重型初始化
+            import chromadb
+            _t_import = time.perf_counter()
+
+            self._client = chromadb.PersistentClient(path=self.chroma_path)
+            _t_client = time.perf_counter()
+
+            self._collection = self._client.get_or_create_collection(
+                name=self.collection_name
+            )
+            _t_coll = time.perf_counter()
+            logger.info(
+                "[ChromaStore._ensure] 首次初始化: import_chromadb=%.3fs client=%.3fs collection=%.3fs total=%.3fs path=%s",
+                _t_import - _t0, _t_client - _t_import, _t_coll - _t_client,
+                _t_coll - _t0, self.chroma_path,
+            )
+
+    def add_chunks(self, paper_path: str, title: str, chunks: list[dict]):
+        """批量入库。
+
+        Args:
+            paper_path: 论文文件路径
+            title: 论文标题
+            chunks: 每个 chunk 形如 {section, text}
+        """
+        if not chunks:
+            return
+        self._ensure()
+        t0 = time.perf_counter()
+        texts = [c["text"] for c in chunks]
+        embeddings = self.embedder.embed_texts(texts)
+        t_emb = time.perf_counter()
+        logger.info(
+            "[add_chunks] %s embedding 完成: %d chunks, 用时 %.2fs",
+            paper_path, len(chunks), t_emb - t0,
+        )
+        # 唯一 id,避免冲突
+        ids = [str(uuid.uuid4()) for _ in chunks]
+        metadatas = [
+            {
+                "paper_path": paper_path,
+                "title": title,
+                "section": c.get("section", ""),
+            }
+            for c in chunks
+        ]
+        self._collection.add(
+            ids=ids,
+            embeddings=embeddings,
+            documents=texts,
+            metadatas=metadatas,
+        )
+        t_add = time.perf_counter()
+        logger.info(
+            "[add_chunks] %s chroma.add 完成: 用时 %.2fs (累计 %.2fs)",
+            paper_path, t_add - t_emb, t_add - t0,
+        )
+
+    def vector_search(self, query: str, top_k: int = 5) -> list[dict]:
+        """向量检索,返回 top_k 结果。
+
+        Returns:
+            list[dict],每项 {text, paper_path, title, section, score}
+            score 越大越相似(由距离转换得到)。
+        """
+        self._ensure()
+        query_emb = self.embedder.embed_query(query)
+        results = self._collection.query(
+            query_embeddings=[query_emb],
+            n_results=top_k,
+        )
+        out: list[dict] = []
+        # chroma 返回结构:每个字段是“外层 list=查询数,内层 list=结果数”
+        docs = (results.get("documents") or [[]])[0]
+        metas = (results.get("metadatas") or [[]])[0]
+        dists = (results.get("distances") or [[]])[0]
+        for doc, meta, dist in zip(docs, metas, dists):
+            # 距离越小越相似,转换为 (0,1] 的相似度分数
+            score = 1.0 / (1.0 + float(dist)) if dist is not None else 0.0
+            out.append(
+                {
+                    "text": doc,
+                    "paper_path": meta.get("paper_path", ""),
+                    "title": meta.get("title", ""),
+                    "section": meta.get("section", ""),
+                    "score": score,
+                }
+            )
+        return out
+
+    def clear(self):
+        """清空 collection(删除后重建空 collection)"""
+        self._ensure()
+        self._client.delete_collection(name=self.collection_name)
+        self._collection = self._client.get_or_create_collection(
+            name=self.collection_name
+        )

+ 15 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/requirements.txt

@@ -0,0 +1,15 @@
+# Paper Innovation Agent - Backend Dependencies
+fastapi==0.115.0
+uvicorn[standard]==0.30.6
+openai==1.51.0
+hello-agents>=1.0.0
+chromadb==0.5.5
+sentence-transformers==3.0.1
+pymupdf==1.24.10
+rank-bm25==0.2.2
+python-dotenv==1.0.1
+pydantic==2.9.2
+httpx==0.27.2
+aiosqlite==0.20.0
+sse-starlette==2.1.3
+python-multipart==0.0.12

+ 1 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/storage/__init__.py

@@ -0,0 +1 @@
+"""论文库持久化存储:管理上传论文元数据与预处理状态"""

+ 258 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/storage/paper_library.py

@@ -0,0 +1,258 @@
+"""论文库持久化管理:data/papers_library.json
+
+职责:
+- 以 PDF 文件内容 SHA-256 作为 paper_id,跨路径/跨会话唯一标识论文
+- 跟踪每篇论文的预处理状态(解析/抽取/索引三步)
+- 提供增删查改与缓存状态查询
+- 删除论文时联动清理缓存文件与 Chroma chunks
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import logging
+import threading
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+from backend.config import settings
+
+logger = logging.getLogger(__name__)
+
+# 合法的预处理状态
+_STATUSES = ("pending", "done", "failed")
+
+
+def compute_paper_id(file_path: str) -> str:
+    """计算 PDF 文件内容的 SHA-256 作为 paper_id
+
+    Args:
+        file_path: PDF 文件路径
+
+    Returns:
+        64 字符的十六进制 SHA-256 哈希
+    """
+    h = hashlib.sha256()
+    with open(file_path, "rb") as f:
+        for chunk in iter(lambda: f.read(8192), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+class PaperLibrary:
+    """论文库持久化管理器
+
+    数据存储在 data/papers_library.json,线程安全(文件锁)。
+    """
+
+    def __init__(self, library_path: Optional[Path] = None) -> None:
+        self._library_path = library_path or (settings.CACHE_DIR / "papers_library.json")
+        self._library_path.parent.mkdir(parents=True, exist_ok=True)
+        self._lock = threading.Lock()
+        self._papers: dict[str, dict] = self._load()
+
+    # ------------------------------------------------------------------ #
+    # 持久化读写
+    # ------------------------------------------------------------------ #
+
+    def _load(self) -> dict[str, dict]:
+        """从磁盘加载论文库"""
+        if not self._library_path.exists():
+            return {}
+        try:
+            with open(self._library_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+            if isinstance(data, dict) and isinstance(data.get("papers"), list):
+                # 兼容 {"papers": [...]} 格式
+                return {p["paper_id"]: p for p in data["papers"] if "paper_id" in p}
+            if isinstance(data, dict):
+                return data
+        except (json.JSONDecodeError, OSError) as exc:
+            logger.warning("加载论文库失败: %s", exc)
+        return {}
+
+    def _save(self) -> None:
+        """保存论文库到磁盘"""
+        data = {"papers": list(self._papers.values())}
+        with open(self._library_path, "w", encoding="utf-8") as f:
+            json.dump(data, f, ensure_ascii=False, indent=2, default=str)
+
+    # ------------------------------------------------------------------ #
+    # 增删查改
+    # ------------------------------------------------------------------ #
+
+    def register(
+        self,
+        paper_id: str,
+        filename: str,
+        source: str,
+        original_path: str,
+    ) -> dict:
+        """注册论文到库中。若已存在则返回现有记录(不覆盖状态)。
+
+        Args:
+            paper_id: 内容哈希
+            filename: 文件名
+            source: "upload" 或 "folder"
+            original_path: 存储路径(上传文件为 data/uploads/{paper_id}.pdf)
+
+        Returns:
+            论文元数据 dict
+        """
+        with self._lock:
+            if paper_id in self._papers:
+                return self._papers[paper_id]
+            entry = {
+                "paper_id": paper_id,
+                "filename": filename,
+                "source": source,
+                "original_path": original_path,
+                "upload_time": datetime.now().isoformat(),
+                "title": "",
+                "parse_status": "pending",
+                "extract_status": "pending",
+                "index_status": "pending",
+                "parsed_at": None,
+                "extracted_at": None,
+                "indexed_at": None,
+            }
+            self._papers[paper_id] = entry
+            self._save()
+            logger.info("注册论文: paper_id=%s, filename=%s", paper_id[:12], filename)
+            return entry
+
+    def get(self, paper_id: str) -> Optional[dict]:
+        """获取单篇论文元数据,不存在返回 None"""
+        with self._lock:
+            return self._papers.get(paper_id)
+
+    def list_all(self) -> list[dict]:
+        """列出全部论文元数据"""
+        with self._lock:
+            return list(self._papers.values())
+
+    def update_status(
+        self,
+        paper_id: str,
+        title: Optional[str] = None,
+        parse_status: Optional[str] = None,
+        extract_status: Optional[str] = None,
+        index_status: Optional[str] = None,
+    ) -> Optional[dict]:
+        """更新论文预处理状态
+
+        Args:
+            paper_id: 论文 ID
+            title: 解析得到的标题(可选)
+            parse_status: 解析状态
+            extract_status: 抽取状态
+            index_status: 索引状态
+
+        Returns:
+            更新后的元数据 dict,或 None(论文不存在)
+        """
+        with self._lock:
+            entry = self._papers.get(paper_id)
+            if entry is None:
+                return None
+            now = datetime.now().isoformat()
+            if title is not None and title:
+                entry["title"] = title
+            if parse_status is not None:
+                if parse_status not in _STATUSES:
+                    raise ValueError(f"非法状态: {parse_status}")
+                entry["parse_status"] = parse_status
+                if parse_status == "done":
+                    entry["parsed_at"] = now
+            if extract_status is not None:
+                if extract_status not in _STATUSES:
+                    raise ValueError(f"非法状态: {extract_status}")
+                entry["extract_status"] = extract_status
+                if extract_status == "done":
+                    entry["extracted_at"] = now
+            if index_status is not None:
+                if index_status not in _STATUSES:
+                    raise ValueError(f"非法状态: {index_status}")
+                entry["index_status"] = index_status
+                if index_status == "done":
+                    entry["indexed_at"] = now
+            self._save()
+            return entry
+
+    def delete(self, paper_id: str) -> bool:
+        """删除论文:移除库记录 + 删除缓存文件 + 删除 Chroma chunks
+
+        Args:
+            paper_id: 论文 ID
+
+        Returns:
+            是否删除成功
+        """
+        with self._lock:
+            entry = self._papers.pop(paper_id, None)
+            if entry is None:
+                return False
+
+        # 删除缓存文件(解析结果)
+        parsed_cache = settings.CACHE_DIR / "parsed" / f"{paper_id}.json"
+        if parsed_cache.exists():
+            try:
+                parsed_cache.unlink()
+            except OSError as exc:
+                logger.warning("删除解析缓存失败: %s", exc)
+
+        # 删除缓存文件(抽取结果)
+        extract_cache = settings.CACHE_DIR / "papers" / f"{paper_id}.json"
+        if extract_cache.exists():
+            try:
+                extract_cache.unlink()
+            except OSError as exc:
+                logger.warning("删除抽取缓存失败: %s", exc)
+
+        # 删除 Chroma chunks
+        original_path = entry.get("original_path", "")
+        if original_path:
+            try:
+                from backend.tools.build_vector_index import delete_paper_chunks
+
+                delete_paper_chunks(original_path)
+            except Exception as exc:
+                logger.warning("删除 Chroma chunks 失败: %s", exc)
+
+        # 删除上传的原文件(仅 upload 来源)
+        if entry.get("source") == "upload":
+            upload_file = Path(entry.get("original_path", ""))
+            if upload_file.exists():
+                try:
+                    upload_file.unlink()
+                except OSError as exc:
+                    logger.warning("删除上传文件失败: %s", exc)
+
+        with self._lock:
+            self._save()
+        logger.info("删除论文: paper_id=%s", paper_id[:12])
+        return True
+
+    def is_preprocessed(self, paper_id: str) -> bool:
+        """检查论文是否已完成全部三步预处理"""
+        entry = self.get(paper_id)
+        if entry is None:
+            return False
+        return (
+            entry.get("parse_status") == "done"
+            and entry.get("extract_status") == "done"
+            and entry.get("index_status") == "done"
+        )
+
+
+# 模块级单例
+_library: Optional[PaperLibrary] = None
+
+
+def get_paper_library() -> PaperLibrary:
+    """获取 PaperLibrary 单例"""
+    global _library
+    if _library is None:
+        _library = PaperLibrary()
+    return _library

+ 1 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/tools/__init__.py

@@ -0,0 +1 @@
+"""工具集:Function Calling Tools"""

+ 215 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/tools/analyze_gaps.py

@@ -0,0 +1,215 @@
+"""步骤4 跨论文 Gap 识别工具:聚合结构化字段,调用强推理模型识别四类研究空白"""
+from __future__ import annotations
+
+import logging
+from typing import Optional
+
+from backend.llm.client import DeepSeekClient
+from backend.llm.json_utils import parse_json_safe
+from backend.tools.base import Tool
+
+logger = logging.getLogger(__name__)
+
+# 模块级懒加载单例
+_client: Optional[DeepSeekClient] = None
+
+
+def get_client() -> DeepSeekClient:
+    """懒加载 DeepSeek 客户端单例"""
+    global _client
+    if _client is None:
+        _client = DeepSeekClient()
+    return _client
+
+
+def _build_comparison_matrix(papers_records: list[dict]) -> str:
+    """将多篇论文的结构化字段按维度聚合成对比矩阵文本
+
+    每条记录是 PaperRecord dict,字段为 FieldSource 结构 {value, source_sections, confidence}
+    """
+    # 字段中文名映射
+    field_labels = {
+        "task_problem": "研究任务/问题",
+        "method": "核心方法",
+        "key_contributions": "主要贡献",
+        "datasets": "数据集",
+        "metrics": "评估指标",
+        "results": "实验结果",
+        "limitations": "局限性",
+        "future_work": "未来工作",
+    }
+
+    lines: list[str] = []
+    for idx, rec in enumerate(papers_records, 1):
+        title = rec.get("title", f"论文{idx}")
+        lines.append(f"===== 论文 {idx}: {title} =====")
+        for field, label in field_labels.items():
+            val = rec.get(field)
+            if val is None:
+                continue
+            # FieldSource 结构:{value, source_sections, confidence}
+            if isinstance(val, dict):
+                text = val.get("value", "")
+            else:
+                text = str(val)
+            if text:
+                lines.append(f"[{label}] {text}")
+        lines.append("")
+    return "\n".join(lines)
+
+
+async def _enrich_with_hybrid_search(gap: dict) -> str:
+    """对单个 Gap 调用混合搜索检索原文细节,补充论证
+
+    懒导入 hybrid_search,避免模块加载期依赖未就绪的模块。
+    """
+    query = gap.get("description", "")
+    if not query:
+        return gap.get("evidence", "")
+    try:
+        # 懒导入,避免模块加载期依赖
+        from backend.tools.hybrid_search_tool import hybrid_search
+
+        result = await hybrid_search(query)
+        snippets: list[str] = []
+        for r in result.get("results", [])[:3]:
+            title = r.get("title", "")
+            section = r.get("section", "")
+            text = r.get("text", "")[:200]
+            snippets.append(f"  - 《{title}》{section}: {text}")
+        if snippets:
+            extra = "\n[原文佐证]\n" + "\n".join(snippets)
+            return gap.get("evidence", "") + extra
+    except Exception as exc:
+        logger.warning("hybrid_search 增强 Gap 论证失败: %s", exc)
+    return gap.get("evidence", "")
+
+
+async def analyze_gaps(papers_records: list[dict]) -> dict:
+    """跨论文 Gap 识别
+
+    输入:papers.jsonl 的记录列表(每条是 PaperRecord dict)
+    输出:{"gaps": [{description, gap_type, source_papers, evidence, confidence}]}
+    """
+    if not papers_records:
+        return {"gaps": []}
+
+    # 1. 聚合对比矩阵
+    matrix = _build_comparison_matrix(papers_records)
+
+    # 2. 构造强推理提示词
+    n_papers = len(papers_records)
+    if n_papers == 1:
+        single_paper_hint = (
+            f"\n## 重要提示\n当前仅 1 篇论文。请基于该论文自身的 limitations(局限性)和 future_work(未来工作),"
+            "识别可深化的研究空白。source_papers 只需包含这 1 篇论文即可。"
+            "至少识别 2 个有价值的 Gap(基于论文内部字段证据,不要求跨论文对比)。"
+        )
+        source_constraint = "source_papers 至少包含 1 篇论文。"
+    else:
+        single_paper_hint = ""
+        source_constraint = "每个 Gap 的 source_papers 至少包含 2 篇论文。"
+
+    prompt = f"""你是一位资深学术研究者,需要从以下多篇论文的结构化对比中识别研究空白(Gap)。
+
+## 论文对比矩阵
+{matrix}
+{single_paper_hint}
+## 任务
+请综合分析上述论文,识别以下四类 Gap 信号:
+1. repeated_limitation(重复局限):多篇论文提到同一局限性,但无人解决
+2. method_gap(方法空白):某类问题只有少数方法尝试且效果不佳
+3. contradictory(矛盾结论):不同论文对同一问题给出冲突结论
+4. unfulfilled_future(未兑现的未来工作):多篇论文指向同一未来方向但无人完成
+
+对于单篇论文场景,重点关注该论文自身的 limitations 与 future_work 字段,
+识别方法层面、数据层面、评估层面的可深化方向。
+
+## 输出要求
+严格输出 JSON,不要包含任何额外说明文本或代码块标记。格式如下:
+{{
+  "gaps": [
+    {{
+      "description": "Gap 的清晰描述",
+      "gap_type": "repeated_limitation|method_gap|contradictory|unfulfilled_future",
+      "source_papers": ["来源论文标题1"],
+      "evidence": "论证依据,引用具体论文的具体字段",
+      "confidence": 0.0到1.0之间的置信度
+    }}
+  ]
+}}
+
+只输出真正有证据支撑的 Gap,不要编造。{source_constraint}"""
+
+    messages = [
+        {
+            "role": "system",
+            "content": "你是一位严谨的学术研究分析专家,擅长跨论文综合推理与 Gap 识别。只输出严格 JSON,不要输出任何其他内容。",
+        },
+        {"role": "user", "content": prompt},
+    ]
+
+    client = get_client()
+    response = await client.chat(messages=messages)
+    content = response.choices[0].message.content or ""
+    data = parse_json_safe(content)
+
+    if not data or not isinstance(data, dict):
+        logger.warning("Gap 识别 JSON 解析失败,原始内容: %s", content[:200])
+        return {"gaps": []}
+
+    gaps = data.get("gaps", [])
+    if not isinstance(gaps, list):
+        gaps = []
+
+    logger.info(
+        "[analyze_gaps] LLM 返回 %d gaps (papers=%d, content_len=%d)",
+        len(gaps), len(papers_records), len(content),
+    )
+    if len(gaps) == 0:
+        logger.warning("[analyze_gaps] Gap 数量为 0!原始内容前 500 字: %s", content[:500])
+
+    # 3. 对每个 Gap 调用混合搜索补充原文佐证
+    enriched: list[dict] = []
+    for gap in gaps:
+        if not isinstance(gap, dict):
+            continue
+        # 规范化字段
+        normalized = {
+            "description": gap.get("description", ""),
+            "gap_type": gap.get("gap_type", "method_gap"),
+            "source_papers": gap.get("source_papers", []),
+            "evidence": gap.get("evidence", ""),
+            "confidence": float(gap.get("confidence", 0.5)),
+        }
+        # 调用混合搜索深化论证
+        normalized["evidence"] = await _enrich_with_hybrid_search(normalized)
+        enriched.append(normalized)
+
+    return {"gaps": enriched}
+
+
+# 工具参数 schema
+analyze_gaps_parameters = {
+    "type": "object",
+    "properties": {
+        "papers_records": {
+            "type": "array",
+            "items": {"type": "object"},
+            "description": "papers.jsonl 的记录列表,每条是 PaperRecord dict",
+        }
+    },
+    "required": ["papers_records"],
+}
+
+# 工具实例
+analyze_gaps_tool = Tool(
+    name="analyze_gaps",
+    description=(
+        "步骤4:跨论文 Gap 识别。将多篇论文结构化字段聚合成对比矩阵,"
+        "调用强推理模型识别四类研究空白(重复局限/方法空白/矛盾结论/未兑现未来工作),"
+        "需要时调用混合搜索检索原文细节佐证。"
+    ),
+    parameters=analyze_gaps_parameters,
+    func=analyze_gaps,
+)

+ 61 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/tools/base.py

@@ -0,0 +1,61 @@
+"""工具基类与注册表:统一管理 Function Calling 工具"""
+from __future__ import annotations
+
+import inspect
+from typing import Any, Callable, Optional
+
+
+class Tool:
+    """单个工具:名称 + 描述 + JSON schema + 可调用函数"""
+
+    def __init__(
+        self,
+        name: str,
+        description: str,
+        parameters: dict,
+        func: Callable,
+    ):
+        self.name = name
+        self.description = description
+        self.parameters = parameters
+        self.func = func
+
+    def to_schema(self) -> dict:
+        """转为 DeepSeek/OpenAI function calling schema"""
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": self.description,
+                "parameters": self.parameters,
+            },
+        }
+
+
+class ToolRegistry:
+    """工具注册表:管理多个工具,供 ToolLoop 使用"""
+
+    def __init__(self):
+        self._tools: dict[str, Tool] = {}
+
+    def register(self, tool: Tool):
+        self._tools[tool.name] = tool
+        return tool
+
+    def get(self, name: str) -> Optional[Tool]:
+        return self._tools.get(name)
+
+    def get_callable(self, name: str) -> Optional[Callable]:
+        tool = self._tools.get(name)
+        return tool.func if tool else None
+
+    def get_callables(self) -> dict[str, Callable]:
+        """返回 name -> func 字典,供 ToolLoop 使用"""
+        return {name: tool.func for name, tool in self._tools.items()}
+
+    def get_schemas(self) -> list[dict]:
+        """返回所有工具的 JSON schema 列表"""
+        return [tool.to_schema() for tool in self._tools.values()]
+
+    def names(self) -> list[str]:
+        return list(self._tools.keys())

+ 208 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/tools/build_vector_index.py

@@ -0,0 +1,208 @@
+"""步骤3 索引构建工具:将解析后的论文加入混合检索向量库"""
+from __future__ import annotations
+
+import logging
+import time
+
+from backend.tools.base import Tool
+
+logger = logging.getLogger(__name__)
+
+# 模块级单例:懒加载,避免导入即触发重型依赖(Embedder/Chroma/BM25)
+_hybrid_searcher = None
+
+
+def _get_searcher():
+    """懒加载模块级 HybridSearcher 单例。
+
+    供 build_vector_index 与 hybrid_search_tool 共享同一实例,
+    保证索引写入与检索读取状态一致。
+    """
+    global _hybrid_searcher
+    if _hybrid_searcher is None:
+        _t0 = time.perf_counter()
+        from backend.rag.hybrid_search import HybridSearcher
+
+        _hybrid_searcher = HybridSearcher()
+        logger.info(
+            "[_get_searcher] HybridSearcher 实例化完成: %.3fs(含 Embedder/ChromaStore/BM25Store 构造,未加载模型)",
+            time.perf_counter() - _t0,
+        )
+    return _hybrid_searcher
+
+
+def _get_vector_store():
+    """获取底层 ChromaStore(用于去重查询与删除)"""
+    searcher = _get_searcher()
+    return searcher.vector_store
+
+
+def is_indexed(paper_path: str) -> bool:
+    """检查指定论文是否已索引(Chroma 中已有该 paper_path 的 chunks)
+
+    Args:
+        paper_path: 论文文件路径
+
+    Returns:
+        是否已存在 chunks
+    """
+    try:
+        _t0 = time.perf_counter()
+        store = _get_vector_store()
+        _t_get_store = time.perf_counter()
+        store._ensure()  # 首次调用会初始化 chromadb client
+        _t_ensure = time.perf_counter()
+        collection = store._collection
+        result = collection.get(where={"paper_path": paper_path}, limit=1)
+        _t_query = time.perf_counter()
+        ids = result.get("ids", []) if result else []
+        logger.info(
+            "[is_indexed] %s: get_store=%.3fs ensure=%.3fs query=%.3fs total=%.3fs result=%s",
+            paper_path, _t_get_store - _t0, _t_ensure - _t_get_store,
+            _t_query - _t_ensure, _t_query - _t0, len(ids) > 0,
+        )
+        return len(ids) > 0
+    except Exception as exc:
+        logger.warning("查询索引状态失败: %s", exc)
+        return False
+
+
+def delete_paper_chunks(paper_path: str) -> int:
+    """删除指定论文在 Chroma 中的所有 chunks
+
+    Args:
+        paper_path: 论文文件路径
+
+    Returns:
+        删除的 chunk 数量
+    """
+    try:
+        store = _get_vector_store()
+        store._ensure()
+        collection = store._collection
+        result = collection.get(where={"paper_path": paper_path})
+        ids = result.get("ids", []) if result else []
+        if ids:
+            collection.delete(ids=ids)
+            logger.info("已删除论文 %s 的 %d 个 chunks", paper_path, len(ids))
+            return len(ids)
+        return 0
+    except Exception as exc:
+        logger.warning("删除论文 chunks 失败: %s", exc)
+        return 0
+
+
+async def build_vector_index(papers_json: list[dict]) -> dict:
+    """将已解析论文列表加入向量库与 BM25 库。
+
+    对每篇论文先检查是否已索引,已索引则跳过(去重)。
+
+    Args:
+        papers_json: 已解析论文列表,每项含 path/title/sections
+
+    Returns:
+        {"indexed_count": N, "skipped_count": M, "status": "done"}
+    """
+    from backend.models.schemas import ParsedPaper, Section
+
+    _t_fn_start = time.perf_counter()
+    logger.info("[build_vector_index] 入口: %d papers", len(papers_json))
+
+    _t0 = time.perf_counter()
+    searcher = _get_searcher()
+    logger.info("[build_vector_index] _get_searcher: %.3fs", time.perf_counter() - _t0)
+
+    indexed = 0
+    skipped = 0
+    for paper_dict in papers_json:
+        try:
+            paper_path = paper_dict.get("path", "")
+            _t_paper0 = time.perf_counter()
+
+            # 去重:已索引的论文跳过
+            if paper_path and is_indexed(paper_path):
+                logger.info("论文 %s 已索引,跳过", paper_path)
+                skipped += 1
+                continue
+
+            _t_dedup = time.perf_counter()
+            sections = [
+                Section(
+                    heading=s.get("heading", ""),
+                    content=s.get("content", ""),
+                    figure_captions=s.get("figure_captions", []),
+                )
+                for s in paper_dict.get("sections", [])
+            ]
+            paper = ParsedPaper(
+                path=paper_path,
+                title=paper_dict.get("title", ""),
+                sections=sections,
+            )
+            _t_construct = time.perf_counter()
+            logger.info(
+                "[build_vector_index] %s: dedup_check=%.3fs paper_construct=%.3fs sections=%d",
+                paper_path, _t_dedup - _t_paper0, _t_construct - _t_dedup, len(sections),
+            )
+            await searcher.async_add_paper(paper)
+            _t_add = time.perf_counter()
+            logger.info(
+                "[build_vector_index] %s: async_add_paper=%.3fs (paper total=%.3fs)",
+                paper_path, _t_add - _t_construct, _t_add - _t_paper0,
+            )
+            indexed += 1
+        except Exception as exc:
+            # 单篇失败隔离,继续处理其余论文
+            logger.exception("[build_vector_index] 单篇索引失败: %s", exc)
+            continue
+    _t_done = time.perf_counter()
+    logger.info(
+        "[build_vector_index] 完成: indexed=%d skipped=%d total=%.3fs",
+        indexed, skipped, _t_done - _t_fn_start,
+    )
+    return {"indexed_count": indexed, "skipped_count": skipped, "status": "done"}
+
+
+# ---------- Tool 定义 ----------
+
+_PARAMETERS = {
+    "type": "object",
+    "properties": {
+        "papers_json": {
+            "type": "array",
+            "description": "已解析论文列表,每项含 path/title/sections",
+            "items": {
+                "type": "object",
+                "properties": {
+                    "path": {"type": "string"},
+                    "title": {"type": "string"},
+                    "sections": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "heading": {"type": "string"},
+                                "content": {"type": "string"},
+                                "figure_captions": {
+                                    "type": "array",
+                                    "items": {"type": "string"},
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        }
+    },
+    "required": ["papers_json"],
+}
+
+build_vector_index_tool = Tool(
+    name="build_vector_index",
+    description=(
+        "步骤3:将已解析论文列表加入向量库与 BM25 库,支持后续混合搜索。"
+        "返回 {indexed_count, status}。"
+    ),
+    parameters=_PARAMETERS,
+    func=build_vector_index,
+)

+ 152 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/tools/design_experiments.py

@@ -0,0 +1,152 @@
+"""步骤6 实验方案设计工具:为每个创新点输出可执行研究方案"""
+from __future__ import annotations
+
+import logging
+from typing import Any, Optional
+
+from backend.llm.client import DeepSeekClient
+from backend.llm.json_utils import parse_json_safe
+from backend.tools.base import Tool
+
+logger = logging.getLogger(__name__)
+
+# 模块级懒加载单例
+_client: Optional[DeepSeekClient] = None
+
+
+def get_client() -> DeepSeekClient:
+    """懒加载 DeepSeek 客户端单例"""
+    global _client
+    if _client is None:
+        _client = DeepSeekClient()
+    return _client
+
+
+def _ensure_list(val: Any) -> list:
+    """确保返回 list 类型"""
+    if isinstance(val, list):
+        return val
+    if isinstance(val, str):
+        return [val]
+    return []
+
+
+async def design_experiments(innovations: list[dict]) -> dict:
+    """为每个创新点输出可执行研究方案
+
+    输入:创新点列表 [{title, idea, source, gap_origin, score, novelty_check, supporting_evidence}]
+    输出:{"experiment_plans": [{innovation_title, hypothesis, datasets, baselines, metrics, ablation, steps, expected_results, risks}]}
+    """
+    if not innovations:
+        return {"experiment_plans": []}
+
+    # 1. 汇总创新点信息
+    innovations_text = "\n".join(
+        f"- {inv.get('title', '')}: {inv.get('idea', '')}"
+        f"(来源: {inv.get('source', '')},Gap: {inv.get('gap_origin', '')})"
+        for inv in innovations
+    )
+
+    # 2. 构造实验设计提示词
+    prompt = f"""你是一位资深学术研究者,需要为以下创新点设计可执行的研究方案。
+
+## 创新点列表
+{innovations_text}
+
+## 任务
+为每个创新点设计完整、可执行的研究方案,包含:
+- hypothesis(研究假设):清晰可验证的假设
+- datasets(数据集列表):适合该研究的公开数据集
+- baselines(基线方法列表):需要对比的现有方法
+- metrics(评估指标列表):量化评估指标
+- ablation(消融实验设计列表):验证各组件贡献
+- steps(实验步骤列表):可复现的实验流程
+- expected_results(预期结果):预期达到的性能或发现
+- risks(风险):可能的失败点与应对
+
+## 输出要求
+严格输出 JSON,不要包含任何额外说明文本或代码块标记。格式如下:
+{{
+  "experiment_plans": [
+    {{
+      "innovation_title": "对应的创新点标题",
+      "hypothesis": "研究假设",
+      "datasets": ["数据集1", "数据集2"],
+      "baselines": ["基线方法1", "基线方法2"],
+      "metrics": ["指标1", "指标2"],
+      "ablation": ["消融实验1", "消融实验2"],
+      "steps": ["步骤1", "步骤2", "步骤3"],
+      "expected_results": "预期结果描述",
+      "risks": "风险与应对描述"
+    }}
+  ]
+}}
+
+每个创新点对应一条方案,方案须具体可执行。datasets/baselines/metrics/ablation/steps 均为字符串数组。"""
+
+    messages = [
+        {
+            "role": "system",
+            "content": "你是一位学术实验设计专家,擅长设计严谨可执行的研究方案。只输出严格 JSON,不要输出任何其他内容。",
+        },
+        {"role": "user", "content": prompt},
+    ]
+
+    client = get_client()
+    response = await client.chat(messages=messages)
+    content = response.choices[0].message.content or ""
+    data = parse_json_safe(content)
+
+    if not data or not isinstance(data, dict):
+        logger.warning("实验方案 JSON 解析失败: %s", content[:200])
+        return {"experiment_plans": []}
+
+    plans = data.get("experiment_plans", [])
+    if not isinstance(plans, list):
+        plans = []
+
+    # 3. 规范化字段,确保列表类型
+    normalized: list[dict] = []
+    for plan in plans:
+        if not isinstance(plan, dict):
+            continue
+        normalized.append(
+            {
+                "innovation_title": plan.get("innovation_title", ""),
+                "hypothesis": plan.get("hypothesis", ""),
+                "datasets": _ensure_list(plan.get("datasets", [])),
+                "baselines": _ensure_list(plan.get("baselines", [])),
+                "metrics": _ensure_list(plan.get("metrics", [])),
+                "ablation": _ensure_list(plan.get("ablation", [])),
+                "steps": _ensure_list(plan.get("steps", [])),
+                "expected_results": plan.get("expected_results", ""),
+                "risks": plan.get("risks", ""),
+            }
+        )
+
+    return {"experiment_plans": normalized}
+
+
+# 工具参数 schema
+design_experiments_parameters = {
+    "type": "object",
+    "properties": {
+        "innovations": {
+            "type": "array",
+            "items": {"type": "object"},
+            "description": "创新点列表,每条含 title/idea/source/gap_origin/score/novelty_check/supporting_evidence",
+        }
+    },
+    "required": ["innovations"],
+}
+
+# 工具实例
+design_experiments_tool = Tool(
+    name="design_experiments",
+    description=(
+        "步骤6:实验方案设计。为每个创新点输出可执行研究方案,"
+        "包含研究假设、数据集、基线方法、评估指标、消融实验、实验步骤、预期结果与风险。"
+    ),
+    parameters=design_experiments_parameters,
+    func=design_experiments,
+)

+ 483 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/tools/extract_paper_structure.py

@@ -0,0 +1,483 @@
+"""步骤2 单篇论文结构化抽取工具:核心主干
+
+职责:
+- 调用 DeepSeek 通过 function calling 强制 JSON 输出,抽取固定 schema 字段;
+- 长论文按章节分块抽取后合并去重;
+- 字段完整性校验 + 针对性补抽(只补缺失字段,不重跑整篇);
+- limitations 字段单独强调须真实可溯源;
+- 自校验输出各字段置信度,低于阈值标记需复核;
+- 结果独立缓存(每篇一个 JSON + 追加 papers.jsonl),失败可单独重跑。
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import logging
+from pathlib import Path
+from typing import Any, Optional
+
+from backend.config import settings
+from backend.llm.client import DeepSeekClient
+from backend.llm.json_utils import parse_json_safe, validate_required_fields
+from backend.tools.base import Tool
+from backend.tools.extract_schema import (
+    EXTRACT_FIELDS,
+    EXTRACT_FUNCTION_SCHEMA,
+    build_extraction_prompt,
+)
+
+logger = logging.getLogger(__name__)
+
+# 长论文分块阈值(章节总字符数超过此值则分块抽取)
+CHUNK_CHAR_THRESHOLD = 20000
+
+# 模块级懒加载单例客户端
+_client: Optional[DeepSeekClient] = None
+
+
+def _get_client() -> DeepSeekClient:
+    """懒加载 DeepSeekClient 单例,首次调用时创建"""
+    global _client
+    if _client is None:
+        _client = DeepSeekClient()
+    return _client
+
+
+# --------------------------------------------------------------------------- #
+# 内部辅助函数
+# --------------------------------------------------------------------------- #
+
+def _normalize_field_source(val: Any) -> Optional[dict]:
+    """将任意值归一化为 FieldSource dict {value, source_sections, confidence}
+
+    支持三种输入:
+    - 字符串:包装为低置信度 FieldSource;
+    - dict:补全缺失键、裁剪 confidence 到 [0,1];
+    - 其他:返回 None。
+    """
+    if val is None:
+        return None
+    if isinstance(val, str):
+        if not val.strip():
+            return None
+        return {"value": val, "source_sections": [], "confidence": 0.5}
+    if isinstance(val, dict):
+        value = val.get("value", "")
+        if value is None:
+            value = ""
+        value = str(value).strip()
+        if not value:
+            return None
+        source = val.get("source_sections", [])
+        if isinstance(source, str):
+            source = [source]
+        elif not isinstance(source, list):
+            source = []
+        else:
+            source = [str(s) for s in source]
+        try:
+            conf = float(val.get("confidence", 0.8))
+        except (TypeError, ValueError):
+            conf = 0.8
+        conf = max(0.0, min(1.0, conf))
+        return {"value": value, "source_sections": source, "confidence": conf}
+    return None
+
+
+def _normalize_record(data: Any) -> dict:
+    """将模型输出的 dict 归一化为标准 record(所有字段为 FieldSource dict)"""
+    if not isinstance(data, dict):
+        return {}
+    record: dict[str, Any] = {}
+    for field in EXTRACT_FIELDS:
+        fs = _normalize_field_source(data.get(field))
+        if fs is not None:
+            record[field] = fs
+    return record
+
+
+def _chunk_sections(
+    sections: list[dict], max_chars: int = CHUNK_CHAR_THRESHOLD
+) -> list[list[dict]]:
+    """按章节分块,每块总字符数不超过 max_chars(不拆分单个章节)"""
+    chunks: list[list[dict]] = []
+    current: list[dict] = []
+    current_chars = 0
+    for sec in sections:
+        sec_chars = len(sec.get("content", ""))
+        # 当前块非空且加入后会超限 → 先落盘当前块
+        if current and current_chars + sec_chars > max_chars:
+            chunks.append(current)
+            current = []
+            current_chars = 0
+        current.append(sec)
+        current_chars += sec_chars
+    if current:
+        chunks.append(current)
+    return chunks
+
+
+def _merge_records(records: list[dict]) -> dict:
+    """合并多次抽取结果:每字段取置信度最高的 value,source_sections 去重合并"""
+    merged: dict[str, Any] = {}
+    for field in EXTRACT_FIELDS:
+        candidates: list[dict] = []
+        for r in records:
+            fs = r.get(field)
+            if fs and isinstance(fs, dict) and fs.get("value"):
+                candidates.append(fs)
+        if not candidates:
+            continue
+        # 取置信度最高的候选作为 value
+        best = max(candidates, key=lambda x: x.get("confidence", 0.0))
+        # 合并所有 source_sections 并去重(保序)
+        all_sources: list[str] = []
+        seen: set[str] = set()
+        for c in candidates:
+            for s in c.get("source_sections", []):
+                if s not in seen:
+                    seen.add(s)
+                    all_sources.append(s)
+        merged[field] = {
+            "value": best["value"],
+            "source_sections": all_sources,
+            "confidence": best.get("confidence", 0.8),
+        }
+    return merged
+
+
+async def _call_extract(
+    client: DeepSeekClient, parsed_paper: dict, focus_fields: Optional[list[str]] = None
+) -> dict:
+    """单次调用模型抽取字段,返回归一化后的 record dict
+
+    Args:
+        client: DeepSeek 客户端
+        parsed_paper: 已解析论文 dict
+        focus_fields: 若指定,则只补抽这些缺失字段(针对性补抽)
+    """
+    prompt = build_extraction_prompt(parsed_paper)
+    if focus_fields:
+        prompt = (
+            f"前一次抽取缺失了以下字段:{', '.join(focus_fields)}。\n"
+            f"请重点从原文中补抽这些字段,其他字段可留空。\n\n{prompt}"
+        )
+
+    messages = [
+        {
+            "role": "system",
+            "content": (
+                "你是论文结构化抽取助手。严格通过函数调用输出 JSON,"
+                "每个字段含 value/source_sections/confidence。"
+                "limitations 必须真实可溯源,严禁臆造。"
+            ),
+        },
+        {"role": "user", "content": prompt},
+    ]
+
+    # 强制调用指定函数以获得结构化 JSON 输出
+    response = await client.chat(
+        messages=messages,
+        tools=[EXTRACT_FUNCTION_SCHEMA],
+        tool_choice={
+            "type": "function",
+            "function": {"name": "extract_paper_fields"},
+        },
+    )
+
+    msg = response.choices[0].message
+    data: Any = None
+
+    # 优先从 tool_calls 提取参数
+    tool_calls = getattr(msg, "tool_calls", None)
+    if tool_calls:
+        try:
+            data = parse_json_safe(tool_calls[0].function.arguments)
+        except Exception:
+            data = None
+
+    # 降级:从 content 解析
+    if data is None and msg.content:
+        data = parse_json_safe(msg.content)
+
+    if data is None:
+        logger.warning("模型未返回可解析的 JSON,返回空 record")
+        return {}
+
+    return _normalize_record(data)
+
+
+# --------------------------------------------------------------------------- #
+# 核心抽取函数
+# --------------------------------------------------------------------------- #
+
+async def extract_paper_structure(paper_path: str, parsed_paper: dict) -> dict:
+    """从已解析论文中抽取结构化字段
+
+    Args:
+        paper_path: 论文文件路径
+        parsed_paper: 已解析论文 dict,含 path/title/sections:[{heading,content,figure_captions}]
+
+    Returns:
+        dict,可序列化为 PaperRecord。所有 EXTRACT_FIELDS 字段为 FieldSource dict。
+    """
+    client = _get_client()
+    sections = parsed_paper.get("sections", [])
+    total_chars = sum(len(s.get("content", "")) for s in sections)
+
+    if total_chars > CHUNK_CHAR_THRESHOLD:
+        # 长论文:按章节分块抽取后合并去重
+        logger.info(
+            "论文 %s 总字符数 %d 超过阈值 %d,按章节分块抽取",
+            paper_path,
+            total_chars,
+            CHUNK_CHAR_THRESHOLD,
+        )
+        chunks = _chunk_sections(sections, CHUNK_CHAR_THRESHOLD)
+        chunk_records: list[dict] = []
+        for idx, chunk in enumerate(chunks):
+            chunk_paper = {**parsed_paper, "sections": chunk}
+            logger.debug("抽取分块 %d/%d(%d 章节)", idx + 1, len(chunks), len(chunk))
+            rec = await _call_extract(client, chunk_paper)
+            if rec:
+                chunk_records.append(rec)
+        record = _merge_records(chunk_records) if chunk_records else {}
+    else:
+        # 短论文:一次性抽取
+        record = await _call_extract(client, parsed_paper)
+
+    # 字段完整性校验:检查必填字段是否齐全
+    missing = validate_required_fields(record, EXTRACT_FIELDS)
+    if missing:
+        logger.info("首次抽取缺失字段 %s,触发针对性补抽", missing)
+        supplement = await _call_extract(client, parsed_paper, focus_fields=missing)
+        for field in missing:
+            fs = supplement.get(field)
+            if fs:
+                record[field] = fs
+
+    # 确保 path 字段(PaperRecord 顶层字段,非 FieldSource)
+    record["path"] = paper_path
+    # 若 title 缺失,用 parsed_paper 的 title 兜底
+    if "title" not in record or not record["title"].get("value"):
+        fallback_title = parsed_paper.get("title", "")
+        if fallback_title:
+            record["title"] = {
+                "value": fallback_title,
+                "source_sections": [],
+                "confidence": 0.6,
+            }
+
+    return record
+
+
+# --------------------------------------------------------------------------- #
+# 自校验函数
+# --------------------------------------------------------------------------- #
+
+async def self_check(
+    record: dict, parsed_paper: dict, client: DeepSeekClient
+) -> dict:
+    """让模型对照原文检查各字段,输出每字段置信度
+
+    Args:
+        record: 抽取结果 dict
+        parsed_paper: 已解析论文 dict
+        client: DeepSeek 客户端(由调用方传入)
+
+    Returns:
+        {
+            "record": record,
+            "field_confidences": {字段名: 置信度},
+            "overall_confidence": float,
+            "needs_review": [低于阈值的字段名]
+        }
+    """
+    # 拼接原文节选(截断避免超长)
+    sections = parsed_paper.get("sections", [])
+    sections_text = "\n\n".join(
+        f"## {s.get('heading', '')}\n{s.get('content', '')[:3000]}"
+        for s in sections
+    )[:15000]
+
+    record_text = json.dumps(record, ensure_ascii=False, indent=2, default=str)
+    fields_list = "、".join(EXTRACT_FIELDS)
+
+    prompt = f"""请对照论文原文,检查以下结构化抽取记录的每个字段是否准确。
+
+论文原文(节选):
+{sections_text}
+
+抽取记录:
+{record_text}
+
+检查要求:
+1. 对以下每个字段输出 0-1 的置信度:{fields_list}
+2. 输出整体置信度 overall_confidence(所有字段的加权平均,limitations 权重更高)。
+3. 严格以 JSON 输出,格式如下:
+{{
+  "field_confidences": {{
+    "title": 0.95,
+    "task_problem": 0.9,
+    "method": 0.85,
+    "key_contributions": 0.8,
+    "datasets": 0.9,
+    "metrics": 0.85,
+    "results": 0.8,
+    "limitations": 0.7,
+    "future_work": 0.6
+  }},
+  "overall_confidence": 0.82,
+  "issues": ["limitations 字段描述过于模糊,原文未明确提及"]
+}}
+"""
+
+    messages = [
+        {"role": "system", "content": "你是论文抽取质量审核员,负责对照原文核查字段准确性。"},
+        {"role": "user", "content": prompt},
+    ]
+
+    response = await client.chat(messages=messages)
+    content = response.choices[0].message.content or ""
+    result = parse_json_safe(content)
+
+    if not isinstance(result, dict):
+        logger.warning("自校验未返回有效 JSON,降级为空结果")
+        result = {}
+
+    field_confidences: dict[str, float] = {}
+    raw_confidences = result.get("field_confidences", {})
+    if isinstance(raw_confidences, dict):
+        for f in EXTRACT_FIELDS:
+            try:
+                field_confidences[f] = float(raw_confidences.get(f, 0.0))
+            except (TypeError, ValueError):
+                field_confidences[f] = 0.0
+
+    try:
+        overall = float(result.get("overall_confidence", 0.0))
+    except (TypeError, ValueError):
+        overall = 0.0
+    overall = max(0.0, min(1.0, overall))
+
+    # 低于阈值的字段标记需复核
+    threshold = settings.CONFIDENCE_THRESHOLD
+    needs_review = [
+        f for f in EXTRACT_FIELDS if field_confidences.get(f, 0.0) < threshold
+    ]
+
+    return {
+        "record": record,
+        "field_confidences": field_confidences,
+        "overall_confidence": overall,
+        "needs_review": needs_review,
+        "issues": result.get("issues", []),
+    }
+
+
+# --------------------------------------------------------------------------- #
+# 缓存函数
+# --------------------------------------------------------------------------- #
+
+def _resolve_cache_dir(cache_dir: Optional[str] = None) -> Path:
+    """解析缓存目录,默认使用 settings.CACHE_DIR"""
+    if cache_dir:
+        p = Path(cache_dir)
+    else:
+        p = settings.CACHE_DIR
+    p.mkdir(parents=True, exist_ok=True)
+    return p
+
+
+def _paper_hash(paper_path: str) -> str:
+    """以论文路径生成 hash,作为缓存文件名(向后兼容旧缓存)"""
+    return hashlib.md5(paper_path.encode("utf-8")).hexdigest()[:16]
+
+
+def _cache_file_path(paper_id: Optional[str], paper_path: str, cache_dir: Optional[Path] = None) -> Path:
+    """解析缓存文件路径,优先用 paper_id,否则回退到路径哈希"""
+    base = cache_dir or _resolve_cache_dir()
+    papers_dir = base / "papers"
+    papers_dir.mkdir(parents=True, exist_ok=True)
+    key = paper_id if paper_id else _paper_hash(paper_path)
+    return papers_dir / f"{key}.json"
+
+
+def save_record(record: dict, cache_dir: Optional[str] = None, paper_id: Optional[str] = None) -> Path:
+    """保存单篇抽取结果到独立 JSON 文件,并追加写入 papers.jsonl
+
+    Args:
+        record: 抽取结果 dict
+        cache_dir: 缓存目录,默认 settings.CACHE_DIR
+        paper_id: 论文内容哈希,优先用作缓存键
+
+    Returns:
+        独立 JSON 文件路径
+    """
+    base = _resolve_cache_dir(cache_dir)
+    paper_path = record.get("path", "")
+    file_path = _cache_file_path(paper_id, paper_path, base)
+
+    # 独立 JSON 文件(可单独重跑)
+    with open(file_path, "w", encoding="utf-8") as f:
+        json.dump(record, f, ensure_ascii=False, indent=2, default=str)
+
+    # 追加写入 papers.jsonl(一行一篇)
+    jsonl_path = base / "papers.jsonl"
+    with open(jsonl_path, "a", encoding="utf-8") as f:
+        f.write(json.dumps(record, ensure_ascii=False, default=str) + "\n")
+
+    logger.info("抽取结果已缓存至 %s", file_path)
+    return file_path
+
+
+def load_record(paper_path: str, cache_dir: Optional[str] = None, paper_id: Optional[str] = None) -> Optional[dict]:
+    """从缓存加载单篇抽取结果,不存在返回 None
+
+    Args:
+        paper_path: 论文文件路径
+        cache_dir: 缓存目录,默认 settings.CACHE_DIR
+        paper_id: 论文内容哈希,优先用作缓存键
+
+    Returns:
+        抽取结果 dict,或 None
+    """
+    base = _resolve_cache_dir(cache_dir)
+    file_path = _cache_file_path(paper_id, paper_path, base)
+    if not file_path.exists():
+        return None
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except (json.JSONDecodeError, OSError) as exc:
+        logger.warning("读取缓存 %s 失败: %s", file_path, exc)
+        return None
+
+
+# --------------------------------------------------------------------------- #
+# 工具定义
+# --------------------------------------------------------------------------- #
+
+_PARAMETERS_SCHEMA: dict = {
+    "type": "object",
+    "properties": {
+        "paper_path": {"type": "string"},
+        "parsed_paper": {
+            "type": "object",
+            "description": "已解析论文,含 path/title/sections",
+        },
+    },
+    "required": ["paper_path", "parsed_paper"],
+}
+
+extract_paper_structure_tool = Tool(
+    name="extract_paper_structure",
+    description=(
+        "从已解析论文中抽取结构化字段"
+        "(title/task_problem/method/key_contributions/datasets/metrics/"
+        "results/limitations/future_work),"
+        "每个字段含来源章节与置信度。长论文自动分块抽取后合并。"
+    ),
+    parameters=_PARAMETERS_SCHEMA,
+    func=extract_paper_structure,
+)

+ 124 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/tools/extract_schema.py

@@ -0,0 +1,124 @@
+"""步骤2 结构化抽取 schema 定义:字段列表、Function Calling schema、提示词构造"""
+from __future__ import annotations
+
+from typing import Any
+
+
+# 抽取的固定字段列表(顺序即重要性顺序,limitations 为重点字段)
+EXTRACT_FIELDS: list[str] = [
+    "title",
+    "task_problem",
+    "method",
+    "key_contributions",
+    "datasets",
+    "metrics",
+    "results",
+    "limitations",
+    "future_work",
+]
+
+# 各字段中文描述,用于 schema 与提示词
+FIELD_DESCRIPTIONS: dict[str, str] = {
+    "title": "论文标题",
+    "task_problem": "研究任务/问题",
+    "method": "核心方法",
+    "key_contributions": "主要贡献",
+    "datasets": "使用的数据集",
+    "metrics": "评估指标",
+    "results": "实验结果",
+    "limitations": "局限性(重点字段,须论文明确承认或可从结果推断,严禁臆造)",
+    "future_work": "未来工作",
+}
+
+
+def _field_source_schema(description: str) -> dict[str, Any]:
+    """构造单个 FieldSource 字段的 JSON schema"""
+    return {
+        "type": "object",
+        "description": description,
+        "properties": {
+            "value": {
+                "type": "string",
+                "description": "字段值",
+            },
+            "source_sections": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "原文出处章节标题列表,用于回溯核查",
+            },
+            "confidence": {
+                "type": "number",
+                "description": "置信度 0.0-1.0,信息明确且原文直述取高值,推断取中值,不足取低值",
+            },
+        },
+        "required": ["value", "source_sections", "confidence"],
+    }
+
+
+# DeepSeek function calling schema:强制模型输出上述字段的 JSON
+EXTRACT_FUNCTION_SCHEMA: dict[str, Any] = {
+    "type": "function",
+    "function": {
+        "name": "extract_paper_fields",
+        "description": (
+            "从论文中抽取结构化字段,每个字段含 value/source_sections/confidence。"
+            "必须返回所有字段,limitations 须真实可溯源。"
+        ),
+        "parameters": {
+            "type": "object",
+            "properties": {
+                field: _field_source_schema(desc)
+                for field, desc in FIELD_DESCRIPTIONS.items()
+            },
+            "required": list(EXTRACT_FIELDS),
+        },
+    },
+}
+
+
+def build_extraction_prompt(parsed_paper: dict) -> str:
+    """构造抽取提示词(中文)
+
+    强调三点:
+    1. source_sections 必须标注原文出处章节;
+    2. limitations 须真实,论文未明确承认时不得臆造;
+    3. 严格输出 JSON,不添加额外说明。
+    """
+    title = parsed_paper.get("title", "")
+    sections = parsed_paper.get("sections", [])
+
+    # 拼接章节正文,保留 heading 以便 source_sections 标注
+    sections_text = ""
+    for i, sec in enumerate(sections, 1):
+        heading = sec.get("heading", f"章节{i}")
+        content = sec.get("content", "")
+        captions = sec.get("figure_captions", []) or []
+        sections_text += f"\n\n## {heading}\n{content}"
+        if captions:
+            sections_text += "\n\n图表标题:\n" + "\n".join(f"- {c}" for c in captions)
+
+    fields_list = "、".join(EXTRACT_FIELDS)
+
+    return f"""请从以下论文中抽取结构化字段。
+
+论文标题:{title}
+
+论文正文:
+{sections_text}
+
+抽取要求:
+1. 必须抽取以下字段:{fields_list}
+2. 每个字段必须是 FieldSource 结构:
+   {{
+     "value": "字段值(字符串,尽量简洁完整)",
+     "source_sections": ["原文出处章节标题列表"],
+     "confidence": 0.0-1.0
+   }}
+3. source_sections 必须标注字段信息来源于上面哪个章节(用章节标题原文),便于回溯核查;可标注多个章节。
+4. limitations 字段特别要求:必须是论文明确承认的局限,或可从实验结果直接推断的局限,严禁臆造或泛泛而谈。若论文未明确提及局限,value 填写"论文未明确陈述局限",confidence 设为较低值(如 0.3)。
+5. confidence 反映你对该字段抽取结果的可信度:
+   - 信息明确且原文直述 → 0.9-1.0
+   - 需要从原文推断 → 0.6-0.8
+   - 信息不足或模糊 → 低于 0.6
+6. 严格输出 JSON,不要添加任何额外说明文字或 markdown 代码块标记。
+"""

+ 208 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/tools/generate_innovations.py

@@ -0,0 +1,208 @@
+"""步骤5 创新生成与筛选工具:针对 Gap 生成候选创新方向,三维评分筛选,联网新颖性去重"""
+from __future__ import annotations
+
+import logging
+from typing import Optional
+
+from backend.llm.client import DeepSeekClient
+from backend.llm.json_utils import parse_json_safe
+from backend.tools.base import Tool
+
+logger = logging.getLogger(__name__)
+
+# 模块级懒加载单例
+_client: Optional[DeepSeekClient] = None
+
+
+def get_client() -> DeepSeekClient:
+    """懒加载 DeepSeek 客户端单例"""
+    global _client
+    if _client is None:
+        _client = DeepSeekClient()
+    return _client
+
+
+async def _novelty_check(title: str, idea: str) -> str:
+    """调用联网搜索做新颖性去重,检索近 1-2 年相关工作
+
+    懒导入 web_search,避免模块加载期依赖未就绪的模块。
+    """
+    query = f"{title} {idea[:100]}"
+    try:
+        # 懒导入
+        from backend.tools.web_search import web_search
+
+        result = await web_search(query)
+        items = result.get("results", [])[:5]
+        if not items:
+            return "未检索到高度相关工作,新颖性较高"
+        lines: list[str] = []
+        for r in items:
+            t = r.get("title", "")
+            snippet = r.get("snippet", "")[:120]
+            url = r.get("url", "")
+            lines.append(f"  - {t}: {snippet} ({url})")
+        return "近 1-2 年相关工作:\n" + "\n".join(lines)
+    except Exception as exc:
+        logger.warning("web_search 新颖性检查失败: %s", exc)
+        return "新颖性检查失败(联网搜索不可用)"
+
+
+async def generate_innovations(
+    gaps: list[dict],
+    research_direction: Optional[str] = None,
+) -> dict:
+    """针对 Gap 生成候选创新方向,三维评分筛选,取综合得分最高的 2-3 个
+
+    输入:Gap 列表 [{description, gap_type, source_papers, evidence, confidence}]
+    输出:{"innovations": [{title, idea, source, gap_origin, score, novelty_check, supporting_evidence}]}
+    """
+    if not gaps:
+        return {"innovations": []}
+
+    # 1. 汇总 Gap 信息
+    gaps_text = "\n".join(
+        f"- [{g.get('gap_type', 'unknown')}] {g.get('description', '')}"
+        f"(来源: {', '.join(g.get('source_papers', []))})"
+        for g in gaps
+    )
+
+    # 1.1 研究方向约束文本
+    direction_text = ""
+    if research_direction and research_direction.strip():
+        direction_text = (
+            f"\n## 用户研究方向约束\n"
+            f"用户的研究方向为:{research_direction.strip()}\n"
+            f"生成的创新点应尽量与该方向相关,"
+            f"并在 supporting_evidence 中说明创新点与该方向的关联。\n"
+        )
+
+    # 2. 构造创新生成提示词
+    prompt = f"""你是一位富有创造力的学术研究者,需要基于以下研究空白(Gap)生成候选创新方向。
+{direction_text}
+## 研究空白列表
+{gaps_text}
+
+## 任务
+针对每个 Gap,从以下四类来源生成候选创新方向:
+1. method_combination(方法组合):把 A 论文方法迁移到 B 论文问题
+2. limitation_fix(局限改进):直接解决被反复提及的局限
+3. cross_domain(跨域迁移):引入其他领域方法
+4. new_scenario(新场景应用):把现有方法用到未被覆盖的数据/场景
+
+对每个候选创新方向,用三维评分(0-10 分):
+- novelty(新颖性)
+- feasibility(可行性)
+- significance(显著性)
+
+## 输出要求
+严格输出 JSON,不要包含任何额外说明文本或代码块标记。格式如下:
+{{
+  "innovations": [
+    {{
+      "title": "创新点标题",
+      "idea": "创新思路详细描述",
+      "source": "method_combination|limitation_fix|cross_domain|new_scenario",
+      "gap_origin": "对应的 Gap 描述",
+      "score": {{
+        "novelty": 0.0到10.0,
+        "feasibility": 0.0到10.0,
+        "significance": 0.0到10.0
+      }},
+      "supporting_evidence": "论据支撑"
+    }}
+  ]
+}}
+
+生成多个候选(每个 Gap 至少 1-2 个),按综合得分(三项之和)从高到低排序。"""
+
+    messages = [
+        {
+            "role": "system",
+            "content": "你是一位学术创新生成专家,擅长从研究空白中挖掘可执行的创新方向。只输出严格 JSON,不要输出任何其他内容。",
+        },
+        {"role": "user", "content": prompt},
+    ]
+
+    client = get_client()
+    response = await client.chat(messages=messages)
+    content = response.choices[0].message.content or ""
+    data = parse_json_safe(content)
+
+    if not data or not isinstance(data, dict):
+        logger.warning("创新生成 JSON 解析失败: %s", content[:200])
+        return {"innovations": []}
+
+    innovations = data.get("innovations", [])
+    if not isinstance(innovations, list):
+        innovations = []
+
+    # 3. 规范化 + 计算综合得分排序
+    normalized: list[dict] = []
+    for inv in innovations:
+        if not isinstance(inv, dict):
+            continue
+        score = inv.get("score", {})
+        if not isinstance(score, dict):
+            score = {}
+        novelty = float(score.get("novelty", 0.0))
+        feasibility = float(score.get("feasibility", 0.0))
+        significance = float(score.get("significance", 0.0))
+        normalized.append(
+            {
+                "title": inv.get("title", ""),
+                "idea": inv.get("idea", ""),
+                "source": inv.get("source", "limitation_fix"),
+                "gap_origin": inv.get("gap_origin", ""),
+                "score": {
+                    "novelty": novelty,
+                    "feasibility": feasibility,
+                    "significance": significance,
+                },
+                "_total": novelty + feasibility + significance,
+                "novelty_check": None,
+                "supporting_evidence": inv.get("supporting_evidence", ""),
+            }
+        )
+
+    # 4. 按综合得分降序,取前 2-3 个
+    normalized.sort(key=lambda x: x["_total"], reverse=True)
+    top_count = 3 if len(normalized) >= 3 else len(normalized)
+    top = normalized[:top_count]
+
+    # 5. 对每个创新点做联网新颖性去重
+    for inv in top:
+        inv["novelty_check"] = await _novelty_check(inv["title"], inv["idea"])
+        inv.pop("_total", None)
+
+    return {"innovations": top}
+
+
+# 工具参数 schema
+generate_innovations_parameters = {
+    "type": "object",
+    "properties": {
+        "gaps": {
+            "type": "array",
+            "items": {"type": "object"},
+            "description": "Gap 列表,每条含 description/gap_type/source_papers/evidence/confidence",
+        },
+        "research_direction": {
+            "type": "string",
+            "description": "用户的研究方向(可选),生成的创新点应尽量与该方向相关",
+        },
+    },
+    "required": ["gaps"],
+}
+
+# 工具实例
+generate_innovations_tool = Tool(
+    name="generate_innovations",
+    description=(
+        "步骤5:创新生成与筛选。针对每个 Gap 从四类来源(方法组合/局限改进/跨域迁移/新场景应用)"
+        "生成候选创新方向,三维评分筛选取综合得分最高的 2-3 个,"
+        "并联网检索近 1-2 年相关工作做新颖性去重。"
+    ),
+    parameters=generate_innovations_parameters,
+    func=generate_innovations,
+)

+ 117 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/tools/hello_agents_bridge.py

@@ -0,0 +1,117 @@
+"""工具桥接:把 PaperMind 工具注册表适配为 HelloAgents 框架的 ToolRegistry
+
+项目的 Function Calling 工具通过桥接成为框架原生 Tool(ToolResponse 协议),
+供框架的 SimpleAgent/ReActAgent 直接调度,享受框架的熔断器与参数校验能力。
+"""
+from __future__ import annotations
+
+import asyncio
+import inspect
+import logging
+from typing import Any, Optional
+
+from hello_agents.tools.base import Tool, ToolParameter
+from hello_agents.tools.registry import ToolRegistry as HelloAgentsToolRegistry
+from hello_agents.tools.response import ToolResponse, ToolStatus
+
+from backend.tools.base import Tool as PaperMindTool
+from backend.tools.base import ToolRegistry as PaperMindToolRegistry
+
+logger = logging.getLogger(__name__)
+
+
+class PaperMindHelloAgentsTool(Tool):
+    """框架 Tool 适配器:把 PaperMind 工具包装为框架原生工具
+
+    - arun: 项目工具为 async 函数时直接 await
+    - run: 同步执行(内部用事件循环驱动 async 工具)
+    """
+
+    def __init__(self, tool: PaperMindTool) -> None:
+        super().__init__(name=tool.name, description=tool.description)
+        self._func = tool.func
+        self._schema = tool.to_schema()
+
+    def to_openai_schema(self) -> dict[str, Any]:
+        """直接沿用项目工具的 OpenAI function calling schema(参数定义更完整)"""
+        return self._schema
+
+    def get_parameters(self) -> list[ToolParameter]:
+        """从项目工具 schema 转换出框架 ToolParameter 列表"""
+        params: list[ToolParameter] = []
+        properties = self._schema.get("function", {}).get("parameters", {}).get("properties", {})
+        required = self._schema.get("function", {}).get("parameters", {}).get("required", [])
+        for pname, pspec in properties.items():
+            params.append(
+                ToolParameter(
+                    name=pname,
+                    type=pspec.get("type", "string"),
+                    description=pspec.get("description", ""),
+                    required=pname in required,
+                )
+            )
+        return params
+
+    def run(self, parameters: dict[str, Any]) -> ToolResponse:
+        """同步执行项目工具,返回框架 ToolResponse"""
+        try:
+            if inspect.iscoroutinefunction(self._func):
+                result = asyncio.run(self._func(**parameters))
+            else:
+                result = self._func(**parameters)
+            return self._to_success_response(result)
+        except Exception as exc:
+            logger.warning("工具 %s 执行失败: %s", self.name, exc)
+            return ToolResponse(
+                status=ToolStatus.ERROR,
+                text=f"工具执行失败: {exc}",
+                error_info={"tool": self.name, "message": str(exc)},
+            )
+
+    async def arun(self, parameters: dict[str, Any]) -> ToolResponse:
+        """异步执行项目工具(优先路径),返回框架 ToolResponse"""
+        try:
+            if inspect.iscoroutinefunction(self._func):
+                result = await self._func(**parameters)
+            else:
+                result = await asyncio.to_thread(self._func, **parameters)
+            return self._to_success_response(result)
+        except Exception as exc:
+            logger.warning("工具 %s 执行失败: %s", self.name, exc)
+            return ToolResponse(
+                status=ToolStatus.ERROR,
+                text=f"工具执行失败: {exc}",
+                error_info={"tool": self.name, "message": str(exc)},
+            )
+
+    def _to_success_response(self, result: Any) -> ToolResponse:
+        """把项目工具返回值转为 ToolResponse:字符串走 text,结构化对象走 data"""
+        if isinstance(result, str):
+            return ToolResponse(status=ToolStatus.SUCCESS, text=result)
+        if isinstance(result, dict):
+            return ToolResponse(status=ToolStatus.SUCCESS, text="ok", data=result)
+        return ToolResponse(status=ToolStatus.SUCCESS, text=str(result))
+
+
+def build_hello_agents_registry(
+    registry: PaperMindToolRegistry,
+    tool_names: Optional[list[str]] = None,
+) -> HelloAgentsToolRegistry:
+    """把 PaperMind 工具注册表转换为 HelloAgents 框架工具注册表
+
+    Args:
+        registry: 项目工具注册表
+        tool_names: 仅桥接指定工具子集(None 表示全部)
+
+    Returns:
+        HelloAgents ToolRegistry,框架 Agent 可直接使用
+    """
+    ha_registry = HelloAgentsToolRegistry()
+    names = tool_names or registry.names()
+    for name in names:
+        tool = registry.get(name)
+        if tool is None:
+            logger.warning("桥接跳过:未注册的工具 %s", name)
+            continue
+        ha_registry.register_tool(PaperMindHelloAgentsTool(tool))
+    return ha_registry

+ 50 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/tools/hybrid_search_tool.py

@@ -0,0 +1,50 @@
+"""混合搜索工具:向量 + BM25 混合检索"""
+from __future__ import annotations
+
+from backend.tools.base import Tool
+
+
+async def hybrid_search(query: str, top_k: int = 5) -> dict:
+    """混合检索向量库,返回相关段落。
+
+    复用 build_vector_index 模块的 HybridSearcher 单例,
+    保证索引写入与检索读取共享同一实例。
+
+    Returns:
+        {"query": query, "results": [{text, paper_path, title, section, score}]}
+    """
+    # 复用 build_vector_index 的单例,确保索引数据可被检索
+    from backend.tools.build_vector_index import _get_searcher
+
+    searcher = _get_searcher()
+    results = await searcher.async_search(query, top_k=top_k)
+    return {"query": query, "results": results}
+
+
+# ---------- Tool 定义 ----------
+
+_PARAMETERS = {
+    "type": "object",
+    "properties": {
+        "query": {
+            "type": "string",
+            "description": "检索查询文本",
+        },
+        "top_k": {
+            "type": "integer",
+            "description": "返回结果数量,默认 5",
+            "default": 5,
+        },
+    },
+    "required": ["query"],
+}
+
+hybrid_search_tool = Tool(
+    name="hybrid_search",
+    description=(
+        "混合搜索(向量相似度 + BM25 关键词)论文向量库,返回相关段落。"
+        "用于回溯原文细节。返回 {query, results: [{text, paper_path, title, section, score}]}。"
+    ),
+    parameters=_PARAMETERS,
+    func=hybrid_search,
+)

+ 74 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/tools/memory_tools.py

@@ -0,0 +1,74 @@
+"""Memory 工具:save_memory / load_memory,供 Agent 通过 Function Calling 操作长期记忆"""
+from __future__ import annotations
+
+from typing import Any
+
+from backend.tools.base import Tool
+
+# 懒加载长期记忆单例
+_long_term = None
+
+
+def _get_long_term():
+    global _long_term
+    if _long_term is None:
+        from backend.memory.long_term import LongTermMemory
+        _long_term = LongTermMemory()
+    return _long_term
+
+
+async def save_memory(content: str, memory_type: str = "knowledge", metadata: str = "") -> dict:
+    """保存知识到长期记忆"""
+    try:
+        lt = _get_long_term()
+        meta = {"source": "agent", "note": metadata} if metadata else {"source": "agent"}
+        if memory_type == "gap":
+            await lt.save_knowledge(content, {**meta, "type": "gap"})
+        elif memory_type == "innovation":
+            await lt.save_knowledge(content, {**meta, "type": "innovation"})
+        else:
+            await lt.save_knowledge(content, meta)
+        return {"status": "saved", "memory_type": memory_type, "content_length": len(content)}
+    except Exception as e:
+        # 降级:长期记忆不可用不影响主流程
+        return {"status": "failed", "error": str(e)}
+
+
+async def load_memory(query: str, top_k: int = 5) -> dict:
+    """从长期记忆检索相关知识"""
+    try:
+        lt = _get_long_term()
+        results = await lt.load_relevant(query, top_k=top_k)
+        return {"query": query, "memories": results}
+    except Exception as e:
+        return {"query": query, "memories": [], "error": str(e)}
+
+
+save_memory_tool = Tool(
+    name="save_memory",
+    description="保存知识/Gap/创新点到长期记忆,供跨会话复用。memory_type 可选 gap/innovation/knowledge",
+    parameters={
+        "type": "object",
+        "properties": {
+            "content": {"type": "string", "description": "要保存的内容"},
+            "memory_type": {"type": "string", "enum": ["gap", "innovation", "knowledge"], "default": "knowledge"},
+            "metadata": {"type": "string", "description": "附加说明,可选"},
+        },
+        "required": ["content"],
+    },
+    func=save_memory,
+)
+
+load_memory_tool = Tool(
+    name="load_memory",
+    description="从长期记忆语义检索相关知识/历史 Gap/创新点,用于创新点去重与知识复用",
+    parameters={
+        "type": "object",
+        "properties": {
+            "query": {"type": "string", "description": "检索查询"},
+            "top_k": {"type": "integer", "default": 5},
+        },
+        "required": ["query"],
+    },
+    func=load_memory,
+)

+ 311 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/tools/parse_pdf.py

@@ -0,0 +1,311 @@
+"""步骤1 PDF 解析工具:用 PyMuPDF 解析 PDF,保留章节结构"""
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import re
+from collections import Counter
+from pathlib import Path
+from typing import Optional
+
+from backend.config import settings
+from backend.tools.base import Tool
+
+logger = logging.getLogger(__name__)
+
+
+# ---------- 启发式规则 ----------
+
+# 常见章节标题模式(英文 + 中文),用于辅助加粗短行的标题判定
+_HEADING_PATTERN = re.compile(
+    r"^("
+    r"abstract|introduction|related\s+work|background|preliminar"
+    r"|method|methods|methodology|approach|model|framework"
+    r"|experiment|experiments|experimental|evaluation|results?"
+    r"|discussion|conclusion|conclusions|references|acknowledg"
+    r"|appendix|contribution"
+    r"|摘要|引言|前言|相关工作|背景|方法|实验|结果|讨论|结论|参考文献|致谢|附录"
+    r"|\d+\.?\s|\d+\.\d+\.?\s"
+    r")",
+    re.IGNORECASE,
+)
+
+# 图表标题模式:Figure X / Fig. X / 表 X / Table X 开头
+_FIGURE_PATTERN = re.compile(
+    r"^((figure|fig)\.?\s+\d+|表\s*\d+|table\s+\d+)",
+    re.IGNORECASE,
+)
+
+# 句末标点:用于判断段落是否结束
+_SENTENCE_END = set(".!?。!?:;")
+
+# 页眉页脚判定阈值:短行长度上限
+_HEADER_FOOTER_MAX_LEN = 80
+
+
+# ---------- 解析辅助函数 ----------
+
+def _extract_title(doc, first_page_lines: list[dict]) -> str:
+    """从元数据或首页大字号文本提取论文标题"""
+    meta = doc.metadata or {}
+    meta_title = (meta.get("title") or "").strip()
+    # 元数据标题有效且非占位符
+    if meta_title and len(meta_title) > 5 and "untitled" not in meta_title.lower():
+        return meta_title
+    # 退化:取首页最大字号文本作为标题(标题可能跨多行)
+    if first_page_lines:
+        max_size = max(ln["size"] for ln in first_page_lines)
+        title_lines = [
+            ln["text"]
+            for ln in first_page_lines
+            if ln["size"] >= max_size * 0.9
+        ]
+        if title_lines:
+            return " ".join(title_lines[:3]).strip()
+    return ""
+
+
+def _is_heading(line: dict, body_size: float) -> bool:
+    """启发式判断是否为章节标题:字号较大或加粗的短行"""
+    text = line["text"]
+    size = line["size"]
+    # 过长的不视为标题
+    if len(text) > 120:
+        return False
+    # 字号明显大于正文 → 标题
+    if size > body_size * 1.15:
+        return True
+    # 加粗且字号不小于正文 → 结合模式/大小写判定
+    if line["bold"] and size >= body_size * 0.95:
+        if _HEADING_PATTERN.match(text):
+            return True
+        if text.isupper() and len(text) < 80:
+            return True
+    return False
+
+
+def _clean_lines_to_content(lines: list[dict]) -> tuple[str, list[str]]:
+    """文本清洗:修复断句(行尾无标点则合并下一行)、合并跨页段落,提取图表标题。
+
+    Returns:
+        (正文, 图表标题列表)
+    """
+    figure_captions: list[str] = []
+    paragraphs: list[str] = []
+    buf = ""
+
+    for ln in lines:
+        text = ln["text"]
+        # 图表标题独立提取,不并入正文
+        if _FIGURE_PATTERN.match(text):
+            figure_captions.append(text)
+            # 图表标题前若有未结束段落,先落段
+            if buf:
+                paragraphs.append(buf)
+                buf = ""
+            continue
+
+        if not buf:
+            buf = text
+        else:
+            # 上一行以句末标点结尾 → 起新段;否则合并(修复断句、跨页段落)
+            if buf[-1] in _SENTENCE_END:
+                paragraphs.append(buf)
+                buf = text
+            else:
+                # 英文之间补空格,中文直接连接
+                if buf[-1].isascii() and text[:1].isascii():
+                    buf = f"{buf} {text}"
+                else:
+                    buf = f"{buf}{text}"
+    if buf:
+        paragraphs.append(buf)
+
+    content = "\n\n".join(paragraphs)
+    return content, figure_captions
+
+
+def _parse_pdf_sync(file_path: str) -> dict:
+    """同步解析 PDF(在线程池中执行)"""
+    import fitz  # PyMuPDF
+
+    doc = fitz.open(file_path)
+    try:
+        # 1. 收集所有行及其字体信息
+        all_lines: list[dict] = []
+        for page_idx in range(len(doc)):
+            page = doc[page_idx]
+            page_dict = page.get_text("dict")
+            for block in page_dict.get("blocks", []):
+                # 只处理文本块(type 0)
+                if block.get("type", 0) != 0:
+                    continue
+                for line in block.get("lines", []):
+                    line_text = ""
+                    max_size = 0.0
+                    is_bold = False
+                    for span in line.get("spans", []):
+                        line_text += span.get("text", "")
+                        max_size = max(max_size, span.get("size", 0.0))
+                        # bold 标志位为 bit4(值 16)
+                        if span.get("flags", 0) & 16:
+                            is_bold = True
+                    line_text = line_text.strip()
+                    if line_text:
+                        all_lines.append(
+                            {
+                                "text": line_text,
+                                "size": max_size,
+                                "bold": is_bold,
+                                "page": page_idx,
+                            }
+                        )
+
+        if not all_lines:
+            return {"path": file_path, "title": "", "sections": []}
+
+        page_count = max(ln["page"] for ln in all_lines) + 1
+
+        # 2. 检测页眉页脚:跨页重复出现的短行
+        short_line_counter = Counter()
+        for ln in all_lines:
+            if len(ln["text"]) <= _HEADER_FOOTER_MAX_LEN:
+                short_line_counter[ln["text"]] += 1
+        header_footer_set = {
+            text
+            for text, cnt in short_line_counter.items()
+            if cnt >= max(3, page_count * 0.3)
+        }
+
+        # 过滤页眉页脚
+        lines = [ln for ln in all_lines if ln["text"] not in header_footer_set]
+        if not lines:
+            lines = all_lines  # 退化:保留全部
+
+        # 3. 计算正文字号(中位数)
+        sizes = sorted(ln["size"] for ln in lines)
+        body_size = sizes[len(sizes) // 2] if sizes else 12.0
+
+        # 4. 提取标题
+        first_page_lines = [ln for ln in lines if ln["page"] == 0]
+        title = _extract_title(doc, first_page_lines)
+
+        # 5. 按章节标题分组
+        sections: list[dict] = []
+        cur_heading = ""
+        cur_lines: list[dict] = []
+
+        for ln in lines:
+            if _is_heading(ln, body_size):
+                # 保存上一章节
+                if cur_lines or cur_heading:
+                    sections.append({"heading": cur_heading, "lines": cur_lines})
+                cur_heading = ln["text"]
+                cur_lines = []
+            else:
+                cur_lines.append(ln)
+        # 末尾章节
+        if cur_lines or cur_heading:
+            sections.append({"heading": cur_heading, "lines": cur_lines})
+
+        # 无标题识别到则整体作为一个默认章节
+        if not sections:
+            sections = [{"heading": "", "lines": lines}]
+
+        # 6. 文本清洗 + 图表标题提取
+        result_sections = []
+        for sec in sections:
+            content, figure_captions = _clean_lines_to_content(sec["lines"])
+            result_sections.append(
+                {
+                    "heading": sec["heading"],
+                    "content": content,
+                    "figure_captions": figure_captions,
+                }
+            )
+
+        return {
+            "path": file_path,
+            "title": title,
+            "sections": result_sections,
+        }
+    finally:
+        doc.close()
+
+
+# ---------- 异步工具函数 ----------
+
+async def parse_pdf(file_path: str) -> dict:
+    """解析 PDF 文件,保留章节结构。
+
+    用 PyMuPDF 解析,识别章节标题、清洗文本、提取图表标题。
+    失败时返回 {"error": "..."} 不抛异常。
+    """
+    try:
+        return await asyncio.to_thread(_parse_pdf_sync, file_path)
+    except Exception as e:
+        return {"error": f"PDF 解析失败: {e}", "path": file_path}
+
+
+# ---------- 缓存函数 ----------
+
+def _parsed_cache_path(paper_id: str) -> Path:
+    """解析结果缓存路径:data/cache/parsed/{paper_id}.json"""
+    parsed_dir = settings.CACHE_DIR / "parsed"
+    parsed_dir.mkdir(parents=True, exist_ok=True)
+    return parsed_dir / f"{paper_id}.json"
+
+
+def save_parsed(paper_id: str, parsed: dict) -> Path:
+    """保存解析结果到缓存
+
+    Args:
+        paper_id: 论文内容哈希
+        parsed: parse_pdf 返回的解析结果 dict
+
+    Returns:
+        缓存文件路径
+    """
+    cache_path = _parsed_cache_path(paper_id)
+    with open(cache_path, "w", encoding="utf-8") as f:
+        json.dump(parsed, f, ensure_ascii=False, indent=2, default=str)
+    logger.info("解析结果已缓存至 %s", cache_path)
+    return cache_path
+
+
+def load_parsed(paper_id: str) -> Optional[dict]:
+    """从缓存加载解析结果,不存在返回 None"""
+    cache_path = _parsed_cache_path(paper_id)
+    if not cache_path.exists():
+        return None
+    try:
+        with open(cache_path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except (json.JSONDecodeError, OSError) as exc:
+        logger.warning("读取解析缓存 %s 失败: %s", cache_path, exc)
+        return None
+
+
+# ---------- Tool 定义 ----------
+
+_PARAMETERS = {
+    "type": "object",
+    "properties": {
+        "file_path": {
+            "type": "string",
+            "description": "PDF 文件绝对路径",
+        }
+    },
+    "required": ["file_path"],
+}
+
+parse_pdf_tool = Tool(
+    name="parse_pdf",
+    description=(
+        "步骤1:解析 PDF 论文,保留章节结构。"
+        "输入 PDF 文件路径,输出 {path, title, sections: [{heading, content, figure_captions}]}。"
+    ),
+    parameters=_PARAMETERS,
+    func=parse_pdf,
+)

+ 50 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/tools/registry.py

@@ -0,0 +1,50 @@
+"""工具注册表:组装所有 Function Calling 工具"""
+from __future__ import annotations
+
+from backend.tools.base import ToolRegistry
+
+
+def build_default_registry() -> ToolRegistry:
+    """构建默认工具注册表,包含全部 10 个工具"""
+    registry = ToolRegistry()
+
+    # 步骤1 解析
+    from backend.tools.scan_folder import scan_folder_tool
+    from backend.tools.parse_pdf import parse_pdf_tool
+    registry.register(scan_folder_tool)
+    registry.register(parse_pdf_tool)
+
+    # 步骤2 抽取
+    from backend.tools.extract_paper_structure import extract_paper_structure_tool
+    registry.register(extract_paper_structure_tool)
+
+    # 步骤3 索引
+    from backend.tools.build_vector_index import build_vector_index_tool
+    registry.register(build_vector_index_tool)
+
+    # 混合搜索
+    from backend.tools.hybrid_search_tool import hybrid_search_tool
+    registry.register(hybrid_search_tool)
+
+    # 步骤4 Gap
+    from backend.tools.analyze_gaps import analyze_gaps_tool
+    registry.register(analyze_gaps_tool)
+
+    # 步骤5 创新
+    from backend.tools.generate_innovations import generate_innovations_tool
+    registry.register(generate_innovations_tool)
+
+    # 步骤6 实验
+    from backend.tools.design_experiments import design_experiments_tool
+    registry.register(design_experiments_tool)
+
+    # 联网搜索
+    from backend.tools.web_search import web_search_tool
+    registry.register(web_search_tool)
+
+    # Memory
+    from backend.tools.memory_tools import save_memory_tool, load_memory_tool
+    registry.register(save_memory_tool)
+    registry.register(load_memory_tool)
+
+    return registry

+ 63 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/tools/scan_folder.py

@@ -0,0 +1,63 @@
+"""文件夹扫描工具:收集指定文件夹下所有 PDF 文件"""
+from __future__ import annotations
+
+import asyncio
+import os
+
+from backend.tools.base import Tool
+
+
+def _scan_folder_sync(folder_path: str) -> dict:
+    """同步遍历文件夹收集 .pdf 文件"""
+    pdf_files: list[str] = []
+    for root, _dirs, files in os.walk(folder_path):
+        for name in files:
+            if name.lower().endswith(".pdf"):
+                pdf_files.append(os.path.join(root, name))
+    # 排序保证顺序稳定
+    pdf_files.sort()
+    return {
+        "folder": folder_path,
+        "pdf_files": pdf_files,
+        "count": len(pdf_files),
+    }
+
+
+async def scan_folder(folder_path: str) -> dict:
+    """扫描文件夹,返回所有 PDF 文件路径列表。
+
+    失败时返回 {"error": "..."} 不抛异常。
+    """
+    try:
+        return await asyncio.to_thread(_scan_folder_sync, folder_path)
+    except Exception as e:
+        return {
+            "error": f"文件夹扫描失败: {e}",
+            "folder": folder_path,
+            "pdf_files": [],
+            "count": 0,
+        }
+
+
+# ---------- Tool 定义 ----------
+
+_PARAMETERS = {
+    "type": "object",
+    "properties": {
+        "folder_path": {
+            "type": "string",
+            "description": "待扫描的文件夹绝对路径",
+        }
+    },
+    "required": ["folder_path"],
+}
+
+scan_folder_tool = Tool(
+    name="scan_folder",
+    description=(
+        "扫描指定文件夹,递归收集所有 .pdf 文件路径。"
+        "返回 {folder, pdf_files, count}。"
+    ),
+    parameters=_PARAMETERS,
+    func=scan_folder,
+)

+ 134 - 0
Co-creation-projects/jphJack-PaperMindAgent/backend/tools/web_search.py

@@ -0,0 +1,134 @@
+"""联网搜索工具:DuckDuckGo HTML 搜索,用于创新点新颖性去重"""
+from __future__ import annotations
+
+import re
+from urllib.parse import parse_qs, unquote, urlparse
+
+from backend.tools.base import Tool
+
+
+# ---------- DuckDuckGo HTML 结果解析 ----------
+
+# 结果标题与链接
+_TITLE_PATTERN = re.compile(
+    r'<a[^>]*class="result__a"[^>]*href="([^"]*)"[^>]*>(.*?)</a>',
+    re.DOTALL,
+)
+# 结果摘要
+_SNIPPET_PATTERN = re.compile(
+    r'<a[^>]*class="result__snippet"[^>]*>(.*?)</a>',
+    re.DOTALL,
+)
+# HTML 标签
+_TAG_PATTERN = re.compile(r"<[^>]+>")
+
+# 常见 HTML 实体
+_HTML_ENTITIES = {
+    "&amp;": "&",
+    "&lt;": "<",
+    "&gt;": ">",
+    "&quot;": '"',
+    "&#39;": "'",
+    "&nbsp;": " ",
+}
+
+
+def _strip_html(s: str) -> str:
+    """去除 HTML 标签与实体,压缩空白"""
+    s = _TAG_PATTERN.sub("", s)
+    for entity, char in _HTML_ENTITIES.items():
+        s = s.replace(entity, char)
+    s = re.sub(r"\s+", " ", s)
+    return s.strip()
+
+
+def _extract_real_url(href: str) -> str:
+    """从 DuckDuckGo 跳转链接中提取真实 URL"""
+    if "uddg=" in href:
+        # 补全协议头以便解析(DDG 链接常以 // 开头)
+        target = href if href.startswith("http") else "https:" + href
+        parsed = urlparse(target)
+        qs = parse_qs(parsed.query)
+        if "uddg" in qs and qs["uddg"]:
+            return unquote(qs["uddg"][0])
+    return href
+
+
+def _parse_ddg_html(html: str, max_results: int) -> list[dict]:
+    """解析 DuckDuckGo HTML 结果页,提取标题、摘要、URL"""
+    titles = _TITLE_PATTERN.findall(html)
+    snippets = _SNIPPET_PATTERN.findall(html)
+
+    results: list[dict] = []
+    for i, (href, raw_title) in enumerate(titles):
+        if i >= max_results:
+            break
+        title = _strip_html(raw_title)
+        snippet = _strip_html(snippets[i]) if i < len(snippets) else ""
+        url = _extract_real_url(href)
+        if title:
+            results.append({"title": title, "snippet": snippet, "url": url})
+    return results
+
+
+# ---------- 异步工具函数 ----------
+
+async def web_search(query: str, max_results: int = 5) -> dict:
+    """DuckDuckGo 联网搜索,返回标题与摘要。
+
+    失败时降级返回空结果,不崩溃。
+
+    Returns:
+        {"query": query, "results": [{title, snippet, url}]}
+    """
+    import httpx
+    from urllib.parse import quote
+
+    try:
+        url = f"https://html.duckduckgo.com/html/?q={quote(query)}"
+        headers = {
+            "User-Agent": (
+                "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+                "AppleWebKit/537.36 (KHTML, like Gecko) "
+                "Chrome/120.0.0.0 Safari/537.36"
+            )
+        }
+        async with httpx.AsyncClient(timeout=15.0, follow_redirects=True) as client:
+            resp = await client.get(url, headers=headers)
+            resp.raise_for_status()
+            html = resp.text
+
+        results = _parse_ddg_html(html, max_results)
+        return {"query": query, "results": results}
+    except Exception as e:
+        # 降级:返回空结果,不崩溃
+        return {"query": query, "results": [], "error": f"联网搜索失败: {e}"}
+
+
+# ---------- Tool 定义 ----------
+
+_PARAMETERS = {
+    "type": "object",
+    "properties": {
+        "query": {
+            "type": "string",
+            "description": "搜索查询文本",
+        },
+        "max_results": {
+            "type": "integer",
+            "description": "最大返回结果数,默认 5",
+            "default": 5,
+        },
+    },
+    "required": ["query"],
+}
+
+web_search_tool = Tool(
+    name="web_search",
+    description=(
+        "联网搜索(DuckDuckGo),用于创新点新颖性去重。"
+        "返回 {query, results: [{title, snippet, url}]}。失败时降级返回空结果。"
+    ),
+    parameters=_PARAMETERS,
+    func=web_search,
+)

+ 51 - 0
Co-creation-projects/jphJack-PaperMindAgent/benchmark_index.py

@@ -0,0 +1,51 @@
+"""端到端索引构建 benchmark:解析 PDF → 构建索引,带分阶段计时"""
+import asyncio
+import glob
+import logging
+import time
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+)
+
+from backend.tools.parse_pdf import parse_pdf
+from backend.tools.build_vector_index import build_vector_index
+
+
+async def main():
+    pdfs = sorted(glob.glob("data/uploads/*.pdf"))
+    if not pdfs:
+        print("没有找到 PDF")
+        return
+    pdf_path = pdfs[0]
+    print(f"\n=== 测试 PDF: {pdf_path} ===\n")
+
+    # 1. 解析 PDF
+    t0 = time.perf_counter()
+    parsed = await parse_pdf(file_path=pdf_path)
+    t_parse = time.perf_counter()
+    print(f"\n>>> parse_pdf: {t_parse - t0:.2f}s")
+    print(f"    sections: {len(parsed.get('sections', []))}")
+    total_chars = sum(len(s.get('content', '')) for s in parsed.get('sections', []))
+    print(f"    total content chars: {total_chars}")
+
+    # 2. 构建索引(带去重检查)
+    print(f"\n>>> 开始 build_vector_index...")
+    t1 = time.perf_counter()
+    result = await build_vector_index(papers_json=[parsed])
+    t_index = time.perf_counter()
+    print(f"\n>>> build_vector_index: {t_index - t1:.2f}s")
+    print(f"    result: {result}")
+
+    # 3. 第二次(测试去重是否生效)
+    print(f"\n>>> 第二次 build_vector_index(应命中去重)...")
+    t2 = time.perf_counter()
+    result2 = await build_vector_index(papers_json=[parsed])
+    t_index2 = time.perf_counter()
+    print(f"\n>>> build_vector_index (cached): {t_index2 - t2:.2f}s")
+    print(f"    result: {result2}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

+ 12 - 0
Co-creation-projects/jphJack-PaperMindAgent/frontend/index.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="zh-CN">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Paper Innovation Agent</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

+ 2901 - 0
Co-creation-projects/jphJack-PaperMindAgent/frontend/package-lock.json

@@ -0,0 +1,2901 @@
+{
+  "name": "paper-innovation-agent-frontend",
+  "version": "0.1.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "paper-innovation-agent-frontend",
+      "version": "0.1.0",
+      "dependencies": {
+        "react": "^18.3.1",
+        "react-dom": "^18.3.1",
+        "react-markdown": "^9.0.1"
+      },
+      "devDependencies": {
+        "@types/react": "^18.3.5",
+        "@types/react-dom": "^18.3.0",
+        "@vitejs/plugin-react": "^4.3.1",
+        "typescript": "^5.5.4",
+        "vite": "^5.4.2"
+      }
+    },
+    "node_modules/@babel/code-frame": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.7.tgz",
+      "integrity": "sha512-Aup7aUOfpbAUg2ROOJN6Iw5f9DMBlzu0mIkm/malLQFN/YQgO48wCj0Kxa3sEHJvPVFg7siR+qRInwXd2qhQKw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-validator-identifier": "^7.29.7",
+        "js-tokens": "^4.0.0",
+        "picocolors": "^1.1.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/compat-data": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.7.tgz",
+      "integrity": "sha512-locTkQyKvwIEgBzVrn8693ebc97F2U8ZHjbXwDXJ5Fn2TCpNwTlKcaKLkdHop5c/icOFE7qt7Q9JC5hnKNa6Gg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/core": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.7.tgz",
+      "integrity": "sha512-RgHBCvtjbOK2gXSNBNIkNoEc9qoVEtau3hj8gEqKQuL3HZAibKarWFEI3Lfm6EYKkLalOh8eSrj9b+ch9H/VBA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.29.7",
+        "@babel/generator": "^7.29.7",
+        "@babel/helper-compilation-targets": "^7.29.7",
+        "@babel/helper-module-transforms": "^7.29.7",
+        "@babel/helpers": "^7.29.7",
+        "@babel/parser": "^7.29.7",
+        "@babel/template": "^7.29.7",
+        "@babel/traverse": "^7.29.7",
+        "@babel/types": "^7.29.7",
+        "@jridgewell/remapping": "^2.3.5",
+        "convert-source-map": "^2.0.0",
+        "debug": "^4.1.0",
+        "gensync": "^1.0.0-beta.2",
+        "json5": "^2.2.3",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/babel"
+      }
+    },
+    "node_modules/@babel/generator": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.7.tgz",
+      "integrity": "sha512-DkXD5OJQaAQIdZ1bt3UZdEnHAn9Imd3IVBdX03UFe+ony9Ojw5pzr9YVKGDY1jt+Gcn/FnGkNf8r+Vj5NOJWtQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.29.7",
+        "@babel/types": "^7.29.7",
+        "@jridgewell/gen-mapping": "^0.3.12",
+        "@jridgewell/trace-mapping": "^0.3.28",
+        "jsesc": "^3.0.2"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-compilation-targets": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.29.7.tgz",
+      "integrity": "sha512-wem6WaBj4NaVYVdNhLPPVacES6ZJ+KBBfSkTMD3YZxbP3rm3Di85tJU5ljaUNhaOynt+Aj0xruhYuzQBt8n71g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/compat-data": "^7.29.7",
+        "@babel/helper-validator-option": "^7.29.7",
+        "browserslist": "^4.24.0",
+        "lru-cache": "^5.1.1",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-globals": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.29.7.tgz",
+      "integrity": "sha512-3nQVUAtvkKH9zahfWgw96Jc/uFOmjACE1kQz82E2lqWmHBgjzbNlsC22nuQTfahmWeQtTq5nQ/4Nnd2A1wj4zA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-module-imports": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.29.7.tgz",
+      "integrity": "sha512-ejHwrQQYcm9xnTivShn2IDOlIzInN34AXskvq9QicvCtEzq1Vzclu/tKF8Jq1Cg8JG2GL6/EmjgsCT7lXepE3g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/traverse": "^7.29.7",
+        "@babel/types": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-module-transforms": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.29.7.tgz",
+      "integrity": "sha512-UPUVSyXbOh627KiCIGQSgwWzGeBKLkaJ9PJEdrngIwMSzxLR4jS4+f1f1jb7VzBbg8nFLaYotvVPFCTqdrmTAg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-module-imports": "^7.29.7",
+        "@babel/helper-validator-identifier": "^7.29.7",
+        "@babel/traverse": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/helper-plugin-utils": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.29.7.tgz",
+      "integrity": "sha512-G7sHYigPY17oO5SYWnfD/0MTBwVR781S/JI643e/JhUYgVgWE/61SoW3NH9KWUKyKq5LVh3npif99Wkt6j86Jw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-string-parser": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.29.7.tgz",
+      "integrity": "sha512-Pb5ijPrZ89GDH8223L4UP8i6QApWxs04RbPQJTeWDV0/keR2E36MeKnyr6LYmUUvqRRI+Iv87SuF1W6ErINzYw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-identifier": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.29.7.tgz",
+      "integrity": "sha512-qehxGkRj55h/ff8EMaJ+cYhyaKlHIxqYDn682wQD7RNp9UujOQsHog2uS0r2vzr4pW+sXf90NeeayjcNaX3fFg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-option": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.29.7.tgz",
+      "integrity": "sha512-N9ZErrD+yW5geCDtBqnOoxmR8+tNKiGuxKlDpuJxfsqpa2dFcexaziGAE/qoHLiDDreVNMupxGmSoNlyvsA3gw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helpers": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.29.7.tgz",
+      "integrity": "sha512-1k2lAGRMfHTcwuNYcCNUmaUffmQv8KWMfh2iJUUeRlwlwH4FdNG7mfPI10NPfLHJFThE4Tyr4mv7kTNZOiPuBg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/template": "^7.29.7",
+        "@babel/types": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/parser": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.7.tgz",
+      "integrity": "sha512-hnORnjP/1P/zFEndoeX+n+t1RwWRJiJpM/jO7FW32Kn9r5+sJB2JWOdYo4L6k78j15eCwY3Gm/7364B1EMwtNg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.29.7"
+      },
+      "bin": {
+        "parser": "bin/babel-parser.js"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-react-jsx-self": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-self/-/plugin-transform-react-jsx-self-7.29.7.tgz",
+      "integrity": "sha512-TL0hMc9xzy86VD31nUiwzd5otRAcyEPcsegCxolO0PvcXuH1v0kECe/UIznYFihpkvU5wg/jk4v0TTEFfm53fw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-react-jsx-source": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-source/-/plugin-transform-react-jsx-source-7.29.7.tgz",
+      "integrity": "sha512-06IyK09H3wi4cGbhDBwp5gUGo0IKtnYa8tyTiephirPCK6fbobVGiXMMI5zLQ4aKEYP3wZ3ArU44o+8KMrSG/Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/template": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.29.7.tgz",
+      "integrity": "sha512-puq+Gf35oI24FeN11LkoUQFqv9uwNeWpxXZi/Ji3rRIoKAzKnxRaZ+Gkj0vKS9ZCiTESfng1N9LyOyXvo+m+Gg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.29.7",
+        "@babel/parser": "^7.29.7",
+        "@babel/types": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/traverse": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.7.tgz",
+      "integrity": "sha512-EhlfNQtZ+NK22w5BM61ciuiq1m58ed33Wr1Xan//ZRTy6hgjnwyCffRYwzsGXdASJSUJ1guZILsErh1eQcl+zw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.29.7",
+        "@babel/generator": "^7.29.7",
+        "@babel/helper-globals": "^7.29.7",
+        "@babel/parser": "^7.29.7",
+        "@babel/template": "^7.29.7",
+        "@babel/types": "^7.29.7",
+        "debug": "^4.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/types": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.7.tgz",
+      "integrity": "sha512-4zBIxpPzowiZpusoFkyGVwakdRJUyuH5PxQ/PrqghfdFWWasvnCdPfQXHrenDai+gyLARulZjZowCOj6fjT4pA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-string-parser": "^7.29.7",
+        "@babel/helper-validator-identifier": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz",
+      "integrity": "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.5.tgz",
+      "integrity": "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz",
+      "integrity": "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.5.tgz",
+      "integrity": "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz",
+      "integrity": "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz",
+      "integrity": "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz",
+      "integrity": "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz",
+      "integrity": "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz",
+      "integrity": "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz",
+      "integrity": "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz",
+      "integrity": "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz",
+      "integrity": "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz",
+      "integrity": "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz",
+      "integrity": "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz",
+      "integrity": "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz",
+      "integrity": "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz",
+      "integrity": "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz",
+      "integrity": "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz",
+      "integrity": "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz",
+      "integrity": "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz",
+      "integrity": "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz",
+      "integrity": "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz",
+      "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@jridgewell/gen-mapping": {
+      "version": "0.3.13",
+      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
+      "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.0",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/remapping": {
+      "version": "2.3.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz",
+      "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/gen-mapping": "^0.3.5",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/resolve-uri": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.5.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@jridgewell/trace-mapping": {
+      "version": "0.3.31",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
+      "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/resolve-uri": "^3.1.0",
+        "@jridgewell/sourcemap-codec": "^1.4.14"
+      }
+    },
+    "node_modules/@rolldown/pluginutils": {
+      "version": "1.0.0-beta.27",
+      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.27.tgz",
+      "integrity": "sha512-+d0F4MKMCbeVUJwG96uQ4SgAznZNSq93I3V+9NHA4OpvqG8mRCpGdKmK8l/dl02h2CCDHwW2FqilnTyDcAnqjA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.62.2.tgz",
+      "integrity": "sha512-6o7ZLZK+BeenkZCFNDXqpbjw9bD6nuWonvS/lwQJp7NoVVxm6p3qE7qQ5jGuBjiFsgvqjD8mZAU5oWxTmbOeOg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.62.2.tgz",
+      "integrity": "sha512-BaH7BllCACHoH1LguOU56UItGfUWjujlO65kS9LAodViaN4bwIKd7oeW/ZHJ/4ljr/7MIiENnNy3HJ0zXv8Zkw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.62.2.tgz",
+      "integrity": "sha512-v39RCCvj4He82I9sFmk+M1VZ0PLM9sfsLVikjfx2hYBNALhrrOR2D3JjQA6AhlaSOgcR+RzrKY7e1+bT6SUO/A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.62.2.tgz",
+      "integrity": "sha512-yl0y2vq3S3lHeuXhEdss6TWfKW8vkujImO12tn4ZkG/4oghr09LvdYm2RElVjokTQiUvDUGXLGsYeLqUMCKpGA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-arm64": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.62.2.tgz",
+      "integrity": "sha512-tT4pvt4qXD+vEoezupCWi+a1F0vvDiksiHc+PxRlYTOH1I6/X4id9jPxTP+Fg+545euaFT1jJVs4CEdHZAU1vw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-x64": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.62.2.tgz",
+      "integrity": "sha512-6nU5F2wCW+qvCBhTn1pdIU3bzsIoF7EUwsCDRxilWGprQR6yd508YnH9+OKFCwpfS8pjZqDUmnCAr7exax0XCg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.62.2.tgz",
+      "integrity": "sha512-n1GJHPOvpIfhi3TmrCeh6S6URt9BFCt0KQE3qvexyGCTAKpR4Lg+eWvNZEqu7epxwus/8ElT3hacYEucm49SZg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.62.2.tgz",
+      "integrity": "sha512-JqgflS8wEB+UXV/vS1RpRbifGBeN4D5lz8D8oOFbFZw4vedvdOgCFAjfBmIMdW3yL10XpQQ0Ambepw6MXrhOnA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.62.2.tgz",
+      "integrity": "sha512-wnFJkogWvN4jm/hQRF2UBaeUmk20j5+DmHvoyWii2b8HJDyvz1MF2OU/6ynXt2KR63rbZLWkFpoytpdc/yBuSA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.62.2.tgz",
+      "integrity": "sha512-HVu2bp0zhvJ8xHEV9+UUs7S90VadmBSY3LcIMvozbPo4AuMGDWlz3ymHLHZPX4hR67TKTt8Qp5PJ5RBg/i+RMQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-gnu": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.62.2.tgz",
+      "integrity": "sha512-mQqqAV8QaoSgr9I2fKDLY2BAVvmKjWoGiu/cSYQonsLvtqwEn1E4QYfnCOcp5zoEqNhsDYin1s6jx/VJmrxlZg==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-musl": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.62.2.tgz",
+      "integrity": "sha512-IxKLoxCQ2IWi6bT2akyDUBGsOImDKB+sPp4EsTmwFQ/fMwpCKm8uLSSgP/Kx/QYUgKis6SEZ5/Nlhup0DIA0PQ==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-gnu": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.62.2.tgz",
+      "integrity": "sha512-Mk5ha2RQSgyFfmYYLkBpPnUk8D8FriBxesO1u9O75X0mHgXL1UQcH5Itl2lurWL2tj0RxV9b9tJgipac0hRY9A==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-musl": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.62.2.tgz",
+      "integrity": "sha512-CjvEnqJL/0/TQ3TXX3OPIJ/kmBellrWd4heXUmHeJlTnmwjKpSJzoehLaL6Xk0ZnMHBu9dZuFADNOrtjF4v+2w==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.62.2.tgz",
+      "integrity": "sha512-1SiZbzwdkaDURsew/tSOrooKiYy7EQGT6m8ufavAi9NEyQb/6VuIxFXAL1fqa4iZe3g4NbNk4P7J32z2tw5Mgg==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-musl": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.62.2.tgz",
+      "integrity": "sha512-nQts12zJ3NQRoE6uYljOH89v7szzLDvG2JD/vsX+vGXU8w/At1GowTZ5/7qeFQ8m7L55rpR8Okugnuo5bgjy2Q==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.62.2.tgz",
+      "integrity": "sha512-E9/ll019jhPIJgpzfZoIkBGhcz+kKNgVWYRY0zr9srBdPPFVpvOKW8VaJKUbeK+eZXyQF9ltME+Kk6affeaPgg==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.62.2.tgz",
+      "integrity": "sha512-5BqxR/pshjey51iliyzTD5Xi3EN0aLmQ2lZ3lvefVV9c82BvrLo2/6OT55iifpWBufs6kdwWbuOKS841DrmK9A==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.62.2.tgz",
+      "integrity": "sha512-uNN83XxQrRAh/w0/pmAfibcwyb6YWt4gP+dpnQKPVJshAloQ785ii8CT8ZCIxkGg9opVsvAlGhFitSm6D1Jjpg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-openbsd-x64": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.62.2.tgz",
+      "integrity": "sha512-srjEIxSH3LRnJN6THczDHWQplqEMFiAJrTab0msUryh9kwNpkICf3Ea6q6MN/2cZwRFUNx5w+h6Hpi4QuHS6Zg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-openharmony-arm64": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.62.2.tgz",
+      "integrity": "sha512-8hOJnxgbyObnCm5AlRA3A931xX19xq80RjVTKgJOvEKWqJruP/Uf12IbAOaDjjEXYRewwHLfmF0YRIdK3OwKWA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.62.2.tgz",
+      "integrity": "sha512-mmF4AY1i0hG/bLWUctUq59gtmgaSIRa3cu/A3JFRp/sCNEme2bgDEiDS22P9FbnJB8NJNF4jPJiSP5RHQpUTDg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.62.2.tgz",
+      "integrity": "sha512-DZgkknc6jhHrk46V25vbAM0zZkyP0nSDkJB8/dRkLTxv470dOmWDqGoEJl/9A0dFfS7yE3REOwNDxpHwSLSt0Q==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-gnu": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.62.2.tgz",
+      "integrity": "sha512-T6xr6ucWSFto+VGajA8YH26LdpHRuP4YLHEKAtCWvJDOlnmWcDZVCI2Jmjr+IFHDlt2zRaTAKE4tfjTaWLgJBg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.62.2.tgz",
+      "integrity": "sha512-BfzEnDJOt9T8M989/lA37EcJgat01wLRnoi5dQf3QzOH7jzpqTAzdDbVfRljVr5r+jzKqpbHeyOfAaXxAd0PAA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@types/babel__core": {
+      "version": "7.20.5",
+      "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz",
+      "integrity": "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.20.7",
+        "@babel/types": "^7.20.7",
+        "@types/babel__generator": "*",
+        "@types/babel__template": "*",
+        "@types/babel__traverse": "*"
+      }
+    },
+    "node_modules/@types/babel__generator": {
+      "version": "7.27.0",
+      "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.27.0.tgz",
+      "integrity": "sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.0.0"
+      }
+    },
+    "node_modules/@types/babel__template": {
+      "version": "7.4.4",
+      "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.4.tgz",
+      "integrity": "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.1.0",
+        "@babel/types": "^7.0.0"
+      }
+    },
+    "node_modules/@types/babel__traverse": {
+      "version": "7.28.0",
+      "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.28.0.tgz",
+      "integrity": "sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.28.2"
+      }
+    },
+    "node_modules/@types/debug": {
+      "version": "4.1.13",
+      "resolved": "https://registry.npmjs.org/@types/debug/-/debug-4.1.13.tgz",
+      "integrity": "sha512-KSVgmQmzMwPlmtljOomayoR89W4FynCAi3E8PPs7vmDVPe84hT+vGPKkJfThkmXs0x0jAaa9U8uW8bbfyS2fWw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/ms": "*"
+      }
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.9",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.9.tgz",
+      "integrity": "sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==",
+      "license": "MIT"
+    },
+    "node_modules/@types/estree-jsx": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/@types/estree-jsx/-/estree-jsx-1.0.5.tgz",
+      "integrity": "sha512-52CcUVNFyfb1A2ALocQw/Dd1BQFNmSdkuC3BkZ6iqhdMfQz7JWOFRuJFloOzjk+6WijU56m9oKXFAXc7o3Towg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "*"
+      }
+    },
+    "node_modules/@types/hast": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/@types/hast/-/hast-3.0.4.tgz",
+      "integrity": "sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "*"
+      }
+    },
+    "node_modules/@types/mdast": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-4.0.4.tgz",
+      "integrity": "sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "*"
+      }
+    },
+    "node_modules/@types/ms": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/@types/ms/-/ms-2.1.0.tgz",
+      "integrity": "sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA==",
+      "license": "MIT"
+    },
+    "node_modules/@types/prop-types": {
+      "version": "15.7.15",
+      "resolved": "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.15.tgz",
+      "integrity": "sha512-F6bEyamV9jKGAFBEmlQnesRPGOQqS2+Uwi0Em15xenOxHaf2hv6L8YCVn3rPdPJOiJfPiCnLIRyvwVaqMY3MIw==",
+      "license": "MIT"
+    },
+    "node_modules/@types/react": {
+      "version": "18.3.31",
+      "resolved": "https://registry.npmjs.org/@types/react/-/react-18.3.31.tgz",
+      "integrity": "sha512-vfEqpXTvwT91yhmwdfouStN2hSKwTvyRs8qpLfADyrq/kxDw0hZM7Wk9Ug1FELj8hIby+S/+kQCSRFF32nv2Qw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/prop-types": "*",
+        "csstype": "^3.2.2"
+      }
+    },
+    "node_modules/@types/react-dom": {
+      "version": "18.3.7",
+      "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-18.3.7.tgz",
+      "integrity": "sha512-MEe3UeoENYVFXzoXEWsvcpg6ZvlrFNlOQ7EOsvhI3CfAXwzPfO8Qwuxd40nepsYKqyyVQnTdEfv68q91yLcKrQ==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "@types/react": "^18.0.0"
+      }
+    },
+    "node_modules/@types/unist": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz",
+      "integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==",
+      "license": "MIT"
+    },
+    "node_modules/@ungap/structured-clone": {
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.3.1.tgz",
+      "integrity": "sha512-mUFwbeTqrVgDQxFveS+df2yfap6iuP20NAKAsBt5jDEoOTDew+zwLAOilHCeQJOVSvmgCX4ogqIrA0mnyr08yQ==",
+      "license": "ISC"
+    },
+    "node_modules/@vitejs/plugin-react": {
+      "version": "4.7.0",
+      "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-4.7.0.tgz",
+      "integrity": "sha512-gUu9hwfWvvEDBBmgtAowQCojwZmJ5mcLn3aufeCsitijs3+f2NsrPtlAWIR6OPiqljl96GVCUbLe0HyqIpVaoA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/core": "^7.28.0",
+        "@babel/plugin-transform-react-jsx-self": "^7.27.1",
+        "@babel/plugin-transform-react-jsx-source": "^7.27.1",
+        "@rolldown/pluginutils": "1.0.0-beta.27",
+        "@types/babel__core": "^7.20.5",
+        "react-refresh": "^0.17.0"
+      },
+      "engines": {
+        "node": "^14.18.0 || >=16.0.0"
+      },
+      "peerDependencies": {
+        "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0"
+      }
+    },
+    "node_modules/bail": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/bail/-/bail-2.0.2.tgz",
+      "integrity": "sha512-0xO6mYd7JB2YesxDKplafRpsiOzPt9V02ddPCLbY1xYGPOX24NTyN50qnUxgCPcSoYMhKpAuBTjQoRZCAkUDRw==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/baseline-browser-mapping": {
+      "version": "2.10.38",
+      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.38.tgz",
+      "integrity": "sha512-31/02mVB4yuQU6adKk5SlY6m+mxDwUq5KZkyYgnLrrKl7TEm1+3PyDtDBz2kOv/wxZz41GHsvV1A/u6RmiyBvw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "baseline-browser-mapping": "dist/cli.cjs"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/browserslist": {
+      "version": "4.28.4",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.4.tgz",
+      "integrity": "sha512-MTc8i/x9jBQd1iMw2CFGS+rwMa07eYjLR0CCTLDACl9xhxy+nIs3KeML/biicXtk9JrZ6dnnTatmc7ErPXIxqw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "baseline-browser-mapping": "^2.10.38",
+        "caniuse-lite": "^1.0.30001799",
+        "electron-to-chromium": "^1.5.376",
+        "node-releases": "^2.0.48",
+        "update-browserslist-db": "^1.2.3"
+      },
+      "bin": {
+        "browserslist": "cli.js"
+      },
+      "engines": {
+        "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
+      }
+    },
+    "node_modules/caniuse-lite": {
+      "version": "1.0.30001799",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001799.tgz",
+      "integrity": "sha512-hG1bReV+OUU+MOqK4t/ZWI0tZOyz3rqS9XuhOUz1cIcbwBKjOyJEJuw9ER5JuNyqxNk8u/JUVbGibBOL1yrjFw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/caniuse-lite"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "CC-BY-4.0"
+    },
+    "node_modules/ccount": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/ccount/-/ccount-2.0.1.tgz",
+      "integrity": "sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/character-entities": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/character-entities/-/character-entities-2.0.2.tgz",
+      "integrity": "sha512-shx7oQ0Awen/BRIdkjkvz54PnEEI/EjwXDSIZp86/KKdbafHh1Df/RYGBhn4hbe2+uKC9FnT5UCEdyPz3ai9hQ==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/character-entities-html4": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/character-entities-html4/-/character-entities-html4-2.1.0.tgz",
+      "integrity": "sha512-1v7fgQRj6hnSwFpq1Eu0ynr/CDEw0rXo2B61qXrLNdHZmPKgb7fqS1a2JwF0rISo9q77jDI8VMEHoApn8qDoZA==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/character-entities-legacy": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/character-entities-legacy/-/character-entities-legacy-3.0.0.tgz",
+      "integrity": "sha512-RpPp0asT/6ufRm//AJVwpViZbGM/MkjQFxJccQRHmISF/22NBtsHqAWmL+/pmkPWoIUJdWyeVleTl1wydHATVQ==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/character-reference-invalid": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/character-reference-invalid/-/character-reference-invalid-2.0.1.tgz",
+      "integrity": "sha512-iBZ4F4wRbyORVsu0jPV7gXkOsGYjGHPmAyv+HiHG8gi5PtC9KI2j1+v8/tlibRvjoWX027ypmG/n0HtO5t7unw==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/comma-separated-tokens": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/comma-separated-tokens/-/comma-separated-tokens-2.0.3.tgz",
+      "integrity": "sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/convert-source-map": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz",
+      "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/csstype": {
+      "version": "3.2.3",
+      "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",
+      "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==",
+      "license": "MIT"
+    },
+    "node_modules/debug": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/decode-named-character-reference": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/decode-named-character-reference/-/decode-named-character-reference-1.3.0.tgz",
+      "integrity": "sha512-GtpQYB283KrPp6nRw50q3U9/VfOutZOe103qlN7BPP6Ad27xYnOIWv4lPzo8HCAL+mMZofJ9KEy30fq6MfaK6Q==",
+      "license": "MIT",
+      "dependencies": {
+        "character-entities": "^2.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/dequal": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/dequal/-/dequal-2.0.3.tgz",
+      "integrity": "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/devlop": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/devlop/-/devlop-1.1.0.tgz",
+      "integrity": "sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA==",
+      "license": "MIT",
+      "dependencies": {
+        "dequal": "^2.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/electron-to-chromium": {
+      "version": "1.5.376",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.376.tgz",
+      "integrity": "sha512-cUVA7/RvbFTEuw/i3obUwDTRIXojaxkResf+ibByPFxjc6XK3VNtcQXV0NSbAlJ0FMjcJGgftVVB4Qo184EXvA==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/esbuild": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz",
+      "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.21.5",
+        "@esbuild/android-arm": "0.21.5",
+        "@esbuild/android-arm64": "0.21.5",
+        "@esbuild/android-x64": "0.21.5",
+        "@esbuild/darwin-arm64": "0.21.5",
+        "@esbuild/darwin-x64": "0.21.5",
+        "@esbuild/freebsd-arm64": "0.21.5",
+        "@esbuild/freebsd-x64": "0.21.5",
+        "@esbuild/linux-arm": "0.21.5",
+        "@esbuild/linux-arm64": "0.21.5",
+        "@esbuild/linux-ia32": "0.21.5",
+        "@esbuild/linux-loong64": "0.21.5",
+        "@esbuild/linux-mips64el": "0.21.5",
+        "@esbuild/linux-ppc64": "0.21.5",
+        "@esbuild/linux-riscv64": "0.21.5",
+        "@esbuild/linux-s390x": "0.21.5",
+        "@esbuild/linux-x64": "0.21.5",
+        "@esbuild/netbsd-x64": "0.21.5",
+        "@esbuild/openbsd-x64": "0.21.5",
+        "@esbuild/sunos-x64": "0.21.5",
+        "@esbuild/win32-arm64": "0.21.5",
+        "@esbuild/win32-ia32": "0.21.5",
+        "@esbuild/win32-x64": "0.21.5"
+      }
+    },
+    "node_modules/escalade": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/estree-util-is-identifier-name": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/estree-util-is-identifier-name/-/estree-util-is-identifier-name-3.0.0.tgz",
+      "integrity": "sha512-hFtqIDZTIUZ9BXLb8y4pYGyk6+wekIivNVTcmvk8NoOh+VeRn5y6cEHzbURrWbfp1fIqdVipilzj+lfaadNZmg==",
+      "license": "MIT",
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/extend": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz",
+      "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==",
+      "license": "MIT"
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/gensync": {
+      "version": "1.0.0-beta.2",
+      "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz",
+      "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/hast-util-to-jsx-runtime": {
+      "version": "2.3.6",
+      "resolved": "https://registry.npmjs.org/hast-util-to-jsx-runtime/-/hast-util-to-jsx-runtime-2.3.6.tgz",
+      "integrity": "sha512-zl6s8LwNyo1P9uw+XJGvZtdFF1GdAkOg8ujOw+4Pyb76874fLps4ueHXDhXWdk6YHQ6OgUtinliG7RsYvCbbBg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "^1.0.0",
+        "@types/hast": "^3.0.0",
+        "@types/unist": "^3.0.0",
+        "comma-separated-tokens": "^2.0.0",
+        "devlop": "^1.0.0",
+        "estree-util-is-identifier-name": "^3.0.0",
+        "hast-util-whitespace": "^3.0.0",
+        "mdast-util-mdx-expression": "^2.0.0",
+        "mdast-util-mdx-jsx": "^3.0.0",
+        "mdast-util-mdxjs-esm": "^2.0.0",
+        "property-information": "^7.0.0",
+        "space-separated-tokens": "^2.0.0",
+        "style-to-js": "^1.0.0",
+        "unist-util-position": "^5.0.0",
+        "vfile-message": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/hast-util-whitespace": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/hast-util-whitespace/-/hast-util-whitespace-3.0.0.tgz",
+      "integrity": "sha512-88JUN06ipLwsnv+dVn+OIYOvAuvBMy/Qoi6O7mQHxdPXpjy+Cd6xRkWwux7DKO+4sYILtLBRIKgsdpS2gQc7qw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/hast": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/html-url-attributes": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/html-url-attributes/-/html-url-attributes-3.0.1.tgz",
+      "integrity": "sha512-ol6UPyBWqsrO6EJySPz2O7ZSr856WDrEzM5zMqp+FJJLGMW35cLYmmZnl0vztAZxRUoNZJFTCohfjuIJ8I4QBQ==",
+      "license": "MIT",
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/inline-style-parser": {
+      "version": "0.2.7",
+      "resolved": "https://registry.npmjs.org/inline-style-parser/-/inline-style-parser-0.2.7.tgz",
+      "integrity": "sha512-Nb2ctOyNR8DqQoR0OwRG95uNWIC0C1lCgf5Naz5H6Ji72KZ8OcFZLz2P5sNgwlyoJ8Yif11oMuYs5pBQa86csA==",
+      "license": "MIT"
+    },
+    "node_modules/is-alphabetical": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/is-alphabetical/-/is-alphabetical-2.0.1.tgz",
+      "integrity": "sha512-FWyyY60MeTNyeSRpkM2Iry0G9hpr7/9kD40mD/cGQEuilcZYS4okz8SN2Q6rLCJ8gbCt6fN+rC+6tMGS99LaxQ==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/is-alphanumerical": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/is-alphanumerical/-/is-alphanumerical-2.0.1.tgz",
+      "integrity": "sha512-hmbYhX/9MUMF5uh7tOXyK/n0ZvWpad5caBA17GsC6vyuCqaWliRG5K1qS9inmUhEMaOBIW7/whAnSwveW/LtZw==",
+      "license": "MIT",
+      "dependencies": {
+        "is-alphabetical": "^2.0.0",
+        "is-decimal": "^2.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/is-decimal": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/is-decimal/-/is-decimal-2.0.1.tgz",
+      "integrity": "sha512-AAB9hiomQs5DXWcRB1rqsxGUstbRroFOPPVAomNk/3XHR5JyEZChOyTWe2oayKnsSsr/kcGqF+z6yuH6HHpN0A==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/is-hexadecimal": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/is-hexadecimal/-/is-hexadecimal-2.0.1.tgz",
+      "integrity": "sha512-DgZQp241c8oO6cA1SbTEWiXeoxV42vlcJxgH+B3hi1AiqqKruZR3ZGF8In3fj4+/y/7rHvlOZLZtgJ/4ttYGZg==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/is-plain-obj": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-4.1.0.tgz",
+      "integrity": "sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/js-tokens": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+      "license": "MIT"
+    },
+    "node_modules/jsesc": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
+      "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "jsesc": "bin/jsesc"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/json5": {
+      "version": "2.2.3",
+      "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
+      "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "json5": "lib/cli.js"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/longest-streak": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/longest-streak/-/longest-streak-3.1.0.tgz",
+      "integrity": "sha512-9Ri+o0JYgehTaVBBDoMqIl8GXtbWg711O3srftcHhZ0dqnETqLaoIK0x17fUw9rFSlK/0NlsKe0Ahhyl5pXE2g==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/loose-envify": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz",
+      "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==",
+      "license": "MIT",
+      "dependencies": {
+        "js-tokens": "^3.0.0 || ^4.0.0"
+      },
+      "bin": {
+        "loose-envify": "cli.js"
+      }
+    },
+    "node_modules/lru-cache": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
+      "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "yallist": "^3.0.2"
+      }
+    },
+    "node_modules/mdast-util-from-markdown": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/mdast-util-from-markdown/-/mdast-util-from-markdown-2.0.3.tgz",
+      "integrity": "sha512-W4mAWTvSlKvf8L6J+VN9yLSqQ9AOAAvHuoDAmPkz4dHf553m5gVj2ejadHJhoJmcmxEnOv6Pa8XJhpxE93kb8Q==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/mdast": "^4.0.0",
+        "@types/unist": "^3.0.0",
+        "decode-named-character-reference": "^1.0.0",
+        "devlop": "^1.0.0",
+        "mdast-util-to-string": "^4.0.0",
+        "micromark": "^4.0.0",
+        "micromark-util-decode-numeric-character-reference": "^2.0.0",
+        "micromark-util-decode-string": "^2.0.0",
+        "micromark-util-normalize-identifier": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0",
+        "unist-util-stringify-position": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-mdx-expression": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/mdast-util-mdx-expression/-/mdast-util-mdx-expression-2.0.1.tgz",
+      "integrity": "sha512-J6f+9hUp+ldTZqKRSg7Vw5V6MqjATc+3E4gf3CFNcuZNWD8XdyI6zQ8GqH7f8169MM6P7hMBRDVGnn7oHB9kXQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree-jsx": "^1.0.0",
+        "@types/hast": "^3.0.0",
+        "@types/mdast": "^4.0.0",
+        "devlop": "^1.0.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-mdx-jsx": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-mdx-jsx/-/mdast-util-mdx-jsx-3.2.0.tgz",
+      "integrity": "sha512-lj/z8v0r6ZtsN/cGNNtemmmfoLAFZnjMbNyLzBafjzikOM+glrjNHPlf6lQDOTccj9n5b0PPihEBbhneMyGs1Q==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree-jsx": "^1.0.0",
+        "@types/hast": "^3.0.0",
+        "@types/mdast": "^4.0.0",
+        "@types/unist": "^3.0.0",
+        "ccount": "^2.0.0",
+        "devlop": "^1.1.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0",
+        "parse-entities": "^4.0.0",
+        "stringify-entities": "^4.0.0",
+        "unist-util-stringify-position": "^4.0.0",
+        "vfile-message": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-mdxjs-esm": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/mdast-util-mdxjs-esm/-/mdast-util-mdxjs-esm-2.0.1.tgz",
+      "integrity": "sha512-EcmOpxsZ96CvlP03NghtH1EsLtr0n9Tm4lPUJUBccV9RwUOneqSycg19n5HGzCf+10LozMRSObtVr3ee1WoHtg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree-jsx": "^1.0.0",
+        "@types/hast": "^3.0.0",
+        "@types/mdast": "^4.0.0",
+        "devlop": "^1.0.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-phrasing": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-phrasing/-/mdast-util-phrasing-4.1.0.tgz",
+      "integrity": "sha512-TqICwyvJJpBwvGAMZjj4J2n0X8QWp21b9l0o7eXyVJ25YNWYbJDVIyD1bZXE6WtV6RmKJVYmQAKWa0zWOABz2w==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/mdast": "^4.0.0",
+        "unist-util-is": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-to-hast": {
+      "version": "13.2.1",
+      "resolved": "https://registry.npmjs.org/mdast-util-to-hast/-/mdast-util-to-hast-13.2.1.tgz",
+      "integrity": "sha512-cctsq2wp5vTsLIcaymblUriiTcZd0CwWtCbLvrOzYCDZoWyMNV8sZ7krj09FSnsiJi3WVsHLM4k6Dq/yaPyCXA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/hast": "^3.0.0",
+        "@types/mdast": "^4.0.0",
+        "@ungap/structured-clone": "^1.0.0",
+        "devlop": "^1.0.0",
+        "micromark-util-sanitize-uri": "^2.0.0",
+        "trim-lines": "^3.0.0",
+        "unist-util-position": "^5.0.0",
+        "unist-util-visit": "^5.0.0",
+        "vfile": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-to-markdown": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/mdast-util-to-markdown/-/mdast-util-to-markdown-2.1.2.tgz",
+      "integrity": "sha512-xj68wMTvGXVOKonmog6LwyJKrYXZPvlwabaryTjLh9LuvovB/KAH+kvi8Gjj+7rJjsFi23nkUxRQv1KqSroMqA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/mdast": "^4.0.0",
+        "@types/unist": "^3.0.0",
+        "longest-streak": "^3.0.0",
+        "mdast-util-phrasing": "^4.0.0",
+        "mdast-util-to-string": "^4.0.0",
+        "micromark-util-classify-character": "^2.0.0",
+        "micromark-util-decode-string": "^2.0.0",
+        "unist-util-visit": "^5.0.0",
+        "zwitch": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-to-string": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-to-string/-/mdast-util-to-string-4.0.0.tgz",
+      "integrity": "sha512-0H44vDimn51F0YwvxSJSm0eCDOJTRlmN0R1yBh4HLj9wiV1Dn0QoXGbvFAWj2hSItVTlCmBF1hqKlIyUBVFLPg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/mdast": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/micromark": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/micromark/-/micromark-4.0.2.tgz",
+      "integrity": "sha512-zpe98Q6kvavpCr1NPVSCMebCKfD7CA2NqZ+rykeNhONIJBpc1tFKt9hucLGwha3jNTNI8lHpctWJWoimVF4PfA==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "@types/debug": "^4.0.0",
+        "debug": "^4.0.0",
+        "decode-named-character-reference": "^1.0.0",
+        "devlop": "^1.0.0",
+        "micromark-core-commonmark": "^2.0.0",
+        "micromark-factory-space": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-chunked": "^2.0.0",
+        "micromark-util-combine-extensions": "^2.0.0",
+        "micromark-util-decode-numeric-character-reference": "^2.0.0",
+        "micromark-util-encode": "^2.0.0",
+        "micromark-util-normalize-identifier": "^2.0.0",
+        "micromark-util-resolve-all": "^2.0.0",
+        "micromark-util-sanitize-uri": "^2.0.0",
+        "micromark-util-subtokenize": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-core-commonmark": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/micromark-core-commonmark/-/micromark-core-commonmark-2.0.3.tgz",
+      "integrity": "sha512-RDBrHEMSxVFLg6xvnXmb1Ayr2WzLAWjeSATAoxwKYJV94TeNavgoIdA0a9ytzDSVzBy2YKFK+emCPOEibLeCrg==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "decode-named-character-reference": "^1.0.0",
+        "devlop": "^1.0.0",
+        "micromark-factory-destination": "^2.0.0",
+        "micromark-factory-label": "^2.0.0",
+        "micromark-factory-space": "^2.0.0",
+        "micromark-factory-title": "^2.0.0",
+        "micromark-factory-whitespace": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-chunked": "^2.0.0",
+        "micromark-util-classify-character": "^2.0.0",
+        "micromark-util-html-tag-name": "^2.0.0",
+        "micromark-util-normalize-identifier": "^2.0.0",
+        "micromark-util-resolve-all": "^2.0.0",
+        "micromark-util-subtokenize": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-factory-destination": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-factory-destination/-/micromark-factory-destination-2.0.1.tgz",
+      "integrity": "sha512-Xe6rDdJlkmbFRExpTOmRj9N3MaWmbAgdpSrBQvCFqhezUn4AHqJHbaEnfbVYYiexVSs//tqOdY/DxhjdCiJnIA==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-factory-label": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-factory-label/-/micromark-factory-label-2.0.1.tgz",
+      "integrity": "sha512-VFMekyQExqIW7xIChcXn4ok29YE3rnuyveW3wZQWWqF4Nv9Wk5rgJ99KzPvHjkmPXF93FXIbBp6YdW3t71/7Vg==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "devlop": "^1.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-factory-space": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-factory-space/-/micromark-factory-space-2.0.1.tgz",
+      "integrity": "sha512-zRkxjtBxxLd2Sc0d+fbnEunsTj46SWXgXciZmHq0kDYGnck/ZSGj9/wULTV95uoeYiK5hRXP2mJ98Uo4cq/LQg==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-factory-title": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-factory-title/-/micromark-factory-title-2.0.1.tgz",
+      "integrity": "sha512-5bZ+3CjhAd9eChYTHsjy6TGxpOFSKgKKJPJxr293jTbfry2KDoWkhBb6TcPVB4NmzaPhMs1Frm9AZH7OD4Cjzw==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-factory-space": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-factory-whitespace": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-factory-whitespace/-/micromark-factory-whitespace-2.0.1.tgz",
+      "integrity": "sha512-Ob0nuZ3PKt/n0hORHyvoD9uZhr+Za8sFoP+OnMcnWK5lngSzALgQYKMr9RJVOWLqQYuyn6ulqGWSXdwf6F80lQ==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-factory-space": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-character": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-2.1.1.tgz",
+      "integrity": "sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-chunked": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-chunked/-/micromark-util-chunked-2.0.1.tgz",
+      "integrity": "sha512-QUNFEOPELfmvv+4xiNg2sRYeS/P84pTW0TCgP5zc9FpXetHY0ab7SxKyAQCNCc1eK0459uoLI1y5oO5Vc1dbhA==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-symbol": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-classify-character": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-classify-character/-/micromark-util-classify-character-2.0.1.tgz",
+      "integrity": "sha512-K0kHzM6afW/MbeWYWLjoHQv1sgg2Q9EccHEDzSkxiP/EaagNzCm7T/WMKZ3rjMbvIpvBiZgwR3dKMygtA4mG1Q==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-combine-extensions": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-combine-extensions/-/micromark-util-combine-extensions-2.0.1.tgz",
+      "integrity": "sha512-OnAnH8Ujmy59JcyZw8JSbK9cGpdVY44NKgSM7E9Eh7DiLS2E9RNQf0dONaGDzEG9yjEl5hcqeIsj4hfRkLH/Bg==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-chunked": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-decode-numeric-character-reference": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/micromark-util-decode-numeric-character-reference/-/micromark-util-decode-numeric-character-reference-2.0.2.tgz",
+      "integrity": "sha512-ccUbYk6CwVdkmCQMyr64dXz42EfHGkPQlBj5p7YVGzq8I7CtjXZJrubAYezf7Rp+bjPseiROqe7G6foFd+lEuw==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-symbol": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-decode-string": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-decode-string/-/micromark-util-decode-string-2.0.1.tgz",
+      "integrity": "sha512-nDV/77Fj6eH1ynwscYTOsbK7rR//Uj0bZXBwJZRfaLEJ1iGBR6kIfNmlNqaqJf649EP0F3NWNdeJi03elllNUQ==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "decode-named-character-reference": "^1.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-decode-numeric-character-reference": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-encode": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-encode/-/micromark-util-encode-2.0.1.tgz",
+      "integrity": "sha512-c3cVx2y4KqUnwopcO9b/SCdo2O67LwJJ/UyqGfbigahfegL9myoEFoDYZgkT7f36T0bLrM9hZTAaAyH+PCAXjw==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/micromark-util-html-tag-name": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-html-tag-name/-/micromark-util-html-tag-name-2.0.1.tgz",
+      "integrity": "sha512-2cNEiYDhCWKI+Gs9T0Tiysk136SnR13hhO8yW6BGNyhOC4qYFnwF1nKfD3HFAIXA5c45RrIG1ub11GiXeYd1xA==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/micromark-util-normalize-identifier": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-normalize-identifier/-/micromark-util-normalize-identifier-2.0.1.tgz",
+      "integrity": "sha512-sxPqmo70LyARJs0w2UclACPUUEqltCkJ6PhKdMIDuJ3gSf/Q+/GIe3WKl0Ijb/GyH9lOpUkRAO2wp0GVkLvS9Q==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-symbol": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-resolve-all": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-resolve-all/-/micromark-util-resolve-all-2.0.1.tgz",
+      "integrity": "sha512-VdQyxFWFT2/FGJgwQnJYbe1jjQoNTS4RjglmSjTUlpUMa95Htx9NHeYW4rGDJzbjvCsl9eLjMQwGeElsqmzcHg==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-sanitize-uri": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-sanitize-uri/-/micromark-util-sanitize-uri-2.0.1.tgz",
+      "integrity": "sha512-9N9IomZ/YuGGZZmQec1MbgxtlgougxTodVwDzzEouPKo3qFWvymFHWcnDi2vzV1ff6kas9ucW+o3yzJK9YB1AQ==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-encode": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-subtokenize": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/micromark-util-subtokenize/-/micromark-util-subtokenize-2.1.0.tgz",
+      "integrity": "sha512-XQLu552iSctvnEcgXw6+Sx75GflAPNED1qx7eBJ+wydBb2KCbRZe+NwvIEEMM83uml1+2WSXpBAcp9IUCgCYWA==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "devlop": "^1.0.0",
+        "micromark-util-chunked": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-symbol": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz",
+      "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/micromark-util-types": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/micromark-util-types/-/micromark-util-types-2.0.2.tgz",
+      "integrity": "sha512-Yw0ECSpJoViF1qTU4DC6NwtC4aWGt1EkzaQB8KPPyCRR8z9TWeV0HbEFGTO+ZY1wB22zmxnJqhPyTpOVCpeHTA==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.15",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.15.tgz",
+      "integrity": "sha512-y7Wygv/7mEOvxTuEQDB8StXdMRBWf1kR/tlhAzBRUFkB2jfcLOAxO/SHmOO2zgz1pVgK29/kyupn059/bCHdjA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/node-releases": {
+      "version": "2.0.48",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.48.tgz",
+      "integrity": "sha512-1uz8041X6LoI6ZSdZacM9lVY28vuzDlSKitnpbSNK0RfKoIJkX29NBPVEFXhnuSuEOA9Ww0xnPJ+ILWbGAv8DA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/parse-entities": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/parse-entities/-/parse-entities-4.0.2.tgz",
+      "integrity": "sha512-GG2AQYWoLgL877gQIKeRPGO1xF9+eG1ujIb5soS5gPvLQ1y2o8FL90w2QWNdf9I361Mpp7726c+lj3U0qK1uGw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "character-entities-legacy": "^3.0.0",
+        "character-reference-invalid": "^2.0.0",
+        "decode-named-character-reference": "^1.0.0",
+        "is-alphanumerical": "^2.0.0",
+        "is-decimal": "^2.0.0",
+        "is-hexadecimal": "^2.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/parse-entities/node_modules/@types/unist": {
+      "version": "2.0.11",
+      "resolved": "https://registry.npmjs.org/@types/unist/-/unist-2.0.11.tgz",
+      "integrity": "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA==",
+      "license": "MIT"
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/postcss": {
+      "version": "8.5.15",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.15.tgz",
+      "integrity": "sha512-FfR8sjd4em2T6fb3I2MwAJU7HWVMr9zba+enmQeeWFfCbm+UOC/0X4DS8XtpUTMwWMGbjKYP7xjfNekzyGmB3A==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "nanoid": "^3.3.12",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/property-information": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/property-information/-/property-information-7.2.0.tgz",
+      "integrity": "sha512-IAtzIB6sUiWaJYrX9smp3V46pBGbBeLFRGdh25kg1334VcBlD8HzhPeNIWQH9zhGmo2itIe25EHt9dQP7G5hmg==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/react": {
+      "version": "18.3.1",
+      "resolved": "https://registry.npmjs.org/react/-/react-18.3.1.tgz",
+      "integrity": "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==",
+      "license": "MIT",
+      "dependencies": {
+        "loose-envify": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/react-dom": {
+      "version": "18.3.1",
+      "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-18.3.1.tgz",
+      "integrity": "sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==",
+      "license": "MIT",
+      "dependencies": {
+        "loose-envify": "^1.1.0",
+        "scheduler": "^0.23.2"
+      },
+      "peerDependencies": {
+        "react": "^18.3.1"
+      }
+    },
+    "node_modules/react-markdown": {
+      "version": "9.1.0",
+      "resolved": "https://registry.npmjs.org/react-markdown/-/react-markdown-9.1.0.tgz",
+      "integrity": "sha512-xaijuJB0kzGiUdG7nc2MOMDUDBWPyGAjZtUrow9XxUeua8IqeP+VlIfAZ3bphpcLTnSZXz6z9jcVC/TCwbfgdw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/hast": "^3.0.0",
+        "@types/mdast": "^4.0.0",
+        "devlop": "^1.0.0",
+        "hast-util-to-jsx-runtime": "^2.0.0",
+        "html-url-attributes": "^3.0.0",
+        "mdast-util-to-hast": "^13.0.0",
+        "remark-parse": "^11.0.0",
+        "remark-rehype": "^11.0.0",
+        "unified": "^11.0.0",
+        "unist-util-visit": "^5.0.0",
+        "vfile": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      },
+      "peerDependencies": {
+        "@types/react": ">=18",
+        "react": ">=18"
+      }
+    },
+    "node_modules/react-refresh": {
+      "version": "0.17.0",
+      "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.17.0.tgz",
+      "integrity": "sha512-z6F7K9bV85EfseRCp2bzrpyQ0Gkw1uLoCel9XBVWPg/TjRj94SkJzUTGfOa4bs7iJvBWtQG0Wq7wnI0syw3EBQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/remark-parse": {
+      "version": "11.0.0",
+      "resolved": "https://registry.npmjs.org/remark-parse/-/remark-parse-11.0.0.tgz",
+      "integrity": "sha512-FCxlKLNGknS5ba/1lmpYijMUzX2esxW5xQqjWxw2eHFfS2MSdaHVINFmhjo+qN1WhZhNimq0dZATN9pH0IDrpA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/mdast": "^4.0.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "micromark-util-types": "^2.0.0",
+        "unified": "^11.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-rehype": {
+      "version": "11.1.2",
+      "resolved": "https://registry.npmjs.org/remark-rehype/-/remark-rehype-11.1.2.tgz",
+      "integrity": "sha512-Dh7l57ianaEoIpzbp0PC9UKAdCSVklD8E5Rpw7ETfbTl3FqcOOgq5q2LVDhgGCkaBv7p24JXikPdvhhmHvKMsw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/hast": "^3.0.0",
+        "@types/mdast": "^4.0.0",
+        "mdast-util-to-hast": "^13.0.0",
+        "unified": "^11.0.0",
+        "vfile": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/rollup": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.62.2.tgz",
+      "integrity": "sha512-RFnrW4lhXA3s3eqHDZvN654g8OTjzRfqpIRJYczCGB6HzphckVAi/Qh4tbPUbRuDi7s1Llv8g/NspLkttY3gTA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "1.0.9"
+      },
+      "bin": {
+        "rollup": "dist/bin/rollup"
+      },
+      "engines": {
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "@rollup/rollup-android-arm-eabi": "4.62.2",
+        "@rollup/rollup-android-arm64": "4.62.2",
+        "@rollup/rollup-darwin-arm64": "4.62.2",
+        "@rollup/rollup-darwin-x64": "4.62.2",
+        "@rollup/rollup-freebsd-arm64": "4.62.2",
+        "@rollup/rollup-freebsd-x64": "4.62.2",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.62.2",
+        "@rollup/rollup-linux-arm-musleabihf": "4.62.2",
+        "@rollup/rollup-linux-arm64-gnu": "4.62.2",
+        "@rollup/rollup-linux-arm64-musl": "4.62.2",
+        "@rollup/rollup-linux-loong64-gnu": "4.62.2",
+        "@rollup/rollup-linux-loong64-musl": "4.62.2",
+        "@rollup/rollup-linux-ppc64-gnu": "4.62.2",
+        "@rollup/rollup-linux-ppc64-musl": "4.62.2",
+        "@rollup/rollup-linux-riscv64-gnu": "4.62.2",
+        "@rollup/rollup-linux-riscv64-musl": "4.62.2",
+        "@rollup/rollup-linux-s390x-gnu": "4.62.2",
+        "@rollup/rollup-linux-x64-gnu": "4.62.2",
+        "@rollup/rollup-linux-x64-musl": "4.62.2",
+        "@rollup/rollup-openbsd-x64": "4.62.2",
+        "@rollup/rollup-openharmony-arm64": "4.62.2",
+        "@rollup/rollup-win32-arm64-msvc": "4.62.2",
+        "@rollup/rollup-win32-ia32-msvc": "4.62.2",
+        "@rollup/rollup-win32-x64-gnu": "4.62.2",
+        "@rollup/rollup-win32-x64-msvc": "4.62.2",
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/scheduler": {
+      "version": "0.23.2",
+      "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.23.2.tgz",
+      "integrity": "sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==",
+      "license": "MIT",
+      "dependencies": {
+        "loose-envify": "^1.1.0"
+      }
+    },
+    "node_modules/semver": {
+      "version": "6.3.1",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      }
+    },
+    "node_modules/source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/space-separated-tokens": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/space-separated-tokens/-/space-separated-tokens-2.0.2.tgz",
+      "integrity": "sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/stringify-entities": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/stringify-entities/-/stringify-entities-4.0.4.tgz",
+      "integrity": "sha512-IwfBptatlO+QCJUo19AqvrPNqlVMpW9YEL2LIVY+Rpv2qsjCGxaDLNRgeGsQWJhfItebuJhsGSLjaBbNSQ+ieg==",
+      "license": "MIT",
+      "dependencies": {
+        "character-entities-html4": "^2.0.0",
+        "character-entities-legacy": "^3.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/style-to-js": {
+      "version": "1.1.21",
+      "resolved": "https://registry.npmjs.org/style-to-js/-/style-to-js-1.1.21.tgz",
+      "integrity": "sha512-RjQetxJrrUJLQPHbLku6U/ocGtzyjbJMP9lCNK7Ag0CNh690nSH8woqWH9u16nMjYBAok+i7JO1NP2pOy8IsPQ==",
+      "license": "MIT",
+      "dependencies": {
+        "style-to-object": "1.0.14"
+      }
+    },
+    "node_modules/style-to-object": {
+      "version": "1.0.14",
+      "resolved": "https://registry.npmjs.org/style-to-object/-/style-to-object-1.0.14.tgz",
+      "integrity": "sha512-LIN7rULI0jBscWQYaSswptyderlarFkjQ+t79nzty8tcIAceVomEVlLzH5VP4Cmsv6MtKhs7qaAiwlcp+Mgaxw==",
+      "license": "MIT",
+      "dependencies": {
+        "inline-style-parser": "0.2.7"
+      }
+    },
+    "node_modules/trim-lines": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/trim-lines/-/trim-lines-3.0.1.tgz",
+      "integrity": "sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/trough": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/trough/-/trough-2.2.0.tgz",
+      "integrity": "sha512-tmMpK00BjZiUyVyvrBK7knerNgmgvcV/KLVyuma/SC+TQN167GrMRciANTz09+k3zW8L8t60jWO1GpfkZdjTaw==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/typescript": {
+      "version": "5.9.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
+      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/unified": {
+      "version": "11.0.5",
+      "resolved": "https://registry.npmjs.org/unified/-/unified-11.0.5.tgz",
+      "integrity": "sha512-xKvGhPWw3k84Qjh8bI3ZeJjqnyadK+GEFtazSfZv/rKeTkTjOJho6mFqh2SM96iIcZokxiOpg78GazTSg8+KHA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0",
+        "bail": "^2.0.0",
+        "devlop": "^1.0.0",
+        "extend": "^3.0.0",
+        "is-plain-obj": "^4.0.0",
+        "trough": "^2.0.0",
+        "vfile": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-is": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-6.0.1.tgz",
+      "integrity": "sha512-LsiILbtBETkDz8I9p1dQ0uyRUWuaQzd/cuEeS1hoRSyW5E5XGmTzlwY1OrNzzakGowI9Dr/I8HVaw4hTtnxy8g==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-position": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-5.0.0.tgz",
+      "integrity": "sha512-fucsC7HjXvkB5R3kTCO7kUjRdrS0BJt3M/FPxmHMBOm8JQi2BsHAHFsy27E0EolP8rp0NzXsJ+jNPyDWvOJZPA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-stringify-position": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-4.0.0.tgz",
+      "integrity": "sha512-0ASV06AAoKCDkS2+xw5RXJywruurpbC4JZSm7nr7MOt1ojAzvyyaO+UxZf18j8FCF6kmzCZKcAgN/yu2gm2XgQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-visit": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-5.1.0.tgz",
+      "integrity": "sha512-m+vIdyeCOpdr/QeQCu2EzxX/ohgS8KbnPDgFni4dQsfSCtpz8UqDyY5GjRru8PDKuYn7Fq19j1CQ+nJSsGKOzg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0",
+        "unist-util-is": "^6.0.0",
+        "unist-util-visit-parents": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-visit-parents": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-6.0.2.tgz",
+      "integrity": "sha512-goh1s1TBrqSqukSc8wrjwWhL0hiJxgA8m4kFxGlQ+8FYQ3C/m11FcTs4YYem7V664AhHVvgoQLk890Ssdsr2IQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0",
+        "unist-util-is": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/update-browserslist-db": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz",
+      "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "escalade": "^3.2.0",
+        "picocolors": "^1.1.1"
+      },
+      "bin": {
+        "update-browserslist-db": "cli.js"
+      },
+      "peerDependencies": {
+        "browserslist": ">= 4.21.0"
+      }
+    },
+    "node_modules/vfile": {
+      "version": "6.0.3",
+      "resolved": "https://registry.npmjs.org/vfile/-/vfile-6.0.3.tgz",
+      "integrity": "sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0",
+        "vfile-message": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/vfile-message": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/vfile-message/-/vfile-message-4.0.3.tgz",
+      "integrity": "sha512-QTHzsGd1EhbZs4AsQ20JX1rC3cOlt/IWJruk893DfLRr57lcnOeMaWG4K0JrRta4mIJZKth2Au3mM3u03/JWKw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0",
+        "unist-util-stringify-position": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/vite": {
+      "version": "5.4.21",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.21.tgz",
+      "integrity": "sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "esbuild": "^0.21.3",
+        "postcss": "^8.4.43",
+        "rollup": "^4.20.0"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^18.0.0 || >=20.0.0",
+        "less": "*",
+        "lightningcss": "^1.21.0",
+        "sass": "*",
+        "sass-embedded": "*",
+        "stylus": "*",
+        "sugarss": "*",
+        "terser": "^5.4.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/yallist": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",
+      "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/zwitch": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/zwitch/-/zwitch-2.0.4.tgz",
+      "integrity": "sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    }
+  }
+}

+ 23 - 0
Co-creation-projects/jphJack-PaperMindAgent/frontend/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "paper-innovation-agent-frontend",
+  "private": true,
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc -b && vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "react-markdown": "^9.0.1"
+  },
+  "devDependencies": {
+    "@types/react": "^18.3.5",
+    "@types/react-dom": "^18.3.0",
+    "@vitejs/plugin-react": "^4.3.1",
+    "typescript": "^5.5.4",
+    "vite": "^5.4.2"
+  }
+}

+ 434 - 0
Co-creation-projects/jphJack-PaperMindAgent/frontend/src/App.tsx

@@ -0,0 +1,434 @@
+// Paper Innovation Agent - 主应用组件
+// 状态管理 + 布局 + 交互流程
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
+import { deletePaper, getHealth, getReport, listPapers, startAnalysis, subscribeProgress, uploadPaper } from './api'
+import { STAGE_LIST } from './types'
+import type { AnalyzeParams, Evaluation, Paper, ProgressEvent, Report, StageKey } from './types'
+import ProgressBar from './components/ProgressBar'
+import StepsTimeline from './components/StepsTimeline'
+import EvaluationPanel from './components/EvaluationPanel'
+import ReportView from './components/ReportView'
+import PaperLibrary from './components/PaperLibrary'
+
+/** 初始化:所有阶段事件为空 */
+function createEmptyEvents(): Record<StageKey, ProgressEvent | undefined> {
+  const obj = {} as Record<StageKey, ProgressEvent | undefined>
+  STAGE_LIST.forEach((s) => (obj[s.key] = undefined))
+  return obj
+}
+
+type TabKey = 'report' | 'evaluation'
+
+export default function App() {
+  // 输入与任务状态
+  const [folderPath, setFolderPath] = useState('')
+  const [taskId, setTaskId] = useState<string | null>(null)
+  const [starting, setStarting] = useState(false)
+  const [running, setRunning] = useState(false)
+
+  // 输入模式:上传论文 / 文件夹路径
+  const [inputMode, setInputMode] = useState<'upload' | 'folder'>('upload')
+  // 论文库列表与选中状态
+  const [papers, setPapers] = useState<Paper[]>([])
+  const [selectedPaperIds, setSelectedPaperIds] = useState<Set<string>>(new Set())
+  // 研究方向(注入创新点生成提示词)
+  const [researchDirection, setResearchDirection] = useState('')
+  // 上传中状态
+  const [uploading, setUploading] = useState(false)
+
+  // 进度与报告
+  const [eventsByStage, setEventsByStage] = useState<Record<StageKey, ProgressEvent | undefined>>(
+    createEmptyEvents,
+  )
+  const [overallProgress, setOverallProgress] = useState(0)
+  const [report, setReport] = useState<Report | null>(null)
+  const [reportLoading, setReportLoading] = useState(false)
+
+  // 错误与健康检查
+  const [error, setError] = useState<string | null>(null)
+  const [model, setModel] = useState<string>('deepseek-chat')
+  const [healthOk, setHealthOk] = useState<boolean>(true)
+
+  // Tab 切换
+  const [activeTab, setActiveTab] = useState<TabKey>('report')
+
+  // EventSource 引用,便于卸载/重试时关闭
+  const sourceRef = useRef<EventSource | null>(null)
+
+  /** 关闭当前 SSE 订阅 */
+  const closeSource = useCallback(() => {
+    if (sourceRef.current) {
+      sourceRef.current.close()
+      sourceRef.current = null
+    }
+  }, [])
+
+  /** 拉取论文库列表 */
+  const refreshPapers = useCallback(async () => {
+    try {
+      const { papers } = await listPapers()
+      setPapers(papers)
+    } catch (err) {
+      console.warn('拉取论文库失败:', err)
+    }
+  }, [])
+
+  /** 上传 PDF 论文 */
+  const handleUpload = useCallback(async (file: File) => {
+    setUploading(true)
+    try {
+      await uploadPaper(file)
+      await refreshPapers()
+    } catch (err) {
+      setError(`上传失败: ${err instanceof Error ? err.message : String(err)}`)
+    } finally {
+      setUploading(false)
+    }
+  }, [refreshPapers])
+
+  /** 删除论文 */
+  const handleDeletePaper = useCallback(async (paperId: string) => {
+    try {
+      await deletePaper(paperId)
+      setSelectedPaperIds((prev) => {
+        const next = new Set(prev)
+        next.delete(paperId)
+        return next
+      })
+      await refreshPapers()
+    } catch (err) {
+      setError(`删除失败: ${err instanceof Error ? err.message : String(err)}`)
+    }
+  }, [refreshPapers])
+
+  /** 切换论文选中状态 */
+  const handleToggleSelect = useCallback((paperId: string) => {
+    setSelectedPaperIds((prev) => {
+      const next = new Set(prev)
+      if (next.has(paperId)) next.delete(paperId)
+      else next.add(paperId)
+      return next
+    })
+  }, [])
+
+  /** 健康检查:拉取后端模型信息 */
+  useEffect(() => {
+    let cancelled = false
+    getHealth()
+      .then((info) => {
+        if (cancelled) return
+        setModel(info.model || 'deepseek-chat')
+        setHealthOk(info.status === 'ok')
+      })
+      .catch(() => {
+        if (!cancelled) setHealthOk(false)
+      })
+    return () => {
+      cancelled = true
+    }
+  }, [])
+
+  /** 挂载时拉取论文库 */
+  useEffect(() => {
+    void refreshPapers()
+  }, [refreshPapers])
+
+  /** 卸载时关闭 SSE */
+  useEffect(() => {
+    return () => closeSource()
+  }, [closeSource])
+
+  /** 拉取最终报告 */
+  const fetchReport = useCallback(async (id: string) => {
+    setReportLoading(true)
+    try {
+      const r = await getReport(id)
+      setReport(r)
+      // 自动切到报告 Tab
+      setActiveTab('report')
+    } catch (err) {
+      setError(`获取报告失败: ${err instanceof Error ? err.message : String(err)}`)
+    } finally {
+      setReportLoading(false)
+    }
+  }, [])
+
+  /** 启动分析 */
+  const handleStart = useCallback(async () => {
+    // 根据输入模式构建请求参数
+    const params: AnalyzeParams = {}
+    if (inputMode === 'folder') {
+      const path = folderPath.trim()
+      if (!path) {
+        setError('请输入 PDF 文件夹路径')
+        return
+      }
+      params.folder_path = path
+    } else {
+      if (selectedPaperIds.size === 0) {
+        setError('请至少选择一篇论文')
+        return
+      }
+      params.paper_ids = Array.from(selectedPaperIds)
+    }
+    const direction = researchDirection.trim()
+    if (direction) params.research_direction = direction
+
+    setError(null)
+    setStarting(true)
+    setRunning(true)
+    setReport(null)
+    setOverallProgress(0)
+    setEventsByStage(createEmptyEvents())
+
+    // 关闭可能存在的旧订阅
+    closeSource()
+
+    try {
+      const { task_id } = await startAnalysis(params)
+      setTaskId(task_id)
+
+      // 订阅进度
+      const source = subscribeProgress(
+        task_id,
+        (evt: ProgressEvent) => {
+          setEventsByStage((prev) => ({ ...prev, [evt.stage]: evt }))
+          if (typeof evt.progress === 'number' && Number.isFinite(evt.progress)) {
+            setOverallProgress(evt.progress)
+          }
+          // 任意步骤失败:标记错误但继续监听
+          if (evt.status === 'failed') {
+            setError(`步骤 ${evt.stage} 失败: ${evt.message}`)
+          }
+        },
+        () => {
+          // step7_integrate done
+          setRunning(false)
+          setOverallProgress(1)
+          void fetchReport(task_id)
+        },
+        () => {
+          // SSE 错误:若任务尚未完成,提示连接异常
+          setRunning((r) => {
+            if (r) {
+              setError('进度订阅连接异常,可点击重试恢复')
+            }
+            return r
+          })
+        },
+      )
+      sourceRef.current = source
+    } catch (err) {
+      setError(`启动分析失败: ${err instanceof Error ? err.message : String(err)}`)
+      setRunning(false)
+    } finally {
+      setStarting(false)
+    }
+  }, [inputMode, folderPath, selectedPaperIds, researchDirection, closeSource, fetchReport])
+
+  /** 重试:基于已有 taskId 重新订阅 + 拉报告 */
+  const handleRetry = useCallback(async () => {
+    if (!taskId) {
+      void handleStart()
+      return
+    }
+    setError(null)
+    setRunning(true)
+    closeSource()
+    try {
+      const source = subscribeProgress(
+        taskId,
+        (evt: ProgressEvent) => {
+          setEventsByStage((prev) => ({ ...prev, [evt.stage]: evt }))
+          if (typeof evt.progress === 'number' && Number.isFinite(evt.progress)) {
+            setOverallProgress(evt.progress)
+          }
+        },
+        () => {
+          setRunning(false)
+          setOverallProgress(1)
+          void fetchReport(taskId)
+        },
+      )
+      sourceRef.current = source
+    } catch (err) {
+      setError(`重试失败: ${err instanceof Error ? err.message : String(err)}`)
+      setRunning(false)
+    }
+  }, [taskId, closeSource, fetchReport, handleStart])
+
+  /** 评估数据:优先取 report.evaluation,其次 report.report.evaluation */
+  const evaluation: Evaluation | null = useMemo(() => {
+    if (!report) return null
+    return report.evaluation ?? report.report?.evaluation ?? null
+  }, [report])
+
+  /** Markdown 文本 */
+  const markdown = useMemo(() => report?.markdown ?? report?.report?.markdown ?? '', [report])
+
+  /** 是否有任意步骤处于运行/完成态(用于判断时间线是否激活) */
+  const hasActivity = useMemo(
+    () => Object.values(eventsByStage).some((e) => e !== undefined),
+    [eventsByStage],
+  )
+
+  return (
+    <div className="app">
+      {/* 顶部标题栏 */}
+      <header className="app-header">
+        <div className="brand">
+          <div className="brand-logo" aria-hidden>P</div>
+          <div>
+            <div className="brand-title">Paper Innovation Agent</div>
+            <div className="brand-subtitle">七步漏斗式论文创新点生成系统</div>
+          </div>
+        </div>
+        <div className="header-right">
+          <span className="model-badge">
+            <span className={`dot ${healthOk ? '' : 'offline'}`} />
+            {healthOk ? '服务正常' : '服务离线'} · {model}
+          </span>
+        </div>
+      </header>
+
+      <div className="app-body">
+        {/* 左侧输入区 + 进度 + 时间线 */}
+        <aside className="sidebar">
+          <div className="input-card">
+            <h3 className="card-title">分析输入</h3>
+
+            {/* 输入模式切换 */}
+            <div className="mode-toggle">
+              <button
+                className={`mode-btn ${inputMode === 'upload' ? 'active' : ''}`}
+                onClick={() => setInputMode('upload')}
+                disabled={starting || running}
+              >
+                上传论文
+              </button>
+              <button
+                className={`mode-btn ${inputMode === 'folder' ? 'active' : ''}`}
+                onClick={() => setInputMode('folder')}
+                disabled={starting || running}
+              >
+                文件夹路径
+              </button>
+            </div>
+
+            {/* 上传模式:论文库;文件夹模式:路径输入 */}
+            {inputMode === 'upload' ? (
+              <PaperLibrary
+                papers={papers}
+                selectedIds={selectedPaperIds}
+                onToggleSelect={handleToggleSelect}
+                onDelete={handleDeletePaper}
+                onUpload={handleUpload}
+                uploading={uploading}
+                disabled={starting || running}
+              />
+            ) : (
+              <>
+                <input
+                  className="path-input"
+                  type="text"
+                  placeholder="例如:D:/papers 或 /home/user/papers"
+                  value={folderPath}
+                  onChange={(e) => setFolderPath(e.target.value)}
+                  onKeyDown={(e) => {
+                    if (e.key === 'Enter' && !starting && !running) {
+                      void handleStart()
+                    }
+                  }}
+                  disabled={starting || running}
+                  aria-label="PDF 文件夹路径"
+                />
+                <p className="hint">输入包含 PDF 论文的本地文件夹路径,系统将自动解析并生成创新点。</p>
+              </>
+            )}
+
+            {/* 研究方向(两种模式都显示) */}
+            <div className="research-direction">
+              <label className="research-label" htmlFor="research-direction">
+                研究方向(可选)
+              </label>
+              <input
+                id="research-direction"
+                className="path-input"
+                type="text"
+                placeholder="例如:大模型高效微调、多模态推理"
+                value={researchDirection}
+                onChange={(e) => setResearchDirection(e.target.value)}
+                disabled={starting || running}
+                aria-label="研究方向"
+              />
+              <p className="hint">注入到创新点生成提示词,引导生成与方向相关的创新点。</p>
+            </div>
+
+            <button
+              className="btn btn-primary"
+              onClick={() => void handleStart()}
+              disabled={
+                starting ||
+                running ||
+                (inputMode === 'folder' ? !folderPath.trim() : selectedPaperIds.size === 0)
+              }
+            >
+              {starting ? <><span className="spinner" /> 启动中...</> : running ? '分析进行中' : '启动分析'}
+            </button>
+          </div>
+
+          {/* 整体进度条 */}
+          {(hasActivity || running) && (
+            <ProgressBar progress={overallProgress} active={running} />
+          )}
+
+          {/* 七步时间线 */}
+          <div>
+            <div className="section-divider">执行链路</div>
+            <StepsTimeline eventsByStage={eventsByStage} />
+          </div>
+
+          {/* 错误提示 + 重试 */}
+          {error && (
+            <div className="error-banner">
+              <span className="error-icon" aria-hidden>!</span>
+              <span className="error-text">{error}</span>
+              <div className="error-actions">
+                <button className="btn btn-secondary" onClick={() => void handleRetry()} disabled={starting}>
+                  重试
+                </button>
+              </div>
+            </div>
+          )}
+        </aside>
+
+        {/* 右侧主内容区:Tab 切换 */}
+        <main className="main-content">
+          <div className="tabs">
+            <button
+              className={`tab ${activeTab === 'report' ? 'active' : ''}`}
+              onClick={() => setActiveTab('report')}
+            >
+              研究报告
+            </button>
+            <button
+              className={`tab ${activeTab === 'evaluation' ? 'active' : ''}`}
+              onClick={() => setActiveTab('evaluation')}
+            >
+              评估指标
+              {evaluation ? <span className="badge">{evaluation.innovations_scores?.length ?? 0}</span> : null}
+            </button>
+          </div>
+
+          <div className="report-container">
+            {activeTab === 'report' ? (
+              <ReportView markdown={markdown} loading={reportLoading} />
+            ) : (
+              <EvaluationPanel evaluation={evaluation} />
+            )}
+          </div>
+        </main>
+      </div>
+    </div>
+  )
+}

+ 153 - 0
Co-creation-projects/jphJack-PaperMindAgent/frontend/src/api.ts

@@ -0,0 +1,153 @@
+// API 调用封装:统一处理后端 /api/* 接口
+import type { ProgressEvent, Report, TaskStatus, HealthInfo, Paper, UploadResponse, AnalyzeParams } from './types'
+
+/** 后端基础地址(vite 代理已将 /api 转发到 localhost:8000) */
+const API_BASE = '/api'
+
+/** 通用 JSON 请求封装,统一抛错 */
+async function requestJson<T>(url: string, init?: RequestInit): Promise<T> {
+  const resp = await fetch(url, {
+    headers: { 'Content-Type': 'application/json' },
+    ...init,
+  })
+  if (!resp.ok) {
+    let detail = ''
+    try {
+      const data = await resp.json()
+      detail = data?.detail || data?.message || JSON.stringify(data)
+    } catch {
+      detail = await resp.text().catch(() => '')
+    }
+    throw new Error(`请求失败 ${resp.status} ${resp.statusText}${detail ? `: ${detail}` : ''}`)
+  }
+  return (await resp.json()) as T
+}
+
+/**
+ * 启动分析任务
+ * POST /api/analyze body: { folder_path?, paper_ids?, research_direction? }
+ */
+export async function startAnalysis(params: AnalyzeParams): Promise<{ task_id: string }> {
+  return requestJson<{ task_id: string }>(`${API_BASE}/analyze`, {
+    method: 'POST',
+    body: JSON.stringify(params),
+  })
+}
+
+/**
+ * 上传 PDF 论文
+ * POST /api/upload (multipart/form-data)
+ */
+export async function uploadPaper(file: File): Promise<UploadResponse> {
+  const formData = new FormData()
+  formData.append('file', file)
+  const resp = await fetch(`${API_BASE}/upload`, {
+    method: 'POST',
+    body: formData,
+  })
+  if (!resp.ok) {
+    let detail = ''
+    try {
+      const data = await resp.json()
+      detail = data?.detail || data?.message || JSON.stringify(data)
+    } catch {
+      detail = await resp.text().catch(() => '')
+    }
+    throw new Error(`上传失败 ${resp.status} ${resp.statusText}${detail ? `: ${detail}` : ''}`)
+  }
+  return (await resp.json()) as UploadResponse
+}
+
+/**
+ * 列出论文库全部论文
+ * GET /api/papers
+ */
+export async function listPapers(): Promise<{ papers: Paper[] }> {
+  return requestJson<{ papers: Paper[] }>(`${API_BASE}/papers`)
+}
+
+/**
+ * 删除论文
+ * DELETE /api/papers/{paper_id}
+ */
+export async function deletePaper(paperId: string): Promise<{ deleted: boolean; paper_id: string }> {
+  return requestJson<{ deleted: boolean; paper_id: string }>(`${API_BASE}/papers/${paperId}`, {
+    method: 'DELETE',
+  })
+}
+
+/**
+ * 订阅任务进度(SSE)
+ * 使用 EventSource 连接 /api/progress/{task_id}
+ * 返回 EventSource 实例,调用方可主动 close() 取消订阅
+ */
+export function subscribeProgress(
+  taskId: string,
+  onEvent: (e: ProgressEvent) => void,
+  onDone: () => void,
+  onError?: (err: Event) => void,
+): EventSource {
+  const source = new EventSource(`${API_BASE}/progress/${taskId}`)
+
+  // 后端推送的是命名事件(event: progress / event: done),
+  // 必须用 addEventListener 监听对应事件名,onmessage 只能收到无名事件。
+  source.addEventListener('progress', (ev: MessageEvent) => {
+    const raw = ev.data
+    if (!raw) return
+    try {
+      const parsed = JSON.parse(raw) as ProgressEvent
+      onEvent(parsed)
+    } catch (err) {
+      console.warn('解析 SSE progress 事件失败:', raw, err)
+    }
+  })
+
+  // 任务结束(completed/failed)后端推送 event: done
+  source.addEventListener('done', (ev: MessageEvent) => {
+    const raw = ev.data
+    if (!raw) return
+    try {
+      const parsed = JSON.parse(raw) as { status: string; progress: number }
+      // 用最终进度刷新一次,保证进度条到 100%
+      if (typeof parsed.progress === 'number' && Number.isFinite(parsed.progress)) {
+        onEvent({ stage: 'step7_integrate', status: 'done', message: '任务完成', progress: parsed.progress, payload: parsed })
+      }
+    } catch {
+      /* ignore */
+    }
+    onDone()
+    // 主动关闭连接,避免 EventSource 自动重连导致反复 GET /api/progress/{taskId}
+    source.close()
+  })
+
+  source.onerror = (err) => {
+    // EventSource 在服务端关闭后会自动重连;这里把错误透传给调用方
+    if (onError) onError(err)
+  }
+
+  return source
+}
+
+/**
+ * 获取最终报告
+ * GET /api/report/{task_id}
+ */
+export async function getReport(taskId: string): Promise<Report> {
+  return requestJson<Report>(`${API_BASE}/report/${taskId}`)
+}
+
+/**
+ * 查询任务状态
+ * GET /api/tasks/{task_id}
+ */
+export async function getTaskStatus(taskId: string): Promise<TaskStatus> {
+  return requestJson<TaskStatus>(`${API_BASE}/tasks/${taskId}`)
+}
+
+/**
+ * 健康检查
+ * GET /api/health
+ */
+export async function getHealth(): Promise<HealthInfo> {
+  return requestJson<HealthInfo>(`${API_BASE}/health`)
+}

+ 169 - 0
Co-creation-projects/jphJack-PaperMindAgent/frontend/src/components/EvaluationPanel.tsx

@@ -0,0 +1,169 @@
+// 评估指标面板:工具调用成功率 / 总数 / 失败数 / 平均置信度 / 三维评分
+import type { Evaluation, ThreeDScore } from '../types'
+
+interface EvaluationPanelProps {
+  evaluation: Evaluation | null
+}
+
+/** 0-1 比率转百分比字符串 */
+function toPercent(v: number): string {
+  if (!Number.isFinite(v)) return '0%'
+  return `${(Math.max(0, Math.min(1, v)) * 100).toFixed(1)}%`
+}
+
+/** 根据成功率返回语义化样式名 */
+function rateClass(rate: number): 'success' | 'warning' | 'danger' {
+  if (rate >= 0.9) return 'success'
+  if (rate >= 0.7) return 'warning'
+  return 'danger'
+}
+
+/** 计算三维评分平均值 */
+function avgScore(scores: ThreeDScore[] | undefined, key: keyof ThreeDScore): number {
+  if (!scores || scores.length === 0) return 0
+  const sum = scores.reduce((acc, s) => acc + (Number(s[key]) || 0), 0)
+  return sum / scores.length
+}
+
+export default function EvaluationPanel({ evaluation }: EvaluationPanelProps) {
+  if (!evaluation) {
+    return (
+      <div className="report-empty">
+        <div className="empty-icon" aria-hidden>i</div>
+        <div className="empty-title">暂无评估数据</div>
+        <div className="empty-desc">任务完成后将展示工具调用成功率、平均置信度与创新点三维评分。</div>
+      </div>
+    )
+  }
+
+  const {
+    tool_call_success_rate: successRate,
+    total_tool_calls: totalCalls,
+    failed_tool_calls: failedCalls,
+    avg_confidence: avgConfidence,
+    innovations_scores: scores,
+    tool_calls: toolCalls,
+  } = evaluation
+
+  const rateCls = rateClass(successRate)
+  const avgNovelty = avgScore(scores, 'novelty')
+  const avgFeasibility = avgScore(scores, 'feasibility')
+  const avgSignificance = avgScore(scores, 'significance')
+  // 三维评分满分 10
+  const scoreMax = 10
+
+  return (
+    <div>
+      {/* 顶部指标卡片 */}
+      <div className="eval-panel">
+        <div className="metric-card">
+          <span className="metric-label">工具调用成功率</span>
+          <span className={`metric-value ${rateCls}`}>{toPercent(successRate)}</span>
+          <div className="metric-bar">
+            <div
+              className={`metric-bar-fill ${rateCls}`}
+              style={{ width: `${Math.max(0, Math.min(1, successRate)) * 100}%` }}
+            />
+          </div>
+        </div>
+
+        <div className="metric-card">
+          <span className="metric-label">总工具调用数</span>
+          <span className="metric-value">{totalCalls}</span>
+          <span className="metric-sub">失败 {failedCalls} 次</span>
+        </div>
+
+        <div className="metric-card">
+          <span className="metric-label">平均置信度</span>
+          <span className={`metric-value ${avgConfidence >= 0.7 ? 'success' : 'warning'}`}>
+            {toPercent(avgConfidence)}
+          </span>
+          <div className="metric-bar">
+            <div
+              className={`metric-bar-fill ${avgConfidence >= 0.7 ? 'success' : 'warning'}`}
+              style={{ width: `${Math.max(0, Math.min(1, avgConfidence)) * 100}%` }}
+            />
+          </div>
+        </div>
+
+        <div className="metric-card">
+          <span className="metric-label">创新点数量</span>
+          <span className="metric-value">{scores?.length ?? 0}</span>
+          <span className="metric-sub">三维评分均值见下</span>
+        </div>
+      </div>
+
+      {/* 三维评分条形图 */}
+      <div className="score-section">
+        <h3 className="section-title">创新点三维评分(均值,满分 10)</h3>
+        <div className="score-item">
+          <div className="score-header">
+            <span className="score-name">新颖性 Novelty</span>
+            <span className="score-num">{avgNovelty.toFixed(2)} / {scoreMax}</span>
+          </div>
+          <div className="score-track">
+            <div
+              className="score-fill novelty"
+              style={{ width: `${(avgNovelty / scoreMax) * 100}%` }}
+            />
+          </div>
+        </div>
+        <div className="score-item">
+          <div className="score-header">
+            <span className="score-name">可行性 Feasibility</span>
+            <span className="score-num">{avgFeasibility.toFixed(2)} / {scoreMax}</span>
+          </div>
+          <div className="score-track">
+            <div
+              className="score-fill feasibility"
+              style={{ width: `${(avgFeasibility / scoreMax) * 100}%` }}
+            />
+          </div>
+        </div>
+        <div className="score-item">
+          <div className="score-header">
+            <span className="score-name">显著性 Significance</span>
+            <span className="score-num">{avgSignificance.toFixed(2)} / {scoreMax}</span>
+          </div>
+          <div className="score-track">
+            <div
+              className="score-fill significance"
+              style={{ width: `${(avgSignificance / scoreMax) * 100}%` }}
+            />
+          </div>
+        </div>
+      </div>
+
+      {/* 工具调用明细 */}
+      <div className="tool-list">
+        <h3 className="section-title">工具调用明细({toolCalls?.length ?? 0} 条)</h3>
+        {toolCalls && toolCalls.length > 0 ? (
+          <div>
+            <div className="tool-row" style={{ fontWeight: 600, color: 'var(--text-muted)', borderBottom: '2px solid var(--border-strong)' }}>
+              <span>工具名</span>
+              <span>入参摘要</span>
+              <span>状态</span>
+              <span style={{ textAlign: 'right' }}>耗时(s)</span>
+            </div>
+            {toolCalls.map((call, idx) => (
+              <div className="tool-row" key={`${call.tool_name}-${idx}`}>
+                <span className="tool-name">{call.tool_name}</span>
+                <span className="tool-args" title={call.args_summary}>{call.args_summary || '-'}</span>
+                <span>
+                  <span className={`tool-status ${call.success ? 'ok' : 'fail'}`}>
+                    {call.success ? '成功' : '失败'}
+                  </span>
+                </span>
+                <span className="tool-duration">{call.duration_sec?.toFixed(2) ?? '-'}</span>
+              </div>
+            ))}
+          </div>
+        ) : (
+          <div style={{ color: 'var(--text-muted)', fontSize: 13, padding: '12px 0' }}>
+            暂无工具调用记录
+          </div>
+        )}
+      </div>
+    </div>
+  )
+}

+ 123 - 0
Co-creation-projects/jphJack-PaperMindAgent/frontend/src/components/PaperLibrary.tsx

@@ -0,0 +1,123 @@
+// 论文库组件:上传、列表、选择、删除
+import { useRef } from 'react'
+import type { Paper, PreprocessStatus } from '../types'
+
+interface PaperLibraryProps {
+  papers: Paper[]
+  selectedIds: Set<string>
+  onToggleSelect: (paperId: string) => void
+  onDelete: (paperId: string) => void
+  onUpload: (file: File) => void
+  uploading: boolean
+  disabled?: boolean
+}
+
+/** 预处理状态徽章 */
+function StatusBadge({ status, label }: { status: PreprocessStatus; label: string }) {
+  const cls = status === 'done' ? 'status-done' : status === 'failed' ? 'status-failed' : 'status-pending'
+  const text = status === 'done' ? '✓' : status === 'failed' ? '✕' : '○'
+  return (
+    <span className={`status-badge ${cls}`} title={`${label}: ${status}`}>
+      {label} {text}
+    </span>
+  )
+}
+
+export default function PaperLibrary({
+  papers,
+  selectedIds,
+  onToggleSelect,
+  onDelete,
+  onUpload,
+  uploading,
+  disabled = false,
+}: PaperLibraryProps) {
+  const fileInputRef = useRef<HTMLInputElement>(null)
+
+  const handleFileChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+    const file = e.target.files?.[0]
+    if (file) {
+      onUpload(file)
+      // 重置 input 以便重复上传同一文件
+      e.target.value = ''
+    }
+  }
+
+  return (
+    <div className="paper-library">
+      {/* 上传区域 */}
+      <div className="upload-area">
+        <input
+          ref={fileInputRef}
+          type="file"
+          accept=".pdf"
+          onChange={handleFileChange}
+          style={{ display: 'none' }}
+          disabled={uploading || disabled}
+        />
+        <button
+          className="btn btn-upload"
+          onClick={() => fileInputRef.current?.click()}
+          disabled={uploading || disabled}
+        >
+          {uploading ? <><span className="spinner" /> 上传中...</> : '+ 上传 PDF'}
+        </button>
+      </div>
+
+      {/* 论文列表 */}
+      <div className="paper-list">
+        {papers.length === 0 ? (
+          <p className="empty-hint">暂无论文,请上传 PDF 文件</p>
+        ) : (
+          papers.map((paper) => {
+            const selected = selectedIds.has(paper.paper_id)
+            const allDone =
+              paper.parse_status === 'done' &&
+              paper.extract_status === 'done' &&
+              paper.index_status === 'done'
+            return (
+              <div
+                key={paper.paper_id}
+                className={`paper-item ${selected ? 'selected' : ''} ${disabled ? 'disabled' : ''}`}
+              >
+                <label className="paper-checkbox">
+                  <input
+                    type="checkbox"
+                    checked={selected}
+                    onChange={() => onToggleSelect(paper.paper_id)}
+                    disabled={disabled}
+                  />
+                </label>
+                <div className="paper-info">
+                  <div className="paper-title" title={paper.title || paper.filename}>
+                    {paper.title || paper.filename}
+                  </div>
+                  <div className="paper-filename">{paper.filename}</div>
+                  <div className="paper-status">
+                    <StatusBadge status={paper.parse_status} label="解析" />
+                    <StatusBadge status={paper.extract_status} label="抽取" />
+                    <StatusBadge status={paper.index_status} label="索引" />
+                    {allDone && <span className="status-badge status-cached">已预处理</span>}
+                  </div>
+                </div>
+                <button
+                  className="btn-icon btn-delete"
+                  onClick={() => onDelete(paper.paper_id)}
+                  disabled={disabled}
+                  title="删除论文"
+                  aria-label="删除论文"
+                >
+                  ✕
+                </button>
+              </div>
+            )
+          })
+        )}
+      </div>
+
+      {selectedIds.size > 0 && (
+        <div className="selected-count">已选择 {selectedIds.size} 篇论文</div>
+      )}
+    </div>
+  )
+}

+ 34 - 0
Co-creation-projects/jphJack-PaperMindAgent/frontend/src/components/ProgressBar.tsx

@@ -0,0 +1,34 @@
+// 整体进度条组件:展示 0-1 浮点进度
+interface ProgressBarProps {
+  /** 0-1 之间的进度值 */
+  progress: number
+  /** 是否处于运行状态(控制 shimmer 动画) */
+  active?: boolean
+  /** 标签文字 */
+  label?: string
+}
+
+/** 将 0-1 浮点格式化为百分比字符串 */
+function formatPercent(value: number): string {
+  if (!Number.isFinite(value)) return '0%'
+  const clamped = Math.max(0, Math.min(1, value))
+  return `${Math.round(clamped * 100)}%`
+}
+
+export default function ProgressBar({ progress, active = false, label = '整体进度' }: ProgressBarProps) {
+  const clamped = Math.max(0, Math.min(1, Number.isFinite(progress) ? progress : 0))
+  return (
+    <div className="progress-section">
+      <div className="section-label">
+        <span>{label}</span>
+        <span className="progress-value">{formatPercent(clamped)}</span>
+      </div>
+      <div className="progress-bar-track" role="progressbar" aria-valuenow={Math.round(clamped * 100)} aria-valuemin={0} aria-valuemax={100}>
+        <div
+          className={`progress-bar-fill${active ? '' : ' idle'}`}
+          style={{ width: `${clamped * 100}%` }}
+        />
+      </div>
+    </div>
+  )
+}

+ 40 - 0
Co-creation-projects/jphJack-PaperMindAgent/frontend/src/components/ReportView.tsx

@@ -0,0 +1,40 @@
+// 报告展示组件:用 react-markdown 渲染 Markdown 报告
+import ReactMarkdown from 'react-markdown'
+
+interface ReportViewProps {
+  /** Markdown 字符串 */
+  markdown: string
+  /** 是否正在加载 */
+  loading?: boolean
+}
+
+export default function ReportView({ markdown, loading = false }: ReportViewProps) {
+  if (loading) {
+    return (
+      <div className="report-empty">
+        <div className="loading-overlay">
+          <span className="spinner" />
+          <span>正在生成研究报告...</span>
+        </div>
+      </div>
+    )
+  }
+
+  if (!markdown || !markdown.trim()) {
+    return (
+      <div className="report-empty">
+        <div className="empty-icon" aria-hidden>R</div>
+        <div className="empty-title">暂无研究报告</div>
+        <div className="empty-desc">
+          输入本地 PDF 文件夹路径并点击启动分析,七步漏斗链路完成后将在此展示 Markdown 研究提案。
+        </div>
+      </div>
+    )
+  }
+
+  return (
+    <div className="markdown-body">
+      <ReactMarkdown>{markdown}</ReactMarkdown>
+    </div>
+  )
+}

+ 73 - 0
Co-creation-projects/jphJack-PaperMindAgent/frontend/src/components/StepsTimeline.tsx

@@ -0,0 +1,73 @@
+// 七步漏斗链路进度时间线组件
+import { STAGE_LIST } from '../types'
+import type { ProgressEvent, StageKey, StepStatus } from '../types'
+
+interface StepsTimelineProps {
+  /** 已收到的进度事件,按 stage 聚合保留最新一条 */
+  eventsByStage: Record<StageKey, ProgressEvent | undefined>
+}
+
+/** 状态文案映射 */
+const STATUS_LABEL: Record<StepStatus, string> = {
+  pending: '待执行',
+  running: '运行中',
+  done: '完成',
+  failed: '失败',
+  degraded: '降级',
+  cached: '复用缓存',
+}
+
+/** 步骤序号图标:未开始显示数字,已完成显示对勾,失败显示叉,降级显示感叹号,缓存显示勾号 */
+function StepIcon({ status, index }: { status: StepStatus; index: number }) {
+  if (status === 'done') return <span aria-hidden>✓</span>
+  if (status === 'failed') return <span aria-hidden>✕</span>
+  if (status === 'degraded') return <span aria-hidden>!</span>
+  if (status === 'cached') return <span aria-hidden>↻</span>
+  return <span aria-hidden>{index}</span>
+}
+
+/** 根据事件状态推导步骤展示状态 */
+function deriveStatus(event: ProgressEvent | undefined): StepStatus {
+  if (!event) return 'pending'
+  if (event.status === 'running') return 'running'
+  if (event.status === 'done') return 'done'
+  if (event.status === 'failed') return 'failed'
+  if (event.status === 'degraded') return 'degraded'
+  if (event.status === 'cached') return 'cached'
+  return 'pending'
+}
+
+export default function StepsTimeline({ eventsByStage }: StepsTimelineProps) {
+  return (
+    <div className="timeline">
+      {STAGE_LIST.map((stage, idx) => {
+        const event = eventsByStage[stage.key]
+        const status = deriveStatus(event)
+        const isActive = status === 'running'
+        return (
+          <div
+            key={stage.key}
+            className={`timeline-step${isActive ? ' active' : ''}`}
+          >
+            <div className="step-marker">
+              <div className={`step-icon ${status}`} aria-label={`步骤 ${idx + 1} 状态: ${STATUS_LABEL[status]}`}>
+                <StepIcon status={status} index={idx + 1} />
+              </div>
+              <div className="step-line" />
+            </div>
+            <div className="step-body">
+              <div className="step-header">
+                <span className="step-name">{stage.label}</span>
+                <span className={`step-status-tag ${status}`}>{STATUS_LABEL[status]}</span>
+              </div>
+              <p className="step-desc">{stage.description}</p>
+              {event?.message ? (
+                <div className={`step-message ${status}`}>{event.message}</div>
+              ) : null}
+            </div>
+          </div>
+        )
+      })}
+    </div>
+  )
+}

+ 1249 - 0
Co-creation-projects/jphJack-PaperMindAgent/frontend/src/index.css

@@ -0,0 +1,1249 @@
+/* ============================================================
+   Paper Innovation Agent - 全局样式
+   现代专业风格,深色为主、浅色辅助,适合简历项目展示
+   ============================================================ */
+
+:root {
+  /* 颜色变量 - 深色主题为默认 */
+  --bg-primary: #0f172a;       /* 主背景:深蓝灰 */
+  --bg-secondary: #1e293b;     /* 次背景:卡片底色 */
+  --bg-tertiary: #334155;      /* 三级背景:输入框/悬停 */
+  --bg-elevated: #1e293b;      /* 抬升卡片 */
+  --border-color: #334155;     /* 边框 */
+  --border-strong: #475569;    /* 强边框 */
+  --text-primary: #f1f5f9;     /* 主文字 */
+  --text-secondary: #cbd5e1;   /* 次文字 */
+  --text-muted: #94a3b8;       /* 弱化文字 */
+  --accent: #3b82f6;           /* 主强调色:蓝 */
+  --accent-hover: #2563eb;
+  --accent-soft: rgba(59, 130, 246, 0.15);
+  --success: #10b981;          /* 成功:绿 */
+  --success-soft: rgba(16, 185, 129, 0.15);
+  --warning: #f59e0b;          /* 警告:橙 */
+  --warning-soft: rgba(245, 158, 11, 0.15);
+  --danger: #ef4444;           /* 失败:红 */
+  --danger-soft: rgba(239, 68, 68, 0.15);
+  --info: #06b6d4;             /* 信息:青 */
+  --info-soft: rgba(6, 182, 212, 0.15);
+
+  /* 评分维度色 */
+  --score-novelty: #8b5cf6;    /* 新颖性:紫 */
+  --score-feasibility: #06b6d4;/* 可行性:青 */
+  --score-significance: #f59e0b;/* 显著性:橙 */
+
+  /* 尺寸 */
+  --radius-sm: 6px;
+  --radius-md: 10px;
+  --radius-lg: 14px;
+  --shadow-sm: 0 1px 2px rgba(0, 0, 0, 0.3);
+  --shadow-md: 0 4px 12px rgba(0, 0, 0, 0.35);
+  --shadow-lg: 0 10px 30px rgba(0, 0, 0, 0.45);
+  --header-height: 60px;
+  --sidebar-width: 380px;
+}
+
+* {
+  box-sizing: border-box;
+}
+
+html, body, #root {
+  margin: 0;
+  padding: 0;
+  height: 100%;
+  width: 100%;
+}
+
+body {
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'PingFang SC',
+    'Hiragino Sans GB', 'Microsoft YaHei', Roboto, Helvetica, Arial, sans-serif;
+  background: var(--bg-primary);
+  color: var(--text-primary);
+  font-size: 14px;
+  line-height: 1.6;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+
+button {
+  font-family: inherit;
+  cursor: pointer;
+  border: none;
+  outline: none;
+}
+
+input {
+  font-family: inherit;
+  outline: none;
+}
+
+/* ====================== 应用主布局 ====================== */
+
+.app {
+  display: flex;
+  flex-direction: column;
+  height: 100vh;
+  overflow: hidden;
+}
+
+/* 顶部标题栏 */
+.app-header {
+  height: var(--header-height);
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 0 24px;
+  background: var(--bg-secondary);
+  border-bottom: 1px solid var(--border-color);
+  flex-shrink: 0;
+}
+
+.app-header .brand {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+}
+
+.app-header .brand-logo {
+  width: 32px;
+  height: 32px;
+  border-radius: 8px;
+  background: linear-gradient(135deg, var(--accent), var(--info));
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  font-weight: 700;
+  color: white;
+  font-size: 16px;
+  letter-spacing: -0.5px;
+}
+
+.app-header .brand-title {
+  font-size: 16px;
+  font-weight: 600;
+  color: var(--text-primary);
+  letter-spacing: 0.2px;
+}
+
+.app-header .brand-subtitle {
+  font-size: 12px;
+  color: var(--text-muted);
+  margin-top: 2px;
+}
+
+.app-header .header-right {
+  display: flex;
+  align-items: center;
+  gap: 16px;
+  font-size: 12px;
+  color: var(--text-muted);
+}
+
+.app-header .model-badge {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  padding: 5px 10px;
+  background: var(--accent-soft);
+  color: var(--accent);
+  border: 1px solid rgba(59, 130, 246, 0.3);
+  border-radius: 999px;
+  font-size: 12px;
+  font-weight: 500;
+}
+
+.app-header .model-badge .dot {
+  width: 6px;
+  height: 6px;
+  border-radius: 50%;
+  background: var(--success);
+  box-shadow: 0 0 6px var(--success);
+}
+
+.app-header .model-badge .dot.offline {
+  background: var(--text-muted);
+  box-shadow: none;
+}
+
+/* 主体两栏 */
+.app-body {
+  flex: 1;
+  display: flex;
+  min-height: 0;
+}
+
+.sidebar {
+  width: var(--sidebar-width);
+  flex-shrink: 0;
+  background: var(--bg-secondary);
+  border-right: 1px solid var(--border-color);
+  padding: 20px;
+  overflow-y: auto;
+  display: flex;
+  flex-direction: column;
+  gap: 20px;
+}
+
+.main-content {
+  flex: 1;
+  min-width: 0;
+  padding: 24px;
+  overflow-y: auto;
+  display: flex;
+  flex-direction: column;
+}
+
+/* ====================== 输入区 ====================== */
+
+.input-card {
+  background: var(--bg-elevated);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-md);
+  padding: 16px;
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+}
+
+.input-card .card-title {
+  font-size: 13px;
+  font-weight: 600;
+  color: var(--text-secondary);
+  text-transform: uppercase;
+  letter-spacing: 0.6px;
+  margin: 0;
+}
+
+.input-card .path-input {
+  width: 100%;
+  padding: 10px 12px;
+  background: var(--bg-primary);
+  border: 1px solid var(--border-strong);
+  border-radius: var(--radius-sm);
+  color: var(--text-primary);
+  font-size: 13px;
+  transition: border-color 0.15s, box-shadow 0.15s;
+}
+
+.input-card .path-input:focus {
+  border-color: var(--accent);
+  box-shadow: 0 0 0 3px var(--accent-soft);
+}
+
+.input-card .path-input:disabled {
+  opacity: 0.6;
+  cursor: not-allowed;
+}
+
+.input-card .hint {
+  font-size: 11px;
+  color: var(--text-muted);
+  margin: 0;
+}
+
+.btn {
+  padding: 10px 16px;
+  border-radius: var(--radius-sm);
+  font-size: 13px;
+  font-weight: 500;
+  transition: background 0.15s, transform 0.05s, opacity 0.15s;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: 8px;
+}
+
+.btn:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
+.btn-primary {
+  background: var(--accent);
+  color: white;
+}
+
+.btn-primary:hover:not(:disabled) {
+  background: var(--accent-hover);
+}
+
+.btn-primary:active:not(:disabled) {
+  transform: translateY(1px);
+}
+
+.btn-secondary {
+  background: var(--bg-tertiary);
+  color: var(--text-primary);
+  border: 1px solid var(--border-strong);
+}
+
+.btn-secondary:hover:not(:disabled) {
+  background: var(--border-strong);
+}
+
+/* ====================== 进度条 ====================== */
+
+.progress-section .section-label {
+  display: flex;
+  justify-content: space-between;
+  align-items: baseline;
+  font-size: 12px;
+  color: var(--text-muted);
+  margin-bottom: 8px;
+}
+
+.progress-section .section-label .progress-value {
+  color: var(--text-primary);
+  font-weight: 600;
+  font-variant-numeric: tabular-nums;
+}
+
+.progress-bar-track {
+  width: 100%;
+  height: 8px;
+  background: var(--bg-tertiary);
+  border-radius: 999px;
+  overflow: hidden;
+  position: relative;
+}
+
+.progress-bar-fill {
+  height: 100%;
+  background: linear-gradient(90deg, var(--accent), var(--info));
+  border-radius: 999px;
+  transition: width 0.4s ease;
+  position: relative;
+}
+
+.progress-bar-fill::after {
+  content: '';
+  position: absolute;
+  inset: 0;
+  background: linear-gradient(
+    90deg,
+    transparent,
+    rgba(255, 255, 255, 0.3),
+    transparent
+  );
+  animation: shimmer 1.6s infinite;
+}
+
+.progress-bar-fill.idle::after {
+  display: none;
+}
+
+@keyframes shimmer {
+  0% { transform: translateX(-100%); }
+  100% { transform: translateX(100%); }
+}
+
+/* ====================== 步骤时间线 ====================== */
+
+.timeline {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+  position: relative;
+}
+
+.timeline-step {
+  display: flex;
+  gap: 12px;
+  padding: 8px 4px;
+  border-radius: var(--radius-sm);
+  transition: background 0.15s;
+  position: relative;
+}
+
+.timeline-step:hover {
+  background: rgba(255, 255, 255, 0.02);
+}
+
+.timeline-step.active {
+  background: var(--accent-soft);
+}
+
+.timeline-step .step-marker {
+  position: relative;
+  flex-shrink: 0;
+  width: 28px;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+}
+
+.timeline-step .step-icon {
+  width: 24px;
+  height: 24px;
+  border-radius: 50%;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  font-size: 12px;
+  font-weight: 600;
+  border: 2px solid var(--border-strong);
+  background: var(--bg-primary);
+  color: var(--text-muted);
+  flex-shrink: 0;
+  z-index: 1;
+}
+
+.timeline-step .step-line {
+  width: 2px;
+  flex: 1;
+  background: var(--border-color);
+  margin-top: 2px;
+  min-height: 8px;
+}
+
+.timeline-step:last-child .step-line {
+  display: none;
+}
+
+.timeline-step .step-icon.pending {
+  color: var(--text-muted);
+}
+
+.timeline-step .step-icon.running {
+  border-color: var(--accent);
+  color: var(--accent);
+  background: var(--accent-soft);
+}
+
+.timeline-step .step-icon.done {
+  border-color: var(--success);
+  background: var(--success);
+  color: white;
+}
+
+.timeline-step .step-icon.failed {
+  border-color: var(--danger);
+  background: var(--danger);
+  color: white;
+}
+
+.timeline-step .step-icon.degraded {
+  border-color: var(--warning);
+  background: var(--warning);
+  color: white;
+}
+
+.timeline-step .step-icon.cached {
+  border-color: var(--info);
+  background: var(--info-soft);
+  color: var(--info);
+}
+
+.timeline-step .step-icon.running::before {
+  content: '';
+  position: absolute;
+  width: 24px;
+  height: 24px;
+  border-radius: 50%;
+  border: 2px solid var(--accent);
+  opacity: 0.6;
+  animation: pulse 1.4s ease-out infinite;
+}
+
+@keyframes pulse {
+  0% { transform: scale(1); opacity: 0.6; }
+  100% { transform: scale(1.8); opacity: 0; }
+}
+
+.timeline-step .step-body {
+  flex: 1;
+  min-width: 0;
+  padding-top: 2px;
+}
+
+.timeline-step .step-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+}
+
+.timeline-step .step-name {
+  font-size: 13px;
+  font-weight: 500;
+  color: var(--text-secondary);
+}
+
+.timeline-step.active .step-name {
+  color: var(--text-primary);
+}
+
+.timeline-step .step-status-tag {
+  font-size: 10px;
+  padding: 2px 6px;
+  border-radius: 4px;
+  text-transform: uppercase;
+  letter-spacing: 0.4px;
+  font-weight: 600;
+  flex-shrink: 0;
+}
+
+.step-status-tag.pending { color: var(--text-muted); background: var(--bg-tertiary); }
+.step-status-tag.running { color: var(--accent); background: var(--accent-soft); }
+.step-status-tag.done { color: var(--success); background: var(--success-soft); }
+.step-status-tag.failed { color: var(--danger); background: var(--danger-soft); }
+.step-status-tag.degraded { color: var(--warning); background: var(--warning-soft); }
+.step-status-tag.cached { color: var(--info); background: var(--info-soft); }
+
+.timeline-step .step-desc {
+  font-size: 11px;
+  color: var(--text-muted);
+  margin: 2px 0 0;
+}
+
+.timeline-step .step-message {
+  font-size: 12px;
+  color: var(--text-secondary);
+  margin-top: 4px;
+  word-break: break-word;
+  background: var(--bg-primary);
+  padding: 6px 8px;
+  border-radius: var(--radius-sm);
+  border-left: 2px solid var(--border-strong);
+}
+
+.timeline-step .step-message.failed { border-left-color: var(--danger); }
+.timeline-step .step-message.degraded { border-left-color: var(--warning); }
+.timeline-step .step-message.done { border-left-color: var(--success); }
+.timeline-step .step-message.running { border-left-color: var(--accent); }
+.timeline-step .step-message.cached { border-left-color: var(--info); }
+
+/* ====================== Tab 切换 ====================== */
+
+.tabs {
+  display: flex;
+  gap: 4px;
+  border-bottom: 1px solid var(--border-color);
+  margin-bottom: 20px;
+  flex-shrink: 0;
+}
+
+.tab {
+  padding: 10px 16px;
+  background: transparent;
+  color: var(--text-muted);
+  font-size: 13px;
+  font-weight: 500;
+  border-bottom: 2px solid transparent;
+  margin-bottom: -1px;
+  transition: color 0.15s, border-color 0.15s;
+}
+
+.tab:hover {
+  color: var(--text-secondary);
+}
+
+.tab.active {
+  color: var(--accent);
+  border-bottom-color: var(--accent);
+}
+
+.tab .badge {
+  display: inline-block;
+  margin-left: 6px;
+  padding: 1px 6px;
+  background: var(--bg-tertiary);
+  color: var(--text-muted);
+  border-radius: 999px;
+  font-size: 10px;
+  font-weight: 600;
+}
+
+.tab.active .badge {
+  background: var(--accent-soft);
+  color: var(--accent);
+}
+
+/* ====================== 报告区 ====================== */
+
+.report-container {
+  background: var(--bg-elevated);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-md);
+  padding: 32px 40px;
+  min-height: 100%;
+  overflow-y: auto;
+}
+
+.report-empty {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  height: 100%;
+  min-height: 300px;
+  color: var(--text-muted);
+  text-align: center;
+  gap: 12px;
+}
+
+.report-empty .empty-icon {
+  width: 64px;
+  height: 64px;
+  border-radius: 50%;
+  background: var(--bg-tertiary);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  font-size: 28px;
+  color: var(--text-muted);
+  margin-bottom: 8px;
+}
+
+.report-empty .empty-title {
+  font-size: 15px;
+  color: var(--text-secondary);
+  font-weight: 500;
+}
+
+.report-empty .empty-desc {
+  font-size: 13px;
+  max-width: 360px;
+}
+
+/* ====================== Markdown 样式 ====================== */
+
+.markdown-body {
+  color: var(--text-primary);
+  font-size: 14px;
+  line-height: 1.75;
+}
+
+.markdown-body h1,
+.markdown-body h2,
+.markdown-body h3,
+.markdown-body h4 {
+  color: var(--text-primary);
+  font-weight: 600;
+  margin: 24px 0 12px;
+  line-height: 1.3;
+}
+
+.markdown-body h1 {
+  font-size: 24px;
+  padding-bottom: 8px;
+  border-bottom: 1px solid var(--border-color);
+}
+
+.markdown-body h2 {
+  font-size: 20px;
+  padding-bottom: 6px;
+  border-bottom: 1px solid var(--border-color);
+}
+
+.markdown-body h3 { font-size: 17px; }
+.markdown-body h4 { font-size: 15px; color: var(--text-secondary); }
+
+.markdown-body p {
+  margin: 0 0 14px;
+}
+
+.markdown-body a {
+  color: var(--accent);
+  text-decoration: none;
+}
+
+.markdown-body a:hover {
+  text-decoration: underline;
+}
+
+.markdown-body ul,
+.markdown-body ol {
+  margin: 0 0 14px;
+  padding-left: 24px;
+}
+
+.markdown-body li {
+  margin: 4px 0;
+}
+
+.markdown-body blockquote {
+  margin: 14px 0;
+  padding: 8px 16px;
+  border-left: 4px solid var(--accent);
+  background: var(--accent-soft);
+  color: var(--text-secondary);
+  border-radius: 0 var(--radius-sm) var(--radius-sm) 0;
+}
+
+.markdown-body code {
+  background: var(--bg-tertiary);
+  color: var(--info);
+  padding: 2px 6px;
+  border-radius: 4px;
+  font-size: 13px;
+  font-family: 'SFMono-Regular', Consolas, 'Liberation Mono', Menlo, monospace;
+}
+
+.markdown-body pre {
+  background: var(--bg-primary);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  padding: 14px 16px;
+  overflow-x: auto;
+  margin: 14px 0;
+}
+
+.markdown-body pre code {
+  background: transparent;
+  color: var(--text-primary);
+  padding: 0;
+  font-size: 13px;
+}
+
+.markdown-body table {
+  width: 100%;
+  border-collapse: collapse;
+  margin: 14px 0;
+  font-size: 13px;
+}
+
+.markdown-body th,
+.markdown-body td {
+  border: 1px solid var(--border-color);
+  padding: 8px 12px;
+  text-align: left;
+}
+
+.markdown-body th {
+  background: var(--bg-tertiary);
+  font-weight: 600;
+  color: var(--text-primary);
+}
+
+.markdown-body tr:nth-child(even) td {
+  background: rgba(255, 255, 255, 0.015);
+}
+
+.markdown-body hr {
+  border: none;
+  border-top: 1px solid var(--border-color);
+  margin: 20px 0;
+}
+
+.markdown-body strong {
+  color: var(--text-primary);
+  font-weight: 600;
+}
+
+/* ====================== 评估面板 ====================== */
+
+.eval-panel {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+  gap: 16px;
+  margin-bottom: 24px;
+}
+
+.metric-card {
+  background: var(--bg-elevated);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-md);
+  padding: 16px;
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+}
+
+.metric-card .metric-label {
+  font-size: 12px;
+  color: var(--text-muted);
+  text-transform: uppercase;
+  letter-spacing: 0.5px;
+}
+
+.metric-card .metric-value {
+  font-size: 26px;
+  font-weight: 700;
+  color: var(--text-primary);
+  font-variant-numeric: tabular-nums;
+  line-height: 1.1;
+}
+
+.metric-card .metric-value.success { color: var(--success); }
+.metric-card .metric-value.warning { color: var(--warning); }
+.metric-card .metric-value.danger { color: var(--danger); }
+
+.metric-card .metric-sub {
+  font-size: 11px;
+  color: var(--text-muted);
+}
+
+.metric-card .metric-bar {
+  margin-top: 6px;
+  height: 6px;
+  background: var(--bg-tertiary);
+  border-radius: 999px;
+  overflow: hidden;
+}
+
+.metric-card .metric-bar-fill {
+  height: 100%;
+  border-radius: 999px;
+  transition: width 0.5s ease;
+}
+
+.metric-bar-fill.success { background: var(--success); }
+.metric-bar-fill.warning { background: var(--warning); }
+.metric-bar-fill.danger { background: var(--danger); }
+
+/* 三维评分条形图 */
+.score-section {
+  background: var(--bg-elevated);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-md);
+  padding: 20px;
+  margin-bottom: 24px;
+}
+
+.score-section .section-title {
+  font-size: 14px;
+  font-weight: 600;
+  color: var(--text-primary);
+  margin: 0 0 16px;
+}
+
+.score-item {
+  margin-bottom: 14px;
+}
+
+.score-item:last-child { margin-bottom: 0; }
+
+.score-item .score-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: baseline;
+  margin-bottom: 6px;
+}
+
+.score-item .score-name {
+  font-size: 13px;
+  color: var(--text-secondary);
+  font-weight: 500;
+}
+
+.score-item .score-num {
+  font-size: 13px;
+  color: var(--text-primary);
+  font-weight: 600;
+  font-variant-numeric: tabular-nums;
+}
+
+.score-item .score-track {
+  height: 8px;
+  background: var(--bg-tertiary);
+  border-radius: 999px;
+  overflow: hidden;
+}
+
+.score-item .score-fill {
+  height: 100%;
+  border-radius: 999px;
+  transition: width 0.6s ease;
+}
+
+.score-fill.novelty { background: var(--score-novelty); }
+.score-fill.feasibility { background: var(--score-feasibility); }
+.score-fill.significance { background: var(--score-significance); }
+
+/* 工具调用列表 */
+.tool-list {
+  background: var(--bg-elevated);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-md);
+  padding: 20px;
+}
+
+.tool-list .section-title {
+  font-size: 14px;
+  font-weight: 600;
+  color: var(--text-primary);
+  margin: 0 0 12px;
+}
+
+.tool-row {
+  display: grid;
+  grid-template-columns: 1.5fr 2fr 0.8fr 0.8fr;
+  gap: 12px;
+  padding: 8px 0;
+  border-bottom: 1px solid var(--border-color);
+  font-size: 12px;
+  align-items: center;
+}
+
+.tool-row:last-child { border-bottom: none; }
+
+.tool-row .tool-name {
+  font-weight: 500;
+  color: var(--text-primary);
+  font-family: 'SFMono-Regular', Consolas, monospace;
+}
+
+.tool-row .tool-args {
+  color: var(--text-muted);
+  font-family: 'SFMono-Regular', Consolas, monospace;
+  font-size: 11px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.tool-row .tool-status {
+  font-size: 11px;
+  font-weight: 600;
+  padding: 2px 8px;
+  border-radius: 4px;
+  display: inline-block;
+  text-align: center;
+}
+
+.tool-status.ok { color: var(--success); background: var(--success-soft); }
+.tool-status.fail { color: var(--danger); background: var(--danger-soft); }
+
+.tool-row .tool-duration {
+  color: var(--text-muted);
+  font-variant-numeric: tabular-nums;
+  text-align: right;
+}
+
+/* ====================== 错误提示 ====================== */
+
+.error-banner {
+  background: var(--danger-soft);
+  border: 1px solid var(--danger);
+  border-radius: var(--radius-md);
+  padding: 12px 16px;
+  margin-bottom: 16px;
+  display: flex;
+  align-items: flex-start;
+  gap: 12px;
+}
+
+.error-banner .error-icon {
+  color: var(--danger);
+  font-weight: 700;
+  flex-shrink: 0;
+}
+
+.error-banner .error-text {
+  flex: 1;
+  color: var(--text-primary);
+  font-size: 13px;
+  word-break: break-word;
+}
+
+.error-banner .error-actions {
+  display: flex;
+  gap: 8px;
+  flex-shrink: 0;
+}
+
+/* ====================== 加载与状态 ====================== */
+
+.loading-overlay {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  color: var(--text-muted);
+  font-size: 13px;
+}
+
+.spinner {
+  width: 14px;
+  height: 14px;
+  border: 2px solid var(--border-strong);
+  border-top-color: var(--accent);
+  border-radius: 50%;
+  animation: spin 0.8s linear infinite;
+}
+
+@keyframes spin {
+  to { transform: rotate(360deg); }
+}
+
+.section-divider {
+  font-size: 11px;
+  font-weight: 600;
+  color: var(--text-muted);
+  text-transform: uppercase;
+  letter-spacing: 0.6px;
+  margin: 0 0 8px;
+}
+
+/* ====================== 输入模式切换 ====================== */
+
+.mode-toggle {
+  display: flex;
+  gap: 4px;
+  background: var(--bg-primary);
+  border: 1px solid var(--border-strong);
+  border-radius: var(--radius-sm);
+  padding: 3px;
+}
+
+.mode-btn {
+  flex: 1;
+  padding: 7px 10px;
+  background: transparent;
+  color: var(--text-muted);
+  font-size: 12px;
+  font-weight: 500;
+  border-radius: 4px;
+  transition: background 0.15s, color 0.15s;
+}
+
+.mode-btn:hover:not(:disabled) {
+  color: var(--text-secondary);
+}
+
+.mode-btn.active {
+  background: var(--accent);
+  color: white;
+}
+
+.mode-btn:disabled {
+  cursor: not-allowed;
+  opacity: 0.5;
+}
+
+/* ====================== 研究方向输入 ====================== */
+
+.research-direction {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+}
+
+.research-direction .research-label {
+  font-size: 12px;
+  color: var(--text-secondary);
+  font-weight: 500;
+}
+
+/* ====================== 论文库组件 ====================== */
+
+.paper-library {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+}
+
+.upload-area {
+  display: flex;
+}
+
+.btn-upload {
+  flex: 1;
+  padding: 10px;
+  background: var(--bg-primary);
+  color: var(--accent);
+  border: 1px dashed var(--border-strong);
+  border-radius: var(--radius-sm);
+  font-size: 13px;
+  font-weight: 500;
+  transition: border-color 0.15s, background 0.15s;
+}
+
+.btn-upload:hover:not(:disabled) {
+  border-color: var(--accent);
+  background: var(--accent-soft);
+}
+
+.btn-upload:disabled {
+  cursor: not-allowed;
+  opacity: 0.5;
+}
+
+.paper-list {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  max-height: 320px;
+  overflow-y: auto;
+}
+
+.empty-hint {
+  font-size: 12px;
+  color: var(--text-muted);
+  text-align: center;
+  padding: 16px 8px;
+  margin: 0;
+}
+
+.paper-item {
+  display: flex;
+  align-items: flex-start;
+  gap: 8px;
+  padding: 8px 10px;
+  background: var(--bg-primary);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  transition: border-color 0.15s, background 0.15s;
+}
+
+.paper-item:hover:not(.disabled) {
+  border-color: var(--border-strong);
+}
+
+.paper-item.selected {
+  border-color: var(--accent);
+  background: var(--accent-soft);
+}
+
+.paper-item.disabled {
+  opacity: 0.6;
+}
+
+.paper-checkbox {
+  flex-shrink: 0;
+  padding-top: 2px;
+}
+
+.paper-checkbox input[type="checkbox"] {
+  width: 14px;
+  height: 14px;
+  accent-color: var(--accent);
+  cursor: pointer;
+}
+
+.paper-info {
+  flex: 1;
+  min-width: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 3px;
+}
+
+.paper-title {
+  font-size: 12px;
+  font-weight: 500;
+  color: var(--text-primary);
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.paper-filename {
+  font-size: 11px;
+  color: var(--text-muted);
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  font-family: 'SFMono-Regular', Consolas, monospace;
+}
+
+.paper-status {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 4px;
+  margin-top: 2px;
+}
+
+.status-badge {
+  display: inline-flex;
+  align-items: center;
+  gap: 3px;
+  padding: 1px 6px;
+  border-radius: 4px;
+  font-size: 10px;
+  font-weight: 500;
+}
+
+.status-badge.status-done { color: var(--success); background: var(--success-soft); }
+.status-badge.status-failed { color: var(--danger); background: var(--danger-soft); }
+.status-badge.status-pending { color: var(--text-muted); background: var(--bg-tertiary); }
+.status-badge.status-cached { color: var(--info); background: var(--info-soft); }
+
+.btn-icon {
+  flex-shrink: 0;
+  width: 22px;
+  height: 22px;
+  border-radius: 4px;
+  background: transparent;
+  color: var(--text-muted);
+  font-size: 12px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  transition: background 0.15s, color 0.15s;
+}
+
+.btn-icon:hover:not(:disabled) {
+  background: var(--danger-soft);
+  color: var(--danger);
+}
+
+.btn-icon:disabled {
+  cursor: not-allowed;
+  opacity: 0.4;
+}
+
+.selected-count {
+  font-size: 11px;
+  color: var(--accent);
+  font-weight: 500;
+  text-align: right;
+}
+
+/* ====================== 响应式 ====================== */
+
+@media (max-width: 960px) {
+  .app-body {
+    flex-direction: column;
+  }
+  .sidebar {
+    width: 100%;
+    border-right: none;
+    border-bottom: 1px solid var(--border-color);
+    max-height: 50vh;
+  }
+  .main-content {
+    padding: 16px;
+  }
+  .report-container {
+    padding: 20px;
+  }
+  .app-header {
+    padding: 0 16px;
+  }
+  .app-header .brand-subtitle {
+    display: none;
+  }
+}
+
+@media (max-width: 600px) {
+  .eval-panel {
+    grid-template-columns: 1fr;
+  }
+  .tool-row {
+    grid-template-columns: 1fr;
+    gap: 4px;
+  }
+  .tool-row .tool-duration,
+  .tool-row .tool-status {
+    text-align: left;
+  }
+}
+
+/* 滚动条美化 */
+::-webkit-scrollbar {
+  width: 8px;
+  height: 8px;
+}
+
+::-webkit-scrollbar-track {
+  background: var(--bg-primary);
+}
+
+::-webkit-scrollbar-thumb {
+  background: var(--border-strong);
+  border-radius: 4px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+  background: var(--text-muted);
+}

+ 10 - 0
Co-creation-projects/jphJack-PaperMindAgent/frontend/src/main.tsx

@@ -0,0 +1,10 @@
+import React from 'react'
+import ReactDOM from 'react-dom/client'
+import App from './App'
+import './index.css'
+
+ReactDOM.createRoot(document.getElementById('root')!).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>,
+)

+ 162 - 0
Co-creation-projects/jphJack-PaperMindAgent/frontend/src/types.ts

@@ -0,0 +1,162 @@
+// 前端共享类型定义:与后端 backend/models/schemas.py 保持一致
+
+/** 七步漏斗式信息收敛链路的阶段标识 */
+export type StageKey =
+  | 'step1_parse'
+  | 'step2_extract'
+  | 'step3_index'
+  | 'step4_gap'
+  | 'step5_innovation'
+  | 'step6_experiment'
+  | 'step7_integrate'
+
+/** 单步状态:待执行 / 运行中 / 完成 / 失败 / 降级 / 复用缓存 */
+export type StepStatus = 'pending' | 'running' | 'done' | 'failed' | 'degraded' | 'cached'
+
+/** 后端推送的进度事件(SSE 单条 data 反序列化结果) */
+export interface ProgressEvent {
+  stage: StageKey
+  status: 'running' | 'done' | 'failed' | 'degraded' | 'cached'
+  message: string
+  /** 整体进度 0-1 */
+  progress: number
+  /** 附加载荷,例如该步骤的中间产物摘要 */
+  payload?: Record<string, unknown> | null
+}
+
+/** 三维评分:新颖性 / 可行性 / 显著性,0-10 分 */
+export interface ThreeDScore {
+  novelty: number
+  feasibility: number
+  significance: number
+}
+
+/** 工具调用记录 */
+export interface ToolCallRecord {
+  tool_name: string
+  args_summary: string
+  success: boolean
+  duration_sec: number
+  error?: string | null
+  timestamp?: string
+}
+
+/** 评估报告:随最终报告一并输出 */
+export interface Evaluation {
+  innovations_scores: ThreeDScore[]
+  /** 工具调用成功率 0-1 */
+  tool_call_success_rate: number
+  total_tool_calls: number
+  failed_tool_calls: number
+  /** 平均自校验置信度 0-1 */
+  avg_confidence: number
+  tool_calls: ToolCallRecord[]
+}
+
+/** 创新点 */
+export interface Innovation {
+  title: string
+  idea: string
+  source: string
+  gap_origin: string
+  score: ThreeDScore
+  novelty_check?: string | null
+  supporting_evidence?: string
+}
+
+/** 实验方案 */
+export interface ExperimentPlan {
+  innovation_title: string
+  hypothesis: string
+  datasets: string[]
+  baselines: string[]
+  metrics: string[]
+  ablation: string[]
+  steps: string[]
+  expected_results: string
+  risks: string
+}
+
+/** 后端最终报告(步骤7 整合输出)的结构化对象 */
+export interface FinalReport {
+  background_review?: string
+  innovations?: Innovation[]
+  experiment_plans?: ExperimentPlan[]
+  references?: Array<Record<string, unknown>>
+  evaluation?: Evaluation | null
+  markdown?: string
+  generated_at?: string
+}
+
+/** GET /api/report/{task_id} 的响应 */
+export interface Report {
+  markdown: string
+  report: FinalReport
+  evaluation: Evaluation | null
+  status: string
+}
+
+/** GET /api/tasks/{task_id} 的响应 */
+export interface TaskStatus {
+  task_id: string
+  status: string
+  progress: number
+  current_stage?: StageKey | null
+}
+
+/** GET /api/health 的响应 */
+export interface HealthInfo {
+  status: string
+  model: string
+}
+
+/** 步骤元信息:用于时间线渲染 */
+export interface StageInfo {
+  key: StageKey
+  label: string
+  description: string
+}
+
+/** 七步链路定义(与后端 StepStage 枚举对齐) */
+export const STAGE_LIST: StageInfo[] = [
+  { key: 'step1_parse', label: '论文解析', description: 'PyMuPDF 解析 PDF 章节结构(已预处理则复用缓存)' },
+  { key: 'step2_extract', label: '结构化抽取', description: '单篇字段抽取 + Reflexion 自校验(已预处理则复用缓存)' },
+  { key: 'step3_index', label: '向量索引构建', description: 'BGE-m3 嵌入 + Chroma + BM25 混合检索(已预处理则复用缓存)' },
+  { key: 'step4_gap', label: 'Gap 识别', description: '跨论文综合分析,识别研究空白' },
+  { key: 'step5_innovation', label: '创新点生成', description: '生成并筛选 2-3 个创新点(结合研究方向)' },
+  { key: 'step6_experiment', label: '实验方案设计', description: '为创新点设计完整实验方案' },
+  { key: 'step7_integrate', label: '整合输出', description: '生成 Markdown 研究提案报告' },
+]
+
+/** 预处理状态 */
+export type PreprocessStatus = 'pending' | 'done' | 'failed'
+
+/** 论文库中的论文元数据 */
+export interface Paper {
+  paper_id: string
+  filename: string
+  source: 'upload' | 'folder'
+  original_path: string
+  upload_time: string
+  title: string
+  parse_status: PreprocessStatus
+  extract_status: PreprocessStatus
+  index_status: PreprocessStatus
+  parsed_at?: string | null
+  extracted_at?: string | null
+  indexed_at?: string | null
+}
+
+/** 上传论文响应 */
+export interface UploadResponse {
+  paper_id: string
+  filename: string
+  duplicate: boolean
+}
+
+/** 分析请求参数 */
+export interface AnalyzeParams {
+  folder_path?: string
+  paper_ids?: string[]
+  research_direction?: string
+}

+ 20 - 0
Co-creation-projects/jphJack-PaperMindAgent/frontend/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "strict": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src"]
+}

+ 15 - 0
Co-creation-projects/jphJack-PaperMindAgent/frontend/vite.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+
+export default defineConfig({
+  plugins: [react()],
+  server: {
+    port: 5173,
+    proxy: {
+      '/api': {
+        target: 'http://localhost:8000',
+        changeOrigin: true,
+      },
+    },
+  },
+})

+ 193 - 0
Co-creation-projects/jphJack-PaperMindAgent/main.ipynb

@@ -0,0 +1,193 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# PaperMind · 论文创新点发现 Agent\n",
+    "\n",
+    "## 项目简介\n",
+    "PaperMind 是一个面向研究生的多 Agent 协作系统:批量阅读本地 PDF 论文 → 漏斗式信息收敛 → 识别研究空白 → 生成 2-3 个可落地的创新点与完整实验方案。\n",
+    "\n",
+    "本项目构建在 **HelloAgents 框架** 之上:LLM 调用走框架 `HelloAgentsLLM`,工具经桥接注册为框架 `ToolRegistry`,质量审核由框架 `SimpleAgent` 执行。\n",
+    "\n",
+    "## 作者信息\n",
+    "- 姓名:jphJack\n",
+    "- GitHub:[@jphJack](https://github.com/jphJack)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 第 1 部分:环境配置"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 安装依赖(HelloAgents 框架)\n",
+    "!pip install -q \"hello-agents[all]\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 导入 HelloAgents 框架与 PaperMind 组件\n",
+    "import os\n",
+    "import sys\n",
+    "\n",
+    "sys.path.append(os.path.abspath(\".\"))  # 使 backend 包可导入\n",
+    "\n",
+    "from hello_agents import HelloAgentsLLM, ReActAgent, SimpleAgent\n",
+    "\n",
+    "from backend.config import settings\n",
+    "from backend.llm.client import DeepSeekClient\n",
+    "from backend.tools.registry import build_default_registry\n",
+    "from backend.tools.hello_agents_bridge import build_hello_agents_registry\n",
+    "from backend.agents.hello_agents_runner import build_reviewer_agent, build_react_agent\n",
+    "\n",
+    "print(\"HelloAgents 框架与 PaperMind 组件导入成功\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 第 2 部分:HelloAgents 框架 LLM 客户端\n",
+    "\n",
+    "PaperMind 的全部模型调用经框架 `HelloAgentsLLM` 发出(OpenAI 兼容适配器自动识别 DeepSeek)。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# DeepSeekClient 底层即框架 HelloAgentsLLM\n",
+    "client = DeepSeekClient()\n",
+    "print(\"底层 LLM 类型:\", type(client.llm).__name__)\n",
+    "print(\"模型:\", client.model)\n",
+    "print(\"服务地址:\", settings.DEEPSEEK_BASE_URL)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 第 3 部分:工具桥接(项目工具 → 框架 ToolRegistry)\n",
+    "\n",
+    "项目的 10+ Function Calling 工具经桥接成为框架原生 Tool(ToolResponse 协议 + 熔断器保护)。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 构建项目工具注册表,并桥接为框架 ToolRegistry\n",
+    "project_registry = build_default_registry()\n",
+    "print(\"项目工具:\", project_registry.names())\n",
+    "\n",
+    "ha_registry = build_hello_agents_registry(project_registry)\n",
+    "print(\"框架工具:\", ha_registry.list_tools())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 第 4 部分:框架 Agent 构建\n",
+    "\n",
+    "- `SimpleAgent`:Reflexion 质量审核(纯推理)\n",
+    "- `ReActAgent`:携带完整工具集的推理-行动调度"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 质量审核 Agent(框架 SimpleAgent)\n",
+    "reviewer = build_reviewer_agent(client.llm)\n",
+    "print(\"审核 Agent:\", type(reviewer).__name__, \"-\", reviewer.name)\n",
+    "\n",
+    "# GapAnalyzer 步骤的框架 ReActAgent(携带桥接工具集)\n",
+    "gap_agent = build_react_agent(\n",
+    "    name=\"GapAnalyzer\",\n",
+    "    llm=client.llm,\n",
+    "    registry=project_registry,\n",
+    "    system_prompt=\"你是研究空白(Gap)识别专家,使用 analyze_gaps 与 hybrid_search 工具识别四类研究空白。\",\n",
+    "    tool_names=[\"analyze_gaps\", \"hybrid_search\"],\n",
+    ")\n",
+    "print(\"步骤 Agent:\", type(gap_agent).__name__, \"-\", gap_agent.name)\n",
+    "print(\"已注册工具:\", gap_agent.tool_registry.list_tools())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 第 5 部分:集成自检\n",
+    "\n",
+    "无需真实 API Key 的冒烟验证,确认三层集成接线正确。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 冒烟自检\n",
+    "from hello_agents.tools.response import ToolStatus\n",
+    "\n",
+    "tool = ha_registry.get_tool(\"scan_folder\")\n",
+    "schema = tool.to_openai_schema()\n",
+    "assert schema[\"function\"][\"name\"] == \"scan_folder\"\n",
+    "assert type(client.llm).__name__ == \"HelloAgentsLLM\"\n",
+    "assert type(reviewer).__name__ == \"SimpleAgent\"\n",
+    "assert type(gap_agent).__name__ == \"ReActAgent\"\n",
+    "print(\"HelloAgents 三层集成自检通过:LLM 层 / 工具层 / Agent 层\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 第 6 部分:完整流水线\n",
+    "\n",
+    "配置 `DEEPSEEK_API_KEY` 后,完整七步漏斗流水线(PDF 解析 → 结构化抽取 → 向量索引 → Gap 识别 → 创新点生成 → 实验方案设计 → 整合报告)由后端 API 提供:\n",
+    "\n",
+    "```bash\n",
+    "python run_backend.py   # http://0.0.0.0:8000\n",
+    "cd frontend && npm run dev   # http://localhost:5173\n",
+    "```\n",
+    "\n",
+    "详见 [README.md](../README.md)。"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python",
+   "version": "3.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

+ 1426 - 0
Co-creation-projects/jphJack-PaperMindAgent/pipeline_walkthrough.html

@@ -0,0 +1,1426 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>PaperMind · 端到端运行流程详解</title>
+<style>
+  :root {
+    --bg: #0f1117;
+    --bg-elev: #161924;
+    --bg-card: #1c2030;
+    --bg-code: #0a0c14;
+    --border: #2a2f42;
+    --text: #e6e9f0;
+    --text-dim: #9aa0b0;
+    --text-mute: #6b7180;
+    --accent: #5b9dff;
+    --accent-2: #a78bfa;
+    --green: #4ade80;
+    --yellow: #fbbf24;
+    --red: #f87171;
+    --cyan: #22d3ee;
+    --pink: #f472b6;
+    --orange: #fb923c;
+    --step1: #60a5fa;
+    --step2: #a78bfa;
+    --step3: #22d3ee;
+    --step4: #4ade80;
+    --step5: #fbbf24;
+    --step6: #fb923c;
+    --step7: #f472b6;
+  }
+  * { box-sizing: border-box; margin: 0; padding: 0; }
+  html { scroll-behavior: smooth; }
+  body {
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", "PingFang SC", "Microsoft YaHei", sans-serif;
+    background: var(--bg);
+    color: var(--text);
+    line-height: 1.65;
+    font-size: 15px;
+  }
+  /* ===== Layout ===== */
+  .layout { display: flex; max-width: 1480px; margin: 0 auto; }
+  .sidebar {
+    position: sticky; top: 0; height: 100vh; width: 260px; flex-shrink: 0;
+    border-right: 1px solid var(--border);
+    background: var(--bg-elev);
+    overflow-y: auto;
+    padding: 24px 16px;
+  }
+  .sidebar h2 { font-size: 13px; color: var(--text-mute); text-transform: uppercase; letter-spacing: 1px; margin-bottom: 12px; padding: 0 8px; }
+  .sidebar a {
+    display: block; padding: 7px 12px; color: var(--text-dim); text-decoration: none;
+    border-radius: 6px; font-size: 13.5px; transition: all 0.15s;
+    border-left: 2px solid transparent;
+  }
+  .sidebar a:hover { color: var(--text); background: rgba(91,157,255,0.08); }
+  .sidebar a.active { color: var(--accent); background: rgba(91,157,255,0.12); border-left-color: var(--accent); }
+  .sidebar a.sub { padding-left: 24px; font-size: 12.5px; }
+  .main { flex: 1; min-width: 0; padding: 48px 56px 120px; }
+  /* ===== Hero ===== */
+  .hero {
+    background: linear-gradient(135deg, #1a1f3a 0%, #0f1117 60%);
+    border: 1px solid var(--border);
+    border-radius: 16px;
+    padding: 48px 44px;
+    margin-bottom: 48px;
+    position: relative;
+    overflow: hidden;
+  }
+  .hero::before {
+    content: ""; position: absolute; top: -50%; right: -10%; width: 500px; height: 500px;
+    background: radial-gradient(circle, rgba(91,157,255,0.15), transparent 70%);
+    pointer-events: none;
+  }
+  .hero h1 { font-size: 34px; font-weight: 700; margin-bottom: 12px; background: linear-gradient(90deg, #fff, #9aa0b0); -webkit-background-clip: text; -webkit-text-fill-color: transparent; }
+  .hero .sub { font-size: 16px; color: var(--text-dim); max-width: 760px; }
+  .hero .meta { margin-top: 24px; display: flex; gap: 12px; flex-wrap: wrap; }
+  .badge { background: rgba(91,157,255,0.12); border: 1px solid rgba(91,157,255,0.3); color: var(--accent); padding: 4px 12px; border-radius: 999px; font-size: 12.5px; }
+  /* ===== Section ===== */
+  section { margin-bottom: 56px; scroll-margin-top: 20px; }
+  h2.section-title {
+    font-size: 24px; font-weight: 700; margin-bottom: 8px;
+    padding-bottom: 12px; border-bottom: 1px solid var(--border);
+    display: flex; align-items: center; gap: 10px;
+  }
+  h2.section-title .num {
+    display: inline-flex; align-items: center; justify-content: center;
+    width: 32px; height: 32px; border-radius: 8px;
+    background: linear-gradient(135deg, var(--accent), var(--accent-2));
+    color: #fff; font-size: 15px; font-weight: 700;
+  }
+  .section-desc { color: var(--text-dim); margin-bottom: 24px; font-size: 14.5px; }
+  h3 { font-size: 18px; font-weight: 600; margin: 28px 0 14px; color: var(--text); }
+  h4 { font-size: 15px; font-weight: 600; margin: 18px 0 10px; color: var(--accent); }
+  p { margin-bottom: 10px; }
+  /* ===== Cards ===== */
+  .card {
+    background: var(--bg-card);
+    border: 1px solid var(--border);
+    border-radius: 12px;
+    padding: 22px 24px;
+    margin-bottom: 18px;
+  }
+  .card.glow { box-shadow: 0 0 0 1px rgba(91,157,255,0.15), 0 8px 32px rgba(0,0,0,0.3); }
+  .step-card { border-left: 3px solid var(--accent); }
+  .step-card.s1 { border-left-color: var(--step1); }
+  .step-card.s2 { border-left-color: var(--step2); }
+  .step-card.s3 { border-left-color: var(--step3); }
+  .step-card.s4 { border-left-color: var(--step4); }
+  .step-card.s5 { border-left-color: var(--step5); }
+  .step-card.s6 { border-left-color: var(--step6); }
+  .step-card.s7 { border-left-color: var(--step7); }
+  .step-header { display: flex; align-items: center; justify-content: space-between; margin-bottom: 14px; flex-wrap: wrap; gap: 10px; }
+  .step-tag {
+    display: inline-flex; align-items: center; gap: 8px;
+    padding: 5px 12px; border-radius: 6px; font-size: 13px; font-weight: 600;
+  }
+  .step-tag.s1 { background: rgba(96,165,250,0.15); color: var(--step1); }
+  .step-tag.s2 { background: rgba(167,139,250,0.15); color: var(--step2); }
+  .step-tag.s3 { background: rgba(34,211,238,0.15); color: var(--step3); }
+  .step-tag.s4 { background: rgba(74,222,128,0.15); color: var(--step4); }
+  .step-tag.s5 { background: rgba(251,191,36,0.15); color: var(--step5); }
+  .step-tag.s6 { background: rgba(251,146,60,0.15); color: var(--step6); }
+  .step-tag.s7 { background: rgba(244,114,182,0.15); color: var(--step7); }
+  .step-num { font-size: 18px; font-weight: 700; }
+  .step-title { font-size: 17px; font-weight: 600; }
+  .code-link {
+    font-family: "JetBrains Mono", Consolas, monospace; font-size: 12px;
+    color: var(--text-dim); text-decoration: none;
+    background: rgba(0,0,0,0.3); padding: 3px 8px; border-radius: 4px;
+    border: 1px solid var(--border);
+  }
+  .code-link:hover { color: var(--accent); border-color: var(--accent); }
+  /* ===== IO blocks ===== */
+  .io-grid { display: grid; grid-template-columns: 1fr 1fr; gap: 14px; margin: 14px 0; }
+  @media (max-width: 900px) { .io-grid { grid-template-columns: 1fr; } }
+  .io-box {
+    background: var(--bg-code); border: 1px solid var(--border); border-radius: 8px;
+    padding: 14px 16px;
+  }
+  .io-box .label {
+    font-size: 11px; font-weight: 700; text-transform: uppercase; letter-spacing: 1px;
+    margin-bottom: 8px; display: flex; align-items: center; gap: 6px;
+  }
+  .io-box.in .label { color: var(--cyan); }
+  .io-box.out .label { color: var(--green); }
+  .io-box .label::before { content: ""; width: 8px; height: 8px; border-radius: 50%; }
+  .io-box.in .label::before { background: var(--cyan); }
+  .io-box.out .label::before { background: var(--green); }
+  /* ===== Code blocks ===== */
+  pre {
+    background: var(--bg-code); border: 1px solid var(--border); border-radius: 8px;
+    padding: 14px 16px; overflow-x: auto; font-size: 12.5px; line-height: 1.55;
+    font-family: "JetBrains Mono", Consolas, "Courier New", monospace;
+    color: #d4d4dc;
+  }
+  pre.prompt {
+    background: linear-gradient(180deg, #14111f 0%, #0a0c14 100%);
+    border-color: rgba(167,139,250,0.3);
+  }
+  code.inline {
+    background: rgba(91,157,255,0.12); color: var(--accent);
+    padding: 1px 6px; border-radius: 4px; font-size: 12.5px;
+    font-family: "JetBrains Mono", Consolas, monospace;
+  }
+  .tok-sys { color: #c792ea; }
+  .tok-user { color: #82aaff; }
+  .tok-kw { color: #c792ea; }
+  .tok-str { color: #c3e88d; }
+  .tok-com { color: #6b7180; font-style: italic; }
+  .tok-num { color: #f78c6c; }
+  /* ===== Collapsible ===== */
+  details {
+    background: var(--bg-code); border: 1px solid var(--border); border-radius: 8px;
+    margin: 10px 0; overflow: hidden;
+  }
+  details[open] { border-color: rgba(167,139,250,0.4); }
+  summary {
+    cursor: pointer; padding: 12px 16px; font-size: 13.5px; font-weight: 600;
+    color: var(--accent-2); user-select: none;
+    display: flex; align-items: center; gap: 8px;
+    background: linear-gradient(90deg, rgba(167,139,250,0.08), transparent);
+  }
+  summary:hover { background: rgba(167,139,250,0.1); }
+  summary::before { content: "▸"; transition: transform 0.15s; font-size: 11px; }
+  details[open] summary::before { transform: rotate(90deg); }
+  details > pre, details > div { border: none; border-radius: 0; margin: 0; border-top: 1px solid var(--border); }
+  /* ===== Tables ===== */
+  table {
+    width: 100%; border-collapse: collapse; margin: 14px 0;
+    background: var(--bg-card); border: 1px solid var(--border); border-radius: 8px;
+    overflow: hidden; font-size: 13px;
+  }
+  th, td { padding: 10px 14px; text-align: left; border-bottom: 1px solid var(--border); vertical-align: top; }
+  th { background: rgba(91,157,255,0.06); color: var(--accent); font-weight: 600; font-size: 12px; text-transform: uppercase; letter-spacing: 0.5px; }
+  tr:last-child td { border-bottom: none; }
+  tr:hover td { background: rgba(91,157,255,0.04); }
+  /* ===== Pipeline diagram ===== */
+  .pipeline {
+    display: flex; flex-direction: column; gap: 0; margin: 24px 0;
+  }
+  .pipeline-row {
+    display: flex; align-items: stretch; gap: 0;
+  }
+  .pipe-node {
+    flex: 1; background: var(--bg-card); border: 1px solid var(--border);
+    border-radius: 10px; padding: 14px; position: relative;
+    transition: transform 0.15s;
+  }
+  .pipe-node:hover { transform: translateY(-2px); }
+  .pipe-node .pn-num {
+    font-size: 11px; font-weight: 700; color: var(--text-mute); margin-bottom: 4px;
+  }
+  .pipe-node .pn-title { font-size: 14px; font-weight: 600; margin-bottom: 4px; }
+  .pipe-node .pn-desc { font-size: 11.5px; color: var(--text-dim); line-height: 1.5; }
+  .pipe-node .pn-llm { font-size: 10.5px; margin-top: 6px; color: var(--accent-2); }
+  .pipe-arrow {
+    display: flex; align-items: center; justify-content: center;
+    width: 28px; color: var(--text-mute); font-size: 18px;
+  }
+  /* ===== Tags ===== */
+  .tag {
+    display: inline-block; padding: 2px 8px; border-radius: 4px;
+    font-size: 11px; font-weight: 600; margin-right: 4px;
+  }
+  .tag.llm { background: rgba(167,139,250,0.15); color: var(--accent-2); }
+  .tag.tool { background: rgba(34,211,238,0.15); color: var(--cyan); }
+  .tag.local { background: rgba(74,222,128,0.15); color: var(--green); }
+  .tag.cache { background: rgba(251,191,36,0.15); color: var(--yellow); }
+  .tag.degrade { background: rgba(248,113,113,0.15); color: var(--red); }
+  .tag.parallel { background: rgba(244,114,182,0.15); color: var(--pink); }
+  /* ===== List ===== */
+  ul, ol { margin: 8px 0 12px 22px; }
+  li { margin-bottom: 5px; }
+  li code.inline { font-size: 12px; }
+  .callout {
+    background: rgba(91,157,255,0.06); border-left: 3px solid var(--accent);
+    padding: 12px 16px; border-radius: 0 8px 8px 0; margin: 12px 0; font-size: 13.5px;
+  }
+  .callout.warn { background: rgba(251,191,36,0.06); border-color: var(--yellow); }
+  .callout.danger { background: rgba(248,113,113,0.06); border-color: var(--red); }
+  .callout.ok { background: rgba(74,222,128,0.06); border-color: var(--green); }
+  .flow-arrow { color: var(--text-mute); text-align: center; font-size: 18px; margin: 6px 0; }
+  .pill-row { display: flex; flex-wrap: wrap; gap: 6px; margin: 8px 0; }
+  .keyword { color: #c3e88d; }
+  .placeholder { color: #f78c6c; }
+  .footer { text-align: center; color: var(--text-mute); padding: 40px 0 0; border-top: 1px solid var(--border); margin-top: 60px; font-size: 12.5px; }
+  ::-webkit-scrollbar { width: 10px; height: 10px; }
+  ::-webkit-scrollbar-track { background: var(--bg); }
+  ::-webkit-scrollbar-thumb { background: var(--border); border-radius: 5px; }
+  ::-webkit-scrollbar-thumb:hover { background: #3a4060; }
+</style>
+</head>
+<body>
+<div class="layout">
+  <!-- Sidebar -->
+  <nav class="sidebar">
+    <h2>导航</h2>
+    <a href="#overview">总览</a>
+    <a href="#startup">1. 启动阶段</a>
+    <a href="#submit">2. 提交任务</a>
+    <a href="#phase1">3. Phase 1 预处理</a>
+    <a href="#step1" class="sub">① PDF 解析</a>
+    <a href="#step2" class="sub">② 结构化抽取</a>
+    <a href="#step3" class="sub">③ 向量索引</a>
+    <a href="#phase2">4. Phase 2 Plan</a>
+    <a href="#phase3">5. Phase 3 Execute</a>
+    <a href="#step4" class="sub">④ Gap 识别</a>
+    <a href="#reflexion" class="sub">↳ Reflexion</a>
+    <a href="#step5" class="sub">⑤ 创新点生成</a>
+    <a href="#step6" class="sub">⑥ 实验设计</a>
+    <a href="#step7" class="sub">⑦ 整合输出</a>
+    <a href="#eval">6. 评估阶段</a>
+    <a href="#summary">7. LLM 调用清单</a>
+    <a href="#principles">8. Prompt 设计原则</a>
+    <a href="#degrade">9. 降级与容错</a>
+  </nav>
+
+  <!-- Main -->
+  <main class="main">
+
+    <!-- Hero -->
+    <div class="hero">
+      <h1>PaperMind · 端到端运行流程详解</h1>
+      <p class="sub">从用户提交 PDF 文件夹,到生成结构化研究提案(含创新点 + 实验方案)的完整代码执行路径、每次 LLM 调用与工具调用的输入输出全记录。</p>
+      <div class="meta">
+        <span class="badge">Plan-and-Execute + Reflexion</span>
+        <span class="badge">7 步漏斗式信息收敛</span>
+        <span class="badge">DeepSeek Function Calling</span>
+        <span class="badge">BGE-m3 + Chroma 混合检索</span>
+      </div>
+    </div>
+
+    <!-- Overview -->
+    <section id="overview">
+      <h2 class="section-title"><span class="num">0</span>总览:七步漏斗流水线</h2>
+      <p class="section-desc">整个系统由 <code class="inline">WorkflowOrchestrator</code> 编排,分三大阶段:预处理(步骤 1-3,带缓存)→ Plan(LLM 动态规划步骤 4-7)→ Execute(步骤 4-7,每步后插入 Reflexion 自校验)。</p>
+
+      <div class="pipeline">
+        <div class="pipeline-row">
+          <div class="pipe-node" style="border-left:3px solid var(--step1)">
+            <div class="pn-num">STEP 1</div>
+            <div class="pn-title">PDF 解析</div>
+            <div class="pn-desc">PyMuPDF 提取章节结构</div>
+            <div class="pn-llm"><span class="tag local">本地</span></div>
+          </div>
+          <div class="pipe-arrow">→</div>
+          <div class="pipe-node" style="border-left:3px solid var(--step2)">
+            <div class="pn-num">STEP 2</div>
+            <div class="pn-title">结构化抽取</div>
+            <div class="pn-desc">Function Calling 抽 9 字段</div>
+            <div class="pn-llm"><span class="tag llm">LLM</span> <span class="tag parallel">并行</span></div>
+          </div>
+          <div class="pipe-arrow">→</div>
+          <div class="pipe-node" style="border-left:3px solid var(--step3)">
+            <div class="pn-num">STEP 3</div>
+            <div class="pn-title">向量索引</div>
+            <div class="pn-desc">BGE-m3 → Chroma + BM25</div>
+            <div class="pn-llm"><span class="tag local">本地</span></div>
+          </div>
+        </div>
+        <div class="flow-arrow">↓</div>
+        <div class="pipeline-row">
+          <div class="pipe-node" style="border-left:3px solid var(--step4)">
+            <div class="pn-num">STEP 4</div>
+            <div class="pn-title">Gap 识别</div>
+            <div class="pn-desc">四类 Gap 信号综合推理</div>
+            <div class="pn-llm"><span class="tag llm">LLM</span> <span class="tag tool">RAG</span></div>
+          </div>
+          <div class="pipe-arrow">→</div>
+          <div class="pipe-node" style="border-left:3px solid var(--step5)">
+            <div class="pn-num">STEP 5</div>
+            <div class="pn-title">创新点生成</div>
+            <div class="pn-desc">四类来源 + 三维评分筛选</div>
+            <div class="pn-llm"><span class="tag llm">LLM</span> <span class="tag tool">联网</span></div>
+          </div>
+          <div class="pipe-arrow">→</div>
+          <div class="pipe-node" style="border-left:3px solid var(--step6)">
+            <div class="pn-num">STEP 6</div>
+            <div class="pn-title">实验设计</div>
+            <div class="pn-desc">8 要素可执行方案</div>
+            <div class="pn-llm"><span class="tag llm">LLM</span></div>
+          </div>
+          <div class="pipe-arrow">→</div>
+          <div class="pipe-node" style="border-left:3px solid var(--step7)">
+            <div class="pn-num">STEP 7</div>
+            <div class="pn-title">整合输出</div>
+            <div class="pn-desc">Markdown 研究提案</div>
+            <div class="pn-llm"><span class="tag llm">LLM</span></div>
+          </div>
+        </div>
+      </div>
+
+      <div class="callout">
+        <strong>核心设计哲学:</strong>漏斗式信息收敛 — 每步压缩信息,最后一步才做创造性推理(避免早期噪声干扰)。所有中间产物都是结构化 JSON / 向量,不依赖长上下文记忆。
+      </div>
+    </section>
+
+    <!-- Startup -->
+    <section id="startup">
+      <h2 class="section-title"><span class="num">1</span>启动阶段(进程级)</h2>
+      <p class="section-desc">用户运行 <code class="inline">python run_backend.py</code> 启动 FastAPI 服务,前端 <code class="inline">npm run dev</code> 启动 Vite。</p>
+
+      <div class="card">
+        <h4>启动命令</h4>
+<pre>python run_backend.py
+# 等价于:uvicorn backend.api.main:app --host 0.0.0.0 --port 8000</pre>
+
+        <h4>启动钩子(on_startup)</h4>
+        <p>应用启动时预加载重型依赖,避免首次请求时才触发 import(torch 单独 import 100+ 秒):</p>
+<pre><span class="tok-com"># 顺序预加载</span>
+import torch              <span class="tok-com"># ~5s</span>
+from transformers import AutoModel, AutoTokenizer   <span class="tok-com"># ~3s</span>
+import chromadb           <span class="tok-com"># ~2s</span>
+
+<span class="tok-com"># 预热 Embedder 单例:加载 BGE-m3 模型 + 首次 forward(初始化 CUDA 上下文)</span>
+_embedder = get_default_embedder()
+_embedder.embed_texts([<span class="tok-str">"预加载测试文本"</span>])</pre>
+
+        <div class="io-grid">
+          <div class="io-box in">
+            <div class="label">输入</div>
+            <div>无(进程启动)</div>
+          </div>
+          <div class="io-box out">
+            <div class="label">输出</div>
+            <div>FastAPI 服务监听 <code class="inline">0.0.0.0:8000</code>,BGE 模型已 warmup,前端可访问 <code class="inline">localhost:5173</code></div>
+          </div>
+        </div>
+      </div>
+    </section>
+
+    <!-- Submit -->
+    <section id="submit">
+      <h2 class="section-title"><span class="num">2</span>用户提交分析任务</h2>
+      <p class="section-desc">前端发 HTTP 请求,后端创建任务并后台异步启动,立即返回 task_id。</p>
+
+      <div class="card">
+        <h4>HTTP 请求</h4>
+<pre><span class="tok-com"># POST /api/analyze</span>
+{
+  <span class="tok-str">"folder_path"</span>: <span class="tok-str">"D:/papers"</span>,
+  <span class="tok-str">"research_direction"</span>: <span class="tok-str">"多模态学习"</span>
+}</pre>
+
+        <h4>路由处理 <a class="code-link" href="file:///d:/code/aa-my-idea/agent/paper-agent-trae/backend/api/routes.py#L157">routes.py:157</a></h4>
+        <ol>
+          <li><code class="inline">task_manager.create_task()</code> → 生成 <code class="inline">task_id</code>(uuid),状态 <code class="inline">pending</code></li>
+          <li><code class="inline">asyncio.create_task(run_analysis(...))</code> → 后台异步启动,<strong>不阻塞响应</strong></li>
+          <li>立即返回 <code class="inline">{"task_id": "..."}</code></li>
+        </ol>
+
+        <h4>后台主流程 <a class="code-link" href="file:///d:/code/aa-my-idea/agent/paper-agent-trae/backend/api/routes.py#L51">routes.py:51</a></h4>
+<pre><span class="tok-com"># 初始化组件</span>
+client = DeepSeekClient()                                    <span class="tok-com"># LLM 客户端</span>
+registry = build_default_registry()                          <span class="tok-com"># 工具注册表</span>
+memory = MemoryManager()                                     <span class="tok-com"># 双层记忆</span>
+orchestrator = WorkflowOrchestrator(client, registry, memory)
+
+<span class="tok-com"># 执行流水线</span>
+pipeline_output = await orchestrator.run_pipeline(...)
+
+<span class="tok-com"># 生成报告 + 评估</span>
+report = await ReportAgent(client).generate_report(final_results)
+evaluation = await Evaluator(client).evaluate(...)
+
+<span class="tok-com"># 存结果</span>
+task_manager.update_task(task_id, status=<span class="tok-str">"completed"</span>, result={...})</pre>
+
+        <div class="callout ok">
+          <strong>SSE 进度推送:</strong>整个后台流程通过 <code class="inline">progress_callback</code> 实时推送 <code class="inline">{stage, status, message, progress, payload}</code> 到 <code class="inline">GET /api/progress/{task_id}</code>,前端可流式渲染进度条。
+        </div>
+      </div>
+    </section>
+
+    <!-- Phase 1 -->
+    <section id="phase1">
+      <h2 class="section-title"><span class="num">3</span>Phase 1:预处理(步骤 1-3,带缓存)</h2>
+      <p class="section-desc">由 <code class="inline">Controller._preprocess_papers()</code> 编排,对每篇论文检查 PaperLibrary 缓存状态:已完成的步骤直接从磁盘加载(标记 cached),未完成的执行后写盘。</p>
+    </section>
+
+    <!-- Step 1 -->
+    <section id="step1">
+      <div class="card step-card s1">
+        <div class="step-header">
+          <div>
+            <span class="step-tag s1"><span class="step-num">①</span> PDF 解析</span>
+            <span class="step-title">PyMuPDF 提取章节结构</span>
+          </div>
+          <a class="code-link" href="file:///d:/code/aa-my-idea/agent/paper-agent-trae/backend/tools/parse_pdf.py">parse_pdf.py</a>
+        </div>
+
+        <div class="pill-row">
+          <span class="tag local">本地处理</span>
+          <span class="tag parallel">并发 asyncio.gather</span>
+          <span class="tag cache">缓存 data/cache/parsed/{paper_id}.json</span>
+        </div>
+
+        <h4>处理流程</h4>
+        <ul>
+          <li>PyMuPDF 提取每页文本 + 字号/字体信息</li>
+          <li>启发式识别章节标题(字号 > 正文×1.15 或加粗 + 关键词匹配 <code class="inline">abstract|introduction|method...</code>)</li>
+          <li>去页眉页脚(短行 &lt; 80 字符且重复出现)</li>
+          <li>提取图表标题(<code class="inline">Figure X</code> / <code class="inline">表 X</code> 正则)</li>
+          <li>合并跨页段落,修复断句</li>
+        </ul>
+
+        <div class="io-grid">
+          <div class="io-box in">
+            <div class="label">输入</div>
+<pre>{
+  <span class="tok-str">"file_path"</span>: <span class="tok-str">"D:/papers/xxx.pdf"</span>
+}</pre>
+          </div>
+          <div class="io-box out">
+            <div class="label">输出:ParsedPaper</div>
+<pre>{
+  <span class="tok-str">"path"</span>: <span class="tok-str">"D:/papers/xxx.pdf"</span>,
+  <span class="tok-str">"title"</span>: <span class="tok-str">"Attention Is All You Need"</span>,
+  <span class="tok-str">"sections"</span>: [
+    {
+      <span class="tok-str">"heading"</span>: <span class="tok-str">"Abstract"</span>,
+      <span class="tok-str">"content"</span>: <span class="tok-str">"..."</span>,
+      <span class="tok-str">"figure_captions"</span>: [<span class="tok-str">"Figure 1: ..."</span>]
+    }
+  ]
+}</pre>
+          </div>
+        </div>
+
+        <div class="callout">
+          <strong>缓存复用:</strong>解析结果写入 <code class="inline">data/cache/parsed/{paper_id}.json</code>,PaperLibrary 标记 <code class="inline">parse_status=done</code>。下次同一论文直接 <code class="inline">load_parsed()</code> 加载,跳过解析。
+        </div>
+      </div>
+    </section>
+
+    <!-- Step 2 -->
+    <section id="step2">
+      <div class="card step-card s2">
+        <div class="step-header">
+          <div>
+            <span class="step-tag s2"><span class="step-num">②</span> 结构化抽取</span>
+            <span class="step-title">核心主干 · Function Calling 强制 JSON</span>
+          </div>
+          <a class="code-link" href="file:///d:/code/aa-my-idea/agent/paper-agent-trae/backend/tools/extract_paper_structure.py#L214">extract_paper_structure.py:214</a>
+        </div>
+
+        <div class="pill-row">
+          <span class="tag llm">LLM 调用</span>
+          <span class="tag parallel">并行 asyncio.gather + Semaphore(5)</span>
+          <span class="tag cache">缓存 data/cache/papers/{paper_id}.json + papers.jsonl</span>
+        </div>
+
+        <h4>处理流程</h4>
+        <ol>
+          <li><strong>长度判断</strong>:总字符 &gt; 20000 → 按章节分块抽取后合并;否则一次性抽取</li>
+          <li><strong>调用 LLM</strong>(<code class="inline">_call_extract</code>):强制 <code class="inline">tool_choice={"type":"function","function":{"name":"extract_paper_fields"}}</code></li>
+          <li><strong>字段完整性校验</strong>:缺失字段 → 针对性补抽(<code class="inline">focus_fields</code> 只补缺失的,不重跑整篇)</li>
+          <li><strong>长论文合并</strong>:多块记录按置信度取最高 value,<code class="inline">source_sections</code> 去重合并</li>
+        </ol>
+
+        <details open>
+          <summary>LLM Prompt · 抽取(核心)</summary>
+<pre class="prompt"><span class="tok-sys">[System]</span>
+你是论文结构化抽取助手。严格通过函数调用输出 JSON,
+每个字段含 value/source_sections/confidence。
+limitations 必须真实可溯源,严禁臆造。
+
+<span class="tok-user">[User]</span>
+请从以下论文中抽取结构化字段。
+
+论文标题:<span class="placeholder">{title}</span>
+
+论文正文:
+## Abstract
+<span class="placeholder">{...}</span>
+## Introduction
+<span class="placeholder">{...}</span>
+
+抽取要求:
+1. 必须抽取以下字段:title、task_problem、method、key_contributions、
+   datasets、metrics、results、limitations、future_work
+2. 每个字段必须是 FieldSource 结构:
+   {
+     "value": "字段值(字符串,尽量简洁完整)",
+     "source_sections": ["原文出处章节标题列表"],
+     "confidence": 0.0-1.0
+   }
+3. source_sections 必须标注字段信息来源于上面哪个章节(用章节标题原文),便于回溯核查
+4. <span class="tok-kw">limitations 字段特别要求</span>:必须是论文明确承认的局限,或可从实验结果直接推断的局限,
+   严禁臆造或泛泛而谈。若论文未明确提及局限,value 填写"论文未明确陈述局限",confidence 设为较低值(如 0.3)
+5. confidence 反映可信度:
+   - 信息明确且原文直述 → 0.9-1.0
+   - 需要从原文推断 → 0.6-0.8
+   - 信息不足或模糊 → 低于 0.6
+6. 严格输出 JSON,不要添加任何额外说明文字或 markdown 代码块标记</pre>
+        </details>
+
+        <details>
+          <summary>LLM Prompt · 针对性补抽(缺失字段)</summary>
+<pre class="prompt"><span class="tok-user">[User]</span>
+前一次抽取缺失了以下字段:<span class="placeholder">{", ".join(focus_fields)}</span>。
+请重点从原文中补抽这些字段,其他字段可留空。
+
+<span class="tok-com">{...同上 prompt...}</span></pre>
+        </details>
+
+        <details>
+          <summary>Function Calling Schema · extract_paper_fields</summary>
+<pre>{
+  "type": "function",
+  "function": {
+    "name": "extract_paper_fields",
+    "description": "从论文中抽取结构化字段,每个字段含 value/source_sections/confidence",
+    "parameters": {
+      "type": "object",
+      "properties": {
+        "title": { "type": "object", "properties": {
+          "value": {"type":"string"},
+          "source_sections": {"type":"array","items":{"type":"string"}},
+          "confidence": {"type":"number"}
+        }},
+        "task_problem": { ... 同上 ... },
+        "method": { ... },
+        "key_contributions": { ... },
+        "datasets": { ... },
+        "metrics": { ... },
+        "results": { ... },
+        "limitations": { ... },
+        "future_work": { ... }
+      },
+      "required": ["title","task_problem","method","key_contributions",
+                   "datasets","metrics","results","limitations","future_work"]
+    }
+  }
+}</pre>
+        </details>
+
+        <div class="io-grid">
+          <div class="io-box in">
+            <div class="label">输入</div>
+<pre>{
+  <span class="tok-str">"paper_path"</span>: <span class="tok-str">"D:/papers/xxx.pdf"</span>,
+  <span class="tok-str">"parsed_paper"</span>: <span class="tok-com">{ParsedPaper dict}</span>
+}</pre>
+          </div>
+          <div class="io-box out">
+            <div class="label">输出:PaperRecord</div>
+<pre>{
+  "path": "...",
+  "title": {
+    "value": "Attention Is All You Need",
+    "source_sections": ["Title"],
+    "confidence": 1.0
+  },
+  "task_problem": {
+    "value": "序列建模任务...",
+    "source_sections": ["Introduction"],
+    "confidence": 0.9
+  },
+  "method": {
+    "value": "Transformer 架构...",
+    "source_sections": ["3 Method","3.1"],
+    "confidence": 0.95
+  },
+  "limitations": {
+    "value": "位置编码外推性差...",
+    "source_sections": ["6 Conclusion"],
+    "confidence": 0.7
+  },
+  <span class="tok-com">...</span>
+}</pre>
+          </div>
+        </div>
+
+        <div class="callout warn">
+          <strong>防编造机制:</strong>每个字段强制 <code class="inline">source_sections</code> 回溯到具体章节,<code class="inline">limitations</code> 严禁臆造。这是后续创新点论证可追溯性的基石。
+        </div>
+      </div>
+    </section>
+
+    <!-- Step 3 -->
+    <section id="step3">
+      <div class="card step-card s3">
+        <div class="step-header">
+          <div>
+            <span class="step-tag s3"><span class="step-num">③</span> 向量索引构建</span>
+            <span class="step-title">BGE-m3 → Chroma + BM25</span>
+          </div>
+          <a class="code-link" href="file:///d:/code/aa-my-idea/agent/paper-agent-trae/backend/tools/build_vector_index.py">build_vector_index.py</a>
+        </div>
+
+        <div class="pill-row">
+          <span class="tag local">本地处理</span>
+          <span class="tag cache">Chroma PersistentClient 持久化</span>
+          <span class="tag degrade">失败降级 skip_rag</span>
+        </div>
+
+        <h4>处理流程</h4>
+        <ol>
+          <li><strong>分块</strong>:按段落累积到 ~500 字符落块,每块携带 <code class="inline">section</code> 标题</li>
+          <li><strong>向量化</strong>:BGE-m3 本地 Embedding(无 API 成本),块内容 = <code class="inline">section_heading + text</code></li>
+          <li><strong>写入 Chroma</strong>:<code class="inline">paper_chunks</code> collection,metadata 含 <code class="inline">paper_path/title/section</code></li>
+          <li><strong>同步构建 BM25</strong>:倒排索引供关键词检索</li>
+        </ol>
+
+        <div class="io-grid">
+          <div class="io-box in">
+            <div class="label">输入</div>
+<pre>{
+  <span class="tok-str">"papers_json"</span>: [<span class="tok-com">{ParsedPaper}</span>, ...]
+}</pre>
+          </div>
+          <div class="io-box out">
+            <div class="label">输出</div>
+<pre>{
+  "indexed_count": 12,
+  "status": "done"
+}</pre>
+          </div>
+        </div>
+
+        <div class="callout">
+          <strong>定位:</strong>RAG 是"点查询工具"而非"分析引擎",仅在结构化摘要不够用时调用(步骤④⑤ 中需原文细节佐证时)。混合搜索 = Chroma 向量(α=0.6)+ BM25(α=0.4)分数归一化加权融合。
+        </div>
+      </div>
+    </section>
+
+    <!-- Phase 2 -->
+    <section id="phase2">
+      <h2 class="section-title"><span class="num">4</span>Phase 2:Plan(LLM 动态规划)</h2>
+      <p class="section-desc">让 LLM 根据任务自主规划步骤顺序/增减,体现动态编排。失败时回退默认七步计划。实际执行时过滤掉步骤 1-3(已由预处理完成),只执行步骤 4-7。</p>
+
+      <div class="card">
+        <h4>调用位置 <a class="code-link" href="file:///d:/code/aa-my-idea/agent/paper-agent-trae/backend/orchestrator/controller.py#L126">controller.py:126</a></h4>
+
+        <details open>
+          <summary>LLM Prompt · 动态规划</summary>
+<pre class="prompt"><span class="tok-sys">[System]</span>
+你是 Agent 编排器,负责生成可执行的动态计划。只输出 JSON。
+
+<span class="tok-user">[User]</span>
+你是论文创新 Agent 的 Controller。请为以下任务生成动态执行计划。
+
+任务:分析文件夹 <span class="placeholder">{folder_path}</span> 中的 PDF 论文,
+识别研究空白,生成 2-3 个创新点并设计实验方案。
+
+可用 Agent:
+- PaperParser:扫描文件夹并解析 PDF
+- Extractor:单篇论文结构化抽取
+- Indexer:向量索引构建
+- GapAnalyzer:跨论文 Gap 识别
+- InnovationGenerator:创新点生成与筛选
+- ExperimentDesigner:实验方案设计
+- Integration:整合输出研究提案
+
+请生成执行计划,输出 JSON 数组,每个元素含:
+- step: 步骤序号(整数)
+- agent: Agent 名称(上述之一)
+- action: 该步骤具体任务描述
+- depends_on: 依赖的步骤序号列表
+
+你可以根据任务自主调整顺序或增减步骤。
+默认链路:解析→抽取→索引→Gap分析→创新生成→实验设计→整合。
+严格只输出 JSON 数组,不要其他文本。</pre>
+        </details>
+
+        <div class="io-grid">
+          <div class="io-box in">
+            <div class="label">输入</div>
+<pre><span class="tok-str">"D:/papers"</span> <span class="tok-com">或</span>
+<span class="tok-str">"已上传的 12 篇论文"</span></pre>
+          </div>
+          <div class="io-box out">
+            <div class="label">输出:计划列表</div>
+<pre>[
+  {"step":4,"agent":"GapAnalyzer",
+   "action":"跨论文综合分析识别研究空白",
+   "depends_on":[2]},
+  {"step":5,"agent":"InnovationGenerator",
+   "action":"针对 Gap 生成创新点并筛选",
+   "depends_on":[4]},
+  <span class="tok-com">...</span>
+]</pre>
+          </div>
+        </div>
+      </div>
+    </section>
+
+    <!-- Phase 3 -->
+    <section id="phase3">
+      <h2 class="section-title"><span class="num">5</span>Phase 3:Execute(步骤 4-7 + Reflexion)</h2>
+      <p class="section-desc">逐步执行计划,每步完成后插入 Reflexion 自校验钩子(仅对 Extractor / GapAnalyzer / InnovationGenerator 启用)。每步还根据结果动态调整剩余计划。</p>
+
+      <div class="callout warn">
+        <strong>绕过 Function Calling 的设计:</strong>步骤 ④⑤⑥ 中,Controller 直接调用工具(参数已确定),不让模型再选一次工具。因为 DeepSeek 实测会把整段 JSON 当字符串传或漏传参数,浪费迭代次数。只让 LLM 做推理,不让它做参数路由。
+      </div>
+    </section>
+
+    <!-- Step 4 -->
+    <section id="step4">
+      <div class="card step-card s4">
+        <div class="step-header">
+          <div>
+            <span class="step-tag s4"><span class="step-num">④</span> Gap 识别</span>
+            <span class="step-title">跨论文综合推理 · 四类 Gap 信号</span>
+          </div>
+          <a class="code-link" href="file:///d:/code/aa-my-idea/agent/paper-agent-trae/backend/tools/analyze_gaps.py#L88">analyze_gaps.py:88</a>
+        </div>
+
+        <div class="pill-row">
+          <span class="tag llm">LLM 调用</span>
+          <span class="tag tool">hybrid_search 工具</span>
+          <span class="tag parallel">RAG 增强 evidence</span>
+        </div>
+
+        <h4>处理流程</h4>
+        <ol>
+          <li><strong>聚合对比矩阵</strong>:把 N 篇论文的 8 个字段聚合成文本(关键:让模型在全局视野下识别 Gap)</li>
+          <li><strong>调用 LLM</strong> 做跨论文综合推理,识别四类 Gap</li>
+          <li><strong>RAG 增强</strong>:对每个 Gap 调用 <code class="inline">hybrid_search</code> 检索原文细节,补充 evidence</li>
+        </ol>
+
+        <details open>
+          <summary>LLM Prompt · Gap 识别</summary>
+<pre class="prompt"><span class="tok-sys">[System]</span>
+你是一位严谨的学术研究分析专家,擅长跨论文综合推理与 Gap 识别。
+只输出严格 JSON,不要输出任何其他内容。
+
+<span class="tok-user">[User]</span>
+你是一位资深学术研究者,需要从以下多篇论文的结构化对比中识别研究空白(Gap)。
+
+## 论文对比矩阵
+===== 论文 1: Attention Is All You Need =====
+[研究任务/问题] 序列建模任务...
+[核心方法] Transformer 架构...
+[局限性] 位置编码外推性差...
+[未来工作] 扩展到多模态...
+===== 论文 2: BERT =====
+[研究任务/问题] ...
+[核心方法] ...
+[局限性] ...
+
+## 任务
+请综合分析上述论文,识别以下四类 Gap 信号:
+1. <span class="tok-kw">repeated_limitation</span>(重复局限):多篇论文提到同一局限性,但无人解决
+2. <span class="tok-kw">method_gap</span>(方法空白):某类问题只有少数方法尝试且效果不佳
+3. <span class="tok-kw">contradictory</span>(矛盾结论):不同论文对同一问题给出冲突结论
+4. <span class="tok-kw">unfulfilled_future</span>(未兑现的未来工作):多篇论文指向同一未来方向但无人完成
+
+对于单篇论文场景,重点关注该论文自身的 limitations 与 future_work 字段。
+
+## 输出要求
+严格输出 JSON:
+{
+  "gaps": [
+    {
+      "description": "Gap 的清晰描述",
+      "gap_type": "repeated_limitation|method_gap|contradictory|unfulfilled_future",
+      "source_papers": ["来源论文标题1"],
+      "evidence": "论证依据,引用具体论文的具体字段",
+      "confidence": 0.0到1.0之间的置信度
+    }
+  ]
+}
+
+只输出真正有证据支撑的 Gap,不要编造。每个 Gap 的 source_papers 至少包含 2 篇论文。</pre>
+        </details>
+
+        <div class="io-grid">
+          <div class="io-box in">
+            <div class="label">输入</div>
+<pre>{
+  <span class="tok-str">"papers_records"</span>: [
+    <span class="tok-com">{PaperRecord 1}</span>,
+    <span class="tok-com">{PaperRecord 2}</span>,
+    ...
+  ]
+}</pre>
+          </div>
+          <div class="io-box out">
+            <div class="label">输出</div>
+<pre>{
+  "gaps": [
+    {
+      "description": "位置编码外推性普遍较差",
+      "gap_type": "repeated_limitation",
+      "source_papers": ["Attention...","BERT..."],
+      "evidence": "两篇均提及... [原文佐证]\n  - 《Attention》6 Conclusion: ...",
+      "confidence": 0.85
+    }
+  ]
+}</pre>
+          </div>
+        </div>
+      </div>
+    </section>
+
+    <!-- Reflexion -->
+    <section id="reflexion">
+      <div class="card step-card" style="border-left-color: var(--accent-2);">
+        <div class="step-header">
+          <div>
+            <span class="step-tag" style="background:rgba(167,139,250,0.15);color:var(--accent-2);">↻ Reflexion 自校验</span>
+            <span class="step-title">针对性补抽(非整篇重跑)</span>
+          </div>
+          <a class="code-link" href="file:///d:/code/aa-my-idea/agent/paper-agent-trae/backend/orchestrator/reflexion.py#L67">reflexion.py:67</a>
+        </div>
+
+        <div class="pill-row">
+          <span class="tag llm">LLM 调用</span>
+          <span class="tag degrade">置信度 &lt; 0.7 触发重试</span>
+        </div>
+
+        <h4>触发条件</h4>
+        <p>仅对 <code class="inline">Extractor</code> / <code class="inline">GapAnalyzer</code> / <code class="inline">InnovationGenerator</code> 启用。步骤完成后,让 LLM 对照上下文检查结果质量。</p>
+
+        <details open>
+          <summary>LLM Prompt · 自校验</summary>
+<pre class="prompt"><span class="tok-sys">[System]</span>
+你是质量审核员,负责对照上下文检查 Agent 输出质量。只输出 JSON。
+
+<span class="tok-user">[User]</span>
+请对照上下文检查以下步骤的结果质量。
+
+步骤:<span class="placeholder">{step_name}</span>
+上下文:
+步骤 2 结果:{抽取记录摘要...}
+
+结果:
+<span class="placeholder">{result_str}</span>
+
+检查要求:
+1. 评估结果是否准确、完整、无臆造;
+2. 输出 0-1 的置信度(confidence);
+3. 列出发现的问题(issues);
+4. 置信度低于 <span class="placeholder">{CONFIDENCE_THRESHOLD=0.7}</span> 时 needs_retry=true;
+5. 指出需重试的字段或方面(retry_fields)。
+
+严格以 JSON 输出:
+{"confidence": 0.85, "issues": ["问题1"], "needs_retry": false, "retry_fields": []}</pre>
+        </details>
+
+        <h4>重试逻辑</h4>
+        <ol>
+          <li><code class="inline">confidence &lt; 0.7</code> → <code class="inline">needs_retry = true</code></li>
+          <li>调用 <code class="inline">retry_func()</code> 重新执行该步骤(针对性补抽,非整篇重跑)</li>
+          <li>最多重试 <code class="inline">MAX_RETRIES=2</code> 次</li>
+          <li>仍不达标 → 标记 <code class="inline">needs_human_review</code>,流程继续不阻塞</li>
+        </ol>
+
+        <div class="io-grid">
+          <div class="io-box in">
+            <div class="label">输入</div>
+<pre>{
+  <span class="tok-str">"step_name"</span>: <span class="tok-str">"GapAnalyzer"</span>,
+  <span class="tok-str">"result"</span>: <span class="tok-com">{步骤结果}</span>,
+  <span class="tok-str">"context"</span>: <span class="tok-com">{依赖步骤结果}</span>
+}</pre>
+          </div>
+          <div class="io-box out">
+            <div class="label">输出</div>
+<pre>{
+  "confidence": 0.85,
+  "issues": ["..."],
+  "needs_retry": false,
+  "retry_fields": []
+}</pre>
+          </div>
+        </div>
+      </div>
+    </section>
+
+    <!-- Step 5 -->
+    <section id="step5">
+      <div class="card step-card s5">
+        <div class="step-header">
+          <div>
+            <span class="step-tag s5"><span class="step-num">⑤</span> 创新点生成</span>
+            <span class="step-title">四类来源 + 三维评分筛选 + 联网去重</span>
+          </div>
+          <a class="code-link" href="file:///d:/code/aa-my-idea/agent/paper-agent-trae/backend/tools/generate_innovations.py#L58">generate_innovations.py:58</a>
+        </div>
+
+        <div class="pill-row">
+          <span class="tag llm">LLM 调用</span>
+          <span class="tag tool">web_search 工具(DuckDuckGo)</span>
+          <span class="tag degrade">联网失败降级 skip_novelty_check</span>
+        </div>
+
+        <h4>处理流程</h4>
+        <ol>
+          <li><strong>调用 LLM</strong>:针对每个 Gap 从四类来源生成候选创新方向</li>
+          <li><strong>规范化 + 排序</strong>:按三维评分之和降序</li>
+          <li><strong>取 Top 2-3</strong></li>
+          <li><strong>联网新颖性去重</strong>:对每个创新点用 DuckDuckGo 搜索近 1-2 年 arXiv/Google Scholar,验证是否已有相同工作</li>
+        </ol>
+
+        <details open>
+          <summary>LLM Prompt · 创新生成</summary>
+<pre class="prompt"><span class="tok-sys">[System]</span>
+你是一位学术创新生成专家,擅长从研究空白中挖掘可执行的创新方向。
+只输出严格 JSON,不要输出任何其他内容。
+
+<span class="tok-user">[User]</span>
+你是一位富有创造力的学术研究者,需要基于以下研究空白(Gap)生成候选创新方向。
+
+## 用户研究方向约束
+用户的研究方向为:<span class="placeholder">{research_direction}</span>
+生成的创新点应尽量与该方向相关,并在 supporting_evidence 中说明创新点与该方向的关联。
+
+## 研究空白列表
+- [repeated_limitation] 位置编码外推性普遍较差(来源: Attention..., BERT...)
+- [method_gap] ...
+
+## 任务
+针对每个 Gap,从以下四类来源生成候选创新方向:
+1. <span class="tok-kw">method_combination</span>(方法组合):把 A 论文方法迁移到 B 论文问题
+2. <span class="tok-kw">limitation_fix</span>(局限改进):直接解决被反复提及的局限
+3. <span class="tok-kw">cross_domain</span>(跨域迁移):引入其他领域方法
+4. <span class="tok-kw">new_scenario</span>(新场景应用):把现有方法用到未被覆盖的数据/场景
+
+对每个候选创新方向,用三维评分(0-10 分):
+- novelty(新颖性)
+- feasibility(可行性)
+- significance(显著性)
+
+## 输出要求
+严格输出 JSON:
+{
+  "innovations": [
+    {
+      "title": "创新点标题",
+      "idea": "创新思路详细描述",
+      "source": "method_combination|limitation_fix|cross_domain|new_scenario",
+      "gap_origin": "对应的 Gap 描述",
+      "score": {"novelty": 8.0, "feasibility": 7.5, "significance": 8.0},
+      "supporting_evidence": "论据支撑"
+    }
+  ]
+}
+
+生成多个候选(每个 Gap 至少 1-2 个),按综合得分(三项之和)从高到低排序。</pre>
+        </details>
+
+        <div class="io-grid">
+          <div class="io-box in">
+            <div class="label">输入</div>
+<pre>{
+  <span class="tok-str">"gaps"</span>: [<span class="tok-com">{Gap}</span>, ...],
+  <span class="tok-str">"research_direction"</span>: <span class="tok-str">"多模态学习"</span>
+}</pre>
+          </div>
+          <div class="io-box out">
+            <div class="label">输出</div>
+<pre>{
+  "innovations": [
+    {
+      "title": "基于 RoPE 的多模态位置编码",
+      "idea": "...",
+      "source": "limitation_fix",
+      "gap_origin": "位置编码外推性差",
+      "score": {"novelty":8.0,"feasibility":7.5,"significance":8.5},
+      "novelty_check": "近 1-2 年无相同工作",
+      "supporting_evidence": "..."
+    }
+  ]
+}</pre>
+          </div>
+        </div>
+      </div>
+    </section>
+
+    <!-- Step 6 -->
+    <section id="step6">
+      <div class="card step-card s6">
+        <div class="step-header">
+          <div>
+            <span class="step-tag s6"><span class="step-num">⑥</span> 实验方案设计</span>
+            <span class="step-title">8 要素可执行研究方案</span>
+          </div>
+          <a class="code-link" href="file:///d:/code/aa-my-idea/agent/paper-agent-trae/backend/tools/design_experiments.py#L34">design_experiments.py:34</a>
+        </div>
+
+        <div class="pill-row">
+          <span class="tag llm">LLM 调用</span>
+        </div>
+
+        <details open>
+          <summary>LLM Prompt · 实验设计</summary>
+<pre class="prompt"><span class="tok-sys">[System]</span>
+你是一位学术实验设计专家,擅长设计严谨可执行的研究方案。
+只输出严格 JSON,不要输出任何其他内容。
+
+<span class="tok-user">[User]</span>
+你是一位资深学术研究者,需要为以下创新点设计可执行的研究方案。
+
+## 创新点列表
+- 基于 RoPE 的多模态位置编码: ...(来源: limitation_fix,Gap: 位置编码外推性差)
+
+## 任务
+为每个创新点设计完整、可执行的研究方案,包含:
+- <span class="tok-kw">hypothesis</span>(研究假设):清晰可验证的假设
+- <span class="tok-kw">datasets</span>(数据集列表):适合该研究的公开数据集
+- <span class="tok-kw">baselines</span>(基线方法列表):需要对比的现有方法
+- <span class="tok-kw">metrics</span>(评估指标列表):量化评估指标
+- <span class="tok-kw">ablation</span>(消融实验设计列表):验证各组件贡献
+- <span class="tok-kw">steps</span>(实验步骤列表):可复现的实验流程
+- <span class="tok-kw">expected_results</span>(预期结果):预期达到的性能或发现
+- <span class="tok-kw">risks</span>(风险):可能的失败点与应对
+
+## 输出要求
+严格输出 JSON:
+{
+  "experiment_plans": [
+    {
+      "innovation_title": "对应的创新点标题",
+      "hypothesis": "研究假设",
+      "datasets": ["数据集1","数据集2"],
+      "baselines": ["基线方法1","基线方法2"],
+      "metrics": ["指标1","指标2"],
+      "ablation": ["消融实验1"],
+      "steps": ["步骤1","步骤2","步骤3"],
+      "expected_results": "预期结果描述",
+      "risks": "风险与应对描述"
+    }
+  ]
+}
+
+每个创新点对应一条方案,方案须具体可执行。</pre>
+        </details>
+
+        <div class="io-grid">
+          <div class="io-box in">
+            <div class="label">输入</div>
+<pre>{
+  <span class="tok-str">"innovations"</span>: [<span class="tok-com">{Innovation}</span>, ...]
+}</pre>
+          </div>
+          <div class="io-box out">
+            <div class="label">输出</div>
+<pre>{
+  "experiment_plans": [
+    {
+      "innovation_title": "基于 RoPE 的多模态位置编码",
+      "hypothesis": "RoPE 能提升多模态任务外推性",
+      "datasets": ["COCO","VQA"],
+      "baselines": ["ALiBi"," vanilla PE"],
+      "metrics": ["BLEU","Accuracy"],
+      "ablation": ["移除旋转矩阵"],
+      "steps": ["..."],
+      "expected_results": "...",
+      "risks": "..."
+    }
+  ]
+}</pre>
+          </div>
+        </div>
+      </div>
+    </section>
+
+    <!-- Step 7 -->
+    <section id="step7">
+      <div class="card step-card s7">
+        <div class="step-header">
+          <div>
+            <span class="step-tag s7"><span class="step-num">⑦</span> 整合输出</span>
+            <span class="step-title">Markdown 研究提案 · 可追溯</span>
+          </div>
+          <a class="code-link" href="file:///d:/code/aa-my-idea/agent/paper-agent-trae/backend/agents/report_agent.py#L47">report_agent.py:47</a>
+        </div>
+
+        <div class="pill-row">
+          <span class="tag llm">LLM 调用(max_tokens=8192)</span>
+          <span class="tag degrade">LLM 失败降级本地格式化</span>
+        </div>
+
+        <h4>输入聚合 <a class="code-link" href="file:///d:/code/aa-my-idea/agent/paper-agent-trae/backend/orchestrator/workflow.py#L127">workflow.py:127</a></h4>
+        <p><code class="inline">_build_final_results()</code> 从各步骤的 <code class="inline">tool_calls</code> 里聚合 4 字段:</p>
+<pre>{
+  "papers_records": [...],    <span class="tok-com"># 步骤②所有抽取记录</span>
+  "gaps": [...],              <span class="tok-com"># 步骤④所有 Gap</span>
+  "innovations": [...],       <span class="tok-com"># 步骤⑤所有创新点</span>
+  "experiment_plans": [...]   <span class="tok-com"># 步骤⑥所有实验方案</span>
+}</pre>
+
+        <details open>
+          <summary>LLM Prompt · 整合报告</summary>
+<pre class="prompt"><span class="tok-sys">[System]</span>
+你是学术研究提案撰写专家,擅长把多篇论文的 Gap 分析、创新点与实验方案
+整合为结构清晰、可追溯的研究提案。严格输出 JSON,不要输出任何额外说明文本。
+
+<span class="tok-user">[User]</span>
+请基于以下前序步骤产物,整合为一份结构化研究提案。
+
+## 研究主题
+<span class="placeholder">{topic}</span>
+
+## 一、论文结构化记录(含 source_sections,可追溯)
+----- 论文 1: Attention Is All You Need (path=...) -----
+  [研究任务/问题] 序列建模...  (出处章节: Introduction)
+  [核心方法] Transformer...  (出处章节: 3 Method; 3.1)
+  [局限性] 位置编码外推性差  (出处章节: 6 Conclusion)
+  ...
+
+## 二、识别到的 Gap 列表
+Gap 1 [repeated_limitation] (置信度=0.85): 位置编码外推性普遍较差
+  来源论文: Attention...; BERT...
+  论证: 两篇均提及...
+
+## 三、创新点列表(含三维评分)
+创新点 1: 基于 RoPE 的多模态位置编码 (来源=limitation_fix)
+  创新思路: ...
+  三维评分: 新颖性 8 / 可行性 7 / 显著性 9
+  新颖性验证: 近 1-2 年无相同工作
+  论据支撑: ...
+
+## 四、实验方案列表
+方案 1 (对应: 基于 RoPE 的多模态位置编码)
+  研究假设: ...
+  数据集: COCO, VQA
+  ...
+
+## 整合任务
+1. 背景综述:基于 Gap 分析梳理领域现状与脉络
+2. 创新点论证:对每个创新点补充 Gap 来源 + 创新思路 + 三维评分 + 论据支撑
+3. 实验方案:保留每个创新点的完整实验方案要素
+4. 参考文献溯源:所有引用论文的来源标注,可追溯至具体章节(source_sections)
+5. Markdown 报告:按指定结构生成完整 Markdown 文本
+
+## Markdown 报告结构要求
+# 研究提案:[主题]
+## 一、背景综述
+## 二、创新点论证
+### 创新点 1:[标题]
+- Gap 来源:...
+- 创新思路:...
+- 三维评分:新颖性 X / 可行性 X / 显著性 X
+- 论据支撑:...
+## 三、实验方案
+## 四、参考文献溯源
+
+## 输出要求
+严格输出 JSON:
+{
+  "background_review": "背景综述文本",
+  "innovations": [...],
+  "experiment_plans": [...],
+  "references": [{"title":"...","path":"...","sections":[...]}],
+  "markdown": "完整 Markdown 报告字符串"
+}
+
+注意:
+- references 必须可追溯至具体章节(source_sections)
+- 不得编造论文或证据,所有引用须来自上述论文记录
+- 若某字段在输入中缺失,对应位置写"暂无"而非编造</pre>
+        </details>
+
+        <div class="io-grid">
+          <div class="io-box in">
+            <div class="label">输入</div>
+<pre>{
+  "papers_records": [...],
+  "gaps": [...],
+  "innovations": [...],
+  "experiment_plans": [...]
+}</pre>
+          </div>
+          <div class="io-box out">
+            <div class="label">输出</div>
+<pre>{
+  "background_review": "...",
+  "innovations": [...],
+  "experiment_plans": [...],
+  "references": [
+    {"title":"...","path":"...",
+     "sections":["3 Method","6 Conclusion"]}
+  ],
+  "markdown": "# 研究提案:...\n## 一、背景综述\n..."
+}</pre>
+          </div>
+        </div>
+      </div>
+    </section>
+
+    <!-- Evaluation -->
+    <section id="eval">
+      <h2 class="section-title"><span class="num">6</span>评估阶段</h2>
+      <p class="section-desc">流水线完成后,<code class="inline">Evaluator</code> 汇总工具调用追踪 + 输出质量评估,产出统一评估结果。</p>
+
+      <div class="card">
+        <h4>调用位置 <a class="code-link" href="file:///d:/code/aa-my-idea/agent/paper-agent-trae/backend/evaluator/evaluator.py#L28">evaluator.py:28</a></h4>
+        <ol>
+          <li><code class="inline">ToolCallTracker</code> 汇总工具调用成功率 / 总数 / 失败数 / 耗时</li>
+          <li><code class="inline">QualityEvaluator</code> 对每个创新点调 LLM 做三维评分校验</li>
+        </ol>
+
+        <details open>
+          <summary>LLM Prompt · 质量评估</summary>
+<pre class="prompt"><span class="tok-sys">[System]</span>
+你是一位学术评审专家,擅长对创新点进行多维评分。只输出严格 JSON。
+
+<span class="tok-user">[User]</span>
+你是一位严谨的学术评审专家,请对以下创新点进行三维评分(0-10 分,保留一位小数)。
+
+## 创新点信息
+- 标题:<span class="placeholder">{title}</span>
+- 思路:<span class="placeholder">{idea}</span>
+- 论据支撑:<span class="placeholder">{supporting_evidence}</span>
+- 新颖性检查:<span class="placeholder">{novelty_check}</span>
+
+## 评分维度
+- <span class="tok-kw">novelty</span>(新颖性):与现有工作的差异程度
+- <span class="tok-kw">feasibility</span>(可行性):技术实现与资源获取的难度
+- <span class="tok-kw">significance</span>(显著性):学术或应用价值
+
+## 输出要求
+严格输出 JSON:
+{
+  "innovation_title": "...",
+  "score": {"novelty": 8.0, "feasibility": 7.5, "significance": 8.0},
+  "reasoning": "评分理由,简明扼要"
+}</pre>
+        </details>
+
+        <h4>输出</h4>
+<pre>{
+  "innovations_scores": [...],
+  "tool_call_success_rate": 0.89,
+  "total_tool_calls": 47,
+  "failed_tool_calls": 5,
+  "avg_confidence": 0.78,
+  "tool_calls": [...],
+  "quality_assessment": {...}
+}</pre>
+      </div>
+    </section>
+
+    <!-- Summary -->
+    <section id="summary">
+      <h2 class="section-title"><span class="num">7</span>完整 LLM 调用清单</h2>
+      <p class="section-desc">单次完整运行共触发 11 次 LLM 调用(不含工具内部重试)。</p>
+
+      <table>
+        <thead>
+          <tr>
+            <th>#</th>
+            <th>阶段</th>
+            <th>调用位置</th>
+            <th>Prompt 设计要点</th>
+            <th>输出格式</th>
+          </tr>
+        </thead>
+        <tbody>
+          <tr><td>1</td><td>Plan</td><td>controller.py:151</td><td>Agent 编排器,生成动态计划</td><td>JSON 数组</td></tr>
+          <tr><td>2</td><td>步骤②</td><td>extract_schema.py:102</td><td>强制 Function Calling,source_sections 防编造,limitations 严禁臆造</td><td>FieldSource JSON</td></tr>
+          <tr><td>3</td><td>步骤②补抽</td><td>extract_paper_structure.py:161</td><td>只补缺失字段,不重跑整篇</td><td>FieldSource JSON</td></tr>
+          <tr><td>4</td><td>步骤②自校验</td><td>extract_paper_structure.py:306</td><td>对照原文逐字段检查置信度</td><td>JSON</td></tr>
+          <tr><td>5</td><td>步骤④</td><td>analyze_gaps.py:113</td><td>四类 Gap 信号识别,对比矩阵输入</td><td>JSON gaps 列表</td></tr>
+          <tr><td>6</td><td>步骤④ Reflexion</td><td>reflexion.py:67</td><td>质量审核员,对照上下文检查</td><td>JSON confidence</td></tr>
+          <tr><td>7</td><td>步骤⑤</td><td>generate_innovations.py:81</td><td>四类创新方向 + 三维评分 + 方向约束</td><td>JSON innovations</td></tr>
+          <tr><td>8</td><td>步骤⑤ Reflexion</td><td>reflexion.py:67</td><td>同上</td><td>JSON confidence</td></tr>
+          <tr><td>9</td><td>步骤⑥</td><td>design_experiments.py:51</td><td>8 要素实验方案</td><td>JSON plans</td></tr>
+          <tr><td>10</td><td>步骤⑦</td><td>report_agent.py:197</td><td>整合 4 字段为 Markdown 研究提案</td><td>JSON + markdown</td></tr>
+          <tr><td>11</td><td>评估</td><td>quality.py:73</td><td>学术评审专家三维评分校验</td><td>JSON score</td></tr>
+        </tbody>
+      </table>
+
+      <h3>工具调用清单</h3>
+      <table>
+        <thead>
+          <tr><th>工具</th><th>步骤</th><th>输入</th><th>输出</th><th>特性</th></tr>
+        </thead>
+        <tbody>
+          <tr><td><code class="inline">scan_folder</code></td><td>①</td><td>folder_path</td><td>pdf_files 列表</td><td>本地</td></tr>
+          <tr><td><code class="inline">parse_pdf</code></td><td>①</td><td>file_path</td><td>ParsedPaper</td><td>本地 · 并发 · 缓存</td></tr>
+          <tr><td><code class="inline">extract_paper_structure</code></td><td>②</td><td>paper_path, parsed_paper</td><td>PaperRecord</td><td>LLM · 并发 · 缓存</td></tr>
+          <tr><td><code class="inline">build_vector_index</code></td><td>③</td><td>papers_json</td><td>indexed_count</td><td>本地 · 持久化</td></tr>
+          <tr><td><code class="inline">analyze_gaps</code></td><td>④</td><td>papers_records</td><td>gaps 列表</td><td>LLM · 内部调 RAG</td></tr>
+          <tr><td><code class="inline">hybrid_search</code></td><td>④⑤</td><td>query</td><td>检索片段 + 分数</td><td>Chroma + BM25</td></tr>
+          <tr><td><code class="inline">generate_innovations</code></td><td>⑤</td><td>gaps, research_direction</td><td>innovations 列表</td><td>LLM · 内部调 web_search</td></tr>
+          <tr><td><code class="inline">web_search</code></td><td>⑤</td><td>query</td><td>搜索结果摘要</td><td>DuckDuckGo</td></tr>
+          <tr><td><code class="inline">design_experiments</code></td><td>⑥</td><td>innovations</td><td>experiment_plans</td><td>LLM</td></tr>
+          <tr><td><code class="inline">load_memory / save_memory</code></td><td>⑤</td><td>type, query</td><td>历史 Gap/创新点</td><td>Chroma 长期记忆</td></tr>
+        </tbody>
+      </table>
+    </section>
+
+    <!-- Principles -->
+    <section id="principles">
+      <h2 class="section-title"><span class="num">8</span>Prompt 设计的 5 个核心原则</h2>
+      <p class="section-desc">贯穿所有 prompt 的设计哲学。</p>
+
+      <div class="card">
+        <h4>① System 角色锚定</h4>
+        <p>每个 prompt 都用 system 消息锁定角色("你是 XX 专家"),并在末尾强调"只输出严格 JSON",避免自由文本。</p>
+
+        <h4>② 结构化输出强制</h4>
+        <p>全部用 Function Calling 或显式 JSON Schema,避免 LLM 自由发挥导致解析失败。步骤② 用 <code class="inline">tool_choice={"type":"function",...}</code> 强制调用。</p>
+
+        <h4>③ 防编造机制</h4>
+        <p><code class="inline">source_sections</code> 强制溯源 + "严禁臆造" + "缺失填暂无"。步骤② limitations 字段特别约束:论文未明确承认时填"论文未明确陈述局限"而非编造。</p>
+
+        <h4>④ 上下文注入</h4>
+        <p>把前序步骤的结构化产物作为"证据"喂给模型,而非让模型凭空推理。步骤④ 喂对比矩阵、步骤⑦ 喂 4 字段聚合。</p>
+
+        <h4>⑤ 降级兜底</h4>
+        <p>每个 LLM 调用都有 <code class="inline">try/except</code>,失败时回退到本地格式化或默认值。步骤⑦ LLM 失败 → <code class="inline">_format_markdown()</code> 本地组装。</p>
+      </div>
+    </section>
+
+    <!-- Degradation -->
+    <section id="degrade">
+      <h2 class="section-title"><span class="num">9</span>降级与容错策略</h2>
+      <p class="section-desc">每个步骤都有失败兜底,局部失败不阻塞全局。</p>
+
+      <table>
+        <thead>
+          <tr><th>失败点</th><th>降级路径</th><th>影响</th></tr>
+        </thead>
+        <tbody>
+          <tr><td>单篇论文解析失败</td><td>隔离跳过,独立缓存可单独重跑</td><td>不影响其他论文</td></tr>
+          <tr><td>LLM 输出非 JSON</td><td>Function Calling 强制 schema + <code class="inline">parse_json_safe</code> 程序层兜底</td><td>该字段降级为空</td></tr>
+          <tr><td>工具调用超时/失败</td><td>3 次重试 + 降级路径</td><td>记录 <code class="inline">degraded_steps</code></td></tr>
+          <tr><td>论文超长截断</td><td>按章节分块抽取后合并去重</td><td>无影响</td></tr>
+          <tr><td>Controller 规划失败</td><td>异常捕获 + 回退默认七步</td><td>无影响</td></tr>
+          <tr><td>向量索引构建失败</td><td>跳过 RAG,仅用结构化字段做 Gap 分析</td><td>Gap evidence 无原文佐证</td></tr>
+          <tr><td>联网搜索失败</td><td>跳过新颖性去重,标记"未验证"</td><td>novelty_check 为空</td></tr>
+          <tr><td>Reflexion 重试 2 次仍不达标</td><td>标记 <code class="inline">needs_human_review</code>,流程继续</td><td>评估报告标注</td></tr>
+          <tr><td>步骤⑦ LLM 整合失败</td><td>本地 <code class="inline">_format_markdown()</code> 格式化组装</td><td>报告样式简化</td></tr>
+          <tr><td>LLM 编造内容</td><td>所有字段强制 <code class="inline">source_sections</code> 字段级回溯</td><td>可人工核查</td></tr>
+        </tbody>
+      </table>
+
+      <div class="callout ok">
+        <strong>设计哲学:</strong>"工具即思维" — Function Calling 把"决策"显式化为工具调用,可观测、可回放;"降级即韧性" — 每个步骤都有失败兜底,局部失败不阻塞全局。
+      </div>
+    </section>
+
+    <div class="footer">
+      PaperMind · 论文创新点发现 Agent · 端到端运行流程详解<br>
+      基于源码 <code style="background:rgba(255,255,255,0.05);padding:2px 6px;border-radius:4px;">backend/</code> 自动生成 · 共 11 次 LLM 调用 · 10 个工具
+    </div>
+
+  </main>
+</div>
+
+<script>
+  // 侧边栏高亮当前 section
+  const links = document.querySelectorAll('.sidebar a');
+  const sections = document.querySelectorAll('section[id], div[id]');
+  const observer = new IntersectionObserver((entries) => {
+    entries.forEach(entry => {
+      if (entry.isIntersecting) {
+        const id = entry.target.id;
+        links.forEach(l => {
+          l.classList.toggle('active', l.getAttribute('href') === '#' + id);
+        });
+      }
+    });
+  }, { rootMargin: '-20% 0px -70% 0px' });
+  sections.forEach(s => observer.observe(s));
+</script>
+</body>
+</html>

BIN
Co-creation-projects/jphJack-PaperMindAgent/plan.docx


+ 24 - 0
Co-creation-projects/jphJack-PaperMindAgent/requirements.txt

@@ -0,0 +1,24 @@
+# PaperMind - 项目依赖(HelloAgents 框架 + 后端 + 评估)
+# 安装:pip install -r requirements.txt
+
+# 核心框架
+hello-agents>=1.0.0
+openai==1.51.0
+
+# Web 框架
+fastapi==0.115.0
+uvicorn[standard]==0.30.6
+sse-starlette==2.1.3
+python-multipart==0.0.12
+
+# RAG 与文档解析
+chromadb==0.5.5
+sentence-transformers==3.0.1
+pymupdf==1.24.10
+rank-bm25==0.2.2
+
+# 工程基础
+pydantic==2.9.2
+python-dotenv==1.0.1
+httpx==0.27.2
+aiosqlite==0.20.0

+ 13 - 0
Co-creation-projects/jphJack-PaperMindAgent/run_backend.py

@@ -0,0 +1,13 @@
+"""项目根目录启动脚本:python run_backend.py 启动 uvicorn 服务
+
+    host=0.0.0.0, port=8000
+"""
+import uvicorn
+
+if __name__ == "__main__":
+    uvicorn.run(
+        "backend.api.main:app",
+        host="0.0.0.0",
+        port=8000,
+        reload=False,
+    )

+ 94 - 0
Co-creation-projects/jphJack-PaperMindAgent/smoke_test_hello_agents.py

@@ -0,0 +1,94 @@
+"""冒烟测试:验证 HelloAgents 集成后的模块导入、客户端构造、响应适配与工具桥接"""
+import asyncio
+import os
+import sys
+
+os.environ.setdefault("DEEPSEEK_API_KEY", "smoke-test-key")
+os.environ.setdefault("DEEPSEEK_BASE_URL", "https://api.deepseek.com")
+os.environ.setdefault("DEEPSEEK_MODEL", "deepseek-chat")
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+failures = []
+
+# 1. LLM 客户端(底层为 HelloAgentsLLM)
+from backend.llm.client import ChatCompletionShim, DeepSeekClient
+
+client = DeepSeekClient()
+assert type(client.llm).__name__ == "HelloAgentsLLM", "底层不是 HelloAgentsLLM"
+print("[PASS] DeepSeekClient 底层为 HelloAgentsLLM")
+
+class FakeLLMResponse:
+    content = '{"confidence": 0.9}'
+    reasoning_content = None
+    model = "deepseek-chat"
+    usage = {"total_tokens": 10}
+
+shim = ChatCompletionShim(FakeLLMResponse())
+assert shim.choices[0].message.content == '{"confidence": 0.9}'
+assert shim.choices[0].finish_reason == "stop"
+print("[PASS] ChatCompletionShim 兼容 choices[0].message.content")
+
+# 2. 工具桥接
+from hello_agents.tools.response import ToolStatus
+from backend.tools.base import Tool as ProjectTool, ToolRegistry
+from backend.tools.hello_agents_bridge import build_hello_agents_registry
+
+def sync_tool(query: str) -> dict:
+    return {"echo": query}
+
+async def async_tool(text: str) -> str:
+    return f"async:{text}"
+
+registry = ToolRegistry()
+registry.register(ProjectTool(
+    name="sync_tool",
+    description="同步工具",
+    parameters={"type": "object", "properties": {"query": {"type": "string"}}, "required": ["query"]},
+    func=sync_tool,
+))
+registry.register(ProjectTool(
+    name="async_tool",
+    description="异步工具",
+    parameters={"type": "object", "properties": {"text": {"type": "string"}}, "required": ["text"]},
+    func=async_tool,
+))
+
+ha_registry = build_hello_agents_registry(registry)
+assert set(ha_registry.list_tools()) == {"sync_tool", "async_tool"}, ha_registry.list_tools()
+schema = ha_registry.get_tool("sync_tool").to_openai_schema()
+assert schema["function"]["name"] == "sync_tool"
+assert "query" in schema["function"]["parameters"]["properties"]
+print("[PASS] 项目工具已桥接为框架 Tool 且 schema 正确")
+
+async def run_async_checks():
+    r1 = await ha_registry.get_tool("sync_tool").arun({"query": "hi"})
+    assert r1.status == ToolStatus.SUCCESS and r1.data["echo"] == "hi", r1
+    r2 = await ha_registry.get_tool("async_tool").arun({"text": "x"})
+    assert r2.status == ToolStatus.SUCCESS and r2.text == "async:x", r2
+    print("[PASS] 框架 Tool arun 同步/异步工具均返回 ToolStatus.SUCCESS")
+
+asyncio.run(run_async_checks())
+
+# 3. 框架 Agent 封装(无需真实 API,仅构造与接线)
+from backend.agents.hello_agents_runner import build_react_agent, build_reviewer_agent
+
+reviewer = build_reviewer_agent(client.llm)
+assert type(reviewer).__name__ == "SimpleAgent"
+react = build_react_agent(
+    name="SmokeReAct",
+    llm=client.llm,
+    registry=registry,
+    system_prompt="测试",
+    tool_names=["sync_tool"],
+)
+assert type(react).__name__ == "ReActAgent"
+assert "sync_tool" in react.tool_registry.list_tools()
+print("[PASS] 框架 SimpleAgent / ReActAgent 构造正常,工具已注册")
+
+# 4. Reflexion 接线(引用框架审核 Agent)
+import backend.orchestrator.reflexion as reflexion_mod
+assert reflexion_mod.REVIEWER_SYSTEM_PROMPT
+print("[PASS] Reflexion 已接入框架 SimpleAgent 审核链路")
+
+print("\n全部冒烟测试通过")

+ 120 - 0
Co-creation-projects/jphJack-PaperMindAgent/staged-skills/paper-innovation-designer/SKILL.md

@@ -0,0 +1,120 @@
+---
+name: paper-innovation-designer
+description: Use when deriving research gaps, innovation ideas, novelty checks, or experiment plans from several academic PDF papers, parsed paper notes, literature-review excerpts, or structured paper records; especially when the user asks to generate 2-3 feasible innovation points, compare limitations across papers, design experiments, select datasets/baselines/metrics, or write a research proposal grounded in source papers.
+---
+
+# Paper Innovation Designer
+
+## Overview
+
+Turn a small paper set into evidence-grounded innovation ideas and executable experiment plans. Preserve traceability: every gap, idea, and experiment choice should point back to specific source papers, sections, pages, or extracted evidence.
+
+## Workflow
+
+1. **Collect inputs**
+   - Use the provided PDFs, paper folder, extracted notes, or structured paper records.
+   - If the research direction is missing, infer a provisional direction from the papers and state it.
+   - If PDFs are available locally, extract text with a PDF-capable tool before synthesizing.
+
+2. **Extract each paper into a fixed schema**
+   - `title`
+   - `task_problem`
+   - `method`
+   - `key_contributions`
+   - `datasets`
+   - `metrics`
+   - `results`
+   - `limitations`
+   - `future_work`
+   - `source_sections` or source page evidence
+
+3. **Build a cross-paper evidence matrix**
+   Compare papers by task, method family, data setting, evaluation metrics, results, limitations, and future-work claims. Keep paper-specific failures isolated; do not let one weak extraction dominate the synthesis.
+
+4. **Identify research gaps**
+   Use these gap types:
+   - `repeated_limitation`: multiple papers share the same unresolved limitation.
+   - `method_gap`: current methods omit a plausible technique, signal, modality, constraint, or optimization target.
+   - `contradictory`: papers report conflicting findings, assumptions, or tradeoffs.
+   - `unfulfilled_future`: papers explicitly suggest future work that later papers still do not address.
+
+5. **Generate candidate innovation ideas**
+   Create candidates from four sources:
+   - `method_combination`: combine complementary methods from different papers.
+   - `limitation_fix`: directly address repeated or high-impact limitations.
+   - `cross_domain`: transfer a method from an adjacent task/domain.
+   - `new_scenario`: adapt the problem to a realistic but under-tested setting.
+
+6. **Score and filter**
+   Score each candidate from 0-10 on:
+   - novelty
+   - feasibility
+   - significance
+
+   Select 2-3 ideas with strong total score and clear evidence. If novelty cannot be checked online, mark it as "needs external novelty verification" instead of overstating originality.
+
+7. **Design experiments for each selected idea**
+   For every chosen idea, include:
+   - hypothesis
+   - target datasets or data collection plan
+   - baselines
+   - metrics
+   - ablation studies
+   - implementation steps
+   - expected results
+   - risks and mitigation
+
+## Output Format
+
+Use this structure unless the user requests another format:
+
+```markdown
+## Paper Evidence Matrix
+| Paper | Task | Method | Data | Key Result | Limitation/Future Work |
+
+## Research Gaps
+1. Gap: ...
+   Type: ...
+   Evidence: ...
+   Confidence: ...
+
+## Candidate Innovations
+| Idea | Source Type | Gap Origin | Novelty | Feasibility | Significance | Evidence |
+
+## Recommended 2-3 Ideas
+### Idea 1: ...
+Rationale: ...
+Why now: ...
+Source evidence: ...
+Novelty check: ...
+
+## Experiment Plans
+### Experiment Plan For Idea 1
+Hypothesis:
+Datasets:
+Baselines:
+Metrics:
+Ablations:
+Steps:
+Expected results:
+Risks:
+```
+
+## Quality Rules
+
+- Do not invent limitations; distinguish explicit limitations from inferred ones.
+- Prefer concrete ideas over broad slogans. A usable idea names the technical change, target task, expected mechanism, and evaluation path.
+- Do not claim novelty from memory alone. Use current web or database search when available; otherwise mark novelty as unverified.
+- Keep all recommendations feasible for a graduate-level research project unless the user asks for high-risk ideas.
+- Penalize ideas that cannot be evaluated with available data, baselines, or metrics.
+- Include negative evidence when a paper already solves the proposed idea.
+
+## Common Failure Modes
+
+| Failure | Correction |
+|---|---|
+| Summarizing each paper but not synthesizing across papers | Build the evidence matrix first, then derive gaps from overlaps and conflicts |
+| Generating generic "improve model accuracy" ideas | Specify method, target limitation, data setting, and measurable outcome |
+| Treating future work as a proven gap | Check whether another provided paper already addresses it |
+| Designing experiments without baselines | Use methods from source papers as minimum baselines |
+| Overclaiming novelty | Add a novelty-check note or uncertainty label |

+ 4 - 0
Co-creation-projects/jphJack-PaperMindAgent/staged-skills/paper-innovation-designer/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Paper Innovation Designer"
+  short_description: "Generate evidence-grounded research ideas and experiment plans from papers."
+  default_prompt: "Use $paper-innovation-designer to generate innovation ideas and experiment plans from these papers."