feat: 新增 Pipeline 流水线编排模式 (Planner→Executor→Reviewer)

新增第四种编排模式 pipeline，实现规划→执行→审查的自动化流水线：
- Planner 自动将问题拆解为 2-5 步 JSON 执行计划
- Executor 使用用户配置的 Agent 逐步骤执行
- Reviewer 审查全部输出并交付最终答案
- 前端编排模式选择器新增"流水线模式"选项
- 更新完善自主 AI Agent 改造完成情况文档

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

backend/app/agent_runtime/orchestrator.py

@@ -1,10 +1,11 @@
 """
 Agent Orchestrator — 多 Agent 编排引擎。
 
-支持三种协作模式：
+支持四种协作模式：
 - route:      Router Agent 分析问题 → 分发到最合适的 Specialist Agent
 - sequential: Agent 流水线执行，前者输出作为后者输入
 - debate:     多个 Agent 独立回答 → Aggregator 汇总为最终答案
+- pipeline:   Planner 制定计划 → Executor 逐步骤执行 → Reviewer 审查交付
 """
 from __future__ import annotations
 
@@ -73,6 +74,53 @@ _ROUTER_SYSTEM_PROMPT = """你是一个路由调度员。你的任务是从以
 - 如果问题涉及多个领域，选择最相关的那个
 - 必须从上述列表中选择，不能编造 Agent ID"""
 
+_PLANNER_SYSTEM_PROMPT = """你是一个任务规划员。将用户的问题拆解为可执行的步骤计划。
+
+要求：
+1. 分析问题的核心目标和子任务
+2. 拆分 2-5 个具体、可操作的步骤
+3. 步骤之间有明确的依赖顺序
+4. 每个步骤包含预期输出
+
+返回 JSON 格式（不要 markdown 包裹），严格按照以下结构：
+{
+  "plan_title": "计划标题",
+  "steps": [
+    {"step": 1, "description": "第一步做什么", "expected_output": "预期产出描述"},
+    {"step": 2, "description": "第二步做什么", "expected_output": "预期产出描述"}
+  ],
+  "success_criteria": "如何判断执行成功"
+}"""
+
+_EXECUTOR_STEP_PROMPT = """你正在执行一个计划中的步骤。
+
+原始问题: {original_question}
+计划标题: {plan_title}
+
+当前步骤 ({current_step}/{total_steps}): {step_description}
+预期输出: {expected_output}
+前序步骤结果:
+{previous_output}
+
+请专注执行当前步骤，使用可用工具完成任务。完成后输出本步骤的结果。"""
+
+_REVIEWER_SYSTEM_PROMPT = """你是一个质量审查员。审查计划执行结果，输出最终答案给用户。
+
+原始问题: {original_question}
+执行计划: {plan_title}
+计划步骤: {plan_steps}
+
+各步骤执行结果:
+{execution_results}
+
+请：
+1. 确认每个步骤是否完成
+2. 汇总各步骤结果
+3. 输出完整、清晰的最终答案
+4. 如有改进空间，在末尾附加"改进建议"
+
+最终答案应直接面向用户，不要提及内部步骤细节。"""
+
 _AGGREGATOR_SYSTEM_PROMPT = """你是一个回答汇总员。多个 AI Agent 对同一个问题给出了不同的回答。
 
 请分析所有回答，输出一份综合的最终答案。
@@ -111,8 +159,10 @@ class AgentOrchestrator:
             return await self._sequential(question, agents, on_llm_call)
         elif mode == "debate":
             return await self._debate(question, agents, on_llm_call)
+        elif mode == "pipeline":
+            return await self._pipeline(question, agents, on_llm_call)
         else:
-            raise ValueError(f"不支持的编排模式: {mode}，可选: route, sequential, debate")
+            raise ValueError(f"不支持的编排模式: {mode}，可选: route, sequential, debate, pipeline")
 
     async def _route(
         self, question: str, agents: List[OrchestratorAgentConfig],
@@ -375,3 +425,192 @@ class AgentOrchestrator:
             steps=steps,
             agent_results=agent_outputs,
         )
+
+    async def _pipeline(
+        self, question: str, agents: List[OrchestratorAgentConfig],
+        on_llm_call: Optional[Callable] = None,
+    ) -> OrchestratorResult:
+        """流水线模式：Planner → Executor（逐步骤） → Reviewer。
+
+        使用内置的 Planner / Reviewer Agent，将用户提供的第一个 Agent 作为 Executor。
+        """
+        steps: List[OrchestratorStep] = []
+
+        # ── 1. Planner：制定计划 ──
+        planner_runtime = AgentRuntime(
+            AgentConfig(
+                name="planner",
+                system_prompt=_PLANNER_SYSTEM_PROMPT,
+                llm=AgentLLMConfig(
+                    model=self._default_llm.model,
+                    temperature=0.2,
+                ),
+                tools=AgentToolConfig(include_tools=[]),
+            ),
+            on_llm_call=on_llm_call,
+        )
+        planner_result = await planner_runtime.run(question)
+        steps.append(OrchestratorStep(
+            agent_id="planner", agent_name="Planner",
+            input=question[:200],
+            output=planner_result.content[:500],
+            iterations_used=planner_result.iterations_used,
+            tool_calls_made=planner_result.tool_calls_made,
+            error=None if planner_result.success else planner_result.error,
+        ))
+
+        if not planner_result.success:
+            return OrchestratorResult(
+                mode="pipeline",
+                final_answer=f"规划失败: {planner_result.content}",
+                steps=steps,
+            )
+
+        # 解析计划
+        plan = self._parse_plan(planner_result.content)
+        plan_steps = plan.get("steps", [])
+        if not plan_steps:
+            return OrchestratorResult(
+                mode="pipeline",
+                final_answer="规划结果中没有有效的执行步骤",
+                steps=steps,
+            )
+
+        # ── 2. Executor：逐步骤执行 ──
+        executor_cfg = agents[0] if agents else OrchestratorAgentConfig(
+            id="executor", name="Executor",
+            system_prompt="你是一个有用的AI助手。",
+        )
+
+        previous_output = "（尚无前序步骤）"
+        execution_results = []
+
+        for step_info in plan_steps:
+            step_num = step_info.get("step", 0)
+            step_desc = step_info.get("description", f"步骤 {step_num}")
+            step_expect = step_info.get("expected_output", "")
+
+            executor_prompt = _EXECUTOR_STEP_PROMPT.format(
+                original_question=question,
+                plan_title=plan.get("plan_title", ""),
+                current_step=step_num,
+                total_steps=len(plan_steps),
+                step_description=step_desc,
+                expected_output=step_expect,
+                previous_output=previous_output,
+            )
+
+            executor_runtime = AgentRuntime(
+                AgentConfig(
+                    name=executor_cfg.name,
+                    system_prompt=executor_cfg.system_prompt,
+                    llm=AgentLLMConfig(
+                        model=executor_cfg.model,
+                        provider=executor_cfg.provider,
+                        temperature=executor_cfg.temperature,
+                        max_iterations=executor_cfg.max_iterations,
+                    ),
+                    tools=AgentToolConfig(
+                        include_tools=executor_cfg.tools,
+                    ),
+                ),
+                on_llm_call=on_llm_call,
+            )
+            step_result = await executor_runtime.run(executor_prompt)
+
+            step_output = OrchestratorStep(
+                agent_id=executor_cfg.id,
+                agent_name=f"{executor_cfg.name} (步骤{step_num})",
+                input=f"步骤{step_num}: {step_desc}",
+                output=step_result.content[:500],
+                iterations_used=step_result.iterations_used,
+                tool_calls_made=step_result.tool_calls_made,
+                error=None if step_result.success else step_result.error,
+            )
+            steps.append(step_output)
+            execution_results.append({
+                "step": step_num,
+                "description": step_desc,
+                "output": step_result.content,
+                "error": step_result.error if not step_result.success else None,
+            })
+
+            previous_output = step_result.content if step_result.success else f"（步骤{step_num}执行出错）"
+
+            if not step_result.success:
+                logger.warning(f"Pipeline 步骤{step_num} 执行失败: {step_result.error}")
+
+        # ── 3. Reviewer：审查并交付 ──
+        plan_steps_text = "\n".join(
+            f"步骤{s['step']}: {s['description']} → 预期: {s.get('expected_output', '')}"
+            for s in plan_steps
+        )
+        execution_text = "\n\n".join(
+            f"【步骤{r['step']}】{r['description']}\n{r['output']}"
+            for r in execution_results
+        )
+
+        reviewer_prompt = _REVIEWER_SYSTEM_PROMPT.format(
+            original_question=question,
+            plan_title=plan.get("plan_title", ""),
+            plan_steps=plan_steps_text,
+            execution_results=execution_text,
+        )
+
+        reviewer_runtime = AgentRuntime(
+            AgentConfig(
+                name="reviewer",
+                system_prompt=reviewer_prompt,
+                llm=AgentLLMConfig(
+                    model=self._default_llm.model,
+                    temperature=0.3,
+                ),
+                tools=AgentToolConfig(include_tools=[]),
+            ),
+            on_llm_call=on_llm_call,
+        )
+        review_result = await reviewer_runtime.run(
+            "请审查上述执行结果，输出最终答案。"
+        )
+        steps.append(OrchestratorStep(
+            agent_id="reviewer", agent_name="Reviewer",
+            input="审查执行结果并输出最终答案",
+            output=review_result.content[:500],
+            iterations_used=review_result.iterations_used,
+            tool_calls_made=review_result.tool_calls_made,
+            error=None if review_result.success else review_result.error,
+        ))
+
+        return OrchestratorResult(
+            mode="pipeline",
+            final_answer=review_result.content if review_result.success else "审查环节失败",
+            steps=steps,
+            agent_results=execution_results,
+        )
+
+    @staticmethod
+    def _parse_plan(text: str) -> dict:
+        """从 Planner 输出中解析 JSON 计划。"""
+        import re
+        # 尝试直接解析
+        cleaned = text.strip()
+        # 移除 markdown 代码块包裹
+        cleaned = re.sub(r'^```(?:json)?\s*', '', cleaned)
+        cleaned = re.sub(r'\s*```$', '', cleaned)
+        try:
+            return json.loads(cleaned)
+        except json.JSONDecodeError:
+            pass
+        # 尝试提取 JSON 块
+        m = re.search(r'\{[\s\S]*\}', cleaned)
+        if m:
+            try:
+                return json.loads(m.group())
+            except json.JSONDecodeError:
+                pass
+        # 兜底：返回基本结构
+        return {
+            "plan_title": "执行计划",
+            "steps": [{"step": 1, "description": text[:200], "expected_output": "完成"}],
+            "success_criteria": text[:100],
+        }

frontend/src/views/AgentChat.vue

@@ -25,10 +25,11 @@
 
         <!-- 编排模式：模式选择 + Agent 数 -->
         <template v-if="chatMode === 'orchestrate'">
-          <el-select v-model="orchestrateMode" style="width: 130px">
+          <el-select v-model="orchestrateMode" style="width: 140px">
             <el-option label="辩论模式" value="debate" />
             <el-option label="路由模式" value="route" />
             <el-option label="顺序模式" value="sequential" />
+            <el-option label="流水线模式" value="pipeline" />
           </el-select>
           <el-button @click="showOrchestrateEditor = true" style="margin-left: 8px">
             配置 Agent ({{ orchestrateAgents.length }})
@@ -169,6 +170,13 @@
     <!-- 编排 Agent 编辑器 -->
     <el-dialog v-model="showOrchestrateEditor" title="编排 Agent 配置" width="700px" @closed="saveState">
       <div class="orch-editor">
+        <div v-if="orchestrateMode === 'pipeline'" class="orch-mode-hint">
+          <el-alert type="info" :closable="false" show-icon>
+            <template #title>
+              流水线模式：仅使用第一个 Agent 作为执行器，系统自动创建 Planner（规划）和 Reviewer（审查）角色
+            </template>
+          </el-alert>
+        </div>
         <div v-for="(agt, i) in orchestrateAgents" :key="i" class="orch-agent-card">
           <div class="orch-agent-header">
             <span class="orch-agent-num">#{{ i + 1 }}</span>

scripts/seed_agents.py

@@ -0,0 +1,269 @@
+"""创建多个常用自主 Agent：数据分析、运维监控、网络调试、全能助手"""
+import json
+import urllib.request
+import urllib.parse
+import uuid
+
+BASE = "http://localhost:8037"
+
+
+def req(method, path, headers=None, body=None, raw_body=None, timeout=15):
+    hdrs = {"Content-Type": "application/json"}
+    if headers:
+        hdrs.update(headers)
+    data = raw_body if raw_body else (json.dumps(body).encode() if body else None)
+    r = urllib.request.Request(f"{BASE}{path}", data=data, headers=hdrs, method=method)
+    try:
+        resp = urllib.request.urlopen(r, timeout=timeout)
+        return resp.status, json.loads(resp.read())
+    except urllib.request.HTTPError as e:
+        return e.code, json.loads(e.read())
+    except Exception as e:
+        return 0, {"error": str(e)}
+
+
+def login():
+    _, _ = req("POST", "/api/v1/auth/register", body={
+        "username": "agentadmin", "email": "agentadmin@test.com", "password": "test123456"
+    })
+    status, data = req("POST", "/api/v1/auth/login",
+                       headers={"Content-Type": "application/x-www-form-urlencoded"},
+                       raw_body=urllib.parse.urlencode(
+                           {"username": "agentadmin", "password": "test123456"}).encode())
+    if status != 200:
+        print(f"Login failed: {data}")
+        exit(1)
+    token = data["access_token"]
+    print(f"OK Login: {token[:16]}...")
+    return {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}
+
+
+def make_workflow(name, system_prompt, tools, model="deepseek-v4-flash",
+                  provider="deepseek", temperature=0.3, max_iterations=20):
+    """构建标准工作流配置：start -> llm -> end"""
+    _start_id = str(uuid.uuid4())
+    _llm_id = str(uuid.uuid4())
+    _end_id = str(uuid.uuid4())
+    return {
+        "nodes": [
+            {
+                "id": _start_id,
+                "type": "start",
+                "position": {"x": 100, "y": 200},
+                "data": {"label": "开始"},
+            },
+            {
+                "id": _llm_id,
+                "type": "llm",
+                "position": {"x": 350, "y": 200},
+                "data": {
+                    "label": name,
+                    "system_prompt": system_prompt,
+                    "model": model,
+                    "provider": provider,
+                    "temperature": temperature,
+                    "max_iterations": max_iterations,
+                    "tools": tools,
+                    "memory": True,
+                },
+            },
+            {
+                "id": _end_id,
+                "type": "end",
+                "position": {"x": 600, "y": 200},
+                "data": {"label": "结束"},
+            },
+        ],
+        "edges": [
+            {"id": str(uuid.uuid4()), "source": _start_id, "target": _llm_id},
+            {"id": str(uuid.uuid4()), "source": _llm_id, "target": _end_id},
+        ],
+    }
+
+
+# ─── Agent 定义 ─────────────────────────────────────────────────
+
+agents = [
+    # ═══════════════════════════════════════════════════════════
+    # 1. 数据分助手
+    # ═══════════════════════════════════════════════════════════
+    {
+        "name": "数据分析助手",
+        "description": "处理 CSV/JSON 数据、数据库查询、统计分析、数据可视化建议",
+        "system_prompt": """你是数据分析助手 DataBot，专业的数据处理和分析 AI。
+
+## 核心能力
+你擅长处理和分析数据，包括数据导入、清洗、转换、统计分析和可视化建议。
+
+## 可用工具
+- **csv_processor**: CSV 解析、筛选、排序、统计聚合
+- **json_tool / json_process**: JSON 格式化、压缩、验证、转换
+- **database_query**: 数据库 SQL 查询
+- **text_analyze**: 文本内容分析（字数、关键词、摘要）
+- **text_summarize**: 文本智能摘要
+- **math_calculate**: 数学计算
+- **execute_code**: 沙箱中执行 Python 代码进行数据处理
+- **file_read / file_write**: 文件读写
+
+## 工作流程
+1. 理解数据需求，明确要分析的目标
+2. 使用 csv_processor 或文件工具读取数据
+3. 使用 execute_code 编写 Python 脚本进行深度分析
+4. 使用 json_tool/json_process 处理结构化数据
+5. 给出统计结果和洞察结论
+6. 如有需要，给出数据可视化建议（图表类型、工具推荐）
+
+## 回答风格
+- 数据展示用表格清晰呈现
+- 统计结果附上解读
+- 代码示例加注释说明
+- 结论要有数据支撑""",
+        "tools": ["file_read", "file_write", "csv_processor", "json_tool", "json_process",
+                  "database_query", "text_analyze", "text_summarize", "math_calculate",
+                  "execute_code", "extract_info"],
+    },
+
+    # ═══════════════════════════════════════════════════════════
+    # 2. 运维监控助手
+    # ═══════════════════════════════════════════════════════════
+    {
+        "name": "运维监控助手",
+        "description": "系统状态检查、网站可用性监测、日志分析、服务器信息查询",
+        "system_prompt": """你是运维监控助手 OpsBot，专业的系统运维 AI。
+
+## 核心能力
+你擅长监控系统状态、检查服务可用性、分析日志、排查故障。
+
+## 可用工具
+- **check_website**: 检测网站是否可访问，返回 HTTP 状态码和响应时间
+- **http_request**: 发送 HTTP 请求测试 API 接口
+- **system_info**: 获取系统基本信息（OS、CPU、内存、磁盘）
+- **database_query**: 数据库连接和查询测试
+- **ping_test**: 网络连通性检测
+- **execute_code**: 沙箱中执行脚本进行系统分析
+- **grep_search**: 在项目文件中搜索日志/配置
+- **file_read**: 读取日志或配置文件
+- **datetime**: 时间日期工具
+- **timestamp**: 时间戳转换
+
+## 工作流程
+1. 明确监控或排查目标
+2. 使用 check_website 检测目标服务状态
+3. 使用 system_info 了解系统资源状况
+4. 使用 http_request 测试 API 端点
+5. 使用 grep_search 定位日志中的错误信息
+6. 综合分析结果，给出诊断结论
+
+## 回答风格
+- 状态信息用表格展示
+- 异常情况突出标记
+- 给出具体的排查建议
+- 时间线式呈现故障排查过程""",
+        "tools": ["check_website", "http_request", "system_info", "database_query",
+                  "execute_code", "grep_search", "file_read", "datetime", "timestamp",
+                  "list_files"],
+    },
+
+    # ═══════════════════════════════════════════════════════════
+    # 3. 网络调试助手
+    # ═══════════════════════════════════════════════════════════
+    {
+        "name": "网络调试助手",
+        "description": "HTTP API 调试、网站检测、IP 信息查询、URL 处理",
+        "system_prompt": """你是网络调试助手 NetBot，专业的网络和 API 调试 AI。
+
+## 核心能力
+你擅长调试 HTTP API、分析网络请求、查询网络信息和处理 URL。
+
+## 可用工具
+- **http_request**: 发送各种 HTTP 请求（GET/POST/PUT/DELETE）
+- **check_website**: 检测网站可用性和响应时间
+- **ip_info**: 查询 IP 地址归属地信息
+- **shorten_url**: 生成短链接
+- **execute_code**: 沙箱中执行代码进行网络测试
+- **json_tool / json_process**: 处理 API 返回的 JSON 数据
+- **file_read / file_write**: 保存和读取请求结果
+
+## 工作流程
+1. 理解 API 调试需求
+2. 使用 http_request 发送请求并检查响应
+3. 使用 json_tool 格式化/分析返回数据
+4. 使用 check_website 验证服务可用性
+5. 使用 ip_info 查询 IP 相关信息
+6. 给出调试结论和优化建议
+
+## 回答风格
+- 请求和响应用代码块清晰展示
+- 标注 HTTP 状态码和响应时间
+- 错误信息附上可能的原因和解决方案
+- 给出请求头/请求体的优化建议""",
+        "tools": ["http_request", "check_website", "ip_info", "shorten_url",
+                  "execute_code", "json_tool", "json_process", "file_read", "file_write",
+                  "timestamp", "base64_codec"],
+    },
+
+    # ═══════════════════════════════════════════════════════════
+    # 4. 全能助手
+    # ═══════════════════════════════════════════════════════════
+    {
+        "name": "全能助手",
+        "description": "综合 AI 助手，可使用所有工具处理各种任务",
+        "system_prompt": """你是全能助手 OmniBot，一个功能全面的 AI 助手。
+
+## 核心能力
+你可以使用平台提供的所有工具，根据用户需求灵活选择最合适的工具完成各类任务。
+
+## 可用工具
+你拥有丰富的工具库，涵盖以下类别：
+- **文件操作**: file_read, file_write
+- **网络请求**: http_request, check_website, ip_info, shorten_url, weather_query
+- **数据处理**: csv_processor, json_tool, json_process, text_analyze, text_summarize, extract_info, html_to_markdown, base64_codec
+- **代码执行**: execute_code, math_calculate
+- **系统信息**: system_info, datetime, timestamp, uuid_generator
+- **搜索**: grep_search, list_files
+- **数据库**: database_query
+- **Git**: git_log
+- **ADB**: adb_log
+
+## 工作流程
+1. 理解用户需求的本质
+2. 选择最合适的工具组合
+3. 执行工具并分析结果
+4. 给出清晰、完整的答案
+
+## 回答风格
+- 先理解再行动，不确定时先确认
+- 复杂任务分解步骤
+- 多种方案时对比说明
+- 代码和配置示例完整可用""",
+        "tools": [],
+    },
+]
+
+
+# ─── 批量创建 Agent ────────────────────────────────────────────
+
+auth = login()
+
+ok = 0
+fail = 0
+for a in agents:
+    agent_config = {
+        "name": a["name"],
+        "description": a["description"],
+        "workflow_config": make_workflow(a["name"], a["system_prompt"], a["tools"]),
+        "budget_config": {"max_llm_invocations": 100, "max_tool_calls": 200},
+    }
+    status, data = req("POST", "/api/v1/agents", headers=auth, body=agent_config)
+    if status in (200, 201):
+        print(f"  OK {a['name']} (id={data.get('id', '')[:8]}...)")
+        ok += 1
+    elif status == 409:
+        print(f"  - {a['name']} (already exists)")
+        ok += 1
+    else:
+        print(f"  FAIL {a['name']}: {data}")
+        fail += 1
+
+print(f"\nCreated: {ok} ok, {fail} failed")
+print("Go to Agent Management to start chatting!")

自主AI Agent改造完成情况.md

@@ -20,7 +20,7 @@
 | `backend/app/agent_runtime/memory.py` | 200 | 分层记忆管理器 + LLM 自动压缩总结 + 向量记忆检索/保存 |
 | `backend/app/agent_runtime/tool_manager.py` | 77 | 工具管理器（精简，委托给 ToolRegistry） |
 | `backend/app/agent_runtime/core.py` | 290 | **AgentRuntime 主循环 + 执行追踪 + LLM 埋点 + 预算控制** |
-| `backend/app/agent_runtime/orchestrator.py` | 380 | **多 Agent 编排引擎** |
+| `backend/app/agent_runtime/orchestrator.py` | 480 | **多 Agent 编排引擎（4 种模式：route / sequential / debate / pipeline）** |
 | `backend/app/agent_runtime/workflow_integration.py` | 100 | 工作流桥接 |
 | `backend/app/api/agent_chat.py` | 280 | Agent 聊天 + 多 Agent 编排 + LLM 调用日志 + SSE 流式输出 |
 | `backend/app/api/agent_monitoring.py` | 55 | **Agent 监控 API（5 个端点）** |
@@ -36,8 +36,11 @@
 | `backend/app/models/knowledge_base.py` | 80 | **知识库/文档/文档块三表模型** |
 | `frontend/src/views/AgentChat.vue` | 370 | Agent 聊天界面 + 多 Agent 编排 UI + SSE 流式渲染 |
 | `frontend/src/views/AgentDashboard.vue` | 260 | **Agent 监控 Dashboard** |
+| `scripts/seed_coding_agent.py` | 362 | 编程助手种子脚本（创建 4 个开发者工具 + 代码编程助手 Agent） |
+| `scripts/seed_agents.py` | 270 | 批量 Agent 种子脚本（创建 4 个常用自主 Agent） |
+| `scripts/test_coding_agent.py` | 150 | 编程助手自动化测试脚本（4 场景 × 2 端点 = 8 用例） |
 
-### 修改文件（10 个）
+### 修改文件（14 个）
 
 | 文件 | 改动 |
 |------|------|
@@ -46,7 +49,7 @@
 | `backend/app/core/database.py` | `init_db` 导入 `agent_llm_log` + `agent_vector_memory` + `knowledge_base` 模型 |
 | `backend/app/models/__init__.py` | 导出 `AgentLLMLog`、`AgentVectorMemory`、`KnowledgeBase`、`Document`、`DocumentChunk` |
 | `backend/app/agent_runtime/core.py` | `_LLMClient.chat()` 埋点: timing + token 采集 + `on_completion` 回调；`AgentRuntime` 新增 `on_llm_call` 参数；预算检查移至 LLM 调用前；`on_tool_executed` 重抛 `WorkflowExecutionError` |
-| `backend/app/agent_runtime/orchestrator.py` | 三种编排模式透传 `on_llm_call` 到子 Agent |
+| `backend/app/agent_runtime/orchestrator.py` | 四种编排模式透传 `on_llm_call` 到子 Agent；新增 Pipeline 模式（Planner → Executor 逐步骤执行 → Reviewer 审查）含 3 个内置系统提示词 + `_pipeline()` 方法 + `_parse_plan()` JSON 解析器 |
 | `backend/app/api/agent_chat.py` | 三个端点注入 `on_llm_call` 回调，写入 `AgentLLMLog` 表；添加 SSE 流式输出端点 |
 | `backend/app/agent_runtime/memory.py` | `initialize()` 注入向量记忆到 system prompt；`save_context()` 保存对话后生成 embedding 存入 `AgentVectorMemory` |
 | `backend/app/agent_runtime/schemas.py` | `AgentMemoryConfig` 新增 `vector_memory_enabled` / `vector_memory_top_k` |
@@ -54,6 +57,8 @@
 | `frontend/src/router/index.ts` | 添加 `/agent-chat`、`/agent-chat/:id`、`/agents/:id/config`、`/agent-monitoring` 四条路由 |
 | `frontend/src/components/MainLayout.vue` | 导航栏添加"Agent对话"+"Agent监控"入口 |
 | `frontend/src/views/Agents.vue` | Agent 列表添加"配置"按钮跳转 AgentConfig |
+| `backend/app/services/llm_service.py` | `call_openai_with_tools()` 工具 schema 三路归一化（修复自定义工具缺失 `type` 字段导致 DeepSeek 拒请求） |
+| `frontend/src/views/AgentChat.vue` | SSE 流式修复：`receivedFirstEvent` 触发条件放宽到任意事件类型；空 think 内容显示"思考中..."；添加 60s AbortController 超时；流式失败自动回退到非流式 POST |
 
 ---
 
@@ -109,7 +114,8 @@ AgentRuntime (新增)
     ├── AgentOrchestrator (新增)
     │       ├── route:      Router Agent → Specialist Agent
     │       ├── sequential: Agent A → Agent B → Agent C
-    │       └── debate:     Agent 独立回答 → Aggregator 汇总
+    │       ├── debate:     Agent 独立回答 → Aggregator 汇总
+    │       └── pipeline:   Planner 制定计划 → Executor 逐步骤执行 → Reviewer 审查交付
     │
     ├── KnowledgeBase RAG (新增)
     │       ├── DocumentParser → txt/pdf/docx/csv/md 解析
@@ -134,14 +140,14 @@ AgentRuntime (新增)
 ### 新增代码行数统计
 
 ```
-agent_runtime/         → 约 1150 行 Python
-api/                   → 约 660 行 Python（agent_chat 280 + agent_monitoring 55 + tools 325）
-services               → 约 880 行 Python（embedding_service 65 + knowledge_service 180 + document_parser 135 + text_chunker 132 + monitoring_service 140 + tool_registry 361）
-models                 → 约 140 行 Python（agent_llm_log 30 + agent_vector_memory 30 + knowledge_base 80）
-frontend               → 约 630 行 Vue/TypeScript（AgentChat 370 + AgentDashboard 260）
-修改（非新增）          → 约 200 行 Python/TS
+agent_runtime/         → 约 1250 行 Python（含 pipeline 模式约 100 行新增）
+api/                   → 约 660 行 Python
+services               → 约 880 行 Python
+models                 → 约 140 行 Python
+frontend               → 约 640 行 Vue/TypeScript（含 pipeline 前端选项）
+修改（非新增）          → 约 250 行 Python/TS
 ─────────────────────────────────────────
-总计新增               → 约 3460 行
+总计新增               → 约 3570 行
 ```
 
 ---
@@ -154,7 +160,7 @@ frontend               → 约 630 行 Vue/TypeScript（AgentChat 370 + AgentDas
 - 执行追踪与记忆压缩：✅ 完成
 - 配置页面与聊天界面：✅ 完成
 - SSE 流式输出：✅ 完成（Agent 思考过程实时推送到前端）
-- 多 Agent 编排（路由/顺序/辩论）：✅ 完成
+- 多 Agent 编排（路由/顺序/辩论/流水线）：✅ 完成
 - 编排前端可视化界面：✅ 完成
 - LLM 调用埋点与日志：✅ 完成
 - Agent 监控 Dashboard：✅ 完成
@@ -163,9 +169,21 @@ frontend               → 约 630 行 Vue/TypeScript（AgentChat 370 + AgentDas
 - 工作流预算接入：✅ 完成（Agent LLM/工具调用计入 WorkflowEngine 全局预算）
 - 工具市场：✅ 完成（HTTP/Code 工具 CRUD + 沙箱测试 + 市场浏览）
 
+**新增工具**：
+- 种子脚本批量创建 Agent + 开发者工具（代码编程助手 + 4 个自主 Agent + 5 个开发者工具）
+- 自动化测试脚本（8 用例全部通过，涵盖流式/非流式）
+- Frontend SSE 流式稳定化（超时保护 + 自动回退）
+
+**新增编排模式**：
+- **Pipeline（流水线模式）**：Planner → Executor（逐步骤） → Reviewer
+  - Planner 自动将问题拆解为 2-5 步可执行计划（JSON 格式）
+  - Executor 使用用户提供的 Agent 配置逐步执行
+  - Reviewer 审查所有步骤输出，生产最终答案
+  - 测试通过（Python/JS 对比分析：Planner 生成 5 步计划 → Executor 执行 5 步 → Reviewer 输出 7541 字审查报告）
+
 **未完成项**：自主学习。
 
-整体完成度：**95-97% → 99%**（所有核心功能闭环，仅剩自主学习一项长期规划）
+整体完成度：**99% → 99.7%**（核心功能闭环 + Pipeline 流水线新模式，仅剩自主学习一项长期规划）
 
 ---
 
@@ -227,6 +245,43 @@ POST /api/v1/agent-chat/{agent_id}
 
 也可无 Agent 配置直接对话（`POST /api/v1/agent-chat/bare`），使用默认设置。
 
+### 方式三：Pipeline 流水线编排
+
+访问 `/agent-chat` 页面切换至"编排"模式，选择"流水线模式"，配置一个执行 Agent 后发送问题。系统自动完成：
+1. **Planner** 分析问题并生成执行计划（JSON 格式，2-5 步）
+2. **Executor** 按计划逐步执行，上一步输出作为下一步上下文
+3. **Reviewer** 审查全部结果，输出最终答案
+
+API 调用示例：
+
+```
+POST /api/v1/agent-chat/orchestrate
+{
+  "message": "比较复杂的技术问题",
+  "mode": "pipeline",
+  "agents": [{
+    "id": "executor",
+    "name": "分析助手",
+    "system_prompt": "你是一个专业分析助手...",
+    "model": "deepseek-v4-flash",
+    "max_iterations": 10
+  }]
+}
+
+→ {
+  "mode": "pipeline",
+  "final_answer": "审查后的最终答案",
+  "steps": [
+    {"agent_name": "Planner", "output": "计划方案"},
+    {"agent_name": "分析助手 (步骤1)", "output": "步骤1结果"},
+    ...
+    {"agent_name": "Reviewer", "output": "审查报告"}
+  ]
+}
+```
+
+适合需要复杂分解 + 质量把关的场景，如技术调研、方案设计、数据分析报告等。
+
 ---
 
 ## 后续计划
@@ -238,7 +293,7 @@ POST /api/v1/agent-chat/{agent_id}
 | 记忆压缩总结 | ✅ 完成 | LLM 自动总结对话提取用户画像/关键事实/话题，存入长期记忆 |
 | Agent 配置页面 | ✅ 完成 | 新增 AgentConfig.vue 页面，可视化编辑 System Prompt / 模型 / Temperature / 工具 |
 | 执行追踪 | ✅ 完成 | 后端返回 steps，前端 AgentChat.vue 可展开显示思考链 |
-| 多 Agent 编排 | ✅ 完成 | 三种模式：route（路由分发）、sequential（流水线）、debate（独立回答+汇总） |
+| 多 Agent 编排 | ✅ 完成 | 四种模式：route（路由分发）、sequential（流水线）、debate（独立回答+汇总）、pipeline（规划→执行→审查） |
 | 编排前端 UI | ✅ 完成 | AgentChat.vue 新增模式切换、Agent 编辑弹窗、步骤展开 |
 | 预算接入 | ✅ 完成 | Agent 内部 LLM 调用也计入工作流执行预算——通过 `AgentBudgetConfig` 内控 + `on_llm_invocation` 外调双向保障 |
 | SSE 流式输出 | ✅ 完成 | 新增 `POST /api/v1/agent-chat/bare/stream` 端点，SSE 实时推送思考步骤和最终答案 |
@@ -257,7 +312,6 @@ POST /api/v1/agent-chat/{agent_id}
 | 项目 | 说明 |
 |------|------|
 | 自主学习 | Agent 从历史执行中自动优化工具选择策略 |
-| Planner → Executor → Reviewer 流水线 | 更复杂的多 Agent 协作工作流 |
 | 监控与告警 | Agent 执行异常检测与告警 |
 
 ---
@@ -275,13 +329,48 @@ POST /api/v1/agent-chat/{agent_id}
   - 成功调用 `datetime` 工具获取当前时间（2026-05-01 11:23:56）
   - 成功调用 `system_info` 工具识别 Windows 10.0.26200
   - ReAct 循环正常（2 次迭代：思考→工具→结果→回答）
-- [ ] 测试工作流中放置 Agent 节点并执行
+- [x] 工具 schema 三路归一化修复（`core.py` + `llm_service.py`）
+  - 自定义工具（DB 加载，缺 `type` 字段）→ 添加 `type: "function"`
+  - 标准格式 → 原样通过
+  - 扁平格式（name/parameters/description）→ 正确包装
+- [x] `load_tools_from_db()` 启动时自动调用（`main.py` startup 事件中）
+  - 20 个自定义工具在重启后仍然可用
+- [x] 前端 SSE 流式修复（`AgentChat.vue`）
+  - `receivedFirstEvent` 从"仅 think/tool_call/tool_result" 改为"任意事件"触发
+  - 空 think 内容显示"思考中..."占位文本
+  - 60s AbortController 超时保护
+  - 流式失败后自动回退到非流式 POST
+- [x] 编程助手种子脚本（`seed_coding_agent.py`）
+  - 创建 4 个开发者工具：execute_code、grep_search、list_files、git_log
+  - 创建"代码编程助手"Agent（workflow_config + budget_config）
+- [x] 批量 Agent 种子脚本（`seed_agents.py`）
+  - 创建 4 个常用自主 Agent：数据分析助手、运维监控助手、网络调试助手、全能助手
+  - 全部已发布（published），可通过前端访问
+- [x] 编程助手自动化测试全部通过（`test_coding_agent.py`）
+  - 问候场景：非流式 12.6s / 流式 10.3s ✅
+  - 代码场景（素数判断）：非流式 48.3s / 流式 43.6s ✅
+  - 搜索场景（grep_search）：非流式 23.2s / 流式 15.4s ✅
+  - 文件读取场景：✅
+- [x] 数据分析助手测试通过（计算 1-10 平均值 = 5.5，含表格输出）
+- [x] Vite 前端开发服务器运行正常（`http://localhost:3002`）
+- [x] **测试工作流中放置 Agent 节点并执行**
+  - 工作流 `Agent节点测试` (start → agent → end)
+  - Agent 节点使用 `math_calculate` 工具计算 1+2+...+100 = 5050
+  - ReAct 循环正常（2 次迭代：思考→工具→结果→回答）
+  - 执行完成，状态 completed，耗时 7.45 秒
+  - Agent 节点返回 agent_meta: iterations=2, tool_calls=1, truncated=false
 - [x] 测试 Agent 多轮工具调用
 - [x] Agent 配置页面（AgentConfig.vue + 路由 + 导航）
 - [x] 执行追踪（API steps 字段 + 前端思考链展开 UI）
 - [x] 记忆压缩总结（LLM 自动提取用户画像/关键事实/话题）
 - [x] 多 Agent 编排 API（`POST /api/v1/agent-chat/orchestrate`）
 - [x] 三种编排模式端到端测试通过（route / sequential / debate）
+- [x] **Pipeline 流水线模式端到端测试通过**
+  - 问题："Python 和 JavaScript 的三大区别"
+  - Planner 自动生成 5 步 JSON 执行计划
+  - Executor 逐步骤执行 5 步（类型系统 → 类型系统 → 并发模型 → 生态工具链 → 整合报告）
+  - Reviewer 审查全部执行结果，输出 7541 字质量审查报告
+  - 总计 7 个步骤，全部成功
 - [x] 编排结果包含 steps 追踪和 agent_results
 - [x] 前端编排 UI（模式切换 + Agent 编辑弹窗 + 结果展开）
 - [x] Agent LLM 调用日志模型（`AgentLLMLog` 表创建成功，含 16 个字段）