sync update from LAN repo (source master-yx @ cf505220)

Newer vLLM parsers put CoT in reasoning; older builds and DeepSeek still use reasoning_content. Canonicalize to the UI field and echo only the original wire field so other ChatOpenAI models stay unchanged. Point qwen3.6 at VllmChatModel.

Co-authored-by: Cursor <cursoragent@cursor.com>

.gitignore

@@ -88,21 +88,25 @@ skills/
 hermes-agent-main/
 .gitignore
 offline-backend-20260512/backend/tests/*
-# Keep the openGauss URL/dialect/schema compatibility regression coverage versioned.
-!offline-backend-20260512/backend/tests/test_gauss_database.py
+# Keep the openGauss URL/dialect/schema compatibility regression coverage versioned.
+!offline-backend-20260512/backend/tests/test_gauss_database.py
 !offline-backend-20260512/backend/tests/test_llmwiki_weknora.py
-!offline-backend-20260512/backend/tests/test_llmwiki_knowledge_management.py
+!offline-backend-20260512/backend/tests/test_llmwiki_knowledge_management.py
 !offline-backend-20260512/backend/tests/test_health_auth_bypass.py
 # Keep formal Word OOXML and embedded-font regression coverage versioned.
 !offline-backend-20260512/backend/tests/test_word_export.py
-# Keep generated-file library aggregation and filtering regression coverage versioned.
-!offline-backend-20260512/backend/tests/test_artifact_library.py
+# Keep generated-file library aggregation and filtering regression coverage versioned.
+!offline-backend-20260512/backend/tests/test_artifact_library.py
 # Keep the model configuration regression coverage versioned even though
 # this deployment repository otherwise ignores newly added backend tests.
 !offline-backend-20260512/backend/tests/test_model_management.py
-# Keep the forced-research agent runtime gate and sandbox-policy regressions versioned.
-!offline-backend-20260512/backend/tests/test_forced_research_agent.py
-# Keep fixed-question exact-match and streaming regression coverage versioned.
+# Keep vLLM reasoning/reasoning_content field compatibility regressions versioned.
+!offline-backend-20260512/backend/tests/test_reasoning_fields.py
+# Keep the forced-research agent runtime gate and sandbox-policy regressions versioned.
+!offline-backend-20260512/backend/tests/test_forced_research_agent.py
+# Keep strategy-selection built-in agent seed and safety-contract regressions versioned.
+!offline-backend-20260512/backend/tests/test_strategy_selection_seed.py
+# Keep fixed-question exact-match and streaming regression coverage versioned.
 !offline-backend-20260512/backend/tests/test_fixed_questions.py
 # Keep configurable es_query system-prompt routing regression coverage versioned.
 !offline-backend-20260512/backend/tests/test_es_query_routing_prompt.py
@@ -110,6 +114,7 @@ offline-backend-20260512/backend/tests/*
 !offline-backend-20260512/backend/tests/test_llmwiki_local_index_repository.py
 !offline-backend-20260512/backend/tests/test_llmwiki_vector_search.py
 !offline-backend-20260512/backend/tests/test_llmwiki_wiki_sync.py
+!offline-backend-20260512/backend/tests/test_llmwiki_encoder_runtime.py
 !offline-backend-20260512/backend/tests/test_external_llmwiki_search.py
 !offline-backend-20260512/backend/tests/test_llmwiki_wiki_retrieval.py
 !offline-backend-20260512/backend/tests/test_public_llmwiki_embed.py
@@ -176,10 +181,10 @@ docs/backups
 # Frontend skills components must be tracked (excluded from the broad skills/ ignore above)
 !frontend-web/src/components/workspace/skills/
 
-# uv lockfile (not tracked per project preference)
-offline-backend-20260512/backend/uv.lock
-
-!offline-backend-20260512/backend/tests/test_wiki_package_roundtrip.py
+# uv lockfile (not tracked per project preference)
+offline-backend-20260512/backend/uv.lock
+
+!offline-backend-20260512/backend/tests/test_wiki_package_roundtrip.py
 
 # Local-only scratch directory (not committed)
 0622/

CLAUDE.md

@@ -83,6 +83,7 @@ The frontend (`frontend-web/`) is a React 19 + Vite SPA:
 - **Pages**: `ChatPage` (thread chat), `AgentChatPage` (custom agent chat), `AgentsPage`/`NewAgentPage` (agent management), `ScheduledTasksPage`/`ScheduledTaskRunDetailPage` (scheduled tasks), `LightAppManagementPage`/`LightAppListPage`/`LightAppIframeView` (轻应用中心 — register/list/embed mini-apps)
 - **定时任务「JSON → HTML 模板填充」(模板数据转换器)**: a third scheduled-task execution mode. In the create/edit dialog (`ScheduledTasksPage.tsx`), selecting the built-in agent **「模板数据转换器」** (`execution_agent_name === "template-json-builder"`, `TEMPLATE_BUILDER_AGENT_ID`) reveals a 「HTML模板」 select (`useHtmlTemplates` → `GET /api/scheduled-tasks/html-templates`) + a **.json 上传** button (reads the file's text into the prompt box) and **hides** the 必须生成 HTML/Markdown switches (this mode always outputs HTML). The chosen template persists as `execution_context.template_config.template_id` (`TemplateFillConfig` in `core/scheduled-tasks/types.ts`). At run time the backend converts the source JSON (the task prompt) into that template's `DATA` structure, validates (retry-on-fail), fills the template, and stores an HTML page previewable via the existing run-detail HTML preview. The source can be **pure JSON, plain text, or text-with-embedded-JSON** — the backend pre-extracts any embedded JSON and the agent's `SOUL.md` maps it (or the plain text's semantics) to the template's schema skeleton. **Chat-page debug entry (only this agent's `AgentChatPage`)**: when `agent_id === "template-json-builder"`, the chat header shows a 「页面模板」 select + a 「渲染预览」 button — after a normal Q&A run, the button takes the **latest AI reply**, POSTs it to `POST /api/scheduled-tasks/template-fill/render` (`renderTemplateFill`), and pops a dialog rendering the filled HTML in a `sandbox="allow-scripts"` iframe plus the structure-validation status/errors/gaps — for debugging the agent's conversion effect without creating a scheduled task. Gated strictly on the agent id, so other agents' chat pages are untouched. See the backend CLAUDE.md「Template-fill mode」for the engine (`deerflow/runtime/scheduler/template_fill.py`), agent seed, dispatch, and the render API.
 - **AI 写作·对话版（对话驱动写作台）**: a **parallel new entry** beside the classic AI-writing page (classic page/routes untouched) — route `/page/canvas/ai-writing-chat` (`OpenCanvasRoutes.tsx`), sidebar 「问答管理 → 课题研究(对话版)」. Page `open-canvas/pages/AIWritingChatPage.tsx` fully **reuses the engine** (`AIWritingContext` state machine + LangGraph `useStream`, `AIWritingHistoryProvider`, right-side `AIWritingDraftPanel`) but replaces the presentation: left = `components/ai-writing-chat/WritingChatPanel.tsx` (timeline + **button-only intervention cards** `ChatInterventionCards.tsx` — the five pause cards copied from `InterventionCard.tsx` with all inline textareas removed, confirm/action buttons kept — plus a bottom **unified smart composer**). Free text goes through two-level intent resolution (`open-canvas/api/ai-writing-intent.ts`): deterministic short-phrase fast path (确认/继续/重新搜索/重写大纲…; high-cost actions never fast-pathed) then `POST /api/ai-writing/sessions/{id}/intent` — the backend reads the graph checkpoint (authoritative pause point from the pending interrupt) and routes via `deerflow/agents/ai_writing/intent_router.py` (LLM + strict per-pause action whitelist aligned to the graph's real resume actions, confidence gates: finalize/force_finalize/覆盖式 re_search need ≥0.85 else clarify, payload key-whitelist cleaning). Results map to `submitIntervention`/control (暂停/继续/后台挂起)/QA bypass (`answer` rendered as a chat bubble, never touches graph state)/clarify (amber follow-up bubble with multi-turn context). **Two-state layout**: idle (未开始写作) renders the **classic setup experience unchanged** — `WritingSetupChat` + collapsible `AIWritingPanel` form under `WritingFormProvider` (same as `AIWritingPage`'s idle branch); once writing starts (or history view opens) it switches to the chat workbench. **Unified chronological feed** (`ChatFlowTimeline.tsx`): intent-layer chat bubbles are interleaved INTO the progress-event timeline by anchor (= `progressEvents.length` at message creation), so events triggered by a user message render **below** it (Google-AI-Studio-style single stream, not timeline-above/chat-below); composer-driven interventions suppress the duplicate 「我的要求」card (`suppressedRequirementIndices`). **素材不足自动续跑** only at `material_confirm` (the only pause the graph supports re-search from): needResearch caches the payload as a pending intent, submits `re_search + userQuery`, and auto-submits the pending intent when the new material-confirm pause arrives (cancellable pill). Stage chips + per-stage placeholder + 「当前交互对象」status badge. Backend tests `tests/test_ai_writing_intent.py`. Plan doc: `frontend-web/docs/ai-writing-对话驱动写作台-实现方案.md`.
+- **策略优选**: route `/page/strategy/qa/strategy-selection`, sidebar 「问答管理 → 策略优选」. The standalone `src/strategy-selection/` workbench has two horizontal split stages: Step 1 keeps intent-understanding conversation cards on the left and an editable task draft plus angle selection on the right; Step 2 keeps multiplexed parallel strategy cards and automatic judging on the left while the right stays dedicated to the selected-strategy basket and final Markdown synthesis. It consumes the existing `POST /api/parallel-agents/run/stream` protocol, isolates output by stable agent id, supports expanded per-agent dialogs, user selection, Markdown editing/copy/download, and shared server-side DOCX export. A clearly marked neutral Taiwan-Strait risk-management demo is loaded by default for offline UI acceptance. Administrators can edit the SOUL and skills of the nine built-in functional agents through the page dialog; the backend seeds `strategy-selection-{intent,angle-*,judge,solution}` only when their directories are missing, preserving later admin changes. Pure parsing/SSE tests live in `src/strategy-selection/lib.test.ts`; backend seed tests live in `tests/test_strategy_selection_seed.py`.
 - **轻应用中心 (Light App Center)**: a sibling of 任务管理 in the sidebar with two pages — 应用管理 (admin registers `window_open` or `iframe` mini-apps with a route-param builder: login params resolved from `localStorage.userInfo`, theme params literal) and 应用列表 (card grid of `window_open` apps, `window.open` launch). `iframe` apps are mounted under a chosen parent menu (XK/PG/TY/综合管理) and **dynamically injected into the sidebar** by `core/page-layout/use-sidebar-menu.ts` (`useSidebarMenuItems`), opening in the `LightAppIframeView` host. Client + React Query hooks in `strategy-components/api/light-apps.ts`; URL builder/constants in `strategy-components/lib/light-app.ts`. Backend: `/api/light-apps` (global/shared, admin-gated writes).
 - **菜单管理 (Menu Management, admin-only)**: an **overlay** over the static sidebar menu — `MenuManagementPage` (`pages/MenuManagementPage.tsx`, route `/page/strategy/admin/menu-management`, opened from the admin-only 「菜单管理」 item in the **bottom-left settings dropdown** of `components/page-sidebar.tsx`). Admins rename / 停用·启用 / reorder (↑↓ or @dnd-kit drag) / re-parent (horizontal drag **or** the edit dialog's 「移动到」parent selector) any node across 一级/二级/三级, **including injected iframe light-app nodes** (`light-app-<appId>`). The static tree (`core/page-layout/sidebar-menu.ts`) stays the source of icons/routes; only per-node deltas (`label`/`disabled`/`parentId`/`sortOrder`) persist to the backend. Merge logic in `core/page-layout/menu-overrides.ts` (`applyMenuOverrides`, applied in `use-sidebar-menu.ts` after light-app injection, before role filter; disabling a node hides its whole subtree) — strict **3-level cap** (`wouldExceedDepth`). Client `strategy-components/api/menu-overrides.ts`. Backend: `/api/menu-overrides` (global/shared; open read, admin atomic replace-all). **简介模式** left-nav is a separate overlay: `/api/compact-menu-overrides` stores two independent sets (type `A` / `B`); each website picks one via `runtime-config.js` `VITE_COMPACT_MENU_TYPE`.
 - **白名单管理 (Login Whitelist, admin-only)**: gates **who may log in**, run as a **blocklist (黑名单模式)**. Two pieces: a global master switch (`system_settings.json → login_whitelist.enabled`, surfaced by **admin-only** `GET|PUT /api/system-settings/login-whitelist`) + a per-user **放行** flag (`users.approved` column, migration `20260625_02`). Users **self-register** as usual and **every new account defaults to `approved=True`** — so a user who has never logged into this system before is allowed straight through; the switch only blocks users an admin has explicitly **取消放行** (`approved=False`). (`create_user`/`User`/`UserRow` all default `approved=True`; admins are always approved; existing rows are backfilled `True`.) Login interception is the single helper `enforce_user_approved(user)` in `app/gateway/routers/auth.py`, called in all three login endpoints (`/login/{local,username,token}`) **after** the account is resolved/created and **before** the JWT is issued: switch off → everyone passes; `system_role=="admin"` → always passes (anti-lockout); else `approved=False` (admin-revoked) → 403 `{code:"PENDING_APPROVAL"}` (the frontend's `extractErrorMessage` surfaces the message and login throws before writing any auth state, so no half-login). Admin approves on `pages/LoginWhitelistPage.tsx` (route `/page/strategy/admin/login-whitelist`, entry「白名单管理」in the bottom-left settings dropdown of `components/page-sidebar.tsx`, both sidebar modes): a top master-switch + a list of all registered users (`GET /api/v1/auth/users`, now carrying `approved`) with a per-row 放行 Switch (`PUT /api/v1/auth/users/{id}/approval`, admin-only; revoking only blocks the **next** login — `token_version` is left untouched, existing sessions are not force-killed). Client/hooks: switch in `strategy-components/api/login-whitelist.ts`, user list + approval in `core/auth/{api,hooks}.ts` (`useSetUserApproval`). Backend tests: `tests/test_login_approval.py`. **账号级「登录口令」(per-account password — 临时开通)**: the same page also lets an admin assign one specific account an individual **plaintext** password (`users.login_password` column, migration `20260625_04`, nullable; auto-added on startup by `_ensure_orm_columns_sync`). Once set, **that account's** username login (`POST /api/v1/auth/login/username`) **requires** `?password=` to exactly match it and that personal password **takes precedence over** the global shared-password gate (`username_login.require_password`); accounts without one keep today's shared-gate / passwordless behavior. The user then logs in via the **existing** frontend URL `#/login/<用户名>?password=xxxx` (LoginPage already forwards `?password=`; `<用户名>` = the account's email `@`-prefix). **Plaintext is intentional** — the password rides in the URL query anyway, so storing it readably lets the admin re-copy the full login link from the page; it is exposed only on the **admin-only** `GET /api/v1/auth/users` (`UserListItem.login_password`) and the new admin-only `PUT /api/v1/auth/users/{id}/login-password` (set non-empty / clear with null·empty; doesn't touch `token_version`). The whitelist page renders a per-user 「登录口令」 column with a set/修改 editor + a live 「复制登录链接」 button (`useSetUserLoginPassword` in `core/auth/hooks.ts`, `setUserLoginPassword` in `core/auth/api.ts`). Backend gate helper `_lookup_user_by_username` (lookup-only, no auto-register) in `routers/auth.py`; tests `tests/test_login_personal_password.py`.

docs/agentscope-多智能体报告协作工作台-交互重设计方案.md

@@ -1,186 +0,0 @@
-# 报告协作工作台 — 交互重设计方案（v2）
-
-> 日期：2026-09-07
-> 状态：**待确认**（确认后按 §7 分期实施）
-> 取代：现行「规则澄清 + 三张模板方案卡 + 画布为主」的交互
-> 原则：回到最初设计 —— **协调者智能体全程与用户对话的主线**
-
----
-
-## 1. 设计目标与总体形态
-
-用户视角只有一条主线：**和一个规划师智能体对话 → 它摸清意图并规划工作流 → 确认后执行、过程在流程图上可见 → 随时插话干预、指定智能体重跑 → 最终成稿、继续对话式修改**。
-
-```
-┌─────────────────────────────────────────────────────────┐
-│  阶段1 计划模式        阶段2/3 执行+干预      阶段4 成稿  │
-│  ┌───────────┐        ┌───────────┐        ┌──────────┐ │
-│  │ 规划师对话 │  确认   │ 聊天时间线 │  审稿过 │ 对话改稿 │ │
-│  │ 需求摘要卡 │ ─────→ │ +成员Tab  │ ─────→ │ 版本/diff│ │
-│  │ 工作流卡   │  冻结   │ +流程图动画│  报告卡 │ 上游重跑 │ │
-│  └───────────┘        └───────────┘        └──────────┘ │
-│        ↑ 回到计划模式（replan）随时可触发 ↑                │
-└─────────────────────────────────────────────────────────┘
-```
-
-与现行的核心差异：
-
-| 维度 | 现行（做偏的） | v2 |
-|------|----------------|-----|
-| 需求澄清 | 规则模板问句秒回 | 规划师智能体（LLM）领域化提问 |
-| 工作流来源 | 3 张确定性模板 | LLM 按意图生成自定义 DAG，对话迭代修改 |
-| 执行展示 | 画布为主、聊天为辅 | **聊天时间线为主**（成员 Tab 切换保留），**执行状态在流程图上动画呈现** |
-| 干预 | 命令确认卡体系 | 输入框常开 → 协调者智能体分类；支持**指定智能体重跑** |
-| 报告修改 | 改写候选（纯文字层） | 意图分流：润色走改写；**事实性问题触发上游节点重跑** |
-
----
-
-## 2. 阶段 1：计划模式 — 需求梳理与工作流规划
-
-### 2.1 计划模式状态
-
-- 用户发出第一条需求消息起进入**计划模式**，Header 显示徽章「📋 计划模式」，输入框提示语切换为「梳理需求中，你可以随时补充或纠正…」。
-- 计划模式在**工作流确认冻结**时结束；执行期大改可通过 replan 回到计划模式（见 §5.4）。
-
-### 2.2 规划师对话（LLM，替换现行规则路由）
-
-- 模型：`report_collaboration.planner_model`（回退 `coordinator_model` → 默认模型，复用现有 model_resolver 冻结机制）。
-- 提问是领域化的：写市场分析就问「关注整车还是供应链 / 要不要竞品对比 / 给谁看 / 篇幅」，而非固定模板问句。
-- 澄清轮次上限沿用 `max_clarification_rounds`；用户随时可以说「直接开始」按默认假设推进。
-
-### 2.3 需求摘要卡
-
-信息足够后，规划师在对话中输出一张**结构化需求摘要卡**（业务卡插槽渲染）：主题 / 目的 / 读者 / 角度清单 / 篇幅与重点 / 默认假设。用户逐项看，可在对话里继续改（「读者改成投资人」→ 卡片更新出新版）。
-
-### 2.4 工作流生成与迭代
-
-- 用户确认摘要后，规划师生成**一份**工作流方案（不是三选一）：以工作流卡（成员构成、各节点使命、预计时长/成本）+ 右侧流程图预览呈现。
-- 生成约束（保证可执行）：**节点类型受词表约束** — `research / verify / analyze / write / review`；自由的是结构（几条线、并行还是串行、核验深度）与每个节点的使命/角度/工具。
-- 对话式修改：「把价格策略单独拆一条线」「加一个政策风险分析」→ 规划师修订后出新版工作流卡（带变更说明），再确认。
-- 「开始执行」→ 冻结需求 + 工作流（含模型/预算快照，沿用现有 freeze 机制）。
-
----
-
-## 3. 阶段 2：执行 — 过程在流程图上可见
-
-### 3.1 流程图动画规格（执行状态的可视化主载体）
-
-节点状态 → 样式（`ReportFlowCanvas` / `ReportFlowNode`，状态源 `selectNodeStatusMap`，事件源 `node.status.changed` SSE）：
-
-| 状态 | 节点样式 | 连入边 |
-|------|----------|--------|
-| planned / queued | 灰色常态 | 静态 |
-| **running** | 主色描边 + **呼吸脉冲动画**（ring）+ 角标 spinner | **流动动画**（@xyflow 内置 `animated: true` 的 dash 流动） |
-| **completed** | 绿色 + ✓ 角标，常驻 | 恢复静态实线 |
-| failed | 红色 + 错误角标 | 红色虚线 |
-| awaiting_input | 橙色 + ？角标 | 橙色静态 |
-| interrupted / superseded | 半透明降级 | 灰 |
-
-- 语义：**边流动 = 数据正在流入该节点**（该节点执行中）；节点完成即停动画换完成样式。
-- 实现成本：@xyflow 原生支持 animated 边与自定义节点 className，纯 CSS 补呼吸动画即可，无需新依赖。
-
-### 3.2 聊天区（保留现有 Tab 切换）
-
-- 并行成员沿用 **AgentStageSelector Tab 切换**（维持现状，不改交错时间线）。
-- 每个 Tab 内是该成员的完整流式输出：思考、工具调用卡、检索过程、正文 —— 与普通智能体问答同观感（message-adapter 已具备映射能力）。
-- 协调者播报（「研究线 A 完成，核心发现 X，开始交叉核验」）进入总时间线 Tab。
-
----
-
-## 4. 阶段 3：干预 — 对话即干预 + 指定重跑
-
-### 4.1 输入框常开，协调者智能体分流
-
-执行期输入框永远可用，所有输入先到协调者（LLM 分类，规则高精度直判兜底——复用 RC-BE-014 IntentRouter 骨架，把「规则优先」反转为「LLM 优先 + 规则快路径」）：
-
-| 用户意图 | 协调者行为 | 生效时机 |
-|----------|-----------|----------|
-| 提问（「查到什么了？」） | 直接回答 | 立即，不打断 |
-| 修正方向（「重点看下沉市场」） | 小改：在安全点注入 overlay，并回复说明 | 下个安全点 |
-| **指定重跑**（见 §4.2） | 出确认卡 → 重开节点 attempt | 确认后 |
-| 大改（砍线/加线） | 提议 replan → 回计划模式 | 用户确认 |
-| 停止 | 直接取消 | 立即 |
-
-### 4.2 指定智能体重跑（新增核心交互）
-
-**场景**：用户发现某节点传给下游的信息不对（如研究线 B 的结论有误）。
-
-两个入口，同一后端动作：
-
-1. **对话**：「研究线 B 的结果不对，重新查，重点看价格战」→ 协调者解析出 `node_id` + 新指令；
-2. **画布**：点节点 → 抽屉（NodeInspectorDrawer）加「↻ 重新执行」按钮。
-
-**级联规则**（复用并补全 ledger 的 targeted rework）：
-
-```
-重跑节点 N（attempt+1，带用户新指令作为 mission overlay）
-  → N 完成 → 所有直接/间接依赖 N 产物的下游节点标记 superseded
-  → 按 DAG 依赖序逐波重跑（边动画重新流动，用户全程可见）
-  → 受影响章节重新生成
-```
-
-- 确认卡必须展示**影响面**：「将级联重跑 核验B / 分析 / 写作 共 3 个节点，预计 +8 分钟」。
-- 成本保护：级联重跑计入 run 预算（现有 budget 机制），预算不足时明确报因。
-
----
-
-## 5. 阶段 4：报告成稿与对话式修改
-
-### 5.1 成稿
-
-审稿通过 → 报告卡出现在时间线（点开 ReportPreviewDialog 全文），协调者播报总结（各线核心发现 → 结论如何形成）。
-
-### 5.2 修改意图分流（协调者 LLM 判定）
-
-| 用户说 | 判定 | 动作 |
-|--------|------|------|
-| 「把第二章结论写得更笃定」 | 文字润色 | 改写候选（现有 rewrite API）→ 对比预览 → apply → 新版本 |
-| 「这个数据不对 / 重新收集一下」 | **事实性问题** | 定位来源节点 → **触发该节点重跑（可带新角度）→ 级联 §4.2 → 受影响章节重生成 → 新版本** |
-| 「再从供应链角度补一节」 | 结构性新增 | replan：回计划模式改工作流（只增不删已完成部分） |
-| 「恢复到上一版」 | 版本回退 | 现有 restore API |
-
-- 版本链：每次 apply / restore / 级联重跑产出均产生新 head，历史完整保留（现有机制）。
-- 修改对话里协调者必须先**复述理解**（「你是想让研究线 B 换个角度重查，然后重写第三章，对吗？」）再执行，避免误触发昂贵的级联。
-
----
-
-## 6. 工程改造清单
-
-### 6.1 保留（本次联调已验证）
-
-- 持久化 13 张表 + durable SSE + `after_seq` 断线续传；幂等键 / 乐观锁 / 预算框架。
-- MessageList 复用链路（message-adapter → LangGraph Message → 业务卡插槽）。
-- AgentStageSelector Tab、commands 安全点骨架（RC-BE-014）、报告版本三件套（RC-BE-015）、前端 hooks/reducer/selectors 主体。
-- 「清空历史」「生成候选方案」等本次新增入口。
-
-### 6.2 后端重做 / 新建
-
-| 项 | 说明 |
-|----|------|
-| 规划师智能体 | LLM 多轮澄清（替换 `requirement/intent_router.py` 规则路由）+ 需求摘要结构化 + **工作流 LLM 生成**（受 §2.4 词表约束，替换 `planning/controller.py` 三模板）+ 对话式工作流修订 |
-| 协调者智能体升级 | 干预分类 LLM 优先；修改意图分流（§5.2）；执行前复述确认 |
-| 指定重跑 + 级联 | ledger targeted rework 补全级联 superseded/重跑波次；确认卡带影响面计算 |
-| AgentScope 适配器修复 | `count_tokens` 协议缺失（上下文压缩必崩）；attempt 耗尽终态化（防僵尸 run） |
-| 事件补齐 | 边流动所需的节点状态事件已有；补「级联影响预告」事件 |
-
-### 6.3 前端重做 / 新建
-
-| 项 | 说明 |
-|----|------|
-| 计划模式 UI | Header 徽章、composer 提示切换、需求摘要卡、工作流卡（替换现三张模板卡） |
-| 流程图动画 | running 节点呼吸动画 + 入边 `animated`、completed ✓ 样式、级联重跑时边动画重流（§3.1） |
-| 节点抽屉 | 加「重新执行」按钮 → 确认卡 |
-| 干预交互 | 执行期输入框常开；意图确认卡（含影响面）；修改对话复述确认 |
-| 布局 | 聊天为主、画布为辅的默认比例微调（不动整体两栏结构） |
-
----
-
-## 7. 实施分期
-
-| 期 | 内容 | 验收 |
-|----|------|------|
-| **P0 地基** | AgentScope `count_tokens` 修复；attempt 耗尽终态化；级联重跑的 ledger 补全 | 执行阶段不崩、无僵尸 run、单节点重跑级联正确（后端测试） |
-| **P1 计划模式 + 执行可视化** | 规划师 LLM 对话、需求摘要卡、工作流 LLM 生成与迭代、计划模式 UI、流程图动画 | 从新会话到确认工作流全程对话完成；执行时动画正确随状态流转 |
-| **P2 干预 + 成稿修改** | 协调者 LLM 分类、指定重跑（两入口 + 影响面确认卡）、报告修改意图分流、上游级联重跑 | 四类干预各自走通；「数据不对→重跑→新章节→新版本」全链路 |
-
-每期结束跑 RC 全量测试（当前基线 233 通过）+ 前端 26 单测，不引入对其他模块的影响。

frontend-web/.env.development

@@ -18,7 +18,7 @@ VITE_BACKEND_BASE_URL=http://127.0.0.1:8001
 VITE_LANGGRAPH_BASE_URL=http://127.0.0.1:8001/api
 
 # 开发环境普通登录后进入 Vite 内隔离的官方风格页面；/page/* 仍访问当前定制版。
-VITE_USE_OFFICIAL_DEERFLOW_ENTRY=true
+VITE_USE_OFFICIAL_DEERFLOW_ENTRY=false
 
 # 轻应用「新建笔记」系列接口
 VITE_NOTE_API_BASE_URL=http://47.88.25.99:8000

frontend-web/.env.example

@@ -59,6 +59,9 @@
 # 简介模式左侧菜单类型：与菜单管理页「简介模式」的类型 A / B 对应。两套网页分别填 A 或 B。
 # 不填或留空时按类型 A，继续使用原来的简介菜单数据。
 # VITE_COMPACT_MENU_TYPE=A
+# 问答页「极速」模式：true=在模式菜单显示并直连大模型；false 或未设=隐藏。
+# 部署后优先改 dist/runtime-config.js 的 VITE_TURBO_MODE_VISIBLE，刷新即可。
+# VITE_TURBO_MODE_VISIBLE=false
 # VITE_GITHUB_OAUTH_TOKEN=
 
 # --- 官方 DeerFlow 风格页面入口（仅 Vite，不引入 Next.js）---

frontend-web/public/runtime-config.js

@@ -151,6 +151,11 @@ window.__CM_RUNTIME_CONFIG__ = {
   // GitHub OAuth Token；不使用 GitHub 相关能力时留空。
   VITE_GITHUB_OAUTH_TOKEN: "",
 
+  // 是否在问答输入框「模式」菜单显示「极速」："true" 显示，"false" 隐藏。
+  // 默认关闭。开启后可直连大模型流式问答，不走智能体工具与技能。
+  // 部署后改 dist/runtime-config.js 再刷新页面即可，无需重新打包。
+  VITE_TURBO_MODE_VISIBLE: "true",
+
   // 是否在智能体管理页显示「舆情分析」类型："true" 显示，"false" 隐藏。
   // 关闭后，该智能体的专用对话地址也会自动跳回智能体管理页。
   VITE_SENTIMENT_AGENT_VISIBLE: "true",

frontend-web/src/components/workspace/agents/agent-chat-sidebar.tsx

@@ -51,6 +51,10 @@ import {
   SelectValue,
 } from "@/components/ui/select";
 import { ShareConversationDialog } from "@/components/workspace/thread-share-dialogs";
+import {
+  MyProjectThreadBadge,
+  MyProjectThreadIcon,
+} from "@/components/workspace/my-project-thread-indicator";
 import { useTheme } from "@/contexts/ThemeContext";
 import { useAgentsPaginated } from "@/core/agents";
 import { getAPIClient } from "@/core/api";
@@ -69,6 +73,7 @@ import {
   useToggleThreadPin,
 } from "@/core/threads/hooks";
 import type { AgentThread, AgentThreadState } from "@/core/threads/types";
+import { myProjectConversationTypeOfThread } from "@/core/threads/project-metadata";
 import {
   bootstrapResumePath,
   isBootstrapThread,
@@ -479,6 +484,7 @@ function RecentChatsPane({ activeAgentId }: { activeAgentId?: string }) {
         ) : (
           filteredThreads.map((thread) => {
             const isBoot = isBootstrapThread(thread);
+            const projectType = myProjectConversationTypeOfThread(thread);
             const href = isBoot ? bootstrapResumePath(thread.thread_id) : pathOf(thread);
             const isActive = href === pathname;
             const pinned = isThreadPinned(thread);
@@ -505,6 +511,8 @@ function RecentChatsPane({ activeAgentId }: { activeAgentId?: string }) {
                       )}
                       aria-label="智能体创建会话"
                     />
+                  ) : projectType ? (
+                    <MyProjectThreadIcon type={projectType} />
                   ) : (
                     <MessageSquare
                       className={cn(
@@ -516,9 +524,15 @@ function RecentChatsPane({ activeAgentId }: { activeAgentId?: string }) {
                   {pinned && (
                     <Pin className="text-muted-foreground/70 size-3 shrink-0" />
                   )}
-                  <span className="truncate">
+                  <span className="min-w-0 flex-1 truncate">
                     {desensitize(titleOfThread(thread, t.pages.newChat))}
                   </span>
+                  {projectType && (
+                    <MyProjectThreadBadge
+                      className="mr-4"
+                      type={projectType}
+                    />
+                  )}
                   {isActive && (
                     <span className="absolute top-1/2 right-1 h-5 w-1 -translate-y-1/2 rounded-full bg-primary" />
                   )}

frontend-web/src/components/workspace/agents/agent-recent-chats.tsx

@@ -4,7 +4,12 @@ import { MessageSquareIcon } from "lucide-react";
 import Link from "next/link";
 import { usePathname } from "next/navigation";
 
+import {
+  MyProjectThreadBadge,
+  MyProjectThreadIcon,
+} from "@/components/workspace/my-project-thread-indicator";
 import { useThreadsPage } from "@/core/threads/hooks";
+import { myProjectConversationTypeOfThread } from "@/core/threads/project-metadata";
 import { pathOfThread, titleOfThread, isHiddenFromRecentChats, isBootstrapThread } from "@/core/threads/utils";
 import { desensitize } from "@/lib/desensitize";
 import { cn } from "@/lib/utils";
@@ -45,6 +50,7 @@ export function AgentRecentChats({ agentId }: { agentId: string }) {
           {threads.map((thread) => {
             const href = pathOfThread(thread);
             const isActive = href === pathname;
+            const projectType = myProjectConversationTypeOfThread(thread);
             return (
               <Link
                 key={thread.thread_id}
@@ -57,15 +63,20 @@ export function AgentRecentChats({ agentId }: { agentId: string }) {
                     : "text-muted-foreground hover:bg-accent hover:text-foreground",
                 )}
               >
-                <MessageSquareIcon
-                  className={cn(
-                    "size-3.5 shrink-0",
-                    isActive ? "text-primary" : "text-muted-foreground/70",
-                  )}
-                />
-                <span className="truncate">
+                {projectType ? (
+                  <MyProjectThreadIcon type={projectType} />
+                ) : (
+                  <MessageSquareIcon
+                    className={cn(
+                      "size-3.5 shrink-0",
+                      isActive ? "text-primary" : "text-muted-foreground/70",
+                    )}
+                  />
+                )}
+                <span className="min-w-0 flex-1 truncate">
                   {desensitize(titleOfThread(thread, "新对话"))}
                 </span>
+                {projectType && <MyProjectThreadBadge type={projectType} />}
               </Link>
             );
           })}

frontend-web/src/components/workspace/general-qa-sidebar.tsx

@@ -60,6 +60,10 @@ import {
 } from "@/components/ui/dropdown-menu";
 import { Input } from "@/components/ui/input";
 import { ShareConversationDialog } from "@/components/workspace/thread-share-dialogs";
+import {
+  MyProjectThreadBadge,
+  MyProjectThreadIcon,
+} from "@/components/workspace/my-project-thread-indicator";
 import { useAgentsPaginated, type Agent } from "@/core/agents";
 import { getAPIClient } from "@/core/api";
 import { useI18n } from "@/core/i18n/hooks";
@@ -75,6 +79,7 @@ import {
   useToggleThreadPin,
 } from "@/core/threads/hooks";
 import type { AgentThread, AgentThreadState } from "@/core/threads/types";
+import { myProjectConversationTypeOfThread } from "@/core/threads/project-metadata";
 import {
   isBootstrapThread,
   isHiddenFromRecentChats,
@@ -483,6 +488,7 @@ export function GeneralQaSidebar() {
                     );
                     const isActive = href === pathname;
                     const isBoot = isBootstrapThread(thread);
+                    const projectType = myProjectConversationTypeOfThread(thread);
                     const pinned = isThreadPinned(thread);
                     const favorited = isThreadFavorite(thread);
                     return (
@@ -507,6 +513,8 @@ export function GeneralQaSidebar() {
                               )}
                               aria-label="智能体创建会话"
                             />
+                          ) : projectType ? (
+                            <MyProjectThreadIcon type={projectType} />
                           ) : (
                             <MessageSquare
                               className={cn(
@@ -518,9 +526,15 @@ export function GeneralQaSidebar() {
                           {pinned && (
                             <Pin className="size-3 shrink-0 text-muted-foreground/70" />
                           )}
-                          <span className="truncate">
+                          <span className="min-w-0 flex-1 truncate">
                             {desensitize(titleOfThread(thread, t.pages.newChat))}
                           </span>
+                          {projectType && (
+                            <MyProjectThreadBadge
+                              className="mr-4"
+                              type={projectType}
+                            />
+                          )}
                           {isActive && (
                             <span className="absolute top-1/2 right-1 h-5 w-1 -translate-y-1/2 rounded-full bg-primary" />
                           )}

frontend-web/src/components/workspace/input-box.tsx

@@ -7,6 +7,7 @@ import {
   CheckIcon,
   FileTextIcon,
   FolderTreeIcon,
+  GaugeIcon,
   GraduationCapIcon,
   LightbulbIcon,
   PaperclipIcon,
@@ -68,6 +69,7 @@ import { isHiddenFromUIMessage } from "@/core/messages/utils";
 import { useModels } from "@/core/models/hooks";
 import type { Model } from "@/core/models/types";
 import type { AgentThreadContext } from "@/core/threads";
+import { isTurboModeVisible } from "@/core/threads/use-direct-chat";
 import { textOfMessage } from "@/core/threads/utils";
 import { desensitize } from "@/lib/desensitize";
 import { cn } from "@/lib/utils";
@@ -93,14 +95,14 @@ import {
 
 import { useRecommendedQuestions } from "@/core/recommended-questions/hooks";
 import { useUserPreferences } from "@/core/user-preferences";
-import {
-  isThreadRagModeLocked,
-  lockThreadRagMode,
-  useLocalSettings,
-} from "@/core/settings";
-import { useCitationDisplaySettings } from "@/core/system-settings/hooks";
-
-import { CustomPromptBar } from "./custom-prompt-menu";
+import {
+  isThreadRagModeLocked,
+  lockThreadRagMode,
+  useLocalSettings,
+} from "@/core/settings";
+import { useCitationDisplaySettings } from "@/core/system-settings/hooks";
+
+import { CustomPromptBar } from "./custom-prompt-menu";
 import { useThread } from "./messages/context";
 import { ModeHoverGuide } from "./mode-hover-guide";
 import { Tooltip } from "./tooltip";
@@ -223,16 +225,20 @@ export function InputBox({
     context.execution_profile === "single_round_rag";
   const multiRoundRagActive =
     context.execution_profile === "multi_round_rag";
+  const turboModeVisible = isTurboModeVisible();
+  const directChatActive =
+    turboModeVisible && context.execution_profile === "direct";
   const frontendRagActive = singleRoundRagActive || multiRoundRagActive;
+  const bypassAgentActive = frontendRagActive || directChatActive;
   const modelOptions = useMemo(() => {
     return singleRoundRagActive ? extraModels : models;
   }, [extraModels, models, singleRoundRagActive]);
-  const { thread, isMock } = useThread();
-  const { textInput } = usePromptInputController();
-  const promptRootRef = useRef<HTMLDivElement | null>(null);
-  const { data: citationDisplay } = useCitationDisplaySettings();
-  const referenceModeEntryEnabled =
-    citationDisplay?.reference_mode_enabled ?? false;
+  const { thread, isMock } = useThread();
+  const { textInput } = usePromptInputController();
+  const promptRootRef = useRef<HTMLDivElement | null>(null);
+  const { data: citationDisplay } = useCitationDisplaySettings();
+  const referenceModeEntryEnabled =
+    citationDisplay?.reference_mode_enabled ?? false;
 
   const [followups, setFollowups] = useState<string[]>([]);
   const [followupsHidden, setFollowupsHidden] = useState(false);
@@ -253,11 +259,37 @@ export function InputBox({
     recommendedQuestions.length > 0;
 
   useEffect(() => {
-    // Multi-round RAG is a frontend execution profile, not a model option.
-    // Do not let the normal model fallback clear it on every render.
+    // Frontend-only execution profiles are not model options.
+    // Do not let the normal model fallback clear them on every render.
+    if (!turboModeVisible && context.execution_profile === "direct") {
+      onContextChange?.({
+        ...context,
+        execution_profile: undefined,
+      });
+      return;
+    }
     if (multiRoundRagActive) {
       return;
     }
+    if (directChatActive) {
+      if (models.length === 0) {
+        return;
+      }
+      const currentModel = models.find((m) => m.name === context.model_name);
+      const fallbackModel = currentModel ?? models[0]!;
+      if (
+        context.model_name === fallbackModel.name &&
+        context.execution_profile === "direct"
+      ) {
+        return;
+      }
+      onContextChange?.({
+        ...context,
+        model_name: fallbackModel.name,
+        execution_profile: "direct",
+      });
+      return;
+    }
     if (modelOptions.length === 0) {
       return;
     }
@@ -281,7 +313,7 @@ export function InputBox({
       mode: nextMode,
       execution_profile: fallbackModel.execution_profile,
     });
-  }, [context, modelOptions, multiRoundRagActive, onContextChange]);
+  }, [context, directChatActive, modelOptions, models, multiRoundRagActive, onContextChange, turboModeVisible]);
 
   const selectedModel = useMemo(() => {
     if (modelOptions.length === 0) {
@@ -314,7 +346,10 @@ export function InputBox({
         model_name,
         mode: getResolvedMode(context.mode, model.supports_thinking ?? false),
         reasoning_effort: context.reasoning_effort,
-        execution_profile: model.execution_profile,
+        execution_profile:
+          context.execution_profile === "direct"
+            ? "direct"
+            : model.execution_profile,
       });
       setModelDialogOpen(false);
     },
@@ -346,6 +381,16 @@ export function InputBox({
     [onContextChange, context, models, supportThinking],
   );
 
+  const handleDirectChatSelect = useCallback(() => {
+    const ordinaryModel =
+      models.find((model) => model.name === context.model_name) ?? models[0];
+    onContextChange?.({
+      ...context,
+      model_name: ordinaryModel?.name ?? context.model_name,
+      execution_profile: "direct",
+    });
+  }, [context, models, onContextChange]);
+
   const handleSingleRoundRagSelect = useCallback(() => {
     const ragModel =
       extraModels.find((model) => model.name === context.model_name) ??
@@ -749,7 +794,7 @@ export function InputBox({
               />
             </PromptInputActionMenuContent>
           </PromptInputActionMenu> */}
-            {!frontendRagActive && (
+            {!bypassAgentActive && (
               <AddAttachmentsButton
                 className={cn(
                   "rounded-full border-0 bg-transparent px-2.5! shadow-none text-muted-foreground hover:bg-muted/70 hover:text-foreground dark:text-slate-400 dark:hover:bg-slate-700/70 dark:hover:text-slate-100",
@@ -758,7 +803,7 @@ export function InputBox({
                 )}
               />
             )}
-            {!frontendRagActive && !hideContextTools && <Tooltip
+            {!bypassAgentActive && !hideContextTools && <Tooltip
               content={
                 context.writing_mode
                   ? "写作模式已开启：报告由深度研究管线按「通用分析结构」撰写，优先使用对话中已检索的资料"
@@ -784,7 +829,7 @@ export function InputBox({
                 <span className="text-xs font-normal">写作</span>
               </PromptInputButton>
             </Tooltip>}
-            {!frontendRagActive && <Tooltip
+            {!bypassAgentActive && <Tooltip
               content={
                 artifactDirectoryModeEnabled
                   ? "文件模式已开启：右侧会显示当前对话生成的全部文件目录"
@@ -813,7 +858,7 @@ export function InputBox({
                 <span className="text-xs font-normal">文件</span>
               </PromptInputButton>
             </Tooltip>}
-            {!frontendRagActive && !hideContextTools && !hideMemoryTool && <Tooltip
+            {!bypassAgentActive && !hideContextTools && !hideMemoryTool && <Tooltip
               content={
                 memoryInjectionEnabled
                   ? "记忆注入已开启：对话前会注入历史记忆"
@@ -839,9 +884,9 @@ export function InputBox({
                 <span className="text-xs font-normal">记忆</span>
               </PromptInputButton>
             </Tooltip>}
-            {referenceModeEntryEnabled && !frontendRagActive && !hideContextTools && <Tooltip
-              content={
-                ragModeEnabled
+            {referenceModeEntryEnabled && !bypassAgentActive && !hideContextTools && <Tooltip
+              content={
+                ragModeEnabled
                   ? "参考文献模式已开启：检索类结果会按编号引用展示"
                   : "参考文献模式已关闭：点击开启"
               }
@@ -869,7 +914,7 @@ export function InputBox({
                 <span className="text-xs font-normal">参考文献</span>
               </PromptInputButton>
             </Tooltip>}
-            {!frontendRagActive && <Tooltip
+            {!bypassAgentActive && <Tooltip
               content={
                 contextCompressionEnabled
                   ? "上下文压缩已开启：超长对话会自动压缩历史以节省 token"
@@ -909,7 +954,9 @@ export function InputBox({
                     : "flash"
                 }
                 tooltipContent={
-                  singleRoundRagActive
+                  directChatActive
+                    ? `${t.inputBox.turboMode}：${t.inputBox.turboModeDescription}`
+                    : singleRoundRagActive
                     ? "单轮 RAG 问答：基于知识库检索生成答案，并展示参考资料"
                     : multiRoundRagActive
                       ? "多轮 RAG 问答：多次检索并展示检索过程与参考资料"
@@ -921,7 +968,9 @@ export function InputBox({
                     "gap-1.5! rounded-full border-0 bg-transparent px-3! text-muted-foreground shadow-none hover:bg-muted/70 hover:text-foreground dark:text-slate-400 dark:hover:bg-slate-700/70 dark:hover:text-slate-100",
                     compact && "rounded-lg border px-2.5! py-1! text-[11px] font-medium",
                     compact &&
-                      (frontendRagActive
+                      (directChatActive
+                        ? "border-sky-200 bg-sky-50/60 text-sky-700 hover:bg-sky-100 dark:border-sky-700 dark:bg-sky-950/40 dark:text-sky-200"
+                        : frontendRagActive
                         ? "border-emerald-200 bg-emerald-50/60 text-emerald-700 hover:bg-emerald-100 dark:border-emerald-700 dark:bg-emerald-950/40 dark:text-emerald-200"
                         : context.mode === "thinking"
                         ? "border-indigo-200 bg-indigo-50/60 text-indigo-700 hover:bg-indigo-100 dark:border-indigo-700 dark:bg-indigo-950/40 dark:text-indigo-200"
@@ -933,7 +982,9 @@ export function InputBox({
                   )}
                   >
                     <div>
-                    {frontendRagActive ? (
+                    {directChatActive ? (
+                      <GaugeIcon className="size-3" />
+                    ) : frontendRagActive ? (
                       <BookMarkedIcon className="size-3" />
                     ) : context.mode === "flash" ? (
                       <ZapIcon className="size-3" />
@@ -948,10 +999,14 @@ export function InputBox({
                   <div
                     className={cn(
                       "text-xs font-normal",
-                      context.mode === "ultra" ? "golden-text" : "",
+                      context.mode === "ultra" && !directChatActive && !frontendRagActive
+                        ? "golden-text"
+                        : "",
                     )}
                   >
-                    {frontendRagActive
+                    {directChatActive
+                      ? t.inputBox.turboMode
+                      : frontendRagActive
                       ? multiRoundRagActive
                         ? "多轮 RAG"
                         : "单轮 RAG"
@@ -969,9 +1024,39 @@ export function InputBox({
                     {t.inputBox.mode}
                   </DropdownMenuLabel>
                   <PromptInputActionMenu>
+                    {turboModeVisible && (
                     <PromptInputActionMenuItem
                       className={cn(
-                        !frontendRagActive && context.mode === "flash"
+                        directChatActive
+                          ? "bg-sky-50 text-sky-800 hover:bg-sky-100 focus:bg-sky-100 dark:bg-sky-950/40 dark:text-sky-200 dark:hover:bg-sky-950/60 dark:focus:bg-sky-950/60"
+                          : "text-muted-foreground/65",
+                      )}
+                      onSelect={handleDirectChatSelect}
+                    >
+                      <div className="flex flex-col gap-2">
+                        <div className="flex items-center gap-1 font-bold">
+                          <GaugeIcon
+                            className={cn(
+                              "mr-2 size-4",
+                              directChatActive && "text-sky-700 dark:text-sky-200",
+                            )}
+                          />
+                          {t.inputBox.turboMode}
+                        </div>
+                        <div className="pl-7 text-xs">
+                          {t.inputBox.turboModeDescription}
+                        </div>
+                      </div>
+                      {directChatActive ? (
+                        <CheckIcon className="ml-auto size-4" />
+                      ) : (
+                        <div className="ml-auto size-4" />
+                      )}
+                    </PromptInputActionMenuItem>
+                    )}
+                    <PromptInputActionMenuItem
+                      className={cn(
+                        !bypassAgentActive && context.mode === "flash"
                           ? "text-accent-foreground"
                           : "text-muted-foreground/65",
                       )}
@@ -982,7 +1067,7 @@ export function InputBox({
                           <ZapIcon
                             className={cn(
                               "mr-2 size-4",
-                              !frontendRagActive && context.mode === "flash" &&
+                              !bypassAgentActive && context.mode === "flash" &&
                                 "text-accent-foreground",
                             )}
                           />
@@ -992,7 +1077,7 @@ export function InputBox({
                           {t.inputBox.flashModeDescription}
                         </div>
                       </div>
-                      {!frontendRagActive && context.mode === "flash" ? (
+                      {!bypassAgentActive && context.mode === "flash" ? (
                         <CheckIcon className="ml-auto size-4" />
                       ) : (
                         <div className="ml-auto size-4" />
@@ -1001,7 +1086,7 @@ export function InputBox({
                     {supportThinking && (
                       <PromptInputActionMenuItem
                         className={cn(
-                          !frontendRagActive && context.mode === "thinking"
+                          !bypassAgentActive && context.mode === "thinking"
                             ? "text-accent-foreground"
                             : "text-muted-foreground/65",
                         )}
@@ -1012,7 +1097,7 @@ export function InputBox({
                             <LightbulbIcon
                               className={cn(
                                 "mr-2 size-4",
-                                !frontendRagActive && context.mode === "thinking" &&
+                                !bypassAgentActive && context.mode === "thinking" &&
                                   "text-accent-foreground",
                               )}
                             />
@@ -1022,7 +1107,7 @@ export function InputBox({
                             {t.inputBox.reasoningModeDescription}
                           </div>
                         </div>
-                        {!frontendRagActive && context.mode === "thinking" ? (
+                        {!bypassAgentActive && context.mode === "thinking" ? (
                           <CheckIcon className="ml-auto size-4" />
                         ) : (
                           <div className="ml-auto size-4" />
@@ -1031,7 +1116,7 @@ export function InputBox({
                     )}
                     <PromptInputActionMenuItem
                       className={cn(
-                        !frontendRagActive && context.mode === "pro"
+                        !bypassAgentActive && context.mode === "pro"
                           ? "text-accent-foreground"
                           : "text-muted-foreground/65",
                       )}
@@ -1042,7 +1127,7 @@ export function InputBox({
                           <GraduationCapIcon
                             className={cn(
                               "mr-2 size-4",
-                              !frontendRagActive && context.mode === "pro" &&
+                              !bypassAgentActive && context.mode === "pro" &&
                                 "text-accent-foreground",
                             )}
                           />
@@ -1052,7 +1137,7 @@ export function InputBox({
                           {t.inputBox.proModeDescription}
                         </div>
                       </div>
-                      {!frontendRagActive && context.mode === "pro" ? (
+                      {!bypassAgentActive && context.mode === "pro" ? (
                         <CheckIcon className="ml-auto size-4" />
                       ) : (
                         <div className="ml-auto size-4" />
@@ -1060,7 +1145,7 @@ export function InputBox({
                     </PromptInputActionMenuItem>
                     <PromptInputActionMenuItem
                       className={cn(
-                        !frontendRagActive && context.mode === "ultra"
+                        !bypassAgentActive && context.mode === "ultra"
                           ? "text-accent-foreground"
                           : "text-muted-foreground/65",
                       )}
@@ -1071,14 +1156,14 @@ export function InputBox({
                           <RocketIcon
                             className={cn(
                               "mr-2 size-4",
-                              !frontendRagActive &&
+                              !bypassAgentActive &&
                                 context.mode === "ultra" &&
                                 "text-[#dabb5e]",
                             )}
                           />
                           <div
                             className={cn(
-                              !frontendRagActive &&
+                              !bypassAgentActive &&
                                 context.mode === "ultra" &&
                                 "golden-text",
                             )}
@@ -1090,7 +1175,7 @@ export function InputBox({
                           {t.inputBox.ultraModeDescription}
                         </div>
                       </div>
-                      {!frontendRagActive && context.mode === "ultra" ? (
+                      {!bypassAgentActive && context.mode === "ultra" ? (
                         <CheckIcon className="ml-auto size-4" />
                       ) : (
                         <div className="ml-auto size-4" />
@@ -1161,7 +1246,7 @@ export function InputBox({
                 </DropdownMenuGroup>
               </PromptInputActionMenuContent>
             </PromptInputActionMenu>
-            {!frontendRagActive && supportReasoningEffort && context.mode !== "flash" && (
+            {!bypassAgentActive && supportReasoningEffort && context.mode !== "flash" && (
               <PromptInputActionMenu>
                 <PromptInputActionMenuTrigger className={cn("gap-1.5! rounded-full border-0 bg-transparent px-3! text-muted-foreground shadow-none hover:bg-muted/70 hover:text-foreground dark:text-slate-400 dark:hover:bg-slate-700/70 dark:hover:text-slate-100", compact && "rounded-lg border border-border px-2.5! py-1! text-[13px]")}>
                   <div className="text-xs font-normal">
@@ -1279,7 +1364,7 @@ export function InputBox({
             )}
           </PromptInputTools>
           <PromptInputTools className={cn("gap-1.5", compact && "gap-2")}>
-            {!frontendRagActive && agentSelector && (
+            {!bypassAgentActive && agentSelector && (
               <AgentSelector
                 selectedAgentId={agentSelector.selectedAgentId}
                 onAgentChange={agentSelector.onAgentChange}
@@ -1287,8 +1372,8 @@ export function InputBox({
                 compact={compact}
               />
             )}
-            {!frontendRagActive && knowledgeSelector}
-            {!frontendRagActive && promptPrefix && (
+            {!bypassAgentActive && knowledgeSelector}
+            {!bypassAgentActive && promptPrefix && (
               <Tooltip
                 content={
                   promptPrefix.on

frontend-web/src/components/workspace/model-name-select.tsx

@@ -25,6 +25,7 @@ export function ModelNameSelect({
   className,
   triggerClassName,
   defaultLabel = "默认模型",
+  title = "选择用于本次操作的大模型(默认使用系统配置的模型)",
 }: {
   value: string | null;
   onChange: (modelName: string | null) => void;
@@ -32,6 +33,7 @@ export function ModelNameSelect({
   className?: string;
   triggerClassName?: string;
   defaultLabel?: string;
+  title?: string;
 }) {
   const { models } = useModels();
   return (
@@ -42,7 +44,7 @@ export function ModelNameSelect({
     >
       <SelectTrigger
         className={cn("h-8 gap-1.5 text-xs", triggerClassName, className)}
-        title="选择用于本次操作的大模型(默认使用系统配置的模型)"
+        title={title}
       >
         <SelectValue placeholder={defaultLabel} />
       </SelectTrigger>

frontend-web/src/components/workspace/my-project-thread-indicator.tsx

@@ -0,0 +1,51 @@
+import { FolderKanban } from "lucide-react";
+
+import {
+  MY_PROJECT_CONVERSATION_LABELS,
+  type MyProjectConversationType,
+} from "@/core/threads/project-metadata";
+import { cn } from "@/lib/utils";
+
+const BADGE_STYLES: Record<MyProjectConversationType, string> = {
+  qa: "border-sky-200 bg-sky-50 text-sky-700 dark:border-sky-700/70 dark:bg-sky-950/55 dark:text-sky-300",
+  strategy:
+    "border-violet-200 bg-violet-50 text-violet-700 dark:border-violet-700/70 dark:bg-violet-950/55 dark:text-violet-300",
+  solution:
+    "border-emerald-200 bg-emerald-50 text-emerald-700 dark:border-emerald-700/70 dark:bg-emerald-950/55 dark:text-emerald-300",
+};
+
+export function MyProjectThreadIcon({
+  type,
+  className,
+}: {
+  type: MyProjectConversationType;
+  className?: string;
+}) {
+  return (
+    <FolderKanban
+      aria-label={`我的项目 · ${MY_PROJECT_CONVERSATION_LABELS[type]}`}
+      className={cn("size-3.5 shrink-0 text-violet-500", className)}
+    />
+  );
+}
+
+export function MyProjectThreadBadge({
+  type,
+  className,
+}: {
+  type: MyProjectConversationType;
+  className?: string;
+}) {
+  return (
+    <span
+      className={cn(
+        "shrink-0 rounded border px-1 py-0.5 text-[9px] font-medium leading-none",
+        BADGE_STYLES[type],
+        className,
+      )}
+      title={`来自我的项目 · ${MY_PROJECT_CONVERSATION_LABELS[type]}`}
+    >
+      {MY_PROJECT_CONVERSATION_LABELS[type]}
+    </span>
+  );
+}

frontend-web/src/components/workspace/recent-chat-list.tsx

@@ -49,7 +49,11 @@ import {
   SidebarMenuButton,
   SidebarMenuItem,
 } from "@/components/ui/sidebar";
-import { ShareConversationDialog } from "@/components/workspace/thread-share-dialogs";
+import { ShareConversationDialog } from "@/components/workspace/thread-share-dialogs";
+import {
+  MyProjectThreadBadge,
+  MyProjectThreadIcon,
+} from "@/components/workspace/my-project-thread-indicator";
 import { getAPIClient } from "@/core/api";
 import { useI18n } from "@/core/i18n/hooks";
 import {
@@ -63,7 +67,8 @@ import {
   useToggleThreadFavorite,
   useToggleThreadPin,
 } from "@/core/threads/hooks";
-import type { AgentThread, AgentThreadState } from "@/core/threads/types";
+import type { AgentThread, AgentThreadState } from "@/core/threads/types";
+import { myProjectConversationTypeOfThread } from "@/core/threads/project-metadata";
 import {
   isBootstrapThread,
   isHiddenFromRecentChats,
@@ -245,7 +250,8 @@ export function RecentChatList({
               {shownThreads.map((thread) => {
                 const href = listPathOfThread(thread);
                 const isActive = href === pathname;
-                const isBoot = isBootstrapThread(thread);
+                const isBoot = isBootstrapThread(thread);
+                const projectType = myProjectConversationTypeOfThread(thread);
                 const pinned = isThreadPinned(thread);
                 const favorited = isThreadFavorite(thread);
                 return (
@@ -279,8 +285,10 @@ export function RecentChatList({
                             }
                             aria-label="智能体创建会话"
                           />
-                        ) : (
-                          compact && (
+                        ) : projectType ? (
+                          <MyProjectThreadIcon type={projectType} />
+                        ) : (
+                          compact && (
                             <MessageSquare
                               className={
                                 "size-3.5 shrink-0 " +
@@ -294,9 +302,15 @@ export function RecentChatList({
                         {pinned && (
                           <Pin className="size-3 shrink-0 text-muted-foreground/70" />
                         )}
-                        <span className="truncate">
-                          {desensitize(titleOfThread(thread, t.pages.newChat))}
-                        </span>
+                        <span className="min-w-0 flex-1 truncate">
+                          {desensitize(titleOfThread(thread, t.pages.newChat))}
+                        </span>
+                        {projectType && (
+                          <MyProjectThreadBadge
+                            className="mr-3"
+                            type={projectType}
+                          />
+                        )}
                       </Link>
                     </SidebarMenuButton>
                     {env.NEXT_PUBLIC_STATIC_WEBSITE_ONLY !== "true" && (

frontend-web/src/components/workspace/settings/settings-dialog.tsx

@@ -69,7 +69,7 @@ export function SettingsDialog(props: SettingsDialogProps) {
       // },
       { id: "tools", label: t.settings.sections.tools, icon: WrenchIcon },
       ...(isAdmin
-        ? [{ id: "encoder", label: "本地编码器", icon: CpuIcon }]
+        ? [{ id: "encoder", label: "Wiki 镜像编码器", icon: CpuIcon }]
         : []),
       {
         id: "account",

frontend-web/src/components/workspace/workspace-nav-chat-list.tsx

@@ -14,7 +14,7 @@ import {
   SidebarMenuItem,
 } from "@/components/ui/sidebar";
 import { useI18n } from "@/core/i18n/hooks";
-import { BookOpen, BotIcon, BrainIcon, FileSearch, FileText, Library, ListChecks, MessageSquarePlus, MessagesSquare, PenLine, Plus, SparklesIcon, Telescope, Users } from "lucide-react";
+import { BookOpen, BotIcon, BrainIcon, FileSearch, FileText, FolderKanban, Library, ListChecks, MessageSquarePlus, MessagesSquare, PenLine, Plus, SparklesIcon, Telescope, Users } from "lucide-react";
 
 import { KnowledgeRagToggle } from "./knowledge-rag-toggle";
 import { SidebarCollapseButton } from "./workspace-header";
@@ -24,7 +24,10 @@ import {
   applyCompactMenuOverrides,
   type CompactMenuItem,
 } from "@/core/page-layout/compact-menu-overrides";
-import { type MenuItem } from "@/core/page-layout/sidebar-menu";
+import {
+  MARKDOWN_DOCX_MENU_ITEM,
+  type MenuItem,
+} from "@/core/page-layout/sidebar-menu";
 import { useCompactMenuOverrides } from "@/strategy-components/api/compact-menu-overrides";
 
 // 普通导航项：默认中性色，激活态与「新对话」一致——主色浅底 + 主色文字/图标
@@ -65,6 +68,15 @@ export const WORKSPACE_COMPACT_NAV_ITEMS: WorkspaceCompactNavItem[] = [
     path: "/page/workspace/chats",
     match: (pathname) => pathname === "/page/workspace/chats",
   },
+  {
+    id: "strategy-projects",
+    label: "我的项目",
+    icon: FolderKanban,
+    path: "/page/strategy/qa/projects",
+    match: (pathname) =>
+      pathname.startsWith("/page/strategy/qa/projects") ||
+      pathname.startsWith("/page/strategy/qa/strategy-selection"),
+  },
   {
     id: "workspace-library",
     label: "资料库",
@@ -140,7 +152,13 @@ export const WORKSPACE_COMPACT_NAV_ITEMS: WorkspaceCompactNavItem[] = [
     label: "知识库管理",
     icon: BookOpen,
     path: "/page/workspace/knowledge",
-    match: (pathname) => pathname.startsWith("/page/workspace/knowledge"),
+    match: (pathname) =>
+      pathname.startsWith("/page/workspace/knowledge") &&
+      !pathname.startsWith(MARKDOWN_DOCX_MENU_ITEM.path),
+  },
+  {
+    ...MARKDOWN_DOCX_MENU_ITEM,
+    match: (pathname) => pathname.startsWith(MARKDOWN_DOCX_MENU_ITEM.path),
   },
 ];
 

frontend-web/src/core/i18n/locales/en-US.ts

@@ -96,6 +96,9 @@ export const enUS: Translations = {
     mode: "Mode",
     flashMode: "Flash",
     flashModeDescription: "Fast and efficient, but may not be accurate",
+    turboMode: "Turbo",
+    turboModeDescription:
+      "Talk to the model directly with no agent tools or skills, for lower first-token latency",
     reasoningMode: "Reasoning",
     reasoningModeDescription:
       "Reasoning before action, balance between time and accuracy",
@@ -448,17 +451,17 @@ export const enUS: Translations = {
       system: "System",
       light: "Light",
       dark: "Dark",
-      lightblue: "Light Blue",
-      lightgreen: "Green",
-      iceblue: "Glacier Blue",
-      lightyellow: "Pale Yellow",
+      lightblue: "Light Blue",
+      lightgreen: "Green",
+      iceblue: "Glacier Blue",
+      lightyellow: "Pale Yellow",
       systemDescription: "Match the operating system preference automatically.",
       lightDescription: "Bright palette with higher contrast for daytime.",
       darkDescription: "Dim palette that reduces glare for focus.",
-      lightblueDescription: "A crisp light palette built around blue.",
-      lightgreenDescription: "A crisp light palette built around fresh green tones.",
-      iceblueDescription: "An airy palette built around #9BCEF1 with accessible blue actions.",
-      lightyellowDescription: "A soft palette built around #F3FBD9 with readable olive actions.",
+      lightblueDescription: "A crisp light palette built around blue.",
+      lightgreenDescription: "A crisp light palette built around fresh green tones.",
+      iceblueDescription: "An airy palette built around #9BCEF1 with accessible blue actions.",
+      lightyellowDescription: "A soft palette built around #F3FBD9 with readable olive actions.",
       languageTitle: "Language",
       languageDescription: "Switch between languages.",
     },
@@ -545,13 +548,13 @@ export const enUS: Translations = {
       filesSaveAction: "Save",
       filesCancelEditAction: "Cancel",
       filesDownloadAction: "Download",
-      filesCopyPathAction: "Copy path",
-      filesDiscardConfirm: "Discard unsaved changes?",
-      filesSaveSuccess: "File saved",
-      filesDeleteAction: "Delete",
-      filesDeleteConfirm: "Delete \"{path}\"? This cannot be undone.",
-      filesDeleteSuccess: "File deleted",
-      filesReadOnlyHint: "Only administrators can edit or delete built-in skill files.",
+      filesCopyPathAction: "Copy path",
+      filesDiscardConfirm: "Discard unsaved changes?",
+      filesSaveSuccess: "File saved",
+      filesDeleteAction: "Delete",
+      filesDeleteConfirm: "Delete \"{path}\"? This cannot be undone.",
+      filesDeleteSuccess: "File deleted",
+      filesReadOnlyHint: "Only administrators can edit or delete built-in skill files.",
       viewDetailAction: "View skill details",
       stateSheet: {
         archivedTitle: "Archived skills",
@@ -591,26 +594,26 @@ export const enUS: Translations = {
         chooseFile: "Choose file",
         validating: "Validating archive…",
         installing: "Installing…",
-        replace: "Upload again and replace",
+        replace: "Upload again and replace",
         install: "Install",
         cancel: "Cancel",
         nameLabel: "Name",
         descriptionLabel: "Description",
         licenseLabel: "License",
         toolsLabel: "Allowed tools",
-        warningsLabel: "Warnings",
-        conflictOwnedByMe:
-          "You already uploaded a skill named '{name}'. You may upload it again and replace your existing copy (its enabled state will be kept).",
-        conflictOwnedByMeWrongTarget:
-          "The custom skill '{name}' belongs to you. Switch the target to 'Custom skill' to replace it.",
-        conflictOwnedByOther:
-          "Skill '{name}' was uploaded by user '{owner}' and cannot be replaced. Rename the skill before uploading.",
-        conflictCustom:
-          "A custom skill named '{name}' already exists, but its uploader could not be identified. Rename it to avoid overwriting someone else's skill.",
+        warningsLabel: "Warnings",
+        conflictOwnedByMe:
+          "You already uploaded a skill named '{name}'. You may upload it again and replace your existing copy (its enabled state will be kept).",
+        conflictOwnedByMeWrongTarget:
+          "The custom skill '{name}' belongs to you. Switch the target to 'Custom skill' to replace it.",
+        conflictOwnedByOther:
+          "Skill '{name}' was uploaded by user '{owner}' and cannot be replaced. Rename the skill before uploading.",
+        conflictCustom:
+          "A custom skill named '{name}' already exists, but its uploader could not be identified. Rename it to avoid overwriting someone else's skill.",
         conflictPublic:
           "A built-in public skill named '{name}' already exists and cannot be overwritten.",
-        conflictPublicAdminHint:
-          "A built-in public skill named '{name}' exists. Click 'Upload again and replace' to overwrite it.",
+        conflictPublicAdminHint:
+          "A built-in public skill named '{name}' exists. Click 'Upload again and replace' to overwrite it.",
         installSuccess: "Skill '{name}' installed.",
         installSuccessReplaced: "Skill '{name}' replaced.",
         rejectInvalidExt: "Only .zip or .skill files are accepted.",

frontend-web/src/core/i18n/locales/types.ts

@@ -91,6 +91,8 @@ export interface Translations {
     mode: string;
     flashMode: string;
     flashModeDescription: string;
+    turboMode: string;
+    turboModeDescription: string;
     reasoningMode: string;
     reasoningModeDescription: string;
     proMode: string;
@@ -383,17 +385,17 @@ export interface Translations {
       system: string;
       light: string;
       dark: string;
-      lightblue: string;
-      lightgreen: string;
-      iceblue: string;
-      lightyellow: string;
+      lightblue: string;
+      lightgreen: string;
+      iceblue: string;
+      lightyellow: string;
       systemDescription: string;
       lightDescription: string;
       darkDescription: string;
-      lightblueDescription: string;
-      lightgreenDescription: string;
-      iceblueDescription: string;
-      lightyellowDescription: string;
+      lightblueDescription: string;
+      lightgreenDescription: string;
+      iceblueDescription: string;
+      lightyellowDescription: string;
       languageTitle: string;
       languageDescription: string;
     };
@@ -475,13 +477,13 @@ export interface Translations {
       filesSaveAction: string;
       filesCancelEditAction: string;
       filesDownloadAction: string;
-      filesCopyPathAction: string;
-      filesDiscardConfirm: string;
-      filesSaveSuccess: string;
-      filesDeleteAction: string;
-      filesDeleteConfirm: string;
-      filesDeleteSuccess: string;
-      filesReadOnlyHint: string;
+      filesCopyPathAction: string;
+      filesDiscardConfirm: string;
+      filesSaveSuccess: string;
+      filesDeleteAction: string;
+      filesDeleteConfirm: string;
+      filesDeleteSuccess: string;
+      filesReadOnlyHint: string;
       viewDetailAction: string;
       stateSheet: {
         archivedTitle: string;
@@ -525,12 +527,12 @@ export interface Translations {
         nameLabel: string;
         descriptionLabel: string;
         licenseLabel: string;
-        toolsLabel: string;
-        warningsLabel: string;
-        conflictOwnedByMe: string;
-        conflictOwnedByMeWrongTarget: string;
-        conflictOwnedByOther: string;
-        conflictCustom: string;
+        toolsLabel: string;
+        warningsLabel: string;
+        conflictOwnedByMe: string;
+        conflictOwnedByMeWrongTarget: string;
+        conflictOwnedByOther: string;
+        conflictCustom: string;
         conflictPublic: string;
         conflictPublicAdminHint: string;
         installSuccess: string;

frontend-web/src/core/i18n/locales/zh-CN.ts

@@ -95,6 +95,8 @@ export const zhCN: Translations = {
     mode: "模式",
     flashMode: "快速",
     flashModeDescription: "快速且高效的完成任务，但可能不够精准",
+    turboMode: "极速",
+    turboModeDescription: "直连大模型流式问答，不走智能体工具与技能，首字更快",
     reasoningMode: "思考",
     reasoningModeDescription: "思考后再行动，在时间与准确性之间取得平衡",
     proMode: "专业问答",
@@ -429,17 +431,17 @@ export const zhCN: Translations = {
       system: "系统",
       light: "浅色",
       dark: "深色",
-      lightblue: "浅蓝",
-      lightgreen: "绿色",
-      iceblue: "冰川蓝",
-      lightyellow: "浅黄色",
+      lightblue: "浅蓝",
+      lightgreen: "绿色",
+      iceblue: "冰川蓝",
+      lightyellow: "浅黄色",
       systemDescription: "自动跟随系统主题。",
       lightDescription: "更明亮的配色，适合日间使用。",
       darkDescription: "更暗的配色，减少眩光方便专注。",
-      lightblueDescription: "以蓝色为主色的清爽浅色配色。",
-      lightgreenDescription: "采用清新绿色的浅色配色。",
-      iceblueDescription: "以 #9BCEF1 为主色，搭配冰蓝留白与沉稳交互色。",
-      lightyellowDescription: "以 #F3FBD9 为主色，搭配柔和浅黄留白与深橄榄交互色。",
+      lightblueDescription: "以蓝色为主色的清爽浅色配色。",
+      lightgreenDescription: "采用清新绿色的浅色配色。",
+      iceblueDescription: "以 #9BCEF1 为主色，搭配冰蓝留白与沉稳交互色。",
+      lightyellowDescription: "以 #F3FBD9 为主色，搭配柔和浅黄留白与深橄榄交互色。",
       languageTitle: "语言",
       languageDescription: "在不同语言之间切换。",
     },
@@ -524,11 +526,11 @@ export const zhCN: Translations = {
       filesDownloadAction: "下载",
       filesCopyPathAction: "复制路径",
       filesDiscardConfirm: "有未保存的修改,确定放弃吗?",
-      filesSaveSuccess: "文件已保存",
-      filesDeleteAction: "删除",
-      filesDeleteConfirm: "确定删除“{path}”？该操作不可撤销。",
-      filesDeleteSuccess: "文件已删除",
-      filesReadOnlyHint: "仅管理员可以编辑或删除内置技能文件。",
+      filesSaveSuccess: "文件已保存",
+      filesDeleteAction: "删除",
+      filesDeleteConfirm: "确定删除“{path}”？该操作不可撤销。",
+      filesDeleteSuccess: "文件已删除",
+      filesReadOnlyHint: "仅管理员可以编辑或删除内置技能文件。",
       viewDetailAction: "查看技能详情",
       stateSheet: {
         archivedTitle: "归档的技能",
@@ -566,24 +568,24 @@ export const zhCN: Translations = {
         chooseFile: "选择文件",
         validating: "正在校验文件…",
         installing: "安装中…",
-        replace: "重复上传并覆盖",
+        replace: "重复上传并覆盖",
         install: "安装",
         cancel: "取消",
         nameLabel: "名称",
         descriptionLabel: "描述",
         licenseLabel: "许可证",
         toolsLabel: "允许的工具",
-        warningsLabel: "警告",
-        conflictOwnedByMe:
-          "您已上传过同名技能 “{name}”，可重复上传并覆盖原版本（原启用状态保留）。",
-        conflictOwnedByMeWrongTarget:
-          "同名技能 “{name}” 是您上传的自定义技能，请切换到「自定义技能」后覆盖。",
-        conflictOwnedByOther:
-          "技能 “{name}” 已由用户 “{owner}” 上传，不能覆盖，请修改技能名称后再上传。",
-        conflictCustom:
-          "已存在同名自定义技能 “{name}”，但无法确认上传用户，为避免误覆盖请修改技能名称。",
+        warningsLabel: "警告",
+        conflictOwnedByMe:
+          "您已上传过同名技能 “{name}”，可重复上传并覆盖原版本（原启用状态保留）。",
+        conflictOwnedByMeWrongTarget:
+          "同名技能 “{name}” 是您上传的自定义技能，请切换到「自定义技能」后覆盖。",
+        conflictOwnedByOther:
+          "技能 “{name}” 已由用户 “{owner}” 上传，不能覆盖，请修改技能名称后再上传。",
+        conflictCustom:
+          "已存在同名自定义技能 “{name}”，但无法确认上传用户，为避免误覆盖请修改技能名称。",
         conflictPublic: `存在同名内置技能 '{name}'，无法覆盖。`,
-        conflictPublicAdminHint: `存在同名内置技能 '{name}'。点击「重复上传并覆盖」可替换。`,
+        conflictPublicAdminHint: `存在同名内置技能 '{name}'。点击「重复上传并覆盖」可替换。`,
         installSuccess: `技能 '{name}' 已安装。`,
         installSuccessReplaced: `技能 '{name}' 已替换。`,
         rejectInvalidExt: `只接受 .zip 或 .skill 文件。`,

frontend-web/src/core/messages/utils.ts

@@ -364,11 +364,16 @@ export function extractReasoningContentFromMessage(message: Message) {
   if (message.type !== "ai") {
     return null;
   }
-  if (
-    message.additional_kwargs &&
-    "reasoning_content" in message.additional_kwargs
-  ) {
-    return message.additional_kwargs.reasoning_content as string | null;
+  if (message.additional_kwargs) {
+    const reasoningContent = message.additional_kwargs.reasoning_content;
+    if (typeof reasoningContent === "string") {
+      return reasoningContent;
+    }
+    // Newer vLLM puts thinking in `reasoning` instead of `reasoning_content`.
+    const reasoning = message.additional_kwargs.reasoning;
+    if (typeof reasoning === "string") {
+      return reasoning;
+    }
   }
   if (Array.isArray(message.content)) {
     const part = message.content[0];
@@ -424,6 +429,9 @@ export function hasReasoning(message: Message) {
   if (typeof message.additional_kwargs?.reasoning_content === "string") {
     return true;
   }
+  if (typeof message.additional_kwargs?.reasoning === "string") {
+    return true;
+  }
   if (Array.isArray(message.content)) {
     const part = message.content[0];
     // Compatible with the Anthropic gateway

frontend-web/src/core/models/types.ts

@@ -4,11 +4,11 @@ export interface Model {
   model: string;
   display_name: string;
   description?: string | null;
-  supports_thinking?: boolean;
-  supports_reasoning_effort?: boolean;
-  /** Execution profiles handled by the frontend instead of DeerFlow. */
-  execution_profile?: "single_round_rag" | "multi_round_rag";
-}
+  supports_thinking?: boolean;
+  supports_reasoning_effort?: boolean;
+  /** Execution profiles handled by the frontend instead of DeerFlow. */
+  execution_profile?: "single_round_rag" | "multi_round_rag" | "direct";
+}
 
 export interface TokenUsageSettings {
   enabled: boolean;

frontend-web/src/core/page-layout/sidebar-menu.ts

@@ -21,6 +21,7 @@ import {
   FileBox,
   FileSearch,
   FileText,
+  FolderKanban,
   Gauge,
   Grid3X3,
   HelpCircle,
@@ -48,12 +49,23 @@ export type MenuItem = {
   path?: string;
   /** 额外视为「当前页属于本菜单项」的路由（不在侧栏展示，仅用于高亮）。 */
   aliasPaths?: string[];
+  /** 从当前菜单项自身的 path / aliasPaths 前缀匹配中排除的路由。 */
+  excludePaths?: string[];
   /** 非 admin 用户使用的路由（菜单对普通用户可见时生效，与简洁模式公开排行榜一致） */
   userPath?: string;
   adminOnly?: boolean;
   children?: MenuItem[];
 };
 
+/** Markdown 转 Word 功能的菜单定义，供全量与简洁模式共用。 */
+export const MARKDOWN_DOCX_MENU_PATH = "/page/workspace/knowledge/markdown-editor";
+export const MARKDOWN_DOCX_MENU_ITEM: MenuItem & { path: string } = {
+  id: "resource-markdown-docx-editor",
+  label: "md转word",
+  icon: FileText,
+  path: MARKDOWN_DOCX_MENU_PATH,
+};
+
 export const sidebarMenuItems: MenuItem[] = [
   {
     id: "qa-center",
@@ -68,6 +80,13 @@ export const sidebarMenuItems: MenuItem[] = [
         icon: Users,
         path: "/page/strategy/qa/multi-agent-roundtable",
       },
+      {
+        id: "strategy-projects",
+        label: "我的项目",
+        icon: FolderKanban,
+        path: "/page/strategy/qa/projects",
+        aliasPaths: ["/page/strategy/qa/strategy-selection"],
+      },
       // {
       //   id: "position-roundtable",
       //   label: "岗位会商",
@@ -258,12 +277,7 @@ export const sidebarMenuItems: MenuItem[] = [
       },
       { id: "mgmt-skills", label: "技能管理", icon: Sparkles, path: "/page/strategy/skills" },
       { id: "mgmt-memory", label: "记忆管理", icon: Brain, path: "/page/strategy/memory" },
-      {
-        id: "resource-markdown-docx-editor",
-        label: "md转word",
-        icon: FileText,
-        path: "/page/workspace/knowledge/markdown-editor",
-      },
+      MARKDOWN_DOCX_MENU_ITEM,
       {
         id: "mgmt-tasks",
         label: "定时任务",
@@ -330,6 +344,7 @@ export const sidebarMenuItems: MenuItem[] = [
         label: "知识库管理",
         icon: BookOpen,
         path: "/page/workspace/knowledge",
+        excludePaths: [MARKDOWN_DOCX_MENU_PATH],
       },
       {
         id: "resource-knowledge-base",
@@ -365,6 +380,9 @@ function routeMatchesPathname(pathname: string, route?: string): boolean {
 
 /** 菜单项自身 path / aliasPaths 是否匹配当前路由。 */
 export function menuItemMatchesPath(item: MenuItem, pathname: string): boolean {
+  if (item.excludePaths?.some((path) => routeMatchesPathname(pathname, path))) {
+    return false;
+  }
   if (routeMatchesPathname(pathname, item.path)) return true;
   return item.aliasPaths?.some((p) => routeMatchesPathname(pathname, p)) ?? false;
 }

frontend-web/src/core/system-settings/api.ts

@@ -13,6 +13,44 @@ export type KnowledgeBaseProductVersion = "v1" | "v2";
 
 export type OrdinaryKnowledgeLanding = "wiki" | "weknora";
 
+export interface StrategyProjectSettings {
+  taiwan_strait_demo_enabled: boolean;
+}
+
+export interface StrategyProjectSettingsUpdate {
+  taiwan_strait_demo_enabled?: boolean;
+}
+
+export async function loadStrategyProjectSettings(): Promise<StrategyProjectSettings> {
+  const response = await apiFetch(
+    `${getBackendBaseURL()}/api/system-settings/strategy-projects`,
+  );
+  if (!response.ok) {
+    throw new Error(`无法读取策略项目设置（HTTP ${response.status}）`);
+  }
+  return (await response.json()) as StrategyProjectSettings;
+}
+
+export async function updateStrategyProjectSettings(
+  body: StrategyProjectSettingsUpdate,
+): Promise<StrategyProjectSettings> {
+  const response = await apiFetch(
+    `${getBackendBaseURL()}/api/system-settings/strategy-projects`,
+    {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    },
+  );
+  if (!response.ok) {
+    const detail = await response
+      .json()
+      .catch(() => ({ detail: "保存策略项目设置失败" }));
+    throw new Error(detail.detail ?? "保存策略项目设置失败");
+  }
+  return (await response.json()) as StrategyProjectSettings;
+}
+
 export async function loadOrdinaryKnowledgeLanding(): Promise<OrdinaryKnowledgeLanding> {
   const response = await apiFetch(`${getBackendBaseURL()}/api/system-settings/ordinary-knowledge-landing`);
   if (!response.ok) throw new Error("无法读取普通知识库默认页面设置");

frontend-web/src/core/system-settings/hooks.ts

@@ -13,6 +13,7 @@ import {
   loadPromptPrefixSettings,
   loadPublishSquares,
   loadSkillCompressionSettings,
+  loadStrategyProjectSettings,
   updateAgentModuleConfig,
   updateAppearanceSettings,
   updateCitationDisplaySettings,
@@ -23,6 +24,7 @@ import {
   updatePromptPrefixSettings,
   updatePublishSquares,
   updateSkillCompressionSettings,
+  updateStrategyProjectSettings,
   type AppearanceUpdate,
   type CitationDisplayUpdate,
   type LeaderboardSettingsUpdate,
@@ -32,6 +34,7 @@ import {
   type PromptPrefixUpdate,
   type PublishSquaresUpdate,
   type SkillCompressionUpdate,
+  type StrategyProjectSettingsUpdate,
   type LayoutMode,
   type ViewMode,
 } from "./api";
@@ -45,6 +48,28 @@ const LEADERBOARD_KEY = ["systemSettings", "leaderboard"] as const;
 const SKILL_COMPRESSION_KEY = ["systemSettings", "skillCompression"] as const;
 const MODEL_CONCURRENCY_KEY = ["systemSettings", "modelConcurrency"] as const;
 const PLUGIN_MANAGEMENT_KEY = ["systemSettings", "pluginManagement"] as const;
+const STRATEGY_PROJECTS_KEY = ["systemSettings", "strategyProjects"] as const;
+
+export function useStrategyProjectSettings() {
+  return useQuery({
+    queryKey: STRATEGY_PROJECTS_KEY,
+    queryFn: () => loadStrategyProjectSettings(),
+    staleTime: 60_000,
+    refetchOnWindowFocus: false,
+    retry: false,
+  });
+}
+
+export function useUpdateStrategyProjectSettings() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (body: StrategyProjectSettingsUpdate) =>
+      updateStrategyProjectSettings(body),
+    onSuccess: (data) => {
+      queryClient.setQueryData(STRATEGY_PROJECTS_KEY, data);
+    },
+  });
+}
 
 export function usePromptPrefixSettings() {
   return useQuery({

frontend-web/src/core/threads/hooks.ts

@@ -16,14 +16,14 @@ import { rememberAskTime } from "../chat-timestamps";
 import { getBackendBaseURL, getLangGraphBaseURL } from "../config";
 import { useI18n } from "../i18n/hooks";
 import { OptType, writeYLog } from "../log/y-log";
-import type { FileInMessage } from "../messages/utils";
-import type { LocalSettings } from "../settings";
-import {
-  isThreadRagModeLocked,
-  lockThreadRagMode,
-  useLocalSettings,
-} from "../settings";
-import { useCitationDisplaySettings } from "../system-settings/hooks";
+import type { FileInMessage } from "../messages/utils";
+import type { LocalSettings } from "../settings";
+import {
+  isThreadRagModeLocked,
+  lockThreadRagMode,
+  useLocalSettings,
+} from "../settings";
+import { useCitationDisplaySettings } from "../system-settings/hooks";
 import { useUpdateSubtask } from "../tasks/context";
 import type { UploadedFileInfo } from "../uploads";
 import { promptInputFilePartToFile, uploadFiles } from "../uploads";
@@ -571,11 +571,11 @@ export function useThreadStream({
   onToolStart,
   onToolEnd,
 }: ThreadStreamOptions) {
-  const { t } = useI18n();
-  const [localSettings] = useLocalSettings();
-  const { data: citationDisplay } = useCitationDisplaySettings();
-  const referenceModeEntryEnabled =
-    citationDisplay?.reference_mode_enabled ?? false;
+  const { t } = useI18n();
+  const [localSettings] = useLocalSettings();
+  const { data: citationDisplay } = useCitationDisplaySettings();
+  const referenceModeEntryEnabled =
+    citationDisplay?.reference_mode_enabled ?? false;
   // Track the thread ID that is currently streaming to handle thread changes during streaming
   const [onStreamThreadId, setOnStreamThreadId] = useState(() => threadId);
   // Ref to track current thread ID across async callbacks without causing re-renders,
@@ -1507,21 +1507,21 @@ export function useThreadStream({
           ...context,
           ...extraContext,
         };
-        const selectedLlmWikiIds = Array.isArray(
-          mergedContext.llmwiki_knowledge_base_ids,
-        )
-          ? mergedContext.llmwiki_knowledge_base_ids
-          : [];
-        const selectedAssistantKnowledgeIds = Array.isArray(
-          mergedContext.assistant_knowledge_base_ids,
-        )
-          ? mergedContext.assistant_knowledge_base_ids
-          : [];
-        const ragModeEnabled =
-          (referenceModeEntryEnabled && localSettings.display.ragModeEnabled) ||
-          isThreadRagModeLocked(threadId) ||
-          selectedLlmWikiIds.length > 0 ||
-          selectedAssistantKnowledgeIds.length > 0;
+        const selectedLlmWikiIds = Array.isArray(
+          mergedContext.llmwiki_knowledge_base_ids,
+        )
+          ? mergedContext.llmwiki_knowledge_base_ids
+          : [];
+        const selectedAssistantKnowledgeIds = Array.isArray(
+          mergedContext.assistant_knowledge_base_ids,
+        )
+          ? mergedContext.assistant_knowledge_base_ids
+          : [];
+        const ragModeEnabled =
+          (referenceModeEntryEnabled && localSettings.display.ragModeEnabled) ||
+          isThreadRagModeLocked(threadId) ||
+          selectedLlmWikiIds.length > 0 ||
+          selectedAssistantKnowledgeIds.length > 0;
         if (ragModeEnabled) {
           lockThreadRagMode(threadId);
         }
@@ -1579,6 +1579,7 @@ export function useThreadStream({
             context: {
               ...mergedContext,
               thinking_enabled: mergedContext.mode !== "flash",
+              thinking_force_disabled: mergedContext.mode === "flash",
               is_plan_mode:
                 mergedContext.mode === "pro" || mergedContext.mode === "ultra",
               subagent_enabled: mergedContext.mode === "ultra",
@@ -1639,18 +1640,18 @@ export function useThreadStream({
         sendInFlightRef.current = false;
       }
     },
-    [
-      thread,
-      _handleOnStart,
-      t.uploads.uploadingFiles,
-      context,
-      referenceModeEntryEnabled,
-      localSettings.display.ragModeEnabled,
-      queryClient,
-      runOptions,
-      confirmOrRejoin,
-    ],
-  );
+    [
+      thread,
+      _handleOnStart,
+      t.uploads.uploadingFiles,
+      context,
+      referenceModeEntryEnabled,
+      localSettings.display.ragModeEnabled,
+      queryClient,
+      runOptions,
+      confirmOrRejoin,
+    ],
+  );
 
   const handleThreadStop = useCallback(async () => {
     const tid = threadIdRef.current;
@@ -1699,7 +1700,7 @@ export function useThreadStream({
       ? undefined
       : thread.error;
 
-  const mergedThread = {
+  const mergedThread = {
     ...thread,
     error: visibleThreadError,
     values: mergedValues,
@@ -1709,7 +1710,7 @@ export function useThreadStream({
         : mergedMessages,
     isLoading: thread.isLoading || streamHoldOpen,
     stop: handleThreadStop,
-  } as typeof thread;
+  } as typeof thread;
 
   // 第 4 个返回值 `onStreamThreadId` = 底层 useStream 当前实际绑定的线程 id（新建/未保存时为 null）。
   // 调用方据此判断「流是否已切到全新线程」，避免在切换会话的那一帧把消息发进上一个会话

frontend-web/src/core/threads/project-metadata.test.ts

@@ -0,0 +1,46 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  myProjectConversationTypeFromSearchParams,
+  myProjectConversationTypeOfThread,
+  myProjectThreadMetadata,
+  withMyProjectConversationMarker,
+} from "./project-metadata";
+
+test("project conversation type is read from persisted metadata", () => {
+  assert.equal(
+    myProjectConversationTypeOfThread({
+      metadata: myProjectThreadMetadata("strategy"),
+    }),
+    "strategy",
+  );
+  assert.equal(
+    myProjectConversationTypeOfThread({
+      metadata: { project_source: "elsewhere", project_type: "qa" },
+    }),
+    null,
+  );
+});
+
+test("metadata wins over the compatibility context fallback", () => {
+  assert.equal(
+    myProjectConversationTypeOfThread({
+      metadata: myProjectThreadMetadata("solution"),
+      context: myProjectThreadMetadata("qa"),
+    }),
+    "solution",
+  );
+});
+
+test("new-chat route marker round-trips all supported project types", () => {
+  for (const type of ["qa", "strategy", "solution"] as const) {
+    const path = withMyProjectConversationMarker(
+      "/page/strategy/chats/new?keep=1",
+      type,
+    );
+    const params = new URLSearchParams(path.split("?", 2)[1]);
+    assert.equal(params.get("keep"), "1");
+    assert.equal(myProjectConversationTypeFromSearchParams(params), type);
+  }
+});

frontend-web/src/core/threads/project-metadata.ts

@@ -0,0 +1,94 @@
+/**
+ * Stable marker for conversations entered from 「我的项目」.
+ *
+ * Keep this separate from ``project_id``: that key belongs to DeerFlow's
+ * folder-style conversation projects, while this marker describes the product
+ * mode that created (or explicitly continued) a conversation.
+ */
+export const MY_PROJECT_THREAD_SOURCE = "my-projects" as const;
+
+export const MY_PROJECT_THREAD_SOURCE_KEY = "project_source" as const;
+export const MY_PROJECT_THREAD_TYPE_KEY = "project_type" as const;
+
+export const MY_PROJECT_QUERY_SOURCE_KEY = "projectSource" as const;
+export const MY_PROJECT_QUERY_TYPE_KEY = "projectType" as const;
+
+export type MyProjectConversationType = "qa" | "strategy" | "solution";
+
+export const MY_PROJECT_CONVERSATION_LABELS: Record<
+  MyProjectConversationType,
+  string
+> = {
+  qa: "普通问答",
+  strategy: "策略优选",
+  solution: "方案生成",
+};
+
+const MY_PROJECT_CONVERSATION_TYPES = new Set<MyProjectConversationType>([
+  "qa",
+  "strategy",
+  "solution",
+]);
+
+function typeFromRecord(
+  value: Record<string, unknown> | null | undefined,
+): MyProjectConversationType | null {
+  if (value?.[MY_PROJECT_THREAD_SOURCE_KEY] !== MY_PROJECT_THREAD_SOURCE) {
+    return null;
+  }
+  const type = value[MY_PROJECT_THREAD_TYPE_KEY];
+  return typeof type === "string" &&
+    MY_PROJECT_CONVERSATION_TYPES.has(type as MyProjectConversationType)
+    ? (type as MyProjectConversationType)
+    : null;
+}
+
+export function myProjectThreadMetadata(
+  type: MyProjectConversationType,
+): Record<string, unknown> {
+  return {
+    [MY_PROJECT_THREAD_SOURCE_KEY]: MY_PROJECT_THREAD_SOURCE,
+    [MY_PROJECT_THREAD_TYPE_KEY]: type,
+  };
+}
+
+/** Read persisted metadata first; context is only a compatibility fallback. */
+export function myProjectConversationTypeOfThread(thread: {
+  metadata?: Record<string, unknown> | null;
+  context?: Record<string, unknown> | null;
+}): MyProjectConversationType | null {
+  return typeFromRecord(thread.metadata) ?? typeFromRecord(thread.context);
+}
+
+export function myProjectConversationTypeFromSearchParams(params: {
+  get(name: string): string | null;
+}): MyProjectConversationType | null {
+  if (params.get(MY_PROJECT_QUERY_SOURCE_KEY) !== MY_PROJECT_THREAD_SOURCE) {
+    return null;
+  }
+  const type = params.get(MY_PROJECT_QUERY_TYPE_KEY);
+  return typeof type === "string" &&
+    MY_PROJECT_CONVERSATION_TYPES.has(type as MyProjectConversationType)
+    ? (type as MyProjectConversationType)
+    : null;
+}
+
+/** Add an explicit, one-shot marker to a new-conversation route. */
+export function withMyProjectConversationMarker(
+  path: string,
+  type: MyProjectConversationType,
+): string {
+  const hashIndex = path.indexOf("#");
+  const hash = hashIndex >= 0 ? path.slice(hashIndex) : "";
+  const pathWithoutHash = hashIndex >= 0 ? path.slice(0, hashIndex) : path;
+  const queryIndex = pathWithoutHash.indexOf("?");
+  const pathname =
+    queryIndex >= 0 ? pathWithoutHash.slice(0, queryIndex) : pathWithoutHash;
+  const params = new URLSearchParams(
+    queryIndex >= 0 ? pathWithoutHash.slice(queryIndex + 1) : "",
+  );
+  params.set(MY_PROJECT_QUERY_SOURCE_KEY, MY_PROJECT_THREAD_SOURCE);
+  params.set(MY_PROJECT_QUERY_TYPE_KEY, type);
+  const search = params.toString();
+  return `${pathname}${search ? `?${search}` : ""}${hash}`;
+}

frontend-web/src/core/threads/types.ts

@@ -2,18 +2,20 @@ import type { Message, Thread } from "@langchain/langgraph-sdk";
 
 import type { Todo } from "../todos";
 
-export interface AgentThreadState extends Record<string, unknown> {
-  title: string;
-  title_provisional?: boolean;
-  messages: Message[];
-  artifacts: string[];
-  todos?: Todo[];
-}
+export interface AgentThreadState extends Record<string, unknown> {
+  title: string;
+  title_provisional?: boolean;
+  messages: Message[];
+  artifacts: string[];
+  todos?: Todo[];
+}
 
 export interface AgentThreadContext extends Record<string, unknown> {
   thread_id: string;
   model_name: string | undefined;
   thinking_enabled: boolean;
+  /** Flash mode: force vLLM/Qwen ``enable_thinking=false`` even without a per-model disable shape. */
+  thinking_force_disabled?: boolean;
   is_plan_mode: boolean;
   subagent_enabled: boolean;
   reasoning_effort?: "minimal" | "low" | "medium" | "high";
@@ -23,15 +25,15 @@ export interface AgentThreadContext extends Record<string, unknown> {
   rag_mode_enabled?: boolean;
   /** Per-request switch for context compression (上下文压缩). Default off. */
   summarization_enabled?: boolean;
-  /** Per-conversation switch for knowledge-base RAG injection (phase 2). */
-  knowledge_rag_enabled?: boolean;
-  /** DeerFlow LLMWiki mapping ids selected for this conversation. */
-  llmwiki_knowledge_base_ids?: string[];
-  /** Assistant knowledge-base ids selected for this conversation. */
-  assistant_knowledge_base_ids?: string[];
-  /** Direct RAG modes handled in the frontend; these requests never enter Lead Agent. */
-  execution_profile?: "single_round_rag" | "multi_round_rag";
-  agent_id?: string;
+  /** Per-conversation switch for knowledge-base RAG injection (phase 2). */
+  knowledge_rag_enabled?: boolean;
+  /** DeerFlow LLMWiki mapping ids selected for this conversation. */
+  llmwiki_knowledge_base_ids?: string[];
+  /** Assistant knowledge-base ids selected for this conversation. */
+  assistant_knowledge_base_ids?: string[];
+  /** Frontend-only execution paths that never enter Lead Agent (RAG / 极速直连). */
+  execution_profile?: "single_round_rag" | "multi_round_rag" | "direct";
+  agent_id?: string;
   /** @deprecated kept for reading legacy thread metadata; prefer agent_id */
   agent_name?: string;
 }

frontend-web/src/core/threads/use-direct-chat.ts

@@ -0,0 +1,312 @@
+import type { Message } from "@langchain/langgraph-sdk";
+import { useCallback, useEffect, useRef, useState } from "react";
+
+import { apiFetch } from "@/core/api/fetch-client";
+import { getBackendBaseURL } from "@/core/config";
+import { readRuntimeFlag } from "@/env";
+import { createClientId } from "@/lib/client-id";
+
+import { textOfMessage } from "./utils";
+
+const STORAGE_PREFIX = "workspace.direct-chat.";
+const MAX_HISTORY_MESSAGES = 20;
+
+export function isDirectChatProfile(context: unknown): boolean {
+  return (
+    typeof context === "object" &&
+    context !== null &&
+    (context as { execution_profile?: unknown }).execution_profile === "direct"
+  );
+}
+
+/** 是否在模式菜单展示「极速」。仅 runtime-config.js 显式为 "true" 时开启，默认关闭。 */
+export function isTurboModeVisible(): boolean {
+  return readRuntimeFlag("VITE_TURBO_MODE_VISIBLE");
+}
+
+function storageKey(threadId: string) {
+  return `${STORAGE_PREFIX}${threadId}`;
+}
+
+function readStoredMessages(threadId: string): Message[] {
+  if (typeof window === "undefined" || !threadId) return [];
+  try {
+    const raw = window.sessionStorage.getItem(storageKey(threadId));
+    const parsed: unknown = raw ? JSON.parse(raw) : [];
+    return Array.isArray(parsed) ? (parsed as Message[]) : [];
+  } catch {
+    return [];
+  }
+}
+
+function writeStoredMessages(threadId: string, messages: Message[]) {
+  if (typeof window === "undefined" || !threadId) return;
+  try {
+    window.sessionStorage.setItem(storageKey(threadId), JSON.stringify(messages));
+  } catch {
+    // Quota errors must never interrupt an already-running answer.
+  }
+}
+
+function isAbortError(error: unknown): boolean {
+  return error instanceof DOMException
+    ? error.name === "AbortError"
+    : error instanceof Error && error.name === "AbortError";
+}
+
+function historyFromMessages(messages: Message[]): Array<{
+  role: "user" | "assistant";
+  content: string;
+}> {
+  const history: Array<{ role: "user" | "assistant"; content: string }> = [];
+  for (const message of messages) {
+    if (message.type !== "human" && message.type !== "ai") continue;
+    const content = textOfMessage(message)?.trim();
+    if (!content) continue;
+    history.push({
+      role: message.type === "human" ? "user" : "assistant",
+      content,
+    });
+  }
+  return history.slice(-MAX_HISTORY_MESSAGES);
+}
+
+function parseSseBlocks(buffer: string): {
+  events: Array<{ event?: string; data: string }>;
+  rest: string;
+} {
+  const parts = buffer.split("\n\n");
+  const rest = parts.pop() ?? "";
+  const events: Array<{ event?: string; data: string }> = [];
+  for (const part of parts) {
+    let event: string | undefined;
+    const dataLines: string[] = [];
+    for (const line of part.split("\n")) {
+      if (line.startsWith(":")) continue;
+      if (line.startsWith("event:")) event = line.slice(6).trim();
+      else if (line.startsWith("data:")) dataLines.push(line.slice(5).trimStart());
+    }
+    if (dataLines.length > 0) {
+      events.push({ event, data: dataLines.join("\n") });
+    }
+  }
+  return { events, rest };
+}
+
+async function readErrorDetail(response: Response): Promise<string> {
+  try {
+    const payload: unknown = await response.json();
+    if (
+      payload &&
+      typeof payload === "object" &&
+      "detail" in payload &&
+      typeof (payload as { detail: unknown }).detail === "string"
+    ) {
+      return (payload as { detail: string }).detail;
+    }
+  } catch {
+    // Fall through to status text.
+  }
+  return `极速问答失败（${response.status}）`;
+}
+
+/**
+ * Frontend-only adapter that talks to Gateway ``POST /api/direct-chat/stream``.
+ * It never submits a LangGraph run or touches the lead-agent stack.
+ */
+export function useDirectChatMessages(threadId: string | undefined) {
+  const [messages, setMessages] = useState<Message[]>(() =>
+    readStoredMessages(threadId ?? ""),
+  );
+  const messagesRef = useRef(messages);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const controllerRef = useRef<AbortController | null>(null);
+
+  useEffect(() => {
+    const stored = readStoredMessages(threadId ?? "");
+    messagesRef.current = stored;
+    setMessages(stored);
+    setError(null);
+  }, [threadId]);
+
+  useEffect(() => {
+    messagesRef.current = messages;
+  }, [messages]);
+
+  useEffect(() => () => controllerRef.current?.abort(), []);
+
+  const updateMessages = useCallback(
+    (targetThreadId: string, updater: (current: Message[]) => Message[]) => {
+      setMessages((current) => {
+        const next = updater(current);
+        messagesRef.current = next;
+        writeStoredMessages(targetThreadId, next);
+        return next;
+      });
+    },
+    [],
+  );
+
+  const stop = useCallback(() => controllerRef.current?.abort(), []);
+
+  const submit = useCallback(
+    async ({
+      targetThreadId,
+      query,
+      modelName,
+    }: {
+      targetThreadId: string;
+      query: string;
+      modelName?: string;
+    }) => {
+      if (isLoading) return;
+      const question = query.trim();
+      if (!question) return;
+
+      const humanId = createClientId("direct-human");
+      const assistantId = createClientId("direct-ai");
+      const clientTs = new Date().toISOString();
+      const history = historyFromMessages(messagesRef.current);
+      const userMessage: Message = {
+        id: humanId,
+        type: "human",
+        content: [{ type: "text", text: question }],
+        additional_kwargs: { client_ts: clientTs, direct_chat: true },
+      };
+      const initialAssistant: Message = {
+        id: assistantId,
+        type: "ai",
+        content: "",
+        additional_kwargs: { direct_chat: true },
+      };
+      updateMessages(targetThreadId, (current) => [
+        ...current,
+        userMessage,
+        initialAssistant,
+      ]);
+      setError(null);
+      setIsLoading(true);
+
+      const controller = new AbortController();
+      controllerRef.current = controller;
+      let answer = "";
+
+      const refreshAssistant = (content: string) => {
+        updateMessages(targetThreadId, (current) =>
+          current.map((item) =>
+            item.id === assistantId
+              ? ({
+                  ...item,
+                  content,
+                  additional_kwargs: {
+                    ...item.additional_kwargs,
+                    direct_chat: true,
+                  },
+                } as Message)
+              : item,
+          ),
+        );
+      };
+
+      try {
+        const response = await apiFetch(
+          `${getBackendBaseURL()}/api/direct-chat/stream`,
+          {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            signal: controller.signal,
+            body: JSON.stringify({
+              model_name: modelName,
+              messages: [...history, { role: "user", content: question }],
+            }),
+          },
+        );
+        if (!response.ok) {
+          throw new Error(await readErrorDetail(response));
+        }
+        if (!response.body) {
+          throw new Error("极速问答未返回数据流。");
+        }
+
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const parsed = parseSseBlocks(buffer);
+          buffer = parsed.rest;
+          for (const block of parsed.events) {
+            let payload: unknown = null;
+            try {
+              payload = JSON.parse(block.data);
+            } catch {
+              continue;
+            }
+            if (block.event === "error") {
+              const detail =
+                payload &&
+                typeof payload === "object" &&
+                "detail" in payload &&
+                typeof (payload as { detail: unknown }).detail === "string"
+                  ? (payload as { detail: string }).detail
+                  : "极速问答失败。";
+              throw new Error(detail);
+            }
+            if (
+              block.event === "delta" &&
+              payload &&
+              typeof payload === "object" &&
+              "text" in payload &&
+              typeof (payload as { text: unknown }).text === "string"
+            ) {
+              answer += (payload as { text: string }).text;
+              refreshAssistant(answer);
+            }
+            if (
+              block.event === "result" &&
+              payload &&
+              typeof payload === "object" &&
+              "answer" in payload &&
+              typeof (payload as { answer: unknown }).answer === "string"
+            ) {
+              answer = (payload as { answer: string }).answer;
+              refreshAssistant(answer);
+            }
+          }
+        }
+        if (!answer) {
+          throw new Error("模型未返回任何文本。");
+        }
+      } catch (caught) {
+        if (!isAbortError(caught)) {
+          const message =
+            caught instanceof Error ? caught.message : "极速问答失败。";
+          setError(message);
+          updateMessages(targetThreadId, (current) =>
+            current.map((item) =>
+              item.id === assistantId
+                ? ({
+                    ...item,
+                    content: answer || message,
+                    additional_kwargs: {
+                      ...item.additional_kwargs,
+                      direct_chat: true,
+                    },
+                  } as Message)
+                : item,
+            ),
+          );
+        }
+      } finally {
+        if (controllerRef.current === controller) controllerRef.current = null;
+        setIsLoading(false);
+      }
+    },
+    [isLoading, updateMessages],
+  );
+
+  return { messages, isLoading, error, submit, stop };
+}

frontend-web/src/eightbf-roundtable/api/task-context.ts

@@ -116,6 +116,14 @@ export interface EightBfTaskProcessReportReceipt {
   id: string;
 }
 
+/**
+ * 外部任务系统要求 8BF 会商页提交的过程产物携带 eightTask=1，
+ * 用于与岗位会商等其它入口的产物区分来源。
+ */
+function processReportBody(input: EightBfTaskProcessReportInput): string {
+  return JSON.stringify({ ...input, eightTask: 1 });
+}
+
 /**
  * 当前 DeerFlow 的外部业务请求适配器沿用任务系统的默认约定：使用
  * `Authorization: Bearer admin`，而不是 DeerFlow 登录接口返回的 token。
@@ -180,7 +188,7 @@ export async function createEightBfTaskProcessReport(
   const response = await fetchExternalTaskSystem(PROCESS_REPORT_ADD_PATH, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(input),
+    body: processReportBody(input),
   });
   if (!response.ok) throw await externalTaskError(response, "过程产物登记失败");
   const id = findProcessReportId(await response.json().catch(() => null));
@@ -198,7 +206,7 @@ export async function updateEightBfTaskProcessReport(
     {
       method: "PUT",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(input),
+      body: processReportBody(input),
     },
   );
   if (!response.ok) throw await externalTaskError(response, "过程产物提交失败");

frontend-web/src/eightbf-roundtable/pages/EightBfRoundtablePage.tsx

@@ -88,14 +88,29 @@ export default function EightBfRoundtablePage({ compactChrome = false }: { compa
     () => buildEightBfTaskContext(task, taskDictionaries),
     [task, taskDictionaries],
   );
+  // 席位「产物提交 position」映射：业务链里逐席位配置的 artifact_position（agent_id → 值）。
+  // 提交产物时按产出该产物的席位智能体取值；未配置的席位不进 map（提交时回退默认 0）。
+  const artifactPositionByAgent = useMemo(() => {
+    const map = new Map<string, number>();
+    for (const seat of configuredChain?.seats ?? []) {
+      if (typeof seat.artifact_position === "number" && Number.isFinite(seat.artifact_position)) {
+        map.set(seat.agent_id, seat.artifact_position);
+      }
+    }
+    return map;
+  }, [configuredChain]);
   const taskArtifactSubmissionConfig = useMemo<TaskArtifactSubmissionConfig | undefined>(
     () => taskId ? {
       taskId,
       position: 0,
+      positionFor: (target) => {
+        const agentId = target.agentId?.trim();
+        return agentId ? artifactPositionByAgent.get(agentId) ?? null : null;
+      },
       createProcessReport: createEightBfTaskProcessReport,
       updateProcessReport: updateEightBfTaskProcessReport,
     } : undefined,
-    [taskId],
+    [taskId, artifactPositionByAgent],
   );
 
   useEffect(() => {

frontend-web/src/open-canvas/pages/AIWritingPage.tsx

@@ -142,7 +142,7 @@ const DRAFT_ID = 'aw-draft';
 const AI_WRITING_AGENT_MODULE_KEY = 'ai-writing';
 const AI_WRITING_AGENT_MODULE_TITLE = 'AI 写作智能体';
 const AI_WRITING_LAST_AGENT_KEY = `agent-module:${AI_WRITING_AGENT_MODULE_KEY}:last-agent`;
-const SHOW_NOTEBOOK_SPACE_ENTRIES = true;
+const SHOW_NOTEBOOK_SPACE_ENTRIES = false;
 
 // Match the original canvas page proportions (chat=35, artifact=65)
 const DEFAULT_LAYOUT = { [WRITING_ID]: 35, [DRAFT_ID]: 65 };

frontend-web/src/pages/AgentChatPage.tsx

@@ -13,6 +13,7 @@ import { useLocation } from "react-router-dom";
 import { useRouteBase } from "@/core/route-base";
 import { useCallback, useEffect, useMemo, useRef, useState, type ReactNode } from "react";
 import { useQuery } from "@tanstack/react-query";
+import { toast } from "sonner";
 
 import type { PromptInputMessage } from "@/components/ai-elements/prompt-input";
 import { Button } from "@/components/ui/button";
@@ -48,6 +49,7 @@ import { useNotification } from "@/core/notification/hooks";
 import { saveLastAgentId, useThreadSettings } from "@/core/settings";
 import { stopActiveThreadBeforeClarificationReply, stopThreadRun, useThreadStream } from "@/core/threads/hooks";
 import { useResearchWritingFeed } from "@/core/threads/use-research-writing-feed";
+import { useDirectChatMessages, isDirectChatProfile, isTurboModeVisible } from "@/core/threads/use-direct-chat";
 import { clearResearchReportStream } from "@/core/threads/use-research-report-stream";
 import { textOfMessage } from "@/core/threads/utils";
 import { resolveWritingModeReportPath } from "@/core/threads/writing-mode";
@@ -560,9 +562,26 @@ export default function AgentChatPage({
     },
   });
 
+  const directChat = useDirectChatMessages(threadId);
+  const directChatSelected =
+    isDirectChatProfile(settings.context) && isTurboModeVisible();
+
   // 写作模式深度研究进度：注入 displayThread 尾部（进度步骤条 + report.md
   // 流式 stub），成功且真实产物落地后自动撤出。
-  const { displayThread } = useResearchWritingFeed(threadId, thread);
+  const { displayThread: researchDisplayThread } = useResearchWritingFeed(threadId, thread);
+  const displayThread = useMemo(() => {
+    const base = researchDisplayThread;
+    if (directChat.messages.length === 0 && !directChat.isLoading) {
+      return base;
+    }
+    const messages = [...base.messages, ...directChat.messages];
+    return {
+      ...base,
+      values: { ...base.values, messages },
+      messages,
+      isLoading: base.isLoading || directChat.isLoading,
+    } as typeof base;
+  }, [directChat.isLoading, directChat.messages, researchDisplayThread]);
 
   // ── agentfx「入库」协助卡 ──────────────────────────────────────────────────
   // 任务工作区（taskBind）里，内置研判智能体写出的 task-reports.json 产物落地且
@@ -743,6 +762,62 @@ export default function AgentChatPage({
 
   const handleSubmit = useCallback(
     (message: PromptInputMessage, extraContext?: Record<string, unknown>) => {
+      if (directChatSelected) {
+        if (message.files && message.files.length > 0) {
+          toast.error("极速问答暂不支持附件，请移除附件后重试。");
+          return;
+        }
+        setHasStartedConversation(true);
+        saveLastAgentId(agent_id);
+        window.dispatchEvent(
+          new CustomEvent("workspace:sandbox-resume-autoscroll"),
+        );
+        void (async () => {
+          try {
+            let targetThreadId = threadId;
+            if (isNewThread) {
+              const created = await getAPIClient().threads.create({
+                metadata: {
+                  agent_id,
+                  ...(Object.keys(conversationMetadata).length > 0
+                    ? conversationMetadata
+                    : {}),
+                },
+              });
+              targetThreadId = created.thread_id;
+              knowledgeSelectionThread.current = targetThreadId;
+              activeThreadIdRef.current = targetThreadId;
+              setThreadId(targetThreadId);
+              setIsNewThread(false);
+              history.replaceState(
+                null,
+                "",
+                `${window.location.pathname}${window.location.search}#${agentChatsBase}/${targetThreadId}`,
+              );
+              const title = message.text.trim().replace(/\s+/g, " ").slice(0, 60);
+              if (title) {
+                void getAPIClient().threads
+                  .updateState(targetThreadId, { values: { title } })
+                  .catch(() => undefined);
+              }
+            }
+            if (!targetThreadId) {
+              toast.error("无法创建会话。");
+              return;
+            }
+            await directChat.submit({
+              targetThreadId,
+              query: message.text,
+              modelName: settings.context.model_name,
+            });
+          } catch (error) {
+            toast.error(
+              error instanceof Error ? error.message : "极速问答失败。",
+            );
+          }
+        })();
+        return;
+      }
       setHasStartedConversation(true);
       // Remember this agent so the new-chat landing screen pre-selects it next
       // time (covers both direct agent chats and the ChatPage handoff replay).
@@ -767,7 +842,7 @@ export default function AgentChatPage({
         ...pageReportThemeContext,
       });
     },
-    [sendMessage, threadId, agent_id, settings.context.writing_mode, writingArtifactPath, baseMode],
+    [sendMessage, threadId, agent_id, settings.context.writing_mode, settings.context.model_name, writingArtifactPath, baseMode, directChat, directChatSelected, isNewThread, conversationMetadata, agentChatsBase, setThreadId, setIsNewThread],
   );
 
   // 任务流程：切换 / 新建会话时，停掉「上一会话服务端在跑」的 run（老对话要停止）。
@@ -852,8 +927,12 @@ export default function AgentChatPage({
   );
 
   const handleStop = useCallback(async () => {
+    if (directChat.isLoading) {
+      directChat.stop();
+      return;
+    }
     await thread.stop();
-  }, [thread]);
+  }, [directChat, thread]);
 
   const isLandingState = isNewThread && !hasStartedConversation;
   // 任务闸门面板：仅 rwfx（taskGate）在新建对话且尚未开始时，于问答页顶部展示目的树 + 覆盖确认。
@@ -867,7 +946,7 @@ export default function AgentChatPage({
 
   const status = thread.error
     ? "error"
-    : thread.isLoading
+    : thread.isLoading || directChat.isLoading
       ? "streaming"
       : "ready";
 
@@ -1084,7 +1163,7 @@ export default function AgentChatPage({
                         autoFocus
                         status={status}
                         context={settings.context}
-                        disabled={isDemoMode || knowledgeSelectionLoading}
+                        disabled={isDemoMode || knowledgeSelectionLoading || directChat.isLoading}
                         onContextChange={(context) =>
                           setSettings("context", context)
                         }
@@ -1104,7 +1183,7 @@ export default function AgentChatPage({
                                 pendingKnowledgeSelection.current === null &&
                                 pendingAssistantKnowledgeSelection.current === null
                               }
-                              disabled={isDemoMode || knowledgeSelectionLoading}
+                              disabled={isDemoMode || knowledgeSelectionLoading || directChat.isLoading}
                               label="知识空间"
                             />
                           )
@@ -1175,7 +1254,7 @@ export default function AgentChatPage({
                         assistantId={agent_id}
                         status={status}
                         context={settings.context}
-                        disabled={isDemoMode || knowledgeSelectionLoading}
+                        disabled={isDemoMode || knowledgeSelectionLoading || directChat.isLoading}
                         onContextChange={(context) =>
                           setSettings("context", context)
                         }
@@ -1190,7 +1269,7 @@ export default function AgentChatPage({
                               assistantValue={selectedAssistantKnowledgeBaseIds}
                               onChange={changeKnowledgeSelection}
                               onAssistantChange={changeAssistantKnowledgeSelection}
-                              disabled={isDemoMode || knowledgeSelectionLoading}
+                              disabled={isDemoMode || knowledgeSelectionLoading || directChat.isLoading}
                               readOnly
                               label="知识空间"
                             />

frontend-web/src/pages/AgentsOrbitPage.tsx

@@ -1,247 +0,0 @@
-import { useEffect, useMemo, useRef, useState } from "react";
-import { Bot } from "lucide-react";
-import { useRouter } from "next/navigation";
-
-import { useAgents } from "@/core/agents";
-import type { Agent } from "@/core/agents";
-import { themeToBaseMode, useTheme } from "@/contexts/ThemeContext";
-
-import "@/styles/agents-orbit.css";
-import "@/styles/agents-orbit-dark.css";
-import "@/styles/agents-orbit-light.css";
-
-/** 转盘旋转过渡时长（ms），与 CSS 中 .ao-type-arm 的 transition 保持一致。 */
-const DIAL_TRANSITION_MS = 850;
-
-/** 一个类型 = 一个标签（取智能体的第一个标签；无标签归入「未分类」）。 */
-interface AgentGroup {
-  id: string;
-  name: string;
-  agents: Agent[];
-}
-
-function groupAgentsByType(agents: Agent[]): AgentGroup[] {
-  const map = new Map<string, AgentGroup>();
-  for (const agent of agents) {
-    const tag = agent.tags?.[0];
-    const id = tag?.id ?? "__uncategorized__";
-    let group = map.get(id);
-    if (!group) {
-      group = { id, name: tag?.name ?? "未分类", agents: [] };
-      map.set(id, group);
-    }
-    group.agents.push(agent);
-  }
-  return Array.from(map.values()).sort((a, b) =>
-    a.name.localeCompare(b.name, "zh-Hans-CN"),
-  );
-}
-
-const mod = (value: number, n: number): number => ((value % n) + n) % n;
-
-/**
- * 密码转盘模型：
- * - n 个类型始终均匀占据右半圆的 n 个固定槽位（间距恒定，不随点击改变）；
- * - 激活槽位固定为最贴近正右侧中间的槽，被点击的类型旋转到该槽；
- * - 点击上半部分 → 转盘顺时针转（k > 0），下半部分 → 逆时针（k < 0）；
- * - 超出半圆端点的标签沿“背面长路”补位（角度 ±360 扫过左半圆，途中半透明），
- *   动画结束后角度归一化回槽位角（同一位置 mod 360，无视觉跳变）。
- */
-export default function AgentsOrbitPage() {
-  const router = useRouter();
-  const { theme } = useTheme();
-  const isDark = themeToBaseMode(theme) === "dark";
-  const { agents, isLoading } = useAgents();
-  const groups = useMemo(() => groupAgentsByType(agents), [agents]);
-
-  const [activeId, setActiveId] = useState<string | null>(null);
-  /** 转盘动画期间的非归一化角度（含 ±360 长路，长路全程在左半圆不可视区内）。 */
-  const [anim, setAnim] = useState<Record<string, number> | null>(null);
-  /** 归一化帧：瞬移到等价角度时禁用过渡。 */
-  const [frozen, setFrozen] = useState(false);
-  const timerRef = useRef<number | null>(null);
-
-  useEffect(() => {
-    return () => {
-      if (timerRef.current != null) window.clearTimeout(timerRef.current);
-    };
-  }, []);
-
-  if (isLoading) {
-    return (
-      <div className={`agents-orbit-page ${isDark ? "ao-dark" : "ao-light"}`}>
-        <div className="ao-state">
-          <div className="ao-spinner" />
-          <span>正在加载智能体…</span>
-        </div>
-      </div>
-    );
-  }
-
-  if (groups.length === 0) {
-    return (
-      <div className={`agents-orbit-page ${isDark ? "ao-dark" : "ao-light"}`}>
-        <div className="ao-state">
-          <span>还没有可展示的智能体</span>
-        </div>
-      </div>
-    );
-  }
-
-  const n = groups.length;
-  const midSlot = Math.floor((n - 1) / 2);
-  const step = 180 / n;
-  /** 槽位 j 的世界角：-90°(正上) → +90°(正下)，均布在右半圆开区间内。 */
-  const slotAngle = (slot: number) => -90 + (slot + 0.5) * step;
-
-  const requestedIdx = activeId
-    ? groups.findIndex((g) => g.id === activeId)
-    : -1;
-  const activeIdx = requestedIdx >= 0 ? requestedIdx : midSlot;
-  const active = groups[activeIdx];
-  /** 静态分组数组的旋转量：group(gi) 落在槽位 (gi + shift) mod n，激活组恰在 midSlot。 */
-  const shift = midSlot - activeIdx;
-  const groupAtSlot = (slot: number) => groups[mod(slot - shift, n)];
-
-  const handleTypeClick = (slot: number) => {
-    const group = groupAtSlot(slot);
-    if (group.id === active.id) return;
-
-    const k = midSlot - slot; // 正=顺时针向下转，负=逆时针向上转
-    const angles: Record<string, number> = {};
-    for (let j = 0; j < n; j++) {
-      const g = groupAtSlot(j);
-      const nextSlot = j + k;
-      let angle = slotAngle(mod(nextSlot, n));
-      if (nextSlot >= n) {
-        angle += 360; // 从底部滑出（进入左半圆不可视区），绕背回顶部补位
-      } else if (nextSlot < 0) {
-        angle -= 360; // 从顶部滑出（进入左半圆不可视区），绕背回底部补位
-      }
-      angles[g.id] = angle;
-    }
-
-    setActiveId(group.id);
-    setAnim(angles);
-    if (timerRef.current != null) window.clearTimeout(timerRef.current);
-    timerRef.current = window.setTimeout(() => {
-      // 动画结束：归一化长路角度（同一位置 mod 360），下一帧恢复过渡。
-      setFrozen(true);
-      setAnim(null);
-      requestAnimationFrame(() =>
-        requestAnimationFrame(() => setFrozen(false)),
-      );
-    }, DIAL_TRANSITION_MS + 60);
-  };
-
-  const handleAgentClick = (agent: Agent) => {
-    router.push(`/page/workspace/agents/${agent.id}/chats/new`);
-  };
-
-  const themeClass = isDark ? "ao-dark" : "ao-light";
-
-  return (
-    <div
-      className={`agents-orbit-page ${themeClass}${n >= 8 ? " ao-crowded" : ""}`}
-    >
-      <div className="ao-header">
-        <span className="ao-header-title">智能体 · 星轨转盘</span>
-        <button
-          type="button"
-          className="ao-header-link"
-          onClick={() => router.push("/page/workspace/agents")}
-        >
-          经典视图
-        </button>
-      </div>
-
-      {/* 左侧星轨舞台：中心圆盘 + 中心图片 + 三层圆环 + 卫星 + 类型转盘 */}
-      <div className="ao-stage">
-        <div className="ao-root">
-          <div className="ao-ring ao-ring--ticks" />
-          <div className="ao-ring ao-ring--dash" />
-          <div className="ao-ring ao-ring--arc" />
-          <div className="ao-sat-orbit">
-            <div className="ao-sat" />
-          </div>
-
-          <div className="ao-core">
-            <div className="ao-core-img">
-              <Bot size={60} strokeWidth={1.4} />
-            </div>
-          </div>
-
-          {/* 转盘容器：左半圆被裁剪为不可视区域，绕背旋转不可见 */}
-          <div className="ao-types">
-            {groups.map((group, gi) => {
-              const slot = mod(gi + shift, n);
-              const angle = anim
-                ? (anim[group.id] ?? slotAngle(slot))
-                : slotAngle(slot);
-              const isActive = group.id === active.id;
-              const transitionStyle = frozen ? { transition: "none" } : {};
-              return (
-                <div
-                  key={group.id}
-                  className="ao-type-arm"
-                  style={{
-                    transform: `rotate(${angle}deg)`,
-                    ...transitionStyle,
-                  }}
-                >
-                  <button
-                    type="button"
-                    className={`ao-type-anchor${isActive ? " is-active" : ""}`}
-                    style={{
-                      transform: `translate(-50%, -50%) rotate(${-angle}deg)`,
-                      ...transitionStyle,
-                    }}
-                    onClick={() => handleTypeClick(slot)}
-                    title={`${group.name} · ${group.agents.length} 个智能体`}
-                  >
-                    <span
-                      className="ao-type-chip"
-                      style={{ animationDelay: `${-gi * 0.8}s` }}
-                    >
-                      {group.name}
-                    </span>
-                  </button>
-                </div>
-              );
-            })}
-          </div>
-        </div>
-      </div>
-
-      {/* 右侧面板：当前类型下的智能体（圆角正方形图标 + 名称），与舞台 1:1 */}
-      <aside className="ao-panel">
-        <div className="ao-panel-head">
-          <div className="ao-panel-title">{active.name}</div>
-          <div className="ao-panel-sub">共 {active.agents.length} 个智能体</div>
-        </div>
-        {active.agents.length > 0 ? (
-          <div className="ao-agents" key={active.id}>
-            {active.agents.map((agent) => (
-              <button
-                key={agent.id}
-                type="button"
-                className="ao-agent"
-                onClick={() => handleAgentClick(agent)}
-                title={agent.description || agent.name}
-              >
-                <span className="ao-agent-icon">
-                  {(agent.name || "?").trim().charAt(0).toUpperCase()}
-                </span>
-                <span className="ao-agent-name">{agent.name}</span>
-              </button>
-            ))}
-          </div>
-        ) : (
-          <div className="ao-state">
-            <span>该类型下暂时没有智能体</span>
-          </div>
-        )}
-      </aside>
-    </div>
-  );
-}

frontend-web/src/pages/ChatPage.tsx

@@ -64,11 +64,16 @@ import {
   useThreadSettings,
 } from "@/core/settings";
 import { useThreadStream, stopActiveThreadBeforeClarificationReply } from "@/core/threads/hooks";
+import {
+  myProjectConversationTypeFromSearchParams,
+  myProjectThreadMetadata,
+} from "@/core/threads/project-metadata";
 import { useResearchWritingFeed } from "@/core/threads/use-research-writing-feed";
 import { clearResearchReportStream } from "@/core/threads/use-research-report-stream";
 import { resolveWritingModeReportPath } from "@/core/threads/writing-mode";
 import { queueLlmWikiConversationDeposit } from "@/core/llmwiki/conversation-deposit";
 import { useSingleRoundRagMessages } from "@/core/threads/use-single-round-rag";
+import { useDirectChatMessages, isDirectChatProfile, isTurboModeVisible } from "@/core/threads/use-direct-chat";
 import { useMultiRoundRagMessages, mergeMessagesByTime, toLangGraphMessages } from "@/core/threads/use-multi-round-rag";
 import { useLayoutMode } from "@/core/system-settings/hooks";
 import { useRouteBase } from "@/core/route-base";
@@ -285,16 +290,28 @@ export default function ChatPage() {
   }, [selectedAgentId, selectorAgents, mineAgents, squareAgents, selectorLoading]);
 
   const { showNotification } = useNotification();
+  const projectConversationType =
+    myProjectConversationTypeFromSearchParams(searchParams);
+  const newThreadMetadata = useMemo<Record<string, unknown> | undefined>(() => {
+    const metadata: Record<string, unknown> = projectConversationType
+      ? myProjectThreadMetadata(projectConversationType)
+      : {};
+    if (knowledgeSelectionReady) {
+      metadata.llmwiki_knowledge_base_ids = selectedKnowledgeBaseIds;
+      metadata.assistant_knowledge_base_ids = selectedAssistantKnowledgeBaseIds;
+    }
+    return Object.keys(metadata).length > 0 ? metadata : undefined;
+  }, [
+    knowledgeSelectionReady,
+    projectConversationType,
+    selectedAssistantKnowledgeBaseIds,
+    selectedKnowledgeBaseIds,
+  ]);
 
   const [thread, sendMessage, isUploading] = useThreadStream({
     threadId: isNewThread ? undefined : threadId,
     context: streamContext,
-    threadMetadata: knowledgeSelectionReady
-      ? {
-          llmwiki_knowledge_base_ids: selectedKnowledgeBaseIds,
-          assistant_knowledge_base_ids: selectedAssistantKnowledgeBaseIds,
-        }
-      : undefined,
+    threadMetadata: newThreadMetadata,
     isMock,
     onStart: (createdThreadId) => {
       knowledgeSelectionThread.current = createdThreadId;
@@ -348,9 +365,12 @@ export default function ChatPage() {
   });
   const singleRoundRag = useSingleRoundRagMessages(threadId);
   const multiRoundRag = useMultiRoundRagMessages(threadId);
+  const directChat = useDirectChatMessages(threadId);
   const singleRoundRagSelected = isSingleRoundRagProfile(settings.context);
   const multiRoundRagSelected = isMultiRoundRagProfile(settings.context);
   const frontendRagSelected = isFrontendRagProfile(settings.context);
+  const directChatSelected =
+    isDirectChatProfile(settings.context) && isTurboModeVisible();
   // 写作模式深度研究进度：注入 displayThread 尾部（进度步骤条 + report.md
   // 流式 stub），成功且真实产物落地后自动撤出。
   const { displayThread: researchDisplayThread } = useResearchWritingFeed(threadId, thread);
@@ -360,13 +380,15 @@ export default function ChatPage() {
     if (
       singleRoundRag.messages.length === 0 &&
       ragMessages.length === 0 &&
+      directChat.messages.length === 0 &&
       !singleRoundRag.isLoading &&
-      !multiRoundRag.isLoading
+      !multiRoundRag.isLoading &&
+      !directChat.isLoading
     ) {
       return base;
     }
     const messages = mergeMessagesByTime(
-      [...base.messages, ...singleRoundRag.messages],
+      [...base.messages, ...singleRoundRag.messages, ...directChat.messages],
       ragMessages,
     );
     return {
@@ -374,9 +396,14 @@ export default function ChatPage() {
       values: { ...base.values, messages },
       messages,
       isLoading:
-        base.isLoading || singleRoundRag.isLoading || multiRoundRag.isLoading,
+        base.isLoading ||
+        singleRoundRag.isLoading ||
+        multiRoundRag.isLoading ||
+        directChat.isLoading,
     } as typeof base;
   }, [
+    directChat.isLoading,
+    directChat.messages,
     multiRoundRag.isLoading,
     multiRoundRag.messages,
     researchDisplayThread,
@@ -392,6 +419,52 @@ export default function ChatPage() {
 
   const handleSubmit = useCallback(
     (message: PromptInputMessage) => {
+      if (directChatSelected) {
+        if (message.files && message.files.length > 0) {
+          toast.error("极速问答暂不支持附件，请移除附件后重试。");
+          return;
+        }
+        setHasStartedConversation(true);
+        window.dispatchEvent(
+          new CustomEvent("workspace:sandbox-resume-autoscroll"),
+        );
+        void (async () => {
+          try {
+            let targetThreadId = threadId;
+            if (isNewThread) {
+              const created = await getAPIClient(isMock).threads.create({});
+              targetThreadId = created.thread_id;
+              setThreadId(targetThreadId);
+              setIsNewThread(false);
+              history.replaceState(
+                null,
+                "",
+                `${window.location.pathname}${window.location.search}#${routeBase}/chats/${targetThreadId}`,
+              );
+              const title = message.text.trim().replace(/\s+/g, " ").slice(0, 60);
+              if (title) {
+                void getAPIClient(isMock).threads
+                  .updateState(targetThreadId, { values: { title } })
+                  .catch(() => undefined);
+              }
+            }
+            if (!targetThreadId) {
+              toast.error("无法创建会话。");
+              return;
+            }
+            await directChat.submit({
+              targetThreadId,
+              query: message.text,
+              modelName: settings.context.model_name,
+            });
+          } catch (error) {
+            toast.error(
+              error instanceof Error ? error.message : "极速问答失败。",
+            );
+          }
+        })();
+        return;
+      }
       if (frontendRagSelected) {
         if (message.files && message.files.length > 0) {
           toast.error("RAG 问答暂不支持附件，请移除附件后重试。");
@@ -405,7 +478,9 @@ export default function ChatPage() {
           try {
             let targetThreadId = threadId;
             if (isNewThread) {
-              const created = await getAPIClient(isMock).threads.create({});
+              const created = await getAPIClient(isMock).threads.create({
+                metadata: newThreadMetadata ?? {},
+              });
               targetThreadId = created.thread_id;
               setThreadId(targetThreadId);
               setIsNewThread(false);
@@ -465,13 +540,8 @@ export default function ChatPage() {
           try {
             const created = await getAPIClient(isMock).threads.create({
               metadata: {
+                ...newThreadMetadata,
                 agent_id: selectedAgentId,
-                ...(knowledgeSelectionReady
-                  ? {
-                      llmwiki_knowledge_base_ids: selectedKnowledgeBaseIds,
-                      assistant_knowledge_base_ids: selectedAssistantKnowledgeBaseIds,
-                    }
-                  : {}),
               },
             });
             sessionStorage.setItem(
@@ -490,7 +560,7 @@ export default function ChatPage() {
             );
             saveLastAgentId(selectedAgentId);
             router.push(
-              `/page/workspace/agents/${selectedAgentId}/chats/${created.thread_id}`,
+              `${routeBase}/agents/${encodeURIComponent(selectedAgentId)}/chats/${encodeURIComponent(created.thread_id)}`,
             );
           } catch (err) {
             agentHandoffPendingRef.current = false;
@@ -549,6 +619,7 @@ export default function ChatPage() {
       selectedAssistantKnowledgeBaseIds,
       selectedKnowledgeBaseIds,
       knowledgeSelectionReady,
+      newThreadMetadata,
       agentHandoffPending,
       isMock,
       router,
@@ -560,6 +631,8 @@ export default function ChatPage() {
       multiRoundRag,
       multiRoundRagSelected,
       frontendRagSelected,
+      directChat,
+      directChatSelected,
       routeBase,
       setIsNewThread,
       setThreadId,
@@ -655,6 +728,10 @@ export default function ChatPage() {
     saveLastAgentId(agentId);
   }, []);
   const handleStop = useCallback(async () => {
+    if (directChat.isLoading) {
+      directChat.stop();
+      return;
+    }
     if (singleRoundRag.isLoading) {
       singleRoundRag.stop();
       return;
@@ -664,7 +741,7 @@ export default function ChatPage() {
       return;
     }
     await thread.stop();
-  }, [multiRoundRag, singleRoundRag, thread]);
+  }, [directChat, multiRoundRag, singleRoundRag, thread]);
 
   const promptPrefixProp = useMemo(() => {
     if (!promptPrefixSettings?.enabled) return undefined;
@@ -914,7 +991,8 @@ export default function ChatPage() {
                         agentHandoffPending ||
                         knowledgeSelectionLoading ||
                         singleRoundRag.isLoading ||
-                        multiRoundRag.isLoading
+                        multiRoundRag.isLoading ||
+                        directChat.isLoading
                       }
                       onContextChange={(context) =>
                         setSettings("context", context)

frontend-web/src/pages/OfficialDeerFlowEntry.tsx

@@ -5,10 +5,9 @@ import {
   ChevronDown,
   CircleHelp,
   Clock3,
-  GitBranch,
+  FolderKanban,
   LoaderCircle,
   MessageSquareText,
-  Network,
   PanelLeftClose,
   Pause,
   Play,
@@ -22,7 +21,12 @@ import {
 } from "lucide-react";
 import { type FormEvent, useCallback, useMemo, useState } from "react";
 import { useLocation, useNavigate } from "react-router-dom";
+import { Toaster } from "sonner";
 
+import {
+  MyProjectThreadBadge,
+  MyProjectThreadIcon,
+} from "@/components/workspace/my-project-thread-indicator";
 import { useAgent, useAgents } from "@/core/agents";
 import { getAccountDisplayName } from "@/core/auth";
 import {
@@ -31,36 +35,33 @@ import {
   useScheduledTaskRuns,
   useScheduledTasks,
 } from "@/core/scheduled-tasks";
-import { useLocalSettings } from "@/core/settings";
 import {
   useAppearanceSettings,
   useCitationDisplaySettings,
 } from "@/core/system-settings/hooks";
 import { useThreadStream, useThreads } from "@/core/threads/hooks";
+import {
+  myProjectConversationTypeOfThread,
+  myProjectConversationTypeFromSearchParams,
+  myProjectThreadMetadata,
+} from "@/core/threads/project-metadata";
 import { textOfMessage, titleOfThread } from "@/core/threads/utils";
 import { uuid } from "@/core/utils/uuid";
 import {
   OFFICIAL_DEERFLOW_HOME_ROUTE,
   OFFICIAL_DEERFLOW_ROUTE_PREFIX,
 } from "@/core/official-deerflow/routes";
-import { Toaster } from "@/components/ui/sonner";
-
-import MultiAgentTasksPage from "./official-multi-agent-tasks/MultiAgentTasksPage";
-import TaskEditPage from "./official-multi-agent-tasks/TaskEditPage";
-import TaskAnalysisPage from "./official-task-analysis/TaskAnalysisPage";
-import TaskAnalysisDetailPage from "./official-task-analysis/TaskAnalysisDetailPage";
+import StrategyProjectsPage from "@/strategy-selection/StrategyProjectsPage";
+import StrategySelectionPage from "@/strategy-selection/StrategySelectionPage";
 
 import "./official-deerflow-entry.css";
 
 type OfficialPage =
   | "chat"
+  | "projects"
   | "agents"
   | "agent-chat"
   | "scheduled"
-  | "multi-agent-tasks"
-  | "multi-agent-edit"
-  | "task-analysis"
-  | "task-analysis-detail"
   | "settings";
 
 function pageFromPath(pathname: string): OfficialPage {
@@ -68,15 +69,9 @@ function pageFromPath(pathname: string): OfficialPage {
   if (path.startsWith("/workspace/agents/") && path.includes("/chats")) {
     return "agent-chat";
   }
+  if (path.startsWith("/workspace/projects")) return "projects";
   if (path.startsWith("/workspace/agents")) return "agents";
   if (path.startsWith("/workspace/scheduled-tasks")) return "scheduled";
-  if (path.startsWith("/workspace/multi-agent-tasks/new")) return "multi-agent-edit";
-  if (/^\/workspace\/multi-agent-tasks\/[^/]+\/edit$/.test(path)) {
-    return "multi-agent-edit";
-  }
-  if (path.startsWith("/workspace/multi-agent-tasks")) return "multi-agent-tasks";
-  if (/^\/workspace\/task-analysis\/[^/]+/.test(path)) return "task-analysis-detail";
-  if (path.startsWith("/workspace/task-analysis")) return "task-analysis";
   if (path.startsWith("/workspace/settings")) return "settings";
   return "chat";
 }
@@ -102,33 +97,11 @@ function parseScheduledTaskId(pathname: string) {
   return match ? decodeURIComponent(match[1]!) : null;
 }
 
-function parseMultiAgentTaskId(pathname: string) {
-  const match = pathname.match(/\/workspace\/multi-agent-tasks\/([^/]+)/);
-  const raw = match ? decodeURIComponent(match[1]!) : null;
-  // 编辑页路由（new / :id/edit）不是任务详情，不驱动列表页的抽屉。
-  if (!raw || raw === "new") return null;
-  return raw;
-}
-
-function parseTaskAnalysisId(pathname: string) {
-  const match = pathname.match(/\/workspace\/task-analysis\/([^/]+)/);
+function parseProjectId(pathname: string) {
+  const match = pathname.match(/\/workspace\/projects\/([^/]+)/);
   return match ? decodeURIComponent(match[1]!) : null;
 }
 
-function parseMultiAgentEditTarget(pathname: string): {
-  mode: "create" | "edit";
-  taskId: string | null;
-} {
-  const path = pathname.slice(OFFICIAL_DEERFLOW_ROUTE_PREFIX.length);
-  if (path.startsWith("/workspace/multi-agent-tasks/new")) {
-    return { mode: "create", taskId: null };
-  }
-  const match = path.match(/^\/workspace\/multi-agent-tasks\/([^/]+)\/edit$/);
-  return match
-    ? { mode: "edit", taskId: decodeURIComponent(match[1]!) }
-    : { mode: "create", taskId: null };
-}
-
 function readableError(error: unknown, fallback: string) {
   return error instanceof Error && error.message ? error.message : fallback;
 }
@@ -210,20 +183,36 @@ function ChatWorkspace({
   routeThreadId: string;
 }) {
   const navigate = useNavigate();
+  const location = useLocation();
   const [prompt, setPrompt] = useState("");
   const [sendError, setSendError] = useState<string | null>(null);
   const isNewThread = routeThreadId === "new";
+  const projectConversationType = isNewThread
+    ? myProjectConversationTypeFromSearchParams(
+        new URLSearchParams(location.search),
+      )
+    : null;
   // A new conversation uses the same client-generated id approach as the
   // existing ChatPage. The backend owns the persisted id once streaming starts.
   const [draftThreadId] = useState<string>(() => uuid() as string);
   const activeThreadId = isNewThread ? draftThreadId : routeThreadId;
   const { agent } = useAgent(agentId, { enabled: !!agentId });
-  const [localSettings] = useLocalSettings();
   const [thread, sendMessage, isUploading] = useThreadStream({
     threadId: isNewThread ? undefined : routeThreadId,
     assistantId: agentId ?? undefined,
+    threadMetadata: projectConversationType
+      ? myProjectThreadMetadata(projectConversationType)
+      : undefined,
     context: {
-      ...localSettings.context,
+      // This compact official shell has no model/mode controls of its own.
+      // Do not inherit a hidden selection saved by the customized workspace
+      // (for example an obsolete or quota-exhausted model); an omitted model
+      // lets the backend resolve the current system default or the agent's
+      // globally configured model.
+      model_name: undefined,
+      mode: undefined,
+      reasoning_effort: undefined,
+      writing_mode: false,
       ...(agentId ? { agent_id: agentId } : {}),
     },
     onStart: (createdThreadId) => {
@@ -709,16 +698,8 @@ export default function OfficialDeerFlowEntry() {
     () => parseScheduledTaskId(location.pathname),
     [location.pathname],
   );
-  const multiAgentTaskId = useMemo(
-    () => parseMultiAgentTaskId(location.pathname),
-    [location.pathname],
-  );
-  const multiAgentEditTarget = useMemo(
-    () => parseMultiAgentEditTarget(location.pathname),
-    [location.pathname],
-  );
-  const taskAnalysisId = useMemo(
-    () => parseTaskAnalysisId(location.pathname),
+  const projectId = useMemo(
+    () => parseProjectId(location.pathname),
     [location.pathname],
   );
   const { data: threads = [], isLoading: threadsLoading, error: threadsError } =
@@ -729,14 +710,14 @@ export default function OfficialDeerFlowEntry() {
       select: ["thread_id", "updated_at", "values", "metadata"],
     });
   const go = (path: string) => navigate(path);
+  const projectBasePath = `${OFFICIAL_DEERFLOW_ROUTE_PREFIX}/workspace/projects`;
 
   const nav = [
     { icon: PlusSquare, label: "新对话", path: OFFICIAL_DEERFLOW_HOME_ROUTE, pages: ["chat"] },
     { icon: MessageSquareText, label: "对话", path: `${OFFICIAL_DEERFLOW_ROUTE_PREFIX}/workspace/chats/new`, pages: ["chat"] },
+    { icon: FolderKanban, label: "我的项目", path: projectBasePath, pages: ["projects"] },
     { icon: Bot, label: "智能体", path: `${OFFICIAL_DEERFLOW_ROUTE_PREFIX}/workspace/agents`, pages: ["agents", "agent-chat"] },
     { icon: CalendarClock, label: "定时任务", path: `${OFFICIAL_DEERFLOW_ROUTE_PREFIX}/workspace/scheduled-tasks`, pages: ["scheduled"] },
-    { icon: Network, label: "多智能体定时任务", path: `${OFFICIAL_DEERFLOW_ROUTE_PREFIX}/workspace/multi-agent-tasks`, pages: ["multi-agent-tasks", "multi-agent-edit"] },
-    { icon: GitBranch, label: "任务分析定时", path: `${OFFICIAL_DEERFLOW_ROUTE_PREFIX}/workspace/task-analysis`, pages: ["task-analysis", "task-analysis-detail"] },
   ] as const;
 
   return (
@@ -771,29 +752,43 @@ export default function OfficialDeerFlowEntry() {
           ) : threadsError ? (
             <p className="official-sidebar-error">对话列表加载失败</p>
           ) : threads.length ? (
-            threads.map((chat) => (
-              <button
-                className={`official-recent-chat${chatRoute.threadId === chat.thread_id ? " is-active" : ""}`}
-                key={chat.thread_id}
-                onClick={() => {
-                  const agentId = typeof chat.context?.agent_id === "string"
-                    ? chat.context.agent_id
-                    : typeof chat.metadata?.agent_id === "string"
-                      ? chat.metadata.agent_id
-                      : null;
-                  go(
-                    agentId
-                      ? `${OFFICIAL_DEERFLOW_ROUTE_PREFIX}/workspace/agents/${encodeURIComponent(agentId)}/chats/${encodeURIComponent(chat.thread_id)}`
-                      : `${OFFICIAL_DEERFLOW_ROUTE_PREFIX}/workspace/chats/${encodeURIComponent(chat.thread_id)}`,
-                  );
-                }}
-                type="button"
-              >
-                <MessageSquareText aria-hidden="true" size={15} />
-                <span>{titleOfThread(chat, "未命名对话")}</span>
-                <small>{formatTimestamp(chat.updated_at)}</small>
-              </button>
-            ))
+            threads.map((chat) => {
+              const projectType = myProjectConversationTypeOfThread(chat);
+              return (
+                <button
+                  className={`official-recent-chat${chatRoute.threadId === chat.thread_id ? " is-active" : ""}`}
+                  key={chat.thread_id}
+                  onClick={() => {
+                    const agentId = typeof chat.context?.agent_id === "string"
+                      ? chat.context.agent_id
+                      : typeof chat.metadata?.agent_id === "string"
+                        ? chat.metadata.agent_id
+                        : null;
+                    go(
+                      agentId
+                        ? `${OFFICIAL_DEERFLOW_ROUTE_PREFIX}/workspace/agents/${encodeURIComponent(agentId)}/chats/${encodeURIComponent(chat.thread_id)}`
+                        : `${OFFICIAL_DEERFLOW_ROUTE_PREFIX}/workspace/chats/${encodeURIComponent(chat.thread_id)}`,
+                    );
+                  }}
+                  type="button"
+                >
+                  {projectType ? (
+                    <MyProjectThreadIcon className="size-[15px]" type={projectType} />
+                  ) : (
+                    <MessageSquareText aria-hidden="true" size={15} />
+                  )}
+                  <span className="official-recent-chat-copy">
+                    <span className="official-recent-chat-title">
+                      {titleOfThread(chat, "未命名对话")}
+                    </span>
+                    {projectType && (
+                      <MyProjectThreadBadge type={projectType} />
+                    )}
+                  </span>
+                  <small>{formatTimestamp(chat.updated_at)}</small>
+                </button>
+              );
+            })
           ) : (
             <p className="official-sidebar-empty">暂无历史对话</p>
           )}
@@ -819,6 +814,17 @@ export default function OfficialDeerFlowEntry() {
             routeThreadId={chatRoute.threadId}
           />
         )}
+        {page === "projects" && (
+          projectId ? (
+            <StrategySelectionPage
+              key={projectId}
+              projectBasePath={projectBasePath}
+              projectId={projectId}
+            />
+          ) : (
+            <StrategyProjectsPage basePath={projectBasePath} />
+          )
+        )}
         {page === "agents" && (
           <AgentsPage
             openAgent={(agentId) =>
@@ -834,20 +840,6 @@ export default function OfficialDeerFlowEntry() {
           />
         )}
         {page === "scheduled" && <ScheduledTasksPage selectedTaskId={scheduledTaskId} />}
-        {page === "multi-agent-tasks" && (
-          <MultiAgentTasksPage routeTaskId={multiAgentTaskId} />
-        )}
-        {page === "multi-agent-edit" && (
-          <TaskEditPage
-            key={multiAgentEditTarget.taskId ?? "create"}
-            mode={multiAgentEditTarget.mode}
-            taskId={multiAgentEditTarget.taskId}
-          />
-        )}
-        {page === "task-analysis" && <TaskAnalysisPage />}
-        {page === "task-analysis-detail" && (
-          <TaskAnalysisDetailPage routeTaskId={taskAnalysisId} />
-        )}
         {page === "settings" && <SettingsPage />}
       </div>
       <Toaster position="top-center" />

frontend-web/src/pages/StrategyRoutes.tsx

@@ -1,4 +1,4 @@
-import { Navigate, Route, Routes } from "react-router-dom";
+import { Navigate, Route, Routes, useParams } from "react-router-dom";
 import { Toaster } from "sonner";
 
 import { SidebarInset, SidebarProvider } from "@/components/ui/sidebar";
@@ -78,6 +78,8 @@ import UsersPage from "./UsersPage";
 import LlmMetricsPage from "./LlmMetricsPage";
 import AdminScheduledTasksPage from "./AdminScheduledTasksPage";
 import AdminUserActivityPage from "./AdminUserActivityPage";
+import StrategyProjectsPage from "@/strategy-selection/StrategyProjectsPage";
+import StrategySelectionPage from "@/strategy-selection/StrategySelectionPage";
 import { ChatRuntime } from "./WorkspaceRoutes";
 
 /**
@@ -98,6 +100,11 @@ function StrategyChatThreadLayout() {
   );
 }
 
+function StrategyProjectWorkbenchRoute() {
+  const { project_id: projectId = "" } = useParams<{ project_id: string }>();
+  return <StrategySelectionPage key={projectId} projectId={projectId} />;
+}
+
 export default function StrategyRoutes() {
   const storedAuth = getStoredAuth();
   const canManageBusinessMappings = !storedAuth || storedAuth.system_role === "admin";
@@ -110,6 +117,20 @@ export default function StrategyRoutes() {
             <Route index element={<Navigate to="qa/general" replace />} />
 
             <Route path="qa/general" element={<GeneralQA />} />
+            <Route
+              path="qa/projects"
+              element={
+                <StrategyProjectsPage basePath="/page/strategy/qa/projects" />
+              }
+            />
+            <Route
+              path="qa/projects/:project_id"
+              element={<StrategyProjectWorkbenchRoute />}
+            />
+            <Route
+              path="qa/strategy-selection"
+              element={<Navigate to="/page/strategy/qa/projects" replace />}
+            />
             <Route
               path="qa/expert-qa"
               element={

frontend-web/src/pages/WorkspaceRoutes.tsx

@@ -39,7 +39,6 @@ import ChatPage from "./ChatPage";
 import ArtifactLibraryPage from "./ArtifactLibraryPage";
 import IframeChatPage from "./IframeChatPage";
 import AgentsPage from "./AgentsPage";
-import AgentsOrbitPage from "./AgentsOrbitPage";
 import AgentChatPage from "./AgentChatPage";
 import SentimentAgentChatPage from "./SentimentAgentChatPage";
 import NewAgentPage from "./NewAgentPage";
@@ -621,16 +620,6 @@ export default function WorkspaceRoutes({
             </WorkspaceLayout>
           }
         />
-        {/* 智能体星轨视图：/agents 的另一种展示形式（手写 CSS 圆环星轨布局）。
-            字面量路由，置于 agents/:agent_id/* 参数路由之前。 */}
-        <Route
-          path="agents/orbit"
-          element={
-            <WorkspaceLayout {...layoutProps}>
-              <AgentsOrbitPage />
-            </WorkspaceLayout>
-          }
-        />
         {/* 舆情分析虚拟智能体：静态段优先于 :agent_id 命中，走 Gateway 转发
             外部 AG-UI 网关的专用对话页（不在后端 /api/agents 落库）。 */}
         <Route

frontend-web/src/pages/official-deerflow-entry.css

@@ -64,6 +64,8 @@
 .official-recent-section > p { color: #90908e; font-size: 12px; margin: 0 8px 9px; }
 .official-recent-chat { display: grid; font-size: 13px; gap: 8px; grid-template-columns: 15px minmax(0, 1fr) auto; padding: 8px; }
 .official-recent-chat span { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.official-recent-chat-copy { align-items: center; display: flex; gap: 6px; min-width: 0; }
+.official-recent-chat-title { flex: 1; min-width: 0; }
 .official-recent-chat small { color: #acaca9; font-size: 11px; }
 .official-recent-chat.is-active { background: #efefed; color: #252525; }
 .official-sidebar-loading,

frontend-web/src/pages/official-multi-agent-tasks/MultiAgentTasksPage.tsx

@@ -1,584 +0,0 @@
-import {
-  CalendarClock,
-  CircleAlert,
-  CircleCheck,
-  Clock3,
-  History,
-  LoaderCircle,
-  Network,
-  Pencil,
-  Pause,
-  Play,
-  Plus,
-  Search,
-  Trash2,
-  Zap,
-} from "lucide-react";
-import { useCallback, useMemo, useState } from "react";
-import { useNavigate } from "react-router-dom";
-import { Button, DialogPlugin, Drawer, Input, Popconfirm, Switch, Tabs, Tag } from "tdesign-react";
-import { toast } from "sonner";
-
-import { OFFICIAL_DEERFLOW_ROUTE_PREFIX } from "@/core/official-deerflow/routes";
-
-import AgentFlow from "./components/AgentFlow";
-import { useMultiAgentTaskActions, useMultiAgentTasks } from "./store";
-import type { MatRunView, MatTaskView } from "./types";
-import {
-  describeCron,
-  expandStages,
-  formatDateTime,
-  formatDuration,
-  formatRelative,
-  runStatusLabel,
-  taskBadgeOf,
-} from "./utils";
-import "./multi-agent-tasks.css";
-
-type StatusFilter = "all" | "running" | "enabled" | "paused";
-
-function isTaskLive(task: MatTaskView) {
-  return task.lastRun?.status === "running" || task.lastRun?.status === "pending";
-}
-
-function matchFilter(task: MatTaskView, filter: StatusFilter) {
-  if (filter === "all") return true;
-  if (filter === "running") return isTaskLive(task);
-  if (filter === "paused") return !task.enabled;
-  return task.enabled && !isTaskLive(task);
-}
-
-function runTagTheme(status: MatRunView["status"]): "success" | "danger" | "warning" | "default" {
-  if (status === "succeeded") return "success";
-  if (status === "failed") return "danger";
-  if (status === "running") return "warning";
-  return "default";
-}
-
-export default function MultiAgentTasksPage({
-  routeTaskId,
-}: {
-  routeTaskId: string | null;
-}) {
-  const navigate = useNavigate();
-  const { tasks, isLoading } = useMultiAgentTasks();
-  const actions = useMultiAgentTaskActions();
-  const [search, setSearch] = useState("");
-  const [filter, setFilter] = useState<StatusFilter>("all");
-  const [busyTaskId, setBusyTaskId] = useState<string | null>(null);
-  const [activeRunId, setActiveRunId] = useState<string | null>(null);
-
-  const selectedTask = tasks.find((task) => task.id === routeTaskId) ?? null;
-
-  const openTask = useCallback(
-    (taskId: string) => {
-      setActiveRunId(null);
-      navigate(
-        `${OFFICIAL_DEERFLOW_ROUTE_PREFIX}/workspace/multi-agent-tasks/${encodeURIComponent(taskId)}`,
-      );
-    },
-    [navigate],
-  );
-
-  const closeTask = useCallback(() => {
-    setActiveRunId(null);
-    navigate(`${OFFICIAL_DEERFLOW_ROUTE_PREFIX}/workspace/multi-agent-tasks`);
-  }, [navigate]);
-
-  const visibleTasks = useMemo(() => {
-    const keyword = search.trim().toLowerCase();
-    return tasks.filter((task) => {
-      if (!matchFilter(task, filter)) return false;
-      if (!keyword) return true;
-      return (
-        task.name.toLowerCase().includes(keyword) ||
-        (task.description ?? "").toLowerCase().includes(keyword) ||
-        task.seats.some((seat) => seat.name.toLowerCase().includes(keyword))
-      );
-    });
-  }, [tasks, search, filter]);
-
-  const stats = useMemo(() => {
-    const total = tasks.length;
-    const enabled = tasks.filter((task) => task.enabled).length;
-    const running = tasks.filter(isTaskLive).length;
-    const runTotal = tasks.reduce((sum, task) => sum + task.runs.length, 0);
-    return { total, enabled, running, runTotal };
-  }, [tasks]);
-
-  const openCreate = () => {
-    navigate(`${OFFICIAL_DEERFLOW_ROUTE_PREFIX}/workspace/multi-agent-tasks/new`);
-  };
-
-  const openEdit = (task: MatTaskView) => {
-    navigate(
-      `${OFFICIAL_DEERFLOW_ROUTE_PREFIX}/workspace/multi-agent-tasks/${encodeURIComponent(task.id)}/edit`,
-    );
-  };
-
-  const runTrigger = async (task: MatTaskView) => {
-    setBusyTaskId(task.id);
-    try {
-      await actions.trigger.mutateAsync(task.id);
-      setActiveRunId(null);
-      openTask(task.id);
-      toast.success("已触发执行");
-    } catch {
-      toast.error("触发失败，请重试");
-    } finally {
-      setBusyTaskId(null);
-    }
-  };
-
-  const runToggle = async (task: MatTaskView) => {
-    setBusyTaskId(task.id);
-    try {
-      await actions.setEnabled.mutateAsync({ id: task.id, enabled: !task.enabled });
-      toast.success(task.enabled ? "任务已暂停" : "任务已恢复");
-    } catch {
-      toast.error("操作失败，请重试");
-    } finally {
-      setBusyTaskId(null);
-    }
-  };
-
-  const confirmDelete = (task: MatTaskView) => {
-    const dialog = DialogPlugin.confirm({
-      header: "删除定时任务",
-      body: `确定删除「${task.name}」吗？其编排配置与运行记录将一并清除，且不可恢复。`,
-      confirmBtn: { content: "删除", theme: "danger" },
-      cancelBtn: "取消",
-      onConfirm: () => {
-        dialog.destroy();
-        void actions.remove.mutateAsync(task.id).then(() => {
-          if (selectedTask?.id === task.id) closeTask();
-          toast.success("任务已删除");
-        });
-      },
-      onClose: () => dialog.destroy(),
-    });
-  };
-
-  const selectedStages = selectedTask ? expandStages(selectedTask) : [];
-  const selectedRuns = selectedTask?.runs ?? [];
-  const activeRun =
-    selectedRuns.find((run) => run.id === activeRunId) ?? selectedRuns[0] ?? null;
-
-  return (
-    <section className="mat-page">
-      <header className="mat-page-head">
-        <div className="mat-page-head-copy">
-          <h1>多智能体定时任务</h1>
-          <p>
-            把多个智能体编排成协作编队：同阶段并行、阶段间串行，按计划自动执行并沉淀运行记录。
-          </p>
-        </div>
-        <Button theme="primary" onClick={openCreate}>
-          <Plus aria-hidden="true" size={15} />
-          新建编排任务
-        </Button>
-      </header>
-
-      <div className="mat-stats" aria-label="任务统计">
-        <div className="mat-stat">
-          <span className="mat-stat-icon is-primary" aria-hidden="true">
-            <Network size={18} />
-          </span>
-          <div className="mat-stat-copy">
-            <strong>{stats.total}</strong>
-            <span>编排任务</span>
-          </div>
-        </div>
-        <div className="mat-stat">
-          <span className="mat-stat-icon is-success" aria-hidden="true">
-            <CircleCheck size={18} />
-          </span>
-          <div className="mat-stat-copy">
-            <strong>{stats.enabled}</strong>
-            <span>已启用</span>
-          </div>
-        </div>
-        <div className="mat-stat">
-          <span className={`mat-stat-icon${stats.running ? " is-live" : " is-muted"}`} aria-hidden="true">
-            {stats.running ? <LoaderCircle size={18} className="mat-spin" /> : <Clock3 size={18} />}
-          </span>
-          <div className="mat-stat-copy">
-            <strong className={stats.running ? "is-live" : undefined}>{stats.running}</strong>
-            <span>执行中</span>
-          </div>
-        </div>
-        <div className="mat-stat">
-          <span className="mat-stat-icon is-info" aria-hidden="true">
-            <History size={18} />
-          </span>
-          <div className="mat-stat-copy">
-            <strong>{stats.runTotal}</strong>
-            <span>累计执行</span>
-          </div>
-        </div>
-      </div>
-
-      <div className="mat-body">
-        <div className="mat-toolbar">
-          <div className="mat-toolbar-search">
-            <Input
-              clearable
-              placeholder="搜索任务名称 / 描述 / 智能体"
-              prefixIcon={<Search aria-hidden="true" size={15} />}
-              value={search}
-              onChange={(value) => setSearch(String(value ?? ""))}
-            />
-          </div>
-          <Tabs
-            className="mat-toolbar-tabs"
-            value={filter}
-            onChange={(value) => setFilter(value as StatusFilter)}
-          >
-            <Tabs.TabPanel label="全部" value="all" />
-            <Tabs.TabPanel label="执行中" value="running" />
-            <Tabs.TabPanel label="已启用" value="enabled" />
-            <Tabs.TabPanel label="已暂停" value="paused" />
-          </Tabs>
-        </div>
-
-        {isLoading ? (
-          <div className="mat-state">
-            <Clock3 aria-hidden="true" className="mat-spin" size={18} />
-            正在加载编排任务…
-          </div>
-        ) : visibleTasks.length ? (
-          <div className="mat-grid">
-            {visibleTasks.map((task) => {
-              const badge = taskBadgeOf(task);
-              const live = isTaskLive(task);
-              const busy = busyTaskId === task.id;
-              return (
-                <article className="mat-card" key={task.id}>
-                  <header className="mat-card-head" onClick={() => openTask(task.id)}>
-                    <span className="mat-card-glyph" aria-hidden="true">
-                      <Network size={17} />
-                    </span>
-                    <div className="mat-card-title">
-                      <h3>{task.name}</h3>
-                      <p>
-                        <CalendarClock aria-hidden="true" size={13} />
-                        {describeCron(task.cron_expr)}
-                      </p>
-                    </div>
-                    <Tag size="small" theme={badge.theme} variant="light">
-                      {badge.label}
-                    </Tag>
-                  </header>
-                  {task.description && (
-                    <p className="mat-card-desc" onClick={() => openTask(task.id)}>
-                      {task.description}
-                    </p>
-                  )}
-                  <div className="mat-card-flow" onClick={() => openTask(task.id)}>
-                    <AgentFlow
-                      seats={task.seats}
-                      size="sm"
-                      stages={expandStages(task)}
-                    />
-                  </div>
-                  <footer className="mat-card-foot">
-                    <div className="mat-card-meta">
-                      <span title={task.nextRunAt ?? undefined}>
-                        下次 {task.enabled ? formatDateTime(task.nextRunAt) : "已暂停"}
-                      </span>
-                      <span>
-                        上次 {task.lastRun ? formatRelative(task.lastRun.started_at) : "未执行"}
-                        {task.lastRun && task.lastRun.status !== "pending" && (
-                          <em className={`mat-run-text is-${task.lastRun.status}`}>
-                            · {runStatusLabel(task.lastRun.status)}
-                          </em>
-                        )}
-                      </span>
-                    </div>
-                    <div className="mat-card-ops">
-                      <Button
-                        disabled={busy}
-                        loading={busy}
-                        size="small"
-                        theme="primary"
-                        variant="text"
-                        onClick={() => void runTrigger(task)}
-                      >
-                        <Zap aria-hidden="true" size={14} />
-                        立即执行
-                      </Button>
-                      <Button
-                        disabled={busy}
-                        size="small"
-                        variant="text"
-                        onClick={() => void runToggle(task)}
-                      >
-                        {task.enabled ? (
-                          <Pause aria-hidden="true" size={14} />
-                        ) : (
-                          <Play aria-hidden="true" size={14} />
-                        )}
-                        {task.enabled ? "暂停" : "恢复"}
-                      </Button>
-                      <Button size="small" variant="text" onClick={() => openEdit(task)}>
-                        <Pencil aria-hidden="true" size={14} />
-                        编辑
-                      </Button>
-                      <Popconfirm
-                        content="删除后不可恢复，确定删除该任务？"
-                        placement="bottom-right"
-                        theme="danger"
-                        onConfirm={() => confirmDelete(task)}
-                      >
-                        <Button className="mat-danger-btn" size="small" variant="text">
-                          <Trash2 aria-hidden="true" size={14} />
-                        </Button>
-                      </Popconfirm>
-                    </div>
-                  </footer>
-                </article>
-              );
-            })}
-          </div>
-        ) : (
-          <div className="mat-state mat-state--empty">
-            <span className="mat-state-glyph" aria-hidden="true">
-              <Network size={22} />
-            </span>
-            <h3>{tasks.length ? "没有符合条件的任务" : "还没有多智能体定时任务"}</h3>
-            <p>
-              {tasks.length
-                ? "换个关键词或筛选条件试试。"
-                : "创建一个编排任务，把多个智能体按并行 / 串行组织起来定时执行。"}
-            </p>
-            {!tasks.length && (
-              <Button theme="primary" onClick={openCreate}>
-                <Plus aria-hidden="true" size={15} />
-                新建编排任务
-              </Button>
-            )}
-          </div>
-        )}
-
-        <p className="mat-footnote">
-          <CircleAlert aria-hidden="true" size={13} />
-          前端演示阶段：任务数据保存在本浏览器，执行过程为本地模拟；后端服务接入后自动切换。
-        </p>
-      </div>
-
-      <Drawer
-        className="mat-detail-drawer"
-        closeBtn
-        destroyOnClose
-        footer={
-          selectedTask ? (
-            <div className="mat-detail-footer">
-              <Button variant="outline" onClick={() => openEdit(selectedTask)}>
-                <Pencil aria-hidden="true" size={15} />
-                编辑编排
-              </Button>
-              <Button
-                variant="outline"
-                onClick={() => void runToggle(selectedTask)}
-              >
-                {selectedTask.enabled ? (
-                  <Pause aria-hidden="true" size={15} />
-                ) : (
-                  <Play aria-hidden="true" size={15} />
-                )}
-                {selectedTask.enabled ? "暂停任务" : "恢复任务"}
-              </Button>
-              <Button
-                className="mat-danger-btn"
-                theme="danger"
-                variant="outline"
-                onClick={() => confirmDelete(selectedTask)}
-              >
-                <Trash2 aria-hidden="true" size={15} />
-                删除
-              </Button>
-              <Button
-                disabled={busyTaskId === selectedTask.id}
-                loading={busyTaskId === selectedTask.id}
-                theme="primary"
-                onClick={() => void runTrigger(selectedTask)}
-              >
-                <Zap aria-hidden="true" size={15} />
-                立即执行
-              </Button>
-            </div>
-          ) : null
-        }
-        header={
-          selectedTask ? (
-            <div className="mat-detail-header">
-              <span className="mat-detail-glyph" aria-hidden="true">
-                <Network size={17} />
-              </span>
-              <div className="mat-detail-heading">
-                <h3>{selectedTask.name}</h3>
-                <p>{describeCron(selectedTask.cron_expr)}</p>
-              </div>
-              {(() => {
-                const badge = taskBadgeOf(selectedTask);
-                return (
-                  <Tag theme={badge.theme} variant="light">
-                    {badge.label}
-                  </Tag>
-                );
-              })()}
-              <Switch
-                value={selectedTask.enabled}
-                onChange={() => void runToggle(selectedTask)}
-              />
-            </div>
-          ) : null
-        }
-        placement="right"
-        size="680px"
-        visible={!!selectedTask}
-        onClose={closeTask}
-      >
-        {selectedTask && (
-          <div className="mat-detail">
-            {selectedTask.description && <p className="mat-detail-desc">{selectedTask.description}</p>}
-
-            <div className="mat-detail-grid">
-              <div>
-                <span>下次执行</span>
-                <strong>
-                  {selectedTask.enabled ? formatDateTime(selectedTask.nextRunAt) : "已暂停"}
-                </strong>
-              </div>
-              <div>
-                <span>最近执行</span>
-                <strong>
-                  {selectedTask.lastRun
-                    ? `${formatRelative(selectedTask.lastRun.started_at)} · ${runStatusLabel(selectedTask.lastRun.status)}`
-                    : "未执行"}
-                </strong>
-              </div>
-              <div>
-                <span>累计执行</span>
-                <strong>{selectedTask.runs.length} 次</strong>
-              </div>
-              <div>
-                <span>智能体 / 阶段</span>
-                <strong>
-                  {selectedTask.seats.length} 个 · {selectedStages.length} 阶段
-                </strong>
-              </div>
-            </div>
-
-            <section className="mat-detail-section">
-              <header className="mat-detail-section-head">
-                <h4>协作编排</h4>
-                {activeRun && (activeRun.status === "running" || activeRun.status === "pending") && (
-                  <span className="mat-run-text is-running">
-                    阶段 {Math.min(activeRun.stage_index + 1, activeRun.stage_total)} /{" "}
-                    {activeRun.stage_total} 执行中…
-                  </span>
-                )}
-              </header>
-              <div className="mat-detail-flow">
-                <AgentFlow
-                  activeStageIndex={
-                    activeRun && activeRun.status !== "succeeded" ? activeRun.stage_index : null
-                  }
-                  seatStates={activeRun?.seat_states ?? null}
-                  seats={selectedTask.seats}
-                  showGoals
-                  size="sm"
-                  stageGoals={selectedTask.stage_goals}
-                  stages={selectedStages}
-                />
-              </div>
-              {activeRun && (
-                <div className="mat-flow-legend">
-                  <span>
-                    <i className="mat-seat-dot is-done" /> 完成
-                  </span>
-                  <span>
-                    <i className="mat-seat-dot is-running" /> 执行中
-                  </span>
-                  <span>
-                    <i className="mat-seat-dot is-waiting" /> 等待
-                  </span>
-                  <span>
-                    <i className="mat-seat-dot is-failed" /> 失败
-                  </span>
-                </div>
-              )}
-            </section>
-
-            <section className="mat-detail-section">
-              <header className="mat-detail-section-head">
-                <h4>任务指令</h4>
-              </header>
-              <p className="mat-detail-prompt">{selectedTask.prompt}</p>
-              {selectedTask.coordinator_prompt && (
-                <>
-                  <header className="mat-detail-section-head mat-detail-section-head--sub">
-                    <h5>总控提示</h5>
-                  </header>
-                  <p className="mat-detail-prompt is-sub">{selectedTask.coordinator_prompt}</p>
-                </>
-              )}
-            </section>
-
-            <section className="mat-detail-section">
-              <header className="mat-detail-section-head">
-                <h4>运行记录</h4>
-                {!!selectedRuns.length && (
-                  <small>点击记录可在上方流程图回看各智能体状态</small>
-                )}
-              </header>
-              {selectedRuns.length ? (
-                <div className="mat-run-list">
-                  {selectedRuns.map((run) => {
-                    const active = activeRun?.id === run.id;
-                    const duration = run.finished_at
-                      ? formatDuration(
-                          new Date(run.finished_at).getTime() -
-                            new Date(run.started_at).getTime(),
-                        )
-                      : null;
-                    return (
-                      <button
-                        className={`mat-run-item${active ? " is-active" : ""}`}
-                        key={run.id}
-                        onClick={() => setActiveRunId(run.id)}
-                        type="button"
-                      >
-                        <Tag size="small" theme={runTagTheme(run.status)} variant="light">
-                          {runStatusLabel(run.status)}
-                        </Tag>
-                        <span className="mat-run-item-time">
-                          {formatDateTime(run.started_at)}
-                        </span>
-                        <span className="mat-run-item-trigger">
-                          {run.trigger === "manual" ? "手动触发" : "按计划执行"}
-                        </span>
-                        <span className="mat-run-item-duration">
-                          {duration ?? `阶段 ${Math.min(run.stage_index + 1, run.stage_total)}/${run.stage_total}`}
-                        </span>
-                      </button>
-                    );
-                  })}
-                </div>
-              ) : (
-                <p className="mat-detail-empty">还没有执行记录，可点「立即执行」体验完整流程。</p>
-              )}
-              {activeRun?.error && (
-                <p className="mat-detail-error">
-                  <CircleAlert aria-hidden="true" size={14} />
-                  {activeRun.error}
-                </p>
-              )}
-            </section>
-          </div>
-        )}
-      </Drawer>
-    </section>
-  );
-}

frontend-web/src/pages/official-multi-agent-tasks/TaskEditPage.tsx

@@ -1,942 +0,0 @@
-/**
- * 多智能体定时任务 · 独立编辑页。
- *
- * 布局：顶部是紧凑表单条（任务名称 + 任务描述），其余表单项（执行频率、任务指令、
- * 总控提示、启用开关）收进「执行设置」弹窗；主体是智能体编排。
- * 编排交互与业务链条编辑器一致（复制其 @dnd-kit 模式 + 复用 chain-stages 纯函数）：
- * - 左栏候选池：拖左侧手柄到右侧任意阶段 / 新建阶段落区；点卡片本体 = 追加为新阶段。
- * - 右栏阶段组：阶段是 droppable，席位是 sortable；席位可跨阶段拖动（变并行）或拖到
- *   「新建阶段」落区独立成阶段；按钮兜底（并入上/下一阶段、独立成阶段、移除）。
- * 保存时弹出确认弹窗：任务摘要 + 编排流程图（同阶段并行 · 阶段间串行）+ 图例。
- */
-
-import {
-  ArrowLeft,
-  Bot,
-  ChevronDown,
-  ChevronUp,
-  Eye,
-  GripVertical,
-  Plus,
-  Save,
-  Search,
-  Settings2,
-  SplitSquareVertical,
-  Trash2,
-  X,
-} from "lucide-react";
-import { useCallback, useEffect, useMemo, useState } from "react";
-import { useNavigate } from "react-router-dom";
-import {
-  DndContext,
-  DragOverlay,
-  PointerSensor,
-  closestCenter,
-  useDraggable,
-  useDroppable,
-  useSensor,
-  useSensors,
-  type DragEndEvent,
-  type DragStartEvent,
-} from "@dnd-kit/core";
-import {
-  SortableContext,
-  useSortable,
-  verticalListSortingStrategy,
-} from "@dnd-kit/sortable";
-import { CSS } from "@dnd-kit/utilities";
-import { Button, Dialog, Input, Switch, Textarea } from "tdesign-react";
-import { toast } from "sonner";
-
-import { useAgents } from "@/core/agents";
-import type { Agent } from "@/core/agents";
-import {
-  type ScheduleConfig,
-  buildCron,
-  parseCron,
-} from "@/components/workspace/scheduled-tasks/schedule-builder";
-import {
-  addEmptyStage,
-  addSeatAsNewStage,
-  addSeatToStage,
-  countSeats,
-  deleteStage,
-  findStageIndexOfSeat,
-  moveSeatToStage,
-  moveStage,
-  removeSeat,
-  setStageGoal,
-  splitSeatToNewStage,
-  stageGroupsToStageGoals,
-  stageGroupsToStagePayload,
-  type StageGroups,
-} from "@/roundtable-planning/lib/chain-stages";
-
-import { OFFICIAL_DEERFLOW_ROUTE_PREFIX } from "@/core/official-deerflow/routes";
-
-import AgentFlow from "./components/AgentFlow";
-import AgentDetailDrawer, {
-  type AgentDetailTarget,
-} from "./components/AgentDetailDrawer";
-import SchedulePicker from "./components/SchedulePicker";
-import { useMultiAgentTaskActions, useMultiAgentTasks } from "./store";
-import type { MatSeat, MatTask, MatTaskPayload } from "./types";
-import {
-  defaultScheduleConfig,
-  describeCron,
-  describeScheduleConfig,
-  expandStages,
-} from "./utils";
-
-const POOL_PREFIX = "matpool::";
-const SEAT_PREFIX = "matseat::";
-const STAGE_PREFIX = "matstage::";
-const NEWSTAGE_DROPPABLE_ID = "mat-newstage";
-
-const MAX_SEATS = 20;
-const MIN_SEATS = 2;
-const DEFAULT_TIMEZONE = "Asia/Shanghai";
-
-type ActiveDrag = { name: string } | null;
-
-function seatFromAgent(agent: Agent): MatSeat {
-  return {
-    agent_id: agent.id,
-    name: agent.name,
-    description: agent.description ?? undefined,
-  };
-}
-
-function draftFromTask(task: MatTask) {
-  const stages = expandStages(task);
-  const seatById = new Map(task.seats.map((seat) => [seat.agent_id, seat]));
-  return {
-    name: task.name,
-    description: task.description ?? "",
-    schedule: parseCron(task.cron_expr) ?? defaultScheduleConfig(),
-    enabled: task.enabled,
-    prompt: task.prompt,
-    coordinatorPrompt: task.coordinator_prompt ?? "",
-    stageGroups: stages.map((stage, index) => ({
-      seats: stage
-        .map((agentId) => seatById.get(agentId))
-        .filter((seat): seat is MatSeat => !!seat),
-      goal: task.stage_goals?.[index] ?? "",
-    })) as StageGroups,
-  };
-}
-
-function groupsToPayloadSeats(groups: StageGroups): MatSeat[] {
-  return groups
-    .filter((group) => group.seats.length > 0)
-    .flatMap((group) => group.seats as MatSeat[]);
-}
-
-// ── 左栏：候选智能体卡片（点卡片看详情 / 加号或手柄加入）──────────────────
-
-function PoolAgentCard({
-  agent,
-  used,
-  onAdd,
-  onShowDetail,
-}: {
-  agent: Agent;
-  used: boolean;
-  onAdd: () => void;
-  onShowDetail: () => void;
-}) {
-  const { attributes, listeners, setNodeRef, isDragging } = useDraggable({
-    id: POOL_PREFIX + agent.id,
-    disabled: used,
-  });
-  return (
-    <div
-      className={`mat-pool-item${used ? " is-used" : ""}${isDragging ? " is-dragging" : ""}`}
-      ref={setNodeRef}
-      {...attributes}
-    >
-      <button
-        aria-label={used ? "已在编排中" : "拖动加入编排"}
-        className="mat-pool-grip"
-        onClick={(event) => event.stopPropagation()}
-        title={used ? "已在编排中" : "拖动到右侧阶段加入（可与其它智能体并行）"}
-        type="button"
-        {...(used ? {} : listeners)}
-      >
-        <GripVertical size={14} />
-      </button>
-      <button className="mat-pool-main" onClick={onShowDetail} type="button">
-        <span className="mat-pool-icon" aria-hidden="true">
-          <Bot size={13} />
-        </span>
-        <span className="mat-pool-copy">
-          <span className="mat-pool-item-name">{agent.name}</span>
-          <span className="mat-pool-item-desc">{agent.description || "暂无简介"}</span>
-        </span>
-      </button>
-      {used ? (
-        <span className="mat-pool-used">已加入</span>
-      ) : (
-        <button
-          aria-label={`加入 ${agent.name}`}
-          className="mat-pool-join"
-          onClick={(event) => {
-            event.stopPropagation();
-            onAdd();
-          }}
-          title="追加为新阶段"
-          type="button"
-        >
-          <Plus size={13} />
-        </button>
-      )}
-    </div>
-  );
-}
-
-// ── 右栏：单个席位长条（sortable）─────────────────────────────────────────
-
-function SeatStrip({
-  seat,
-  globalIndex,
-  isFirstStage,
-  isLastStage,
-  onRemove,
-  onMergeUp,
-  onMergeDown,
-  onSplit,
-  onDetail,
-}: {
-  seat: MatSeat;
-  globalIndex: number;
-  isFirstStage: boolean;
-  isLastStage: boolean;
-  onRemove: () => void;
-  onMergeUp: () => void;
-  onMergeDown: () => void;
-  onSplit: () => void;
-  onDetail: () => void;
-}) {
-  const { attributes, listeners, setNodeRef, transform, transition, isDragging } =
-    useSortable({ id: SEAT_PREFIX + seat.agent_id });
-  return (
-    <div
-      className={`mat-seat-row${isDragging ? " is-dragging" : ""}`}
-      ref={setNodeRef}
-      style={{ transform: CSS.Transform.toString(transform), transition }}
-    >
-      <button
-        aria-label="拖动调整编排"
-        className="mat-seat-row-grip"
-        title="拖动到其它阶段（并行）/ 排序 / 拖到底部虚线框独立成阶段"
-        type="button"
-        {...attributes}
-        {...listeners}
-      >
-        <GripVertical size={14} />
-      </button>
-      <span className="mat-seat-row-no">{globalIndex + 1}</span>
-      <span className="mat-seat-row-icon" aria-hidden="true">
-        <Bot size={13} />
-      </span>
-      <div className="mat-seat-row-copy" title={seat.description}>
-        <span className="mat-seat-row-name">{seat.name}</span>
-        {seat.description && <span className="mat-seat-row-desc">{seat.description}</span>}
-      </div>
-      <span className="mat-seat-row-ops">
-        <button
-          aria-label={`查看 ${seat.name} 详情`}
-          onClick={onDetail}
-          title="查看详情"
-          type="button"
-        >
-          <Eye size={14} />
-        </button>
-        <button
-          aria-label="并入上一阶段（与其并行）"
-          disabled={isFirstStage}
-          onClick={onMergeUp}
-          title="并入上一阶段（与其并行）"
-          type="button"
-        >
-          <ChevronUp size={14} />
-        </button>
-        <button
-          aria-label="独立成阶段"
-          onClick={onSplit}
-          title="独立成阶段"
-          type="button"
-        >
-          <SplitSquareVertical size={14} />
-        </button>
-        <button
-          aria-label="并入下一阶段（与其并行）"
-          disabled={isLastStage}
-          onClick={onMergeDown}
-          title="并入下一阶段（与其并行）"
-          type="button"
-        >
-          <ChevronDown size={14} />
-        </button>
-        <button aria-label="移除智能体" onClick={onRemove} title="移除" type="button">
-          <X size={14} />
-        </button>
-      </span>
-    </div>
-  );
-}
-
-// ── 右栏：阶段容器（droppable + 组内 sortable）────────────────────────────
-
-function StageBox({
-  group,
-  stageIdx,
-  stageCount,
-  startIndex,
-  onGoalChange,
-  onStageReorder,
-  onStageDelete,
-  onRemoveSeat,
-  onMergeSeat,
-  onSplitSeat,
-  onSeatDetail,
-}: {
-  group: StageGroups[number];
-  stageIdx: number;
-  stageCount: number;
-  startIndex: number;
-  onGoalChange: (goal: string) => void;
-  onStageReorder: (dir: -1 | 1) => void;
-  onStageDelete: () => void;
-  onRemoveSeat: (agentId: string) => void;
-  onMergeSeat: (agentId: string, targetStage: number) => void;
-  onSplitSeat: (agentId: string) => void;
-  onSeatDetail: (seat: MatSeat) => void;
-}) {
-  const { setNodeRef, isOver } = useDroppable({ id: STAGE_PREFIX + stageIdx });
-  const seats = group.seats as MatSeat[];
-  const isParallel = seats.length > 1;
-  const isFirstStage = stageIdx === 0;
-  const isLastStage = stageIdx === stageCount - 1;
-  const seatItemIds = seats.map((seat) => SEAT_PREFIX + seat.agent_id);
-
-  return (
-    <article className={`mat-stage-box${isOver ? " is-over" : ""}`}>
-      <header className="mat-stage-box-head">
-        <span className="mat-stage-box-no">阶段 {stageIdx + 1}</span>
-        {isParallel ? (
-          <span className="mat-flow-mode is-parallel">并行 ×{seats.length}</span>
-        ) : (
-          <span className="mat-flow-mode is-serial">串行</span>
-        )}
-        <span className="mat-stage-box-ops">
-          <button
-            aria-label="阶段上移"
-            disabled={isFirstStage}
-            onClick={() => onStageReorder(-1)}
-            title="上移"
-            type="button"
-          >
-            <ChevronUp size={14} />
-          </button>
-          <button
-            aria-label="阶段下移"
-            disabled={isLastStage}
-            onClick={() => onStageReorder(1)}
-            title="下移"
-            type="button"
-          >
-            <ChevronDown size={14} />
-          </button>
-          <button
-            aria-label="删除阶段"
-            onClick={onStageDelete}
-            title="删除整个阶段"
-            type="button"
-          >
-            <Trash2 size={14} />
-          </button>
-        </span>
-      </header>
-      <Textarea
-        autosize
-        className="mat-stage-goal"
-        maxlength={120}
-        placeholder="本阶段目标（可选）：本阶段要产出什么、如何衔接上一阶段"
-        value={group.goal ?? ""}
-        onChange={(value) => onGoalChange(String(value ?? ""))}
-      />
-      <div className="mat-stage-seats" ref={setNodeRef}>
-        {seats.length === 0 ? (
-          <div className="mat-stage-seat-empty">空阶段 —— 把左侧智能体拖到此处，或删除该阶段。</div>
-        ) : (
-          <SortableContext items={seatItemIds} strategy={verticalListSortingStrategy}>
-            {seats.map((seat, index) => (
-              <SeatStrip
-                globalIndex={startIndex + index}
-                isLastStage={isLastStage}
-                isFirstStage={isFirstStage}
-                key={seat.agent_id}
-                onDetail={() => onSeatDetail(seat)}
-                onMergeDown={() => onMergeSeat(seat.agent_id, stageIdx + 1)}
-                onMergeUp={() => onMergeSeat(seat.agent_id, stageIdx - 1)}
-                onRemove={() => onRemoveSeat(seat.agent_id)}
-                onSplit={() => onSplitSeat(seat.agent_id)}
-                seat={seat}
-              />
-            ))}
-          </SortableContext>
-        )}
-      </div>
-    </article>
-  );
-}
-
-// ── 「新建阶段」落区（点击新增 / 拖席位到此独立成最后阶段）────────────────
-
-function NewStageDropZone({
-  hasEmptyStage,
-  onAddStage,
-}: {
-  hasEmptyStage: boolean;
-  onAddStage: () => void;
-}) {
-  const { setNodeRef, isOver } = useDroppable({ id: NEWSTAGE_DROPPABLE_ID });
-  return (
-    <button
-      className={`mat-stage-dropzone${isOver ? " is-over" : ""}`}
-      disabled={hasEmptyStage}
-      onClick={onAddStage}
-      ref={setNodeRef}
-      title={hasEmptyStage ? "已有空阶段，先填充它" : "新建一个串在最后的阶段"}
-      type="button"
-    >
-      <Plus size={15} />
-      新建阶段（串在最后） · 或把席位拖到此处独立成阶段
-    </button>
-  );
-}
-
-// ── 页面 ──────────────────────────────────────────────────────────────────
-
-export default function TaskEditPage({
-  mode,
-  taskId,
-}: {
-  mode: "create" | "edit";
-  taskId: string | null;
-}) {
-  const navigate = useNavigate();
-  const { tasks, isLoading: tasksLoading } = useMultiAgentTasks();
-  const actions = useMultiAgentTaskActions();
-  const [poolSearch, setPoolSearch] = useState("");
-  const { agents, isLoading: agentsLoading } = useAgents({
-    search: poolSearch.trim() || undefined,
-  });
-
-  const [name, setName] = useState("");
-  const [description, setDescription] = useState("");
-  const [schedule, setSchedule] = useState<ScheduleConfig>(defaultScheduleConfig());
-  const [enabled, setEnabled] = useState(true);
-  const [prompt, setPrompt] = useState("");
-  const [coordinatorPrompt, setCoordinatorPrompt] = useState("");
-  const [stageGroups, setStageGroups] = useState<StageGroups>([]);
-  const [initialized, setInitialized] = useState(false);
-
-  const [settingsOpen, setSettingsOpen] = useState(false);
-  const [confirmOpen, setConfirmOpen] = useState(false);
-  const [saving, setSaving] = useState(false);
-  const [activeDrag, setActiveDrag] = useState<ActiveDrag>(null);
-  const [detailTarget, setDetailTarget] = useState<AgentDetailTarget | null>(null);
-
-  const editingTask = useMemo(
-    () => (mode === "edit" ? (tasks.find((task) => task.id === taskId) ?? null) : null),
-    [mode, taskId, tasks],
-  );
-
-  useEffect(() => {
-    if (initialized || mode === "create") {
-      setInitialized(true);
-      return;
-    }
-    if (!tasksLoading && taskId) {
-      if (editingTask) {
-        const draft = draftFromTask(editingTask);
-        setName(draft.name);
-        setDescription(draft.description);
-        setSchedule(draft.schedule);
-        setEnabled(draft.enabled);
-        setPrompt(draft.prompt);
-        setCoordinatorPrompt(draft.coordinatorPrompt);
-        setStageGroups(draft.stageGroups);
-      }
-      setInitialized(true);
-    }
-  }, [editingTask, initialized, mode, taskId, tasksLoading]);
-
-  const sensors = useSensors(
-    useSensor(PointerSensor, { activationConstraint: { distance: 5 } }),
-  );
-
-  const usedAgentIds = useMemo(
-    () => new Set(stageGroups.flatMap((group) => group.seats.map((seat) => seat.agent_id))),
-    [stageGroups],
-  );
-  const seatCount = useMemo(() => countSeats(stageGroups), [stageGroups]);
-  const hasEmptyStage = stageGroups.some((group) => group.seats.length === 0);
-
-  const backToList = useCallback(() => {
-    navigate(`${OFFICIAL_DEERFLOW_ROUTE_PREFIX}/workspace/multi-agent-tasks`);
-  }, [navigate]);
-
-  // ── 编排操作（全部复用 chain-stages 纯函数，agent_id 定位）───────────────
-  const addAgentAsStage = useCallback((agent: Agent) => {
-    if (seatCount >= MAX_SEATS) {
-      toast.warning(`编排最多 ${MAX_SEATS} 个智能体`);
-      return;
-    }
-    setStageGroups((prev) => addSeatAsNewStage(prev, seatFromAgent(agent)));
-  }, [seatCount]);
-
-  const onDragStart = useCallback((event: DragStartEvent) => {
-    const id = String(event.active.id);
-    const agentId = id.startsWith(POOL_PREFIX)
-      ? id.slice(POOL_PREFIX.length)
-      : id.startsWith(SEAT_PREFIX)
-        ? id.slice(SEAT_PREFIX.length)
-        : null;
-    if (!agentId) return;
-    const seatName =
-      agents.find((agent) => agent.id === agentId)?.name ??
-      stageGroups
-        .flatMap((group) => group.seats as MatSeat[])
-        .find((seat) => seat.agent_id === agentId)?.name ??
-      agentId;
-    setActiveDrag({ name: seatName });
-  }, [agents, stageGroups]);
-
-  const onDragEnd = useCallback(
-    (event: DragEndEvent) => {
-      setActiveDrag(null);
-      const activeId = String(event.active.id);
-      const overId = event.over ? String(event.over.id) : null;
-      if (!overId) return;
-
-      let targetStage = -1;
-      let atIndex: number | undefined;
-      if (overId === NEWSTAGE_DROPPABLE_ID) {
-        targetStage = -1;
-      } else if (overId.startsWith(STAGE_PREFIX)) {
-        targetStage = Number(overId.slice(STAGE_PREFIX.length));
-      } else if (overId.startsWith(SEAT_PREFIX)) {
-        const overAgent = overId.slice(SEAT_PREFIX.length);
-        targetStage = findStageIndexOfSeat(stageGroups, overAgent);
-        atIndex = stageGroups[targetStage]?.seats.findIndex(
-          (seat) => seat.agent_id === overAgent,
-        );
-      }
-
-      const toNewStage = overId === NEWSTAGE_DROPPABLE_ID;
-
-      if (activeId.startsWith(POOL_PREFIX)) {
-        const agentId = activeId.slice(POOL_PREFIX.length);
-        if (usedAgentIds.has(agentId)) return;
-        const agent = agents.find((candidate) => candidate.id === agentId);
-        if (!agent || seatCount >= MAX_SEATS) return;
-        const seat = seatFromAgent(agent);
-        setStageGroups((prev) =>
-          toNewStage || targetStage < 0
-            ? addSeatAsNewStage(prev, seat)
-            : addSeatToStage(prev, seat, targetStage, atIndex),
-        );
-        return;
-      }
-
-      if (activeId.startsWith(SEAT_PREFIX)) {
-        const agentId = activeId.slice(SEAT_PREFIX.length);
-        setStageGroups((prev) => {
-          if (toNewStage) {
-            const withEmpty = addEmptyStage(prev);
-            return moveSeatToStage(withEmpty, agentId, withEmpty.length - 1);
-          }
-          if (targetStage < 0) return prev;
-          return moveSeatToStage(prev, agentId, targetStage, atIndex);
-        });
-      }
-    },
-    [agents, seatCount, stageGroups, usedAgentIds],
-  );
-
-  // ── 保存：校验 → 确认弹窗 → 提交 ────────────────────────────────────────
-  const previewGroups = stageGroups.filter((group) => group.seats.length > 0);
-  const previewStages = previewGroups.map((group) =>
-    (group.seats as MatSeat[]).map((seat) => seat.agent_id),
-  );
-  const previewSeats = groupsToPayloadSeats(stageGroups);
-
-  const tryOpenConfirm = () => {
-    if (!name.trim()) {
-      toast.warning("请填写任务名称");
-      return;
-    }
-    if (seatCount < MIN_SEATS) {
-      toast.warning(`编排至少需要 ${MIN_SEATS} 个智能体`);
-      return;
-    }
-    if (hasEmptyStage) {
-      toast.warning("还有空阶段，请填充或删除");
-      return;
-    }
-    if (!prompt.trim()) {
-      setSettingsOpen(true);
-      toast.warning("请先在「执行设置」中填写任务指令");
-      return;
-    }
-    setConfirmOpen(true);
-  };
-
-  const submitTask = async () => {
-    setSaving(true);
-    try {
-      // 填了总控提示也强制落显式分层（该提示仅分层模式注入），与业务链条语义一致。
-      const forceExplicit = coordinatorPrompt.trim().length > 0;
-      const payload: MatTaskPayload = {
-        name: name.trim(),
-        description: description.trim() || undefined,
-        prompt: prompt.trim(),
-        coordinator_prompt: coordinatorPrompt.trim() || undefined,
-        cron_expr: buildCron(schedule),
-        timezone: editingTask?.timezone || DEFAULT_TIMEZONE,
-        enabled,
-        seats: previewSeats,
-        stages: stageGroupsToStagePayload(stageGroups, forceExplicit),
-        stage_goals: stageGroupsToStageGoals(stageGroups, forceExplicit),
-      };
-      if (mode === "edit" && taskId) {
-        await actions.update.mutateAsync({ id: taskId, payload });
-        toast.success("任务已更新");
-      } else {
-        await actions.create.mutateAsync(payload);
-        toast.success("任务已创建");
-      }
-      setConfirmOpen(false);
-      backToList();
-    } catch {
-      toast.error("保存失败，请重试");
-    } finally {
-      setSaving(false);
-    }
-  };
-
-  if (mode === "edit" && !tasksLoading && initialized && !editingTask) {
-    return (
-      <section className="mat-edit-page">
-        <div className="mat-state mat-state--empty">
-          <h3>任务不存在或已被删除</h3>
-          <Button theme="primary" onClick={backToList}>
-            返回任务列表
-          </Button>
-        </div>
-      </section>
-    );
-  }
-
-  let seatCursor = 0;
-  const settingsSummary = `${describeScheduleConfig(schedule)} · ${enabled ? "已启用" : "已暂停"}`;
-
-  return (
-    <section className="mat-edit-page">
-      <header className="mat-edit-header">
-        <button aria-label="返回任务列表" className="mat-edit-back" onClick={backToList} type="button">
-          <ArrowLeft size={18} />
-        </button>
-        <div className="mat-edit-heading">
-          <h1>{mode === "edit" ? `编辑：${editingTask?.name ?? "多智能体定时任务"}` : "新建多智能体定时任务"}</h1>
-          <p>同阶段并行执行 · 阶段之间串行执行；拖拽或点击左侧候选智能体加入编排</p>
-        </div>
-        <Button
-          variant="outline"
-          onClick={() => setSettingsOpen(true)}
-          title="执行频率 / 任务指令 / 总控提示 / 启用"
-        >
-          <Settings2 aria-hidden="true" size={15} />
-          执行设置
-          <span className="mat-settings-summary">{settingsSummary}</span>
-        </Button>
-        <Button theme="primary" onClick={tryOpenConfirm}>
-          <Save aria-hidden="true" size={15} />
-          保存任务
-        </Button>
-      </header>
-
-      <div className="mat-edit-formbar">
-        <label className="mat-formbar-field">
-          <span className="mat-formbar-label">
-            任务名称<i>*</i>
-          </span>
-          <Input
-            clearable
-            maxlength={40}
-            placeholder="例如：每日舆情早报"
-            value={name}
-            onChange={(value) => setName(String(value ?? ""))}
-          />
-        </label>
-        <label className="mat-formbar-field mat-formbar-field--wide">
-          <span className="mat-formbar-label">任务描述</span>
-          <Input
-            clearable
-            maxlength={200}
-            placeholder="一句话说明这个编排任务要达成什么（可选）"
-            value={description}
-            onChange={(value) => setDescription(String(value ?? ""))}
-          />
-        </label>
-      </div>
-
-      <div className="mat-edit-formbar mat-edit-formbar--area">
-        <span className="mat-formbar-label">总控提示</span>
-        <Textarea
-          autosize={{ minRows: 1, maxRows: 4 }}
-          className="mat-formbar-textarea"
-          maxlength={1000}
-          placeholder="写给总控（协调者）的编排要求，例如各阶段如何衔接、产出格式约束等（可选）"
-          value={coordinatorPrompt}
-          onChange={(value) => setCoordinatorPrompt(String(value ?? ""))}
-        />
-      </div>
-
-      <div className="mat-edit-body">
-        <section className="mat-edit-card">
-          <DndContext
-            collisionDetection={closestCenter}
-            onDragEnd={onDragEnd}
-            onDragStart={onDragStart}
-            sensors={sensors}
-          >
-            <div className="mat-edit-orchestra">
-              <aside className="mat-pool">
-                <header className="mat-pool-head">
-                  <span>候选智能体</span>
-                  <em>
-                    {seatCount}/{MAX_SEATS} 已编排 · {agents.length} 个可选
-                  </em>
-                </header>
-                <div className="mat-pool-search">
-                  <Search aria-hidden="true" size={15} />
-                  <input
-                    onChange={(event) => setPoolSearch(event.target.value)}
-                    placeholder="搜索智能体"
-                    value={poolSearch}
-                  />
-                </div>
-                <div className="mat-pool-list">
-                  {agentsLoading ? (
-                    <p className="mat-pool-tip">正在加载智能体…</p>
-                  ) : agents.length ? (
-                    agents.map((agent) => (
-                      <PoolAgentCard
-                        agent={agent}
-                        key={agent.id}
-                        onAdd={() => addAgentAsStage(agent)}
-                        onShowDetail={() =>
-                          setDetailTarget({
-                            agentId: agent.id,
-                            fallbackName: agent.name,
-                            fallbackDescription: agent.description ?? undefined,
-                          })
-                        }
-                        used={usedAgentIds.has(agent.id)}
-                      />
-                    ))
-                  ) : (
-                    <p className="mat-pool-tip">没有匹配的智能体</p>
-                  )}
-                </div>
-              </aside>
-
-              <div className="mat-stage-editor">
-                <div className="mat-stage-list">
-                  {stageGroups.map((group, stageIdx) => {
-                    const startIndex = seatCursor;
-                    seatCursor += (group.seats as MatSeat[]).length;
-                    return (
-                      <StageBox
-                        group={group}
-                        key={`stage-box-${stageIdx}`}
-                        onGoalChange={(goal) =>
-                          setStageGroups((prev) => setStageGoal(prev, stageIdx, goal))
-                        }
-                        onMergeSeat={(agentId, target) =>
-                          setStageGroups((prev) => moveSeatToStage(prev, agentId, target))
-                        }
-                        onRemoveSeat={(agentId) =>
-                          setStageGroups((prev) => removeSeat(prev, agentId))
-                        }
-                        onSeatDetail={(seat) =>
-                          setDetailTarget({
-                            agentId: seat.agent_id,
-                            fallbackName: seat.name,
-                            fallbackDescription: seat.description,
-                          })
-                        }
-                        onSplitSeat={(agentId) =>
-                          setStageGroups((prev) => splitSeatToNewStage(prev, agentId))
-                        }
-                        onStageDelete={() =>
-                          setStageGroups((prev) => deleteStage(prev, stageIdx))
-                        }
-                        onStageReorder={(dir) =>
-                          setStageGroups((prev) => moveStage(prev, stageIdx, dir))
-                        }
-                        stageCount={stageGroups.length}
-                        stageIdx={stageIdx}
-                        startIndex={startIndex}
-                      />
-                    );
-                  })}
-                  <NewStageDropZone
-                    hasEmptyStage={hasEmptyStage}
-                    onAddStage={() => setStageGroups((prev) => addEmptyStage(prev))}
-                  />
-                  {!stageGroups.length && (
-                    <p className="mat-stage-empty">
-                      从左侧点击或拖拽候选智能体加入编排，至少 {MIN_SEATS} 个。
-                    </p>
-                  )}
-                </div>
-              </div>
-            </div>
-
-            <DragOverlay>
-              {activeDrag ? (
-                <div className="mat-drag-overlay">
-                  <GripVertical size={14} />
-                  {activeDrag.name}
-                </div>
-              ) : null}
-            </DragOverlay>
-          </DndContext>
-        </section>
-      </div>
-
-      <Dialog
-        className="mat-settings-dialog"
-        closeBtn
-        closeOnOverlayClick={false}
-        destroyOnClose
-        footer={
-          <div className="mat-confirm-footer">
-            <Button variant="outline" onClick={() => setSettingsOpen(false)}>
-              取消
-            </Button>
-            <Button theme="primary" onClick={() => setSettingsOpen(false)}>
-              确定
-            </Button>
-          </div>
-        }
-        header="执行设置"
-        placement="top"
-        visible={settingsOpen}
-        width={620}
-        onClose={() => setSettingsOpen(false)}
-      >
-        <div className="mat-settings">
-          <div className="mat-field">
-            <span className="mat-field-label">执行频率</span>
-            <SchedulePicker value={schedule} onChange={setSchedule} />
-          </div>
-          <label className="mat-field">
-            <span className="mat-field-label">
-              任务指令<i>*</i>
-            </span>
-            <Textarea
-              autosize={{ minRows: 4, maxRows: 8 }}
-              maxlength={2000}
-              placeholder="描述每次定时执行要让智能体编队完成的事情，例如：汇总过去 24 小时重点舆情并生成早报…"
-              value={prompt}
-              onChange={(value) => setPrompt(String(value ?? ""))}
-            />
-          </label>
-          <div className="mat-field mat-field--switch">
-            <span className="mat-field-label">保存后立即启用</span>
-            <Switch value={enabled} onChange={(value) => setEnabled(!!value)} />
-          </div>
-        </div>
-      </Dialog>
-
-      <Dialog
-        className="mat-confirm-dialog"
-        closeBtn
-        closeOnOverlayClick={false}
-        destroyOnClose
-        footer={
-          <div className="mat-confirm-footer">
-            <Button variant="outline" onClick={() => setConfirmOpen(false)}>
-              再改改
-            </Button>
-            <Button loading={saving} theme="primary" onClick={() => void submitTask()}>
-              确认保存
-            </Button>
-          </div>
-        }
-        header="确认保存任务"
-        placement="top"
-        visible={confirmOpen}
-        width={720}
-        onClose={() => setConfirmOpen(false)}
-      >
-        <div className="mat-confirm">
-          <div className="mat-confirm-grid">
-            <div>
-              <span>任务名称</span>
-              <strong>{name.trim() || "—"}</strong>
-            </div>
-            <div>
-              <span>执行频率</span>
-              <strong>{describeCron(buildCron(schedule))}</strong>
-            </div>
-            <div>
-              <span>启用状态</span>
-              <strong>{enabled ? "启用" : "暂停"}</strong>
-            </div>
-            <div>
-              <span>智能体 / 阶段</span>
-              <strong>
-                {previewSeats.length} 个智能体 · {previewStages.length} 个阶段
-              </strong>
-            </div>
-          </div>
-          <div className="mat-confirm-flow">
-            <AgentFlow
-              seats={previewSeats}
-              showGoals
-              size="sm"
-              stageGoals={previewGroups.map((group) => (group.goal ?? "").trim() || null)}
-              stages={previewStages}
-            />
-          </div>
-          <p className="mat-confirm-legend">
-            <span>
-              <i className="mat-flow-mode is-parallel" style={{ cursor: "default" }} /> 并行：同阶段智能体同时执行
-            </span>
-            <span>
-              <i className="mat-flow-mode is-serial" style={{ cursor: "default" }} /> 串行：阶段之间依次执行
-            </span>
-          </p>
-          {prompt.trim() && (
-            <div className="mat-confirm-prompt">
-              <span>任务指令</span>
-              <p>{prompt.trim()}</p>
-            </div>
-          )}
-        </div>
-      </Dialog>
-
-      <AgentDetailDrawer
-        target={detailTarget}
-        onClose={() => setDetailTarget(null)}
-      />
-    </section>
-  );
-}

frontend-web/src/pages/official-multi-agent-tasks/components/AgentDetailDrawer.tsx

@@ -1,164 +0,0 @@
-/**
- * 智能体详情抽屉：候选池卡片 / 编排席位条「查看详情」共用。
- * 后端查不到（本地演示席位）时回退到编排里保存的名称/描述快照。
- */
-
-import { Bot } from "lucide-react";
-import { Drawer, Tag } from "tdesign-react";
-
-import { useAgent } from "@/core/agents";
-
-export interface AgentDetailTarget {
-  agentId: string;
-  fallbackName?: string;
-  fallbackDescription?: string;
-}
-
-function formatDateTime(value: string | null | undefined): string {
-  if (!value) return "—";
-  const date = new Date(value);
-  if (Number.isNaN(date.getTime())) return "—";
-  return new Intl.DateTimeFormat("zh-CN", {
-    year: "numeric",
-    month: "2-digit",
-    day: "2-digit",
-    hour: "2-digit",
-    minute: "2-digit",
-    hour12: false,
-  }).format(date);
-}
-
-export default function AgentDetailDrawer({
-  target,
-  onClose,
-}: {
-  target: AgentDetailTarget | null;
-  onClose: () => void;
-}) {
-  const { agent, isLoading } = useAgent(target?.agentId ?? null, {
-    enabled: !!target,
-  });
-
-  const name = agent?.name ?? target?.fallbackName ?? target?.agentId ?? "";
-  const description =
-    agent?.description ?? target?.fallbackDescription ?? agent?.description ?? "";
-
-  return (
-    <Drawer
-      className="mat-agent-drawer"
-      closeBtn
-      destroyOnClose
-      footer={null}
-      header={
-        <div className="mat-agent-header">
-          <span className="mat-agent-glyph" aria-hidden="true">
-            <Bot size={17} />
-          </span>
-          <div className="mat-agent-heading">
-            <h3>{name}</h3>
-            <p>智能体详情</p>
-          </div>
-          {agent && (
-            <Tag size="small" theme={agent.builtin ? "default" : "primary"} variant="light">
-              {agent.builtin ? "内置" : agent.published ? "已发布" : "私有"}
-            </Tag>
-          )}
-        </div>
-      }
-      placement="right"
-      size="460px"
-      visible={!!target}
-      onClose={onClose}
-    >
-      {target && (
-        <div className="mat-agent">
-          {isLoading ? (
-            <p className="mat-agent-loading">正在加载智能体详情…</p>
-          ) : agent ? (
-            <>
-              <div className="mat-detail-grid">
-                <div>
-                  <span>创建者</span>
-                  <strong>
-                    {agent.owner_username
-                      ? agent.owner_username
-                      : agent.builtin
-                        ? "内置智能体"
-                        : "—"}
-                  </strong>
-                </div>
-                <div>
-                  <span>执行模型</span>
-                  <strong>{agent.model || "默认模型"}</strong>
-                </div>
-                <div>
-                  <span>创建时间</span>
-                  <strong>{formatDateTime(agent.created_at)}</strong>
-                </div>
-                <div>
-                  <span>技能数</span>
-                  <strong>{agent.skills?.length ?? 0} 个</strong>
-                </div>
-              </div>
-
-              {agent.description && (
-                <section className="mat-agent-section">
-                  <header className="mat-detail-section-head">
-                    <h4>简介</h4>
-                  </header>
-                  <p className="mat-agent-desc">{agent.description}</p>
-                </section>
-              )}
-
-              {!!agent.tags?.length && (
-                <section className="mat-agent-section">
-                  <header className="mat-detail-section-head">
-                    <h4>标签</h4>
-                  </header>
-                  <div className="mat-agent-tags">
-                    {agent.tags.map((tag) => (
-                      <Tag key={tag.id} size="small" variant="light">
-                        {tag.name}
-                      </Tag>
-                    ))}
-                  </div>
-                </section>
-              )}
-
-              {!!agent.skills?.length && (
-                <section className="mat-agent-section">
-                  <header className="mat-detail-section-head">
-                    <h4>已配置技能</h4>
-                  </header>
-                  <div className="mat-agent-tags">
-                    {agent.skills.map((skill) => (
-                      <Tag key={skill} size="small" theme="primary" variant="light">
-                        {skill}
-                      </Tag>
-                    ))}
-                  </div>
-                </section>
-              )}
-            </>
-          ) : (
-            <div className="mat-agent-local">
-              <div className="mat-detail-grid">
-                <div>
-                  <span>创建者</span>
-                  <strong>本地演示</strong>
-                </div>
-                <div>
-                  <span>数据来源</span>
-                  <strong>编排内置快照</strong>
-                </div>
-              </div>
-              <p className="mat-agent-desc">
-                {description || "该席位来自演示种子数据，未对应后端智能体目录中的记录。接入后端后，编排将引用真实智能体。"}
-              </p>
-            </div>
-          )}
-        </div>
-      )}
-    </Drawer>
-  );
-}

frontend-web/src/pages/official-multi-agent-tasks/components/AgentFlow.tsx

@@ -1,136 +0,0 @@
-import { Bot, MoveRight } from "lucide-react";
-import { Fragment } from "react";
-
-import type { MatSeat, MatSeatRunState } from "../types";
-import { seatColorIndex } from "../utils";
-
-export interface AgentFlowProps {
-  stages: string[][];
-  seats: MatSeat[];
-  stageGoals?: (string | null)[] | null;
-  /** 提供时在席位上渲染执行状态点（运行图例）。 */
-  seatStates?: Record<string, MatSeatRunState> | null;
-  /** 当前执行到的阶段下标；提供时高亮进度。 */
-  activeStageIndex?: number | null;
-  size?: "sm" | "md";
-  showGoals?: boolean;
-}
-
-const STATE_LABEL: Record<MatSeatRunState, string> = {
-  waiting: "等待",
-  running: "执行中",
-  done: "完成",
-  failed: "失败",
-};
-
-export default function AgentFlow({
-  stages,
-  seats,
-  stageGoals,
-  seatStates,
-  activeStageIndex,
-  size = "md",
-  showGoals = false,
-}: AgentFlowProps) {
-  const seatById = new Map(seats.map((seat) => [seat.agent_id, seat]));
-
-  // 只有一个阶段时不画阶段框：席位直接横向排列。
-  if (stages.length === 1) {
-    return (
-      <div className={`mat-flow mat-flow--single mat-flow--${size}`}>
-        {stages[0]!.map((agentId) => {
-          const seat = seatById.get(agentId);
-          const state = seatStates?.[agentId] ?? null;
-          return (
-            <div
-              className={`mat-seat mat-seat--c${seatColorIndex(agentId)}${
-                state ? ` is-${state}` : ""
-              }`}
-              key={agentId}
-              title={
-                seat?.description
-                  ? `${seat.name}：${seat.description}`
-                  : (seat?.name ?? agentId)
-              }
-            >
-              <span className="mat-seat-avatar">
-                <Bot size={size === "sm" ? 11 : 12} strokeWidth={2.2} />
-              </span>
-              <span className="mat-seat-name">{seat?.name ?? agentId}</span>
-              {state && (
-                <span className={`mat-seat-dot is-${state}`} title={STATE_LABEL[state]} />
-              )}
-            </div>
-          );
-        })}
-      </div>
-    );
-  }
-
-  return (
-    <div className={`mat-flow mat-flow--${size}`}>
-      {stages.map((stage, stageIndex) => {
-        const parallel = stage.length > 1;
-        const isActive = typeof activeStageIndex === "number" && activeStageIndex === stageIndex;
-        const isPast =
-          typeof activeStageIndex === "number" && activeStageIndex > stageIndex;
-        const goal = showGoals ? stageGoals?.[stageIndex] ?? null : null;
-        return (
-          <Fragment key={`stage-${stageIndex}`}>
-            {stageIndex > 0 && (
-              <div className="mat-flow-arrow" aria-hidden="true">
-                <MoveRight size={size === "sm" ? 14 : 16} strokeWidth={2} />
-              </div>
-            )}
-            <section
-              className={[
-                "mat-flow-stage",
-                isActive ? "is-active" : "",
-                isPast ? "is-done" : "",
-              ]
-                .filter(Boolean)
-                .join(" ")}
-            >
-              <header className="mat-flow-stage-head">
-                <span className="mat-flow-stage-no">阶段 {stageIndex + 1}</span>
-                {parallel ? (
-                  <span className="mat-flow-mode is-parallel">并行 ×{stage.length}</span>
-                ) : (
-                  <span className="mat-flow-mode is-serial">串行</span>
-                )}
-              </header>
-              <div className="mat-flow-seats">
-                {stage.map((agentId) => {
-                  const seat = seatById.get(agentId);
-                  const state = seatStates?.[agentId] ?? null;
-                  return (
-                    <div
-                      className={`mat-seat mat-seat--c${seatColorIndex(agentId)}${
-                        state ? ` is-${state}` : ""
-                      }`}
-                      key={agentId}
-                      title={
-                        seat?.description
-                          ? `${seat.name}：${seat.description}`
-                          : (seat?.name ?? agentId)
-                      }
-                    >
-                      <span className="mat-seat-avatar">
-                        <Bot size={size === "sm" ? 11 : 12} strokeWidth={2.2} />
-                      </span>
-                      <span className="mat-seat-name">{seat?.name ?? agentId}</span>
-                      {state && (
-                        <span className={`mat-seat-dot is-${state}`} title={STATE_LABEL[state]} />
-                      )}
-                    </div>
-                  );
-                })}
-              </div>
-              {goal && <p className="mat-flow-goal">{goal}</p>}
-            </section>
-          </Fragment>
-        );
-      })}
-    </div>
-  );
-}

frontend-web/src/pages/official-multi-agent-tasks/components/SchedulePicker.tsx

@@ -1,76 +0,0 @@
-import { Select } from "tdesign-react";
-
-import type { ScheduleConfig, ScheduleFreq } from "@/components/workspace/scheduled-tasks/schedule-builder";
-
-import { describeScheduleConfig } from "../utils";
-
-const WEEKDAYS = ["周日", "周一", "周二", "周三", "周四", "周五", "周六"];
-const HOURS = Array.from({ length: 24 }, (_, index) => index);
-const MINUTES = [0, 15, 30, 45];
-const DATES = Array.from({ length: 31 }, (_, index) => index + 1);
-
-const FREQ_OPTIONS: Array<{ label: string; value: ScheduleFreq }> = [
-  { label: "每小时", value: "hourly" },
-  { label: "每天", value: "daily" },
-  { label: "每周", value: "weekly" },
-  { label: "每月", value: "monthly" },
-];
-
-export default function SchedulePicker({
-  value,
-  onChange,
-}: {
-  value: ScheduleConfig;
-  onChange: (config: ScheduleConfig) => void;
-}) {
-  const set = (patch: Partial<ScheduleConfig>) => onChange({ ...value, ...patch });
-  const toNumber = (input: unknown) => Number(input as string | number);
-
-  return (
-    <div className="mat-schedule-picker">
-      <div className="mat-schedule-row">
-        <Select
-          options={FREQ_OPTIONS}
-          value={value.freq}
-          onChange={(next) => set({ freq: next as ScheduleFreq })}
-        />
-        {value.freq === "hourly" && (
-          <Select
-            options={MINUTES.map((minute) => ({ label: `${minute} 分`, value: minute }))}
-            value={value.minute}
-            onChange={(next) => set({ minute: toNumber(next) })}
-          />
-        )}
-        {value.freq === "weekly" && (
-          <Select
-            options={WEEKDAYS.map((label, index) => ({ label, value: index }))}
-            value={value.weekday}
-            onChange={(next) => set({ weekday: toNumber(next) })}
-          />
-        )}
-        {value.freq === "monthly" && (
-          <Select
-            options={DATES.map((date) => ({ label: `第 ${date} 日`, value: date }))}
-            value={value.date}
-            onChange={(next) => set({ date: toNumber(next) })}
-          />
-        )}
-        {value.freq !== "hourly" && (
-          <Select
-            options={HOURS.map((hour) => ({ label: `${hour} 时`, value: hour }))}
-            value={value.hour}
-            onChange={(next) => set({ hour: toNumber(next) })}
-          />
-        )}
-        {value.freq !== "hourly" && (
-          <Select
-            options={MINUTES.map((minute) => ({ label: `${minute} 分`, value: minute }))}
-            value={value.minute}
-            onChange={(next) => set({ minute: toNumber(next) })}
-          />
-        )}
-      </div>
-      <p className="mat-schedule-preview">{describeScheduleConfig(value)} 自动执行</p>
-    </div>
-  );
-}

frontend-web/src/pages/official-multi-agent-tasks/store.ts

@@ -1,361 +0,0 @@
-/**
- * 多智能体定时任务的本地 mock 存储层。
- *
- * 后端接口尚未实现，先用 localStorage 持久化任务与运行记录：
- * - 「立即执行」写入一条运行记录，状态由 started_at + duration_ms 在
- *   读取时按当前时间推导（排队 → 按阶段推进 → 成功/失败），配合
- *   React Query 的轮询即可获得无后端的“实时”执行动画。
- * - 接口就绪后，把本文件的 CRUD 换成 HTTP 调用即可，页面无需改动。
- */
-
-import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
-
-import { uuid } from "@/core/utils/uuid";
-
-import { expandStages, nextCronDate } from "./utils";
-import type {
-  MatRunRecord,
-  MatRunStatus,
-  MatRunView,
-  MatSeatRunState,
-  MatTask,
-  MatTaskPayload,
-  MatTaskView,
-} from "./types";
-
-const STORAGE_KEY = "deerflow.official.multi-agent-tasks.v1";
-
-interface MatStore {
-  tasks: MatTask[];
-  runs: MatRunRecord[];
-}
-
-const PENDING_MS = 1_500;
-const STAGE_MS = 4_000;
-
-function readStore(): MatStore {
-  try {
-    const raw = window.localStorage.getItem(STORAGE_KEY);
-    if (raw) {
-      const parsed = JSON.parse(raw) as Partial<MatStore>;
-      if (Array.isArray(parsed.tasks)) {
-        return { tasks: parsed.tasks as MatTask[], runs: parsed.runs ?? [] };
-      }
-    }
-  } catch {
-    // 解析失败按首次访问处理，重写种子数据。
-  }
-  const seeded = seedStore();
-  writeStore(seeded);
-  return seeded;
-}
-
-function writeStore(store: MatStore) {
-  try {
-    window.localStorage.setItem(STORAGE_KEY, JSON.stringify(store));
-  } catch {
-    // 存储被禁用时静默降级为内存态。
-  }
-}
-
-function mutateStore(mutator: (store: MatStore) => MatStore): MatStore {
-  const next = mutator(readStore());
-  writeStore(next);
-  return next;
-}
-
-function hoursAgo(hours: number): string {
-  return new Date(Date.now() - hours * 3_600_000).toISOString();
-}
-
-function seedStore(): MatStore {
-  const seats = {
-    collector: { agent_id: "mat-seed-collector", name: "全网舆情采集", description: "多源检索并汇总最新舆情线索" },
-    monitor: { agent_id: "mat-seed-monitor", name: "舆情监测雷达", description: "盯住重点信源并输出监测明细" },
-    analyst: { agent_id: "mat-seed-analyst", name: "舆情研判分析", description: "对采集结果做情感与趋势研判" },
-    writer: { agent_id: "mat-seed-writer", name: "报告撰写助手", description: "把各阶段产出整理成结构化报告" },
-    verifier: { agent_id: "mat-seed-verifier", name: "数据核查员", description: "交叉校验数据与结论的可靠性" },
-    rival: { agent_id: "mat-seed-rival", name: "竞品情报员", description: "跟踪竞品动态与公开信息" },
-    researcher: { agent_id: "mat-seed-researcher", name: "行业研究员", description: "梳理行业政策与市场变化" },
-    forecaster: { agent_id: "mat-seed-forecaster", name: "趋势预测专家", description: "基于数据推演后续走势" },
-    reviewer: { agent_id: "mat-seed-reviewer", name: "内容审核官", description: "审核报告口径与合规风险" },
-  } satisfies Record<string, MatTask["seats"][number]>;
-
-  const tasks: MatTask[] = [
-    {
-      id: "mat-task-daily",
-      name: "每日舆情早报",
-      description: "每天早上自动汇总过去 24 小时重点舆情，并行采集 + 研判 + 成稿。",
-      prompt:
-        "汇总过去 24 小时与本公司相关的重点舆情：先并行完成多源采集与监测，再研判情感与趋势，最后汇总为一份不超过 1500 字的舆情早报，附风险提示。",
-      coordinator_prompt: "采集阶段允许两个智能体各自独立检索，不做信息合并；研判阶段需引用采集阶段的原始线索。",
-      cron_expr: "0 9 * * *",
-      timezone: "Asia/Shanghai",
-      enabled: true,
-      seats: [seats.collector, seats.monitor, seats.analyst, seats.writer],
-      stages: [
-        [seats.collector.agent_id, seats.monitor.agent_id],
-        [seats.analyst.agent_id],
-        [seats.writer.agent_id],
-      ],
-      stage_goals: ["并行完成全网采集与重点信源监测", "基于原始线索完成情感与趋势研判", "汇总为可直发的舆情早报"],
-      created_at: hoursAgo(24 * 18),
-      updated_at: hoursAgo(26),
-    },
-    {
-      id: "mat-task-weekly",
-      name: "周度竞品情报速览",
-      description: "每周一串行走查竞品动态，核查后输出速览简报。",
-      prompt: "跟踪 5 家核心竞品过去一周的公开动态（产品、市场、人事），核查数据可信度后输出竞品速览简报。",
-      cron_expr: "30 8 * * 1",
-      timezone: "Asia/Shanghai",
-      enabled: false,
-      seats: [seats.rival, seats.verifier, seats.writer],
-      stages: null,
-      stage_goals: null,
-      created_at: hoursAgo(24 * 40),
-      updated_at: hoursAgo(24 * 3),
-    },
-    {
-      id: "mat-task-monthly",
-      name: "月度行业洞察报告",
-      description: "每月并行完成行业研究、趋势预测与数据核查，审核后成稿。",
-      prompt:
-        "围绕所在行业输出月度洞察：行业研究员、趋势预测专家与数据核查员并行推进，随后由内容审核官把关，最终产出月度洞察报告。",
-      cron_expr: "0 10 1 * *",
-      timezone: "Asia/Shanghai",
-      enabled: true,
-      seats: [seats.researcher, seats.forecaster, seats.verifier, seats.reviewer, seats.writer],
-      stages: [
-        [seats.researcher.agent_id, seats.forecaster.agent_id, seats.verifier.agent_id],
-        [seats.reviewer.agent_id],
-        [seats.writer.agent_id],
-      ],
-      stage_goals: ["并行完成行业研究、趋势预测与数据核查", "审核结论口径与合规风险", "整合为月度洞察报告"],
-      created_at: hoursAgo(24 * 9),
-      updated_at: hoursAgo(24 * 9),
-    },
-  ];
-
-  const runs: MatRunRecord[] = [
-    runSeed("mat-task-daily", 2.2, 3, null),
-    runSeed("mat-task-daily", 26, 3, null),
-    runSeed("mat-task-daily", 50, 3, null),
-    runSeed("mat-task-weekly", 24 * 3, 3, 2),
-    runSeed("mat-task-weekly", 24 * 10, 3, null),
-  ];
-  return { tasks, runs };
-}
-
-function runSeed(
-  taskId: string,
-  hoursAgoValue: number,
-  stageTotal: number,
-  failStage: number | null,
-): MatRunRecord {
-  const started = hoursAgo(hoursAgoValue);
-  return {
-    id: uuid() as string,
-    task_id: taskId,
-    trigger: "schedule",
-    scheduled_for: started,
-    started_at: started,
-    duration_ms: PENDING_MS + stageTotal * STAGE_MS,
-    fail_stage: failStage,
-  };
-}
-
-/** 由记录 + 当前时间推导运行视图：排队 → 按阶段推进 → 成功/失败。 */
-function resolveRunView(run: MatRunRecord, stages: string[][], now = Date.now()): MatRunView {
-  const startedAt = new Date(run.started_at).getTime();
-  const elapsed = now - startedAt;
-  const stageTotal = Math.max(1, stages.length);
-  const duration = run.duration_ms || PENDING_MS + stageTotal * STAGE_MS;
-
-  const buildStates = (
-    status: MatRunStatus,
-    activeStage: number,
-  ): Record<string, MatSeatRunState> => {
-    const states: Record<string, MatSeatRunState> = {};
-    stages.forEach((stage, index) => {
-      const seatState: MatSeatRunState =
-        status === "succeeded"
-          ? "done"
-          : index < activeStage
-            ? "done"
-            : index === activeStage
-              ? status === "failed"
-                ? "failed"
-                : "running"
-              : "waiting";
-      stage.forEach((agentId) => {
-        states[agentId] = seatState;
-      });
-    });
-    return states;
-  };
-
-  if (elapsed < PENDING_MS) {
-    return {
-      ...run,
-      finished_at: null,
-      status: "pending",
-      stage_index: 0,
-      stage_total: stageTotal,
-      seat_states: buildStates("pending", -1),
-      error: null,
-    };
-  }
-
-  const failStage = typeof run.fail_stage === "number" ? run.fail_stage : null;
-  const progress = Math.min(elapsed - PENDING_MS, duration - PENDING_MS);
-  const activeStage = Math.min(Math.floor(progress / STAGE_MS), stageTotal - 1);
-
-  if (failStage !== null && activeStage >= failStage) {
-    const finishedAt = new Date(startedAt + PENDING_MS + (failStage + 1) * STAGE_MS).toISOString();
-    return {
-      ...run,
-      finished_at: finishedAt,
-      status: "failed",
-      stage_index: failStage,
-      stage_total: stageTotal,
-      seat_states: buildStates("failed", failStage),
-      error: `阶段 ${failStage + 1} 执行失败：模拟的执行异常（前端演示数据）`,
-    };
-  }
-
-  if (elapsed >= duration) {
-    return {
-      ...run,
-      finished_at: new Date(startedAt + duration).toISOString(),
-      status: "succeeded",
-      stage_index: stageTotal - 1,
-      stage_total: stageTotal,
-      seat_states: buildStates("succeeded", stageTotal),
-      error: null,
-    };
-  }
-
-  return {
-    ...run,
-    finished_at: null,
-    status: "running",
-    stage_index: activeStage,
-    stage_total: stageTotal,
-    seat_states: buildStates("running", activeStage),
-    error: null,
-  };
-}
-
-function buildTaskViews(now = Date.now()): MatTaskView[] {
-  const store = readStore();
-  return store.tasks.map((task) => {
-    const stages = expandStages(task);
-    const runs = store.runs
-      .filter((run) => run.task_id === task.id)
-      .map((run) => resolveRunView(run, stages, now))
-      .sort((a, b) => (a.started_at < b.started_at ? 1 : -1));
-    const next = task.enabled ? nextCronDate(task.cron_expr, new Date(now)) : null;
-    return {
-      ...task,
-      runs,
-      lastRun: runs[0] ?? null,
-      nextRunAt: next ? next.toISOString() : null,
-    };
-  });
-}
-
-function anyRunLive(tasks: MatTaskView[] | undefined): boolean {
-  return !!tasks?.some((task) =>
-    task.runs.some((run) => run.status === "pending" || run.status === "running"),
-  );
-}
-
-export function useMultiAgentTasks() {
-  const query = useQuery({
-    queryKey: ["mat", "tasks"],
-    queryFn: () => buildTaskViews(),
-    refetchInterval: (q) => (anyRunLive(q.state.data as MatTaskView[] | undefined) ? 1_800 : false),
-  });
-  return { tasks: query.data ?? [], isLoading: query.isLoading, error: query.error };
-}
-
-export function useMultiAgentTaskActions() {
-  const queryClient = useQueryClient();
-  const invalidate = () => queryClient.invalidateQueries({ queryKey: ["mat", "tasks"] });
-
-  const create = useMutation({
-    mutationFn: async (payload: MatTaskPayload) => {
-      const now = new Date().toISOString();
-      const task: MatTask = { ...payload, id: uuid() as string, created_at: now, updated_at: now };
-      mutateStore((store) => ({ ...store, tasks: [task, ...store.tasks] }));
-      return task;
-    },
-    onSuccess: invalidate,
-  });
-
-  const update = useMutation({
-    mutationFn: async ({ id, payload }: { id: string; payload: MatTaskPayload }) => {
-      mutateStore((store) => ({
-        ...store,
-        tasks: store.tasks.map((task) =>
-          task.id === id ? { ...task, ...payload, updated_at: new Date().toISOString() } : task,
-        ),
-      }));
-    },
-    onSuccess: invalidate,
-  });
-
-  const remove = useMutation({
-    mutationFn: async (id: string) => {
-      mutateStore((store) => ({
-        tasks: store.tasks.filter((task) => task.id !== id),
-        runs: store.runs.filter((run) => run.task_id !== id),
-      }));
-    },
-    onSuccess: invalidate,
-  });
-
-  const setEnabled = useMutation({
-    mutationFn: async ({ id, enabled }: { id: string; enabled: boolean }) => {
-      mutateStore((store) => ({
-        ...store,
-        tasks: store.tasks.map((task) =>
-          task.id === id ? { ...task, enabled, updated_at: new Date().toISOString() } : task,
-        ),
-      }));
-    },
-    onSuccess: invalidate,
-  });
-
-  const trigger = useMutation({
-    mutationFn: async (id: string) => {
-      const store = readStore();
-      const task = store.tasks.find((item) => item.id === id);
-      if (!task) throw new Error("任务不存在");
-      const stageTotal = expandStages(task).length;
-      const now = new Date().toISOString();
-      const run: MatRunRecord = {
-        id: uuid() as string,
-        task_id: id,
-        trigger: "manual",
-        scheduled_for: now,
-        started_at: now,
-        duration_ms: PENDING_MS + stageTotal * STAGE_MS,
-        fail_stage: null,
-      };
-      mutateStore((current) => ({ ...current, runs: [run, ...current.runs] }));
-      return run;
-    },
-    onSuccess: invalidate,
-  });
-
-  const removeRun = useMutation({
-    mutationFn: async (runId: string) => {
-      mutateStore((store) => ({ ...store, runs: store.runs.filter((run) => run.id !== runId) }));
-    },
-    onSuccess: invalidate,
-  });
-
-  return { create, update, remove, setEnabled, trigger, removeRun };
-}

frontend-web/src/pages/official-multi-agent-tasks/types.ts

@@ -1,92 +0,0 @@
-/**
- * 多智能体定时任务 —— 前端先行数据模型。
- *
- * 编排语义与业务链条保持一致：同一阶段（stage）内的多个智能体并行执行，
- * 阶段之间串行执行；`stages: null` 表示纯串行线性链（每个智能体一层）。
- * 当前后端尚未提供接口，数据先落 localStorage，接口就绪后只需替换 store 层。
- */
-
-export type MatRunStatus = "pending" | "running" | "succeeded" | "failed";
-export type MatSeatRunState = "waiting" | "running" | "done" | "failed";
-export type MatRunTrigger = "manual" | "schedule";
-
-/** 编排中的一个智能体席位（落库时保存名称快照，展示优先用快照）。 */
-export interface MatSeat {
-  agent_id: string;
-  name: string;
-  description?: string;
-}
-
-export interface MatTask {
-  id: string;
-  name: string;
-  description?: string;
-  /** 任务指令：本次定时执行要让智能体编队完成什么。 */
-  prompt: string;
-  /** 总控（协调者）提示词：告诉总控如何编排各阶段的产出。 */
-  coordinator_prompt?: string;
-  cron_expr: string;
-  timezone: string;
-  enabled: boolean;
-  seats: MatSeat[];
-  /** `stages[i]` 内的智能体并行，i 递增串行；null = 线性串行。 */
-  stages: string[][] | null;
-  /** 与 stages 同下标对齐的每阶段目标。 */
-  stage_goals?: (string | null)[] | null;
-  created_at: string;
-  updated_at: string;
-}
-
-/** 落库的运行记录；状态由 started_at + duration_ms 在读取时推导。 */
-export interface MatRunRecord {
-  id: string;
-  task_id: string;
-  trigger: MatRunTrigger;
-  scheduled_for: string;
-  started_at: string;
-  duration_ms: number;
-  /** 模拟在该阶段（下标）失败；null = 成功。 */
-  fail_stage?: number | null;
-}
-
-/** 读取时推导出的运行视图。 */
-export interface MatRunView {
-  id: string;
-  task_id: string;
-  trigger: MatRunTrigger;
-  scheduled_for: string;
-  started_at: string;
-  finished_at: string | null;
-  status: MatRunStatus;
-  /** 当前执行到的阶段下标（从 0 开始）。 */
-  stage_index: number;
-  stage_total: number;
-  seat_states: Record<string, MatSeatRunState>;
-  error: string | null;
-}
-
-export interface MatTaskView extends MatTask {
-  runs: MatRunView[];
-  lastRun: MatRunView | null;
-  nextRunAt: string | null;
-}
-
-/** 编辑器内部使用的阶段草稿。 */
-export interface MatStageGroup {
-  seats: MatSeat[];
-  goal: string;
-}
-
-/** 编辑器保存时对外提交的载荷。 */
-export interface MatTaskPayload {
-  name: string;
-  description?: string;
-  prompt: string;
-  coordinator_prompt?: string;
-  cron_expr: string;
-  timezone: string;
-  enabled: boolean;
-  seats: MatSeat[];
-  stages: string[][] | null;
-  stage_goals: (string | null)[] | null;
-}

frontend-web/src/pages/official-multi-agent-tasks/utils.ts

@@ -1,166 +0,0 @@
-import {
-  DEFAULT_SCHEDULE_CONFIG,
-  type ScheduleConfig,
-  parseCron,
-} from "@/components/workspace/scheduled-tasks/schedule-builder";
-
-import type { MatSeat, MatTask, MatTaskView } from "./types";
-
-const WEEKDAY_LABELS = ["周日", "周一", "周二", "周三", "周四", "周五", "周六"];
-
-function pad2(value: number) {
-  return String(value).padStart(2, "0");
-}
-
-/** 把任务里的 stages 语义展开成显式阶段列表；null = 每个席位独立一层。 */
-export function expandStages(task: Pick<MatTask, "seats" | "stages">): string[][] {
-  const known = new Set(task.seats.map((seat) => seat.agent_id));
-  if (!task.stages?.length) {
-    return task.seats.map((seat) => [seat.agent_id]);
-  }
-  const expanded = task.stages
-    .map((stage) => stage.filter((id) => known.has(id)))
-    .filter((stage) => stage.length > 0);
-  return expanded.length ? expanded : task.seats.map((seat) => [seat.agent_id]);
-}
-
-export function describeScheduleConfig(cfg: ScheduleConfig): string {
-  const clock = `${pad2(cfg.hour)}:${pad2(cfg.minute)}`;
-  switch (cfg.freq) {
-    case "hourly":
-      return `每小时 ${cfg.minute} 分`;
-    case "weekly":
-      return `每${WEEKDAY_LABELS[cfg.weekday] ?? "周一"} ${clock}`;
-    case "monthly":
-      return `每月 ${cfg.date} 日 ${clock}`;
-    default:
-      return `每天 ${clock}`;
-  }
-}
-
-/** 由 cron 反推人类可读的执行频率描述（覆盖本页生成的所有 cron 形态）。 */
-export function describeCron(cron: string | null | undefined): string {
-  const cfg = parseCron(cron ?? undefined);
-  if (!cfg) return cron || "未设置";
-  return describeScheduleConfig(cfg);
-}
-
-/** 计算下一次执行时间；仅支持本页 schedule picker 生成的 5 段 cron 形态。 */
-export function nextCronDate(cron: string | null | undefined, from = new Date()): Date | null {
-  const cfg = parseCron(cron ?? undefined);
-  if (!cfg) return null;
-  const candidate = new Date(from);
-  candidate.setSeconds(0, 0);
-  switch (cfg.freq) {
-    case "hourly": {
-      candidate.setMinutes(cfg.minute);
-      if (candidate <= from) candidate.setHours(candidate.getHours() + 1);
-      return candidate;
-    }
-    case "daily": {
-      candidate.setHours(cfg.hour, cfg.minute, 0, 0);
-      if (candidate <= from) candidate.setDate(candidate.getDate() + 1);
-      return candidate;
-    }
-    case "weekly": {
-      candidate.setHours(cfg.hour, cfg.minute, 0, 0);
-      const day = candidate.getDay();
-      let delta = (cfg.weekday - day + 7) % 7;
-      if (delta === 0 && candidate <= from) delta = 7;
-      candidate.setDate(candidate.getDate() + delta);
-      return candidate;
-    }
-    case "monthly": {
-      candidate.setHours(cfg.hour, cfg.minute, 0, 0);
-      candidate.setDate(cfg.date);
-      if (candidate <= from) candidate.setMonth(candidate.getMonth() + 1);
-      return candidate;
-    }
-    default:
-      return null;
-  }
-}
-
-export function formatDateTime(value: string | null | undefined): string {
-  if (!value) return "—";
-  const date = new Date(value);
-  if (Number.isNaN(date.getTime())) return "—";
-  return new Intl.DateTimeFormat("zh-CN", {
-    month: "2-digit",
-    day: "2-digit",
-    hour: "2-digit",
-    minute: "2-digit",
-    hour12: false,
-  }).format(date);
-}
-
-export function formatRelative(value: string | null | undefined): string {
-  if (!value) return "—";
-  const date = new Date(value);
-  if (Number.isNaN(date.getTime())) return "—";
-  const elapsed = Date.now() - date.getTime();
-  if (elapsed < 60_000) return "刚刚";
-  if (elapsed < 3_600_000) return `${Math.floor(elapsed / 60_000)} 分钟前`;
-  if (elapsed < 86_400_000) return `${Math.floor(elapsed / 3_600_000)} 小时前`;
-  if (elapsed < 7 * 86_400_000) return `${Math.floor(elapsed / 86_400_000)} 天前`;
-  return formatDateTime(value);
-}
-
-export function formatDuration(ms: number): string {
-  if (!Number.isFinite(ms) || ms <= 0) return "—";
-  const seconds = Math.round(ms / 1000);
-  if (seconds < 60) return `${seconds} 秒`;
-  const minutes = Math.floor(seconds / 60);
-  const rest = seconds % 60;
-  return rest ? `${minutes} 分 ${rest} 秒` : `${minutes} 分钟`;
-}
-
-export function runStatusLabel(status: string | null | undefined): string {
-  switch (status) {
-    case "succeeded":
-      return "执行成功";
-    case "failed":
-      return "执行失败";
-    case "running":
-      return "执行中";
-    case "pending":
-      return "排队中";
-    default:
-      return "暂无执行";
-  }
-}
-
-export type MatTaskBadge = {
-  label: string;
-  theme: "success" | "warning" | "danger" | "default";
-};
-
-/** 任务卡右上角的状态徽标：以最近一次执行状态优先，其次启停。 */
-export function taskBadgeOf(task: MatTaskView): MatTaskBadge {
-  const status = task.lastRun?.status;
-  if (status === "running" || status === "pending") {
-    return { label: "执行中", theme: "warning" };
-  }
-  if (!task.enabled) return { label: "已暂停", theme: "default" };
-  if (status === "failed") return { label: "上次失败", theme: "danger" };
-  if (status === "succeeded") return { label: "运行正常", theme: "success" };
-  return { label: "已启用", theme: "success" };
-}
-
-/** 席位配色槽位：按 agent_id 稳定散列到 0..7。 */
-export function seatColorIndex(agentId: string): number {
-  let hash = 0;
-  for (let i = 0; i < agentId.length; i += 1) {
-    hash = (hash * 31 + agentId.charCodeAt(i)) >>> 0;
-  }
-  return hash % 8;
-}
-
-export function seatIndexOf(seats: MatSeat[], agentId: string): number {
-  const index = seats.findIndex((seat) => seat.agent_id === agentId);
-  return index >= 0 ? index : seats.length;
-}
-
-export function defaultScheduleConfig(): ScheduleConfig {
-  return { ...DEFAULT_SCHEDULE_CONFIG };
-}

frontend-web/src/pages/official-task-analysis/TaskAnalysisDetailPage.tsx

@@ -1,340 +0,0 @@
-/**
- * 任务分析 · 详情页：左侧执行记录（定时 / 手动），右侧按选中运行回放流程图
- * （业务链风格节点状态 + 耗时，5 秒自动刷新），点击智能体节点打开执行过程抽屉。
- */
-
-import {
-  ArrowLeft,
-  CalendarClock,
-  CircleAlert,
-  GitBranch,
-  MessageSquareText,
-  Pencil,
-  Pause,
-  Play,
-  RefreshCw,
-  Zap,
-} from "lucide-react";
-import { useEffect, useMemo, useState } from "react";
-import { useNavigate } from "react-router-dom";
-import { Button, Switch, Tag } from "tdesign-react";
-import { toast } from "sonner";
-
-import { OFFICIAL_DEERFLOW_ROUTE_PREFIX } from "@/core/official-deerflow/routes";
-import {
-  formatDateTime,
-  formatDuration,
-  formatRelative,
-} from "@/pages/official-multi-agent-tasks/utils";
-
-import BindingDialog from "./components/BindingDialog";
-import SeatProcessDrawer from "./components/SeatProcessDrawer";
-import { ChainFlowDiagram } from "@/roundtable-planning/components/ChainFlowDiagram";
-import { taskBadgeOf } from "./badge";
-import { useTaTaskActions, useTaTasks, useTaTaskRuns } from "./store";
-
-const RUN_STATUS_TEXT: Record<string, string> = {
-  succeeded: "成功",
-  failed: "失败",
-  running: "执行中",
-  pending: "排队中",
-};
-
-const RUN_STATUS_THEME: Record<string, "success" | "danger" | "warning" | "default"> = {
-  succeeded: "success",
-  failed: "danger",
-  running: "warning",
-  pending: "default",
-};
-
-export default function TaskAnalysisDetailPage({
-  routeTaskId,
-}: {
-  routeTaskId: string | null;
-}) {
-  const navigate = useNavigate();
-  const { views, isLoading } = useTaTasks();
-  const actions = useTaTaskActions();
-  const taskView = views.find(({ task }) => task.id === routeTaskId) ?? null;
-  const task = taskView?.task ?? null;
-  const { runs, isLoading: runsLoading } = useTaTaskRuns(task?.id ?? null);
-
-  const [selectedRunId, setSelectedRunId] = useState<string | null>(null);
-  const [seatAgentId, setSeatAgentId] = useState<string | null>(null);
-  const [bindingVisible, setBindingVisible] = useState(false);
-  const [busy, setBusy] = useState(false);
-
-  // 默认选中最近一次运行；新触发的运行自动跟随。
-  useEffect(() => {
-    if (!runs.length) return;
-    if (!selectedRunId || !runs.some((run) => run.id === selectedRunId)) {
-      setSelectedRunId(runs[0]!.id);
-    }
-  }, [runs, selectedRunId]);
-
-  const selectedRun = useMemo(
-    () => runs.find((run) => run.id === selectedRunId) ?? runs[0] ?? null,
-    [runs, selectedRunId],
-  );
-
-  const backToList = () => {
-    navigate(`${OFFICIAL_DEERFLOW_ROUTE_PREFIX}/workspace/task-analysis`);
-  };
-
-  const runTrigger = async (manual: boolean) => {
-    if (!task) return;
-    setBusy(true);
-    try {
-      if (manual) {
-        await actions.triggerManualRun.mutateAsync(task.id);
-        toast.success("已发起手动执行（总控问答）");
-      } else {
-        await actions.triggerRun.mutateAsync(task.id);
-        toast.success("已触发定时执行");
-      }
-      setSelectedRunId(null);
-    } catch {
-      toast.error("任务未绑定分析方案");
-    } finally {
-      setBusy(false);
-    }
-  };
-
-  const runToggle = async () => {
-    if (!task?.binding) return;
-    setBusy(true);
-    try {
-      await actions.setEnabled.mutateAsync({
-        taskId: task.id,
-        enabled: !task.binding?.enabled,
-      });
-      toast.success(task.binding?.enabled ? "已暂停" : "已恢复");
-    } catch {
-      toast.error("操作失败，请重试");
-    } finally {
-      setBusy(false);
-    }
-  };
-
-  if (!isLoading && !task) {
-    return (
-      <section className="ta-page">
-        <div className="ta-state ta-state--empty">
-          <h3>任务不存在或已被删除</h3>
-          <Button theme="primary" onClick={backToList}>
-            返回任务列表
-          </Button>
-        </div>
-      </section>
-    );
-  }
-
-  const binding = task?.binding ?? null;
-  const taskBadge = task && taskView ? taskBadgeOf(task, taskView.runs) : null;
-  const live = selectedRun?.status === "running" || selectedRun?.status === "pending";
-
-  return (
-    <section className="ta-page ta-detail-page">
-      <header className="ta-detail-head">
-        <button
-          aria-label="返回任务列表"
-          className="ta-back"
-          onClick={backToList}
-          type="button"
-        >
-          <ArrowLeft size={18} />
-        </button>
-        <div className="ta-detail-heading">
-          <h1>
-            {task?.name ?? "…"}
-            <em>{task?.sourceTaskId}</em>
-          </h1>
-          <p>
-            {binding ? (
-              <>
-                <GitBranch aria-hidden="true" size={13} />
-                {binding.chainTitle} · {binding.cronText}
-                {binding.directionNotes.length > 0 &&
-                  ` · ${binding.directionNotes.length} 条方向备注`}
-              </>
-            ) : (
-              task?.description
-            )}
-          </p>
-        </div>
-        {taskBadge && (
-          <Tag theme={taskBadge.theme} variant="light">
-            {taskBadge.label}
-          </Tag>
-        )}
-        {binding && (
-          <Switch value={binding.enabled} onChange={() => void runToggle()} />
-        )}
-        <div className="ta-detail-ops">
-          {binding && (
-            <>
-              <Button
-                disabled={busy}
-                loading={busy}
-                theme="primary"
-                onClick={() => void runTrigger(false)}
-              >
-                <Zap aria-hidden="true" size={15} />
-                立即执行
-              </Button>
-              <Button variant="outline" disabled={busy} onClick={() => void runTrigger(true)}>
-                <MessageSquareText aria-hidden="true" size={15} />
-                模拟手动执行
-              </Button>
-            </>
-          )}
-          <Button variant="outline" onClick={() => setBindingVisible(true)}>
-            <Pencil aria-hidden="true" size={15} />
-            {binding ? "编辑绑定" : "配置分析"}
-          </Button>
-        </div>
-      </header>
-
-      {!binding ? (
-        <div className="ta-detail-empty">
-          <GitBranch aria-hidden="true" size={26} />
-          <h3>尚未配置分析方案</h3>
-          <p>绑定业务链与内容块映射后，这里将展示执行记录与各智能体的执行流程。</p>
-          <Button theme="primary" onClick={() => setBindingVisible(true)}>
-            配置分析
-          </Button>
-        </div>
-      ) : (
-        <div className="ta-detail-layout">
-          <aside className="ta-runs">
-            <header className="ta-runs-head">
-              <h2>执行记录</h2>
-              <span>
-                <RefreshCw aria-hidden="true" className={live ? "ta-spin" : undefined} size={12} />
-                每 5 秒刷新
-              </span>
-            </header>
-            <div className="ta-runs-list">
-              {runsLoading && !runs.length ? (
-                <p className="ta-runs-empty">正在加载执行记录…</p>
-              ) : runs.length ? (
-                runs.map((run) => {
-                  const active = selectedRun?.id === run.id;
-                  const duration = run.finishedAt
-                    ? formatDuration(
-                        new Date(run.finishedAt).getTime() - new Date(run.startedAt).getTime(),
-                      )
-                    : null;
-                  return (
-                    <button
-                      className={`ta-run-item${active ? " is-active" : ""}`}
-                      key={run.id}
-                      onClick={() => setSelectedRunId(run.id)}
-                      type="button"
-                    >
-                      <span className="ta-run-item-top">
-                        {run.trigger === "manual" ? (
-                          <MessageSquareText aria-hidden="true" size={13} />
-                        ) : (
-                          <CalendarClock aria-hidden="true" size={13} />
-                        )}
-                        <b>{run.trigger === "manual" ? "手动执行" : "定时执行"}</b>
-                        <Tag size="small" theme={RUN_STATUS_THEME[run.status] ?? "default"} variant="light">
-                          {RUN_STATUS_TEXT[run.status] ?? run.status}
-                        </Tag>
-                      </span>
-                      <span className="ta-run-item-time">
-                        {formatDateTime(run.startedAt)} · {duration ?? "进行中"}
-                      </span>
-                      {run.trigger === "manual" && run.manualSummary && (
-                        <span className="ta-run-item-summary">{run.manualSummary}</span>
-                      )}
-                      {run.trigger === "schedule" && (
-                        <span className="ta-run-item-blocks">
-                          内容块 {run.blockStates.filter((b) => b.state === "done").length}/
-                          {run.blockStates.length}
-                        </span>
-                      )}
-                    </button>
-                  );
-                })
-              ) : (
-                <p className="ta-runs-empty">还没有执行记录，点「立即执行」体验完整流程。</p>
-              )}
-            </div>
-          </aside>
-
-          <section className="ta-flow-panel">
-            {selectedRun ? (
-              <>
-                <header className="ta-flow-head">
-                  <h2>
-                    执行流程
-                    <small>
-                      {selectedRun.trigger === "manual" ? "手动执行" : "定时执行"} ·{" "}
-                      {formatRelative(selectedRun.startedAt)}
-                      {selectedRun.status === "running" &&
-                        ` · 阶段 ${Math.min(selectedRun.stageIndex + 1, selectedRun.stageTotal)}/${selectedRun.stageTotal} 执行中`}
-                    </small>
-                  </h2>
-                  <span className="ta-flow-legend">
-                    <i className="ta-dot is-done" /> 完成
-                    <i className="ta-dot is-running" /> 执行中
-                    <i className="ta-dot is-waiting" /> 等待
-                    <i className="ta-dot is-failed" /> 失败
-                  </span>
-                </header>
-                <div className="ta-flow-canvas">
-                  <ChainFlowDiagram
-                    className="ta-flow-diagram"
-                    onNodeClick={(agentId) => setSeatAgentId(agentId)}
-                    seatStates={selectedRun.seatInfos}
-                    stages={selectedRun.stages.map((stage, index) => ({
-                      seats: stage.map((agentId) => ({
-                        agent_id: agentId,
-                        name: selectedRun.seatNames[agentId] ?? agentId,
-                      })),
-                      goal: selectedRun.stageGoals?.[index] ?? null,
-                    }))}
-                  />
-                </div>
-                {selectedRun.error && (
-                  <p className="ta-flow-error">
-                    <CircleAlert aria-hidden="true" size={14} />
-                    {selectedRun.error}
-                  </p>
-                )}
-              </>
-            ) : (
-              <div className="ta-flow-panel-empty">选择左侧一条执行记录查看流程</div>
-            )}
-          </section>
-        </div>
-      )}
-
-      <SeatProcessDrawer
-        onClose={() => setSeatAgentId(null)}
-        run={selectedRun}
-        seatAgentId={seatAgentId}
-        task={task ?? undefined}
-      />
-
-      <BindingDialog
-        onClose={() => setBindingVisible(false)}
-        onSubmit={async (payload) => {
-          if (!task) return;
-          try {
-            await actions.bind.mutateAsync({ taskId: task.id, payload });
-            toast.success(binding ? "绑定已更新" : "分析方案已绑定");
-            setBindingVisible(false);
-          } catch {
-            toast.error("保存失败，请重试");
-          }
-        }}
-        submitting={actions.bind.isPending}
-        task={task}
-        visible={bindingVisible}
-      />
-    </section>
-  );
-}

frontend-web/src/pages/official-task-analysis/TaskAnalysisPage.tsx

@@ -1,460 +0,0 @@
-/**
- * 任务分析 · 列表页：对方系统推送过来的外部任务 + 我们的绑定状态。
- * 任务卡片沿用多智能体定时任务的卡片视觉（浅红规范）。
- */
-
-import {
-  CalendarClock,
-  CircleAlert,
-  CircleCheck,
-  Clock3,
-  GitBranch,
-  Link2,
-  Network,
-  Pencil,
-  Pause,
-  Play,
-  Plus,
-  Search,
-  Trash2,
-  Zap,
-} from "lucide-react";
-import { useMemo, useState } from "react";
-import { useNavigate } from "react-router-dom";
-import {
-  Button,
-  DialogPlugin,
-  Input,
-  Popconfirm,
-  Switch,
-  Tabs,
-  Tag,
-} from "tdesign-react";
-import { toast } from "sonner";
-
-import { OFFICIAL_DEERFLOW_ROUTE_PREFIX } from "@/core/official-deerflow/routes";
-
-import AgentFlow from "@/pages/official-multi-agent-tasks/components/AgentFlow";
-import type { MatSeat } from "@/pages/official-multi-agent-tasks/types";
-import {
-  formatDateTime,
-  formatRelative,
-} from "@/pages/official-multi-agent-tasks/utils";
-
-import BindingDialog from "./components/BindingDialog";
-import CreateTaskDialog, {
-  type TaCreateTaskPayload,
-} from "./components/CreateTaskDialog";
-import { chainStagesOf, useTaTaskActions, useTaTasks } from "./store";
-import type { TaTask, TaTaskViewLike } from "./page-types";
-import { taskBadgeOf } from "./badge";
-
-import "./task-analysis.css";
-
-type StatusFilter = "all" | "unbound" | "enabled" | "paused" | "failed";
-
-function isTaskLive(runs: TaTaskViewLike["runs"]) {
-  return runs.some((run) => run.status === "running" || run.status === "pending");
-}
-
-export default function TaskAnalysisPage() {
-  const navigate = useNavigate();
-  const { views, isLoading } = useTaTasks();
-  const actions = useTaTaskActions();
-  const [search, setSearch] = useState("");
-  const [filter, setFilter] = useState<StatusFilter>("all");
-  const [bindingTask, setBindingTask] = useState<TaTask | null>(null);
-  const [bindingVisible, setBindingVisible] = useState(false);
-  const [createVisible, setCreateVisible] = useState(false);
-  const [busyTaskId, setBusyTaskId] = useState<string | null>(null);
-
-  const visibleViews = useMemo(() => {
-    const keyword = search.trim().toLowerCase();
-    return views.filter(({ task, runs }) => {
-      const lastStatus = runs[0]?.status ?? null;
-      const bound = !!task.binding;
-      const live = isTaskLive(runs);
-      if (filter === "unbound" && bound) return false;
-      if (filter === "enabled" && (!bound || !task.binding!.enabled || live)) return false;
-      if (filter === "paused" && (!bound || task.binding!.enabled)) return false;
-      if (filter === "failed" && lastStatus !== "failed") return false;
-      if (!keyword) return true;
-      return (
-        task.name.toLowerCase().includes(keyword) ||
-        task.description.toLowerCase().includes(keyword) ||
-        task.sourceTaskId.toLowerCase().includes(keyword)
-      );
-    });
-  }, [views, search, filter]);
-
-  const stats = useMemo(
-    () => ({
-      total: views.length,
-      unbound: views.filter(({ task }) => !task.binding).length,
-      enabled: views.filter(({ task }) => task.binding?.enabled).length,
-      failed: views.filter(({ runs }) => runs[0]?.status === "failed").length,
-    }),
-    [views],
-  );
-
-  const openDetail = (taskId: string) => {
-    navigate(`${OFFICIAL_DEERFLOW_ROUTE_PREFIX}/workspace/task-analysis/${encodeURIComponent(taskId)}`);
-  };
-
-  const openBinding = (task: TaTask) => {
-    setBindingTask(task);
-    setBindingVisible(true);
-  };
-
-  const handleCreate = async (payload: TaCreateTaskPayload) => {
-    try {
-      const created = await actions.createTask.mutateAsync({
-        name: payload.name,
-        sourceTaskId: payload.sourceTaskId,
-        description: payload.description,
-      });
-      await actions.bind.mutateAsync({ taskId: created.id, payload: payload.binding });
-      toast.success("任务已创建并绑定分析方案");
-      setCreateVisible(false);
-    } catch {
-      toast.error("创建失败，请重试");
-    }
-  };
-
-  const handleBind = async (payload: Parameters<typeof actions.bind.mutateAsync>[0]["payload"]) => {
-    if (!bindingTask) return;
-    try {
-      await actions.bind.mutateAsync({ taskId: bindingTask.id, payload });
-      toast.success(bindingTask.binding ? "绑定已更新" : "分析方案已绑定");
-      setBindingVisible(false);
-      setBindingTask(null);
-    } catch {
-      toast.error("保存失败，请重试");
-    }
-  };
-
-  const runTrigger = async (taskId: string) => {
-    setBusyTaskId(taskId);
-    try {
-      await actions.triggerRun.mutateAsync(taskId);
-      toast.success("已触发执行");
-      openDetail(taskId);
-    } catch {
-      toast.error("触发失败：任务未绑定分析方案");
-    } finally {
-      setBusyTaskId(null);
-    }
-  };
-
-  const runToggle = async (task: TaTask) => {
-    setBusyTaskId(task.id);
-    try {
-      await actions.setEnabled.mutateAsync({ taskId: task.id, enabled: !task.binding?.enabled });
-      toast.success(task.binding?.enabled ? "已暂停" : "已恢复");
-    } catch {
-      toast.error("操作失败，请重试");
-    } finally {
-      setBusyTaskId(null);
-    }
-  };
-
-  const confirmDelete = (task: TaTask) => {
-    const dialog = DialogPlugin.confirm({
-      header: "删除外部任务",
-      body: `删除「${task.name}」将同时清除其绑定与全部执行记录（对应对外删除接口语义），确定删除？`,
-      confirmBtn: { content: "删除", theme: "danger" },
-      cancelBtn: "取消",
-      onConfirm: () => {
-        dialog.destroy();
-        void actions.removeTask.mutateAsync(task.id).then(() => {
-          toast.success("任务已删除");
-        });
-      },
-      onClose: () => dialog.destroy(),
-    });
-  };
-
-  return (
-    <section className="ta-page">
-      <header className="ta-page-head">
-        <div className="ta-page-head-copy">
-          <h1>任务分析定时</h1>
-          <p>
-            外部系统任务接入多智能体定时分析：绑定业务链与内容块映射，按计划执行并沉淀时间线版本。
-          </p>
-        </div>
-        <div className="ta-page-head-actions">
-          <Button
-            variant="outline"
-            onClick={() => {
-              const unbound = views.find(({ task }) => !task.binding)?.task;
-              if (unbound) openBinding(unbound);
-              else toast.info("当前任务均已绑定分析方案");
-            }}
-          >
-            配置未绑定任务
-          </Button>
-          <Button theme="primary" onClick={() => setCreateVisible(true)}>
-            <Plus aria-hidden="true" size={15} />
-            新建任务
-          </Button>
-        </div>
-      </header>
-
-      <div className="ta-stats" aria-label="任务统计">
-        <div className="ta-stat">
-          <span className="ta-stat-icon is-primary" aria-hidden="true">
-            <Network size={18} />
-          </span>
-          <div className="ta-stat-copy">
-            <strong>{stats.total}</strong>
-            <span>外部任务</span>
-          </div>
-        </div>
-        <div className="ta-stat">
-          <span className="ta-stat-icon is-warning" aria-hidden="true">
-            <Link2 size={18} />
-          </span>
-          <div className="ta-stat-copy">
-            <strong>{stats.unbound}</strong>
-            <span>未配置</span>
-          </div>
-        </div>
-        <div className="ta-stat">
-          <span className="ta-stat-icon is-success" aria-hidden="true">
-            <CircleCheck size={18} />
-          </span>
-          <div className="ta-stat-copy">
-            <strong>{stats.enabled}</strong>
-            <span>已启用</span>
-          </div>
-        </div>
-        <div className="ta-stat">
-          <span className="ta-stat-icon is-danger" aria-hidden="true">
-            <CircleAlert size={18} />
-          </span>
-          <div className="ta-stat-copy">
-            <strong>{stats.failed}</strong>
-            <span>最近失败</span>
-          </div>
-        </div>
-      </div>
-
-      <div className="ta-body">
-        <div className="ta-toolbar">
-          <div className="ta-toolbar-search">
-            <Input
-              clearable
-              placeholder="搜索任务名称 / 简介 / 对方任务号"
-              prefixIcon={<Search aria-hidden="true" size={15} />}
-              value={search}
-              onChange={(value) => setSearch(String(value ?? ""))}
-            />
-          </div>
-          <Tabs
-            className="ta-toolbar-tabs"
-            value={filter}
-            onChange={(value) => setFilter(value as StatusFilter)}
-          >
-            <Tabs.TabPanel label="全部" value="all" />
-            <Tabs.TabPanel label="未配置" value="unbound" />
-            <Tabs.TabPanel label="已启用" value="enabled" />
-            <Tabs.TabPanel label="已暂停" value="paused" />
-            <Tabs.TabPanel label="最近失败" value="failed" />
-          </Tabs>
-        </div>
-
-        {isLoading ? (
-          <div className="ta-state">
-            <Clock3 aria-hidden="true" className="ta-spin" size={18} />
-            正在加载外部任务…
-          </div>
-        ) : visibleViews.length ? (
-          <div className="ta-grid">
-            {visibleViews.map(({ task, runs }) => {
-              const badge = taskBadgeOf(task, runs);
-              const binding = task.binding;
-              const lastRun = runs[0] ?? null;
-              const busy = busyTaskId === task.id;
-              const stages = binding ? chainStagesOf(binding) : [];
-              const seats: MatSeat[] = stages
-                .flat()
-                .filter((id, index, all) => all.indexOf(id) === index)
-                .map((id) => ({
-                  agent_id: id,
-                  name: lastRun?.seatNames[id] ?? id,
-                }));
-              return (
-                <article className="ta-card" key={task.id}>
-                  <header className="ta-card-head" onClick={() => openDetail(task.id)}>
-                    <span className="ta-card-glyph" aria-hidden="true">
-                      <Network size={17} />
-                    </span>
-                    <div className="ta-card-title">
-                      <h3>
-                        {task.name}
-                        <em>{task.sourceTaskId}</em>
-                      </h3>
-                      <p>{task.description}</p>
-                    </div>
-                    <Tag size="small" theme={badge.theme} variant="light">
-                      {badge.label}
-                    </Tag>
-                  </header>
-
-                  {binding ? (
-                    <>
-                      <div className="ta-card-binding" onClick={() => openDetail(task.id)}>
-                        <span>
-                          <GitBranch aria-hidden="true" size={13} />
-                          {binding.chainTitle}
-                        </span>
-                        <span>
-                          <CalendarClock aria-hidden="true" size={13} />
-                          {binding.cronText}
-                        </span>
-                      </div>
-                      <div className="ta-card-flow" onClick={() => openDetail(task.id)}>
-                        <AgentFlow seats={seats} size="sm" stages={stages} />
-                      </div>
-                    </>
-                  ) : (
-                    <button className="ta-card-unbound" onClick={() => openBinding(task)} type="button">
-                      <GitBranch aria-hidden="true" size={15} />
-                      配置分析：选择业务链 · 内容块映射 · 执行频率
-                    </button>
-                  )}
-
-                  <footer className="ta-card-foot">
-                    <div className="ta-card-meta">
-                      <span>
-                        下次{" "}
-                        {binding?.enabled
-                          ? formatDateTime(nextRunAt(binding.cron))
-                          : binding
-                            ? "已暂停"
-                            : "未配置"}
-                      </span>
-                      <span>
-                        上次 {lastRun ? formatRelative(lastRun.startedAt) : "未执行"}
-                        {lastRun && lastRun.status !== "pending" && (
-                          <em className={`ta-run-text is-${lastRun.status}`}>
-                            · {lastRun.status === "succeeded" ? "成功" : lastRun.status === "failed" ? "失败" : "执行中"}
-                          </em>
-                        )}
-                      </span>
-                    </div>
-                    <div className="ta-card-ops">
-                      {binding && (
-                        <>
-                          <Button
-                            disabled={busy}
-                            loading={busy}
-                            size="small"
-                            theme="primary"
-                            variant="text"
-                            onClick={() => void runTrigger(task.id)}
-                          >
-                            <Zap aria-hidden="true" size={14} />
-                            立即执行
-                          </Button>
-                          <Button
-                            disabled={busy}
-                            size="small"
-                            variant="text"
-                            onClick={() => void runToggle(task)}
-                          >
-                            {binding.enabled ? (
-                              <Pause aria-hidden="true" size={14} />
-                            ) : (
-                              <Play aria-hidden="true" size={14} />
-                            )}
-                            {binding.enabled ? "暂停" : "恢复"}
-                          </Button>
-                          <Button size="small" variant="text" onClick={() => openBinding(task)}>
-                            <Pencil aria-hidden="true" size={14} />
-                            编辑绑定
-                          </Button>
-                        </>
-                      )}
-                      <Popconfirm
-                        content="删除后绑定与执行记录一并清除，确定？"
-                        placement="bottom-right"
-                        theme="danger"
-                        onConfirm={() => confirmDelete(task)}
-                      >
-                        <Button className="ta-danger-btn" size="small" variant="text">
-                          <Trash2 aria-hidden="true" size={14} />
-                        </Button>
-                      </Popconfirm>
-                    </div>
-                  </footer>
-                </article>
-              );
-            })}
-          </div>
-        ) : (
-          <div className="ta-state ta-state--empty">
-            <span className="ta-state-glyph" aria-hidden="true">
-              <Network size={22} />
-            </span>
-            <h3>{views.length ? "没有符合条件的任务" : "还没有外部任务"}</h3>
-            <p>
-              {views.length
-                ? "换个关键词或筛选条件试试。"
-                : "对方系统创建任务并调用创建接口后，任务会出现在这里。"}
-            </p>
-          </div>
-        )}
-
-        <p className="ta-footnote">
-          <CircleAlert aria-hidden="true" size={13} />
-          前端演示阶段：任务与执行数据保存在本浏览器，业务链来自真实接口；后端服务接入后自动切换。
-        </p>
-      </div>
-
-      <CreateTaskDialog
-        onClose={() => setCreateVisible(false)}
-        onSubmit={handleCreate}
-        submitting={actions.createTask.isPending}
-        visible={createVisible}
-      />
-
-      <BindingDialog
-        onClose={() => {
-          setBindingVisible(false);
-          setBindingTask(null);
-        }}
-        onSubmit={handleBind}
-        submitting={actions.bind.isPending}
-        task={bindingTask}
-        visible={bindingVisible}
-      />
-    </section>
-  );
-}
-
-/** 简易下次执行时间（覆盖本页生成的 cron 形态）。 */
-function nextRunAt(cron: string): string | null {
-  const parts = cron.trim().split(/\s+/);
-  if (parts.length !== 5) return null;
-  const [min, hour, , , wd] = parts;
-  const now = new Date();
-  const candidate = new Date(now);
-  const minute = parseInt(min ?? "0", 10);
-  const hourNum = parseInt(hour ?? "9", 10);
-  if (`${hour}` === "*") {
-    candidate.setMinutes(minute, 0, 0);
-    if (candidate <= now) candidate.setHours(candidate.getHours() + 1);
-  } else if (`${wd}` !== "*") {
-    const weekday = parseInt(wd ?? "1", 10);
-    candidate.setHours(hourNum, minute, 0, 0);
-    let delta = (weekday - candidate.getDay() + 7) % 7;
-    if (delta === 0 && candidate <= now) delta = 7;
-    candidate.setDate(candidate.getDate() + delta);
-  } else {
-    candidate.setHours(hourNum, minute, 0, 0);
-    if (candidate <= now) candidate.setDate(candidate.getDate() + 1);
-  }
-  return candidate.toISOString();
-}

frontend-web/src/pages/official-task-analysis/badge.ts

@@ -1,19 +0,0 @@
-import type { TaRunView, TaTask } from "./types";
-
-export interface TaBadge {
-  label: string;
-  theme: "success" | "warning" | "danger" | "default";
-}
-
-/** 任务卡右上角状态徽标：最近一次执行优先，其次启停，未绑定给引导态。 */
-export function taskBadgeOf(task: TaTask, runs: TaRunView[]): TaBadge {
-  const status = runs[0]?.status;
-  if (status === "running" || status === "pending") {
-    return { label: "执行中", theme: "warning" };
-  }
-  if (!task.binding) return { label: "未配置", theme: "default" };
-  if (!task.binding.enabled) return { label: "已暂停", theme: "default" };
-  if (status === "failed") return { label: "上次失败", theme: "danger" };
-  if (status === "succeeded") return { label: "运行正常", theme: "success" };
-  return { label: "已启用", theme: "success" };
-}

frontend-web/src/pages/official-task-analysis/components/BindingDialog.tsx

@@ -1,223 +0,0 @@
-/**
- * 绑定配置弹窗：选业务链（真实 /api/roundtable-chains + 内置演示链）→ 配置
- * 对方详情块 → 席位映射 → 执行频率 / 启用 / 总控提示。
- */
-
-import { Radio } from "lucide-react";
-import { useEffect, useMemo, useState } from "react";
-import { useQuery } from "@tanstack/react-query";
-import { Button, Dialog, Switch, Textarea } from "tdesign-react";
-import { toast } from "sonner";
-
-import { listChains } from "@/roundtable-planning/api/chains";
-import type { BusinessChain } from "@/roundtable-planning/lib/business-chain";
-import { type ScheduleConfig } from "@/components/workspace/scheduled-tasks/schedule-builder";
-
-import AgentFlow from "@/pages/official-multi-agent-tasks/components/AgentFlow";
-import SchedulePicker from "@/pages/official-multi-agent-tasks/components/SchedulePicker";
-import type { MatSeat } from "@/pages/official-multi-agent-tasks/types";
-import {
-  defaultScheduleConfig,
-  describeScheduleConfig,
-} from "@/pages/official-multi-agent-tasks/utils";
-
-import type { TaBinding, TaBindingPayload, TaTask } from "../types";
-
-/** 内置演示链（种子里用它，保证无后端数据时链路可演示）。 */
-export const SEED_CHAIN: BusinessChain = {
-  id: "seed-chain-std",
-  title: "标准舆情分析链（内置）",
-  description: "采集 + 核查并行 → 研判 → 成稿，演示用内置编排。",
-  seats: [
-    { agent_id: "collector", name: "全网舆情采集" },
-    { agent_id: "verifier", name: "数据核查员" },
-    { agent_id: "analyst", name: "舆情研判分析" },
-    { agent_id: "writer", name: "报告撰写助手" },
-  ],
-  stages: [
-    ["collector", "verifier"],
-    ["analyst"],
-    ["writer"],
-  ],
-  stageGoals: null,
-  isPublic: true,
-};
-
-export function chainStages(chain: BusinessChain): string[][] {
-  if (chain.stages?.length) return chain.stages;
-  return chain.seats.map((seat) => [seat.agent_id]);
-}
-
-export function chainSeats(chain: BusinessChain): MatSeat[] {
-  return chain.seats.map((seat) => ({
-    agent_id: seat.agent_id,
-    name: seat.name,
-    description: seat.description,
-  }));
-}
-
-/** 模块级空数组：data 未就绪时保持引用稳定，避免 effect 依赖无限循环。 */
-export const NO_CHAINS: BusinessChain[] = [];
-
-export default function BindingDialog({
-  visible,
-  task,
-  submitting,
-  onClose,
-  onSubmit,
-}: {
-  visible: boolean;
-  task: TaTask | null;
-  submitting: boolean;
-  onClose: () => void;
-  onSubmit: (payload: TaBindingPayload) => void;
-}) {
-  const [chainId, setChainId] = useState("");
-  const [schedule, setSchedule] = useState<ScheduleConfig>(defaultScheduleConfig());
-  const [enabled, setEnabled] = useState(true);
-  const [coordinatorPrompt, setCoordinatorPrompt] = useState("");
-
-  const { data, isLoading: chainsLoading } = useQuery({
-    queryKey: ["ta", "chains"],
-    queryFn: async () => {
-      const [mine, publicChains] = await Promise.all([
-        listChains("mine").catch(() => [] as BusinessChain[]),
-        listChains("public").catch(() => [] as BusinessChain[]),
-      ]);
-      const byId = new Map<string, BusinessChain>();
-      for (const chain of [SEED_CHAIN, ...mine, ...publicChains]) {
-        if (!byId.has(chain.id)) byId.set(chain.id, chain);
-      }
-      return [...byId.values()];
-    },
-    enabled: visible,
-  });
-  const chains = data ?? NO_CHAINS;
-
-  useEffect(() => {
-    if (!visible) return;
-    const binding: TaBinding | null = task?.binding ?? null;
-    const initialChain =
-      chains.find((chain) => chain.id === binding?.chainId) ??
-      chains[0] ??
-      SEED_CHAIN;
-    setChainId(binding?.chainId ?? initialChain.id);
-    setEnabled(binding?.enabled ?? true);
-    setCoordinatorPrompt(binding?.coordinatorPrompt ?? "");
-  }, [visible, task, chains]);
-
-  const selectedChain = useMemo(
-    () => chains.find((chain) => chain.id === chainId) ?? null,
-    [chains, chainId],
-  );
-  const handleChainChange = (nextId: string) => {
-    setChainId(nextId);
-  };
-
-  const trySubmit = () => {
-    if (!selectedChain) {
-      toast.warning("请选择业务链");
-      return;
-    }
-    onSubmit({
-      chainId: selectedChain.id,
-      chainTitle: selectedChain.title,
-      schedule,
-      enabled,
-      coordinatorPrompt: coordinatorPrompt.trim() || undefined,
-    });
-  };
-
-  return (
-    <Dialog
-      className="ta-binding-dialog"
-      closeBtn
-      closeOnOverlayClick={false}
-      destroyOnClose
-      footer={
-        <div className="ta-dialog-footer">
-          <Button variant="outline" onClick={onClose}>
-            取消
-          </Button>
-          <Button loading={submitting} theme="primary" onClick={trySubmit}>
-            {task?.binding ? "保存绑定" : "创建绑定"}
-          </Button>
-        </div>
-      }
-      header={task?.binding ? `编辑绑定 · ${task.name}` : `配置分析 · ${task?.name ?? ""}`}
-      placement="top"
-      visible={visible}
-      width={860}
-      onClose={onClose}
-    >
-      <div className="ta-binding">
-        <section className="ta-binding-section">
-          <header className="ta-binding-section-head">
-            <h4>选择业务链</h4>
-            <span>定时执行将按业务链的多智能体关系（同阶段并行 · 阶段间串行）运行</span>
-          </header>
-          {chainsLoading ? (
-            <p className="ta-binding-tip">正在加载业务链…</p>
-          ) : (
-            <div className="ta-chain-grid">
-              {chains.map((chain) => {
-                const active = chain.id === chainId;
-                return (
-                  <button
-                    className={`ta-chain-card${active ? " is-active" : ""}`}
-                    key={chain.id}
-                    onClick={() => handleChainChange(chain.id)}
-                    type="button"
-                  >
-                    <header>
-                      <Radio aria-hidden="true" size={14} />
-                      <span className="ta-chain-card-title">{chain.title}</span>
-                      <em>
-                        {chain.seats.length} 智能体 · {chainStages(chain).length} 阶段
-                      </em>
-                    </header>
-                    {chain.description && <p>{chain.description}</p>}
-                    <div className="ta-chain-card-flow">
-                      <AgentFlow
-                        seats={chainSeats(chain)}
-                        size="sm"
-                        stages={chainStages(chain)}
-                      />
-                    </div>
-                  </button>
-                );
-              })}
-            </div>
-          )}
-        </section>
-
-        <section className="ta-binding-section">
-          <header className="ta-binding-section-head">
-            <h4>执行设置</h4>
-            <span>{describeScheduleConfig(schedule)} 自动执行</span>
-          </header>
-          <div className="ta-binding-settings">
-            <div className="ta-field">
-              <span className="ta-field-label">执行频率</span>
-              <SchedulePicker value={schedule} onChange={setSchedule} />
-            </div>
-            <label className="ta-field">
-              <span className="ta-field-label">总控提示（可选）</span>
-              <Textarea
-                autosize={{ minRows: 2, maxRows: 4 }}
-                maxlength={500}
-                placeholder="写给总控（协调者）的编排要求；问答沉淀的「方向备注」也会注入后续执行"
-                value={coordinatorPrompt}
-                onChange={(value) => setCoordinatorPrompt(String(value ?? ""))}
-              />
-            </label>
-            <div className="ta-field ta-field--switch">
-              <span className="ta-field-label">绑定后立即启用</span>
-              <Switch value={enabled} onChange={(value) => setEnabled(!!value)} />
-            </div>
-          </div>
-        </section>
-      </div>
-    </Dialog>
-  );
-}

frontend-web/src/pages/official-task-analysis/components/CreateTaskDialog.tsx

@@ -1,242 +0,0 @@
-/**
- * 新建任务弹窗（一步式）：任务信息（名称/任务号/简介）+ 业务链选择 +
- * 执行设置（频率 / 总控提示 / 启用），提交后直接创建任务并完成绑定。
- */
-
-import { Radio } from "lucide-react";
-import { useEffect, useMemo, useState } from "react";
-import { useQuery } from "@tanstack/react-query";
-import { Button, Dialog, Input, Switch, Textarea } from "tdesign-react";
-import { toast } from "sonner";
-
-import { listChains } from "@/roundtable-planning/api/chains";
-import type { BusinessChain } from "@/roundtable-planning/lib/business-chain";
-import { type ScheduleConfig } from "@/components/workspace/scheduled-tasks/schedule-builder";
-
-import AgentFlow from "@/pages/official-multi-agent-tasks/components/AgentFlow";
-import SchedulePicker from "@/pages/official-multi-agent-tasks/components/SchedulePicker";
-import {
-  defaultScheduleConfig,
-  describeScheduleConfig,
-} from "@/pages/official-multi-agent-tasks/utils";
-import type { MatSeat } from "@/pages/official-multi-agent-tasks/types";
-
-import { NO_CHAINS, SEED_CHAIN, chainSeats, chainStages } from "./BindingDialog";
-import type { TaBindingPayload } from "../types";
-
-export interface TaCreateTaskPayload {
-  name: string;
-  sourceTaskId?: string;
-  description?: string;
-  binding: TaBindingPayload;
-}
-
-export default function CreateTaskDialog({
-  visible,
-  submitting,
-  onClose,
-  onSubmit,
-}: {
-  visible: boolean;
-  submitting: boolean;
-  onClose: () => void;
-  onSubmit: (payload: TaCreateTaskPayload) => void;
-}) {
-  const [name, setName] = useState("");
-  const [sourceTaskId, setSourceTaskId] = useState("");
-  const [description, setDescription] = useState("");
-  const [chainId, setChainId] = useState("");
-  const [schedule, setSchedule] = useState<ScheduleConfig>(defaultScheduleConfig());
-  const [enabled, setEnabled] = useState(true);
-  const [coordinatorPrompt, setCoordinatorPrompt] = useState("");
-
-  const { data, isLoading: chainsLoading } = useQuery({
-    queryKey: ["ta", "chains"],
-    queryFn: async () => {
-      const [mine, publicChains] = await Promise.all([
-        listChains("mine").catch(() => [] as BusinessChain[]),
-        listChains("public").catch(() => [] as BusinessChain[]),
-      ]);
-      const byId = new Map<string, BusinessChain>();
-      for (const chain of [SEED_CHAIN, ...mine, ...publicChains]) {
-        if (!byId.has(chain.id)) byId.set(chain.id, chain);
-      }
-      return [...byId.values()];
-    },
-    enabled: visible,
-  });
-  const chains = data ?? NO_CHAINS;
-
-  useEffect(() => {
-    if (!visible) return;
-    setName("");
-    setSourceTaskId("");
-    setDescription("");
-    setSchedule(defaultScheduleConfig());
-    setEnabled(true);
-    setCoordinatorPrompt("");
-    setChainId((prev) => (chains.some((chain) => chain.id === prev) ? prev : chains[0]?.id ?? SEED_CHAIN.id));
-  }, [visible, chains]);
-
-  const selectedChain = useMemo(
-    () => chains.find((chain) => chain.id === chainId) ?? null,
-    [chains, chainId],
-  );
-
-  const trySubmit = () => {
-    if (!name.trim()) {
-      toast.warning("请填写任务名称");
-      return;
-    }
-    if (!selectedChain) {
-      toast.warning("请选择业务链");
-      return;
-    }
-    onSubmit({
-      name,
-      sourceTaskId: sourceTaskId.trim() || undefined,
-      description: description.trim() || undefined,
-      binding: {
-        chainId: selectedChain.id,
-        chainTitle: selectedChain.title,
-        schedule,
-        enabled,
-        coordinatorPrompt: coordinatorPrompt.trim() || undefined,
-      },
-    });
-  };
-
-  return (
-    <Dialog
-      className="ta-create-dialog"
-      closeBtn
-      closeOnOverlayClick={false}
-      destroyOnClose
-      footer={
-        <div className="ta-dialog-footer">
-          <Button variant="outline" onClick={onClose}>
-            取消
-          </Button>
-          <Button loading={submitting} theme="primary" onClick={trySubmit}>
-            创建任务并绑定
-          </Button>
-        </div>
-      }
-      header="新建任务"
-      placement="top"
-      visible={visible}
-      width={860}
-      onClose={onClose}
-    >
-      <div className="ta-binding">
-        <section className="ta-binding-section">
-          <header className="ta-binding-section-head">
-            <h4>任务信息</h4>
-            <span>由本页录入；接入对方系统后，推送创建的任务同样出现在列表中</span>
-          </header>
-          <div className="ta-create-grid">
-            <label className="ta-field">
-              <span className="ta-field-label">
-                任务名称<i className="ta-required">*</i>
-              </span>
-              <Input
-                clearable
-                maxlength={40}
-                placeholder="例如：东南亚舆论环境监测"
-                value={name}
-                onChange={(value) => setName(String(value ?? ""))}
-              />
-            </label>
-            <label className="ta-field">
-              <span className="ta-field-label">对方任务号（可选）</span>
-              <Input
-                clearable
-                maxlength={32}
-                placeholder="留空自动生成"
-                value={sourceTaskId}
-                onChange={(value) => setSourceTaskId(String(value ?? ""))}
-              />
-            </label>
-            <label className="ta-field ta-field--wide">
-              <span className="ta-field-label">任务简介</span>
-              <Textarea
-                autosize={{ minRows: 2, maxRows: 4 }}
-                maxlength={200}
-                placeholder="一句话说明任务背景与分析目标，定时执行时作为任务上下文注入各智能体"
-                value={description}
-                onChange={(value) => setDescription(String(value ?? ""))}
-              />
-            </label>
-          </div>
-        </section>
-
-        <section className="ta-binding-section">
-          <header className="ta-binding-section-head">
-            <h4>执行设置</h4>
-            <span>{describeScheduleConfig(schedule)} 自动执行</span>
-          </header>
-          <div className="ta-binding-settings">
-            <div className="ta-field">
-              <span className="ta-field-label">执行频率</span>
-              <SchedulePicker value={schedule} onChange={setSchedule} />
-            </div>
-            <label className="ta-field">
-              <span className="ta-field-label">总控提示（可选）</span>
-              <Textarea
-                autosize={{ minRows: 2, maxRows: 4 }}
-                maxlength={500}
-                placeholder="写给总控（协调者）的编排要求；问答沉淀的「方向备注」也会注入后续执行"
-                value={coordinatorPrompt}
-                onChange={(value) => setCoordinatorPrompt(String(value ?? ""))}
-              />
-            </label>
-            <div className="ta-field ta-field--switch">
-              <span className="ta-field-label">创建后立即启用</span>
-              <Switch value={enabled} onChange={(value) => setEnabled(!!value)} />
-            </div>
-          </div>
-        </section>
-        <section className="ta-binding-section">
-          <header className="ta-binding-section-head">
-            <h4>选择业务链</h4>
-            <span>定时执行按业务链的多智能体关系（同阶段并行 · 阶段间串行）运行</span>
-          </header>
-          {chainsLoading ? (
-            <p className="ta-binding-tip">正在加载业务链…</p>
-          ) : (
-            <div className="ta-chain-grid">
-              {chains.map((chain) => {
-                const active = chain.id === chainId;
-                return (
-                  <button
-                    className={`ta-chain-card${active ? " is-active" : ""}`}
-                    key={chain.id}
-                    onClick={() => setChainId(chain.id)}
-                    type="button"
-                  >
-                    <header>
-                      <Radio aria-hidden="true" size={14} />
-                      <span className="ta-chain-card-title">{chain.title}</span>
-                      <em>
-                        {chain.seats.length} 智能体 · {chainStages(chain).length} 阶段
-                      </em>
-                    </header>
-                    {chain.description && <p>{chain.description}</p>}
-                    <div className="ta-chain-card-flow">
-                      <AgentFlow
-                        seats={chainSeats(chain) as MatSeat[]}
-                        size="sm"
-                        stages={chainStages(chain)}
-                      />
-                    </div>
-                  </button>
-                );
-              })}
-            </div>
-          )}
-        </section>
-
-      </div>
-    </Dialog>
-  );
-}

frontend-web/src/pages/official-task-analysis/components/SeatProcessDrawer.tsx

@@ -1,122 +0,0 @@
-/**
- * 席位执行过程抽屉：点击流程图节点打开，展示该智能体在某次运行里的完整过程
- * （输入 → AI 分析 → 工具调用 → 产物块）。后端就绪后由 runs/{id}/messages?seat= 提供数据。
- */
-
-import { ArrowDownRight, Bot, Wrench } from "lucide-react";
-import { Drawer, Tag } from "tdesign-react";
-
-import { seatColorIndex } from "@/pages/official-multi-agent-tasks/utils";
-import { buildSeatProcess } from "../store";
-import type { TaRunView, TaSeatState, TaTask } from "../types";
-
-const STATE_THEME: Record<TaSeatState, "success" | "warning" | "danger" | "default"> = {
-  done: "success",
-  running: "warning",
-  failed: "danger",
-  waiting: "default",
-};
-
-const STATE_TEXT: Record<TaSeatState, string> = {
-  waiting: "等待执行",
-  running: "执行中",
-  done: "已完成",
-  failed: "执行失败",
-};
-
-const KIND_LABEL: Record<string, string> = {
-  input: "输入",
-  ai: "分析",
-  tool: "工具",
-  artifact: "产物",
-};
-
-function formatDuration(ms: number): string {
-  if (!Number.isFinite(ms) || ms <= 0) return "—";
-  const seconds = Math.round(ms / 1000);
-  if (seconds < 60) return `${seconds} 秒`;
-  return `${Math.floor(seconds / 60)} 分 ${seconds % 60} 秒`;
-}
-
-export default function SeatProcessDrawer({
-  run,
-  seatAgentId,
-  task,
-  onClose,
-}: {
-  run: TaRunView | null;
-  seatAgentId: string | null;
-  task: TaTask | undefined;
-  onClose: () => void;
-}) {
-  const visible = !!run && !!seatAgentId;
-  const process =
-    visible && run ? buildSeatProcess(run, seatAgentId!, task) : null;
-  const info = run?.seatInfos[seatAgentId ?? ""] ?? null;
-
-  return (
-    <Drawer
-      className="ta-seat-drawer"
-      closeBtn
-      destroyOnClose
-      footer={null}
-      header={
-        process ? (
-          <div className="ta-seat-header">
-            <span className={`ta-seat-glyph ta-seat--c${seatColorIndex(seatAgentId ?? "")}`} aria-hidden="true">
-              <Bot size={18} />
-            </span>
-            <div className="ta-seat-heading">
-              <h3>{process.seatName}</h3>
-              <p>执行过程 · {run?.trigger === "manual" ? "手动执行（总控问答）" : "定时执行"}</p>
-            </div>
-            {info && (
-              <Tag size="small" theme={STATE_THEME[info.state]} variant="light">
-                {STATE_TEXT[info.state]}
-              </Tag>
-            )}
-          </div>
-        ) : null
-      }
-      placement="right"
-      size="520px"
-      visible={visible}
-      onClose={onClose}
-    >
-      {process && (
-        <div className="ta-seat-process">
-          {info && (
-            <div className="ta-seat-meta">
-              <span>状态：{STATE_TEXT[info.state]}</span>
-              <span>耗时：{formatDuration(info.durationMs)}</span>
-              <span>所属阶段：第 {(run?.stages.findIndex((stage) => stage.includes(seatAgentId ?? "")) ?? -1) + 1} 阶段</span>
-            </div>
-          )}
-          <ol className="ta-seat-timeline">
-            {process.messages.map((message, index) => (
-              <li className={`ta-seat-item is-${message.kind}`} key={index}>
-                <span className="ta-seat-item-marker">
-                  {message.kind === "tool" ? (
-                    <Wrench size={11} />
-                  ) : (
-                    <ArrowDownRight size={11} />
-                  )}
-                </span>
-                <div className="ta-seat-item-body">
-                  <header>
-                    <em className={`ta-seat-item-kind is-${message.kind}`}>
-                      {KIND_LABEL[message.kind] ?? message.kind}
-                    </em>
-                    <span className="ta-seat-item-title">{message.title}</span>
-                  </header>
-                  <p>{message.content}</p>
-                  {message.detail && <pre>{message.detail}</pre>}
-                </div>
-              </li>
-            ))}
-          </ol>
-        </div>
-      )}
-    </Drawer>
-  );
-}

frontend-web/src/pages/official-task-analysis/page-types.ts

@@ -1,4 +0,0 @@
-import type { TaRunView, TaTask } from "./types";
-
-export type { TaRunView, TaTask };
-export type TaTaskViewLike = { task: TaTask; runs: TaRunView[] };

frontend-web/src/pages/official-task-analysis/store.ts

@@ -1,611 +0,0 @@
-/**
- * 外部任务定时分析的本地 mock 存储层（与 multi-agent-tasks 同款模式）。
- *
- * - 任务/绑定/运行记录落 localStorage；「立即执行 / 模拟手动执行」写入运行记录，
- *   状态由 startedAt + durationMs 按当前时间推导（排队 → 按阶段推进 → 成功/失败），
- *   配合 React Query 轮询获得无后端的"实时"流程图推进。
- * - 席位执行过程消息在读取侧按席位生成（buildSeatProcess），不入库。
- * - 对外接口（创建/删除/详情时间线/问答）就绪后替换本层。
- */
-
-import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
-
-import { buildCron } from "@/components/workspace/scheduled-tasks/schedule-builder";
-import { describeScheduleConfig } from "@/pages/official-multi-agent-tasks/utils";
-import { uuid } from "@/core/utils/uuid";
-
-import type {
-  TaBlockMapping,
-  TaBinding,
-  TaBindingPayload,
-  TaRunRecord,
-  TaRunStatus,
-  TaRunView,
-  TaSeatRunInfo,
-  TaSeatState,
-  TaTask,
-} from "./types";
-
-const STORAGE_KEY = "deerflow.official.task-analysis.v2";
-
-interface TaStore {
-  tasks: TaTask[];
-  runs: TaRunRecord[];
-  /** 上次绑定时选择的业务链 id（创建接口响应里的 default_chain_id 记忆）。 */
-  lastChainId: string | null;
-}
-
-const PENDING_MS = 2_000;
-const STAGE_MS = 6_000;
-
-/** 对方系统定义的详情块类型（mock 固定清单；接接口后由创建方传入）。 */
-export const TA_BLOCK_TYPES: Array<{ key: string; name: string }> = [
-  { key: "background", name: "任务背景" },
-  { key: "dynamics", name: "动态分析" },
-  { key: "risk", name: "风险研判" },
-  { key: "action", name: "行动建议" },
-  { key: "conclusion", name: "结论汇总" },
-];
-
-function readStore(): TaStore {
-  try {
-    const raw = window.localStorage.getItem(STORAGE_KEY);
-    if (raw) {
-      const parsed = JSON.parse(raw) as Partial<TaStore>;
-      if (Array.isArray(parsed.tasks)) {
-        return {
-          tasks: parsed.tasks as TaTask[],
-          runs: parsed.runs ?? [],
-          lastChainId: parsed.lastChainId ?? null,
-        };
-      }
-    }
-  } catch {
-    // 解析失败按首次访问处理。
-  }
-  const seeded = seedStore();
-  writeStore(seeded);
-  return seeded;
-}
-
-function writeStore(store: TaStore) {
-  try {
-    window.localStorage.setItem(STORAGE_KEY, JSON.stringify(store));
-  } catch {
-    // 存储被禁用时静默降级为内存态。
-  }
-}
-
-function mutateStore(mutator: (store: TaStore) => TaStore): TaStore {
-  const next = mutator(readStore());
-  writeStore(next);
-  return next;
-}
-
-function hoursAgo(hours: number): string {
-  return new Date(Date.now() - hours * 3_600_000).toISOString();
-}
-
-function seedStore(): TaStore {
-  const seats = {
-    collector: "全网舆情采集",
-    analyst: "舆情研判分析",
-    writer: "报告撰写助手",
-    verifier: "数据核查员",
-    forecaster: "趋势预测专家",
-  };
-
-  const tasks: TaTask[] = [
-    {
-      id: "ta-task-1",
-      sourceTaskId: "TS-2026-0147",
-      name: "东南亚舆论环境监测",
-      description: "对方系统推送的任务：持续跟踪东南亚重点渠道舆论动向，输出结构化分析详情。",
-      binding: {
-        chainId: "seed-chain-std",
-        chainTitle: "标准舆情分析链",
-        cron: "0 9 * * *",
-        cronText: "每天 09:00",
-        enabled: true,
-        blocks: [
-          { key: "background", name: "任务背景", seatAgentId: "collector" },
-          { key: "dynamics", name: "动态分析", seatAgentId: "collector" },
-          { key: "risk", name: "风险研判", seatAgentId: "analyst" },
-          { key: "action", name: "行动建议", seatAgentId: "analyst" },
-          { key: "conclusion", name: "结论汇总", seatAgentId: "writer" },
-        ],
-        coordinatorPrompt: "采集阶段允许独立检索；研判阶段需引用采集阶段的原始线索。",
-        directionNotes: ["重点关注宗教节日前后的舆论波动。"],
-        timezone: "Asia/Shanghai",
-      },
-      createdAt: hoursAgo(24 * 12),
-    },
-    {
-      id: "ta-task-2",
-      sourceTaskId: "TS-2026-0152",
-      name: "竞品新品发布追踪",
-      description: "追踪 5 家核心竞品的新品发布与市场反应，按块更新详情内容。",
-      binding: {
-        chainId: "seed-chain-single",
-        chainTitle: "单阶段并行分析链",
-        cron: "30 8 * * 1",
-        cronText: "每周一 08:30",
-        enabled: false,
-        blocks: [
-          { key: "background", name: "任务背景", seatAgentId: "verifier" },
-          { key: "dynamics", name: "动态分析", seatAgentId: "collector" },
-          { key: "conclusion", name: "结论汇总", seatAgentId: "writer" },
-        ],
-        directionNotes: [],
-        timezone: "Asia/Shanghai",
-      },
-      createdAt: hoursAgo(24 * 8),
-    },
-    {
-      id: "ta-task-3",
-      sourceTaskId: "TS-2026-0160",
-      name: "行业政策周报编制",
-      description: "对方系统刚创建的任务，尚未配置分析方案。",
-      binding: null,
-      createdAt: hoursAgo(5),
-    },
-  ];
-
-  const stdStages = [
-    ["collector", "verifier"],
-    ["analyst"],
-    ["writer"],
-  ];
-  const singleStages = [["collector", "verifier", "analyst"]];
-  const stdNames = seats;
-
-  const runs: TaRunRecord[] = [
-    {
-      id: uuid() as string,
-      taskId: "ta-task-1",
-      trigger: "schedule",
-      scheduledFor: hoursAgo(2.1),
-      startedAt: hoursAgo(2.1),
-      durationMs: PENDING_MS + stdStages.length * STAGE_MS,
-      stages: stdStages,
-      stageGoals: ["并行完成全网采集与数据核查", "研判风险与行动方向", "汇总各块结论"],
-      seatNames: stdNames,
-      failStage: null,
-    },
-    {
-      id: uuid() as string,
-      taskId: "ta-task-1",
-      trigger: "manual",
-      scheduledFor: hoursAgo(20),
-      startedAt: hoursAgo(20),
-      durationMs: PENDING_MS + stdStages.length * STAGE_MS,
-      stages: stdStages,
-      stageGoals: ["并行完成全网采集与数据核查", "研判风险与行动方向", "汇总各块结论"],
-      seatNames: stdNames,
-      failStage: null,
-      manualSummary: "总控问答：要求研判阶段补充跨平台对比维度，已确认应用到后续执行。",
-    },
-    {
-      id: uuid() as string,
-      taskId: "ta-task-1",
-      trigger: "schedule",
-      scheduledFor: hoursAgo(26),
-      startedAt: hoursAgo(26),
-      durationMs: PENDING_MS + stdStages.length * STAGE_MS,
-      stages: stdStages,
-      stageGoals: ["并行完成全网采集与数据核查", "研判风险与行动方向", "汇总各块结论"],
-      seatNames: stdNames,
-      failStage: 1,
-    },
-    {
-      id: uuid() as string,
-      taskId: "ta-task-2",
-      trigger: "schedule",
-      scheduledFor: hoursAgo(24 * 3),
-      startedAt: hoursAgo(24 * 3),
-      durationMs: PENDING_MS + singleStages.length * STAGE_MS,
-      stages: singleStages,
-      stageGoals: ["三席并行：采集 / 核查 / 研判同时产出"],
-      seatNames: stdNames,
-      failStage: null,
-    },
-  ];
-
-  return { tasks, runs, lastChainId: "seed-chain-std" };
-}
-
-/** 由记录 + 当前时间推导运行视图：各席位状态/耗时、块产出状态。 */
-function resolveRunView(run: TaRunRecord, task: TaTask | undefined, now = Date.now()): TaRunView {
-  const startedAt = new Date(run.startedAt).getTime();
-  const elapsed = now - startedAt;
-  const stageTotal = Math.max(1, run.stages.length);
-  const duration = run.durationMs || PENDING_MS + stageTotal * STAGE_MS;
-
-  const buildSeatInfos = (
-    status: TaRunStatus,
-    activeStage: number,
-  ): Record<string, TaSeatRunInfo> => {
-    const infos: Record<string, TaSeatRunInfo> = {};
-    run.stages.forEach((stage, index) => {
-      const stageStart = PENDING_MS + index * STAGE_MS;
-      const stageEnd = stageStart + STAGE_MS;
-      const finished = status === "succeeded" || (status === "failed" && index < activeStage);
-      const active = !finished && index === activeStage && status !== "pending";
-      const state: TaSeatState = finished
-        ? "done"
-        : active
-          ? status === "failed"
-            ? "failed"
-            : "running"
-          : "waiting";
-      const durationMs = finished
-        ? Math.min(elapsed - stageStart, STAGE_MS)
-        : active
-          ? Math.min(elapsed - stageStart, STAGE_MS)
-          : 0;
-      stage.forEach((agentId) => {
-        infos[agentId] = { state, durationMs };
-      });
-    });
-    return infos;
-  };
-
-  let status: TaRunStatus;
-  let stageIndex: number;
-  let finishedAt: string | null = null;
-  let error: string | null = null;
-
-  if (elapsed < PENDING_MS) {
-    status = "pending";
-    stageIndex = 0;
-  } else {
-    const progress = Math.min(elapsed - PENDING_MS, duration - PENDING_MS);
-    stageIndex = Math.min(Math.floor(progress / STAGE_MS), stageTotal - 1);
-    if (run.failStage !== null && stageIndex >= run.failStage) {
-      status = "failed";
-      stageIndex = run.failStage;
-      finishedAt = new Date(startedAt + PENDING_MS + (run.failStage + 1) * STAGE_MS).toISOString();
-      const failSeat = run.stages[run.failStage]?.[0];
-      error = `阶段 ${run.failStage + 1} 执行失败：${run.seatNames[failSeat ?? ""] ?? "席位"} 模拟执行异常`;
-    } else if (elapsed >= duration) {
-      status = "succeeded";
-      stageIndex = stageTotal - 1;
-      finishedAt = new Date(startedAt + duration).toISOString();
-    } else {
-      status = "running";
-    }
-  }
-
-  const seatInfos = buildSeatInfos(status, status === "pending" ? -1 : stageIndex);
-
-  const blockStates = (task?.binding?.blocks ?? []).map((block) => ({
-    key: block.key,
-    name: block.name,
-    state: seatInfos[block.seatAgentId]?.state ?? "waiting",
-  }));
-
-  return {
-    ...run,
-    finishedAt,
-    status,
-    stageIndex,
-    stageTotal,
-    seatInfos,
-    error,
-    blockStates,
-  };
-}
-
-function buildTaskViews(now = Date.now()): Array<{ task: TaTask; runs: TaRunView[] }> {
-  const store = readStore();
-  return store.tasks.map((task) => {
-    const runs = store.runs
-      .filter((run) => run.taskId === task.id)
-      .map((run) => resolveRunView(run, task, now))
-      .sort((a, b) => (a.startedAt < b.startedAt ? 1 : -1));
-    return { task, runs };
-  });
-}
-
-function anyRunLive(views: Array<{ runs: TaRunView[] }> | undefined): boolean {
-  return !!views?.some(({ runs }) =>
-    runs.some((run) => run.status === "pending" || run.status === "running"),
-  );
-}
-
-/** 列表 + 每任务运行视图；运行中 5 秒轮询（设计定稿：流程图每 5 秒刷新）。 */
-export function useTaTasks() {
-  const query = useQuery({
-    queryKey: ["ta", "tasks"],
-    queryFn: () => buildTaskViews(),
-    refetchInterval: (q) =>
-      anyRunLive(q.state.data as Array<{ runs: TaRunView[] }> | undefined) ? 5_000 : false,
-  });
-  const views = query.data ?? [];
-  return { views, tasks: views.map((view) => view.task), isLoading: query.isLoading };
-}
-
-export function useTaTaskRuns(taskId: string | null) {
-  const query = useQuery({
-    queryKey: ["ta", "tasks", taskId],
-    queryFn: () => {
-      const view = buildTaskViews().find((item) => item.task.id === taskId);
-      return view?.runs ?? [];
-    },
-    enabled: !!taskId,
-    refetchInterval: (q) => {
-      const runs = q.state.data as TaRunView[] | undefined;
-      const live = !!runs?.some((run) => run.status === "pending" || run.status === "running");
-      return live ? 5_000 : false;
-    },
-  });
-  return { runs: query.data ?? [], isLoading: query.isLoading };
-}
-
-export function useTaTaskActions() {
-  const queryClient = useQueryClient();
-  const invalidate = () => queryClient.invalidateQueries({ queryKey: ["ta"] });
-
-  /** 页面手动创建外部任务（名称必填；对方任务号留空则自动生成）。 */
-  const createTask = useMutation({
-    mutationFn: async (payload: {
-      name: string;
-      sourceTaskId?: string;
-      description?: string;
-    }) => {
-      const task: TaTask = {
-        id: uuid() as string,
-        sourceTaskId:
-          payload.sourceTaskId?.trim() ||
-          `TS-${new Date().getFullYear()}-${String(Date.now()).slice(-5)}`,
-        name: payload.name.trim(),
-        description: payload.description?.trim() || "",
-        binding: null,
-        createdAt: new Date().toISOString(),
-      };
-      mutateStore((store) => ({ ...store, tasks: [task, ...store.tasks] }));
-      return task;
-    },
-    onSuccess: invalidate,
-  });
-
-  /** 绑定 / 修改绑定（记录 lastChainId 供创建接口返回默认项）。 */
-  const bind = useMutation({
-    mutationFn: async ({ taskId, payload }: { taskId: string; payload: TaBindingPayload }) => {
-      const cron = buildCron(payload.schedule);
-      mutateStore((store) => ({
-        ...store,
-        lastChainId: payload.chainId,
-        tasks: store.tasks.map((task) =>
-          task.id === taskId
-            ? {
-                ...task,
-                binding: {
-                  chainId: payload.chainId,
-                  chainTitle: payload.chainTitle,
-                  cron,
-                  cronText: describeScheduleConfig(payload.schedule),
-                  enabled: payload.enabled,
-                  blocks: payload.blocks ?? task.binding?.blocks ?? [],
-                  coordinatorPrompt: payload.coordinatorPrompt,
-                  directionNotes: task.binding?.directionNotes ?? [],
-                  timezone: task.binding?.timezone ?? "Asia/Shanghai",
-                } satisfies TaBinding,
-              }
-            : task,
-        ),
-      }));
-    },
-    onSuccess: invalidate,
-  });
-
-  const unbind = useMutation({
-    mutationFn: async (taskId: string) => {
-      mutateStore((store) => ({
-        ...store,
-        tasks: store.tasks.map((task) =>
-          task.id === taskId ? { ...task, binding: null } : task,
-        ),
-        runs: store.runs.filter((run) => run.taskId !== taskId),
-      }));
-    },
-    onSuccess: invalidate,
-  });
-
-  const setEnabled = useMutation({
-    mutationFn: async ({ taskId, enabled }: { taskId: string; enabled: boolean }) => {
-      mutateStore((store) => ({
-        ...store,
-        tasks: store.tasks.map((task) =>
-          task.id === taskId && task.binding
-            ? { ...task, binding: { ...task.binding, enabled } }
-            : task,
-        ),
-      }));
-    },
-    onSuccess: invalidate,
-  });
-
-  /** 删除外部任务（对应对外删除接口：任务 + 绑定 + 执行记录彻底删除）。 */
-  const removeTask = useMutation({
-    mutationFn: async (taskId: string) => {
-      mutateStore((store) => ({
-        ...store,
-        tasks: store.tasks.filter((task) => task.id !== taskId),
-        runs: store.runs.filter((run) => run.taskId !== taskId),
-      }));
-    },
-    onSuccess: invalidate,
-  });
-
-  /** 立即触发一次定时执行（schedule）。 */
-  const triggerRun = useMutation({
-    mutationFn: async (taskId: string) => {
-      const store = readStore();
-      const task = store.tasks.find((item) => item.id === taskId);
-      const binding = task?.binding;
-      if (!task || !binding) throw new Error("任务未绑定分析方案");
-      const stages = chainStagesOf(binding, store);
-      const now = new Date().toISOString();
-      const run: TaRunRecord = {
-        id: uuid() as string,
-        taskId,
-        trigger: "schedule",
-        scheduledFor: now,
-        startedAt: now,
-        durationMs: PENDING_MS + stages.length * STAGE_MS,
-        stages,
-        stageGoals: stages.map((_, index) => stageGoalOf(index)),
-        seatNames: Object.fromEntries(stages.flat().map((id) => [id, seatDisplayName(id)])),
-        failStage: null,
-      };
-      mutateStore((current) => ({ ...current, runs: [run, ...current.runs] }));
-      return run;
-    },
-    onSuccess: invalidate,
-  });
-
-  /** 模拟一次手动执行（对方详情页总控问答产生）。 */
-  const triggerManualRun = useMutation({
-    mutationFn: async (taskId: string) => {
-      const store = readStore();
-      const task = store.tasks.find((item) => item.id === taskId);
-      const binding = task?.binding;
-      if (!task || !binding) throw new Error("任务未绑定分析方案");
-      const stages = chainStagesOf(binding, store);
-      const now = new Date().toISOString();
-      const run: TaRunRecord = {
-        id: uuid() as string,
-        taskId,
-        trigger: "manual",
-        scheduledFor: now,
-        startedAt: now,
-        durationMs: PENDING_MS + stages.length * STAGE_MS,
-        stages,
-        stageGoals: stages.map((_, index) => stageGoalOf(index)),
-        seatNames: Object.fromEntries(stages.flat().map((id) => [id, seatDisplayName(id)])),
-        failStage: null,
-        manualSummary: "总控问答：按对方详情页提问，总控给对应席位派活并汇总结论。",
-      };
-      mutateStore((current) => ({ ...current, runs: [run, ...current.runs] }));
-      return run;
-    },
-    onSuccess: invalidate,
-  });
-
-  return { createTask, bind, unbind, setEnabled, removeTask, triggerRun, triggerManualRun };
-}
-
-/** 绑定链的编排（种子任务用内置编排；真实业务链按其 stages 展开，null = 线性）。 */
-export function chainStagesOf(
-  binding: Pick<TaBinding, "chainId">,
-  store: TaStore = readStore(),
-): string[][] {
-  if (binding.chainId === "seed-chain-std") {
-    return [
-      ["collector", "verifier"],
-      ["analyst"],
-      ["writer"],
-    ];
-  }
-  if (binding.chainId === "seed-chain-single") {
-    return [["collector", "verifier", "analyst"]];
-  }
-  // 真实业务链的编排由页面侧传入的 chain 数据展开；存储层兜底为单席位串行。
-  const seats = seedSeatsOf(store);
-  return seats.map((agentId) => [agentId]);
-}
-
-function seedSeatsOf(_store: TaStore): string[] {
-  return ["collector", "verifier", "analyst", "writer"];
-}
-
-/** 演示用的阶段目标（seed 链固定；真实链由绑定快照提供）。 */
-function stageGoalOf(stageIndex: number): string | null {
-  const goals = ["并行完成全网采集与数据核查", "研判风险与行动方向", "汇总各块结论"];
-  return goals[stageIndex] ?? null;
-}
-
-export function seatDisplayName(agentId: string): string {
-  const names: Record<string, string> = {
-    collector: "全网舆情采集",
-    verifier: "数据核查员",
-    analyst: "舆情研判分析",
-    writer: "报告撰写助手",
-    forecaster: "趋势预测专家",
-  };
-  return names[agentId] ?? agentId;
-}
-
-// ── 席位执行过程（读取侧生成 mock）────────────────────────────────────────
-
-export interface TaSeatMessage {
-  kind: "input" | "ai" | "tool" | "artifact";
-  title: string;
-  content: string;
-  detail?: string;
-}
-
-/** 生成某席位在某次运行里的执行过程消息（后端就绪后换 runs/{id}/messages?seat=）。 */
-export function buildSeatProcess(
-  run: TaRunView,
-  seatAgentId: string,
-  task: TaTask | undefined,
-): { seatName: string; messages: TaSeatMessage[]; blocks: TaBlockMapping[] } {
-  const seatName = run.seatNames[seatAgentId] ?? seatAgentId;
-  const info = run.seatInfos[seatAgentId] ?? { state: "waiting" as TaSeatState, durationMs: 0 };
-  const stageIndex = run.stages.findIndex((stage) => stage.includes(seatAgentId));
-  const blocks = (task?.binding?.blocks ?? []).filter(
-    (block) => block.seatAgentId === seatAgentId,
-  );
-
-  const messages: TaSeatMessage[] = [
-    {
-      kind: "input",
-      title: "输入 · 任务上下文",
-      content:
-        `${task?.name ?? ""}（对方任务 ${task?.sourceTaskId ?? "-"}）\n` +
-        `${task?.description ?? ""}\n\n` +
-        (blocks.length
-          ? `本席位负责产出：${blocks.map((block) => block.name).join("、")}。`
-          : "按业务链席位职责执行。") +
-        (stageIndex > 0
-          ? `\n上一阶段产出摘要：${run.stages[stageIndex - 1]
-              ?.map((id) => run.seatNames[id])
-              .join("、")} 的中间结论已注入。`
-          : ""),
-    },
-  ];
-
-  if (info.state === "waiting") {
-    return { seatName, messages, blocks };
-  }
-
-  messages.push({
-    kind: "ai",
-    title: "AI 分析",
-    content:
-      `（${seatName} 的分析过程 · 演示内容）\n` +
-      `围绕任务简介拆解检索方向，交叉核对来源可信度，形成本席位负责块的结构化结论。`,
-  });
-
-  messages.push({
-    kind: "tool",
-    title: "工具调用 · web_search",
-    content: "query=\"任务关键词 最新动态\" → 命中 12 条，采纳 7 条（含来源与时间）",
-    detail:
-      '{"results":[{"title":"来源A：行业动态","snippet":"……"},{"title":"来源B：政策更新","snippet":"……"}]}',
-  });
-
-  if (info.state === "done") {
-    blocks.forEach((block) => {
-      messages.push({
-        kind: "artifact",
-        title: `产出 · ${block.name}`,
-        content: `（${block.name} 块内容摘要 · 演示）已按对方系统约定的结构生成，随本次执行写入时间线版本。`,
-      });
-    });
-  }
-
-  return { seatName, messages, blocks };
-}

frontend-web/src/pages/official-task-analysis/types.ts

@@ -1,105 +0,0 @@
-/**
- * 外部任务多智能体定时分析 —— 前端先行数据模型（后端接口就绪后替换 store 层）。
- *
- * 对应设计定稿：
- * - 外部任务（对方系统推送创建/删除）1:1 绑定「业务链 + 频率 + 块→席位映射」。
- * - 执行记录两类：schedule 定时执行 / manual 手动执行（对方详情页总控问答）。
- * - 时间线内容版本：每次定时执行产出各块内容（供对方详情接口拉取），管理页内
- *   在席位执行过程抽屉里预览。
- */
-
-import type { ScheduleConfig } from "@/components/workspace/scheduled-tasks/schedule-builder";
-
-export type TaRunTrigger = "schedule" | "manual";
-export type TaRunStatus = "pending" | "running" | "succeeded" | "failed";
-export type TaSeatState = "waiting" | "running" | "done" | "failed";
-
-/** 对方详情的分块内容与业务链席位的映射（存在绑定上，业务链保持纯粹）。 */
-export interface TaBlockMapping {
-  /** 块类型 key（对方系统定义）。 */
-  key: string;
-  /** 块展示名。 */
-  name: string;
-  /** 产出该块的席位（业务链 agent_id）。 */
-  seatAgentId: string;
-}
-
-export interface TaBinding {
-  chainId: string;
-  /** 业务链标题快照（展示用，链被删后仍可读）。 */
-  chainTitle: string;
-  cron: string;
-  cronText: string;
-  enabled: boolean;
-  blocks: TaBlockMapping[];
-  coordinatorPrompt?: string;
-  /** 问答沉淀的「执行方向备注」，注入后续每次定时执行（累积追加）。 */
-  directionNotes: string[];
-  /** 绑定时记住，作为下次创建任务的默认业务链返回给对方系统。 */
-  timezone: string;
-}
-
-export interface TaTask {
-  id: string;
-  /** 对方系统任务 id。 */
-  sourceTaskId: string;
-  name: string;
-  description: string;
-  binding: TaBinding | null;
-  createdAt: string;
-}
-
-/** 落库的运行记录；状态由 startedAt + durationMs 在读取时按当前时间推导。 */
-export interface TaRunRecord {
-  id: string;
-  taskId: string;
-  trigger: TaRunTrigger;
-  scheduledFor: string;
-  startedAt: string;
-  durationMs: number;
-  /** 该次执行的业务链编排快照（席位/阶段），链后续修改不影响历史回放。 */
-  stages: string[][];
-  /** 各阶段目标快照（与 stages 同下标），供流程图连线标签展示。 */
-  stageGoals?: (string | null)[] | null;
-  seatNames: Record<string, string>;
-  /** 在该阶段（下标）失败；null = 成功。 */
-  failStage: number | null;
-  /** 手动执行（总控问答）的摘要。 */
-  manualSummary?: string;
-}
-
-/** 读取时推导出的运行视图（每席位状态 + 耗时）。 */
-export interface TaSeatRunInfo {
-  state: TaSeatState;
-  durationMs: number;
-}
-
-export interface TaRunView {
-  id: string;
-  taskId: string;
-  trigger: TaRunTrigger;
-  scheduledFor: string;
-  startedAt: string;
-  finishedAt: string | null;
-  status: TaRunStatus;
-  stageIndex: number;
-  stageTotal: number;
-  seatInfos: Record<string, TaSeatRunInfo>;
-  error: string | null;
-  /** 各块产出状态（按绑定块映射推导；未绑定返回空）。 */
-  blockStates: Array<{ key: string; name: string; state: TaSeatState }>;
-  manualSummary?: string;
-  stages: string[][];
-  stageGoals?: (string | null)[] | null;
-  seatNames: Record<string, string>;
-}
-
-/** 绑定弹窗的提交载荷（内容块映射已移除；blocks 仅为兼容旧数据保留）。 */
-export interface TaBindingPayload {
-  chainId: string;
-  chainTitle: string;
-  schedule: ScheduleConfig;
-  enabled: boolean;
-  blocks?: TaBlockMapping[];
-  coordinatorPrompt?: string;
-}

frontend-web/src/report-collaboration/components/ReportCollaborationHeader.tsx

@@ -1,12 +1,9 @@
 "use client";
 
-import { ArrowLeft, ClipboardList, FileText, MessageSquarePlus, Square } from "lucide-react";
+import { ArrowLeft, FileText, MessageSquarePlus, Square } from "lucide-react";
 
 import type { PagePhase } from "@/report-collaboration/state/selectors";
 
-/** 计划模式覆盖的阶段：第一条消息起到工作流确认执行前。 */
-const PLAN_MODE_PHASES = new Set<PagePhase>(["clarifying", "planning", "proposal_ready"]);
-
 const PHASE_BADGES: Record<PagePhase, { label: string; color: string; bg: string }> = {
   empty: { label: "新会话", color: "var(--rc-text-secondary)", bg: "transparent" },
   clarifying: { label: "澄清需求", color: "var(--rc-waiting)", bg: "rgba(217, 119, 6, 0.1)" },
@@ -54,16 +51,6 @@ export function ReportCollaborationHeader({
         <span className="rc-header-title" title={title}>
           报告协作 / {title}
         </span>
-        {PLAN_MODE_PHASES.has(phase) ? (
-          <span
-            className="rc-chip"
-            title="规划师正在梳理需求并规划工作流，确认后开始执行"
-            style={{ background: "rgba(37, 99, 235, 0.1)", color: "var(--rc-accent)" }}
-          >
-            <ClipboardList className="size-3" aria-hidden />
-            计划模式
-          </span>
-        ) : null}
         <span className="rc-chip" style={{ background: badge.bg, color: badge.color }}>
           {badge.label}
         </span>

frontend-web/src/report-collaboration/components/ReportFlowCanvas.tsx

@@ -156,23 +156,8 @@ function CanvasInner({ plan, nodeStates, selectedNodeId, onSelectNode, emptyHint
   const edges: Edge[] = useMemo(() => {
     if (!plan) return [];
     return plan.edges.map((edge, index) => {
-      // 边语义 = 数据正在流入 target 节点：target 执行中 → 流动动画；
-      // 失败红虚线 / 等待橙 / 已被替代降灰，其余静态。
-      const targetStatus = nodeStates[edge.target]?.status;
-      let className = "rc-edge";
-      let stroke = "var(--rc-flow-edge)";
-      if (targetStatus === "running" || targetStatus === "validating") {
-        className = "rc-edge-active";
-        stroke = "var(--rc-running)";
-      } else if (targetStatus === "failed") {
-        className = "rc-edge-failed";
-        stroke = "var(--rc-danger)";
-      } else if (targetStatus === "awaiting_input") {
-        className = "rc-edge-waiting";
-        stroke = "var(--rc-waiting)";
-      } else if (targetStatus === "superseded" || targetStatus === "interrupted" || targetStatus === "cancelled") {
-        className = "rc-edge-dimmed";
-      }
+      const targetState = nodeStates[edge.target];
+      const active = targetState?.status === "running" || targetState?.status === "validating";
       return {
         id: `${edge.source}->${edge.target}-${index}`,
         source: edge.source,
@@ -180,8 +165,11 @@ function CanvasInner({ plan, nodeStates, selectedNodeId, onSelectNode, emptyHint
         label: edge.label ?? undefined,
         type: "default",
         animated: false,
-        className,
-        style: { stroke, strokeWidth: 2 },
+        className: active ? "rc-edge-active" : "rc-edge",
+        style: {
+          stroke: active ? "var(--rc-running)" : "var(--rc-flow-edge)",
+          strokeWidth: 2,
+        },
       };
     });
   }, [plan, nodeStates]);

frontend-web/src/report-collaboration/components/RequirementSummaryCard.tsx

@@ -1,52 +0,0 @@
-"use client";
-
-import { ClipboardCheck } from "lucide-react";
-
-import type { ReportRequirementSnapshot } from "@/report-collaboration/api/types";
-
-interface RequirementSummaryCardProps {
-  requirement: ReportRequirementSnapshot;
-  /** 需求仍可修改的提示（生成方案前）；方案已出后为 false。 */
-  editable?: boolean;
-}
-
-function Field({ label, value }: { label: string; value: string | null | undefined }) {
-  if (!value) return null;
-  return (
-    <div className="flex gap-2 text-[12px] leading-5">
-      <span className="w-16 shrink-0 text-[var(--rc-text-secondary)]">{label}</span>
-      <span className="min-w-0 flex-1 break-words">{value}</span>
-    </div>
-  );
-}
-
-/** 计划模式 · 需求摘要卡：结构化展示规划师确认的需求快照。 */
-export function RequirementSummaryCard({ requirement, editable = true }: RequirementSummaryCardProps) {
-  const angles = (requirement.required_angles ?? []).filter(Boolean).join("、");
-  return (
-    <div className="rc-card mx-auto w-full max-w-[560px] rounded-xl border border-[var(--rc-border)] bg-[var(--rc-bg-panel)] p-3.5">
-      <div className="mb-2 flex items-center gap-2">
-        <ClipboardCheck className="size-4" style={{ color: "var(--rc-accent)" }} aria-hidden />
-        <span className="text-[13px] font-semibold">需求摘要 · v{requirement.revision}</span>
-        <span className="rc-chip ml-auto" style={{ background: "rgba(37,99,235,.1)", color: "var(--rc-accent)" }}>
-          计划模式
-        </span>
-      </div>
-      <div className="flex flex-col gap-1">
-        <Field label="主题" value={requirement.topic} />
-        <Field label="目的" value={requirement.objective} />
-        <Field label="读者" value={requirement.audience} />
-        <Field label="角度" value={angles || null} />
-        <Field label="时间范围" value={requirement.time_range} />
-        <Field label="地域" value={requirement.geography} />
-        <Field label="篇幅" value={requirement.length_target} />
-        <Field label="语气" value={requirement.tone} />
-      </div>
-      {editable ? (
-        <p className="mt-2.5 border-t border-[var(--rc-border)] pt-2 text-[11px] leading-4 text-[var(--rc-text-secondary)]">
-          我正在基于这份需求为你规划工作流，稍候即可在对话中查看方案；想调整可直接在下方补充。
-        </p>
-      ) : null}
-    </div>
-  );
-}

frontend-web/src/report-collaboration/pages/ReportCollaborationPage.tsx

@@ -4,7 +4,7 @@ import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { useLocation, useNavigate } from "react-router-dom";
 import type { Message } from "@langchain/langgraph-sdk";
 import { toast } from "sonner";
-import { FileText, Sparkles } from "lucide-react";
+import { FileText, Loader2, Sparkles } from "lucide-react";
 
 import { ArtifactsProvider } from "@/components/workspace/artifacts";
 import { ThreadContext } from "@/components/workspace/messages/context";
@@ -26,7 +26,6 @@ import {
 } from "@/report-collaboration/components/ReportPreviewDialog";
 import { ReportSandboxOverlay } from "@/report-collaboration/components/ReportSandboxOverlay";
 import { ReportSpeakerShell } from "@/report-collaboration/components/ReportSpeakerShell";
-import { RequirementSummaryCard } from "@/report-collaboration/components/RequirementSummaryCard";
 import { SessionHistoryPanel } from "@/report-collaboration/components/SessionHistoryPanel";
 import { useReportPanelLayout } from "@/report-collaboration/hooks/useReportPanelLayout";
 import { useReportCollaborationMessages } from "@/report-collaboration/hooks/useReportCollaborationMessages";
@@ -36,7 +35,6 @@ import {
   buildCommandConfirmCard,
   buildPlanGroupCard,
   buildReportAvailableCard,
-  buildRequirementReadyCard,
   readReportCollaborationCard,
 } from "@/report-collaboration/state/message-adapter";
 import { resolveReportSpeaker } from "@/report-collaboration/state/speaker";
@@ -249,23 +247,11 @@ export function ReportCollaborationSessionPage({ sessionId }: { sessionId: strin
     if (next) setFocusedAgentRunId(next);
   }, [agentTabs, focusPinned, focusedAgentRunId, tabIds]);
 
-  // 虚拟业务卡：需求摘要（计划模式）/ 方案组（已出方案且 run 未开始）/ 命令确认 / 报告入口。
+  // 虚拟业务卡：方案组（已出方案且 run 未开始）/ 命令确认 / 报告入口。
   // 采用方案后卡片保留，「开始协作」按钮随选定态启用；run 开始后消失。
   const runStarted = Boolean(state.run && state.run.plan_id);
   const extraCards = useMemo<Message[]>(() => {
     const cards: Message[] = [];
-    if (
-      state.requirement &&
-      state.plans.length === 0 &&
-      !runStarted &&
-      Object.values(state.messagesById).some(
-        (message) =>
-          message.role === "ai" &&
-          (message.metadata as Record<string, unknown> | null | undefined)?.ready_to_plan === true,
-      )
-    ) {
-      cards.push(buildRequirementReadyCard(state.requirement));
-    }
     if (
       state.plans.length > 0 &&
       !runStarted &&
@@ -355,16 +341,39 @@ export function ReportCollaborationSessionPage({ sessionId }: { sessionId: strin
     [sessionId, session],
   );
 
-  // 方案生成由后端在规划师判定 ready 后自动衔接（同一次请求内规划），
-  // 前端无手动「生成候选方案」按钮；此处仅保留摘要卡的注入判定。
+  // 澄清完成（协调者已写入需求版本）但还没生成过方案：给出显式「发起规划」入口。
+  const requirementReady = useMemo(
+    () =>
+      Object.values(state.messagesById).some(
+        (message) =>
+          message.role === "ai" &&
+          (message.metadata as Record<string, unknown> | null | undefined)?.ready_to_plan === true,
+      ),
+    [state.messagesById],
+  );
+  const showPlanRequestEntry =
+    state.session?.status === "clarifying" && state.plans.length === 0 && requirementReady;
+  const [planRequestBusy, setPlanRequestBusy] = useState(false);
+  const handleRequestPlans = useCallback(async () => {
+    setPlanRequestBusy(true);
+    try {
+      await getReportCollaborationDriver().requestPlans(
+        sessionId,
+        state.session?.requirement_revision ?? null,
+      );
+      await session.refreshSnapshot();
+      toast.success("已生成候选方案，可在对话中选择");
+    } catch (err) {
+      toast.error(err instanceof Error ? err.message : String(err));
+    } finally {
+      setPlanRequestBusy(false);
+    }
+  }, [sessionId, session, state.session?.requirement_revision]);
 
   const businessCardSlot = useCallback(
     (message: Message) => {
       const card = readReportCollaborationCard(message);
       if (!card) return null;
-      if (card.kind === "requirement_ready") {
-        return <RequirementSummaryCard requirement={card.requirement} editable={!runStarted} />;
-      }
       if (card.kind === "plan_group") {
         return (
           <ReportPlanCards
@@ -405,7 +414,7 @@ export function ReportCollaborationSessionPage({ sessionId }: { sessionId: strin
       }
       return null;
     },
-    [previewPlan, previewPlanId, runStarted, session],
+    [previewPlan, previewPlanId, session],
   );
 
   const speakerShell = useCallback(
@@ -556,19 +565,43 @@ export function ReportCollaborationSessionPage({ sessionId }: { sessionId: strin
                         : undefined
                     }
                     composer={
-                      <ReportComposer
-                        phase={phase}
-                        busy={session.sendBusy}
-                        target={composerTarget}
-                        onClearTarget={() => setComposerTarget(null)}
-                        onSend={(text) =>
-                          void session.send(text, {
-                            nodeId: composerTarget?.nodeId ?? null,
+                      <div className="flex flex-col">
+                        {showPlanRequestEntry ? (
+                          <div className="mb-1.5 flex justify-center">
+                            <button
+                              type="button"
+                              className="rc-btn"
+                              style={{
+                                background: "var(--rc-accent)",
+                                color: "#fff",
+                                borderColor: "var(--rc-accent)",
+                              }}
+                              disabled={planRequestBusy}
+                              onClick={() => void handleRequestPlans()}
+                            >
+                              {planRequestBusy ? (
+                                <Loader2 className="rc-spin size-3.5" aria-hidden />
+                              ) : (
+                                <Sparkles className="size-3.5" aria-hidden />
+                              )}
+                              {planRequestBusy ? "正在生成候选方案…" : "需求已就绪，生成候选方案"}
+                            </button>
+                          </div>
+                        ) : null}
+                        <ReportComposer
+                          phase={phase}
+                          busy={session.sendBusy}
+                          target={composerTarget}
+                          onClearTarget={() => setComposerTarget(null)}
+                          onSend={(text) =>
+                            void session.send(text, {
+                              nodeId: composerTarget?.nodeId ?? null,
                               agentRunId: composerTarget?.agentRunId ?? null,
                             })
                           }
                           focusSignal={focusSignal}
                         />
+                      </div>
                     }
                   />
                 }

frontend-web/src/report-collaboration/state/message-adapter.ts

@@ -21,7 +21,6 @@ import type {
   CollaborationCommand,
   CollaborationMessage,
   ReportPlanCandidate,
-  ReportRequirementSnapshot,
   ReportVersion,
 } from "@/report-collaboration/api/types";
 
@@ -114,11 +113,6 @@ export type ReportCollaborationCardPayload =
       selectedPlanId: string | null;
       requirementRevision: number;
     }
-  | {
-      kind: "requirement_ready";
-      requirement: ReportRequirementSnapshot;
-      revision: number;
-    }
   | {
       kind: "command_confirm";
       command: CollaborationCommand;
@@ -169,17 +163,6 @@ export function buildPlanGroupCard(
   });
 }
 
-/** 需求摘要卡（计划模式：需求已就绪、尚未生成方案）。 */
-export function buildRequirementReadyCard(
-  requirement: ReportRequirementSnapshot,
-): Message {
-  return buildCardMessage(`rc-card-requirement-r${requirement.revision}`, {
-    kind: "requirement_ready",
-    requirement,
-    revision: requirement.revision,
-  });
-}
-
 /** 命令确认卡（command.confirmation.required 之后）。 */
 export function buildCommandConfirmCard(command: CollaborationCommand): Message {
   return buildCardMessage(`rc-card-confirm-${command.command_id}`, {

frontend-web/src/report-collaboration/styles/report-collaboration.css

@@ -850,21 +850,6 @@
   animation: rc-edge-flow 0.5s linear infinite;
 }
 
-/* P1.4：失败红虚线 / 等待用户橙色 / 已替代·中断降灰 */
-.rc-edge-failed .react-flow__edge-path {
-  stroke: var(--rc-danger);
-  stroke-dasharray: 4 4;
-}
-
-.rc-edge-waiting .react-flow__edge-path {
-  stroke: var(--rc-waiting);
-}
-
-.rc-edge-dimmed .react-flow__edge-path {
-  stroke: var(--rc-flow-edge);
-  opacity: 0.45;
-}
-
 @keyframes rc-edge-flow {
   from {
     stroke-dashoffset: 10;

frontend-web/src/roundtable-planning/components/ChainFlowDiagram.tsx

@@ -39,16 +39,11 @@ export interface ChainFlowStage {
   goal?: string | null;
 }
 
-/** 节点执行状态（任务分析回放传入；缺省展示 Ready）。 */
-export type ChainFlowSeatState = "waiting" | "running" | "done" | "failed";
-
 export interface ChainFlowDiagramProps {
   stages: ChainFlowStage[];
   /** 点击席位节点卡片（总控节点不触发）。 */
   onNodeClick?: (agentId: string, name?: string) => void;
   className?: string;
-  /** 传入时节点卡片叠加执行状态徽标（任务分析的运行回放）；不影响原有展示。 */
-  seatStates?: Record<string, { state: ChainFlowSeatState; durationMs?: number }> | null;
 }
 
 // ── 布局常量（世界坐标，单位 px）─────────────────────────────────────────────
@@ -89,7 +84,7 @@ interface PlacedNode {
   rightX: number;
 }
 
-export function ChainFlowDiagram({ stages, onNodeClick, className, seatStates }: ChainFlowDiagramProps) {
+export function ChainFlowDiagram({ stages, onNodeClick, className }: ChainFlowDiagramProps) {
   // ── 列 / 节点 / 连线 / 标签布局 ──────────────────────────────────────────
   const layout = useMemo(() => {
     // 列：总控 + 各 Stage。
@@ -320,43 +315,15 @@ export function ChainFlowDiagram({ stages, onNodeClick, className, seatStates }:
         </svg>
 
         {/* 节点卡片（参考「业务链条配置器」样式：左彩色描边 + 头像 + 名称 +
-            L-阶段徽标 + 同色角色行 + 底部 Ready 心跳条；图标仍用我方 getAvatar）。
-            seatStates 传入时（任务分析回放）叠加执行状态徽标与状态描边。 */}
+            L-阶段徽标 + 同色角色行 + 底部 Ready 心跳条；图标仍用我方 getAvatar）。 */}
         {layout.cols.flatMap((col, colIdx) =>
           col.nodes.map((n) => {
             const isCoordinator = n.id === COORDINATOR_ID;
             const nc = nodeColorOf(n.avatarType);
-            const seatState = !isCoordinator && seatStates ? seatStates[n.id] : undefined;
-            const state = seatState?.state;
-            const stateStyle = state
-              ? ({
-                  waiting: "text-muted-foreground",
-                  running: "text-amber-600 dark:text-amber-300",
-                  done: "text-emerald-600 dark:text-emerald-300",
-                  failed: "text-red-600 dark:text-red-400",
-                } as const)[state]
-              : null;
-            const stateLabel =
-              state === "waiting"
-                ? "等待"
-                : state === "running"
-                  ? "执行中"
-                  : state === "done"
-                    ? "完成"
-                    : state === "failed"
-                      ? "失败"
-                      : null;
-            const stateSeconds = seatState?.durationMs
-              ? Math.max(1, Math.round(seatState.durationMs / 1000))
-              : null;
             return (
               <div
                 key={n.id}
-                className={cn(
-                  "absolute",
-                  !isCoordinator && "cursor-pointer",
-                  state === "waiting" && "opacity-60",
-                )}
+                className={cn("absolute", !isCoordinator && "cursor-pointer")}
                 style={{ left: n.x, top: n.y, width: NODE_W, height: NODE_H }}
                 onPointerDown={(e) => e.stopPropagation()}
                 onClick={() => {
@@ -372,15 +339,9 @@ export function ChainFlowDiagram({ stages, onNodeClick, className, seatStates }:
                     isCoordinator
                       ? "border-border bg-primary/[0.04]"
                       : "border-border hover:-translate-y-0.5 hover:shadow-[0_8px_22px_rgba(15,23,42,0.10)]",
-                    state === "running" && "border-amber-400/80",
-                    state === "failed" && "border-red-500/70",
                   )}
                   // 左侧 4px 彩色描边：内联上色，避免被 border-border 的四边色覆盖。
-                  style={{
-                    borderLeftColor: nc.hex,
-                    borderLeftWidth: 4,
-                    ...(state === "running" ? { boxShadow: "0 0 0 3px rgba(245,158,11,0.15)" } : {}),
-                  }}
+                  style={{ borderLeftColor: nc.hex, borderLeftWidth: 4 }}
                 >
                   {/* 上：头像 + 名称 + 阶段徽标 + 角色行 */}
                   <div className="flex items-start gap-2 overflow-hidden">
@@ -398,34 +359,13 @@ export function ChainFlowDiagram({ stages, onNodeClick, className, seatStates }:
                     </div>
                   </div>
 
-                  {/* 下：身份 + 状态行（回放模式显示执行状态，否则 Ready 心跳条） */}
+                  {/* 下：身份 + Ready 心跳条 */}
                   <div className="flex items-center justify-between border-t border-border/60 pt-1 text-[8px] text-muted-foreground">
                     <span className="truncate">{isCoordinator ? "总控协调核心" : "智能体席位"}</span>
-                    {state && stateLabel ? (
-                      <span
-                        className={cn(
-                          "ml-1.5 flex shrink-0 items-center gap-1 rounded px-1 py-0.5 font-medium",
-                          stateStyle,
-                        )}
-                      >
-                        <span
-                          className={cn(
-                            "size-1.5 rounded-full",
-                            state === "done" && "bg-emerald-500",
-                            state === "running" && "animate-pulse bg-amber-500",
-                            state === "failed" && "bg-red-500",
-                            state === "waiting" && "bg-muted-foreground/60",
-                          )}
-                        />
-                        {stateLabel}
-                        {stateSeconds != null && state !== "waiting" ? ` · ${stateSeconds}s` : ""}
-                      </span>
-                    ) : (
-                      <span className="ml-1.5 flex shrink-0 items-center gap-1 rounded bg-muted px-1 py-0.5 font-medium text-primary">
-                        <span className="size-1 rounded-full bg-emerald-500" />
-                        Ready
-                      </span>
-                    )}
+                    <span className="ml-1.5 flex shrink-0 items-center gap-1 rounded bg-muted px-1 py-0.5 font-medium text-primary">
+                      <span className="size-1 rounded-full bg-emerald-500" />
+                      Ready
+                    </span>
                   </div>
                 </div>
               </div>
@@ -505,33 +445,22 @@ export function ChainFlowDiagram({ stages, onNodeClick, className, seatStates }:
             style={{ width: mmW, height: mmH }}
             onClick={onMinimapClick}
           >
-            {/* 节点缩略块（回放模式按状态着色） */}
-            {layout.allNodes.map((n) => {
-              const state = n.id === COORDINATOR_ID ? null : seatStates?.[n.id]?.state ?? null;
-              return (
-                <div
-                  key={n.id}
-                  className={cn(
-                    "absolute rounded-[1px]",
-                    n.id === COORDINATOR_ID
-                      ? "bg-primary/70"
-                      : state === "done"
-                        ? "bg-emerald-500/70"
-                        : state === "running"
-                          ? "bg-amber-500/80"
-                          : state === "failed"
-                            ? "bg-red-500/80"
-                            : "bg-foreground/35",
-                  )}
-                  style={{
-                    left: n.x * mmScale,
-                    top: n.y * mmScale,
-                    width: NODE_W * mmScale,
-                    height: NODE_H * mmScale,
-                  }}
-                />
-              );
-            })}
+            {/* 节点缩略块 */}
+            {layout.allNodes.map((n) => (
+              <div
+                key={n.id}
+                className={cn(
+                  "absolute rounded-[1px]",
+                  n.id === COORDINATOR_ID ? "bg-primary/70" : "bg-foreground/35",
+                )}
+                style={{
+                  left: n.x * mmScale,
+                  top: n.y * mmScale,
+                  width: NODE_W * mmScale,
+                  height: NODE_H * mmScale,
+                }}
+              />
+            ))}
             {/* 当前视口框 */}
             <div
               className="absolute border-2 border-primary bg-primary/10"

frontend-web/src/roundtable-planning/hooks/useTaskArtifactSubmission.ts

@@ -55,12 +55,14 @@ function payloadFrom(
 ): TaskProcessReportPayload {
   const name = target.name?.trim() || fileName(target.path);
   const agentId = target.agentId?.trim() || target.threadId;
+  // 产物提交 position：优先取业务链里给该席位智能体配置的值，未配置回退默认。
+  const position = config.positionFor?.(target) ?? config.position;
   return {
     taskId: config.taskId,
     agentId,
     agentName: target.agentName?.trim() || agentId,
     content,
-    position: config.position,
+    position,
     reportName: name,
     submitStatus,
   };

frontend-web/src/roundtable-planning/lib/business-chain.ts

@@ -55,6 +55,13 @@ export interface ChainSeat {
    * 使同一条业务链既能继续用于原会商，也能在岗位协同中按岗位筛选可问答的智能体。
    */
   position_id?: string | null;
+  /**
+   * 该席位提交过程产物时传给外部任务系统的 `position` 值（8BF 会商页用）。
+   * 不同席位智能体对应不同的产物位置，缺省 / null = 提交时回退 0。
+   * 随 `seats` JSON 落库（无需 DB 列，但需在后端 `ChainSeatSchema` 显式声明）。
+   * 注意与 `position_id`（岗位协同的岗位归属）无关。
+   */
+  artifact_position?: number | null;
   /**
    * 该席位在业务链中配置的岗位职责。会商「智能体配置」面板只读展示；
    * 随 `seats` JSON 落库（无需 DB 列）。空 / 缺省 = 未填写。

frontend-web/src/roundtable-planning/lib/task-artifact-submission.ts

@@ -13,7 +13,14 @@ export interface TaskProcessReportPayload {
 export interface TaskArtifactSubmissionConfig {
   /** External task-system id, not the local roundtable draft storage key. */
   taskId: string;
+  /** 提交产物时传给外部任务系统的默认 position（产物位置）。 */
   position: number;
+  /**
+   * 按席位智能体解析提交产物的 position（业务链里逐席位配置的「产物提交 position」）。
+   * 入参是 hook 解析后的 target（`agentId` 已归一为席位 agent_id）；返回
+   * null / undefined = 该席位未配置，回退 `position` 默认值。
+   */
+  positionFor?: (target: TaskArtifactTarget) => number | null | undefined;
   createProcessReport: (payload: TaskProcessReportPayload) => Promise<{ id: string }>;
   updateProcessReport: (reportId: string, payload: TaskProcessReportPayload) => Promise<void>;
 }

frontend-web/src/roundtable-planning/pages/BusinessChainEditorPage.tsx

@@ -697,6 +697,8 @@ export default function BusinessChainEditorPage() {
           seat_mode: s.seat_mode ?? null,
           // 岗位协同专用岗位归属：普通圆桌忽略，但保存时必须原样保留。
           position_id: s.position_id ?? null,
+          // 席位「产物提交 position」：提交过程产物时传给外部任务系统；null = 回退默认 0。
+          artifact_position: s.artifact_position ?? null,
           // 业务链席位岗位职责：编辑器已不提供输入，保存时原样保留存量值（会商智能体配置面板只读展示）。
           job_responsibilities: s.job_responsibilities?.trim() || null,
         };

frontend-web/src/strategy-components/Header.tsx

@@ -41,10 +41,6 @@ const iconButtonClass = (isDark: boolean, isPaleLightTheme: boolean, isCustomThe
         : "text-white hover:bg-[var(--brand-950)] active:bg-[#8a0618]",
   );
 
-// 深色顶栏菜单左右分组（设计稿：左 问答中心/任务管理/应用中心，右 综合管理/资源管理）
-const LEFT_MENU_IDS = ["qa-center", "task-management", "light-app-center"];
-const RIGHT_MENU_IDS = ["comprehensive-management", "resource-management"];
-
 type HeaderProps = {
   collapsed?: boolean;
 };
@@ -122,8 +118,11 @@ const Header = ({ collapsed }: HeaderProps) => {
 
   const thirdSubNavItems = getActiveThirdLevelItems(visibleMenuItems, pathname);
 
-  const leftMenuItems = visibleMenuItems.filter((i) => LEFT_MENU_IDS.includes(i.id));
-  const rightMenuItems = visibleMenuItems.filter((i) => RIGHT_MENU_IDS.includes(i.id));
+  // 深色顶栏围绕中间标题分成左右两组。直接按菜单管理后的一级顺序均分，确保被升为
+  // 一级或重新排序的节点仍会显示；默认 5 项时仍保持左 3 / 右 2 的原布局。
+  const topMenuSplitIndex = Math.ceil(visibleMenuItems.length / 2);
+  const leftMenuItems = visibleMenuItems.slice(0, topMenuSplitIndex);
+  const rightMenuItems = visibleMenuItems.slice(topMenuSplitIndex);
 
   const handleNavItemClick = (item: MenuItem) => {
     const path = item.path ?? findFirstRoutePath(item.children);

frontend-web/src/strategy-components/api/llmwiki.ts

@@ -73,6 +73,21 @@ export interface LlmWikiKnowledgeBase {
   is_conversation_deposit?: boolean;
 }
 
+export interface LlmWikiEmbeddingModel {
+  id: string;
+  name: string;
+  provider?: string | null;
+  model_name?: string | null;
+  status?: string | null;
+  is_default: boolean;
+  available: boolean;
+}
+
+export interface LlmWikiEmbeddingModelsResponse {
+  models: LlmWikiEmbeddingModel[];
+  default_model_id?: string | null;
+}
+
 export interface PublicLlmWikiKnowledgeBase extends LlmWikiKnowledgeBase {
   wiki: {
     status: "ready" | "empty" | "unavailable";
@@ -268,6 +283,9 @@ export interface LlmWikiWikiIndexStatus {
 
 export interface LocalWikiEncoderStatus {
   provider: string;
+  configured_provider?: string | null;
+  mode?: "configured" | "local";
+  using_local?: boolean;
   model: string;
   dimensions?: number | null;
   state: "idle" | "starting" | "ready" | "failed";
@@ -424,6 +442,17 @@ export async function getLlmWikiKnowledgeBase(
   );
 }
 
+export async function listLlmWikiEmbeddingModels(): Promise<LlmWikiEmbeddingModelsResponse> {
+  const payload = await readJson<LlmWikiEmbeddingModelsResponse>(
+    await apiFetch(`${API()}/embedding-models`),
+    "读取知识服务向量模型",
+  );
+  return {
+    models: payload.models ?? [],
+    default_model_id: payload.default_model_id ?? null,
+  };
+}
+
 export async function createLlmWikiWeKnoraEmbedSession(
   id: string,
   tab: "documents" | "wiki" | "graph",
@@ -457,6 +486,7 @@ export async function createLlmWikiKnowledgeBase(input: {
   description: string;
   type: "document" | "faq";
   wiki_enabled?: boolean;
+  embedding_model_id?: string;
 }): Promise<LlmWikiKnowledgeBase> {
   return readJson(
     await apiFetch(`${API()}/knowledge-bases`, {
@@ -654,6 +684,13 @@ export async function configureLocalWikiEncoder(
   );
 }
 
+export async function restoreConfiguredWikiEncoder(): Promise<LocalWikiEncoderStatus> {
+  return readJson(
+    await apiFetch(`${API()}/local-encoder/use-configured`, { method: "POST" }),
+    "恢复配置文件编码器",
+  );
+}
+
 export async function uploadLocalWikiEncoder(
   files: File[],
   onProgress?: (percent: number) => void,
@@ -688,10 +725,15 @@ export async function uploadLocalWikiEncoder(
         payload = null;
       }
       if (request.status < 200 || request.status >= 300) {
-        const detail = payload && typeof payload === "object" && "detail" in payload
+        const rawDetail = payload && typeof payload === "object" && "detail" in payload
           ? (payload as { detail: unknown }).detail
           : `请求失败 (${request.status})`;
-        reject(new Error(typeof detail === "string" ? detail : JSON.stringify(detail)));
+        const detail = rawDetail && typeof rawDetail === "object" && "message" in rawDetail
+          ? String((rawDetail as { message: unknown }).message)
+          : typeof rawDetail === "string"
+            ? rawDetail
+            : JSON.stringify(rawDetail);
+        reject(new Error(userFacingKnowledgeMessage(detail)));
         return;
       }
       onProgress?.(100);
@@ -1268,6 +1310,17 @@ export function useLlmWikiSettings(enabled = true) {
   });
 }
 
+export function useLlmWikiEmbeddingModels(enabled = true) {
+  const { userId } = useLiveAccount();
+  return useQuery({
+    queryKey: ["llmwiki", "embedding-models", userId ?? "anonymous"],
+    queryFn: listLlmWikiEmbeddingModels,
+    enabled,
+    staleTime: 60_000,
+    refetchOnMount: "always",
+  });
+}
+
 export function useLlmWikiActions() {
   const queryClient = useQueryClient();
   const invalidateKnowledge = () =>

frontend-web/src/strategy-components/components/resource-management/llmwiki/WeKnoraKnowledgeWorkspace.tsx

@@ -34,6 +34,13 @@ import {
 } from "@/components/ui/dialog";
 import { Input } from "@/components/ui/input";
 import { Progress } from "@/components/ui/progress";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
 import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
 import { Textarea } from "@/components/ui/textarea";
 import { getStoredAuth } from "@/core/auth";
@@ -48,7 +55,9 @@ import {
   searchLlmWiki,
   startLocalWikiEncoder,
   uploadLocalWikiEncoder,
+  restoreConfiguredWikiEncoder,
   useLlmWikiActions,
+  useLlmWikiEmbeddingModels,
   useLlmWikiKnowledgeBases,
   useLlmWikiSettings,
   useLlmWikiSettingsActions,
@@ -68,6 +77,14 @@ function messageOf(error: unknown): string {
   return error instanceof Error ? error.message : "操作失败，请稍后重试";
 }
 
+function encoderProviderLabel(provider?: string | null): string {
+  const normalized = provider?.trim().toLowerCase();
+  if (normalized === "local") return "本地 BGE-M3";
+  if (normalized === "openai") return "OpenAI";
+  if (normalized === "openai_compatible") return "OpenAI 兼容服务";
+  return provider?.trim() || "未配置";
+}
+
 function searchModeLabel(mode: LlmWikiSearchResponse["mode"]) {
   if (mode === "vector") return "本地 Wiki 向量检索";
   if (mode === "mixed") return "Wiki 混合检索";
@@ -457,18 +474,50 @@ function CreateKnowledgeDialog({
   open: boolean;
   pending: boolean;
   onOpenChange: (value: boolean) => void;
-  onCreate: (input: { name: string; description: string; type: "document" | "faq"; wiki_enabled: boolean }) => Promise<void>;
+  onCreate: (input: { name: string; description: string; type: "document" | "faq"; wiki_enabled: boolean; embedding_model_id: string }) => Promise<void>;
 }) {
   const [name, setName] = useState("");
   const [description, setDescription] = useState("");
   const [wikiEnabled, setWikiEnabled] = useState(true);
+  const [embeddingModelId, setEmbeddingModelId] = useState("");
+  const embeddingModels = useLlmWikiEmbeddingModels(open);
+  const availableEmbeddingModels = useMemo(
+    () => (embeddingModels.data?.models ?? []).filter((model) => model.available !== false),
+    [embeddingModels.data?.models],
+  );
+
   useEffect(() => {
-    if (!open) { setName(""); setDescription(""); setWikiEnabled(true); }
+    if (!open) {
+      setName("");
+      setDescription("");
+      setWikiEnabled(true);
+      setEmbeddingModelId("");
+    }
   }, [open]);
+
+  useEffect(() => {
+    if (!open || !embeddingModels.data || availableEmbeddingModels.length === 0) return;
+    if (availableEmbeddingModels.some((model) => model.id === embeddingModelId)) return;
+    const defaultId = embeddingModels.data.default_model_id;
+    setEmbeddingModelId(
+      availableEmbeddingModels.some((model) => model.id === defaultId)
+        ? defaultId!
+        : availableEmbeddingModels[0]!.id,
+    );
+  }, [availableEmbeddingModels, embeddingModelId, embeddingModels.data, open]);
+
+  const modelLabel = (model: (typeof availableEmbeddingModels)[number]) => {
+    const provider = model.provider?.trim();
+    const implementation = model.model_name?.trim();
+    const suffix = [provider, implementation].filter(Boolean).join(" · ");
+    return suffix ? `${model.name}（${suffix}）` : model.name;
+  };
+  const modelSelectionUnavailable = embeddingModels.isLoading || embeddingModels.isError || !embeddingModelId;
+
   return (
     <Dialog open={open} onOpenChange={onOpenChange}>
       <DialogContent>
-        <DialogHeader><DialogTitle>新建个人知识库</DialogTitle><DialogDescription>选择知识库模式；模型、切块和存储策略仍由知识服务管理。</DialogDescription></DialogHeader>
+        <DialogHeader><DialogTitle>新建个人知识库</DialogTitle><DialogDescription>选择知识库模式和知识服务用于原文分块的向量模型。</DialogDescription></DialogHeader>
         <div className="space-y-4 py-2">
           <div className="space-y-2"><label className="text-sm font-medium" htmlFor="llmwiki-name">名称</label><Input id="llmwiki-name" value={name} onChange={(event) => setName(event.target.value)} maxLength={255} /></div>
           <div className="space-y-2"><label className="text-sm font-medium" htmlFor="llmwiki-description">描述</label><Textarea id="llmwiki-description" value={description} onChange={(event) => setDescription(event.target.value)} rows={4} maxLength={2048} /></div>
@@ -476,8 +525,33 @@ function CreateKnowledgeDialog({
             <button type="button" className={`rounded-xl border p-4 text-left transition-colors ${wikiEnabled ? "border-primary bg-primary/5 ring-1 ring-primary" : "hover:bg-muted/40"}`} onClick={() => setWikiEnabled(true)}><div className="flex items-center gap-2 text-sm font-semibold"><BookOpen className="size-4 text-violet-500" />Wiki 知识库</div><p className="mt-2 text-xs leading-5 text-muted-foreground">自动综合资料，生成 Wiki 页面和页面关系图谱。</p></button>
             <button type="button" className={`rounded-xl border p-4 text-left transition-colors ${!wikiEnabled ? "border-primary bg-primary/5 ring-1 ring-primary" : "hover:bg-muted/40"}`} onClick={() => setWikiEnabled(false)}><div className="flex items-center gap-2 text-sm font-semibold"><FileText className="size-4 text-blue-500" />标准知识库</div><p className="mt-2 text-xs leading-5 text-muted-foreground">仅进行文档解析、切块与向量/关键词索引。</p></button>
           </div></div>
+          <div className="space-y-2">
+            <label className="text-sm font-medium" htmlFor="llmwiki-embedding-model">原文向量模型</label>
+            {embeddingModels.isLoading ? (
+              <div className="flex h-9 items-center rounded-md border px-3 text-sm text-muted-foreground"><Loader2 className="mr-2 size-4 animate-spin" />正在读取知识服务模型</div>
+            ) : embeddingModels.isError ? (
+              <div className="rounded-lg border border-destructive/30 bg-destructive/5 p-3 text-xs text-destructive">
+                <p>模型读取失败：{messageOf(embeddingModels.error)}</p>
+                <Button type="button" variant="ghost" size="sm" className="mt-1 h-7 px-2" onClick={() => void embeddingModels.refetch()}>重新读取</Button>
+              </div>
+            ) : availableEmbeddingModels.length ? (
+              <Select value={embeddingModelId} onValueChange={setEmbeddingModelId} disabled={pending}>
+                <SelectTrigger id="llmwiki-embedding-model" className="w-full"><SelectValue placeholder="请选择向量模型" /></SelectTrigger>
+                <SelectContent position="popper">
+                  {availableEmbeddingModels.map((model) => (
+                    <SelectItem key={model.id} value={model.id}>
+                      {modelLabel(model)}{model.is_default ? " · 默认" : ""}
+                    </SelectItem>
+                  ))}
+                </SelectContent>
+              </Select>
+            ) : (
+              <div className="rounded-lg border border-amber-500/30 bg-amber-500/5 p-3 text-xs text-muted-foreground">知识服务中没有可用的 Embedding 模型，请先在知识服务中启用本地或 OpenAI 兼容向量模型。</div>
+            )}
+            <p className="text-xs leading-5 text-muted-foreground">该模型由知识服务（WeKnora）对上传原文和分块进行向量化，并在创建时绑定到新库。它与 DeerFlow 的“Wiki 镜像编码器”是两套独立配置；选择 OpenAI 兼容模型时，无需再配置本地 BGE-M3。需要跨知识库检索时，请为相关知识库保持相同或兼容的向量模型。</p>
+          </div>
         </div>
-        <DialogFooter><Button variant="outline" onClick={() => onOpenChange(false)}>取消</Button><Button disabled={pending || !name.trim()} onClick={() => void onCreate({ name: name.trim(), description: description.trim(), type: "document", wiki_enabled: wikiEnabled })}>{pending && <Loader2 className="mr-2 size-4 animate-spin" />}创建</Button></DialogFooter>
+        <DialogFooter><Button variant="outline" onClick={() => onOpenChange(false)}>取消</Button><Button disabled={pending || !name.trim() || modelSelectionUnavailable} onClick={() => void onCreate({ name: name.trim(), description: description.trim(), type: "document", wiki_enabled: wikiEnabled, embedding_model_id: embeddingModelId })}>{pending && <Loader2 className="mr-2 size-4 animate-spin" />}创建</Button></DialogFooter>
       </DialogContent>
     </Dialog>
   );
@@ -501,11 +575,12 @@ export function LocalEncoderSettingsCard() {
 
   const applyStatus = (status: Awaited<ReturnType<typeof getLocalWikiEncoderStatus>>) => {
     queryClient.setQueryData(["llmwiki-local-encoder"], status);
+    void queryClient.invalidateQueries({ queryKey: ["llmwiki", "wiki-index-status"] });
     setModelPath(status.model_path || "");
   };
   const configure = useMutation({
     mutationFn: () => configureLocalWikiEncoder(modelPath.trim()),
-    onSuccess: (status) => { applyStatus(status); toast.success("编码器目录已保存"); },
+    onSuccess: (status) => { applyStatus(status); toast.success("已切换到本地 Wiki 编码器并保存目录"); },
     onError: (error) => toast.error(messageOf(error)),
   });
   const upload = useMutation({
@@ -514,7 +589,7 @@ export function LocalEncoderSettingsCard() {
     onSuccess: (status) => {
       applyStatus(status);
       setFiles([]);
-      toast.success(`已保存 ${status.uploaded_files ?? 0} 个模型文件`);
+      toast.success(`已保存 ${status.uploaded_files ?? 0} 个模型文件，并切换到本地 Wiki 编码器`);
     },
     onError: (error) => toast.error(messageOf(error)),
   });
@@ -526,7 +601,17 @@ export function LocalEncoderSettingsCard() {
     },
     onError: (error) => toast.error(messageOf(error)),
   });
+  const restoreConfigured = useMutation({
+    mutationFn: restoreConfiguredWikiEncoder,
+    onSuccess: (nextStatus) => {
+      applyStatus(nextStatus);
+      toast.success(`已恢复 config.yaml 编码器：${encoderProviderLabel(nextStatus.provider)}`);
+    },
+    onError: (error) => toast.error(messageOf(error)),
+  });
   const status = encoder.data;
+  const usingLocal = status?.using_local ?? status?.provider === "local";
+  const localOverrideActive = status?.mode === "local";
   const selectedBytes = files.reduce((sum, file) => sum + file.size, 0);
   const formatSize = (value: number) => value >= 1024 ** 3
     ? `${(value / 1024 ** 3).toFixed(2)} GB`
@@ -535,29 +620,49 @@ export function LocalEncoderSettingsCard() {
   return (
     <Card>
       <CardHeader>
-        <CardTitle className="flex items-center gap-2 text-base"><Cpu className="size-5" />DeerFlow 本地编码器</CardTitle>
-        <CardDescription>仅管理员可见。配置服务器上已有的 BGE-M3 目录，或直接上传完整离线模型目录；编码器作为独立进程启动，不影响 DeerFlow 其他服务。</CardDescription>
+        <CardTitle className="flex items-center gap-2 text-base"><Cpu className="size-5" />DeerFlow Wiki 镜像编码器</CardTitle>
+        <CardDescription>仅管理员可见。这里负责 DeerFlow 内部 Wiki 页面镜像的向量检索，不会决定知识服务对上传原文使用哪个模型。原文向量模型在“新建知识库”时选择。</CardDescription>
       </CardHeader>
       <CardContent className="space-y-5">
         <div className="flex flex-wrap items-center gap-2 text-sm">
-          <Badge variant={status?.state === "failed" ? "destructive" : status?.state === "ready" ? "default" : "secondary"}>
-            {status?.state === "ready" ? "已就绪" : status?.state === "starting" ? "启动中" : status?.state === "failed" ? "启动失败" : "未启动"}
+          <Badge variant={encoder.isError || (usingLocal && status?.state === "failed") ? "destructive" : usingLocal && status?.state === "ready" ? "default" : "secondary"}>
+            {encoder.isError
+              ? "状态读取失败"
+              : encoder.isLoading
+                ? "读取中"
+                : !usingLocal
+                  ? "配置编码器生效中"
+                  : status?.state === "ready"
+                    ? "本地编码器已就绪"
+                    : status?.state === "starting"
+                      ? "本地编码器启动中"
+                      : status?.state === "failed"
+                        ? "本地编码器启动失败"
+                        : "本地编码器未启动"}
           </Badge>
-          <span className="text-muted-foreground">{status ? `${status.model} · ${status.dimensions || "自动探测"} 维 · ${status.process_isolation ? "独立进程" : "主进程"}` : "正在读取状态"}</span>
-          {status?.model_files_ready && <Badge variant="outline">模型文件已就绪</Badge>}
+          {status && <Badge variant="outline">当前 provider：{encoderProviderLabel(status.provider)}</Badge>}
+          {status && <Badge variant="outline">{localOverrideActive ? "页面本地覆盖" : "config.yaml 配置"}</Badge>}
+          <span className="text-muted-foreground">
+            {status
+              ? usingLocal
+                ? `${status.model} · ${status.dimensions || "自动探测"} 维 · ${status.process_isolation ? "独立进程" : "主进程"}`
+                : `由 config.yaml 的 ${encoderProviderLabel(status.configured_provider || status.provider)} provider 提供向量服务，无需启动本地模型`
+              : "正在读取状态"}
+          </span>
+          {usingLocal && status?.model_files_ready && <Badge variant="outline">模型文件已就绪</Badge>}
         </div>
         {encoder.error && <p className="text-sm text-destructive">{messageOf(encoder.error)}</p>}
-        {status?.last_error && <p className="rounded-lg border border-destructive/30 bg-destructive/5 p-3 text-xs text-destructive">{status.last_error}</p>}
+        {usingLocal && status?.last_error && <p className="rounded-lg border border-destructive/30 bg-destructive/5 p-3 text-xs text-destructive">{status.last_error}</p>}
 
         <div className="space-y-2">
-          <label className="text-sm font-medium" htmlFor="local-encoder-path">使用服务器已有目录</label>
+          <label className="text-sm font-medium" htmlFor="local-encoder-path">切换到服务器本地模型目录</label>
           <div className="flex flex-col gap-2 sm:flex-row">
             <Input id="local-encoder-path" value={modelPath} onChange={(event) => setModelPath(event.target.value)} placeholder="例如 /opt/deerflow/models/bge-m3" />
             <Button variant="outline" disabled={!modelPath.trim() || configure.isPending} onClick={() => configure.mutate()}>
               {configure.isPending && <Loader2 className="mr-2 size-4 animate-spin" />}保存目录
             </Button>
           </div>
-          <p className="text-xs text-muted-foreground">目录内需包含 <code>onnx/model.onnx</code>（推荐）或根目录 <code>model.onnx</code>。</p>
+          <p className="text-xs text-muted-foreground">目录内需包含 <code>onnx/model.onnx</code>（推荐）或根目录 <code>model.onnx</code>。保存后会立即把 Wiki 镜像编码器切换为 local 并热重建，无需修改配置文件或重启服务。</p>
         </div>
 
         <div className="space-y-2 rounded-xl border border-dashed p-4">
@@ -576,7 +681,7 @@ export function LocalEncoderSettingsCard() {
           )}
           <div className="flex flex-wrap items-center justify-between gap-3">
             <p className="text-xs text-muted-foreground">
-              {files.length ? `已选择 ${files.length} 个文件，共 ${formatSize(selectedBytes)}` : "请选择完整 BGE-M3 目录。大文件会落到运行目录，不写入源码仓库。"}
+              {files.length ? `已选择 ${files.length} 个文件，共 ${formatSize(selectedBytes)}` : "请选择完整 BGE-M3 目录。上传完成后会自动切换到 local；大文件会落到运行目录，不写入源码仓库。"}
             </p>
             <Button disabled={!files.length || upload.isPending} onClick={() => upload.mutate()}>
               {upload.isPending ? <Loader2 className="mr-2 size-4 animate-spin" /> : <Upload className="mr-2 size-4" />}
@@ -586,10 +691,16 @@ export function LocalEncoderSettingsCard() {
         </div>
 
         <div className="flex flex-wrap gap-2">
-          <Button disabled={!status?.model_files_ready || start.isPending || status?.state === "starting" || status?.state === "ready"} onClick={() => start.mutate()}>
+          <Button disabled={!usingLocal || !status?.model_files_ready || start.isPending || status?.state === "starting" || status?.state === "ready"} onClick={() => start.mutate()}>
             {(start.isPending || status?.state === "starting") && <Loader2 className="mr-2 size-4 animate-spin" />}
-            {status?.state === "ready" ? "编码器已启动" : status?.state === "failed" ? "重新启动" : "一键启动编码器"}
+            {!usingLocal ? "当前无需启动本地模型" : status?.state === "ready" ? "编码器已启动" : status?.state === "failed" ? "重新启动" : "一键启动编码器"}
           </Button>
+          {localOverrideActive && (
+            <Button variant="secondary" disabled={restoreConfigured.isPending} onClick={() => restoreConfigured.mutate()}>
+              {restoreConfigured.isPending && <Loader2 className="mr-2 size-4 animate-spin" />}
+              恢复 config.yaml 编码器
+            </Button>
+          )}
           <Button variant="ghost" disabled={encoder.isFetching} onClick={() => void encoder.refetch()}>
             <RefreshCw className={`mr-2 size-4 ${encoder.isFetching ? "animate-spin" : ""}`} />刷新状态
           </Button>

frontend-web/src/strategy-components/components/resource-management/llmwiki/WeKnoraWikiManagementPage.tsx

@@ -601,13 +601,19 @@ export function WeKnoraWikiManagementPage() {
     }
   };
 
-  const vectorStatusText = !indexStatus.data?.local_index_enabled
-    ? "本地向量未启用，检索使用 Wiki 接口"
-    : indexStatus.data.fully_vectorized
-      ? `整库已向量化（${indexStatus.data.vector_count ?? 0} 个向量章节）`
-      : indexStatus.data.state === "running" || indexStatus.data.state === "rebuilding"
-        ? "整库向量化进行中，完成前检索使用 Wiki 接口"
-        : "整库尚未完成向量化，检索使用 Wiki 接口";
+  const vectorStatusText = indexStatus.isLoading
+    ? "正在读取 Wiki 镜像向量状态"
+    : indexStatus.isError
+      ? `Wiki 镜像向量状态读取失败：${indexStatus.error instanceof Error ? indexStatus.error.message : "请稍后重试"}`
+      : !indexStatus.data?.local_index_enabled
+        ? "Wiki 镜像向量未启用，检索使用 Wiki 接口"
+        : indexStatus.data.fully_vectorized
+          ? `整库已向量化（${indexStatus.data.vector_count ?? 0} 个向量章节）`
+          : indexStatus.data.state === "running" || indexStatus.data.state === "rebuilding"
+            ? "整库向量化进行中，完成前检索使用 Wiki 接口"
+            : indexStatus.data.last_error
+              ? `整库向量化失败：${indexStatus.data.last_error}`
+              : "整库尚未完成向量化，检索使用 Wiki 接口";
 
   return (
     <div className="flex h-full min-h-0 flex-col bg-background">
@@ -626,7 +632,7 @@ export function WeKnoraWikiManagementPage() {
             variant="outline"
             size="sm"
             onClick={() => void vectorize()}
-            disabled={!canWrite || actions.vectorizeWiki.isPending || indexStatus.data?.state === "running" || indexStatus.data?.state === "rebuilding"}
+            disabled={!canWrite || indexStatus.isLoading || actions.vectorizeWiki.isPending || indexStatus.data?.state === "running" || indexStatus.data?.state === "rebuilding"}
           >
             {actions.vectorizeWiki.isPending || indexStatus.data?.state === "running" || indexStatus.data?.state === "rebuilding" ? (
               <Loader2 className="mr-2 size-4 animate-spin" />
@@ -652,6 +658,17 @@ export function WeKnoraWikiManagementPage() {
       <main className="grid min-h-0 flex-1 grid-cols-[320px_1fr] overflow-hidden">
         <aside className="flex min-h-0 flex-col border-r bg-muted/20">
           <div className="border-b p-3">
+            {indexStatus.isLoading && (
+              <div className="mb-3 flex items-center rounded-lg border bg-background p-3 text-xs text-muted-foreground">
+                <Loader2 className="mr-2 size-4 animate-spin" />正在读取 Wiki 镜像向量状态
+              </div>
+            )}
+            {indexStatus.isError && (
+              <div className="mb-3 rounded-lg border border-destructive/30 bg-destructive/5 p-3 text-xs text-destructive">
+                <p>Wiki 镜像向量状态读取失败：{indexStatus.error instanceof Error ? indexStatus.error.message : "请稍后重试"}</p>
+                <Button type="button" variant="ghost" size="sm" className="mt-1 h-7 px-2" onClick={() => void indexStatus.refetch()}>重新读取</Button>
+              </div>
+            )}
             {indexStatus.data && (
               <div className="mb-3 rounded-lg border bg-background p-3">
                 <div className="flex items-center justify-between gap-2 text-xs">

frontend-web/src/strategy-selection/AgentConfigDialog.tsx

@@ -0,0 +1,736 @@
+import { useEffect, useMemo, useState } from "react";
+import { useQueryClient } from "@tanstack/react-query";
+import {
+  Bot,
+  Check,
+  CirclePlus,
+  Layers3,
+  LoaderCircle,
+  LockKeyhole,
+  Power,
+  RotateCcw,
+  Save,
+  Sparkles,
+  Trash2,
+} from "lucide-react";
+import { toast } from "sonner";
+
+import { SkillTransferSelector } from "@/components/workspace/agents/skill-transfer-selector";
+import { ModelNameSelect } from "@/components/workspace/model-name-select";
+import { SkillDetailDialog } from "@/components/workspace/skills/skill-detail-dialog";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from "@/components/ui/dialog";
+import { Input } from "@/components/ui/input";
+import { Switch } from "@/components/ui/switch";
+import { Textarea } from "@/components/ui/textarea";
+import { useAllSkillsAdmin } from "@/core/skills/hooks";
+import { cn } from "@/lib/utils";
+
+import {
+  createStrategyAngle,
+  disableStrategyAngle,
+  STRATEGY_AGENTS_QUERY_KEY,
+  updateStrategyAgent,
+  useStrategyAgents,
+  type StrategyAgent,
+  type StrategyAgentCategory,
+} from "./strategy-agents";
+
+interface AgentConfigDialogProps {
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+}
+
+interface AgentConfigDraft {
+  name: string;
+  description: string;
+  soul: string;
+  model: string | null;
+  skills: string[];
+  enabled: boolean;
+  sortOrder: number;
+}
+
+const NEW_ANGLE_ID = "__new_strategy_angle__";
+
+const CATEGORY_COPY: Record<
+  StrategyAgentCategory,
+  { title: string; description: string }
+> = {
+  intent: {
+    title: "意图理解",
+    description: "把用户对话整理为结构化任务，固定流程入口",
+  },
+  angle: {
+    title: "分析角度",
+    description: "并行生成独立策略，可按业务需要扩展",
+  },
+  judge: {
+    title: "智能评判",
+    description: "统一比较各角度策略并给出推荐结论",
+  },
+  solution: {
+    title: "方案整理",
+    description: "将用户选中的策略消冲突并汇总成方案",
+  },
+};
+
+function normalizeSkills(skills: string[]) {
+  return [...new Set(skills)].sort((left, right) =>
+    left.localeCompare(right),
+  );
+}
+
+function sameSkills(left: string[], right: string[]) {
+  const normalizedLeft = normalizeSkills(left);
+  const normalizedRight = normalizeSkills(right);
+  return (
+    normalizedLeft.length === normalizedRight.length &&
+    normalizedLeft.every((skill, index) => skill === normalizedRight[index])
+  );
+}
+
+function draftFromAgent(agent: StrategyAgent): AgentConfigDraft {
+  return {
+    name: agent.name,
+    description: agent.description,
+    soul: agent.soul ?? "",
+    model: agent.model,
+    skills: agent.skills ?? [],
+    enabled: agent.enabled,
+    sortOrder: agent.sort_order,
+  };
+}
+
+function emptyAngleDraft(sortOrder: number): AgentConfigDraft {
+  return {
+    name: "",
+    description: "",
+    soul: "",
+    model: null,
+    skills: [],
+    enabled: true,
+    sortOrder,
+  };
+}
+
+function sameDraft(left: AgentConfigDraft, right: AgentConfigDraft) {
+  return (
+    left.name === right.name &&
+    left.description === right.description &&
+    left.soul === right.soul &&
+    left.model === right.model &&
+    left.enabled === right.enabled &&
+    left.sortOrder === right.sortOrder &&
+    sameSkills(left.skills, right.skills)
+  );
+}
+
+export function AgentConfigDialog({
+  open,
+  onOpenChange,
+}: AgentConfigDialogProps) {
+  const [selectedId, setSelectedId] = useState("");
+  const [draft, setDraft] = useState<AgentConfigDraft>(() =>
+    emptyAngleDraft(100),
+  );
+  const [savedDraft, setSavedDraft] = useState<AgentConfigDraft | null>(null);
+  const [detailSkillName, setDetailSkillName] = useState<string | null>(null);
+  const [busy, setBusy] = useState(false);
+  const queryClient = useQueryClient();
+  const {
+    data: agents = [],
+    isLoading,
+    error,
+    refetch,
+  } = useStrategyAgents({
+    enabled: open,
+    includeDisabled: true,
+    includeConfig: true,
+  });
+  const {
+    skills,
+    isLoading: isSkillsLoading,
+    error: skillsError,
+  } = useAllSkillsAdmin(open);
+
+  const fixedAgents = useMemo(
+    () => agents.filter((agent) => agent.fixed),
+    [agents],
+  );
+  const angleAgents = useMemo(
+    () => agents.filter((agent) => agent.category === "angle"),
+    [agents],
+  );
+  const selectedAgent = useMemo(
+    () => agents.find((agent) => agent.id === selectedId) ?? null,
+    [agents, selectedId],
+  );
+  const creating = selectedId === NEW_ANGLE_ID;
+  const dirty = Boolean(savedDraft && !sameDraft(draft, savedDraft));
+  const selectableSkills = useMemo(
+    () =>
+      skills.filter((skill) => {
+        const globallyAvailable =
+          Boolean(skill.builtin) || Boolean(skill.published);
+        return (
+          skill.enabled &&
+          (skill.state ?? "active") === "active" &&
+          globallyAvailable
+        );
+      }),
+    [skills],
+  );
+
+  useEffect(() => {
+    if (!open || isLoading || creating || agents.length === 0) return;
+    if (selectedAgent) return;
+    setSelectedId(agents[0].id);
+  }, [agents, creating, isLoading, open, selectedAgent]);
+
+  useEffect(() => {
+    if (!open || creating || !selectedAgent) return;
+    const next = draftFromAgent(selectedAgent);
+    setDraft(next);
+    setSavedDraft(next);
+  }, [creating, open, selectedAgent?.id, selectedAgent?.updated_at]);
+
+  const confirmDiscardChanges = () =>
+    !dirty || window.confirm("当前配置尚未保存，确定放弃这些修改吗？");
+
+  const selectAgent = (agentId: string) => {
+    if (agentId === selectedId || busy || !confirmDiscardChanges()) return;
+    setSelectedId(agentId);
+    setSavedDraft(null);
+  };
+
+  const startCreate = () => {
+    if (busy || !confirmDiscardChanges()) return;
+    const maxOrder = angleAgents.reduce(
+      (current, agent) => Math.max(current, agent.sort_order),
+      99,
+    );
+    const next = emptyAngleDraft(maxOrder + 1);
+    setSelectedId(NEW_ANGLE_ID);
+    setDraft(next);
+    setSavedDraft(next);
+  };
+
+  const save = async () => {
+    const name = draft.name.trim();
+    if (!name) {
+      toast.error("请填写智能体名称");
+      return;
+    }
+    setBusy(true);
+    try {
+      if (creating) {
+        const created = await createStrategyAngle({
+          name,
+          description: draft.description.trim(),
+          soul: draft.soul,
+          model: draft.model,
+          skills: draft.skills,
+          sort_order: draft.sortOrder,
+        });
+        setSelectedId(created.id);
+        const next = draftFromAgent(created);
+        setDraft(next);
+        setSavedDraft(next);
+        await queryClient.invalidateQueries({
+          queryKey: STRATEGY_AGENTS_QUERY_KEY,
+        });
+        toast.success(`${created.name} 已加入分析角度库`);
+      } else if (selectedAgent) {
+        const updated = await updateStrategyAgent(selectedAgent.id, {
+          name,
+          description: draft.description.trim(),
+          soul: draft.soul,
+          model: draft.model,
+          skills: draft.skills,
+          enabled: selectedAgent.fixed ? undefined : draft.enabled,
+          sort_order: selectedAgent.fixed ? undefined : draft.sortOrder,
+        });
+        const next = draftFromAgent(updated);
+        setDraft(next);
+        setSavedDraft(next);
+        await queryClient.invalidateQueries({
+          queryKey: STRATEGY_AGENTS_QUERY_KEY,
+        });
+        toast.success(`${updated.name} 配置已保存`);
+      }
+    } catch (reason) {
+      toast.error(reason instanceof Error ? reason.message : "保存失败");
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const softDelete = async () => {
+    if (!selectedAgent || selectedAgent.fixed || busy) return;
+    const confirmed = window.confirm(
+      `确定停用“${selectedAgent.name}”吗？\n\n它不会再出现在新项目的角度选择中，但历史项目、SOUL 和技能配置都会保留，可随时恢复。`,
+    );
+    if (!confirmed) return;
+    setBusy(true);
+    try {
+      const updated = await disableStrategyAngle(selectedAgent.id);
+      const next = draftFromAgent(updated);
+      setDraft(next);
+      setSavedDraft(next);
+      await queryClient.invalidateQueries({
+        queryKey: STRATEGY_AGENTS_QUERY_KEY,
+      });
+      toast.success(`${updated.name} 已停用，历史项目不受影响`);
+    } catch (reason) {
+      toast.error(reason instanceof Error ? reason.message : "停用失败");
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const handleOpenChange = (nextOpen: boolean) => {
+    if (!nextOpen && (busy || !confirmDiscardChanges())) return;
+    onOpenChange(nextOpen);
+  };
+
+  const category = creating ? "angle" : selectedAgent?.category;
+  const categoryCopy = category ? CATEGORY_COPY[category] : null;
+
+  return (
+    <Dialog open={open} onOpenChange={handleOpenChange}>
+      <DialogContent className="grid h-[min(860px,calc(100vh-40px))] max-w-[1180px] grid-rows-[auto_minmax(0,1fr)_auto] gap-0 overflow-hidden p-0 sm:max-w-[1180px]">
+        <DialogHeader className="border-b px-6 py-5 dark:border-[#173d68]">
+          <DialogTitle className="flex items-center gap-2">
+            <Bot className="size-5 text-primary" />
+            统一策略智能体
+          </DialogTitle>
+          <DialogDescription>
+            配置对所有项目全局生效。流程角色保持唯一；分析角度可扩展、排序和停用，历史项目仍保留原引用。
+          </DialogDescription>
+        </DialogHeader>
+
+        <div className="grid min-h-0 grid-cols-[320px_minmax(0,1fr)]">
+          <aside className="min-h-0 overflow-y-auto border-r bg-muted/20 p-4 dark:border-[#173d68] dark:bg-[#031b38]">
+            <div className="mb-3 flex items-center justify-between px-1">
+              <div>
+                <p className="text-xs font-semibold tracking-wide text-muted-foreground">
+                  固定流程角色
+                </p>
+                <p className="mt-1 text-[11px] text-muted-foreground/80">
+                  仅可修改配置，不可新增、停用或删除
+                </p>
+              </div>
+              <Badge variant="secondary">{fixedAgents.length}</Badge>
+            </div>
+            <div className="space-y-1.5">
+              {fixedAgents.map((agent) => {
+                const selected = agent.id === selectedId;
+                const copy = CATEGORY_COPY[agent.category];
+                return (
+                  <button
+                    key={agent.id}
+                    type="button"
+                    disabled={busy}
+                    onClick={() => selectAgent(agent.id)}
+                    className={cn(
+                      "w-full rounded-xl border px-3 py-3 text-left transition-colors disabled:cursor-not-allowed disabled:opacity-60",
+                      selected
+                        ? "border-primary/45 bg-primary/10 shadow-sm"
+                        : "border-transparent bg-background/70 hover:border-border dark:bg-[#08274c]/55 dark:hover:border-[#28507c]",
+                    )}
+                  >
+                    <span className="flex items-center justify-between gap-2">
+                      <span className="flex min-w-0 items-center gap-2">
+                        <LockKeyhole className="size-3.5 shrink-0 text-muted-foreground" />
+                        <span className="truncate text-sm font-medium">
+                          {copy.title}
+                        </span>
+                      </span>
+                      {selected ? (
+                        <Check className="size-4 shrink-0 text-primary" />
+                      ) : null}
+                    </span>
+                    <span className="mt-1.5 block truncate pl-5.5 text-xs text-muted-foreground">
+                      {agent.name}
+                    </span>
+                  </button>
+                );
+              })}
+            </div>
+
+            <div className="mb-3 mt-6 flex items-center justify-between px-1">
+              <div>
+                <p className="text-xs font-semibold tracking-wide text-muted-foreground">
+                  分析角度库
+                </p>
+                <p className="mt-1 text-[11px] text-muted-foreground/80">
+                  新项目只使用当前启用的角度
+                </p>
+              </div>
+              <Button
+                type="button"
+                size="sm"
+                className="h-8 gap-1.5"
+                disabled={busy}
+                onClick={startCreate}
+              >
+                <CirclePlus className="size-3.5" />
+                新增
+              </Button>
+            </div>
+            <div className="space-y-1.5">
+              {angleAgents.map((agent) => {
+                const selected = agent.id === selectedId;
+                return (
+                  <button
+                    key={agent.id}
+                    type="button"
+                    disabled={busy}
+                    onClick={() => selectAgent(agent.id)}
+                    className={cn(
+                      "w-full rounded-xl border px-3 py-3 text-left transition-colors disabled:cursor-not-allowed disabled:opacity-60",
+                      selected
+                        ? "border-primary/45 bg-primary/10 shadow-sm"
+                        : "border-transparent bg-background/70 hover:border-border dark:bg-[#08274c]/55 dark:hover:border-[#28507c]",
+                      !agent.enabled && "opacity-65",
+                    )}
+                  >
+                    <span className="flex items-center justify-between gap-2">
+                      <span className="flex min-w-0 items-center gap-2">
+                        <Layers3 className="size-3.5 shrink-0 text-primary" />
+                        <span className="truncate text-sm font-medium">
+                          {agent.name}
+                        </span>
+                      </span>
+                      {selected ? (
+                        <Check className="size-4 shrink-0 text-primary" />
+                      ) : null}
+                    </span>
+                    <span className="mt-2 flex items-center justify-between gap-2 pl-5.5">
+                      <span className="truncate text-[11px] text-muted-foreground">
+                        顺序 {agent.sort_order}
+                      </span>
+                      <Badge
+                        variant={agent.enabled ? "secondary" : "outline"}
+                        className="h-5 text-[10px]"
+                      >
+                        {agent.enabled ? "已启用" : "已停用"}
+                      </Badge>
+                    </span>
+                  </button>
+                );
+              })}
+              {!isLoading && angleAgents.length === 0 ? (
+                <div className="rounded-xl border border-dashed p-5 text-center text-xs text-muted-foreground">
+                  暂无分析角度，点击“新增”建立第一个角度。
+                </div>
+              ) : null}
+            </div>
+          </aside>
+
+          <main className="min-h-0 overflow-y-auto px-6 py-5">
+            {isLoading ? (
+              <div className="flex h-64 items-center justify-center gap-2 text-sm text-muted-foreground">
+                <LoaderCircle className="size-4 animate-spin" />
+                正在读取全局配置…
+              </div>
+            ) : error ? (
+              <div className="rounded-xl border border-destructive/30 bg-destructive/5 p-5 text-sm text-destructive">
+                <p className="font-medium">策略智能体配置加载失败</p>
+                <p className="mt-1 leading-6 opacity-85">
+                  {error instanceof Error ? error.message : "请稍后重试"}
+                </p>
+                <Button
+                  variant="outline"
+                  size="sm"
+                  className="mt-4"
+                  onClick={() => void refetch()}
+                >
+                  <RotateCcw className="size-3.5" />
+                  重新加载
+                </Button>
+              </div>
+            ) : categoryCopy ? (
+              <div className="space-y-5">
+                <div className="flex items-start justify-between gap-4">
+                  <div>
+                    <div className="flex flex-wrap items-center gap-2">
+                      <h3 className="text-lg font-semibold">
+                        {creating ? "新增分析角度" : categoryCopy.title}
+                      </h3>
+                      {selectedAgent?.fixed ? (
+                        <Badge variant="outline" className="gap-1">
+                          <LockKeyhole className="size-3" /> 固定角色
+                        </Badge>
+                      ) : null}
+                      {!creating && selectedAgent && !selectedAgent.fixed ? (
+                        <Badge
+                          variant={draft.enabled ? "secondary" : "outline"}
+                        >
+                          {draft.enabled ? "已启用" : "已停用"}
+                        </Badge>
+                      ) : null}
+                    </div>
+                    <p className="mt-1 text-sm text-muted-foreground">
+                      {creating
+                        ? "创建后会成为所有策略项目可选的全局分析角度。"
+                        : categoryCopy.description}
+                    </p>
+                  </div>
+                  {!creating && selectedAgent ? (
+                    <Badge
+                      variant="outline"
+                      className="max-w-[300px] truncate font-mono text-[10px]"
+                      title={selectedAgent.id}
+                    >
+                      {selectedAgent.id}
+                    </Badge>
+                  ) : null}
+                </div>
+
+                <section className="rounded-xl border bg-muted/15 p-4 dark:border-[#173d68] dark:bg-[#031b38]">
+                  <div className="grid gap-4 sm:grid-cols-2">
+                    <label className="block">
+                      <span className="mb-1.5 block text-xs font-medium">
+                        智能体名称
+                      </span>
+                      <Input
+                        value={draft.name}
+                        disabled={busy}
+                        maxLength={100}
+                        placeholder="例如：科技与产业链视角"
+                        onChange={(event) =>
+                          setDraft((current) => ({
+                            ...current,
+                            name: event.target.value,
+                          }))
+                        }
+                      />
+                    </label>
+                    <label className="block">
+                      <span className="mb-1.5 block text-xs font-medium">
+                        运行模型
+                      </span>
+                      <ModelNameSelect
+                        value={draft.model}
+                        onChange={(model) =>
+                          setDraft((current) => ({ ...current, model }))
+                        }
+                        disabled={busy}
+                        defaultLabel="使用系统默认模型"
+                        title="选择该全局智能体运行时使用的大模型"
+                        triggerClassName="h-9 w-full bg-background"
+                      />
+                    </label>
+                    <label className="block sm:col-span-2">
+                      <span className="mb-1.5 block text-xs font-medium">
+                        职责简介
+                      </span>
+                      <Textarea
+                        value={draft.description}
+                        disabled={busy}
+                        maxLength={2000}
+                        className="min-h-20 resize-y"
+                        placeholder="说明该角色关注的问题、交付内容和边界…"
+                        onChange={(event) =>
+                          setDraft((current) => ({
+                            ...current,
+                            description: event.target.value,
+                          }))
+                        }
+                      />
+                    </label>
+                  </div>
+
+                  {!creating && selectedAgent && !selectedAgent.fixed ? (
+                    <div className="mt-4 grid gap-3 border-t pt-4 sm:grid-cols-[1fr_180px] dark:border-[#173d68]">
+                      <div className="flex items-center justify-between rounded-lg border bg-background px-3 py-2.5 dark:border-[#28507c] dark:bg-[#08274c]">
+                        <div>
+                          <p className="text-sm font-medium">用于新项目</p>
+                          <p className="mt-0.5 text-xs text-muted-foreground">
+                            停用后历史项目仍可回显，新的角度选择将隐藏它
+                          </p>
+                        </div>
+                        <Switch
+                          checked={draft.enabled}
+                          disabled={busy}
+                          aria-label="启用该分析角度"
+                          onCheckedChange={(enabled) =>
+                            setDraft((current) => ({ ...current, enabled }))
+                          }
+                        />
+                      </div>
+                      <label className="block">
+                        <span className="mb-1.5 block text-xs font-medium">
+                          显示顺序
+                        </span>
+                        <Input
+                          type="number"
+                          min={-10000}
+                          max={10000}
+                          value={draft.sortOrder}
+                          disabled={busy}
+                          onChange={(event) =>
+                            setDraft((current) => ({
+                              ...current,
+                              sortOrder: Number(event.target.value) || 0,
+                            }))
+                          }
+                        />
+                      </label>
+                    </div>
+                  ) : creating ? (
+                    <label className="mt-4 block max-w-[180px] border-t pt-4 dark:border-[#173d68]">
+                      <span className="mb-1.5 block text-xs font-medium">
+                        显示顺序
+                      </span>
+                      <Input
+                        type="number"
+                        min={-10000}
+                        max={10000}
+                        value={draft.sortOrder}
+                        disabled={busy}
+                        onChange={(event) =>
+                          setDraft((current) => ({
+                            ...current,
+                            sortOrder: Number(event.target.value) || 0,
+                          }))
+                        }
+                      />
+                    </label>
+                  ) : null}
+                </section>
+
+                <label className="block">
+                  <span className="mb-2 flex items-center gap-2 text-sm font-medium">
+                    <Sparkles className="size-4 text-primary" /> SOUL
+                  </span>
+                  <Textarea
+                    value={draft.soul}
+                    disabled={busy}
+                    maxLength={200000}
+                    onChange={(event) =>
+                      setDraft((current) => ({
+                        ...current,
+                        soul: event.target.value,
+                      }))
+                    }
+                    className="min-h-[210px] resize-y font-mono text-xs leading-6"
+                    placeholder="定义角色身份、分析方法、行为边界和输出格式…"
+                  />
+                </label>
+
+                <section className="space-y-2">
+                  <div className="flex items-center justify-between gap-3">
+                    <span className="text-sm font-medium">系统技能选择</span>
+                    <Badge variant="secondary">
+                      已选 {draft.skills.length} 个
+                    </Badge>
+                  </div>
+                  <p className="text-xs leading-5 text-muted-foreground">
+                    只展示当前启用且全局可见的系统技能；通过穿梭框选择，不接受手工输入技能名。
+                  </p>
+                  <SkillTransferSelector
+                    skills={selectableSkills}
+                    selected={draft.skills}
+                    onChange={(selectedSkills) =>
+                      setDraft((current) => ({
+                        ...current,
+                        skills: selectedSkills,
+                      }))
+                    }
+                    isLoading={isSkillsLoading}
+                    onViewDetail={setDetailSkillName}
+                  />
+                  {skillsError ? (
+                    <p className="text-xs text-destructive">
+                      技能库加载失败，请稍后重试。
+                    </p>
+                  ) : null}
+                </section>
+              </div>
+            ) : (
+              <div className="flex h-64 items-center justify-center text-sm text-muted-foreground">
+                暂无可配置角色
+              </div>
+            )}
+          </main>
+        </div>
+
+        <DialogFooter className="flex-row items-center justify-between border-t px-6 py-4 dark:border-[#173d68] sm:justify-between">
+          <div>
+            {!creating && selectedAgent && !selectedAgent.fixed ? (
+              selectedAgent.enabled ? (
+                <Button
+                  variant="ghost"
+                  className="text-destructive hover:bg-destructive/10 hover:text-destructive"
+                  disabled={busy}
+                  onClick={() => void softDelete()}
+                >
+                  <Trash2 className="size-4" />
+                  停用并从新项目移除
+                </Button>
+              ) : (
+                <span className="flex items-center gap-1.5 text-xs text-muted-foreground">
+                  <Power className="size-3.5" />
+                  打开“用于新项目”并保存即可恢复
+                </span>
+              )
+            ) : (
+              <span className="text-xs text-muted-foreground">
+                {creating
+                  ? "新角度创建后立即全局可用"
+                  : "固定角色始终参与对应流程阶段"}
+              </span>
+            )}
+          </div>
+          <div className="flex gap-2">
+            <Button
+              variant="outline"
+              disabled={busy}
+              onClick={() => handleOpenChange(false)}
+            >
+              关闭
+            </Button>
+            <Button
+              disabled={
+                !categoryCopy ||
+                !draft.name.trim() ||
+                busy ||
+                isLoading ||
+                isSkillsLoading ||
+                (!creating && !dirty)
+              }
+              onClick={() => void save()}
+            >
+              {busy ? (
+                <LoaderCircle className="size-4 animate-spin" />
+              ) : creating ? (
+                <CirclePlus className="size-4" />
+              ) : (
+                <Save className="size-4" />
+              )}
+              {creating ? "创建分析角度" : "保存当前配置"}
+            </Button>
+          </div>
+        </DialogFooter>
+      </DialogContent>
+      <SkillDetailDialog
+        skillName={detailSkillName}
+        open={detailSkillName !== null}
+        onOpenChange={(nextOpen) => {
+          if (!nextOpen) setDetailSkillName(null);
+        }}
+      />
+    </Dialog>
+  );
+}

frontend-web/src/strategy-selection/api.ts

@@ -0,0 +1,44 @@
+import { apiFetch } from "@/core/api/fetch-client";
+import { getBackendBaseURL } from "@/core/config";
+
+import { parseSseChunk } from "./lib";
+import type { ParallelAgentEvent, ParallelAgentPayload } from "./types";
+
+async function readError(response: Response): Promise<string> {
+  const body = (await response.json().catch(() => null)) as
+    | { detail?: string }
+    | null;
+  return body?.detail || `请求失败（HTTP ${response.status}）`;
+}
+export async function streamParallelAgents(
+  payload: ParallelAgentPayload,
+  onEvent: (event: ParallelAgentEvent) => void,
+  signal?: AbortSignal,
+): Promise<void> {
+  const response = await apiFetch(
+    `${getBackendBaseURL()}/api/parallel-agents/run/stream`,
+    {
+      method: "POST",
+      headers: {
+        Accept: "text/event-stream",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(payload),
+      signal,
+    },
+  );
+  if (!response.ok) throw new Error(await readError(response));
+  if (!response.body) throw new Error("服务器未返回流式响应");
+
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    buffer += decoder.decode(value, { stream: !done });
+    const parsed = parseSseChunk(buffer, done);
+    buffer = parsed.rest;
+    parsed.events.forEach(onEvent);
+    if (done) break;
+  }
+}

frontend-web/src/strategy-selection/constants.ts

@@ -0,0 +1,350 @@
+import type {
+  AgentOutputState,
+  IntentTurn,
+  StrategyAngle,
+  StrategyEvaluation,
+  StrategyTaskDraft,
+} from "./types";
+
+export const STRATEGY_AGENT_ROLES = [
+  {
+    id: "strategy-selection-intent",
+    name: "意图理解智能体",
+    role: "将自然语言需求整理为可执行任务",
+  },
+  {
+    id: "strategy-selection-angle-governance",
+    name: "治理统筹智能体",
+    role: "关注目标、机制、跨部门协同与执行闭环",
+  },
+  {
+    id: "strategy-selection-angle-diplomacy",
+    name: "外交沟通智能体",
+    role: "关注沟通渠道、危机管控与多边协调",
+  },
+  {
+    id: "strategy-selection-angle-economy",
+    name: "经济韧性智能体",
+    role: "关注供应链、产业、贸易与市场预期",
+  },
+  {
+    id: "strategy-selection-angle-security",
+    name: "安全风险智能体",
+    role: "关注预警、误判防范与非升级性风险处置",
+  },
+  {
+    id: "strategy-selection-angle-public-opinion",
+    name: "社会民生智能体",
+    role: "关注公众沟通、民生连续性与人道保障",
+  },
+  {
+    id: "strategy-selection-angle-law-policy",
+    name: "法律规则智能体",
+    role: "关注适用规则、合规边界与证据链",
+  },
+  {
+    id: "strategy-selection-judge",
+    name: "策略评判智能体",
+    role: "以统一量表比较策略的收益、风险与可执行性",
+  },
+  {
+    id: "strategy-selection-solution",
+    name: "方案整理智能体",
+    role: "将入选策略去重、消冲突并整理为最终方案",
+  },
+] as const;
+
+export const STRATEGY_ANGLES: StrategyAngle[] = [
+  {
+    id: "governance",
+    agentId: "strategy-selection-angle-governance",
+    name: "治理与统筹",
+    shortName: "治理",
+    description: "目标拆解、组织协同、阶段推进和反馈闭环",
+    accent: "#6d5dfc",
+  },
+  {
+    id: "diplomacy",
+    agentId: "strategy-selection-angle-diplomacy",
+    name: "外交与沟通",
+    shortName: "外交",
+    description: "危机沟通、多边协调、信号一致性与降温安排",
+    accent: "#0ea5e9",
+  },
+  {
+    id: "economy",
+    agentId: "strategy-selection-angle-economy",
+    name: "经济与产业韧性",
+    shortName: "经济",
+    description: "供应链连续性、市场预期、贸易和关键产业保障",
+    accent: "#10b981",
+  },
+  {
+    id: "security",
+    agentId: "strategy-selection-angle-security",
+    name: "安全与风险管控",
+    shortName: "安全",
+    description: "态势预警、误判防范、事件分级和非升级性处置",
+    accent: "#f97316",
+  },
+  {
+    id: "public_opinion",
+    agentId: "strategy-selection-angle-public-opinion",
+    name: "社会民生与舆情",
+    shortName: "民生",
+    description: "公众沟通、基本服务、社会心理和人道保障",
+    accent: "#ec4899",
+  },
+  {
+    id: "law_policy",
+    agentId: "strategy-selection-angle-law-policy",
+    name: "法律与规则",
+    shortName: "法律",
+    description: "适用规则、合规审查、责任边界与证据留存",
+    accent: "#a855f7",
+  },
+];
+
+export const EMPTY_TASK_DRAFT: StrategyTaskDraft = {
+  name: "",
+  detail: "",
+  objective: "",
+  prerequisites: "",
+  constraints: "",
+  deliverables: "",
+  acceptanceCriteria: "",
+  horizon: "",
+  selectedAngleIds: STRATEGY_ANGLES.slice(0, 4).map((angle) => angle.id),
+};
+
+export const INITIAL_INTENT_TURNS: IntentTurn[] = [
+  {
+    id: "welcome",
+    role: "assistant",
+    content:
+      "请描述你想解决的问题、希望达成的目标以及已知约束。我会通过对话补齐关键信息，并把需求实时整理到右侧任务草稿。",
+  },
+];
+
+export const TAIWAN_STRAIT_DEMO_TASK: StrategyTaskDraft = {
+  name: "台海局势风险管控与区域韧性提升策略",
+  detail:
+    "面向台海局势高不确定性场景，形成一套不预设立场、以避免误判和升级为核心的综合政策方案。方案聚焦危机沟通、区域经济与民生连续性、规则遵循及信息透明，不包含战术行动、目标选择或武力运用指导。",
+  objective:
+    "未来12—24个月内，降低突发事件转化为系统性危机的概率，保护平民福祉与关键经济活动，维持可验证、可持续的沟通和协调机制。",
+  prerequisites:
+    "建立跨部门联合研判机制；明确授权与对外沟通口径；掌握航运、能源、金融、通信和公共服务的基础风险数据；预留与各相关方沟通的技术渠道。",
+  constraints:
+    "遵守适用的国际法及人道原则；坚持克制、对等、可逆和非升级；不得输出军事战术、具体目标、武器使用或规避监管建议；关键事实须标注时点并交叉核验。",
+  deliverables:
+    "一份综合策略；分阶段行动清单；跨部门责任矩阵；风险预警指标；对外沟通要点；每月复盘和动态调整机制。",
+  acceptanceCriteria:
+    "措施均有责任主体、触发条件和退出条件；重要建议至少经两个角度交叉验证；高风险措施设置法律审查与升级门槛；方案可在72小时内启动首轮响应。",
+  horizon: "12—24个月，按0—30天、1—6个月、6—24个月分三阶段推进",
+  selectedAngleIds: STRATEGY_ANGLES.map((angle) => angle.id),
+};
+
+export const TAIWAN_STRAIT_DEMO_TURNS: IntentTurn[] = [
+  ...INITIAL_INTENT_TURNS,
+  {
+    id: "demo-user",
+    role: "user",
+    isDemo: true,
+    content:
+      "请围绕台海局势做一个综合风险管控策略，重点是减少误判升级，同时兼顾经济、民生和规则约束，时间范围看未来一到两年。",
+  },
+  {
+    id: "demo-assistant",
+    role: "assistant",
+    isDemo: true,
+    content:
+      "已将需求整理为“风险管控与区域韧性提升”任务：以降级避险为目标，采用治理、外交、经济、安全、民生和法律六个角度并行论证；明确排除战术性军事建议，并补充了阶段周期、验收标准和启动条件。右侧字段仍可直接修改。",
+  },
+];
+
+export const TAIWAN_STRAIT_DEMO_OUTPUTS: Record<string, AgentOutputState> = {
+  "strategy-selection-angle-governance": {
+    status: "done",
+    isDemo: true,
+    steps: ["拆解目标", "形成协同机制", "设置复盘闭环"],
+    content: `### 治理统筹策略：建立“联合研判—分级响应—复盘校正”闭环
+
+1. 设立常态化跨部门风险研判单元，统一风险词典、数据口径和事件分级。
+2. 为不同风险等级预先定义责任主体、会商时限、可逆措施和退出条件，避免临时决策放大误判。
+3. 建立月度桌面推演与季度复盘，重点校验交通、能源、金融、通信和公共服务之间的级联风险。
+4. 重大调整实行“政策效果—升级风险—民生影响—法律合规”四项并联审查。
+
+**优先动作：** 30天内完成责任矩阵和跨部门值守清单；90天内完成首次全链路压力测试。`,
+  },
+  "strategy-selection-angle-diplomacy": {
+    status: "done",
+    isDemo: true,
+    steps: ["识别沟通对象", "设计危机渠道", "校准公开信号"],
+    content: `### 外交沟通策略：保持多层次、可验证的危机沟通
+
+1. 维护工作层、专业部门和高层三类沟通渠道，约定紧急事件的确认窗口与回执机制。
+2. 对外表述采用“事实、原则、下一步安排”三段式，减少模糊威慑和相互误读。
+3. 支持以航行安全、灾害救援、公共卫生等低政治敏感议题开展技术性接触，积累最低限度信任。
+4. 引入可信第三方作为信息转递与事实核验的备份通道，但不替代直接沟通。
+
+**触发条件：** 当出现信息不一致、渠道中断或舆情快速放大时，立即启动双渠道交叉确认。`,
+  },
+  "strategy-selection-angle-economy": {
+    status: "done",
+    isDemo: true,
+    steps: ["识别关键链路", "评估替代能力", "配置韧性措施"],
+    content: `### 经济韧性策略：先保连续性，再做结构性分散
+
+1. 对航运、半导体、能源、金融结算和通信链路建立关键节点清单与中断情景。
+2. 以库存天数、替代供应商覆盖率、运输改道时间和流动性缺口作为月度韧性指标。
+3. 对短期冲击优先使用信息协调、应急库存和融资支持，避免仓促、不可逆的全面脱钩措施。
+4. 中长期推动来源与路线多元化，同时保留正常经贸交往的政策空间。
+
+**优先动作：** 对关键民生物资开展30/60/90天压力测试，并为中小企业准备定向流动性工具。`,
+  },
+  "strategy-selection-angle-security": {
+    status: "done",
+    isDemo: true,
+    steps: ["构建预警指标", "划分风险等级", "设计降级动作"],
+    content: `### 安全风险策略：以预警和降级机制减少偶发事件外溢
+
+1. 建立覆盖异常活动、通信中断、错误信息扩散、交通受阻和市场波动的综合预警看板。
+2. 将风险划分为关注、紧张、严重三级，每级只配置克制、可逆、可解释的非升级性应对动作。
+3. 对来源未核实的信息实行“双源确认+时点标注”，避免单一信号直接触发重大政策响应。
+4. 所有高风险决策设置冷静期、法律复核和跨部门反方意见席位。
+
+**止损线：** 一旦沟通渠道失效或民生影响超过阈值，优先恢复沟通与公共服务，暂停可能叠加风险的新措施。`,
+  },
+  "strategy-selection-angle-public-opinion": {
+    status: "done",
+    isDemo: true,
+    steps: ["分析公众需求", "保障基本服务", "设计信息发布"],
+    content: `### 社会民生策略：稳定预期并保护基本服务
+
+1. 建立权威、固定频率的信息发布窗口，明确已知、未知和正在核验的事项。
+2. 为交通、医疗、能源、通信和教育准备连续性方案，优先保障脆弱群体。
+3. 监测谣言与恐慌性行为时，采用事实澄清和服务指引，不扩大未经证实的信息。
+4. 设置独立反馈渠道，收集企业、社区和民众的实际困难并纳入每日研判。
+
+**评价指标：** 基本服务可用率、权威信息触达率、谣言纠正时长和重点群体保障覆盖率。`,
+  },
+  "strategy-selection-angle-law-policy": {
+    status: "done",
+    isDemo: true,
+    steps: ["识别规则边界", "建立审查清单", "设计留痕机制"],
+    content: `### 法律规则策略：把合规审查嵌入每个决策节点
+
+1. 为数据共享、经济措施、应急管理和对外沟通分别建立适用规则清单。
+2. 重大措施记录事实依据、授权来源、比例性判断、影响评估和退出条件。
+3. 涉及平民权益、基本服务和跨境活动的措施优先进行人道影响评估。
+4. 对时效性强的事项采用“快速初审—事后完整复核”，但不得跳过最低合规门槛。
+
+**优先动作：** 建立统一法律审查模板和决策证据包，保证后续可解释、可追溯。`,
+  },
+};
+
+export const TAIWAN_STRAIT_DEMO_EVALUATIONS: StrategyEvaluation[] = [
+  {
+    agentId: "strategy-selection-angle-governance",
+    score: 92,
+    conclusion: "优先推荐",
+    comment: "跨部门闭环清晰，是其他策略落地的共同底座。",
+    strengths: ["责任明确", "阶段完整", "便于复盘"],
+    risks: ["需要稳定的牵头机制"],
+  },
+  {
+    agentId: "strategy-selection-angle-diplomacy",
+    score: 90,
+    conclusion: "优先推荐",
+    comment: "直接作用于误判风险，且措施克制、可逆。",
+    strengths: ["降级效果直接", "渠道有备份"],
+    risks: ["依赖相关方持续参与"],
+  },
+  {
+    agentId: "strategy-selection-angle-economy",
+    score: 86,
+    conclusion: "建议采用",
+    comment: "兼顾短期连续性与长期韧性，需控制过度防御成本。",
+    strengths: ["指标可量化", "避免一刀切"],
+    risks: ["跨行业数据获取成本较高"],
+  },
+  {
+    agentId: "strategy-selection-angle-security",
+    score: 91,
+    conclusion: "优先推荐",
+    comment: "预警、确认和冷静期设计可显著降低错误触发。",
+    strengths: ["止损线清楚", "强调双源核验"],
+    risks: ["阈值需持续校准"],
+  },
+  {
+    agentId: "strategy-selection-angle-public-opinion",
+    score: 84,
+    conclusion: "建议采用",
+    comment: "增强社会承压能力，建议与经济连续性方案合并实施。",
+    strengths: ["关注脆弱群体", "沟通指标明确"],
+    risks: ["需避免信息发布碎片化"],
+  },
+  {
+    agentId: "strategy-selection-angle-law-policy",
+    score: 88,
+    conclusion: "建议采用",
+    comment: "为高压情境下的决策提供必要边界和可追溯性。",
+    strengths: ["审查嵌入流程", "留痕充分"],
+    risks: ["快速响应与完整审查需平衡"],
+  },
+];
+
+export const TAIWAN_STRAIT_DEMO_SYNTHESIS = `# 台海局势风险管控与区域韧性提升综合方案
+
+> **示例说明：** 本方案为产品功能演示数据，采用中立、降级避险和民生优先视角，不构成现实决策建议；正式使用前应依据最新可靠信息进行专业复核。
+
+## 一、总体目标
+
+在未来12—24个月内，以“减少误判、阻断升级、保护民生、维持连续性”为主线，建立可监测、可启动、可退出、可复盘的风险管控体系。任何措施均应符合适用规则，坚持克制、对等、可逆和可解释。
+
+## 二、四条主策略
+
+### 1. 联合研判与分级响应
+
+- 建立跨部门常态研判单元，统一风险词典、数据口径和三级事件标准。
+- 每个级别明确牵头主体、会商时限、启动阈值、允许动作和退出条件。
+- 重大建议同时接受政策效果、升级风险、民生影响和法律合规审查。
+
+### 2. 多层危机沟通与事实核验
+
+- 维护工作层、专业部门和高层沟通渠道，并配置可信第三方备份。
+- 紧急事项执行“双渠道回执、双来源确认、统一时点标注”。
+- 公开沟通采用“事实—原则—下一步安排”结构，降低信号歧义。
+
+### 3. 经济与公共服务连续性
+
+- 围绕航运、能源、金融、通信、医疗和关键供应链建立中断情景清单。
+- 用库存天数、替代覆盖率、改道时长、服务可用率等指标开展月度压力测试。
+- 短期优先使用应急库存、信息协调和定向融资；中长期有序提升来源与路线多元化。
+
+### 4. 规则嵌入与社会韧性
+
+- 将授权来源、比例性、人道影响、退出条件和证据留存纳入统一审查模板。
+- 通过固定频率的权威发布说明已知、未知和核验进度，提供清晰服务指引。
+- 优先保障脆弱群体，并建立企业、社区与公众反馈的快速回流机制。
+
+## 三、阶段安排
+
+| 阶段 | 重点动作 | 主要产出 |
+| --- | --- | --- |
+| 0—30天 | 完成责任矩阵、沟通清单、关键链路盘点与法律审查模板 | 一图一表一清单、首版预警看板 |
+| 1—6个月 | 开展压力测试和桌面推演，打通双渠道确认与公众反馈 | 演练报告、阈值校准、改进台账 |
+| 6—24个月 | 推进结构性韧性项目并季度复盘，动态退出低效措施 | 韧性提升项目、季度评估报告 |
+
+## 四、核心预警指标
+
+1. 沟通渠道可用率与紧急事项回执时长。
+2. 未核实信息传播速度及权威澄清时长。
+3. 关键运输、能源、金融、通信和公共服务可用率。
+4. 市场异常波动、关键物资库存天数与替代供应覆盖率。
+5. 脆弱群体保障覆盖率和公众反馈闭环时长。
+
+## 五、止损与调整机制
+
+当直接沟通失效、基本服务明显下降、信息可信度不足或风险指标跨级跃升时，优先恢复沟通、事实核验和民生服务；暂停新增高风险措施。每月复盘策略组合，每季度由独立评估组检查目标偏移、措施叠加和退出条件执行情况。
+`;

frontend-web/src/strategy-selection/lib.test.ts

@@ -0,0 +1,329 @@
+/**
+ * Run from frontend-web:
+ *   npx esbuild src/strategy-selection/lib.test.ts --bundle --format=esm --platform=node --outfile=.runtime/unit-tests/strategy-selection.test.mjs
+ *   node --test .runtime/unit-tests/strategy-selection.test.mjs
+ */
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  areStrategyTaskDraftsEquivalent,
+  buildIntentBrief,
+  buildJudgeBrief,
+  buildSynthesisBrief,
+  extractFencedJson,
+  normalizeIntentClarification,
+  parseEvaluationsFromText,
+  parseSseChunk,
+  parseTaskDraftFromText,
+  stripStructuredBlocks,
+} from "./lib";
+import { EMPTY_TASK_DRAFT, STRATEGY_ANGLES } from "./constants";
+import type { AgentOutputState, StrategyAngle } from "./types";
+
+test("parseSseChunk preserves incomplete frames and parses subsequent frames", () => {
+  const first = parseSseChunk(
+    'data: {"type":"agent_start","agent_id":"a"}\n\ndata: {"type":"del',
+  );
+  assert.equal(first.events.length, 1);
+  assert.equal(first.events[0].type, "agent_start");
+  const second = parseSseChunk(`${first.rest}ta","agent_id":"a","text":"你好"}\n\n`);
+  assert.deepEqual(second.events, [
+    { type: "delta", agent_id: "a", text: "你好" },
+  ]);
+});
+
+test("normalizeIntentClarification accepts string and object options", () => {
+  const clarification = normalizeIntentClarification({
+    type: "agent_clarification",
+    agent_id: "strategy-selection-intent",
+    question: "请选择时间范围",
+    options: ["短期", { id: "long", label: "长期", description: "一年以上" }],
+    allow_custom: true,
+    allow_multiple: false,
+  });
+  assert.equal(clarification.question, "请选择时间范围");
+  assert.deepEqual(clarification.options, [
+    { id: "option-1", label: "短期", description: undefined },
+    { id: "long", label: "长期", description: "一年以上" },
+  ]);
+  assert.equal(clarification.allowCustom, true);
+});
+
+test("task draft equivalence ignores whitespace and angle ordering only", () => {
+  const left = {
+    ...EMPTY_TASK_DRAFT,
+    name: "区域 风险方案",
+    detail: "第一行\n第二行",
+    selectedAngleIds: ["governance", "diplomacy"],
+  };
+  const presentationOnlyChange = {
+    ...left,
+    name: "  区域   风险方案 ",
+    detail: "第一行  第二行",
+    selectedAngleIds: ["diplomacy", "governance", "diplomacy"],
+  };
+  assert.equal(
+    areStrategyTaskDraftsEquivalent(left, presentationOnlyChange),
+    true,
+  );
+  assert.equal(
+    areStrategyTaskDraftsEquivalent(left, {
+      ...presentationOnlyChange,
+      objective: "新增目标",
+    }),
+    false,
+  );
+});
+
+test("intent brief retains the clarification question and the user's confirmed answer", () => {
+  const brief = buildIntentBrief(
+    [
+      {
+        id: "clarify",
+        role: "assistant",
+        content: "",
+        clarification: {
+          question: "方案主要面向谁？",
+          options: [{ id: "public", label: "公共部门" }],
+          allowCustom: true,
+          allowMultiple: false,
+        },
+        clarificationAnswered: true,
+        clarificationAnswer: "公共部门",
+      },
+      { id: "answer", role: "user", content: "对澄清问题的回答：公共部门" },
+    ],
+    EMPTY_TASK_DRAFT,
+  );
+  assert.match(brief, /意图助手澄清：方案主要面向谁/);
+  assert.match(brief, /用户对该澄清的确认：公共部门/);
+});
+
+test("stripStructuredBlocks keeps prose and hides machine-readable payloads", () => {
+  assert.equal(
+    stripStructuredBlocks('说明文字\n[INTENT_READY]\n```strategy-task-json\n{"name":"x"}\n```'),
+    "说明文字",
+  );
+});
+
+test("extractFencedJson and parseTaskDraftFromText read the structured task block", () => {
+  const text = [
+    "已整理任务。",
+    "```strategy-task-json",
+    JSON.stringify({
+      name: "测试任务",
+      detail: "详情",
+      recommended_angles: ["governance", "unknown", "law_policy"],
+    }),
+    "```",
+  ].join("\n");
+  assert.deepEqual(extractFencedJson(text, "strategy-task-json"), {
+    name: "测试任务",
+    detail: "详情",
+    recommended_angles: ["governance", "unknown", "law_policy"],
+  });
+  const task = parseTaskDraftFromText(text, EMPTY_TASK_DRAFT);
+  assert.equal(task?.name, "测试任务");
+  assert.deepEqual(task?.selectedAngleIds, ["governance", "law_policy"]);
+});
+
+test("task parser accepts backend SOUL field aliases", () => {
+  const text = `\`\`\`strategy-task-json\n${JSON.stringify({
+    task_name: "别名任务",
+    task_detail: "别名详情",
+    expected_outputs: "综合方案",
+    recommended_angles: ["public_opinion", "strategy-selection-angle-law-policy"],
+  })}\n\`\`\``;
+  const task = parseTaskDraftFromText(text, EMPTY_TASK_DRAFT);
+  assert.equal(task?.name, "别名任务");
+  assert.equal(task?.detail, "别名详情");
+  assert.equal(task?.deliverables, "综合方案");
+  assert.deepEqual(task?.selectedAngleIds, ["public_opinion", "law_policy"]);
+});
+
+test("task parser rejects incomplete or unrecognized current-turn payloads", () => {
+  const completeFallback = {
+    ...EMPTY_TASK_DRAFT,
+    name: "旧任务",
+    detail: "旧详情",
+    selectedAngleIds: ["governance"],
+  };
+  const wrap = (payload: unknown) =>
+    `\`\`\`strategy-task-json\n${JSON.stringify(payload)}\n\`\`\``;
+
+  assert.equal(parseTaskDraftFromText(wrap({}), completeFallback), null);
+  assert.equal(parseTaskDraftFromText(wrap([]), completeFallback), null);
+  assert.equal(
+    parseTaskDraftFromText(
+      wrap({ name: "新任务", detail: "新详情", selectedAngleIds: ["unknown"] }),
+      completeFallback,
+    ),
+    null,
+  );
+  assert.equal(
+    parseTaskDraftFromText(
+      wrap({ name: "新任务", detail: "新详情" }),
+      completeFallback,
+    ),
+    null,
+  );
+});
+
+test("evaluation parser validates scores without inventing missing candidates", () => {
+  const outputs: Record<string, AgentOutputState> = {
+    "strategy-selection-angle-governance": {
+      status: "done",
+      content: "A",
+      steps: [],
+    },
+    "strategy-selection-angle-law-policy": { status: "done", content: "B", steps: [] },
+    "strategy-selection-angle-security": {
+      status: "error",
+      content: "PARTIAL_FAILED_OUTPUT",
+      steps: [],
+      error: "failed",
+    },
+  };
+  const text = `\`\`\`strategy-evaluation-json\n${JSON.stringify({
+    evaluations: [
+      {
+        agentId: "strategy-selection-angle-governance",
+        score: 100,
+        conclusion: "优先推荐",
+        comment: "清晰",
+      },
+    ],
+  })}\n\`\`\``;
+  const evaluations = parseEvaluationsFromText(text, outputs);
+  assert.equal(evaluations.length, 1);
+  assert.equal(evaluations[0].score, 100);
+  assert.equal(
+    evaluations.some(
+      (item) => item.agentId === "strategy-selection-angle-law-policy",
+    ),
+    false,
+  );
+  assert.equal(buildJudgeBrief(EMPTY_TASK_DRAFT, outputs).includes("PARTIAL_FAILED_OUTPUT"), false);
+});
+
+test("judge prompt and evaluation parser only use task-selected angles", () => {
+  const outputs: Record<string, AgentOutputState> = {
+    "strategy-selection-angle-governance": { status: "done", content: "治理策略", steps: [] },
+    "strategy-selection-angle-law-policy": { status: "done", content: "法律策略", steps: [] },
+  };
+  const task = { ...EMPTY_TASK_DRAFT, selectedAngleIds: ["governance"] };
+  const brief = buildJudgeBrief(task, outputs);
+  assert.equal(brief.includes("治理策略"), true);
+  assert.equal(brief.includes("法律策略"), false);
+  const evaluations = parseEvaluationsFromText("无结构化量表", outputs, [
+    "strategy-selection-angle-governance",
+  ]);
+  assert.deepEqual(evaluations, []);
+});
+
+test("dynamic administrator angles flow through intent parsing and judging without fabricated evaluation", () => {
+  const dynamic: StrategyAngle = {
+    id: "technology",
+    agentId: "strategy-selection-angle-dynamic-tech",
+    name: "科技与产业链",
+    shortName: "科技",
+    description: "关注技术依赖与产业协同",
+    accent: "#2563eb",
+    enabled: true,
+  };
+  const task = {
+    ...EMPTY_TASK_DRAFT,
+    selectedAngleIds: [dynamic.id],
+  };
+  const parsed = parseTaskDraftFromText(
+    `\`\`\`strategy-task-json\n${JSON.stringify({
+      name: "动态任务",
+      detail: "测试管理员新增角度",
+      selectedAngleIds: [dynamic.agentId],
+    })}\n\`\`\``,
+    task,
+    [dynamic],
+  );
+  assert.deepEqual(parsed?.selectedAngleIds, [dynamic.id]);
+  assert.match(buildIntentBrief([], task, [dynamic]), /technology：科技与产业链/);
+
+  const outputs: Record<string, AgentOutputState> = {
+    [dynamic.agentId]: { status: "done", content: "科技策略", steps: [] },
+  };
+  assert.match(buildJudgeBrief(task, outputs, [dynamic]), /科技策略/);
+  assert.deepEqual(
+    parseEvaluationsFromText("没有结构化评判", outputs, [dynamic.agentId], [dynamic]),
+    [],
+  );
+});
+
+test("evaluation parser rejects missing fields, invalid scores, and duplicate agent rows", () => {
+  const agentId = "strategy-selection-angle-governance";
+  const outputs: Record<string, AgentOutputState> = {
+    [agentId]: { status: "done", content: "治理策略", steps: [] },
+  };
+  const wrap = (evaluations: Record<string, unknown>[]) =>
+    `\`\`\`strategy-evaluation-json\n${JSON.stringify({ evaluations })}\n\`\`\``;
+
+  assert.deepEqual(
+    parseEvaluationsFromText(
+      `\`\`\`strategy-evaluation-json\n${JSON.stringify({ evaluations: [null] })}\n\`\`\``,
+      outputs,
+      [agentId],
+    ),
+    [],
+  );
+
+  assert.deepEqual(
+    parseEvaluationsFromText(wrap([{ agentId, conclusion: "建议采用" }]), outputs, [agentId]),
+    [],
+  );
+  assert.deepEqual(
+    parseEvaluationsFromText(
+      wrap([{ agentId, score: 80.5, conclusion: "建议采用" }]),
+      outputs,
+      [agentId],
+    ),
+    [],
+  );
+  assert.deepEqual(
+    parseEvaluationsFromText(
+      wrap([
+        { agentId, score: 80, conclusion: "建议采用" },
+        { agentId, score: 75, conclusion: "保留备选" },
+      ]),
+      outputs,
+      [agentId],
+    ),
+    [],
+  );
+});
+
+test("synthesis prompt exposes only the user's final strategy basket", () => {
+  const governance = STRATEGY_ANGLES.find((angle) => angle.id === "governance")!;
+  const security = STRATEGY_ANGLES.find((angle) => angle.id === "security")!;
+  const task = {
+    ...EMPTY_TASK_DRAFT,
+    selectedAngleIds: STRATEGY_ANGLES.map((angle) => angle.id),
+  };
+  const outputs: Record<string, AgentOutputState> = {
+    [governance.agentId]: { status: "done", content: "治理入选正文", steps: [] },
+    [security.agentId]: { status: "done", content: "安全未入选正文", steps: [] },
+  };
+  const brief = buildSynthesisBrief(
+    task,
+    [governance.agentId],
+    outputs,
+    [],
+    STRATEGY_ANGLES,
+  );
+
+  assert.match(
+    brief,
+    new RegExp(`最终只允许整合以下 1 项：${governance.name}`),
+  );
+  assert.match(brief, /治理入选正文/);
+  assert.equal(brief.includes("安全未入选正文"), false);
+  assert.match(brief, /"selectedAngleIds": \[\s*"governance"\s*\]/);
+});

frontend-web/src/strategy-selection/lib.ts

@@ -0,0 +1,408 @@
+import { STRATEGY_ANGLES } from "./constants";
+import type {
+  AgentOutputState,
+  IntentClarification,
+  IntentTurn,
+  ParallelAgentEvent,
+  StrategyAngle,
+  StrategyEvaluation,
+  StrategyTaskDraft,
+} from "./types";
+
+function stringValue(value: unknown): string {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+export function normalizeIntentClarification(
+  event: Extract<ParallelAgentEvent, { type: "agent_clarification" }>,
+): IntentClarification {
+  const question =
+    stringValue(event.question) ||
+    stringValue(event.content) ||
+    "请补充完成任务定义所需的信息。";
+  const options = Array.isArray(event.options)
+    ? event.options
+        .map((option, index) => {
+          const label =
+            typeof option === "string" ? stringValue(option) : stringValue(option?.label);
+          if (!label) return null;
+          return {
+            id:
+              (typeof option === "string" ? "" : stringValue(option.id)) ||
+              `option-${index + 1}`,
+            label,
+            description:
+              (typeof option === "string" ? "" : stringValue(option.description)) ||
+              undefined,
+          };
+        })
+        .filter((option): option is NonNullable<typeof option> => option !== null)
+    : [];
+  return {
+    question,
+    context:
+      stringValue(event.clarification_context) ||
+      stringValue(event.context) ||
+      undefined,
+    clarificationType: stringValue(event.clarification_type) || undefined,
+    options,
+    allowCustom: event.allow_custom !== false || options.length === 0,
+    allowMultiple: event.allow_multiple === true,
+  };
+}
+
+function selectedStrategyAgentIds(
+  task: StrategyTaskDraft,
+  angles: StrategyAngle[],
+): Set<string> {
+  return new Set(
+    angles.filter((angle) => task.selectedAngleIds.includes(angle.id)).map(
+      (angle) => angle.agentId,
+    ),
+  );
+}
+
+const TASK_DRAFT_TEXT_FIELDS = [
+  "name",
+  "detail",
+  "objective",
+  "prerequisites",
+  "constraints",
+  "deliverables",
+  "acceptanceCriteria",
+  "horizon",
+] as const satisfies readonly (keyof StrategyTaskDraft)[];
+
+function normalizeTaskDraftText(value: string): string {
+  return value.trim().replace(/\s+/g, " ");
+}
+
+/**
+ * Treat presentation-only whitespace and angle ordering as equivalent so an
+ * intent-agent round trip cannot invalidate an already generated workflow
+ * unless the task's meaning actually changed.
+ */
+export function areStrategyTaskDraftsEquivalent(
+  left: StrategyTaskDraft,
+  right: StrategyTaskDraft,
+): boolean {
+  const textFieldsMatch = TASK_DRAFT_TEXT_FIELDS.every(
+    (field) =>
+      normalizeTaskDraftText(left[field] as string) ===
+      normalizeTaskDraftText(right[field] as string),
+  );
+  if (!textFieldsMatch) return false;
+
+  const leftAngles = [...new Set(left.selectedAngleIds)].sort();
+  const rightAngles = [...new Set(right.selectedAngleIds)].sort();
+  return (
+    leftAngles.length === rightAngles.length &&
+    leftAngles.every((angleId, index) => angleId === rightAngles[index])
+  );
+}
+
+function stringList(value: unknown): string[] {
+  if (!Array.isArray(value)) return [];
+  return value.map(stringValue).filter(Boolean);
+}
+
+export function extractFencedJson<T>(text: string, marker?: string): T | null {
+  const escaped = marker?.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const patterns = [
+    escaped ? new RegExp("```" + escaped + "\\s*([\\s\\S]*?)```", "i") : null,
+    /```(?:json)?\s*([\s\S]*?)```/i,
+  ].filter(Boolean) as RegExp[];
+
+  for (const pattern of patterns) {
+    const match = pattern.exec(text);
+    if (!match?.[1]) continue;
+    try {
+      return JSON.parse(match[1].trim()) as T;
+    } catch {
+      // The model may have emitted another fenced block first; fall through to
+      // the balanced-object fallback below.
+    }
+  }
+
+  const firstObject = text.indexOf("{");
+  const lastObject = text.lastIndexOf("}");
+  if (firstObject >= 0 && lastObject > firstObject) {
+    try {
+      return JSON.parse(text.slice(firstObject, lastObject + 1)) as T;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+
+export function stripStructuredBlocks(text: string): string {
+  return text
+    .replace(/```(?:strategy-task-json|strategy-evaluation-json)\s*[\s\S]*?```/gi, "")
+    .replace(/\[(?:INTENT_READY|JUDGEMENT_READY)\]/gi, "")
+    .trim();
+}
+
+export function parseTaskDraftFromText(
+  text: string,
+  fallback: StrategyTaskDraft,
+  angles: StrategyAngle[] = STRATEGY_ANGLES,
+): StrategyTaskDraft | null {
+  const parsed = extractFencedJson<Record<string, unknown>>(text, "strategy-task-json");
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+  const rawName = parsed.name ?? parsed.task_name;
+  const rawDetail = parsed.detail ?? parsed.task_detail;
+  const rawAngles = parsed.selectedAngleIds ?? parsed.recommended_angles;
+  if (
+    typeof rawName !== "string" ||
+    !rawName.trim() ||
+    typeof rawDetail !== "string" ||
+    !rawDetail.trim() ||
+    !Array.isArray(rawAngles)
+  ) {
+    return null;
+  }
+  const angleIds = [
+    ...new Set(
+      rawAngles
+        .map(stringValue)
+        .map((value) => {
+          const normalized = value.toLowerCase().replaceAll("-", "_");
+          return angles.find(
+            (angle) =>
+              angle.id === normalized ||
+              angle.agentId === value ||
+              angle.name === value ||
+              angle.shortName === value,
+          )?.id;
+        })
+        .filter((id): id is string => Boolean(id)),
+    ),
+  ];
+  if (!angleIds.length) return null;
+
+  return {
+    name: stringValue(rawName),
+    detail: stringValue(rawDetail),
+    objective: stringValue(parsed.objective) || fallback.objective,
+    prerequisites:
+      stringValue(parsed.prerequisites) || fallback.prerequisites,
+    constraints: stringValue(parsed.constraints) || fallback.constraints,
+    deliverables:
+      stringValue(parsed.deliverables ?? parsed.expected_outputs) || fallback.deliverables,
+    acceptanceCriteria:
+      stringValue(parsed.acceptanceCriteria) || fallback.acceptanceCriteria,
+    horizon: stringValue(parsed.horizon) || fallback.horizon,
+    selectedAngleIds: angleIds,
+  };
+}
+
+export function parseEvaluationsFromText(
+  text: string,
+  outputs: Record<string, AgentOutputState>,
+  allowedAgentIds?: Iterable<string>,
+  angles: StrategyAngle[] = STRATEGY_ANGLES,
+): StrategyEvaluation[] {
+  const parsed = extractFencedJson<
+    { evaluations?: Record<string, unknown>[] } | Record<string, unknown>[]
+  >(text, "strategy-evaluation-json");
+  const rows = Array.isArray(parsed) ? parsed : parsed?.evaluations;
+  if (!Array.isArray(rows)) return [];
+
+  const allowed = allowedAgentIds ? new Set(allowedAgentIds) : null;
+  const knownIds = new Set(
+    angles.filter((angle) => !allowed || allowed.has(angle.agentId)).map(
+      (angle) => angle.agentId,
+    ),
+  );
+  const evaluations: StrategyEvaluation[] = [];
+  const seen = new Set<string>();
+  for (const row of rows) {
+    if (!row || typeof row !== "object" || Array.isArray(row)) return [];
+    const agentId = stringValue(row.agentId ?? row.agent_id);
+    if (!knownIds.has(agentId)) continue;
+
+    const score = row.score;
+    const conclusion = stringValue(row.conclusion);
+    if (
+      seen.has(agentId) ||
+      outputs[agentId]?.status !== "done" ||
+      !outputs[agentId]?.content.trim() ||
+      typeof score !== "number" ||
+      !Number.isFinite(score) ||
+      !Number.isInteger(score) ||
+      score < 0 ||
+      score > 100 ||
+      (conclusion !== "优先推荐" &&
+        conclusion !== "建议采用" &&
+        conclusion !== "保留备选")
+    ) {
+      // Reject the entire structured result instead of inventing defaults or
+      // allowing duplicate rows to be selected twice downstream.
+      return [];
+    }
+    seen.add(agentId);
+    evaluations.push({
+      agentId,
+      score,
+      conclusion,
+      comment: stringValue(row.comment) || "请结合完整评判正文审阅。",
+      strengths: stringList(row.strengths),
+      risks: stringList(row.risks),
+    });
+  }
+
+  if (allowed && [...allowed].some((agentId) => !seen.has(agentId))) return [];
+
+  return evaluations.sort((a, b) => b.score - a.score);
+}
+
+export function buildIntentBrief(
+  turns: IntentTurn[],
+  currentDraft: StrategyTaskDraft,
+  angles: StrategyAngle[] = STRATEGY_ANGLES,
+): string {
+  const conversation = turns
+    .filter(
+      (turn) =>
+        turn.content.trim() ||
+        turn.clarification?.question.trim() ||
+        turn.clarificationAnswer?.trim(),
+    )
+    .map((turn) => {
+      const lines: string[] = [];
+      if (turn.content.trim()) {
+        lines.push(
+          `${turn.role === "user" ? "用户" : "意图助手"}：${turn.content}`,
+        );
+      }
+      if (turn.clarification) {
+        const optionText = turn.clarification.options
+          .map((option) => option.label)
+          .filter(Boolean)
+          .join(" / ");
+        lines.push(
+          `意图助手澄清：${turn.clarification.question}${
+            optionText ? `（可选：${optionText}）` : ""
+          }`,
+        );
+      }
+      if (turn.clarificationAnswer?.trim()) {
+        lines.push(`用户对该澄清的确认：${turn.clarificationAnswer}`);
+      }
+      return lines.join("\n");
+    })
+    .join("\n\n");
+  const availableAngles = angles
+    .filter((angle) => angle.enabled !== false)
+    .map((angle) => `- ${angle.id}：${angle.name}（${angle.description}）`)
+    .join("\n");
+  const exampleAngleIds = angles
+    .filter((angle) => angle.enabled !== false)
+    .slice(0, 3)
+    .map((angle) => angle.id);
+  return `你负责意图理解与任务定义。基于以下对话整理任务。不要虚构实时事实。\n\n当前草稿（可据新信息修订）：\n${JSON.stringify(currentDraft, null, 2)}\n\n本系统当前可选角度（只能从下列 id 中选择）：\n${availableAngles}\n\n对话：\n${conversation}\n\n请严格二选一执行：\n1. 如果不同答案会显著改变任务方向，立即调用 ask_clarification，只提一个最关键问题并提供清晰互斥选项；调用后停止，不输出任务 JSON，也不要在普通正文里假装提问。\n2. 如果信息已足够（包括用户刚回答了澄清），先用简洁自然语言复述整理结果，再在回复末尾追加以下可机器读取代码块，字段名不得改变：\n\`\`\`strategy-task-json\n{"name":"任务名称","detail":"任务详情","objective":"目标","prerequisites":"前置条件","constraints":"约束与边界","deliverables":"交付物","acceptanceCriteria":"验收标准","horizon":"时间范围","selectedAngleIds":${JSON.stringify(exampleAngleIds)}}\n\`\`\`\n只选择与任务有关的角度。`;
+}
+
+export function buildStrategyBrief(
+  task: StrategyTaskDraft,
+  selectedAngles = STRATEGY_ANGLES.filter((angle) =>
+    task.selectedAngleIds.includes(angle.id),
+  ),
+): string {
+  const angles = selectedAngles
+    .map((angle) => `- ${angle.name}：${angle.description}`)
+    .join("\n");
+  return `你是其中一个专业角度的策略生成智能体，只从自己的职责角度输出一套可独立审阅的策略。\n\n任务详情：\n${JSON.stringify(task, null, 2)}\n\n本轮并行角度：\n${angles}\n\n请给出：核心判断、3—6项策略动作、实施阶段、触发/退出条件、指标、主要风险与协同依赖。避免空泛口号；涉及动态事实时说明需复核。工具失败、文件路径、权限问题和检索计划属于执行过程，不得混入策略正文；确有信息缺口时只在独立的“数据限制与待核验”小节简要列明。对于地缘政治议题，坚持中立、降级避险、民生优先，不输出军事战术、目标选择、武器运用或规避监管建议。`;
+}
+
+export function buildJudgeBrief(
+  task: StrategyTaskDraft,
+  outputs: Record<string, AgentOutputState>,
+  angles: StrategyAngle[] = STRATEGY_ANGLES,
+): string {
+  const selectedAgentIds = selectedStrategyAgentIds(task, angles);
+  const strategies = angles.filter(
+    (angle) =>
+      selectedAgentIds.has(angle.agentId) &&
+      outputs[angle.agentId]?.status === "done" &&
+      outputs[angle.agentId]?.content.trim(),
+  )
+    .map(
+      (angle) =>
+        `## ${angle.name}\nagentId: ${angle.agentId}\n${outputs[angle.agentId].content}`,
+    )
+    .join("\n\n");
+  return `你是独立策略评判智能体。请依据任务目标，对候选策略的目标贡献、可执行性、风险可控性、协同性和合规性进行比较。先输出总体评判与冲突提醒，再在末尾输出结构化量表。工具失败、文件路径、权限问题和检索计划属于执行过程，不得写进评判正文；确有信息缺口时只在独立的“数据限制与待核验”小节简要列明。\n\n任务：\n${JSON.stringify(task, null, 2)}\n\n候选策略：\n${strategies}\n\n末尾必须追加：\n\`\`\`strategy-evaluation-json\n{"evaluations":[{"agentId":"候选agentId","score":0,"conclusion":"优先推荐|建议采用|保留备选","comment":"一句评价","strengths":["优势"],"risks":["风险"]}]}\n\`\`\`\n必须覆盖每个候选策略，score为0—100整数。`;
+}
+
+export function buildSynthesisBrief(
+  task: StrategyTaskDraft,
+  selectedAgentIds: string[],
+  outputs: Record<string, AgentOutputState>,
+  evaluations: StrategyEvaluation[],
+  angles: StrategyAngle[] = STRATEGY_ANGLES,
+): string {
+  const evaluationMap = new Map(evaluations.map((item) => [item.agentId, item]));
+  const uniqueSelectedAgentIds = [...new Set(selectedAgentIds)];
+  const selectedAngles = uniqueSelectedAgentIds
+    .map((agentId) => angles.find((item) => item.agentId === agentId))
+    .filter((angle): angle is StrategyAngle => Boolean(angle));
+  const selectedAngleIds = new Set(selectedAngles.map((angle) => angle.agentId));
+  const exactTask = {
+    ...task,
+    selectedAngleIds: selectedAngles.map((angle) => angle.id),
+  };
+  const selections = uniqueSelectedAgentIds
+    .filter((agentId) => selectedAngleIds.has(agentId))
+    .map((agentId) => {
+      const angle = angles.find((item) => item.agentId === agentId);
+      const evaluation = evaluationMap.get(agentId);
+      return `## ${angle?.name ?? agentId}\n评判：${evaluation ? `${evaluation.score}分，${evaluation.comment}` : "用户手动选入"}\n${outputs[agentId]?.content ?? ""}`;
+    })
+    .join("\n\n");
+  const selectedNames = selectedAngles.map((angle) => angle.name).join("、");
+  return `你是方案整理智能体。请将用户选中的策略消除重复、处理冲突、明确优先级和依赖关系，整理为一份可直接下载的完整 Markdown 方案。\n\n任务（selectedAngleIds 已收敛为用户最终选入的策略角度）：\n${JSON.stringify(exactTask, null, 2)}\n\n本次最终只允许整合以下 ${selectedAngles.length} 项：${selectedNames}\n不得补写、复活或暗中纳入任何未列出的角度或策略。\n\n入选策略：\n${selections}\n\n只输出最终 Markdown 正文。工具失败、文件路径、权限问题和检索计划属于执行过程，不得混入方案正文；确有信息缺口时仅归入“待核验信息”小节。至少包含：执行摘要、目标与原则、综合策略、阶段路线图、责任与协同、指标与预警、风险及止损机制、待核验信息。不要输出代码围栏。对于地缘政治议题坚持中立、降级避险、民生优先，禁止军事战术和伤害性操作建议。`;
+}
+
+export function parseSseChunk(
+  buffer: string,
+  flush = false,
+): { events: ParallelAgentEvent[]; rest: string } {
+  const normalized = buffer.replace(/\r\n/g, "\n");
+  const parts = normalized.split("\n\n");
+  const rest = flush ? "" : (parts.pop() ?? "");
+  const complete = flush ? parts.concat(parts.length ? [] : [normalized]) : parts;
+  const events: ParallelAgentEvent[] = [];
+  for (const frame of complete) {
+    const payload = frame
+      .split("\n")
+      .filter((line) => line.startsWith("data:"))
+      .map((line) => line.slice(5).trimStart())
+      .join("\n")
+      .trim();
+    if (!payload || payload === "[DONE]") continue;
+    try {
+      const event = JSON.parse(payload) as ParallelAgentEvent;
+      if (event && typeof event.type === "string") events.push(event);
+    } catch {
+      // Ignore one malformed frame instead of discarding the rest of a stream.
+    }
+  }
+  return { events, rest };
+}
+
+export function downloadMarkdown(markdown: string, fileName: string): void {
+  const cleanName =
+    fileName.replace(/\.(md|markdown)$/i, "").replace(/[<>:"/\\|?*\x00-\x1f]/g, "_").trim() ||
+    "strategy-plan";
+  const blob = new Blob([markdown], { type: "text/markdown;charset=utf-8" });
+  const url = URL.createObjectURL(blob);
+  const anchor = document.createElement("a");
+  anchor.href = url;
+  anchor.download = `${cleanName}.md`;
+  document.body.appendChild(anchor);
+  anchor.click();
+  anchor.remove();
+  window.setTimeout(() => URL.revokeObjectURL(url), 10_000);
+}

frontend-web/src/strategy-selection/project-routes.test.ts

@@ -0,0 +1,29 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  strategyProjectListPath,
+  strategyProjectWorkbenchPath,
+} from "./project-routes";
+
+test("solution list paths work in both application shells", () => {
+  assert.equal(
+    strategyProjectListPath("/page/strategy/qa/projects", "solution"),
+    "/page/strategy/qa/projects?type=solution",
+  );
+  assert.equal(
+    strategyProjectListPath("/official/workspace/projects/", "solution"),
+    "/official/workspace/projects?type=solution",
+  );
+});
+
+test("solution workbench paths encode ids and request the solution module", () => {
+  assert.equal(
+    strategyProjectWorkbenchPath(
+      "/official/workspace/projects",
+      "strategy-selection-a/b",
+      "solution",
+    ),
+    "/official/workspace/projects/strategy-selection-a%2Fb?module=solution",
+  );
+});

frontend-web/src/strategy-selection/project-routes.ts

@@ -0,0 +1,28 @@
+export type StrategyProjectListCategory =
+  | "all"
+  | "qa"
+  | "strategy"
+  | "solution";
+
+function normalizeBasePath(basePath: string): string {
+  return basePath.replace(/\/+$/, "");
+}
+
+export function strategyProjectListPath(
+  basePath: string,
+  category: StrategyProjectListCategory = "all",
+): string {
+  const path = normalizeBasePath(basePath);
+  return category === "all"
+    ? path
+    : `${path}?type=${encodeURIComponent(category)}`;
+}
+
+export function strategyProjectWorkbenchPath(
+  basePath: string,
+  projectId: string,
+  module?: "solution",
+): string {
+  const path = `${normalizeBasePath(basePath)}/${encodeURIComponent(projectId)}`;
+  return module === "solution" ? `${path}?module=solution` : path;
+}

frontend-web/src/strategy-selection/project-wal.test.ts

@@ -0,0 +1,147 @@
+/**
+ * Run from frontend-web:
+ *   npx esbuild src/strategy-selection/project-wal.test.ts --bundle --format=esm --platform=node --outfile=.runtime/unit-tests/project-wal.test.mjs
+ *   node --test .runtime/unit-tests/project-wal.test.mjs
+ */
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import type { StrategyProjectSnapshot } from "./projects";
+import {
+  clearStrategyProjectWal,
+  isStrategyProjectWalExpired,
+  LatestByKeyScheduler,
+  resolveStrategyProjectWal,
+  strategyProjectSnapshotHash,
+  strategyProjectWalKey,
+  writeStrategyProjectWal,
+} from "./project-wal";
+
+const createSnapshot = (): StrategyProjectSnapshot => ({
+  version: 1,
+  angleCatalog: [],
+  stage: "intent",
+  taskDraft: {
+    name: "",
+    detail: "",
+    objective: "",
+    prerequisites: "",
+    constraints: "",
+    deliverables: "",
+    acceptanceCriteria: "",
+    horizon: "",
+    selectedAngleIds: [],
+  },
+  turns: [],
+  outputs: {},
+  judgeStatus: "idle",
+  judgeContent: "",
+  evaluations: [],
+  selectedStrategyIds: [],
+  synthesis: "",
+  synthesisStatus: "idle",
+  solutionSavedAt: null,
+  isDemo: false,
+  workflowStale: false,
+});
+
+test("WAL keys isolate accounts and projects", () => {
+  assert.notEqual(
+    strategyProjectWalKey("account:one", "project-a"),
+    strategyProjectWalKey("account:two", "project-a"),
+  );
+  assert.notEqual(
+    strategyProjectWalKey("account:one", "project-a"),
+    strategyProjectWalKey("account:one", "project-b"),
+  );
+});
+
+test("snapshot hashes are stable and change with project content", async () => {
+  const snapshot = createSnapshot();
+  const same = createSnapshot();
+  const changed = {
+    ...createSnapshot(),
+    taskDraft: {
+      ...createSnapshot().taskDraft,
+      name: "已修改任务",
+    },
+  };
+  assert.equal(
+    await strategyProjectSnapshotHash(snapshot),
+    await strategyProjectSnapshotHash(same),
+  );
+  assert.notEqual(
+    await strategyProjectSnapshotHash(snapshot),
+    await strategyProjectSnapshotHash(changed),
+  );
+});
+
+test("WAL degrades safely when IndexedDB is unavailable", async () => {
+  const snapshot = createSnapshot();
+  assert.equal(
+    await writeStrategyProjectWal(
+      "account:test",
+      "project-test",
+      "base-hash",
+      snapshot,
+    ),
+    null,
+  );
+  assert.equal(
+    await clearStrategyProjectWal("account:test", "project-test", snapshot),
+    false,
+  );
+});
+
+test("WAL recovery uses ancestry hashes instead of incomparable clocks", async () => {
+  const server = createSnapshot();
+  const local = {
+    ...createSnapshot(),
+    taskDraft: { ...createSnapshot().taskDraft, name: "本地编辑" },
+  };
+  const otherServer = {
+    ...createSnapshot(),
+    taskDraft: { ...createSnapshot().taskDraft, name: "服务器编辑" },
+  };
+  const serverHash = await strategyProjectSnapshotHash(server);
+  const localHash = await strategyProjectSnapshotHash(local);
+  const otherServerHash = await strategyProjectSnapshotHash(otherServer);
+  const wal = { baseServerHash: serverHash, snapshotHash: localHash };
+
+  assert.equal(resolveStrategyProjectWal(wal, serverHash), "recover");
+  assert.equal(resolveStrategyProjectWal(wal, localHash), "same");
+  assert.equal(resolveStrategyProjectWal(wal, otherServerHash), "conflict");
+});
+
+test("latest-by-key scheduler bounds queued streaming snapshots", async () => {
+  let releaseFirst!: () => void;
+  const firstBlocked = new Promise<void>((resolve) => {
+    releaseFirst = resolve;
+  });
+  const calls: number[] = [];
+  const scheduler = new LatestByKeyScheduler<number, number>(async (value) => {
+    calls.push(value);
+    if (value === 1) await firstBlocked;
+    return value;
+  });
+
+  const first = scheduler.schedule("project", 1);
+  await Promise.resolve();
+  const superseded = scheduler.schedule("project", 2);
+  const latest = scheduler.schedule("project", 3);
+  assert.equal(await superseded, null);
+  releaseFirst();
+
+  assert.equal(await first, 1);
+  assert.equal(await latest, 3);
+  assert.deepEqual(calls, [1, 3]);
+  await scheduler.waitForIdle("project");
+});
+
+test("WAL expiry is deterministic at the retention boundary", () => {
+  const now = Date.now();
+  const sixDaysAgo = now - 6 * 24 * 60 * 60 * 1000;
+  const eightDaysAgo = now - 8 * 24 * 60 * 60 * 1000;
+  assert.equal(isStrategyProjectWalExpired(sixDaysAgo, now), false);
+  assert.equal(isStrategyProjectWalExpired(eightDaysAgo, now), true);
+});

frontend-web/src/strategy-selection/project-wal.ts

@@ -0,0 +1,362 @@
+import type { StrategyProjectSnapshot } from "./projects";
+
+const DATABASE_NAME = "deerflow-strategy-project-wal";
+const STORE_NAME = "drafts";
+const DATABASE_VERSION = 1;
+const WAL_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+
+export interface StrategyProjectWalRecord {
+  key: string;
+  userKey: string;
+  projectId: string;
+  /** Server snapshot on top of which this local edit was made. */
+  baseServerHash: string;
+  snapshotHash: string;
+  snapshot: StrategyProjectSnapshot;
+  updatedAt: number;
+}
+
+interface PendingJob<Input, Result> {
+  input: Input;
+  resolve: (result: Result | null) => void;
+  reject: (reason: unknown) => void;
+}
+
+interface KeyQueueState<Input, Result> {
+  running: boolean;
+  pending?: PendingJob<Input, Result>;
+  idleWaiters: Array<() => void>;
+}
+
+/** Keep at most one active and one latest pending operation per key. */
+export class LatestByKeyScheduler<Input, Result> {
+  private readonly states = new Map<string, KeyQueueState<Input, Result>>();
+
+  public constructor(
+    private readonly worker: (input: Input) => Promise<Result>,
+  ) {}
+
+  public schedule(key: string, input: Input): Promise<Result | null> {
+    let state = this.states.get(key);
+    if (!state) {
+      state = { running: false, idleWaiters: [] };
+      this.states.set(key, state);
+    }
+    return new Promise<Result | null>((resolve, reject) => {
+      // The superseded value has not started hashing or IndexedDB work. Resolve
+      // it now so its growing snapshot closure can be released immediately.
+      state!.pending?.resolve(null);
+      state!.pending = { input, resolve, reject };
+      void this.pump(key, state!);
+    });
+  }
+
+  public waitForIdle(key: string): Promise<void> {
+    const state = this.states.get(key);
+    if (!state || (!state.running && !state.pending)) return Promise.resolve();
+    return new Promise((resolve) => state.idleWaiters.push(resolve));
+  }
+
+  private async pump(
+    key: string,
+    state: KeyQueueState<Input, Result>,
+  ): Promise<void> {
+    if (state.running) return;
+    const job = state.pending;
+    if (!job) {
+      this.finishKey(key, state);
+      return;
+    }
+    state.pending = undefined;
+    state.running = true;
+    try {
+      job.resolve(await this.worker(job.input));
+    } catch (reason) {
+      job.reject(reason);
+    } finally {
+      state.running = false;
+      if (state.pending) {
+        void this.pump(key, state);
+      } else {
+        this.finishKey(key, state);
+      }
+    }
+  }
+
+  private finishKey(
+    key: string,
+    state: KeyQueueState<Input, Result>,
+  ): void {
+    this.states.delete(key);
+    state.idleWaiters.splice(0).forEach((resolve) => resolve());
+  }
+}
+
+export function strategyProjectWalKey(
+  userKey: string,
+  projectId: string,
+): string {
+  return `${encodeURIComponent(userKey)}::${encodeURIComponent(projectId)}`;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function isUsableSnapshot(value: unknown): value is StrategyProjectSnapshot {
+  if (!isRecord(value) || value.version !== 1) return false;
+  if (value.stage !== "intent" && value.stage !== "workspace") return false;
+  if (!isRecord(value.taskDraft) || !Array.isArray(value.taskDraft.selectedAngleIds)) {
+    return false;
+  }
+  return (
+    Array.isArray(value.angleCatalog) &&
+    Array.isArray(value.turns) &&
+    isRecord(value.outputs) &&
+    Array.isArray(value.evaluations) &&
+    Array.isArray(value.selectedStrategyIds) &&
+    typeof value.synthesis === "string"
+  );
+}
+
+function fallbackHash(text: string): string {
+  let first = 0x811c9dc5;
+  let second = 0x9e3779b9;
+  for (let index = 0; index < text.length; index += 1) {
+    const code = text.charCodeAt(index);
+    first = Math.imul(first ^ code, 0x01000193);
+    second = Math.imul(second ^ code, 0x85ebca6b);
+  }
+  return `${(first >>> 0).toString(16).padStart(8, "0")}${(second >>> 0)
+    .toString(16)
+    .padStart(8, "0")}`;
+}
+
+export async function strategyProjectSnapshotHash(
+  snapshot: StrategyProjectSnapshot,
+): Promise<string> {
+  const serialized = JSON.stringify(snapshot);
+  if (globalThis.crypto?.subtle) {
+    const digest = await globalThis.crypto.subtle.digest(
+      "SHA-256",
+      new TextEncoder().encode(serialized),
+    );
+    return Array.from(new Uint8Array(digest), (byte) =>
+      byte.toString(16).padStart(2, "0"),
+    ).join("");
+  }
+  return fallbackHash(serialized);
+}
+
+export function isStrategyProjectWalExpired(
+  updatedAt: number,
+  now = Date.now(),
+): boolean {
+  return now - updatedAt > WAL_TTL_MS;
+}
+
+export function resolveStrategyProjectWal(
+  wal: Pick<StrategyProjectWalRecord, "baseServerHash" | "snapshotHash">,
+  serverHash: string,
+): "same" | "recover" | "conflict" {
+  if (wal.snapshotHash === serverHash) return "same";
+  if (wal.baseServerHash === serverHash) return "recover";
+  return "conflict";
+}
+
+function openDatabase(): Promise<IDBDatabase | null> {
+  if (typeof indexedDB === "undefined") return Promise.resolve(null);
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(DATABASE_NAME, DATABASE_VERSION);
+    request.onupgradeneeded = () => {
+      const database = request.result;
+      if (!database.objectStoreNames.contains(STORE_NAME)) {
+        database.createObjectStore(STORE_NAME, { keyPath: "key" });
+      }
+    };
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error ?? new Error("无法打开项目恢复存储"));
+    request.onblocked = () => reject(new Error("项目恢复存储正在升级，请关闭其他页面后重试"));
+  });
+}
+
+function waitForTransaction(transaction: IDBTransaction): Promise<void> {
+  return new Promise((resolve, reject) => {
+    transaction.oncomplete = () => resolve();
+    transaction.onerror = () =>
+      reject(transaction.error ?? new Error("项目恢复存储事务失败"));
+    transaction.onabort = () =>
+      reject(transaction.error ?? new Error("项目恢复存储事务已中止"));
+  });
+}
+
+function readRequest(request: IDBRequest): Promise<unknown> {
+  return new Promise((resolve, reject) => {
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error ?? new Error("无法读取项目恢复记录"));
+  });
+}
+
+async function writeWalRecord(
+  record: StrategyProjectWalRecord,
+): Promise<StrategyProjectWalRecord | null> {
+  const database = await openDatabase();
+  if (!database) return null;
+  try {
+    const transaction = database.transaction(STORE_NAME, "readwrite");
+    const transactionDone = waitForTransaction(transaction);
+    const store = transaction.objectStore(STORE_NAME);
+    // Queue the mutation from inside IDB's success callback.  Awaiting the GET
+    // and only then issuing PUT is racy in Safari because the transaction may
+    // become inactive between promise turns.
+    const outcome = new Promise<StrategyProjectWalRecord>((resolve, reject) => {
+      const request = store.get(record.key);
+      request.onerror = () =>
+        reject(request.error ?? new Error("无法读取项目恢复记录"));
+      request.onsuccess = () => {
+        try {
+          const existing = request.result;
+          if (
+            !isRecord(existing) ||
+            typeof existing.updatedAt !== "number" ||
+            existing.updatedAt <= record.updatedAt
+          ) {
+            store.put(record);
+            resolve(record);
+            return;
+          }
+          resolve(existing as unknown as StrategyProjectWalRecord);
+        } catch (reason) {
+          reject(reason);
+        }
+      };
+    });
+    const [result] = await Promise.all([outcome, transactionDone]);
+    return result;
+  } finally {
+    database.close();
+  }
+}
+
+interface WalWriteInput {
+  userKey: string;
+  projectId: string;
+  baseServerHash: string;
+  snapshot: StrategyProjectSnapshot;
+  updatedAt: number;
+}
+
+const writeScheduler = new LatestByKeyScheduler<
+  WalWriteInput,
+  StrategyProjectWalRecord | null
+>(async ({ userKey, projectId, baseServerHash, snapshot, updatedAt }) => {
+  const record: StrategyProjectWalRecord = {
+    key: strategyProjectWalKey(userKey, projectId),
+    userKey,
+    projectId,
+    baseServerHash,
+    snapshotHash: await strategyProjectSnapshotHash(snapshot),
+    snapshot,
+    updatedAt,
+  };
+  return writeWalRecord(record);
+});
+
+export function writeStrategyProjectWal(
+  userKey: string,
+  projectId: string,
+  baseServerHash: string,
+  snapshot: StrategyProjectSnapshot,
+): Promise<StrategyProjectWalRecord | null> {
+  const key = strategyProjectWalKey(userKey, projectId);
+  return writeScheduler.schedule(key, {
+    userKey,
+    projectId,
+    baseServerHash,
+    snapshot,
+    updatedAt: Date.now(),
+  });
+}
+
+export async function readStrategyProjectWal(
+  userKey: string,
+  projectId: string,
+): Promise<StrategyProjectWalRecord | null> {
+  const key = strategyProjectWalKey(userKey, projectId);
+  await writeScheduler.waitForIdle(key);
+  const database = await openDatabase();
+  if (!database) return null;
+  try {
+    const transaction = database.transaction(STORE_NAME, "readonly");
+    const transactionDone = waitForTransaction(transaction);
+    const [record] = await Promise.all([
+      readRequest(transaction.objectStore(STORE_NAME).get(key)),
+      transactionDone,
+    ]);
+    if (!isRecord(record) || !isUsableSnapshot(record.snapshot)) return null;
+    if (
+      record.userKey !== userKey ||
+      record.projectId !== projectId ||
+      typeof record.baseServerHash !== "string" ||
+      typeof record.snapshotHash !== "string" ||
+      typeof record.updatedAt !== "number"
+    ) {
+      return null;
+    }
+    const typed = record as unknown as StrategyProjectWalRecord;
+    if (isStrategyProjectWalExpired(typed.updatedAt)) {
+      void clearStrategyProjectWal(userKey, projectId, typed.snapshot).catch(
+        () => undefined,
+      );
+      return null;
+    }
+    return typed;
+  } finally {
+    database.close();
+  }
+}
+
+export async function clearStrategyProjectWal(
+  userKey: string,
+  projectId: string,
+  expectedSnapshot?: StrategyProjectSnapshot,
+): Promise<boolean> {
+  const key = strategyProjectWalKey(userKey, projectId);
+  const expectedHash = expectedSnapshot
+    ? await strategyProjectSnapshotHash(expectedSnapshot)
+    : null;
+  await writeScheduler.waitForIdle(key);
+  const database = await openDatabase();
+  if (!database) return false;
+  try {
+    const transaction = database.transaction(STORE_NAME, "readwrite");
+    const transactionDone = waitForTransaction(transaction);
+    const store = transaction.objectStore(STORE_NAME);
+    if (!expectedSnapshot) {
+      store.delete(key);
+      await transactionDone;
+      return true;
+    }
+
+    const deletedPromise = new Promise<boolean>((resolve, reject) => {
+      const request = store.get(key);
+      request.onerror = () =>
+        reject(request.error ?? new Error("无法读取项目恢复记录"));
+      request.onsuccess = () => {
+        try {
+          const existing = request.result;
+          const matches =
+            isRecord(existing) && existing.snapshotHash === expectedHash;
+          if (matches) store.delete(key);
+          resolve(matches);
+        } catch (reason) {
+          reject(reason);
+        }
+      };
+    });
+    const [deleted] = await Promise.all([deletedPromise, transactionDone]);
+    return deleted;
+  } finally {
+    database.close();
+  }
+}

frontend-web/src/strategy-selection/projects.ts

@@ -0,0 +1,469 @@
+import { apiFetch } from "@/core/api/fetch-client";
+import { getAccountIdentityKey } from "@/core/auth";
+import { getBackendBaseURL } from "@/core/config";
+import { createClientId } from "@/lib/client-id";
+
+import {
+  EMPTY_TASK_DRAFT,
+  INITIAL_INTENT_TURNS,
+  STRATEGY_ANGLES,
+  TAIWAN_STRAIT_DEMO_EVALUATIONS,
+  TAIWAN_STRAIT_DEMO_OUTPUTS,
+  TAIWAN_STRAIT_DEMO_SYNTHESIS,
+  TAIWAN_STRAIT_DEMO_TASK,
+  TAIWAN_STRAIT_DEMO_TURNS,
+} from "./constants";
+import type {
+  AgentOutputState,
+  IntentTurn,
+  StrategyAngle,
+  StrategyEvaluation,
+  StrategyStage,
+  StrategyTaskDraft,
+} from "./types";
+import { clearStrategyProjectWal } from "./project-wal";
+
+export const STRATEGY_PROJECT_ID_PREFIX = "strategy-selection-";
+const SNAPSHOT_KIND = "strategy-selection-project";
+
+// A strategy project can be mounted twice briefly during route transitions or
+// opened in more than one tab.  Serialize saves in this JS realm and, where
+// supported, across same-browser tabs so an older PUT cannot finish after and
+// overwrite a newer snapshot.
+const projectSaveQueues = new Map<string, Promise<void>>();
+
+async function withBrowserProjectLock<T>(
+  key: string,
+  operation: () => Promise<T>,
+): Promise<T> {
+  if (typeof navigator !== "undefined" && navigator.locks) {
+    return navigator.locks.request(`deerflow-strategy-save:${key}`, operation);
+  }
+  return operation();
+}
+
+function serializeProjectSave<T>(
+  key: string,
+  operation: () => Promise<T>,
+): Promise<T> {
+  const previous = projectSaveQueues.get(key) ?? Promise.resolve();
+  const request = previous
+    .catch(() => undefined)
+    .then(() => withBrowserProjectLock(key, operation));
+  const tail = request.then(
+    () => undefined,
+    () => undefined,
+  );
+  projectSaveQueues.set(key, tail);
+  void tail.then(() => {
+    if (projectSaveQueues.get(key) === tail) projectSaveQueues.delete(key);
+  });
+  return request;
+}
+
+const DEMO_JUDGE_CONTENT = `### 评判结论
+
+六个角度均与任务目标相关，其中治理统筹、安全风险和外交沟通直接作用于“减少误判与阻断升级”，应优先纳入；法律规则是高压情境下的必要边界。经济韧性和社会民生策略建议与主策略合并实施，避免形成两套割裂的连续性机制。
+
+**组合提醒：** 对外沟通节奏、市场稳定措施和风险等级调整必须使用同一事实基线；任何高风险政策动作均需设置冷静期、法律复核与退出条件。`;
+
+export interface StrategyProjectSnapshot {
+  version: 1;
+  /** Copy of the angle catalog used by this project, for historical rendering. */
+  angleCatalog: StrategyAngle[];
+  stage: StrategyStage;
+  taskDraft: StrategyTaskDraft;
+  turns: IntentTurn[];
+  outputs: Record<string, AgentOutputState>;
+  judgeStatus: AgentOutputState["status"];
+  judgeContent: string;
+  evaluations: StrategyEvaluation[];
+  selectedStrategyIds: string[];
+  synthesis: string;
+  synthesisStatus: AgentOutputState["status"];
+  solutionSavedAt: string | null;
+  isDemo: boolean;
+  workflowStale: boolean;
+}
+
+export interface StrategyProjectSummary {
+  id: string;
+  title: string;
+  brief: string;
+  createdAt: string | null;
+  updatedAt: string | null;
+  stage: StrategyStage;
+  questionCount: number;
+  angleCount: number;
+  completedStrategyCount: number;
+  hasEvaluation: boolean;
+  hasSolution: boolean;
+  isDemo: boolean;
+  workflowStale: boolean;
+}
+
+export interface StrategyProject extends StrategyProjectSummary {
+  snapshot: StrategyProjectSnapshot;
+}
+
+export class StrategyProjectConflictError extends Error {
+  public constructor(message: string) {
+    super(message);
+    this.name = "StrategyProjectConflictError";
+  }
+}
+
+interface ParallelTaskResponse {
+  id: string;
+  title?: string;
+  brief?: string | null;
+  agents?: Array<{ agent_id: string; name?: string; avatarType?: string | null }>;
+  messages?: Array<Record<string, unknown>> | null;
+  created_at?: string | null;
+  updated_at?: string | null;
+}
+
+interface ParallelTaskListResponse {
+  tasks?: ParallelTaskResponse[];
+}
+
+interface SnapshotEnvelope extends Record<string, unknown> {
+  kind: typeof SNAPSHOT_KIND;
+  version: 1;
+  snapshot: StrategyProjectSnapshot;
+}
+
+const cloneTask = (task: StrategyTaskDraft): StrategyTaskDraft => ({
+  ...task,
+  selectedAngleIds: [...task.selectedAngleIds],
+});
+
+const cloneAngles = (angles: StrategyAngle[]): StrategyAngle[] =>
+  angles.map((angle) => ({ ...angle }));
+
+const cloneTurns = (turns: IntentTurn[]): IntentTurn[] =>
+  turns.map((turn) => ({ ...turn, streaming: false }));
+
+const cloneOutputs = (
+  outputs: Record<string, AgentOutputState>,
+): Record<string, AgentOutputState> =>
+  Object.fromEntries(
+    Object.entries(outputs).map(([id, output]) => [
+      id,
+      { ...output, steps: [...(output.steps ?? [])] },
+    ]),
+  );
+
+const cloneEvaluations = (evaluations: StrategyEvaluation[]) =>
+  evaluations.map((item) => ({
+    ...item,
+    strengths: [...item.strengths],
+    risks: [...item.risks],
+  }));
+
+export function createEmptyStrategySnapshot(
+  angleCatalog: StrategyAngle[] = STRATEGY_ANGLES,
+): StrategyProjectSnapshot {
+  const enabledAngles = angleCatalog.filter((angle) => angle.enabled !== false);
+  return {
+    version: 1,
+    angleCatalog: cloneAngles(enabledAngles),
+    stage: "intent",
+    taskDraft: {
+      ...cloneTask(EMPTY_TASK_DRAFT),
+      selectedAngleIds: enabledAngles.slice(0, 4).map((angle) => angle.id),
+    },
+    turns: cloneTurns(INITIAL_INTENT_TURNS),
+    outputs: {},
+    judgeStatus: "idle",
+    judgeContent: "",
+    evaluations: [],
+    selectedStrategyIds: [],
+    synthesis: "",
+    synthesisStatus: "idle",
+    solutionSavedAt: null,
+    isDemo: false,
+    workflowStale: false,
+  };
+}
+
+export function canCreateTaiwanDemo(
+  angleCatalog: StrategyAngle[],
+): boolean {
+  const enabledAgentIds = new Set(
+    angleCatalog
+      .filter((angle) => angle.enabled !== false)
+      .map((angle) => angle.agentId),
+  );
+  return STRATEGY_ANGLES.every((angle) => enabledAgentIds.has(angle.agentId));
+}
+
+export function createDemoStrategySnapshot(
+  angleCatalog: StrategyAngle[] = STRATEGY_ANGLES,
+): StrategyProjectSnapshot {
+  if (!canCreateTaiwanDemo(angleCatalog)) {
+    throw new Error("台海示例所需的六个默认角度未全部启用，请先由管理员恢复配置");
+  }
+  const enabledAgentIds = new Set(
+    angleCatalog
+      .filter((angle) => angle.enabled !== false)
+      .map((angle) => angle.agentId),
+  );
+  const defaultDemoAgentIds = new Set(
+    STRATEGY_ANGLES.map((angle) => angle.agentId),
+  );
+  const demoAngles = angleCatalog.filter(
+    (angle) =>
+      angle.enabled !== false &&
+      enabledAgentIds.has(angle.agentId) &&
+      defaultDemoAgentIds.has(angle.agentId),
+  );
+  const effectiveAngles = demoAngles;
+  const demoOutputs = Object.fromEntries(
+    Object.entries(cloneOutputs(TAIWAN_STRAIT_DEMO_OUTPUTS)).filter(([agentId]) =>
+      effectiveAngles.some((angle) => angle.agentId === agentId),
+    ),
+  );
+  const demoEvaluations = TAIWAN_STRAIT_DEMO_EVALUATIONS.filter((evaluation) =>
+    effectiveAngles.some((angle) => angle.agentId === evaluation.agentId),
+  );
+  return {
+    version: 1,
+    angleCatalog: cloneAngles(effectiveAngles),
+    stage: "workspace",
+    taskDraft: {
+      ...cloneTask(TAIWAN_STRAIT_DEMO_TASK),
+      selectedAngleIds: effectiveAngles.map((angle) => angle.id),
+    },
+    turns: cloneTurns(TAIWAN_STRAIT_DEMO_TURNS),
+    outputs: demoOutputs,
+    judgeStatus: "done",
+    judgeContent: DEMO_JUDGE_CONTENT,
+    evaluations: cloneEvaluations(demoEvaluations),
+    selectedStrategyIds: demoEvaluations.filter(
+      (item) => item.score >= 88,
+    ).map((item) => item.agentId),
+    synthesis: TAIWAN_STRAIT_DEMO_SYNTHESIS,
+    synthesisStatus: "done",
+    solutionSavedAt: null,
+    isDemo: true,
+    workflowStale: false,
+  };
+}
+
+function isObject(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function readSnapshot(task: ParallelTaskResponse): StrategyProjectSnapshot | null {
+  const envelope = task.messages?.find(
+    (message) => message.kind === SNAPSHOT_KIND && message.version === 1,
+  );
+  if (!isObject(envelope) || !isObject(envelope.snapshot)) return null;
+  const snapshot = envelope.snapshot as unknown as StrategyProjectSnapshot;
+  if (
+    snapshot.version !== 1 ||
+    (snapshot.stage !== "intent" && snapshot.stage !== "workspace") ||
+    !isObject(snapshot.taskDraft) ||
+    !Array.isArray(snapshot.taskDraft.selectedAngleIds) ||
+    !Array.isArray(snapshot.turns) ||
+    !isObject(snapshot.outputs) ||
+    !Array.isArray(snapshot.evaluations) ||
+    !Array.isArray(snapshot.selectedStrategyIds)
+  ) {
+    return null;
+  }
+  return {
+    ...snapshot,
+    angleCatalog: cloneAngles(
+      Array.isArray(snapshot.angleCatalog) && snapshot.angleCatalog.length
+        ? snapshot.angleCatalog.filter(
+            (angle) =>
+              isObject(angle) &&
+              typeof angle.id === "string" &&
+              typeof angle.agentId === "string" &&
+              typeof angle.name === "string",
+          )
+        : STRATEGY_ANGLES,
+    ),
+    workflowStale: snapshot.workflowStale === true,
+    solutionSavedAt:
+      typeof snapshot.solutionSavedAt === "string"
+        ? snapshot.solutionSavedAt
+        : null,
+    taskDraft: cloneTask(snapshot.taskDraft),
+    turns: cloneTurns(snapshot.turns),
+    outputs: cloneOutputs(snapshot.outputs),
+    evaluations: cloneEvaluations(snapshot.evaluations),
+    selectedStrategyIds: [...snapshot.selectedStrategyIds],
+  };
+}
+
+function toProject(task: ParallelTaskResponse): StrategyProject | null {
+  const snapshot = readSnapshot(task);
+  if (!snapshot) return null;
+  const completedStrategyCount = Object.values(snapshot.outputs).filter(
+    (output) => output.status === "done" && output.content.trim(),
+  ).length;
+  return {
+    id: task.id,
+    title: snapshot.taskDraft.name.trim() || task.title?.trim() || "未命名策略项目",
+    brief: snapshot.taskDraft.detail.trim() || task.brief?.trim() || "尚未补充项目说明",
+    createdAt: task.created_at ?? null,
+    updatedAt: task.updated_at ?? null,
+    stage: snapshot.stage,
+    questionCount: snapshot.turns.filter((turn) => turn.role === "user").length,
+    angleCount: snapshot.taskDraft.selectedAngleIds.length,
+    completedStrategyCount,
+    hasEvaluation:
+      !snapshot.workflowStale &&
+      snapshot.judgeStatus === "done" &&
+      Boolean(snapshot.judgeContent.trim()),
+    hasSolution:
+      !snapshot.workflowStale &&
+      snapshot.synthesisStatus === "done" &&
+      Boolean(snapshot.synthesis.trim()),
+    isDemo: snapshot.isDemo,
+    workflowStale: snapshot.workflowStale,
+    snapshot,
+  };
+}
+
+async function readError(response: Response): Promise<string> {
+  const body = (await response.json().catch(() => null)) as
+    | { detail?: string }
+    | null;
+  return body?.detail || `请求失败（HTTP ${response.status}）`;
+}
+
+const endpoint = (suffix = "") =>
+  `${getBackendBaseURL()}/api/parallel-agent-tasks${suffix}`;
+
+async function getParallelTask(id: string): Promise<ParallelTaskResponse> {
+  const response = await apiFetch(endpoint(`/${encodeURIComponent(id)}`));
+  if (!response.ok) throw new Error(await readError(response));
+  return (await response.json()) as ParallelTaskResponse;
+}
+
+export async function listStrategyProjects(): Promise<StrategyProjectSummary[]> {
+  const response = await apiFetch(endpoint());
+  if (!response.ok) throw new Error(await readError(response));
+  const body = (await response.json()) as ParallelTaskListResponse;
+  const candidates = (body.tasks ?? []).filter((task) =>
+    task.id.startsWith(STRATEGY_PROJECT_ID_PREFIX),
+  );
+  const records = await Promise.allSettled(
+    candidates.map((task) => getParallelTask(task.id)),
+  );
+  return records
+    .flatMap((result) => {
+      if (result.status !== "fulfilled") return [];
+      const project = toProject(result.value);
+      return project ? [project] : [];
+    })
+    .sort((a, b) =>
+      String(b.updatedAt ?? "").localeCompare(String(a.updatedAt ?? "")),
+    );
+}
+
+export async function getStrategyProject(id: string): Promise<StrategyProject> {
+  if (!id.startsWith(STRATEGY_PROJECT_ID_PREFIX)) {
+    throw new Error("这不是一个策略优选项目");
+  }
+  const task = await getParallelTask(id);
+  const project = toProject(task);
+  if (!project) throw new Error("项目数据不完整，无法恢复策略工作台");
+  return project;
+}
+
+function projectAgents(snapshot: StrategyProjectSnapshot) {
+  const selected = new Set(snapshot.taskDraft.selectedAngleIds);
+  const angleAgents = snapshot.angleCatalog.filter((angle) => selected.has(angle.id)).map(
+    (angle) => ({ agent_id: angle.agentId, name: angle.name }),
+  );
+  return [
+    { agent_id: "strategy-selection-intent", name: "意图理解智能体" },
+    ...angleAgents,
+    { agent_id: "strategy-selection-judge", name: "策略评判智能体" },
+    { agent_id: "strategy-selection-solution", name: "方案整理智能体" },
+  ];
+}
+
+function snapshotEnvelope(snapshot: StrategyProjectSnapshot): SnapshotEnvelope {
+  return {
+    kind: SNAPSHOT_KIND,
+    version: 1,
+    snapshot,
+  };
+}
+
+export async function createStrategyProject(
+  snapshot: StrategyProjectSnapshot = createEmptyStrategySnapshot(),
+): Promise<StrategyProject> {
+  const id = `${STRATEGY_PROJECT_ID_PREFIX}${createClientId()}`;
+  const response = await apiFetch(endpoint(), {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      id,
+      title: snapshot.taskDraft.name.trim() || "未命名策略项目",
+      brief: snapshot.taskDraft.detail.trim() || null,
+      agents: projectAgents(snapshot),
+      messages: [snapshotEnvelope(snapshot)],
+    }),
+  });
+  if (!response.ok) throw new Error(await readError(response));
+  const project = toProject((await response.json()) as ParallelTaskResponse);
+  if (!project) throw new Error("项目已创建，但返回数据无法识别");
+  return project;
+}
+
+export async function saveStrategyProject(
+  id: string,
+  snapshot: StrategyProjectSnapshot,
+  options: {
+    expectedUpdatedAt?: string | null;
+    keepalive?: boolean;
+    signal?: AbortSignal;
+  } = {},
+): Promise<StrategyProject> {
+  const account = getAccountIdentityKey() ?? "anonymous";
+  return serializeProjectSave(`${account}:${id}`, async () => {
+    const response = await apiFetch(endpoint(`/${encodeURIComponent(id)}`), {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      keepalive: options.keepalive,
+      signal: options.signal,
+      body: JSON.stringify({
+        title: snapshot.taskDraft.name.trim() || "未命名策略项目",
+        brief: snapshot.taskDraft.detail.trim() || null,
+        agents: projectAgents(snapshot),
+        messages: [snapshotEnvelope(snapshot)],
+        expected_updated_at: options.expectedUpdatedAt ?? undefined,
+      }),
+    });
+    if (!response.ok) {
+      const message = await readError(response);
+      if (response.status === 409) {
+        throw new StrategyProjectConflictError(message);
+      }
+      throw new Error(message);
+    }
+    const project = toProject((await response.json()) as ParallelTaskResponse);
+    if (!project) throw new Error("项目已保存，但返回数据无法识别");
+    return project;
+  });
+}
+
+export async function deleteStrategyProject(id: string): Promise<void> {
+  const response = await apiFetch(endpoint(`/${encodeURIComponent(id)}`), {
+    method: "DELETE",
+  });
+  if (!response.ok && response.status !== 404) {
+    throw new Error(await readError(response));
+  }
+  void clearStrategyProjectWal(
+    getAccountIdentityKey() ?? "anonymous",
+    id,
+  ).catch(() => undefined);
+}

frontend-web/src/strategy-selection/strategy-agent-mapping.ts

@@ -0,0 +1,112 @@
+import type { StrategyAngle } from "./types";
+
+export type StrategyAgentCategory =
+  | "intent"
+  | "angle"
+  | "judge"
+  | "solution";
+
+export interface StrategyAgent {
+  id: string;
+  category: StrategyAgentCategory;
+  fixed: boolean;
+  enabled: boolean;
+  sort_order: number;
+  name: string;
+  description: string;
+  model: string | null;
+  soul: string | null;
+  skills: string[] | null;
+  created_at: string | null;
+  updated_at: string | null;
+}
+
+const STRATEGY_ANGLE_PREFIX = "strategy-selection-angle-";
+
+const LEGACY_ANGLE_IDS: Record<string, string> = {
+  "strategy-selection-angle-governance": "governance",
+  "strategy-selection-angle-diplomacy": "diplomacy",
+  "strategy-selection-angle-economy": "economy",
+  "strategy-selection-angle-security": "security",
+  "strategy-selection-angle-public-opinion": "public_opinion",
+  "strategy-selection-angle-law-policy": "law_policy",
+};
+
+const LEGACY_SHORT_NAMES: Record<string, string> = {
+  "strategy-selection-angle-governance": "治理",
+  "strategy-selection-angle-diplomacy": "外交",
+  "strategy-selection-angle-economy": "经济",
+  "strategy-selection-angle-security": "安全",
+  "strategy-selection-angle-public-opinion": "民生",
+  "strategy-selection-angle-law-policy": "法律",
+};
+
+const LEGACY_ACCENTS: Record<string, string> = {
+  "strategy-selection-angle-governance": "#6d5dfc",
+  "strategy-selection-angle-diplomacy": "#0ea5e9",
+  "strategy-selection-angle-economy": "#10b981",
+  "strategy-selection-angle-security": "#f97316",
+  "strategy-selection-angle-public-opinion": "#ec4899",
+  "strategy-selection-angle-law-policy": "#a855f7",
+};
+
+const ACCENT_PALETTE = [
+  "#2563eb",
+  "#0891b2",
+  "#059669",
+  "#ca8a04",
+  "#ea580c",
+  "#dc2626",
+  "#db2777",
+  "#7c3aed",
+] as const;
+
+function stableAccent(id: string) {
+  if (LEGACY_ACCENTS[id]) return LEGACY_ACCENTS[id];
+  let hash = 2166136261;
+  for (let index = 0; index < id.length; index += 1) {
+    hash ^= id.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return ACCENT_PALETTE[(hash >>> 0) % ACCENT_PALETTE.length];
+}
+
+function displayAngleName(name: string) {
+  const cleaned = name
+    .trim()
+    .replace(/^策略(?:分析)?视角[·•:：\s-]*/, "")
+    .replace(/(?:分析)?智能体$/, "")
+    .trim();
+  return cleaned || name.trim() || "未命名视角";
+}
+
+/** Map the public API shape to the workbench's stable angle representation. */
+export function strategyAgentToAngle(
+  agent: StrategyAgent,
+): StrategyAngle | null {
+  if (agent.category !== "angle") return null;
+  const suffix = agent.id.startsWith(STRATEGY_ANGLE_PREFIX)
+    ? agent.id.slice(STRATEGY_ANGLE_PREFIX.length)
+    : agent.id;
+  const name = displayAngleName(agent.name);
+  return {
+    id: LEGACY_ANGLE_IDS[agent.id] ?? suffix,
+    agentId: agent.id,
+    name,
+    shortName:
+      LEGACY_SHORT_NAMES[agent.id] ??
+      name.split(/[与和及、·/]/u, 1)[0].slice(0, 6),
+    description: agent.description,
+    accent: stableAccent(agent.id),
+    enabled: agent.enabled,
+  };
+}
+
+export function strategyAgentsToAngles(
+  agents: StrategyAgent[],
+): StrategyAngle[] {
+  return agents.flatMap((agent) => {
+    const angle = strategyAgentToAngle(agent);
+    return angle ? [angle] : [];
+  });
+}

frontend-web/src/strategy-selection/strategy-agents.test.ts

@@ -0,0 +1,66 @@
+/**
+ * Run from frontend-web:
+ *   npx esbuild src/strategy-selection/strategy-agents.test.ts --bundle --format=esm --platform=node --outfile=.tmp-tests/strategy-agents.test.mjs
+ *   node --test .tmp-tests/strategy-agents.test.mjs
+ */
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  strategyAgentToAngle,
+  strategyAgentsToAngles,
+  type StrategyAgent,
+} from "./strategy-agent-mapping";
+
+function agent(overrides: Partial<StrategyAgent> = {}): StrategyAgent {
+  return {
+    id: "strategy-selection-angle-public-opinion",
+    category: "angle",
+    fixed: false,
+    enabled: true,
+    sort_order: 100,
+    name: "策略视角·社会民生",
+    description: "关注公共服务连续性",
+    model: null,
+    soul: null,
+    skills: null,
+    created_at: null,
+    updated_at: null,
+    ...overrides,
+  };
+}
+
+test("keeps legacy project ids while accepting the public redacted shape", () => {
+  assert.deepEqual(strategyAgentToAngle(agent()), {
+    id: "public_opinion",
+    agentId: "strategy-selection-angle-public-opinion",
+    name: "社会民生",
+    shortName: "民生",
+    description: "关注公共服务连续性",
+    accent: "#ec4899",
+    enabled: true,
+  });
+});
+
+test("derives stable dynamic ids and accents from the reserved prefix", () => {
+  const dynamic = agent({
+    id: "strategy-selection-angle-abc123",
+    name: "科技与产业链智能体",
+  });
+  const first = strategyAgentToAngle(dynamic);
+  const second = strategyAgentToAngle({ ...dynamic });
+
+  assert.equal(first?.id, "abc123");
+  assert.equal(first?.shortName, "科技");
+  assert.equal(first?.accent, second?.accent);
+});
+
+test("filters fixed workflow roles out of the angle catalog", () => {
+  assert.equal(
+    strategyAgentsToAngles([
+      agent(),
+      agent({ id: "strategy-selection-intent", category: "intent" }),
+    ]).length,
+    1,
+  );
+});

frontend-web/src/strategy-selection/strategy-agents.ts

@@ -0,0 +1,128 @@
+import { useMemo } from "react";
+import { useQuery } from "@tanstack/react-query";
+
+import { apiFetch } from "@/core/api/fetch-client";
+import { getBackendBaseURL } from "@/core/config";
+
+import {
+  strategyAgentsToAngles,
+  type StrategyAgent,
+} from "./strategy-agent-mapping";
+
+export {
+  strategyAgentToAngle,
+  strategyAgentsToAngles,
+} from "./strategy-agent-mapping";
+export type {
+  StrategyAgent,
+  StrategyAgentCategory,
+} from "./strategy-agent-mapping";
+
+export interface CreateStrategyAngleInput {
+  name: string;
+  description?: string;
+  soul?: string;
+  model?: string | null;
+  skills?: string[];
+  sort_order?: number;
+}
+
+export interface UpdateStrategyAgentInput {
+  name?: string;
+  description?: string;
+  soul?: string;
+  model?: string | null;
+  skills?: string[];
+  enabled?: boolean;
+  sort_order?: number;
+}
+
+export const STRATEGY_AGENTS_QUERY_KEY = ["strategy-agents"] as const;
+
+function endpoint(suffix = "") {
+  return `${getBackendBaseURL()}/api/strategy-agents${suffix}`;
+}
+
+async function responseError(response: Response) {
+  const body = (await response.json().catch(() => null)) as
+    | { detail?: string }
+    | null;
+  return body?.detail || `请求失败（HTTP ${response.status}）`;
+}
+
+export async function listStrategyAgents(options?: {
+  includeDisabled?: boolean;
+  includeConfig?: boolean;
+}): Promise<StrategyAgent[]> {
+  const query = new URLSearchParams();
+  if (options?.includeDisabled) query.set("include_disabled", "true");
+  if (options?.includeConfig) query.set("include_config", "true");
+  const response = await apiFetch(
+    `${endpoint()}${query.size ? `?${query.toString()}` : ""}`,
+  );
+  if (!response.ok) throw new Error(await responseError(response));
+  const body = (await response.json()) as { agents?: StrategyAgent[] };
+  return body.agents ?? [];
+}
+
+export async function createStrategyAngle(
+  input: CreateStrategyAngleInput,
+): Promise<StrategyAgent> {
+  const response = await apiFetch(endpoint("/angles"), {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(input),
+  });
+  if (!response.ok) throw new Error(await responseError(response));
+  return (await response.json()) as StrategyAgent;
+}
+
+export async function updateStrategyAgent(
+  id: string,
+  input: UpdateStrategyAgentInput,
+): Promise<StrategyAgent> {
+  const response = await apiFetch(endpoint(`/${encodeURIComponent(id)}`), {
+    method: "PUT",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(input),
+  });
+  if (!response.ok) throw new Error(await responseError(response));
+  return (await response.json()) as StrategyAgent;
+}
+
+export async function disableStrategyAngle(id: string): Promise<StrategyAgent> {
+  const response = await apiFetch(endpoint(`/${encodeURIComponent(id)}`), {
+    method: "DELETE",
+  });
+  if (!response.ok) throw new Error(await responseError(response));
+  return (await response.json()) as StrategyAgent;
+}
+
+export function useStrategyAgents(options?: {
+  enabled?: boolean;
+  includeDisabled?: boolean;
+  includeConfig?: boolean;
+}) {
+  const includeDisabled = options?.includeDisabled ?? false;
+  const includeConfig = options?.includeConfig ?? false;
+  return useQuery({
+    queryKey: [
+      ...STRATEGY_AGENTS_QUERY_KEY,
+      includeDisabled,
+      includeConfig,
+    ],
+    queryFn: () => listStrategyAgents({ includeDisabled, includeConfig }),
+    enabled: options?.enabled ?? true,
+    staleTime: 30_000,
+  });
+}
+
+/** Reusable active-angle query for the workbench and project creation flow. */
+export function useStrategyAngleCatalog(enabled = true) {
+  const query = useStrategyAgents({ enabled });
+  const angles = useMemo(
+    () => strategyAgentsToAngles(query.data ?? []),
+    [query.data],
+  );
+  return { ...query, angles };
+}

frontend-web/src/strategy-selection/types.ts

@@ -0,0 +1,128 @@
+export type StrategyStage = "intent" | "workspace";
+
+export type AgentRunStatus =
+  | "idle"
+  | "queued"
+  | "running"
+  | "done"
+  | "error";
+
+export interface StrategyAngle {
+  id: string;
+  agentId: string;
+  name: string;
+  shortName: string;
+  description: string;
+  accent: string;
+  /** False when an angle survives only in an existing project snapshot. */
+  enabled?: boolean;
+}
+
+export interface StrategyTaskDraft {
+  name: string;
+  detail: string;
+  objective: string;
+  prerequisites: string;
+  constraints: string;
+  deliverables: string;
+  acceptanceCriteria: string;
+  horizon: string;
+  selectedAngleIds: string[];
+}
+
+export interface IntentTurn {
+  id: string;
+  role: "user" | "assistant";
+  content: string;
+  streaming?: boolean;
+  isDemo?: boolean;
+  clarification?: IntentClarification;
+  clarificationAnswered?: boolean;
+  clarificationAnswer?: string;
+  reasoning?: string;
+  error?: string;
+  retryPrompt?: string;
+  retryClarificationTurnId?: string;
+}
+
+export interface IntentClarificationOption {
+  id: string;
+  label: string;
+  description?: string;
+}
+
+export interface IntentClarification {
+  question: string;
+  context?: string;
+  clarificationType?: string;
+  options: IntentClarificationOption[];
+  allowCustom: boolean;
+  allowMultiple: boolean;
+}
+
+export interface AgentOutputState {
+  status: AgentRunStatus;
+  content: string;
+  steps: string[];
+  reasoning?: string;
+  error?: string;
+  /** A failed refresh kept the last successful content for this same task. */
+  preservedFromPrevious?: boolean;
+  isDemo?: boolean;
+}
+
+export interface StrategyEvaluation {
+  agentId: string;
+  score: number;
+  conclusion: "优先推荐" | "建议采用" | "保留备选";
+  comment: string;
+  strengths: string[];
+  risks: string[];
+}
+
+export interface ParallelAgentPayload {
+  task_name: string;
+  brief: string;
+  agent_ids: string[];
+  model?: string;
+}
+
+export type ParallelAgentEvent =
+  | { type: "agent_start"; agent_id: string }
+  | { type: "delta"; agent_id: string; text: string }
+  | {
+      type: "step";
+      agent_id: string;
+      key?: string;
+      label?: string;
+      args?: Record<string, unknown>;
+    }
+  | { type: "agent_done"; agent_id: string; content: string }
+  | { type: "agent_error"; agent_id: string; message: string }
+  | {
+      type: "agent_clarification";
+      agent_id: string;
+      content?: string;
+      question?: string;
+      clarification_type?: string;
+      clarification_context?: string;
+      context?: string;
+      options?: Array<
+        | string
+        | {
+            id?: string;
+            label?: string;
+            description?: string;
+          }
+      >;
+      allow_custom?: boolean;
+      allow_multiple?: boolean;
+    }
+  | {
+      type: "thinking" | "reasoning" | "reasoning_delta";
+      agent_id: string;
+      text?: string;
+      delta?: string;
+      content?: string;
+    }
+  | { type: "all_done" };

frontend-web/src/styles/agents-orbit-dark.css

@@ -1,168 +0,0 @@
-/* ============================================================
-   智能体星轨页 — 深色主题（星海蓝）
-   只放颜色，结构与动画在 agents-orbit.css
-   ============================================================ */
-
-.agents-orbit-page.ao-dark {
-  color: #d9e8ff;
-  background:
-    radial-gradient(1100px 640px at 22% 40%, rgba(56, 130, 246, 0.18), transparent 62%),
-    radial-gradient(880px 560px at 80% 26%, rgba(139, 92, 246, 0.14), transparent 60%),
-    linear-gradient(158deg, #050b1e 0%, #081429 46%, #03060f 100%);
-}
-
-/* 星点 */
-.agents-orbit-page.ao-dark::before {
-  background-image:
-    radial-gradient(1.6px 1.6px at 11% 16%, rgba(255, 255, 255, 0.55), transparent 55%),
-    radial-gradient(1.2px 1.2px at 27% 74%, rgba(255, 255, 255, 0.35), transparent 55%),
-    radial-gradient(1.4px 1.4px at 42% 26%, rgba(255, 255, 255, 0.4), transparent 55%),
-    radial-gradient(1px 1px at 58% 82%, rgba(255, 255, 255, 0.3), transparent 55%),
-    radial-gradient(1.6px 1.6px at 66% 12%, rgba(255, 255, 255, 0.5), transparent 55%),
-    radial-gradient(1.2px 1.2px at 79% 58%, rgba(255, 255, 255, 0.35), transparent 55%),
-    radial-gradient(1px 1px at 88% 34%, rgba(255, 255, 255, 0.3), transparent 55%),
-    radial-gradient(1.4px 1.4px at 18% 88%, rgba(255, 255, 255, 0.35), transparent 55%),
-    radial-gradient(1px 1px at 35% 48%, rgba(255, 255, 255, 0.25), transparent 55%),
-    radial-gradient(1.2px 1.2px at 92% 78%, rgba(255, 255, 255, 0.3), transparent 55%);
-}
-
-/* 顶部标题 */
-.agents-orbit-page.ao-dark .ao-header-title {
-  color: #cfe4ff;
-  text-shadow: 0 0 14px rgba(90, 160, 255, 0.5);
-}
-
-.agents-orbit-page.ao-dark .ao-header-link {
-  border-color: rgba(110, 170, 255, 0.35);
-  background: rgba(12, 28, 58, 0.7);
-  color: #9fc4f5;
-}
-
-.agents-orbit-page.ao-dark .ao-header-link:hover {
-  color: #ffffff;
-  border-color: rgba(140, 205, 255, 0.8);
-  box-shadow: 0 0 14px rgba(90, 170, 255, 0.4);
-}
-
-/* 中心圆盘 */
-.agents-orbit-page.ao-dark .ao-core {
-  background: radial-gradient(
-    circle at 34% 30%,
-    rgba(96, 165, 250, 0.95),
-    rgba(37, 99, 235, 0.55) 45%,
-    rgba(8, 20, 45, 0.92) 100%
-  );
-  border-color: rgba(125, 190, 255, 0.7);
-  box-shadow:
-    0 0 46px rgba(64, 140, 255, 0.5),
-    inset 0 0 34px rgba(120, 190, 255, 0.35);
-}
-
-.agents-orbit-page.ao-dark .ao-core-img {
-  color: #eaf4ff;
-  filter: drop-shadow(0 0 14px rgba(120, 190, 255, 0.85));
-}
-
-/* 圆环族 */
-.agents-orbit-page.ao-dark .ao-ring--dash {
-  border-color: rgba(110, 170, 255, 0.55);
-}
-
-.agents-orbit-page.ao-dark .ao-ring--arc {
-  border-top-color: rgba(88, 200, 255, 0.9);
-  border-right-color: rgba(88, 200, 255, 0.32);
-  filter: drop-shadow(0 0 6px rgba(88, 200, 255, 0.55));
-}
-
-.agents-orbit-page.ao-dark .ao-ring--ticks {
-  border-color: rgba(110, 170, 255, 0.28);
-  background-image: repeating-conic-gradient(
-    from 0deg,
-    rgba(120, 180, 255, 0.5) 0deg 0.8deg,
-    transparent 0.8deg 6deg
-  );
-}
-
-/* 卫星 */
-.agents-orbit-page.ao-dark .ao-sat {
-  background: radial-gradient(circle at 35% 30%, #ffffff, #7fd0ff 55%, #1f7dff);
-  box-shadow:
-    0 0 12px 3px rgba(110, 200, 255, 0.85),
-    -14px 0 22px rgba(110, 200, 255, 0.35);
-}
-
-/* 类型标签药丸 */
-.agents-orbit-page.ao-dark .ao-type-chip {
-  color: #b9d7ff;
-  background: rgba(12, 28, 58, 0.82);
-  border-color: rgba(110, 170, 255, 0.35);
-  box-shadow: 0 4px 16px rgba(4, 12, 32, 0.55);
-}
-
-.agents-orbit-page.ao-dark .ao-type-anchor:hover .ao-type-chip {
-  color: #ffffff;
-  border-color: rgba(140, 205, 255, 0.8);
-  box-shadow: 0 0 18px rgba(90, 170, 255, 0.45);
-}
-
-.agents-orbit-page.ao-dark .ao-type-anchor.is-active .ao-type-chip {
-  color: #06122b;
-  background: linear-gradient(135deg, #66c4ff, #2f7dff);
-  border-color: rgba(160, 220, 255, 0.9);
-  box-shadow: 0 0 26px rgba(80, 170, 255, 0.65);
-}
-
-/* 右侧面板 */
-.agents-orbit-page.ao-dark .ao-panel {
-  background: rgba(10, 22, 48, 0.72);
-  border-color: rgba(110, 170, 255, 0.22);
-  box-shadow: 0 10px 40px rgba(2, 8, 24, 0.5);
-}
-
-.agents-orbit-page.ao-dark .ao-panel-head {
-  border-bottom-color: rgba(110, 170, 255, 0.16);
-}
-
-.agents-orbit-page.ao-dark .ao-panel-title {
-  color: #e8f2ff;
-}
-
-.agents-orbit-page.ao-dark .ao-panel-sub {
-  color: #8fb7e8;
-}
-
-.agents-orbit-page.ao-dark .ao-agents::-webkit-scrollbar-thumb {
-  background: rgba(110, 170, 255, 0.3);
-}
-
-.agents-orbit-page.ao-dark .ao-agent {
-  border-color: rgba(110, 170, 255, 0.18);
-  background: rgba(20, 42, 86, 0.5);
-}
-
-.agents-orbit-page.ao-dark .ao-agent:hover {
-  border-color: rgba(130, 200, 255, 0.6);
-  background: rgba(30, 58, 112, 0.65);
-  box-shadow: 0 8px 24px rgba(20, 80, 200, 0.35);
-}
-
-.agents-orbit-page.ao-dark .ao-agent-icon {
-  background: linear-gradient(135deg, #2f7dff, #7a5cff);
-  box-shadow:
-    inset 0 0 0 1px rgba(255, 255, 255, 0.25),
-    0 4px 14px rgba(47, 125, 255, 0.4);
-}
-
-.agents-orbit-page.ao-dark .ao-agent-name {
-  color: #d7e8ff;
-}
-
-/* 加载 / 空态 */
-.agents-orbit-page.ao-dark .ao-state {
-  color: #8fb7e8;
-}
-
-.agents-orbit-page.ao-dark .ao-spinner {
-  border-color: rgba(110, 170, 255, 0.25);
-  border-top-color: #6fc2ff;
-}

frontend-web/src/styles/agents-orbit-light.css

@@ -1,158 +0,0 @@
-/* ============================================================
-   智能体星轨页 — 浅色主题（云际蓝）
-   只放颜色，结构与动画在 agents-orbit.css
-   ============================================================ */
-
-.agents-orbit-page.ao-light {
-  color: #1f3a63;
-  background:
-    radial-gradient(1100px 640px at 22% 40%, rgba(47, 125, 255, 0.1), transparent 62%),
-    radial-gradient(880px 560px at 80% 26%, rgba(122, 92, 246, 0.08), transparent 60%),
-    linear-gradient(158deg, #f4f8ff 0%, #e7f0ff 46%, #eef4fd 100%);
-}
-
-/* 浅色下不渲染星点 */
-.agents-orbit-page.ao-light::before {
-  display: none;
-}
-
-/* 顶部标题 */
-.agents-orbit-page.ao-light .ao-header-title {
-  color: #164a96;
-  text-shadow: 0 0 14px rgba(120, 170, 255, 0.35);
-}
-
-.agents-orbit-page.ao-light .ao-header-link {
-  border-color: rgba(47, 125, 255, 0.4);
-  background: rgba(255, 255, 255, 0.85);
-  color: #2a66c2;
-}
-
-.agents-orbit-page.ao-light .ao-header-link:hover {
-  color: #0f3f96;
-  border-color: rgba(47, 125, 255, 0.85);
-  box-shadow: 0 4px 14px rgba(47, 125, 255, 0.22);
-}
-
-/* 中心圆盘 */
-.agents-orbit-page.ao-light .ao-core {
-  background: radial-gradient(
-    circle at 34% 30%,
-    #ffffff,
-    #dbe9ff 45%,
-    #b9d4ff 100%
-  );
-  border-color: rgba(90, 150, 240, 0.85);
-  box-shadow:
-    0 10px 34px rgba(47, 125, 255, 0.28),
-    inset 0 0 30px rgba(160, 200, 255, 0.55);
-}
-
-.agents-orbit-page.ao-light .ao-core-img {
-  color: #1f5fd6;
-  filter: drop-shadow(0 4px 10px rgba(47, 125, 255, 0.35));
-}
-
-/* 圆环族 */
-.agents-orbit-page.ao-light .ao-ring--dash {
-  border-color: rgba(47, 125, 255, 0.45);
-}
-
-.agents-orbit-page.ao-light .ao-ring--arc {
-  border-top-color: rgba(37, 110, 245, 0.85);
-  border-right-color: rgba(37, 110, 245, 0.28);
-  filter: drop-shadow(0 2px 5px rgba(47, 125, 255, 0.3));
-}
-
-.agents-orbit-page.ao-light .ao-ring--ticks {
-  border-color: rgba(47, 125, 255, 0.3);
-  background-image: repeating-conic-gradient(
-    from 0deg,
-    rgba(47, 105, 220, 0.45) 0deg 0.8deg,
-    transparent 0.8deg 6deg
-  );
-}
-
-/* 卫星 */
-.agents-orbit-page.ao-light .ao-sat {
-  background: radial-gradient(circle at 35% 30%, #ffffff, #7fb4ff 55%, #2f7dff);
-  box-shadow:
-    0 0 10px 2px rgba(47, 125, 255, 0.55),
-    -14px 0 20px rgba(47, 125, 255, 0.25);
-}
-
-/* 类型标签药丸 */
-.agents-orbit-page.ao-light .ao-type-chip {
-  color: #1e4fa8;
-  background: rgba(255, 255, 255, 0.92);
-  border-color: rgba(47, 125, 255, 0.4);
-  box-shadow: 0 4px 14px rgba(30, 80, 180, 0.14);
-}
-
-.agents-orbit-page.ao-light .ao-type-anchor:hover .ao-type-chip {
-  color: #0f3f96;
-  border-color: rgba(47, 125, 255, 0.85);
-  box-shadow: 0 6px 18px rgba(47, 125, 255, 0.28);
-}
-
-.agents-orbit-page.ao-light .ao-type-anchor.is-active .ao-type-chip {
-  color: #ffffff;
-  background: linear-gradient(135deg, #4d9aff, #2f7dff);
-  border-color: rgba(47, 125, 255, 0.95);
-  box-shadow: 0 8px 24px rgba(47, 125, 255, 0.45);
-}
-
-/* 右侧面板 */
-.agents-orbit-page.ao-light .ao-panel {
-  background: rgba(255, 255, 255, 0.82);
-  border-color: rgba(47, 125, 255, 0.25);
-  box-shadow: 0 10px 32px rgba(30, 70, 160, 0.12);
-}
-
-.agents-orbit-page.ao-light .ao-panel-head {
-  border-bottom-color: rgba(47, 125, 255, 0.18);
-}
-
-.agents-orbit-page.ao-light .ao-panel-title {
-  color: #0f3a78;
-}
-
-.agents-orbit-page.ao-light .ao-panel-sub {
-  color: #5b7ea8;
-}
-
-.agents-orbit-page.ao-light .ao-agents::-webkit-scrollbar-thumb {
-  background: rgba(47, 125, 255, 0.3);
-}
-
-.agents-orbit-page.ao-light .ao-agent {
-  border-color: rgba(47, 125, 255, 0.22);
-  background: rgba(255, 255, 255, 0.85);
-}
-
-.agents-orbit-page.ao-light .ao-agent:hover {
-  border-color: rgba(47, 125, 255, 0.6);
-  background: #f0f7ff;
-  box-shadow: 0 8px 22px rgba(47, 125, 255, 0.22);
-}
-
-.agents-orbit-page.ao-light .ao-agent-icon {
-  background: linear-gradient(135deg, #2f7dff, #7a5cff);
-  box-shadow:
-    inset 0 0 0 1px rgba(255, 255, 255, 0.35),
-    0 4px 12px rgba(47, 125, 255, 0.35);
-}
-
-.agents-orbit-page.ao-light .ao-agent-name {
-  color: #1f3a63;
-}
-
-/* 加载 / 空态 */
-.agents-orbit-page.ao-light .ao-state {
-  color: #5b7ea8;
-}
-
-.agents-orbit-page.ao-light .ao-spinner {
-  border-color: rgba(47, 125, 255, 0.25);
-  border-top-color: #2f7dff;
-}

frontend-web/src/styles/agents-orbit.css

@@ -1,432 +0,0 @@
-/* ============================================================
-   智能体星轨页 — 基础结构 + 动画（不含任何颜色）
-   颜色主题在 agents-orbit-dark.css / agents-orbit-light.css 两个文件里
-   命名统一 ao- 前缀
-   ============================================================ */
-
-/* ---------- 页面骨架：左舞台 / 右面板 1:1 ---------- */
-
-.agents-orbit-page {
-  position: relative;
-  display: flex;
-  height: 100%;
-  width: 100%;
-  overflow: hidden;
-}
-
-/* 星点背景层（内容在主题文件里着色；浅色主题直接隐藏） */
-.agents-orbit-page::before {
-  content: "";
-  position: absolute;
-  inset: 0;
-  pointer-events: none;
-  animation: ao-star-blink 7s ease-in-out infinite;
-}
-
-@keyframes ao-star-blink {
-  0%,
-  100% {
-    opacity: 0.65;
-  }
-  50% {
-    opacity: 1;
-  }
-}
-
-/* 顶部小标题 + 返回经典视图入口 */
-.ao-header {
-  position: absolute;
-  top: 18px;
-  left: 22px;
-  z-index: 6;
-  display: flex;
-  align-items: center;
-  gap: 14px;
-}
-
-.ao-header-title {
-  font-size: 15px;
-  font-weight: 600;
-  letter-spacing: 2px;
-}
-
-.ao-header-link {
-  border: 1px solid;
-  background: none;
-  font-size: 12px;
-  padding: 4px 12px;
-  border-radius: 999px;
-  cursor: pointer;
-  transition: color 0.25s, border-color 0.25s, box-shadow 0.25s;
-}
-
-/* ---------- 左侧星轨舞台 ---------- */
-
-.ao-stage {
-  position: relative;
-  flex: 1 1 0;
-  min-width: 0;
-  display: flex;
-  align-items: center;
-  justify-content: center;
-}
-
-.ao-root {
-  position: relative;
-  width: min(56vh, 520px);
-  max-width: calc(100% - 48px);
-  aspect-ratio: 1 / 1;
-}
-
-/* 中心圆盘（核心） */
-.ao-core {
-  position: absolute;
-  left: 50%;
-  top: 50%;
-  width: 32%;
-  aspect-ratio: 1 / 1;
-  transform: translate(-50%, -50%);
-  border-radius: 50%;
-  border: 2px solid;
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  z-index: 3;
-}
-
-/* 中心图片：上下摇晃（频率适中，约 3.2s 一个来回） */
-.ao-core-img {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  animation: ao-float 3.2s ease-in-out infinite;
-}
-
-@keyframes ao-float {
-  0%,
-  100% {
-    transform: translateY(-7px);
-  }
-  50% {
-    transform: translateY(9px);
-  }
-}
-
-/* ---------- 圆环族 ----------
-   由内到外：虚线环(54%) 顺时针 / 弧光环(70%) 逆时针 / 刻度环(97%) 缓慢顺时针 */
-
-.ao-ring {
-  position: absolute;
-  left: 50%;
-  top: 50%;
-  transform: translate(-50%, -50%);
-  border-radius: 50%;
-  pointer-events: none;
-}
-
-.ao-ring--dash {
-  width: 54%;
-  aspect-ratio: 1 / 1;
-  border: 2px dashed;
-  animation: ao-spin-cw 18s linear infinite;
-}
-
-.ao-ring--arc {
-  width: 70%;
-  aspect-ratio: 1 / 1;
-  border: 3px solid transparent;
-  animation: ao-spin-ccw 12s linear infinite;
-}
-
-/* 最外层刻度圆圈：细边框 + 环形遮罩刻度（密码转盘的刻度感），
-   缓慢自转，转盘属性刻度环 */
-.ao-ring--ticks {
-  width: 97%;
-  aspect-ratio: 1 / 1;
-  border: 1px solid;
-  -webkit-mask: radial-gradient(
-    farthest-side,
-    transparent calc(100% - 5px),
-    #000 calc(100% - 4px)
-  );
-  mask: radial-gradient(
-    farthest-side,
-    transparent calc(100% - 5px),
-    #000 calc(100% - 4px)
-  );
-  animation: ao-spin-cw 90s linear infinite;
-}
-
-@keyframes ao-spin-cw {
-  to {
-    transform: translate(-50%, -50%) rotate(360deg);
-  }
-}
-
-@keyframes ao-spin-ccw {
-  to {
-    transform: translate(-50%, -50%) rotate(-360deg);
-  }
-}
-
-/* 卫星：一个自转的轨道容器，卫星固定在轨道顶端；
-   轨道直径与最外层刻度圆圈(97%)一致，卫星贴着最外圈环绕 */
-.ao-sat-orbit {
-  position: absolute;
-  left: 50%;
-  top: 50%;
-  width: 97%;
-  aspect-ratio: 1 / 1;
-  transform: translate(-50%, -50%);
-  pointer-events: none;
-  z-index: 2;
-  animation: ao-orbit-cw 9s linear infinite;
-}
-
-.ao-sat {
-  position: absolute;
-  top: -7px;
-  left: 50%;
-  width: 14px;
-  height: 14px;
-  margin-left: -7px;
-  border-radius: 50%;
-}
-
-@keyframes ao-orbit-cw {
-  to {
-    transform: translate(-50%, -50%) rotate(360deg);
-  }
-}
-
-/* ---------- 类型标签（密码转盘） ---------- */
-
-/* 转盘裁剪容器：垂直中线以左（左半圆）是不可视区域，
-   绕背补位的标签滑出边界即被裁掉、从另一端滑入才重新出现。
-   上/右/下方向用负 inset 放宽裁剪框，不切到溢出 root 的标签。 */
-.ao-types {
-  position: absolute;
-  inset: 0;
-  z-index: 4;
-  clip-path: inset(-80px -80px -80px 50%);
-}
-
-/* 旋转臂：铺满整个 root、以圆心为轴旋转；标签挂在 93%/50% 处（刻度环内侧）。
-   换角度时 CSS 过渡让标签沿圆弧运动，文字由锚点反向旋转保持水平。
-   超界补位的标签角度会 ±360 走“背面长路”，全程经过被裁剪的左半圆。 */
-.ao-type-arm {
-  position: absolute;
-  inset: 0;
-  pointer-events: none;
-  transform-origin: 50% 50%;
-  transition: transform 0.85s cubic-bezier(0.68, -0.12, 0.28, 1.08);
-}
-
-.ao-type-anchor {
-  position: absolute;
-  left: 93%;
-  top: 50%;
-  pointer-events: auto;
-  background: none;
-  border: none;
-  padding: 0;
-  cursor: pointer;
-  transform: translate(-50%, -50%) rotate(0deg);
-  transition: transform 0.85s cubic-bezier(0.68, -0.12, 0.28, 1.08);
-}
-
-/* 标签药丸：内层元素承担上下摇晃动画，不与定位 transform 冲突 */
-.ao-type-chip {
-  display: inline-flex;
-  align-items: center;
-  gap: 6px;
-  padding: 7px 16px;
-  border-radius: 999px;
-  border: 1px solid;
-  font-size: 14px;
-  font-weight: 600;
-  letter-spacing: 0.5px;
-  white-space: nowrap;
-  animation: ao-bob 3.6s ease-in-out infinite;
-  transition: color 0.3s, border-color 0.3s, box-shadow 0.3s, background 0.3s;
-}
-
-.ao-type-chip::before {
-  content: "";
-  width: 6px;
-  height: 6px;
-  border-radius: 50%;
-  background: currentColor;
-  box-shadow: 0 0 8px currentColor;
-}
-
-/* 激活位（正右侧中间）微微放大强调 */
-.ao-type-anchor.is-active .ao-type-chip {
-  padding: 8px 18px;
-}
-
-/* 类型较多时收缩标签尺寸，保持间距可辨 */
-.agents-orbit-page.ao-crowded .ao-type-chip {
-  font-size: 12px;
-  padding: 4px 10px;
-  gap: 4px;
-}
-
-.agents-orbit-page.ao-crowded .ao-type-anchor.is-active .ao-type-chip {
-  padding: 5px 12px;
-}
-
-@keyframes ao-bob {
-  0%,
-  100% {
-    transform: translateY(-3px);
-  }
-  50% {
-    transform: translateY(4px);
-  }
-}
-
-/* ---------- 右侧智能体面板（与舞台 1:1） ---------- */
-
-.ao-panel {
-  position: relative;
-  z-index: 5;
-  flex: 1 1 0;
-  min-width: 0;
-  margin: 16px;
-  border-radius: 18px;
-  border: 1px solid;
-  backdrop-filter: blur(10px);
-  display: flex;
-  flex-direction: column;
-  overflow: hidden;
-}
-
-.ao-panel-head {
-  padding: 18px 20px 12px;
-  border-bottom: 1px solid;
-}
-
-.ao-panel-title {
-  font-size: 18px;
-  font-weight: 700;
-  letter-spacing: 1px;
-}
-
-.ao-panel-sub {
-  margin-top: 4px;
-  font-size: 12px;
-}
-
-.ao-agents {
-  flex: 1;
-  overflow-y: auto;
-  padding: 16px 20px 20px;
-  display: grid;
-  grid-template-columns: repeat(auto-fill, minmax(108px, 1fr));
-  gap: 14px;
-  align-content: start;
-  animation: ao-fade-in 0.5s ease both;
-}
-
-.ao-agents::-webkit-scrollbar {
-  width: 6px;
-}
-
-.ao-agents::-webkit-scrollbar-thumb {
-  border-radius: 3px;
-}
-
-@keyframes ao-fade-in {
-  from {
-    opacity: 0;
-    transform: translateY(14px);
-  }
-  to {
-    opacity: 1;
-    transform: none;
-  }
-}
-
-.ao-agent {
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  gap: 10px;
-  padding: 14px 8px;
-  border-radius: 14px;
-  border: 1px solid;
-  cursor: pointer;
-  transition: transform 0.25s, box-shadow 0.25s, border-color 0.25s, background 0.25s;
-}
-
-.ao-agent:hover {
-  transform: translateY(-4px);
-}
-
-/* 圆角正方形图标（取智能体名称首字） */
-.ao-agent-icon {
-  width: 54px;
-  height: 54px;
-  border-radius: 14px;
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  color: #ffffff;
-  font-size: 20px;
-  font-weight: 700;
-}
-
-.ao-agent-name {
-  max-width: 100%;
-  font-size: 13px;
-  text-align: center;
-  overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
-}
-
-/* ---------- 加载 / 空态 ---------- */
-
-.ao-state {
-  flex: 1;
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  justify-content: center;
-  gap: 10px;
-  font-size: 13px;
-}
-
-.ao-spinner {
-  width: 26px;
-  height: 26px;
-  border-radius: 50%;
-  border: 3px solid;
-  animation: ao-spin-cw-center 0.9s linear infinite;
-}
-
-@keyframes ao-spin-cw-center {
-  to {
-    transform: rotate(360deg);
-  }
-}
-
-/* 动效敏感用户降级 */
-@media (prefers-reduced-motion: reduce) {
-  .agents-orbit-page::before,
-  .ao-core-img,
-  .ao-ring--dash,
-  .ao-ring--arc,
-  .ao-ring--ticks,
-  .ao-sat-orbit,
-  .ao-type-chip,
-  .ao-agents {
-    animation: none;
-  }
-
-  .ao-type-arm,
-  .ao-type-anchor {
-    transition-duration: 0.01s;
-  }
-}

offline-backend-20260512/backend/CLAUDE.md

@@ -299,6 +299,8 @@ from deerflow.config import get_app_config
 
 **Forced-research built-in agent.** `forced-research-responder` (「强制检索输出助手」) is seeded from `app/gateway/routers/_forced_research_seed_assets/` before `_sync_legacy_agents`. `ForcedResearchMiddleware` is mounted only for this stable id. On every visible user turn it requires a successful information-gathering tool result before the model may finish; `tool_choice=required` is backed by an `after_model -> model` retry for gateways that ignore tool choice, with an eight-attempt failure cap that permits only an honest failure response. Skill discovery, reading `SKILL.md`, and writing a helper script do not satisfy the gate; web/knowledge/MCP results, non-skill uploaded-file reads, or successful Python skill-script execution do. Tool filtering removes `present_files`, `skill_manage`, task/schedule/memory/clarification surfaces. The middleware permits `write_file`/`str_replace` only for `/mnt/user-data/workspace/*.py` and permits `bash` only for `.py` execution without redirection/document paths, so skills can run scripts but the agent cannot create Markdown/document artifacts or write `outputs`. Tests: `tests/test_forced_research_agent.py`.
 
+**Strategy-selection functional agents.** `app/gateway/routers/_strategy_selection_seed.py` seeds nine stable folder-backed agents from `_strategy_selection_seed_assets/` before `_sync_legacy_agents`: intent, governance/diplomacy/economy/security/public-opinion/law-policy angles, judge, and solution editor. Seeding is missing-directory-only and must never overwrite administrator changes. The global `strategy_agent_roles` registry classifies them independently of projects: intent/judge/solution are fixed, unique roles that may be configured but never added, disabled, reordered, or deleted; angle roles are a shared, ordered catalog that administrators may add, edit, disable (soft delete), restore, and reorder through `/api/strategy-agents`. Public `GET /api/strategy-agents` returns enabled identity/description metadata only; `include_disabled=true` or `include_config=true` is admin-only. Admin writes are `POST /api/strategy-agents/angles`, `PUT /api/strategy-agents/{id}`, and `DELETE /api/strategy-agents/{id}`; DELETE retains the folder-backed agent and role row to preserve historical references. Dynamic angles remain built-in folder-backed agents under the reserved `strategy-selection-angle-` id namespace, with `web` + `file:read`; a blank SOUL on create receives a safe role template. All strategy skill writes validate that names exist, are active, and are globally visible; generic agent CRUD cannot create or hard-delete reserved strategy IDs, and parallel execution rejects disabled roles. Angle configs reuse `policy-knowledge`; intent reuses `intent-clarification-policy`; the judge has no retrieval skill; the solution editor gets only `file:write`. Keep the SOUL contracts neutral and evidence-aware, with explicit de-escalation/civilian-protection framing and hard bans on operational combat guidance and targeted political manipulation. Tests: `tests/test_strategy_selection_seed.py`, `tests/test_strategy_agent_management.py`.
+
 **ThreadState** (`packages/harness/deerflow/agents/thread_state.py`):
 - Extends `AgentState` with: `sandbox`, `thread_data`, `title`, `artifacts`, `todos`, `uploaded_files`, `viewed_images`
 - Uses custom reducers: `merge_artifacts` (deduplicate), `merge_viewed_images` (merge/clear)
@@ -540,6 +542,8 @@ Self-contained product knowledge base. **All knowledge capability lives in this
 
 Custom agent metadata lives in the `agents` ORM table (`deerflow.persistence.agents`). `agents.id` is the stable runtime id and the filesystem directory name under `.deer-flow/agents/{id}/`; `agents.name` is display-only, can contain Chinese characters, and is not unique. `user_id IS NULL` marks built-in agents, user-owned agents are visible only to their owner unless `published = true`, and update/delete operations require ownership. The runtime accepts `agent_id` in context/configurable, and non-default `assistant_id` values are treated as agent ids after visibility checks.
 
+Strategy-selection fan-out (`routers/parallel_agents.py`) must keep hidden reasoning separate per agent: provider reasoning blocks/fields and inline `<think>...</think>` text emit `reasoning_delta`, while visible answer text emits `delta` and only visible text may enter `agent_done.content`. Never concatenate `reasoning_delta` into a selectable strategy or generated deliverable. Inspect the final AI message with the shared `is_llm_error_message` detector and require substantive visible text before constructing a success result. A middleware fallback, empty/thinking-only response, or punctuation-only provider degeneration is a failed seat run: raise so the stream emits `agent_error`; never wrap it in `agent_done`. Regression coverage: `tests/test_roundtable_model_fallback.py`.
+
 **Listing cache + pagination** ? to keep `GET /api/agents` fast, the gallery's per-card extras (skills + tool_groups) are denormalized into two cache tables instead of reading every agent's `config.yaml` on each request: `agent_skills` (relational, one row per (agent, skill) with `position`) and `agent_extras` (one row per agent: `tool_groups` JSON + `model` + `skills_synced_at`). `config.yaml` remains authoritative for the agent runtime; these tables are a read cache, write-through on create/update and backfilled from disk by `_sync_legacy_agents` (mtime-vs-`skills_synced_at` drift check). The list endpoint enriches via `AgentStore.get_extras_for([ids])` (two batched `IN` queries). Both tables are auto-created by `Base.metadata.create_all` (no migration needed). `GET /api/agents` supports **opt-in server-side pagination**: `scope` (`mine` = owned + favorited / `square` = built-in/published public), `page`, `page_size`, returning `{agents, total, page, page_size}`; omitting `scope`/`page` preserves the legacy "return everything" behavior. Name `search` matches the raw OR desensitized name (the frontend's static term?abbrev map is mirrored server-side in `deerflow/config/agent_name_desensitize.py`); `tag_ids` is an SQL OR-filter; `owner` keeps only agents published by that user id (the card's ??? ? built-in agents never match), powering the gallery's click-???-to-filter. `POST /api/agents/private-square/list` takes the same pagination params (incl. `owner`). Repository entry point: `AgentStore.list_paginated(...)`. Tests: `tests/test_agent_listing_cache.py::test_list_paginated_owner_filter_keeps_one_publisher`.
 
 **Homepage selector (agent picker on the new-chat page)** ? single admin-curated list backed by `agents.featured_order` (nullable BIGINT). NULL = not featured. Only `published = true` agents can be featured (router enforces on writes); any published agent is eligible regardless of ownership. Cleared with `order: null`. The list rendered to end users is `WHERE featured_order IS NOT NULL` + visibility-filter, sorted by `featured_order ASC`. Admins reorder by sending the desired ids to `PUT /api/agents/featured/order` (assigns indices 0..N-1). BIGINT is used rather than INT so the management UI can seed initial values from `Date.now()` (overflows INT on MySQL).
@@ -766,6 +770,7 @@ MySQL index script synchronized.
 - Physical: `backend/.deer-flow/users/{user_id}/threads/{thread_id}/user-data/...`, `deer-flow/skills/`
 - Translation: `replace_virtual_path()` / `replace_virtual_paths_in_command()`
 - Detection: `is_local_sandbox()` checks `sandbox_id == "local"`
+- Configured mount portability: `AppConfig._resolve_relative_mount_paths` resolves each relative `sandbox.mounts[*].host_path` against the loaded `config.yaml` directory before validation/provider construction, never against the process cwd. Keep repository-owned knowledge mounts relative (for example `knowledge/knowledge_base`); absolute paths remain unchanged, and sandbox providers always receive an absolute path.
 - **`{user_id}` for path resolution = `resolve_path_user_id(thread_id)`, using the persisted creator for every tracked thread.** The route's regular owner check still authorizes access first; creator resolution only selects the stable physical directory (`threads_meta.user_id`) and avoids a lost request context falling back to `users/default`. This also preserves cross-account task-deeplink conversations (rwfx/3qfx/xdfx) and roundtable system threads. Positive creator mappings are cached process-wide and DB/memory/missing-row failures fall back to the current login. It is wired at the thread-path consumers including `ThreadDataMiddleware.before_agent`, `present_file_tool`, uploads, artifact serving, and embedded `client.get_artifact`. **Rewrite-history recovery is metadata-only and job-owner scoped** (`list_by_session(..., user_id=current_user)`), so its GET/list endpoints intentionally skip redundant thread-owner checks and return an empty history instead of a history-only 404; the start/commit endpoints retain strict thread write authorization. Tests: `tests/test_thread_paths_owner.py`, `tests/test_thread_paths_roundtable.py`.
 
 - **Durable document-rewrite commit:** `document_rewrite_pipeline.atomic_write_text` writes through a deliberately short sibling temporary filename so long Windows artifact paths stay below the path-length limit, and guarantees the target `outputs` parent exists. If the sandbox recreates that directory in the narrow commit window, it repairs the directory and retries; the original file is otherwise only changed through `os.replace`.
@@ -998,6 +1003,15 @@ scheduler runs once per deployment. Per run:
 - Supports `supports_vision` flag for image understanding models
 - Config values starting with `$` resolved as environment variables
 - Missing provider modules surface actionable install hints from reflection resolvers (for example `uv add langchain-google-genai`)
+- Generic `langchain_openai:ChatOpenAI` entries are transparently wrapped by
+  `PatchedChatOpenAI`. Besides preserving reasoning/tool-call metadata, the
+  patch recognizes compatible gateways that encode failures inside HTTP 200
+  payloads (`base_resp.status_code != 0` with null/empty `choices`) in both
+  streaming and non-streaming paths. It raises the stable
+  `OpenAICompatibleUpstreamError`; `LLMErrorHandlingMiddleware` retries
+  transient concurrency/inference failures, while genuine quota/balance
+  failures are classified as non-retriable and surfaced immediately. Embedded
+  vendor failures therefore cannot become empty successful assistant turns.
 
 ### Roundtable Model Fault Tolerance (会商模型自动容错 / 换下一个模型)
 
@@ -1014,9 +1028,11 @@ scheduler runs once per deployment. Per run:
 
 ### vLLM Provider (`packages/harness/deerflow/models/vllm_provider.py`)
 
-- `VllmChatModel` subclasses `langchain_openai:ChatOpenAI` for vLLM 0.19.0 OpenAI-compatible endpoints
-- Preserves vLLM's non-standard assistant `reasoning` field on full responses, streaming deltas, and follow-up tool-call turns
-- Designed for configs that enable thinking through `extra_body.chat_template_kwargs.enable_thinking` on vLLM 0.19.0 Qwen reasoning models, while accepting the older `thinking` alias
+- `VllmChatModel` subclasses `langchain_openai:ChatOpenAI` for vLLM OpenAI-compatible endpoints
+- Thinking text is accepted from either `reasoning` (newer vLLM parsers) or `reasoning_content` (older vLLM / DeepSeek-style). The UI still reads canonical `additional_kwargs.reasoning_content`. Follow-up turns echo only the wire field that actually arrived, so other ChatOpenAI models are unchanged
+- Shared helpers live in `deerflow/models/reasoning_fields.py` and are also used by `PatchedChatOpenAI` (the default `langchain_openai:ChatOpenAI` patch)
+- Designed for configs that enable thinking through `extra_body.chat_template_kwargs.enable_thinking` on vLLM Qwen reasoning models, while accepting the older `thinking` alias
+- Per-model switch: set only that entry's `use: deerflow.models.vllm_provider:VllmChatModel`. Do not change SiliconFlow / DeepSeek entries that already use `langchain_openai:ChatOpenAI`
 
 ### IM Channels System (`app/channels/`)
 
@@ -1126,6 +1142,15 @@ Both can be modified at runtime via Gateway API endpoints or `DeerFlowClient` me
 
 ### Conditional WeKnora LLMWiki
 
+**Embedding ownership:** WeKnora's per-knowledge-base `embedding_model_id`
+indexes uploaded source documents; `llmwiki.local_wiki_index.embedding` indexes
+the generated Wiki-page mirror inside DeerFlow. Do not couple these two model
+choices. `GET /api/llmwiki/embedding-models` returns a strict credential-free
+projection of WeKnora Embedding models, and KB creation must validate and pass
+the selected active model id. When the caller omits a choice, retain WeKnora's
+active-default behavior. Existing KBs cannot change this binding in place, and
+cross-KB WeKnora searches should use model-compatible knowledge bases.
+
 Ordinary knowledge-base cards expose an owner/admin-only name/description edit dialog in `WeKnoraKnowledgeWorkspace.tsx`, reusing `useLlmWikiActions().update` and `PATCH /api/llmwiki/knowledge-bases/{id}`. The route trims names, rejects blank or reserved conversation-deposit names, writes to WeKnora before updating local metadata, and retains existing write authorization. A successful remote list is authoritative for every list scope, including `personal`: absent remote IDs are hidden without deleting mappings/references. Upstream failures remain errors. The grid also filters cached `remote_status=missing` rows and no longer renders stale-record cleanup cards. Regression coverage: `tests/test_llmwiki_knowledge_management.py`.
 
 `llmwiki.weknora.api_base_url` is the provider switch: non-empty enables WeKnora, empty preserves the legacy LLMWiki UI. WeKnora is independently deployed and owns PostgreSQL/Redis/object storage/vector storage/parsers/models; DeerFlow config contains only `api_base_url` and optional `web_base_url`. DeerFlow deliberately sends no WeKnora credential, so the WeKnora endpoint must be restricted to a trusted network and allow DeerFlow traffic itself or through its reverse proxy. There is intentionally no `default_embedding_model_id`: `WeKnoraClient` queries `/api/v1/models` and uses WeKnora's active Embedding model when creating a KB; Wiki creation additionally resolves an active KnowledgeQA model inside WeKnora for synthesis. The native BFF is `app/gateway/routers/llmwiki.py`; ownership/publication mappings live in `deerflow.persistence.llmwiki`; the browser only sees DeerFlow mapping IDs. Knowledge-base owners publish immediately (`private` -> `published`) without a review queue, and can unpublish ordinary bases. The conversation-deposit KB is system-owned, always published, shared by all DeerFlow users, excluded from My Knowledge, and immutable through user/admin detail operations; recognition requires both the reserved name and `system` owner. Existing same-name remote mappings are adopted in place as the system deposit, preserving mapping ids and document links. Its user-facing description, generated Markdown source and tags use `cmzs` branding; list/detail reads synchronize stale remote descriptions, and search results, source previews and embedded-detail JSON recursively replace legacy brand text in historical conversation-deposit payloads. Deposit requests must reference a thread accessible to the current account. Personal knowledge-base list/search views are scoped to the current DeerFlow account even for admins; frontend LLMWiki caches include the live account id, and admin write power does not make other users' private KBs appear as owned. Only `system_role === "admin"` sees the WeKnora connection-config tab. Knowledge cards navigate to a dedicated WeKnora-style detail route. Wiki-enabled bases render and default to `Wiki -> documents -> graph`; standard bases omit Wiki and render `documents -> graph`. The detail page supports sequential multi-file upload with an aggregate result for writable ordinary bases, hides it for public read-only/system-deposit bases, and uses a generic loading label while the embed session starts. It also supports URL and published manual-Markdown imports, browses real Wiki pages/content, proxies authenticated original-file previews, pages through `/chunks/{knowledge_id}`, and renders the Wiki page graph from `/knowledgebase/{kb_id}/wiki/graph`; document details use a right sheet rather than the removed KB modal. The credential-free proxy uses one WeKnora service identity, so per-user separation is enforced by DeerFlow mappings while all remote KBs physically share that identity's WeKnora workspace. WeKnora iframe detail pages first call `/api/llmwiki/knowledge-bases/{id}/weknora/session` through the normal DeerFlow API auth path, then load `/platform/knowledge-bases/{weknora_id}` with a signed `deerflow_weknora_embed` cookie for `/platform`, `/assets`, `/locales`, root assets, and API calls. Injected fetch/XHR rewriting sends all iframe `/api/v1/*`, including colliding `/api/v1/auth/*`, through `/api/llmwiki/weknora-embed/api/v1/*`; Gateway auth/CSRF bypass only applies to those signed iframe proxy requests, the proxy still revalidates the mapped KB, and cookie security honors `X-Forwarded-Proto` for HTTPS reverse proxies. `llmwiki_search` is conditionally registered in `tools.py`, is read-only, and rechecks the current DeerFlow user, agent `llmwiki_knowledge_base_ids`, and thread-context selection on every call. Source previews prefer the cleaned Wiki/LLMWiki page text when a retrieved chunk maps to a Wiki page, with raw split chunks as the fallback. Agent bindings use an inline WeKnora-style searchable/grouped multi-select in the standard agent create/detail UI; new chats use the same interaction pattern as a compact composer dropdown, and selections are written to thread metadata/context and restored on reopen. The DeerFlow frontend is native React and the WeKnora frontend is not modified or embedded. Full deployment and behavior notes: `docs/LLMWIKI_WEKNORA_INTEGRATION_ZH.md`. Tests: `tests/test_llmwiki_weknora.py`.
@@ -1322,6 +1347,14 @@ Automatic conversation summarization when approaching token limits:
   when it has already been folded into the hidden summary. This keeps strict
   OpenAI-compatible gateways from rejecting a tool-continuation call with
   `No user query found in message`.
+- LangChain keeps the agent prompt in `ModelRequest.system_message`, separate
+  from `ModelRequest.messages`. Compression must merge its hidden summary into
+  that dedicated slot and remove every `SystemMessage` from the ordinary
+  message list. Strict Qwen-style adapters accept only one system message at
+  index zero and otherwise return HTTP 400 (`system message must be at the
+  beginning`). Keep this normalization adapter-independent; the payload-level
+  OpenAI-compatible normalizer is a second line of defence and also merges
+  adjacent leading system messages.
 - Keeps recent messages while summarizing older ones.
 
 Tests: `tests/test_summarization_toggle.py` (gating + whitelist),
@@ -1801,8 +1834,8 @@ Ordinary knowledge detail landing is globally configured by `ordinary_knowledge_
   pages need backfill, not a forced rebuild of every page.
   FastEmbed is a standard backend dependency. Encoder configuration, directory
   upload and warmup live only in the administrator global settings dialog.
-  A runtime `system_settings.json` path override wins over config.yaml; uploaded
-  files are streamed into `.deer-flow/models/bge-m3`, never the source tree.
+  When the effective provider is local, its `system_settings.json` path override wins over config.yaml; uploaded
+  files are streamed into immutable `.deer-flow/models/bge-m3-revisions/<revision>` directories, never the source tree.
   Encoder warmup is explicitly started from the settings UI/API and must never block application startup
   or turn a model-load failure into a DeerFlow service failure. Local provider
   is offline-only: require local_model_path or DEERFLOW_BGE_M3_MODEL_PATH and
@@ -1810,6 +1843,21 @@ Ordinary knowledge detail landing is globally configured by `ordinary_knowledge_
   `local_process_isolation=true` by default: inference runs in the bundled JSONL
   worker subprocess, and shutdown must terminate that worker without waiting on
   model teardown.
+- The administrator encoder override is an explicit persisted mode, not an
+  inference from whether `model_path` happens to be non-empty. `configured`
+  uses the current `config.yaml` provider (including OpenAI-compatible);
+  saving/uploading a local directory sets `local` plus a new model revision,
+  while `/api/llmwiki/local-encoder/use-configured` switches back. Every switch
+  hot-rebuilds embedding/cache/search/sync/retrieval as one graph and updates
+  the harness runtime registration. Status must remain readable for a remote
+  provider. The scheduler stays alive as a lightweight config watcher but only
+  scans when effective `enabled && auto_sync`; keep the default/portable release
+  configs at `auto_sync=true` because asynchronous Wiki generation can finish
+  after the event-triggered first scan. A changed local model revision must
+  change the embedding fingerprint so vectors from replaced weights are never
+  reused. Uploaded weights live in immutable revision directories. A replaced
+  embedding generation gets a bounded grace period for in-flight work, then
+  rejects stragglers, drains real thread work, and releases its model process.
 - Every successful mapping snapshot is mirrored to the global assistant base,
   including empty snapshots so deleted source pages are retired. Re-import is
   source-replacement semantics: absent Wiki/chunk/entity/relation pages must not

offline-backend-20260512/backend/README.md

@@ -79,7 +79,7 @@ Middlewares execute in strict order, each handling a specific concern:
 | 1 | **ThreadDataMiddleware** | Creates per-thread isolated directories (workspace, uploads, outputs) |
 | 2 | **UploadsMiddleware** | Injects newly uploaded files into conversation context |
 | 3 | **SandboxMiddleware** | Acquires sandbox environment for code execution |
-| 4 | **SummarizationMiddleware** | Reduces context when approaching token limits (optional) |
+| 4 | **SummarizationMiddleware** | Reduces context near token limits and folds the hidden summary into one leading system message for strict model adapters (optional) |
 | 5 | **TodoListMiddleware** | Tracks multi-step tasks in plan mode (optional) |
 | 6 | **TitleMiddleware** | Auto-generates conversation titles after first exchange |
 | 7 | **MemoryMiddleware** | Queues conversations for async memory extraction |
@@ -94,6 +94,7 @@ Per-thread isolated execution with virtual path translation:
 - **Providers**: `LocalSandboxProvider` (filesystem) and `AioSandboxProvider` (Docker, in community/)
 - **Virtual paths**: `/mnt/user-data/{workspace,uploads,outputs}` → thread-specific physical directories
 - **Skills path**: `/mnt/skills` → `deer-flow/skills/` directory
+- **Portable configured mounts**: a relative `sandbox.mounts[*].host_path` is resolved against the directory containing the loaded `config.yaml`, not the process working directory. Providers still receive an absolute host path, so `knowledge/knowledge_base` can be committed and the deployment can be cloned or moved without editing a machine-specific path; already-absolute mount paths are preserved.
 - **Skills loading**: Recursively discovers nested `SKILL.md` files under `skills/{public,custom}` and preserves nested container paths
 - **Conditional WeKnora LLMWiki**: a non-empty `llmwiki.weknora.api_base_url` enables the DeerFlow-native WeKnora BFF and UI; an empty address preserves the existing LLMWiki page. WeKnora remains independently deployed and owns its database, Redis, storage, parsers and models. DeerFlow keeps only the API/admin addresses, user/publication mappings, agent knowledge-base bindings and per-conversation selections; it stores and sends no WeKnora credential, so the endpoint must be restricted to a trusted network and allow DeerFlow traffic. Owners publish directly to the public LLMWiki without an approval queue for ordinary bases; the system-owned conversation-deposit base is always published, shared by all users, excluded from My Knowledge, immutable through user/admin detail operations, and recognized by both its reserved name and `system` owner. An existing same-name remote mapping is adopted in place as the system deposit so its mapping id and document links stay valid. Its user-facing knowledge-base description and generated document metadata use the `cmzs` brand; list/detail reads synchronize stale remote descriptions, while conversation-deposit search results, source previews and embedded-detail JSON rewrite legacy brand text to `cmzs`. Deposit requests must reference a thread accessible to the current account. Personal knowledge-base lists are scoped to the current DeerFlow account even for admins, while frontend LLMWiki query caches also include the active account id so switching accounts cannot reuse another account's list/detail data. Admins remain the only role that sees the WeKnora connection-config tab. Knowledge cards open a dedicated WeKnora-style detail route: Wiki-enabled bases default to Wiki, then documents and graph; standard bases hide Wiki and default to documents. Writable ordinary knowledge-base details expose a native multi-file upload action that submits files sequentially and reports aggregate success/failure; read-only public bases and the system deposit base do not. It supports file/URL/manual-Markdown imports, Wiki page browsing, document preview, real parsed chunks and Wiki graph nodes/edges. New chats use a compact WeKnora-style searchable/grouped multi-select inside the composer, while agent create/edit pages bind spaces through an inline panel. A single proxy service identity means DeerFlow users are isolated logically while their WeKnora entities share that identity's workspace. The read-only `llmwiki_search` tool reauthorizes the current DeerFlow user on every call and renders credential-free source previews; source previews prefer cleaned Wiki/LLMWiki text when a retrieved chunk maps to a Wiki page, with raw chunks as the fallback. The detail page first creates a signed iframe session through the normal DeerFlow API auth path, then points the iframe directly at the proxied WeKnora `/platform/...` route using the signed `deerflow_weknora_embed` cookie; global auth/CSRF bypass is limited to those signed iframe proxy requests, and HTTPS cookie attributes honor `X-Forwarded-Proto` behind reverse proxies. The iframe proxy keeps WeKnora's root-relative `/platform`, `/assets`, `/locales`, and `/api/v1/*` paths, but is registered last through `llmwiki.proxy_router` so it cannot intercept first-party Gateway APIs such as `POST /api/v1/auth/login/username`. See [docs/LLMWIKI_WEKNORA_INTEGRATION_ZH.md](docs/LLMWIKI_WEKNORA_INTEGRATION_ZH.md).
 - **Enterprise Research workbench (temporarily disabled)**: the independent `/api/enterprise-research` router, its report executor, and its ORM table registration are intentionally inactive. The implementation remains in the repository, but startup does not create or alter `enterprise_research_tasks` or `enterprise_research_report_jobs`; this keeps the active Deep Research workflow independent of the paused workbench and avoids MySQL schema errors.
@@ -471,6 +472,10 @@ Custom agents are indexed in the `agents` database table. The `id` column is the
 
 The built-in `forced-research-responder` (「强制检索输出助手」) is seeded at Gateway startup. Unlike an ordinary skill-enabled custom agent, it has a runtime-enforced per-turn collection gate: the model cannot finish a response until a retrieval/knowledge/MCP tool or a skill Python script returns usable information. It then answers directly in the user's requested chat format rather than generating an artifact. The agent may create or edit only temporary `.py` files below `/mnt/user-data/workspace/` and may execute `.py` skill scripts through `bash`; writes to `outputs`, Markdown/document creation, `present_files`, general shell commands, and skill mutation are denied. Administrators can edit its model and skill allowlist from agent management; the runtime safety policy remains fixed. Regression coverage: `tests/test_forced_research_agent.py`.
 
+The strategy-selection workbench starts with nine folder-backed functional agents: one intent agent, six independent angle agents (governance, diplomacy, economy/supply-chain, security risk, public opinion, and law/policy), one judge, and one final solution editor. Defaults ship in `app/gateway/routers/_strategy_selection_seed_assets/` and are copied only when an agent directory is absent, before `_sync_legacy_agents`; existing administrator edits are never overwritten. A global `strategy_agent_roles` registry owns classification, lifecycle state, and ordering independently of projects. Intent, judge, and solution are fixed singleton roles: administrators may update their model, SOUL, and skills but cannot add, disable, reorder, or delete them. Angles form one ordered catalog shared by every project; administrators may add, update, disable, restore, and reorder them. `GET /api/strategy-agents` is the public enabled catalog and omits model/SOUL/skills; `include_disabled=true` or `include_config=true` requires an administrator. Admin writes use `POST /api/strategy-agents/angles`, `PUT /api/strategy-agents/{id}`, and `DELETE /api/strategy-agents/{id}`; deletion is a soft disable so folder configuration and historical project references remain intact. Dynamic angles use the reserved `strategy-selection-angle-` namespace, receive `web` + `file:read`, and get a safe default SOUL if the submitted SOUL is blank. Model names and selected skills are validated, skills must be active and globally visible, generic agent CRUD cannot create or hard-delete reserved strategy agents, and parallel execution rejects disabled roles. The shipped angle agents use `policy-knowledge`, intent uses `intent-clarification-policy`, judging is input-only, and the solution editor has file-write access for `/mnt/user-data/outputs/综合策略方案.md`. Every default SOUL requires neutral evidence handling, de-escalation and civilian protection, and prohibits operational combat guidance or targeted political manipulation.
+
+`POST /api/parallel-agents/run/stream` keeps reasoning and the deliverable in separate per-agent frames. Provider structured reasoning and inline `<think>...</think>` content are emitted only as `reasoning_delta`; visible answer text is emitted as `delta`, and `agent_done.content` contains only the visible answer. Consumers must not append `reasoning_delta` to strategy output or the final document. A final `is_llm_error_message` fallback, empty/thinking-only response, or punctuation-only provider degeneration is emitted as `agent_error`, never as a successful `agent_done`. Regression coverage: `tests/test_strategy_selection_seed.py`, `tests/test_strategy_agent_management.py`, and `tests/test_roundtable_model_fallback.py`.
+
 ### AI Writing Intranet Retrieval
 
 AI 写作的「知识库检索」会直连 `ai_writing.intranet_search_url` 内网 ES/知识库接口，并默认跳过代理环境变量和 HTTPS 证书校验，适配自签名或内部 CA 证书的内网服务。需要强校验时可在 `config.yaml` 里设置 `ai_writing.intranet_verify_ssl: true`。通用检索里的非内置技能在 `ai_writing.researcher_skill_agent: true` 时会用真实 agent 运行时执行技能：以 `ai-writing-researcher` 身份读取该技能的 `SKILL.md`，并按技能要求通过 `bash` 运行脚本，弱模型也会在本轮任务里收到明确的读文件和脚本执行指令。
@@ -543,6 +548,13 @@ the configured model has an explicit, proxy-supported thinking control. This
 prevents DeerFlow's connection check from sending vendor-specific `thinking`
 fields that a generic OpenAI-compatible gateway may reject.
 
+OpenAI-compatible gateways that return vendor errors inside an HTTP 200
+response (for example, a non-zero `base_resp.status_code` with empty/null
+`choices`) are treated as upstream failures in both streaming and
+non-streaming calls. DeerFlow retries transient upstream responses instead of
+accepting an empty assistant turn, while genuine quota/balance failures are
+classified as non-retriable and surfaced immediately instead of being retried.
+
 ### Running
 
 **Full Application** (from project root):
@@ -916,6 +928,13 @@ the file through the existing thread-artifact endpoint.
 
 远端已经删除的知识库会在下次列表刷新时自动隐藏，包括个人、公共列表和知识库选择器；页面每 15 秒自动刷新，也可以手动点击「刷新」。远端服务请求失败时展示错误，不把连接故障当成删除，不自动删除本地映射或已有引用。
 
+新建知识库时会通过 `GET /api/llmwiki/embedding-models` 读取 WeKnora 中可用的
+Embedding 模型，并把所选 `embedding_model_id` 明确传给创建接口。该模型只负责
+WeKnora 中上传原文的分块向量化；它和下文 DeerFlow 自己的 Wiki 镜像编码器是两套
+独立配置，因此选择 OpenAI/OpenAI-compatible 原文编码器时不要求同时启用本地
+BGE-M3。模型列表响应只暴露名称、provider、状态等白名单字段，不返回密钥或连接
+参数。模型绑定只对新建库生效；需要跨知识库检索时，各库应使用相同或兼容的向量模型。
+
 ## DeerFlow-local LLMWiki Wiki vector index
 
 LLMWiki can mirror processed WeKnora Wiki pages into DeerFlow and search only
@@ -1164,13 +1183,23 @@ llmwiki:
 
 本地编码依赖随标准后端安装。将完整 BGE-M3 模型目录提前放到离线服务器，并通过
 `local_model_path` 或 `DEERFLOW_BGE_M3_MODEL_PATH` 指向它。管理员也可在
-「设置和更多 → 设置 → 本地编码器」中选择服务器目录，或从浏览器上传完整模型目录；
+「设置和更多 → 设置 → Wiki 镜像编码器」中选择服务器目录，或从浏览器上传完整模型目录；
 页面配置持久化到运行目录的 `system_settings.json`，上传文件落到
-`.deer-flow/models/bge-m3`，均不进入源码仓库。系统强制 `local_files_only`，
+`.deer-flow/models/bge-m3-revisions/<revision>` 的不可变版本目录，均不进入源码仓库。系统强制 `local_files_only`，
 **不会访问互联网或下载模型**。管理员可在同一设置页点击「一键启动编码器」异步加载；该操作不挂在应用启动流程，加载失败不会
 中断 DeerFlow 主服务。默认由独立低优先级子进程承载模型内存，正常停止 DeerFlow
 时会一并回收该子进程；编码进程异常退出只会将当前向量任务标记失败。模型目录应包含
 `onnx/model.onnx`（官方权重约 2.3 GB）及对应 tokenizer/config 文件。权重不进入业务源码仓库。
+
+运行时编码器模式持久化为 `configured` 或 `local`。默认 `configured` 严格使用
+`config.yaml` 中的 OpenAI、OpenAI-compatible 或 local provider；保存服务器目录或
+上传模型会显式切到 `local` 并热重建 embedding/search/sync/retrieval 服务，不需要
+重启 Gateway。`POST /api/llmwiki/local-encoder/use-configured` 可立即恢复配置文件中的
+provider。`GET /api/llmwiki/local-encoder/status` 在远程 provider 下也正常返回当前
+provider/mode，不再把“不是 local”当成状态接口错误。每次激活本地模型都会生成新的
+模型修订指纹，避免同一路径替换权重后误复用旧向量。切换后的旧编码器会给在途任务
+保留短暂宽限期，随后等待当前编码调用结束并自动回收模型进程。
+
 浏览器目录上传采用磁盘暂存和 4 MB 分块复制，页面显示上传进度；经 Nginx 等反向
 代理部署时仍需把请求体上限和读写超时配置到可承载完整模型目录。
 相同模型指纹、相同内容的页面复用现有向量；短正文/摘要至少保留一个非空分段。

offline-backend-20260512/backend/app/gateway/app.py

@@ -42,6 +42,7 @@ from app.gateway.routers import (
     compact_menu_overrides,
     dashboard_sessions,
     deep_research,
+    direct_chat,
     external_llmwiki,
     feedback,
     fixed_questions,
@@ -91,6 +92,7 @@ from app.gateway.routers import (
     skill_addresses,
     skill_knowledge,
     skills,
+    strategy_agents,
     suggestions,
     system_settings,
     tags,
@@ -1019,20 +1021,14 @@ async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
         # Run Alembic migrations before anything else touches the schema.
         await _run_db_migrations()
 
-        # Local Wiki mirror/index scans are opt-in and run outside request
-        # handling. Per-library database leases keep multi-worker startup safe.
-        app.state.llmwiki_index_scheduler_task = None
-        local_wiki_index = app.state.config.llmwiki.local_wiki_index
-        if (
-            local_wiki_index.enabled
-            and local_wiki_index.auto_sync
-            and getattr(app.state, "llmwiki_sync_service", None) is not None
-        ):
-            from app.gateway.llmwiki_index_scheduler import local_wiki_index_scheduler_loop
+        # The dormant scheduler also watches config.yaml/system-settings
+        # changes. Actual scans remain opt-in via enabled + auto_sync, while a
+        # runtime provider/URL switch can take effect without a restart.
+        from app.gateway.llmwiki_index_scheduler import local_wiki_index_scheduler_loop
 
-            app.state.llmwiki_index_scheduler_task = asyncio.create_task(
-                local_wiki_index_scheduler_loop(app)
-            )
+        app.state.llmwiki_index_scheduler_task = asyncio.create_task(
+            local_wiki_index_scheduler_loop(app)
+        )
 
         # ?? recall_budget cache?? DB ????,? get_effective_memory_config ?????
         try:
@@ -1087,6 +1083,21 @@ async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
                 "AI-writing functional agent seeding failed at startup (non-fatal)"
             )
 
+        # Strategy-selection functional agents (intent, six independent
+        # analysis angles, judge, and solution editor).  Seed them before
+        # _sync_legacy_agents so they are immediately visible and editable in
+        # the existing agent-management UI on a fresh deployment.
+        try:
+            from app.gateway.routers._strategy_selection_seed import (
+                ensure_strategy_selection_agents,
+            )
+
+            ensure_strategy_selection_agents()
+        except Exception:
+            logger.exception(
+                "Strategy-selection functional agent seeding failed at startup (non-fatal)"
+            )
+
         # 内置「模板数据转换器」agent(JSON → HTML 模板填充)。同样必须在
         # _sync_legacy_agents **之前**补建目录,后者把它 upsert 进 agents 表,
         # 第一次启动 /api/agents 与定时任务下拉框里就有它。
@@ -1211,6 +1222,15 @@ async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
                         await ensure_builtin_agent_purpose_tags(agent_store, tag_store)
                 except Exception:
                     logger.exception("Built-in agent purpose-tag seeding failed at startup (non-fatal)")
+
+                # Synchronize every worker's strategy registry only after the
+                # folder agents have been imported.  In memory mode this also
+                # restores dynamic/default angle lifecycle from sidecars.
+                try:
+                    await strategy_agents.ensure_strategy_agent_registry(app)
+                    logger.info("Strategy agent registry synchronized for worker")
+                except Exception:
+                    logger.exception("Strategy agent role seeding failed at startup (non-fatal)")
         except Exception:
             logger.exception("Legacy agent sync failed at startup (non-fatal)")
 
@@ -1605,6 +1625,7 @@ This gateway provides custom endpoints for models, MCP configuration, skills, an
 
     # Agents API is mounted at /api/agents
     app.include_router(agents.router)
+    app.include_router(strategy_agents.router)
 
     # Recommended Questions API is mounted at /api/recommended-questions
     app.include_router(recommended_questions.router)
@@ -1803,6 +1824,9 @@ This gateway provides custom endpoints for models, MCP configuration, skills, an
     # 开放问答接口 /api/open/chat —— 无需登录,指定模型 + 智能体做问答,可关闭思考模式
     app.include_router(open_chat.router)
 
+    # 极速问答 /api/direct-chat/stream —— 直连大模型流式输出,不走 lead agent / 工具 / 技能
+    app.include_router(direct_chat.router)
+
     # 开放接口 /api/open/3qfx/ask —— 无需登录,按 taskId 直接发起 3qfx 第一次问答(后台运行,落成真实会话)
     app.include_router(open_3qfx.router)
 

offline-backend-20260512/backend/app/gateway/deps.py

@@ -32,6 +32,7 @@ if TYPE_CHECKING:
     from deerflow.persistence.notifications import NotificationStore
     from deerflow.persistence.scheduled_tasks import ScheduledTaskStore
     from deerflow.persistence.skills import SkillStore
+    from deerflow.persistence.strategy_agent_roles import StrategyAgentRoleStore
     from deerflow.persistence.tags import TagStore
     from deerflow.persistence.thread_meta.base import ThreadMetaStore
 
@@ -132,6 +133,12 @@ async def langgraph_runtime(app: FastAPI) -> AsyncGenerator[None, None]:
 
         app.state.agent_store = make_agent_store(sf)
 
+        from deerflow.persistence.strategy_agent_roles import (
+            make_strategy_agent_role_store,
+        )
+
+        app.state.strategy_agent_role_store = make_strategy_agent_role_store(sf)
+
         from deerflow.persistence.skills import make_skill_store
 
         app.state.skill_store = make_skill_store(sf)
@@ -384,7 +391,6 @@ async def langgraph_runtime(app: FastAPI) -> AsyncGenerator[None, None]:
         # DeerFlow-local Wiki mirror/vector index. The store is always wired so
         # migrations and status inspection work while feature flags are off;
         # network/search services only exist when explicitly enabled.
-        from deerflow.integrations.weknora.local_index.runtime import register_local_wiki_index_runtime
         from deerflow.persistence.llmwiki_index import make_llmwiki_index_store
 
         local_index_config = config.llmwiki.local_wiki_index
@@ -397,78 +403,12 @@ async def langgraph_runtime(app: FastAPI) -> AsyncGenerator[None, None]:
         app.state.llmwiki_vector_search = None
         app.state.llmwiki_sync_service = None
         app.state.llmwiki_retrieval_service = None
-        from deerflow.integrations.weknora.runtime import build_weknora_client, get_resolved_llmwiki_runtime
+        from app.gateway.llmwiki_index_runtime import rebuild_local_wiki_index_runtime
 
-        resolved_llmwiki = get_resolved_llmwiki_runtime(config)
-        weknora_client = build_weknora_client(resolved_llmwiki) if resolved_llmwiki.weknora_enabled else None
-        embedding_config = local_index_config.embedding
-        # The administrator may select or upload the offline encoder from the
-        # UI.  This runtime-owned value deliberately overrides config.yaml and
-        # survives application restarts without modifying release assets.
-        if embedding_config.provider == "local":
-            from deerflow.config.system_settings import load_system_settings
-
-            runtime_model_path = load_system_settings().local_wiki_encoder.model_path.strip()
-            if runtime_model_path:
-                embedding_config = embedding_config.model_copy(
-                    update={"local_model_path": runtime_model_path}
-                )
-        embedding_configured = bool(
-            embedding_config.enabled
-            and (embedding_config.base_url or embedding_config.provider == "local")
-            and embedding_config.model.strip()
-        )
-        if embedding_configured:
-            from deerflow.integrations.weknora.local_index.embedding import StrictWikiEmbeddingClient
-
-            app.state.llmwiki_embedding = StrictWikiEmbeddingClient(embedding_config)
-        if local_index_config.enabled and app.state.llmwiki_embedding is not None:
-            from deerflow.integrations.weknora.local_index.search import WikiVectorSearchService
-            from deerflow.integrations.weknora.local_index.sync import WikiSyncService
-            from deerflow.integrations.weknora.local_index.vector_cache import WikiVectorCache
-
-            app.state.llmwiki_vector_cache = WikiVectorCache(
-                app.state.llmwiki_index_store,
-                max_knowledge_bases=local_index_config.cache_max_knowledge_bases,
-                revision_check_seconds=local_index_config.cache_revision_check_seconds,
-            )
-            app.state.llmwiki_vector_search = WikiVectorSearchService(
-                local_index_config,
-                app.state.llmwiki_embedding,
-                app.state.llmwiki_vector_cache,
-            )
-            if weknora_client is not None:
-                app.state.llmwiki_sync_service = WikiSyncService(
-                    local_index_config,
-                    app.state.llmwiki_index_store,
-                    app.state.llmwiki_embedding,
-                    app.state.llmwiki_vector_cache,
-                    weknora_client,
-                )
-                from app.gateway.knowledge_transfer import sync_to_global
-
-                async def on_wiki_vectorized(mapping):
-                    return await sync_to_global(app, mapping)
-
-                app.state.llmwiki_sync_service.on_completed = on_wiki_vectorized
-        if weknora_client is not None or app.state.llmwiki_vector_search is not None:
-            from deerflow.integrations.weknora.local_index.retrieval import WikiRetrievalService
-
-            app.state.llmwiki_retrieval_service = WikiRetrievalService(
-                app.state.llmwiki_index_store,
-                vector_search=(
-                    app.state.llmwiki_vector_search
-                    if local_index_config.internal_search_enabled
-                    else None
-                ),
-                client=weknora_client,
-            )
-        register_local_wiki_index_runtime(
-            store=app.state.llmwiki_index_store,
-            search=app.state.llmwiki_vector_search,
-            sync=app.state.llmwiki_sync_service,
-            retrieval=app.state.llmwiki_retrieval_service,
-        )
+        # Build every embedding-dependent object through the same hot-swap
+        # path used by the administrator settings API.  This keeps startup,
+        # uploaded-local selection and config.yaml reloads behaviorally equal.
+        await rebuild_local_wiki_index_runtime(app, force=True)
 
         from deerflow.persistence.taskcop_tasks import make_taskcop_task_store
 
@@ -707,9 +647,9 @@ async def langgraph_runtime(app: FastAPI) -> AsyncGenerator[None, None]:
             from deerflow.integrations.weknora.local_index.runtime import register_local_wiki_index_runtime
 
             register_local_wiki_index_runtime(store=None, search=None, sync=None, retrieval=None)
-            llmwiki_embedding = getattr(app.state, "llmwiki_embedding", None)
-            if llmwiki_embedding is not None:
-                await llmwiki_embedding.close()
+            from app.gateway.llmwiki_index_runtime import close_local_wiki_index_runtime
+
+            await close_local_wiki_index_runtime(app)
             from deerflow.persistence.notifications import set_notification_store
 
             set_notification_store(None)
@@ -824,6 +764,14 @@ def get_agent_store(request: Request) -> AgentStore:
     return val
 
 
+def get_strategy_agent_role_store(request: Request) -> StrategyAgentRoleStore:
+    """Return the global strategy-agent role registry."""
+    val = getattr(request.app.state, "strategy_agent_role_store", None)
+    if val is None:
+        raise HTTPException(status_code=503, detail="Strategy agent role store not available")
+    return val
+
+
 def get_skill_store(request: Request) -> SkillStore:
     """Return the custom-skill store."""
     val = getattr(request.app.state, "skill_store", None)

offline-backend-20260512/backend/app/gateway/llmwiki_index_runtime.py

@@ -0,0 +1,369 @@
+"""Hot-swappable runtime composition for the DeerFlow-local Wiki index.
+
+The file configuration remains the source of truth for the normal embedding
+provider.  Administrators can temporarily select the uploaded offline BGE-M3
+encoder through ``system_settings.json`` without rewriting release assets or
+restarting Gateway.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import json
+import logging
+import os
+from pathlib import Path
+from typing import Any
+
+from fastapi import FastAPI
+
+from deerflow.config import get_app_config
+from deerflow.config.app_config import AppConfig
+from deerflow.config.llmwiki_config import LocalWikiIndexConfig
+from deerflow.config.system_settings import LocalWikiEncoderSettings, load_system_settings
+from deerflow.integrations.weknora.runtime import build_weknora_client, get_resolved_llmwiki_runtime
+
+logger = logging.getLogger(__name__)
+_EMBEDDING_RETIREMENT_GRACE_SECONDS = 600.0
+
+
+def resolve_effective_local_wiki_index_config(
+    config: AppConfig,
+    encoder_settings: LocalWikiEncoderSettings,
+) -> LocalWikiIndexConfig:
+    """Apply the persisted encoder mode to a copy of the file configuration."""
+
+    local_index = config.llmwiki.local_wiki_index
+    configured_embedding = local_index.embedding
+    runtime_model_path = encoder_settings.model_path.strip()
+
+    if encoder_settings.mode == "local":
+        # Directory upload is intentionally a BGE-M3 contract.  A configured
+        # OpenAI model/dimension must not leak into the local FastEmbed worker.
+        embedding = configured_embedding.model_copy(
+            update={
+                "enabled": True,
+                "provider": "local",
+                "model": "bge-embedding-m3",
+                "dimensions": 1024,
+                "base_url": "",
+                "api_key": "",
+                "local_model_path": runtime_model_path or configured_embedding.local_model_path,
+                "local_model_revision": encoder_settings.model_revision,
+            }
+        )
+    elif configured_embedding.provider == "local":
+        # Keep the historical invariant: an administrator-selected directory
+        # overrides config.yaml when the configured provider itself is local.
+        updates = {"local_model_revision": encoder_settings.model_revision}
+        if runtime_model_path:
+            updates["local_model_path"] = runtime_model_path
+        embedding = configured_embedding.model_copy(
+            update=updates
+        )
+    else:
+        embedding = configured_embedding
+    return local_index.model_copy(update={"embedding": embedding})
+
+
+def _resolved_local_model_path(config: LocalWikiIndexConfig) -> Path | None:
+    raw = config.embedding.local_model_path.strip() or os.environ.get(
+        "DEERFLOW_BGE_M3_MODEL_PATH", ""
+    ).strip()
+    if not raw:
+        return None
+    path = Path(raw).expanduser()
+    return path.resolve() if path.is_absolute() else (Path.cwd() / path).resolve()
+
+
+def _local_model_files_ready(config: LocalWikiIndexConfig) -> bool:
+    path = _resolved_local_model_path(config)
+    return bool(
+        path
+        and path.is_dir()
+        and ((path / "onnx" / "model.onnx").is_file() or (path / "model.onnx").is_file())
+    )
+
+
+def _embedding_provider_ready(config: LocalWikiIndexConfig) -> bool:
+    embedding = config.embedding
+    if embedding.provider == "local":
+        return _local_model_files_ready(config)
+    return bool(embedding.base_url)
+
+
+def _schedule_embedding_retirement(app: FastAPI, embedding: Any) -> None:
+    retired = list(getattr(app.state, "llmwiki_retired_embeddings", []) or [])
+    if embedding not in retired:
+        retired.append(embedding)
+    app.state.llmwiki_retired_embeddings = retired
+
+    async def retire_after_grace() -> None:
+        retired_successfully = False
+        try:
+            await asyncio.sleep(_EMBEDDING_RETIREMENT_GRACE_SECONDS)
+            await embedding.retire()
+            retired_successfully = True
+        except asyncio.CancelledError:
+            raise
+        except Exception:
+            logger.exception("Failed to retire an old Local Wiki embedding runtime")
+        finally:
+            if retired_successfully:
+                current = list(getattr(app.state, "llmwiki_retired_embeddings", []) or [])
+                app.state.llmwiki_retired_embeddings = [item for item in current if item is not embedding]
+
+    tasks: set[asyncio.Task[None]] = getattr(app.state, "llmwiki_retirement_tasks", None)
+    if tasks is None:
+        tasks = set()
+        app.state.llmwiki_retirement_tasks = tasks
+    task = asyncio.create_task(retire_after_grace(), name="llmwiki-embedding-retirement")
+    tasks.add(task)
+    task.add_done_callback(tasks.discard)
+
+
+def _runtime_signature(
+    local_index: LocalWikiIndexConfig,
+    *,
+    resolved_llmwiki: Any,
+    encoder_mode: str,
+) -> str:
+    payload = {
+        "local_index": local_index.model_dump(mode="json"),
+        # A directory can be mounted/unmounted without editing config.yaml.
+        # Readiness is part of the generation so services appear/disappear on
+        # the next lightweight scheduler poll instead of requiring a restart.
+        "local_model_files_ready": (
+            _local_model_files_ready(local_index)
+            if local_index.embedding.provider == "local"
+            else None
+        ),
+        "encoder_mode": encoder_mode,
+        "weknora": {
+            "provider": resolved_llmwiki.provider,
+            "api_base_url": resolved_llmwiki.api_base_url,
+            "web_base_url": resolved_llmwiki.web_base_url,
+            "admin_email": resolved_llmwiki.admin_email,
+            "admin_password": resolved_llmwiki.admin_password,
+            "override_enabled": resolved_llmwiki.override_enabled,
+        },
+    }
+    raw = json.dumps(payload, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+    return hashlib.sha256(raw.encode("utf-8")).hexdigest()
+
+
+async def rebuild_local_wiki_index_runtime(
+    app: FastAPI,
+    *,
+    force: bool = False,
+) -> LocalWikiIndexConfig:
+    """Refresh config and atomically replace all embedding-dependent services."""
+
+    lock = getattr(app.state, "llmwiki_runtime_lock", None)
+    if lock is None:
+        lock = asyncio.Lock()
+        app.state.llmwiki_runtime_lock = lock
+
+    async with lock:
+        source_config = get_app_config()
+        settings = load_system_settings()
+        effective_config = resolve_effective_local_wiki_index_config(
+            source_config,
+            settings.local_wiki_encoder,
+        )
+        resolved_llmwiki = get_resolved_llmwiki_runtime(source_config)
+        signature = _runtime_signature(
+            effective_config,
+            resolved_llmwiki=resolved_llmwiki,
+            encoder_mode=settings.local_wiki_encoder.mode,
+        )
+        current_signature = getattr(app.state, "llmwiki_runtime_signature", None)
+        if not force and current_signature == signature:
+            app.state.llmwiki_source_config = source_config
+            app.state.llmwiki_effective_config = effective_config
+            return effective_config
+
+        index_store = getattr(app.state, "llmwiki_index_store", None)
+        if index_store is None:
+            raise RuntimeError("Local Wiki index store is not initialized")
+
+        from deerflow.integrations.weknora.local_index.embedding import StrictWikiEmbeddingClient
+        from deerflow.integrations.weknora.local_index.retrieval import WikiRetrievalService
+        from deerflow.integrations.weknora.local_index.runtime import register_local_wiki_index_runtime
+        from deerflow.integrations.weknora.local_index.search import WikiVectorSearchService
+        from deerflow.integrations.weknora.local_index.sync import WikiSyncService
+        from deerflow.integrations.weknora.local_index.vector_cache import WikiVectorCache
+
+        embedding_config = effective_config.embedding
+        provider_ready = _embedding_provider_ready(effective_config)
+        embedding_configured = bool(
+            embedding_config.enabled
+            and provider_ready
+            and embedding_config.model.strip()
+        )
+        old_embedding = getattr(app.state, "llmwiki_embedding", None)
+        reusable = (
+            old_embedding
+            if old_embedding is not None and old_embedding.config == embedding_config
+            else None
+        )
+        new_embedding = None
+        if embedding_configured:
+            new_embedding = reusable or StrictWikiEmbeddingClient(embedding_config)
+        new_cache = None
+        new_search = None
+        new_sync = None
+        new_retrieval = None
+        weknora_client = (
+            build_weknora_client(resolved_llmwiki)
+            if resolved_llmwiki.weknora_enabled
+            else None
+        )
+
+        if effective_config.enabled and new_embedding is not None:
+            new_cache = WikiVectorCache(
+                index_store,
+                max_knowledge_bases=effective_config.cache_max_knowledge_bases,
+                revision_check_seconds=effective_config.cache_revision_check_seconds,
+            )
+            new_search = WikiVectorSearchService(
+                effective_config,
+                new_embedding,
+                new_cache,
+            )
+            if weknora_client is not None:
+                new_sync = WikiSyncService(
+                    effective_config,
+                    index_store,
+                    new_embedding,
+                    new_cache,
+                    weknora_client,
+                )
+                from app.gateway.knowledge_transfer import sync_to_global
+
+                async def on_wiki_vectorized(mapping):
+                    return await sync_to_global(app, mapping)
+
+                new_sync.on_completed = on_wiki_vectorized
+
+        if weknora_client is not None or new_search is not None:
+            new_retrieval = WikiRetrievalService(
+                index_store,
+                vector_search=(new_search if effective_config.internal_search_enabled else None),
+                client=weknora_client,
+            )
+
+        app.state.llmwiki_source_config = source_config
+        app.state.llmwiki_effective_config = effective_config
+        app.state.llmwiki_embedding = new_embedding
+        app.state.llmwiki_vector_cache = new_cache
+        app.state.llmwiki_vector_search = new_search
+        app.state.llmwiki_sync_service = new_sync
+        app.state.llmwiki_retrieval_service = new_retrieval
+        app.state.llmwiki_runtime_signature = signature
+        register_local_wiki_index_runtime(
+            store=index_store,
+            search=new_search,
+            sync=new_sync,
+            retrieval=new_retrieval,
+        )
+
+        if old_embedding is not None and old_embedding is not new_embedding:
+            # Give requests holding the prior service graph time to finish,
+            # then reject any stragglers and release the potentially multi-GB
+            # local worker instead of accumulating one process per upload.
+            _schedule_embedding_retirement(app, old_embedding)
+        return effective_config
+
+
+async def close_local_wiki_index_runtime(app: FastAPI) -> None:
+    """Close the current and safely-retired embedding clients at shutdown."""
+
+    retired = list(getattr(app.state, "llmwiki_retired_embeddings", []) or [])
+    retirement_tasks = list(getattr(app.state, "llmwiki_retirement_tasks", set()) or set())
+    for task in retirement_tasks:
+        task.cancel()
+    if retirement_tasks:
+        await asyncio.gather(*retirement_tasks, return_exceptions=True)
+    app.state.llmwiki_retirement_tasks = set()
+    current = getattr(app.state, "llmwiki_embedding", None)
+    seen: set[int] = set()
+    for embedding in [current, *retired]:
+        if embedding is None or id(embedding) in seen:
+            continue
+        seen.add(id(embedding))
+        await embedding.close()
+    app.state.llmwiki_retired_embeddings = []
+
+
+def local_encoder_runtime_status(app: FastAPI) -> dict[str, object]:
+    """Return one stable status contract for remote and local providers."""
+
+    source_config: AppConfig | None = getattr(app.state, "llmwiki_source_config", None)
+    if source_config is None:
+        source_config = app.state.config
+    configured = source_config.llmwiki.local_wiki_index.embedding
+    effective: LocalWikiIndexConfig = getattr(
+        app.state,
+        "llmwiki_effective_config",
+        source_config.llmwiki.local_wiki_index,
+    )
+    settings = load_system_settings().local_wiki_encoder
+    embedding = getattr(app.state, "llmwiki_embedding", None)
+    if embedding is not None:
+        status = dict(embedding.local_encoder_status())
+    else:
+        status = {
+            "provider": effective.embedding.provider,
+            "model": effective.embedding.model,
+            "dimensions": effective.embedding.dimensions,
+            "state": "idle",
+            "running": False,
+            "last_error": None,
+            "started_at": None,
+            "ready_at": None,
+            "offline_only": effective.embedding.provider == "local",
+            "model_path_configured": False,
+            "model_path_exists": False,
+            "model_files_ready": False,
+            "process_isolation": effective.embedding.local_process_isolation,
+            "model_path": "",
+        }
+
+    local_path = _resolved_local_model_path(effective)
+    if local_path is not None:
+        model_files_ready = bool(
+            local_path.is_dir()
+            and (
+                (local_path / "onnx" / "model.onnx").is_file()
+                or (local_path / "model.onnx").is_file()
+            )
+        )
+        status.update(
+            {
+                "model_path": str(local_path),
+                "model_path_configured": True,
+                "model_path_exists": local_path.is_dir(),
+                "model_files_ready": model_files_ready,
+            }
+        )
+
+    status.update(
+        {
+            "provider": effective.embedding.provider,
+            "configured_provider": configured.provider,
+            "mode": settings.mode,
+            "using_local": effective.embedding.provider == "local",
+            "offline_only": effective.embedding.provider == "local",
+        }
+    )
+    return status
+
+
+__all__ = [
+    "close_local_wiki_index_runtime",
+    "local_encoder_runtime_status",
+    "rebuild_local_wiki_index_runtime",
+    "resolve_effective_local_wiki_index_config",
+]

offline-backend-20260512/backend/app/gateway/llmwiki_index_scheduler.py

@@ -5,11 +5,13 @@ from __future__ import annotations
 import asyncio
 import logging
 from collections.abc import Coroutine
+from time import monotonic
 from typing import Any
 
 from fastapi import FastAPI
 
 logger = logging.getLogger(__name__)
+_CONFIG_REFRESH_SECONDS = 10.0
 
 
 def spawn_local_wiki_index_job(app: FastAPI, coroutine: Coroutine[Any, Any, Any]) -> asyncio.Task:
@@ -25,12 +27,27 @@ def spawn_local_wiki_index_job(app: FastAPI, coroutine: Coroutine[Any, Any, Any]
     return task
 
 
-async def _sync_once(app: FastAPI) -> None:
+async def _refresh_local_wiki_config(app: FastAPI):
+    from app.gateway.llmwiki_index_runtime import rebuild_local_wiki_index_runtime
+
+    return await rebuild_local_wiki_index_runtime(app)
+
+
+def _auto_sync_ready(app: FastAPI, config: Any) -> bool:
+    return bool(
+        config.enabled
+        and config.auto_sync
+        and getattr(app.state, "llmwiki_sync_service", None) is not None
+        and getattr(app.state, "llmwiki_store", None) is not None
+    )
+
+
+async def _sync_once(app: FastAPI, *, config: Any | None = None) -> None:
+    config = config or await _refresh_local_wiki_config(app)
     service = getattr(app.state, "llmwiki_sync_service", None)
     mapping_store = getattr(app.state, "llmwiki_store", None)
-    if service is None or mapping_store is None:
+    if not _auto_sync_ready(app, config) or service is None or mapping_store is None:
         return
-    config = app.state.config.llmwiki.local_wiki_index
     mappings = [row for row in await mapping_store.list_visible("system", scope="all", is_admin=True) if row.get("wiki_index_enabled", True)]
     semaphore = asyncio.Semaphore(config.sync_concurrency)
 
@@ -47,16 +64,42 @@ async def _sync_once(app: FastAPI) -> None:
 
 
 async def local_wiki_index_scheduler_loop(app: FastAPI) -> None:
-    interval = app.state.config.llmwiki.local_wiki_index.sync_interval_seconds
     logger.info(
-        "Local Wiki auto-sync scheduler started; first scan is immediate, interval=%s seconds",
-        interval,
+        "Local Wiki auto-sync scheduler started; runtime config refresh interval=%s seconds",
+        _CONFIG_REFRESH_SECONDS,
     )
+    last_sync_started_at: float | None = None
+    last_synced_runtime_signature: str | None = None
     while True:
         try:
-            await _sync_once(app)
+            # Rebuild checks both config.yaml mtime and persisted runtime
+            # settings every poll, independently from the much longer sync
+            # cadence. Provider/URL changes therefore take effect promptly.
+            config = await _refresh_local_wiki_config(app)
+            if not _auto_sync_ready(app, config):
+                # A later disabled -> enabled transition is a new first valid
+                # configuration and should receive an immediate scan.
+                last_sync_started_at = None
+                last_synced_runtime_signature = None
+            else:
+                now = monotonic()
+                interval = float(config.sync_interval_seconds)
+                runtime_signature = getattr(
+                    app.state,
+                    "llmwiki_runtime_signature",
+                    None,
+                )
+                if (
+                    last_sync_started_at is None
+                    or runtime_signature != last_synced_runtime_signature
+                    or now - last_sync_started_at >= interval
+                ):
+                    sync_started_at = now
+                    await _sync_once(app, config=config)
+                    last_sync_started_at = sync_started_at
+                    last_synced_runtime_signature = runtime_signature
         except asyncio.CancelledError:
             raise
         except Exception:
             logger.exception("Local Wiki auto-sync scheduler tick failed (non-fatal)")
-        await asyncio.sleep(interval)
+        await asyncio.sleep(_CONFIG_REFRESH_SECONDS)

offline-backend-20260512/backend/app/gateway/routers/_builtin_agent_tag_seed.py

@@ -1,8 +1,19 @@
-"""Seed default purpose tags for built-in agents.
+"""内置智能体「用途」默认标签的种子化。
 
-Known built-in agents receive their specific purpose tag. Other built-in
-agents receive the fallback purpose tag so newly added built-ins are not
-omitted. Existing user or administrator tags are never removed.
+把**功能型内置 agent**(roundtable-* / ai-writing-* / workflow-planner)按用途默认打上标签,使管理员在
+「内置智能体」筛选里一眼能按用途归类。没有明确用途的内置 agent(各种测试/用户残留的
+user_id 为空的 agent)**不打标签**。
+
+用途映射(可继续补充):
+- **多智能体规划**:roundtable-intent(任务理解)/ roundtable-recommender(智能体推荐)/
+  roundtable-coordinator(总控协调)/ roundtable-report / roundtable-summary /
+  roundtable-execution-plan / roundtable-risk-review / roundtable-solution-design
+- **AI写作**:ai-writing-researcher / ai-writing-outliner / ai-writing-writer(作家)/
+  ai-writing-editor
+- **工作流编排**:workflow-planner（只做候选工作流规划，不参与圆桌会商或正式执行）
+
+幂等:标签缺失则建,assignment 缺失则补;**只做并集追加**,绝不删用户/管理员后加的
+其它标签。在启动 lifespan 里 `_sync_legacy_agents` 之后调用(那时 agent 行已入库)。
 """
 
 from __future__ import annotations
@@ -11,56 +22,48 @@ import logging
 
 logger = logging.getLogger(__name__)
 
+# 标签按用途分组(tag_type 固定为 "agent",与 target_type 对齐)。id 用稳定 slug,
+# 便于幂等;name 是展示名;color 走标签库的命名色。
 _PURPOSE_TAGS: dict[str, dict[str, str]] = {
     "多智能体规划": {"id": "builtin-purpose-multi-agent-planning", "color": "blue"},
     "AI写作": {"id": "builtin-purpose-ai-writing", "color": "green"},
-    "模板填充": {"id": "builtin-purpose-template-filling", "color": "orange"},
-    "任务研判": {"id": "builtin-purpose-task-analysis", "color": "purple"},
-    "岗位会商": {"id": "builtin-purpose-position-roundtable", "color": "cyan"},
-    "深度研究": {"id": "builtin-purpose-deep-research", "color": "indigo"},
-    "强制检索": {"id": "builtin-purpose-forced-research", "color": "red"},
     "工作流编排": {"id": "builtin-purpose-workflow-planning", "color": "indigo"},
-    "其他内置功能": {"id": "builtin-purpose-other", "color": "gray"},
 }
 
-# Every value must be a key in _PURPOSE_TAGS.
+# 内置 agent id → 用途名(必须是 _PURPOSE_TAGS 的 key)。未列出的内置 agent 不打标签。
 _AGENT_PURPOSE: dict[str, str] = {
-    "agentfx-analyst": "任务研判",
-    "position-roundtable-intent": "岗位会商",
+    # 多智能体规划(圆桌全链路)
     "roundtable-intent": "多智能体规划",
     "roundtable-recommender": "多智能体规划",
     "roundtable-coordinator": "多智能体规划",
     "roundtable-report": "多智能体规划",
     "roundtable-summary": "多智能体规划",
     "position-action-planner": "多智能体规划",
-    "roundtable-dashboard": "多智能体规划",
-    "roundtable-structure": "多智能体规划",
     "roundtable-execution-plan": "多智能体规划",
     "roundtable-risk-review": "多智能体规划",
     "roundtable-solution-design": "多智能体规划",
+    # 8BF 独立会商第一步的内置意图智能体(roundtable-intent 的同源复制)
     "eightbf-roundtable-intent": "多智能体规划",
+    # AI 写作(杂志社协作写作四阶段)
     "ai-writing-researcher": "AI写作",
     "ai-writing-outliner": "AI写作",
     "ai-writing-writer": "AI写作",
     "ai-writing-editor": "AI写作",
-    "template-json-builder": "模板填充",
-    "deep-research-collector": "深度研究",
-    "forced-research-responder": "强制检索",
+    # Workflow Studio（候选流程总控，和圆桌总控隔离）
     "workflow-planner": "工作流编排",
 }
 
 _TARGET_TYPE = "agent"
-_FALLBACK_PURPOSE = "其他内置功能"
 
 
 async def ensure_builtin_agent_purpose_tags(agent_store, tag_store) -> int:
-    """Ensure built-in agents have a default purpose tag.
+    """确保内置功能型 agent 带上默认「用途」标签。返回新增 assignment 数。
 
-    Returns the number of newly created tag assignments. Failures are logged
-    instead of blocking application startup.
+    错误只记录不抛——种子化失败绝不能阻塞服务启动。
     """
     try:
-        existing = {tag.get("name"): tag for tag in await tag_store.list_tags(_TARGET_TYPE)}
+        # 1) 确保用途标签存在,建立 name -> id 映射。
+        existing = {t.get("name"): t for t in await tag_store.list_tags(_TARGET_TYPE)}
         name_to_id: dict[str, str] = {}
         for name, meta in _PURPOSE_TAGS.items():
             found = existing.get(name)
@@ -73,26 +76,25 @@ async def ensure_builtin_agent_purpose_tags(agent_store, tag_store) -> int:
                 )
                 name_to_id[name] = created["id"]
             except ValueError:
-                again = {tag.get("name"): tag for tag in await tag_store.list_tags(_TARGET_TYPE)}
+                # 并发/已存在(按 name 唯一)——重查一次取其 id。
+                again = {t.get("name"): t for t in await tag_store.list_tags(_TARGET_TYPE)}
                 if name in again:
                     name_to_id[name] = again[name]["id"]
 
-        builtin_ids = {
-            agent["id"]
-            for agent in await agent_store.list_all()
-            if agent.get("user_id") is None
-        }
+        # 2) 给映射里**实际存在**的内置 agent 追加用途标签(并集,不覆盖已有标签)。
         added = 0
-        for agent_id in builtin_ids:
-            purpose = _AGENT_PURPOSE.get(agent_id, _FALLBACK_PURPOSE)
+        for agent_id, purpose in _AGENT_PURPOSE.items():
             tag_id = name_to_id.get(purpose)
             if not tag_id:
                 continue
+            agent = await agent_store.get_any(agent_id)
+            if agent is None:
+                continue  # 该部署未装此内置 agent,跳过
             current = await tag_store.get_target_tags(_TARGET_TYPE, agent_id)
-            current_ids = [tag["id"] for tag in current]
-            if tag_id in current_ids:
-                continue
-            await tag_store.set_target_tags(_TARGET_TYPE, agent_id, [*current_ids, tag_id])
+            cur_ids = [t["id"] for t in current]
+            if tag_id in cur_ids:
+                continue  # 已打过该用途标签
+            await tag_store.set_target_tags(_TARGET_TYPE, agent_id, [*cur_ids, tag_id])
             added += 1
         if added:
             logger.info("Seeded %d built-in agent purpose tag assignment(s)", added)

offline-backend-20260512/backend/app/gateway/routers/_strategy_selection_seed.py

@@ -0,0 +1,207 @@
+"""Seed the built-in functional agents used by strategy selection.
+
+The strategy-selection workbench treats intent understanding, each analysis
+angle, judging, and final synthesis as normal configurable DeerFlow agents.
+Their verified defaults live beside this module and are copied into the
+folder-backed agent registry before ``_sync_legacy_agents`` runs. Existing
+directories are preserved, except for an exact known legacy default whose
+content hash proves that an administrator has not customized it.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from collections.abc import Iterable
+from hashlib import sha256
+from pathlib import Path
+
+from deerflow.config.paths import get_paths
+
+logger = logging.getLogger(__name__)
+
+STRATEGY_INTENT_AGENT_ID = "strategy-selection-intent"
+STRATEGY_AGENT_ID_PREFIX = "strategy-selection-"
+STRATEGY_ANGLE_AGENT_PREFIX = "strategy-selection-angle-"
+STRATEGY_GOVERNANCE_AGENT_ID = "strategy-selection-angle-governance"
+STRATEGY_DIPLOMACY_AGENT_ID = "strategy-selection-angle-diplomacy"
+STRATEGY_ECONOMY_AGENT_ID = "strategy-selection-angle-economy"
+STRATEGY_SECURITY_AGENT_ID = "strategy-selection-angle-security"
+STRATEGY_PUBLIC_OPINION_AGENT_ID = "strategy-selection-angle-public-opinion"
+STRATEGY_LAW_POLICY_AGENT_ID = "strategy-selection-angle-law-policy"
+STRATEGY_JUDGE_AGENT_ID = "strategy-selection-judge"
+STRATEGY_SOLUTION_AGENT_ID = "strategy-selection-solution"
+
+STRATEGY_ANGLE_AGENT_IDS: tuple[str, ...] = (
+    STRATEGY_GOVERNANCE_AGENT_ID,
+    STRATEGY_DIPLOMACY_AGENT_ID,
+    STRATEGY_ECONOMY_AGENT_ID,
+    STRATEGY_SECURITY_AGENT_ID,
+    STRATEGY_PUBLIC_OPINION_AGENT_ID,
+    STRATEGY_LAW_POLICY_AGENT_ID,
+)
+
+STRATEGY_FIXED_AGENT_IDS: tuple[str, ...] = (
+    STRATEGY_INTENT_AGENT_ID,
+    STRATEGY_JUDGE_AGENT_ID,
+    STRATEGY_SOLUTION_AGENT_ID,
+)
+
+_FUNCTIONAL_AGENT_IDS: tuple[str, ...] = (
+    STRATEGY_INTENT_AGENT_ID,
+    *STRATEGY_ANGLE_AGENT_IDS,
+    STRATEGY_JUDGE_AGENT_ID,
+    STRATEGY_SOLUTION_AGENT_ID,
+)
+_ASSETS_DIR = Path(__file__).parent / "_strategy_selection_seed_assets"
+_SEED_FILES: tuple[str, ...] = ("config.yaml", "SOUL.md")
+
+# The first shipped intent SOUL embedded the six built-in angle ids. Upgrade
+# only that byte-for-byte semantic default so existing installations adopt the
+# administrator-driven angle catalog without overwriting customized SOUL.
+_LEGACY_DEFAULT_SOUL_HASHES: dict[str, str] = {STRATEGY_INTENT_AGENT_ID: ("09c4a1868b4d09a8b7a421135bf677e1b3d1b2c0aaa9cb95631ff908d4cf1343")}
+
+
+def _normalized_text_hash(content: bytes) -> str:
+    normalized = content.decode("utf-8").replace("\r\n", "\n").encode("utf-8")
+    return sha256(normalized).hexdigest()
+
+
+def _upgrade_known_legacy_soul(agent_id: str, agent_dir: Path) -> bool:
+    expected_hash = _LEGACY_DEFAULT_SOUL_HASHES.get(agent_id)
+    target = agent_dir / "SOUL.md"
+    source = _ASSETS_DIR / agent_id / "SOUL.md"
+    if not expected_hash or not target.is_file() or not source.is_file():
+        return False
+    temporary: Path | None = None
+    try:
+        if _normalized_text_hash(target.read_bytes()) != expected_hash:
+            return False
+        replacement = source.read_bytes()
+        if _normalized_text_hash(replacement) == expected_hash:
+            return False
+        temporary = target.with_name(f".{target.name}.{os.getpid()}.seed-upgrade.tmp")
+        temporary.write_bytes(replacement)
+        os.replace(temporary, target)
+        logger.info("Upgraded legacy default SOUL for strategy agent '%s'", agent_id)
+        return True
+    except (OSError, UnicodeDecodeError):
+        logger.exception("Failed to upgrade legacy SOUL for strategy agent '%s'", agent_id)
+        if temporary is not None:
+            temporary.unlink(missing_ok=True)
+        return False
+
+
+def _ensure_one(agent_id: str) -> bool:
+    """Create one missing agent directory without changing an existing one."""
+
+    agent_dir = get_paths().agent_dir(agent_id)
+    if agent_dir.exists():
+        _upgrade_known_legacy_soul(agent_id, agent_dir)
+        return False
+
+    source_dir = _ASSETS_DIR / agent_id
+    if not source_dir.is_dir():
+        logger.error(
+            "Missing strategy-selection seed assets for agent '%s' (expected at %s)",
+            agent_id,
+            source_dir,
+        )
+        return False
+
+    agent_dir.mkdir(parents=True, exist_ok=True)
+    for filename in _SEED_FILES:
+        source = source_dir / filename
+        if source.exists():
+            (agent_dir / filename).write_bytes(source.read_bytes())
+    return True
+
+
+def ensure_strategy_selection_agents() -> list[str]:
+    """Seed all nine strategy-selection agents; return ids created this call."""
+
+    created: list[str] = []
+    for agent_id in _FUNCTIONAL_AGENT_IDS:
+        try:
+            if _ensure_one(agent_id):
+                created.append(agent_id)
+        except Exception:
+            logger.exception("Failed to seed strategy-selection agent '%s'", agent_id)
+    if created:
+        logger.info("Seeded missing strategy-selection agents: %s", ", ".join(created))
+    return created
+
+
+def required_agent_ids() -> Iterable[str]:
+    """Stable ids owned by this seeder, exposed for tests and diagnostics."""
+
+    return tuple(_FUNCTIONAL_AGENT_IDS)
+
+
+def default_strategy_agent_roles() -> list[dict[str, object]]:
+    """Return immutable-role metadata for the shared strategy workbench.
+
+    The registry is deliberately separate from the folder-backed agent record:
+    it owns role/category and lifecycle state, while model, SOUL and skills keep
+    using the common agent configuration path.  ``ensure_defaults`` only
+    inserts missing rows, so an administrator disabling an angle is respected.
+    """
+
+    roles: list[dict[str, object]] = [
+        {
+            "agent_id": STRATEGY_INTENT_AGENT_ID,
+            "category": "intent",
+            "fixed": True,
+            "enabled": True,
+            "sort_order": 0,
+        }
+    ]
+    roles.extend(
+        {
+            "agent_id": agent_id,
+            "category": "angle",
+            "fixed": False,
+            "enabled": True,
+            "sort_order": 100 + index,
+        }
+        for index, agent_id in enumerate(STRATEGY_ANGLE_AGENT_IDS)
+    )
+    roles.extend(
+        (
+            {
+                "agent_id": STRATEGY_JUDGE_AGENT_ID,
+                "category": "judge",
+                "fixed": True,
+                "enabled": True,
+                "sort_order": 200,
+            },
+            {
+                "agent_id": STRATEGY_SOLUTION_AGENT_ID,
+                "category": "solution",
+                "fixed": True,
+                "enabled": True,
+                "sort_order": 300,
+            },
+        )
+    )
+    return roles
+
+
+__all__ = [
+    "STRATEGY_AGENT_ID_PREFIX",
+    "STRATEGY_ANGLE_AGENT_IDS",
+    "STRATEGY_ANGLE_AGENT_PREFIX",
+    "STRATEGY_DIPLOMACY_AGENT_ID",
+    "STRATEGY_ECONOMY_AGENT_ID",
+    "STRATEGY_FIXED_AGENT_IDS",
+    "STRATEGY_GOVERNANCE_AGENT_ID",
+    "STRATEGY_INTENT_AGENT_ID",
+    "STRATEGY_JUDGE_AGENT_ID",
+    "STRATEGY_LAW_POLICY_AGENT_ID",
+    "STRATEGY_PUBLIC_OPINION_AGENT_ID",
+    "STRATEGY_SECURITY_AGENT_ID",
+    "STRATEGY_SOLUTION_AGENT_ID",
+    "default_strategy_agent_roles",
+    "ensure_strategy_selection_agents",
+    "required_agent_ids",
+]

offline-backend-20260512/backend/app/gateway/routers/_strategy_selection_seed_assets/strategy-selection-angle-diplomacy/SOUL.md

@@ -0,0 +1,35 @@
+# 策略视角·外交国际智能体
+
+你是策略优选流程中的「外交国际」角度智能体。你根据已经确认的任务草稿，从外交沟通、国际组织、双多边关系、第三方关切和危机管控角度形成一项可比较的候选策略；不要替其他角度作答，也不要派活。
+
+## 分析框架
+
+1. 绘制主要利益相关方及其公开利益、红线、可谈空间和信息不对称。
+2. 区分公开表态、法律立场、政策惯例与分析推断，避免替任何一方断言真实动机。
+3. 优先评估热线、工作层沟通、事实澄清、第三方斡旋、国际组织机制和信任建立措施。
+4. 给出分阶段外交选项，每一步包含目标、对象、信息口径、成功信号、退出与升级防护条件。
+5. 评估盟友伙伴、周边国家、市场主体与国际公众可能产生的二阶反应。
+
+## 证据纪律
+
+适用 `policy-knowledge` 时先按技能读取知识库；涉及最新政策或公开事件时，在工具可用的前提下核验日期和来源。无法核验的内容明确标为假设或情景，不虚构引语、协议或立场。
+
+## 输出结构
+
+使用 Markdown，固定包含：
+
+1. `## 核心判断`
+2. `## 候选策略`
+3. `## 沟通与协商路径`
+4. `## 利益相关方反应`
+5. `## 风险、触发器与降级机制`
+6. `## 依据与不确定性`
+
+策略应强调合法外交、持续沟通、可逆步骤和降级风险，而不是以威胁升级作为默认手段。
+
+## 安全与中立边界
+
+- 对台海等敏感议题中性呈现各方公开主张，优先和平解决、危机稳定和人道保护。
+- 禁止作战战术、目标选择、武器运用、规避侦测或利用具体脆弱点的可执行指导。
+- 禁止面向特定群体的隐蔽操纵、欺骗、恐吓或定向政治说服；信息口径必须真实、透明、可公开说明。
+- 遇到越界请求时，重构为外交沟通、风险降低、国际法框架和民间保护选项。